RioError.cpp File Reference

#include "RioError.h"
#include "RioInterfaceTypes.h"
#include "iostream"
#include <pthread.h>
#include <execinfo.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/syscall.h>

Go to the source code of this file.

Functions

string GetErrorDescription (const unsigned int error)
void Rioperror (const char *msg)
char * myInfo (bool parseHour)
void showtimenow (string msg)
debugCerr & operator<< (debugCerr &out, char c)
debugCerr & operator<< (debugCerr &out, signed char c)
debugCerr & operator<< (debugCerr &out, unsigned char c)
debugCerr & operator<< (debugCerr &out, const char *s)
debugCerr & operator<< (debugCerr &out, const signed char *s)
debugCerr & operator<< (debugCerr &out, const unsigned char *s)
debugCerr & operator<< (debugCerr &out, string s)

Variables

debugCerr RioErr
 RioErr � a inst�ncia global da classe debugCerr utilizada para exibir mensagens de debug.
pthread_mutexattr_t err_mutex_attr
pthread_mutex_t err_mutex
bool printHeader

Function Documentation

string GetErrorDescription ( const unsigned int  error  ) 

Definition at line 41 of file RioError.cpp.

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         // Novo erro da classe StreamControl de controle do fluxo.     
00140         case ERROR_STREAMCONTROL:
00141              RioError = "STREAM CONTROL";
00142              break;
00143         // Novo erro da classe CLogRotation de impressao de logs.     
00144         case ERROR_LOGROTATION:
00145              RioError = "LOG ROTATION";
00146              break;
00147         // Novo erro da classe CSearchLogs para a busca nos logs.     
00148         case ERROR_SEARCHLOGS:
00149              RioError = "SEARCH LOGS";
00150              break;
00151         // Novo erro usado pelo modulo do apache
00152         case ERROR_RIOMODULE:
00153              RioError = "RIO MODULE";
00154              break;
00155         // Novo erro usado pela classe CNetInterface.
00156         case ERROR_NETINTERFACE:       
00157              RioError = "NET INTERFACE";
00158              break;
00159         // Novo erro usado pela classe CNetTCP.       
00160         case ERROR_NETTCP:       
00161              RioError = "NET TCP";
00162              break;
00163         // Novo erro usado pela classe CNetUDP.       
00164         case ERROR_NETUDP:       
00165              RioError = "NET UDP";
00166              break;
00167         // Novo erro usado pela classe CTcpStreams.
00168         case ERROR_TCPSTREAMS:
00169              RioError = "TCP STREAMS";
00170              break;
00171         // Novo erro para a classe CTransferInfo.
00172         case ERROR_TRANSFERINFO:
00173              RioError = "TRANSFER INFO";
00174              break;     
00175         // Novo erro para a nova classe de gerenciamento de uma conexao TCP.
00176         case ERROR_TCPCONNECTION:
00177              RioError = "TCP CONNECTION";
00178              break;     
00179         // Novo erro para indicar um erro critico no accept
00180         case ERROR_SOCKET_ACCEPT_CRITICAL:
00181              RioError = "SOCKET ACCEPT CRITICAL";
00182              break;
00183         // Novo erro para a nova classe para salvar os logs de comportamento do
00184         // cliente pelo modulo (parte "servidora", que recebe as linhas de log
00185         // pelo socket UDP e as coloca no log.
00186         case ERROR_SERVERUSERLOGS:
00187              RioError = "SERVER USER LOGS";
00188              break;
00189         // Novo erro para a nova classe para salvar os logs de comportamento do
00190         // cliente pelo modulo (parte "cliente", que envia as linhas de log pelo
00191         // socket UDP para serem salvas).
00192         case ERROR_CLIENTUSERLOGS:
00193              RioError = "CLIENT USER LOGS";
00194              break;
00195         // Novo erro para a nova classe usada para fazer a interface com o
00196         // servidor RIO. Esta classe, alem de enviar e receber arquivos pela
00197         // conexao TCP, ira tambem executar comandos do riosh.
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         // Erros gerados pela implementacao de logs.
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         // Novo erro gerado quando o numero de servidores de armazenamento
00599         // ativos deixa de permitir que os servicos sejam corratamente
00600         // garantidos.
00601         case ERROR_SERVICE_TEMPORARY_UNAVAILABLE:
00602              UserError = "SERVICE TEMPORARY UNAVAILABLE";
00603              break;
00604         // Novo erro para indicar que nao foi possivel ler o arquivo que 
00605         // armazena os blocos a serem liberados de um servidor de armazenamento
00606         case ERROR_OPEN_FREEBLOCKS_FILE:
00607              UserError = "OPEN FREEBLOCKS FILE";
00608              break;     
00609         // Novo erro, gerado pelo modulo, para indicar que nao foi passado um
00610         // nome de objeto para ser lido/gravado.
00611         case ERROR_OBJECT_NOT_DEFINED:
00612              UserError = "OBJECT NOT DEFINED";
00613              break;     
00614         // Novo erro usado para indicar que nenhum nome foi definido para um 
00615         // servidor.
00616         case ERROR_SERVER_NOT_DEFINED:
00617              UserError = "SERVER NOT DEFINED";
00618              break;
00619         // Novo erro usado para indicar que um nome incorreto foi passado ao 
00620         // modulo.
00621         case ERROR_INVALID_MODULE_POLICY:
00622              UserError = "INVALID MODULE POLICY";
00623              break;
00624         // Novo erro usado para indicar que uma conexao TCP fechou por timeout.
00625         case ERROR_SOCKET_TIMEOUT:
00626              UserError = "SOCKET TIMEOUT";
00627              break;
00628         // Novo erro usado para indicar que ocorreu um erro ao executar o 
00629         // select.     
00630         case ERROR_SOCKETS_SELECT:
00631              UserError = "SOCKETS SELECT";
00632              break;
00633         // Novo erro usado para indicar que um recursos ainda nao foi 
00634         // implememtado.
00635         case ERROR_NOT_IMPLEMENTED:
00636              UserError = "NOT IMPLEMENTED";
00637              break;
00638         // Novo erro usado para indicar que uma chamada a funcao ioctl falhou.
00639         case ERROR_IOCTL_FAILED:
00640              UserError = "IOCTL FAILED";
00641              break;
00642         // Novo erro usado para indicar que o socket foi fechado.
00643         case ERROR_SOCKET_CLOSED:
00644              UserError = "SOCKET CLOSED";
00645              break;
00646         // Novo erro usado para indicar (as callbacks), que a classe de 
00647         // gerenciamento de transferencias (CTransferInfo) foi removida.
00648         case ERROR_PROCESS_TERMINATED:
00649              UserError = "PROCESS TERMINATED";
00650              break;
00651         // Novo erro usado para indicar um identificador invalido de 
00652         // trasnferencia.
00653         case ERROR_INVALID_TRANSFERID:
00654              UserError = "INVALID TRANSFERID";
00655              break;
00656         // Novo erro usado para indicar que o par IP, Porta de um Host nao e o 
00657         // correto.             
00658         case ERROR_INVALID_HOST:
00659              UserError = "INVALID HOST";
00660              break;
00661         // Erro usado pelo modulo quando a linha do log nao e definida nas
00662         // opcoes da opcao userlogs para salvar os logs de comportamento.
00663         case ERROR_LOGLINE_NOT_DEFINED:
00664             UserError = "LOGLINE NOT DEFINED";
00665             break;
00666         // Novo erro usado para indicar que a opcao que define o comando nao foi
00667         // usada ao usarmos a opcao "exec.rio" do modulo.
00668         case ERROR_COMMAND_NOT_DEFINED:
00669             UserError = "COMMAND NOT DEFINED";
00670             break;
00671         // Novo erro usado para indicar que um comando invalido foi passado pela
00672         // opcao "exec.rio" do modulo.
00673         case ERROR_INVALID_COMMAND:
00674             UserError = "INVALID COMMAND";
00675             break;
00676         // Novo erro usado para indicar um erro de sintaxe em um dos comandos
00677         // executados pela opcao "exec.rio" do modulo.
00678         case ERROR_COMMAND_SYNTAX:
00679             UserError = "COMMAND SYNTAX";
00680             break;
00681         // Novo erro usado para indicar que a opcao que defineo identificador da
00682         // sessao nao foi usada ao usarmos a opcao "exec.rio" do modulo com um
00683         // comando diferente do login.
00684         case ERROR_SESSIONID_NOT_DEFINED:
00685             UserError = "SESSIONID NOT DEFINED";
00686             break;
00687         // Novo erro usado para indicar que a opcao que define identificador da
00688         // sessao foi usada ao usarmos a opcao "exec.rio" do modulo com o
00689         // comando login.
00690         case ERROR_SESSIONID_ALREADY_DEFINED:
00691             UserError = "SESSIONID ALREADY DEFINED";
00692             break;
00693         // Novo erro usado para indicar que ocorreu algum erro durante a copia
00694         // (erro ao copiar o bloco de/para o servidor ou de/para o cliente).
00695         case ERROR_COPYING_OBJECT:
00696             UserError = "COPYING OBJECT";
00697             break;
00698         // Novo erro usado para indicar que o metodo usado pelo pedido nao e uma
00699         // conexao segura (https).
00700         case ERROR_HTTPS_REQUIRED:
00701             UserError = "HTTPS REQUIRED";
00702             break;
00703         // Novo erro para indicar que um usuario ja existe.
00704         case ERROR_USER_EXISTS:
00705             UserError = "USER EXISTS";
00706             break;
00707         // Novo erro para indicar que existe um erro com o diretorio do usuario.
00708         case ERROR_INVALID_USER_DIRECTORY:
00709             UserError = "INVALID USER DIRECTORY";
00710             break;
00711         // Novo erro para indicar que ocorreu um erro ao ler o arquivo com os
00712         // usuarios e as senhas.
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 }

