wmtransportagent.cpp

This SDK allows to integrate a syncml stack in a C++ application on a variety of platforms. Current

/*
 * Copyright (C) 2003-2007 Funambol
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 How to test SSL connections 
 ----------------------------

 On the server:
 1) create the keystore:
    %JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA
 2) In $CATALINA_HOME/conf/server.xml uncomment the lines:
    <Connector className="org.apache.catalina.connector.http.HttpConnector"
               port="8443" minProcessors="5" maxProcessors="75"
               enableLookups="true"
               acceptCount="10" debug="0" scheme="https" secure="true">
      <Factory className="org.apache.catalina.net.SSLServerSocketFactory" clientAuth="false" protocol="TLS"/>
    </Connector>
 2) Export the certificate from the key store:
    %JAVA_HOME%\bin\keytool -export -alias tomcat -file myroot.cer  

 On the emulator:
 1) Copy myroot.cer in a device/emulator directory
 2) Click on it to import the certificate as a trusted CA

*/

#include "base/Log.h"
#include "base/messages.h"
#include "base/util/utils.h"
#include "http/constants.h"
#include "http/errors.h"
#include "http/WMTransportAgent.h"

#include "http/GPRSConnection.h"
#include "spdm/spdmutils.h"
#include "event/FireEvent.h"

#define ENTERING(func) LOG.debug("Entering %ls", func);
#define EXITING(func)  LOG.debug("Exiting %ls", func);


#ifdef USE_ZLIB
#include "zlib.h"
#endif

/*
 * Constructor.
 * In this implementation newProxy is ignored, since proxy configuration
 * is taken from the WinInet subsystem.
 *
 * @param url the url where messages will be sent with sendMessage()
 * @param proxy proxy information or NULL if no proxy should be used
 */
WMTransportAgent::WMTransportAgent(
                    URL& newURL, Proxy& newProxy, 
                    unsigned int maxResponseTimeout, 
                    unsigned int maxmsgsize)
            // Use base class constructor to initialize common attributes
            : TransportAgent(newURL,
                             newProxy,
                             maxResponseTimeout,
                             maxmsgsize)
{

#ifdef USE_ZLIB
    isToDeflate = FALSE;
    isToInflate = FALSE;
    isFirstMessage = TRUE;    
#endif

    // used by default. check connection before...
    if (!EstablishConnection()) {
#ifdef WIN32_PLATFORM_PSPC
        lastErrorCode = ERR_INTERNET_CONNECTION_MISSING;
        sprintf(lastErrorMsg, "%s: %d",
                 "Internet Connection Missing",
                 ERR_INTERNET_CONNECTION_MISSING);
#else
        LOG.error("Warning: internet connection missing.");
#endif
    }
}

WMTransportAgent::~WMTransportAgent(){}



/*
 * Sends the given SyncML message to the server specified
 * by the instal property 'url'. Returns the response status code or -1
 * if it was not possible initialize the connection.
 *
 */
