src/socket.cc

   1 ///
   2 /// \file       socket.cc
   3 ///             Class wrapper to encapsulate the Blackberry USB logical socket
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2006, 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 "socket.h"
  23 #include "usbwrap.h"
  24 #include "protocol.h"
  25 #include "protostructs.h"
  26 #include "debug.h"
  27 #include "data.h"
  28 #include "error.h"
  29 #include "packet.h"
  30
  31
  32 using namespace Usb;
  33
  34
  35 namespace Barry {
  36
  37 Socket::Socket(Device &dev, int writeEndpoint, int readEndpoint)
  38         : m_dev(dev),
  39         m_writeEp(writeEndpoint),
  40         m_readEp(readEndpoint),
  41         m_socket(0),
  42         m_flag(0),
  43         m_sequenceId(0),
  44         m_lastStatus(0)
  45 {
  46 }
  47
  48 Socket::~Socket()
  49 {
  50         // trap exceptions in the destructor
  51         try {
  52                 // a non-default socket has been opened, close it
  53                 Close();
  54         }
  55         catch( std::runtime_error &re ) {
  56                 // do nothing... log it?
  57                 dout("Exception caught in ~Socket: " << re.what());
  58         }
  59 }
  60
  61 //
  62 // Open
  63 //
  64 /// Open a logical socket on the device.
  65 ///
  66 /// Both the socket number and the flag are based on the response to the
  67 /// SELECT_MODE command.  See Controller::SelectMode() for more info
  68 /// on this.
  69 ///
  70 /// The packet sequence is normal for most socket operations.
  71 ///
  72 ///     - Down: command packet with OPEN_SOCKET
  73 ///     - Up: optional sequence handshake packet
  74 ///     - Up: command response, which repeats the socket and flag data
  75 ///             as confirmation
  76 ///
  77 /// \exception  Barry::BError
  78 ///
  79 void Socket::Open(uint16_t socket, uint8_t flag)
  80 {
  81         if( m_socket != 0 ) {
  82                 // already open
  83                 throw BError("Socket: already open");
  84         }
  85
  86         // build open command
  87         Barry::Protocol::Packet packet;
  88         packet.socket = 0;
  89         packet.size = SB_SOCKET_PACKET_SIZE;
  90         packet.command = SB_COMMAND_OPEN_SOCKET;
  91         packet.u.socket.socket = socket;
  92         packet.u.socket.param = flag;
  93
  94         Data send(&packet, packet.size);
  95         Data receive;
  96         if( !Send(send, receive) ) {
  97                 eeout(send, receive);
  98                 throw BError(GetLastStatus(), "Error opening socket");
  99         }
 100
 101         // starting fresh, reset sequence ID
 102         Protocol::CheckSize(receive);
 103         if( IS_COMMAND(receive, SB_COMMAND_SEQUENCE_HANDSHAKE) ) {
 104                 CheckSequence(receive);
 105
 106                 // still need our ACK
 107                 Receive(receive);
 108         }
 109
 110         Protocol::CheckSize(receive, SB_SOCKET_PACKET_SIZE);
 111         MAKE_PACKET(rpack, receive);
 112         if( rpack->command != SB_COMMAND_OPENED_SOCKET ||
 113             rpack->u.socket.socket != socket ||
 114             rpack->u.socket.param != flag )
 115         {
 116                 eout("Packet:\n" << receive);
 117                 throw BError("Socket: Bad OPENED packet in Open");
 118         }
 119
 120         // success!  save the socket
 121         m_socket = socket;
 122         m_flag = flag;
 123 }
 124
 125 //
 126 // Close
 127 //
 128 /// Closes a non-default socket (i.e. non-zero socket number)
 129 ///
 130 /// The packet sequence is just like Open(), except the command is
 131 /// CLOSE_SOCKET.
 132 ///
 133 /// \exception  Barry::BError
 134 ///
 135 void Socket::Close()
 136 {
 137         if( m_socket != 0 ) {
 138                 // only close non-default sockets
 139
 140                 // build close command
 141                 Barry::Protocol::Packet packet;
 142                 packet.socket = 0;
 143                 packet.size = SB_SOCKET_PACKET_SIZE;
 144                 packet.command = SB_COMMAND_CLOSE_SOCKET;
 145                 packet.u.socket.socket = m_socket;
 146                 packet.u.socket.param = m_flag;
 147
 148                 Data command(&packet, packet.size);
 149                 Data response;
 150                 if( !Send(command, response) ) {
 151                         // reset so this won't be called again
 152                         m_socket = 0;
 153                         m_flag = 0;
 154
 155                         eeout(command, response);
 156                         throw BError(GetLastStatus(), "Error closing socket");
 157                 }
 158
 159                 // starting fresh, reset sequence ID
 160                 Protocol::CheckSize(response);
 161                 if( IS_COMMAND(response, SB_COMMAND_SEQUENCE_HANDSHAKE) ) {
 162                         CheckSequence(response);
 163
 164                         // still need our ACK
 165                         Receive(response);
 166                 }
 167
 168                 Protocol::CheckSize(response, SB_SOCKET_PACKET_SIZE);
 169                 MAKE_PACKET(rpack, response);
 170                 if( rpack->command != SB_COMMAND_CLOSED_SOCKET ||
 171                     rpack->u.socket.socket != m_socket ||
 172                     rpack->u.socket.param != m_flag )
 173                 {
 174                         // reset so this won't be called again
 175                         m_socket = 0;
 176                         m_flag = 0;
 177
 178                         eout("Packet:\n" << response);
 179                         throw BError("Socket: Bad CLOSED packet in Close");
 180                 }
 181
 182                 // and finally, there always seems to be an extra read of
 183                 // an empty packet at the end... just throw it away
 184 //              Receive(response);
 185
 186                 // reset socket and flag
 187                 m_socket = 0;
 188                 m_flag = 0;
 189         }
 190 }
 191
 192 //
 193 // Send
 194 //
 195 /// Sends 'send' data to device, and waits for response, using
 196 /// "read first, write second" order observed in capture.
 197 ///
 198 /// \returns    bool
 199 ///             - true on success
 200 ///             - false on failure, use GetLastStatus() for kernel
 201 ///                     URB error code
 202 ///
 203 bool Socket::Send(const Data &send, Data &receive)
 204 {
 205         // Special case: it seems that sending packets with a size that's an
 206         // exact multiple of 0x40 causes the device to get confused.
 207         //
 208         // To get around that, it is observed in the captures that the size
 209         // is sent in a special 3 byte packet before the real packet.
 210         // Check for this case here.
 211         //
 212         if( (send.GetSize() % 0x40) == 0 ) {
 213                 Protocol::SizePacket packet;
 214                 packet.size = send.GetSize();
 215                 packet.buffer[2] = 0;           // zero the top byte
 216                 Data sizeCommand(&packet, 3);
 217
 218                 m_dev.BulkWrite(m_writeEp, sizeCommand);
 219         }
 220
 221         m_dev.BulkWrite(m_writeEp, send);
 222         m_dev.BulkRead(m_readEp, receive);
 223
 224         // the stable libusb doesn't give us the actual size read,
 225         // so parse the first bit of the packet for the size field
 226         m_lastStatus = m_dev.GetLastError();
 227         receive.ReleaseBuffer(receive.GetBufSize());
 228         unsigned int bufsize = Protocol::GetSize(receive);
 229         if( bufsize < receive.GetBufSize() )
 230                 receive.ReleaseBuffer(bufsize);
 231         return m_lastStatus >= 0;
 232 }
 233
 234 bool Socket::Receive(Data &receive)
 235 {
 236         m_dev.BulkRead(m_readEp, receive);
 237
 238         // the stable libusb doesn't give us the actual size read,
 239         // so parse the first bit of the packet for the size field
 240         m_lastStatus = m_dev.GetLastError();
 241         receive.ReleaseBuffer(receive.GetBufSize());
 242         unsigned int bufsize = Protocol::GetSize(receive);
 243         if( bufsize < receive.GetBufSize() )
 244                 receive.ReleaseBuffer(bufsize);
 245         return m_lastStatus >= 0;
 246 }
 247
 248 // appends fragment to whole... if whole is empty, simply copies, and
 249 // sets command to DATA instead of FRAGMENTED.  Always updates the
 250 // packet size of whole, to reflect the total size
 251 void Socket::AppendFragment(Data &whole, const Data &fragment)
 252 {
 253         if( whole.GetSize() == 0 ) {
 254                 // empty, so just copy
 255                 whole = fragment;
 256         }
 257         else {
 258                 // has some data already, so just append
 259                 int size = whole.GetSize();
 260                 unsigned char *buf = whole.GetBuffer(size + fragment.GetSize());
 261                 MAKE_PACKET(fpack, fragment);
 262                 int fragsize = fragment.GetSize() - SB_FRAG_HEADER_SIZE;
 263
 264                 memcpy(buf+size, &fpack->u.db.u.fragment, fragsize);
 265                 whole.ReleaseBuffer(size + fragsize);
 266         }
 267
 268         // update whole's size and command type for future sanity
 269         Barry::Protocol::Packet *wpack = (Barry::Protocol::Packet *) whole.GetBuffer();
 270         wpack->size = (uint16_t) whole.GetSize();
 271         wpack->command = SB_COMMAND_DB_DATA;
 272         // don't need to call ReleaseBuffer here, since we're not changing
 273         // the real size size
 274 }
 275
 276 // If offset is 0, starts fresh, taking the first fragment packet size chunk
 277 // out of whole and creating a sendable packet in fragment.  Returns the
 278 // next offset if there is still more data, or 0 if finished.
 279 unsigned int Socket::MakeNextFragment(const Data &whole, Data &fragment, unsigned int offset)
 280 {
 281         // sanity check
 282         if( whole.GetSize() < SB_FRAG_HEADER_SIZE ) {
 283                 eout("Whole packet too short to fragment: " << whole.GetSize());
 284                 throw BError("Socket: Whole packet too short to fragment");
 285         }
 286
 287         // calculate size
 288         unsigned int todo = whole.GetSize() - SB_FRAG_HEADER_SIZE - offset;
 289         unsigned int nextOffset = 0;
 290         if( todo > (MAX_PACKET_SIZE - SB_FRAG_HEADER_SIZE) ) {
 291                 todo = MAX_PACKET_SIZE - SB_FRAG_HEADER_SIZE;
 292                 nextOffset = offset + todo;
 293         }
 294
 295         // create fragment header
 296         unsigned char *buf = fragment.GetBuffer(SB_FRAG_HEADER_SIZE + todo);
 297         memcpy(buf, whole.GetData(), SB_FRAG_HEADER_SIZE);
 298
 299         // copy over a fragment size of data
 300         memcpy(buf + SB_FRAG_HEADER_SIZE, whole.GetData() + SB_FRAG_HEADER_SIZE + offset, todo);
 301
 302         // update fragment's size and command type
 303         Barry::Protocol::Packet *wpack = (Barry::Protocol::Packet *) buf;
 304         wpack->size = (uint16_t) (todo + SB_FRAG_HEADER_SIZE);
 305         if( nextOffset )
 306                 wpack->command = SB_COMMAND_DB_FRAGMENTED;
 307         else
 308                 wpack->command = SB_COMMAND_DB_DATA;
 309
 310         // adjust the new fragment size
 311         fragment.ReleaseBuffer(SB_FRAG_HEADER_SIZE + todo);
 312
 313         // return next round
 314         return nextOffset;
 315 }
 316
 317 void Socket::CheckSequence(const Data &seq)
 318 {
 319 //      if( m_socket == 0 ) {
 320 //              // don't do any sequence checking on socket 0
 321 //              return;
 322 //      }
 323
 324         MAKE_PACKET(spack, seq);
 325         if( (unsigned int) seq.GetSize() < SB_SEQUENCE_PACKET_SIZE ) {
 326                 eout("Short sequence packet:\n" << seq);
 327                 throw BError("Socket: invalid sequence packet");
 328         }
 329
 330         // we'll cheat here... if the packet's sequence is 0, we'll
 331         // silently restart, otherwise, fail
 332         uint32_t sequenceId = spack->u.sequence.sequenceId;
 333         if( sequenceId == 0 ) {
 334                 // silently restart (will advance below)
 335                 m_sequenceId = 0;
 336         }
 337         else {
 338                 if( sequenceId != m_sequenceId ) {
 339                         if( m_socket != 0 ) {
 340                                 eout("Socket sequence: " << m_sequenceId
 341                                         << ". Packet sequence: " << sequenceId);
 342                                 throw BError("Socket: out of sequence");
 343                         }
 344                         else {
 345                                 dout("Bad sequence on socket 0: expected: "
 346                                         << msequenceId
 347                                         << ". Packet sequence: " << sequenceId);
 348                         }
 349                 }
 350         }
 351
 352         // advance!
 353         m_sequenceId++;
 354 }
 355
 356 // sends the send packet down to the device, fragmenting if
 357 // necessary, and returns the response in receive, defragmenting
 358 // if needed
 359 // Blocks until response received or timed out in Usb::Device
 360 bool Socket::Packet(const Data &send, Data &receive)
 361 {
 362 /*
 363 // FIXME - this might be a good idea someday, or perhaps provide a wrapper
 364 // function that forces the socket number to the correct current value,
 365 // but putting it here means a copy on every packet.
 366
 367         // force socket to our socket
 368         Data send = sendorig;
 369         Barry::Protocol::Packet *sspack = (Barry::Protocol::Packet *)send.GetBuffer(2);
 370         sspack->socket = GetSocket();
 371 */
 372
 373         MAKE_PACKET(spack, send);
 374         if( send.GetSize() < MIN_PACKET_SIZE ||
 375             (spack->command != SB_COMMAND_DB_DATA &&
 376              spack->command != SB_COMMAND_DB_DONE) )
 377         {
 378                 // we don't do that around here
 379                 throw std::logic_error("Socket: unknown send data in Packet()");
 380         }
 381
 382         Data inFrag;
 383         receive.Zap();
 384
 385         if( send.GetSize() <= MAX_PACKET_SIZE ) {
 386                 // send non-fragmented
 387                 if( !Send(send, inFrag) )
 388                         return false;
 389         }
 390         else {
 391                 // send fragmented
 392                 unsigned int offset = 0;
 393                 Data outFrag;
 394
 395                 do {
 396                         offset = MakeNextFragment(send, outFrag, offset);
 397                         if( !Send(outFrag, inFrag) )
 398                                 return false;
 399
 400                         MAKE_PACKET(rpack, inFrag);
 401                         // only process sequence handshakes... once we
 402                         // get to the last fragment, we fall through to normal
 403                         // processing below
 404                         if( offset && inFrag.GetSize() > 0 ) {
 405
 406                                 Protocol::CheckSize(inFrag);
 407
 408                                 switch( rpack->command )
 409                                 {
 410                                 case SB_COMMAND_SEQUENCE_HANDSHAKE:
 411                                         CheckSequence(inFrag);
 412                                         break;
 413
 414                                 default:
 415                                         eout("Command: " << rpack->command << inFrag);
 416                                         throw BError("Socket: unhandled packet in Packet()");
 417                                         break;
 418                                 }
 419                         }
 420
 421
 422                 } while( offset > 0 );
 423         }
 424
 425         bool done = false, frag = false;
 426         int blankCount = 0;
 427         while( !done ) {
 428                 MAKE_PACKET(rpack, inFrag);
 429
 430                 // check the packet's validity
 431                 if( inFrag.GetSize() > 0 ) {
 432                         blankCount = 0;
 433
 434                         Protocol::CheckSize(inFrag);
 435
 436                         switch( rpack->command )
 437                         {
 438                         case SB_COMMAND_SEQUENCE_HANDSHAKE:
 439                                 CheckSequence(inFrag);
 440                                 break;
 441
 442                         case SB_COMMAND_DB_DATA:
 443                                 if( frag ) {
 444                                         AppendFragment(receive, inFrag);
 445                                 }
 446                                 else {
 447                                         receive = inFrag;
 448                                 }
 449                                 done = true;
 450                                 break;
 451
 452                         case SB_COMMAND_DB_FRAGMENTED:
 453                                 AppendFragment(receive, inFrag);
 454                                 frag = true;
 455                                 break;
 456
 457                         case SB_COMMAND_DB_DONE:
 458                                 receive = inFrag;
 459                                 done = true;
 460                                 break;
 461
 462                         default:
 463                                 eout("Command: " << rpack->command << inFrag);
 464                                 throw BError("Socket: unhandled packet in Packet()");
 465                                 break;
 466                         }
 467                 }
 468                 else {
 469                         blankCount++;
 470                         //std::cerr << "Blank! " << blankCount << std::endl;
 471                         if( blankCount == 10 ) {
 472                                 // only ask for more data on stalled sockets
 473                                 // for so long
 474                                 throw BError("Socket: 10 blank packets received");
 475                         }
 476                 }
 477
 478                 if( !done ) {
 479                         // not done yet, ask for another read
 480                         if( !Receive(inFrag) )
 481                                 return false;
 482                 }
 483         }
 484
 485         return true;
 486 }
 487
 488 bool Socket::Packet(Barry::Packet &packet)
 489 {
 490         return Packet(packet.m_send, packet.m_receive);
 491 }
 492
 493 bool Socket::NextRecord(Data &receive)
 494 {
 495         Barry::Protocol::Packet packet;
 496         packet.socket = GetSocket();
 497         packet.size = 7;
 498         packet.command = SB_COMMAND_DB_DONE;
 499         packet.u.db.tableCmd = 0;
 500         packet.u.db.u.command.operation = 0;
 501
 502         Data command(&packet, packet.size);
 503         return Packet(command, receive);
 504 }
 505
 506
 507 } // namespace Barry
 508