libmp3splt
src/errors.c
00001 /**********************************************************
00002  *
00003  * libmp3splt -- library based on mp3splt,
00004  *               for mp3/ogg splitting without decoding
00005  *
00006  * Copyright (c) 2002-2005 M. Trotta - <mtrotta@users.sourceforge.net>
00007  * Copyright (c) 2005-2011 Alexandru Munteanu - io_fx@yahoo.fr
00008  *
00009  * http://mp3splt.sourceforge.net
00010  *
00011  *********************************************************/
00012 
00013 /**********************************************************
00014  *
00015  * This program is free software; you can redistribute it and/or
00016  * modify it under the terms of the GNU General Public License
00017  * as published by the Free Software Foundation; either version 2
00018  * of the License, or (at your option) any later version.
00019  *
00020  * This program is distributed in the hope that it will be useful,
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023  * GNU General Public License for more details.
00024  *
00025  * You should have received a copy of the GNU General Public License
00026  * along with this program; if not, write to the Free Software
00027  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00028  * 02111-1307,
00029  * USA.
00030  *
00031  *********************************************************/
00032 
00039 #include <string.h>
00040 #include <errno.h>
00041 
00042 #ifdef __WIN32__
00043 #include <winsock.h>
00044 #else
00045 #include <netdb.h>
00046 #endif
00047 
00048 #include "splt.h"
00049 
00050 static void splt_e_set_strerr_msg(splt_state *state, const char *message);
00051 
00052 void splt_e_set_errors_default_values(splt_state *state)
00053 {
00054   splt_error *err = &state->err;
00055   err->error_data = NULL;
00056   err->strerror_msg = NULL;
00057 }
00058 
00059 void splt_e_free_errors(splt_state *state)
00060 {
00061   splt_error *err = &state->err;
00062 
00063   if (err->error_data)
00064   {
00065     free(err->error_data);
00066     err->error_data = NULL;
00067   }
00068 
00069   if (err->strerror_msg)
00070   {
00071     free(err->strerror_msg);
00072     err->strerror_msg = NULL;
00073   }
00074 }
00075 
00076 void splt_e_set_error_data(splt_state *state, const char *error_data)
00077 {
00078   splt_error *err = &state->err;
00079 
00080  if (err->error_data)
00081   {
00082     free(err->error_data);
00083     err->error_data = NULL;
00084   }
00085 
00086   if (error_data)
00087   {
00088     splt_su_copy(error_data, &err->error_data);
00089   }
00090 }
00091 
00092 void splt_e_set_error_data_from_splitpoint(splt_state *state, long splitpoint)
00093 {
00094   long mins = 0, secs = 0, hundr = 0;
00095   splt_sp_get_mins_secs_hundr_from_splitpoint(splitpoint, &mins, &secs, &hundr);
00096   char str_value[256] = { '\0' };
00097   snprintf(str_value,256,"%ldm%lds%ldh",mins,secs,hundr);
00098   splt_e_set_error_data(state, str_value);
00099 }
00100 
00101 void splt_e_set_error_data_from_splitpoints(splt_state *state, long splitpoint1,
00102     long splitpoint2)
00103 {
00104   long mins = 0, secs = 0, hundr = 0;
00105   long mins2 = 0, secs2 = 0, hundr2 = 0;
00106   splt_sp_get_mins_secs_hundr_from_splitpoint(splitpoint1, &mins, &secs, &hundr);
00107   splt_sp_get_mins_secs_hundr_from_splitpoint(splitpoint2, &mins2, &secs2, &hundr2);
00108   char str_value[256] = { '\0' };
00109   snprintf(str_value,256,"%ldm%lds%ldh, %ldm%lds%ldh",
00110       mins, secs, hundr, mins2, secs2, hundr2);
00111   splt_e_set_error_data(state, str_value);
00112 }
00113 
00114 void splt_e_clean_strerror_msg(splt_state *state)
00115 {
00116   splt_e_set_strerr_msg(state, NULL);
00117 }
00118 
00119 void splt_e_set_strerror_msg(splt_state *state)
00120 {
00121   splt_e_set_strerr_msg(state, strerror(errno));
00122 }
00123 
00124 void splt_e_set_strherror_msg(splt_state *state)
00125 {
00126 #ifndef __WIN32__
00127   splt_e_set_strerr_msg(state, hstrerror(h_errno));
00128 #else
00129   splt_e_set_strerr_msg(state, _("Network error"));
00130 #endif
00131 }
00132 
00133 void splt_e_set_strerr_msg_with_data(splt_state *state, const char *message, const char *data)
00134 {
00135   splt_e_set_strerr_msg(state, message);
00136   splt_e_set_error_data(state, data);
00137 }
00138 
00139 void splt_e_set_strerror_msg_with_data(splt_state *state, const char *data)
00140 {
00141   splt_e_set_strerror_msg(state);
00142   splt_e_set_error_data(state, data);
00143 }
00144 
00145 void splt_e_error(int error_type, const char *function,
00146     int arg_int, char *arg_char)
00147 {
00148   switch (error_type)
00149   {
00150     case SPLT_IERROR_INT:
00151       fprintf(stderr, "libmp3splt: error in %s with value %d\n",
00152           function, arg_int);
00153       fflush(stderr);
00154       break;
00155     case SPLT_IERROR_SET_ORIGINAL_TAGS:
00156       fprintf(stderr,
00157           "libmp3splt: cannot set original file tags, "
00158           "libmp3splt not compiled with libid3tag\n");
00159       fflush(stderr);
00160       break;
00161     case SPLT_IERROR_CHAR:
00162       fprintf(stderr,
00163           "libmp3splt: error in %s with message '%s'\n",function,arg_char);
00164       fflush(stderr);
00165       break;
00166     default:
00167       fprintf(stderr, "libmp3splt: unknown error in %s\n", function);
00168       fflush(stderr);
00169       break;
00170   }
00171 }
00172 
00173 char *splt_e_strerror(splt_state *state, splt_code error_code)
00174 {
00175   switch (error_code)
00176   {
00177     case SPLT_MIGHT_BE_VBR:
00178       return splt_su_get_formatted_message(state,
00179           _(" warning: might be VBR, use frame mode"));
00180     case SPLT_SYNC_OK:
00181       return splt_su_get_formatted_message(state, _(" error mode ok"));
00182     case SPLT_ERR_SYNC:
00183       return splt_su_get_formatted_message(state, _(" error: unknown sync error"));
00184     case SPLT_ERR_NO_SYNC_FOUND:
00185       return splt_su_get_formatted_message(state, _(" no sync errors found"));
00186     case SPLT_ERR_TOO_MANY_SYNC_ERR:
00187       return splt_su_get_formatted_message(state, 
00188           _(" sync error: too many sync errors"));
00189       //
00190     case SPLT_FREEDB_MAX_CD_REACHED:
00191       return splt_su_get_formatted_message(state,
00192           _(" maximum number of found CD reached"));
00193     case SPLT_CUE_OK:
00194       return splt_su_get_formatted_message(state, _(" cue file processed"));
00195     case SPLT_CDDB_OK:
00196       return splt_su_get_formatted_message(state, _(" cddb file processed"));
00197     case SPLT_FREEDB_FILE_OK:
00198       return splt_su_get_formatted_message(state, _(" freedb file downloaded"));
00199     case SPLT_FREEDB_OK:
00200       return splt_su_get_formatted_message(state, _(" freedb search processed"));
00201       //
00202     case SPLT_FREEDB_ERROR_INITIALISE_SOCKET:
00203       return splt_su_get_formatted_message(state,
00204           _(" freedb error: cannot initialise socket (%s)"),
00205           state->err.strerror_msg);
00206     case SPLT_FREEDB_ERROR_CANNOT_GET_HOST:
00207       return splt_su_get_formatted_message(state,
00208           _(" freedb error: cannot get host '%s' by name (%s)"),
00209           state->err.error_data, state->err.strerror_msg);
00210     case SPLT_FREEDB_ERROR_CANNOT_OPEN_SOCKET:
00211       return splt_su_get_formatted_message(state,
00212           _(" freedb error: cannot open socket"));
00213     case SPLT_FREEDB_ERROR_CANNOT_CONNECT:
00214       return splt_su_get_formatted_message(state,
00215           _(" freedb error: cannot connect to host '%s' (%s)"),
00216           state->err.error_data, state->err.strerror_msg);
00217     case SPLT_FREEDB_ERROR_CANNOT_SEND_MESSAGE:
00218       return splt_su_get_formatted_message(state,
00219           _(" freedb error: cannot send message to host '%s' (%s)"),
00220           state->err.error_data, state->err.strerror_msg);
00221     case SPLT_FREEDB_ERROR_INVALID_SERVER_ANSWER:
00222       return splt_su_get_formatted_message(state,
00223           _(" freedb error: invalid server answer"));
00224     case SPLT_FREEDB_ERROR_SITE_201:
00225       return splt_su_get_formatted_message(state,
00226           _(" freedb error: site returned code 201"));
00227     case SPLT_FREEDB_ERROR_SITE_200:
00228       return splt_su_get_formatted_message(state,
00229           _(" freedb error: site returned code 200"));
00230     case SPLT_FREEDB_ERROR_BAD_COMMUNICATION:
00231       return splt_su_get_formatted_message(state,
00232           _(" freedb error: bad communication with site"));
00233     case SPLT_FREEDB_ERROR_GETTING_INFOS:
00234       return splt_su_get_formatted_message(state,
00235           _(" freedb error: could not get infos from site '%s'"),
00236           state->err.error_data);
00237     case SPLT_FREEDB_NO_CD_FOUND:
00238       return splt_su_get_formatted_message(state, _(" no CD found for this search"));
00239     case SPLT_FREEDB_ERROR_CANNOT_RECV_MESSAGE:
00240       return splt_su_get_formatted_message(state,
00241           _(" freedb error: cannot receive message from server '%s' (%s)"),
00242           state->err.error_data, state->err.strerror_msg);
00243     case SPLT_INVALID_CUE_FILE:
00244       return splt_su_get_formatted_message(state, _(" cue error: invalid cue file '%s'"),
00245           state->err.error_data);
00246     case SPLT_INVALID_CDDB_FILE:
00247       return splt_su_get_formatted_message(state, _(" cddb error: invalid cddb file '%s'"),
00248           state->err.error_data);
00249     case SPLT_FREEDB_NO_SUCH_CD_IN_DATABASE:
00250       return splt_su_get_formatted_message(state,
00251           _(" freedb error: No such CD entry in database"));
00252     case SPLT_FREEDB_ERROR_SITE:
00253       return splt_su_get_formatted_message(state,
00254           _(" freedb error: site returned an unknown error"));
00255       //
00256     case SPLT_DEWRAP_OK:
00257       return splt_su_get_formatted_message(state, _(" wrap split ok"));
00258       //
00259     case SPLT_DEWRAP_ERR_FILE_LENGTH:
00260       return splt_su_get_formatted_message(state, _(" wrap error: incorrect file length"));
00261     case SPLT_DEWRAP_ERR_VERSION_OLD:
00262       return splt_su_get_formatted_message(state,
00263           _(" wrap error: libmp3splt version too old for this wrap file"));
00264     case SPLT_DEWRAP_ERR_NO_FILE_OR_BAD_INDEX:
00265       return splt_su_get_formatted_message(state,
00266           _(" wrap error: no file found or bad index"));
00267     case SPLT_DEWRAP_ERR_FILE_DAMAGED_INCOMPLETE:
00268       return splt_su_get_formatted_message(state,
00269           _(" wrap error: file '%s' damaged or incomplete"),
00270           state->err.error_data);
00271     case SPLT_DEWRAP_ERR_FILE_NOT_WRAPED_DAMAGED:
00272       return splt_su_get_formatted_message(state,
00273           _(" wrap error: maybe not a wrapped file or wrap file damaged"));
00274       //
00275     case SPLT_OK_SPLIT_EOF:
00276       return splt_su_get_formatted_message(state, _(" file split (EOF)"));
00277     case SPLT_NO_SILENCE_SPLITPOINTS_FOUND:
00278       return splt_su_get_formatted_message(state, _(" no silence splitpoints found"));
00279     case SPLT_TIME_SPLIT_OK:
00280       return splt_su_get_formatted_message(state, _(" time split ok"));
00281     case SPLT_LENGTH_SPLIT_OK:
00282       return splt_su_get_formatted_message(state, _(" split in equal tracks ok"));
00283     case SPLT_SILENCE_OK:
00284       return splt_su_get_formatted_message(state, _(" silence split ok"));
00285     case SPLT_SPLITPOINT_BIGGER_THAN_LENGTH:
00286       return splt_su_get_formatted_message(state,
00287           _(" file split, splitpoints bigger than length"));
00288     case SPLT_OK_SPLIT:
00289       return splt_su_get_formatted_message(state, _(" file split"));
00290     case SPLT_OK:
00291       return NULL;
00292     case SPLT_ERROR_SPLITPOINTS:
00293       return splt_su_get_formatted_message(state, _(" error: not enough splitpoints (<2)"));
00294     case SPLT_ERROR_CANNOT_OPEN_FILE:
00295       return splt_su_get_formatted_message(state,
00296           _(" error: cannot open file '%s': %s"),
00297           state->err.error_data, state->err.strerror_msg);
00298     case SPLT_ERROR_CANNOT_CLOSE_FILE:
00299       return splt_su_get_formatted_message(state,
00300           _(" error: cannot close file '%s': %s"),
00301           state->err.error_data, state->err.strerror_msg);
00302     case SPLT_ERROR_INVALID:
00303       ;
00304       int err = SPLT_OK;
00305       const char *plugin_name = splt_p_get_name(state, &err);
00306       return splt_su_get_formatted_message(state,
00307           _(" error: invalid input file '%s' for '%s' plugin"),
00308           state->err.error_data, plugin_name);
00309     case SPLT_ERROR_EQUAL_SPLITPOINTS:
00310       return splt_su_get_formatted_message(state,
00311           _(" error: splitpoints are equal (%s)"),
00312           state->err.error_data);
00313     case SPLT_ERROR_TIME_SPLIT_VALUE_INVALID:
00314       return splt_su_get_formatted_message(state, _(" error: invalid time split value"));
00315     case SPLT_ERROR_LENGTH_SPLIT_VALUE_INVALID:
00316       return splt_su_get_formatted_message(state,
00317           _(" error: invalid number of files for equal length split"));
00318     case SPLT_ERROR_CANNOT_GET_TOTAL_TIME:
00319       return splt_su_get_formatted_message(state,
00320           _(" error: cannot get total audio length"));
00321     case SPLT_ERROR_SPLITPOINTS_NOT_IN_ORDER:
00322       return splt_su_get_formatted_message(state,
00323           _(" error: the splitpoints are not in order (%s)"),
00324           state->err.error_data);
00325     case SPLT_ERROR_NEGATIVE_SPLITPOINT:
00326       return splt_su_get_formatted_message(state, _(" error: negative splitpoint (%s)"),
00327           state->err.error_data);
00328     case SPLT_ERROR_INCORRECT_PATH:
00329       return splt_su_get_formatted_message(state,
00330           _(" error: bad destination folder '%s' (%s)"),
00331           state->err.error_data, state->err.strerror_msg);
00332     case SPLT_ERROR_INCOMPATIBLE_OPTIONS:
00333       return splt_su_get_formatted_message(state, _(" error: incompatible options"));
00334     case SPLT_ERROR_INPUT_OUTPUT_SAME_FILE:
00335       return splt_su_get_formatted_message(state,
00336           _(" input and output are the same file ('%s')"),
00337           state->err.error_data);
00338     case SPLT_ERROR_CANNOT_ALLOCATE_MEMORY:
00339       return splt_su_get_formatted_message(state, _(" error: cannot allocate memory"));
00340     case SPLT_ERROR_CANNOT_OPEN_DEST_FILE:
00341       return splt_su_get_formatted_message(state,
00342           _(" error: cannot open destination file '%s': %s"),
00343           state->err.error_data,state->err.strerror_msg);
00344     case SPLT_ERROR_CANT_WRITE_TO_OUTPUT_FILE:
00345       return splt_su_get_formatted_message(state,
00346           _(" error: cannot write to output file '%s'"),
00347           state->err.error_data);
00348     case SPLT_ERROR_WHILE_READING_FILE:
00349       return splt_su_get_formatted_message(state,
00350           _(" error: error while reading file '%s': %s"),
00351           state->err.error_data, state->err.strerror_msg);
00352     case SPLT_ERROR_SEEKING_FILE:
00353       return splt_su_get_formatted_message(state, _(" error: cannot seek file '%s'"),
00354           state->err.error_data);
00355     case SPLT_ERROR_BEGIN_OUT_OF_FILE:
00356       return splt_su_get_formatted_message(state, _(" error: begin point out of file"));
00357     case SPLT_ERROR_INEXISTENT_FILE:
00358       return splt_su_get_formatted_message(state, _(" error: inexistent file '%s': %s"),
00359           state->err.error_data,state->err.strerror_msg);
00360     case SPLT_SPLIT_CANCELLED:
00361       return splt_su_get_formatted_message(state, _(" split process cancelled"));
00362     case SPLT_ERROR_LIBRARY_LOCKED: 
00363       return splt_su_get_formatted_message(state, _(" error: library locked"));
00364     case SPLT_ERROR_STATE_NULL:
00365       return splt_su_get_formatted_message(state,
00366           _(" error: the state has not been initialized with 'mp3splt_new_state'"));
00367     case SPLT_ERROR_NEGATIVE_TIME_SPLIT:
00368       return splt_su_get_formatted_message(state, _(" error: negative time split"));
00369     case SPLT_ERROR_CANNOT_CREATE_DIRECTORY:
00370       return splt_su_get_formatted_message(state,
00371           _(" error: cannot create directory '%s'"),
00372           state->err.error_data);
00373     case SPLT_ERROR_NO_PLUGIN_FOUND:
00374       return splt_su_get_formatted_message(state, _(" error: no plugin found"));
00375     case SPLT_ERROR_CANNOT_INIT_LIBLTDL:
00376       return splt_su_get_formatted_message(state, _(" error: cannot initiate libltdl"));
00377     case SPLT_ERROR_CRC_FAILED:
00378       return splt_su_get_formatted_message(state, _(" error: CRC failed"));
00379     case SPLT_ERROR_NO_PLUGIN_FOUND_FOR_FILE:
00380       return splt_su_get_formatted_message(state,
00381           _(" error: no plugin matches the file '%s'"),
00382           state->err.error_data);
00383       //
00384     case SPLT_OUTPUT_FORMAT_OK:
00385       return NULL;
00386     case SPLT_OUTPUT_FORMAT_AMBIGUOUS:
00387       return splt_su_get_formatted_message(state,
00388           _(" warning: output format ambiguous (@t or @n missing)"));
00389       //
00390     case SPLT_OUTPUT_FORMAT_ERROR:
00391       if (state->err.error_data != NULL && strlen(state->err.error_data) == 1)
00392       {
00393         return splt_su_get_formatted_message(state,
00394             _(" error: illegal variable '@%s' in output format"),
00395             state->err.error_data);
00396       }
00397       else
00398       {
00399         return splt_su_get_formatted_message(state, _(" error: invalid output format"));
00400       }
00401       //
00402     case SPLT_ERROR_INEXISTENT_SPLITPOINT:
00403       return splt_su_get_formatted_message(state, _(" error: inexistent splitpoint"));
00404       //
00405     case SPLT_ERROR_PLUGIN_ERROR:
00406       return splt_su_get_formatted_message(state, _(" plugin error: '%s'"),
00407           state->err.error_data);
00408       //
00409     case SPLT_PLUGIN_ERROR_UNSUPPORTED_FEATURE:
00410       ;
00411       splt_plugins *pl = state->plug;
00412       int current_plugin = splt_p_get_current_plugin(state);
00413       return splt_su_get_formatted_message(state,
00414           _(" error: unsupported feature for the plugin '%s'"),
00415           pl->data[current_plugin].info.name);
00416     case SPLT_AUDACITY_OK:
00417       return splt_su_get_formatted_message(state, _(" audacity labels file processed"));
00418     case SPLT_INVALID_AUDACITY_FILE:
00419       return splt_su_get_formatted_message(state,
00420           _(" audacity error: invalid audacity labels file '%s'"),
00421           state->err.error_data);
00422     case SPLT_INVALID_REGEX:
00423       return splt_su_get_formatted_message(state,
00424           _(" regular expression error: %s"), state->err.error_data);
00425     case SPLT_REGEX_NO_MATCH:
00426       return splt_su_get_formatted_message(state, _(" regular expression error: no match"));
00427     case SPLT_REGEX_OK:
00428       return splt_su_get_formatted_message(state, _(" regular expression ok"));
00429   }
00430 
00431   return NULL;
00432 }
00433 
00434 static void splt_e_set_strerr_msg(splt_state *state, const char *message)
00435 {
00436   splt_su_copy(message, &state->err.strerror_msg);
00437 }
00438