int test_write_header() { struct setec_astronomy_header w_header, r_header; char temp_file[] = TEST_DATA_DIR "temp"; init_header(&w_header); init_header(&r_header); create_header(&w_header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); test_equals(write_header(&w_header, temp_file), SA_SUCCESS); test_equals(read_header(&r_header, temp_file), SA_SUCCESS); test_equals(w_header.salt_len, r_header.salt_len); test_equals(w_header.hash_count, r_header.hash_count); test_equals(w_header.hash_len, w_header.hash_len); test_equals(w_header.iv_len, r_header.iv_len); test_equals(strncmp(w_header.salt, r_header.salt, w_header.salt_len), 0); test_equals(strncmp(w_header.hash, r_header.hash, w_header.hash_len), 0); test_equals(strncmp(w_header.iv, r_header.iv, w_header.iv_len), 0); test_equals(strncmp(w_header.hash, r_header.hash, w_header.hash_len), 0); free_header(&w_header); free_header(&r_header); return 0; }
int on_header_field(http_parser *parser, const char *at, size_t len) { http_state *st = parser->data; if (st->last_header_cb_was_value) { if (st->header_cb != NULL) { st->header_cb(st); } st->last_header->next = init_header(); st->last_header = st->last_header->next; st->num_headers++; if (st->num_headers > MAX_HEADERS) { disconnectAndClean(st->mc); } st->last_header->field_len = len; st->last_header->field = malloc(len + 1); memcpy(st->last_header->field, at, len); st->last_header->field[len] = '\0'; } else { if (st->headers == NULL) { st->headers = init_header(); st->last_header = st->headers; } int old_len = st->last_header->field_len; st->last_header->field_len += len; st->last_header->field = realloc(st->last_header->field, st->last_header->field_len + 1); memcpy(st->last_header->field + old_len, at, len); st->last_header->field[st->last_header->field_len] = '\0'; } st->last_header_cb_was_value = 0; return 0; }
static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node) { if (other_node == this_node) return; bool this_inited = inited(this_node); bool other_inited = inited(other_node); if(this_inited){ init_header(this_node); } if(other_inited){ init_header(other_node); } node_ptr next_this(NodeTraits::get_next(this_node)); node_ptr prev_this(NodeTraits::get_previous(this_node)); node_ptr next_other(NodeTraits::get_next(other_node)); node_ptr prev_other(NodeTraits::get_previous(other_node)); //these first two swaps must happen before the other two swap_prev(next_this, next_other); swap_next(prev_this, prev_other); swap_next(this_node, other_node); swap_prev(this_node, other_node); if(this_inited){ init(other_node); } if(other_inited){ init(this_node); } }
static void *ft_head(int fd, t_header *header) { int name; int comment; t_token tok; char *str; name = 0; comment = 0; init_header(header); while ((tok = next_token(fd, &str)) != END) if (tok != ENDLINE) { if (name == 0 && tok == COMMAND_NAME) name += ft_name(fd, header); else if (comment == 0 && tok == COMMAND_COMMENT) comment += ft_comm(fd, header); else ft_tok_error(tok, str, NULL, 0); free(str); if (name == 1 && comment == 1) return (header); } ft_tok_error(tok, str, NULL, 0); free(header); return (header); }
int init(int argc, char **argv, bcf_hdr_t *in, bcf_hdr_t *out) { static struct option loptions[] = { {"replace",0,0,'r'}, {"gp-to-gl",0,0,1}, {0,0,0,0} }; char c; while ((c = getopt_long(argc, argv, "?hr",loptions,NULL)) >= 0) { switch (c) { case 1 : mode = GP_TO_GL; break; case 'r': drop_source_tag = 1; break; case 'h': case '?': default: error("%s", usage()); break; } } if ( !mode ) mode = GP_TO_GL; in_hdr = in; out_hdr = out; if ( mode==GP_TO_GL ) init_header(out_hdr,drop_source_tag?"GP":NULL,BCF_HL_FMT,"##FORMAT=<ID=GL,Number=G,Type=Float,Description=\"Genotype Likelihoods\">"); return 0; }
void addindexfile(SWISH *sw, char *line) { IndexFILE *head = sw->indexlist; IndexFILE *indexf = (IndexFILE *) emalloc(sizeof(IndexFILE)); memset( indexf, 0, sizeof(IndexFILE) ); indexf->sw = sw; /* save parent object */ indexf->line = estrdup(line); init_header(&indexf->header); indexf->next = NULL; /* Add default meta names -- these will be replaced if reading from an index file */ add_default_metanames(indexf); /* Add index to end of list */ if ( head == NULL ) /* first entry? */ sw->indexlist = head = indexf; else head->nodep->next = indexf; /* point the previous last one to the new last one */ head->nodep = indexf; /* set the last pointer */ }
static void init_ite(composite_t *c, occ_t t1, occ_t t2, occ_t t3) { init_header(c, mk_ite_tag()); c->child[0] = t1; c->child[1] = t2; c->child[2] = t3; init_hooks(c); }
/* * Initialize the "r_info" array */ static errr init_r_info(void) { int i; errr err; /* Init the header */ init_header(&r_head, z_info->r_max, sizeof(monster_race)); /* Save a pointer to the parsing function */ r_head.parse_info_txt = parse_r_info; /* Save a pointer to the evaluate power function*/ r_head.eval_info_post = eval_r_power; /* Save a pointer to the text file output function*/ if (arg_rebalance) r_head.emit_info_txt_index = emit_r_info_index; err = init_info("monster", &r_head); /* Set the global variables */ r_info = r_head.info_ptr; r_name = r_head.name_ptr; r_text = r_head.text_ptr; tot_mon_power = 0; for (i = 0; i < z_info->r_max; i++) { tot_mon_power += r_info[i].power; } return (err); }
static int write_suspend_image(void) { int error; swp_entry_t prev = { 0 }; init_header(); if ((error = write_data())) goto FreeData; if ((error = write_pagedir())) goto FreePagedir; if ((error = write_header(&prev))) goto FreePagedir; error = mark_swapfiles(prev); Done: return error; FreePagedir: free_pagedir_entries(); FreeData: free_data(); goto Done; }
static int query_get_string_answer(cmd_request_t cmd) { struct booth_site *site; struct boothc_header reply; char *data; int data_len; int rv; struct booth_transport const *tpt; data = NULL; init_header(&cl.msg.header, cmd, 0, cl.options, 0, 0, sizeof(cl.msg)); if (!*cl.site) site = local; else if (!find_site_by_name(cl.site, &site, 1)) { log_error("cannot find site \"%s\"", cl.site); rv = ENOENT; goto out; } tpt = booth_transport + TCP; rv = tpt->open(site); if (rv < 0) goto out_free; rv = tpt->send(site, &cl.msg, sizeof(cl.msg)); if (rv < 0) goto out_free; rv = tpt->recv(site, &reply, sizeof(reply)); if (rv < 0) goto out_free; data_len = ntohl(reply.length) - sizeof(reply); /* no tickets? */ if (!data_len) { rv = 0; goto out_close; } data = malloc(data_len); if (!data) { rv = -ENOMEM; goto out_free; } rv = tpt->recv(site, data, data_len); if (rv < 0) goto out_free; do_write(STDOUT_FILENO, data, data_len); rv = 0; out_free: free(data); out_close: tpt->close(site); out: return rv; }
void init_tables(void) { font_table_init(); /* subsidiary fonts in virtual fonts */ init_header(); init_planes(); init_measures(); }
int test_read_header() { struct setec_astronomy_header r_header; unsigned char * hash; /* Start off with a good test */ init_header(&r_header); test_equals(read_header(&r_header, GOOD_HEADER_TEST), SA_SUCCESS); /* Check to make sure that the read and write headers are identical */ test_equals(r_header.salt_len, DEFAULT_SALT_LEN); test_equals(r_header.hash_count, DEFAULT_HASH_COUNT); test_equals(r_header.hash_len, DEFAULT_HASH_LEN); test_equals(r_header.iv_len, DEFAULT_IV_LEN); hash = malloc(r_header.hash_len); PKCS5_PBKDF2_HMAC_SHA1(DEFAULT_PASSWORD, strlen(DEFAULT_PASSWORD), r_header.salt, r_header.salt_len, r_header.hash_count*2, r_header.hash_len, hash); test_equals(memcmp(r_header.hash, hash, r_header.hash_len), 0); free(hash); free_header(&r_header); /* Now try to read a header from a file that doesn't exist */ init_header(&r_header); test_equals(read_header(&r_header, "thisfiledoesntexists"), SA_FILE_NOT_FOUND); free_header(&r_header); /* Test against a file that exists but has no data */ init_header(&r_header); test_equals(read_header(&r_header, NO_DATA_TEST), SA_NO_DATA); free_header(&r_header); /* Test against a file that exists and has some but not enough data */ init_header(&r_header); test_equals(read_header(&r_header, NOT_ENOUGH_DATA_TEST), SA_NO_DATA); free_header(&r_header); return UT_SUCCESS; }
int gfsc_mountgroup_nodes(char *name, int type, int max, int *count, struct gfsc_node *nodes) { struct gfsc_header h, *rh; char *reply; int reply_len; int fd, rv, result, node_count; init_header(&h, GFSC_CMD_MOUNTGROUP_NODES, name, 0); h.option = type; h.data = max; reply_len = sizeof(struct gfsc_header) + (max * sizeof(struct gfsc_node)); reply = malloc(reply_len); if (!reply) { rv = -1; goto out; } memset(reply, 0, reply_len); fd = do_connect(GFSC_QUERY_SOCK_PATH); if (fd < 0) { rv = fd; goto out; } rv = do_write(fd, &h, sizeof(h)); if (rv < 0) goto out_close; /* won't usually get back the full reply_len */ do_read(fd, reply, reply_len); rh = (struct gfsc_header *)reply; result = rh->data; if (result < 0 && result != -E2BIG) { rv = result; goto out_close; } if (result == -E2BIG) { *count = -E2BIG; node_count = max; } else { *count = result; node_count = result; } rv = 0; memcpy(nodes, (char *)reply + sizeof(struct gfsc_header), node_count * sizeof(struct gfsc_node)); out_close: close(fd); out: return rv; }
static void init_packet(struct dhcpMessage *packet, struct dhcpMessage *oldpacket, char type) { init_header(packet, type); packet->xid = oldpacket->xid; memcpy(packet->chaddr, oldpacket->chaddr, 16); packet->flags = oldpacket->flags; packet->giaddr = oldpacket->giaddr; packet->ciaddr = oldpacket->ciaddr; add_simple_option(packet->options, DHCP_SERVER_ID, server_config.server); }
void Libni_Sender::init(uint32_t client_id) { this->client_id = client_id; message = new byte[MAX_BUFFER_SIZE]; for(int i=0; i<MAX_BUFFER_SIZE; i++) { message[i]=0; // init } // init header init_header(); }
static int write_mhli (Itdb_DB *db, iPodBuffer *buffer ) { GList *it = NULL; MhliHeader *mhli; unsigned int total_bytes; int num_thumbs; mhli = (MhliHeader *)init_header (buffer, "mhli", sizeof (MhliHeader)); if (mhli == NULL) { return -1; } num_thumbs = 0; total_bytes = get_gint32 (mhli->header_len, buffer->byte_order); switch (buffer->db_type) { case DB_TYPE_PHOTO: it = db_get_photodb(db)->photos; break; case DB_TYPE_ITUNES: it = db_get_itunesdb(db)->tracks; break; default: g_return_val_if_reached (-1); } while (it != NULL) { Itdb_Track *song; int bytes_written; iPodBuffer *sub_buffer; if (buffer->db_type == DB_TYPE_ITUNES) { song = (Itdb_Track*)it->data; if (!song->artwork->thumbnail || (song->artwork->dbid == 0)) { it = it->next; continue; } } sub_buffer = ipod_buffer_get_sub_buffer (buffer, total_bytes); if (sub_buffer == NULL) { break; } bytes_written = write_mhii (db, it->data, sub_buffer); ipod_buffer_destroy (sub_buffer); if (bytes_written != -1) { num_thumbs++; total_bytes += bytes_written; } it = it->next; } mhli = ipod_buffer_get_pointer (buffer); mhli->num_children = get_gint32 (num_thumbs, buffer->byte_order); dump_mhl ((MhlHeader *)mhli, "mhli"); return total_bytes; }
static void init_distinct(composite_t *c, uint32_t n, occ_t *a) { uint32_t i; assert(n >= 2); // ? 3 is a better limit init_header(c, mk_distinct_tag(n)); for (i=0; i<n; i++) { c->child[i] = a[i]; } init_hooks(c); }
static int write_mhni (Itdb_DB *db, Itdb_Thumb_Ipod_Item *item, iPodBuffer *buffer) { MhniHeader *mhni; unsigned int total_bytes; int bytes_written; iPodBuffer *sub_buffer; const Itdb_ArtworkFormat *format; if (item == NULL) { return -1; } mhni = (MhniHeader *)init_header (buffer, "mhni", sizeof (MhniHeader)); if (mhni == NULL) { return -1; } total_bytes = get_gint32 (mhni->header_len, buffer->byte_order); mhni->total_len = get_gint32 (total_bytes, buffer->byte_order); format = item->format; mhni->format_id = get_gint32 (format->format_id, buffer->byte_order); mhni->image_width = get_gint16 (item->width, buffer->byte_order); mhni->image_height = get_gint16 (item->height, buffer->byte_order); mhni->image_size = get_gint32 (item->size, buffer->byte_order); mhni->ithmb_offset = get_gint32 (item->offset, buffer->byte_order); mhni->vertical_padding = get_gint16 (item->vertical_padding, buffer->byte_order); mhni->horizontal_padding = get_gint16 (item->horizontal_padding, buffer->byte_order); sub_buffer = ipod_buffer_get_sub_buffer (buffer, total_bytes); if (sub_buffer == NULL) { return -1; } bytes_written = write_mhod_type_3 (item->filename, sub_buffer); ipod_buffer_destroy (sub_buffer); if (bytes_written == -1) { return -1; } total_bytes += bytes_written; mhni = ipod_buffer_get_pointer (buffer); mhni->total_len = get_gint32 (total_bytes, buffer->byte_order); /* Only update number of children when all went well to try to get * something somewhat consistent when there are errors */ mhni->num_children = get_gint32 (1, buffer->byte_order); dump_mhni (mhni); return total_bytes; }
static void init_tuple(composite_t *c, uint32_t n, occ_t *a) { uint32_t i; assert(n >= 1); init_header(c, mk_tuple_tag(n)); for (i=0; i<n; i++) { c->child[i] = a[i]; } init_hooks(c); }
static void init_update(composite_t *c, occ_t f, uint32_t n, occ_t *a, occ_t v) { uint32_t i; assert(n >= 1); init_header(c, mk_update_tag(n + 2)); c->child[0] = f; for (i=0; i<n; i++) { c->child[i+1] = a[i]; } c->child[n+1] = v; init_hooks(c); }
static void init_apply(composite_t *c, occ_t f, uint32_t n, occ_t *a) { uint32_t i; assert(n >= 1); init_header(c, mk_apply_tag(n + 1)); c->child[0] = f; for (i=0; i<n; i++) { c->child[i+1] = a[i]; } init_hooks(c); }
static int queue(struct buffer *buffer) { init_header(&buffer->header, buffer->pcm_data, buffer->pcm_nsamples, config_channels, config_speed, config_precision); if (soundcmd(QUEUE, bufferCmd, 0, (long) &buffer->header) == -1 || soundcmd(QUEUE, callBackCmd, 0, (long) buffer) == -1) return -1; return 0; }
static int do_list(void) { struct boothc_header h, *rh; char *reply = NULL, *data; int data_len; int fd, rv; init_header(&h, BOOTHC_CMD_LIST, 0, 0, 0); fd = do_connect(BOOTHC_SOCK_PATH); if (fd < 0) { rv = fd; goto out; } rv = do_write(fd, &h, sizeof(h)); if (rv < 0) goto out_close; reply = malloc(sizeof(struct boothc_header)); if (!reply) { rv = -ENOMEM; goto out_close; } rv = do_read(fd, reply, sizeof(struct boothc_header)); if (rv < 0) goto out_free; rh = (struct boothc_header *)reply; data_len = rh->len; reply = realloc(reply, sizeof(struct boothc_header) + data_len); if (!reply) { rv = -ENOMEM; goto out_free; } data = reply + sizeof(struct boothc_header); rv = do_read(fd, data, data_len); if (rv < 0) goto out_free; do_write(STDOUT_FILENO, data, data_len); rv = 0; out_free: free(reply); out_close: close(fd); out: return rv; }
int gfsc_fs_join(int fd, struct gfsc_mount_args *ma) { char msg[sizeof(struct gfsc_header) + sizeof(struct gfsc_mount_args)]; struct gfsc_header *h = (struct gfsc_header *)msg; char *name = strstr(ma->table, ":") + 1; init_header(h, GFSC_CMD_FS_JOIN, name, sizeof(struct gfsc_mount_args)); memcpy(msg + sizeof(struct gfsc_header), ma, sizeof(struct gfsc_mount_args)); return do_write(fd, msg, sizeof(msg)); }
void VbExporter::translate(t_output &out, t_programa &prog) { // cppcheck-suppress unusedScopedObject TiposExporter(prog,false); // para que se cargue el mapa_memorias con memorias que tengan ya definidos los tipos de variables que correspondan // cabecera init_header(out,"' "); out.push_back(string("Module ")+main_process_name); if (!for_test) out.push_back(""); // procesos y subprocesos translate_all_procs(out,prog,"\t"); out.push_back("End Module"); }
static int do_revoke(void) { char *buf; struct boothc_header *h, reply; int buflen; int fd, rv; buflen = sizeof(struct boothc_header) + sizeof(cl.ticket); buf = malloc(buflen); if (!buf) { rv = -ENOMEM; goto out; } h = (struct boothc_header *)buf; init_header(h, BOOTHC_CMD_REVOKE, 0, 0, 0, sizeof(cl.ticket)); strcpy(buf + sizeof(struct boothc_header), cl.ticket); fd = do_connect(BOOTHC_SOCK_PATH); if (fd < 0) { rv = fd; goto out_free; } rv = do_write(fd, buf, buflen); if (rv < 0) goto out_close; rv = do_read(fd, &reply, sizeof(struct boothc_header)); if (rv < 0) goto out_close; if (reply.result == BOOTHC_RLT_ASYNC) { log_info("revoke command sent, but result is async."); rv = 0; } else if (reply.result == BOOTHC_RLT_SYNC_SUCC) { log_info("revoke succeeded!"); rv = 0; } else if (reply.result == BOOTHC_RLT_SYNC_FAIL) { log_info("revoke failed!"); rv = 0; } else { log_error("internal error!"); rv = -1; } out_close: close(fd); out_free: free(buf); out: return rv; }
composite_t *new_or_composite_var(uint32_t n, occ_t *a) { composite_t *tmp; uint32_t i; assert(n <= MAX_COMPOSITE_ARITY); tmp = (composite_t *) safe_malloc(sizeof(composite_t) + n * sizeof(int32_t)); init_header(tmp, mk_or_tag(n)); for (i=0; i<n; i++) { tmp->child[i] = a[i]; } return tmp; }
void MatLabExporter::translate(t_output &out, t_programa &prog) { // cppcheck-suppress unusedScopedObject TiposExporter(prog,false); // para que se cargue el mapa_memorias con memorias que tengan ya definidos los tipos de variables que correspondan // procesos y subprocesos t_output out_aux; translate_all_procs(out_aux,prog); // cabecera init_header(out,"% "); if (!for_test) insertar(out,""); if (use_string_matrix && !for_test) { insertar(out,"% El algoritmo generado declara uno o más vectores/matrices cuyos elementos son"); insertar(out,"% cadenas de caracteres En MatLab, estos no son arreglos comunes, sino arreglos de"); insertar(out,"% celdas (se crean con la función cell en lugar de zeros como losdemás), y por"); insertar(out,"% ello deben ser accedidos utilizando llaves {} en lugar de paréntisis () para"); insertar(out,"% sus índices. Es posible que el código generado utilice paréntesis donde deberían"); insertar(out,"% ir llaves, por lo que deberá realizar estas correcciones manualmente."); insertar(out,""); } if (use_comparar_cadenas) { if (!for_test) { insertar(out,"% No hay en matlab una función para comparar cadenas completas por mayor/menor,"); insertar(out,"% solo por igualdad/desigualdad. Por eso se crea esta función auxiliar que lo hace"); insertar(out,"% realizando comparaciones letra y por letra y de sus longitudes. Su comportamiento"); insertar(out,"% es similar al strcmp de C, al comparar el resultado con 0 se obtiene el mismo"); insertar(out,"% resultado que si compararamos las dos cadenas."); insertar(out,"% Ej: para hacer a<=b usamos comparar_cadenas(a,b)<=0"); } insertar(out,"function r=comparar_cadenas(a,b)"); insertar(out,"\tn1=length(a);"); insertar(out,"\tn2=length(b);"); insertar(out,"\tn=min(n1,n2);"); insertar(out,"\ti=0;"); insertar(out,"\twhile i<n"); insertar(out,"\t\tif (a(i)!=b(i))"); insertar(out,"\t\t\tr=a(i)-b(i);"); insertar(out,"\t\t\tbreak;"); insertar(out,"\t\tend"); insertar(out,"\t\ti=i+1;"); insertar(out,"\tend"); insertar(out,"\tif i==n"); insertar(out,"\t\tr=n1-n2;"); insertar(out,"\tend"); insertar(out,"end"); if (!for_test) insertar(out,""); } insertar_out(out,out_aux); }
void FC_FUNC_(write_binary,WRITE_BINARY) (const int * np, void * f, int * type, int * ierr, STR_F_TYPE fname STR_ARG1) { header_t * h; char * filename; int fd; ssize_t moved; h = (header_t *) malloc(sizeof(header_t)); assert(h != NULL); *ierr = 0; TO_C_STR1(fname, filename); fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH ); if( fd < 0 ) { inf_error("octopus.write_binary", ierr); *ierr = 2; return; } free(filename); /* create header */ init_header(h); h->np = *np; h->type = *type; /* write header */ moved = write(fd, h, sizeof(header_t)); if(moved < sizeof(header_t)){ inf_error("octopus.write_binary", ierr); close(fd); return; } /* now write the values */ moved = write(fd, f, (*np)*size_of[(*type)]); if(moved < (*np)*size_of[(*type)]){ inf_error("octopus.write_binary", ierr); } /* close the file */ close(fd); free(h); }
void VariableScope::setup_as_block(VariableScope* top, VariableScope* parent, CompiledMethod* cm, int num, Object* self) { init_header(UnspecifiedZone, InvalidType); parent_ = parent; self_ = self; method_ = cm; module_ = top->module(); block_ = top->block(); number_of_locals_ = num; for(int i = 0; i < num; i++) { locals_[i] = Qnil; } }