src/connector.h

   1 //
   2 // \file        connector.h
   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 #ifndef __BARRY_CONNECT_H__
  23 #define __BARRY_CONNECT_H__
  24
  25 #include "dll.h"
  26 #include "iconv.h"
  27 #include "pin.h"
  28 #include "probe.h"
  29 #include <string>
  30 #include <memory>
  31 #include <time.h>
  32
  33 namespace Barry {
  34
  35 class SocketRoutingQueue;
  36 class Controller;
  37 namespace Mode {
  38         class Desktop;
  39 }
  40
  41 class BXEXPORT Connector
  42 {
  43 protected:
  44         std::string m_password;
  45         bool m_needs_reconnect;
  46         Barry::IConverter m_ic;
  47         Barry::ProbeResult m_probe_result;
  48         int m_connect_count;
  49         time_t m_last_disconnect;
  50
  51 protected:
  52         // helper functions
  53         static Barry::ProbeResult FindDevice(Barry::Pin pin);
  54
  55         // required overrides by derived classes
  56         virtual void StartConnect(const char *password) = 0;
  57         virtual void RetryPassword(const char *password) = 0;
  58         virtual void FinishConnect() = 0;
  59         virtual void DoDisconnect() = 0;
  60         /// slightly different than IsConnected()... this returns true
  61         /// even if there is a partial connection in progress...
  62         /// i.e. this returns true if DoDisconnect() can be safely skipped
  63         virtual bool IsDisconnected() = 0;
  64
  65 public:
  66         Connector(const char *password, const std::string &locale,
  67                 Barry::Pin pin = 0);
  68         Connector(const char *password, const std::string &locale,
  69                 const Barry::ProbeResult &result);
  70         virtual ~Connector();
  71
  72         IConverter& GetIConverter() { return m_ic; }
  73         const IConverter& GetIConverter() const { return m_ic; }
  74         Barry::ProbeResult& GetProbeResult() { return m_probe_result; }
  75         const Barry::ProbeResult& GetProbeResult() const { return m_probe_result; }
  76
  77         virtual void ClearPassword();
  78         virtual void SetPassword(const char *password);
  79
  80         /// Returns true if connected, false if user cancelled, throws
  81         /// Barry exception on error.
  82         virtual bool Connect();
  83
  84         /// Disconnects from the device
  85         virtual void Disconnect();
  86
  87         /// Returns same as Connect(), but normally remembers the password
  88         /// and so avoids prompting the user if possible.  Password prompts
  89         /// are still possible though, if you have called ClearPassword().
  90         ///
  91         /// It is valid to call Reconnect() without ever calling Connect(),
  92         /// since Reconnect() is simply a wrapper that handles retries.
  93         virtual bool Reconnect(int total_tries = 2);
  94
  95         /// Calls Reconnect() (and returns it's result) only if you have
  96         /// called RequireDirtyReconnect().  Otherwise, does nothing, but
  97         /// returns true.
  98         virtual bool ReconnectForDirtyFlags();
  99
 100         /// Returns true if connected, false if not
 101         virtual bool IsConnected() = 0;
 102
 103         /// This function flags the Connector object so that a future
 104         /// call to ReconnectForDirtyFlags() will actually Reconnect().
 105         /// This is needed in cases where you are updating the device,
 106         /// and require that the dirty flags on the device itself are
 107         /// properly cleared and updated.  In this case, you must call
 108         /// ReconnectForDirtyFlags() before Desktop::GetRecordStateTable().
 109         /// Disconnecting from the device, or reconnecting, clears the flag.
 110         virtual void RequireDirtyReconnect();
 111
 112         //
 113         // Callbacks, overridden by the application
 114         //
 115
 116         /// App should prompt user for password, fill password_result with
 117         /// what he enters and then return true.  Return false if user
 118         /// wishes to stop trying.
 119         ///
 120         /// This function is *not* called from inside a catch() routine,
 121         /// so it is safe to throw exceptions from it if you must.
 122         virtual bool PasswordPrompt(const Barry::BadPassword &bp,
 123                                         std::string &password_result) = 0;
 124 };
 125
 126 class BXEXPORT DesktopConnector : public Connector
 127 {
 128         Barry::SocketRoutingQueue *m_router;
 129         std::auto_ptr<Barry::Controller> m_con;
 130         std::auto_ptr<Mode::Desktop> m_desktop;
 131         int m_connect_timeout;
 132
 133 protected:
 134         virtual void StartConnect(const char *password);
 135         virtual void RetryPassword(const char *password);
 136         virtual void FinishConnect();
 137         virtual void DoDisconnect();
 138         virtual bool IsDisconnected();
 139
 140 public:
 141         // Override the timeout due to a firmware issue... sometimes
 142         // the firmware will hang during a Reconnect, and fail to
 143         // respond to a Desktop::Open().  To work around this, we
 144         // set the default timeout to 10 seconds so that we find this
 145         // failure early enough to fix it within opensync's 30 second timeout.
 146         // Then if we get such a timeout, we do the Reconnect again and
 147         // hope for the best... this often fixes it.
 148         //
 149         DesktopConnector(const char *password, const std::string &locale,
 150                 Barry::Pin pin = 0, Barry::SocketRoutingQueue *router = 0,
 151                 int connect_timeout = 10000);
 152
 153         DesktopConnector(const char *password, const std::string &locale,
 154                 const Barry::ProbeResult &result,
 155                 Barry::SocketRoutingQueue *router = 0,
 156                 int connect_timeout = 10000);
 157
 158         virtual bool IsConnected();
 159
 160         virtual bool PasswordPrompt(const Barry::BadPassword &bp,
 161                                         std::string &password_result)
 162         {
 163                 // default to only trying the existing password once
 164                 return false;
 165         }
 166
 167         //
 168         // Do not use these functions if IsConnected() returns false
 169         //
 170
 171         Controller& GetController() { return *m_con; }
 172         Mode::Desktop& GetDesktop() { return *m_desktop; }
 173
 174         const Controller& GetController() const { return *m_con; }
 175         const Mode::Desktop& GetDesktop()  const{ return *m_desktop; }
 176 };
 177
 178 }
 179
 180 #endif
 181