src/socket.h

   1 ///
   2 /// \file       socket.h
   3 ///             Class wrapper to encapsulate the Blackberry USB logical socket
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2008, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #ifndef __BARRY_SOCKET_H__
  23 #define __BARRY_SOCKET_H__
  24
  25 #include "dll.h"
  26 #include <stdint.h>
  27 #include <queue>
  28 #include <memory>
  29 #include "router.h"
  30
  31 // forward declarations
  32 namespace Usb { class Device; }
  33 namespace Barry {
  34         class Data;
  35         class Packet;
  36         class SocketRoutingQueue;
  37 }
  38
  39 namespace Barry {
  40
  41 class Socket;
  42 typedef std::auto_ptr<Socket>   SocketHandle;
  43
  44 class BXEXPORT SocketZero
  45 {
  46         friend class Socket;
  47
  48         Usb::Device *m_dev;
  49         SocketRoutingQueue *m_queue;
  50         int m_writeEp, m_readEp;
  51         uint8_t m_zeroSocketSequence;
  52
  53         uint32_t m_sequenceId;
  54
  55         // half open socket stata, for passwords
  56         bool m_halfOpen;
  57         uint32_t m_challengeSeed;
  58         unsigned int m_remainingTries;
  59
  60 private:
  61         static void AppendFragment(Data &whole, const Data &fragment);
  62         static unsigned int MakeNextFragment(const Data &whole, Data &fragment,
  63                 unsigned int offset = 0);
  64         void CheckSequence(uint16_t socket, const Data &seq);
  65
  66         void SendOpen(uint16_t socket, Data &receive);
  67         void SendPasswordHash(uint16_t socket, const char *password, Data &receive);
  68
  69         // Raw send and receive functions, used for all low level
  70         // communication to the USB level.
  71         void RawSend(Data &send, int timeout = -1);
  72         void RawReceive(Data &receive, int timeout = -1);
  73
  74 protected:
  75         bool SequencePacket(const Data &data);
  76
  77 public:
  78         explicit SocketZero(SocketRoutingQueue &queue, int writeEndpoint,
  79                 uint8_t zeroSocketSequenceStart = 0);
  80         SocketZero(Usb::Device &dev, int writeEndpoint, int readEndpoint,
  81                 uint8_t zeroSocketSequenceStart = 0);
  82         ~SocketZero();
  83
  84         uint8_t GetZeroSocketSequence() const { return m_zeroSocketSequence; }
  85
  86         void SetRoutingQueue(SocketRoutingQueue &queue);
  87         void UnlinkRoutingQueue();
  88
  89         // Send functions for socket 0 only.
  90         // These functions will overwrite:
  91         //     - the zeroSocketSequence byte *inside* the packet
  92         //     - the socket number to 0
  93         //
  94         void Send(Data &send, int timeout = -1);        // send only
  95         void Send(Data &send, Data &receive, int timeout = -1); // send+recv
  96         void Send(Barry::Packet &packet, int timeout = -1);
  97 //      void Receive(Data &receive, int timeout = -1);
  98
  99         // Opens a new socket and returns a Socket object to manage it
 100         SocketHandle Open(uint16_t socket, const char *password = 0);
 101         void Close(Socket &socket);
 102 };
 103
 104
 105 //
 106 // Socket class
 107 //
 108 /// Encapsulates a "logical socket" in the Blackberry USB protocol.
 109 /// By default, provides raw send/receive access, as well as packet
 110 /// writing on socket 0, which is always open.
 111 ///
 112 /// There are Open and Close members to open data sockets which are used
 113 /// to transfer data to and from the device.
 114 ///
 115 /// The destructor will close any non-0 open sockets automatically.
 116 ///
 117 /// Requires an active Usb::Device object to work on.
 118 ///
 119 class BXEXPORT Socket
 120 {
 121         friend class SocketZero;
 122
 123         SocketZero *m_zero;
 124         uint16_t m_socket;
 125         uint8_t m_closeFlag;
 126
 127         bool m_registered;
 128
 129 protected:
 130         void CheckSequence(const Data &seq);
 131         void ForceClosed();
 132
 133         Socket(SocketZero &zero, uint16_t socket, uint8_t closeFlag);
 134
 135 public:
 136         ~Socket();
 137
 138         uint16_t GetSocket() const { return m_socket; }
 139         uint8_t GetCloseFlag() const { return m_closeFlag; }
 140
 141         void Close();
 142
 143         // Send and Receive are available before Open...
 144         // an unopened socket defaults to socket 0, which you need
 145         // in order to set the blackberry mode
 146         // The send function will overwrite the zeroSocketSequence byte
 147         // *inside* the packet, if the current m_socket is 0.
 148         void Send(Data &send, int timeout = -1);        // send only
 149         void Send(Data &send, Data &receive, int timeout = -1); // send+recv
 150         void Send(Barry::Packet &packet, int timeout = -1);
 151         void Receive(Data &receive, int timeout = -1);
 152
 153         // sends the send packet down to the device, fragmenting if
 154         // necessary, and returns the response in receive, defragmenting
 155         // if needed
 156         // Blocks until response received or timed out in Usb::Device
 157         void Packet(Data &send, Data &receive, int timeout = -1);
 158         void Packet(Barry::Packet &packet, int timeout = -1);
 159
 160         // some handy wrappers for the Packet() interface
 161         void NextRecord(Data &receive);
 162
 163         // Register a callback for incoming data from the device.
 164         // This function assumes that this socket is based on a socketZero
 165         // that has a SocketRoutingQueue, otherwise throws logic_error.
 166         void RegisterInterest(SocketRoutingQueue::SocketDataHandler handler, void *context);
 167         void UnregisterInterest();
 168 };
 169
 170
 171 } // namespace Barry
 172
 173 #endif
 174