/** @file
* Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies  this distribution, and is available 
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Produces SOAP messages
*
*/



// INCLUDE FILES
#include "upnpsoapmessagefactory.h"
#include "upnphttpmessagefactory.h"
#include "upnpsoapmessage.h"
#include "upnpaction.h"
#include "upnpargument.h"
#include "upnperrors.h"
#include "upnpserviceimplementation.h"
#include "upnpdevice.h"
#include "upnpstring.h"
#include "upnpcommonupnplits.h"
#define KLogFile _L("UPnPStack.txt")
#include "upnpcustomlog.h"
#include "upnplist.h"
#include "upnpcons.h"

// CONSTANTS
_LIT8(KSoapEnvelopeStart, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n<s:Body>\n<u:");
_LIT8(KSoapServiceNsStart, " xmlns:u=\"urn:schemas-upnp-org:service:");
_LIT8(KSoapServiceNsEnd, "\">\n");
_LIT8(KActionNameEnd, "</u:");
_LIT8(KSoapEnvelopeEnd, ">\n</s:Body>\n</s:Envelope>");
_LIT8(KSoapActionStart, "\"urn:schemas-upnp-org:service:");
_LIT8(KCrash, "#");
_LIT8(KOpenBracket, "<");
_LIT8(KCloseBracket, ">");
_LIT8(KLinefeed, "\n");
_LIT8(KResponse, "Response");

_LIT(KSoapErrorStart, 
     "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n<s:Body>\n<s:Fault>\n<faultcode>s:Client</faultcode>\n<faultstring>UPnPError</faultstring>\n<detail>\n<UPnPError xmlns=\"urn:schemas-upnp-org:control-1-0\">\n<errorCode>");

_LIT(KSoapErrorBetween,
     "</errorCode>\n<errorDescription>");
_LIT(KSoapErrorEnd,
     "</errorDescription>\n</UPnPError>\n</detail>\n</s:Fault>\n</s:Body>\n</s:Envelope>");

static const TInt KTagCharsLength = 7;
static const TInt KExtraCharsLength = 2;
static const TInt KMaxErrorCodeLength = 20;


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

// -----------------------------------------------------------------------------
// RUpnpSoapMessageFactory::SoapRequest
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpSoapMessage* RUpnpSoapMessageFactory::SoapRequestL(CUpnpAction* aAction)
    {
    LOGS("RUpnpSoapMessageFactory::SoapRequest(CUpnpAction*)");
    
    if (aAction == NULL)
    {
        return NULL;
    }
    const TDesC8& actName = aAction->Name();
    HBufC8* servTypeB = NULL;
    TInt posS(KErrNotFound);
    TInt posD(KErrNotFound);
    
    const TDesC8& servType = aAction->ServiceType();
    TInt serviceVersion(KErrNotFound);
    if(servType.Length())
        {
        posS = servType.LocateReverse(':');
        if (posS != KErrNotFound)
            {
            TLex8 number(servType.Right(servType.Length() - posS - 1));
            if(number.Val(serviceVersion) != KErrNone)
                {
                serviceVersion = KErrNotFound;
                }
            }
        }
    
    const TDesC8& devType = aAction->Service().Device().DeviceType();
    TInt deviceVersion(KErrNotFound);
    
    if(devType.Length())
        {
        posD = devType.LocateReverse(':');
        if (posD != KErrNotFound)
            {
            TLex8 number(devType.Right(devType.Length() - posD - 1));
            if(number.Val(deviceVersion) != KErrNone)
                {
                deviceVersion = KErrNotFound;
                }
            }
        }    
    
    if(deviceVersion != KErrNotFound && serviceVersion != KErrNotFound)
        {
        if(deviceVersion < serviceVersion)
            {
            servTypeB = HBufC8::NewLC(servType.Length() + devType.Length() - posD);
            TPtr8 buf = servTypeB->Des();
            buf.Append(servType.Left(posS + 1));
            buf.Append(devType.Right(devType.Length() - posD - 1));
            }
        else
            {
            servTypeB = servType.AllocLC();
            }           
        }
    else
        {
        servTypeB = servType.AllocLC();
        }
    
    RPointerArray<CUpnpArgument>& args = aAction->ArgumentList();
    
    TInt argLength = 0;
    
    TInt i=0;
    for(i=0; i<args.Count(); i++)
    {
        argLength += KTagCharsLength; 
        argLength += args[i]->Name().Length() * 2;
        argLength += args[i]->Value().Length();
    }
    
    argLength += KSoapEnvelopeStart().Length();
    argLength += KSoapServiceNsStart().Length();
    argLength += KSoapServiceNsEnd().Length();
    argLength += KActionNameEnd().Length();
    argLength += KSoapEnvelopeEnd().Length();
    
    argLength += actName.Length()*2;
    argLength += servTypeB->Length();
    
    HBufC8* buffer = HBufC8::NewLC(argLength);
    TPtr8 ptr = buffer->Des();
    
    ptr.Append(KSoapEnvelopeStart());
    ptr.Append(actName);
    ptr.Append(KSoapServiceNsStart());
    ptr.Append(*servTypeB);
    ptr.Append(KSoapServiceNsEnd());
    
    for (i=0; i<args.Count(); i++)
    {
        if (args[i]->Direction() == EIn)
        {
            const TDesC8& name = args[i]->Name();
            const TDesC8& value = args[i]->Value();
            
            ptr.Append(KOpenBracket());
            ptr.Append(name);
            ptr.Append(KCloseBracket());
            ptr.Append(value);
            ptr.Append(KOpenBracket());
            ptr.Append(UpnpString::KSlash());
            ptr.Append(name);
            ptr.Append(KCloseBracket());
            ptr.Append(KLinefeed());
            
        }
    }
    ptr.Append(KActionNameEnd());
    ptr.Append(actName);
    ptr.Append(KSoapEnvelopeEnd());
    
    
    CUpnpSoapMessage* self = NULL;
    
    TInetAddr dest = aAction->DestinationAddr();
    dest.SetFamily(KAfInet);
    
    TPtrC8 destPath = aAction->DestinationPath();
    if (destPath.Length() > KHttp().Length() && 
        destPath.Left( KHttp().Length() ) == KHttp())
    {
        self = static_cast<CUpnpSoapMessage*>(RUpnpHttpMessageFactory::HttpPostL(
            destPath));
    }
    else if (destPath.Find(UpnpString::KSlash()) != 0)
    {
        HBufC8* longPath = HBufC8::NewLC(destPath.Length() +1);
        longPath->Des().Append(UpnpString::KSlash());
        longPath->Des().Append(destPath);
        self = static_cast<CUpnpSoapMessage*>(RUpnpHttpMessageFactory::HttpPostL(
                                                        dest, *longPath));
        
        CleanupStack::PopAndDestroy( longPath );
    }
    else
    {
        self = static_cast<CUpnpSoapMessage*>(RUpnpHttpMessageFactory::HttpPostL(
                                                        dest, destPath));
    }
    
    CleanupStack::PushL(self);
    CUpnpHttpHeaderList* hdrList=self->HeaderList();
    
    CUpnpHttpHeader* hdr = hdrList->First();
    
    
    while ( hdr )
    {
     TBool flag = EFalse;
        if(hdr->Name().Length() == UpnpSSDP::KHdrHost().Length())
        {
            if (hdr->Name().FindC(UpnpSSDP::KHdrHost()) == 0)
            {
				CUpnpHttpHeader* temp = hdr;
				hdr = hdrList->Next(hdr);
				flag = ETrue;
				hdrList->Remove(temp);
                delete temp;
				
            }
        }
		if(!flag)
			hdr = hdrList->Next(hdr);
    }
    
    HBufC8* host = UpnpString::InetToStringL( self->Sender() );
    CleanupStack::PushL( host );
    self->AddPairL( UpnpSSDP::KHdrHost(), *host );
    CleanupStack::PopAndDestroy( host );
    
    self->SetSessionId(aAction->SessionId());
    self->SetBodyL(*buffer);
    self->AddPairL(UpnpHTTP::KHdrContentType(), UpnpGENA::KTextXmlUtf8());
    
    
    HBufC8* soapAction = HBufC8::NewLC(
                   KSoapActionStart().Length() + 
                   aAction->Name().Length() + 
                   servTypeB->Length() + 
                   KExtraCharsLength);
    
    TPtr8 soapPtr = soapAction->Des();
    
    // soapPtr = "urn:schemas-upnp-org:service:
    soapPtr.Append(KSoapActionStart());
    // soapPtr = "urn:schemas-upnp-org:service:serviceType:v
    soapPtr.Append(*servTypeB);
    // soapPtr = "urn:schemas-upnp-org:service:serviceType:v#
    soapPtr.Append(KCrash());
    // soapPtr = "urn:schemas-upnp-org:service:serviceType:v#actionName
    soapPtr.Append(aAction->Name());
    // soapPtr = "urn:schemas-upnp-org:service:serviceType:v#actionName"
    soapPtr.Append(UpnpString::KInvComma());
    
    self->AddPairL(KSoapAction(), soapPtr);
    
    self->SetLocal(aAction->Local());
    CleanupStack::PopAndDestroy(soapAction);
    CleanupStack::Pop(self);
    CleanupStack::PopAndDestroy(buffer);
    
    CleanupStack::PopAndDestroy(servTypeB);
    
    return self;
}

// -----------------------------------------------------------------------------
// RUpnpSoapMessageFactory::SoapResponseL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpSoapMessage* RUpnpSoapMessageFactory::SoapResponseL(CUpnpAction* aAction)
{
    LOGS("RUpnpSoapMessageFactory::SoapResponseL(CUpnpAction*)");
    if (aAction == NULL)
    {
        return NULL;
    }
    const TDesC8& actName = aAction->Name();
    const TDesC8& servType = aAction->ServiceType();
    
    RPointerArray<CUpnpArgument>& args = aAction->ArgumentList();
    
    TInt argLength = 0;
    
    TInt i=0;
    for(i=0; i<args.Count(); i++)
    {
        argLength += KTagCharsLength;
        
        argLength += args[i]->Name().Length() * 2;
        argLength += args[i]->Value().Length();
    }
    
    argLength += (2 * KResponse().Length()); 
    
    argLength += KSoapEnvelopeStart().Length();
    argLength += KSoapServiceNsStart().Length();
    argLength += KSoapServiceNsEnd().Length();
    argLength += KActionNameEnd().Length();
    argLength += KSoapEnvelopeEnd().Length();
    
    argLength += actName.Length() * 2;
    argLength += servType.Length();
    
    HBufC8* buffer = HBufC8::NewLC(argLength);
    TPtr8 ptr = buffer->Des();
    
    ptr.Append(KSoapEnvelopeStart());
    ptr.Append(actName);
    ptr.Append(KResponse());
    ptr.Append(KSoapServiceNsStart());
    ptr.Append(servType);
    ptr.Append(KSoapServiceNsEnd());
    
    for (i=0; i<args.Count(); i++)
    {
        if (args[i]->Direction() == EOut)
        {
            TDesC8& name = args[i]->Name();
            TDesC8& value = args[i]->Value();
            
            ptr.Append(KOpenBracket());
            ptr.Append(name);
            ptr.Append(KCloseBracket());
            ptr.Append(value);
            ptr.Append(KOpenBracket());
            ptr.Append(UpnpString::KSlash());
            ptr.Append(name);
            ptr.Append(KCloseBracket());
            ptr.Append(KLinefeed());
            
        }
    }
    ptr.Append(KActionNameEnd());
    ptr.Append(actName);
    ptr.Append(KResponse());
    ptr.Append(KSoapEnvelopeEnd());
    
    CUpnpSoapMessage* self = static_cast<CUpnpSoapMessage*>(
                    RUpnpHttpMessageFactory::HttpResponseOkL(aAction->Sender()));
    CleanupStack::PushL(self);
    
    self->SetSessionId(aAction->SessionId());
    
    self->SetBodyL(*buffer);
    
    self->AddPairL(UpnpHTTP::KHdrContentType(), UpnpGENA::KTextXmlUtf8());

    self->AddPairL(UpnpHTTP::KHdrExtWithoutColon(), KNullDesC8);
    
    self->SetLocal(aAction->Local());
      
    CleanupStack::Pop(self);
    CleanupStack::PopAndDestroy(buffer);
    
    return self;
}

// -----------------------------------------------------------------------------
// RUpnpSoapMessageFactory::SoapResponseL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpSoapMessage* RUpnpSoapMessageFactory::SoapResponseL( CUpnpAction* aAction, TUpnpErrorCode aCode)
{
    LOGS("RUpnpSoapMessageFactory::SoapResponseL(CUpnpAction*, TUpnpErrorCode)");
    
    HBufC8* errorString = CUpnpSoapMessage::UpnpErrorL(aCode);
    CleanupStack::PushL(errorString);
    CUpnpSoapMessage* self = RUpnpSoapMessageFactory::SoapResponseL(aAction, aCode, *errorString);       
    CleanupStack::PopAndDestroy(errorString);    
    return self;   
}

EXPORT_C CUpnpSoapMessage* RUpnpSoapMessageFactory::SoapResponseL( CUpnpAction* aAction, 
                                                                   TUpnpErrorCode aCode, 
                                                                   const TDesC8& aDescription)
{
    LOGS("RUpnpSoapMessageFactory::SoapResponseL(CUpnpAction*, TUpnpErrorCode,TDesC8&)");
    
    if (aAction == NULL)
    {
        return NULL;
    }
    TBuf8<KMaxErrorCodeLength> errorCode;
    TInt code = aCode;
    errorCode.Num(code);
    
    TInt length = 0;
    length += KSoapErrorStart().Length();
    length += KSoapErrorBetween().Length();
    length += KSoapErrorEnd().Length();
    length += errorCode.Length();
    
    length += aDescription.Length();
    
    HBufC8* buffer = HBufC8::NewL(length);
    TPtr8 ptr = buffer->Des();
    
    ptr.Append(KSoapErrorStart());
    ptr.Append(errorCode);
    ptr.Append(KSoapErrorBetween());
    ptr.Append(aDescription);
    ptr.Append(KSoapErrorEnd());
    
    CleanupStack::PushL(buffer);
    
    CUpnpSoapMessage* self = static_cast<CUpnpSoapMessage*>(
        RUpnpHttpMessageFactory::HttpResponseErrorL(aAction->Sender(), 500));
    
    CleanupStack::PushL(self);
    self->SetSessionId(aAction->SessionId());
    
    self->SetBodyL(*buffer);
    self->AddPairL(UpnpHTTP::KHdrContentType(), UpnpGENA::KTextXmlUtf8());
    self->AddPairL(UpnpHTTP::KHdrExtWithoutColon(), KNullDesC8);
    
    self->SetLocal(aAction->Local());

        CleanupStack::Pop(self);
    CleanupStack::PopAndDestroy(buffer);
    
    return self;
}
                                                           
// -----------------------------------------------------------------------------
// RUpnpSoapMessageFactory::SoapResponseL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpSoapMessage* RUpnpSoapMessageFactory::SoapResponseL( 
                                            CUpnpSoapMessage* aMessage,
                                            TUpnpErrorCode aCode )
{
    if (aMessage == NULL)
    {
        return NULL;
    }
    TBuf8<KMaxErrorCodeLength> errorCode;
    TInt code = aCode;
    errorCode.Num(code);
    
    TInt length = 0;
    length += KSoapErrorStart().Length();
    length += KSoapErrorBetween().Length();
    length += KSoapErrorEnd().Length();
    length += errorCode.Length();
    
    HBufC8* errorString = CUpnpSoapMessage::UpnpErrorL(aCode);
    CleanupStack::PushL(errorString);
    
    length += errorString->Length();
    
    HBufC8* buffer = HBufC8::NewLC(length);
    TPtr8 ptr = buffer->Des();
    
    ptr.Append(KSoapErrorStart());
    ptr.Append(errorCode);
    ptr.Append(KSoapErrorBetween());
    ptr.Append(*errorString);
    ptr.Append(KSoapErrorEnd());
    
    CUpnpSoapMessage* self = static_cast<CUpnpSoapMessage*>(
            RUpnpHttpMessageFactory::HttpResponseErrorL(aMessage->Sender(), 500));
    
    self->SetSessionId(aMessage->SessionId());
    
    self->SetBodyL(*buffer);
    self->AddPairL(UpnpHTTP::KHdrContentType(), UpnpGENA::KTextXmlUtf8());
    self->AddPairL(UpnpHTTP::KHdrExtWithoutColon(), KNullDesC8);

    self->SetLocal(aMessage->Local());
  
    CleanupStack::PopAndDestroy(2);
    
    return self;
}

//  End of File