char* myInfo ( bool  parseHour  ) 

Definition at line 780 of file RioError.cpp.

00781 {
00782     struct tm     *date;
00783     time_t         segundos;
00784     ostringstream  s;
00785     char          *info;
00786     // Nome do arquivo do processo, e um descritor para ler o arquivo.
00787     FILE          *processfiledesc;
00788     char           processfilename[ MaxPathSize ];
00789     
00790     time( &segundos );
00791 
00792     //Jogando em 's' o pid da thread atual e a hora atual.
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     // Abre o arquivo /proc com o estado do processo.
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 }

debugCerr& operator<< ( debugCerr &  out,
string  s 
)

Definition at line 1449 of file RioError.cpp.

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; // Foi percebido que a pilha
01458                                                        //come�a com tamanho 4, da�
01459                                                        //subrai-se 3 aqui.
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 }

debugCerr& operator<< ( debugCerr &  out,
const unsigned char *  s 
)

Definition at line 1421 of file RioError.cpp.

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; // Foi percebido que a pilha
01430                                                        //come�a com tamanho 4, da�
01431                                                        //subrai-se 3 aqui.
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 }

debugCerr& operator<< ( debugCerr &  out,
const signed char *  s 
)

Definition at line 1393 of file RioError.cpp.

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; // Foi percebido que a pilha
01402                                                        //come�a com tamanho 4, da�
01403                                                        //subrai-se 3 aqui.
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 }

