axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject cvs commit: ws-axis/c/src/transport/libwww LibWWWTransport.cpp LibWWWTransport.h Makefile.am
Date Thu, 15 Jul 2004 03:13:35 GMT
samisa      2004/07/14 20:13:35

  Added:       c/src/transport/libwww LibWWWTransport.cpp LibWWWTransport.h
                        Makefile.am
  Log:
  Implemented client side trasport module.
  Need the LibWWW to be compiled with HT_EXT defined, to eliminate 100-continue.
  This is because at the moment C++ server cannot deal with continue.
  Axis Java is capable of dealing with continue. Hence continue support will be
  added soon.
  This implementation is yet to be tested with Windows platform
  
  Revision  Changes    Path
  1.1                  ws-axis/c/src/transport/libwww/LibWWWTransport.cpp
  
  Index: LibWWWTransport.cpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   * @author Samisa Abeysinghe (sabeysinghe@virtusa.com)
   *
   */
  
  
  #include "LibWWWTransport.h"
  #include "WWWLib.h"
  #include "WWWInit.h"
  
  /*PRIVATE int printer (const char * fmt, va_list pArgs)
  {
      return (vfprintf(stdout, fmt, pArgs));
  }*/
  
  /*PRIVATE int tracer (const char * fmt, va_list pArgs)
  {
      return (vfprintf(stderr, fmt, pArgs));
  }*/
  
  int terminate_handler (HTRequest * request, HTResponse * response,
                                 void * param, int status)
  {
      /*if (status == HT_LOADED && m_pResult ) {
          HTPrint("%s\n", HTChunk_m_pcData(m_pResult));
          HTChunk_delete(m_pResult);
      }*/
  
      HTEventList_stopLoop();
      return status;
  }
  
  
  LibWWWTransport::LibWWWTransport()
  :m_pRequest(NULL), m_pResult(NULL), m_pcData(NULL), m_pcProxy(NULL), m_iBytesLeft(0), m_pcReceived(NULL)
  
  {
      //Create a new premptive client 
      HTProfile_newNoCacheClient("AxisCpp", "1.3");
      //Disable interactive mode, could be useful when debugging
      HTAlert_setInteractive(NO);
      // Add our own filter to do the clean up after response received
      HTNet_addAfter(terminate_handler, NULL, NULL, HT_ALL, HT_FILTER_LAST);
      //How long we are going to wait for a response
      HTHost_setEventTimeout(20000);
  
      m_pRequest = HTRequest_new();
  
  }
  
  LibWWWTransport::~LibWWWTransport()
  {
      if (m_pResult)
          HTChunk_delete(m_pResult);
      if(m_pRequest)
          HTRequest_delete(m_pRequest);
      if (m_pcData)
          free(m_pcData);
      if (m_pcProxy)
          free(m_pcProxy);
      //if (m_pcReceived) //This is not required as the m_pRequest Chunk deletion takes care
of this
      //    free(m_pcReceived);
  
      //Terminate libwww 
      HTProfile_delete();
  
      //Samisa:This deletion should also go to the base class 
      //destructos as is the setEndpointUri method should
      if (m_pcEndpointUri)
          free(m_pcEndpointUri);
  }
  
  AXIS_TRANSPORT_STATUS LibWWWTransport::sendBytes(const char* pcSendBuffer, 
  		const void* pBufferid)
  {
      //Samisa: Why do I have to go through the buffers of Serializer?
      //If I am the transport, I would like the serializer 
      //to give me the m_pcData to be sent. 
      //This method causes, high degree of coupling between the transport 
      //and the Serializer. See the SOAPTrasport ducumetation for details.
      //SOAP transport expects the implementation to send the m_pcData over the wire
      //in flushOutput() and not in this method. I think there need to be some 
      //renaming here.
  
      //In LibWWW context, the library is going to handle the document content
      //that is to be posted. Hence I am not going to bother about buffering
      //here.
  
      //As per the SOAPTrasport documentation, I assume that if I get 
      //null pcSendBuffer, that indicated the end of the document to be sent.
      if (pcSendBuffer)
      {
          char* temp = m_pcData;
          if (m_pcData)
              m_pcData = (char*)malloc(sizeof(char) * (strlen(m_pcData) + strlen(pcSendBuffer)
+ 1));
          else
              m_pcData = (char*)malloc(sizeof(char) * (strlen(pcSendBuffer) + 1));
  
          m_pcData[0] = '\0';
          if(temp)
          {
              strcat(m_pcData, temp);
              free(temp);
          }
          strcat(m_pcData, pcSendBuffer);
          m_pReleaseBufferCallback(pcSendBuffer, pBufferid);
      }
       
      return TRANSPORT_IN_PROGRESS;
  
  }
       
  AXIS_TRANSPORT_STATUS LibWWWTransport::getBytes(char* pcBuffer, int* piRetSize)
  {
      if (m_iBytesLeft > 0)
      {
          int iToCopy = (*piRetSize < m_iBytesLeft) ? *piRetSize : m_iBytesLeft;
          strncpy(pcBuffer, m_pcReceived + (strlen(m_pcReceived) - m_iBytesLeft), iToCopy);
                  m_iBytesLeft -= iToCopy;
          *piRetSize = iToCopy;
          return TRANSPORT_IN_PROGRESS;
      }
      else
      {
          return TRANSPORT_FINISHED;
      }
  
  }
       
  int LibWWWTransport::openConnection()
  {
      //Samisa: I wonder is this should be an API call.
      //It should not be the job of the upper layers to tell the trasport 
      //to open and close connections. Rather the transport should determine 
      //when to do that, when sendBytes is called
      //Infact, in LibWWW, opening and closing the connection is trasparernt.
      //Rather the user has to focus on the content to be sent, formats, semantics etc.
      //So I think there is nothing to be done here, in case of LibWWW. 
      //I think it is better to rename this method to intialize in SOAP transport.
      return AXIS_SUCCESS;
  }
       
  void LibWWWTransport::closeConnection()
  {
      //Samisa: comment on openConnection apply here too.
  }
       
  void LibWWWTransport::registerReleaseBufferCallback(
                      AXIS_ENGINE_CALLBACK_RELEASE_SEND_BUFFER pFunct)
  {
      m_pReleaseBufferCallback = pFunct;
  }
  
  void LibWWWTransport::setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE eType,
                      const char* pcValue)
  {
      char* key = NULL;
      switch(eType)
      {
      case SOAPACTION_HEADER:
          key = "SOAPAction";
          break;
      case SERVICE_URI: /* need to set ? NO*/
          break;
      case OPERATION_NAME: /* need to set ? NO */
          break;
      case SOAP_MESSAGE_LENGTH: //No need to set, LibWWW sets this
          break;
      default:;
      }
      
      if (!key) 
          return;
      
      char* value = const_cast<char*>(pcValue);
      HTRequest_addExtraHeader(m_pRequest, key, value);
  }
       
  const char* LibWWWTransport::getTransportProperty(
                      AXIS_TRANSPORT_INFORMATION_TYPE eType)
  {
      return "TODO";
  }
       
  void LibWWWTransport::setTransportProperty(const char* pcKey, const char* pcValue)
  {
      char* key = const_cast<char*>(pcKey);
      char* value = const_cast<char*>(pcValue);
      HTRequest_addExtraHeader(m_pRequest, key, value);
  }
       
  const char* LibWWWTransport::getTransportProperty(const char* pcKey)
  {
      return "TODO"; //this could be implemented with HTAssocList * HTRequest_extraHeader
(HTRequest * request); 
  }
       
  void LibWWWTransport::setAttachment(const char* pcAttachmentid, const char* pcAttachment)
  {
      //TODO
  }
       
  const char* LibWWWTransport::getAttachment(const char* pcAttachmentid)
  {
      return "TODO";
  }
  
  void LibWWWTransport::setEndpointUri(const char* pcEndpointUri)
  {
      //Samisa:This too should go to the base class SOAPTransport
      //It is not point duplicating this method in all transport implementations
      m_pcEndpointUri = strdup(pcEndpointUri);
  }
       
  void LibWWWTransport::setSessionId(const char* pcSessionId)
  {
      //TODO
  }
  
  const char* LibWWWTransport::getSessionId()
  {
      //TODO
  }
       
  const char* LibWWWTransport::getServiceName()
  {
      //Samisa: Copied and pasted from AxisTrasport class.
      //Should be moved to SOAPTrasport class as it is always derived from the 
      //inherited attribute
      char* pachTmp = strrchr (m_pcEndpointUri, '/');
  
      if (pachTmp != NULL)
      {
          int iTmp = strlen (pachTmp);
  
          if (iTmp <= 1)
          {
              return NULL;
          }
          else
          {
              pachTmp = pachTmp + 1;
          }
      }
  
      return pachTmp;
  
  }
       
  AXIS_PROTOCOL_TYPE LibWWWTransport::getProtocol()
  {
      return APTHTTP;//HTTP
  }
       
  int LibWWWTransport::getSubProtocol()
  {
      return 0; //TODO:Should return POST
  }
       
  AXIS_TRANSPORT_STATUS LibWWWTransport::flushOutput()
  {
      //HTRequest * request = NULL;
      //HTParentAnchor* src = NULL;
      //HTAnchor * dst = NULL;
  
  //#ifdef HT_EXT
      HTRequest_setOutputFormat(m_pRequest, WWW_SOURCE);
      HTRequest_setOutputFormat(m_pRequest, HTAtom_for ("text/xml"));
      HTRequest_setMethod(m_pRequest, METHOD_EXT_0);
      HTMethod_setExtensionMethod(METHOD_EXT_0, "POST", NO);
          
      if(HTRequest_setMessageBody(m_pRequest, m_pcData) == NO)
          return TRANSPORT_FAILED;
  
      HTRequest_setMessageBodyFormat(m_pRequest, HTAtom_for ("text/xml"));
      HTRequest_setMessageBodyLength(m_pRequest, strlen(m_pcData));
      if (m_pResult)
          HTChunk_delete(m_pResult);
      m_pResult = HTLoadToChunk(m_pcEndpointUri, m_pRequest);
      HTEventList_loop(m_pRequest);
      
      if (m_pcReceived)
          free(m_pcReceived);
      
      if(m_pResult)
      {
          m_pcReceived = HTChunk_data(m_pResult);
          if(m_pcReceived)
          {
              m_iBytesLeft = strlen(m_pcReceived);
              return TRANSPORT_FINISHED;
          }
          else
              return TRANSPORT_FAILED;
      }
      else
          return TRANSPORT_FAILED;
  //#endif //HT_EXT
      
  }
       
  void LibWWWTransport::setProxy(const char* pcProxyHost, unsigned int uiProxyPort)
  {
      if(m_pcProxy)
          free(m_pcProxy);
  
       char port[10];
       sprintf(port, "%d", uiProxyPort);
       m_pcProxy = (char*)malloc(sizeof(char) * (strlen(pcProxyHost) + strlen(":") + strlen(port)
+ 1));
       strcat(m_pcProxy, pcProxyHost);
       strcat(m_pcProxy, ":");
       strcat(m_pcProxy, port);
       HTRequest_setProxy(m_pRequest, m_pcProxy);
  }
  
  void LibWWWTransport::setTimeout(const long lSeconds)
  {
      //Samisa: Got the feeling that LibWWWTransport::setTimeout 
      //should use milliseconds rather than seconds
      HTHost_setEventTimeout(lSeconds * 1000);
  }
  
  
  extern "C" {
  STORAGE_CLASS_INFO
  int CreateInstance(SOAPTransport **inst)
  {
          *inst = new LibWWWTransport();
          if (*inst)
          {
                  return AXIS_SUCCESS;
          }
          return AXIS_FAIL;
  }
  STORAGE_CLASS_INFO
  int DestroyInstance(SOAPTransport *inst)
  {
          if (inst)
          {
                  delete inst;
                  return AXIS_SUCCESS;
          }
          return AXIS_FAIL;
  }
  }
  
  
  
  
  1.1                  ws-axis/c/src/transport/libwww/LibWWWTransport.h
  
  Index: LibWWWTransport.h
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   * @author Samisa Abeysinghe (sabeysinghe@virtusa.com)
   *
   */
  
  #if !defined(AXIS_LIB_WWW_TRANSPORT_H__OF_AXIS_INCLUDED_)
  #define AXIS_LIB_WWW_TRANSPORT_H__OF_AXIS_INCLUDED_
  
  #include "../SOAPTransport.h"
  #include "WWWLib.h"
  #include "WWWInit.h"
  
  /**
   * @file LibWWWTransport.h
   *
   * Implementation of SOAPTransport using LibWWW library.
   */
  
  #ifdef __cplusplus
  
  /**
   * @class LibWWWTransport
   *
   * Class that implements the SOAPTransport interface with LibWWW library.
   *
   * @brief Class that implements the SOAPTransport interface with LibWWW library.
   *
   */
  class LibWWWTransport : public SOAPTransport
  {
  public:
      /**
       * Constructor.
       */
      LibWWWTransport();
  
      /**
       * Destructor.
       */
      ~LibWWWTransport();
  
      /**
       * Sends a buffer to the transport layer. A Caller may call this method
       * multiple times to send several buffers. Its upto the transport to
       * decide how they are sent (chunked/unchunked etc). But should return the
       * appropriate status code.
       *
       * @brief Sends a buffer to the transport layer.
       * @pre   1. Transport connection should have been established by calling
       *           Openconnection of the LibWWWTransport's implementaion.
       *        2. If the implementaion of LibWWWTransport intends to accumulate
       * @param pcSendBuffer Null terminated character buffer to be sent.
       * @param pBufferid void* that represents the buffer id. This pointer will
       *        only be needed by the transport layer when it needs to call
       *        caller provided callback function to indicate that transport
       *        layer has finished using the buffer. So when the transport layer
       *        intends to keep the pcSendBuffer for late sending, the value of
       *        pBufferid should also be stored. In case when pBufferid is NULL
       *        the transport layer can keep the buffer for late sending. But
       *        MUST never call the release buffer callback.
       *
       * @return Transport status. Three states are possible. They are,
       *       TRANSPORT_FINISHED    - Passed buffer has been sent. So the caller
       *                               can re-use the buffer
       *       TRANSPORT_IN_PROGRESS - Passed buffer is not yet sent. So the
       *                               caller cannot re-use the buffer
       *       TRANSPORT_FAILED      - Transport layer has failed. So the caller
       *                               should not send any more buffers.
       * @post In case this function returns TRANSPORT_IN_PROGRESS. The caller
       *       should wait till the transport layer calls the provided callback
       *       function with the bufferid to indicate that it can re-use
       *       the buffer. The transport layer MUST call the callback function
       *       for each buffer for which this function returned the status
       *       code TRANSPORT_IN_PROGRESS.
       */
      AXIS_TRANSPORT_STATUS sendBytes(const char* pcSendBuffer, 
  		const void* pBufferid);
      /**
       * Gets a part of or full SOAP message. A Caller may call this method
       * multiple times to get parts of the SOAP message until the function
       * return status says that no more data available.
       *
       * @brief Gets a part of or full SOAP message.
       * @pre   Transport connection should have been established by calling
       *        Openconnection of the LibWWWTransport's implementaion.
       * @param pcBuffer The character buffer provided by the caller to be
       *        filled by the transport layer. The size of the buffer is given
       *        by the value of second parameter piRetSize. The transport layer
       *        should fill the buffer and put the number of bytes filled into
       *        the inout parameter piRetSize.
       * @param piRetSize Inout parameter which contain the size of the buffer
       *        as the in value. On return the transport layer should populate
       *        this parameter with the number of bytes copied to the buffer.
       *
       * @return Transport status. Three states are possible. They are,
       *       TRANSPORT_FINISHED    - Method call successful. No more data
       *                               is available. If pcBuffer contains any
       *                               data this is the final part of the message.
       *                               can re-use the buffer.
       *       TRANSPORT_IN_PROGRESS - Method call is successful. There can be
       *                               more data of this message for subsequent
       *                               calls to this method. pcBuffer must have
       *                               been filled to its maximum capacity.
       *       TRANSPORT_FAILED      - Transport layer has failed. So the caller
       *                               should not call this method again. Any
       *                               data in the pcBuffer are not reliable and
       *                               should not be used.
       */
       AXIS_TRANSPORT_STATUS getBytes(char* pcBuffer, int* piRetSize);
      /**
       * Opens a connection with the provided endpoint URI. The connection
       * type (protocol) is decided by the implementation and the protocol
       * set. See example implementation.
       *
       * @brief Opens a connection with the provided endpoint URI.
       * @pre   The endpoint URI and the protocol type (if needed) MUST have
       *        been set.
       * @example AxisTransport.h
       * @return Returns AXIS_SUCCESS if connection established successfully.
       *         Else returns AXIS_FAIL
       */
       int openConnection();
      /**
       * @brief Closes the connection established with OpenConnection.
       * @example AxisTransport.h
       */
       void closeConnection();
      /**
       * Registers the callback function which is used by transport layer to
       * inform the caller that a buffer given to be sent was sent and it can
       * be re-used by the caller.
       *
       * @brief Registers the m_pReleaseBufferCallback callback function.
       * @param pFunct Function pointer to caller's function signature of
       *        this function is defined in Packet.h
       */
       void registerReleaseBufferCallback(
                      AXIS_ENGINE_CALLBACK_RELEASE_SEND_BUFFER pFunct);
      /**
       * Sets a predefined transport property to be included in the outgoing
       * message. This transport property is not persistent in the transport
       * layer. These transport properties should be set for each outgoing
       * message.
       *
       * @brief Sets a predefined transport property for outgoing message.
       * @param eType Predefined transport property to be set. See Packet.h
       *        for predefined transport property types.
       * @param pcValue Transport property value to be set.
       */
       void setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE eType,
                      const char* pcValue);
      /**
       * @brief Gets a predefined transport property in the arrived message
       *
       * @param eType Predefined transport property to get. See Packet.h
       *        for predefined transport property types.
       * @return Value of the transport property if available. Returns null
       *         if unavailable.
       */
       const char* getTransportProperty(
                      AXIS_TRANSPORT_INFORMATION_TYPE eType);
      /**
       * Sets any transport property to be included in the outgoing message.
       * This transport property is not persistent in the transport layer.
       * These transport properties should be set for each outgoing message.
       *
       * @brief Sets any transport property.
       * @param pcKey Key for the transport property to be set.
       * @param pcValue Value for transport property to be set.
       */
       void setTransportProperty(const char* pcKey, const char* pcValue);
      /**
       * @brief Gets any transport property in the arrived message
       *
       * @param pcKey The key of the transport property to get.
       * @return Value of the transport property if available. Returns null
       *         if unavailable.
       */
       const char* getTransportProperty(const char* pcKey);
      /**
       * Sets a SOAP attachment to be sent with outgoing message. This
       * attachment is usually the base64 or hex encoded character buffer
       * that is null terminated.
       *
       * @brief Sets a SOAP attachment to be sent with outgoing message
       * @param pcAttachmentid An identifier for the attachment. This identifier also
       *        will go in to the SOAP message so that the recipient will know that
       *        there is an attachemet in the message.
       * @param pcAttachment The attachment. This is usually a null terminated string
       *        encoded to base64 or hex binary.
       */
       void setAttachment(const char* pcAttachmentid, const char* pcAttachment);
      /**
       * Gets an attachment arrived in the inbound message. Usually the SOAP message will
       * contain the information indicating that there is an attachment arrived at the
       * transport. The SOAP message also contain the attachement id which is required
       * to request the transport for the particular attachment.
       *
       * @brief Gets an attachment arrived in the inbound message.
       * @pre To get an attachment the attachment id must be provided. The SOAP message
       *      should contain the attachment id.
       * @param pcAttachmentid Attachment identifier that the caller should find from
       *        the SOAP message and pass in. The transport will use this identifier
       *        to locate the corresponding attachment.
       * @return The attachment if available. Returns null if the attachment
       *         corresponding to the pcAttachmentid is not found.
       */
       const char* getAttachment(const char* pcAttachmentid);
      /**
       * Sets the the remote endpoint for tranport to connect to. This URI
       * depends on the the transport type. 
       *
       * @pre   A caller should use the method getProtocol() to get the type
       *        of the transport. Then the caller should set the endpoint URI
       *        accordingly. For example if the transport is HTTP this
       *        endpoint can be "http://www.xxx.com/"and if the transport is
       *        SMTP this endpoint can be the mail server and port.
       *
       * @brief Sets the remote endpoint for tranport to connect to.
       * @param pcEndpointUri Endpoint URI to connect to.
       */
       void setEndpointUri(const char* pcEndpointUri);
      /**
       * Sets the session id for the transport session. Actual usage of this
       * session id is depend on the implementation of the transport.
       *
       * @brief Sets the session id for the transport session.
       * @param pcSessionId The session id.
       */
       void setSessionId(const char* pcSessionId);
      /**
       * Gets the session id of the transport session sent by the remote end if
       * any. 
       *
       * @brief  Sets the session id for the transport session.
       * @return Session id if available. Returns null otherwise.
       */
       const char* getSessionId();
      /**
       * Gets the service name of the web service to be invoked. How this
       * service name is found is upto the type of the transport layer. For
       * example HTTP transports will look at the value of http header
       * "soapAction" and extract the service name. Whereas a SMTP transport
       * will look at recepitent address.
       *
       * @brief  Gets the service name of the web service to be invoked.
       * @return Service name if available and null otherwise.
       */
       const char* getServiceName();
      /**
       * Gets the protocol type of the transport library. The caller should
       * use this function to check the protocol of the transport layer and
       * should use the transport accordingly.
       *
       * @brief Gets the protocol type of the transport library.
       * @return The type of the transport. See AXIS_PROTOCOL_TYPE in Packet.h
       */
       AXIS_PROTOCOL_TYPE getProtocol();
      /**
       * Gets the sub protocol. The usefulness of this method and the return
       * values depend on the particular implementation. For example HTTP
       * transports should return one of the values defined in enumeration
       * AXIS_HTTP_METHOD. See Packet.h
       *
       * @brief Gets the sub protocol. 
       * @return Type of the sub protocol (Ex: GET, POST, UNSUPPORTED for HTTP).
       */
       int getSubProtocol();
      /**
       * @brief Forces transport to send any remaining data of the outgoing message.
       * @return Transport status. Two return status are possible. They are,
       *         TRANSPORT_FAILED   - Sending data has failed.
       *         TRANSPORT_FINISHED - Sending finished and successful.
       */
       AXIS_TRANSPORT_STATUS flushOutput();
    /**
      * Set proxy server and port for transport.
      *
      * Setting the proxy is useful for users who are behind proxies.
      *
      * For some trasports this method may not make sense.
      * Hence this method is not pure .
      * Those trasports that implement this interface, that wish to use proxy, must provide
an implementation.
      * Also, the hadling of the proxy is the responsibility of the deriving classes
      *
      * @param pcProxyHost Host name of proxy server
      * @param uiProxyPort Port of proxy server
      */
       void setProxy(const char* pcProxyHost, unsigned int uiProxyPort); 
  
    /**
      * Set transport timeout.
      *
      * @param lSeconds Timeout in seconds
      */
       void setTimeout(const long lSeconds);
  
  protected:
      //Handler that terminate the event loop and clean up
      //int terminate_handler (HTRequest * request, HTResponse * response,
      //                           void * param, int status);
  
  
      //Request object
      HTRequest * m_pRequest;
      //Chunk to hold the result
      HTChunk * m_pResult;
      //data to be posted
      char* m_pcData;
      //proxy
      char* m_pcProxy;
      //getting bytes
      int m_iBytesLeft;
      char* m_pcReceived;
  
  };
  
  #endif
  
  #endif // !defined(AXIS_LIB_WWW_TRANSPORT_H__OF_AXIS_INCLUDED_)
  
  
  
  1.1                  ws-axis/c/src/transport/libwww/Makefile.am
  
  Index: Makefile.am
  ===================================================================
  lib_LTLIBRARIES = libaxis_LibWWWTransport.la
  AM_CPPFLAGS = $(CPPFLAGS)
  libaxis_LibWWWTransport_la_SOURCES = LibWWWTransport.cpp
  #libaxis_LibWWWTransport_la_LIBADD = "`libwww-config  --libs`"
  libaxis_LibWWWTransport_la_LDFLAGS="`libwww-config  --libs`"
  INCLUDES = -I$(AXISCPP_HOME)/include `libwww-config --cflags`
  
  
  
  

Mime
View raw message