void wpacket_destroy(wpacket_t *w) { buffer_release(&(*w)->buf); buffer_release(&(*w)->writebuf); FREE((*w)->allocator,*w); *w = NULL; }
void rpacket_destroy(rpacket_t *r) { //释放所有对buffer_t的引用 buffer_release(&(*r)->buf); buffer_release(&(*r)->readbuf); buffer_release(&(*r)->binbuf); FREE((*r)->allocator,*r); *r = 0; }
void wpacket_destroy(wpacket_t *w) { buffer_release(&(*w)->buf); buffer_release(&(*w)->writebuf); LIST_PUSH_BACK(g_wpacket_pool,*w); //free(*w); *w = 0; }
void rpk_destroy(rpacket_t *r) { //释放所有对buffer_t的引用 buffer_release(&PACKET_BUF(*r));//(*r)->base.buf); buffer_release(&(*r)->readbuf); buffer_release(&(*r)->binbuf); FREE(rpacket_allocator,*r); *r = 0; }
void connection_destroy(void *arg) { struct connection *c = (struct connection*)arg; unregister_timer(con2wheelitem(c)); wpacket_t w; while((w = LLIST_POP(wpacket_t,&c->send_list))!=NULL) wpk_destroy(&w); buffer_release(&c->unpack_buf); buffer_release(&c->next_recv_buf); free(c); //printf("connection_destroy\n"); }
static char *parse_delimited_text(const char **s) { Buffer buf; bool escaped = false; char delim = **s; if (!delim) return NULL; buffer_init(&buf); for ((*s)++; **s && (**s != delim || escaped); (*s)++) { if (!escaped && **s == '\\') { escaped = true; continue; } char c = **s; if (escaped) { escaped = false; switch (**s) { case '\n': continue; case 'n': c = '\n'; break; case 't': c = '\t'; break; default: if (**s != '\\' && **s != delim) buffer_append(&buf, "\\", 1); break; } } if (!buffer_append(&buf, &c, 1)) { buffer_release(&buf); return NULL; } } if (**s == delim) (*s)++; if (!buffer_append(&buf, "\0", 1)) { buffer_release(&buf); return NULL; } return buf.data; }
void vis_free(Vis *vis) { if (!vis) return; if (vis->event && vis->event->vis_quit) vis->event->vis_quit(vis); vis->event = NULL; while (vis->windows) vis_window_close(vis->windows); file_free(vis, vis->command_file); file_free(vis, vis->search_file); file_free(vis, vis->error_file); for (int i = 0; i < LENGTH(vis->registers); i++) register_release(&vis->registers[i]); vis->ui->free(vis->ui); map_free(vis->cmds); map_free_full(vis->usercmds); map_free(vis->options); map_free(vis->actions); map_free(vis->keymap); buffer_release(&vis->input_queue); for (int i = 0; i < VIS_MODE_INVALID; i++) map_free(vis_modes[i].bindings); array_release_full(&vis->motions); array_release_full(&vis->textobjects); free(vis); }
int connection_destroy(struct connection** c) { if(!(*c)->recv_overlap.isUsed && !(*c)->send_overlap.isUsed) { wpacket_t w; while(w = LINK_LIST_POP(wpacket_t,(*c)->send_list)) wpacket_destroy(&w); LINK_LIST_DESTROY(&(*c)->send_list); buffer_release(&(*c)->unpack_buf); buffer_release(&(*c)->next_recv_buf); free(*c); *c = 0; return 0; } return -1; }
static char* load_query( const char* filename ) { FILE* fp; // Sanity check if( ! filename || ! *filename ) { fprintf( stderr, "Name of query file is empty or missing\n" ); return NULL; } // Open query file, or use standard input if( ! strcmp( filename, "-" ) ) fp = stdin; else { fp = fopen( filename, "r" ); if( !fp ) { fprintf( stderr, "Unable to open query file \"%s\"\n", filename ); return NULL; } } // Load file into a growing_buffer size_t num_read; char buf[ BUFSIZ + 1 ]; growing_buffer* gb = buffer_init( sizeof( buf ) ); while( ( num_read = fread( buf, 1, sizeof( buf ) - 1, fp ) ) ) { buf[ num_read ] = '\0'; buffer_add( gb, buf ); } if( fp != stdin ) fclose( fp ); return buffer_release( gb ); }
void uv_udp_handle_t::write(request_udp_write_t& request) { int32_t err = UV_UNKNOWN; if (request.m_shared_write) { uv_udp_handle_t* handle = (uv_udp_handle_t*)singleton_ref(network_t).get_shared_write_socket(request.m_socket_fd); if (handle != NULL) { uint32_t length = request.m_length > 0 ? request.m_length : (uint32_t)buffer_data_length(request.m_buffer); if (uv_is_closing((uv_handle_t*)handle)) { err = NL_EUDPSCLOSED; } else { err = handle->write_handle(request); } } else { err = NL_EUDPNOWSHARED; } } else { err = request.m_socket_handle->write_handle(request); } if (err != UV_OK) { /* write error had been occurred */ if (request.m_length > 0) { nl_free((void*)request.m_string); } else { buffer_release(request.m_buffer); } if (request.m_session != LUA_REFNIL) { singleton_ref(node_lua_t).context_send(request.m_source, 0, request.m_session, RESPONSE_UDP_WRITE, (nl_err_code)err); } } }
struct gwseriport *gwseriport_create(const char *ttypath,int uart_speed) { struct gwseriport *s = malloc(sizeof(*s)); if(s == NULL) return NULL; memset(s,0,sizeof(*s)); int fd = open_seriport(ttypath,uart_speed); if(fd < 0){ free(s); return NULL; } s->recvbuf = buffer_create(1024); s->fd = fd; s->ttypath = strdup(ttypath); if(aeCreateFileEvent(server.el,fd,AE_READABLE,seriportHandler,s) == AE_ERR){ close(fd); buffer_release(s->recvbuf); free(s); return NULL; } listAddNodeTail(server.seriports,s); return s; }
/* ser_phy API function */ void ser_phy_close(void) { m_spi_master_state = SER_PHY_STATE_DISABLED; m_callback_events_handler = NULL; buffer_release(&mp_tx_buffer, &m_tx_buf_len); buffer_release(&mp_rx_buffer, &m_rx_buf_len); m_tx_packet_length = 0; m_accumulated_tx_packet_length = 0; m_current_tx_packet_length = 0; m_rx_packet_length = 0; m_accumulated_rx_packet_length = 0; m_current_rx_packet_length = 0; ser_phy_deinit_gpiote(); spi_master_close(SER_PHY_SPI_MASTER); }
static void buffer_destroy(void *b) { buffer_t _b = (buffer_t)b; if(_b->next) buffer_release(&(_b)->next); FREE(buffer_allocator,_b); b = 0; }
static inline void buffer_destroy(void *b) { buffer_t _b = (buffer_t)b; if(_b->next) buffer_release(&(_b)->next); FREE(NULL,_b); b = 0; }
static void content(void) { char current; /* * We should get one character at a time. */ assert(strlen(yytext) == 1); current = yytext[0]; if (current == EOF) return; if (is_newline(current)) { newline(); return; } buffer_push_char(current_buf, current); /* * Forcing newline changes 'text' so lets do it after we've pushed * it to the buffer. */ if (wrap_long_lines && need_wrap(current_buf)) { struct buffer tmp; buffer_init(&tmp, buffer_size(current_buf)); /* * Find last character that was not whitespace */ for (;;) { int c; if (buffer_size(current_buf) == 0) break; c = buffer_pop_char(current_buf); if (is_whitespace(c)) { /* * Do not push whitespace because it would appear * after the newline. */ break; } /* * Characters are put in tmp buffer in reverse order. */ buffer_push_char(&tmp, c); } force_newline_for_wrap(current_buf); /* * Restore non-wrapped text into buffer. */ while (buffer_size(&tmp) > 0) { buffer_push_char(current_buf, buffer_pop_char(&tmp)); } buffer_release(&tmp); } }
void cleanup(cog *c){ switch(c->type){ case COG_CONCAT: cleanup(c->data.concat.lhs); cleanup(c->data.concat.rhs); break; case COG_BTREE: cleanup(c->data.btree.lhs); cleanup(c->data.btree.rhs); break; case COG_ARRAY: buffer_release(c->data.array.records); break; case COG_SORTEDARRAY: buffer_release(c->data.sortedarray.records); break; } free_cog(c); }
int connection_destroy(struct connection** c) { if(!(*c)->recv_overlap.isUsed && !(*c)->send_overlap.isUsed) { wpacket_t w; while((w = LINK_LIST_POP(wpacket_t,(*c)->send_list))!=NULL) wpacket_destroy(&w); LINK_LIST_DESTROY(&(*c)->send_list); buffer_release(&(*c)->unpack_buf); buffer_release(&(*c)->next_recv_buf); if((*c)->wheelitem) DestroyWheelItem(&((*c)->wheelitem)); free(*c); *c = NULL; printf("connection_destroy\n"); return 0; } return -1; }
int vsprintf(char *string, const char *fmt, va_list ap) { struct buffer b; buffer_init(&b); vbprintf(&b, fmt, ap); memcpy(string, b.buffer, b.position); string[b.position]= '\0'; buffer_release(&b); return b.position; }
buffer_t buffer_acquire(buffer_t b1,buffer_t b2) { if(b1 == b2) return b1; if(b2) ref_increase(&b2->_refbase); if(b1) buffer_release(&b1); return b2; }
char* jsonObjectToXML(const jsonObject* obj) { if (!obj) return strdup("<null/>"); growing_buffer * res_xml = buffer_init(1024); _recurse_jsonObjectToXML( obj, res_xml ); return buffer_release(res_xml); }
int main(void) { buffer_t buf; buffer_create(&buf, LIBNET_BM_MEMORY); buffer_write_formatted(&buf, "Hallo Welt\r\nEinfach\tmal\tden\tBuffer\ttesten.\n"); buffer_set_mode(&buf, LIBNET_BM_FILE); buffer_release(&buf); printf("\r\n\r\nLast Error: %s (%d)\n", libnet_str_error(libnet_error_get()), libnet_error_get()); return 0; }
int fat32_init( t_16 dev ) { FAT32_BOOTSEC* boot; void* buf; fat32 = &fatdev; root = &rootfile; memset( fat32, 0, sizeof(FAT32DEV) ); buf = buffer_read( dev, 0 ); //读取第一块 1KB boot = (FAT32_BOOTSEC*)buf; if( boot->EBR != 0x28 && boot->EBR !=0x29 ) { //printf("Not fat32 system\n"); buffer_release( buf ); return -1; } printf("fat32 System OEM: %s\n", boot-> OEM ); fat32->fats = boot->Fats;// fat32->secPerClu = boot->SecPerClu;// fat32->secPerFat = boot->SecPerFat; //每fat扇区数 fat32->bytPerSec = boot->BytPerSec; //每扇区字节数 512 fat32->secReserved = boot->SecReserved; //保留扇区数 fat32->rootClu = boot->RootCluster; //根目录簇号 buffer_release( buf ); //caculate some information fat32->fatAddr = fat32->bytPerSec * fat32->secReserved; //fat基址 //printf("fat addr: 0x%X\n", fat32->FatAddr); fat32->dataAddr = fat32->fatAddr + fat32->fats * fat32->secPerFat *fat32->bytPerSec; //数据区基址 fat32->bytPerClu = fat32->bytPerSec * fat32->secPerClu; printf("fat32 RootClu: 0x%X data_addr: 0x%X bytPerClu:%x fatAddr:%x\n", fat32->rootClu, fat32->dataAddr, fat32->bytPerClu, fat32->fatAddr ); //设置根目录 memset( root, 0, sizeof(FILE_DESC) ); root->dev = dev; root->data = fat32->rootClu; //根目录的簇 root->attribute = FILE_ATTR_ISDIR; root->dev_info = fat32; return 0; }
void indent(FILE * input, FILE * output, struct indent_options * opts) { set_options(opts); buffer_init(&primary_buf, BUFFER_INITIAL_CAPACITY); buffer_init(&secondary_buf, BUFFER_INITIAL_CAPACITY); buffer_init(&tag_buf, BUFFER_INITIAL_CAPACITY); current_buf = &primary_buf; yyin = input; indent_output = output; yylex(); /* * There might not have been a newline before EOF. */ buffer_flush(current_buf, indent_output); buffer_release(&primary_buf); buffer_release(&secondary_buf); buffer_release(&tag_buf); }
void gwseriport_release(struct gwseriport *s) { aeDeleteFileEvent(server.el,s->fd,AE_READABLE); aeDeleteFileEvent(server.el,s->fd,AE_WRITABLE); close(s->fd); buffer_release(s->recvbuf); listNode *ln = listSearchKey(server.seriports,s); assert(ln != NULL); listDelNode(server.seriports,ln); free(s); }
static int oilsAuthLoginVerifyPassword(const osrfMethodContext* ctx, int user_id, const char* username, const char* password) { // build the cache key growing_buffer* gb = buffer_init(64); // free me buffer_add(gb, OILS_AUTH_CACHE_PRFX); buffer_add(gb, username); buffer_add(gb, OILS_AUTH_COUNT_SFFX); char* countkey = buffer_release(gb); // free me jsonObject* countobject = osrfCacheGetObject(countkey); // free me long failcount = 0; if (countobject) { failcount = (long) jsonObjectGetNumber(countobject); if (failcount >= _oilsAuthBlockCount) { // User is blocked. Don't waste any more CPU cycles on them. osrfLogInfo(OSRF_LOG_MARK, "oilsAuth found too many recent failures for '%s' : %i, " "forcing failure state.", username, failcount); jsonObjectFree(countobject); free(countkey); return 0; } } int verified = oilsAuthLoginCheckPassword(user_id, password); if (!verified) { // login failed. increment failure counter. failcount++; if (countobject) { // append to existing counter jsonObjectSetNumber(countobject, failcount); } else { // first failure, create a new counter countobject = jsonNewNumberObject((double) failcount); } osrfCachePutObject(countkey, countobject, _oilsAuthBlockTimeout); } jsonObjectFree(countobject); // NULL OK free(countkey); return verified; }
void uv_udp_handle_t::on_write(uv_udp_send_t* req, int status) { write_uv_request_t *uv_request = (write_uv_request_t*)req->data; uv_udp_handle_t *socket_handle = (uv_udp_handle_t*)(req->handle->data); if (uv_request->m_length > 0) { nl_free((void*)uv_request->m_string); } else { buffer_release(uv_request->m_buffer); } if (uv_request->m_session != LUA_REFNIL) { singleton_ref(node_lua_t).context_send(uv_request->m_source, 0, uv_request->m_session, RESPONSE_UDP_WRITE, status == 0 ? UV_OK : singleton_ref(network_t).last_error()); } socket_handle->put_write_cached_request(uv_request); }
static char* _escape_xml (const char* text) { growing_buffer* b = buffer_init(256); int len = strlen(text); int i; for (i = 0; i < len; i++) { if (text[i] == '&') buffer_add(b,"&"); else if (text[i] == '<') buffer_add(b,"<"); else if (text[i] == '>') buffer_add(b,">"); else buffer_add_char(b,text[i]); } return buffer_release(b); }
/** * Returns true if the provided password is correct. * Turn the password into the nested md5 hash required of migrated * passwords, then check the password in the DB. */ static int oilsAuthLoginCheckPassword(int user_id, const char* password) { growing_buffer* gb = buffer_init(33); // free me 1 char* salt = oilsAuthGetSalt(user_id); // free me 2 char* passhash = md5sum(password); // free me 3 buffer_add(gb, salt); // gb strdup's internally buffer_add(gb, passhash); free(salt); // free 2 free(passhash); // free 3 // salt + md5(password) passhash = buffer_release(gb); // free 1 ; free me 4 char* finalpass = md5sum(passhash); // free me 5 free(passhash); // free 4 jsonObject *arr = jsonNewObjectType(JSON_ARRAY); jsonObjectPush(arr, jsonNewObject("actor.verify_passwd")); jsonObjectPush(arr, jsonNewNumberObject((long) user_id)); jsonObjectPush(arr, jsonNewObject("main")); jsonObjectPush(arr, jsonNewObject(finalpass)); jsonObject *params = jsonNewObjectType(JSON_HASH); // free me 6 jsonObjectSetKey(params, "from", arr); free(finalpass); // free 5 jsonObject* verify_obj = // free oilsUtilsCStoreReq("open-ils.cstore.json_query", params); jsonObjectFree(params); // free 6 if (!verify_obj) return 0; // error int verified = oilsUtilsIsDBTrue( jsonObjectGetString( jsonObjectGetKeyConst(verify_obj, "actor.verify_passwd") ) ); jsonObjectFree(verify_obj); return verified; }
void editor_free(Editor *ed) { if (!ed) return; while (ed->windows) editor_window_close(ed->windows); file_free(ed, ed->prompt->file); window_free(ed->prompt); text_regex_free(ed->search_pattern); for (int i = 0; i < REG_LAST; i++) register_release(&ed->registers[i]); for (int i = 0; i < MACRO_LAST; i++) macro_release(&ed->macros[i]); editor_syntax_unload(ed); ed->ui->free(ed->ui); map_free(ed->cmds); map_free(ed->options); buffer_release(&ed->buffer_repeat); free(ed); }
static char *parse_text(const char **s) { skip_spaces(s); if (**s != '\n') return parse_delimited_text(s); Buffer buf; buffer_init(&buf); const char *start = *s + 1; bool dot = false; for ((*s)++; **s && (!dot || **s != '\n'); (*s)++) dot = (**s == '.'); if (!dot || !buffer_put(&buf, start, *s - start - 1) || !buffer_append(&buf, "\0", 1)) { buffer_release(&buf); return NULL; } return buf.data; }