debugCerr& operator<< ( debugCerr &  out,
const char *  s 
)

Definition at line 1365 of file RioError.cpp.

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; // Foi percebido que a pilha
01374                                                        //come�a com tamanho 4, da�
01375                                                        //subrai-se 3 aqui.
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 }

debugCerr& operator<< ( debugCerr &  out,
unsigned char  c 
)

Definition at line 1337 of file RioError.cpp.

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; // Foi percebido que a pilha
01346                                                        //come�a com tamanho 4, da�
01347                                                        //subrai-se 3 aqui.
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 }

debugCerr& operator<< ( debugCerr &  out,
signed char  c 
)

Definition at line 1309 of file RioError.cpp.

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; // Foi percebido que a pilha
01318                                                        //come�a com tamanho 4, da�
01319                                                        //subrai-se 3 aqui.
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 }

debugCerr& operator<< ( debugCerr &  out,
char  c 
)

Definition at line 1281 of file RioError.cpp.

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; // Foi percebido que a pilha
01290                                                        //come�a com tamanho 4, da�
01291                                                        //subrai-se 3 aqui.
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 }

void Rioperror ( const char *  msg  ) 

Definition at line 752 of file RioError.cpp.

00753 {
00754     int err;
00755     err = errno; // garda o valor de errno, para garantir que vamos imprimir o
00756                  // erro correto.
00757     RioErr << msg << ": " << strerror( err ) << endl;
00758 }

void showtimenow ( string  msg  ) 

Definition at line 826 of file RioError.cpp.

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 }

Variable Documentation

pthread_mutex_t err_mutex

Definition at line 769 of file RioError.cpp.

pthread_mutexattr_t err_mutex_attr

Definition at line 768 of file RioError.cpp.

bool printHeader

Definition at line 770 of file RioError.cpp.

debugCerr RioErr

RioErr � a inst�ncia global da classe debugCerr utilizada para exibir mensagens de debug.

A formata��o, definida no operator<< sobrecarregado para a classe debugCerr, consiste em mostrar hierarquia entre m�todos, tabulando-os segundo sua posi��o na pilha de execu��o. Antes da tabula��o, o id da thread correspondente � exibido.

Definition at line 767 of file RioError.cpp.

Generated on Wed Jul 4 16:03:30 2012 for RIO by  doxygen 1.6.3