src/probe.cc

   1 ///
   2 /// \file       probe.cc
   3 ///             USB Blackberry detection routines
   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 "common.h"
  23 #include "probe.h"
  24 #include "usbwrap.h"
  25 #include "data.h"
  26 #include "error.h"
  27 #include "debug.h"
  28 #include <iomanip>
  29
  30 using namespace Usb;
  31
  32 namespace Barry {
  33
  34 unsigned char Intro_Sends[][32] = {
  35         // packet #1
  36         { 0x00, 0x00, 0x10, 0x00, 0x01, 0xff, 0x00, 0x00,
  37           0xa8, 0x18, 0xda, 0x8d, 0x6c, 0x02, 0x00, 0x00 },
  38
  39         // packet #2
  40         { 0x00, 0x00, 0x0c, 0x00, 0x05, 0xff, 0x00, 0x01,
  41           0x14, 0x00, 0x01, 0x00 },
  42
  43         // packet #3
  44         { 0x00, 0x00, 0x0c, 0x00, 0x05, 0xff, 0x00, 0x02,
  45           0x08, 0x00, 0x04, 0x00 }
  46 };
  47
  48
  49 unsigned char Intro_Receives[][32] = {
  50         // response to packet #1
  51         { 0x00, 0x00, 0x10, 0x00, 0x02, 0xff, 0x00, 0x00,
  52           0xa8, 0x18, 0xda, 0x8d, 0x6c, 0x02, 0x00, 0x00 },
  53
  54         // response to packet #2
  55         { 0x00, 0x00, 0x20, 0x00, 0x06, 0xff, 0x00, 0x01,
  56           0x14, 0x00, 0x01, 0x00, 0x51, 0xe1, 0x33, 0x6b,
  57           0xf3, 0x09, 0xbc, 0x37, 0x3b, 0xa3, 0x5e, 0xed,
  58           0xff, 0x30, 0xa1, 0x3a, 0x60, 0xc9, 0x81, 0x8e },
  59
  60         { 0x00, 0x00, 0x14, 0x00, 0x06, 0xff, 0x00, 0x02,
  61           0x08, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00,
  62           0xe3, 0xef, 0x09, 0x30 }
  63 };
  64
  65 namespace {
  66
  67         unsigned int GetSize(const unsigned char *packet)
  68         {
  69                 return *((uint16_t *)&packet[2]);
  70         }
  71
  72         bool Intro(int IntroIndex, const EndpointPair &ep, Device &dev, Data &response)
  73         {
  74                 IO rd = dev.ABulkRead(ep.read, response);
  75                 IO wr = dev.ABulkWrite(ep.write, Intro_Sends[IntroIndex],
  76                         GetSize(Intro_Sends[IntroIndex]));
  77
  78                 rd.Wait();
  79                 wr.Wait();
  80
  81                 response.ReleaseBuffer(rd.GetStatus() >= 0 ? rd.GetSize() : 0);
  82                 return rd.GetStatus() >= 0;
  83         }
  84
  85 } // anonymous namespace
  86
  87
  88 bool Probe::Parse(const Data &data, ProbeResult &result)
  89 {
  90         // validate response data
  91         const unsigned char *pd = data.GetData();
  92         if( GetSize(pd) != (unsigned int) data.GetSize() ||
  93             data.GetSize() < 0x14 ||
  94             pd[4] != 0x06 )
  95         {
  96                 return false;
  97 //              throw BError("Probe: Unexpected reponse data in parse");
  98         }
  99
 100         // capture the PIN
 101         result.m_pin = *((uint32_t *) &pd[16]);
 102         return true;
 103 }
 104
 105 Probe::Probe()
 106 {
 107         Match match(VENDOR_RIM, PRODUCT_RIM_BLACKBERRY);
 108
 109         libusb_device_id_t devid;
 110         while( match.next_device(&devid) ) {
 111
 112                 // skip if we can't properly discover device config
 113                 DeviceDiscovery discover(devid);
 114                 EndpointDiscovery &ed = discover.configs[BLACKBERRY_CONFIGURATION]
 115                         .interfaces[BLACKBERRY_INTERFACE]
 116                         .endpoints;
 117                 if( !ed.IsValid() || ed.GetEndpointPairs().size() == 0 )
 118                         continue;
 119
 120
 121                 ProbeResult result;
 122                 result.m_dev = devid;
 123
 124                 // find the first bulk read/write endpoint pair that answers
 125                 // to our probe commands
 126                 // Search in reverse, since evidence indicates the last pairs
 127                 // are the ones we need.
 128                 for(size_t i = ed.GetEndpointPairs().size(); i; i-- ) {
 129                         const EndpointPair &ep = ed.GetEndpointPairs()[i-1];
 130                         if( ep.type == USB_ENDPOINT_TYPE_BULK ) {
 131                                 result.m_ep = ep;
 132
 133                                 Device dev(devid);
 134                                 dev.Reset();
 135                                 sleep(5);
 136
 137                                 if( !dev.SetConfiguration(BLACKBERRY_CONFIGURATION) )
 138                                         throw BError(dev.GetLastError(),
 139                                                 "Probe: SetConfiguration failed");
 140
 141                                 Interface iface(dev, BLACKBERRY_INTERFACE);
 142
 143                                 Data data;
 144                                 if( Intro(0, ep, dev, data) && Intro(1, ep, dev, data) &&
 145                                     Intro(2, ep, dev, data) && Parse(data, result) )
 146                                 {
 147                                         // all info obtained, add to list
 148                                         m_results.push_back(result);
 149                                         ddout("Using ReadEndpoint: " << (unsigned int)result.m_ep.read);
 150                                         ddout("      WriteEndpoint: " << (unsigned int)result.m_ep.write);
 151                                         break;
 152                                 }
 153                         }
 154                 }
 155
 156                 if( !result.m_ep.IsComplete() )
 157                         ddout("Unable to discover endpoint pair for one device.");
 158         }
 159 }
 160
 161 int Probe::FindActive(uint32_t pin) const
 162 {
 163         for( int i = 0; i < GetCount(); i++ ) {
 164                 if( Get(i).m_pin == pin )
 165                         return i;
 166         }
 167         if( pin == 0 ) {
 168                 // can we default to a single device?
 169                 if( GetCount() == 1 )
 170                         return 0;       // yes!
 171         }
 172
 173         // PIN not found
 174         return -1;
 175 }
 176
 177 std::ostream& operator<< (std::ostream &os, const ProbeResult &pr)
 178 {
 179         os << "Device ID: " << pr.m_dev << std::setbase(16) << ". PIN: "
 180                 << pr.m_pin;
 181         return os;
 182 }
 183
 184 } // namespace Barry
 185