static void search_attr_req(const struct l2cap_frame *frame, struct tid_data *tid) { uint32_t search_bytes, attr_bytes; search_bytes = get_bytes(frame->data, frame->size); print_field("Search pattern: [len %d]", search_bytes); if (search_bytes + 2 > frame->size) { print_text(COLOR_ERROR, "invalid search list length"); packet_hexdump(frame->data, frame->size); return; } decode_data_elements(0, 2, frame->data, search_bytes, NULL); print_field("Max record count: %d", get_be16(frame->data + search_bytes)); attr_bytes = get_bytes(frame->data + search_bytes + 2, frame->size - search_bytes - 2); print_field("Attribute list: [len %d]", attr_bytes); if (search_bytes + attr_bytes > frame->size) { print_text(COLOR_ERROR, "invalid attribute list length"); return; } decode_data_elements(0, 2, frame->data + search_bytes + 2, attr_bytes, NULL); store_continuation(tid, frame->data + search_bytes + 2 + attr_bytes, frame->size - search_bytes - 2 - attr_bytes); }
static int get_usage (uint8_t * report_descriptor, size_t size, unsigned short *usage_page, unsigned short *usage) { size_t i = 0; int size_code; int data_len, key_size; int usage_found = 0, usage_page_found = 0; while (i < size) { int key = report_descriptor[i]; int key_cmd = key & 0xfc; if ((key & 0xf0) == 0xf0) { fprintf (stderr, "invalid data received.\n"); return -1; } else { size_code = key & 0x3; switch (size_code) { case 0: case 1: case 2: data_len = size_code; break; case 3: data_len = 4; break; default: /* Can't ever happen since size_code is & 0x3 */ data_len = 0; break; }; key_size = 1; } if (key_cmd == 0x4) { *usage_page = get_bytes (report_descriptor, size, data_len, i); usage_page_found = 1; } if (key_cmd == 0x8) { *usage = get_bytes (report_descriptor, size, data_len, i); usage_found = 1; } if (usage_page_found && usage_found) return 0; /* success */ i += data_len + key_size; } return -1; /* failure */ }
int Stream::get_string_ptr( char const *&s ) { char c; void *tmp_ptr = 0; int len; s = NULL; switch(_code){ case internal: case external: // For 6.2 compatibility, we had to put this code back if (!get_encryption()) { if (!peek(c)) return FALSE; if (c == '\255'){ if (get_bytes(&c, 1) != 1) return FALSE; s = NULL; } else{ if (get_ptr(tmp_ptr, '\0') <= 0) return FALSE; s = (char *)tmp_ptr; } } else { // 6.3 with encryption support // First, get length if (get(len) == FALSE) { return FALSE; } if( !decrypt_buf || decrypt_buf_len < len ) { free( decrypt_buf ); decrypt_buf = (char *)malloc(len); ASSERT( decrypt_buf ); decrypt_buf_len = len; } if( get_bytes(decrypt_buf, len) != len ) { return FALSE; } if( *decrypt_buf == '\255' ) { s = NULL; } else { s = decrypt_buf; } } break; case ascii: return FALSE; } if( s ) { NETWORK_TRACE("get string ptr " << s); } else { NETWORK_TRACE("get string ptr NULL"); } return TRUE; }
/* Check that an in-use record is valid. */ static bool tdb_check_used_record(struct tdb_context *tdb, tdb_off_t off, const struct tdb_record *rec, unsigned char **hashes, int (*check)(TDB_DATA, TDB_DATA, void *), void *private_data) { TDB_DATA key, data; if (!tdb_check_record(tdb, off, rec)) return false; /* key + data + tailer must fit in record */ if (rec->key_len + rec->data_len + sizeof(tdb_off_t) > rec->rec_len) { TDB_LOG((tdb, TDB_DEBUG_ERROR, "Record offset %d too short for contents\n", off)); return false; } key = get_bytes(tdb, off + sizeof(*rec), rec->key_len); if (!key.dptr) return false; if (tdb->hash_fn(&key) != rec->full_hash) { TDB_LOG((tdb, TDB_DEBUG_ERROR, "Record offset %d has incorrect hash\n", off)); goto fail_put_key; } /* Mark this offset as a known value for this hash bucket. */ record_offset(hashes[BUCKET(rec->full_hash)+1], off); /* And similarly if the next pointer is valid. */ if (rec->next) record_offset(hashes[BUCKET(rec->full_hash)+1], rec->next); /* If they supply a check function and this record isn't dead, get data and feed it. */ if (check && rec->magic != TDB_DEAD_MAGIC) { data = get_bytes(tdb, off + sizeof(*rec) + rec->key_len, rec->data_len); if (!data.dptr) goto fail_put_key; if (check(key, data, private_data) == -1) goto fail_put_data; put_bytes(tdb, data); } put_bytes(tdb, key); return true; fail_put_data: put_bytes(tdb, data); fail_put_key: put_bytes(tdb, key); return false; }
/** @return 1 is ok, <= 0 is failure */ static int convert_data(struct burn_write_opts *o, struct burn_track *track, int inmode, unsigned char *data) { int outlen, inlen; int offset = -1; int outmode; outmode = get_outmode(o); if (outmode == 0) outmode = inmode; outlen = burn_sector_length(outmode); inlen = burn_sector_length(inmode); /* ts A61010 */ /* a ssert(outlen >= inlen); */ if (outlen < inlen) return 0; if ((outmode & BURN_MODE_BITS) == (inmode & BURN_MODE_BITS)) { /* see MMC-5 4.2.3.8.5.3 Block Format for Mode 2 form 1 Data Table 24 Mode 2 Formed Sector Sub-header Format */ if (track != NULL) if (track->cdxa_conversion == 1) inlen += 8; get_bytes(track, inlen, data); if (track != NULL) if (track->cdxa_conversion == 1) memmove(data, data + 8, inlen - 8); return 1; } /* ts A61010 */ /* a ssert(outmode & BURN_MODE_RAW); */ if (!(outmode & BURN_MODE_RAW)) return 0; if (inmode & BURN_MODE1) offset = 16; if (inmode & BURN_MODE_RAW) offset = 0; if (inmode & BURN_AUDIO) offset = 0; /* ts A61010 */ /* a ssert(offset != -1); */ if (offset == -1) return 0; get_bytes(track, inlen, data + offset); return 1; }
int speed(char *dev, char *type, int max) { int first, end, perc; first = get_bytes(dev, type); sleep(1); end = get_bytes(dev, type); perc=((end - first) * 100) / max; if(perc > 100) perc=100; printf("%d\n", perc); return 0; }
int Stream::get( int64_t &l) { int i; char sign; // On Windows, INT_SIZE == sizeof(int64_t). // MSVC won't allocate an array of size 0, so just skip it. #ifndef WIN32 char pad[INT_SIZE-sizeof(int64_t)]; #endif switch(_code){ case internal: if (get_bytes(&l, sizeof(int64_t)) != sizeof(int64_t)) return FALSE; break; case external: if ((sizeof(int) == sizeof(int64_t)) || (sizeof(int64_t) > INT_SIZE)) { if (!get(i)) return FALSE; l = (long) i; } else { #ifndef WIN32 if (sizeof(int64_t) < INT_SIZE) { if (get_bytes(pad, INT_SIZE-sizeof(int64_t)) != INT_SIZE-sizeof(int64_t)) { return FALSE; } } #endif if (get_bytes(&l, sizeof(int64_t)) != sizeof(int64_t)) return FALSE; if (!hton_is_noop()) { // need to convert to host order l = ntohLL(l); } sign = (l >= 0) ? 0 : 0xff; #ifndef WIN32 for (int s=0; s < INT_SIZE-(int)sizeof(int64_t); s++) { // overflow? if (pad[s] != sign) { return FALSE; // overflow } } #endif } break; case ascii: return FALSE; } NETWORK_TRACE("get int64_t " << l); return TRUE; }
static void attr_req(const struct l2cap_frame *frame, struct tid_data *tid) { uint32_t attr_bytes; if (frame->size < 6) { print_text(COLOR_ERROR, "invalid size"); packet_hexdump(frame->data, frame->size); return; } print_field("Record handle: 0x%4.4x", get_be32(frame->data)); print_field("Max attribute bytes: %d", get_be16(frame->data + 4)); attr_bytes = get_bytes(frame->data + 6, frame->size - 6); print_field("Attribute list: [len %d]", attr_bytes); if (attr_bytes + 6 > frame->size) { print_text(COLOR_ERROR, "invalid attribute list length"); packet_hexdump(frame->data, frame->size); return; } decode_data_elements(0, 2, frame->data + 6, attr_bytes, NULL); store_continuation(tid, frame->data + 6 + attr_bytes, frame->size - 6 - attr_bytes); }
int RAND_egd_bytes(const char *filename, int size) { void *data; int ret; if (size <= 0) return 0; data = malloc(size); if (data == NULL) return 0; ret = get_bytes(filename, data, size); if (ret != 1) { free(data); return ret; } RAND_seed(data, size); memset(data, 0, size); free(data); return 1; }
int main(int argc, char *argv[]) { struct elf_handle *handle; char *file, *bytes; int size; file = parse_args(argc, argv); if (!options.flat_binary) { if ((handle = elf_init(file)) == NULL) { fprintf(stderr, "Failed to initialize elf file %s: %s\n", file, strerror(errno)); return 1; } bytes = get_bytes(handle, options.function, &size); elf_free(handle); } else bytes = read_flat_binary(file, &size); fprintf(stderr, "Printing shellcode (%d bytes)\n", size); if (!strcasecmp(options.format, "python")) print_opcodes_py(bytes, size); else if (!strcasecmp(options.format, "hexdump")) print_opcodes_hex(bytes, size); else if (!strcasecmp(options.format, "raw")) print_opcodes_raw(bytes, size); else print_opcodes_C(bytes, size); fflush(stdout); free(bytes); return 0; }
// ----------------------------------------------------------------------------- int BlockFile::fread_number() // read an <int> value from bin file { char ca[SIZEINT]; get_bytes(ca, SIZEINT); return *((int *)ca); }
char *rm16_sreg(char *buffer, int *j, int *error) { int err = 0; memset(str, '\0', 255) ; if (get_bytes(1, *j)) { *error = 1 ; return str ; } unsigned char reg = ((buffer[++(*j)] & 0x38) >> 3) ; (*j)-- ; char *s = rm(buffer, j, 16, &err) ; if (err) { *error = 1 ; return str ; } if (reg < 4) { char *sreg = segreg[reg] ; sprintf(str,"%s,%s", s, sreg) ; *error = 0 ; } else *error = 1 ; return str ; }
char *call_inter(char *buffer, int *j, int *err) { memset(str, '\0', 255) ; if (get_bytes(4, *j)) { *err = 1 ; return str ; } (*j)++ ; bytes++ ; unsigned char offset_low = buffer[*j] ; (*j)++ ; bytes++ ; unsigned char offset_high = buffer[*j] ; (*j)++ ; bytes++ ; unsigned char seg_low = buffer[*j] ; (*j)++ ; bytes++ ; unsigned char seg_high = buffer[*j] ; unsigned short offset = ((offset_high << 8) + offset_low) ; unsigned short seg = ((seg_high << 8) + seg_low) ; sprintf(str,"0x%x:0x%x", seg, offset) ; return str ; }
char *moffs16(char *buffer, int *j, int *err) { memset(str, '\0', 255) ; char segment[10] ; memset(segment, '\0', 10) ; if (segment_override >= 0) { switch (segment_override) { case ES: sprintf(segment, "es:") ; break ; case CS: sprintf(segment, "cs:") ; break ; case SS: sprintf(segment, "ss:") ; break ; case DS: sprintf(segment, "ds:") ; break ; } segment_override = -1 ; } if (get_bytes(2, *j)) { *err = 1 ; return str ; } (*j)++ ; bytes++ ; unsigned char low = buffer[*j] ; (*j)++ ; bytes++ ; unsigned char high = buffer[*j] ; unsigned short imm16 = ((high << 8) + low) ; sprintf(str, "[%s0x%x]", segment, imm16) ; return str ; }
static inline AVP_dword DATA_PARAM get_size_t( Serialize* sz, AVP_size_t* val ) { if ( get_bytes(sz,val,sizeof(AVP_size_t)) != sizeof(AVP_size_t) ) return 0; WriteSize_tPtr( val, *val ); return sizeof(AVP_size_t); }
/* Description: This function writes a command to the camera and checks if the write was done successfully by checking camera's response. Parameters: fd: serial port file descriptor msg: the command to be send to the camera Returns: 1: if the write was successful 0: otherwise */ int write_check(int fd, char *msg, int respond_size) { char respond[5]; // write the command to the camera if( write(fd, msg, strlen(msg)) != (int)strlen(msg) ) { printf( "Cmucam2: writing to serial device failed.\n" ); return 0; } if( get_bytes(fd, respond, respond_size) < 1 ) { printf( "Cmucam2: get bytes failed\n" ); return 0; } // If NCK is returned, there was an error in writing if(respond[0] == 'N') { printf("Cmucam2: received NCK!\n"); return 0; } return 1; }
char *rm16_imm8(char *buffer, int *j, int *err) { int error = 0 ; memset(str, '\0', 255) ; char *s = rm(buffer, j, 16, &error) ; if (error) { *err = 1 ; return str ; } (*j)++ ; if (get_bytes(1, *j)) { (*j)--; *err = 1 ; return str ; } (*j)--; (*j)++; bytes++ ; signed char imm8 = buffer[*j] ; char sign = '+' ; if (imm8 < 0) { sign = '-' ; imm8 = -imm8 ; } sprintf(str, "%s,byte %c0x%x", s, sign, imm8) ; return str ; }
// ----------------------------------------------------------------------------- // Read a <block> from <index> // // We point out the difference of counting among the <number>, <act_block> // and <pos>. // (1) <num_blocks_>: record the number of blocks, excluding the block // of header. start from 1. (internal block) // (2) <act_block_>: record the number of blocks currently read or written, // including the block of header, thus when we read or write file, // current <act_block> equal to 1. <act_block> is corresponding to // file pointer. // (3) <index> : record position of block we want to read or write, excluding // the block of header. start from 0. (external block), i.e., when // <index> = 0, the file pointer is pointed to next block after the // block of header, at this time, <act_block_> equals to 1. // // i.e. if number = 3, there are 4 blocks in the file, 1 header block + // 3 data block. // // When file is opened, <act_block_> = 1. if <index> = 1, it means that we // want to read or write the 3rd block (2nd data block), thus firstly index++, // then <index> = 2, then fseek move to 2nd data block. // // After reading or writing the 2nd data block, file pointer is pointed to // the 3rd data block. As we know it has read or written 3 blocks, thus // currently <act_block> = <index> + 1 = 2 + 1 = 3. // ----------------------------------------------------------------------------- bool BlockFile::read_block( // read a <block> from <index> Block block, // a <block> (return) int index) // pos of the block { index++; // extrnl block to intrnl block // move to the position if (index <= num_blocks_ && index > 0) { seek_block(index); } else { printf("BlockFile::read_block request the block %d " "which is illegal.", index - 1); error("\n", true); } get_bytes(block, block_length_);// read the block if (index + 1 > num_blocks_) { // <fp_> reaches the end of file fseek(fp_, 0, SEEK_SET); act_block_ = 0; // <act_block_> rewind to start pos } else { act_block_ = index + 1; // <act_block_> to next pos } return true; }
char *rm16_imm16(char *buffer, int *j, int *err) { int error = 0; memset(str, '\0', 255) ; char *s = rm(buffer, j, 16, &error) ; if (error) { *err = 1 ; return str ; } (*j)++ ; if (get_bytes(2, *j)) { (*j)-- ; *err = 1 ; return str ; } (*j)-- ; (*j)++; bytes++ ; unsigned char low = buffer[*j] ; (*j)++ ; bytes++ ; unsigned char high = buffer[*j] ; unsigned short imm16 = ((high << 8) + low) ; sprintf(str, "%s,0x%x", s, imm16) ; return str ; }
static inline AVP_dword DATA_PARAM get_qword ( Serialize* sz, AVP_qword* val ) { if ( get_bytes(sz,val,sizeof(AVP_qword)) != sizeof(AVP_qword) ) return 0; WriteQWordPtr( val, *val ); return sizeof(AVP_qword); }
// Increase the maximum number of interrupts static void _max_irqs(struct client *client, uint8_t id) { struct psl *psl; uint8_t buffer[MAX_LINE_CHARS]; uint8_t major, minor; uint16_t value; // Retrieve requested new maximum interrupts psl = _find_psl(id, &major, &minor); if (get_bytes(client->fd, 2, buffer, psl->timeout, &(client->abort), psl->dbg_fp, psl->dbg_id, client->context) < 0) { client_drop(client, PSL_IDLE_CYCLES, CLIENT_NONE); return; } memcpy((char *)&client->max_irqs, (char *)buffer, sizeof(uint16_t)); client->max_irqs = ntohs(client->max_irqs); // Limit to legal value if (client->max_irqs < psl->mmio->desc.num_ints_per_process) client->max_irqs = psl->mmio->desc.num_ints_per_process; if (client->max_irqs > 2037 / psl->mmio->desc.num_of_processes) client->max_irqs = 2037 / psl->mmio->desc.num_of_processes; // Return set value buffer[0] = PSLSE_MAX_INT; value = htons(client->max_irqs); memcpy(&(buffer[1]), (char *)&value, 2); if (put_bytes(client->fd, 3, buffer, psl->dbg_fp, psl->dbg_id, client->context) < 0) { client_drop(client, PSL_IDLE_CYCLES, CLIENT_NONE); } }
static char * get_address_block_header(struct olsrv2* olsr, struct address_block_info *info, char *msg_ptr) { olsr_u8_t head_octet, tail_octet; msg_ptr = get_u8(msg_ptr, &info->num_addr); // check head_length & no_tail bit msg_ptr = get_u8(msg_ptr, &head_octet); info->head_length = head_octet & GET_HEAD_LENGTH; info->no_tail = (head_octet & NO_TAIL) != 0 ? 1 : 0; // get head memset(&info->head, 0 , sizeof(union olsr_ip_addr)); msg_ptr = get_bytes(msg_ptr, info->head_length, &info->head); //check invalid info if(info->head_length > olsr->olsr_cnf->ipsize) olsr_printf("\n\tWarning : [length is too long (%u) ] %s(%u)\n", info->head_length, __FUNCTION__, __LINE__); //check tail part if(info->no_tail == 0){ // contains tail msg_ptr = get_u8(msg_ptr, &tail_octet); info->tail_length = tail_octet & GET_TAIL_LENGTH; info->zero_tail = (tail_octet & ZERO_TAIL) != 0 ? 1 : 0; //get tail memset(&info->tail, 0, sizeof(union olsr_ip_addr)); if(info->zero_tail == 0) msg_ptr = get_bytes(msg_ptr, info->tail_length, &info->tail); //check invalid info if(info->tail_length > olsr->olsr_cnf->ipsize) olsr_printf("\n\tWarning : [length is too long (%u) ] %s(%u)\n", info->head_length, __FUNCTION__, __LINE__); }else{ // not includes tail info->tail_length = 0; info->zero_tail = 1; } //mid_length info->mid_length = (olsr_u8_t)olsr->olsr_cnf->ipsize - info->head_length - info->tail_length; return msg_ptr; }
int Stream::get( int &i) { int tmp; char pad[INT_SIZE-sizeof(int)], sign; switch(_code){ case internal: if (get_bytes(&i, sizeof(int)) != sizeof(int)) { dprintf(D_NETWORK, "Stream::get(int) from internal failed\n"); return FALSE; } break; case external: { if (INT_SIZE > sizeof(int)) { // get overflow bytes if (get_bytes(pad, INT_SIZE-sizeof(int)) != INT_SIZE-sizeof(int)) { dprintf(D_NETWORK, "Stream::get(int) failed to read padding\n"); return FALSE; } } if (get_bytes(&tmp, sizeof(int)) != sizeof(int)) { dprintf(D_NETWORK, "Stream::get(int) failed to read int\n"); return FALSE; } i = ntohl(tmp); sign = (i >= 0) ? 0 : 0xff; for (int s=0; s < INT_SIZE-(int)sizeof(int); s++) { // chk 4 overflow if (pad[s] != sign) { dprintf(D_NETWORK, "Stream::get(int) incorrect pad received: %x\n", pad[s]); return FALSE; // overflow } } break; } case ascii: return FALSE; } putcount =0; getcount += 4; NETWORK_TRACE("get int " << i<< " c(" << getcount << ") "); return TRUE; }
static inline AVP_dword DATA_PARAM get_avp_property( Serialize* sz, AVP_Property* val ) { if ( get_bytes(sz,val,sizeof(AVP_Property)) == sizeof(AVP_Property) ) { val->id = ReadWordPtr (&val->id); return sizeof(AVP_Property); } return 0; }
static Xauth * read_numeric(FILE *fp) { Xauth *auth; auth = (Xauth *) malloc (sizeof (Xauth)); if (!auth) goto bad; auth->family = 0; auth->address = NULL; auth->address_length = 0; auth->number = NULL; auth->number_length = 0; auth->name = NULL; auth->name_length = 0; auth->data = NULL; auth->data_length = 0; if (!get_short (fp, (unsigned short *) &auth->family)) goto bad; if (!get_short (fp, (unsigned short *) &auth->address_length)) goto bad; if (!get_bytes (fp, (unsigned int) auth->address_length, &auth->address)) goto bad; if (!get_short (fp, (unsigned short *) &auth->number_length)) goto bad; if (!get_bytes (fp, (unsigned int) auth->number_length, &auth->number)) goto bad; if (!get_short (fp, (unsigned short *) &auth->name_length)) goto bad; if (!get_bytes (fp, (unsigned int) auth->name_length, &auth->name)) goto bad; if (!get_short (fp, (unsigned short *) &auth->data_length)) goto bad; if (!get_bytes (fp, (unsigned int) auth->data_length, &auth->data)) goto bad; switch (getinput (fp)) { /* get end of line */ case EOF: case '\n': return auth; } bad: if (auth) XauDisposeAuth (auth); /* won't free null pointers */ return NULL; }
/*For rank 2, I believe I'm doing this correctly, but doesn't work as expected when printed*/ void arr_set(Array * arr, int coords[3], void * val ){ int bytes = get_bytes(arr); if (arr->rank == 1){ memcpy(&(arr->vals[coords[0]* bytes]), val, bytes); } if (arr->rank == 2){ memcpy(&(arr->vals[(arr->dims[0] * coords[1] + coords[0]) * bytes]), val, bytes); } }
char* get_string(int pipe) { short len; int readres; char *str; /* Read the string length */ get_bytes(pipe, &len, 2); /* Malloc the string with null termination */ str = (char*) malloc(len+1); get_bytes(pipe, str, len); str[len] = '\0'; return str; }
template<class T> bool unpack_int (T *v) { u_int8_t buf[sizeof (T)]; bool ok = get_bytes (buf, sizeof (T)); if (ok) { big_endian (*v, buf, sizeof (T)); } return ok; }
static pyc_object *get_ascii_object_generic(RBuffer *buffer, ut32 size, bool interned) { pyc_object *ret = R_NEW0 (pyc_object); if (!ret) return NULL; ret->type = TYPE_ASCII; ret->data = get_bytes (buffer, size); if (!ret->data) R_FREE (ret); return ret; }
int Stream::get( long &l) { int i; char pad[INT_SIZE-sizeof(long)], sign; switch(_code){ case internal: if (get_bytes(&l, sizeof(long)) != sizeof(long)) return FALSE; break; case external: if ((sizeof(int) == sizeof(long)) || (sizeof(long) > INT_SIZE)) { if (!get(i)) return FALSE; l = (long) i; } else { if (sizeof(long) < INT_SIZE) { if (get_bytes(pad, INT_SIZE-sizeof(long)) != INT_SIZE-sizeof(long)) { return FALSE; } } if (get_bytes(&l, sizeof(long)) != sizeof(long)) return FALSE; if (!hton_is_noop()) { // need to convert to host order l = ntohL(l); } sign = (l >= 0) ? 0 : 0xff; for (int s=0; s < INT_SIZE-(int)sizeof(long); s++) { // overflow? if (pad[s] != sign) { return FALSE; // overflow } } } break; case ascii: return FALSE; } NETWORK_TRACE("get long " << l); return TRUE; }