tools/brawchannel.cc

   1 ///
   2 /// \file       brawchannel.cc
   3 ///
   4 ///
   5
   6 /*
   7     Copyright (C) 2010, RealVNC Ltd.
   8
   9         Some parts are inspired from bjavaloader.cc
  10
  11     This program is free software; you can redistribute it and/or modify
  12     it under the terms of the GNU General Public License as published by
  13     the Free Software Foundation; either version 2 of the License, or
  14     (at your option) any later version.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19
  20     See the GNU General Public License in the COPYING file at the
  21     root directory of this project for more details.
  22 */
  23
  24
  25 #include <barry/barry.h>
  26 #include <iostream>
  27 #include <vector>
  28 #include <string>
  29 #include <cstring>
  30 #include <cstdio>
  31 #include <cstdlib>
  32 #include <algorithm>
  33 #include <getopt.h>
  34 #include <fstream>
  35 #include <string.h>
  36 #include <unistd.h>
  37 #include <sys/types.h>
  38 #include <signal.h>
  39 #include <errno.h>
  40 #include <pthread.h>
  41
  42 #include "i18n.h"
  43
  44 using namespace std;
  45 using namespace Barry;
  46
  47 // How long to wait between reads before checking if should shutdown
  48 #define READ_TIMEOUT_SECONDS 1
  49
  50 static volatile bool signalReceived = false;
  51
  52 static void signalHandler(int signum)
  53 {
  54         signalReceived = true;
  55 }
  56
  57 class Condvar;
  58
  59 // Wrapper for pthread_mutex_t
  60 class Mutex
  61 {
  62 public:
  63         friend class Condvar;
  64         Mutex();
  65         ~Mutex();
  66         void Lock();
  67         void Unlock();
  68 private:
  69         bool m_initialized;
  70         pthread_mutex_t m_mutex;
  71 };
  72
  73 Mutex::Mutex()
  74         : m_initialized(false)
  75 {
  76         int ret = pthread_mutex_init(&m_mutex, NULL);
  77         if (ret != 0)
  78                 throw Barry::Error("Mutex: failed to create mutex");
  79         m_initialized = true;
  80 }
  81
  82 Mutex::~Mutex()
  83 {
  84         if (m_initialized)
  85         {
  86                 int ret = pthread_mutex_destroy(&m_mutex);
  87                 if (ret != 0)
  88                         cerr << "Failed to destroy mutex with error: " << ret << endl;
  89         }
  90 }
  91
  92 void Mutex::Lock()
  93 {
  94         int ret = pthread_mutex_lock(&m_mutex);
  95         if (ret != 0)
  96                 throw Barry::Error("Mutex: failed to lock mutex");
  97 }
  98
  99 void Mutex::Unlock()
 100 {
 101         int ret = pthread_mutex_unlock(&m_mutex);
 102         if (ret != 0)
 103                 throw Barry::Error("Mutex: failed to unlock mutex");
 104 }
 105
 106 // RIAA wrapper for locking Mutex class
 107 class MutexLock
 108 {
 109 public:
 110         MutexLock(Mutex& mutex)
 111                 : m_locked(false),
 112                   m_mutex(mutex)
 113                 { mutex.Lock(); m_locked = true; };
 114         void Unlock()
 115                 {
 116                         if (m_locked)
 117                         {
 118                                 m_mutex.Unlock();
 119                                 m_locked = false;
 120                         }
 121                 }
 122         ~MutexLock() { Unlock(); }
 123 private:
 124         bool m_locked;
 125         Mutex& m_mutex;
 126         };
 127
 128 // Wrapper for pthread_cont_t
 129 class Condvar
 130 {
 131 public:
 132         Condvar();
 133         ~Condvar();
 134         void Wait(Mutex& mutex);
 135         void Signal();
 136 private:
 137         bool m_initialized;
 138         pthread_cond_t m_cv;
 139 };
 140
 141 Condvar::Condvar()
 142         : m_initialized(false)
 143 {
 144         int ret = pthread_cond_init(&m_cv, NULL);
 145         if (ret != 0)
 146                 throw Barry::Error("Condvar: failed to create condvar");
 147         m_initialized = true;
 148 }
 149
 150 Condvar::~Condvar()
 151 {
 152         if (m_initialized)
 153         {
 154                 int ret = pthread_cond_destroy(&m_cv);
 155                 if (ret != 0)
 156                         cerr << "Failed to destroy condvar with error: " << ret << endl;
 157         }
 158 }
 159
 160 void Condvar::Wait(Mutex& mutex)
 161 {
 162         int ret = pthread_cond_wait(&m_cv, &mutex.m_mutex);
 163         if (ret != 0)
 164                 throw Barry::Error("Condvar: failed to wait on condvar");
 165 }
 166
 167 void Condvar::Signal()
 168 {
 169         int ret = pthread_cond_signal(&m_cv);
 170         if (ret != 0)
 171                 throw Barry::Error("Condvar: failed to signal condvar");
 172 }
 173
 174 // Semaphore class for signalling between threads
 175 class Semaphore
 176 {
 177 public:
 178         Semaphore(int initialVal = 0);
 179         ~Semaphore();
 180         void WaitForSignal();
 181         void Signal();
 182 private:
 183         int m_value;
 184         Mutex m_mutex;
 185         Condvar m_cv;
 186 };
 187
 188 Semaphore::Semaphore(int initialVal)
 189   : m_value(initialVal),
 190     m_mutex(),
 191     m_cv()
 192 {
 193 }
 194
 195 Semaphore::~Semaphore()
 196 {
 197 }
 198
 199 void Semaphore::WaitForSignal()
 200 {
 201         MutexLock lock(m_mutex);
 202         while (m_value <= 0) {
 203                 m_cv.Wait(m_mutex);
 204         }
 205         --m_value;
 206         lock.Unlock();
 207 }
 208
 209 void Semaphore::Signal()
 210 {
 211         MutexLock lock(m_mutex);
 212         ++m_value;
 213         m_cv.Signal();
 214         lock.Unlock();
 215 }
 216
 217 class StdoutWriter : public Barry::Mode::RawChannelDataCallback
 218 {
 219 public:
 220         StdoutWriter(volatile bool& keepGoing, bool verbose, Semaphore& semaphore)
 221                 : m_continuePtr(&keepGoing),
 222                   m_verbose(verbose),
 223                   m_semaphore(semaphore)
 224                 {
 225                 }
 226
 227
 228 public: // From RawChannelDataCallback
 229         virtual void DataReceived(Data& data);
 230         virtual void DataSendAck();
 231         virtual void ChannelError(string msg);
 232         virtual void ChannelClose();
 233
 234 private:
 235         volatile bool* m_continuePtr;
 236         bool m_verbose;
 237         Semaphore& m_semaphore;
 238 };
 239
 240
 241 void StdoutWriter::DataReceived(Data& data)
 242 {
 243         if (m_verbose) {
 244                 cerr << "From BB: ";
 245                 data.DumpHex(cerr);
 246                 cerr << "\n";
 247         }
 248
 249         size_t toWrite = data.GetSize();
 250         size_t written = 0;
 251
 252         while (written < toWrite && *m_continuePtr) {
 253                 ssize_t writtenThisTime = write(STDOUT_FILENO, &(data.GetData()[written]), toWrite - written);
 254                 if (m_verbose) {
 255                         cerr.setf(ios::dec, ios::basefield);
 256                         cerr << "Written " << writtenThisTime << " bytes over stdout" << endl;
 257                 }
 258                 fflush(stdout);
 259                 if (writtenThisTime < 0)
 260                 {
 261                         ChannelClose();
 262                 }
 263                 else
 264                 {
 265                         written += writtenThisTime;
 266                 }
 267         }
 268 }
 269
 270 void StdoutWriter::DataSendAck()
 271 {
 272         m_semaphore.Signal();
 273 }
 274
 275 void StdoutWriter::ChannelError(string msg)
 276 {
 277         cerr << "StdoutWriter: Received error: " << msg << endl;
 278         ChannelClose();
 279 }
 280
 281 void StdoutWriter::ChannelClose()
 282 {
 283         *m_continuePtr = false;
 284         m_semaphore.Signal();
 285 }
 286
 287 // Class which adds error detection and setting of a continue boolean
 288 // to false when an error is detected to SocketRoutingQueue.
 289 // This code is heavily based on the thread creation code of
 290 // SocketRoutingQueue, which sadly has too many private variables
 291 // to just sub-class.
 292 class ErrorHandlingSocketRoutingQueue
 293 {
 294 public:
 295         ErrorHandlingSocketRoutingQueue(volatile bool& continuePtr, Semaphore& semaphore)
 296                 : m_socketRoutingQueue(),
 297                   m_continuePtr(&continuePtr),
 298                   m_runningThread(false),
 299                   m_semaphore(semaphore)
 300                 {
 301                         // Nothing to do
 302                 }
 303
 304         ~ErrorHandlingSocketRoutingQueue() {
 305                 // Is the read thread still running
 306                 if( m_runningThread ) {
 307                         m_runningThread = false;
 308                         pthread_join(m_usb_read_thread, NULL);
 309                 }
 310         }
 311
 312         // Utility function to make it easier to create the
 313         // USB pure-read thread.
 314         // Throws Barry::ErrnoError on thread creation error.
 315         void SpinoffReadThread() {
 316                 // signal that it's ok to run inside the thread
 317                 if( m_runningThread )
 318                         return; // already running
 319                 m_runningThread = true;
 320
 321                 // Start USB read thread, to handle all routing
 322                 int ret = pthread_create(&m_usb_read_thread, NULL, &ReadThreadFunction, this);
 323                 if (ret) {
 324                         m_runningThread = false;
 325                         throw Barry::ErrnoError("SocketRoutingQueue: Error creating USB read thread.", ret);
 326                 }
 327         }
 328
 329         SocketRoutingQueue* GetSocketRoutingQueue() {
 330                 return &m_socketRoutingQueue;
 331         }
 332
 333 protected:
 334         static void* ReadThreadFunction(void* userPtr) {
 335                 ErrorHandlingSocketRoutingQueue *q = (ErrorHandlingSocketRoutingQueue *)userPtr;
 336
 337                 // read from USB and write to stdout until finished
 338                 string msg;
 339                 while (q->m_runningThread) {
 340                         if( !q->m_socketRoutingQueue.DoRead(msg,  READ_TIMEOUT_SECONDS * 1000) &&
 341                             // Only report the first failure, so check m_continuePtr
 342                                 *q->m_continuePtr) {
 343                                 cerr << "Error in ReadThread: " << msg << endl;
 344                                 *q->m_continuePtr = false;
 345                                 q->m_semaphore.Signal();
 346                         }
 347                 }
 348                 return 0;
 349         }
 350
 351 protected:
 352         SocketRoutingQueue m_socketRoutingQueue;
 353         volatile bool* m_continuePtr;
 354         volatile bool m_runningThread;
 355         pthread_t m_usb_read_thread;
 356         Semaphore& m_semaphore;
 357 };
 358
 359 void Usage()
 360 {
 361         int major, minor;
 362         const char *Version = Barry::Version(major, minor);
 363
 364         cerr
 365                 << "brawchannel - Command line USB Blackberry raw channel interface\n"
 366                 << "        Copyright 2010, RealVNC Ltd.\n"
 367                 << "        Using: " << Version << "\n"
 368                 << "\n"
 369                 << "Usage:\n"
 370                 << "brawchannel [options] <channel name>\n"
 371                 << "\n"
 372                 << "   -h        This help\n"
 373                 << "   -p pin    PIN of device to talk with\n"
 374                 << "             If only one device is plugged in, this flag is optional\n"
 375                 << "   -P pass   Simplistic method to specify device password\n"
 376                 << "   -v        Dump protocol data during operation\n"
 377                 << "             This will cause libusb output to appear on STDOUT unless\n"
 378                 << "             the environment variable USB_DEBUG is set to 0,1 or 2.\n"
 379                 << endl;
 380 }
 381
 382 // Helper class to restore signal handlers when shutdown is occuring
 383 // This class isn't responsible for setting up the signal handlers
 384 // as they need to be restored before the Barry::Socket starts closing.
 385 class SignalRestorer
 386 {
 387 public:
 388         SignalRestorer(int signum, sighandler_t handler)
 389                 : m_signum(signum), m_handler(handler) {}
 390         ~SignalRestorer() { signal(m_signum, m_handler); }
 391 private:
 392         int m_signum;
 393         sighandler_t m_handler;
 394 };
 395
 396 int main(int argc, char *argv[])
 397 {
 398         INIT_I18N(PACKAGE);
 399
 400         // Setup signal handling
 401         sighandler_t oldSigHup = signal(SIGHUP, &signalHandler);
 402         sighandler_t oldSigTerm = signal(SIGTERM, &signalHandler);
 403         sighandler_t oldSigInt = signal(SIGINT, &signalHandler);
 404         sighandler_t oldSigQuit = signal(SIGQUIT, &signalHandler);
 405
 406         cerr.sync_with_stdio(true);     // since libusb uses
 407                                         // stdio for debug messages
 408         unsigned char* buf = NULL;
 409         try {
 410                 uint32_t pin = 0;
 411                 bool data_dump = false;
 412                 string password;
 413                 vector<string> params;
 414                 string busname;
 415                 string devname;
 416                 string iconvCharset;
 417                 Usb::EndpointPair epOverride;
 418
 419                 // process command line options
 420                 for(;;) {
 421                         int cmd = getopt(argc, argv, "hp:P:v");
 422                         if( cmd == -1 )
 423                                 break;
 424
 425                         switch( cmd )
 426                         {
 427                         case 'p':       // Blackberry PIN
 428                                 pin = strtoul(optarg, NULL, 16);
 429                                 break;
 430
 431                         case 'P':       // Device password
 432                                 password = optarg;
 433                                 break;
 434
 435                         case 'v':       // data dump on
 436                                 data_dump = true;
 437                                 break;
 438
 439                         case 'h':       // help
 440                         default:
 441                                 Usage();
 442                         return 0;
 443                         }
 444                 }
 445
 446                 argc -= optind;
 447                 argv += optind;
 448
 449                 if( argc < 1 ) {
 450                         cerr << "Error: Missing raw channel name." << endl;
 451                         Usage();
 452                         return 1;
 453                 }
 454
 455                 // Fetch command from remaining arguments
 456                 string channelName = argv[0];
 457                 argc --;
 458                 argv ++;
 459
 460                 // Put the remaining arguments into an array
 461                 for (; argc > 0; argc --, argv ++) {
 462                         params.push_back(string(argv[0]));
 463                 }
 464
 465                 if (data_dump)
 466                 {
 467                         // Warn if USB_DEBUG isn't set to 0, 1 or 2
 468                         // as that usually means libusb will write to STDOUT
 469                         char* val = getenv("USB_DEBUG");
 470                         int parsedValue = -1;
 471                         if(val)
 472                         {
 473                                 parsedValue = atoi(val);
 474                         }
 475                         if(parsedValue != 0 && parsedValue != 1 && parsedValue != 2)
 476                         {
 477                                 cerr << "Warning: Protocol dump enabled without setting USB_DEBUG to 0, 1 or 2.\n"
 478                                      << "         libusb might log to STDOUT and ruin data stream." << endl;
 479                         }
 480                 }
 481
 482                 // Initialize the barry library.  Must be called before
 483                 // anything else.
 484                 Barry::Init(data_dump, &cerr);
 485
 486                 // Probe the USB bus for Blackberry devices and display.
 487                 // If user has specified a PIN, search for it in the
 488                 // available device list here as well
 489                 Barry::Probe probe;
 490                 int activeDevice = probe.FindActive(pin);
 491                 if( activeDevice == -1 ) {
 492                         cerr << "No device selected, or PIN not found" << endl;
 493                         return 1;
 494                 }
 495
 496                 // Now start to read from stdin and get ready to write
 497                 // to the BlackBerry.
 498                 if (data_dump)
 499                         cerr << "Connected to device, starting read/write\n";
 500
 501                 volatile bool running = true;
 502
 503                 Semaphore sem;
 504
 505                 // Create the thing which will write onto stdout
 506                 StdoutWriter stdoutWriter(running, data_dump, sem);
 507
 508                 // Set up the BlackBerry gubbins
 509                 // Start a thread to handle any data arriving from
 510                 // the BlackBerry.
 511                 auto_ptr<ErrorHandlingSocketRoutingQueue> router;
 512                 router.reset(new ErrorHandlingSocketRoutingQueue(running, sem));
 513                 router->SpinoffReadThread();
 514
 515                 // Create our controller object
 516                 Barry::Controller con(probe.Get(activeDevice), *router->GetSocketRoutingQueue());
 517
 518                 Barry::Mode::RawChannel rawChannel(con, stdoutWriter);
 519
 520                 //
 521                 // execute each mode that was turned on
 522                 //
 523                 rawChannel.Open(password.c_str(), channelName.c_str());
 524
 525                 // We now have a thread running to read from the
 526                 // BB and write over stdout; in this thread we'll
 527                 // read from stdin and write to the BB.
 528                 const size_t bufSize = rawChannel.MaximumSendSize();
 529                 buf = new unsigned char[bufSize];
 530                 fd_set rfds;
 531                 struct timeval tv;
 532                 FD_ZERO(&rfds);
 533
 534                 SignalRestorer srh(SIGHUP, oldSigHup);
 535                 SignalRestorer srt(SIGTERM, oldSigTerm);
 536                 SignalRestorer sri(SIGINT, oldSigInt);
 537                 SignalRestorer srq(SIGQUIT, oldSigQuit);
 538
 539                 while (running && !signalReceived) {
 540                         FD_SET(STDIN_FILENO, &rfds);
 541                         tv.tv_sec = READ_TIMEOUT_SECONDS;
 542                         tv.tv_usec = 0;
 543
 544                         int ret = select(1, &rfds, NULL, NULL, &tv);
 545                         if (ret < 0) {
 546                                 cerr << "Select failed with errno: " << errno << endl;
 547                                 running = false;
 548                         }
 549                         else if (ret && FD_ISSET(STDIN_FILENO, &rfds)) {
 550                                 ssize_t haveRead = read(STDIN_FILENO, buf, bufSize);
 551                                 if (haveRead > 0) {
 552                                         Data toWrite(buf, haveRead);
 553                                         if (data_dump) {
 554                                                 cerr.setf(ios::dec, ios::basefield);
 555                                                 cerr << "Sending " << haveRead << " bytes stdin->USB\n";
 556                                                 cerr << "To BB: ";
 557                                                 toWrite.DumpHex(cerr);
 558                                                 cerr << "\n";
 559                                         }
 560                                         rawChannel.Send(toWrite);
 561                                         if (data_dump) {
 562                                                 cerr.setf(ios::dec, ios::basefield);
 563                                                 cerr << "Sent " << ios::dec << haveRead << " bytes stdin->USB\n";
 564                                         }
 565                                         sem.WaitForSignal();
 566                                 }
 567                                 else if (haveRead < 0) {
 568                                         running = false;
 569                                 }
 570                         }
 571                 }
 572         }
 573         catch( Usb::Error &ue) {
 574                 cerr << "Usb::Error caught: " << ue.what() << endl;
 575                 return 1;
 576         }
 577         catch( Barry::Error &se ) {
 578                 cerr << "Barry::Error caught: " << se.what() << endl;
 579                 return 1;
 580         }
 581         catch( exception &e ) {
 582                 cerr << "exception caught: " << e.what() << endl;
 583                 return 1;
 584         }
 585
 586         delete[] buf;
 587
 588         return 0;
 589 }
 590