GdkPixbuf* getPixBuf(char* name) { GFile* file=g_file_new_for_path(name); GFileInfo* file_info=g_file_query_info(file,"standard::*",G_FILE_QUERY_INFO_NONE,NULL,NULL); GIcon* icon=g_file_info_get_icon(file_info); GdkPixbuf* pix=NULL; gchar* path; gchar const* const* names; GFile* icon_file; char* newname; if(G_IS_THEMED_ICON(icon)) { names=g_themed_icon_get_names(G_THEMED_ICON(icon)); pix=gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),*names,16,(GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN|GTK_ICON_LOOKUP_FORCE_SVG|GTK_ICON_LOOKUP_GENERIC_FALLBACK|GTK_ICON_LOOKUP_FORCE_SIZE),NULL); if(pix==NULL) { asprintf(&newname,"gnome-mime-%s",*names); pix=gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),(const gchar*)newname,16,(GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN|GTK_ICON_LOOKUP_FORCE_SVG|GTK_ICON_LOOKUP_GENERIC_FALLBACK|GTK_ICON_LOOKUP_FORCE_SIZE),NULL); debugFree(&newname); } } else if(G_IS_FILE_ICON(icon)) { icon_file=g_file_icon_get_file(G_FILE_ICON(icon)); path=g_file_get_path(icon_file); pix=gdk_pixbuf_new_from_file_at_size(path,16,16,NULL); debugFree(&path); g_object_unref(G_OBJECT(icon_file)); } g_object_unref(G_OBJECT(file)); g_object_unref(G_OBJECT(file_info)); return(pix); }
gboolean getNode(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data) { char* name=NULL; char* thispath=NULL; bool retval=false; thispath=gtk_tree_path_to_string(path); if(node!=NULL && thispath!=NULL) { if((strlen(thispath)<strlen(node)) || (strcmp(thispath,node)==0)) { debugFree(&thispath); return(false); } } gtk_tree_model_get(model,iter,COLUMN_FILENAME,&name,-1); if(name!=NULL) { if(strcmp(name,(char*)data)==0) { debugFree(&node); node=gtk_tree_path_to_string(path); gtk_tree_view_expand_row((GtkTreeView*)treeview,path,false); retval=true; } debugFree(&name); } debugFree(&thispath); return(retval); }
static void sms_cleanup( void ) { if (extensions_fd > -1) { if( extensions_wd > -1) { inotify_rm_watch(extensions_fd, extensions_wd); extensions_wd = -1; } set_fd_hook(extensions_fd, json_inotify_event_hook, DEL); close(extensions_fd); extensions_fd = -1; } else { task_remove(check_for_changed_sms, NULL); } while (json_sms_tree.items) { struct json_sms *sms = avl_first_item(&json_sms_tree); avl_remove(&json_sms_tree, sms->name, -300381); debugFree(sms, -300382); } }
extern "C" void doTabMenu(GtkWidget *widget,gpointer data) { plugData* plugdata=(plugData*)data; pageStruct* page=plugdata->page; char* ptr=strdup(page->filePath); GtkTreeModel* model=NULL; GtkTreePath* scrollpath; gtk_tree_view_collapse_all((GtkTreeView *)treeview); ptr=strtok(ptr,"/"); model=GTK_TREE_MODEL(store); gtk_tree_model_foreach(model,getNode,(gpointer)"/"); while(ptr!=NULL) { gtk_tree_model_foreach(model,getNode,ptr); ptr=strtok(NULL,"/"); } scrollpath=gtk_tree_path_new_from_string(node); gtk_tree_view_set_cursor((GtkTreeView *)treeview,scrollpath,NULL,false); gtk_tree_view_scroll_to_cell((GtkTreeView *)treeview,scrollpath,NULL,true,0.5,0.5); debugFree(&node); node=NULL; showing=false; toggleBrowser(NULL,plugdata); }
void showHideBrowser(plugData* pdata,bool startup) { char* filepath; setTextDomain(true,pdata); asprintf(&filepath,"%s/filebrowser.rc",pdata->lPlugFolder); if(showing==true) { gtk_widget_show_all(scrollbox); if(pdata->leftShow==0 && startup==false) showSide(true); touch(filepath); gtk_menu_item_set_label((GtkMenuItem*)hideMenu,gettext("Hide Browser")); } else { gtk_widget_hide(scrollbox); unlink(filepath); if(pdata->leftShow==1 && startup==false) hideSide(true); gtk_menu_item_set_label((GtkMenuItem*)hideMenu,gettext("Show Browser")); } debugFree(&filepath); setTextDomain(false,pdata); }
void collapseRow(GtkTreeView* treeview,GtkTreeIter* iter,GtkTreePath* path,gpointer user_data) { char* pathstring=gtk_tree_path_to_string(path); if(strcmp(pathstring,"0")==0) flag=false; debugFree(&pathstring); }
STATIC_FUNC void destroy_local_topology_cache(void) { struct local_topology_node *ltn; while ((ltn = avl_remove_first_item(&local_topology_tree, -300000))) debugFree(ltn, -300000); }
void doStartUpCheck(plugData* pdata) { char* filepath; asprintf(&filepath,"%s/filebrowser.rc",pdata->lPlugFolder); if(g_file_test(filepath,G_FILE_TEST_EXISTS)) showing=true; else showing=false; debugFree(&filepath); asprintf(&filepath,"%s/filebrowser.inv",pdata->lPlugFolder); if(g_file_test(filepath,G_FILE_TEST_EXISTS)) showInvisible=true; else showInvisible=false; debugFree(&filepath); }
void showHideInvisibles(plugData* pdata) { char* filepath; asprintf(&filepath,"%s/filebrowser.inv",pdata->lPlugFolder); if(showInvisible==true) touch(filepath); else unlink(filepath); debugFree(&filepath); }
VOID idfrDone(PIDFREQ pIDFreq) { if ( pIDFreq->hmtxList != NULLHANDLE ) { xplMutexDestroy( pIDFreq->hmtxList ); pIDFreq->hmtxList = NULLHANDLE; } if ( pIDFreq->paList != NULL ) { debugFree( pIDFreq->paList ); pIDFreq->paList = NULL; } }
void onRowActivated(GtkTreeView* treeview, GtkTreePath* path,GtkTreeViewColumn* col,gpointer userdata) { GtkTreeModel *model; GtkTreeIter iter; gchar *name; char *command; GdkModifierType mask; const char *app; #ifdef _USEGTK3_ GdkDeviceManager *device_manager=gdk_display_get_device_manager(gdk_display_get_default()); GdkDevice *device=gdk_device_manager_get_client_pointer(device_manager); GdkWindow *window; window=gdk_screen_get_active_window (gdk_screen_get_default()); gdk_window_get_device_position(window,device,NULL,NULL,&mask); #else gdk_window_get_pointer(NULL,NULL,NULL,&mask); #endif model=gtk_tree_view_get_model(treeview); if(gtk_tree_model_get_iter(model,&iter,path)) { gtk_tree_model_get(model,&iter,COLUMN_PATHNAME,&name,-1); app=getApp(name); asprintf(&command,"%s '%s'",app,name); if (GDK_CONTROL_MASK & mask ) runCommand(command,NULL,false,TOOL_ASYNC,true,NULL); else runCommand(command,NULL,false,TOOL_ASYNC,false,NULL); debugFree(&command); debugFree(&name); } }
extern "C" int doAbout(gpointer data) { plugData* plugdata=(plugData*)data; char* licencepath; const char copyright[] ="Copyright \xc2\xa9 2014 K.D.Hedger"; char* licence; GtkAboutDialog* about; char* translators; setTextDomain(true,plugdata); const char* aboutboxstring=gettext("File Browser - Add's a simple file browser to the left pane"); asprintf(&licencepath,"%s/docs/gpl-3.0.txt",plugdata->dataDir); asprintf(&translators,"%s:\nNguyen Thanh Tung <*****@*****.**>",gettext("French Translation")); g_file_get_contents(licencepath,&licence,NULL,NULL); about=(GtkAboutDialog*)gtk_about_dialog_new(); gtk_about_dialog_set_program_name(about,gettext("FileBrowser")); gtk_about_dialog_set_authors(about,authors); gtk_about_dialog_set_comments(about,aboutboxstring); gtk_about_dialog_set_copyright(about,copyright); gtk_about_dialog_set_version(about,VERSION); gtk_about_dialog_set_website(about,MYWEBSITE); gtk_about_dialog_set_logo_icon_name(about,"KKEditPlug"); gtk_about_dialog_set_license(about,licence); gtk_about_dialog_set_translator_credits(about,(const gchar*)translators); gtk_dialog_run(GTK_DIALOG(about)); gtk_widget_destroy((GtkWidget*)about); debugFree(&licence); debugFree(&licencepath); free(translators); setTextDomain(false,plugdata); return(0); }
/* remove bucket (this might be used in hash_iterate() if you already found * the bucket you want to delete and don't need the overhead to find it again * with hash_remove(). But usually, you don't want to use this function, as it * fiddles with hash-internals. */ void *hash_remove_bucket(struct hashtable_t *hash, struct hash_it_t *hash_it_t) { void *data_save; /* save the pointer to the data */ data_save = hash_it_t->bucket->data; if (hash_it_t->prev_bucket) hash_it_t->prev_bucket->next = hash_it_t->bucket->next; else if (hash_it_t->first_bucket) (*hash_it_t->first_bucket) = hash_it_t->bucket->next; debugFree(hash_it_t->bucket, 1306); hash->elements--; return data_save; }
/* adds data to the hashtable. returns 0 on success, -1 on error */ int hash_add(struct hashtable_t *hash, void *data) { int ret; struct element_t *bucket; /* found the tail of the list, add new element */ bucket = debugMalloc(sizeof(struct element_t), 304); if (!bucket) return -1; ret = hash_add_bucket(hash, data, bucket, 1); if (ret < 0) debugFree(bucket, 1307); return ret; }
VOID cfgDone() { if ( pConfig == NULL ) { debug( "Was not initialized" ); return; } rwmtxDone( &rwmtxConfig ); _cfgFree( pConfig ); if ( pszCfgFile != NULL ) { debugFree( pszCfgFile ); pszCfgFile = NULL; } }
void *_debugRealloc(void *memoryParameter, uint32_t length, int32_t tag) { unsigned char *memory; struct chunkHeader *chunkHeader=NULL; struct chunkTrailer *chunkTrailer; unsigned char *result; uint32_t copyLength; if (memoryParameter) { /* if memoryParameter==NULL, realloc() should work like malloc() !! */ memory = memoryParameter; chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader)); if (chunkHeader->magicNumber != MAGIC_NUMBER) { dbgf( DBGL_SYS, DBGT_ERR, "invalid magic number in header: %08x, malloc tag = %d", chunkHeader->magicNumber, chunkHeader->tag ); cleanup_all( -500078 ); } chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length); if (chunkTrailer->magicNumber != MAGIC_NUMBER) { dbgf( DBGL_SYS, DBGT_ERR, "invalid magic number in trailer: %08x, malloc tag = %d", chunkTrailer->magicNumber, chunkHeader->tag ); cleanup_all( -500079 ); } } result = _debugMalloc(length, tag); if (memoryParameter) { copyLength = length; if (copyLength > chunkHeader->length) copyLength = chunkHeader->length; memcpy(result, memoryParameter, copyLength); debugFree(memoryParameter, -300280); } return result; }
void *debugRealloc(void *memoryParameter, uint32_t length, int32_t tag) { unsigned char *memory; struct chunkHeader *chunkHeader; struct chunkTrailer *chunkTrailer; unsigned char *result; uint32_t copyLength; if (memoryParameter) { /* if memoryParameter==NULL, realloc() should work like malloc() !! */ memory = memoryParameter; chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader)); if (chunkHeader->magicNumber != MAGIC_NUMBER) { fprintf(stderr, "debugRealloc - invalid magic number in header: %08x, malloc tag = %d\n", chunkHeader->magicNumber, chunkHeader->tag); exit(1); } chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length); if (chunkTrailer->magicNumber != MAGIC_NUMBER) { fprintf(stderr, "debugRealloc - invalid magic number in trailer: %08x, malloc tag = %d\n", chunkTrailer->magicNumber, chunkHeader->tag); exit(1); } } result = debugMalloc(length, tag); if (memoryParameter) { copyLength = length; if (copyLength > chunkHeader->length) copyLength = chunkHeader->length; memcpy(result, memoryParameter, copyLength); debugFree(memoryParameter, 9999); } return result; }
STATIC_FUNC void json_inotify_event_hook(int fd) { TRACE_FUNCTION_CALL; dbgf_track(DBGT_INFO, "detected changes in directory: %s", smsTx_dir); assertion(-501278, (fd > -1 && fd == extensions_fd)); int ilen = 1024; char *ibuff = debugMalloc(ilen, -300375); int rcvd; int processed = 0; while ((rcvd = read(fd, ibuff, ilen)) == 0 || rcvd == EINVAL) { ibuff = debugRealloc(ibuff, (ilen = ilen * 2), -300376); assertion(-501279, (ilen <= (1024 * 16))); } if (rcvd > 0) { while (processed < rcvd) { struct inotify_event *ievent = (struct inotify_event *) &ibuff[processed]; processed += (sizeof (struct inotify_event) +ievent->len); if (ievent->mask & (IN_DELETE_SELF)) { dbgf_sys(DBGT_ERR, "directory %s has been removed \n", smsTx_dir); cleanup_all(-501290); } } } else { dbgf_sys(DBGT_ERR, "read()=%d: %s \n", rcvd, strerror(errno)); } debugFree(ibuff, -300377); check_for_changed_sms(NULL); }
/* remove the hash structure. if hashdata_free_cb != NULL, * this function will be called to remove the elements inside of the hash. * if you don't remove the elements, memory might be leaked. */ void hash_delete(struct hashtable_t *hash, hashdata_free_cb free_cb) { struct element_t *bucket, *last_bucket; int i; for (i = 0; i < hash->size; i++) { bucket = hash->table[i]; while (bucket) { if (free_cb) free_cb(bucket->data); last_bucket = bucket; bucket = bucket->next; debugFree(last_bucket, 1301); } } hash_destroy(hash); }
/* allocates and clears the hash */ struct hashtable_t *hash_new(int size, hashdata_compare_cb compare, hashdata_choose_cb choose) { struct hashtable_t *hash; hash = debugMalloc(sizeof(struct hashtable_t), 302); if (!hash) return NULL; hash->size= size; hash->table= debugMalloc(sizeof(struct element_t *) * size, 303); if (!hash->table) { debugFree(hash, 1305); return NULL; } hash_init(hash); hash->compare = compare; hash->choose = choose; return hash; }
/* free hash_it_t pointer when stopping hash_iterate early */ void hash_iterate_free(struct hash_it_t *iter_in) { debugFree(iter_in, 1304); }
/* iterate though the hash. first element is selected with iter_in NULL. * use the returned iterator to access the elements until hash_it_t returns NULL. */ struct hash_it_t *hash_iterate(struct hashtable_t *hash, struct hash_it_t *iter_in) { struct hash_it_t *iter; if (iter_in == NULL) { iter = debugMalloc(sizeof(struct hash_it_t), 301); iter->index = -1; iter->bucket = NULL; iter->prev_bucket = NULL; } else iter= iter_in; /* sanity checks first (if our bucket got deleted in the last iteration): */ if (iter->bucket != NULL) { if (iter->first_bucket != NULL) { /* we're on the first element and it got removed after the last iteration. */ if ((*iter->first_bucket) != iter->bucket) { /* there are still other elements in the list */ if ((*iter->first_bucket) != NULL) { iter->prev_bucket = NULL; iter->bucket = (*iter->first_bucket); iter->first_bucket = &hash->table[iter->index]; return iter; } else { iter->bucket = NULL; } } } else if (iter->prev_bucket != NULL) { /* we're not on the first element, and the bucket got removed after the last iteration. * the last bucket's next pointer is not pointing to our actual bucket anymore. * select the next. */ if (iter->prev_bucket->next != iter->bucket) iter->bucket = iter->prev_bucket; } } /* now as we are sane, select the next one if there is some */ if (iter->bucket != NULL) { if (iter->bucket->next != NULL) { iter->prev_bucket = iter->bucket; iter->bucket = iter->bucket->next; iter->first_bucket = NULL; return iter; } } /* if not returned yet, we've reached the last one on the index and have to search forward */ iter->index++; /* go through the entries of the hash table */ while (iter->index < hash->size) { if ((hash->table[iter->index]) == NULL) { iter->index++; continue; } iter->prev_bucket = NULL; iter->bucket = hash->table[iter->index]; iter->first_bucket = &hash->table[iter->index]; return iter; /* if this table entry is not null, return it */ } /* nothing to iterate over anymore */ debugFree(iter, 1304); return NULL; }
void operator delete (void* p) throw() { debugFree(p); }
static PCONFIG _cfgNew(PSZ pszFile) { PCONFIG pConfig = debugCAlloc( 1, sizeof(CONFIG) ); xmlDocPtr pDoc; xmlNodePtr pNode; PXMLUSCAN pScan; LONG lRC; BOOL fNoError = TRUE; PSZ pszAttr; ULONG ulIdx; if ( pConfig == NULL ) { debug( "Not enough memory" ); return NULL; } // Load XML tree from the file. pDoc = xmlReadFile( pszFile, "UTF-8", XML_PARSE_NOERROR+XML_PARSE_NOWARNING ); if ( pDoc == NULL ) { CHAR acBuf[512]; PCHAR pcBuf = &acBuf[ sprintf( &acBuf, "Configuration read error: %s", pszFile ) ]; xmlErrorPtr pError = xmlGetLastError(); if ( pError != NULL ) { if ( pError->line != 0 ) pcBuf += sprintf( pcBuf, ":%d", pError->line ); acBuf[sizeof(acBuf) - 1] = '\0'; pcBuf += _snprintf( pcBuf, sizeof(acBuf) - (pcBuf - &acBuf) - 1, ", %s", pError->message ); while( (pcBuf > &acBuf) && isspace( *(pcBuf - 1) ) ) pcBuf--; *pcBuf = '\0'; } logWrite( &acBuf ); debugFree( pConfig ); return NULL; } // Read configuration. pNode = xmlDocGetRootElement( pDoc ); if ( pNode == NULL || ( xmlStrcmp( pNode->name, "config" ) != 0 ) ) { logWrite( "Unknown root node <%s>", pNode->name ); xmlFreeDoc( pDoc ); debugFree( pConfig ); return FALSE; } pConfig->ulThreads = _CFG_DEF_THREADS; pConfig->ulURIBLHits = 1; pConfig->ulPipes = _CFG_DEF_PIPES; pConfig->ulCommandTimeout = _CFG_DEF_COMMAND_TIMEOUT; pConfig->stGreylistMask.s_addr = _CFG_DEF_GLMASK; pConfig->ulGreylistCfNum = _CFG_DEF_CFNUM; pConfig->ulGreylistCfDen = _CFG_DEF_CFDEN; pConfig->ulGreylistCfTTL = _CFG_DEF_CFTTL; pConfig->ulMaxMessage = _CFG_DEF_MAX_MESSAGE; pConfig->ulMaxBodyPart = _CFG_DEF_MAX_BODY_PART; lnkseqInit( &pConfig->lsHostListRelays ); lnkseqInit( &pConfig->lsHostListLocal ); lnkseqInit( &pConfig->lsHostListIPFreqIgnore ); lnkseqInit( &pConfig->lsHostListScore ); lnkseqInit( &pConfig->lsHostListRWLIgnore ); lnkseqInit( &pConfig->lsHostListMailFrom ); lnkseqInit( &pConfig->lsHostListEHLO ); lnkseqInit( &pConfig->lsHostListEHLOURIBLIgnore ); lnkseqInit( &pConfig->lsHostListGreylistIgnore ); lnkseqInit( &pConfig->lsHostListDNSBLIgnore ); lnkseqInit( &pConfig->lsHostListMailFromURIBLIgnore ); lnkseqInit( &pConfig->lsMailBoxCheckIgnore ); lnkseqInit( &pConfig->lsHostListSPFIgnore ); lnkseqInit( &pConfig->lsHostListMsgIdIgnore ); lnkseqInit( &pConfig->lsHostListMsgId ); lRC = xmluBeginScan( pNode, &pScan, "path-data:pr path-log:pr log-level log-size log-history socket:r " "pipe threads weasel-log-pipe name-server:r mail-server-name:r " "local-domain:rm spam-store update-header command-timeout uribl:e " "command-ataccept:re command-ehlo:re command-rset:re command-mail:re " "command-rcpt:re command-data:re command-atcontent:re " "command-quit:re" ); while( lRC >= 0 ) { switch( lRC ) { case 0: // path-data case 1: // path-log *(lRC == 0 ? &pConfig->pszDataPath : &pConfig->pszLogPath) = utilStrNewSZ( pScan->cbValue, pScan->pcValue ); break; case 2: // log-level fNoError = utilStrToULong( pScan->cbValue, pScan->pcValue, 0, 5, &pConfig->ulLogLevel ); break; case 3: // log-size fNoError = utilStrToBytes( pScan->cbValue, pScan->pcValue, &pConfig->ulLogSize ); break; case 4: // log-history fNoError = utilStrToULong( pScan->cbValue, pScan->pcValue, 0, 365, &pConfig->ulLogHistory ); break; case 5: // socket if ( pScan->cbValue > 99 ) { fNoError = FALSE; break; } pConfig->pszSocket = utilStrNewSZ( pScan->cbValue, pScan->pcValue ); break; case 6: // pipe if ( pScan->cbValue > (_MAX_PATH - 7 /* \PIPE\ and ZERO */) ) { fNoError = FALSE; break; } pConfig->pszPipe = utilStrNewSZ( pScan->cbValue, pScan->pcValue ); pszAttr = xmlGetNoNsProp( pScan->xmlNode, "number" ); if ( pszAttr != NULL ) fNoError = utilStrToULong( strlen( pszAttr ), pszAttr, 1, _CFG_MAX_PIPES, &pConfig->ulPipes ); break; case 7: // threads fNoError = utilStrToULong( pScan->cbValue, pScan->pcValue, 1, _CFG_MAX_THREADS, &pConfig->ulThreads ); break; case 8: // weasel-log-pipe pConfig->fWeaselLogPipe = utilStrWordIndex( _CFG_SW_ON, pScan->cbValue, pScan->pcValue ) != -1; pConfig->fWeaselLogToScreen = __cfgAttrSwitch( pScan->xmlNode, "screen" ); break; case 9: // name-server fNoError = utilStrToInAddrPort( pScan->cbValue, pScan->pcValue, &pConfig->stNSAddr, &pConfig->usNSPort, FALSE, 53 ); break; case 10: // mail-server-name fNoError = utilVerifyDomainName( pScan->cbValue, pScan->pcValue ); if ( fNoError ) pConfig->pszMailServerName = utilStrNewSZ( pScan->cbValue, pScan->pcValue ); break; case 11: // local-domain fNoError = utilStrAddWords( &pConfig->cbLocalDomains, &pConfig->pcLocalDomains, pScan->cbValue, pScan->pcValue, NULL ); break; case 12: // spam-store pConfig->pszSpamStore = utilStrNewSZ( pScan->cbValue, pScan->pcValue ); pConfig->fSpamTrapStore = __cfgAttrSwitch( pScan->xmlNode, "to-trap" ); break; case 13: // update-header pConfig->fUpdateHeader = utilStrWordIndex( _CFG_SW_ON, pScan->cbValue, pScan->pcValue ) != -1; pszAttr = xmlGetNoNsProp( pScan->xmlNode, "from-local" ); pConfig->fUpdateHeaderLocal = ( pszAttr != NULL ) && ( utilStrWordIndex( _CFG_SW_ON, strlen( pszAttr ), pszAttr ) != -1 ); break; case 14: // command-timeout fNoError = utilStrTimeToSec( pScan->cbValue, pScan->pcValue, &pConfig->ulCommandTimeout ) && ( pConfig->ulCommandTimeout >= _CFG_MIN_COMMAND_TIMEOUT ) && ( pConfig->ulCommandTimeout <= _CFG_MAX_COMMAND_TIMEOUT ); break; case 15: // uribl fNoError = __cfgReadURIBL( pConfig, pScan->xmlNode ); break; case 16: // command-ataccept fNoError = __cfgReadCmdAtAccept( pConfig, pScan->xmlNode ); break; case 17: // command-ehlo fNoError = __cfgReadCmdEHLO( pConfig, pScan->xmlNode ); break; case 18: // command-rset fNoError = __cfgReadCmdRSET( pConfig, pScan->xmlNode ); break; case 19: // command-mail fNoError = __cfgReadCmdMAIL( pConfig, pScan->xmlNode ); break; case 20: // command-rcpt fNoError = __cfgReadCmdRCPT( pConfig, pScan->xmlNode ); break; case 21: // command-data fNoError = __cfgReadCmdDATA( pConfig, pScan->xmlNode ); break; case 22: // command-atcontent fNoError = __cfgReadCmdAtContent( pConfig, pScan->xmlNode ); break; case 23: // command-quit fNoError = __cfgReadCmdQUIT( pConfig, pScan->xmlNode ); break; } if ( !fNoError ) { if ( lRC <= 14 ) xmluScanLog( pScan, "Invalid value." ); break; } lRC = xmluScan( pScan ); } xmluEndScan( pScan ); xmlFreeDoc( pDoc ); if ( lRC != XMLU_SCAN_END ) { _cfgFree( pConfig ); return NULL; } // Check score limmits and TTLs for commands. The score limmit value should // not be less than previous one. for( ulIdx = 1; ulIdx < ARRAY_SIZE( pConfig->aCmdParam ); ulIdx++ ) { // Default TTL. if ( pConfig->aCmdParam[ulIdx].ulTTL == 0 ) pConfig->aCmdParam[ulIdx].ulTTL = ( 24 * 60 * 60 * 1000 ); if ( pConfig->aCmdParam[ulIdx].lScoreLimit < pConfig->aCmdParam[ulIdx-1].lScoreLimit ) { pConfig->aCmdParam[ulIdx].lScoreLimit = pConfig->aCmdParam[ulIdx-1].lScoreLimit; /* log( 1, "[WARNING] Set score limit for stage %u to %u", ulIdx, pConfig->lStageScoringLimit[ulIdx] );*/ } } return pConfig; }
static VOID _cfgFree(PCONFIG pConfig) { ULONG ulIdx; if ( pConfig->pszDataPath != NULL ) debugFree( pConfig->pszDataPath ); if ( pConfig->pszLogPath != NULL ) debugFree( pConfig->pszLogPath ); if ( pConfig->pszSocket != NULL ) debugFree( pConfig->pszSocket ); if ( pConfig->pszPipe != NULL ) debugFree( pConfig->pszPipe ); if ( pConfig->pszMailServerName != NULL ) debugFree( pConfig->pszMailServerName ); if ( pConfig->pcLocalDomains != NULL ) debugFree( pConfig->pcLocalDomains ); if ( pConfig->pszSpamStore != NULL ) debugFree( pConfig->pszSpamStore ); if ( pConfig->pcURIBLProviders != NULL ) debugFree( pConfig->pcURIBLProviders ); if ( pConfig->pcURIBLNotSpam != NULL ) debugFree( pConfig->pcURIBLNotSpam ); lnkseqFree( &pConfig->lsHostListLocal, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListRelays, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListIPFreqIgnore, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListScore, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListRWLIgnore, PHOSTREC, debugFree ); if ( pConfig->pcRWLProviders != NULL ) debugFree( pConfig->pcRWLProviders ); lnkseqFree( &pConfig->lsHostListMailFrom, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListEHLO, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListEHLOURIBLIgnore, PHOSTREC, debugFree ); if ( pConfig->pcAutoWhitelistIgnoreSenders != NULL ) debugFree( pConfig->pcAutoWhitelistIgnoreSenders ); if ( pConfig->pcSpamTrap != NULL ) debugFree( pConfig->pcSpamTrap ); if ( pConfig->pcGreylistIgnoreSenders != NULL ) debugFree( pConfig->pcGreylistIgnoreSenders ); lnkseqFree( &pConfig->lsHostListGreylistIgnore, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListDNSBLIgnore, PHOSTREC, debugFree ); if ( pConfig->paDNSBL != NULL ) { PDNSBL pDNSBL = pConfig->paDNSBL; for( ulIdx = 0; ulIdx < pConfig->cDNSBL; ulIdx++, pDNSBL++ ) { if ( pDNSBL->pszName != NULL ) debugFree( pDNSBL->pszName ); lnkseqFree( &pDNSBL->lsHostListAnswers, PHOSTREC, debugFree ); } debugFree( pConfig->paDNSBL ); } lnkseqFree( &pConfig->lsHostListMailFromURIBLIgnore, PHOSTREC, debugFree ); if ( pConfig->pcMailBoxCheckIgnoreSenders != NULL ) debugFree( pConfig->pcMailBoxCheckIgnoreSenders ); lnkseqFree( &pConfig->lsMailBoxCheckIgnore, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListSPFIgnore, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListMsgId, PHOSTREC, debugFree ); lnkseqFree( &pConfig->lsHostListMsgIdIgnore, PHOSTREC, debugFree ); debugFree( pConfig ); }
STATIC_FUNC void check_for_changed_sms(void *unused) { uint16_t found_sms = 0; uint16_t matching_sms = 0; struct opt_type *opt = get_option( 0, 0, ARG_SMS ); struct opt_parent *p = NULL; struct json_sms * sms = NULL; struct avl_node *an = NULL; char name[MAX_JSON_SMS_NAME_LEN]; char data[MAX_JSON_SMS_DATA_LEN + 1]; dbgf_all(DBGT_INFO, "checking..."); if (extensions_fd == -1) { task_remove(check_for_changed_sms, NULL); task_register(SMS_POLLING_INTERVAL, check_for_changed_sms, NULL, 300000); } while ((sms = avl_iterate_item(&json_sms_tree, &an))) { sms->stale = 1; } while ((p = list_iterate(&opt->d.parents_instance_list, p))) { int len = 0; memset(name, 0, sizeof (name)); strcpy(name, p->val); int fd = -1; char path_name[MAX_PATH_SIZE + 20] = ""; sprintf(path_name, "%s/%s", smsTx_dir, p->val); if ((fd = open(path_name, O_RDONLY, 0)) < 0) { dbgf_all(DBGT_INFO, "could not open %s - %s", path_name, strerror(errno)); continue; } else if ((len = read(fd, data, sizeof (data))) < 0 || len > MAX_JSON_SMS_DATA_LEN) { dbgf_sys(DBGT_ERR, "sms=%s data_len>=%d MUST BE <=%d bytes! errno: %s", path_name, len, MAX_JSON_SMS_DATA_LEN, strerror(errno)); close(fd); continue; } else if ((sms = avl_find_item(&json_sms_tree, name)) && sms->text_len == len && !memcmp(sms->text, data, len)) { matching_sms++; sms->stale = 0; close(fd); } else { if (sms) { avl_remove(&json_sms_tree, sms->name, -300378); debugFree(sms, -300369); } sms = debugMalloc(sizeof (struct json_sms) +len, -300370); memset(sms, 0, sizeof (struct json_sms) +len); strcpy(sms->name, name); sms->text_len = len; sms->stale = 0; memcpy(sms->text, data, len); avl_insert(&json_sms_tree, sms, -300371); close(fd); dbgf_track(DBGT_INFO, "new sms=%s size=%d! updating description..-", path_name, sms->text_len); } found_sms++; } if (found_sms != matching_sms || found_sms != json_sms_tree.items) { dbgf_all(DBGT_INFO, "sms found=%d matching=%d items=%d", found_sms, matching_sms, json_sms_tree.items); memset(name, 0, sizeof (name)); while ((sms = avl_next_item(&json_sms_tree, name))) { memcpy(name, sms->name, sizeof (sms->name)); if (sms->stale) { dbgf_track(DBGT_INFO, "removed sms=%s/%s size=%d! updating description...", smsTx_dir, sms->name, sms->text_len); avl_remove(&json_sms_tree, sms->name, -300373); debugFree(sms, -300374); } } my_description_changed = YES; } }
/* free only the hashtable and the hash itself. */ void hash_destroy(struct hashtable_t *hash) { debugFree(hash->table, 1302); debugFree(hash, 1303); }
VISIBLE void toggleBookmark(GtkWidget *widget,GtkTextIter *titer) { ERRDATA pageStruct *page=getPageStructByIDFromPage(-1); GtkWidget *menuitem; GtkTextMark *mark; GtkTextIter *iter; GtkTextIter siter; int line; GtkTextIter startprev,endprev; char *previewtext; GSList *mark_list=NULL; const gchar *mark_type; GList *ptr=NULL; bookMarksNew *bookmarkdata; char *correctedpreview; if(page==NULL) return; mark_type=MARK_TYPE_1; if(titer==NULL) { mark=gtk_text_buffer_get_insert((GtkTextBuffer*)page->buffer); gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&siter,mark); gtk_text_iter_set_line_offset(&siter,0); iter=(GtkTextIter*)(&siter); } else iter=titer; mark_list=gtk_source_buffer_get_source_marks_at_line(page->buffer,gtk_text_iter_get_line(iter),mark_type); if(mark_list!=NULL) { //remove entry from bookmark list ptr=newBookMarksList; while(ptr!=NULL) { if((gpointer)((bookMarksNew*)ptr->data)->mark==(gpointer)GTK_TEXT_MARK(mark_list->data)) { ERRDATA debugFree(&((bookMarksNew*)ptr->data)->markName); newBookMarksList=g_list_remove(newBookMarksList,ptr->data); gtk_text_buffer_delete_mark(GTK_TEXT_BUFFER(page->buffer),GTK_TEXT_MARK(mark_list->data)); break; } ptr=g_list_next(ptr); } /* just take the first and delete it */ //rebuild bookmark menu rebuildBookMarkMenu(); ptr=newBookMarksList; while(ptr!=NULL) { menuitem=gtk_menu_item_new_with_label(((bookMarksNew*)ptr->data)->label); gtk_menu_shell_append(GTK_MENU_SHELL(bookMarkSubMenu),menuitem); g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(jumpToMark),ptr->data); ptr=g_list_next(ptr); } gtk_widget_show_all(bookMarkMenu); g_slist_free(mark_list); } else { /* no mark found: create one */ bookmarkdata=(bookMarksNew*)malloc(sizeof(bookMarksNew)); newBookMarksList=g_list_append(newBookMarksList,(gpointer)bookmarkdata); bookmarkdata->page=page; sinkReturn=asprintf(&bookmarkdata->markName,"%s-%i",BOOKMARK_LABEL,bmMarkNumber++); bookmarkdata->mark=gtk_source_buffer_create_source_mark(page->buffer,bookmarkdata->markName,mark_type,iter); bookmarkdata->pageID=page->pageID; //preview text for menu line=gtk_text_iter_get_line(iter); gtk_text_buffer_get_iter_at_line((GtkTextBuffer*)page->buffer,&startprev,line); gtk_text_buffer_get_iter_at_line((GtkTextBuffer*)page->buffer,&endprev,line+1); previewtext=gtk_text_iter_get_text(&startprev,&endprev); previewtext[strlen(previewtext)-1]=0; g_strchug(previewtext); g_strchomp(previewtext); correctedpreview=truncateWithElipses(previewtext,maxBMChars); ERRDATA debugFree(&previewtext); previewtext=correctedpreview; bookmarkdata->label=previewtext; bookmarkdata->line=line; menuitem=gtk_menu_item_new_with_label(bookmarkdata->label); gtk_menu_shell_append(GTK_MENU_SHELL(bookMarkSubMenu),menuitem); g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(jumpToMark),(void*)bookmarkdata); gtk_widget_show_all(bookMarkMenu); } }
BOOL utilStrAddWords(PULONG pcbText, PCHAR *ppcText, ULONG cbWords, PCHAR pcWords, ULONG (*fnFilter)(ULONG cbWord, PCHAR pcWord) ) { ULONG cbText; PCHAR pcText; ULONG cbWord; PCHAR pcWord; ULONG ulSize = 0; BOOL fSpace; ULONG ulRC; // Calculate additional space for the result text. cbText = cbWords; pcText = pcWords; while( TRUE ) { utilStrCutWord( &cbText, &pcText, &cbWord, &pcWord ); if ( cbWord == 0 ) break; ulSize += cbWord + 1; // +1 - SPACE } if ( ulSize == 0 ) return TRUE; fSpace = *pcbText != 0; if ( !fSpace ) ulSize--; // Allocate memory for the result text. ulSize += *pcbText; pcText = debugReAlloc( *ppcText, ulSize ); if ( pcText == NULL ) { debug( "Not enough memory" ); return FALSE; } *ppcText = pcText; pcText += *pcbText; *pcbText = ulSize; // Adding words to the end of text. while( TRUE ) { utilStrCutWord( &cbWords, &pcWords, &cbWord, &pcWord ); if ( cbWord == 0 ) break; ulRC = ( fnFilter == NULL ) ? 1 : fnFilter( cbWord, pcWord ); if ( ulRC == 1 ) { if ( fSpace ) { *pcText = ' '; pcText++; } else fSpace = TRUE; memcpy( pcText, pcWord, cbWord ); pcText += cbWord; } else if ( ulRC != 0 ) { if ( ulSize == cbWord ) { fSpace = FALSE; ulSize = 0; } else ulSize -= ( cbWord + 1 ); } else { debugFree( *ppcText ); *ppcText = NULL; *pcbText = 0; return FALSE; } } if ( *pcbText != ulSize ) { if ( ulSize == 0 ) { debugFree( *ppcText ); *ppcText = NULL; } else *ppcText = debugReAlloc( *ppcText, ulSize ); *pcbText = ulSize; } return TRUE; }
void destroyBMData(gpointer data) { ERRDATA debugFree(&((bookMarksNew*)data)->markName); }