src/controller.cc

   1 ///
   2 /// \file       controller.cc
   3 ///             High level Barry API class
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2010, 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 #include "controller.h"
  23 #include "probe.h"
  24 #include "common.h"
  25 #include "protocol.h"
  26 #include "protostructs.h"
  27 #include "data.h"
  28 #include "endian.h"
  29 #include <string.h>
  30
  31 #define __DEBUG_MODE__
  32 #include "debug.h"
  33
  34 namespace Barry {
  35
  36 //
  37 // Controller constructor
  38 //
  39 /// Constructor for the Controller class.  Requires a valid ProbeResult
  40 /// object to find the USB device to talk to.
  41 ///
  42 /// \param[in]  device          One of the ProbeResult objects from the
  43 ///                             Probe class.
  44 /// \param[in]  default_timeout Override Usb::Device's default timeout
  45 ///
  46 Controller::Controller(const ProbeResult &device,
  47                         int default_timeout)
  48         : m_result(device)
  49         , m_dev(device.m_dev, default_timeout)
  50         , m_iface(0)
  51         , m_pin(device.m_pin)
  52         , m_zero(m_dev, device.m_ep.write, device.m_ep.read, device.m_zeroSocketSequence)
  53         , m_queue(0)
  54 {
  55         dout("Controller: Using non-threaded sockets");
  56         SetupUsb(device);
  57 }
  58
  59 //
  60 // Controller constructor
  61 //
  62 /// Constructor for the Controller class.  Requires a valid ProbeResult
  63 /// object to find the USB device to talk to.
  64 ///
  65 /// \param[in]  device          One of the ProbeResult objects from the
  66 ///                             Probe class.
  67 /// \param[in]  queue           Plugin router object for reading data
  68 ///                             from sockets.
  69 /// \param[in]  default_timeout Override Usb::Device's default timeout
  70 ///
  71 Controller::Controller(const ProbeResult &device,
  72                         SocketRoutingQueue &queue,
  73                         int default_timeout)
  74         : m_result(device)
  75         , m_dev(device.m_dev, default_timeout)
  76         , m_iface(0)
  77         , m_pin(device.m_pin)
  78         , m_zero(queue, device.m_ep.write, device.m_zeroSocketSequence)
  79         , m_queue(&queue)
  80 {
  81         dout("Controller: Using threaded socket router");
  82
  83         SetupUsb(device);
  84
  85         // set the queue to use our device
  86         queue.SetUsbDevice(&m_dev, device.m_ep.write, device.m_ep.read);
  87 }
  88
  89 void Controller::SetupUsb(const ProbeResult &device)
  90 {
  91         unsigned char cfg;
  92         if( !m_dev.GetConfiguration(cfg) )
  93                 throw Usb::Error(m_dev.GetLastError(),
  94                         "Controller: GetConfiguration failed");
  95
  96         if( cfg != BLACKBERRY_CONFIGURATION ) {
  97                 if( !m_dev.SetConfiguration(BLACKBERRY_CONFIGURATION) )
  98                         throw Usb::Error(m_dev.GetLastError(),
  99                                 "Controller: SetConfiguration failed");
 100         }
 101
 102         m_iface = new Usb::Interface(m_dev, device.m_interface);
 103
 104         m_dev.ClearHalt(device.m_ep.read);
 105         m_dev.ClearHalt(device.m_ep.write);
 106 }
 107
 108 Controller::~Controller()
 109 {
 110 //      // trap exceptions in the destructor
 111 //      try {
 112 //              // a non-default socket has been opened, close it
 113 //              m_socket.Close();
 114 //      }
 115 //      catch( std::runtime_error &re ) {
 116 //              // do nothing... log it?
 117 //              dout("Exception caught in ~Socket: " << re.what());
 118 //      }
 119
 120         // detach the router from our device
 121         if( m_queue ) {
 122                 m_queue->ClearUsbDevice();
 123                 m_queue = 0;
 124         }
 125
 126         // cleanup the interface
 127         delete m_iface;
 128
 129         // this happens when for some reason the Desktop mode
 130         // is not fully opened, but the device has already recommended
 131         // a socket to open... in this case, reset the device
 132         // in the hopes that on next open, it will be in a
 133         // recognizable state.
 134         //
 135         // FIXME - this should not be necessary, and someday we
 136         // we should figure out how to handle the "already open"
 137         // response we get for the Desktop
 138         //
 139         // FIXME - halfOpen now seems to be handled in the Socket class...
 140         // perhaps move this there if needed
 141         //
 142 /*
 143         if( m_halfOpen ) {
 144                 dout("Controller object destroyed in halfopen state, resetting device");
 145                 m_dev.Reset();
 146         }
 147 */
 148 }
 149
 150 ///////////////////////////////////////////////////////////////////////////////
 151 // protected members
 152
 153 //
 154 // Tells device which mode is desired, and returns the suggested
 155 // socket ID to use for that mode.
 156 //
 157 uint16_t Controller::SelectMode(ModeType mode)
 158 {
 159         return SelectMode(mode, NULL);
 160 }
 161 //
 162 // Tells device which mode is desired, and returns the suggested
 163 // socket ID to use for that mode.
 164 //
 165 // If explicitModeName is not NULL then it will be used as the mode name.
 166 // Otherwise the default mode name for the given mode will be used.
 167 // It should be a nul terminated string if it is provided.
 168 //
 169 // The RawChannel mode requires an explicitModeName to be specified.
 170 //
 171 uint16_t Controller::SelectMode(ModeType mode, const char *explicitModeName)
 172 {
 173         // select mode
 174         Protocol::Packet packet;
 175         packet.socket = 0;
 176         packet.size = htobs(SB_MODE_PACKET_COMMAND_SIZE);
 177         packet.command = SB_COMMAND_SELECT_MODE;
 178         packet.u.socket.socket = htobs(SB_MODE_REQUEST_SOCKET);
 179         packet.u.socket.sequence = 0; // updated by Socket::Send()
 180         memset(packet.u.socket.u.mode.name, 0, sizeof(packet.u.socket.u.mode.name));
 181
 182         char *modeName = (char *) packet.u.socket.u.mode.name;
 183
 184         if( explicitModeName ) {
 185                 if( strlen(explicitModeName) >= sizeof(packet.u.socket.u.mode.name) ) {
 186                         throw std::logic_error("Controller: explicit mode name too long");
 187                 }
 188                 strcpy(modeName, explicitModeName);
 189         }
 190         else {
 191                 // No modeName given, use the default
 192                 switch( mode )
 193                 {
 194                 case Bypass:
 195                         strcpy(modeName, "RIM Bypass");
 196                         break;
 197
 198                 case Desktop:
 199                         strcpy(modeName, "RIM Desktop");
 200                         break;
 201
 202                 case JavaLoader:
 203                         strcpy(modeName, "RIM_JavaLoader");
 204                         break;
 205
 206                 case JVMDebug:
 207                         strcpy(modeName, "RIM_JVMDebug");
 208                         break;
 209
 210                 case UsbSerData:
 211                         strcpy(modeName, "RIM_UsbSerData");
 212                         break;
 213
 214                 case UsbSerCtrl:
 215                         strcpy(modeName, "RIM_UsbSerCtrl");
 216                         break;
 217
 218                 case RawChannel:
 219                         throw std::logic_error("Controller: No channel name given with RawChannel mode");
 220                         break;
 221
 222                 default:
 223                         throw std::logic_error("Controller: Invalid mode in SelectMode");
 224                         break;
 225                 }
 226         }
 227
 228         // send mode command before we open, as a default socket is socket 0
 229         Data command(&packet, btohs(packet.size));
 230         Data response;
 231
 232         try {
 233                 m_zero.Send(command, response);
 234
 235                 // get the data socket number
 236                 // indicates the socket number that
 237                 // should be used below in the Open() call
 238                 MAKE_PACKET(modepack, response);
 239                 if( modepack->command == SB_COMMAND_MODE_NOT_SELECTED ) {
 240                         throw Error("Controller: requested mode not supported");
 241                 }
 242                 if( modepack->command != SB_COMMAND_MODE_SELECTED ) {
 243                         eeout(command, response);
 244                         throw Error("Controller: mode not selected");
 245                 }
 246
 247                 if( mode == Desktop ) {
 248                         // On the BlackBerry Storm, I have to read a packet
 249                         // after opening a socket. (only for Desktop mode)
 250                         // Otherwise, barrybackup and opensync-plugin can crash (timeout)
 251                         // I don't know why ! Maybe a bug on the handheld.
 252                         m_zero.HideSequencePacket(false);
 253                         m_zero.Receive(response);
 254                         m_zero.HideSequencePacket(true);
 255                 }
 256                 // return the socket that the device is expecting us to use
 257                 return btohs(modepack->u.socket.socket);
 258         }
 259         catch( Usb::Error & ) {
 260                 eout("Controller: error setting desktop mode");
 261                 eeout(command, response);
 262                 throw;
 263         }
 264 }
 265
 266
 267 ///////////////////////////////////////////////////////////////////////////////
 268 // public API
 269
 270
 271 } // namespace Barry
 272