--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingappbase/obexmtms/TObexMTM/obexstub/IrobexStub/IROBEX/OBEX.CPP Thu Dec 17 08:44:11 2009 +0200
@@ -0,0 +1,451 @@
+// Copyright (c) 1997-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:
+// obex_client.cpp [stub]
+// oscarg, September 2003.
+// This is a modified version of Obex.cpp.
+// Modified file for BT/IR OBEX stub
+//
+//
+
+#include <charconv.h>
+//#include "debug.h"
+#include "trans.h"
+#include "obex.h"
+#include "obexutil.h"
+//#include "authentication.h"
+
+
+//
+// class CObex
+//
+
+CObex::CObex()
+ {
+ SetConnectState(EConnIdle);
+ iConnector = NULL;
+ iTransport = NULL;
+ iCallBack = NULL;
+ iChallPassword = NULL;
+ iRespPassword = NULL;
+ iRxChallenge = NULL;
+ iCallBack = NULL;
+ iChallenge = EFalse;
+ iRemoteRealm = NULL;
+ iRemoteUID = NULL;
+ }
+
+void CObex::ConstructL(TObexProtocolInfo& /*aObexProtocolInfoPtr*/)
+ {
+ }
+
+
+
+CObex::~CObex()
+ {
+ DeleteTransport();
+ DeleteConnector();
+ iSocketServ.Close();
+ //delete iAuthEngine;
+ delete iChallPassword;
+ delete iRespPassword;
+ delete iRemoteUID;
+ delete iRemoteRealm;
+ delete iRxChallenge;
+
+ }
+
+EXPORT_C void CObex::RemoteAddr(TSockAddr& /*aAddr*/)
+ {
+ }
+
+EXPORT_C TInt CObex::SetLocalWho(const TDesC8& aInfo)
+/**
+ The local who field is used to identify the local end of the OBEX session
+ when the OBEX connection is made. Set this to a unique value before
+ establishing the connection, if recognition strict peers (i.e. a peer also
+ using this who value) is required.
+**/
+ {
+ if(aInfo.Length())
+ { iLocalInfo.iWho.Copy(aInfo); return KErrNone;}
+ else
+ return KErrArgument;
+ }
+
+void CObex::PrepareChallResponseL(const TDesC& /*aPassword*/)
+ {
+ }
+
+
+
+TInt CObex::GenerateChallenge(TObexPacket& /*aPacket*/)
+ {
+ return KErrNone;
+ }
+
+void CObex::ProcessChallResponseL(const TObexInternalHeader& /*hdr*/)
+ {
+ }
+
+void CObex::ProcessChallengeL(const TObexInternalHeader& /*hdr*/)
+ {
+ }
+
+EXPORT_C void CObex::SetCallBack(MObexAuthChallengeHandler& aCallBack)
+ {
+ iCallBack = &aCallBack;
+ }
+
+void CObex::Process(TObexPacket& /*aPacket*/)
+ {
+ }
+
+void CObex::Error(TInt aError)
+ {
+ OnError(aError);
+ }
+
+void CObex::TransportUp(TObexConnectionInfo& /*aInfo*/)
+ {
+ }
+
+void CObex::TransportDown(TBool /*aForceTransportDeletion*/)
+ {
+ }
+
+void CObex::BringTransportDown()
+ {
+ }
+
+void CObex::NewConnectorL(TObexProtocolInfo& /*aObexProtocolInfoPtr*/)
+ {
+ }
+
+void CObex::DeleteConnector()
+ {
+ delete iConnector;
+ iConnector = NULL;
+ }
+
+void CObex::NewTransportL(TObexConnectionInfo& /*aInfo*/)
+ {
+ }
+
+void CObex::DeleteTransport()
+ {
+ delete iTransport;
+ iTransport = NULL;
+ }
+
+void CObex::SetConnectState(TConnectState aNewState)
+ {
+ iConnectState = aNewState;
+ }
+
+// CObex::TSetPathInfo
+EXPORT_C CObex::TSetPathInfo::TSetPathInfo()
+/**
+@publishedAll
+@released
+*/
+ {
+ iFlags = 0;
+ iConstants = 0;
+ iNamePresent = EFalse;
+ }
+
+EXPORT_C TBool CObex::TSetPathInfo::Parent() const
+/**
+@publishedAll
+@released
+*/
+ {
+ return(iFlags & KObexSetPathParent);
+ }
+
+// CObex
+EXPORT_C TBool CObex::IsConnected() const
+/**
+ Returns @c ETrue if this CObex is connected at an OBEX level, merely having
+ a transport connected does not satisfy this condition. I.e. the two devices
+ must have completed the OBEX connection request/response . All other states
+ return @c EFalse. This will be unreliable if either the server blindly
+ returns the client’s who header (always reporting ETrue), or if neither
+ supply "who" headers (always reporting EFalse).
+
+@publishedAll
+@released
+**/
+ {
+ return(ConnectState() == EConnObex);
+ }
+
+EXPORT_C TBool CObex::IsStrictPeer() const
+/**
+ Returns true if the "who" header specified in the server’s connect response
+ matched that of the client’s connect request, and both had a length greater
+ than 0 (i.e. both specified a "who" field). Undefined if @c IsConnected()
+ == @c EFalse.
+
+@publishedAll
+@released
+**/
+ {
+ return((iLocalInfo.iWho.Length()>0) && (iLocalInfo.iWho==iRemoteInfo.iWho));
+ }
+
+EXPORT_C const TObexConnectInfo& CObex::LocalInfo() const
+/**
+ Use this member to gain access to (and alter, if necessary) the
+ CObex::TConnectInfo structure which will be sent to the OBEX peer as part
+ of the connection process. Only alter the contents of this having read and
+ understood the purpose of the fields, as defined in the OBEX spec. Altering
+ this structure after a connection has been made will have no effect on the
+ current session, but will be used for future connection attempts.
+
+@publishedAll
+@released
+**/
+ {
+ return(iLocalInfo);
+ }
+
+
+EXPORT_C const TObexConnectInfo& CObex::RemoteInfo() const
+/**
+ Use this member to read the details of the remote machine’s connection
+ information, as specified by it in during OBEX connection. This data can
+ not be altered, as this serves no purpose.
+ The content of this structure is undefined when @c IsConnected () == @c
+ EFalse.
+
+@publishedAll
+@released
+**/
+ {
+ return(iRemoteInfo);
+ }
+
+EXPORT_C CObex::TConnectState CObex::ConnectState() const
+ {
+ return (iConnectState);
+ };
+
+
+/**
+@ fn virtual void MObexServerNotify::ErrorIndication (TInt aError) =0;
+This function will be called when some form of OBEX protocol error occurs, the
+passed parameter aError is a standard EPOC error code which describes the
+nature of this error. It is only be called for fatal errors, in that the OBEX
+connection will be brought down and then the error indication passed. Any
+error which does not bring the connection down will not be indicated, for
+example the server issuing a semantically valid, but unrecognised command.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual void MObexServerNotify::TransportUpIndication () =0;
+Called when the underlying socket transport connection is made from a remote
+client to the server. Note that this does not, however, indicate an OBEX
+connection has been successfully established. Define any low-level connection
+policy here. Also a good place to set up the LocalConnectInfo, if any
+non-defaults are required.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual void MObexServerNotify::TransportDownIndication () =0;
+Override this to provide processing when the transport connection is dropped
+(by either party), whether the OBEX connection was gracefully disconnected or
+not. This is the definitive place for disconnection processing; it will always
+be called on disconnection.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual TInt MObexServerNotify::ObexConnectIndication (const CObex::TConnectInfo& aRemoteInfo, const TDesC8& aInfo) =0;
+Override this function to provide extra processing when an OBEX connection is
+made from a remote client.
+@param aRemoteInfo holds the connection information supplied by that
+ remote machine.
+@param aInfo holds further information about the requested
+ connection (reserved).
+@return EPOC error indicating the success of the connection.
+
+@publishedAll
+@released
+**/
+
+/** fn virtual void MObexServerNotify::ObexDisconnectIndication (const TDesC8& aInfo) =0;
+Override this to provide extra processing on a (graceful) OBEX disconnection
+by the client.
+@param aInfo Contains information about the disconnection (reserved).
+@note This indication will not be raised if the remote machine simply
+drops the transport connection. However, ErrorIndication () will be called if
+the disconnection is unexpected/ invalid (i.e. another operation was in
+progress at the time). In all cases, TransportDownIndication () will be
+called.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual CObexBaseObject* MObexServerNotify::PutRequestIndication () =0;
+Called on receipt of the first packet of a (valid) put request. It is called
+before any parsing of the packet is performed, simply to establish whether
+this server is interested in receiving objects at all.
+@return a pointer to a CObexBaseObject derived object, which the object
+being put will be parsed into.
+@return NULL ERespForbidden will be returned to the client.
+@note If the returned object cannot be initialised for receiving (e.g. a
+tempory file could not be created for CObexFileObjects)
+ERespInternalError will be returned to the client.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual TInt MObexServerNotify::PutPacketIndication () =0;
+Called on receipt of every packet of an OBEX ‘put’ operation. It will always
+be preceded by a PutRequestIndicatoin(). The object returned by the request
+indication will updated to reflect all the information received concerning the
+object which the client is sending, from packets up to and including the
+current one.
+@return KErrNone instructs the server to allow the client to continue the
+ put operation.
+@return - any other value the operation is cancelled with an
+ appropriate OBEX server response code.
+Use this function to provide periodic user notification on the progress of the
+transfer (noting that the Length attribute may take an arbitrary number of
+packets to become non-zero, and the constraints on its accuracy). Due to the
+nature of OBEX operations, where any header attribute can be sent at any point
+in the transfer, this is also a good place to marshal the details of a
+received object, and possibly prompt for action on the received object (e.g.
+renaming on filename clashes).
+@note It is worth noting that this function could be hit quite heavily, in
+proportion to the size of the object transferred. Therefore more consideration
+should be given to the speed of execution of this function than that of the
+other indications.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual TInt MObexServerNotify::PutCompleteIndication () =0;
+Called after the final put packet has been successfully received and parsed.
+@return KErrNone instructs the remote client that the put completed successfully.
+@return - any other value the operation is cancelled with an
+ appropriate OBEX server response code.
+@note Note that there will not necessarily be a call to this function
+corresponding to each PutRequestIndication; if an error occurs while the put
+is being carried out ErrorIndication will be called instead.
+@since 6.1 Before 6.1, the return type was void.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual CObexBaseObject* MObexServerNotify::GetRequestIndication (CObexBaseObject* aRequestedObject) =0;
+Called when a full get request has been received from the client.
+aRequestedObject holds all the details about the object the remote client has
+requested. Use this function to analyse the clients request, and return a
+pointer to the object to be returned to the client, or NULL to return no
+object. If NULL is returned, the server will send ERespForbidden to the
+client, if an error occurs in returning the object, ERespInternalError is
+returned, otherwise the returned object is sent back to the client.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual TInt MObexServerNotify::GetPacketIndication () =0;
+Called for every packet of get reply sent by the server back to the client.
+That is, it is only called while an object is being sent to the client, not
+while the client is providing its initial specification for the object it
+requires. Return KErrNone to continue sending the object, or some other error
+code to cancel the operation.
+Use this function to provide user notification on the object being sent, and
+its progress. As with PutPacketIndication, it is worth bearing in mind that
+this packet might get called quite heavily, especially for large objects and
+small OBEX packet sizes, so the speed of execution here is important.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual TInt MObexServerNotify::GetCompleteIndication () =0;
+Called when the final packet of the object has been returned to the client.
+@return KErrNone instructs the remote client that the get completed successfully.
+@return - any other value the operation is cancelled with an
+ appropriate OBEX server response code.
+@note Like PutCompleteIndication, this function might not be
+called for each GetRequestIndication, if the operation is interrupted by an
+error.
+@since 6.1 Before 6.1, the return type was void.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual TInt MObexServerNotify::SetPathIndication (const CObex::TSetPathInfo& aPathInfo, const TDesC8& aInfo) =0;
+Indicates a SETPATH command has been received by the server.
+@param aPathInfo Will contain the flags, constants, and
+ name (if present) for this Setpath
+@param aInfo Not currently used: will be == KNullDesC
+
+@return An EPOC error code indicating the success of the setpath.
+
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual void MObexServerNotify::AbortIndication () =0;
+Called when an abort packet is received from the client. An OBEX abort command
+simply cancels the current operation, and does not necessarily have to cause
+the connection to be dropped. On return, a ERespSuccess packet is sent to the
+client.
+
+@publishedAll
+@released
+**/
+
+/** @fn virtual void MObexAuthChallengeHandler::GetUserPasswordL(const TDesC& aRealm) =0;
+Indicates that the server/client has received an Authentication challenge. The challenge
+can only be responded to once a password has been retrieved by some means and passed
+back to the calling class. The password is passed back via
+CObex::UserPasswordL( const TDesC& aPassword)
+@param aRealm this will contain the Realm specified by the unit forcing
+ the Authentication, if no UserID was supplied then this
+ parameter will be of zero length.
+
+@publishedAll
+@released
+**/
+
+
+//
+//
+// DLL entry point
+//
+// The reason code is of no interest here and it is ignored
+//
+
+GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
+ {
+ return KErrNone;
+ }