char* WMTransportAgent::sendMessage(const char* msg) {

    ENTERING(L"TransportAgent::sendMessage");
    int status = -1;
    unsigned int contentLength = 0;
    WCHAR* wurlHost;
    WCHAR* wurlResource;
    char* response = NULL;
    HINTERNET inet       = NULL,
              connection = NULL,
              request    = NULL;


    // Check sending msg and host.
    if (!msg) {
        lastErrorCode = ERR_NETWORK_INIT;
        sprintf(lastErrorMsg, "TransportAgent::sendMessage error: NULL message.");
        goto exit;
    }
    if (!(url.host) || strlen(url.host) == 0) {
        lastErrorCode = ERR_HOST_NOT_FOUND;
        sprintf(lastErrorMsg, "TransportAgent::sendMessage error: %s.", ERRMSG_HOST_NOT_FOUND);
        goto exit;
    }


    DWORD size  = 0,
          read  = 0,
          flags = INTERNET_FLAG_RELOAD | 
                  INTERNET_FLAG_NO_CACHE_WRITE | 
                  INTERNET_FLAG_KEEP_CONNECTION |     // This is necessary if authentication is required.
                  INTERNET_FLAG_NO_COOKIES;           // This is used to avoid possible server errors on successive sessions.

	LPCWSTR acceptTypes[2] = {TEXT("*/*"), NULL};
    

    // Set flags for secure connection (https).
    if (url.isSecure()) {
        flags = flags
              | INTERNET_FLAG_SECURE
              | INTERNET_FLAG_IGNORE_CERT_CN_INVALID
              | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID
              ;
    }


    //
    // Open Internet connection.
    //
    WCHAR* ua = toWideChar(userAgent);
    inet = InternetOpen(ua, INTERNET_OPEN_TYPE_PRECONFIG, NULL, 0, 0);
    if (ua) {delete [] ua; ua = NULL; }

    if (!inet) {
        lastErrorCode = ERR_NETWORK_INIT;
        sprintf (lastErrorMsg, "%s: %d", "InternetOpen Error", GetLastError());
        LOG.error(lastErrorMsg);
        goto exit;
    }   
    LOG.debug("Connecting to %s:%d", url.host, url.port);

    //
    // Open an HTTP session for a specified site by using lpszServer.
    //
    wurlHost = toWideChar(url.host);
    if (!(connection = InternetConnect (inet,
                                        wurlHost,
                                        url.port,
                                        NULL, // username
                                        NULL, // password
                                        INTERNET_SERVICE_HTTP,
                                        0,
                                        0))) {
        lastErrorCode = ERR_CONNECT;
        sprintf (lastErrorMsg, "%s: %d", "InternetConnect Error", GetLastError());
        LOG.error(lastErrorMsg);
        goto exit;
    }

    
    LOG.debug("Requesting resource %s", url.resource);

    //
    // Open an HTTP request handle.
	//
    wurlResource = toWideChar(url.resource);
    if (!(request = HttpOpenRequest(connection,
                                    METHOD_POST,
                                    wurlResource,
                                    HTTP_VERSION,
                                    NULL,
                                    acceptTypes,
                                    flags, 0))) {
        lastErrorCode = ERR_CONNECT;
        sprintf (lastErrorMsg, "%s: %d", "HttpOpenRequest Error", GetLastError());
        LOG.error(lastErrorMsg);
        goto exit;
    }


    //
    // Prepares headers
    //
    WCHAR headers[512];
    contentLength = strlen(msg);

    // Msg to send is the original msg by default.
    // If compression is enabled, it will be switched to
    // compr. We don't want to touch this pointer, so
    // it's const (msg is also const).
    const void* msgToSend = (const void*)msg;

#ifdef USE_ZLIB
    // This is the locally allocated buffer for the compressed message.
    // Must be deleted after send.
    Bytef* compr = NULL;

    //
    // Say the client can accept the zipped content but the first message is clear
    //
    if (isFirstMessage || !isToDeflate) { 
        wsprintf(headers, TEXT("Content-Type: %s\r\nContent-Length: %d\r\nAccept-Encoding: deflate"),
                          SYNCML_CONTENT_TYPE, contentLength);    
        isFirstMessage = false;
    }
    else if (isToDeflate) {
        //
        // DEFLATE (compress data)
        //
        uLong comprLen = contentLength;
        Bytef* compr = new Bytef[contentLength];
        
        // Compresses the source buffer into the destination buffer.
        int err = compress(compr, &comprLen, (Bytef*)msg, contentLength);
            if (err != Z_OK) {
                lastErrorCode = ERR_HTTP_DEFLATE;
                sprintf(lastErrorMsg, "ZLIB: error occurred compressing data.");
                delete [] compr;  
                compr = NULL;
                goto exit;
            }            

        // Msg to send is the compressed data.
        msgToSend = (const void*)compr;
        int uncomprLenght = contentLength;
        contentLength = comprLen;

        wsprintf(headers, TEXT("Content-Type: %s\r\nContent-Length: %d\r\nAccept-Encoding: deflate\r\nUncompressed-Content-Length: %d\r\nContent-Encoding: deflate"),
                          SYNCML_CONTENT_TYPE, contentLength, uncomprLenght);                                    
    }
#else
    wsprintf(headers, TEXT("Content-Type: %s\r\nContent-Length: %d"), SYNCML_CONTENT_TYPE, contentLength);
#endif

    // Set response timeout
    DWORD respTOut = getTimeout()*1000;
    InternetSetOption(request, INTERNET_OPTION_RECEIVE_TIMEOUT, &respTOut, sizeof(DWORD));

    //
    // Try MAX_RETRIES times to send http request, in case of network errors
    //
    for (int numretries = 0; numretries < MAX_RETRIES; numretries++) {

        // Fire Send Data Begin Transport Event
        fireTransportEvent(contentLength, SEND_DATA_BEGIN);

        // Send a request to the HTTP server.
        if (!HttpSendRequest(request, headers, wcslen(headers),
                             (LPVOID)msgToSend, contentLength)) {
            DWORD code = GetLastError();

            if (code == 12002) {
                lastErrorCode = ERR_HTTP_TIME_OUT;
                sprintf(lastErrorMsg, "Network error: the request has timed out. %d", code);
                LOG.debug(lastErrorMsg);
                goto exit;
            }
            else if (code == 12019) {
                lastErrorCode = ERR_HTTP_TIME_OUT;
                sprintf(lastErrorMsg, "Network error: the handle supplied is not in the correct state. %d", code);
                LOG.debug(lastErrorMsg);
                goto exit;
            }
            else if (code == ERROR_INTERNET_CANNOT_CONNECT) { // 12029
                lastErrorCode = ERROR_INTERNET_CANNOT_CONNECT;
                sprintf(lastErrorMsg, "Network error: the attempt to connect to the server failed. %d", code);
                LOG.debug(lastErrorMsg);