static void * rotate(void *arg) { logstr(GLOG_DEBUG, "rotate thread starting"); if ((time(NULL) - *ctx->last_rotate) <= ctx->config.rotate_interval) { logstr(GLOG_DEBUG, "rotation not needed"); return NULL; } /* debug_print_ring_queue(ctx->filter, TRUE); */ logstr(GLOG_DEBUG, "Now: %d Last: %d Max-diff %d", time(NULL), *(ctx->last_rotate), ctx->config.rotate_interval * ctx->config.num_bufs); ACTIVATE_BLOOM_GUARD(); if (time(NULL) - *(ctx->last_rotate) > ctx->config.rotate_interval * ctx->config.num_bufs) { zero_bloom_ring_queue(ctx->filter); *(ctx->last_rotate) = time(NULL); logstr(GLOG_INFO, "Max timediff exceeded. Zeroing whole bloom ring."); } else { *(ctx->last_rotate) += ctx->config.rotate_interval; ctx->filter = rotate_bloom_ring_queue(ctx->filter); } RELEASE_BLOOM_GUARD(); logstr(GLOG_DEBUG, "rotation completed"); return NULL; }
void TWIN_DumpGdiObjects() { HPEN hPen; HBRUSH hBrush; LPOBJHEAD lpObjHead; int i; logstr(LF_DEBUG,"Dumping GDI Objects\n"); for(i=0;i<SD_NUMCOLORS+1;i++) { hBrush = SysColorBrushes[i]; if(hBrush && IsGDIObject(hBrush)) { logstr(LF_DEBUG,"deleting brush %d %x\n",i,hBrush); lpObjHead = GETGDIINFO(hBrush); lpObjHead->wRefCount = 0; DeleteObject(hBrush); } } for(i=0;i<SD_NUMCOLORS+1;i++) { hPen = SysColorPens[i]; if(hPen && IsGDIObject(hPen)) { logstr(LF_DEBUG,"deleting pen %d %x\n",i,hPen); lpObjHead = GETGDIINFO(hPen); lpObjHead->wRefCount = 0; DeleteObject(hPen); } } }
/***************************************************************** * handle_sig() : signal handler for SIGCHLD, SIGTERM and SIGALRM *****************************************************************/ void handle_sig( int sig ) { char s[256]; switch( sig ) { case SIGTERM: if( !child ) { unlink(sz_pidfile); sprintf( s, PROG_NAME" "PROG_VERSION" shutting down cleanly " ": killing %d connections",con_cnt ); logstr(s,NULL); } exit(0); break; case SIGCHLD: while( waitpid(-1,NULL,WNOHANG) > 0 ) con_cnt--; break; case SIGALRM: if( child ) { sprintf(s,"Connection closed (%s)",sz_error[ERR_NEGTIME]); logstr(s,&ad_client); exit(ERR_NEGTIME); } exit(0); break; } }
void WinFreeCheck(LPVOID ptr,char *lparam, int wparam) { MALLOCINFO *p,*l; for(p=lpMallocInfo; p; p = p->next) { if(p->data == ptr) { if(lpMallocInfo == p) { lpMallocInfo = p->next; } else { for(l=lpMallocInfo; l; l = l->next) { if(l->next == p) { l->next = p->next; } } } logstr(LF_DEBUG,"%s:%d: WinFreeCheck: data=%x from=%s:%d %x %x\n", lparam,wparam, ptr, p->lparam,p->wparam, p->flag,p->handle); WinFree(p); totalfree += p->size; totalfcalls++; break; } } if(p == 0) { logstr(LF_DEBUG,"*** ERROR *** WinFreeCheck: freeing %x %s:%d\n", ptr, lparam,wparam); } WinFree(ptr); }
int find_head_offset(char *upload_data) { int head_offset=0 ; char *pStart=NULL; int iestr_offset=0; char *dquote; char *dquote1; if (upload_data==NULL) { //fprintf(stderr, "upload data is NULL\n"); return -1; } if(strstr(upload_data, WINIE6_STR)) { pStart = strstr(upload_data, WINIE6_STR); iestr_offset = 17; } else if(strstr(upload_data, GZ_STR)) { pStart = strstr(upload_data, GZ_STR); iestr_offset = 22; }else if(strstr(upload_data, LINUXFX36_FWSTR)) { pStart = strstr(upload_data, LINUXFX36_FWSTR); iestr_offset = 26; }else if(strstr(upload_data, MACIE5_FWSTR)) { pStart = strstr(upload_data, MACIE5_FWSTR); iestr_offset = 14; }else if(strstr(upload_data, OPERA_FWSTR)) { pStart = strstr(upload_data, OPERA_FWSTR); iestr_offset = 16; }else if(strstr(upload_data, WIN64IE_FWSTR)) { pStart = strstr(upload_data, WIN64IE_FWSTR); logstr("\nWIN64IE_FWSTR:"); logstr(WIN64IE_FWSTR); iestr_offset = 10; }else if(strstr(upload_data, "filename=")) { pStart = strstr(upload_data, "filename="); dquote = strstr(pStart, "\""); if (dquote !=NULL) { dquote1 = strstr(dquote, LINE_FWSTR); if (dquote1!=NULL) { iestr_offset = 4; pStart = dquote1; } else { return -1; } } } //fprintf(stderr,"####%s:%d %d###\n", __FILE__, __LINE__ , iestr_offset); head_offset = (int)(((unsigned long)pStart)-((unsigned long)upload_data)) + iestr_offset; //printf("<br>head_offset=%d \n",head_offset); return head_offset; }
void LoadExportsTable(MODULE_HEADERS *mp,PIMAGE_NT_HEADERS pNTHeader,char *ModuleName) { PIMAGE_EXPORT_DIRECTORY exportDir; DWORD i; PDWORD functions; PWORD ordinals; PSTR *name; LPSTR fname; IMAGE_DATA_DIRECTORY dir; logstr(lf_exports,"Exports of %s\n",ModuleName); // get the image_data_directory for exported symbols dir = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]; // convert to pointer exportDir = MAKEPTR((PIMAGE_EXPORT_DIRECTORY), mp->BaseAddress, dir.VirtualAddress); // any functions at all? if (exportDir->NumberOfFunctions == 0) return ; // create array of function addresses functions = MAKEPTR((PDWORD),mp->BaseAddress, exportDir->AddressOfFunctions); // create array of function ordinals ordinals = MAKEPTR((PWORD),mp->BaseAddress, exportDir->AddressOfNameOrdinals); // create array of RVA's to function names name = MAKEPTR((PSTR *),mp->BaseAddress, exportDir->AddressOfNames); // resort to straight line linear search // should/could we ignore comparing strings, until we // are in range? for ( i=0; i < exportDir->NumberOfNames; i++ ) { // get the pointer to the name fname = MAKEPTR((LPSTR),mp->BaseAddress,*name); logstr(lf_exports,"export %x %s\n", *ordinals,fname); // bump all the pointers functions++; // function address ordinals++; // function ordinal name++; // function name } // the name is not in the module... return ; }
void js_debug_resumerequest(JSContext *cx, jsrefcount rc, const char *file, unsigned long line) { struct request_log *req; if(!initialized) initialize_request(); pthread_mutex_lock(&req_mutex); req=match_request(cx); if(req==NULL) { strcpy(str,"Missing req in Resume\n"); logstr(); return; } if(!JS_IsInRequest(cx)) { sprintf(str,"Resume WITHOUT REQUEST after %s from %s:%lu at %s:%lu (%p)\n",type_names[req->type],req->file,req->line,file,line,req->cx); } switch(req->type) { case LAST_REQUEST_TYPE_SUSPEND: break; case LAST_REQUEST_TYPE_NONE: case LAST_REQUEST_TYPE_END: case LAST_REQUEST_TYPE_BEGIN: case LAST_REQUEST_TYPE_RESUME: sprintf(str,"Resume after %s from %s:%lu at %s:%lu (%p)\n",type_names[req->type],req->file,req->line,file,line,req->cx); logstr(); break; } switch(JS_RequestDepth(cx)) { case 0: default: sprintf(str,"depth=%u at Resume after %s from %s:%lu at %s:%lu (%p)\n",JS_RequestDepth(cx),type_names[req->type],req->file,req->line,file,line,req->cx); logstr(); break; case 1: break; } switch(JS_SuspendDepth(cx)) { case 1: default: break; case 0: sprintf(str,"Suspend depth=%u at Resume after %s from %s:%lu at %s:%lu (%p)\n",JS_SuspendDepth(cx),type_names[req->type],req->file,req->line,file,line,req->cx); logstr(); break; } req->type=LAST_REQUEST_TYPE_RESUME; req->file=file; req->line=line; pthread_mutex_unlock(&req_mutex); JS_ResumeRequest(cx, rc); }
void proxy_client_handler::on_connect(frog::generic::tcpsession_ptr session) { if (session) { logstr("%s - %s connected", session->localaddr().c_str(), session->remoteaddr().c_str()); frog::generic::encoder out; out.begin(cmd_server_register); out.write_int(config::ref().get_servertype()); out.end(); session->send(&out); } else { logstr("cannot connect to proxy"); } }
LPVOID WinMallocCheck(unsigned int size, char *lparam,int wparam,int flag, int handle) { LPVOID lpMemory; MALLOCINFO *p; lpMemory = WinMalloc(size); logstr(LF_DEBUG,"%s:%d: WinMallocCheck data=%x size=%x %x %x\n", lparam,wparam, lpMemory,size, flag,handle); p = (MALLOCINFO *) WinMalloc(sizeof(MALLOCINFO)); memset(p,0,sizeof(MALLOCINFO)); p->next = lpMallocInfo; p->data = lpMemory; p->size = size; p->lparam = lparam; p->wparam = wparam; p->flag = flag; p->handle = handle; p->call = totalacalls; lpMallocInfo = p; totalacalls++; totalalloc += size; return lpMemory; }
void free_wrapper (void *mem) { if (DEBUG) logstr ("freeing memory at %p\n", mem); free (mem); }
/* * logprg prints msg at log level of level * * in: * level - a level number consisted with LOG_LEVEL_T * msg - a log message * out: * log displayed on stdout */ void logprg ( LOG_LEVEL_T level, const char * msg ){ char s[LOGMSGLEN]; char * copy; char * start = (char *)msg; char * end; logstr ( s, level ); /* first we search for end line characters */ end = strchr ( start, '\n' ); if ( end ){ /* if found we need to erase them */ copy = MALLOC ( strlen ( msg ) + 1 ); while ( ( end = strchr ( start, '\n' )) ){ /* end line chars erase */ if ( start != end ){ strncpy ( copy, start, end - start ); copy [ end - start ] = '\0'; printf ( "%s %s\n", s, copy ); } start = end + 1; } FREE ( copy ); } else { /* if not found simply display it */ printf ( "%s %s\n", s, msg ); } }
void edict_unlink(edict_t *edict) { int ret; poolresult_message_t message; ret = pthread_mutex_lock(&edict->reference.mx); assert(0 == ret); assert(edict->reference.count > 0); if (--edict->reference.count == 0) { /* last reference */ if (edict->resultmq > 0) while (release_queue(edict->resultmq) < 0) { /* queue wasn't emtpy */ logstr(GLOG_INSANE, "queue not empty, flushing"); ret = get_msg_timed(edict->resultmq, &message, sizeof(message.result), -1); if (ret > 0) { assert(message.result); free((chkresult_t *)message.result); message.result = NULL; } } pthread_mutex_unlock(&edict->reference.mx); Free(edict); } else { pthread_mutex_unlock(&edict->reference.mx); } }
jsrefcount js_debug_suspendrequest(JSContext *cx, const char *file, unsigned long line) { struct request_log *req; jsrefcount ret; if(!initialized) initialize_request(); pthread_mutex_lock(&req_mutex); req=match_request(cx); if(req==NULL) { strcpy(str,"Missing req in Suspend\n"); logstr(); return -1; } if(!JS_IsInRequest(cx)) { sprintf(str,"Suspend WITHOUT REQUEST after %s from %s:%lu at %s:%lu (%p)\n",type_names[req->type],req->file,req->line,file,line,req->cx); } switch(req->type) { case LAST_REQUEST_TYPE_BEGIN: case LAST_REQUEST_TYPE_RESUME: break; case LAST_REQUEST_TYPE_NONE: if(req->file==NULL) /* Assumed to be a provided request */ break; case LAST_REQUEST_TYPE_END: case LAST_REQUEST_TYPE_SUSPEND: sprintf(str,"Suspend after %s from %s:%lu at %s:%lu (%p)\n",type_names[req->type],req->file,req->line,file,line,req->cx); logstr(); break; } switch(JS_RequestDepth(cx)) { case 0: default: sprintf(str,"depth=%u at Suspend after %s from %s:%lu at %s:%lu (%p)\n",JS_RequestDepth(cx),type_names[req->type],req->file,req->line,file,line,req->cx); logstr(); break; case 1: break; } req->type=LAST_REQUEST_TYPE_SUSPEND; req->file=file; req->line=line; ret=JS_SuspendRequest(cx); pthread_mutex_unlock(&req_mutex); return(ret); }
void DumpSectionTable(void *LoadAddress,PIMAGE_SECTION_HEADER section, unsigned cSections) { unsigned j; logstr(lf_header,"Section Table %x %d\n",LoadAddress,cSections); logstr(lf_header," %02X %-8.8s %s: %08X VirtAddr: %08X\n", cSections, section->Name, "VirtSize", section->Misc.VirtualSize, section->VirtualAddress); logstr(lf_header," raw data offs: %08X raw data size: %08X\n", section->PointerToRawData, section->SizeOfRawData ); logstr(lf_header," relocation offs: %08X relocations: %08X\n", section->PointerToRelocations, section->NumberOfRelocations); logstr(lf_header," line # offs: %08X line #'s: %08X\n", section->PointerToLinenumbers, section->NumberOfLinenumbers ); logstr(lf_header," characteristics: %08X\n", section->Characteristics); for ( j=0; j < NUMBER_SECTION_CHARACTERISTICS; j++ ) { if ( section->Characteristics & SectionCharacteristics[j].flag ) logstr(lf_header," %s\n", SectionCharacteristics[j].name ); } }
void ExecEntryPoint(void *BaseAddress, PIMAGE_NT_HEADERS pNTHeader,char *ModuleName) { int *fp; fp = MAKEPTR((int *), BaseAddress, pNTHeader->OptionalHeader.AddressOfEntryPoint); logstr(lf_header,"execute: %s %x %x\n", ModuleName,pNTHeader->OptionalHeader.AddressOfEntryPoint, fp); }
void DumpHeader(PIMAGE_FILE_HEADER pImageFileHeader) { UINT headerFieldWidth = 30; UINT i; char *szMachine; logstr(lf_header,"File Header\n"); switch( pImageFileHeader->Machine ) { case IMAGE_FILE_MACHINE_I386: szMachine = "i386"; break; case IMAGE_FILE_MACHINE_I860: szMachine = "i860"; break; case IMAGE_FILE_MACHINE_R3000: szMachine = "R3000"; break; case IMAGE_FILE_MACHINE_R4000: szMachine = "R4000"; break; case IMAGE_FILE_MACHINE_ALPHA: szMachine = "alpha"; break; default: szMachine = "unknown"; break; } logstr(lf_header," %-*s%04X (%s)\n", headerFieldWidth, "Machine:", pImageFileHeader->Machine, szMachine); logstr(lf_header," %-*s%04X\n", headerFieldWidth, "Number of Sections:", pImageFileHeader->NumberOfSections); logstr(lf_header2," %-*s%08X\n", headerFieldWidth, "TimeDateStamp:", pImageFileHeader->TimeDateStamp); logstr(lf_header2," %-*s%08X\n", headerFieldWidth, "PointerToSymbolTable:", pImageFileHeader->PointerToSymbolTable); logstr(lf_header2," %-*s%08X\n", headerFieldWidth, "NumberOfSymbols:", pImageFileHeader->NumberOfSymbols); logstr(lf_header2," %-*s%04X\n", headerFieldWidth, "SizeOfOptionalHeader:", pImageFileHeader->SizeOfOptionalHeader); logstr(lf_header," %-*s%04X\n", headerFieldWidth, "Characteristics:", pImageFileHeader->Characteristics); for ( i=0; i < NUMBER_IMAGE_HEADER_FLAGS; i++ ) { if ( pImageFileHeader->Characteristics & ImageFileHeaderCharacteristics[i].flag ) logstr(lf_header," %s\n", ImageFileHeaderCharacteristics[i].name ); } logstr(lf_header,"\n"); }
/* Perform connection to server. */ void server_connect (char *host) { struct addrinfo *server = NULL, hints; int st, sock; memset (&hints, 0, sizeof (struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; hints.ai_protocol = 0; sock = socket (AF_INET, SOCK_STREAM, 0); if (sock == -1) { logstr ("socket creation failed\n"); goto err; } st = getaddrinfo (host, "6667", &hints, &server); if (st != 0) { logstr("failed to resolve hostname\n"); goto err; } logstr ("hostname resolved\n"); st = connect (sock, server->ai_addr, server->ai_addrlen); if (st == -1) { logstr("connection to server failed\n"); goto err; } logstr ("connected\n"); settings->socket = fdopen (sock, "r+"); freeaddrinfo (server); return; err: if (server) freeaddrinfo (server); exit (EXIT_FAILURE); }
int main (int argc, char *argv[]) { char *l = NULL; message_t *cmsg = NULL; command_t *ccmd = NULL; settings_t global_settings; settings = &global_settings; settings->execname = argv[0]; settings->action_trigger = '`'; /* default trigger char */ settings->verbose = false; settings->socket = NULL; logstr ("Radroach here\n"); register_signals (); if (configure (argc, argv)) exit (EXIT_FAILURE); logstr ("trusted users are: %s\n", settings->trusted); if (settings->aj_list) logstr ("channels to join: %s\n", settings->aj_list); server_connect (settings->host); setup (); plugins_load ("./plugins/"); while ((l = sogetline ()) != NULL) { if (p_response (l)) continue; cmsg = parsemsg (l); if (cmsg != NULL) { ccmd = parsecmd (cmsg->msg); if (ccmd != NULL) execute (cmsg, ccmd); } else free (l); } return EXIT_SUCCESS; }
void helo_init(pool_limits_t *limits) { thread_pool_t *pool; /* initialize the thread pool */ logstr(GLOG_INFO, "initializing helo thread pool"); pool = create_thread_pool("helo", &helo, limits, NULL); if (pool == NULL) daemon_fatal("create_thread_pool"); register_check(pool, false); }
void reverse_init(pool_limits_t *limits) { thread_pool_t *pool; /* initialize the thread pool */ logstr(GLOG_INFO, "initializing reverse thread pool"); pool = create_thread_pool("reverse", &reverse, limits, NULL); if (pool == NULL) daemon_fatal("create_thread_pool"); register_check(pool, false); }
void spf_init(pool_limits_t *limits) { thread_pool_t *pool; /* initialize the thread pool */ logstr(GLOG_INFO, "initializing spf checker thread pool"); pool = create_thread_pool("spf", &spfc, limits, NULL); if (pool == NULL) daemon_fatal("create_thread_pool"); /* This is a definitive check */ register_check(pool, true); }
/* * abortprg prints msg at a log level of LOGERROR and exits program with error code of err. * * in: * pdata - main program data * err - error code * msg - error message * out: * program abort and exit */ void abortprg ( pgsqldata * pdata, int err, const char * msg ){ char h[LOGMSGLEN]; /* Program aborting always generate ERROR message */ logstr ( h, LOGERROR ); printf ( "%s %s\n", h, msg ); printf ( "%s Aborting!\n", h ); if ( pdata->catdb ) PQfinish ( pdata->catdb ); freepdata ( pdata ); exit (err); }
void Shader::printInfo(ShaderInfo info, GLuint posy) { GLuint posx = 260; switch(info) { case SHADER_LOG: { if(!log) { glColor3f(GLfloat(0.3), GLfloat(1.0), GLfloat(0.3)); GLHelper::getGLH()->glPrintf(false, posx, posy, "no log available"); return; } glColor3f(GLfloat(1.0), GLfloat(0.3), GLfloat(0.3)); std::string logstr(log); std::string message; for(int loc = logstr.find("\n", 0); loc != int(std::string::npos); ) { message = logstr.substr(0, loc); GLHelper::getGLH()->glPrintf(false, posx, posy, "%s", message.c_str()); logstr = logstr.substr(loc+1, logstr.size()); loc = logstr.find("\n", 0); posy -= 20; } } break; case SHADER_SOURCE: { glColor3f(GLfloat(0.7), GLfloat(0.7), GLfloat(0.7)); if(source) { std::string sourcestr(source); std::string message; for(int loc = sourcestr.find("\n", 0); loc != int(std::string::npos); ) { message = sourcestr.substr(0, loc); GLHelper::getGLH()->glPrintf(false, posx, posy, "%s", message.c_str()); sourcestr = sourcestr.substr(loc+1, sourcestr.size()); loc = sourcestr.find("\n", 0); posy -= 20; } } else GLHelper::getGLH()->glPrintf(false, posx, posy, "source not loaded"); } break; default: break; } }
/* We want to use the logging facility key=value to keep track of the * node ip address we use when we use the filesystem domain. This * will help us know that we are accessing the nodes in a balanced way. * (We access the filesystem nodes via a domain which resolves to many * A records or IP addrs; our mechanism chooses one of those A records (IP addr). * We know the address used because we capture the libcurl message * "Trying <ip addr>...". Kind of clunky since the message can change. Do * we have a better way? */ static void print_ipaddr_pair(char *msg) { // nodeaddr is global so it can be reused in later logging char *end; // msg+9 takes us past " Trying ". We assume the ip addr starts there. strncpy(nodeaddr, msg + 9, LOGSTRSZ); nodeaddr[LOGSTRSZ - 1] = '\0'; // Just make sure it's null terminated // end finds the first two dots after the ip addr. We put a zero there // to turn the original string into just the IP addr. end = strstr(nodeaddr, ".."); end[0] = '\0'; // Change dots in addr to underscore for logging logstr(nodeaddr); // We print the key=value pair. log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "Using filesystem_host=%s", nodeaddr); }
/* Executes apropriate function as parameters specify. */ void execute (message_t * msg, command_t * cmd) { unsigned int i; if (checkrights (msg)) { logstr ("accepted command %s from %s (%s@%s)\n", cmd->action, msg->sender, msg->ident, msg->host); for (i = 0; i < plugin_count; i++) { /* bad performance impact. meh. */ if (!strcmp(plugins[i]->name, cmd->action)) { logstr ("plugin %s matched\n", plugins[i]->name); plugins[i]->execute (msg, cmd, 1); } else plugins[i]->execute (msg, cmd, 0); } } free (cmd->raw); free (cmd); msgfree (msg); }
int reverse(thread_pool_t *info, thread_ctx_t *thread_ctx, edict_t *edict) { chkresult_t *result; struct hostent *canonicalhost, *reversehost; grey_tuple_t *request; const char *client_address; char buf[INET_ADDRSTRLEN]; const char *ptr; mseconds_t timelimit; request = (grey_tuple_t *)edict->job; client_address = request->client_address; assert(client_address); result = (chkresult_t *)Malloc(sizeof(chkresult_t)); memset(result, 0, sizeof(*result)); result->judgment = J_UNDEFINED; result->checkname = "reverse"; timelimit = edict->timelimit; reversehost = Gethostbyaddr_str(client_address, timelimit); if (reversehost) { logstr(GLOG_INSANE, "client_address (%s) has a PTR record (%s)", client_address, reversehost->h_name); canonicalhost = Gethostbyname(reversehost->h_name, timelimit); if (canonicalhost) { ptr = inet_ntop(AF_INET, canonicalhost->h_addr_list[0], buf, INET_ADDRSTRLEN); assert(ptr); logstr(GLOG_INSANE, "client_ip (%s) canonical (%s)", client_address, buf); if (strcmp(buf, client_address)) { logstr(GLOG_DEBUG, "client_address (%s) not canonical (%s)", client_address, buf); result->judgment = J_SUSPICIOUS; result->weight = 1; /* FIXME */ } } else { logstr(GLOG_DEBUG, "No A for PTR for client_ip (%s)", client_address); result->judgment = J_SUSPICIOUS; result->weight = 1; } } else { logstr(GLOG_DEBUG, "client_ip (%s) has no PTR record", client_address); result->judgment = J_SUSPICIOUS; result->weight = 1; } send_result(edict, result); logstr(GLOG_DEBUG, "reverse returning"); request_unlink(request); return 0; }
void * malloc_wrapper (size_t size) { void *mem; mem = malloc (size); if (mem == NULL) { fprintf (stderr, "%s: failed to allocate %d bytes, exiting", settings->execname, (unsigned int) size); exit (EXIT_FAILURE); } if (DEBUG) logstr ("allocated %d bytes at %p\n", size, mem); return mem; }
/* Returns a line from irc server. */ char * sogetline () { /* irc RFC specifies maximum message length of 512 chars, plus one for \0 */ char buffer[513], *line; size_t len; if (feof (settings->socket) || ferror (settings->socket)) return NULL; fgets (buffer, 513, settings->socket); len = strlen (buffer); line = malloc (len); strncpy (line, buffer, len); line[len - 1] = '\0'; if (settings->verbose) logstr ("-> %s\n", line); return line; }
void sighandler (int sig) { switch (sig) { case SIGABRT: logstr ("\tSIGABRT\n"); break; case SIGBUS: logstr ("\tSIGBUS\n"); break; case SIGHUP: logstr ("\tSIGHUP\n"); break; case SIGINT: logstr ("\tSIGINT\n"); break; case SIGKILL: logstr ("\tSIGKILL\n"); break; case SIGQUIT: logstr ("\tSIGQUIT\n"); break; case SIGTERM: logstr ("\tSIGTERM\n"); break; case 0: logstr ("exiting, goodbye\n"); break; default: break; } if (settings->socket) { fclose (settings->socket); settings->socket = NULL; } plugins_unload (); }
LPVOID WinReallocCheck(LPVOID ptr, unsigned int size, char *lparam, int wparam,int flag,int handle) { LPVOID lp; MALLOCINFO *p; for(p=lpMallocInfo; p; p = p->next) { if(p->data == ptr) { totalalloc -= p->size; break; } } lp = WinRealloc(ptr,size); logstr(LF_DEBUG,"%s:%d: WinReallocCheck: old data=%x new data=%x size=%x %x %x\n", lparam,wparam, ptr,lp,size, flag,handle); if(ptr == 0) return 0; if(lp) { p->size = size; } else { p->size = 0; } p->data = lp; p->lparam = lparam; p->wparam = wparam; totalalloc += size; return lp; }