1 /*

     2 * Copyright (c) 2000, 2004 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   This module contains the implementation of CCrBer class. 

    15 *

    16 */

    17 

    18 

    19 

    20 //  INCLUDE FILES

    21 #include "crber.h"

    22 #include <e32math.h>    // Pow

    23 

    24 

    25 // -----------------------------------------------------------------------------

    26 // CCrBer

    27 // Constructor 

    28 // This function constructs CCrBer object

    29 // -----------------------------------------------------------------------------

    30 CCrBer::CCrBer(TInt aLevel /* = 0 */)

    31     {

    32     TReal size = 0;

    33     

    34     Math::Pow(size, 256, sizeof(TUint));

    35     iMaxUint = STATIC_CAST(TUint, size - 1);

    36     

    37     Math::Pow(size, 128, sizeof(TInt));

    38     iMaxInt = STATIC_CAST(TInt, size - 1);

    39     

    40     

    41     iEOCBytes[0] = 0x00;

    42     iEOCBytes[1] = 0x00;

    43 

    44     iType = KBerUnknown;

    45     

    46     iIndefinite = EFalse;

    47 

    48     iObjectBegin = 0;

    49     iContentBegin = 0;

    50     iContentLen = 0;

    51     iObjectLen = 0;

    52 

    53     iLevel = aLevel;

    54 

    55     iData = NULL;

    56     }

    57 

    58 // -----------------------------------------------------------------------------

    59 // CCrBer

    60 // Destructor 

    61 // This function destructs CCrBer object

    62 // -----------------------------------------------------------------------------

    63 EXPORT_C CCrBer::~CCrBer()

    64     {

    65     iData = NULL;

    66 	iInt.Close();

    67     }

    68 

    69 // -----------------------------------------------------------------------------

    70 // CCrBer::ConstructL

    71 // This function initializes CCrBer object's member objects.

    72 // -----------------------------------------------------------------------------

    73 TAny CCrBer::ConstructL()

    74     {

    75     }

    76 // -----------------------------------------------------------------------------

    77 // CCrBer::NewLC

    78 // -----------------------------------------------------------------------------

    79 EXPORT_C CCrBer* CCrBer::NewLC(TInt aLevel /* = 0 */)

    80     {

    81     CCrBer* self = new (ELeave) CCrBer(aLevel);

    82     CleanupStack::PushL(self);

    83 

    84     self->ConstructL();

    85 

    86     return self; 

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CCrBer::NewL

    91 // -----------------------------------------------------------------------------

    92 EXPORT_C CCrBer* CCrBer::NewL(TInt aLevel /* = 0 */)

    93     {

    94     CCrBer* self = NewLC(aLevel);

    95     CleanupStack::Pop();

    96 

    97     return self; 

    98     }

    99 

   100 // -----------------------------------------------------------------------------

   101 // CCrBer::Read

   102 // Read next BER encoded object from the current position of

   103 // given CCrData to this object. Return the type of the BER

   104 // object, or KBerUnknown, if not of any known type. Only pointer

   105 // to aData is stored into this object, so Get* functions are

   106 // meaningful only if original data object is still existing,

   107 // when these functions are used.

   108 // -----------------------------------------------------------------------------

   109 EXPORT_C TUint8 CCrBer::Read(CCrData* aData)

   110     {

   111     if ((iType = ReadType(aData)) != KBerUnknown)

   112         {

   113         TInt  move;

   114         TInt  pos = 0;

   115         TBool conLenKnown;

   116 

   117 

   118         // If type is known, this object begins right here,

   119         // well, to be exact, one byte before this point.

   120         if ((aData->Seek(ESeekCurrent, pos)) == KErrNone)

   121             {

   122             conLenKnown = ETrue;

   123 

   124             // Now we have at least something sensible. Store pointer to

   125             // the data object (and hope that the caller doesn't delete it :)

   126             iData = aData;

   127 

   128             iObjectBegin = pos - 1;

   129 

   130             // Read length.

   131             iContentLen = ReadLen(aData, iIndefinite, &iLenLen);

   132 

   133             // Content begins right after type tag and length bytes.

   134             iContentBegin = pos + iLenLen;

   135 

   136             // If length is indefinite and type isn't set, sequence,

   137             // or explicit/implicit constructed, find next end-of-content

   138             // tag to define exact length.

   139             if (iIndefinite)

   140                 {

   141                 if ((iType != KBerSeq) &&

   142                     (iType != KBerSet) &&

   143                     (iType != KBerImplicitConstructed) &&

   144                     (iType != KBerExplicitConstructed))

   145                     {

   146                     // Give special treatment to constructed encoding.

   147                     if ((iType & KBerConstructedBit) ||

   148                         (iType & KBerImplicitConstructed))

   149                         {

   150                         iContentLen = OpenConstructedEncodingWithTagL(

   151                                         aData, *this);

   152                         

   153                         }

   154                     else

   155                         {

   156                         iContentLen = FindEndOfContent(aData);

   157                         }

   158                     }

   159                 else

   160                     {

   161                     // We really can't know what the length is,

   162                     // until we open up the whole inner content.

   163                     conLenKnown = EFalse;

   164                     }

   165                 }

   166 

   167             // Now, if we know content length, then we can calculate whole

   168             // object's length; it is tag + length bytes + content length.

   169             if (conLenKnown)

   170                 {

   171                 SetObjectLen();

   172 

   173                 // Also move data pointer at the end of this object, except

   174                 // if object was set or sequence, in which case don't move,

   175                 // because we still have to open inner items.

   176                 // At indefinite case this is already done (other than

   177                 // sequence or set) or this can't be done (sequence or

   178                 // set). So, if not indefinite and not sequence or set,

   179                 // move data pointer the amount of content length.

   180                 if (!(iIndefinite) && !(IsSeqOrSet(iType)))

   181                     {

   182                     move = iContentLen;

   183 

   184                     aData->Seek(ESeekCurrent, move);

   185                     }

   186                 }

   187 

   188             // If tag was end-of-content tag, check that also length

   189             // was 0 and not indefinite, this guarantees that we really

   190             // have an end-of-content tag (00 00).

   191             if (iType == KBerEndOfContent)

   192                 {

   193                 if ((iContentLen != 0) || (iIndefinite))

   194                     {

   195                     iType = KBerUnknown;

   196                     }

   197                 }

   198             }

   199         

   200 	

   201 	 

   202 		}

   203     return iType;

   204     }

   205 

   206 

   207 

   208 // -----------------------------------------------------------------------------

   209 // CCrBer::ReadType

   210 // Read type tag from current position in given CCrData.

   211 // Returns type tag or KBerUnknown, if not of any known type.

   212 // -----------------------------------------------------------------------------

   213 EXPORT_C TUint8 CCrBer::ReadType(CCrData* aData)

   214     {

   215     TBuf8<1> byte;

   216     TUint8   type = KBerUnknown;   // By default we are pessimists.

   217 

   218     // Read type.

   219     if ((aData != 0) &&

   220         (aData->Read(byte, 1) == KErrNone) &&

   221         (byte.Length() > 0))

   222         {

   223         type = byte[0];

   224 

   225         if (!IsKnownType(type))

   226             {

   227             // Don't let type to be whatever byte happened to be

   228             // at that place. Set it to unknown, which we all know.

   229             type = KBerUnknown;

   230             }

   231         }

   232 

   233     return type;

   234     }

   235 

   236 // -----------------------------------------------------------------------------

   237 // CCrBer::ReadLen

   238 // Read length tags from current position in given CCrData.

   239 // Returns length. If length is indefinite, aIndefinite is set

   240 // to true, otherwise to false. In indefinite case length is 0.

   241 // Also sets amount of length bytes in aLenLen, if given.

   242 // -----------------------------------------------------------------------------

   243 EXPORT_C TUint CCrBer::ReadLen(

   244     CCrData* aData,

   245     TBool&   aIndefinite,

   246     TUint8*  aLenLen/* = 0 */)

   247     {

   248     TBuf8<LEN_BYTES_MAX> bytes;

   249     TUint8               byte = 0;

   250     TUint                len = 0;

   251 

   252     // Originally assume that length is definite,

   253     aIndefinite = EFalse;

   254 

   255     // First byte tells if the length bytes are in short or in long form.

   256     if ((aData != 0) && (aData->Read(bytes, 1) == KErrNone))

   257         {

   258         if (bytes.Length() <= 0)        

   259             {

   260             User::Leave(KErrArgument);

   261             }

   262         byte = bytes[0];

   263 

   264         // We have at least one length byte.

   265         if (aLenLen != 0)

   266             {

   267             *aLenLen = 1;

   268             }

   269 

   270         if (byte & KBerLongLengthBit)

   271             {

   272             // We have length bytes, but how many?

   273             TUint8 lenBytes = (TUint8)(byte & ~KBerLongLengthBit);

   274 

   275             // If length is in long form, but there are zero

   276             // length bytes, then length is indefinite.

   277             if (lenBytes == 0)

   278                 {

   279                 aIndefinite = ETrue;

   280                 }

   281             else

   282                 {

   283                 if (aLenLen != 0)

   284                     {

   285                     // Add amount of actual length bytes to one,

   286                     // which was for long length form byte.

   287                     for (TInt i = 0; i < lenBytes; i++)

   288                         {

   289                         (*aLenLen)++;

   290                         }

   291 					}

   292 

   293                 // Otherwise we have to interpret length bytes and

   294                 // move the result into len variable. First check

   295                 // that there aren't more bytes than fits to

   296                 // unsigned integer, we don't want any troubles here.

   297                 if (lenBytes > sizeof(TUint))

   298                     {

   299                     // Return max uint, caller can then decide

   300                     // what to do with this huge pile of...

   301                     return iMaxUint;

   302                     }

   303 

   304                 // Read length bytes

   305                 if (aData->Read(bytes, lenBytes) == KErrNone)

   306                     {

   307                     TUint8 i;

   308 

   309                     // and move them to len.

   310                     for (i = 0; i < lenBytes; i++)

   311                         {

   312                         len = len << 8;

   313 

   314                         len += bytes[i];

   315                         }

   316                     }

   317                 }

   318             }

   319         else

   320             {

   321             // Otherwise length was in short form and length

   322             // byte alone tells us the length of the contens.

   323             len = byte;

   324             }

   325         }

   326 

   327     return len;

   328     }

   329 

   330 

   331 // -----------------------------------------------------------------------------

   332 // CCrBer::IsKnownType

   333 // Returns true if given BER tag is identified one.

   334 // Returns:  ETrue of EFalse.

   335 // -----------------------------------------------------------------------------

   336 EXPORT_C TBool CCrBer::IsKnownType(TBerTag aTag)

   337     {

   338     TBool isKnown = EFalse;

   339 

   340     // Remove constructed bit, if it is on without other upper byte tags.

   341     if ((aTag & 0xF0) == KBerConstructedBit)

   342         {

   343         aTag &= ~KBerConstructedBit;

   344         }

   345 

   346     // Remove implicit/explicit constructed bit, 

   347     // if it is on without other upper byte tags.

   348     if ((aTag & 0xF0) == KBerImplicitConstructed)

   349         {

   350         aTag &= ~KBerImplicitConstructed;

   351         }

   352 

   353     switch (aTag)

   354         {

   355         case KBerEndOfContent:

   356         case KBerBoolean:

   357         case KBerInteger:

   358         case KBerBitString:

   359         case KBerOctetString:

   360         case KBerNull:

   361         case KBerOid:

   362 		case KBerNumS:

   363         case KBerPrS:

   364         case KBerT61S:

   365 		case KBerVideoS:

   366         case KBerIA5S:

   367         case KBerUtc:

   368 		case KBerGenTime:                                

   369 		case KBerGraphS: 

   370 		case KBerVisibleS:

   371 		case KBerGeneralS:

   372         case KBerBmpS:

   373         case KBerSeq:

   374         case KBerSet:

   375         case KBerImplicitConstructed:

   376         // Same as KBerExplicitConstructed

   377         case KBerImplicit:

   378         // Same as KBerExplicit

   379             {

   380             isKnown = ETrue;

   381             break;

   382             }

   383         default:

   384             {

   385             isKnown = EFalse;

   386             break;

   387             }

   388         }

   389 

   390     return isKnown;

   391     }

   392 

   393 

   394 

   395 // -----------------------------------------------------------------------------

   396 // CCrBer::IsSeqOrSet

   397 // Returns true if given BER tag is set, sequence,

   398 // implicit contructed, or explicit constructed tag.

   399 // -----------------------------------------------------------------------------

   400 EXPORT_C TBool CCrBer::IsSeqOrSet(TBerTag aTag)

   401     {

   402     TBool isSeqOrSet = EFalse;

   403 

   404     if ((aTag == KBerSeq) ||

   405         (aTag == KBerSet) ||

   406         (aTag == KBerImplicit) ||

   407         (aTag == KBerExplicit) ||

   408         (aTag == KBerImplicitConstructed) ||

   409         (aTag == KBerExplicitConstructed))

   410 

   411         {

   412         isSeqOrSet = ETrue;

   413         }

   414 

   415     return isSeqOrSet;

   416     }

   417 

   418 // -----------------------------------------------------------------------------

   419 // CCrBer::FindEndOfContent

   420 // Finds next end-of-content (00 00) tag from given data.

   421 // Returns the distance between current place and the tag,

   422 // or 0, if not found. Moves data pointer to the next byte

   423 // _after_ the tag, i.e. two bytes longer than you might

   424 // except from the return value.

   425 // -----------------------------------------------------------------------------

   426 EXPORT_C TUint CCrBer::FindEndOfContent(CCrData* aData)

   427     {

   428     TBool go = ETrue;

   429     TInt bufferOffset = 0;

   430     TInt dataOffset = 0;

   431     TInt move = 0;

   432 

   433     TBuf8<KReadBufMax> bytes;

   434 

   435     if (aData == 0)

   436         {

   437         return dataOffset;

   438         }

   439 

   440     // Read buffer of data. Go on, if there is something to go with.

   441     while ((aData->Read(bytes, KReadBufMax) == KErrNone) &&

   442            (bytes.Length() != 0) && go)

   443         {

   444         TBuf8<2> EOCBytes;

   445 

   446         EOCBytes.Append(iEOCBytes[0]);

   447         EOCBytes.Append(iEOCBytes[1]);

   448 

   449         // Try to find end-of-content tag.

   450         bufferOffset = bytes.Find(EOCBytes);

   451 

   452         // If found, move data pointer right _after_

   453         // the place of founded tag, and break.

   454         if (bufferOffset != KErrNotFound)

   455             {

   456             move = bufferOffset -

   457                        bytes.Length() +

   458                        EOCBytes.Length();

   459 

   460             aData->Seek(ESeekCurrent, move);

   461 

   462             dataOffset += bufferOffset;

   463 

   464             go = EFalse;                    //break;

   465             }

   466         else

   467             {

   468             // Otherwise keep searching. First check that the last

   469             // character of the buffer isn't 00. If it is, move the

   470             // data pointer one byte backwards to prevent us from

   471             // missing end-of-content tag, if it is divided between

   472             // buffers.

   473             if (bytes[bytes.Length() - 1] == KBerEndOfContent)

   474                 {

   475                 move = -1;

   476 

   477                 aData->Seek(ESeekCurrent, move);

   478 

   479                 dataOffset--;

   480                 }

   481 

   482             dataOffset += bytes.Length();

   483             }

   484         }

   485 

   486     // If nothing was found, move data pointer back

   487     // to where it was and return 0.

   488     if (bytes.Length() == 0)

   489         {

   490         dataOffset = -dataOffset;

   491 

   492         aData->Seek(ESeekCurrent, dataOffset);

   493 

   494         dataOffset = 0;

   495         }

   496 

   497     return dataOffset;

   498     }

   499 

   500 // -----------------------------------------------------------------------------

   501 // CCrBer::OpenConstructedEncodingL

   502 // Open constructed encoding from this object.  

   503 // Parameters: aTarget; target for contentbytes.

   504 // Return Values:  Number of objects in this contructed object.

   505 // -----------------------------------------------------------------------------

   506 EXPORT_C TInt CCrBer::OpenConstructedEncodingL(CCrData& aTarget)

   507     {      

   508     TInt err = KErrNone;

   509     TInt count = 0;

   510     TInt offset = iContentBegin;

   511     TInt objectNum = 0;

   512     TInt type = Type();

   513     CCrBer* object = NULL;

   514 

   515     if (type <= KBerConstructed)        // not valid type

   516         {

   517         User::Leave(KErrArgument);

   518         }

   519     else  

   520         {

   521         type -= KBerConstructed;        // type what we are looking for

   522         }

   523 

   524     CCrBerSet* newSet = CCrBerSet::NewL(1);

   525     CleanupStack::PushL(newSet);

   526     iData->Seek(ESeekStart, offset);    // seek right place; content begin

   527     newSet->OpenL(iData, KOpenAllLevels);

   528     count = newSet->Count();            

   529 

   530     HBufC8* obj = NULL;                 // buffer for CCrBer-objects

   531 

   532     for (objectNum = 0; (objectNum < count); objectNum++)

   533         {

   534         object = newSet->At(objectNum); // select object

   535         

   536         if (object->Type() == type)

   537             {

   538             obj = HBufC8::NewLC(object->ContentLen());

   539             TPtr8 pObj  = obj->Des();

   540             

   541             err = iData->Read(object->ContentBegin(), pObj, object->ContentLen());

   542             

   543             if (err < KErrNone)         // if error -> leave

   544                 {

   545                 CleanupStack::PopAndDestroy(2);  // delete newSet, obj;

   546                 User::Leave(err);

   547                 }    

   548             err = aTarget.Write(pObj);  // write content to CCrData  

   549             

   550             CleanupStack::PopAndDestroy();  // delete obj;

   551             obj = NULL;

   552             

   553             if (err < KErrNone)         // if error -> leave

   554                 {

   555                 CleanupStack::PopAndDestroy();  // delete newSet;

   556                 User::Leave(err);

   557                 }

   558             

   559             }

   560         else 

   561             {

   562             count = objectNum;

   563             }

   564         }

   565     CleanupStack::PopAndDestroy();      // delete newSet;

   566 

   567     return count;

   568     }

   569 

   570 // -----------------------------------------------------------------------------

   571 // CCrBer::OpenConstructedEncodingWithTagL

   572 // Open constructed encoding with given tag from given data.

   573 // Add all founded octets into the parameter string, if given.

   574 // Return amount of bytes read.

   575 // -----------------------------------------------------------------------------

   576 EXPORT_C TUint CCrBer::OpenConstructedEncodingWithTagL(

   577     CCrData* aData,

   578     CCrBer&  parentObj,

   579     HBufC8*  aBuf /* = 0 */)

   580     {

   581     TInt    read = 0;

   582     CCrBer  temp;

   583     TBerTag parentTag = KBerUnknown;

   584     TBerTag tempTag   = KBerUnknown;

   585     HBufC8* tempBuf   = NULL;

   586 

   587     parentTag = parentObj.Type();

   588 

   589     // Check given object. It should have constructed tag.

   590     if (parentTag & KBerConstructedBit)

   591         {

   592         TUint len = 0;

   593         TUint totalLen = iMaxUint;

   594         TBool isIndefinite = parentObj.Indefinite();

   595 

   596         TBufC8<4> buf = _L8("Test");

   597         TPtr8     ptr = buf.Des();

   598 

   599         if (aBuf != 0)

   600             {

   601             ptr = aBuf->Des();

   602             }

   603 

   604         tempBuf = HBufC8::NewLC(KReadBufMax);

   605 

   606         // After that we know that object either contains length or

   607         // it is indefinite. Set max int to len even in the case of

   608         // indefinite length to prevent this loop from going on forever.

   609         if (!isIndefinite)

   610             {

   611             totalLen = parentObj.ContentLen();

   612             }

   613 

   614         while (len < totalLen)

   615             {

   616             // Read objects one by one, calculate content lengths together,

   617             // add contents to target buffer, if given, and calculate also

   618             // total object lengths together to know when stop. In indefinite

   619             // case stop when end-of-content tag found.

   620             temp.Read(aData);

   621 

   622             tempTag = temp.Type();

   623 

   624             if ((tempTag == KBerEndOfContent) ||

   625                 (tempTag == KBerUnknown) ||

   626                 (!(tempTag & parentTag)))

   627                 {

   628                 CleanupStack::PopAndDestroy();  // delete tempBuf;

   629                 return read;                // break

   630                 }

   631 

   632             len += temp.ObjectLen();

   633             read += temp.ContentLen();

   634 

   635             if (aBuf != 0)

   636                 {

   637                 // Resize buffer, if needed, and append data to it.

   638                 if (aBuf->Length() < read)

   639                     {

   640                     // It is impossible to know how long buffer should be,

   641                     // but add some extra space, so reallocation won't occur

   642                     // each time.

   643                     aBuf->ReAllocL(read + (read / 5));

   644                     ptr = aBuf->Des();

   645                     }

   646 

   647                 temp.Content(tempBuf);

   648                 ptr.Append(*tempBuf);

   649                 }

   650             }

   651 

   652         CleanupStack::PopAndDestroy();      // delete tempBuf;

   653         }

   654 

   655     return read;

   656     }

   657 

   658 

   659 

   660 // -----------------------------------------------------------------------------

   661 // CCrBer::Type

   662 // Get type of the object.

   663 // -----------------------------------------------------------------------------

   664 EXPORT_C TBerTag CCrBer::Type()

   665     {

   666 	return iType;

   667     }

   668 

   669 // -----------------------------------------------------------------------------

   670 // CCrBer::Value

   671 // Get value of the object. Used in encoding.

   672 // -----------------------------------------------------------------------------

   673 TInt CCrBer::Value()

   674     {

   675     return iValue;

   676     }

   677 // -----------------------------------------------------------------------------

   678 // CCrBer::GetBigInt

   679 // -----------------------------------------------------------------------------

   680 RInteger CCrBer::GetBigInt()

   681     {

   682     return iInt;

   683     }

   684 

   685 // -----------------------------------------------------------------------------

   686 // CCrBer::SetValue

   687 // Set value of the object.

   688 // -----------------------------------------------------------------------------

   689 TAny CCrBer::SetValue(TInt aInt)

   690     {

   691     iValue = aInt;

   692     }

   693 

   694 // -----------------------------------------------------------------------------

   695 // CCrBer::ValuePtr

   696 // Get valuePtr of the object. (encoding)

   697 // -----------------------------------------------------------------------------

   698 TDesC8* CCrBer::ValuePtr()

   699     {

   700     return iValuePtr;

   701     }

   702 

   703 // -----------------------------------------------------------------------------

   704 // CCrBer::LenLen

   705 // Get amount of length bytes.

   706 // -----------------------------------------------------------------------------

   707 EXPORT_C TInt CCrBer::LenLen()

   708     {

   709     return iLenLen;

   710     }

   711 

   712 // -----------------------------------------------------------------------------

   713 // CCrBer::ObjectBegin

   714 // Return begin of the whole object.

   715 // -----------------------------------------------------------------------------

   716 EXPORT_C TInt CCrBer::ObjectBegin()

   717     {

   718     return iObjectBegin;

   719     }

   720 

   721 // -----------------------------------------------------------------------------

   722 // CCrBer::ContentBegin

   723 // Return begin of the content.

   724 // -----------------------------------------------------------------------------

   725 EXPORT_C TInt CCrBer::ContentBegin()

   726     {

   727     return iContentBegin;

   728     }

   729 

   730 // -----------------------------------------------------------------------------

   731 // CCrBer::ObjectLen

   732 // Get length of the whole object.

   733 // -----------------------------------------------------------------------------

   734 EXPORT_C TInt CCrBer::ObjectLen()

   735     {

   736 	return iObjectLen;

   737 	}

   738 

   739 // -----------------------------------------------------------------------------

   740 // CCrBer::ContentLen

   741 // Get length of the content.

   742 // -----------------------------------------------------------------------------

   743 EXPORT_C TInt CCrBer::ContentLen()

   744     {

   745     return iContentLen;

   746     }

   747 

   748 // -----------------------------------------------------------------------------

   749 // CCrBer::Indefinite

   750 // Returns true if this object is indefinite length.

   751 // -----------------------------------------------------------------------------

   752 EXPORT_C TBool CCrBer::Indefinite()

   753     {

   754     return iIndefinite;

   755     }

   756 

   757 // -----------------------------------------------------------------------------

   758 // CCrBer::Data

   759 // Return pointer to data object.

   760 // -----------------------------------------------------------------------------

   761 EXPORT_C CCrData* CCrBer::Data()

   762     {

   763     return iData;

   764     }

   765 

   766 // -----------------------------------------------------------------------------

   767 // CCrBer::Object

   768 // Return whole BER object with tag and stuff. For implementation

   769 // reasons ObjectL returns only max 255 bytes of data.

   770 // -----------------------------------------------------------------------------

   771 

   772 EXPORT_C TInt CCrBer::Object(HBufC8* aBuf)

   773     {

   774     return BufferL(aBuf, iData, iObjectBegin, iObjectLen);

   775     }

   776 

   777 // -----------------------------------------------------------------------------

   778 // CCrBer::Object

   779 // Return whole BER object with tag and stuff. For implementation

   780 // reasons ObjectL returns only max 255 bytes of data.

   781 // -----------------------------------------------------------------------------

   782 EXPORT_C TInt CCrBer::ObjectL(HBufC* aBuf)

   783     {

   784     TUint8 len = 255;

   785 

   786 

   787     if (iObjectLen < 255)

   788         {

   789         len = (TUint8)iObjectLen;

   790         }

   791 	

   792     return BufferL(aBuf, iData, iObjectBegin, len);

   793     }

   794 

   795 // -----------------------------------------------------------------------------

   796 // CCrBer::Content

   797 // Return content of this object. For implementation reasons

   798 // ContentL returns only max 255 bytes of data.

   799 // -----------------------------------------------------------------------------

   800 EXPORT_C TInt CCrBer::Content(HBufC8* aBuf)

   801     {

   802     return BufferL(aBuf, iData, iContentBegin, iContentLen);

   803     }

   804 

   805 // -----------------------------------------------------------------------------

   806 // CCrBer::ContentL

   807 // -----------------------------------------------------------------------------

   808 EXPORT_C TInt CCrBer::ContentL(HBufC* aBuf)

   809     {

   810     TUint8 len = 255;

   811 

   812     if (iContentLen < 255)

   813         {

   814         len = (TUint8)iContentLen;

   815         }

   816 

   817     return BufferL(aBuf, iData, iContentBegin, len);

   818     }

   819 

   820 // -----------------------------------------------------------------------------

   821 // CCrBer::BufferL

   822 // Read aAmount of data starting from begin to the buffer.

   823 // Return amount of data read. For implementation reasons

   824 // BufferL can be used only to read max 256 bytes of data.

   825 // -----------------------------------------------------------------------------

   826 EXPORT_C TInt CCrBer::BufferL(

   827     HBufC8*   aBuf,

   828     CCrData*  aData,

   829     TUint     aBegin  /* = 0 */,

   830     TUint     aAmount /* = KReadBufMax */)

   831     {

   832     TInt pos = 0;

   833     TInt begin = aBegin;

   834     TInt amount = aAmount;

   835     TInt read = 0;

   836 

   837     if ((aBuf == 0) || (aData == 0))

   838         {

   839         // Don't bother to continue.

   840         return read;

   841         }

   842 

   843     // Store current position,

   844     if ((aData->Seek(ESeekCurrent, pos)) != KErrNone)

   845         {

   846         // Don't bother to continue.

   847         return read;

   848         }

   849 

   850     // Set data pointer to wanted position.

   851     if (aData->Seek(ESeekStart, begin) == KErrNone)

   852         {

   853         // Resize buffer, if needed, and read data.

   854         if (aBuf->Length() < amount)

   855             {

   856             aBuf->ReAllocL(amount);

   857             }

   858 

   859         TPtr8 ptr = aBuf->Des();

   860 

   861         if (aData->Read(ptr, amount) == KErrNone)

   862             {

   863             read = aBuf->Length();

   864             }

   865         }

   866 

   867     // Put data pointer back to previous position.

   868     aData->Seek(ESeekStart, pos);

   869 

   870     return read;

   871     }

   872 

   873 EXPORT_C TInt CCrBer::BufferL(

   874     HBufC*   aBuf,

   875     CCrData* aData,

   876     TUint    aBegin  /* = 0 */,

   877     TUint8   aAmount /* = 255 */)

   878     {

   879     TInt      index = 0;

   880     TInt      len = 0;

   881     TInt      amount = NULL;

   882     TBuf<255> buf;

   883     HBufC8*   heapBuf = NULL;

   884 

   885     heapBuf = HBufC8::NewLC(255);

   886 

   887     amount = BufferL(heapBuf, aData, aBegin, aAmount);

   888 

   889     len = heapBuf->Length();

   890 

   891     for (index = 0; index < len; index++)

   892         {

   893         buf.Append((*heapBuf)[index]);

   894         }

   895 

   896     *aBuf = buf;

   897 

   898     CleanupStack::PopAndDestroy();      // delete heapBuf;

   899     // heapBuf = NULL;

   900 

   901     return amount;

   902     }

   903 

   904 

   905 // -----------------------------------------------------------------------------

   906 // CCrBer::Level

   907 // Return nesting level of this object.

   908 // -----------------------------------------------------------------------------

   909 EXPORT_C TUint CCrBer::Level()

   910     {

   911     return iLevel;

   912     }

   913 

   914 // -----------------------------------------------------------------------------

   915 // CCrBer::SetLevel

   916 // Set nesting level of this object.

   917 // -----------------------------------------------------------------------------

   918 EXPORT_C TUint CCrBer::SetLevel(TUint aLevel)

   919     {

   920     iLevel = aLevel;

   921 

   922     return iLevel;

   923     }

   924 

   925 // -----------------------------------------------------------------------------

   926 // CCrBer::AddToContentLen

   927 // Add given integer to content length of this object.

   928 // -----------------------------------------------------------------------------

   929 EXPORT_C TAny CCrBer::AddToContentLen(TInt iLen)

   930     {

   931     iContentLen += iLen;

   932     }

   933 

   934 // -----------------------------------------------------------------------------

   935 // CCrBer::SetObjectLen

   936 // Calculate object length from tag, length's length, and

   937 // content's length. Used to 'close' indefinite objects, meaning

   938 // that their end-of-contents tag is finally found, so their

   939 // length can be calculated.

   940 // -----------------------------------------------------------------------------

   941 EXPORT_C TAny CCrBer::SetObjectLen()

   942     {

   943     // Objects length is tag len (always 1) + length byte

   944     // amount + content length.

   945     iObjectLen = 1 + iLenLen + iContentLen;

   946 

   947     // If object was of indefinite length, there are

   948     // two additional end-of-contents bytes at the end.

   949     if (iIndefinite)

   950         {

   951         iObjectLen += 2;

   952         }

   953     }

   954 

   955 // -----------------------------------------------------------------------------

   956 // CCrBer::SetObjLenWithOutContent

   957 // Parameters:     Content length.

   958 // -----------------------------------------------------------------------------

   959 TAny CCrBer::SetObjLenWithOutContent(TUint aContentLen)

   960     {

   961     iObjectLen  = KBerShortLen;             // Tag + len

   962     if (aContentLen >= KBerLongLengthBit)

   963         {

   964         while (aContentLen > 0)                    

   965             {

   966             aContentLen >>= 8;              // Next byte

   967             iObjectLen++;                 

   968             }

   969         }

   970     }

   971 

   972 // -----------------------------------------------------------------------------

   973 // Get content functions.

   974 // -----------------------------------------------------------------------------

   975 

   976 // -----------------------------------------------------------------------------

   977 // CCrBer::GetBooleanL

   978 // Returns value of Boolean object.

   979 // -----------------------------------------------------------------------------

   980 EXPORT_C TBool CCrBer::GetBooleanL()

   981     {		

   982     TInt err = KErrNone;

   983     TASN1DecBoolean dec;                                // ASN1 lib (Symbian)

   984     TInt pos    = NULL;

   985     TBool ret   = EFalse;

   986 

   987     HBufC8* buf = HBufC8::NewLC(iObjectLen);            // buffer to object

   988 

   989     TPtr8 ptr   = buf->Des();

   990    

   991     err = iData->Read(iObjectBegin,ptr,iObjectLen);     // Read object

   992 

   993     if (err == KErrNone)

   994         {

   995         ret = dec.DecodeDERL(ptr, pos); 	        // decode object

   996         }

   997     else

   998         {        

   999         CleanupStack::PopAndDestroy();                  // delete buf;

  1000         User::Leave(err);

  1001         }

  1002 

  1003     CleanupStack::PopAndDestroy();                      // delete buf;

  1004  

  1005     return ret;

  1006     }	

  1007 

  1008 // -----------------------------------------------------------------------------

  1009 // CCrBer::GetIntegerL

  1010 // Returns value of Integer object.

  1011 // -----------------------------------------------------------------------------		

  1012 EXPORT_C TInt CCrBer::GetIntegerL()

  1013     {

  1014     TInt err = KErrNone;

  1015     TASN1DecInteger dec;                                // ASN1 lib (Symbian)

  1016     TInt pos    = NULL;

  1017     TInt ret    = NULL;

  1018 

  1019     HBufC8* buf = HBufC8::NewLC(iObjectLen);             // buffer to object

  1020 

  1021     TPtr8 ptr   = buf->Des();

  1022    

  1023     err = iData->Read(iObjectBegin,ptr,iObjectLen);     // Read object

  1024 

  1025     if (err == KErrNone)

  1026         {

  1027         ret = dec.DecodeDERShortL(ptr, pos);        	// decode object

  1028         }

  1029     else

  1030         {        

  1031         CleanupStack::PopAndDestroy();                  // delete buf;

  1032         User::Leave(err);

  1033         }

  1034 

  1035     CleanupStack::PopAndDestroy();                      // delete buf;

  1036 

  1037     return ret;

  1038     }

  1039 

  1040 // -----------------------------------------------------------------------------

  1041 // CCrBer::GetIntegerL

  1042 // Returns value of Long Integer object.

  1043 // -----------------------------------------------------------------------------		

  1044 EXPORT_C RInteger CCrBer::GetLongIntegerL()

  1045     {	

  1046     TInt err    = KErrNone;

  1047     TInt pos    = NULL;

  1048     TASN1DecInteger dec;                                // ASN1 lib (Symbian)

  1049 

  1050     HBufC8* buf = HBufC8::NewLC(iObjectLen);             // buffer to object

  1051 

  1052     TPtr8 ptr   = buf->Des();

  1053     RInteger value;

  1054 

  1055     // Read object to buf

  1056     err = iData->Read(iObjectBegin,ptr,iObjectLen);

  1057 

  1058     if (err == KErrNone)

  1059         {

  1060         value = dec.DecodeDERLongL(ptr, pos);           // decode object

  1061         }

  1062     else

  1063         {        

  1064         CleanupStack::PopAndDestroy();                  // delete buf;

  1065         User::Leave(err);

  1066         }

  1067     

  1068     CleanupStack::PopAndDestroy();                      // delete buf;

  1069 

  1070     return value;

  1071     }

  1072   

  1073 // -----------------------------------------------------------------------------

  1074 // HBufC* CCrBer::GetOidL

  1075 // Returns value of object identifier.

  1076 // -----------------------------------------------------------------------------

  1077 EXPORT_C HBufC* CCrBer::GetOidL()

  1078     {	

  1079     TInt err    = KErrNone;

  1080     TInt pos    = NULL;

  1081     HBufC* ret  = NULL;

  1082     TASN1DecObjectIdentifier dec;                       // ASN1 lib (Symbian)

  1083 

  1084     HBufC8* buf = HBufC8::NewLC(iObjectLen);            // buffer to object

  1085 

  1086     TPtr8 ptr   = buf->Des();

  1087 

  1088     // Read object to buf

  1089     err = iData->Read(iObjectBegin,ptr,iObjectLen);    

  1090 

  1091     if (err == KErrNone)

  1092         {

  1093         ret = dec.DecodeDERL(ptr, pos);                 // decode object

  1094         }

  1095     else

  1096         {        

  1097         CleanupStack::PopAndDestroy();                  // delete buf;

  1098         User::Leave(err);

  1099         }

  1100 

  1101     CleanupStack::PopAndDestroy();                      // delete buf;

  1102 

  1103     return ret;

  1104     }

  1105 

  1106 // -----------------------------------------------------------------------------

  1107 // HBufC8* CCrBer::GetOctetStringL

  1108 // Returns value of octet string.

  1109 // -----------------------------------------------------------------------------

  1110 EXPORT_C HBufC8* CCrBer::GetOctetStringL()

  1111     {	

  1112     TInt pos = NULL;

  1113     HBufC8* ret = NULL;

  1114     TInt err = KErrNone;

  1115     TASN1DecOctetString dec;                            // ASN1 lib (Symbian)

  1116 

  1117     HBufC8* buf = HBufC8::NewLC(iObjectLen);             // buffer to object

  1118 

  1119     TPtr8 ptr   = buf->Des();

  1120 

  1121     // Read object to buf

  1122     err = iData->Read(iObjectBegin,ptr,iObjectLen);    

  1123 

  1124     if (err == KErrNone)

  1125         {

  1126         ret = dec.DecodeDERL(ptr, pos);                 // decode object

  1127         }

  1128     else

  1129         {        

  1130         CleanupStack::PopAndDestroy(buf);                  // delete buf;

  1131         User::Leave(err);

  1132         }

  1133 

  1134     CleanupStack::PopAndDestroy(buf);                      // delete buf;

  1135