obex_def.h

Go to the documentation of this file.

/*
 Copyright (c) 2007, Forkbeard team

 All rights reserved.

 Licensed under BSD license. See License.txt
*/

#ifndef __OBEX_DEF_H__
#define __OBEX_DEF_H__

#ifndef __OBEX_PRIVATE_INCLUDE__
#error "This is private interface definition file. Do not include outside obex."
#endif

#include "obex.h"

#include <winsock2.h>
#include <bthdef.h>
#include <Bthsdpdef.h>
#include <BluetoothAPIs.h>

#ifdef __cplusplus
extern "C" {
#endif


#define OBEX_SOCKET_VERSION MAKEWORD( 2, 2 )
#define OBEX_BLUETOOTH_MAX_CHANNEL     32

#define OBEX_MINUMUM_RESPONSE_SIZE      3

#define OBEX_CONNECT_REQ_SIZE   7
#define OBEX_SETPATH_REQ_SIZE   5
#define OBEX_DEFAULT_REQ_SIZE   3

#define OBEX_CONNECT_RES_SIZE   7
#define OBEX_DEFAULT_RES_SIZE   3

#define OBEX_DEFAULT_VERSION 0x10

/* Enumerations */

typedef enum _ObexSessionState
{
    OBEX_SESSION_STATE_UNKNOWN = 0,
    OBEX_SESSION_STATE_UNINITIALIZED = 1,
    OBEX_SESSION_STATE_OPERATING,       
    OBEX_SESSION_STATE_SUSPENDED,       
    OBEX_SESSION_STATE_DISCONNECTED,    
    OBEX_SESSION_STATE_FORCE_DWORD = 0xffffffff,
} ObexSessionState;

/* Structures */

struct _BTConnection
{
    SOCKET      sckt;

    BTH_ADDR    address;

    OBEX_UUID   serviceClass;

    int         port;

    dword       packetSize;
};


struct _ObexSession
{
    BTConnection*       connection;

    ObexSessionState    sessionState;

    word                maximumPacketSize;

    OBEX_UUID           target;

    dword               connectionId;

    AuthenticationResponseFunc  authFunc;
    
    void*                       appData;

    /* Reliable session support  */
    /*
    byte                sequenceNumber;
    SessioId            sessionId;
    Address             clientDeviceAddress;
    Address             serverDeviceAddress;
    Nonce               clientNonce;
    Nonce               serverNonce;
    */
};

typedef struct _HeaderOffsetEntry
{
    ObexPacketHeader    header;

    word                offset;

    word                size;
} HeaderOffsetEntry;

typedef enum _ObexPacketType
{
    OBEX_PACKET_TYPE_UNKNOWN = 0,
    OBEX_PACKET_TYPE_REQUEST = 1,
    OBEX_PACKET_TYPE_RESPONSE,
} ObexPacketType;

struct _ObexPacket
{
    ObexPacketType  type;

    byte            id;

    word            length;

    byte            flags;

    word            headerCount;

    HeaderOffsetEntry*      headers;

    byte*           packetData;
};

typedef struct _ObexDataBuffer
{
    byte*   dataPtr;

    dword   size;

    dword   readOffset;

    int     bufferType; 
} ObexDataBuffer;


/* Functions */


/* Packet functions */

int obexPacketTransfer( BTConnection* connection, ObexPacket *request, ObexPacket **response );

int obexPacketParseResponse( ObexPacket *request, ObexPacket *response );

int obexPacketGetMaximumPacketSize( ObexPacket* packet, word *size );

int obexPacketSetMaximumPacketSize( ObexPacket* packet, word size );

int obexPacketGetVersion( ObexPacket* packet, byte *minor, byte *major );

int obexPacketSetVersion( ObexPacket* packet, byte minor, byte major );

int obexPacketInitialize( ObexPacket* newPacket, ObexPacketOperation operation, byte flags );

int obexPacketAddHeaderOffset( ObexPacket *packet, ObexPacketHeader header, word offset, word size );

word obexPacketGetEmptyPacketSize( ObexPacketOperation operation );

/* Parameter check functions */

BOOL checkPacketHeader( ObexPacket* packet, ObexPacketHeader header, word size );

BOOL exclusiveHeader( ObexPacketHeader header1 , ObexPacketHeader header2 );

BOOL legalPacketHeader( ObexPacketHeader header );

BOOL legalOperationFlag ( ObexPacketOperation operation, byte flags );

BOOL legalPacketOperation( ObexPacketOperation operation );

/* Data buffer functions */

int obexDataBufferRead( ObexDataBuffer* buffer, dword *size, void* data );

int obexDataBufferWrite( ObexDataBuffer* buffer, dword size, void* data );

void MD5(void *dest, void *orig, int len);

/* Debugging functions */
#ifdef _DEBUG

void* _mallocTracked(unsigned int size, char *file, unsigned int line );
void  _freeTracked(void *ptr, char *file, unsigned int line );

#define obexAlloc( size )   _mallocTracked( size, __FILE__, __LINE__ )
#define obexDealloc( ptr )  _freeTracked( ptr, __FILE__, __LINE__ )

void _debugStrOutHex(const char *str, int len);
void _debugStrOut(const char* output);

#else

#define obexAlloc( size ) malloc(size)
#define obexDealloc( ptr )  free(ptr);

#endif

static const word wordToNetworkByteOrder( const word w )
{
    return htons ( w );
}

static const word wordFromNetworkByteOrder( const word w )
{
    return ntohs( w );
}

static const dword dwordToNetworkByteOrder( const dword dw )
{
    return htonl ( dw );
}

static const dword dwordFromNetworkByteOrder( const dword dw )
{
    return ntohl ( dw );
}


#ifdef __cplusplus
"}"
#endif


#endif  // __OBEX_DEF_H__

// End of file  

---