1 /** @file

     2 * Copyright (c) 2005-2006 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:  HTTP header

    15 *

    16 */

    17 

    18 

    19 // INCLUDES

    20 #include <e32math.h>

    21 #include <f32file.h>

    22 #include <e32std.h>

    23 

    24 #include <e32property.h>

    25 

    26 #include "upnplist.h"

    27 

    28 #include "upnphttpmessage.h"

    29 #include "upnpcommonupnplits.h"

    30 #include "upnpcons.h"

    31 #include "upnpstring.h"

    32 #include "upnpcustomlog.h"

    33 #include "upnpmessageobserver.h"

    34 

    35 const TInt KHeadersMaxSixe = 8192;

    36 // ================= MEMBER FUNCTIONS =======================

    37 

    38 // -----------------------------------------------------------------------------

    39 // CUpnpHttpMessage::NewL

    40 // Two-phased constructor.

    41 // -----------------------------------------------------------------------------

    42 //

    43 EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL()

    44     {

    45     CUpnpHttpMessage* self = new (ELeave) CUpnpHttpMessage();

    46     CleanupStack::PushL(self);

    47     self->ConstructL();

    48     CleanupStack::Pop(self);

    49     

    50     return self;

    51     }

    52 

    53 // -----------------------------------------------------------------------------

    54 // CCHttpMessage::NewL

    55 // Two-phased constructor.

    56 // -----------------------------------------------------------------------------

    57 //

    58 EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(const TInetAddr& aAddr)

    59     {

    60     return NewL(aAddr, NewSessionIdL());

    61     }

    62 

    63 // -----------------------------------------------------------------------------

    64 // CCHttpMessage::NewL

    65 // Two-phased constructor.

    66 // -----------------------------------------------------------------------------

    67 //

    68 EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(TInetAddr aAddr, TInt aSessionId)

    69     {

    70     CUpnpHttpMessage* self = new (ELeave) CUpnpHttpMessage();

    71     CleanupStack::PushL(self);

    72     

    73     

    74     self->ConstructL(aAddr, aSessionId);

    75     CleanupStack::Pop(self);

    76     

    77     return self;

    78     }

    79 

    80 // -----------------------------------------------------------------------------

    81 // CCHttpMessage::NewL

    82 // Two-phased constructor.

    83 // -----------------------------------------------------------------------------

    84 //

    85 EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(TDesC8& aMessageBuffer, TInetAddr aSender)

    86     {

    87     

    88     return NewL(aMessageBuffer, aSender, NewSessionIdL());

    89     }

    90 

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

    92 // CCHttpMessage::NewL

    93 // Two-phased constructor.

    94 // -----------------------------------------------------------------------------

    95 //

    96 EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(TDesC8& aMessageBuffer, const TInetAddr& aSender, TInt aSessionId)

    97     {

    98     CUpnpHttpMessage* self = NewL(aSender, aSessionId);

    99     CleanupStack::PushL(self);

   100     self->ParseL(aMessageBuffer);

   101     CleanupStack::Pop();

   102 

   103     return self;

   104     }

   105 

   106 // -----------------------------------------------------------------------------

   107 // CUpnpHttpMessage::~CUpnpHttpMessage

   108 // Destructor.

   109 // -----------------------------------------------------------------------------

   110 //

   111 EXPORT_C CUpnpHttpMessage::~CUpnpHttpMessage()

   112     {

   113     if (iHeaderList)

   114         {

   115         iHeaderList->DeleteObjects();

   116         delete iHeaderList;

   117         }

   118 

   119     if( iTimer )

   120         {

   121         iTimer->Cancel();

   122         delete iTimer;

   123         }

   124 

   125     if ( iOutUri )

   126         {

   127         delete iOutUri;

   128         }

   129 

   130     delete iDestinationPath;

   131 

   132 

   133     delete iSenderPath;

   134 

   135 

   136     delete iTextBody;

   137 

   138 

   139     delete iOutFilename;

   140 

   141 

   142     delete iInFilename;

   143 

   144     }

   145 

   146 // -----------------------------------------------------------------------------

   147 // CUpnpHttpMessage::CUpnpHttpMessage

   148 // C++ default constructor can NOT contain any code, that

   149 // might leave.

   150 // -----------------------------------------------------------------------------

   151 //

   152 EXPORT_C CUpnpHttpMessage::CUpnpHttpMessage()

   153     {

   154     iSessionPriority = EPriorityNormal;

   155     

   156     iOverwriteExisting = EFalse;

   157     

   158     // Parameters connected with downloading range of requested content.

   159     // This mechanism if disabled by default an the whole file is requested.

   160     iOffset = 0;

   161     iLength = 0; 

   162     iSaveAtOffset = EFalse;

   163     }

   164 

   165 // -----------------------------------------------------------------------------

   166 // CUpnpHttpMessage::ConstructL

   167 // Symbian 2nd phase constructor can leave.

   168 // -----------------------------------------------------------------------------

   169 //

   170 EXPORT_C void CUpnpHttpMessage::ConstructL()

   171     {

   172     iHeaderList = new (ELeave) CUpnpHttpHeaderList;

   173 

   174     

   175     iTextBody = HBufC8::NewL(0);

   176 

   177     iDestinationPath = HBufC8::NewL(0);

   178     iSenderPath = HBufC8::NewL(0);

   179 

   180     iInFilename = HBufC8::NewL(0);

   181     iOutFilename = HBufC8::NewL(0);

   182     //by default EFalse, meaning ignored

   183     iClientRequest = EFalse;

   184     //TCP-session's 0 means the value will be ignored unless changed later on!

   185     iTcpTimeout = 0;

   186     iInternalError = KErrNone;

   187     }

   188 

   189 // -----------------------------------------------------------------------------

   190 // CUpnpHttpMessage::ConstructL

   191 // Symbian 2nd phase constructor can leave.

   192 // -----------------------------------------------------------------------------

   193 //

   194 EXPORT_C void CUpnpHttpMessage::ConstructL( TInetAddr& aSender, TInt aSessionId)

   195     {

   196     iDestinationPath = HBufC8::NewL(0);

   197 

   198     iSenderPath = HBufC8::NewL(0);

   199 

   200     iInFilename = HBufC8::NewL(0);

   201     

   202     iOutFilename = HBufC8::NewL(0);

   203     

   204     iHeaderList = new (ELeave) CUpnpHttpHeaderList;

   205 

   206     iTextBody = HBufC8::NewL(0);

   207     

   208     iRemoteHost = aSender;

   209     iSessionId = aSessionId;

   210     //by default EFalse, meaning ignored

   211     iClientRequest = EFalse;

   212     }

   213 

   214 // -----------------------------------------------------------------------------

   215 // CUpnpHttpMessage::ParseL

   216 // Parses one row of headers.

   217 // -----------------------------------------------------------------------------

   218 //

   219 EXPORT_C void CUpnpHttpMessage::ParseL(TDesC8& aBuffer)

   220     {

   221 

   222     // position where the header ends

   223     TInt endOfHeader=0;

   224     

   225     // position of first \r\n

   226     TInt posOfNextLine = 0;

   227     

   228     // position of first space

   229     TInt posOfFirstSpace = 0;

   230 

   231     // position of second space

   232     TInt posOfSecondSpace = 0;

   233 

   234     // Boolean value that is used to check if message is

   235     // request or response. If message is response, protocol

   236     // version information is at the beginning of first row

   237     // (HTTP/1.1 200 OK)

   238     // In request, protocol version is at the end.

   239     // (GET / HTTP/1.1)

   240     TBool isResponse = EFalse;

   241 

   242 // Handling of header part

   243     

   244     // trying to find Head/body separator

   245     endOfHeader = aBuffer.Find(UpnpString::KDoubleLineFeed);

   246     if( endOfHeader == KErrNotFound)

   247         {

   248         User::Leave(KErrAbort);

   249         }

   250 

   251     posOfNextLine = aBuffer.Find(UpnpString::KLineFeed); 

   252     if( posOfNextLine != KErrNotFound )

   253         {

   254         TPtrC8 spacePtr;

   255         spacePtr.Set( aBuffer );

   256         

   257         // finding first space

   258         posOfFirstSpace = spacePtr.Find(UpnpString::KSpace);

   259         if ( posOfFirstSpace != KErrNotFound )

   260             {

   261             spacePtr.Set( spacePtr.Left( posOfFirstSpace ) );

   262 

   263             // if first word of message is HTTP/1.1 or HTTP/1.0

   264             // message is response

   265             if( ( spacePtr.Find( KHttp11WithoutSpace() ) == 0 && 

   266                   posOfFirstSpace == KHttp11WithoutSpace().Length() ) 

   267                 ||

   268                 ( spacePtr.Find( KHttp10() ) == 0 && 

   269                   posOfFirstSpace == KHttp10().Length() ) )

   270                 {

   271                 isResponse = ETrue;

   272                 }

   273             else

   274                 {

   275                 isResponse = EFalse;            

   276                 }

   277             }

   278         else

   279             {

   280             isResponse = EFalse;            

   281             }

   282 

   283         // back to basic handling

   284         spacePtr.Set( aBuffer );

   285         

   286         if( posOfFirstSpace < posOfNextLine && posOfFirstSpace != KErrNotFound )

   287             {

   288             // if first space is found, it has to be before linefeed

   289             // +1 comes from going over the first space, we are interested

   290             // in what comes after it.

   291             spacePtr.Set( spacePtr.Mid( posOfFirstSpace  + 1 ) );

   292             posOfSecondSpace = spacePtr.Find(UpnpString::KSpace);

   293             if( posOfSecondSpace < posOfNextLine && posOfSecondSpace != KErrNotFound )

   294                 {

   295                 // check that length of path is longer than zero.

   296                 if( posOfSecondSpace > 0 )

   297                     {

   298                     // Now check that Protocol version is HTTP/1.0 

   299                     // or HTTP/1.1. 

   300                     

   301                     // If message is response, version is defined in first 

   302                     // parameter of the message. This has been checked before,

   303                     // so if response, no check needed.

   304                     spacePtr.Set( spacePtr.Mid( posOfSecondSpace+1 ) );

   305                     posOfNextLine = spacePtr.FindC( UpnpString::KLineFeed() );

   306                     spacePtr.Set( spacePtr.Left( posOfNextLine ) );

   307                     

   308                     if( !isResponse )

   309                         {

   310                         //Check protocol's version                        

   311                         if (spacePtr.Match( KHttpVersionPattern() ) == 0 )

   312                             {    

   313                             //get only version numbers    

   314                             TPtrC8 version = spacePtr.Mid(5);

   315                             TLex8 lex(version);

   316                             TUint major;                            

   317                             if(lex.Val(major)!= KErrNone || lex.Peek()!='.')

   318                                 {

   319                                 {

   320                                 // (protocol NOT HTTP/1.0 or HTTP/1.1. Invalid message)

   321                                 User::Leave(KErrAbort);        

   322                                 }

   323                                 }

   324                             lex.Inc();                                                        

   325                             TUint minor;

   326                             if (lex.Val(minor) !=KErrNone)

   327                                 {

   328                                 // (protocol NOT HTTP/1.x. Invalid message)

   329                                 User::Leave(KErrAbort);    

   330                                 }                                

   331                             lex.SkipSpace();

   332                             if (!lex.Eos())

   333                                 {

   334                                 // (protocol NOT HTTP/1.x. Invalid message)

   335                                 User::Leave(KErrAbort);    

   336                                 }

   337                             //only 1.1 and 1.0 supported

   338                             if(major != 1 || (minor>1))

   339                                 {

   340                                 // (HTTP Version not supported)

   341                                 User::Leave(-EHttpVersionNotSupported);    

   342                                 }

   343                             

   344                             }

   345                         else

   346                             {

   347                             // (protocol NOT HTTP/1.0 or HTTP/1.1. Invalid message)

   348                             User::Leave(KErrAbort);                                

   349                             }

   350                         }

   351         

   352                     }

   353                 else

   354                     {

   355                     // header too short. Invalid message

   356                     User::Leave(KErrAbort);

   357                     }

   358                 }

   359             else

   360                 {

   361                 // no second space found. Invalid message.

   362                 User::Leave(KErrAbort);

   363                 }

   364             }

   365         else

   366             {

   367             // no space found before linefeed. Invalid message

   368             User::Leave(KErrAbort);

   369             }

   370         }

   371     else

   372         {

   373         // no linefeed found. Invalid message

   374         User::Leave(KErrAbort);

   375         }

   376 

   377     if ( endOfHeader != KErrNotFound )

   378         {

   379         TPtrC8 tempHeaderPointer;

   380         TPtrC8 finderIndexPointer;

   381         tempHeaderPointer.Set(aBuffer.Left(endOfHeader));

   382         

   383         

   384         // if header lenght is longer that 8k,cut headers after one that cross the line

   385         if (endOfHeader > KHeadersMaxSixe)

   386             {

   387             TInt afterLimit = tempHeaderPointer.Mid(KHeadersMaxSixe).Find(UpnpString::KLineFeed);

   388             if (afterLimit != KErrNotFound)

   389                 {

   390                 tempHeaderPointer.Set(tempHeaderPointer.Left(KHeadersMaxSixe + afterLimit));

   391                 }

   392             }    

   393         TInt index=0, indexLWS=0, indexCRLF=0;

   394         TBool FirstLine=ETrue;

   395         

   396         while (index != KErrNotFound)

   397             {

   398             // locate end-of-line, parse each line separately

   399         

   400             //RFC822 3.2 field-name  =  1*<any CHAR, excluding CTLs, SPACE, and ":">

   401             index = tempHeaderPointer.Find(UpnpString::KLineFeed);

   402             indexLWS = FindLWS(tempHeaderPointer);

   403             finderIndexPointer.Set(tempHeaderPointer);

   404             indexCRLF = index;

   405             //the length of the string for the end-line marker CRLF

   406             TInt headerCRLF = 2;

   407             while (indexCRLF == indexLWS && indexCRLF != KErrNotFound)

   408             {

   409                 //3 below =the length of the LWS string

   410                 finderIndexPointer.Set(finderIndexPointer.Right(finderIndexPointer.Length()-(indexCRLF+3)));

   411                 indexCRLF = finderIndexPointer.Find(UpnpString::KLineFeed);

   412                 if (indexCRLF == KErrNotFound)

   413                 {

   414                     //3 below =the length of the LWS string

   415                     index += finderIndexPointer.Length() + 3; 

   416                     indexLWS = finderIndexPointer.Length();

   417                     headerCRLF = 0;

   418                 }

   419                 else

   420                 {

   421                     index += indexCRLF+3;    

   422                     indexLWS = FindLWS(finderIndexPointer);

   423                 }

   424                 

   425                 

   426             }

   427             if(index != KErrNotFound)

   428                 {

   429                 TPtrC8 oneHeaderRow;

   430                 oneHeaderRow.Set(tempHeaderPointer.Left(index));

   431 

   432                 // To check if is the first line of message (e.g. GET / HTTP 1.1 etc.)

   433                 if (FirstLine)

   434                     {

   435                     ParseHeaderRowL( (TDesC8&) oneHeaderRow, ETrue);

   436                     FirstLine=EFalse;

   437                     }

   438                 else 

   439                     {

   440                     ParseHeaderRowL(oneHeaderRow, EFalse);

   441                     }

   442 

   443                 // To delete one header row + "\r\n" = length+2 to prepare for next row.

   444                 if (headerCRLF)

   445                     {

   446                     tempHeaderPointer.Set(tempHeaderPointer.Right(tempHeaderPointer.Length()-(index+headerCRLF)));    

   447                     

   448                     }

   449                     else

   450                     {

   451                         index = KErrNotFound;

   452                     }

   453                 }

   454             }

   455             

   456         if (FirstLine)

   457             {

   458             ParseHeaderRowL(tempHeaderPointer, ETrue);

   459             }

   460         else

   461             {

   462             ParseHeaderRowL(tempHeaderPointer, EFalse);

   463             }

   464         }

   465     // check if all HTTP/1 requests have HOST header

   466     if(!isResponse && RequestHTTPVersion() == KHttp11WithoutSpace() )

   467         {

   468         TBool exists;

   469         IsHeader(UpnpSSDP::KHdrHost(), exists);

   470         if (!exists) 

   471             User::Leave(KErrAbort);    

   472         }

   473     

   474     // Handle body:

   475     

   476     if(iTextBody)

   477         {

   478         delete iTextBody;

   479         iTextBody=NULL;

   480         }

   481     

   482     iTextBody=HBufC8::NewL(aBuffer.Length() - endOfHeader);

   483     iTextBody->Des().Zero();

   484     

   485     // Append rest of message to iTextBody. Leave out string "\r\n\r\n".

   486     iTextBody->Des().Append(aBuffer.Right(aBuffer.Length() - (endOfHeader + 4)));

   487     }

   488 // -----------------------------------------------------------------------------

   489 // CUpnpHttpMessage::ParseHeaderRowL

   490 // Parses one row of headers.

   491 // -----------------------------------------------------------------------------

   492 //

   493 EXPORT_C TInt CUpnpHttpMessage::FindLWS(const TDesC8& aText)

   494 {

   495     TInt indexSP = aText.Find(UpnpString::KCRLFSP);

   496     TInt indexHT = aText.Find(UpnpString::KCRLFHT);

   497     

   498     

   499     if (indexSP == KErrNotFound) 

   500         return indexHT;

   501     else if    (indexHT == KErrNotFound) 

   502         return indexSP;

   503     else if(indexSP < indexHT) 

   504         return indexSP;

   505     else

   506         return indexHT;

   507     

   508 }

   509 

   510 // -----------------------------------------------------------------------------

   511 // CUpnpHttpMessage::ParseHeaderRowL

   512 // Parses one row of headers.

   513 // -----------------------------------------------------------------------------

   514 //

   515 EXPORT_C void CUpnpHttpMessage::ParseHeaderRowL(const TDesC8& aBuffer, TBool aFirstLine)

   516     {

   517     TInt FirstColonPosition=0;

   518 

   519     // locate first colon. This separates header's name and value.

   520 

   521     FirstColonPosition = aBuffer.Find(UpnpString::KColon());

   522     if(aFirstLine)

   523         {

   524         AddPairL(aBuffer, KSpace8());

   525         }

   526     else

   527         {

   528         if (FirstColonPosition == KErrNotFound )

   529             {

   530                 User::Leave(KErrAbort);

   531             }

   532         else 

   533             {    

   534             HBufC8* TrimBuffer;

   535             TrimBuffer=HBufC8::NewLC(aBuffer.Length() - (FirstColonPosition + 1));

   536             TrimBuffer->Des().Zero();

   537             

   538             TrimBuffer->Des().Append(aBuffer.Right(aBuffer.Length() - (FirstColonPosition + 1)));

   539             TrimBuffer->Des().Trim();

   540             UnFoldHeader(TrimBuffer);

   541 

   542             TPtrC8 ptr = aBuffer.Left(FirstColonPosition);

   543             

   544             // if there are spaces, ignore them.

   545             TBool spaceFound = ETrue;

   546 

   547             while( spaceFound )

   548                 {

   549                 if(ptr.Find(KSpace()) == 0)

   550                     {

   551                     ptr.Set(ptr.Mid(1));

   552                     }

   553                 else

   554                     {

   555                     spaceFound = EFalse;

   556                     }

   557                 }

   558 

   559             AddPairL(ptr, *TrimBuffer);

   560             

   561             CleanupStack::PopAndDestroy();    

   562             }

   563         }

   564     }

   565 

   566 // -----------------------------------------------------------------------------

   567 // CUpnpHttpMessage::TimerEventL

   568 // Timer expired. For SSDP messages

   569 // -----------------------------------------------------------------------------

   570 //

   571 EXPORT_C void CUpnpHttpMessage::TimerEventL( CUpnpNotifyTimer* /*aTimer*/ )

   572     {

   573     // Cancel timer if exists.

   574     if( iTimer )

   575         {

   576         if( iTimer->IsActive() )

   577             {

   578             iTimer->Cancel();

   579             }

   580         }

   581     iMessageObserver->MessageExpiredL( this );

   582     }

   583 

   584 // -----------------------------------------------------------------------------

   585 // CUpnpHttpMessage::SetMessageTimeoutL

   586 // Set message timer timeout for SSDP messages.

   587 // -----------------------------------------------------------------------------

   588 //   

   589 EXPORT_C TInt CUpnpHttpMessage::SetMessageTimeoutL( MUpnpMessageObserver* aObserver, const TInt aTimeoutValue )

   590     {

   591     // check that request is valid.

   592     if( !aObserver )

   593         {

   594         return KErrNotFound;

   595         }

   596         

   597     iMessageObserver = aObserver;

   598 

   599     if( iTimer )

   600         {

   601         if( iTimer->IsActive() )

   602             {

   603             iTimer->Cancel();

   604             }

   605         }

   606     else

   607         {

   608         // setup timer;

   609         iTimer = CUpnpNotifyTimer::NewL( this );

   610         }

   611     iTimer->After( aTimeoutValue );

   612     return KErrNone;

   613     }

   614 

   615 // -----------------------------------------------------------------------------

   616 // CUpnpHttpMessage::CancelMessageTimeout

   617 // Set message timer timeout.

   618 // -----------------------------------------------------------------------------

   619 //   

   620 EXPORT_C void CUpnpHttpMessage::CancelMessageTimeout()

   621     {

   622     if ( iTimer )

   623         {

   624         iTimer->Cancel();

   625         // Deleting timer will also null the observer in the timer.

   626         delete iTimer;

   627         iTimer = NULL;

   628         }

   629     }

   630     

   631 // -----------------------------------------------------------------------------

   632 // CUpnpHttpMessage::AddPairL

   633 // Adds a Headerrow in this message.

   634 // -----------------------------------------------------------------------------

   635 //

   636 EXPORT_C void CUpnpHttpMessage::AddPairL(const TDesC8& aName, const TDesC8& aValue)

   637     {

   638     // first checking if given header already exists in the message

   639 

   640     CUpnpHttpHeader* chk = iHeaderList->First();

   641     while( chk != NULL )

   642         {

   643         if( chk->Name().CompareC( aName ) == 0 )

   644             {

   645             chk->SetValueL( aValue );

   646             // no delete to chk, it is owned by iHeaderList.

   647             return;

   648             }

   649         chk = iHeaderList->Next( chk );

   650         }

   651     

   652     // header name not found, adding it.

   653         

   654     CUpnpHttpHeader* hdr = CUpnpHttpHeader::NewL(aName, aValue);

   655     CleanupStack::PushL(hdr);

   656     iHeaderList->AddL(hdr);

   657     CleanupStack::Pop(hdr);

   658     }

   659     

   660     

   661 // -----------------------------------------------------------------------------

   662 // CUpnpHttpMessage::AddPairL

   663 // Adds a Headerrow in this message.

   664 // -----------------------------------------------------------------------------

   665 //

   666 EXPORT_C void CUpnpHttpMessage::RemovePairL(const TDesC8& aName)

   667     {

   668     // first checking if given header already exists in the message

   669 

   670     CUpnpHttpHeader* chk = iHeaderList->First();

   671     while( chk != NULL )

   672         {

   673         if( chk->Name().CompareC( aName ) == 0 )

   674             {

   675             // no delete to chk, it is owned by iHeaderList.

   676             iHeaderList->Remove(chk);

   677             delete chk;

   678             return;

   679             }

   680         chk = iHeaderList->Next( chk );

   681         }

   682     

   683     }

   684 

   685     

   686 

   687 // -----------------------------------------------------------------------------

   688 // CUpnpHttpMessage::SetBodyL

   689 // Sets the body of message.

   690 // -----------------------------------------------------------------------------

   691 //

   692 EXPORT_C void CUpnpHttpMessage::SetBodyL(const TDesC8& aBody)

   693     {

   694     delete iTextBody;

   695     iTextBody = NULL;

   696     iTextBody = aBody.AllocL();

   697     }

   698 

   699 // -----------------------------------------------------------------------------

   700 // CUpnpHttpMessage::Body

   701 // Getter for the body of message.

   702 // -----------------------------------------------------------------------------

   703 //

   704 EXPORT_C TDesC8& CUpnpHttpMessage::Body()

   705     {

   706     return *iTextBody;

   707     }

   708 

   709 // -----------------------------------------------------------------------------

   710 // CUpnpHttpMessage::HeadersToStringL

   711 // Returns message as HBufC8.

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

   713 //

   714 EXPORT_C HBufC8* CUpnpHttpMessage::HeadersToStringL()

   715     {

   716     CUpnpHttpHeader* hdr = iHeaderList->First();

   717 

   718     HBufC8* headerBuf = NULL;

   719     headerBuf = HBufC8::NewL(0);

   720     headerBuf->Des().SetLength(0);

   721     TBool firstLine = ETrue;

   722     

   723     while (hdr != NULL)

   724         {

   725         CleanupStack::PushL( headerBuf );

   726         

   727         HBufC8* tempHeader = NULL;

   728     

   729         tempHeader=HBufC8::NewLC( hdr->Name().Length() +

   730                                     hdr->Value().Length() +

   731                                     4 ); // 4 for colon, space and linefeed

   732         tempHeader->Des().Zero();        

   733         tempHeader->Des().Append(hdr->Name());

   734 

   735 

   736         //first line is Request line (Request-Line   = Method SP Request-URI SP HTTP-Version CRLF)

   737         //block is needed for URI manipualtion, first line is ALSO added

   738         //-- can not be folded, DLNA says directly "Each HTTP header line"

   739 

   740 

   741         TInt posOfSpace = tempHeader->Des().Find(UpnpString::KSpace());

   742             TPtrC8 ptr;

   743             if (posOfSpace != KErrNotFound)

   744                 {

   745                 ptr.Set( 

   746                 tempHeader->Des().Right( tempHeader->Des().Length() - 

   747                                             (posOfSpace + 1)  )

   748                     );

   749                 }

   750             

   751             TInt posOfSecondSpace = ptr.Find( UpnpString::KSpace() );

   752             TPtrC8 ptr2;

   753             

   754             if (posOfSecondSpace != KErrNotFound)            

   755                 ptr2.Set( ptr.Left( posOfSecondSpace ) );

   756 

   757             HBufC8* url = ptr2.AllocLC();

   758 

   759             

   760         tempHeader->Des().Replace( posOfSpace+1,

   761                                           url->Des().Length(),

   762                                           *url );

   763 

   764             CleanupStack::PopAndDestroy( url );

   765             url = NULL;

   766             

   767 /*------if Content-Length is not at the beginning (can be some same string in value) so copy it, otherwise will be added and calcualted at the end----*/

   768 

   769         if(hdr->Name().FindC(UpnpHTTP::KHdrContentLength()) != 0)

   770 

   771             {

   772             if (hdr->Value().Length() > 0 && !firstLine)

   773                 {

   774                 tempHeader->Des().Append(UpnpString::KColon());

   775                 tempHeader->Des().Append(UpnpString::KSpace());

   776                 tempHeader->Des().Append(hdr->Value());

   777                 }

   778             else 

   779                 {

   780                 if (firstLine)

   781                     {

   782                     firstLine = EFalse;

   783                     }

   784                 else

   785                     {

   786                     tempHeader->Des().Append(UpnpString::KColon());

   787                     }

   788                 }

   789             //folding, we pass with lineFeed

   790             FoldHeaderL(tempHeader);                

   791             tempHeader->Des().Append(UpnpString::KLineFeed());

   792             }

   793 

   794         HBufC8* tempBuf;

   795         tempBuf = HBufC8::NewLC( headerBuf->Des().Length() +

   796                                  tempHeader->Des().Length() );

   797         tempBuf->Des().Zero();

   798         tempBuf->Des().Append( *headerBuf );

   799         

   800 

   801         if(hdr->Name().FindC(UpnpHTTP::KHdrContentLength()) != 0)

   802             {

   803             tempBuf->Des().Append(*tempHeader);

   804             }

   805         

   806         CleanupStack::Pop( tempBuf );

   807         CleanupStack::PopAndDestroy( tempHeader ); 

   808         CleanupStack::PopAndDestroy( headerBuf ); 

   809         

   810         tempHeader = NULL;

   811         headerBuf = NULL;

   812 

   813         headerBuf = tempBuf;

   814         tempBuf = NULL;

   815         

   816         hdr = iHeaderList->Next(hdr);    

   817         }

   818     

   819     AppendContentLengthToHeadersL(headerBuf);

   820     return headerBuf;

   821 }

   822 // -----------------------------------------------------------------------------

   823 // CUpnpHttpMessage::AppendContentLengthToHeadersL

   824 // Appends ContentLength when headers are dumped to string (using public method HeadersToStringL).

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

   826 //

   827 EXPORT_C void CUpnpHttpMessage::AppendContentLengthToHeadersL(HBufC8*& aHeaders){

   828 

   829 /*------open file which keep message--------*/

   830     TInt bodyLength( 0 );

   831     CleanupStack::PushL( aHeaders );    

   832 

   833 

   834     if(iOutFilename->Length() > 0)

   835         {

   836         RFs fs;

   837         CleanupClosePushL(fs);

   838         RFile file;

   839         CleanupClosePushL(file);

   840 

   841         User::LeaveIfError( fs.Connect() );

   842         

   843         HBufC16* outFilename16 = UpnpString::ToUnicodeL( *iOutFilename);

   844         CleanupStack::PushL(outFilename16);

   845         

   846         User::LeaveIfError( file.Open(fs,*outFilename16,  EFileRead|EFileShareAny ) );

   847 

   848         TInt Filesize( 0 );

   849         User::LeaveIfError( file.Size( Filesize ) );

   850         

   851         CleanupStack::PopAndDestroy( outFilename16 );

   852         

   853         CleanupStack::PopAndDestroy();  //file.Close();

   854         outFilename16 = NULL;

   855         

   856         CleanupStack::PopAndDestroy(); //fs.Close();

   857                 

   858         bodyLength = Filesize;

   859         }

   860     else

   861         {

   862         iTextBody->Des().Trim();

   863         bodyLength=iTextBody->Des().Length();

   864         }

   865 

   866     TBuf8<20> tempBuf;

   867     tempBuf.Num( bodyLength );

   868 

   869     HBufC8* tempBuf2;

   870     tempBuf2=HBufC8::NewL( aHeaders->Des().Length() +

   871                             tempBuf.Length() +

   872                             UpnpHTTP::KHdrContentLength().Length() +

   873                             2 ); // +2 from colon and space

   874     tempBuf2->Des().Append( *aHeaders);

   875     

   876     CleanupStack::Pop(aHeaders);

   877     delete aHeaders;

   878     aHeaders=NULL;

   879 

   880     tempBuf2->Des().Append(UpnpHTTP::KHdrContentLength());

   881     tempBuf2->Des().Append(UpnpString::KColon());

   882     tempBuf2->Des().Append(UpnpString::KSpace());

   883     tempBuf2->Des().Append(tempBuf);

   884 

   885     aHeaders=tempBuf2;

   886     tempBuf2=NULL;

   887 

   888     }

   889 // -----------------------------------------------------------------------------

   890 // CUpnpHttpMessage::FoldHeaderL

   891 // Folds long header fields (without last CRLF)  - "MUST limit 998".

   892 // -----------------------------------------------------------------------------

   893 //

   894 EXPORT_C void CUpnpHttpMessage::FoldHeaderL(HBufC8*& aHeader){

   895 HBufC8* result = NULL;

   896 TInt length = aHeader->Length();

   897 

   898     if(length > KLineLengthLimit)

   899         {

   900         //Body can be only folded, so 1st we check if name is not too long

   901         if (aHeader->FindC(UpnpString::KColon()) > KLineLengthLimit-1)

   902             {

   903             User::Leave(KErrOverflow);

   904             #ifdef _DEBUG

   905             LOGS("[CUpnpHttpMessage::FoldHeaderL] name of header > KLineLengthLimit");

   906             #endif //_DEBUG

   907             }

   908         else

   909             {

   910             //RFC 2822 3.2.3 (check if any FWS already exist and remove them) comment in DLNA doesnt exist so there are not processing)

   911             UnFoldHeader(aHeader);

   912             aHeader->Des().TrimAll();

   913 

   914             //now proper folding

   915             //new length is estimated,

   916             //its faster way to estiamte max number (worst possible case) than calculate strict number

   917             //how estimation is calculate: HighLevel break (but not SP) in worst case will be in every half -1 in every maxLength string

   918             

   919             

   920             result = HBufC8::NewL(length + length/KLineLengthLimit*2*3 + 2);//CRLFSP + LineFeed

   921             CleanupStack::PushL(result);

   922             TInt x1 = 0, x2 = 0;

   923             TBool last = EFalse;

   924             while(ETrue)

   925                 {

   926                 length = aHeader->Length();

   927                 x2 = x1 + KLineLengthLimit;

   928                 if (x2 >= length) 

   929                     {

   930                     x2 = length-1;

   931                     last = ETrue;

   932                     }

   933                 else

   934                     {

   935                     TBool foundBreak = EFalse;

   936                     for (TInt j=0; j<KHigherLevelSintaticBreaks().Length(); j++)

   937                         {

   938                         x2 = x1 + KLineLengthLimit;

   939                         while (x2 > 0 && !foundBreak)

   940                             {

   941                             if (aHeader->Des()[x2] == KHigherLevelSintaticBreaks()[j])

   942                                 {

   943                                 foundBreak = ETrue;

   944                                 }

   945                             else

   946                                 {

   947                                 x2--;

   948                                 }

   949                                 

   950                             }

   951                         if (foundBreak) break;

   952                         }

   953                     if (!foundBreak)

   954                         {

   955                         User::Leave(KErrOverflow);

   956                         #ifdef _DEBUG

   957                         LOGS("[CUpnpHttpMessage::FoldHeaderL] value of header > KLineLengthLimit");

   958                         #endif //_DEBUG

   959                         }

   960                     }

   961                 //we will append in different way whether SP or other breaks

   962                 if (aHeader->Des()[x2] == UpnpString::KSpace()[0] || 

   963                     aHeader->Des()[x2] == UpnpString::KTab()[0])

   964                     {

   965                     result->Des().Append(aHeader->Des().Mid(x1, x2));

   966                     if (!last)

   967                         {

   968                         result->Des().Append(UpnpString::KLineFeed());

   969                         }

   970                     }

   971                 else

   972                     {

   973                     result->Des().Append(aHeader->Des().Mid(x1, x2+1));

   974                     if (!last)

   975                         {

   976                         result->Des().Append(UpnpString::KLineFeed());

   977                         result->Des().Append(UpnpString::KSpace());//additional space, HTTP req, also break reversibility (folding and unfolding will give new string)

   978                         }

   979                     }

   980                 aHeader->Des().Delete(x1, x2-x1);// from, length

   981                 if (last)

   982                     {

   983                     break;

   984                     }

   985                 

   986                 }

   987             CleanupStack::Pop(result);

   988             CleanupStack::PopAndDestroy(aHeader);

   989             aHeader = result;

   990             CleanupStack::PushL(aHeader);

   991             }

   992         }

   993     

   994  

   995 }

   996 // -----------------------------------------------------------------------------

   997 // CUpnpHttpMessage::ToStringL

   998 // Unfolds header by simply removing any CRLF that is immediately followed by WSP.

   999 // -----------------------------------------------------------------------------

  1000 //

  1001 EXPORT_C void CUpnpHttpMessage::UnFoldHeader(HBufC8*& aHeader){

  1002     TPtr8 ptr = aHeader->Des();

  1003     TInt pos = ptr.FindC(UpnpString::KLineFeed());

  1004     while(pos != KErrNotFound)

  1005     {

  1006         ptr.Delete(pos, 2);

  1007         pos = ptr.FindC(UpnpString::KLineFeed());

  1008     }

  1009 }

  1010 

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

  1012 // CUpnpHttpMessage::ToStringL

  1013 // Returns message as HBufC8.

  1014 // -----------------------------------------------------------------------------

  1015 //

  1016 EXPORT_C HBufC8* CUpnpHttpMessage::ToStringL()

  1017     {

  1018     HBufC8* buffer;

  1019     buffer=HeadersToStringL();

  1020     CleanupStack::PushL(buffer);

  1021 

  1022     HBufC8* returnBuf;

  1023     //4 added to the length of the buffer becasue of the additional 2 line feeds

  1024     returnBuf=HBufC8::NewL(buffer->Des().Length()+iTextBody->Des().Length()+4);

  1025     

  1026     returnBuf->Des().Append(*buffer);

  1027     CleanupStack::PopAndDestroy(buffer);

  1028     buffer=NULL;

  1029     //2 line feeds appended

  1030     returnBuf->Des().Append(UpnpString::KLineFeed);

  1031     returnBuf->Des().Append(UpnpString::KLineFeed);

  1032     

  1033     returnBuf->Des().Append(*iTextBody);

  1034     

  1035     return returnBuf;

  1036     }

  1037 

  1038 // -----------------------------------------------------------------------------

  1039 // CUpnpHttpMessage::SetMessageDateL

  1040 // Sets the date of message.

  1041 // -----------------------------------------------------------------------------

  1042 //

  1043 

  1044 EXPORT_C void CUpnpHttpMessage::SetMessageDateL(const TTime& aTime)

  1045 {   

  1046     HBufC8* timebuf = NULL;

  1047     timebuf = UpnpString::GetDateLC(aTime);

  1048     

  1049     CUpnpHttpHeader* hdr = iHeaderList->First();

  1050     

  1051     TBool HeaderFound=EFalse;

  1052     

  1053     while (hdr != NULL)

  1054         {

  1055         if (hdr->Name() == UpnpHTTP::KHdrDate() )

  1056             {

  1057             HeaderFound = ETrue;

  1058             hdr->SetValueL(*timebuf);

  1059             }

  1060         hdr = iHeaderList->Next(hdr);    

  1061         }

  1062     

  1063     if(!HeaderFound)

  1064         {

  1065         AddPairL(UpnpHTTP::KHdrDate(),*timebuf);

  1066         }

  1067     CleanupStack::PopAndDestroy(timebuf);

  1068 }

  1069 

  1070 // -----------------------------------------------------------------------------

  1071 // CUpnpHttpMessage::Sender

  1072 // Returns the IP address of the sender of the message.

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

  1074 //

  1075 EXPORT_C TInetAddr& CUpnpHttpMessage::Sender()

  1076     {

  1077     return iRemoteHost;

  1078     }

  1079 

  1080 // -----------------------------------------------------------------------------

  1081 // CUpnpHttpMessage::Receiver

  1082 // Returns the IP address of the receiver of the message.

  1083 // -----------------------------------------------------------------------------

  1084 //

  1085 EXPORT_C TInetAddr& CUpnpHttpMessage::Receiver()

  1086     {

  1087     return iRemoteHost;

  1088     }

  1089 

  1090 // -----------------------------------------------------------------------------

  1091 // CUpnpHttpMessage::SetDestinationPathL

  1092 // Sets the DestinationPath of the message.

  1093 // -----------------------------------------------------------------------------

  1094 //

  1095 EXPORT_C void CUpnpHttpMessage::SetDestinationPathL(const TDesC8& aDestinationPath)

  1096     {

  1097     if(iDestinationPath)

  1098         {

  1099         delete iDestinationPath;

  1100         iDestinationPath = NULL;

  1101         }

  1102         

  1103     iDestinationPath = aDestinationPath.AllocL();

  1104     }

  1105 

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

  1107 // CUpnpHttpMessage::DestinationPath

  1108 // Returns the DestinationPath of the message.

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

  1110 //

  1111 EXPORT_C TPtrC8 CUpnpHttpMessage::DestinationPath()

  1112     {

  1113     if(iDestinationPath->Length()>0)

  1114         {

  1115         return iDestinationPath->Des();

  1116         }

  1117     else

  1118         {

  1119         return (TDesC8&) KNullDesC8();

  1120         }

  1121     }

  1122 

  1123 // -----------------------------------------------------------------------------

  1124 // CUpnpHttpMessage::SetSenderPathL

  1125 // Sets the SourcePath of the message.

  1126 // -----------------------------------------------------------------------------

  1127 //

  1128 EXPORT_C void CUpnpHttpMessage::SetSenderPathL(const TDesC8& aSenderPath)

  1129     {

  1130     if(iSenderPath)

  1131         {

  1132         delete iSenderPath;

  1133         iSenderPath = NULL;

  1134         }

  1135