diff -r 000000000000 -r f5a58ecadc66 servicediscoveryandcontrol/pnp/test/upnp/Server/Flow/inc/httpevent.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/servicediscoveryandcontrol/pnp/test/upnp/Server/Flow/inc/httpevent.h Tue Feb 02 01:12:20 2010 +0200 @@ -0,0 +1,482 @@ +// Copyright (c) 2001-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: +// THTTPEvent.h +// This file contains Rose Model ID comments - please do not delete +// +// + +/** + @file +*/ + +#ifndef __THTTPEVENT_H_ +#define __THTTPEVENT_H_ + +// System includes +#include + +/** +The HTTP UID. This UID is used for all events defined here. +@internalAll +@released +*/ +const TUint KHTTPUid = 0x1000A441; + +/** +Wildcard Matching UID. When specified as part of an event then the UID event +part of the match will be ignored. +@internalAll +@released +*/ +const TUint KHTTPMatchAnyEventUid = 0x1000A44C; + +/** +The base status code for transaction events. Any number above this but below +KSessionEventBaseStatus is a transaction event. +@internalAll +@released +*/ +const TInt KTransactionEventBaseStatus = 0; + +/** +The base status code for transaction warning events. +@internalAll +@released +*/ +const TInt KTransactionWarningBaseStatus = 10000; + +/** +The base status code for session events. Any number above this is a session +event. +@internalAll +@released +*/ +const TInt KSessionEventBaseStatus = 100000; + +/** +The base status code for session warning events. +@internalAll +@released +*/ +const TInt KSessionWarningBaseStatus = 110000; + + +//##ModelId=3C4C18740294 +class THTTPEvent +/** +A HTTP status message. Status messages consist of a UID and a +status code within that UID. Extension dlls that needs to create +new status messages should use their own UID and create status codes +within that UID. +@internalAll +@released +*/ + { +public: + + /** The TStandardEvent type is used to specify a family of event types. Any + negative event number is used to convey error codes. All events are + incoming (originate with the origin server) unless otherwise indicated. + Outgoing messages will not be seen by the MHTTPTransactionCallback's + MHFRunL. + */ + enum TStandardEvent + { + /** Used when registering filter to indicate the filter is instrested + in ALL events, both transaction and session events. + */ + EAll = KRequestPending + 1, + /** Used when registering filters to indicate the filter is interested + in any transaction event, from any direction. + */ + EAnyTransactionEvent = KRequestPending, + /** Used when registering filters to indicate the filter is interested + in any session event. + */ + EAnySessionEvent = KSessionEventBaseStatus + }; + + /** The TTransactionEvents type defines the events that correspond to + transactions. Outgoing events originate from the client or from filters. + The clients do not send these explicitly since the API methods of + RHTTPTransaction do it on their behalf. Incoming events originate from + the protocol handler or from filters, and clients should handle these. + The ESucceeded and EFailed events are mutually exclusive, but one will + always be sent to the client as the final event for a transaction. + */ + enum TTransactionEvent + { + /** The transaction is being submitted. An outgoing event. + */ + ESubmit = KTransactionEventBaseStatus, + /** The transaction is being cancelled. An outgoing event. + */ + ECancel = KTransactionEventBaseStatus + 1, + /** A new part of request body data is available for transmission. An + outgoing event + */ + ENotifyNewRequestBodyPart = KTransactionEventBaseStatus + 2, + /** The transaction is being closed. An outgoing event. + */ + EClosed = KTransactionEventBaseStatus + 3, + /** All the response headers have been received. An incoming event. + */ + EGotResponseHeaders = KTransactionEventBaseStatus + 4, + /** Some (more) body data has been received (in the HTTP response). An + incoming event. + */ + EGotResponseBodyData = KTransactionEventBaseStatus + 5, + /** The transaction's response is complete. An incoming event. + */ + EResponseComplete = KTransactionEventBaseStatus + 6, + /** Some trailer headers have been received. An incoming event. + */ + EGotResponseTrailerHeaders = KTransactionEventBaseStatus + 7, + /** The transaction has succeeded. An incoming event. + */ + ESucceeded = KTransactionEventBaseStatus + 8, + /** The transaction has failed. This is a 'catch-all' for communicating + failures, and more details of the failure should have been notified + in previous messages or status codes. If the client could process + these then it is possible that it should not consider the transaction + a failure. For instance a browser that displays the body of 404 + responses to the user would not consider a 404 response to be a + failure, as it would display it just like a 200 response even though + a 404 will be flagged as a 'failure'. An incoming event. + */ + EFailed = KTransactionEventBaseStatus + 9, + /** Generated from RHTTPTransaction::Fail(). A filter has failed in a + way that prevents it from using the normal event mechanism to inform + the client of the error. This probably means it's run out of memory. + An incoming event. + */ + EUnrecoverableError = KTransactionEventBaseStatus + 10, + /** An event that indicates that there is too much request data to be + sent. The transaction will subsequently be cancelled. An incoming + event. + */ + ETooMuchRequestData = KTransactionEventBaseStatus + 11, + + + /** If the returned status code for a transaciton is either 301, 302 or 307 + and the requested method is NOT a GET or HEAD, then the filter sends the + client an event ERedirectRequiresConfirmation as stated in RFC2616. + + On receiving this event, the transaction is already setup with the redirected URI + and the client is required to make the decision to whether to submit the + transaction or close the transaction. + + If the requested method is GET or HEAD the transaction is automatically + redirected and this event is not used. + */ + ERedirectRequiresConfirmation = KTransactionEventBaseStatus + 12, + + /** A transaction has been specified to use a proxy and the request + requires a tunnel to be establised to the origin server. + */ + ENeedTunnel = KTransactionEventBaseStatus + 13, + + /** The client wishes to view the current cipher suite. + */ + EGetCipherSuite = KTransactionEventBaseStatus + 14, + + /** The transaction's request is complete. An incoming event. + */ + ERequestComplete = KTransactionEventBaseStatus + 15, + + /**An event to signal that 100 Continue response has been received. + */ + EReceived100Continue = KTransactionEventBaseStatus + 16, + + /**An event to cancel the wait for a 100-Continue event. + */ + ECancelWaitFor100Continue = KTransactionEventBaseStatus + 17, + + EGotRequestHeaders = KTransactionEventBaseStatus + 18, + + EGotRequestBodyData = KTransactionEventBaseStatus + 19, + + ECompleteResponse = KTransactionEventBaseStatus + 20, + }; + + /** The TDirection type defines the direction of an event. An outgoing event + originates from the client or from filters. The clients do not send these + explicitly since the API methods of RHTTPTransaction or RHTTPSession do + it on their behalf. Incoming events originate from the protocol handler + or from filters, and clients should handle these. + */ + enum TDirection + { + /** An event originating with the client (e.g. start transaction). + */ + EOutgoing, + /** An event originating with the server (e.g. something received). + */ + EIncoming + }; + + /** The TTransactionWarning type indicates that something in a transaction + may be incorrect but the transaction may continue. It may also indicate + that something (e.g. a filter) may have performed an action that has + changed the transaction and that the client should be informed of this. + */ + enum TTransactionWarning + { + /** An event indicating that the transaction has been redirected and the + original origin server indicated that it was a permanent redirection. + The URI for the transaction is now the redirected location. A + permanent redirection may require further client behavior if the + request came from a stored URI. This is to avoid further redirections + on subsequent requests for this resource. + */ + ERedirectedPermanently = KTransactionWarningBaseStatus, + /** An event indicating that the transaction has been redirected and the + original server indicated that it was a temporary redirection. + */ + ERedirectedTemporarily = KTransactionWarningBaseStatus + 1, + /** An event generated by the Protocol Handler when it receives a Content- + Length value that does not match the actual length of the body data. + */ + EMoreDataReceivedThanExpected = KTransactionWarningBaseStatus + 2 + }; + +public: // Methods + + /** Constructor + @param aStatus The status value. + @param aUID The UID. + */ + //##ModelId=3C4C187402FB + inline THTTPEvent(TInt aStatus, TUint aUID = KHTTPUid); + + /** Constructor (using a standard event and the HTTP UID) + @param aStatus The standard event to use. + */ + //##ModelId=3C4C18740304 + inline THTTPEvent(TStandardEvent aStatus = EAnyTransactionEvent); + + /** Constructor (using a transaction event and the HTTP UID) + @param aStatus The transaction event to use. + */ + //##ModelId=3C4C1874030C + inline THTTPEvent(TTransactionEvent aStatus); + + /** Assigns a standard event code to an event object + @param aStatus The standard event. + @return The HTTP event object. + */ + //##ModelId=3C4C187402EF + inline THTTPEvent& operator=(TStandardEvent aStatus); + + /** Assigns a transaction event code to an event object + @param aStatus The transaction event. + @return The HTTP event object. + */ + //##ModelId=3C4C187402F1 + inline THTTPEvent& operator=(TTransactionEvent aStatus); + + /** Equality operator + @param The HTTP event object to compare. + @return ETrue if the HTTP event objects are equal. + */ + //##ModelId=3C4C187402DA + inline TBool operator==(THTTPEvent aThat) const; + + /** Inequality operator + @param The HTTP event object to compare. + @return ETrue if the HTTP event objects are not equal. + */ + //##ModelId=3C4C187402BD + inline TBool operator!=(THTTPEvent aThat) const; + + /** Equality operator (compares with a standard event) + @param The standard event object to compare. + @return ETrue if the standard event objects are equal. + */ + //##ModelId=3C4C187402DC + inline TBool operator==(TStandardEvent aStatus) const; + + /** Inequality operator (compares with a standard event) + @param The standard event object to compare. + @return ETrue if the standard event objects are not equal. + */ + //##ModelId=3C4C187402C7 + inline TBool operator!=(TStandardEvent aStatus) const; + + /** Equality operator (compares with a transaction event) + @param The transaction event object to compare. + @return ETrue if the transaction event objects are equal. + */ + //##ModelId=3C4C187402E4 + inline TBool operator==(TTransactionEvent aStatus) const; + + /** Inequality operator (compares with a transaction event) + @param The transaction event object to compare. + @return ETrue if the transaction event objects are not equal. + */ + //##ModelId=3C4C187402D0 + inline TBool operator!=(TTransactionEvent aStatus) const; + + /** @return ETrue if the event is a session event + */ + //##ModelId=3C4C187402BC + inline TBool IsSessionEvent() const; + +public: // Attributes + + /** The status value. + */ + //##ModelId=3C4C187402B4 + TInt iStatus; + + /** The UID. + */ + //##ModelId=3C4C187402AA + TUint iUID; + +protected: // Attributes + /** Flag to indicate whether the event is a session event + */ + TBool iIsSessionEventFlag; + + }; + + +class THTTPSessionEvent : public THTTPEvent +/** +A HTTP session status message. Status messages consist of a UID and a +status code within that UID. Extension dlls that needs to create +new status messages should use their own UID and create status codes +within that UID. +@internalAll +@released +*/ + { +public: // Enumerations + /** The TSessionEvents type defines the evenst that correspond to the + of a session entity. Outgoing events originate from the client or from + filters. Incoming events originate from the protocol handler or from + filters, and clients should handle these. + */ + enum TSessionEvent + { + /** A session connection should be initiated. An outgoing event. + */ + EConnect = KSessionEventBaseStatus, + /** The session should be disconnected. An outgoing event. + */ + EDisconnect = KSessionEventBaseStatus + 1, + /** The session has been successfully connected. None of the client + requested capabilities were denied or reduced by the proxy. An + incoming event. + */ + EConnectedOK = KSessionEventBaseStatus + 2, + /** The session has been connected, but with one or more of the client + requested capabilities denied or reduced by the proxy. An incoming + event. + */ + EConnectedWithReducedCapabilities = KSessionEventBaseStatus + 3, + /** The session has been disconnected. This either confirms an earlier + EDisconnect event or indicates a forced disconnection by the proxy. + An incoming event. + */ + EDisconnected = KSessionEventBaseStatus + 4, + /** The authentication handshake succeeded with the automatic validation + of the (proxy) server certificate. + */ + EAuthenticatedOK = KSessionEventBaseStatus + 5, + /** The authentication handshake failed. + */ + EAuthenticationFailure = KSessionEventBaseStatus + 6, + /** The connection attempt to the proxy timed out. + */ + EConnectionTimedOut = KSessionEventBaseStatus + 7 + }; + + /** + HTTP session warning events. + */ + enum TSessionWarning + { + /** The client has requested a transaction event that requires a session + to be connected or the connection to be initiated, but neither is + currently true. The transaction event will be left pending until the + session is connected. An incoming event. + */ + ENotConnected = KSessionWarningBaseStatus, + /** The proxy has sent some information that is not related to a + transaction and has no effect on the state of the session. The + information from the proxy is in the EProxyExceptionInfo property. + */ + EExceptionInfo = KSessionWarningBaseStatus + 1, + /** The client connection request was (permanently) redirected to a new + WAP proxy address. The client should check the EWspProxyAddress + property for the new address. The client's access-point database can + then be updated with this address. No notification is given of a + temporary redirection. + */ + ERedirected = KSessionWarningBaseStatus + 2, + /** The client has requested a session event that is not valid whilst + the WSP session is trying to establish a connection. + */ + EAlreadyConnecting = KSessionWarningBaseStatus + 3, + /** The client has requested a session event that is not valid whilst + the WSP session is in the Connected state. + */ + EAlreadyConnected = KSessionWarningBaseStatus + 4, + /** The client has requested a session event that is not valid whilst + the WSP session is trying to close the connection. + */ + EAlreadyDisconnecting = KSessionWarningBaseStatus + 5, + /** The client has requested a session event that is not valid whilst + the WSP session is in the Null (or disconnected) state. + */ + EAlreadyDisconnected = KSessionWarningBaseStatus + 6 + }; + +public: + /** Constructor + @param aStatus The status value. + @param aUID The UID. + */ + inline THTTPSessionEvent(TInt aStatus, TUint aUID = KHTTPUid); + + /** Constructor (using a standard event and the HTTP UID) + @param aStatus The standard event to use. + */ + inline THTTPSessionEvent(TStandardEvent aStatus = EAnySessionEvent); + + /** Constructor (using a session event and the HTTP UID) + @param aStatus The session event to use. + */ + inline THTTPSessionEvent(TSessionEvent aStatus); + + /** Assigns a session event code to an event object + @param aStatus The session event. + */ + //##ModelId=3C4C187402F9 + inline THTTPSessionEvent& operator=(TSessionEvent aStatus); + + // Equality operator (compares with a session event) + //##ModelId=3C4C187402E6 + inline TBool operator==(TSessionEvent aStatus) const; + + // Inequality operator (compares with a session event) + //##ModelId=3C4C187402D2 + inline TBool operator!=(TSessionEvent aStatus) const; + }; + +#include + +#endif // __THTTPEVENT_H__