// 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;
}