00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "RioError.h"
00021 #include "RioInterfaceTypes.h"
00022 #include "iostream"
00023
00024 #include <pthread.h>
00025 #include <execinfo.h>
00026 #include <string.h>
00027
00028 #include <sys/time.h>
00029 #include <time.h>
00030 #include <errno.h>
00031 #include <stdlib.h>
00032 #include <sys/types.h>
00033 #include <unistd.h>
00034 #include <stdio.h>
00035
00036
00037 #include <sys/syscall.h>
00038
00039
00040
00041 string GetErrorDescription( const unsigned int error )
00042 {
00043 string RioError;
00044 string UserError;
00045
00046 #ifdef RIO_DEBUG2
00047 bool showstack = false;
00048 #endif
00049
00050 switch( (error & 0xFFFFFF00) )
00051 {
00052 case ERROR_NO_RIO_ERROR:
00053 RioError = "NO RIO ERROR";
00054 break;
00055 case ERROR_STORAGEDEVICE:
00056 RioError = "STORAGE DEVICE";
00057 break;
00058 case ERROR_STORAGEMANAGER:
00059 RioError = "STORAGE MANAGER";
00060 break;
00061 case ERROR_STORAGESERVER:
00062 RioError = "STORAGE SERVER";
00063 break;
00064 case ERROR_REQUEST:
00065 RioError = "REQUEST";
00066 break;
00067 case ERROR_REQUESTQUEUE:
00068 RioError = "REQUEST QUEUE";
00069 break;
00070 case ERROR_NETWORKMANAGER:
00071 RioError = "NETWORK MANAGER";
00072 break;
00073 case ERROR_ROUTER:
00074 RioError = "ROUTER";
00075 break;
00076 case ERROR_SYSTEMMANAGER:
00077 RioError = "SYSTEM MANAGER";
00078 break;
00079 case ERROR_CONNECTIONMANAGER:
00080 RioError = "CONNECTION MANAGER";
00081 break;
00082 case ERROR_PLCONNECTIONMANAGER:
00083 RioError = "PL CONNECTION MANAGER";
00084 break;
00085 case ERROR_SESSIONMANAGER:
00086 RioError = "SESSION MANAGER";
00087 break;
00088 case ERROR_PLSESSIONMANAGER:
00089 RioError = "PL SESSION MANAGER";
00090 break;
00091 case ERROR_STREAMMANAGER:
00092 RioError = "STREAM MANAGER";
00093 break;
00094 case ERROR_OBJECTMANAGER:
00095 RioError = "OBJECT MANAGER";
00096 break;
00097 case ERROR_BUFFERMANAGER:
00098 RioError = "BUFFER MANAGER";
00099 break;
00100 case ERROR_USERMANAGER:
00101 RioError = "USER MANAGER";
00102 break;
00103 case ERROR_DISKMGR:
00104 RioError = "DISK MANAGER";
00105 break;
00106 case ERROR_BITMAP:
00107 RioError = "BITMAP";
00108 break;
00109 case ERROR_CLIENT:
00110 RioError = "CLIENT";
00111 break;
00112 case ERROR_RIOTCP:
00113 RioError = "RIO TCP";
00114 break;
00115 case ERROR_RIOPROXY:
00116 RioError = "RIO PROXY";
00117 break;
00118 case ERROR_RIOSESSION:
00119 RioError = "RIO SESSION";
00120 break;
00121 case ERROR_RIOSTREAM:
00122 RioError = "RIO STREAM";
00123 break;
00124 case ERROR_RIOOBJECT:
00125 RioError = "RIO OBJECT";
00126 break;
00127 case ERROR_NETMGR:
00128 RioError = "NET MANAGER";
00129 break;
00130 case ERROR_RIONETI:
00131 RioError = "RIO NETI";
00132 break;
00133 case ERROR_EVENT:
00134 RioError = "EVENT";
00135 break;
00136 case ERROR_STREAMPOLICING:
00137 RioError = "STREAM POLICING";
00138 break;
00139
00140 case ERROR_STREAMCONTROL:
00141 RioError = "STREAM CONTROL";
00142 break;
00143
00144 case ERROR_LOGROTATION:
00145 RioError = "LOG ROTATION";
00146 break;
00147
00148 case ERROR_SEARCHLOGS:
00149 RioError = "SEARCH LOGS";
00150 break;
00151
00152 case ERROR_RIOMODULE:
00153 RioError = "RIO MODULE";
00154 break;
00155
00156 case ERROR_NETINTERFACE:
00157 RioError = "NET INTERFACE";
00158 break;
00159
00160 case ERROR_NETTCP:
00161 RioError = "NET TCP";
00162 break;
00163
00164 case ERROR_NETUDP:
00165 RioError = "NET UDP";
00166 break;
00167
00168 case ERROR_TCPSTREAMS:
00169 RioError = "TCP STREAMS";
00170 break;
00171
00172 case ERROR_TRANSFERINFO:
00173 RioError = "TRANSFER INFO";
00174 break;
00175
00176 case ERROR_TCPCONNECTION:
00177 RioError = "TCP CONNECTION";
00178 break;
00179
00180 case ERROR_SOCKET_ACCEPT_CRITICAL:
00181 RioError = "SOCKET ACCEPT CRITICAL";
00182 break;
00183
00184
00185
00186 case ERROR_SERVERUSERLOGS:
00187 RioError = "SERVER USER LOGS";
00188 break;
00189
00190
00191
00192 case ERROR_CLIENTUSERLOGS:
00193 RioError = "CLIENT USER LOGS";
00194 break;
00195
00196
00197
00198 case ERROR_SERVERINTERFACE:
00199 RioError = "SERVER INTERFACE";
00200 break;
00201 default:
00202 RioError = "UNKNOWN";
00203
00204 #ifdef RIO_DEBUG2
00205 showstack = true;
00206 #endif
00207
00208 break;
00209 }
00210
00211 switch( (error & 0x000000FF) )
00212 {
00213 case ERROR_NO_USER_ERROR:
00214 UserError = "NO USER ERROR";
00215 break;
00216 case ERROR_INITIALIZED:
00217 UserError = "INITIALIZED";
00218 break;
00219 case ERROR_NOT_INITIALIZED:
00220 UserError = "NOT INITIALIZED";
00221 break;
00222 case ERROR_STARTED:
00223 UserError = "STARTED";
00224 break;
00225 case ERROR_NOT_STARTED:
00226 UserError = "NOT STARTED";
00227 break;
00228 case ERROR_STREAM_ACTIVE:
00229 UserError = "STREAM ACTIVE";
00230 break;
00231 case ERROR_REQUEST_TYPE:
00232 UserError = "REQUEST TYPE";
00233 break;
00234 case ERROR_INVALID_STREAM:
00235 UserError = "INVALID STREAM";
00236 break;
00237 case ERROR_INVALID_PARAM:
00238 UserError = "INVALID PARAM";
00239 break;
00240 case ERROR_INVALID_OPERATION:
00241 UserError = "INVALID OPERATION";
00242 break;
00243 case ERROR_INVALID_PHYSICAL_BLOCK:
00244 UserError = "INVALID PHYSICAL BLOCK";
00245 break;
00246 case ERROR_MAX_SESSIONS:
00247 UserError = "MAX SESSIONS";
00248 break;
00249 case ERROR_INVALID_SESSION:
00250 UserError = "INVALID SESSION";
00251 break;
00252 case ERROR_MAX_STREAMS:
00253 UserError = "MAX STREAMS";
00254 break;
00255 case ERROR_STREAM_REFUSED:
00256 UserError = "STREAM REFUSED";
00257 break;
00258 case ERROR_INVALID_TRAFFIC:
00259 UserError = "INVALID TRAFFIC";
00260 break;
00261 case ERROR_INVALID_BLOCKSIZE:
00262 UserError = "INVALID BLOCK SIZE";
00263 break;
00264 case ERROR_INVALID_DIRECTION:
00265 UserError = "INVALID DIRECTION";
00266 break;
00267 case ERROR_INVALID_ACCESS_TYPE:
00268 UserError = "INVALID ACCESS TYPE";
00269 break;
00270 case ERROR_DISKFULL:
00271 UserError = "DISK FULL";
00272 break;
00273 case ERROR_LARGE_NAME:
00274 UserError = "LARGE NAME";
00275 break;
00276 case ERROR_INVALID_OBJECT_TYPE:
00277 UserError = "INVALID OBJECT TYPE";
00278 break;
00279 case ERROR_OBJECT_EXISTS:
00280 UserError = "OBJECT EXISTS";
00281 break;
00282 case ERROR_INVALID_OBJECTNAME:
00283 UserError = "INVALID OBJECT NAME";
00284 break;
00285 case ERROR_OBJECT_OPEN_FAILED:
00286 UserError = "OBJECT OPEN FAILED";
00287 break;
00288 case ERROR_OBJECT_REMOVE_FAILED:
00289 UserError = "OBJECT REMOVE FAILED";
00290 break;
00291 case ERROR_MAX_OPENED_OBJECTS:
00292 UserError = "MAX OPENED OBJECTS";
00293 break;
00294 case ERROR_INVALID_OBJECT_HANDLE:
00295 UserError = "INVALID OBJECT HANDLE";
00296 break;
00297 case ERROR_INVALID_LOGICAL_BLOCK:
00298 UserError = "INVALID LOGICAL BLOCK";
00299 break;
00300 case ERROR_NOT_EXCLUSIVE_ACCESS:
00301 UserError = "NOT EXCLUSIVE ACCESS";
00302 break;
00303 case ERROR_CONNECTED:
00304 UserError = "CONNECTED";
00305 break;
00306 case ERROR_NOTCONNECTED:
00307 UserError = "NOT CONNECTED";
00308 break;
00309 case ERROR_NOT_CLIENT:
00310 UserError = "NOT CLIENT";
00311 break;
00312 case ERROR_NOT_SERVER:
00313 UserError = "NOT SERVER";
00314 break;
00315 case ERROR_OBJECT_IS_DIRECTORY:
00316 UserError = "OBJECT IS DIRECTORY";
00317 break;
00318 case ERROR_OBJECT_NOT_DIRECTORY:
00319 UserError = "OBJECT NOT DIRECTORY";
00320 break;
00321 case ERROR_NAMEBUFFER_OVERFLOW:
00322 UserError = "NAME BUFFER OVERFLOW";
00323 break;
00324 case ERROR_NO_MORE_OBJECTS:
00325 UserError = "NO MORE OBJECTS";
00326 break;
00327 case ERROR_DIRECTORY_READ_FAILED:
00328 UserError = "DIRECTORY READ FAILED";
00329 break;
00330 case ERROR_INVALID_DIRECTORYNAME:
00331 UserError = "INVALID DIRECTORY NAME";
00332 break;
00333 case ERROR_INVALID_BLOCK:
00334 UserError = "INVALID BLOCK";
00335 break;
00336 case ERROR_MAX_STREAM_REQUESTS:
00337 UserError = "MAX STREAM REQUESTS";
00338 break;
00339 case ERROR_SESSION_ALREADY_OPENED:
00340 UserError = "SESSION ALREADY OPENED";
00341 break;
00342 case ERROR_SESSION_NOT_OPENED:
00343 UserError = "SESSION NOT OPENED";
00344 break;
00345 case ERROR_STREAM_ALREADY_OPENED:
00346 UserError = "STREAM ALREADY OPENED";
00347 break;
00348 case ERROR_STREAM_NOT_OPENED:
00349 UserError = "STREAM NOT OPENED";
00350 break;
00351 case ERROR_CAC_STREAM_NOT_OPENED:
00352 UserError = "CAC STREAM NOT OPENED";
00353 break;
00354 case ERROR_OBJECT_ALREADY_OPENED:
00355 UserError = "OBJECT ALREADY OPENED";
00356 break;
00357 case ERROR_OBJECT_NOT_OPENED:
00358 UserError = "OBJECT NOT OPENED";
00359 break;
00360 case ERROR_INVALID_USER:
00361 UserError = "INVALID USER";
00362 break;
00363 case ERROR_PATHNAME_TOOLARGE:
00364 UserError = "PATHNAME TOO LARGE";
00365 break;
00366 case ERROR_PATHNAME_BADSYNTAX:
00367 UserError = "PATHNAME BAD SYNTAX";
00368 break;
00369 case ERROR_NOT_DIRECTORY:
00370 UserError = "NOT DIRECTORY";
00371 break;
00372 case ERROR_UNEXPECTED:
00373 UserError = "UNEXPECTED";
00374 break;
00375 case ERROR_DISK_GEOMETRY:
00376 UserError = "DISK GEOMETRY";
00377 break;
00378 case ERROR_DISK_SEEK:
00379 UserError = "DISK SEEK";
00380 break;
00381 case ERROR_DISK_WRITE:
00382 UserError = "DISK WRITE";
00383 break;
00384 case ERROR_DISK_READ:
00385 UserError = "DISK READ";
00386 break;
00387 case ERROR_CREATE_EVENT:
00388 UserError = "CREATE EVENT";
00389 break;
00390 case ERROR_SET_EVENT:
00391 UserError = "SET EVENT";
00392 break;
00393 case ERROR_RESET_EVENT:
00394 UserError = "RESET EVENT";
00395 break;
00396 case ERROR_WAIT_EVENT:
00397 UserError = "WAIT EVENT";
00398 break;
00399 case ERROR_CREATE_THREAD:
00400 UserError = "CREATE THREAD";
00401 break;
00402 case ERROR_WAIT_THREAD:
00403 UserError = "WAIT THREAD";
00404 break;
00405 case ERROR_THREAD_ATTRIB:
00406 UserError = "THREAD ATTRIB";
00407 break;
00408 case ERROR_CREATE_MUTEX:
00409 UserError = "CREATE MUTEX";
00410 break;
00411 case ERROR_WAIT_MUTEX:
00412 UserError = "WAIT MUTEX";
00413 break;
00414 case ERROR_RELEASE_MUTEX:
00415 UserError = "RELEASE MUTEX";
00416 break;
00417 case ERROR_CREATE_SEMAPHORE:
00418 UserError = "CREATE SEMAPHORE";
00419 break;
00420 case ERROR_CREATE_INSTANCE:
00421 UserError = "CREATE INSTANCE";
00422 break;
00423 case ERROR_QUERY_INTERFACE:
00424 UserError = "QUERY INTERFACE";
00425 break;
00426 case ERROR_MEMORY:
00427 UserError = "MEMORY";
00428 break;
00429 case ERROR_METADATA_CORRUPTED:
00430 UserError = "METADATA CORRUPTED";
00431 break;
00432 case ERROR_OBJECT_METADATA_WRITE:
00433 UserError = "OBJECT METADATA WRITE";
00434 break;
00435 case ERROR_OBJECT_METADATA_CORRUPTED:
00436 UserError = "OBJECT METADATA CORRUPTED";
00437 break;
00438 case ERROR_DISK_OPEN:
00439 UserError = "DISK OPEN";
00440 break;
00441 case ERROR_SYSTEM_CONFIGURATION:
00442 UserError = "SYSTEM CONFIGURATION";
00443 break;
00444 case ERROR_SOCKET_LIBRARY:
00445 UserError = "SOCKET LIBRARY";
00446 break;
00447 case ERROR_SOCKET_CREATE:
00448 UserError = "SOCKET CREATE";
00449 break;
00450 case ERROR_SOCKET_BIND:
00451 UserError = "SOCKET BIND";
00452 break;
00453 case ERROR_SOCKET_LISTEN:
00454 UserError = "SOCKET LISTEN";
00455 break;
00456 case ERROR_SOCKET_RECEIVE:
00457 UserError = "SOCKET RECEIVE";
00458 break;
00459 case ERROR_SOCKET_CONNECT:
00460 UserError = "SOCKET CONNECT";
00461 break;
00462 case ERROR_SOCKET_ACCEPT:
00463 UserError = "SOCKET ACCEPT";
00464 break;
00465 case ERROR_LOCALHOSTNAME:
00466 UserError = "LOCAL HOST NAME";
00467 break;
00468 case ERROR_HOSTBYNAME:
00469 UserError = "HOST BY NAME";
00470 break;
00471 case ERROR_HOST_NOTFOUND:
00472 UserError = "HOST NOT FOUND";
00473 break;
00474 case ERROR_SOCKET_SEND:
00475 UserError = "SOCKET SEND";
00476 break;
00477 case ERROR_SOCKET_REFUSED_CONNECTION:
00478 UserError = "SOCKET REFUSED CONNECTION";
00479 break;
00480 case ERROR_RIO_PROTOCOL:
00481 UserError = "RIO PROTOCOL";
00482 break;
00483 case ERROR_INVALID_VERSION:
00484 UserError = "INVALID VERSION";
00485 break;
00486 case ERROR_INVALID_DISK:
00487 UserError = "INVALID DISK";
00488 break;
00489 case ERROR_QUEUE_EMPTY:
00490 UserError = "QUEUE EMPTY";
00491 break;
00492 case ERROR_INVALID_CLASS:
00493 UserError = "INVALID CLASS";
00494 break;
00495 case ERROR_INVALID_METHOD_PARAM:
00496 UserError = "INVALID METHOD PARAM";
00497 break;
00498 case ERROR_INVALID_METHOD:
00499 UserError = "INVALID METHOD";
00500 break;
00501 case ERROR_RESULT_MESSAGE_OVERFLOW:
00502 UserError = "RESULT MESSAGE OVERFLOW";
00503 break;
00504 case ERROR_MAX_STORAGE_NODES:
00505 UserError = "MAX STORAGE NODES";
00506 break;
00507 case ERROR_MESSAGE_DATA_FORMAT:
00508 UserError = "MESSAGE DATA FORMAT";
00509 break;
00510 case ERROR_CALL_MESSAGE_OVERFLOW:
00511 UserError = "CALL MESSAGE OVERFLOW";
00512 break;
00513 case ERROR_INVALID_BUFFER:
00514 UserError = "INVALID BUFFER";
00515 break;
00516 case ERROR_LOGFILE:
00517 UserError = "LOG FILE";
00518 break;
00519 case ERROR_CREATE_CONFIGFILE:
00520 UserError = "CREATE CONFIG FILE";
00521 break;
00522 case ERROR_OPEN_CONFIGFILE:
00523 UserError = "OPEN CONFIG FILE";
00524 break;
00525 case ERROR_INVALID_CONFIGFILE:
00526 UserError = "INVALID CONFIG FILE";
00527 break;
00528 case ERROR_LARGE_ROOTNAME:
00529 UserError = "LARGE ROOT NAME";
00530 break;
00531 case ERROR_CREATE_ROOT:
00532 UserError = "CREATE ROOT";
00533 break;
00534 case ERROR_CLOSED_CONNECTION:
00535 UserError = "CLOSED CONNECTION";
00536 break;
00537 case ERROR_PERMISSION_DENIED:
00538 UserError = "PERMISSION DENIED";
00539 break;
00540
00541 case ERROR_LOGFILE_OPEN_FAILED:
00542 UserError = "LOGFILE OPEN FAILED";
00543 break;
00544 case ERROR_LOGFILE_READ_FAILED:
00545 UserError = "LOGFILE READ FAILED";
00546 break;
00547 case ERROR_LOGFILE_WRITE_FAILED:
00548 UserError = "LOGFILE WRITE FAILED";
00549 break;
00550 case ERROR_LOGFILE_CLOSE_FAILED:
00551 UserError = "LOGFILE CLOSE FAILED";
00552 break;
00553 case ERROR_LOGFILE_LINE_FORMAT:
00554 UserError = "LOGFILE LINE FORMAT";
00555 break;
00556 case ERROR_LOGFILE_FILENAME_FORMAT:
00557 UserError = "LOGFILE FILENAME FORMAT";
00558 break;
00559 case ERROR_LOGFILES_LIST:
00560 UserError = "LOGFILES LIST";
00561 break;
00562 case ERROR_LOGLINE_TOOLARGE:
00563 UserError = "LOGLINE TOOLARGE";
00564 break;
00565 case ERROR_LOGFILE_REMOVE_FAILED:
00566 UserError = "LOGFILE REMOVE FAILED";
00567 break;
00568 case ERROR_LOGROTATION_SEARCH_FAILED:
00569 UserError = "LOGROTATION SEARCH FAILED";
00570 break;
00571 case ERROR_INITIALIZE_LOGROTATION:
00572 UserError = "INITIALIZE LOGROTATION";
00573 break;
00574 case ERROR_CREATE_SEARCHRESULT_FILENAME:
00575 UserError = "CREATE SEARCHRESULT FILENAME";
00576 break;
00577 case ERROR_OPEN_SEARCHRESULT_FILE:
00578 UserError = "OPEN SEARCHRESULT FILE";
00579 break;
00580 case ERROR_READ_SEARCHRESULT_FILE:
00581 UserError = "READ SEARCHRESULT FILE";
00582 break;
00583 case ERROR_INVALID_SEARCHRESULT_IDENTIFICATION:
00584 UserError = "INVALID SEARCHRESULT IDENTIFICATION";
00585 break;
00586 case ERROR_REMOVE_SEARCHRESULT_FILE:
00587 UserError = "REMOVE SEARCHRESULT FILE";
00588 break;
00589 case ERROR_INITIALIZE_SEARCHLOGS:
00590 UserError = "INITIALIZE SEARCHLOGS";
00591 break;
00592 case ERROR_SEARCHLOGS_SEARCH_TYPE:
00593 UserError = "SEARCHLOGS SEARCH TYPE";
00594 break;
00595 case ERROR_SEARCHLOGS_TIME_INTERVAL:
00596 UserError = "SEARCHLOGS TIME INTERVAL";
00597 break;
00598
00599
00600
00601 case ERROR_SERVICE_TEMPORARY_UNAVAILABLE:
00602 UserError = "SERVICE TEMPORARY UNAVAILABLE";
00603 break;
00604
00605
00606 case ERROR_OPEN_FREEBLOCKS_FILE:
00607 UserError = "OPEN FREEBLOCKS FILE";
00608 break;
00609
00610
00611 case ERROR_OBJECT_NOT_DEFINED:
00612 UserError = "OBJECT NOT DEFINED";
00613 break;
00614
00615
00616 case ERROR_SERVER_NOT_DEFINED:
00617 UserError = "SERVER NOT DEFINED";
00618 break;
00619
00620
00621 case ERROR_INVALID_MODULE_POLICY:
00622 UserError = "INVALID MODULE POLICY";
00623 break;
00624
00625 case ERROR_SOCKET_TIMEOUT:
00626 UserError = "SOCKET TIMEOUT";
00627 break;
00628
00629
00630 case ERROR_SOCKETS_SELECT:
00631 UserError = "SOCKETS SELECT";
00632 break;
00633
00634
00635 case ERROR_NOT_IMPLEMENTED:
00636 UserError = "NOT IMPLEMENTED";
00637 break;
00638
00639 case ERROR_IOCTL_FAILED:
00640 UserError = "IOCTL FAILED";
00641 break;
00642
00643 case ERROR_SOCKET_CLOSED:
00644 UserError = "SOCKET CLOSED";
00645 break;
00646
00647
00648 case ERROR_PROCESS_TERMINATED:
00649 UserError = "PROCESS TERMINATED";
00650 break;
00651
00652
00653 case ERROR_INVALID_TRANSFERID:
00654 UserError = "INVALID TRANSFERID";
00655 break;
00656
00657
00658 case ERROR_INVALID_HOST:
00659 UserError = "INVALID HOST";
00660 break;
00661
00662
00663 case ERROR_LOGLINE_NOT_DEFINED:
00664 UserError = "LOGLINE NOT DEFINED";
00665 break;
00666
00667
00668 case ERROR_COMMAND_NOT_DEFINED:
00669 UserError = "COMMAND NOT DEFINED";
00670 break;
00671
00672
00673 case ERROR_INVALID_COMMAND:
00674 UserError = "INVALID COMMAND";
00675 break;
00676
00677
00678 case ERROR_COMMAND_SYNTAX:
00679 UserError = "COMMAND SYNTAX";
00680 break;
00681
00682
00683
00684 case ERROR_SESSIONID_NOT_DEFINED:
00685 UserError = "SESSIONID NOT DEFINED";
00686 break;
00687
00688
00689
00690 case ERROR_SESSIONID_ALREADY_DEFINED:
00691 UserError = "SESSIONID ALREADY DEFINED";
00692 break;
00693
00694
00695 case ERROR_COPYING_OBJECT:
00696 UserError = "COPYING OBJECT";
00697 break;
00698
00699
00700 case ERROR_HTTPS_REQUIRED:
00701 UserError = "HTTPS REQUIRED";
00702 break;
00703
00704 case ERROR_USER_EXISTS:
00705 UserError = "USER EXISTS";
00706 break;
00707
00708 case ERROR_INVALID_USER_DIRECTORY:
00709 UserError = "INVALID USER DIRECTORY";
00710 break;
00711
00712
00713 case ERROR_RIOPASSWORD_FILE:
00714 UserError = "RIOPASSWORD FILE";
00715 break;
00716 default:
00717 UserError = "UNKNOWN";
00718
00719 #ifdef RIO_DEBUG2
00720 showstack = true;
00721 #endif
00722
00723 break;
00724 }
00725
00726 #ifdef RIO_DEBUG2
00727 if( showstack )
00728 {
00729 RioErr << "error = " << error << endl;
00730 RioErr << "RioError:UserError= " << RioError << ":" << UserError
00731 << endl;
00732
00733 void *trace[16];
00734 char **messages = (char **)NULL;
00735 int i, trace_size = 0;
00736
00737 trace_size = backtrace( trace, 16 );
00738 messages = backtrace_symbols( trace, trace_size );
00739 RioErr << "[RioError] Execution path (SERVER DID NOT EXPLODE!):"
00740 << endl;
00741 for( i = 0; i < trace_size; ++i )
00742 RioErr << "[RioError(" << i << "/" << trace_size << ")] "
00743 << messages[i] << endl;
00744
00745 free( messages );
00746 }
00747 #endif
00748
00749 return RioError + ": " + UserError;
00750 }
00751
00752 void Rioperror( const char * msg )
00753 {
00754 int err;
00755 err = errno;
00756
00757 RioErr << msg << ": " << strerror( err ) << endl;
00758 }
00759
00760
00761
00762
00763
00764
00765
00766
00767 debugCerr RioErr;
00768 pthread_mutexattr_t err_mutex_attr;
00769 pthread_mutex_t err_mutex;
00770 bool printHeader;
00771
00772 debugCerr::debugCerr()
00773 {
00774 pthread_mutexattr_init( &err_mutex_attr );
00775 pthread_mutexattr_settype( &err_mutex_attr, PTHREAD_MUTEX_RECURSIVE );
00776 pthread_mutex_init( &err_mutex, &err_mutex_attr );
00777 printHeader = true;
00778 }
00779
00780 char *myInfo( bool parseHour )
00781 {
00782 struct tm *date;
00783 time_t segundos;
00784 ostringstream s;
00785 char *info;
00786
00787 FILE *processfiledesc;
00788 char processfilename[ MaxPathSize ];
00789
00790 time( &segundos );
00791
00792
00793 s << "[TID:" << pthread_self() << ",LWP:" << syscall( SYS_gettid ) << "|";
00794
00795 if( parseHour == true )
00796 {
00797 date = localtime( &segundos );
00798 s << date->tm_hour << ":" << date->tm_min << ":" << date->tm_sec;
00799 }
00800 else
00801 {
00802 s << segundos;
00803 }
00804
00805
00806
00807 sprintf( processfilename, "/proc/%u/stat", getpid() );
00808 processfiledesc = fopen( processfilename, "r" );
00809 if( processfiledesc != NULL )
00810 {
00811 unsigned long usedmemory;
00812 int processed;
00813 processed = fscanf(processfiledesc,
00814 "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %*u %*u %*d %*d %*d %*d %*d %*d %*u %lu",
00815 &usedmemory );
00816 fclose( processfiledesc );
00817 if( processed == 1 )
00818 s << "|" << usedmemory;
00819 }
00820 s << "] ";
00821
00822 info = strdup( s.str().c_str() );
00823 return info;
00824 }
00825
00826 void showtimenow( string msg )
00827 {
00828 static struct timeval velhoold;
00829 static bool primeiravez = true;
00830 struct timeval now;
00831
00832 gettimeofday( &now, 0 );
00833
00834 if( !primeiravez )
00835 {
00836 RioErr << "PID: " << pthread_self() << " - intervalo: "
00837 << (now.tv_sec*1000000+now.tv_usec)-
00838 (velhoold.tv_sec*1000000+velhoold.tv_usec)
00839 << " (" << msg << ")" << endl;
00840 }
00841 else
00842 {
00843 RioErr << "PID: " << pthread_self() << " - Tempo 0"
00844 << " (" << msg << ")." << endl;
00845
00846 primeiravez = false;
00847 }
00848
00849 velhoold = now;
00850 }
00851
00852 debugCerr &debugCerr::operator<<( bool val )
00853 {
00854 pthread_mutex_lock( &err_mutex );
00855
00856 if( printHeader )
00857 {
00858 void *trace[ 32 ];
00859 char *myinfo;
00860 int trace_size = backtrace( trace, 32 ) - 4;
00861
00862
00863
00864 myinfo = myInfo();
00865 cerr << myinfo;
00866 free( myinfo );
00867 for( int j = trace_size; j > 0; j-- ) cerr << " ";
00868 cerr << "[" << trace_size << "] " << val;
00869 printHeader = false;
00870 }
00871 else
00872 {
00873 cerr << val;
00874 pthread_mutex_unlock( &err_mutex );
00875 }
00876
00877 return *this;
00878 }
00879
00880 debugCerr &debugCerr::operator<<( short val )
00881 {
00882 pthread_mutex_lock( &err_mutex );
00883
00884 if( printHeader )
00885 {
00886 void *trace[ 32 ];
00887 char *myinfo;
00888 int trace_size = backtrace( trace, 32 ) - 4;
00889
00890
00891
00892 myinfo = myInfo();
00893 cerr << myinfo;
00894 free( myinfo );
00895 for( int j = trace_size; j > 0; j-- ) cerr << " ";
00896 cerr << "[" << trace_size << "] " << val;
00897 printHeader = false;
00898 }
00899 else
00900 {
00901 cerr << val;
00902 pthread_mutex_unlock( &err_mutex );
00903 }
00904
00905 return *this;
00906 }
00907
00908 debugCerr &debugCerr::operator<<( unsigned short val )
00909 {
00910 pthread_mutex_lock( &err_mutex );
00911
00912 if( printHeader )
00913 {
00914 void *trace[ 32 ];
00915 char *myinfo;
00916 int trace_size = backtrace( trace, 32 ) - 4;
00917
00918
00919
00920 myinfo = myInfo();
00921 cerr << myinfo;
00922 free( myinfo );
00923 for( int j = trace_size; j > 0; j-- ) cerr << " ";
00924 cerr << "[" << trace_size << "] " << val;
00925 printHeader = false;
00926 }
00927 else
00928 {
00929 cerr << val;
00930 pthread_mutex_unlock( &err_mutex );
00931 }
00932
00933 return *this;
00934 }
00935
00936 debugCerr &debugCerr::operator<<( int val )
00937 {
00938 pthread_mutex_lock( &err_mutex );
00939
00940 if( printHeader )
00941 {
00942 void *trace[ 32 ];
00943 char *myinfo;
00944 int trace_size = backtrace( trace, 32 ) - 4;
00945
00946
00947
00948 myinfo = myInfo();
00949 cerr << myinfo;
00950 free( myinfo );
00951 for( int j = trace_size; j > 0; j-- ) cerr << " ";
00952 cerr << "[" << trace_size << "] " << val;
00953 printHeader = false;
00954 }
00955 else
00956 {
00957 cerr << val;
00958 pthread_mutex_unlock( &err_mutex );
00959 }
00960
00961 return *this;
00962 }
00963
00964 debugCerr &debugCerr::operator<<( unsigned int val )
00965 {
00966 pthread_mutex_lock( &err_mutex );
00967
00968 if( printHeader )
00969 {
00970 void *trace[ 32 ];
00971 char *myinfo;
00972 int trace_size = backtrace( trace, 32 ) - 4;
00973
00974
00975
00976 myinfo = myInfo();
00977 cerr << myinfo;
00978 free( myinfo );
00979 for( int j = trace_size; j > 0; j-- ) cerr << " ";
00980 cerr << "[" << trace_size << "] " << val;
00981 printHeader = false;
00982 }
00983 else
00984 {
00985 cerr << val;
00986 pthread_mutex_unlock( &err_mutex );
00987 }
00988
00989 return *this;
00990 }
00991
00992 debugCerr &debugCerr::operator<<( long val )
00993 {
00994 pthread_mutex_lock( &err_mutex );
00995
00996 if( printHeader )
00997 {
00998 void *trace[ 32 ];
00999 char *myinfo;
01000 int trace_size = backtrace( trace, 32 ) - 4;
01001
01002
01003
01004 myinfo = myInfo();
01005 cerr << myinfo;
01006 free( myinfo );
01007 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01008 cerr << "[" << trace_size << "] " << val;
01009 printHeader = false;
01010 }
01011 else
01012 {
01013 cerr << val;
01014 pthread_mutex_unlock( &err_mutex );
01015 }
01016
01017 return *this;
01018 }
01019
01020 debugCerr &debugCerr::operator<<( unsigned long val )
01021 {
01022 pthread_mutex_lock( &err_mutex );
01023
01024 if( printHeader )
01025 {
01026 void *trace[ 32 ];
01027 char *myinfo;
01028 int trace_size = backtrace( trace, 32 ) - 4;
01029
01030
01031
01032 myinfo = myInfo();
01033 cerr << myinfo;
01034 free( myinfo );
01035 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01036 cerr << "[" << trace_size << "] " << val;
01037 printHeader = false;
01038 }
01039 else
01040 {
01041 cerr << val;
01042 pthread_mutex_unlock( &err_mutex );
01043 }
01044
01045 return *this;
01046 }
01047
01048 debugCerr &debugCerr::operator<<( long long int val )
01049 {
01050 pthread_mutex_lock( &err_mutex );
01051
01052 if( printHeader )
01053 {
01054 void *trace[ 32 ];
01055 char *myinfo;
01056 int trace_size = backtrace( trace, 32 ) - 4;
01057
01058
01059
01060 myinfo = myInfo();
01061 cerr << myinfo;
01062 free( myinfo );
01063 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01064 cerr << "[" << trace_size << "] " << val;
01065 printHeader = false;
01066 }
01067 else
01068 {
01069 cerr << val;
01070 pthread_mutex_unlock( &err_mutex );
01071 }
01072
01073 return *this;
01074 }
01075
01076 debugCerr &debugCerr::operator<<( unsigned long long int val )
01077 {
01078 pthread_mutex_lock( &err_mutex );
01079
01080 if( printHeader )
01081 {
01082 void *trace[ 32 ];
01083 char *myinfo;
01084 int trace_size = backtrace( trace, 32 ) - 4;
01085
01086
01087
01088 myinfo = myInfo();
01089 cerr << myinfo;
01090 free( myinfo );
01091 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01092 cerr << "[" << trace_size << "] " << val;
01093 printHeader = false;
01094 }
01095 else
01096 {
01097 cerr << val;
01098 pthread_mutex_unlock( &err_mutex );
01099 }
01100
01101 return *this;
01102 }
01103
01104 debugCerr &debugCerr::operator<<( float val )
01105 {
01106 pthread_mutex_lock( &err_mutex );
01107
01108 if( printHeader )
01109 {
01110 void *trace[ 32 ];
01111 char *myinfo;
01112 int trace_size = backtrace( trace, 32 ) - 4;
01113
01114
01115
01116 myinfo = myInfo();
01117 cerr << myinfo;
01118 free( myinfo );
01119 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01120 cerr << "[" << trace_size << "] " << val;
01121 printHeader = false;
01122 }
01123 else
01124 {
01125 cerr << val;
01126 pthread_mutex_unlock( &err_mutex );
01127 }
01128
01129 return *this;
01130 }
01131
01132 debugCerr &debugCerr::operator<<( double val )
01133 {
01134 pthread_mutex_lock( &err_mutex );
01135
01136 if( printHeader )
01137 {
01138 void *trace[ 32 ];
01139 char *myinfo;
01140 int trace_size = backtrace( trace, 32 ) - 4;
01141
01142
01143
01144 myinfo = myInfo();
01145 cerr << myinfo;
01146 free( myinfo );
01147 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01148 cerr << "[" << trace_size << "] " << val;
01149 printHeader = false;
01150 }
01151 else
01152 {
01153 cerr << val;
01154 pthread_mutex_unlock( &err_mutex );
01155 }
01156
01157 return *this;
01158 }
01159
01160 debugCerr &debugCerr::operator<<( long double val )
01161 {
01162 pthread_mutex_lock( &err_mutex );
01163
01164 if( printHeader )
01165 {
01166 void *trace[ 32 ];
01167 char *myinfo;
01168 int trace_size = backtrace( trace, 32 ) - 4;
01169
01170
01171
01172 myinfo = myInfo();
01173 cerr << myinfo;
01174 free( myinfo );
01175 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01176 cerr << "[" << trace_size << "] " << val;
01177 printHeader = false;
01178 }
01179 else
01180 {
01181 cerr << val;
01182 pthread_mutex_unlock( &err_mutex );
01183 }
01184
01185 return *this;
01186 }
01187
01188 debugCerr &debugCerr::operator<<( void* val )
01189 {
01190 pthread_mutex_lock( &err_mutex );
01191
01192 if( printHeader )
01193 {
01194 void *trace[ 32 ];
01195 char *myinfo;
01196 int trace_size = backtrace( trace, 32 ) - 4;
01197
01198
01199
01200 myinfo = myInfo();
01201 cerr << myinfo;
01202 free( myinfo );
01203 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01204 cerr << "[" << trace_size << "] " << val;
01205 printHeader = false;
01206 }
01207 else
01208 {
01209 cerr << val;
01210 pthread_mutex_unlock( &err_mutex );
01211 }
01212
01213 return *this;
01214 }
01215
01216 debugCerr &debugCerr::operator<<( streambuf* sb )
01217 {
01218 pthread_mutex_lock( &err_mutex );
01219
01220 if( printHeader )
01221 {
01222 void *trace[ 32 ];
01223 char *myinfo;
01224 int trace_size = backtrace( trace, 32 ) - 4;
01225
01226
01227
01228 myinfo = myInfo();
01229 cerr << myinfo;
01230 free( myinfo );
01231 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01232 cerr << "[" << trace_size << "] " << sb;
01233 printHeader = false;
01234 }
01235 else
01236 {
01237 cerr << sb;
01238 pthread_mutex_unlock( &err_mutex );
01239 }
01240
01241 return *this;
01242 }
01243
01244
01245
01246 debugCerr &debugCerr::operator<< ( ostream& ( *pf )( ostream& ) )
01247 {
01248 pthread_mutex_lock( &err_mutex );
01249 cerr << pf;
01250 if( ( !printHeader ) &&
01251 ( pf == static_cast < std::ostream& ( * )( std::ostream& ) >( &std::endl )
01252 ) )
01253 {
01254 printHeader = true;
01255 pthread_mutex_unlock( &err_mutex );
01256 }
01257 fflush( stderr );
01258 pthread_mutex_unlock( &err_mutex );
01259 return *this;
01260 }
01261
01262
01263 debugCerr &debugCerr::operator<< ( ios& ( *pf )( ios& ) ){
01264 pthread_mutex_lock( &err_mutex );
01265 cerr << pf;
01266 pthread_mutex_unlock( &err_mutex );
01267 return *this;
01268 }
01269
01270
01271
01272 debugCerr &debugCerr::operator<< ( ios_base& ( *pf )( ios_base& ) ){
01273 pthread_mutex_lock( &err_mutex );
01274 cerr << pf;
01275 pthread_mutex_unlock( &err_mutex );
01276 return *this;
01277 }
01278
01279
01280
01281 debugCerr &operator<<( debugCerr& out, char c )
01282 {
01283 pthread_mutex_lock( &err_mutex );
01284
01285 if( printHeader )
01286 {
01287 void *trace[ 32 ];
01288 char *myinfo;
01289 int trace_size = backtrace( trace, 32 ) - 4;
01290
01291
01292
01293 myinfo = myInfo();
01294 cerr << myinfo;
01295 free( myinfo );
01296 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01297 cerr << "[" << trace_size << "] " << c;
01298 printHeader = false;
01299 }
01300 else
01301 {
01302 cerr << c;
01303 pthread_mutex_unlock( &err_mutex );
01304 }
01305
01306 return out;
01307 }
01308
01309 debugCerr &operator<<( debugCerr& out, signed char c )
01310 {
01311 pthread_mutex_lock( &err_mutex );
01312
01313 if( printHeader )
01314 {
01315 void *trace[ 32 ];
01316 char *myinfo;
01317 int trace_size = backtrace( trace, 32 ) - 4;
01318
01319
01320
01321 myinfo = myInfo();
01322 cerr << myinfo;
01323 free( myinfo );
01324 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01325 cerr << "[" << trace_size << "] " << c;
01326 printHeader = false;
01327 }
01328 else
01329 {
01330 cerr << c;
01331 pthread_mutex_unlock( &err_mutex );
01332 }
01333
01334 return out;
01335 }
01336
01337 debugCerr &operator<<( debugCerr& out, unsigned char c )
01338 {
01339 pthread_mutex_lock( &err_mutex );
01340
01341 if( printHeader )
01342 {
01343 void *trace[ 32 ];
01344 char *myinfo;
01345 int trace_size = backtrace( trace, 32 ) - 4;
01346
01347
01348
01349 myinfo = myInfo();
01350 cerr << myinfo;
01351 free( myinfo );
01352 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01353 cerr << "[" << trace_size << "] " << c;
01354 printHeader = false;
01355 }
01356 else
01357 {
01358 cerr << c;
01359 pthread_mutex_unlock( &err_mutex );
01360 }
01361
01362 return out;
01363 }
01364
01365 debugCerr &operator<<( debugCerr& out, const char *s )
01366 {
01367 pthread_mutex_lock( &err_mutex );
01368
01369 if( printHeader )
01370 {
01371 void *trace[ 32 ];
01372 char *myinfo;
01373 int trace_size = backtrace( trace, 32 ) - 4;
01374
01375
01376
01377 myinfo = myInfo();
01378 cerr << myinfo;
01379 free( myinfo );
01380 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01381 cerr << "[" << trace_size << "] " << s;
01382 printHeader = false;
01383 }
01384 else
01385 {
01386 cerr << s;
01387 pthread_mutex_unlock( &err_mutex );
01388 }
01389
01390 return out;
01391 }
01392
01393 debugCerr &operator<<( debugCerr& out, const signed char *s )
01394 {
01395 pthread_mutex_lock( &err_mutex );
01396
01397 if( printHeader )
01398 {
01399 void *trace[ 32 ];
01400 char *myinfo;
01401 int trace_size = backtrace( trace, 32 ) - 4;
01402
01403
01404
01405 myinfo = myInfo();
01406 cerr << myinfo;
01407 free( myinfo );
01408 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01409 cerr << "[" << trace_size << "] " << s;
01410 printHeader = false;
01411 }
01412 else
01413 {
01414 cerr << s;
01415 pthread_mutex_unlock( &err_mutex );
01416 }
01417
01418 return out;
01419 }
01420
01421 debugCerr &operator<<( debugCerr& out, const unsigned char *s )
01422 {
01423 pthread_mutex_lock( &err_mutex );
01424
01425 if( printHeader )
01426 {
01427 void *trace[ 32 ];
01428 char *myinfo;
01429 int trace_size = backtrace( trace, 32 ) - 4;
01430
01431
01432
01433 myinfo = myInfo();
01434 cerr << myinfo;
01435 free( myinfo );
01436 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01437 cerr << "[" << trace_size << "] " << s;
01438 printHeader = false;
01439 }
01440 else
01441 {
01442 cerr << s;
01443 pthread_mutex_unlock( &err_mutex );
01444 }
01445
01446 return out;
01447 }
01448
01449 debugCerr &operator<<( debugCerr& out, string s )
01450 {
01451 pthread_mutex_lock( &err_mutex );
01452
01453 if( printHeader )
01454 {
01455 void *trace[ 32 ];
01456 char *myinfo;
01457 int trace_size = backtrace( trace, 32 ) - 4;
01458
01459
01460
01461 myinfo = myInfo();
01462 cerr << myinfo;
01463 free( myinfo );
01464 for( int j = trace_size; j > 0; j-- ) cerr << " ";
01465 cerr << "[" << trace_size << "] " << s;
01466 printHeader = false;
01467 }
01468 else
01469 {
01470 cerr << s;
01471 pthread_mutex_unlock( &err_mutex );
01472 }
01473
01474 return out;
01475 }