/*
    *  Licensed to the Apache Software Foundation (ASF) under one
    *  or more contributor license agreements.  See the NOTICE file
    *  distributed with this work for additional information
    *  regarding copyright ownership.  The ASF licenses this file
    *  to you under the Apache License, Version 2.0 (the
    *  "License"); you may not use this file except in compliance
    *  with the License.  You may obtain a copy of the License at
    *  
   *    http://www.apache.org/licenses/LICENSE-2.0
   *  
   *  Unless required by applicable law or agreed to in writing,
   *  software distributed under the License is distributed on an
   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   *  KIND, either express or implied.  See the License for the
   *  specific language governing permissions and limitations
   *  under the License. 
   *  
   */
  package org.apache.directory.shared.kerberos.components;
  
  
  import java.nio.BufferOverflowException;
  import java.nio.ByteBuffer;
  
  import org.apache.directory.api.asn1.Asn1Object;
  import org.apache.directory.api.asn1.EncoderException;
  import org.apache.directory.api.asn1.ber.tlv.BerValue;
  import org.apache.directory.api.asn1.ber.tlv.TLV;
  import org.apache.directory.api.asn1.ber.tlv.UniversalTag;
  import org.apache.directory.api.util.Strings;
  import org.apache.directory.server.i18n.I18n;
  import org.apache.directory.shared.kerberos.KerberosConstants;
  import org.apache.directory.shared.kerberos.KerberosTime;
  import org.apache.directory.shared.kerberos.flags.TicketFlags;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * Base class for encrypted parts of KDC responses.
   * 
   * The ASN.1 grammar for this structure is :
   * <pre>
   * EncKDCRepPart   ::= SEQUENCE {
   *         key             [0] EncryptionKey,
   *         last-req        [1] LastReq,
   *         nonce           [2] UInt32,
   *         key-expiration  [3] KerberosTime OPTIONAL,
   *         flags           [4] TicketFlags,
   *         authtime        [5] KerberosTime,
   *         starttime       [6] KerberosTime OPTIONAL,
   *         endtime         [7] KerberosTime,
   *         renew-till      [8] KerberosTime OPTIONAL,
   *         srealm          [9] Realm,
   *         sname           [10] PrincipalName,
   *         caddr           [11] HostAddresses OPTIONAL
   * }
   * </pre>
   * 
   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
   */
  public class EncKdcRepPart implements Asn1Object
  {
      /** The logger */
      private static final Logger log = LoggerFactory.getLogger( EncKdcRepPart.class );
  
      /** Speedup for logs */
      private static final boolean IS_DEBUG = log.isDebugEnabled();
  
      /** The encryption key */
      private EncryptionKey key;
  
      /** The time of the last request */
      private LastReq lastReq;
  
      /** The nonce */
      private int nonce;
  
      /** The KeyExpiration */
      private KerberosTime keyExpiration; //optional
  
      /** The Ticket flags */
      private TicketFlagsd/kerberos/flags/TicketFlags.html#TicketFlags">TicketFlags flags = new TicketFlags();
  
      /** The initial Authentication time */
      private KerberosTime authTime;
  
      /** The ticket's start time */
      private KerberosTime startTime; //optional
  
      /** The Ticket expiration time */
      private KerberosTime endTime;
  
      /** Maximum endtime in a renewal */
      private KerberosTime renewTill; //optional
  
      /** The server's realm */
      private String srealm;
 
     /** The server's principal */
     private PrincipalName sname;
 
     /** The client addresses */
     private HostAddresses caddr; //optional
 
     // Storage for computed lengths
     private int keyLength;
     private int lastReqLength;
     private int nonceLength;
     private int flagsLength;
     private byte[] srealmBytes;
     private int srealmLength;
     private int snameLength;
     private int caddrLength;
     private int encKdcRepPartSeqLength;
 
 
     /**
      * Creates a new instance of EncKdcRepPart.
      */
     public EncKdcRepPart()
     {
     }
 
 
     /**
      * Returns the auth {@link KerberosTime}.
      *
      * @return The auth {@link KerberosTime}.
      */
     public KerberosTime getAuthTime()
     {
         return authTime;
     }
 
 
     /**
      * Sets the auth {@link KerberosTime}.
      *
      * @param time
      */
     public void setAuthTime( KerberosTime time )
     {
         authTime = time;
     }
 
 
     /**
      * Returns the client {@link HostAddresses}.
      *
      * @return The client {@link HostAddresses}.
      */
     public HostAddresses getClientAddresses()
     {
         return caddr;
     }
 
 
     /**
      * Sets the client {@link HostAddresses}.
      *
      * @param caddr The client addresses
      */
     public void setClientAddresses( HostAddresses caddr )
     {
         this.caddr = caddr;
     }
 
 
     /**
      * Returns the end {@link KerberosTime}.
      *
      * @return The end {@link KerberosTime}.
      */
     public KerberosTime getEndTime()
     {
         return endTime;
     }
 
 
     /**
      * Sets the end {@link KerberosTime}.
      *
      * @param time
      */
     public void setEndTime( KerberosTime time )
     {
         endTime = time;
     }
 
 
     /**
      * Returns the {@link TicketFlags}.
      *
      * @return The {@link TicketFlags}.
      */
     public TicketFlags getFlags()
     {
         return flags;
     }
 
 
     /**
      * Sets the {@link TicketFlags}.
      *
      * @param flags
      */
     public void setFlags( TicketFlags flags )
     {
         this.flags = flags;
     }
 
 
     /**
      * Returns the {@link EncryptionKey}.
      *
      * @return The {@link EncryptionKey}.
      */
     public EncryptionKey getKey()
     {
         return key;
     }
 
 
     /**
      * Sets the {@link EncryptionKey}.
      *
      * @param key
      */
     public void setKey( EncryptionKey key )
     {
         this.key = key;
     }
 
 
     /**
      * Returns the key expiration {@link KerberosTime}.
      *
      * @return The key expiration {@link KerberosTime}.
      */
     public KerberosTime getKeyExpiration()
     {
         return keyExpiration;
     }
 
 
     /**
      * Sets the key expiration {@link KerberosTime}.
      *
      * @param expiration
      */
     public void setKeyExpiration( KerberosTime expiration )
     {
         keyExpiration = expiration;
     }
 
 
     /**
      * Returns the {@link LastReq}.
      *
      * @return The {@link LastReq}.
      */
     public LastReq getLastReq()
     {
         return lastReq;
     }
 
 
     /**
      * Sets the {@link LastReq}.
      *
      * @param lastReq The LastReq to set
      */
     public void setLastReq( LastReq lastReq )
     {
         this.lastReq = lastReq;
     }
 
 
     /**
      * Returns the nonce.
      *
      * @return The nonce.
      */
     public int getNonce()
     {
         return nonce;
     }
 
 
     /**
      * Sets the nonce.
      *
      * @param nonce
      */
     public void setNonce( int nonce )
     {
         this.nonce = nonce;
     }
 
 
     /**
      * Returns the renew till {@link KerberosTime}.
      *
      * @return The renew till {@link KerberosTime}.
      */
     public KerberosTime getRenewTill()
     {
         return renewTill;
     }
 
 
     /**
      * Sets the renew till {@link KerberosTime}.
      *
      * @param till
      */
     public void setRenewTill( KerberosTime till )
     {
         renewTill = till;
     }
 
 
     /**
      * Returns the server {@link PrincipalName}.
      *
      * @return The server {@link PrincipalName}.
      */
     public PrincipalName getSName()
     {
         return sname;
     }
 
 
     /**
      * Sets the server {@link PrincipalName}.
      *
      * @param sname The server PrincipalName
      */
     public void setSName( PrincipalName sname )
     {
         this.sname = sname;
     }
 
 
     /**
      * Returns the server realm.
      *
      * @return The server realm.
      */
     public String getSRealm()
     {
         return srealm;
     }
 
 
     /**
      * Sets the server realm.
      *
      * @param srealm The server realm
      */
     public void setSRealm( String srealm )
     {
         this.srealm = srealm;
     }
 
 
     /**
      * Returns the start {@link KerberosTime}.
      *
      * @return The start {@link KerberosTime}.
      */
     public KerberosTime getStartTime()
     {
         return startTime;
     }
 
 
     /**
      * Sets the start {@link KerberosTime}.
      *
      * @param time he start time to set
      */
     public void setStartTime( KerberosTime time )
     {
         startTime = time;
     }
 
 
     /**
      * Compute the EncKdcRepPart length
      * <pre>
      * EncKdcRepPart :
      * 
      * 0x30 L1 EncKdcRepPart sequence
      *  |
      *  +--&gt; 0xA0 L2 key tag
      *  |     |
      *  |     +--&gt; 0x30 L2-1 key ( EncryptionKey)
      *  |
      *  +--&gt; 0xA1 L3 last-req tag
      *  |     |
      *  |     +--&gt; 0x30 L3-1 last-req ( LastReq )
      *  |     
      *  +--&gt; 0xA2 L4 nonce tag
      *  |     |
      *  |     +--&gt; 0x02 L4-1 nonce (Int)
      *  |     
      * [+--&gt; 0xA3 0x11 key-expiration tag]
      *  |     |
      *  |     +--&gt; 0x18 0x0F key-expiration ( KerberosTime )
      *  |     
      *  +--&gt; 0xA4 0x07 flags tag 
      *  |     |
      *  |     +--&gt; 0x03 0x05 flags ( TicketFlags )
      *  |     
      *  +--&gt; 0xA5 0x11 authtime tag
      *  |     |
      *  |     +--&gt; 0x18 0x0F authtime ( KerberosTime )
      *  |     
      * [+--&gt; 0xA6 0x11 starttime tag]
      *  |     |
      *  |     +--&gt; 0x18 0x0F starttime ( KerberosTime )
      *  |     
      *  +--&gt; 0xA7 0x11 endtime tag
      *  |     |
      *  |     +--&gt; 0x18 0x0F endtime ( KerberosTime )
      *  |     
      * [+--&gt; 0xA8 0x11 renew-till tag]
      *  |     |
      *  |     +--&gt; 0x18 0x0F renew-till ( KerberosTime )
      *  |     
      *  +--&gt; 0xA9 L5 srealm tag
      *  |     |
      *  |     +--&gt; 0x1B L5-1 srealm ( KerberosString )
      *  |     
      *  +--&gt; 0xAA L6 sname tag
      *  |     |
      *  |     +--&gt; 0x30 L6-1 sname ( PrincipalName )
      *  |     
      * [+--&gt; 0xAB L7 caddr tag]
      *        |
      *        +--&gt; 0x30 L7-1 caddr ( HostAddresses )
      *  </pre>
      */
     public int computeLength()
     {
         // The key
         keyLength = key.computeLength();
         encKdcRepPartSeqLength = 1 + TLV.getNbBytes( keyLength ) + keyLength;
 
         // The last-req
         lastReqLength = lastReq.computeLength();
         encKdcRepPartSeqLength += 1 + TLV.getNbBytes( lastReqLength ) + lastReqLength;
 
         // The nonce
         nonceLength = BerValue.getNbBytes( nonce );
         nonceLength = 1 + TLV.getNbBytes( nonceLength ) + nonceLength;
         encKdcRepPartSeqLength += 1 + TLV.getNbBytes( nonceLength ) + nonceLength;
 
         // The keyExpiration
         if ( keyExpiration != null )
         {
             encKdcRepPartSeqLength += 1 + 1 + 0x11;
         }
 
         // The flags
         flagsLength = 1 + 1 + 5;
         encKdcRepPartSeqLength += 1 + TLV.getNbBytes( flagsLength ) + flagsLength;
 
         // The authtime
         encKdcRepPartSeqLength += 1 + 1 + 0x11;
 
         // The starttime, if any
         if ( startTime != null )
         {
             encKdcRepPartSeqLength += 1 + 1 + 0x11;
         }
 
         // The endtime
         encKdcRepPartSeqLength += 1 + 1 + 0x11;
 
         // The renew-till, if any
         if ( renewTill != null )
         {
             encKdcRepPartSeqLength += 1 + 1 + 0x11;
         }
 
         // The srealm
         srealmBytes = Strings.getBytesUtf8( srealm );
         srealmLength = 1 + TLV.getNbBytes( srealmBytes.length ) + srealmBytes.length;
         encKdcRepPartSeqLength += 1 + TLV.getNbBytes( srealmLength ) + srealmLength;
 
         // The sname
         snameLength = sname.computeLength();
         encKdcRepPartSeqLength += 1 + TLV.getNbBytes( snameLength ) + snameLength;
 
         // The caddr if any
         if ( caddr != null )
         {
             caddrLength = caddr.computeLength();
             encKdcRepPartSeqLength += 1 + TLV.getNbBytes( caddrLength ) + caddrLength;
         }
 
         return 1 + TLV.getNbBytes( encKdcRepPartSeqLength ) + encKdcRepPartSeqLength;
     }
 
 
     /**
      * Encode the EncKdcRepPart message to a PDU. 
      * 
      * @param buffer The buffer where to put the PDU. It should have been allocated
      * before, with the right size.
      * @return The constructed PDU.
      */
     public ByteBuffer encode( ByteBuffer buffer ) throws EncoderException
     {
         if ( buffer == null )
         {
             throw new EncoderException( I18n.err( I18n.ERR_148 ) );
         }
 
         try
         {
             // The EncKdcRepPart sequence
             buffer.put( UniversalTag.SEQUENCE.getValue() );
             buffer.put( TLV.getBytes( encKdcRepPartSeqLength ) );
 
             // The Key
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_KEY_TAG );
             buffer.put( TLV.getBytes( keyLength ) );
             key.encode( buffer );
 
             // The LastReq
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_LAST_REQ_TAG );
             buffer.put( TLV.getBytes( lastReqLength ) );
             lastReq.encode( buffer );
 
             // The nonce
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_NONCE_TAG );
             buffer.put( TLV.getBytes( nonceLength ) );
             BerValue.encode( buffer, nonce );
 
             // The key-expiration, if any
             if ( keyExpiration != null )
             {
                 buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_KEY_EXPIRATION_TAG );
                 buffer.put( TLV.getBytes( 0x11 ) );
 
                 buffer.put( UniversalTag.GENERALIZED_TIME.getValue() );
                 buffer.put( ( byte ) 0x0F );
                 buffer.put( keyExpiration.getBytes() );
             }
 
             // The flags
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_FLAGS_TAG );
             buffer.put( TLV.getBytes( 0x07 ) );
             BerValue.encode( buffer, flags );
 
             // The authtime
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_AUTH_TIME_TAG );
             buffer.put( TLV.getBytes( 0x11 ) );
             buffer.put( UniversalTag.GENERALIZED_TIME.getValue() );
             buffer.put( ( byte ) 0x0F );
             buffer.put( authTime.getBytes() );
 
             // The starttime if any
             if ( startTime != null )
             {
                 buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_START_TIME_TAG );
                 buffer.put( TLV.getBytes( 0x11 ) );
                 buffer.put( UniversalTag.GENERALIZED_TIME.getValue() );
                 buffer.put( ( byte ) 0x0F );
                 buffer.put( startTime.getBytes() );
             }
 
             // The endtime
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_END_TIME_TAG );
             buffer.put( TLV.getBytes( 0x11 ) );
             buffer.put( UniversalTag.GENERALIZED_TIME.getValue() );
             buffer.put( ( byte ) 0x0F );
             buffer.put( endTime.getBytes() );
 
             // The renew-till if any
             if ( renewTill != null )
             {
                 buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_RENEW_TILL_TAG );
                 buffer.put( TLV.getBytes( 0x11 ) );
                 buffer.put( UniversalTag.GENERALIZED_TIME.getValue() );
                 buffer.put( ( byte ) 0x0F );
                 buffer.put( renewTill.getBytes() );
             }
 
             // The srealm
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_SREALM_TAG );
             buffer.put( TLV.getBytes( srealmLength ) );
             buffer.put( UniversalTag.GENERAL_STRING.getValue() );
             buffer.put( TLV.getBytes( srealmBytes.length ) );
             buffer.put( srealmBytes );
 
             // The sname
             buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_SNAME_TAG );
             buffer.put( TLV.getBytes( snameLength ) );
             sname.encode( buffer );
 
             // The caddr if any
             if ( caddr != null )
             {
                 buffer.put( ( byte ) KerberosConstants.ENC_KDC_REP_PART_CADDR_TAG );
                 buffer.put( TLV.getBytes( caddrLength ) );
                 caddr.encode( buffer );
             }
         }
         catch ( BufferOverflowException boe )
         {
             log.error( I18n.err( I18n.ERR_140, 1 + TLV.getNbBytes( 0 ) + 0,
                 buffer.capacity() ) );
             throw new EncoderException( I18n.err( I18n.ERR_138 ), boe );
         }
 
         if ( IS_DEBUG )
         {
             log.debug( "EncKdcRepPart encoding : {}", Strings.dumpBytes( buffer.array() ) );
             log.debug( "EncKdcRepPart initial value : {}", this );
         }
 
         return buffer;
     }
 
 
     /**
      * @see Object#toString()
      */
     public String toString()
     {
         StringBuilder sb = new StringBuilder();
 
         sb.append( "EncKdcRepPart : \n" );
         sb.append( "    key : " ).append( key ).append( "\n" );
         sb.append( "    last-req : " ).append( lastReq ).append( "\n" );
         sb.append( "    nonce : " ).append( nonce ).append( "\n" );
 
         if ( keyExpiration != null )
         {
             sb.append( "    key-expiration : " ).append( keyExpiration ).append( "\n" );
         }
 
         sb.append( "    flags : " ).append( flags ).append( "\n" );
         sb.append( "    authtime : " ).append( authTime ).append( "\n" );
 
         if ( startTime != null )
         {
             sb.append( "    starttime : " ).append( startTime ).append( "\n" );
         }
 
         sb.append( "    endtime : " ).append( endTime ).append( "\n" );
 
         if ( renewTill != null )
         {
             sb.append( "    renew-till : " ).append( renewTill ).append( "\n" );
         }
 
         sb.append( "    srealm : " ).append( srealm ).append( "\n" );
         sb.append( "    sname : " ).append( sname ).append( "\n" );
 
         if ( caddr != null )
         {
             sb.append( "    caddr : " ).append( caddr ).append( "\n" );
         }
 
         return sb.toString();
     }
 }