int hashtable_insert(hashtable_t *h, int32_t key, void *p) { size_t hashv = calc_hash(h, key); hash_item_t *item = h->T + hashv; if (!item->p) { item->key = key; item->p = p; return 0; } else { hash_item_t *new_item = calloc(1, sizeof(hash_item_t)); if (!new_item) { fprintf(stderr, "out of memory in hashtable_insert()\n"); return -1; } new_item->key = key; new_item->p = p; new_item->next = item->next; item->next = new_item; return 0; } }
/** Add or change an incidence on the calendar. This function * is used for events and to-dos */ bool KCalSharedResource::commit(OSyncDataSource *dsobj, OSyncContext *ctx, OSyncChange *chg) { OSyncChangeType type = osync_change_get_changetype(chg); switch (type) { case OSYNC_CHANGE_TYPE_DELETED: { KCal::Incidence *e = calendar->incidence(QString::fromUtf8(osync_change_get_uid(chg))); if (!e) { osync_context_report_error(ctx, OSYNC_ERROR_FILE_NOT_FOUND, "Event not found while deleting"); return false; } calendar->deleteIncidence(e); break; } case OSYNC_CHANGE_TYPE_ADDED: case OSYNC_CHANGE_TYPE_MODIFIED: { KCal::ICalFormat format; OSyncData *odata = osync_change_get_data(chg); char *databuf; //size_t databuf_size; // osync_data_get_data requires an unsigned int which is not compatible with size_t on 64bit machines unsigned int databuf_size = 0; osync_data_get_data(odata, &databuf, &databuf_size); /* First, parse to a temporary calendar, because * we should set the uid on the events */ KCal::CalendarLocal cal(QString::fromLatin1( "UTC" )); QString data = QString::fromUtf8(databuf, databuf_size); if (!format.fromString(&cal, data)) { osync_context_report_error(ctx, OSYNC_ERROR_CONVERT, "Couldn't import calendar data"); return false; } KCal::Incidence *oldevt = calendar->incidence(QString::fromUtf8(osync_change_get_uid(chg))); if (oldevt) { calendar->deleteIncidence(oldevt); } /* Add the events from the temporary calendar, setting the UID * * We iterate over the list, but it should have only one event. */ KCal::Incidence::List evts = cal.incidences(); for (KCal::Incidence::List::ConstIterator i = evts.begin(); i != evts.end(); i++) { KCal::Incidence *e = (*i)->clone(); if (type == OSYNC_CHANGE_TYPE_MODIFIED) e->setUid(QString::fromUtf8(osync_change_get_uid(chg))); // if we run with a configured category filter, but the received added incidence does // not contain that category, add the filter-categories so that the incidence will be // found again on the next sync if ( ! dsobj->has_category(e->categories()) ) { QStringList cats = e->categories(); for (QStringList::const_iterator it = dsobj->categories.constBegin(); it != dsobj->categories.constEnd(); ++it ) cats.append(*it); e->setCategories(cats); } osync_change_set_uid(chg, e->uid().utf8()); QString hash = calc_hash(*i); osync_change_set_hash(chg, hash.utf8()); calendar->addIncidence(e); } break; } default: { osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "Invalid or unsupported change type"); return false; } } return true; }
static ssize_t felica_cen_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { int ret; char kbuf; u8 *src; u8 hash[AUTH_HASH_LEN]; struct miscdevice *c = file->private_data; struct felica_dev *d = container_of(c, struct felica_dev, device_cen); dev_dbg(d->device_cen.this_device, "%s\n", __func__); if ((AUTHENTICATION_LEN+1) != count || buf == NULL) { dev_err(d->device_cen.this_device, "%s: Error. Invalid arg @CEN write.\n", __func__); ret = -EINVAL; goto exit; } /* Carry out user authentication */ src = kmalloc(AUTHENTICATION_LEN, GFP_KERNEL); if (!src) { dev_err(d->device_cen.this_device, "%s: Error. No enough mem for Auth.\n", __func__); ret = -ENOMEM; goto exit; } ret = copy_from_user(src, buf, AUTHENTICATION_LEN); if (ret) { dev_err(d->device_cen.this_device, "%s: Error. copy_from_user failure.\n", __func__); ret = -EFAULT; goto end_process; } if (calc_hash(src, AUTHENTICATION_LEN, hash, d->device_cen.this_device)) { dev_err(d->device_cen.this_device, "%s: Error. calc hash digest failure.\n", __func__); ret = -EACCES; goto end_process; } if (memcmp(auth_hash, hash, AUTH_HASH_LEN)) { dev_err(d->device_cen.this_device, "%s: Error. invalid authentication.\n", __func__); ret = -EACCES; goto end_process; } /* Copy value from user space */ ret = copy_from_user(&kbuf, &buf[AUTHENTICATION_LEN], sizeof(kbuf)); if (ret) { dev_err(d->device_cen.this_device, "%s: Error. copy_from_user failure.\n", __func__); ret = -EFAULT; goto end_process; } ret = d->flcen->cen_write(kbuf, d); if (ret) { dev_err(d->device_cen.this_device, "%s: Error. Cannot write PM-nfc.\n", __func__); goto end_process; } /* usec delay*/ udelay(UDELAY_CEN_WRITE); /* 1 byte write */ ret = 1; end_process: kfree(src); exit: return ret; }
static void test_calc_hash(void) { ok(calc_hash(H2O_STRLIT("https://example.com/style.css"), H2O_STRLIT("")) == 0xbaf9e86f03330860); ok(calc_hash(H2O_STRLIT("https://example.com/style.css"), H2O_STRLIT("\"deadbeef\"")) == 0xa53eb398509042d7); }
/** Initialise the state for NTLMSSP signing. */ NTSTATUS ntlmssp_sign_init(NTLMSSP_STATE *ntlmssp_state) { unsigned char p24[24]; ZERO_STRUCT(p24); DEBUG(3, ("NTLMSSP Sign/Seal - Initialising with flags:\n")); debug_ntlmssp_flags(ntlmssp_state->neg_flags); if (!ntlmssp_state->session_key.length) { DEBUG(3, ("NO session key, cannot intialise signing\n")); return NT_STATUS_NO_USER_SESSION_KEY; } if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) { const char *send_sign_const; const char *send_seal_const; const char *recv_sign_const; const char *recv_seal_const; switch (ntlmssp_state->role) { case NTLMSSP_CLIENT: send_sign_const = CLI_SIGN; send_seal_const = CLI_SEAL; recv_sign_const = SRV_SIGN; recv_seal_const = SRV_SEAL; break; case NTLMSSP_SERVER: send_sign_const = SRV_SIGN; send_seal_const = SRV_SEAL; recv_sign_const = CLI_SIGN; recv_seal_const = CLI_SEAL; break; } calc_ntlmv2_hash(ntlmssp_state->send_sign_hash, ntlmssp_state->send_sign_const, ntlmssp_state->session_key, send_sign_const); dump_data_pw("NTLMSSP send sign hash:\n", ntlmssp_state->send_sign_hash, sizeof(ntlmssp_state->send_sign_hash)); calc_ntlmv2_hash(ntlmssp_state->send_seal_hash, ntlmssp_state->send_seal_const, ntlmssp_state->session_key, send_seal_const); dump_data_pw("NTLMSSP send sesl hash:\n", ntlmssp_state->send_seal_hash, sizeof(ntlmssp_state->send_seal_hash)); calc_ntlmv2_hash(ntlmssp_state->recv_sign_hash, ntlmssp_state->recv_sign_const, ntlmssp_state->session_key, recv_sign_const); dump_data_pw("NTLMSSP receive sign hash:\n", ntlmssp_state->recv_sign_hash, sizeof(ntlmssp_state->recv_sign_hash)); calc_ntlmv2_hash(ntlmssp_state->recv_seal_hash, ntlmssp_state->recv_seal_const, ntlmssp_state->session_key, recv_seal_const); dump_data_pw("NTLMSSP receive seal hash:\n", ntlmssp_state->recv_sign_hash, sizeof(ntlmssp_state->recv_sign_hash)); } else if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY) { if (!ntlmssp_state->session_key.data || ntlmssp_state->session_key.length < 8) { /* can't sign or check signatures yet */ DEBUG(5, ("NTLMSSP Sign/Seal - cannot use LM KEY yet\n")); return NT_STATUS_UNSUCCESSFUL; } DEBUG(5, ("NTLMSSP Sign/Seal - using LM KEY\n")); calc_hash(ntlmssp_state->ntlmssp_hash, (const char *)(ntlmssp_state->session_key.data), 8); dump_data_pw("NTLMSSP hash:\n", ntlmssp_state->ntlmssp_hash, sizeof(ntlmssp_state->ntlmssp_hash)); } else { if (!ntlmssp_state->session_key.data || ntlmssp_state->session_key.length < 16) { /* can't sign or check signatures yet */ DEBUG(5, ("NTLMSSP Sign/Seal - cannot use NT KEY yet\n")); return NT_STATUS_UNSUCCESSFUL; } DEBUG(5, ("NTLMSSP Sign/Seal - using NT KEY\n")); calc_hash(ntlmssp_state->ntlmssp_hash, (const char *)(ntlmssp_state->session_key.data), 16); dump_data_pw("NTLMSSP hash:\n", ntlmssp_state->ntlmssp_hash, sizeof(ntlmssp_state->ntlmssp_hash)); } ntlmssp_state->ntlmssp_seq_num = 0; return NT_STATUS_OK; }
bool write() { hash = calc_hash(data); return system_rtc_mem_write(USER_DATA_ADDR, this, sizeof(*this)); }
int main(int argc, char* argv[]) { int i; int fd, len; char* elf; int entry, phoff, phnum; int* ph; #if 0 if (argc < 2) error("Usage: el <elf>"); LOG("loading %s\n", argv[1]); #endif fd = open("simple_hash", O_RDONLY); if (fd < 0) error("Usage: el <elf>"); len = lseek(fd, 0, SEEK_END); elf = (char*)malloc(len); lseek(fd, 0, SEEK_SET); read(fd, elf, len); if (*(int*)elf != 0x464c457f) error("not elf"); if (*(int*)(elf+16) != 0x30002) error("not i386 exec"); entry = *(int*)(elf+24); phoff = *(int*)(elf+28); phnum = *(int*)(elf+42); LOG("%x %x %x\n", entry, phoff, phnum); ph = (int*)(elf + phoff); for (i = 0; i < phnum >> 16; i++) { int poff, paddr, pfsize, psize, pafsize, pflag /*, palign */; poff = ph[1]; paddr = ph[2]; pfsize = ph[4]; psize = ph[5]; pflag = ph[6]; /*palign = ph[7];*/ switch (ph[0]) { case 1: { int prot = 0; if (pflag & 1) prot |= PROT_EXEC; if (pflag & 2) prot |= PROT_WRITE; if (pflag & 4) prot |= PROT_READ; if (prot & PROT_EXEC) { prot |= PROT_WRITE; } psize += paddr & 0xfff; pfsize += paddr & 0xfff; poff -= paddr & 0xfff; paddr &= ~0xfff; pafsize = (pfsize + 0xfff) & ~0xfff; psize = (psize + 0xfff) & ~0xfff; LOG("PT_LOAD size=%d fsize=%d flag=%d addr=%x prot=%d poff=%d\n", psize, pafsize, pflag, paddr, prot, poff); if (mmap((void*)paddr, pafsize, prot, MAP_FILE|MAP_PRIVATE|MAP_FIXED, fd, poff) == MAP_FAILED) { error("mmap(file)"); } if ((prot & PROT_WRITE)) { LOG("%p\n", (char*)paddr); for (; pfsize < pafsize; pfsize++) { char* p = (char*)paddr; p[pfsize] = 0; } if (pfsize != psize) { if (mmap((void*)(paddr + pfsize), psize - pfsize, prot, MAP_ANON|MAP_PRIVATE, -1, 0) == MAP_FAILED) { error("mmap(anon)"); } } } break; } case 2: { char* dyn; char* dstr = NULL; char* dsym = NULL; char* rel = NULL; char* pltrel = NULL; int relsz, relent, pltrelsz = 0; int needed[999] = {}, *neededp = needed; puts("PT_DYNAMIC"); dyn = elf + poff; for (;;) { short dtag = *(short*)dyn; int dval = *(int*)(dyn + 4); dyn += 8; if (dtag == 0) break; switch (dtag) { case 1: { /* DT_NEEDED */ *neededp++ = dval; } case 2: { pltrelsz = dval; LOG("pltrelsz: %d\n", pltrelsz); break; } case 5: { dstr = (char*)dval; LOG("dstr: %p %s\n", dstr, dstr+1); break; } case 6: { dsym = (char*)dval; LOG("dsym: %p\n", dsym); break; } case 17: { rel = (char*)dval; LOG("rel: %p\n", rel); break; } case 18: { relsz = dval; LOG("relsz: %d\n", relsz); break; } case 19: { relent = dval; LOG("relent: %d\n", relent); break; } case 20: { pltrel = (char*)dval; LOG("pltrel: %p\n", pltrel); break; } default: LOG("unknown DYN %d %d\n", dtag, dval); } } if (!dsym || !dstr) { error("no dsym or dstr"); } for (neededp = needed; *neededp; neededp++) { LOG("needed: %s\n", dstr + *neededp); dlopen(dstr + *neededp, RTLD_NOW | RTLD_GLOBAL); } { int i, j; for (j = 0; j < 2; j++) { for (i = 0; i < relsz; rel += relent, i += relent) { int* addr = *(int**)rel; int info = *(int*)(rel + 4); int sym = info >> 8; int type = info & 0xff; int* ds = (int*)(dsym + 16 * sym); char* sname = dstr + *ds; void* val=0; int k; #if 0 for(k=0;T[k].n;k++){ if(!strcmp(sname,T[k].n)){ val = T[k].f; break; } } #endif if(!val){ if (!strcmp(sname,"stdout")) val = &stdout; else if (!strcmp(sname,"_Stdout")) val = stdout; else if (!strcmp(sname,"stderr")) val = &stderr; else if (!strcmp(sname,"_Stderr")) val = stderr; /* else if (!strcmp(sname, "__environ")) val = &environ; */ else val = dlsym(RTLD_DEFAULT, sname); } LOG("%srel: %p %s(%d) %d => %p\n", j ? "plt" : "", (void*)addr, sname, sym, type, val); if (!val) { val = (void*)&undefined; } switch (type) { case 1: { *addr += (int)val; } case 5: { if (val) { *addr = *(int*)val; } else { fprintf(stderr, "undefined: %s\n", sname); //abort(); } } case 6: { if (val) { *addr = (int)val; } else { fprintf(stderr, "undefined data %s\n", sname); } break; } case 7: { if (val) { *addr = (int)val; } else { *addr = (int)&undefined; } break; } } } if ((int)pltrel != 17) { rel = pltrel; } relsz = pltrelsz; } } break; } default: fprintf(stderr, "unknown PT %d\n", ph[0]); } ph += 8; } //g_argc = argc-1; //g_argv = argv+1; fprintf(stderr, "start!: %s %x\n", argv[1], entry); #define TEST(a, b) printf("%lld*%lld=%lld (%lld)\n", a, b, mm(a, b), a * b % 0x38d7ea4c68025LL) TEST(1LL, 2LL); TEST(0xdeaddeadULL, 0xdeaddeadULL); *(char**)(0x8048963+1) = (char*)mm_wrap - (0x8048963 + 5); char* str = (char*)0x80491a0; str[0] = 'X'; str[1] = 'X'; str[2] = 0; long long (*calc_hash)() = (long long (*)())0x08048927; printf("%lld\n", calc_hash()); //run((void*)entry); return 0; }
#endif return sym_id; } //================================================================ /*! constructor @param vm pointer to VM. @param str String @return symbol object */ mrbc_value mrbc_symbol_new(struct VM *vm, const char *str) { mrbc_value ret = {.tt = MRBC_TT_SYMBOL}; uint16_t h = calc_hash(str); mrbc_sym sym_id = search_index(h, str); if( sym_id >= 0 ) { ret.i = sym_id; return ret; // already exist. } // create symbol object dynamically. int size = strlen(str) + 1; char *buf = mrbc_raw_alloc(size); if( buf == NULL ) return ret; // ENOMEM raise? memcpy(buf, str, size); ret.i = add_index( h, buf );
adlb_code xlb_xpt_index_lookup(const void *key, size_t key_len, xpt_index_entry *res) { assert(xpt_index_init); assert(key != NULL); adlb_datum_id id = id_for_hash(calc_hash(key, key_len)); adlb_subscript subscript = { .key = key, .length = key_len }; adlb_retrieve_refc refcounts = ADLB_RETRIEVE_NO_REFC; void *buffer = xlb_xfer; adlb_data_type type; size_t length; adlb_code rc = ADLB_Retrieve(id, subscript, refcounts, &type, buffer, &length); ADLB_CHECK_MSG(rc == ADLB_SUCCESS, "Error looking up checkpoint in " "container %"PRId64, id); if (rc == ADLB_NOTHING) { // Not present return ADLB_NOTHING; } ADLB_CHECK_MSG(length >= 1, "Checkpoint index val too small: %zu", length); // Type flag goes at end of buffer char in_file_flag = ((char*)buffer)[length - 1]; if (in_file_flag != 0) { res->in_file = true; xpt_file_loc *res_file = &res->FILE_LOC; // Write info to binary buffer char *pos = (char*)buffer; size_t filename_len; ADLB_CHECK_MSG(length >= sizeof(filename_len), "Buffer not large enough " "for filename len: %zu v %zu", length, sizeof(filename_len)); MSG_UNPACK_BIN(pos, &filename_len); // Check buffer was expected size (members plus in_file byte) size_t exp_length = sizeof(filename_len) + filename_len + sizeof(res_file->val_offset) + sizeof(res_file->val_len) + 1; ADLB_CHECK_MSG(length == exp_length, "Buffer not expected size: %zu vs %zu", length, exp_length); // Extract filename if needed if (filename_len == 0) { res_file->file = NULL; } else { res_file->file = malloc(filename_len + 1); ADLB_CHECK_MSG(res_file->file != NULL, "Error allocating filename"); memcpy(res_file->file, pos, filename_len); res_file->file[filename_len] = '\0'; pos += filename_len; } MSG_UNPACK_BIN(pos, &res_file->val_offset); MSG_UNPACK_BIN(pos, &res_file->val_len); pos++; // in_file byte assert(pos - (char*)buffer == exp_length); } else { res->in_file = false; adlb_binary_data *d = &res->DATA; d->length = length - 1; // Account for flag d->data = buffer; // Determine whether caller owns buffer d->caller_data = NULL; } return ADLB_SUCCESS; }
hash_string::hash_string(const std::string& _s) : m_string(_s) { calc_hash(); }
Song::Song(mpd_song *s) { assert(s); m_song = std::shared_ptr<mpd_song>(s, mpd_song_free); m_hash = calc_hash(mpd_song_get_uri(s)); }
hash_string::hash_string(const char* _c, size_t _n) : m_string(_c, _n) { calc_hash(); }
hash_string::hash_string(const char* _c): m_string(_c) { calc_hash(); }
int main(int argc, char *argv[]) { pev_config_t config; PEV_INITIALIZE(&config); if (argc < 2) { usage(); return EXIT_FAILURE; } output_set_cmdline(argc, argv); OpenSSL_add_all_digests(); options_t *options = parse_options(argc, argv); pe_ctx_t ctx; pe_err_e err = pe_load_file(&ctx, argv[argc-1]); if (err != LIBPE_E_OK) { pe_error_print(stderr, err); return EXIT_FAILURE; } err = pe_parse(&ctx); if (err != LIBPE_E_OK) { pe_error_print(stderr, err); return EXIT_FAILURE; } if (!pe_is_pe(&ctx)) EXIT_ERROR("not a valid PE file"); const IMAGE_SECTION_HEADER *section_ptr = NULL; const unsigned char *data = NULL; uint64_t data_size = 0; unsigned c = pe_sections_count(&ctx); IMAGE_SECTION_HEADER ** const sections = pe_sections(&ctx); char hash_value[EVP_MAX_MD_SIZE * 2 + 1]; data = ctx.map_addr; data_size = pe_filesize(&ctx); output_open_document(); if (options->all) { output_open_scope("file", OUTPUT_SCOPE_TYPE_OBJECT); output("filepath", ctx.path); print_basic_hash(data, data_size); output_close_scope(); // file } output_open_scope("headers", OUTPUT_SCOPE_TYPE_ARRAY); if (options->all || options->headers.all || options->headers.dos) { const IMAGE_DOS_HEADER *dos_hdr = pe_dos(&ctx); data = (const unsigned char *)dos_hdr; data_size = sizeof(IMAGE_DOS_HEADER); output_open_scope("header", OUTPUT_SCOPE_TYPE_OBJECT); output("header_name", "IMAGE_DOS_HEADER"); PRINT_HASH_OR_HASHES; output_close_scope(); // header } if (options->all || options->headers.all || options->headers.coff) { const IMAGE_COFF_HEADER *coff_hdr = pe_coff(&ctx); data = (const unsigned char *)coff_hdr; data_size = sizeof(IMAGE_COFF_HEADER); output_open_scope("header", OUTPUT_SCOPE_TYPE_OBJECT); output("header_name", "IMAGE_COFF_HEADER"); PRINT_HASH_OR_HASHES; output_close_scope(); // header } if (options->all || options->headers.all || options->headers.optional) { const IMAGE_OPTIONAL_HEADER *opt_hdr = pe_optional(&ctx); switch (opt_hdr->type) { case MAGIC_ROM: // Oh boy! We do not support ROM. Abort! fprintf(stderr, "ROM image is not supported\n"); break; case MAGIC_PE32: if (!pe_can_read(&ctx, opt_hdr->_32, sizeof(IMAGE_OPTIONAL_HEADER_32))) { // TODO: Should we report something? break; } data = (const unsigned char *)opt_hdr->_32; data_size = sizeof(IMAGE_OPTIONAL_HEADER_32); break; case MAGIC_PE64: if (!pe_can_read(&ctx, opt_hdr->_64, sizeof(IMAGE_OPTIONAL_HEADER_64))) { // TODO: Should we report something? break; } data = (const unsigned char *)opt_hdr->_64; data_size = sizeof(IMAGE_OPTIONAL_HEADER_64); break; } output_open_scope("header", OUTPUT_SCOPE_TYPE_OBJECT); output("header_name", "IMAGE_OPTIONAL_HEADER"); PRINT_HASH_OR_HASHES; output_close_scope(); // header } output_close_scope(); // headers if (options->all) { output_open_scope("sections", OUTPUT_SCOPE_TYPE_ARRAY); for (unsigned int i=0; i<c; i++) { data_size = sections[i]->SizeOfRawData; data = LIBPE_PTR_ADD(ctx.map_addr, sections[i]->PointerToRawData); output_open_scope("section", OUTPUT_SCOPE_TYPE_OBJECT); output("section_name", (char *)sections[i]->Name); if (data_size) { PRINT_HASH_OR_HASHES; } output_close_scope(); // section } output_close_scope(); // sections } else if (options->sections.name != NULL) { const IMAGE_SECTION_HEADER *section = pe_section_by_name(&ctx, options->sections.name); if (section == NULL) { EXIT_ERROR("The requested section could not be found on this binary"); } section_ptr = section; } else if (options->sections.index > 0) { const uint16_t num_sections = pe_sections_count(&ctx); if (num_sections == 0 || options->sections.index > num_sections) { EXIT_ERROR("The requested section could not be found on this binary"); } IMAGE_SECTION_HEADER ** const sections = pe_sections(&ctx); const IMAGE_SECTION_HEADER *section = sections[options->sections.index - 1]; section_ptr = section; } if (section_ptr != NULL) { if (section_ptr->SizeOfRawData > 0) { const uint8_t *section_data_ptr = LIBPE_PTR_ADD(ctx.map_addr, section_ptr->PointerToRawData); // printf("map_addr = %p\n", ctx.map_addr); // printf("section_data_ptr = %p\n", section_data_ptr); // printf("SizeOfRawData = %u\n", section_ptr->SizeOfRawData); if (!pe_can_read(&ctx, section_data_ptr, section_ptr->SizeOfRawData)) { EXIT_ERROR("The requested section has an invalid size"); } data = (const unsigned char *)section_data_ptr; data_size = section_ptr->SizeOfRawData; } else { data = (const unsigned char *)""; data_size = 0; } } if (!options->all && data != NULL) { char hash_value[EVP_MAX_MD_SIZE * 2 + 1]; if (options->algorithms.all && options->all) { print_basic_hash(data, data_size); } else if (options->algorithms.alg_name != NULL) { calc_hash(options->algorithms.alg_name, data, data_size, hash_value); output(options->algorithms.alg_name, hash_value); } else { print_basic_hash(data, data_size); } } output_close_document(); // free free_options(options); err = pe_unload(&ctx); if (err != LIBPE_E_OK) { pe_error_print(stderr, err); return EXIT_FAILURE; } EVP_cleanup(); // Clean OpenSSL_add_all_digests. PEV_FINALIZE(&config); return EXIT_SUCCESS; }
DescInfo * desc_info_load (const char *filename) { FILE *f; DescInfo *info = NULL; DescInfo *first = NULL; char line[512]; char *ID = NULL; unsigned int hash = 0; unsigned int description_len = 0; char description[1024 * 2]; /* Open file. */ f = fopen (filename, "r"); if (f == NULL) return NULL; /* Read file and process each desription entry. */ while (!feof (f)) { fgets (line, sizeof (line), f); if (ID == NULL) { /* This should be the start of a new entry. */ char *end; if (line[0] == '#' || (end = strchr (line, '#')) == NULL) /* Hm... doesn't look like one after all. */ continue; /* Get the entry's ID. */ end[0] = 0; ID = strdup (line); hash = calc_hash (ID); description_len = 0; } else if (line[0] == '#') { /* This should be the end of an entry. */ if (ID == NULL) /* Or maybe not. */ continue; /* * Add entry to list. */ if (info == NULL) { /* This is the first entry. Allocate the first node. */ info = malloc (sizeof (DescInfo)); info->next = NULL; first = info; } else { /* Allocate new node and append it to linked list. */ DescInfo *old; old = info; info = malloc (sizeof (DescInfo)); info->next = NULL; old->next = info; } info->ID = ID; info->hash = hash; ID = NULL; postprocess (description, &description_len); info->description = malloc (description_len + 1); memcpy (info->description, description, description_len); info->description[description_len] = '\0'; } else { /* This should be a line containing the description. * Append line to description. */ size_t len; len = strlen (line); if (description_len + len > sizeof (description)) /* What? The total description is bigger than 2K? Ignore it. */ continue; memcpy (description + description_len, line, len); description_len += len; } } fclose (f); return first; }
void * thread_fun(void * param) { ShareData * p = (ShareData *)param; CURL *curl = curl_easy_init(); if (curl == NULL) { return NULL; } CURLcode res, res_get_code= 0; char *buf_ptr = NULL; long buf_len = p->data_len_max; buf_ptr = malloc(buf_len); if (buf_ptr == NULL) { return NULL; } if (p->fill_char) { memset(buf_ptr, p->fill_char, buf_len); } for (long i=p->data_begin; i<= p->data_end; ++i) { long real_len = buf_len; if (p->data_len_random) { long diff = p->data_len_max - p->data_len_min; real_len = p->data_len_min + rand()%diff; } char fname[64] = {0}; sprintf(fname, "%ld", i); if (p->md5_crc32) { size_t name_len = sizeof(fname); if (calc_hash(fname, &name_len, fname, strlen(fname)) < 0) { fprintf(stderr, "calc_hash error- %ld\n", i); goto err; } } struct curl_httppost *formpost = NULL; struct curl_httppost *lastptr = NULL; int upload_res = 0; long http_code; if (curl) { curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "file", CURLFORM_BUFFER, fname, CURLFORM_BUFFERPTR, buf_ptr, CURLFORM_BUFFERLENGTH, real_len, CURLFORM_END); curl_easy_setopt(curl, CURLOPT_URL, p->url); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fun_write); curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost); res = curl_easy_perform(curl); res_get_code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code); if ((res == CURLE_OK) && (res_get_code == CURLE_OK) && (http_code == 200)) {upload_res = 1;} curl_formfree(formpost); } if (upload_res) { fprintf(stderr, "%s: ok\n", fname); } else { fprintf(stderr, "%s: error\n", fname); } //if (!upload_res) { fprintf(stderr, "%s: error\n", fname); } } curl_easy_cleanup(curl); err: if (buf_ptr) { free(buf_ptr); buf_ptr = NULL;} return NULL; }