diff -r 000000000000 -r f5a58ecadc66 servicediscoveryandcontrol/pnp/test/upnp/upnpmessage/inc/rhttpmessagecomposer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/servicediscoveryandcontrol/pnp/test/upnp/upnpmessage/inc/rhttpmessagecomposer.h Tue Feb 02 01:12:20 2010 +0200 @@ -0,0 +1,172 @@ +// Copyright (c) 2008-2009 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: +// + +#ifndef __RHTTPMESSAGECOMPOSER_H__ +#define __RHTTPMESSAGECOMPOSER_H__ + +#include + +class CHttpMessageComposer; +class MHttpMessageComposerObserver; + +class RHttpMessageComposer +/** +The RHttpMessageComposer class provides functionality for creating HTTP/1.1 +messages as defined in RFC2616. The HTTP/1.1 protocol specifies that the CR +LF sequence is the end of line (eol) marker for all protocol elements except +the entity-body. + +The composer does not process any header fields or start-line tokens. +Therefore it needs to be told if headers and/or an entity body is expected. +If the message does contain an entity body and the body data is streamed the +composer will apply the chunked transfer encoding to the entity body. + +The composer needs an observer (MHttpMessageComposerObserver). The observer +supplies the message info such as the start-line tokens, header field tokens +and other message info. An MHTTPDataSupplier object is used to supply the +entity body data if there is one. The observer must ensure that the +descriptors containing the tokens it supplies remain valid until the composer +notifies it that the message is complete. + +The composer is initially in the Idle state waiting to be notified of +available message info. When it is notified, the composer moves into the +CreatingStartLine state. + +In the CreatingStartLine state the composer obtains the start-line tokens +from the observer. These are added to the current data buffer. The composer +asks its observer if the message has any headers. If there are headers the +composer moves to the CreatingHeaders state otherwise it moves to the +CreatingEndOfHeaders state. + +In the CreatingHeaders state the composer adds header fields to the current +data buffer. The observer provides the header field tokens for the field name +and field value. The composer will not fold header field values onto multiple +lines unless the provided field token already contains folded field values. +The observer also informs the composer if the provided field info is for the +last header field. If this is the case the composer moves into the +CreatingEndOfHeaders state, otherwise it remains in the CreatingHeaders state. + +In the CreatingEndOfHeaders state the composer adds an empty line to the +current data buffer to mark the end of the header fields section. The current +data buffer is ready to be sent and the composer informs its observer of this. +The composer moves into the PendingEntityBody and waits for the observer to +notify it that it has finished with the current data buffer. + +In the PendingEntityBody state the releases the current data buffer. It then +asks its observer if the message has an entity body. If there is no entity +body or if it is zero length then the composer moves to PendingIdle state. +If there is an entity body and the size is known the composer moves to the +SendEntityData state. If the entity body size is unknown, implying streamed +entity body data, the composer moves to the CreatingChunkSize state. + +In the SendEntityBody state the composer gets the next entity body data part +from the data supplier for the entity body. It sets this data as the current +send buffer and notifies the observer that message data is ready. A check is +made to see that if the data supplier claims that this is the last data part +that all the specified amount of entity body data has been sent. If this is +not true the observer will receive an error code of KErrCorrupt. The composer +moves to PendingReleaseData state and waits for the observer to notify it +that it has finished with the current data buffer. + +In the PendingReleaseData state the composer notifies the entity body data +supplier that it has finished with the current data part. If all the +specified entity body data has been sent the composer moves to the +PendingIdle state. If there is more entity body data to send the composer +moves to the SendEntityData and waits for the observer to notify it that +there is more message info available. + +In the CreatingChunkSize state the composer adds the size of the following +chunk-data component to the current send buffer as defined in RFC2616 +section 3.6.1. The send buffer wil contain the empty line delimiting the +previous chunk-data component if this is not the first chunk-size component +to be sent. The composer notifies its observer that message data is ready. +The composer moves into the SendChunkData state and waits for the observer +to notify it that it has finished with the current data buffer. + +If the chunk-data is zero-length then the chunk-size component is not added +to the send buffer. + +In the SendChunkData state the composer releases the current data buffer. It +then gets the chunk-data from the data supplier for the entity body. It sets +this data as the current buffer. The observer is only notified that message +data is ready if the chunk-data is not zer-length. The composer moves into +the PendingReleaseChunk state and waits for the observer to notify it that +it has finished with the current data buffer. + +In the PendingReleaseChunk state the composer notifies the entity body data +supplier that it has finished with the current data part. If that was the +last part of the entity body data the composer adds the last-chunk component +to the current data buffer. It then asks the observer if the message has any +trailer headers. If there are trailer headers then the composer moves to the +CreatingTrailers state. Otherwise the composer moves to the +CreatingEndOfTrailers state. + +If there is more entity body data to follow the composer moves to the +CreatingChunkSize state and waits for the observer to notify it that there is +more message info available. + +In the CreatingTrailers state the composer adds trailer header fields to the +current data buffer. The observer provides the trailer header field tokens +for the field name and field value. The composer will not fold header field +values onto multiple lines unless the provided field token already contains +folded field values. The observer also informs the composer if the provided +field info is for the last trailer header field. If this is the case the +composer moves into the CreatingEndOfTrailers state, otherwise it remains in +the CreatingTrailers state. + +In the CreatingEndOfTrailers state the composer adds an empty line to the +current data buffer to mark the end of the trailer header fields section. +The current data buffer is ready to be sent and the composer informs its +bserver of this. The composer moves into the PendingEndOfChunkedBody and +waits for the observer to notify it that it has finished with the current +data buffer. + +In the PendingEndOfChunkedBody the composer releases the current data buffer +and moves into the PendingIdle state. + +In the PendingIdle state the composer informs its observer that the message +is complete. The composer moves to the Idle state. +@see MHttpMessageComposerObserver +*/ + { +public: // methods + + inline RHttpMessageComposer(); + + IMPORT_C void OpenL(MHttpMessageComposerObserver& aObserver); + IMPORT_C void Close(); + IMPORT_C void MessageInfoAvailable(); + IMPORT_C void GetMessageData(TPtrC8& aData); + IMPORT_C void ReleaseMessageData(); + IMPORT_C void Reset(); + IMPORT_C TBool CheckMessagePendingComplete(); + +private: // methods + + IMPORT_C void Reserved_RHttpMessageComposer(); + +private: // attributes + + CHttpMessageComposer* iImplementation; + + }; + +inline RHttpMessageComposer::RHttpMessageComposer() +: iImplementation(NULL) + { + } + +#endif // __RHTTPMESSAGECOMPOSER_H__ +