httptrans.c

SyncML ToolKits,学习syncml的参考工具包.非常好用.

          info->pServiceInfo->info.clientInfo.pchServerAddress,
          &info->socket,
          // %%% luz:2003-04-16 added SSL support with special "cS" open mode.
          info->pServiceInfo->info.clientInfo.useSSL ? "cS" : "c",
          &info->pServiceInfo->info.clientInfo.firewallInfo
        );
        if ( rc != TCP_RC_OK ) {
            setError( rc, "TCP error Unable to establish connection with server" );
        }
    } else {
        rc = tcpWaitforConnections ( &info->pServiceInfo->info.serverInfo.serverSocket, &info->socket , info->pServiceInfo->info.serverInfo.pchSenderAddress );
        if ( rc != TCP_RC_OK ) {
            setError( rc, "TCP error Error accepting connection from client" );
        }
    }
    if ( rc != TCP_RC_OK ) {
        rc = SML_ERR_A_XPT_COMMUNICATION;
        xppFree( info );
        info = NULL;
    }

    *pPrivateConnectionInfo = info;
    return rc;
}

Ret_t XPTAPI  HTTP_closeCommunication(void *privateConnectionInfo) {

    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    if ( connInfo == NULL ) {
        setError( 1, "privateConnectionInfo was NULL" );
        return SML_ERR_A_XPT_INVALID_PARM;
    }
#ifdef OLD
    if ( !connInfo->pServiceInfo->socketClient && connInfo->state == HTTP_TRANSPORT_RECEIVING ) {
        // if server mode and didn't send response......
        HttpReplyBuffer_t replyDoc;
        xppMemset( &replyDoc, '\0', sizeof( replyDoc ) );
        replyDoc.cbSize = sizeof( replyDoc );
        replyDoc.cbLength = 0;
        replyDoc.pszType  = "text/text";
        httpReply( connInfo->http, 500, &replyDoc, NULL );
    }
#endif
    tcpCloseConnection( &connInfo->socket );
    xppFree( privateConnectionInfo );
    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_beginExchange(void *privateConnectionInfo) {
    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    if ( connInfo == NULL ) {
        setError( 1, "privateConnectionInfo was NULL" );
        return SML_ERR_A_XPT_INVALID_PARM;
    }

    connInfo->http = xppMalloc( httpGetBufferSize() );
    xppMemset( connInfo->http, '\0', httpGetBufferSize() );

    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_endExchange(void *privateConnectionInfo) {
    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    if (connInfo->http) {
        httpClose( connInfo->http );
        xppFree( connInfo->http );
        connInfo->http = NULL;
    }
    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_receiveData(void *privateConnectionInfo,
                               void *buffer,
                               size_t bufferLen,
                               size_t *dataLen) {

    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    HttpRc_t rc;
    if ( privateConnectionInfo == NULL || buffer == NULL || dataLen == NULL ) {
        setError( 1, "One of privateConnectionInfo, dataBuffer or datLen pointer was NULL" );
        return SML_ERR_A_XPT_INVALID_PARM;
    }
    *dataLen = 0;
    if ( !httpIsEox( connInfo->http ) ) {
        rc = httpRead( connInfo->http, buffer, bufferLen, (BufferSize_t *)dataLen );
        if ( HTTP_RC_OK != rc ) {
            setError( rc, "HTTP error reading data." );
            return SML_ERR_A_XPT_COMMUNICATION;
        }
    }

    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_sendData(void *privateConnectionInfo,
                            const void *buffer,
                            size_t bufferLen,
                            size_t *bytesSent ){

    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    HttpRc_t rc;
    *bytesSent = 0;
    if ( privateConnectionInfo == NULL || buffer == NULL) {
        setError( 1, "One of privateConnectionInfo or dataBuffer was NULL" );
        return SML_ERR_A_XPT_INVALID_PARM;
    }
    rc = httpWrite( connInfo->http, (void *)buffer, bufferLen, false );
    if ( HTTP_RC_OK != rc ) {
        setError( rc, "HTTP error sending data." );
        return SML_ERR_A_XPT_COMMUNICATION;
    }

    *bytesSent = bufferLen;
    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_sendComplete(void *privateConnectionInfo) {
#ifdef BASE64_ENCODING
    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    HttpRc_t rc = httpWrite( connInfo->http, (void *)NULL, 0, true );
    if ( HTTP_RC_OK != rc ) {
        setError( rc, "HTTP error sending data." );
        return SML_ERR_A_XPT_COMMUNICATION;
    }
#endif
    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_setDocumentInfo(void *privateConnectionInfo,
                                   const XptCommunicationInfo_t *pDoc) {
    HttpRc_t hrc;
    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;


    if ( connInfo == NULL || pDoc == NULL ) {
        setError( 1, "One of privateConnectionInfo or XptCommunicationInfo pointer was NULL" );
        return SML_ERR_A_XPT_INVALID_PARM;
    }


    if (connInfo->smlClient) {

        HttpDocumentContext_t doc;


        xppMemset( &doc, '\0', sizeof( doc ) );
        doc.cbSize   = sizeof( doc );
        doc.cbLength = pDoc->cbLength != -1 ? pDoc->cbLength : 0;
        doc.pszType  = pDoc->mimeType;
        doc.pszURL   = pDoc->docName;
        doc.pszProxy = connInfo->pServiceInfo->info.clientInfo.proxyString;
        doc.pszHost  = connInfo->pServiceInfo->info.clientInfo.pchServerAddress;
		doc.pXSyncmlHmac = pDoc->hmacInfo;
        // %%% luz:2002-05-23: Auth support added
        doc.auth = pDoc->auth;  // auth structure created by authInit()

        hrc = httpOpen( connInfo->http, &connInfo->socket, "EXCHANGE", &doc, doc.auth /* %%% luz:2002-05-23, was NULL before (no auth support for client) */ );

        if ( HTTP_RC_OK != hrc ) {
            setError( hrc, "HTTP error starting exchange with server" );
            return SML_ERR_A_XPT_COMMUNICATION;
        }
    } else {

        HttpReplyBuffer_t replyDoc;

        xppMemset( &replyDoc, '\0', sizeof( replyDoc ) );
        replyDoc.cbSize = sizeof( replyDoc );
        replyDoc.cbLength = pDoc->cbLength != -1 ? pDoc->cbLength : 0;
        replyDoc.pszType  = pDoc->mimeType;
		replyDoc.pXSyncmlHmac = pDoc->hmacInfo;

        hrc = httpReply( connInfo->http, 200, &replyDoc, NULL );

        if ( HTTP_RC_OK != hrc ) {
            setError( hrc, "HTTP error seding reply to client" );
            return SML_ERR_A_XPT_COMMUNICATION;
        }
    }

    return SML_ERR_OK;
}

Ret_t XPTAPI  HTTP_getDocumentInfo(void *privateConnectionInfo,
                                      XptCommunicationInfo_t *pDoc){

    HttpRc_t hrc;
    HttpDocumentContext_t doc;
    int len;

    HttpTransportConnInfoPtr_t connInfo = ( HttpTransportConnInfoPtr_t )privateConnectionInfo;
    if ( connInfo == NULL || pDoc == NULL ) {
        setError( 1, "One of privateConnectionInfo or XptCommunicationInfo pointer was NULL" );
        return SML_ERR_A_XPT_INVALID_PARM;
    }

    xppMemset( &doc, '\0', sizeof( doc ) );
    doc.cbSize   = sizeof( doc );

    // %%% luz:2002-05-23: Auth support added
    doc.auth = pDoc->auth;  // auth structure created by authInit()

    if (connInfo->smlClient) {
        hrc = httpWait( connInfo->http, &doc, doc.auth /* %%% luz:2002-05-23, was NULL before (no auth support for client) */  );
        // %%% luz:2002-05-28: added handling for HTTP 401/407 error case
        if ( hrc == HTTP_RC_RETRY) {
            setError( hrc, "HTTP server access denied, must retry sending with proper credentials" );
            // do not modify document info, just return
            return SML_ERR_A_XPT_ACCESS_DENIED;
        }
        if ( HTTP_RC_OK != hrc ) {
            setError( hrc, "HTTP error waiting for a response from the server" );
            return SML_ERR_A_XPT_COMMUNICATION;
        }

    } else {

        hrc = httpOpen( connInfo->http, &connInfo->socket, "SERVER", &doc, NULL );
        if ( HTTP_RC_OK != hrc ) {
            setError( hrc, "HTTP error establishing a HTTP session with the client" );
            return SML_ERR_A_XPT_COMMUNICATION;
        }
    }
	  pDoc->hmacInfo = doc.pXSyncmlHmac;
	  // %%% luz:2002-05-23: Auth support added
    pDoc->auth = doc.auth; // return auth structure, NULL if none

    pDoc->cbLength = ((doc.cbLength >= 0) && (doc.cbLength != UNDEFINED_CONTENT_LENGTH))  ? doc.cbLength : -1;
    len = xppStrlen( doc.pszURL );
    if ( len > XPT_DOC_NAME_SIZE ) {
      char *msg = xppMalloc( len + 64 );
      sprintf( msg, "Returned document length is too large for supplied buffer: %s", doc.pszURL );
      setError( 5, msg );
      xppFree( msg );
      return SML_ERR_A_XPT_COMMUNICATION;
    }
    xppMemcpy( pDoc->docName, doc.pszURL, len+1 );

    // %%% discovered by luz 2002-04-xx: for some uninvestigated reason,
    // doc.pszType can be NULL here sometimes.
    // RTK Maint.Rel.4 adds own handling here, but
    // will xppMemCpy work ok with UNDEFINED_CONTENT_LENGTH???

    // %%% modified code by luz 2002-05-23
    if (doc.pszType) {
      len = xppStrlen( doc.pszType );
      if ( len > XPT_DOC_TYPE_SIZE ) {
  		  char *base_msg = "Returned document mime type is too large for supplied buffer";
        char *msg = xppMalloc( len + 64 );
  		  if (msg) {
           sprintf( msg, "%s: %s", base_msg, doc.pszType );
           setError( 5, msg );
           xppFree( msg );
  		  } else {
  			   setError( 5, base_msg);
  		  }
        return SML_ERR_A_XPT_COMMUNICATION;
      }
      xppMemcpy( pDoc->mimeType, doc.pszType, len+1 );
    } else {
      // no MIME-type
      pDoc->mimeType[0]=0;
    }

    /* original code:
    if (doc.pszType) {
      len = xppStrlen( doc.pszType );
    } else {
      len = UNDEFINED_CONTENT_LENGTH;
    }
    if ( len > XPT_DOC_TYPE_SIZE ) {
		  char *base_msg = "Returned document mime type is too large for supplied buffer";
      char *msg = xppMalloc( len + 64 );
		  if (msg) {
         sprintf( msg, "%s: %s", base_msg, doc.pszType );
         setError( 5, msg );
         xppFree( msg );
		  } else {
			   setError( 5, base_msg);
		  }
      return SML_ERR_A_XPT_COMMUNICATION;
    }
    xppMemcpy( pDoc->mimeType, doc.pszType, len+1 );
    */
    
    return SML_ERR_OK;
}