src/error.h

   1 ///
   2 /// \file       error.h
   3 ///             Common exception classes for the Barry library
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2010, 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 <stdexcept>
  27 #include <stdint.h>
  28
  29 namespace Barry {
  30
  31 /// \addtogroup exceptions
  32 /// @{
  33
  34 //
  35 // Error class
  36 //
  37 /// The base class for any future derived exceptions.
  38 /// Can be thrown on any protocol error.
  39 ///
  40 class BXEXPORT Error : public std::runtime_error
  41 {
  42 public:
  43         Error(const std::string &str) : std::runtime_error(str) {}
  44 };
  45
  46
  47 //
  48 // BadPassword
  49 //
  50 /// A bad or unknown password when talking to the device.
  51 /// Can be thrown in the following instances:
  52 ///
  53 ///     - no password provided and the device requests one
  54 ///     - device rejected the available password
  55 ///     - too few remaining tries left... Barry will refuse to keep
  56 ///             trying passwords if there are fewer than
  57 ///             BARRY_MIN_PASSWORD_TRIES tries remaining.  In this case,
  58 ///             out_of_tries() will return true.
  59 ///
  60 ///
  61 class BXEXPORT BadPassword : public Barry::Error
  62 {
  63         int m_remaining_tries;
  64         bool m_out_of_tries;
  65
  66 public:
  67         BadPassword(const std::string &str, int remaining_tries,
  68                 bool out_of_tries)
  69                 : Barry::Error(str),
  70                 m_remaining_tries(remaining_tries),
  71                 m_out_of_tries(out_of_tries)
  72                 {}
  73         int remaining_tries() const { return m_remaining_tries; }
  74         bool out_of_tries() const { return m_out_of_tries; }
  75 };
  76
  77 //
  78 // BadData
  79 //
  80 /// Thrown by record classes if their data is invalid and cannot be
  81 /// uploaded to the Blackberry.
  82 ///
  83 class BXEXPORT BadData : public Barry::Error
  84 {
  85 public:
  86         BadData(const std::string &str)
  87                 : Barry::Error(str)
  88                 {}
  89 };
  90
  91 //
  92 // BadSize
  93 //
  94 /// Unexpected packet size, or not enough data.
  95 ///
  96 class BXEXPORT BadSize : public Barry::Error
  97 {
  98         unsigned int m_packet_size,
  99                 m_data_buf_size,
 100                 m_required_size;
 101
 102         BXLOCAL static std::string GetMsg(const char *msg, unsigned int d, unsigned int r);
 103         BXLOCAL static std::string GetMsg(unsigned int p, unsigned int d, unsigned int r);
 104
 105 public:
 106         BadSize(const char *msg, unsigned int data_size, unsigned int required_size);
 107         BadSize(unsigned int packet_size,
 108                 unsigned int data_buf_size,
 109                 unsigned int required_size);
 110         unsigned int packet_size() const { return m_packet_size; }
 111         unsigned int data_buf_size() const { return m_data_buf_size; }
 112         unsigned int required_size() const { return m_required_size; }
 113 };
 114
 115 //
 116 // ErrnoError
 117 //
 118 /// System error that provides an errno error code.
 119 ///
 120 class BXEXPORT ErrnoError : public Barry::Error
 121 {
 122         int m_errno;
 123
 124         BXLOCAL static std::string GetMsg(const std::string &msg, int err);
 125
 126 protected:
 127         ErrnoError(const std::string &msg); // for derived classes
 128
 129 public:
 130         ErrnoError(const std::string &msg, int err);
 131
 132         int error_code() const { return m_errno; }
 133 };
 134
 135 //
 136 // ConfigFileError
 137 //
 138 /// Thrown by the ConfigFile class when encountering a serious system
 139 /// error while loading the global config file for a given PIN.
 140 ///
 141 class BXEXPORT ConfigFileError : public Barry::ErrnoError
 142 {
 143 public:
 144         ConfigFileError(const char *msg) : Barry::ErrnoError(msg) {}
 145         ConfigFileError(const char *msg, int err)
 146                 : Barry::ErrnoError(msg, err)
 147                 {}
 148 };
 149
 150 //
 151 // BadPackedFormat
 152 //
 153 /// Thrown by record classes that don't recognize a given packed format code.
 154 /// This exception is mostly handled internally, but is published here
 155 /// just in case it escapes.
 156 ///
 157 class BXEXPORT BadPackedFormat : public Barry::Error
 158 {
 159         uint8_t m_format;
 160
 161 public:
 162         BadPackedFormat(uint8_t format)
 163                 : Barry::Error("Bad packed format - internal exception")
 164                 , m_format(format)
 165                 {}
 166
 167         uint8_t format() const { return m_format; }
 168 };
 169
 170 //
 171 // BadPacket
 172 //
 173 /// Thrown by the socket class if a packet command's response indicates
 174 /// an error.  Some commands may be able to recover inside the library,
 175 /// so a special exception is used, that includes the response code.
 176 ///
 177 class BXEXPORT BadPacket : public Barry::Error
 178 {
 179         uint8_t m_response;
 180
 181 public:
 182         BadPacket(uint8_t response, const std::string &msg)
 183                 : Barry::Error(msg)
 184                 , m_response(response)
 185                 {}
 186
 187         uint8_t response() const { return m_response; }
 188 };
 189
 190 //
 191 // ConvertError
 192 //
 193 /// Thrown by the vformat related barrysync library classes.
 194 ///
 195 class BXEXPORT ConvertError : public Barry::Error
 196 {
 197 public:
 198         ConvertError(const std::string &msg) : Barry::Error(msg) {}
 199 };
 200
 201 //
 202 // BackupError
 203 //
 204 /// Thrown by the Backup parser class when there is a problem with the
 205 /// low level file operation.
 206 ///
 207 class BXEXPORT BackupError : public Barry::Error
 208 {
 209 public:
 210         BackupError(const std::string &str) : Error(str) {}
 211 };
 212
 213 //
 214 // RestoreError
 215 //
 216 /// Thrown by the Restore builder class when there is a problem with the
 217 /// low level file operation.
 218 ///
 219 class BXEXPORT RestoreError : public Barry::Error
 220 {
 221 public:
 222         RestoreError(const std::string &str) : Error(str) {}
 223 };
 224
 225 /// @}
 226
 227 } // namespace Barry
 228
 229 #endif
 230