src/connector.cc

   1 //
   2 // \file        connector.cc
   3 //              Base class interface for handling Mode connections to device
   4 //
   5
   6 /*
   7     Copyright (C) 2011, 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 "connector.h"
  23 #include "router.h"
  24 #include "controller.h"
  25 #include "m_desktop.h"
  26 #include "debug.h"
  27
  28 using namespace std;
  29 using namespace Barry;
  30
  31 namespace Barry {
  32
  33 //////////////////////////////////////////////////////////////////////////////
  34 // Connector base class
  35
  36 // we use a const char *password here because we don't want the
  37 // responsibility of clear its memory... that's the application's job
  38 Connector::Connector(const char *password,
  39                      const std::string &locale,
  40                      Barry::Pin pin)
  41         : m_password(password)
  42         , m_needs_reconnect(false)
  43         , m_ic(locale.c_str())
  44         , m_probe_result(FindDevice(pin))
  45         , m_connect_count(0)
  46         , m_last_disconnect(0)
  47 {
  48 }
  49
  50 Connector::Connector(const char *password,
  51                      const std::string &locale,
  52                      const Barry::ProbeResult &result)
  53         : m_password(password)
  54         , m_needs_reconnect(false)
  55         , m_ic(locale.c_str())
  56         , m_probe_result(result)
  57         , m_connect_count(0)
  58         , m_last_disconnect(0)
  59 {
  60 }
  61
  62 Connector::~Connector()
  63 {
  64 }
  65
  66 Barry::ProbeResult Connector::FindDevice(Barry::Pin pin)
  67 {
  68         Barry::Probe probe;
  69         int i = probe.FindActive(pin);
  70         if( i != -1 )
  71                 return probe.Get(i);
  72         else
  73                 throw Barry::PinNotFound(pin, probe.GetCount());
  74 }
  75
  76 void Connector::ClearPassword()
  77 {
  78         // blank the memory first
  79         size_t len = m_password.size();
  80         while( len ) {
  81                 len--;
  82                 m_password[len] = '0';
  83         }
  84
  85         // free it
  86         m_password.clear();
  87 }
  88
  89 void Connector::SetPassword(const char *password)
  90 {
  91         ClearPassword();
  92         m_password = password;
  93 }
  94
  95 bool Connector::Connect()
  96 {
  97         Disconnect();
  98
  99         bool started = false;
 100         BadPassword bpcopy("", 0, 0);
 101         for(;;) {
 102
 103                 try {
 104                         if( !started ) {
 105                                 started = true;
 106                                 StartConnect(m_password.c_str());
 107                         }
 108                         else {
 109                                 RetryPassword(m_password.c_str());
 110                         }
 111
 112                         FinishConnect();
 113                         m_connect_count++;
 114                         return true;
 115
 116                 }
 117                 catch( BadPassword &bp ) {
 118                         if( bp.out_of_tries() ) {
 119                                 throw;
 120                         }
 121
 122                         bpcopy = bp;
 123
 124                         // fall through to password prompt
 125                 }
 126
 127                 // ask user for device password
 128                 ClearPassword();
 129                 if( !PasswordPrompt(bpcopy, m_password) ) {
 130                         // user wants out
 131                         return false;
 132                 }
 133         }
 134 }
 135
 136 void Connector::Disconnect()
 137 {
 138         m_needs_reconnect = false;
 139         if( !IsDisconnected() ) {
 140                 DoDisconnect();
 141                 m_last_disconnect = time(NULL);
 142         }
 143 }
 144
 145 bool Connector::Reconnect(int total_tries)
 146 {
 147         int tries = 0;
 148
 149         while(1) try {
 150
 151                 tries++;
 152
 153                 Disconnect();
 154
 155                 if( m_connect_count ) {
 156                         // let the device settle... this seems to help prevent
 157                         // the firmware hang, and therefore ultimately speeds
 158                         // up the sync
 159                         if( (time(NULL) - m_last_disconnect) < 2 ) {
 160                                 // don't bother sleeping if 2 seconds have
 161                                 // already passed
 162                                 sleep(1);
 163                         }
 164
 165                         // temporary fix for odd reconnect message...
 166                         // without this probe, the reconnect will often fail on
 167                         // newer Blackberries due to an unexpected close socket
 168                         // message.
 169                         //
 170                         // It is unclear if this is really a message from
 171                         // the device, but until then, we add this probe.
 172                         m_probe_result = FindDevice(m_probe_result.m_pin);
 173                 }
 174
 175                 return Connect();
 176         }
 177         catch( Usb::Timeout & ) {
 178                 if( tries >= total_tries ) {
 179                         throw;
 180                 }
 181                 else {
 182                         dout("Timeout in Connector::Reconnect()... trying again");
 183                 }
 184         }
 185 }
 186
 187 bool Connector::ReconnectForDirtyFlags()
 188 {
 189         if( m_needs_reconnect ) {
 190                 return Reconnect();
 191         }
 192         else {
 193                 return true;
 194         }
 195 }
 196
 197 void Connector::RequireDirtyReconnect()
 198 {
 199         m_needs_reconnect = true;
 200 }
 201
 202
 203 //////////////////////////////////////////////////////////////////////////////
 204 // DesktopConnector class
 205
 206 DesktopConnector::DesktopConnector(const char *password,
 207                                 const std::string &locale,
 208                                 Barry::Pin pin,
 209                                 Barry::SocketRoutingQueue *router,
 210                                 int connect_timeout)
 211         : Connector(password, locale, pin)
 212         , m_router(router)
 213         , m_connect_timeout(connect_timeout)
 214 {
 215 }
 216
 217 DesktopConnector::DesktopConnector(const char *password,
 218                                 const std::string &locale,
 219                                 const Barry::ProbeResult &result,
 220                                 Barry::SocketRoutingQueue *router,
 221                                 int connect_timeout)
 222         : Connector(password, locale, result)
 223         , m_router(router)
 224         , m_connect_timeout(connect_timeout)
 225 {
 226 }
 227
 228 void DesktopConnector::StartConnect(const char *password)
 229 {
 230         // Note that there is a firmware issue that causes the firmware
 231         // to sometimes hang during a connect and it fails to respond
 232         // to a Desktop::Open() call.  To work around this, set the
 233         // timeout to something lower than the usual 30 seconds.
 234         // The default in DesktopConnector is 10 seconds, which should
 235         // be fine.
 236         //
 237         // If this bug triggers, a Timeout exception will be thrown,
 238         // which will be caught by the Reconnect() method, and Reconnect()
 239         // will retry according to the total number of retries it is
 240         // set to do.
 241         //
 242         if( m_router ) {
 243                 m_con.reset( new Barry::Controller(m_probe_result,
 244                                                 *m_router, m_connect_timeout) );
 245         }
 246         else {
 247                 m_con.reset( new Barry::Controller(m_probe_result,
 248                                                 m_connect_timeout) );
 249         }
 250         m_desktop.reset( new Barry::Mode::Desktop(*m_con, m_ic) );
 251         m_desktop->Open(password);
 252 }
 253
 254 void DesktopConnector::RetryPassword(const char *password)
 255 {
 256         m_desktop->RetryPassword(password);
 257 }
 258
 259 void DesktopConnector::FinishConnect()
 260 {
 261 }
 262
 263 void DesktopConnector::DoDisconnect()
 264 {
 265         m_desktop.reset();
 266         m_con.reset();
 267 }
 268
 269 bool DesktopConnector::IsDisconnected()
 270 {
 271         // return true if DoDisconnect can safely be skipped
 272         return !m_con.get() && !m_desktop.get();
 273 }
 274
 275 bool DesktopConnector::IsConnected()
 276 {
 277         if( m_con.get() && m_desktop.get() )
 278                 return true;
 279         return false;
 280 }
 281
 282 }
 283