[ http://issues.apache.org/jira/browse/AXISCPP-518?page=history ]
Chinthana Danapala updated AXISCPP-518: --------------------------------------- Attachment: HTTPTransportcpp diff.txt i have add some changes here it will help to solve this problem. > Call to method getBytes of the class HTTPTransport never returns a value > different from TRANSPORT_IN_PROGRESS > ------------------------------------------------------------------------------------------------------------- > > Key: AXISCPP-518 > URL: http://issues.apache.org/jira/browse/AXISCPP-518 > Project: Axis-C++ > Type: Bug > Components: Transport (axis3) > Versions: unspecified > Environment: The bug affects all platforms > Reporter: Arcangelo Di Balsamo > Attachments: HTTPTransport.cpp, HTTPTransportcpp diff.txt, > HTTPTrasportTestClient.zip > > I got a bug in the http trasport library ( HTTPTransport). I wrote a simple > test client to reproduce the problem (I can send the test program, if you > want ). > The problem is that the method getBytes of the class HTTPTransport never > returns a value different from TRANSPORT_IN_PROGRESS. That makes the caller > to loop forever. > I tried to workaround the problem by checking the size of the ruturned buffer > in the client, but that led to data truncation. > The regression suite should be modified too. In fact you should try to use a > buffer smaller than the size of the expected response from the server. > I've already made a fix: the affected module is HTTPTransport.cpp. > The modified code is : > /* > * 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 ([EMAIL PROTECTED]) > * > */ > #ifdef WIN32 > #pragma warning (disable : 4786) > #pragma warning (disable : 4101) > #endif > #include "HTTPTransport.hpp" > #include <stdio.h> > #include <iostream> > /* > * HTTPTransport constuctor > */ > HTTPTransport::HTTPTransport ():m_bReopenConnection (false), > m_strHTTPProtocol ("HTTP/1.1"), > m_strHTTPMethod ("POST"), > m_bChunked (false), > m_bReadPastHTTPHeaders (false), > m_strProxyHost (""), m_uiProxyPort (0), m_bUseProxy (false), > m_bMaintainSession (false) > { > m_pcEndpointUri = NULL; > m_pReleaseBufferCallback = 0; > m_eProtocolType = APTHTTP1_1; > m_strBytesToSend = ""; > m_strHeaderBytesToSend = ""; > m_iBytesLeft = 0; > m_iContentLength = 0; > m_pcReceived = 0; > m_bChannelSecure = false; > m_pNormalChannel = 0; > m_pSecureChannel = 0; > m_pActiveChannel = 0; > m_pChannelFactory = new ChannelFactory(); > m_bMimeTrue = false; > m_viCurrentHeader = m_vHTTPHeaders.begin(); > m_pszRxBuffer = new char [BUF_SIZE]; > #ifdef WIN32 > m_lChannelTimeout = 10; > #else > m_lChannelTimeout = 0; > #endif > } > /* > * HTTPTransport destuctor > */ > HTTPTransport::~HTTPTransport() > { > if( m_pcEndpointUri) > { > delete[] m_pcEndpointUri; > } > if( m_pChannelFactory) > { > delete m_pChannelFactory; > m_pChannelFactory = 0; > } > delete [] m_pszRxBuffer; > } > /* > * HTTPTransport::setEndpointUri( EndpointURI) sets the URI for the message. > * Everytime the endpoint changes then currently connected channel is closed > * and a new channel connection is opened. > * > * @param EndpointURI - char * to a null terminated string that holds the > * new URI. > */ > void HTTPTransport::setEndpointUri( const char * pcEndpointUri) throw > (HTTPTransportException) > { > bool bUpdateURL = false; > // Get the current channel URI > if( m_pActiveChannel != NULL && m_pActiveChannel->getURL()) > { > // Does the new URI equal the existing channel URI? > if( strcmp (m_pActiveChannel->getURL (), pcEndpointUri) != 0) > { > // There is a new URI. > bUpdateURL = true; > } > } > else > { > bUpdateURL = true; > } > // If there is a new URI, then this flag will be set. Depending on > whether > // there is an SSL implementation available, if the new URI is a secure > // connection, a secure channel will be opened. If an SSL > implementation > // is not available and the URL requires a secure connection then an > // exception will be thrown. > if( bUpdateURL) > { > if( m_pActiveChannel == NULL) > { > m_pActiveChannel = m_pNormalChannel; > } > m_pActiveChannel->setURL( pcEndpointUri); > m_bReopenConnection = true; > // Check if the new URI requires SSL (denoted by the https prefix). > if( (m_pActiveChannel->getURLObject()).getProtocol() == > URL::https) > { > if( m_pSecureChannel != NULL) > { > m_pNormalChannel->close(); > m_pActiveChannel = m_pSecureChannel; > m_pActiveChannel->setURL( pcEndpointUri); > m_bChannelSecure = true; > } > if( !m_bChannelSecure) > { > throw HTTPTransportException( > CLIENT_TRANSPORT_HAS_NO_SECURE_TRANSPORT_LAYER); > } > } > else > { > // URI does not require a secure channel. Delete the existing > // channel if it is secure and create a new unsecure > // channel. > if (m_bChannelSecure) > { > if( m_pNormalChannel != NULL) > { > m_pSecureChannel->close(); > m_pActiveChannel = m_pNormalChannel; > m_pActiveChannel->setURL( > pcEndpointUri); > m_bChannelSecure = false; > } > if( m_bChannelSecure) > { > throw HTTPTransportException( > CLIENT_TRANSPORT_HAS_NO_UNSECURE_TRANSPORT_LAYER); > } > } > } > } > // Need this code to set the channel timeout. If the timeout was changed > // before the channel was created, then it may not have the correct timeout. > // By setting it here, the channel is sure to have the correct timeout value > // next time the channel is read. > if( m_pActiveChannel != NULL) > { > m_pActiveChannel->setTimeout( m_lChannelTimeout); > } > } > /* > * HTTPTransport::openConnection(). > */ > int HTTPTransport::openConnection() > { > return m_pActiveChannel->open(); > } > /* > * HTTPTransport::closeConnection(). > */ > void HTTPTransport::closeConnection() > { > // get ready for a new message. > m_bReadPastHTTPHeaders = false; > //clear the message buffer in preperation of the next read. > m_strReceived = ""; > m_iContentLength = 0; > if( m_pActiveChannel != NULL) > { > m_pActiveChannel->close(); > } > } > /* > * HTTPTransport::flushOutput() Is called when the message construction is > * complete. The message is ready to be 'flushed out' onto the network. > * Check if the URI has changed. If it has, then need to open a new Channel > * instance before transmitting the message. > * > * @return AXIS_TRANSPORT_STATUS If the method completes successfully, then > * this will be set to TRANSPORT_FINISHED. Otherwise, an exception will have > * been thrown. > */ > AXIS_TRANSPORT_STATUS HTTPTransport::flushOutput() throw > (HTTPTransportException) > { > if( m_bReopenConnection) > { > m_bReopenConnection = false; > if( m_pActiveChannel->open() != AXIS_SUCCESS) > { > int iStringLength = > m_pActiveChannel->GetLastErrorMsg().length() + 1; > const char * pszLastError = new char[iStringLength]; > memcpy( (void *) pszLastError, > > m_pActiveChannel->GetLastErrorMsg().c_str(), > iStringLength); > throw HTTPTransportException( > CLIENT_TRANSPORT_OPEN_CONNECTION_FAILED, > > (char *) pszLastError); > } > } > // In preperation for sending the message, calculate the size of the > message > // by using the string length method. > // NB: This calculation may not necessarily be correct when dealing with > SSL > // messages as the length of the encoded message is not necessarily > the > // same as the length of the uncoded message. > char buff[8]; > sprintf( buff, "%d", m_strBytesToSend.length ()); > this->setTransportProperty ("Content-Length", buff); > // The header is now complete. The message header and message can now be > // transmitted. > try > { > *m_pActiveChannel << this->getHTTPHeaders (); > *m_pActiveChannel << this->m_strBytesToSend.c_str (); > } > catch( HTTPTransportException & e) > { > throw; > } > catch( AxisException & e) > { > throw; > } > catch(...) > { > throw; > } > // Empty the bytes to send string. > m_strBytesToSend = ""; > m_strHeaderBytesToSend = ""; > return TRANSPORT_FINISHED; > } > /* HTTPTransport::getHTTPHeaders() Called to retreive the current HTTP header > * information block that will preceed the SOAP message. > * > * @return const char* Pointer to a NULL terminated character string > containing > * the HTTP header block of information. > */ > const char * HTTPTransport::getHTTPHeaders() > { > URL & url = m_pActiveChannel->getURLObject(); > unsigned short uiPort = url.getPort(); > char buff[8]; > m_strHeaderBytesToSend = m_strHTTPMethod + " "; > m_strHeaderBytesToSend += std::string (url.getResource ()) + " "; > m_strHeaderBytesToSend += m_strHTTPProtocol + "\r\n"; > m_strHeaderBytesToSend += std::string ("Host: ") + url.getHostName (); > sprintf (buff, "%u", uiPort); > m_strHeaderBytesToSend += ":"; > m_strHeaderBytesToSend += buff; > m_strHeaderBytesToSend += "\r\n"; > m_strHeaderBytesToSend += "Content-Type: text/xml; charset=UTF-8\r\n"; > // Set other HTTP headers > for (unsigned int i = 0; i < m_vHTTPHeaders.size (); i++) > { > m_strHeaderBytesToSend += m_vHTTPHeaders[i].first; > m_strHeaderBytesToSend += ": "; > m_strHeaderBytesToSend += m_vHTTPHeaders[i].second; > m_strHeaderBytesToSend += "\r\n"; > } > // Set session cookie > if (m_bMaintainSession && (m_strSessionKey.size () > 0)) > { > m_strHeaderBytesToSend += "Cookie"; > m_strHeaderBytesToSend += ": "; > m_strHeaderBytesToSend += m_strSessionKey; > m_strHeaderBytesToSend += "\r\n"; > } > m_strHeaderBytesToSend += "\r\n"; > return m_strHeaderBytesToSend.c_str (); > } > /* HTTPTransport::getHTTPMethod() Is a public method that gets the HTTP method > * (i.e. GET or POST) that will be part of the HTTP header block. > * > * @return const char* Pointer to a NULL terminated character string > containing > * the HTTP method. > */ > const char * HTTPTransport::getHTTPMethod() > { > return m_strHTTPMethod.c_str (); > } > /* HTTPTransport::setHTTPMethod( Method) Is a public method that sets the HTTP > * method (i.e. POST or GET) that will be part of the HTTP header block. > * > * @param const char* Pointer to a NULL terminated character string containing > * the new HTTP method. > */ > void HTTPTransport::setHTTPMethod( const char *cpMethod) > { > m_strHTTPMethod = std::string( cpMethod); > } > /* HTTPTransport::sendBytes( SendBuffer, BufferId) Is a public method that > * concatinates the new send buffer to the bytes to send string. This message > * will only be sent when a flush buffer is received. > * > * @param const char* SendBufer - Pointer to a NULL terminated character > string > * containing all or some of the transmission message. > * @param const void* BufferId - Pointer. This parameter is ignored. > * > * @return AXIS_TRANSPORT_STATUS Value to a status value (currently it will > * always be TRANSPORT_IN_PROGRESS). > */ > AXIS_TRANSPORT_STATUS HTTPTransport::sendBytes( const char *pcSendBuffer, > const void *pBufferId) > { > m_strBytesToSend += std::string (pcSendBuffer); > return TRANSPORT_IN_PROGRESS; > } > /* HTTPTransport::getBytes( ReceiveBuffer, Size) Is a public method that will > * receive the synchronous reply to the sent message. > * > * @param const char* ReceiveBuffer - Pointer to a character string that on > * return will containing all or part of the received message. > * @param int* Size - Pointer to an integer value that on return will contain > * the length of the received message. > * > * @return AXIS_TRANSPORT_STATUS Value to the status o message reception > * (TRANSPORT_FINISHED or TRANSPORT_IN_PROGRESS). > */ > AXIS_TRANSPORT_STATUS HTTPTransport::getBytes( char *pcBuffer, int *pSize) > throw (AxisException, HTTPTransportException) > { > if (0 >= m_iBytesLeft) > { > try > { > m_pszRxBuffer [0] = '\0'; > *m_pActiveChannel >> m_pszRxBuffer; > m_strReceived = m_pszRxBuffer; > if( !m_bReadPastHTTPHeaders) > { > unsigned int start = std::string::npos; > do > { > do > { > if (m_strReceived.find( > "\r\n\r\n") == std::string::npos) > { > m_pszRxBuffer [0] = > '\0'; > *m_pActiveChannel >> > m_pszRxBuffer; > m_strReceived += > m_pszRxBuffer; > } > } while( m_strReceived.find( > "\r\n\r\n") == std::string::npos); > if( m_strReceived.find ("HTTP") == > std::string::npos) > { > // Most probably what we read was left overs from > earlier reads > // Skip this \r\n\r\n > m_strReceived = > m_strReceived.substr( m_strReceived.find( "\r\n\r\n") + 4); > do > { > if( m_strReceived.find( > "\r\n\r\n") == std::string::npos) > { > m_pszRxBuffer > [0] = '\0'; > > *m_pActiveChannel >> m_pszRxBuffer; > m_strReceived > += m_pszRxBuffer; > } > } while( m_strReceived.find( > "\r\n\r\n") == std::string::npos); > // now this must contain HTTP. Else there is a conent > error. > } > //now we have found the end of headers > m_bReadPastHTTPHeaders = true; > unsigned int pos = 0; > // Look for content lenght > if( (pos = m_strReceived.find( > "Content-Length: ")) != std::string::npos) > { > m_iContentLength = atoi( > m_strReceived.substr( pos + strlen( "Content-Length: "), > > > m_strReceived.find( "\n", pos)).c_str()); > } > // Check if the message is chunked > if( (pos = m_strReceived.find( > "Transfer-Encoding: chunked")) != std::string::npos) > { > m_bChunked = true; > } > else > { > m_bChunked = false; > } > // check if there is HTTP header. If not, there must be an > error and > // will be detected by processResponseHTTPHeaders() > // However, must make sure that the left overs from eatlier > reads > // do not appear before HTTP/1.x > start = m_strReceived.find( "HTTP"); > if( start == std::string::npos) > { > start = 0; > } > // Extract HTTP headers and process them > m_strResponseHTTPHeaders = > m_strReceived.substr( start, > > m_strReceived.find( > "\r\n\r\n") + 2 - start); > processResponseHTTPHeaders(); > if( m_iResponseHTTPStatusCode == 100) > { > // Samisa: We found Continue. Keep on reading and > processing headers > // till we get a HTTP code other than 100 > // Here it is assumed that the whole of the request is > already sent > m_pszRxBuffer [0] = '\0'; > *m_pActiveChannel >> > m_pszRxBuffer; > m_strReceived = m_pszRxBuffer; > } > } while( m_iResponseHTTPStatusCode == 100); > if ( m_iResponseHTTPStatusCode != 500 && > ( m_iResponseHTTPStatusCode < 200 || > m_iResponseHTTPStatusCode >= 300 )) > { > throw HTTPTransportException( > SERVER_TRANSPORT_HTTP_EXCEPTION, > > const_cast <char *> > (m_strResponseHTTPStatusMessage.c_str())); > } > // Done with HTTP headers, get payload > m_strReceived = m_strReceived.substr( > m_strReceived.find( "\r\n\r\n", start) + 4); > } > // Read past headers. Deal with payload > // make sure we have a message with some content > if( m_strReceived.length () == 0) > { > m_pszRxBuffer [0] = '\0'; > *m_pActiveChannel >> m_pszRxBuffer; > m_strReceived = m_pszRxBuffer; > } > if( m_strReceived.length () > 0) > { > if( m_bChunked && m_iContentLength < 1) // Read > first chunk > { > /* > *Chunked data looks like -> > * Chunked-Body = *chunk > * "0" CRLF > * footer > * CRLF > * > * chunk = chunk-size [ chunk-ext ] CRLF > * chunk-data CRLF > * > * hex-no-zero = <HEX excluding "0"> > * > * chunk-size = hex-no-zero *HEX > * chunk-ext = *( ";" chunk-ext-name [ "=" > chunk-ext-value ] ) > * chunk-ext-name = token > * chunk-ext-val = token | quoted-string > * chunk-data = chunk-size(OCTET) > * > * footer = *entity-header > */ > // firstly read in the chunk size line. > //There might be chunk extensions in there too but we > may not need them > unsigned int endOfChunkData = > m_strReceived.find( "\r\n"); > // make sure we have read at least some part of the > message > if( endOfChunkData == std::string::npos) > { > do > { > m_pszRxBuffer [0] = > '\0'; > *m_pActiveChannel >> > m_pszRxBuffer; > m_strReceived = > m_pszRxBuffer; > endOfChunkData = > m_strReceived.find( "\r\n"); > } while( endOfChunkData == > std::string::npos); > } > int endOfChunkSize = endOfChunkData; > // now get the size of the chunk from the data > // look to see if there are any extensions - these are > put in brackets so look for those > if( m_strReceived.substr( 0, > endOfChunkData).find( "(") != string::npos) > { > endOfChunkSize = > m_strReceived.find( "("); > } > // convert the hex String into the length of the chunk > m_iContentLength = axtoi( (char *) > m_strReceived.substr( 0, endOfChunkSize).c_str()); > // if the chunk size is zero then we have reached the > footer > // If we have reached the footer then we can throw it > away because we don't need it > if( m_iContentLength > 0) > { > // now get the chunk without the CRLF > // check if we have read past chunk length > if( m_strReceived.length() >= > (endOfChunkData + 2 + m_iContentLength)) > { > m_strReceived = > m_strReceived.substr( endOfChunkData + 2, m_iContentLength); > } > else // we have read lesser > than chunk length > { > m_strReceived = > m_strReceived.substr( endOfChunkData + 2); > } > /* We have received part of chunk data. If > received payload > * is a mime struct, process it > */ > if( m_bMimeTrue) > { > processRootMimeBody(); > } > } > else > { > m_strReceived = ""; > } > } > else if( m_bChunked) // read continued > portions of a chunk > { > // Samisa - NOTE: It looks as if there is some logic > duplication > // in this block, where we read continued chunks and > the block > // above, where we read the first chunk. However, there > are slight > // logical differences here, and that is necessary to > enable the > // pull model used by the parser - this logic makes > pulling more > // efficient (30th Sept 2004) > if( m_strReceived.length () >= > m_iContentLength) // We have reached end of current chunk > { > // Get remainder of current chunk > std::string strTemp = > m_strReceived.substr( 0, m_iContentLength); > // Start looking for the next chunk > // The format we are expecting here is: > // <previous chunk>\r\n<chunk size>\r\n<next > chunk> > unsigned int endOfChunkData = > m_strReceived.find( "\r\n"); > // Make sure that we have the found the end of > previous chunk > while( endOfChunkData == > std::string::npos) > { > m_pszRxBuffer [0] = > '\0'; > *m_pActiveChannel >> > m_pszRxBuffer; > m_strReceived += > m_pszRxBuffer; > endOfChunkData = > m_strReceived.find( "\r\n"); > } > m_strReceived = > m_strReceived.substr( endOfChunkData + 2); // Skip end of previous chunk > endOfChunkData = > m_strReceived.find( "\r\n"); // Locate the start of next chunk > // Make sure that we have the starting line of > next chunk > while( endOfChunkData == > std::string::npos) > { > m_pszRxBuffer [0] = > '\0'; > *m_pActiveChannel >> > m_pszRxBuffer; > m_strReceived += > m_pszRxBuffer; > endOfChunkData = > m_strReceived.find( "\r\n"); > } > int endOfChunkSize = > endOfChunkData; > // look to see if there are any extensions - > these are put in brackets so look for those > if (m_strReceived.substr (0, > endOfChunkData).find ("(") != string::npos) > { > endOfChunkSize = > m_strReceived.find ("("); > } > // convert the hex String into the length of > the chunk > int iTempContentLength = axtoi( > (char *) m_strReceived.substr( 0, endOfChunkSize).c_str()); > // if the chunk size is zero then we have > reached the footer > // If we have reached the footer then we can > throw it away because we don't need it > if( iTempContentLength > 0) > { > // Update the content lenght to be remainde of > previous chunk and lenght of new chunk > m_iContentLength += > iTempContentLength; > // now get the chunk without the CRLF > // check if we have read past chunk length > if( > m_strReceived.length() >= (endOfChunkData + 2 + iTempContentLength)) > { > m_strReceived = > m_strReceived.substr( endOfChunkData + 2, iTempContentLength); > } > else > { > m_strReceived = > m_strReceived.substr( endOfChunkData + 2); > } > /* We have received part of chunk data. If > received payload > * is a mime struct, process it > */ > if( m_bMimeTrue) > { > > processRootMimeBody(); > } > } > else > { > m_strReceived = ""; > } > // Append the data of new chunk to data from > previous chunk > m_strReceived = strTemp + > m_strReceived; > } // End of if > (m_strReceived.length() >= m_iContentLength) > // If we have not reached end of current chunk, nothing > to be done > } > else // Not chunked > { > //nothing to do here > /* We have received part of chunk data. If > received payload > * is a mime struct, process it > */ > if( m_bMimeTrue) > { > processRootMimeBody(); > } > } > } > m_pcReceived = m_strReceived.c_str(); > if( m_pcReceived) > { > m_iBytesLeft = strlen( m_pcReceived); > } > else > { > throw HTTPTransportException( > SERVER_TRANSPORT_BUFFER_EMPTY, "Recieved null"); > } > m_iContentLength -= m_iBytesLeft; > } > catch( HTTPTransportException & e) > { > throw; > } > catch( AxisException & e) > { > throw; > } > catch(...) > { > throw; > } > } > if (( m_pcReceived) && (*m_pcReceived)) > { > int iToCopy = (*pSize < m_iBytesLeft) ? *pSize : m_iBytesLeft; > strncpy( pcBuffer, m_pcReceived, iToCopy); > m_iBytesLeft -= iToCopy; > m_pcReceived += iToCopy; > *pSize = iToCopy; > return TRANSPORT_IN_PROGRESS; > } > else > { > m_bReadPastHTTPHeaders = false; // get ready for a new message > m_strReceived = ""; //clear the message buffer in > preperation of the next read > return TRANSPORT_FINISHED; > } > } > /* HTTPTransport::setTransportProperty( Type, Value) Is an overloaded public > * method used to set a HTTP transport or SSL implementation property. > * > * @param AXIS_TRANSPORT_INFORMATION_TYPE Type is an enumerated type > containing > * the type of information to be stored in either the HTTP Header or SSL > * implementation settings. > * @param const char* Value is a NULL terminated character string containing > * the value associated with the type. > */ > void HTTPTransport::setTransportProperty( AXIS_TRANSPORT_INFORMATION_TYPE > type, const char *value) throw (HTTPTransportException) > { > const char *key = NULL; > switch (type) > { > case SOAPACTION_HEADER: > { > key = "SOAPAction"; > break; > } > case SERVICE_URI: // need to set ? > { > break; > } > case OPERATION_NAME: // need to set ? > { > break; > } > case SOAP_MESSAGE_LENGTH: > { > key = "Content-Length"; // this Axis transport handles > only HTTP > break; > } > case TRANSPORT_PROPERTIES: > { > m_pActiveChannel->setTransportProperty( type, value); > break; > } > case SECURE_PROPERTIES: > { > m_pActiveChannel->setSecureProperties( value); > break; > } > case CHANNEL_HTTP_DLL_NAME: > { > m_pNormalChannel = > m_pChannelFactory->LoadChannelLibrary( UnsecureChannel, value); > break; > } > case CHANNEL_HTTP_SSL_DLL_NAME: > { > m_pSecureChannel = > m_pChannelFactory->LoadChannelLibrary( SecureChannel, value); > break; > } > default: > { > break; > } > } > if( key) > { > setTransportProperty( key, value); > } > } > /* HTTPTransport::setTransportProperty( Key, Value) Is an overloaded public > * method used to set a HTTP transport or SSL implementation property. > * > * @param const char* Key is a NULL terminated character string containing > * the type of information to be stored in either the HTTP Header or SSL > * implementation settings. > * @param const char* Value is a NULL terminated character string containing > * the value associated with the type. > */ > void HTTPTransport::setTransportProperty( const char *pcKey, const char > *pcValue) throw (HTTPTransportException) > { > if( !pcKey || !pcValue) // Samisa - fix for AXISCPP-295. We must check > for valid values here. > { > return; > } > bool b_KeyFound = false; > if( strcmp( pcKey, "SOAPAction") == 0 || strcmp( pcKey, "Content-Length") > == 0) > { > std::string strKeyToFind = std::string( pcKey); > for (unsigned int i = 0; i < m_vHTTPHeaders.size(); i++) > { > if (m_vHTTPHeaders[i].first == strKeyToFind) > { > m_vHTTPHeaders[i].second = (string) pcValue; > b_KeyFound = true; > break; > } > } > } > if( !b_KeyFound) > { > m_vHTTPHeaders.push_back( std::make_pair( (string) pcKey, > (string) pcValue)); > } > } > /* HTTPTransport::getTransportProperty( Type) Is a public method that will > * return the HTTP Header/SSL implementation value associated with type. > * > * @param AXIS_TRANSPORT_INFORMATION_TYPE Type is an enumerated type > containing > * the type of information to be retrieved in either the HTTP Header or SSL > * implementation settings. > * > * @return const char* Value is a NULL terminated character string containing > * the value associated with the type. > */ > const char * HTTPTransport::getTransportProperty( > AXIS_TRANSPORT_INFORMATION_TYPE eType) throw (HTTPTransportException) > { > const char *pszPropValue = NULL; > switch( eType) > { > case SOAPACTION_HEADER: > { > int iIndex = FindTransportPropertyIndex( "SOAPAction"); > if (iIndex > -1) > { > pszPropValue = > m_vHTTPHeaders[iIndex].second.c_str(); > } > break; > } > case SERVICE_URI: > { > break; > } > case OPERATION_NAME: > { > break; > } > case SOAP_MESSAGE_LENGTH: > { > int iIndex = FindTransportPropertyIndex( > "Content-Length"); > if (iIndex > -1) > { > pszPropValue = > m_vHTTPHeaders[iIndex].second.c_str(); > } > break; > } > case TRANSPORT_PROPERTIES: > case SECURE_PROPERTIES: > { > pszPropValue = m_pActiveChannel->getTransportProperty( > eType); > break; > } > case CHANNEL_HTTP_SSL_DLL_NAME: > case CHANNEL_HTTP_DLL_NAME: > { > break; > } > } > return pszPropValue; > } > /* HTTPTransport::FindTransportPropertyIndex( Key) Is a private method that > will > * return the HTTP Header index associated with Key. > * > * @param AXIS_TRANSPORT_INFORMATION_TYPE Key is an enumerated type containing > * the type of information to be retrieved in either the HTTP Header settings. > * > * @return int Index is an index to the key within the HTTP Header list. If > * the return value is -1, then the key was not found. > */ > int HTTPTransport::FindTransportPropertyIndex( string sKey) > { > bool bKeyFound = false; > int iIndex = 0; > do > { > if (!m_vHTTPHeaders[iIndex].first.compare( sKey)) > { > bKeyFound = true; > } > else > { > iIndex++; > } > } while( (unsigned int) iIndex < m_vHTTPHeaders.size() && !bKeyFound); > if( !bKeyFound) > { > iIndex = -1; > } > return iIndex; > } > /* HTTPTransport::getServiceName() Is a public method to return the HTTP > * Header service name. > * > * @return const char* Value is a NULL terminated character string containing > * the value associated with the service name. > */ > const char * HTTPTransport::getServiceName() > { > //Assume SOAPAction header to contain service name > int iIndex = FindTransportPropertyIndex( "SOAPAction"); > if (iIndex > -1) > { > return m_vHTTPHeaders[iIndex].second.c_str(); > } > return NULL; > } > AXIS_PROTOCOL_TYPE HTTPTransport::getProtocol() > { > return m_eProtocolType; > } > int HTTPTransport::setProtocol( AXIS_PROTOCOL_TYPE eProtocol) > { > if (eProtocol == APTHTTP1_1 || eProtocol == APTHTTP1_0) > { > m_eProtocolType = eProtocol; > m_strHTTPProtocol = (m_eProtocolType == APTHTTP1_1) ? > "HTTP/1.1" : "HTTP/1.0"; > return AXIS_SUCCESS; > } > else > { > return AXIS_FAIL; > } > } > /** > * HTTPTransport::getSubProtocol() is a public method that is supposed to > * return the sub protocol (currently this method always return 0). > * This method is supposed to return whether it is http GET or POST > */ > int HTTPTransport::getSubProtocol() > { > //TODO > // for SimpleAxisServer assume POST > return AXIS_HTTP_POST; > //return 0; > } > /* HTTPTransport::setProxy( Host, Port) Is a public method for setting or > * updating the proxy for the connection. > * > * @param const char* Host is a NULL terminated character string containing > the new > * proxy host. > * @param unsigned int Port is the new proxy port number. > */ > void HTTPTransport::setProxy( const char *pcProxyHost, unsigned int > uiProxyPort) > { > m_strProxyHost = pcProxyHost; > m_uiProxyPort = uiProxyPort; > m_bUseProxy = true; > } > /* HTTPTransport::setTimeout( Timeout) Is a public method for setting the > * current maximum timeout period between that can elapse between receiving > * message parts. > * > * @param const long Timeout is a long value in seconds. > */ > void HTTPTransport::setTimeout( const long lSeconds) > { > if( m_pActiveChannel != NULL) > { > m_pActiveChannel->setTimeout( lSeconds); > } > m_lChannelTimeout = lSeconds; > } > /* HTTPTransport::getHTTPProtocol() Is a public method for retrieving the > * current HTTP protocol settings. > * > * @return const char* HTTPProtocol is a NULL terminated character string > * containing the HTTP protocol. > */ > const char * HTTPTransport::getHTTPProtocol() > { > return m_strHTTPProtocol.c_str (); > } > /* axtoi( Hex) Is a private method to convert an ascii hex string to an > integer. > */ > int axtoi( char *pcHexStg) > { > int iN = 0; // position in string > int iM = 0; // position in digit[] to shift > int iCount; // loop index > int intValue = 0; // integer value of hex string > int iDigit[32]; // hold values to convert > while( iN < 32) > { > if( pcHexStg[iN] == '\0') > { > break; > } > > if( pcHexStg[iN] > 0x29 && pcHexStg[iN] < 0x40) //if 0 to 9 > { > iDigit[iN] = pcHexStg[iN] & 0x0f; //convert to int > } > else if (pcHexStg[iN] >= 'a' && pcHexStg[iN] <= 'f') //if a > to f > { > iDigit[iN] = (pcHexStg[iN] & 0x0f) + 9; //convert to int > } > else if (pcHexStg[iN] >= 'A' && pcHexStg[iN] <= 'F') //if A > to F > { > iDigit[iN] = (pcHexStg[iN] & 0x0f) + 9; //convert to int > } > else > { > break; > } > iN++; > } > iCount = iN; > iM = iN - 1; > iN = 0; > while( iN < iCount) > { > // digit[n] is value of hex digit at position n > // (m << 2) is the number of positions to shift > // OR the bits into return value > intValue = intValue | (iDigit[iN] << (iM << 2)); > iM--; // adjust the position to set > iN++; // next digit to process > } > return intValue; > } > /* HTTPTransport::processResponseHTTPHeaders() Is a public method used to > * parse the HTTP header of the response message. > */ > void HTTPTransport::processResponseHTTPHeaders() throw > (HTTPTransportException) > { > unsigned int iPosition = std::string::npos; > unsigned int iStartPosition = iPosition; > if( (iPosition = m_strResponseHTTPHeaders.find( "HTTP")) != > std::string::npos) > { > m_strResponseHTTPProtocol = m_strResponseHTTPHeaders.substr( > iPosition, strlen( "HTTP/1.x")); > iPosition += strlen( "HTTP/1.x"); > while( m_strResponseHTTPHeaders.substr()[iPosition] == ' ') > { > iPosition++; > } > iStartPosition = iPosition; > while( m_strResponseHTTPHeaders.substr()[iPosition] != ' ') > { > iPosition++; > } > std::string strResponseHTTPStatusCode = > m_strResponseHTTPHeaders.substr( iStartPosition, > > > iPosition - iStartPosition); > m_iResponseHTTPStatusCode = atoi( > strResponseHTTPStatusCode.c_str()); > iStartPosition = ++iPosition; > iPosition = m_strResponseHTTPHeaders.find( "\n"); > m_strResponseHTTPStatusMessage = > m_strResponseHTTPHeaders.substr( iStartPosition, > > iPosition - > iStartPosition - 1); > // reached the end of the first line > iStartPosition = m_strResponseHTTPHeaders.find( "\n"); > iStartPosition++; > // read header fields and add to vector > do > { > m_strResponseHTTPHeaders = m_strResponseHTTPHeaders.substr( > iStartPosition); > iPosition = m_strResponseHTTPHeaders.find( "\n"); > if( iPosition == std::string::npos) > { > break; > } > std::string strHeaderLine = > m_strResponseHTTPHeaders.substr( 0, iPosition); > unsigned int iSeperator = strHeaderLine.find(":"); > if( iSeperator == std::string::npos) > { > break; > } > iStartPosition = iPosition + 1; > string key = strHeaderLine.substr( 0, iSeperator); > string value = strHeaderLine.substr( iSeperator + 1, > > strHeaderLine.length () - iSeperator - 1 - 1); > m_vResponseHTTPHeaders.push_back( std::make_pair( key, > value)); > // if HTTP/1.0 we have to always close the connection by default > if( m_eProtocolType == APTHTTP1_0) > { > m_bReopenConnection = true; > } > // if HTTP/1.1 we have to assume persistant connection by default > // We need to close the connection and open a new one if we have > 'Connection: close' > if( key == "Connection" && value == " close") > { > m_bReopenConnection = true; > } > // For both HTTP/1.0 and HTTP/1.1, > // We need to keep the connection if we have 'Connection: > Keep-Alive' > if( key == "Connection" && value == " Keep-Alive") > { > m_bReopenConnection = false; > } > // Look for cookies > if( m_bMaintainSession && !(m_strSessionKey.size() > 0)) > { > if( key == "Set-Cookie") > { > m_strSessionKey = value; > // Spec syntax : Set-Cookie: NAME=VALUE; expires=DATE; > path=PATH; domain=DOMAIN_NAME; secure > // This code assumes it to be : Set-Cookie: NAME=VALUE; > Anything_else > // And discards stuff after first ';' > // This is the same assumption used in Axis Java > unsigned long ulKeyEndsAt = > m_strSessionKey.find( ";"); > > if( ulKeyEndsAt != std::string::npos) > { > m_strSessionKey = > m_strSessionKey.substr( 0, ulKeyEndsAt); > } > } > } > /* If Content-Type: Multipart/Related; boundary=<MIME_boundary>; > type=text/xml; > start="<content id>" */ > if( key == "Content-Type") > { > m_strContentType = value; > > unsigned long ulMimePos = > m_strContentType.find( ";"); > std::string strTypePart; > if( ulMimePos != std::string::npos) > { > strTypePart = m_strContentType.substr( > 1, ulMimePos - 1); > } > > if( "Multipart/Related" == strTypePart) > { > m_bMimeTrue = true; > m_strContentType = > m_strContentType.substr( ulMimePos + 1, > > m_strContentType.length()); > ulMimePos = m_strContentType.find( > "boundary="); > m_strMimeBoundary = > m_strContentType.substr( ulMimePos); > ulMimePos = m_strMimeBoundary.find( > ";"); > m_strMimeBoundary = > m_strMimeBoundary.substr( 9, ulMimePos - 9); > ulMimePos = m_strContentType.find( > "type="); > m_strMimeType = > m_strContentType.substr( ulMimePos); > ulMimePos = m_strMimeType.find( ";"); > m_strMimeType = m_strMimeType.substr( > 5, ulMimePos - 5); > ulMimePos = m_strContentType.find( > "start="); > m_strMimeStart = > m_strContentType.substr( ulMimePos); > ulMimePos = m_strMimeStart.find( ";"); > m_strMimeStart = m_strMimeStart.substr( > 6, ulMimePos - 6); > } > } > } while( iPosition != std::string::npos); > } > else > { > throw HTTPTransportException( > SERVER_TRANSPORT_UNKNOWN_HTTP_RESPONSE, > > "Protocol is not HTTP."); > } > } > /* HTTPTransport::processRootMimeBody() Is a public method used to > * parse the mime attachments. > */ > void HTTPTransport::processRootMimeBody() > { > if( false == m_bReadPastRootMimeHeader) > { > do > { > if( m_strReceived.find( "\r\n\r\n") == > std::string::npos) > { > m_pszRxBuffer [0] = '\0'; > *m_pActiveChannel >> m_pszRxBuffer; > m_strReceived += m_pszRxBuffer; > } > } while( m_strReceived.find( "\r\n\r\n") == std::string::npos); > //now we have found the end of root mime header > m_bReadPastRootMimeHeader = true; > //processMimeHeader(); For the time being we don't process this > // Done with root mime body headers, get rest of the payload > // which contain the soap message > m_strReceived = m_strReceived.substr( m_strReceived.find( > "\r\n\r\n") + 4); > > unsigned int intMimeTemp = m_strReceived.find( > m_strMimeBoundary); > if (intMimeTemp != std::string::npos) > { > m_strReceived = m_strReceived.substr( 0, intMimeTemp); > m_strMimeReceived = m_strReceived.substr( intMimeTemp); > /* Using m_strMimeReceived will be > * continued when getAttachment is called. > */ > m_bMimeTrue = false; > } > } > else > { > unsigned int intMimeTemp = m_strReceived.find( > m_strMimeBoundary); > > if( intMimeTemp != std::string::npos) > { > m_strReceived = m_strReceived.substr( 0, intMimeTemp); > m_strMimeReceived = m_strReceived.substr( intMimeTemp); > /* Using m_strMimeReceived will be > * continued when getAttachment is called. > */ > m_bMimeTrue = false; > } > return; > } > } > /* HTTPTransport::processMimeHeaders() Is a public method used to > * parse the Mime headers of the response message. > */ > void HTTPTransport::processMimeHeader() > { > unsigned int pos = 0; > unsigned int temppos = 0; > // Look for content lenght > if( (pos = m_strMimeReceived.find( "Content-Type: ")) != > std::string::npos) > { > m_strMimeContentType = m_strMimeReceived.substr( pos + strlen( > "Content-Type: "), > > m_strMimeReceived.find( "\n", pos)); > pos = m_strMimeContentType.find( ";"); > temppos = m_strMimeContentType.find( "\r\n"); > if( pos < temppos) > { > m_strMimeContentType = m_strMimeContentType.substr( 0, > pos); > } > else > { > m_strMimeContentType = m_strMimeContentType.substr( 0, > temppos); > } > } > // Look for mime root body's content transfer encoding > if( (pos = m_strMimeReceived.find( "Content-Transfer-Encoding: ")) != > std::string::npos) > { > m_strMimeContentTransferEncoding = m_strMimeReceived.substr( > pos + strlen( "Content-Transfer-Encoding: "), > > m_strMimeReceived.find( > "\n", pos)); > temppos = m_strMimeContentTransferEncoding.find( "\r\n"); > m_strMimeContentTransferEncoding = > m_strMimeContentTransferEncoding.substr( 0, temppos); > } > // Look for mime root body's content id > if( (pos = m_strMimeReceived.find( "Content-ID: ")) != std::string::npos) > { > m_strMimeContentID = m_strMimeReceived.substr( pos + strlen( > "Content-ID: "), > > m_strMimeReceived.find( "\n", pos)); > temppos = m_strMimeContentID.find( "\r\n"); > m_strMimeContentID = m_strMimeContentID.substr( 0, temppos); > } > // Look for mime root body's content location > if( (pos = m_strMimeReceived.find( "Content-Location: ")) != > std::string::npos) > { > m_strMimeContentLocation = atoi( m_strMimeReceived.substr( pos > + strlen( "Content-Location: "), > > m_strMimeReceived.find( > "\n", pos)).c_str()); > temppos = m_strMimeContentLocation.find( "\r\n"); > m_strMimeContentLocation = m_strMimeContentLocation.substr( 0, > temppos); > } > } > void HTTPTransport::processMimeBody () > { > } > void HTTPTransport::getAttachment( char * pStrAttachment, int * pIntSize, int > intAttachmentId) > { > m_pszRxBuffer [0] = '\0'; > *m_pActiveChannel >> m_pszRxBuffer; > m_strMimeReceived += m_pszRxBuffer; > do > { > if( m_strMimeReceived.find( "\r\n\r\n") == std::string::npos) > { > m_pszRxBuffer [0] = '\0'; > *m_pActiveChannel >> m_pszRxBuffer; > m_strMimeReceived += m_pszRxBuffer; > } > } while( m_strMimeReceived.find( "\r\n\r\n") == std::string::npos); > //now we have found the end of next mime header > processMimeHeader(); > m_strMimeReceived = m_strMimeReceived.substr( m_strMimeReceived.find( > "\r\n\r\n")); > processMimeBody(); > } > void HTTPTransport::setSocket( unsigned int uiNewSocket) > { > m_pActiveChannel->setSocket( uiNewSocket); > } > const char * HTTPTransport::getTransportProperty( const char * pcKey) throw > (HTTPTransportException) > { > std::string strKeyToFind = std::string( pcKey); > for( unsigned int i = 0; i < m_vResponseHTTPHeaders.size(); i++) > { > if( m_vResponseHTTPHeaders[i].first == strKeyToFind) > { > return ((string) > m_vResponseHTTPHeaders[i].second).c_str(); > } > } > return NULL; > } > const char * HTTPTransport::getFirstTransportPropertyKey() > { > m_viCurrentHeader = m_vHTTPHeaders.begin (); > if( m_viCurrentHeader == m_vHTTPHeaders.end()) > { > return NULL; > } > else > { > return (*m_viCurrentHeader).first.c_str(); > } > } > const char * HTTPTransport::getNextTransportPropertyKey() > { > //already at the end? > if( m_viCurrentHeader == m_vHTTPHeaders.end()) > { > return NULL; > } > m_viCurrentHeader++; > if( m_viCurrentHeader == m_vHTTPHeaders.end()) > { > return NULL; > } > else > { > return (*m_viCurrentHeader).first.c_str(); > } > } > const char * HTTPTransport::getCurrentTransportPropertyKey() > { > if( m_viCurrentHeader == m_vHTTPHeaders.end()) > { > return NULL; > } > else > { > return (*m_viCurrentHeader).first.c_str(); > } > } > const char * HTTPTransport::getCurrentTransportPropertyValue() > { > if( m_viCurrentHeader == m_vHTTPHeaders.end()) > { > return NULL; > } > else > { > return (*m_viCurrentHeader).second.c_str(); > } > } > void HTTPTransport::deleteCurrentTransportProperty() > { > if( m_viCurrentHeader != m_vHTTPHeaders.end()) > { > m_vHTTPHeaders.erase( m_viCurrentHeader); > } > } > void HTTPTransport::deleteTransportProperty (char *pcKey, unsigned int > uiOccurance) > { > vector < std::pair < std::string, > std::string > >::iterator currentHeader = m_vHTTPHeaders.begin(); > unsigned int uiCount = 1; > while( currentHeader != m_vHTTPHeaders.end() && uiCount <= uiOccurance) > { > if( strcmp( pcKey, (*currentHeader).first.c_str()) == 0) > { > if( uiCount == uiOccurance) > { > m_vHTTPHeaders.erase( currentHeader); > break; > } > > uiCount++; > } > > currentHeader++; > } > } > void HTTPTransport::setMaintainSession( bool bSession) > { > m_bMaintainSession = bSession; > } > void HTTPTransport::setSessionId( const char * pcSessionId) > { > m_strSessionKey = std::string (pcSessionId); > } > const char * HTTPTransport::getSessionId() > { > return m_strSessionKey.c_str(); > } -- This message is automatically generated by JIRA. - If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa - If you want more information on JIRA, or have a bug to report see: http://www.atlassian.com/software/jira