void BufStringDelete( BufString *bs ) { if( bs != NULL ) { if( bs->bs_Buffer ) { FFree( bs->bs_Buffer ); } FFree( bs ); } }
/** * Destroys a running event manager and the associated list of events * * @param em pointer to the EventManager structure */ void EventManagerDelete( EventManager *em ) { DEBUG("[EventManager] Delete\n"); // remove long time events if( em != NULL ) { em->em_EventThread->t_Quit = TRUE; while( TRUE ) { if( em->em_EventThread->t_Launched == FALSE ) { break; } usleep( 5000 ); } if( em->em_EventThread != NULL ) { DEBUG("[EventManager] Delete thread\n"); ThreadDelete( em->em_EventThread ); } DEBUG("[EventManager] thread removed\n"); // waiting till all functions died while( TRUE ) { if( threadsNo <= 0 ) { break; } DEBUG("[EventManager] Not all threads were closed properly, waiting. ThreadsNo: %d\n", threadsNo ); usleep( 500 ); } CoreEvent *locnce = em->em_EventList; while( locnce != NULL ) { CoreEvent *rem = locnce; locnce = (CoreEvent *)locnce->node.mln_Succ; FFree( rem ); } FFree( em ); } DEBUG("[EventManager] Delete end\n"); }
void test1(void) { int i; assert(MAX >= 100); InitFMem(BasicAlloc, BasicFree, NULL, NULL); memset(a, 0, sizeof(a)); FAlloc(0); FFree(0); for (i = 0; i < MAX-50; i++) { AddElem(i, rand() % 50 + 1); } for (i = MAX-50; i < MAX; i++) { AddElem(i, rand() % 10 + 253); } for (i = 0; i < MAX; i++) { FreeElem(i); } for (i = 0; i < 10000; i++) { if (rand() % 2 && numInA < MAX) { AddRandElem(rand() % 20 + 1); } else if (numInA > 0) { FreeRandElem(); } } FreeAllElems(); AddRandElem(20); AddRandElem(40); AddRandElem(255); AddRandElem(256); FiniFMem(FMEM_CHECK); assert(g_memUsed == 0); printf("Test 1 -- Success.\n"); printMemStats(); }
void HashedString ( char **str ) { unsigned char temp[SHA_DIGEST_LENGTH]; memset( temp, 0x0, SHA_DIGEST_LENGTH ); //char *buf = FMallocAlign( ( SHIFT_LEFT( SHA_DIGEST_LENGTH, 1) ) + 1 ); char *buf = FCallocAlign( ( SHIFT_LEFT( SHA_DIGEST_LENGTH, 1) ) + 1, 1 ); //char *buf = FCalloc( ( SHIFT_LEFT( SHA_DIGEST_LENGTH, 1) ) + 1, sizeof( char ) ); if( buf != NULL ) { SHA1( ( unsigned char *)*str, strlen( *str ), temp); int i = 0; for ( ; i < SHA_DIGEST_LENGTH; i++ ) { sprintf( (char*)&(buf[ SHIFT_LEFT( i, 1) ]), "%02x", temp[i] ); } if ( *str ) { FFree ( *str ); } DEBUG ( "[HashedString] Hashing\n" ); *str = buf; DEBUG ( "[HashedString] Hashed\n" ); } else { FERROR("Cannot allocate memory for hashed string\n"); } }
/** * Delete UserGroup * * @param ug pointer to UserGroup which will be deleted * @return 0 when success, otherwise error number */ int UserGroupDelete( UserGroup *ug ) { if( ug != NULL ) { if( ug->ug_Name != NULL ) { FFree( ug->ug_Name ); } if( ug->ug_Type != NULL ) { FFree( ug->ug_Type ); } } return 0; }
/** * De-initialize authmodule * * @param l pointer to AuthMod */ void libClose( struct AuthMod *l ) { if( l->SpecialData != NULL ) { FFree( l->SpecialData ); } DEBUG("[FCDB] close\n"); }
int KeyValueListDelete( KeyValueList *list ) { if( list != NULL ) { if( list->key != NULL ) { FFree( list->key ); } if( list->value != NULL ) { FFree( list->value ); } FFree( list ); } return 0; }
void AppSessionDelete( AppSession *as ) { DEBUG("[AppSession] Delete app session\n"); if( as != NULL ) { pthread_mutex_lock( &as->as_SessionsMut ); SASUList *ali = as->as_UserSessionList; SASUList *rml = ali; while( ali != NULL ) { rml = ali; ali = (SASUList *) ali->node.mln_Succ; FFree( rml ); rml = NULL; } pthread_mutex_unlock( &as->as_SessionsMut ); pthread_mutex_destroy( &as->as_SessionsMut ); pthread_mutex_lock( &as->as_VariablesMut ); INVAREntry *le = as->as_Variables; INVAREntry *re = le; while( le != NULL ) { re = le; le = (INVAREntry *) le->node.mln_Succ; INVAREntryDelete( re ); } pthread_mutex_unlock( &as->as_VariablesMut ); pthread_mutex_destroy( &as->as_VariablesMut ); FFree( as ); as = NULL; } DEBUG("[AppSession] App sessions deleted\n"); }
int KeyValueListSetValues( KeyValueList *list, char *key, char *value ) { if( list != NULL ) { if( list->key != NULL ) { FFree( list->key ); } if( list->value != NULL ) { FFree( list->value ); } list->key = StringDuplicate( key ); list->value = StringDuplicate( value ); } return 0; }
static inline BYTE *readFormFromSocket( Socket_t *s, ULONG *length ) { BYTE *retData = NULL; char buffer[ MAX_SIZE ]; int readSize; readSize = SocketRead( s, buffer, MAX_SIZE, 0 ); DataForm *ldf = (DataForm *)buffer; // its our packet if( ldf->df_ID == ID_FCRE ) { // message is bigger then buffer // we must read it all if( ldf->df_Size > MAX_SIZE ) { unsigned int readedBytes = readSize; BufString *bs = BufStringNew(); BufStringAddSize( bs, buffer, readSize ); // reading bytes till end while( readedBytes <= ldf->df_Size ) { readSize = SocketRead( s, buffer, MAX_SIZE, 0 ); BufStringAddSize( bs, buffer, readSize ); readedBytes += readSize; } FFree( bs ); *length = bs->bs_Size; return (BYTE *)bs->bs_Buffer; } // message fits buffer else { if( ( retData = FCalloc( readSize, sizeof(BYTE) ) ) != NULL ) { memcpy( retData, buffer, readSize ); *length = readSize; } else { ERROR("Cannot allocate memory for message buffer\n"); } } } return retData; }
/** * Delete LocFile structure * * @param file pointer to LocFile which will be deleted */ void LocFileDelete( LocFile* file ) { if( file == NULL ) { FERROR("Cannot free file which doesnt exist\n"); } if( file->lf_Filename != NULL ) { FFree( file->lf_Filename ); } /* if( file->lf_Fp ) { fclose( file->lf_Fp ); file->lf_Fp = NULL; } */ if( file->lf_Path ) { FFree( file->lf_Path ); file->lf_Path = NULL; } if( file->lf_Buffer ) { #if LOCFILE_USE_MMAP == 0 FFree( file->lf_Buffer ); #else munmap(file->lf_Buffer, file->lf_FileSize); #endif file->lf_Buffer = NULL; } if( file->lf_Mime != NULL ) { FFree( file->lf_Mime ); file->lf_Mime = NULL; } FFree( file ); }
int SafeString ( char **string, int length ) { if ( length == 0 ) length = strlen ( *string ); if ( ( *string )[length-1] != '\0' ) { char *newStr = MakeString ( length ); sprintf ( newStr, "%.*s", length, *string ); FFree ( *string ); *string = newStr; return length + 1; } return length; }
/** * Websocket delete function * * @param ws pointer to WebSocket structure which will be deleted */ void WebSocketDelete( WebSocket* ws ) { if( ws != NULL ) { ws->ws_Quit = TRUE; DEBUG("[WS] Websocket close in progress\n"); int tries = 0; #ifdef ENABLE_WEBSOCKETS_THREADS while( TRUE ) { if( WSThreadNum <= 0 && ws->ws_Thread->t_Launched == FALSE ) { break; } DEBUG("[WS] Closeing WS. Threads: %d\n", WSThreadNum ); sleep( 1 ); tries++; if( tries > 50 ) { //WorkerManagerDebug( SLIB ); tries = 0; } } #endif Log( FLOG_DEBUG, "[WS] Closeing thread\n"); if( ws->ws_Thread ) { ThreadDelete( ws->ws_Thread ); } Log( FLOG_DEBUG, "[WS] Thread closed\n"); if( ws->ws_Context != NULL ) { lws_context_destroy( ws->ws_Context ); ws->ws_Context = NULL; } if( ws->ws_CertPath != NULL ) { } FFree( ws ); } pthread_mutex_destroy( &WSThreadMutex ); }
int Release( struct FHandler *s, void *f ) { if( f != NULL ) { DEBUG("[fsysphp] Release filesystem\n"); File *lf = (File*)f; if( lf->f_SpecialData ) { SpecialData *sd = (SpecialData *)lf->f_SpecialData; // Free up active device information if( sd->module ){ FFree( sd->module ); sd->module = NULL; } //if( lf->f_SessionID ){ FFree( lf->f_SessionID ); lf->f_SessionID = NULL; } if( sd->type ){ FFree( sd->type ); sd->type = NULL; } FFree( lf->f_SpecialData ); } // Free up active device information if( lf->f_Name ){ FFree( lf->f_Name ); } if( lf->f_Path ){ FFree( lf->f_Path ); } } return 0; }
void StringSecureFree( char* str ) { char *ptr; if( !str ) { return; } ptr = str; while( *ptr ) { *(ptr++) = 0; } FFree( str ); return; }
void SSHServerDelete( SSHServer *ts ) { if( ts != NULL ) { ts->sshs_Quit = TRUE; #ifdef ENABLE_SSH if( ts->sshs_Thread ) { ThreadDelete( ts->sshs_Thread ); } ssh_finalize(); #endif FFree( ts ); } }
void FreeElem(unsigned num) { int i; int size; char *p; assert(num < MAX); assert(a[num].ptr != NULL); assert(numInA > 0); p = a[num].ptr; size = a[num].size; for (i = 0; i < size; i++) { assert(p[i] == (char) size); } FFree(p); numInA--; a[num].ptr = NULL; a[num].size = 0; }
void test2(void) { clock_t timer = clock(); int top = 0; int i; for (i = 0; i < 500000; i++) { if (rand() % 2) { if (top < MAX) { a[top++].ptr = FAlloc(rand() % 20 + 1); } } else if (top > 0) { FFree(a[--top].ptr); } } FiniFMem(FMEM_NO_CHECK); timer = clock() - timer; printf("Time spent: %ld\n", timer); printf("Test 2 -- Success.\n"); }
BufString *BufStringNewSize( int bufsize ) { BufString *str = NULL; if( ( str = FCalloc( sizeof( BufString ), 1 ) ) != NULL ) { str->bs_Size = 0; str->bs_Bufsize = bufsize; str->bs_MAX_SIZE = bufsize; if( ( str->bs_Buffer = FCalloc( str->bs_Bufsize + 1, sizeof( char ) ) ) != NULL ) { return str; } FFree( str ); } return NULL; }
int AppSessionRemUsersession( AppSession *as, UserSession *u ) { if( as != NULL ) { DEBUG("[AppSession] AppSessionRemUsersession %s\n", u->us_SessionID ); pthread_mutex_lock( &as->as_SessionsMut ); SASUList *ali = (SASUList *)as->as_UserSessionList->node.mln_Succ; // we cannot remove owner SASUList *prevali = as->as_UserSessionList; while( ali != NULL ) { if( u == ali->usersession ) { if( ali == as->as_UserSessionList ) { as->as_UserSessionList =(SASUList *)ali->node.mln_Succ; } else { prevali->node.mln_Succ = ali->node.mln_Succ; } as->as_UserNumber--; DEBUG("[AppSession] Session removed, sessions %d\n", as->as_UserNumber ); FFree( ali ); break; } prevali = ali; ali = (SASUList *) ali->node.mln_Succ; } pthread_mutex_unlock( &as->as_SessionsMut ); as->as_Timer = time( NULL ); } return -1; }
int UnMount( struct FHandler *s, void *f ) { if( f != NULL ) { DEBUG("[fsysphp] Unmount filesystem\n"); File *lf = (File*)f; if( lf->f_SpecialData ) { SpecialData *sd = (SpecialData *)lf->f_SpecialData; char command[ 2048 ]; // maybe we should count that... sprintf( command, "php \"modules/system/module.php\" \"command=unmount&devname=%s&module=%s&sessionid=%s\";", lf->f_Name, sd->module, lf->f_SessionID ); int answerLength; ListString *result = PHPCall( command, &answerLength ); if( result && result->ls_Size >= 0 ) { if( strncmp( result->ls_Data, "fail", 4 ) == 0 ) { DEBUG( "[fsysphp] Failed to unmount device %s..\n", lf->f_Name ); } } else { DEBUG( "[fsysphp] Unknown error unmounting device %s..\n", lf->f_Name ); } // we should parse result to get information about success if( result ) ListStringDelete( result ); // Free up active device information if( sd->module ) FFree( sd->module ); if( lf->f_SessionID ) FFree( lf->f_SessionID ); if( sd->type ) FFree( sd->type ); FFree( lf->f_SpecialData ); } // Free up active device information if( lf->f_Name ){ FFree( lf->f_Name ); } if( lf->f_Path ){ FFree( lf->f_Path ); } } return 0; }
void FriendCoreManagerDelete( FriendCoreManager *fcm ) { DEBUG("FriendCoreManager END - start\n"); if( fcm != NULL ) { DEBUG("FriendCoreManager: close event\n"); if( fcm->fcm_EventManager != NULL ) { EventManagerDelete( fcm->fcm_EventManager ); } DEBUG("FriendCoreManager Shutdown\n"); FriendCoreShutdown( fcm->fcm_FriendCores ); DEBUG("FriendCoreManager shutdown finished\n"); DEBUG("FriendCoreManager Close client\n"); CommServiceDelete( fcm->fcm_CommServiceClient ); DEBUG("FriendCoreManager Close server\n"); CommServiceDelete( fcm->fcm_CommServiceServer ); #ifdef ENABLE_WEBSOCKETS WebSocketFree( fcm->fcm_WebSocket ); #endif DEBUG("FriendCoreManager Close services\n"); if( fcm->fcm_ServiceManager != NULL ) { ServiceManagerDelete( fcm->fcm_ServiceManager ); } DEBUG("FriendCoreManager Close SSH Server\n"); SSHServerDelete( fcm->fcm_SSHServer ); FFree( fcm ); } DEBUG("FriendCoreManager END - Reads: %d Writes: %d\n", _reads, _writes ); }
int AppSessionSendOwnerMessage( AppSession *as, UserSession *sender, char *msg, int length ) { int msgsndsize = 0; if( as == NULL ) { DEBUG("[AppSession] AppSession parameter is empty\n"); return -1; } time_t ntime = time( NULL ); DEBUG("[AppSession] OLD TIME %lld NEW TIME %lld\n", (long long)as->as_Timer, (long long)ntime ); if( ( ntime - as->as_Timer ) > TIMEOUT_APP_SESSION ) { as->as_Obsolete = TRUE; } as->as_Timer = ntime; DEBUG("[AppSession] Send message %s\n", msg ); char *newmsg = NULL; if( ( newmsg = FCalloc( length+256, sizeof(char) ) ) != NULL ) { User *usend = sender->us_User; DEBUG("[AppSession] AS POINTER %p SENDER %p\n", as, usend ); int newmsgsize = sprintf( newmsg, WS_MESSAGE_TEMPLATE_USER, as->as_AuthID, as->as_SASID, usend->u_Name, msg ); msgsndsize += WebSocketSendMessageInt( as->as_UserSessionList->usersession, newmsg, newmsgsize ); DEBUG("[AppSession] FROM %s TO %s MESSAGE SIZE %d\n", usend->u_Name, as->as_UserSessionList->usersession->us_User->u_Name, msgsndsize ); FFree( newmsg ); } else { FERROR("Cannot allocate memory for message\n"); } return msgsndsize; }
/** * Create new worker * * @param nr id of new worker * @return pointer to new Worker structure when success, otherwise NULL */ void WorkerDelete( Worker *w ) { if( w != NULL ) { if( w->w_Thread ) { int count = 0; w->w_Quit = TRUE; while( w->w_State != W_STATE_TO_REMOVE ) { if( pthread_mutex_lock( &(w->w_Mut) ) == 0 ) { pthread_cond_signal( &(w->w_Cond) ); // <- wake up!! pthread_mutex_unlock( &(w->w_Mut) ); } DEBUG("[WorkerThread] State %d quit %d WRKID %d\n", w->w_State, w->w_Quit, w->w_Nr ); if( count++ > 1 ) { usleep( 10000 ); } } ThreadDelete( w->w_Thread ); } // Free up the mutex elements if( w->w_State ) { pthread_cond_destroy( &(w->w_Cond) ); pthread_mutex_destroy( &(w->w_Mut) ); } DEBUG("[WorkerThread] Worker deleted: %d\n", w->w_Nr ); FFree( w ); } }
/** * Reload content from file * * @param file pointer to LocFile structure * @param path pointer to path from which data will be reloaded * @return 0 when success, otherwise error number */ int LocFileReload( LocFile *file, char *path ) { DEBUG("File %s will be reloaded\n", path ); if( file->lf_Buffer ) { FFree( file->lf_Buffer ); file->lf_Buffer = NULL; } FILE* fp = fopen( path, "rb" ); if( fp == NULL ) { FERROR("Cannot open file %s (file does not exist?)..\n", path ); return -1; } struct stat st; if( stat( path, &st ) < 0 ) { FERROR("Cannot run stat on file: %s!\n", path); return -2; } memcpy( &(file->lf_Info), &st, sizeof(stat) ); fseek( fp, 0, SEEK_END ); long fsize = ftell( fp ); fseek( fp, 0, SEEK_SET ); //same as rewind(f); file->lf_FileSize = fsize; LocFileRead( file, fp, 0, file->lf_FileSize ); fclose( fp ); return 0; }
void FilesystemDelete( Filesystem *fs ) { if( fs->fs_Name != NULL ) { FFree( fs->fs_Name ); } if( fs->fs_Type != NULL ) { FFree( fs->fs_Type ); } if( fs->fs_ShortDescription != NULL ) { FFree( fs->fs_ShortDescription ); } if( fs->fs_Server ) { FFree( fs->fs_Server ); } if( fs->fs_Path != NULL ) { FFree( fs->fs_Path ); } if( fs->fs_Username != NULL ) { FFree( fs->fs_Username ); } if( fs->fs_Password != NULL ) { FFree( fs->fs_Password ); } }
/** * Create WebSocket structure * * @param sb pointer to SystemBase * @param port port on which WS will work * @param sslOn TRUE when WS must be secured through SSL, otherwise FALSE * @return pointer to new WebSocket structure, otherwise NULL */ WebSocket *WebSocketNew( void *sb, int port, FBOOL sslOn ) { WebSocket *ws = NULL; SystemBase *lsb = (SystemBase *)sb; DEBUG1("[WS] New websocket\n"); pthread_mutex_init( &WSThreadMutex, NULL ); if( ( ws = FCalloc( 1, sizeof( WebSocket ) ) ) != NULL ) { char *fhome = getenv( "FRIEND_HOME" ); ws->ws_FCM = lsb->fcm; ws->ws_Port = port; ws->ws_UseSSL = sslOn; ws->ws_OldTime = 0; ws->ws_InterfaceName[ 0 ] = 0; memset( &(ws->ws_Info), 0, sizeof ws->ws_Info ); ws->ws_Opts = 0; ws->ws_Interface = NULL; if( ws->ws_UseSSL == TRUE ) { INFO("[WS] WebSocket: SSL Enabled\n"); ws->ws_CertPath = lsb->RSA_SERVER_CERT; ws->ws_KeyPath = lsb->RSA_SERVER_KEY; DEBUG1("[WS] server cert %s keycert %s\n", ws->ws_CertPath, ws->ws_KeyPath ); //sprintf( ws->ws_CertPath, "%s%s", fhome, "/libwebsockets-test-server.pem" ); //sprintf( ws->ws_KeyPath, "%s%s", fhome, "/libwebsockets-test-server.key.pem" ); //ws->ws_Opts |= LWS_SERVER_OPTION_REDIRECT_HTTP_TO_HTTPS; } if( ws->ws_AllowNonSSL == TRUE ) { //ws->ws_Opts |= LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT; } /* case 'k': opts = LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK; break; */ ws->ws_Info.port = ws->ws_Port; ws->ws_Info.protocols = protocols; ws->ws_Info.iface = ws->ws_Interface; ws->ws_Info.gid = -1; ws->ws_Info.uid = -1; ws->ws_Info.extensions = NULL; ws->ws_Info.ssl_cert_filepath = ws->ws_CertPath; ws->ws_Info.ssl_private_key_filepath = ws->ws_KeyPath; ws->ws_Info.options = ws->ws_Opts;// | LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT; if( ws->ws_UseSSL == TRUE ) { ws->ws_Info.options |= LWS_SERVER_OPTION_REDIRECT_HTTP_TO_HTTPS|LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT; } ws->ws_Info.user = ws; //ws->ws_Info.extensions = lws_get_internal_extensions(); //ws->ws_Info.extensions->per_context_private_data = ws; ws->ws_Info.ssl_cipher_list = "ECDHE-ECDSA-AES256-GCM-SHA384:" "ECDHE-RSA-AES256-GCM-SHA384:" "DHE-RSA-AES256-GCM-SHA384:" "ECDHE-RSA-AES256-SHA384:" "HIGH:!aNULL:!eNULL:!EXPORT:" "!DES:!MD5:!PSK:!RC4:!HMAC_SHA1:" "!SHA1:!DHE-RSA-AES128-GCM-SHA256:" "!DHE-RSA-AES128-SHA256:" "!AES128-GCM-SHA256:" "!AES128-SHA256:" "!DHE-RSA-AES256-SHA256:" "!AES256-GCM-SHA384:" "!AES256-SHA256"; ws->ws_CountPollfds = 0; //ws->ws_Info.ka_time = 15; //lws_set_log_level( 0, lwsl_emit_syslog); ws->ws_Context = lws_create_context( &ws->ws_Info ); if( ws->ws_Context == NULL ) { FERROR( "Libwebsocket init failed, cannot create context\n" ); FFree( ws ); return NULL; } INFO("[WS] NEW Websockets ptr %p context %p\n", ws, ws->ws_Context); ws->ws_Buf[ LWS_SEND_BUFFER_PRE_PADDING ] = 'x'; } else { FERROR("[WS] Cannot allocate memory for WebSocket\n"); } DEBUG1("[WS] Websocket created\n"); return ws; }
void *FileOpen( struct File *s, const char *path, char *mode ) { int spath = strlen( path ); char *tmppath = FCalloc( spath+10, sizeof(char) ); memcpy( tmppath, path, spath ); File *locfil = NULL; DEBUG("File open\n"); SpecialData *srd = (SpecialData *)s->f_SpecialData; int error = 0; // we are takeing filename from path, path will be used to make directories only char *nameptr = (char *)path; int i; for( i=spath ; i >= 0 ; i-- ) { if( path[ i ] == '/' ) { nameptr = (char *)&path[i+1]; tmppath[ i ] = 0; break; } } DEBUG("File open 1 path %s tmppath %s nameptr %s\n", path, tmppath, nameptr ); INRAMFile *directory = NULL; if( strcmp( path, nameptr ) != 0 ) { directory = INRAMFileMakedirPath( srd->root, tmppath, &error ); } else { directory = srd->root; } if( directory != NULL ) { DEBUG("Directory where file will be create/exist %s\n", directory->nf_Name ); INRAMFile *nf = NULL; nf = INRAMFileGetChildByName( directory, nameptr ); // read DEBUG("\nINRAM opened file for %s\n\n", mode ); if( mode[ 0 ] == 'r' ) { if( nf == NULL ) { free( tmppath ); FERROR("Cannot open file %s\n", path ); return NULL; } nf->nf_Offset = 0; } else // write { if( nf == NULL ) { nf = INRAMFileNew( INRAM_FILE, tmppath, nameptr ); if( INRAMFileAddChild( directory, nf ) == 0 ) { } } else { } } // Ready the file structure if( ( locfil = calloc( sizeof( File ), 1 ) ) != NULL ) { locfil->f_Path = StringDup( path ); DEBUG("Fileopen, path duplicated %s\n", path ); locfil->f_SpecialData = calloc( 1, sizeof( SpecialData ) ); SpecialData *sd = (SpecialData *)locfil->f_SpecialData; if( sd ) { sd->fp = nf; } DEBUG("\nOffset set to %ld\n\n", nf->nf_Offset ); DEBUG("File open, descriptor returned\n"); return locfil; } } FFree( tmppath ); DEBUG("File open end\n"); return NULL; }
int BufStringAdd( BufString *bs, const char *ntext ) { if( ntext == NULL ) { return 1; } int addsize = strlen( ntext );//+1; if( bs->bs_Size == 0 ) { // buffer is too small to handle data, we must extend it if( addsize > bs->bs_MAX_SIZE ) { int allsize = ( (addsize / bs->bs_MAX_SIZE) + 1) * bs->bs_MAX_SIZE; char *tmp; if( ( tmp = FCalloc( allsize+1, sizeof(char) ) ) != NULL ) { strcpy( tmp, ntext ); bs->bs_Bufsize = allsize; bs->bs_Size = addsize; } else { ERROR("Cannot allocate memory for BUFString\n"); return -1; } } else // buffer is enough to hold data, just copy it { strcpy( bs->bs_Buffer, ntext ); bs->bs_Size = strlen( ntext ); } return 0; } //int modsize = (bs->bs_Size / bs->bs_MAX_SIZE) * bs->bs_MAX_SIZE; int newsize = (bs->bs_Size + addsize); if( newsize > bs->bs_Bufsize ) { char *tmp; int allsize = ( (newsize / bs->bs_MAX_SIZE) + 1) * bs->bs_MAX_SIZE; if( ( tmp = FCalloc( allsize+1, sizeof(char) ) ) != NULL ) { bs->bs_Bufsize = allsize; bs->bs_Size = newsize; strcpy( tmp, bs->bs_Buffer ); strcat( tmp, ntext ); FFree( bs->bs_Buffer ); bs->bs_Buffer = tmp; } else { ERROR("Cannot allocate memory for buffer!\n"); return -1; } // there is no space in the buffer, we must extend it } else { // there is some space in buffer, we can put information there strcat( bs->bs_Buffer, ntext ); bs->bs_Size = newsize; } return 0; }
int BufStringAddSize( BufString *bs, const char *ntext, int len ) { if( ntext == NULL ) { ERROR("Cannot add NULL text!\n"); return 1; } if( bs->bs_Size == 0 ) { // buffer is too small to handle data, we must extend it if( len > bs->bs_MAX_SIZE ) { DEBUG( "Too big buffer! (len: %d, max: %d)\n", len, bs->bs_MAX_SIZE ); int allsize = ( (len / bs->bs_MAX_SIZE) + 1) * bs->bs_MAX_SIZE; char *tmp; if( ( tmp = FCalloc( allsize + 10, sizeof(char) ) ) != NULL ) { memcpy( tmp, ntext, len ); bs->bs_Bufsize = allsize; bs->bs_Size = len; FFree( bs->bs_Buffer ); bs->bs_Buffer = tmp; } else { ERROR("Cannot allocate memory for BUFString\n"); return -1; } } else // buffer is enough to hold data, just copy it { memcpy( bs->bs_Buffer, ntext, len ); bs->bs_Size = len; } return 0; } int addsize = len; // int modsize = (bs->bs_Size / bs->bs_MAX_SIZE) * bs->bs_MAX_SIZE; int newsize = (bs->bs_Size + addsize); //DEBUG("Add memory for buffer addsize %d modsize %d newsize %d current %d\n", addsize, modsize, newsize, bs->bs_Size ); if( newsize > bs->bs_Bufsize ) { char *tmp; int allsize = ( (newsize / bs->bs_MAX_SIZE) + 1) * bs->bs_MAX_SIZE; //DEBUG("Allocated mem size %d\n", allsize ); if( ( tmp = FCalloc( allsize+10, sizeof(char) ) ) != NULL ) { memcpy( tmp, bs->bs_Buffer, bs->bs_Size ); //DEBUG("copy from %d len %d\n", bs->bs_Size, len ); memcpy( &(tmp[ bs->bs_Size ]), ntext, len ); bs->bs_Bufsize = allsize; bs->bs_Size = newsize; FFree( bs->bs_Buffer ); bs->bs_Buffer = tmp; } else { ERROR("Cannot allocate memory for buffer!\n"); return -1; } // there is no space in the buffer, we must extend it } else { // there is some space in buffer, we can put information there memcpy( &(bs->bs_Buffer[ bs->bs_Size ] ), ntext, len ); bs->bs_Size = newsize; } return 0; }