src/error.h

   1 ///
   2 /// \file       error.h
   3 ///             Common exception classes for the Barry library
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2013, 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_ERROR_H__
  23 #define __BARRY_ERROR_H__
  24
  25 #include "dll.h"
  26 #include "pin.h"
  27 #include <stdexcept>
  28 #include <stdint.h>
  29
  30 namespace Barry {
  31
  32 /// \addtogroup exceptions
  33 /// @{
  34
  35 //
  36 // Error class
  37 //
  38 /// The base class for any future derived exceptions.
  39 /// Can be thrown on any protocol error.
  40 ///
  41 class BXEXPORT Error : public std::runtime_error
  42 {
  43 public:
  44         Error(const std::string &str) : std::runtime_error(str) {}
  45 };
  46
  47
  48 //
  49 // BadPassword
  50 //
  51 /// A bad or unknown password when talking to the device.
  52 /// Can be thrown in the following instances:
  53 ///
  54 ///     - no password provided and the device requests one
  55 ///     - device rejected the available password
  56 ///     - too few remaining tries left... Barry will refuse to keep
  57 ///             trying passwords if there are fewer than
  58 ///             BARRY_MIN_PASSWORD_TRIES tries remaining.  In this case,
  59 ///             out_of_tries() will return true.
  60 ///
  61 ///
  62 class BXEXPORT BadPassword : public Barry::Error
  63 {
  64         int m_remaining_tries;
  65         bool m_out_of_tries;
  66
  67 public:
  68         BadPassword(const std::string &str, int remaining_tries,
  69                 bool out_of_tries)
  70                 : Barry::Error(str),
  71                 m_remaining_tries(remaining_tries),
  72                 m_out_of_tries(out_of_tries)
  73                 {}
  74         int remaining_tries() const { return m_remaining_tries; }
  75         bool out_of_tries() const { return m_out_of_tries; }
  76 };
  77
  78 //
  79 // SocketCloseOnOpen
  80 //
  81 /// Thrown by the Socket class if it receives a CLOSE message in
  82 /// response to an OPEN command.  This can mean a number of things:
  83 ///
  84 ///     - device is password protected, and the wrong password was given
  85 ///     - device thinks that the socket is already open
  86 ///
  87 /// This special exception thrown so the application can try again
  88 /// with a fresh Socket::Open() call.
  89 ///
  90 class BXEXPORT SocketCloseOnOpen : public Barry::Error
  91 {
  92 public:
  93         SocketCloseOnOpen(const std::string &str) : Barry::Error(str) {}
  94 };
  95
  96 //
  97 // PinNotFound
  98 //
  99 /// Thrown by the Connector class when unable to find the requested Pin
 100 /// If the attached pin is not Valid(), then unable to autodetect device.
 101 /// If pin is Valid(), then the specified pin number was not available.
 102 /// probe_count is the number of devices found during the probe.
 103 ///
 104 class BXEXPORT PinNotFound : public Barry::Error
 105 {
 106         Barry::Pin m_pin;
 107         int m_probe_count;
 108
 109 public:
 110         PinNotFound(Barry::Pin pin, int probe_count)
 111                 : Barry::Error("PIN not found: " + pin.Str())
 112                 , m_pin(pin)
 113                 , m_probe_count(probe_count)
 114                 {}
 115
 116         const Barry::Pin& pin() const { return m_pin; }
 117         int probe_count() const { return m_probe_count; }
 118 };
 119
 120 //
 121 // BadData
 122 //
 123 /// Thrown by record classes if their data is invalid and cannot be
 124 /// uploaded to the Blackberry.
 125 ///
 126 class BXEXPORT BadData : public Barry::Error
 127 {
 128 public:
 129         BadData(const std::string &str)
 130                 : Barry::Error(str)
 131                 {}
 132 };
 133
 134 //
 135 // BadSize
 136 //
 137 /// Unexpected packet size, or not enough data.
 138 ///
 139 class BXEXPORT BadSize : public Barry::Error
 140 {
 141         unsigned int m_packet_size,
 142                 m_data_buf_size,
 143                 m_required_size;
 144
 145         BXLOCAL static std::string GetMsg(const char *msg, unsigned int d, unsigned int r);
 146         BXLOCAL static std::string GetMsg(unsigned int p, unsigned int d, unsigned int r);
 147
 148 public:
 149         BadSize(const char *msg, unsigned int data_size, unsigned int required_size);
 150         BadSize(unsigned int packet_size,
 151                 unsigned int data_buf_size,
 152                 unsigned int required_size);
 153         unsigned int packet_size() const { return m_packet_size; }
 154         unsigned int data_buf_size() const { return m_data_buf_size; }
 155         unsigned int required_size() const { return m_required_size; }
 156 };
 157
 158 //
 159 // ErrnoError
 160 //
 161 /// System error that provides an errno error code.
 162 ///
 163 class BXEXPORT ErrnoError : public Barry::Error
 164 {
 165         int m_errno;
 166
 167         BXLOCAL static std::string GetMsg(const std::string &msg, int err);
 168
 169 protected:
 170         ErrnoError(const std::string &msg); // for derived classes
 171
 172 public:
 173         ErrnoError(const std::string &msg, int err);
 174
 175         int error_code() const { return m_errno; }
 176 };
 177
 178 //
 179 // ConfigFileError
 180 //
 181 /// Thrown by the ConfigFile class when encountering a serious system
 182 /// error while loading the global config file for a given PIN.
 183 ///
 184 class BXEXPORT ConfigFileError : public Barry::ErrnoError
 185 {
 186 public:
 187         ConfigFileError(const char *msg) : Barry::ErrnoError(msg) {}
 188         ConfigFileError(const char *msg, int err)
 189                 : Barry::ErrnoError(msg, err)
 190                 {}
 191 };
 192
 193 //
 194 // BadPackedFormat
 195 //
 196 /// Thrown by record classes that don't recognize a given packed format code.
 197 /// This exception is mostly handled internally, but is published here
 198 /// just in case it escapes.
 199 ///
 200 class BXEXPORT BadPackedFormat : public Barry::Error
 201 {
 202         uint8_t m_format;
 203
 204 public:
 205         BadPackedFormat(uint8_t format)
 206                 : Barry::Error("Bad packed format - internal exception")
 207                 , m_format(format)
 208                 {}
 209
 210         uint8_t format() const { return m_format; }
 211 };
 212
 213 //
 214 // BadPacket
 215 //
 216 /// Thrown by the socket class if a packet command's response indicates
 217 /// an error.  Some commands may be able to recover inside the library,
 218 /// so a special exception is used, that includes the response code.
 219 ///
 220 class BXEXPORT BadPacket : public Barry::Error
 221 {
 222         uint8_t m_response;
 223
 224 public:
 225         BadPacket(uint8_t response, const std::string &msg)
 226                 : Barry::Error(msg)
 227                 , m_response(response)
 228                 {}
 229
 230         uint8_t response() const { return m_response; }
 231 };
 232
 233 //
 234 // ConvertError
 235 //
 236 /// Thrown by the vformat related barrysync library classes.
 237 ///
 238 class BXEXPORT ConvertError : public Barry::Error
 239 {
 240 public:
 241         ConvertError(const std::string &msg) : Barry::Error(msg) {}
 242 };
 243
 244 //
 245 // BackupError
 246 //
 247 /// Thrown by the Backup parser class when there is a problem with the
 248 /// low level file operation.
 249 ///
 250 class BXEXPORT BackupError : public Barry::Error
 251 {
 252 public:
 253         BackupError(const std::string &str) : Error(str) {}
 254 };
 255
 256 //
 257 // RestoreError
 258 //
 259 /// Thrown by the Restore builder class when there is a problem with the
 260 /// low level file operation.
 261 ///
 262 class BXEXPORT RestoreError : public Barry::Error
 263 {
 264 public:
 265         RestoreError(const std::string &str) : Error(str) {}
 266 };
 267
 268 //
 269 // ReturnCodeError
 270 //
 271 /// Thrown by the Mode::Desktop class when a database command returns
 272 /// a non-zero error code.  Can happen when writing or clearing a database.
 273 /// The packet command and return code are passed along, for examination
 274 /// by application code.  Note that return code 0x02 usually means
 275 /// you're trying to clear or write to a read-only database, like Time Zones.
 276 ///
 277 class BXEXPORT ReturnCodeError : public Barry::Error
 278 {
 279         unsigned int m_command, m_return_code;
 280
 281 public:
 282         ReturnCodeError(const std::string &str, unsigned int command,
 283                         unsigned int return_code)
 284                 : Error(str)
 285                 , m_command(command)
 286                 , m_return_code(return_code)
 287         {
 288         }
 289
 290         unsigned int command() const { return m_command; }
 291         unsigned int return_code() const { return m_return_code; }
 292
 293         bool IsReadOnly() const { return return_code() == 0x02; }
 294 };
 295
 296 //
 297 // ValidationError
 298 //
 299 /// Thrown by one of the record classes' Validate() function.  Contains
 300 /// and error message describing the deficiency.
 301 ///
 302 class BXEXPORT ValidationError : public Barry::Error
 303 {
 304 public:
 305         explicit ValidationError(const std::string &str)
 306                 : Error(str)
 307         {
 308         }
 309 };
 310
 311 /// @}
 312
 313 } // namespace Barry
 314
 315 #endif
 316