libparted/exception.c

   1 /*
   2     libparted - a library for manipulating disk partitions
   3     Copyright (C) 1999-2000, 2007-2011 Free Software Foundation, Inc.
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 /** \file exception.c */
  20
  21 /**
  22  * \addtogroup PedException
  23  *
  24  * \brief Exception handling.
  25  *
  26  * There are a few types of exceptions: PED_EXCEPTION_INFORMATION,
  27  * PED_EXCEPTION_WARNING, PED_EXCEPTION_ERROR, PED_EXCEPTION_FATAL,
  28  * PED_EXCEPTION_BUG.
  29  *
  30  * They are "thrown" when one of the above events occur while executing
  31  * a libparted function. For example, if ped_device_open() fails
  32  * because the device doesn't exist, an exception will be thrown.
  33  * Exceptions contain text describing what the event was. It will give
  34  * at least one option for resolving the exception: PED_EXCEPTION_FIX,
  35  * PED_EXCEPTION_YES, PED_EXCEPTION_NO, PED_EXCEPTION_OK, PED_EXCEPTION_RETRY,
  36  * PED_EXCEPTION_IGNORE, PED_EXCEPTION_CANCEL. After an exception is thrown,
  37  * there are two things that can happen:
  38  *
  39  * -# an exception handler is called, which selects how the exception should be
  40  *    resolved (usually by asking the user). Also note: an exception handler may
  41  *    choose to return PED_EXCEPTION_UNHANDLED. In this case, a default action
  42  *    will be taken by libparted (respectively the code that threw the
  43  *    exception). In general, a default action will be "safe".
  44  * -# the exception is not handled, because the caller of the function wants to
  45  *    handle everything itself. In this case, PED_EXCEPTION_UNHANDLED is
  46  *    returned.
  47  *
  48  * @{
  49  */
  50
  51 #include <config.h>
  52
  53 #include <parted/parted.h>
  54 #include <parted/debug.h>
  55
  56 #define N_(String) String
  57 #if ENABLE_NLS
  58 #  include <libintl.h>
  59 #  define _(String) dgettext (PACKAGE, String)
  60 #else
  61 #  define _(String) (String)
  62 #endif /* ENABLE_NLS */
  63
  64 #include <stdio.h>
  65 #include <stdarg.h>
  66 #include <stdlib.h>
  67
  68 int                             ped_exception = 0;
  69
  70 static PedExceptionOption default_handler (PedException* ex);
  71
  72 static PedExceptionHandler*     ex_handler = default_handler;
  73 static PedException*            ex = NULL;
  74 static int                      ex_fetch_count = 0;
  75
  76 static const char *const type_strings [] = {
  77         N_("Information"),
  78         N_("Warning"),
  79         N_("Error"),
  80         N_("Fatal"),
  81         N_("Bug"),
  82         N_("No Implementation")
  83 };
  84
  85 static const char *const option_strings [] = {
  86         N_("Fix"),
  87         N_("Yes"),
  88         N_("No"),
  89         N_("OK"),
  90         N_("Retry"),
  91         N_("Ignore"),
  92         N_("Cancel")
  93 };
  94
  95 /**
  96  *  Return a string describing an exception type.
  97  */
  98 char*
  99 ped_exception_get_type_string (PedExceptionType ex_type)
 100 {
 101         return (char *) type_strings [ex_type - 1];
 102 }
 103
 104 /* FIXME: move this out to the prospective math.c */
 105 /* FIXME: this can probably be done more efficiently */
 106 static int
 107 ped_log2 (int n)
 108 {
 109         int x;
 110
 111         PED_ASSERT (n > 0, return -1);
 112
 113         for (x=0; 1 << x <= n; x++);
 114
 115         return x - 1;
 116 }
 117
 118 /**
 119  * Return a string describing an exception option.
 120  */
 121 char*
 122 ped_exception_get_option_string (PedExceptionOption ex_opt)
 123 {
 124         return (char *) option_strings [ped_log2 (ex_opt)];
 125 }
 126
 127 static PedExceptionOption
 128 default_handler (PedException* e)
 129 {
 130         if (e->type == PED_EXCEPTION_BUG)
 131                 fprintf (stderr,
 132                         _("A bug has been detected in GNU Parted.  "
 133                         "Refer to the web site of parted "
 134                         "http://www.gnu.org/software/parted/parted.html "
 135                         "for more information of what could be useful "
 136                         "for bug submitting!  "
 137                         "Please email a bug report to "
 138                         "%s containing at least the "
 139                         "version (%s) and the following message:  "),
 140                          PACKAGE_BUGREPORT, VERSION);
 141         else
 142                 fprintf (stderr, "%s: ",
 143                          ped_exception_get_type_string (e->type));
 144         fprintf (stderr, "%s\n", e->message);
 145
 146         switch (e->options) {
 147                 case PED_EXCEPTION_OK:
 148                 case PED_EXCEPTION_CANCEL:
 149                 case PED_EXCEPTION_IGNORE:
 150                         return e->options;
 151
 152                 default:
 153                         return PED_EXCEPTION_UNHANDLED;
 154         }
 155 }
 156
 157 /**
 158  * Set the exception handler.
 159  *
 160  * The exception handler should return ONE of the options set in ex->options,
 161  * indicating the way the event should be resolved.
 162  */
 163 void
 164 ped_exception_set_handler (PedExceptionHandler* handler)
 165 {
 166         if (handler)
 167                 ex_handler = handler;
 168         else
 169                 ex_handler = default_handler;
 170 }
 171
 172 /**
 173  * Get the current exception handler.
 174  */
 175 PedExceptionHandler *
 176 ped_exception_get_handler (void)
 177 {
 178         if (ex_handler)
 179                 return ex_handler;
 180         return default_handler;
 181 }
 182
 183 /**
 184  * Assert that the current exception has been resolved.
 185  */
 186 void
 187 ped_exception_catch ()
 188 {
 189         if (ped_exception) {
 190                 ped_exception = 0;
 191                 free (ex->message);
 192                 free (ex);
 193                 ex = NULL;
 194         }
 195 }
 196
 197 static PedExceptionOption
 198 do_throw ()
 199 {
 200         PedExceptionOption      ex_opt;
 201
 202         ped_exception = 1;
 203
 204         if (ex_fetch_count) {
 205                 return PED_EXCEPTION_UNHANDLED;
 206         } else {
 207                 ex_opt = ex_handler (ex);
 208                 ped_exception_catch ();
 209                 return ex_opt;
 210         }
 211 }
 212
 213 /**
 214  * Throw an exception.
 215  *
 216  * You can also use this in a program using libparted.
 217  * "message" is a printf-like format string, so you can do
 218  *
 219  * \code
 220  * ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_RETRY_CANCEL,
 221  *      "Can't open %s", file_name);
 222  * \endcode
 223  *
 224  * Returns the option selected to resolve the exception. If the exception was
 225  * unhandled, PED_EXCEPTION_UNHANDLED is returned.
 226  */
 227 PedExceptionOption
 228 ped_exception_throw (PedExceptionType ex_type,
 229                      PedExceptionOption ex_opts, const char* message, ...)
 230 {
 231         va_list         arg_list;
 232         int result;
 233         static int size = 1000;
 234
 235         if (ex)
 236                 ped_exception_catch ();
 237
 238         ex = (PedException*) malloc (sizeof (PedException));
 239         if (!ex)
 240                 goto no_memory;
 241
 242         ex->type = ex_type;
 243         ex->options = ex_opts;
 244
 245         while (message) {
 246                         ex->message = (char*) malloc (size * sizeof (char));
 247                         if (!ex->message)
 248                                         goto no_memory;
 249
 250                         va_start (arg_list, message);
 251                         result = vsnprintf (ex->message, size, message, arg_list);
 252                         va_end (arg_list);
 253
 254                         if (result > -1 && result < size)
 255                                         break;
 256
 257                         size += 10;
 258                         free (ex->message);
 259         }
 260
 261         return do_throw ();
 262
 263 no_memory:
 264         fputs ("Out of memory in exception handler!\n", stderr);
 265
 266         va_start (arg_list, message);
 267         vfprintf (stderr, message, arg_list);
 268         va_end (arg_list);
 269
 270         return PED_EXCEPTION_UNHANDLED;
 271 }
 272
 273 /**
 274  * Rethrow an unhandled exception.
 275  * This means repeating the last ped_exception_throw() statement.
 276  */
 277 PedExceptionOption
 278 ped_exception_rethrow ()
 279 {
 280         return do_throw ();
 281 }
 282
 283 /**
 284  * Indicates that exceptions should not go to the exception handler, but
 285  * passed up to the calling function(s).  All calls to
 286  * ped_exception_throw() will return PED_EXCEPTION_UNHANDLED.
 287  */
 288 void
 289 ped_exception_fetch_all ()
 290 {
 291         ex_fetch_count++;
 292 }
 293
 294 /**
 295  * Indicates that the calling function does not want to accept any
 296  * responsibility for exceptions any more.
 297  *
 298  * \note a caller of that function may still want responsibility, so
 299  *      ped_exception_throw() may not invoke the exception handler.
 300  *
 301  * \warning every call to this function must have a preceding
 302  *      ped_exception_fetch_all().
 303  */
 304 void
 305 ped_exception_leave_all ()
 306 {
 307         PED_ASSERT (ex_fetch_count > 0, return);
 308         ex_fetch_count--;
 309 }
 310
 311 /** @} */