code.vuplus.com Git - vuplus_xbmc/blob - lib/UnrarXLib/errhnd.cpp

   1 #include "rar.hpp"
   2
   3
   4 static bool UserBreak;
   5
   6 ErrorHandler::ErrorHandler()
   7 {
   8   Clean();
   9 }
  10
  11
  12 void ErrorHandler::Clean()
  13 {
  14   ExitCode=SUCCESS;
  15   ErrCount=0;
  16   EnableBreak=true;
  17   Silent=false;
  18   DoShutdown=false;
  19 }
  20
  21
  22 void ErrorHandler::MemoryError()
  23 {
  24   MemoryErrorMsg();
  25   Throw(MEMORY_ERROR);
  26 }
  27
  28
  29 void ErrorHandler::OpenError(const char *FileName)
  30 {
  31 #ifndef SILENT
  32   OpenErrorMsg(FileName);
  33   Throw(OPEN_ERROR);
  34 #endif
  35 }
  36
  37
  38 void ErrorHandler::CloseError(const char *FileName)
  39 {
  40 #ifndef SILENT
  41   if (!UserBreak)
  42   {
  43     ErrMsg(NULL,St(MErrFClose),FileName);
  44     SysErrMsg();
  45   }
  46 #endif
  47 #if !defined(SILENT) || defined(RARDLL)
  48   Throw(FATAL_ERROR);
  49 #endif
  50 }
  51
  52
  53 void ErrorHandler::ReadError(const char *FileName)
  54 {
  55 #ifndef SILENT
  56   ReadErrorMsg(NULL,FileName);
  57 #endif
  58 #if !defined(SILENT) || defined(RARDLL)
  59   Throw(FATAL_ERROR);
  60 #endif
  61 }
  62
  63
  64 bool ErrorHandler::AskRepeatRead(const char *FileName)
  65 {
  66 #if !defined(SILENT) && !defined(SFX_MODULE) && !defined(_WIN_CE)
  67   if (!Silent)
  68   {
  69     mprintf("\n");
  70     Log(NULL,St(MErrRead),FileName);
  71     return(Ask(St(MRetryAbort))==1);
  72   }
  73 #endif
  74   return(false);
  75 }
  76
  77
  78 void ErrorHandler::WriteError(const char *ArcName,const char *FileName)
  79 {
  80 #ifndef SILENT
  81   WriteErrorMsg(ArcName,FileName);
  82 #endif
  83 #if !defined(SILENT) || defined(RARDLL)
  84   Throw(WRITE_ERROR);
  85 #endif
  86 }
  87
  88
  89 #ifdef _WIN_32
  90 void ErrorHandler::WriteErrorFAT(const char *FileName)
  91 {
  92 #if !defined(SILENT) && !defined(SFX_MODULE)
  93   SysErrMsg();
  94   ErrMsg(NULL,St(MNTFSRequired),FileName);
  95 #endif
  96 #if !defined(SILENT) && !defined(SFX_MODULE) || defined(RARDLL)
  97   Throw(WRITE_ERROR);
  98 #endif
  99 }
 100 #endif
 101
 102
 103 bool ErrorHandler::AskRepeatWrite(const char *FileName)
 104 {
 105 #if !defined(SILENT) && !defined(_WIN_CE)
 106   if (!Silent)
 107   {
 108     mprintf("\n");
 109     Log(NULL,St(MErrWrite),FileName);
 110     return(Ask(St(MRetryAbort))==1);
 111   }
 112 #endif
 113   return(false);
 114 }
 115
 116
 117 void ErrorHandler::SeekError(const char *FileName)
 118 {
 119 #ifndef SILENT
 120   if (!UserBreak)
 121   {
 122     ErrMsg(NULL,St(MErrSeek),FileName);
 123     SysErrMsg();
 124   }
 125 #endif
 126 #if !defined(SILENT) || defined(RARDLL)
 127   Throw(FATAL_ERROR);
 128 #endif
 129 }
 130
 131
 132 void ErrorHandler::MemoryErrorMsg()
 133 {
 134 #ifndef SILENT
 135   ErrMsg(NULL,St(MErrOutMem));
 136 #endif
 137 }
 138
 139
 140 void ErrorHandler::OpenErrorMsg(const char *FileName)
 141 {
 142   OpenErrorMsg(NULL,FileName);
 143 }
 144
 145
 146 void ErrorHandler::OpenErrorMsg(const char *ArcName,const char *FileName)
 147 {
 148 #ifndef SILENT
 149   Log(ArcName && *ArcName ? ArcName:NULL,St(MCannotOpen),FileName);
 150   Alarm();
 151   SysErrMsg();
 152 #endif
 153 }
 154
 155
 156 void ErrorHandler::CreateErrorMsg(const char *FileName)
 157 {
 158   CreateErrorMsg(NULL,FileName);
 159 }
 160
 161
 162 void ErrorHandler::CreateErrorMsg(const char *ArcName,const char *FileName)
 163 {
 164 #ifndef SILENT
 165   Log(ArcName && *ArcName ? ArcName:NULL,St(MCannotCreate),FileName);
 166   Alarm();
 167 #if defined(_WIN_32) && !defined(_WIN_CE) && !defined(SFX_MODULE) && defined(MAXPATH)
 168   if (GetLastError()==ERROR_PATH_NOT_FOUND)
 169   {
 170     int NameLength=strlen(FileName);
 171     if (!IsFullPath(FileName))
 172     {
 173       char CurDir[NM];
 174       GetCurrentDirectory(sizeof(CurDir),CurDir);
 175       NameLength+=strlen(CurDir)+1;
 176     }
 177     if (NameLength>MAXPATH)
 178     {
 179       Log(ArcName && *ArcName ? ArcName:NULL,St(MMaxPathLimit),MAXPATH);
 180     }
 181   }
 182 #endif
 183   SysErrMsg();
 184 #endif
 185 }
 186
 187
 188 void ErrorHandler::ReadErrorMsg(const char *ArcName,const char *FileName)
 189 {
 190 #ifndef SILENT
 191   ErrMsg(ArcName,St(MErrRead),FileName);
 192   SysErrMsg();
 193 #endif
 194 }
 195
 196
 197 void ErrorHandler::WriteErrorMsg(const char *ArcName,const char *FileName)
 198 {
 199 #ifndef SILENT
 200   ErrMsg(ArcName,St(MErrWrite),FileName);
 201   SysErrMsg();
 202 #endif
 203 }
 204
 205
 206 void ErrorHandler::Exit(int ExitCode)
 207 {
 208 #ifndef SFX_MODULE
 209   Alarm();
 210 #endif
 211   Throw(ExitCode);
 212 }
 213
 214
 215 #ifndef GUI
 216 void ErrorHandler::ErrMsg(const char *ArcName,const char *fmt,...)
 217 {
 218   safebuf char Msg[NM+1024];
 219   va_list argptr;
 220   va_start(argptr,fmt);
 221   vsprintf(Msg,fmt,argptr);
 222   va_end(argptr);
 223 #ifdef _WIN_32
 224   if (UserBreak)
 225     Sleep(5000);
 226 #endif
 227   Alarm();
 228   if (*Msg)
 229   {
 230     Log(ArcName,"\n%s",Msg);
 231     mprintf("\n%s\n",St(MProgAborted));
 232   }
 233 }
 234 #endif
 235
 236
 237 void ErrorHandler::SetErrorCode(int Code)
 238 {
 239   switch(Code)
 240   {
 241     case WARNING:
 242     case USER_BREAK:
 243       if (ExitCode==SUCCESS)
 244         ExitCode=Code;
 245       break;
 246     case FATAL_ERROR:
 247       if (ExitCode==SUCCESS || ExitCode==WARNING)
 248         ExitCode=FATAL_ERROR;
 249       break;
 250     default:
 251       ExitCode=Code;
 252       break;
 253   }
 254   ErrCount++;
 255 }
 256
 257
 258 #if !defined(GUI) && !defined(_SFX_RTL_)
 259 #ifdef _WIN_32
 260 BOOL __stdcall ProcessSignal(DWORD SigType)
 261 #else
 262 #if defined(__sun)
 263 extern "C"
 264 #endif
 265 void _stdfunction ProcessSignal(int SigType)
 266 #endif
 267 {
 268 #if defined(_WIN_32) && !defined(TARGET_POSIX)
 269   if (SigType==CTRL_LOGOFF_EVENT)
 270     return(TRUE);
 271 #endif
 272   UserBreak=true;
 273   mprintf(St(MBreak));
 274   for (int I=0;!File::RemoveCreated() && I<3;I++)
 275   {
 276 #ifdef _WIN_32
 277     Sleep(100);
 278 #endif
 279   }
 280 #if defined(USE_RC) && !defined(SFX_MODULE) && !defined(_WIN_CE)
 281   ExtRes.UnloadDLL();
 282 #endif
 283 #if !defined(TARGET_POSIX)
 284   exit(USER_BREAK);
 285 #endif
 286 #ifdef _WIN_32
 287   return(TRUE);
 288 #endif
 289 }
 290 #endif
 291
 292
 293 void ErrorHandler::SetSignalHandlers(bool Enable)
 294 {
 295   EnableBreak=Enable;
 296 #if !defined(GUI) && !defined(_SFX_RTL_)
 297 #ifdef _WIN_32
 298   SetConsoleCtrlHandler(Enable ? ProcessSignal:NULL,TRUE);
 299 #else
 300   signal(SIGINT,Enable ? ProcessSignal:SIG_IGN);
 301   signal(SIGTERM,Enable ? ProcessSignal:SIG_IGN);
 302 #endif
 303 #endif
 304 }
 305
 306
 307 void ErrorHandler::Throw(int Code)
 308 {
 309   if (Code==USER_BREAK && !EnableBreak)
 310     return;
 311   ErrHandler.SetErrorCode(Code);
 312 #ifdef ALLOW_EXCEPTIONS
 313   throw Code;
 314 #else
 315   File::RemoveCreated();
 316 #if !defined(_XBMC) && !defined(TARGET_POSIX)
 317   exit(Code);
 318 #endif
 319 #endif
 320 }
 321
 322
 323 void ErrorHandler::SysErrMsg()
 324 {
 325 #if defined(_WIN_32) && !defined(SFX_MODULE) && !defined(SILENT)
 326     #define STRCHR strchr
 327     #define ERRCHAR char
 328   ERRCHAR  *lpMsgBuf=NULL;
 329   int ErrType=GetLastError();
 330   if (ErrType!=0 && FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 331               NULL,ErrType,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 332               (LPTSTR)&lpMsgBuf,0,NULL))
 333   {
 334     ERRCHAR  *CurMsg=lpMsgBuf;
 335     while (CurMsg!=NULL)
 336     {
 337       while (*CurMsg=='\r' || *CurMsg=='\n')
 338         CurMsg++;
 339       if (*CurMsg==0)
 340         break;
 341       ERRCHAR *EndMsg=STRCHR(CurMsg,'\r');
 342       if (EndMsg==NULL)
 343         EndMsg=STRCHR(CurMsg,'\n');
 344       if (EndMsg!=NULL)
 345       {
 346         *EndMsg=0;
 347         EndMsg++;
 348       }
 349       Log(NULL,"\n%s",CurMsg);
 350       CurMsg=EndMsg;
 351     }
 352   }
 353   LocalFree( lpMsgBuf );
 354 #endif
 355 }