int execute_get_load_threshold_handle(struct data_buffer *dbuf, int socket_fd, MEM_POOL_PTR mem_pool) { struct data_buffer rbuf; //发数据包 if(socket_write(socket_fd,dbuf->data,dbuf->data_len) <= 0) return -1; //接受命名 memset(&rbuf,0,sizeof(struct data_buffer)); rbuf.data_len = sizeof(uint32_t); rbuf.size = rbuf.data_len; rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,sizeof(uint32_t)); if(socket_read(socket_fd,rbuf.data,sizeof(uint32_t)) <= 0) return -1; rbuf.data_len = read_int32(&rbuf); rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,rbuf.data_len); rbuf.rpos = 0; rbuf.size = rbuf.data_len; if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0) return -1; rbuf.rpos += MESSAGE_HEAD_LEN; uint16_t type = message_type(&rbuf); if (type != MT_DC_EXE_RS) return -1; double load = 0; read_bytes(&rbuf, (uint8_t *)&load, sizeof(load)); fprintf(stderr, "%g\n", load); return 0; }
int read_version() { int sum = 0; int bytes_read = 0; uint16_t header = read_bytes(2, &bytes_read, &sum); // Always 0x210 (0x10-0x02) uint16_t command = read_bytes(2, &bytes_read, &sum); if (header == START && command == UNIT_VERSION) { read_bytes(2, &bytes_read, &sum); // length int major_version = read_bytes(1, &bytes_read, &sum); int minor_version = read_bytes(2, &bytes_read, &sum); int data_version = read_bytes(2, &bytes_read, &sum); QString version = QString(minor_version<100?"%1.0%2 (%3)":"%1.%2 (%3)").arg(major_version).arg(minor_version).arg(data_version); deviceInfo += rideFile->deviceType()+QString(" Version %1\n").arg(version); read_bytes(1, &bytes_read, &sum); // checksum } return bytes_read; }
int read_system_info() { int sum = 0; int bytes_read = 0; uint16_t header = read_bytes(2, &bytes_read, &sum); // Always (0x10-0x02) uint16_t command = read_bytes(2, &bytes_read, &sum); if (header == START && command == SYSTEM_INFO) { read_bytes(2, &bytes_read, &sum); // length read_bytes(52, &bytes_read, &sum); uint16_t odometer = read_bytes(8, &bytes_read, &sum); deviceInfo += QString("Odometer %1km\n").arg(odometer/1000.0); read_bytes(1, &bytes_read, &sum); // checksum } return bytes_read; }
void read_ride_summary(int *bytes_read = NULL, int *sum = NULL) { data_version = read_bytes(1, bytes_read, sum); // data_version read_bytes(1, bytes_read, sum); // firmware_minor_version QDateTime t = read_date(bytes_read, sum); rideFile->setStartTime(t); if (jouleGPS) { read_bytes(148, bytes_read, sum); if (data_version >= 4) read_bytes(8, bytes_read, sum); if (data_version >= 6) read_bytes(8, bytes_read, sum); } else { read_bytes(84, bytes_read, sum); } }
static int read_block(FILE *fp, pcap_t *p, struct block_cursor *cursor, char *errbuf) { int status; struct block_header bhdr; status = read_bytes(fp, &bhdr, sizeof(bhdr), 0, errbuf); if (status <= 0) return (status); /* error or EOF */ if (p->swapped) { bhdr.block_type = SWAPLONG(bhdr.block_type); bhdr.total_length = SWAPLONG(bhdr.total_length); } /* * Is this block "too big"? * * We choose 16MB as "too big", for now, so that we handle * "reasonably" large buffers but don't chew up all the * memory if we read a malformed file. */ if (bhdr.total_length > 16*1024*1024) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "pcap-ng block size %u > maximum %u", bhdr.total_length, 16*1024*1024); return (-1); } /* * Is this block "too small" - i.e., is it shorter than a block * header plus a block trailer? */ if (bhdr.total_length < sizeof(struct block_header) + sizeof(struct block_trailer)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "block in pcap-ng dump file has a length of %u < %lu", bhdr.total_length, (unsigned long)(sizeof(struct block_header) + sizeof(struct block_trailer))); return (-1); } /* * Is the buffer big enough? */ if (p->bufsize < (int)bhdr.total_length) { /* * No - make it big enough. */ p->buffer = realloc(p->buffer, bhdr.total_length); if (p->buffer == NULL) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory"); return (-1); } } /* * Copy the stuff we've read to the buffer, and read the rest * of the block. */ memcpy(p->buffer, &bhdr, sizeof(bhdr)); if (read_bytes(fp, p->buffer + sizeof(bhdr), bhdr.total_length - sizeof(bhdr), 1, errbuf) == -1) return (-1); /* * Initialize the cursor. */ cursor->data = p->buffer + sizeof(bhdr); cursor->data_remaining = bhdr.total_length - sizeof(bhdr) - sizeof(struct block_trailer); cursor->block_type = bhdr.block_type; return (1); }
void pmix_usock_recv_handler(int sd, short flags, void *cbdata) { pmix_status_t rc; pmix_peer_t *peer = (pmix_peer_t*)cbdata; pmix_ptl_recv_t *msg = NULL; /* acquire the object */ PMIX_ACQUIRE_OBJECT(peer); pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "usock:recv:handler called with peer %s:%d", (NULL == peer) ? "NULL" : peer->info->pname.nspace, (NULL == peer) ? PMIX_RANK_UNDEF : peer->info->pname.rank); if (NULL == peer) { return; } /* allocate a new message and setup for recv */ if (NULL == peer->recv_msg) { pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "usock:recv:handler allocate new recv msg"); peer->recv_msg = PMIX_NEW(pmix_ptl_recv_t); if (NULL == peer->recv_msg) { pmix_output(0, "usock_recv_handler: unable to allocate recv message\n"); goto err_close; } PMIX_RETAIN(peer); peer->recv_msg->peer = peer; // provide a handle back to the peer object /* start by reading the header */ peer->recv_msg->rdptr = (char*)&peer->recv_msg->hdr; peer->recv_msg->rdbytes = sizeof(pmix_usock_hdr_t); } msg = peer->recv_msg; msg->sd = sd; /* if the header hasn't been completely read, read it */ if (!msg->hdr_recvd) { pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "usock:recv:handler read hdr on socket %d", peer->sd); if (PMIX_SUCCESS == (rc = read_bytes(peer->sd, &msg->rdptr, &msg->rdbytes))) { /* completed reading the header */ peer->recv_msg->hdr_recvd = true; pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "RECVD MSG FOR TAG %d SIZE %d", (int)peer->recv_msg->hdr.tag, (int)peer->recv_msg->hdr.nbytes); /* if this is a zero-byte message, then we are done */ if (0 == peer->recv_msg->hdr.nbytes) { pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "RECVD ZERO-BYTE MESSAGE FROM %s:%d for tag %d", peer->info->pname.nspace, peer->info->pname.rank, peer->recv_msg->hdr.tag); peer->recv_msg->data = NULL; // make sure peer->recv_msg->rdptr = NULL; peer->recv_msg->rdbytes = 0; /* post it for delivery */ PMIX_ACTIVATE_POST_MSG(peer->recv_msg); peer->recv_msg = NULL; PMIX_POST_OBJECT(peer); return; } else { pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "usock:recv:handler allocate data region of size %lu", (unsigned long)peer->recv_msg->hdr.nbytes); /* allocate the data region */ peer->recv_msg->data = (char*)malloc(peer->recv_msg->hdr.nbytes); memset(peer->recv_msg->data, 0, peer->recv_msg->hdr.nbytes); /* point to it */ peer->recv_msg->rdptr = peer->recv_msg->data; peer->recv_msg->rdbytes = peer->recv_msg->hdr.nbytes; } /* fall thru and attempt to read the data */ } else if (PMIX_ERR_RESOURCE_BUSY == rc || PMIX_ERR_WOULD_BLOCK == rc) { /* exit this event and let the event lib progress */ return; } else { /* the remote peer closed the connection - report that condition * and let the caller know */ pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "pmix_usock_msg_recv: peer closed connection"); goto err_close; } } if (peer->recv_msg->hdr_recvd) { /* continue to read the data block - we start from * wherever we left off, which could be at the * beginning or somewhere in the message */ if (PMIX_SUCCESS == (rc = read_bytes(peer->sd, &msg->rdptr, &msg->rdbytes))) { /* we recvd all of the message */ pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "RECVD COMPLETE MESSAGE FROM SERVER OF %d BYTES FOR TAG %d ON PEER SOCKET %d", (int)peer->recv_msg->hdr.nbytes, peer->recv_msg->hdr.tag, peer->sd); /* post it for delivery */ PMIX_ACTIVATE_POST_MSG(peer->recv_msg); peer->recv_msg = NULL; /* ensure we post the modified peer object before another thread * picks it back up */ PMIX_POST_OBJECT(peer); return; } else if (PMIX_ERR_RESOURCE_BUSY == rc || PMIX_ERR_WOULD_BLOCK == rc) { /* exit this event and let the event lib progress */ /* ensure we post the modified peer object before another thread * picks it back up */ PMIX_POST_OBJECT(peer); return; } else { /* the remote peer closed the connection - report that condition * and let the caller know */ pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "pmix_usock_msg_recv: peer closed connection"); goto err_close; } } /* success */ return; err_close: /* stop all events */ if (peer->recv_ev_active) { pmix_event_del(&peer->recv_event); peer->recv_ev_active = false; } if (peer->send_ev_active) { pmix_event_del(&peer->send_event); peer->send_ev_active = false; } if (NULL != peer->recv_msg) { PMIX_RELEASE(peer->recv_msg); peer->recv_msg = NULL; } pmix_ptl_base_lost_connection(peer, PMIX_ERR_UNREACH); /* ensure we post the modified peer object before another thread * picks it back up */ PMIX_POST_OBJECT(peer); }
int main(int argc, char** argv) { if( 1 >= argc){ printf("usage: %s file offset length\n", basename(argv[0])); return 0; } FILE *fh = NULL; cmp_ctx_t cmp; uint16_t year = 1983; uint8_t month = 5; uint8_t day = 28; int64_t sint = 0; uint64_t uint = 0; float flt = 0.0f; double dbl = 0.0; bool boolean = false; uint8_t fake_bool = 0; uint32_t string_size = 0; uint32_t array_size = 0; uint32_t binary_size = 0; uint32_t map_size = 0; int8_t ext_type = 0; uint32_t ext_size = 0; char sbuf[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; fh = fopen(argv[1], "rb"); if (fh == NULL){ error_and_exit(strerror(errno)); } cmp_init(&cmp, fh, file_reader, file_writer); /* Alternately, you can read objects until the stream is empty */ while (1) { cmp_object_t obj; if (!cmp_read_object(&cmp, &obj)) { if (feof(fh)) break; error_and_exit(cmp_strerror(&cmp)); } switch (obj.type) { case CMP_TYPE_POSITIVE_FIXNUM: case CMP_TYPE_UINT8: //printf("Unsigned Integer: %u\n", obj.as.u8); printf("Unsigned Integer: %u\n", obj.as.u8); break; case CMP_TYPE_FIXMAP: case CMP_TYPE_MAP16: case CMP_TYPE_MAP32: printf("Map: %u\n", obj.as.map_size); break; case CMP_TYPE_FIXARRAY: case CMP_TYPE_ARRAY16: case CMP_TYPE_ARRAY32: printf("Array: %u\n", obj.as.array_size); break; case CMP_TYPE_FIXSTR: case CMP_TYPE_STR8: case CMP_TYPE_STR16: case CMP_TYPE_STR32: if (!read_bytes(sbuf, obj.as.str_size, fh)) error_and_exit(strerror(errno)); sbuf[obj.as.str_size] = 0; printf("String: %s\n", sbuf); break; case CMP_TYPE_BIN8: case CMP_TYPE_BIN16: case CMP_TYPE_BIN32: memset(sbuf, 0, sizeof(sbuf)); if (!read_bytes(sbuf, obj.as.bin_size, fh)) error_and_exit(strerror(errno)); printf("Binary: %s\n", sbuf); break; case CMP_TYPE_NIL: printf("NULL\n"); break; case CMP_TYPE_BOOLEAN: if (obj.as.boolean) printf("Boolean: true\n"); else printf("Boolean: false\n"); break; case CMP_TYPE_EXT8: case CMP_TYPE_EXT16: case CMP_TYPE_EXT32: case CMP_TYPE_FIXEXT1: case CMP_TYPE_FIXEXT2: case CMP_TYPE_FIXEXT4: case CMP_TYPE_FIXEXT8: case CMP_TYPE_FIXEXT16: if (obj.as.ext.type == 1) { /* Date object */ if (!read_bytes(&year, sizeof(uint16_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&month, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); if (!read_bytes(&day, sizeof(uint8_t), fh)) error_and_exit(strerror(errno)); printf("Date: %u/%u/%u\n", year, month, day); } else { printf("Extended type {%d, %u}: ", obj.as.ext.type, obj.as.ext.size); while (obj.as.ext.size--) { read_bytes(sbuf, sizeof(uint8_t), fh); printf("%02x ", sbuf[0]); } printf("\n"); } break; case CMP_TYPE_FLOAT: printf("Float: %f\n", obj.as.flt); break; case CMP_TYPE_DOUBLE: printf("Double: %f\n", obj.as.dbl); break; case CMP_TYPE_UINT16: printf("Unsigned Integer: %u\n", obj.as.u16); break; case CMP_TYPE_UINT32: printf("Unsigned Integer: %u\n", obj.as.u32); break; case CMP_TYPE_UINT64: printf("Unsigned Integer: %" PRIu64 "\n", obj.as.u64); break; case CMP_TYPE_NEGATIVE_FIXNUM: case CMP_TYPE_SINT8: printf("Signed Integer: %d\n", obj.as.s8); break; case CMP_TYPE_SINT16: printf("Signed Integer: %d\n", obj.as.s16); break; case CMP_TYPE_SINT32: printf("Signed Integer: %d\n", obj.as.s32); break; case CMP_TYPE_SINT64: printf("Signed Integer: %" PRId64 "\n", obj.as.s64); break; default: printf("Unrecognized object type %u\n", obj.type); break; } } fclose(fh); return EXIT_SUCCESS; }
void pmix_usock_recv_handler(int sd, short flags, void *cbdata) { int rc; opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s usock:recv:handler called", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); switch (mca_pmix_native_component.state) { case PMIX_USOCK_CONNECT_ACK: if (OPAL_SUCCESS == (rc = usock_recv_connect_ack())) { opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s usock:recv:handler starting send/recv events", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); /* we connected! Start the send/recv events */ if (!mca_pmix_native_component.recv_ev_active) { opal_event_add(&mca_pmix_native_component.recv_event, 0); mca_pmix_native_component.recv_ev_active = true; } if (mca_pmix_native_component.timer_ev_active) { opal_event_del(&mca_pmix_native_component.timer_event); mca_pmix_native_component.timer_ev_active = false; } /* if there is a message waiting to be sent, queue it */ if (NULL == mca_pmix_native_component.send_msg) { mca_pmix_native_component.send_msg = (pmix_usock_send_t*)opal_list_remove_first(&mca_pmix_native_component.send_queue); } if (NULL != mca_pmix_native_component.send_msg && !mca_pmix_native_component.send_ev_active) { opal_event_add(&mca_pmix_native_component.send_event, 0); mca_pmix_native_component.send_ev_active = true; } /* update our state */ mca_pmix_native_component.state = PMIX_USOCK_CONNECTED; } else { opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s UNABLE TO COMPLETE CONNECT ACK WITH SERVER", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); opal_event_del(&mca_pmix_native_component.recv_event); mca_pmix_native_component.recv_ev_active = false; return; } break; case PMIX_USOCK_CONNECTED: opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s usock:recv:handler CONNECTED", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); /* allocate a new message and setup for recv */ if (NULL == mca_pmix_native_component.recv_msg) { opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s usock:recv:handler allocate new recv msg", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); mca_pmix_native_component.recv_msg = OBJ_NEW(pmix_usock_recv_t); if (NULL == mca_pmix_native_component.recv_msg) { opal_output(0, "%s usock_recv_handler: unable to allocate recv message\n", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); return; } /* start by reading the header */ mca_pmix_native_component.recv_msg->rdptr = (char*)&mca_pmix_native_component.recv_msg->hdr; mca_pmix_native_component.recv_msg->rdbytes = sizeof(pmix_usock_hdr_t); } /* if the header hasn't been completely read, read it */ if (!mca_pmix_native_component.recv_msg->hdr_recvd) { opal_output_verbose(2, opal_pmix_base_framework.framework_output, "usock:recv:handler read hdr"); if (OPAL_SUCCESS == (rc = read_bytes(mca_pmix_native_component.recv_msg))) { /* completed reading the header */ mca_pmix_native_component.recv_msg->hdr_recvd = true; /* if this is a zero-byte message, then we are done */ if (0 == mca_pmix_native_component.recv_msg->hdr.nbytes) { opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s RECVD ZERO-BYTE MESSAGE FROM SERVER for tag %d", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), mca_pmix_native_component.recv_msg->hdr.tag); mca_pmix_native_component.recv_msg->data = NULL; // make sure mca_pmix_native_component.recv_msg->rdptr = NULL; mca_pmix_native_component.recv_msg->rdbytes = 0; } else { opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s usock:recv:handler allocate data region of size %lu", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), (unsigned long)mca_pmix_native_component.recv_msg->hdr.nbytes); /* allocate the data region */ mca_pmix_native_component.recv_msg->data = (char*)malloc(mca_pmix_native_component.recv_msg->hdr.nbytes); /* point to it */ mca_pmix_native_component.recv_msg->rdptr = mca_pmix_native_component.recv_msg->data; mca_pmix_native_component.recv_msg->rdbytes = mca_pmix_native_component.recv_msg->hdr.nbytes; } /* fall thru and attempt to read the data */ } else if (OPAL_ERR_RESOURCE_BUSY == rc || OPAL_ERR_WOULD_BLOCK == rc) { /* exit this event and let the event lib progress */ return; } else { /* close the connection */ opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s usock:recv:handler error reading bytes - closing connection", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); CLOSE_THE_SOCKET(mca_pmix_native_component.sd); return; } } if (mca_pmix_native_component.recv_msg->hdr_recvd) { /* continue to read the data block - we start from * wherever we left off, which could be at the * beginning or somewhere in the message */ if (OPAL_SUCCESS == (rc = read_bytes(mca_pmix_native_component.recv_msg))) { /* we recvd all of the message */ opal_output_verbose(2, opal_pmix_base_framework.framework_output, "%s RECVD COMPLETE MESSAGE FROM SERVER OF %d BYTES FOR TAG %d", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), (int)mca_pmix_native_component.recv_msg->hdr.nbytes, mca_pmix_native_component.recv_msg->hdr.tag); /* post it for delivery */ PMIX_ACTIVATE_POST_MSG(mca_pmix_native_component.recv_msg); mca_pmix_native_component.recv_msg = NULL; } else if (OPAL_ERR_RESOURCE_BUSY == rc || OPAL_ERR_WOULD_BLOCK == rc) { /* exit this event and let the event lib progress */ return; } else { // report the error opal_output(0, "%s usock_peer_recv_handler: unable to recv message", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); /* turn off the recv event */ opal_event_del(&mca_pmix_native_component.recv_event); mca_pmix_native_component.recv_ev_active = false; CLOSE_THE_SOCKET(mca_pmix_native_component.sd); return; } } break; default: opal_output(0, "%s usock_peer_recv_handler: invalid socket state(%d)", OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), mca_pmix_native_component.state); CLOSE_THE_SOCKET(mca_pmix_native_component.sd); break; } }
// Parse the user data for captions. The udtype variable denotes // to which type of data it belongs: // 0 .. sequence header // 1 .. GOP header // 2 .. picture header // Return TRUE if the data parsing finished, FALSE otherwise. // estream->pos is advanced. Data is only processed if ustream->error // is FALSE, parsing can set ustream->error to TRUE. int user_data(struct lib_cc_decode *ctx, struct bitstream *ustream, int udtype, struct cc_subtitle *sub) { dbg_print(CCX_DMT_VERBOSE, "user_data(%d)\n", udtype); // Shall not happen if (ustream->error || ustream->bitsleft <= 0) { // ustream->error=1; return 0; // Actually discarded on call. // CFS: Seen in a Wobble edited file. // fatal(CCX_COMMON_EXIT_BUG_BUG, "user_data: Impossible!"); } // Do something ctx->stat_numuserheaders++; //header+=4; unsigned char *ud_header = next_bytes(ustream, 4); if (ustream->error || ustream->bitsleft <= 0) { return 0; // Actually discarded on call. // CFS: Seen in Stick_VHS.mpg. // fatal(CCX_COMMON_EXIT_BUG_BUG, "user_data: Impossible!"); } // DVD CC header, see // <http://www.theneitherworld.com/mcpoodle/SCC_TOOLS/DOCS/SCC_FORMAT.HTML> if ( !memcmp(ud_header,"\x43\x43", 2 ) ) { ctx->stat_dvdccheaders++; // Probably unneeded, but keep looking for extra caption blocks int maybeextracb = 1; read_bytes(ustream, 4); // "43 43 01 F8" unsigned char pattern_flag = (unsigned char) read_bits(ustream,1); read_bits(ustream,1); int capcount=(int) read_bits(ustream,5); int truncate_flag = (int) read_bits(ustream,1); // truncate_flag - one CB extra int field1packet = 0; // expect Field 1 first if (pattern_flag == 0x00) field1packet=1; // expect Field 1 second dbg_print(CCX_DMT_VERBOSE, "Reading %d%s DVD CC segments\n", capcount, (truncate_flag?"+1":"")); capcount += truncate_flag; // This data comes before the first frame header, so // in order to get the correct timing we need to set the // current time to one frame after the maximum time of the // last GOP. Only useful when there are frames before // the GOP. if (ctx->timing->fts_max > 0) ctx->timing->fts_now = ctx->timing->fts_max + (LLONG) (1000.0/current_fps); int rcbcount = 0; for (int i=0; i<capcount; i++) { for (int j=0;j<2;j++) { unsigned char data[3]; data[0]=read_u8(ustream); data[1]=read_u8(ustream); data[2]=read_u8(ustream); // Obey the truncate flag. if ( truncate_flag && i == capcount-1 && j == 1 ) { maybeextracb = 0; break; } /* Field 1 and 2 data can be in either order, with marker bytes of \xff and \xfe Since markers can be repeated, use pattern as well */ if ((data[0]&0xFE) == 0xFE) // Check if valid { if (data[0]==0xff && j==field1packet) data[0]=0x04; // Field 1 else data[0]=0x05; // Field 2 do_cb(ctx, data, sub); rcbcount++; } else { dbg_print(CCX_DMT_VERBOSE, "Illegal caption segment - stop here.\n"); maybeextracb = 0; break; } } } // Theoretically this should not happen, oh well ... // Deal with extra closed captions some DVD have. int ecbcount = 0; while ( maybeextracb && (next_u8(ustream)&0xFE) == 0xFE ) { for (int j=0;j<2;j++) { unsigned char data[3]; data[0]=read_u8(ustream); data[1]=read_u8(ustream); data[2]=read_u8(ustream); /* Field 1 and 2 data can be in either order, with marker bytes of \xff and \xfe Since markers can be repeated, use pattern as well */ if ((data[0]&0xFE) == 0xFE) // Check if valid { if (data[0]==0xff && j==field1packet) data[0]=0x04; // Field 1 else data[0]=0x05; // Field 2 do_cb(ctx, data, sub); ecbcount++; } else { dbg_print(CCX_DMT_VERBOSE, "Illegal (extra) caption segment - stop here.\n"); maybeextracb = 0; break; } } } dbg_print(CCX_DMT_VERBOSE, "Read %d/%d DVD CC blocks\n", rcbcount, ecbcount); } // SCTE 20 user data else if (!ctx->noscte20 && ud_header[0] == 0x03) { if ((ud_header[1]&0x7F) == 0x01) { unsigned char cc_data[3*31+1]; // Maximum cc_count is 31 ctx->stat_scte20ccheaders++; read_bytes(ustream, 2); // "03 01" unsigned cc_count = (unsigned int) read_bits(ustream,5); dbg_print(CCX_DMT_VERBOSE, "Reading %d SCTE 20 CC blocks\n", cc_count); unsigned field_number; unsigned cc_data1; unsigned cc_data2; for (unsigned j=0;j<cc_count;j++) { skip_bits(ustream,2); // priority - unused field_number = (unsigned int) read_bits(ustream,2); skip_bits(ustream,5); // line_offset - unused cc_data1 = (unsigned int) read_bits(ustream,8); cc_data2 = (unsigned int) read_bits(ustream,8); read_bits(ustream,1); // TODO: Add syntax check */ if (ustream->bitsleft < 0) fatal(CCX_COMMON_EXIT_BUG_BUG, "In user_data: ustream->bitsleft < 0. Cannot continue."); // Field_number is either // 0 .. forbidden // 1 .. field 1 (odd) // 2 .. field 2 (even) // 3 .. repeated, from repeat_first_field, effectively field 1 if (field_number < 1) { // 0 is invalid cc_data[j*3]=0x00; // Set to invalid cc_data[j*3+1]=0x00; cc_data[j*3+2]=0x00; } else { // Treat field_number 3 as 1 field_number = (field_number - 1) & 0x01; // top_field_first also affects to which field the caption // belongs. if(!ctx->top_field_first) field_number ^= 0x01; cc_data[j*3]=0x04|(field_number); cc_data[j*3+1]=reverse8(cc_data1); cc_data[j*3+2]=reverse8(cc_data2); } } cc_data[cc_count*3]=0xFF; store_hdcc(ctx, cc_data, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); dbg_print(CCX_DMT_VERBOSE, "Reading SCTE 20 CC blocks - done\n"); } // reserved - unspecified } // ReplayTV 4000/5000 caption header - parsing information // derived from CCExtract.bdl else if ( (ud_header[0] == 0xbb //ReplayTV 4000 || ud_header[0] == 0x99) //ReplayTV 5000 && ud_header[1] == 0x02 ) { unsigned char data[3]; if (ud_header[0]==0xbb) ctx->stat_replay4000headers++; else ctx->stat_replay5000headers++; read_bytes(ustream, 2); // "BB 02" or "99 02" data[0]=0x05; // Field 2 data[1]=read_u8(ustream); data[2]=read_u8(ustream); do_cb(ctx, data, sub); read_bytes(ustream, 2); // Skip "CC 02" for R4000 or "AA 02" for R5000 data[0]=0x04; // Field 1 data[1]=read_u8(ustream); data[2]=read_u8(ustream); do_cb(ctx, data, sub); } // HDTV - see A/53 Part 4 (Video) else if ( !memcmp(ud_header,"\x47\x41\x39\x34", 4 ) ) { ctx->stat_hdtv++; read_bytes(ustream, 4); // "47 41 39 34" unsigned char type_code = read_u8(ustream); if (type_code==0x03) // CC data. { skip_bits(ustream,1); // reserved unsigned char process_cc_data = (unsigned char) read_bits(ustream,1); skip_bits(ustream,1); // additional_data - unused unsigned char cc_count = (unsigned char) read_bits(ustream,5); read_bytes(ustream, 1); // "FF" if (process_cc_data) { dbg_print(CCX_DMT_VERBOSE, "Reading %d HDTV CC blocks\n", cc_count); int proceed = 1; unsigned char *cc_data = read_bytes(ustream, cc_count*3); if (ustream->bitsleft < 0) fatal(CCX_COMMON_EXIT_BUG_BUG, "In user_data: ustream->bitsleft < 0. Cannot continue.\n"); // Check for proper marker - This read makes sure that // cc_count*3+1 bytes are read and available in cc_data. if (read_u8(ustream)!=0xFF) proceed=0; if (!proceed) { dbg_print(CCX_DMT_VERBOSE, "\rThe following payload is not properly terminated.\n"); dump (CCX_DMT_VERBOSE, cc_data, cc_count*3+1, 0, 0); } dbg_print(CCX_DMT_VERBOSE, "Reading %d HD CC blocks\n", cc_count); // B-frames might be (temporal) before or after the anchor // frame they belong to. Store the buffer until the next anchor // frame occurs. The buffer will be flushed (sorted) in the // picture header (or GOP) section when the next anchor occurs. // Please note we store the current value of the global // fts_now variable (and not get_fts()) as we are going to // re-create the timeline in process_hdcc() (Slightly ugly). store_hdcc(ctx, cc_data, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); dbg_print(CCX_DMT_VERBOSE, "Reading HDTV blocks - done\n"); } } // reserved - additional_cc_data } // DVB closed caption header for Dish Network (Field 1 only) */ else if ( !memcmp(ud_header,"\x05\x02", 2 ) ) { // Like HDTV (above) Dish Network captions can be stored at each // frame, but maximal two caption blocks per frame and only one // field is stored. // To process this with the HDTV framework we create a "HDTV" caption // format compatible array. Two times 3 bytes plus one for the 0xFF // marker at the end. Pre-init to field 1 and set the 0xFF marker. static unsigned char dishdata[7] = {0x04, 0, 0, 0x04, 0, 0, 0xFF}; int cc_count; dbg_print(CCX_DMT_VERBOSE, "Reading Dish Network user data\n"); ctx->stat_dishheaders++; read_bytes(ustream, 2); // "05 02" // The next bytes are like this: // header[2] : ID: 0x04 (MPEG?), 0x03 (H264?) // header[3-4]: Two byte counter (counting (sub-)GOPs?) // header[5-6]: Two bytes, maybe checksum? // header[7]: Pattern type // on B-frame: 0x02, 0x04 // on I-/P-frame: 0x05 unsigned char id = read_u8(ustream); unsigned dishcount = read_u16(ustream); unsigned something = read_u16(ustream); unsigned char type = read_u8(ustream); dbg_print(CCX_DMT_PARSE, "DN ID: %02X Count: %5u Unknown: %04X Pattern: %X", id, dishcount, something, type); unsigned char hi; // The following block needs 4 to 6 bytes starting from the // current position unsigned char *dcd = ustream->pos; // dish caption data switch (type) { case 0x02: // Two byte caption - always on B-frame // The following 4 bytes are: // 0 : 0x09 // 1-2: caption block // 3 : REPEAT - 02: two bytes // - 04: four bytes (repeat first two) dbg_print(CCX_DMT_PARSE, "\n02 %02X %02X:%02X - R:%02X :", dcd[0], dcd[1], dcd[2], dcd[3]); cc_count = 1; dishdata[1]=dcd[1]; dishdata[2]=dcd[2]; dbg_print(CCX_DMT_PARSE, "%s", debug_608_to_ASC( dishdata, 0) ); type=dcd[3]; // repeater (0x02 or 0x04) hi = dishdata[1] & 0x7f; // Get only the 7 low bits if (type==0x04 && hi<32) // repeat (only for non-character pairs) { cc_count = 2; dishdata[3]=0x04; // Field 1 dishdata[4]=dishdata[1]; dishdata[5]=dishdata[2]; dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); } else { dbg_print(CCX_DMT_PARSE, ":\n"); } dishdata[cc_count*3] = 0xFF; // Set end marker store_hdcc(ctx, dishdata, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); // Ignore 3 (0x0A, followed by two unknown) bytes. break; case 0x04: // Four byte caption - always on B-frame // The following 5 bytes are: // 0 : 0x09 // 1-2: caption block // 3-4: caption block dbg_print(CCX_DMT_PARSE, "\n04 %02X %02X:%02X:%02X:%02X :", dcd[0], dcd[1], dcd[2], dcd[3], dcd[4]); cc_count = 2; dishdata[1]=dcd[1]; dishdata[2]=dcd[2]; dishdata[3]=0x04; // Field 1 dishdata[4]=dcd[3]; dishdata[5]=dcd[4]; dishdata[6] = 0xFF; // Set end marker dbg_print(CCX_DMT_PARSE, "%s", debug_608_to_ASC( dishdata, 0) ); dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); store_hdcc(ctx, dishdata, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); // Ignore 4 (0x020A, followed by two unknown) bytes. break; case 0x05: // Buffered caption - always on I-/P-frame // The following six bytes are: // 0 : 0x04 // - the following are from previous 0x05 caption header - // 1 : prev dcd[2] // 2-3: prev dcd[3-4] // 4-5: prev dcd[5-6] dbg_print(CCX_DMT_PARSE, " - %02X pch: %02X %5u %02X:%02X\n", dcd[0], dcd[1], (unsigned)dcd[2]*256+dcd[3], dcd[4], dcd[5]); dcd+=6; // Skip these 6 bytes // Now one of the "regular" 0x02 or 0x04 captions follows dbg_print(CCX_DMT_PARSE, "%02X %02X %02X:%02X", dcd[0], dcd[1], dcd[2], dcd[3]); type=dcd[0]; // Number of caption bytes (0x02 or 0x04) cc_count = 1; dishdata[1]=dcd[2]; dishdata[2]=dcd[3]; dcd+=4; // Skip the first 4 bytes. if (type==0x02) { type=dcd[0]; // repeater (0x02 or 0x04) dcd++; // Skip the repeater byte. dbg_print(CCX_DMT_PARSE, " - R:%02X :%s", type, debug_608_to_ASC( dishdata, 0) ); hi = dishdata[1] & 0x7f; // Get only the 7 low bits if (type==0x04 && hi<32) { cc_count = 2; dishdata[3]=0x04; // Field 1 dishdata[4]=dishdata[1]; dishdata[5]=dishdata[2]; dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); } else { dbg_print(CCX_DMT_PARSE, ":\n"); } dishdata[cc_count*3] = 0xFF; // Set end marker } else { dbg_print(CCX_DMT_PARSE, ":%02X:%02X ", dcd[0], dcd[1]); cc_count = 2; dishdata[3]=0x04; // Field 1 dishdata[4]=dcd[0]; dishdata[5]=dcd[1]; dishdata[6] = 0xFF; // Set end marker dbg_print(CCX_DMT_PARSE, ":%s", debug_608_to_ASC( dishdata, 0) ); dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); } store_hdcc(ctx, dishdata, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); // Ignore 3 (0x0A, followed by 2 unknown) bytes. break; default: // printf ("Unknown?\n"); break; } // switch dbg_print(CCX_DMT_VERBOSE, "Reading Dish Network user data - done\n"); } // CEA 608 / aka "Divicom standard", see: // http://www.pixeltools.com/tech_tip_closed_captioning.html else if ( !memcmp(ud_header,"\x02\x09", 2 ) ) { // Either a documentation or more examples are needed. ctx->stat_divicom++; unsigned char data[3]; read_bytes(ustream, 2); // "02 09" read_bytes(ustream, 2); // "80 80" ??? read_bytes(ustream, 2); // "02 0A" ??? data[0]=0x04; // Field 1 data[1]=read_u8(ustream); data[2]=read_u8(ustream); do_cb(ctx, data, sub); // This is probably incomplete! } // GXF vbi OEM code else if ( !memcmp(ud_header,"\x73\x52\x21\x06", 4 ) ) { int udatalen = ustream->end - ustream->pos; uint16_t line_nb; uint8_t line_type; uint8_t field = 1; read_bytes(ustream, 4); //skip header code read_bytes(ustream, 2); //skip data length line_nb = read_bits(ustream, 16); line_type = read_u8(ustream); field = (line_type & 0x03); if(field == 0) mprint("MPEG:VBI: Invalid field\n"); line_type = line_type >> 2; if(line_type != 1) mprint("MPEG:VBI: only support Luma line\n"); if (udatalen < 720) mprint("MPEG:VBI: Minimum 720 bytes in luma line required\n"); decode_vbi(ctx, field, ustream->pos, 720, sub); dbg_print(CCX_DMT_VERBOSE, "GXF (vbi line %d) user data:\n", line_nb); }
/* Read single byte and return byte read */ static inline u8 read_byte(u16 port) { u8 byte; read_bytes(port, 1, &byte, NULL); return byte; }
static int spin_read_bytes(thread_args *args, char *buf) { return read_bytes(args->fds.read_fd, buf, args->msg_size, 1); }
static int blocking_read_bytes(thread_args *args, char *buf) { return read_bytes(args->fds.read_fd, buf, args->msg_size, 0); }
void read_interval_summary(int *bytes_read = NULL, int *sum = NULL) { read_bytes(3200, bytes_read, sum); }
void read_header(uint16_t &header, uint16_t &command, uint16_t &length, int *bytes_read = NULL, int *sum = NULL) { header = read_bytes(2, bytes_read, sum); command = read_bytes(2, bytes_read, sum); length = read_bytes(2, bytes_read, sum); }
void read_detail_record(double *secs, int *bytes_read = NULL, int *sum = NULL) { int cad = read_bytes(1, bytes_read, sum); read_bytes(1, bytes_read, sum); // pedal_smoothness int lrbal = read_bytes(1, bytes_read, sum); int hr = read_bytes(1, bytes_read, sum); read_bytes(1, bytes_read, sum); // dummy int watts = read_bytes(2, bytes_read, sum); int nm = read_bytes(2, bytes_read, sum); double kph = read_bytes(2, bytes_read, sum); int alt = read_bytes(2, bytes_read, sum); double temp = read_bytes(2, bytes_read, sum)/10.0; double lat = read_bytes(4, bytes_read, sum); double lng = read_bytes(4, bytes_read, sum); double km = read_bytes(8, bytes_read, sum)/1000.0/1000.0; // Validations if (lrbal == 0xFF) lrbal = 0; else if ((lrbal & 0x200) == 0x200) lrbal = 100-lrbal; if (cad == 0xFF) cad = 0; if (hr == 0xFF) hr = 0; if (watts == 0xFFFF) // 65535 watts = 0; if (kph == 0xFFFF) // 65535 kph = 0; else kph = kph/10.0; if (temp == 0x8000) temp = 0; if (alt == 0x8000) alt = 0; if (lat == -2147483648) //2147483648 lat = 0; else lat = lat/10000000.0; if (lng == -2147483648) //0x80000000 lng = 0; else lng = lng/10000000.0; rideFile->appendPoint(*secs, cad, hr, km, kph, nm, watts, alt, lng, lat, 0.0, 0, temp, lrbal, interval); (*secs)++; }
static int google_chromeec_command_v3(struct chromeec_command *cec_command) { struct ec_host_request rq; struct ec_host_response rs; const u8 *d; u8 csum = 0; int i; if (cec_command->cmd_size_in + sizeof(rq) > EC_LPC_HOST_PACKET_SIZE) { printk(BIOS_ERR, "EC cannot send %zu bytes\n", cec_command->cmd_size_in + sizeof(rq)); return -1; } if (cec_command->cmd_size_out > EC_LPC_HOST_PACKET_SIZE) { printk(BIOS_ERR, "EC cannot receive %d bytes\n", cec_command->cmd_size_out); return -1; } if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) { printk(BIOS_ERR, "Timeout waiting for EC start command %d!\n", cec_command->cmd_code); return -1; } /* Fill in request packet */ rq.struct_version = EC_HOST_REQUEST_VERSION; rq.checksum = 0; rq.command = cec_command->cmd_code | EC_CMD_PASSTHRU_OFFSET(cec_command->cmd_dev_index); rq.command_version = cec_command->cmd_version; rq.reserved = 0; rq.data_len = cec_command->cmd_size_in; /* Copy data and start checksum */ write_bytes(EC_LPC_ADDR_HOST_PACKET + sizeof(rq), cec_command->cmd_size_in, (u8*)cec_command->cmd_data_in, &csum); /* Finish checksum */ for (i = 0, d = (const u8 *)&rq; i < sizeof(rq); i++, d++) csum += *d; /* Write checksum field so the entire packet sums to 0 */ rq.checksum = -csum; /* Copy header */ write_bytes(EC_LPC_ADDR_HOST_PACKET, sizeof(rq), (u8*)&rq, NULL); /* Start the command */ write_byte(EC_COMMAND_PROTOCOL_3, EC_LPC_ADDR_HOST_CMD); if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) { printk(BIOS_ERR, "Timeout waiting for EC process command %d!\n", cec_command->cmd_code); return -1; } /* Check result */ cec_command->cmd_code = read_byte(EC_LPC_ADDR_HOST_DATA); if (cec_command->cmd_code) { printk(BIOS_ERR, "EC returned error result code %d\n", cec_command->cmd_code); return -i; } /* Read back response header and start checksum */ csum = 0; read_bytes(EC_LPC_ADDR_HOST_PACKET, sizeof(rs), (u8*)&rs, &csum); if (rs.struct_version != EC_HOST_RESPONSE_VERSION) { printk(BIOS_ERR, "EC response version mismatch (%d != %d)\n", rs.struct_version, EC_HOST_RESPONSE_VERSION); return -1; } if (rs.reserved) { printk(BIOS_ERR, "EC response reserved is %d, should be 0\n", rs.reserved); return -1; } if (rs.data_len > cec_command->cmd_size_out) { printk(BIOS_ERR, "EC returned too much data (%d > %d)\n", rs.data_len, cec_command->cmd_size_out); return -1; } /* Read back data and update checksum */ read_bytes(EC_LPC_ADDR_HOST_PACKET + sizeof(rs), rs.data_len, cec_command->cmd_data_out, &csum); /* Verify checksum */ if (csum) { printk(BIOS_ERR, "EC response has invalid checksum\n"); return -1; } return 0; }
static int google_chromeec_command_v1(struct chromeec_command *cec_command) { struct ec_lpc_host_args args; u8 cmd_code = cec_command->cmd_code; u8 csum; /* Fill in args */ args.flags = EC_HOST_ARGS_FLAG_FROM_HOST; args.command_version = cec_command->cmd_version; args.data_size = cec_command->cmd_size_in; /* Initialize checksum */ csum = cmd_code + args.flags + args.command_version + args.data_size; write_bytes(EC_LPC_ADDR_HOST_PARAM, cec_command->cmd_size_in, (u8*)cec_command->cmd_data_in, &csum); /* Finalize checksum and write args */ args.checksum = csum; write_bytes(EC_LPC_ADDR_HOST_ARGS, sizeof(args), (u8*)&args, NULL); /* Issue the command */ write_byte(cmd_code, EC_LPC_ADDR_HOST_CMD); if (google_chromeec_wait_ready(EC_LPC_ADDR_HOST_CMD)) { printk(BIOS_ERR, "Timeout waiting for EC process command %d!\n", cec_command->cmd_code); return 1; } /* Check result */ cec_command->cmd_code = read_byte(EC_LPC_ADDR_HOST_DATA); if (cec_command->cmd_code) return 1; /* Read back args */ read_bytes(EC_LPC_ADDR_HOST_ARGS, sizeof(args), (u8*)&args, NULL); /* * If EC didn't modify args flags, then somehow we sent a new-style * command to an old EC, which means it would have read its params * from the wrong place. */ if (!(args.flags & EC_HOST_ARGS_FLAG_TO_HOST)) { printk(BIOS_ERR, "EC protocol mismatch\n"); return 1; } if (args.data_size > cec_command->cmd_size_out) { printk(BIOS_ERR, "EC returned too much data\n"); return 1; } cec_command->cmd_size_out = args.data_size; /* Start calculating response checksum */ csum = cmd_code + args.flags + args.command_version + args.data_size; /* Read data, if any */ read_bytes(EC_LPC_ADDR_HOST_PARAM, args.data_size, cec_command->cmd_data_out, &csum); /* Verify checksum */ if (args.checksum != csum) { printk(BIOS_ERR, "EC response has invalid checksum\n"); return 1; } return 0; }
int load_game(char* s) { int i, ver, vt_entries = MAX_VIEWTABLE; UINT8 t; SINT16 parm[7]; char sig[8]; char id[8]; char description[256]; FILE *f = fopen(s, "rb"); if(!f) return err_BadFileOpen; read_bytes(f, sig, 8); if (strncmp (sig, strSig, 8)) { fclose(f); return err_BadFileOpen; } read_string (f, description); ver = read_uint8(f); if (ver == 0) vt_entries = 64; game.state = read_uint8(f); /* game.name - not saved */ read_string(f, id); if(strcmp(id, game.id)) { fclose(f); return err_BadFileOpen; } /* game.crc - not saved */ for (i = 0; i < MAX_FLAGS; i++) game.flags[i] = read_uint8(f); for (i = 0; i < MAX_VARS; i++) game.vars[i] = read_uint8(f); game.horizon = read_sint16(f); game.line_status = read_sint16(f); game.line_user_input = read_sint16(f); game.line_min_print = read_sint16(f); /* These are never saved */ game.cursor_pos = 0; game.input_buffer[0] = 0; game.echo_buffer[0] = 0; game.keypress = 0; game.input_mode = read_sint16(f); game.lognum = read_sint16(f); game.player_control = read_sint16(f); game.quit_prog_now = read_sint16(f); game.status_line = read_sint16(f); game.clock_enabled = read_sint16(f); game.exit_all_logics = read_sint16(f); game.picture_shown = read_sint16(f); game.has_prompt = read_sint16(f); game.game_flags = read_sint16(f); game.input_enabled = !read_sint16(f); for (i = 0; i < _HEIGHT; i++) game.pri_table[i] = read_uint8(f); if(game.has_window) close_window(); game.msg_box_ticks = 0; game.block.active = FALSE; /* game.window - fixed by close_window() */ /* game.has_window - fixed by close_window() */ game.gfx_mode = read_sint16(f); game.cursor_char = read_uint8(f); game.color_fg = read_sint16(f); game.color_bg = read_sint16(f); /* game.hires (#ifdef USE_HIRES) - rebuilt from image stack */ /* game.sbuf - rebuilt from image stack */ /* game.ego_words - fixed by clean_input */ /* game.num_ego_words - fixed by clean_input */ game.num_objects = read_sint16(f); for(i = 0; i < (SINT16)game.num_objects; i++) object_set_location(i, read_sint16(f)); /* Those are not serialized */ for (i = 0; i < MAX_DIRS; i++) { game.ev_keyp[i].occured = FALSE; } for (i = 0; i < MAX_STRINGS; i++) read_string (f, game.strings[i]); for (i = 0; i < MAX_DIRS; i++) { if(read_uint8(f) & RES_LOADED) agi_load_resource (rLOGIC, i); else agi_unload_resource (rLOGIC, i); game.logics[i].sIP = read_sint16(f); game.logics[i].cIP = read_sint16(f); } for (i = 0; i < MAX_DIRS; i++) { if(read_uint8(f) & RES_LOADED) agi_load_resource(rPICTURE, i); else agi_unload_resource(rPICTURE, i); } for (i = 0; i < MAX_DIRS; i++) { if(read_uint8(f) & RES_LOADED) agi_load_resource(rVIEW, i); else agi_unload_resource(rVIEW, i); } for(i = 0; i < MAX_DIRS; i++) { if(read_uint8(f) & RES_LOADED) agi_load_resource(rSOUND, i); else agi_unload_resource(rSOUND, i); } /* game.pictures - loaded above */ /* game.logics - loaded above */ /* game.views - loaded above */ /* game.sounds - loaded above */ for (i = 0; i < vt_entries; i++) { struct vt_entry* v = &game.view_table[i]; v->step_time = read_uint8(f); v->step_time_count = read_uint8(f); v->entry = read_uint8(f); v->x_pos = read_sint16(f); v->y_pos = read_sint16(f); v->current_view = read_uint8(f); /* v->view_data - fixed below */ v->current_loop = read_uint8(f); v->num_loops = read_uint8(f); /* v->loop_data - fixed below */ v->current_cel = read_uint8(f); v->num_cels = read_uint8(f); /* v->cel_data - fixed below */ /* v->cel_data_2 - fixed below */ v->x_pos2 = read_sint16(f); v->y_pos2 = read_sint16(f); /* v->s - fixed below */ v->x_size = read_sint16(f); v->y_size = read_sint16(f); v->step_size = read_uint8(f); v->cycle_time = read_uint8(f); v->cycle_time_count = read_uint8(f); v->direction = read_uint8(f); v->motion = read_uint8(f); v->cycle = read_uint8(f); v->priority = read_uint8(f); v->flags = read_uint16(f); v->parm1 = read_uint8(f); v->parm2 = read_uint8(f); v->parm3 = read_uint8(f); v->parm4 = read_uint8(f); } for (i = vt_entries; i < MAX_VIEWTABLE; i++) { memset (&game.view_table[i], 0, sizeof (struct vt_entry)); } /* Fix some pointers in viewtable */ for (i = 0; i < MAX_VIEWTABLE; i++) { struct vt_entry* v = &game.view_table[i]; if(game.dir_view[v->current_view].offset == _EMPTY) continue; if(!(game.dir_view[v->current_view].flags & RES_LOADED)) agi_load_resource(rVIEW, v->current_view); set_view(v, v->current_view); /* Fix v->view_data */ set_loop(v, v->current_loop); /* Fix v->loop_data */ set_cel(v, v->current_cel); /* Fix v->cel_data */ v->cel_data_2 = v->cel_data; v->s = NULL; /* not sure if it is used... */ } erase_both(); /* Clear input line */ clear_screen(0); write_status(); /* Recreate background from saved image stack */ clear_image_stack(); while ((t = read_uint8(f)) != 0) { for (i = 0; i < 7; i++) parm[i] = read_sint16(f); replay_image_stack_call (t, parm[0], parm[1], parm[2], parm[3], parm[4], parm[5], parm[6]); } fclose(f); setflag(F_restore_just_ran, TRUE); game.has_prompt = 0; /* force input line repaint if necessary*/ clean_input(); erase_both(); blit_both(); commit_both(); show_pic(); do_update(); return err_OK; }
int read_page() { int sum = 0; int bytes_read = 0; char record_command = read_bytes(1, &bytes_read, &sum); // Always 0x89 if ((0xff & record_command) == 0x89) { // 1. page # data int page_number = read_bytes(2, &bytes_read, &sum); // Page # int data_number = read_bytes(1, &bytes_read, &sum); // # of data in page if (page_number == 1 || (page_number == 64010 and secs == 0.0)) { // 2. Training Summary data (60 bytes)"; read_bytes(39, &bytes_read, &sum); int record_training_flag = read_bytes(1, &bytes_read, &sum); // Training Flag if ((record_training_flag & 0x01) == 0) { // Only new lap rideFile->addInterval(last_interval_secs, secs, QString("%1").arg(interval)); last_interval_secs = secs; interval ++; } read_bytes(20, &bytes_read, &sum); // Don't care } if (page_number == 1 || (page_number == 64010 and secs == 0.0)) { // Section Start time and date data (12 byte) int sec = read_bsd_byte(&bytes_read, &sum); // Section start time sec int min = read_bsd_byte(&bytes_read, &sum); // Section start time min int hour = read_bsd_byte(&bytes_read, &sum); // Section start time hour int day = read_bsd_byte(&bytes_read, &sum); // Section start time day int month = read_bytes(1, &bytes_read, &sum); // Section start time month int year = read_bsd_byte(&bytes_read, &sum); // Section start time year QDateTime t = QDateTime(QDate(2000+year,month,day), QTime(hour,min,sec)); if (secs == 0.0 || rideFile->startTime().toTime_t()<0) { rideFile->setStartTime(t); } else { int gap = (t.toTime_t() - rideFile->startTime().toTime_t()) - secs; secs += gap; } read_bytes(5, &bytes_read, &sum); // Don't care read_bytes(1, &bytes_read, &sum); // Data Flag data_number--; } for (int i = 0; i < data_number; ++i) { read_graph_data(&secs, &bytes_read, &sum); } int finish = 259-bytes_read; for (int i = 0; i < finish; i++) { read_bytes(1, &bytes_read, &sum); // to finish } read_bytes(1, &bytes_read, &sum); // Checksum } return bytes_read; }
static int select_slot (char *path) { int i, key, active = 0; int rc = -1; int hm = 2, vm = 3; /* box margins */ char desc[NUM_SLOTS][40]; for (i = 0; i < NUM_SLOTS; i++) { char name[MAX_PATH]; FILE *f; char sig[8]; sprintf (name, "%s/%08d.sav", path, i); f = fopen (name, "rb"); if (f == NULL) { strcpy (desc[i], " (empty slot)"); } else { read_bytes (f, sig, 8); if (strncmp (sig, strSig, 8)) { strcpy (desc[i], "(corrupt file)"); } else { read_string (f, desc[i]); } fclose(f); } } while (42) { char dstr[64]; for (i = 0; i < NUM_SLOTS; i++) { sprintf (dstr, "[%-32.32s]", desc[i]); print_text (dstr, 0, hm + 1, vm + 4 + i, (40 - 2 * hm) - 1, i == active ? MSG_BOX_COLOUR : MSG_BOX_TEXT, i == active ? MSG_BOX_TEXT : MSG_BOX_COLOUR); } poll_timer (); /* msdos driver -> does nothing */ key = do_poll_keyboard (); if (!console_keyhandler (key)) { switch (key) { case KEY_ENTER: rc = active; strncpy (game.strings[MAX_STRINGS], desc[i], MAX_STRINGLEN); goto press; case KEY_ESCAPE: rc = -1; goto getout; #ifdef USE_MOUSE case BUTTON_LEFT: break; #endif case KEY_DOWN: active++; active %= NUM_SLOTS; break; case KEY_UP: active--; if (active < 0) active = NUM_SLOTS - 1; break; } } console_cycle (); } press: _D (_D_WARN "Button pressed: %d", rc); getout: close_window(); return rc; }
unsigned char *read_den(char *filename,int *xptr,int *yptr,int *zptr) { FILE *fd; /* file descriptor */ unsigned char *data; /* data array */ int swapbytes; /* true if header must be byte-swapped */ short map_version; /* Version of this .den file */ short orig_min[3]; /* Dimensions of original data file */ short orig_max[3]; short orig_len[3]; short extr_min[3]; /* Extracted portion of original file */ short extr_max[3]; /* (mins and maxes will be subset of */ short extr_len[3]; /* orig and lengths will be <= orig) */ short map_min[3]; /* Dimensions of this map */ short map_max[3]; /* (mins will be 0 in this program and */ short map_len[3]; /* lens may be != extr if warps > 0) */ short map_warps; /* Number of warps since extraction */ /* (0 = none) */ int map_length; /* Total number of densities in map */ /* (= product of lens) */ /* open the file */ if ((fd = fopen(filename, "rb")) == NULL) { fprintf(stderr, "cannot open file %s\n", filename); return(NULL); } /* read the magic number */ if (!read_shorts(fd, &map_version, 1, 0)) { fprintf(stderr, "read failed on file %s (empty file?)\n", filename); return(NULL); } if (map_version == MAP_CUR_VERSION) { swapbytes = 0; } else if (map_version == MAP_CUR_VERSION_SWAB) { swapbytes = 1; } else { fprintf(stderr, "file %s is not a density file\n", filename); return(NULL); } /* read the volume size information */ if (!read_shorts(fd, orig_min, 3, swapbytes) || !read_shorts(fd, orig_max, 3, swapbytes) || !read_shorts(fd, orig_len, 3, swapbytes) || !read_shorts(fd, extr_min, 3, swapbytes) || !read_shorts(fd, extr_max, 3, swapbytes) || !read_shorts(fd, extr_len, 3, swapbytes) || !read_shorts(fd, map_min, 3, swapbytes) || !read_shorts(fd, map_max, 3, swapbytes) || !read_shorts(fd, map_len, 3, swapbytes) || !read_shorts(fd, &map_warps, 1, swapbytes) || !read_words(fd, &map_length, 1, swapbytes)) { fprintf(stderr, "read failed on file %s (truncated file?)\n",filename); return(NULL); } if (map_length != map_len[0]*map_len[1]*map_len[2]) { fprintf(stderr, "density file %s has an inconsistent header\n", filename); return(NULL); } /* allocate array for data */ data = (unsigned char *)malloc(map_length); if (data == NULL) { fprintf(stderr, "out of memory\n"); return(NULL); } /* copy the data from the file */ if (!read_bytes(fd, (char *)data, map_length)) { fprintf(stderr, "read failed on file %s\n", filename); fclose(fd); free(data); return(NULL); } /* finish up */ fclose(fd); *xptr = map_len[0]; *yptr = map_len[1]; *zptr = map_len[2]; return(data); }
static bool read_s8(struct dwbuf *d, int8_t *v) { return (read_bytes(d, v, sizeof(*v))); }
static bool file_reader(cmp_ctx_t *ctx, void *data, size_t limit) { return read_bytes(data, limit, (FILE *) ctx->buf); }
static bool read_u64(struct dwbuf *d, uint64_t *v) { return (read_bytes(d, v, sizeof(*v))); }
int read_fragment_table_3() { int res, i, indexes = SQUASHFS_FRAGMENT_INDEXES_3(sBlk.fragments); squashfs_fragment_index fragment_table_index[indexes]; TRACE("read_fragment_table: %d fragments, reading %d fragment indexes " "from 0x%llx\n", sBlk.fragments, indexes, sBlk.fragment_table_start); if(sBlk.fragments == 0) return -1; if((fragment_table = malloc(sBlk.fragments * sizeof(squashfs_fragment_entry_3))) == NULL) EXIT_UNSQUASH("read_fragment_table: failed to allocate " "fragment table\n"); if(swap) { squashfs_fragment_index sfragment_table_index[indexes]; res = read_bytes(sBlk.fragment_table_start, SQUASHFS_FRAGMENT_INDEX_BYTES_3(sBlk.fragments), (char *) sfragment_table_index); if(res == FALSE) { ERROR("read_fragment_table: failed to read fragment " "table index\n"); return FALSE; } SQUASHFS_SWAP_FRAGMENT_INDEXES_3(fragment_table_index, sfragment_table_index, indexes); } else { res = read_bytes(sBlk.fragment_table_start, SQUASHFS_FRAGMENT_INDEX_BYTES_3(sBlk.fragments), (char *) fragment_table_index); if(res == FALSE) { ERROR("read_fragment_table: failed to read fragment " "table index\n"); return FALSE; } } for(i = 0; i < indexes; i++) { int length = read_block(fragment_table_index[i], NULL, ((char *) fragment_table) + (i * SQUASHFS_METADATA_SIZE)); TRACE("Read fragment table block %d, from 0x%llx, length %d\n", i, fragment_table_index[i], length); if(length == FALSE) { ERROR("read_fragment_table: failed to read fragment " "table block\n"); return FALSE; } } if(swap) { squashfs_fragment_entry_3 sfragment; for(i = 0; i < sBlk.fragments; i++) { SQUASHFS_SWAP_FRAGMENT_ENTRY_3((&sfragment), (&fragment_table[i])); memcpy((char *) &fragment_table[i], (char *) &sfragment, sizeof(squashfs_fragment_entry_3)); } } return TRUE; }
/* * Check whether this is a pcap-ng savefile and, if it is, extract the * relevant information from the header. */ int pcap_ng_check_header(pcap_t *p, bpf_u_int32 magic, FILE *fp, char *errbuf, int isng) { size_t amt_read; bpf_u_int32 total_length; bpf_u_int32 byte_order_magic; struct pcapng_block_header *bhdrp; struct pcapng_section_header_fields *shbp; int status; struct block_cursor cursor; struct pcapng_interface_description_fields *idbp; long file_offset = ftell(fp); /* * Check whether the first 4 bytes of the file are the block * type for a pcap-ng savefile. */ if (magic != PCAPNG_BT_SHB) { /* * XXX - check whether this looks like what the block * type would be after being munged by mapping between * UN*X and DOS/Windows text file format and, if it * does, look for the byte-order magic number in * the appropriate place and, if we find it, report * this as possibly being a pcap-ng file transferred * between UN*X and Windows in text file format? */ return (0); /* nope */ } /* * OK, they are. However, that's just \n\r\r\n, so it could, * conceivably, be an ordinary text file. * * It could not, however, conceivably be any other type of * capture file, so we can read the rest of the putative * Section Header Block; put the block type in the common * header, read the rest of the common header and the * fixed-length portion of the SHB, and look for the byte-order * magic value. */ amt_read = fread(&total_length, 1, sizeof(total_length), fp); if (amt_read < sizeof(total_length)) { if (ferror(fp)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "error reading dump file: %s", pcap_strerror(errno)); return (-1); /* fail */ } /* * Possibly a weird short text file, so just say * "not pcap-ng". */ return (0); } amt_read = fread(&byte_order_magic, 1, sizeof(byte_order_magic), fp); if (amt_read < sizeof(byte_order_magic)) { if (ferror(fp)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "error reading dump file: %s", pcap_strerror(errno)); return (-1); /* fail */ } /* * Possibly a weird short text file, so just say * "not pcap-ng". */ return (0); } if (byte_order_magic != PCAPNG_BYTE_ORDER_MAGIC) { byte_order_magic = SWAPLONG(byte_order_magic); if (byte_order_magic != PCAPNG_BYTE_ORDER_MAGIC) { /* * Not a pcap-ng file. */ return (0); } p->sf.swapped = 1; total_length = SWAPLONG(total_length); } /* * Check the sanity of the total length. */ if (total_length < sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct pcapng_block_trailer)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "Section Header Block in pcap-ng dump file has a length of %u < %lu", total_length, (unsigned long)(sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct pcapng_block_trailer))); return (-1); } /* * Allocate a buffer into which to read blocks. We default to * the maximum of: * * the total length of the SHB for which we read the header; * * 2K, which should be more than large enough for an Enhanced * Packet Block containing a full-size Ethernet frame, and * leaving room for some options. * * If we find a bigger block, we reallocate the buffer. */ p->bufsize = 2048; if (p->bufsize < total_length) p->bufsize = total_length; p->buffer = malloc(p->bufsize); if (p->buffer == NULL) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory"); return (-1); } /* * Copy the stuff we've read to the buffer, and read the rest * of the SHB. */ bhdrp = (struct pcapng_block_header *)p->buffer; shbp = (struct pcapng_section_header_fields *)(p->buffer + sizeof(struct pcapng_block_header)); bhdrp->block_type = magic; bhdrp->total_length = total_length; shbp->byte_order_magic = byte_order_magic; if (read_bytes(fp, p->buffer + (sizeof(magic) + sizeof(total_length) + sizeof(byte_order_magic)), total_length - (sizeof(magic) + sizeof(total_length) + sizeof(byte_order_magic)), 1, errbuf) == -1) goto fail; if (p->sf.swapped) { /* * Byte-swap the fields we've read. */ shbp->major_version = SWAPSHORT(shbp->major_version); shbp->minor_version = SWAPSHORT(shbp->minor_version); /* * XXX - we don't care about the section length. */ } if (shbp->major_version != PCAPNG_VERSION_MAJOR) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown pcap-ng savefile major version number %u", shbp->major_version); goto fail; } p->sf.version_major = shbp->major_version; p->sf.version_minor = shbp->minor_version; /* * Set the default time stamp resolution and offset. */ p->sf.tsresol = 1000000; /* microsecond resolution */ p->sf.tsscale = 1; /* multiply by 1 to scale to microseconds */ p->sf.tsoffset = 0; /* absolute timestamps */ /* * Now start looking for an Interface Description Block. */ for (;;) { /* * Read the next block. */ status = read_block(fp, p, &cursor, errbuf); if (status == 0) { /* EOF - no IDB in this file */ snprintf(errbuf, PCAP_ERRBUF_SIZE, "the capture file has no Interface Description Blocks"); goto fail; } if (status == -1) goto fail; /* error */ switch (cursor.block_type) { case PCAPNG_BT_IDB: /* * Get a pointer to the fixed-length portion of the * IDB. */ idbp = get_from_block_data(&cursor, sizeof(*idbp), errbuf); if (idbp == NULL) goto fail; /* error */ /* * Byte-swap it if necessary. */ if (p->sf.swapped) { idbp->linktype = SWAPSHORT(idbp->linktype); idbp->snaplen = SWAPLONG(idbp->snaplen); } /* * Now look for various time stamp options, so * we know how to interpret the time stamps. */ if (process_idb_options(p, idbp, &cursor, &p->sf.tsresol, &p->sf.tsoffset, errbuf) == -1) goto fail; /* * Compute the scaling factor to convert the * sub-second part of the time stamp to * microseconds. */ if (p->sf.tsresol > 1000000) { /* * Higher than microsecond resolution; * scale down to microseconds. */ p->sf.tsscale = (p->sf.tsresol / 1000000); } else { /* * Lower than microsecond resolution; * scale up to microseconds. */ p->sf.tsscale = (1000000 / p->sf.tsresol); } p->tzoff = 0; /* XXX - not used in pcap */ p->snapshot = idbp->snaplen; p->linktype = linktype_to_dlt(idbp->linktype); p->linktype_ext = 0; goto done; case PCAPNG_BT_EPB: case PCAPNG_BT_SPB: case PCAPNG_BT_PB: /* * Saw a packet before we saw any IDBs. That's * not valid, as we don't know what link-layer * encapsulation the packet has. */ snprintf(errbuf, PCAP_ERRBUF_SIZE, "the capture file has a packet block before any Interface Description Blocks"); goto fail; default: /* * Just ignore it. */ break; } } done: p->sf.next_packet_op = isng ? pcap_ng_next_block : pcap_ng_next_packet; /* * Special using block based API */ if (isng) { /* * Rewind to begining of Section Header Block */ if (file_offset < 4) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "bad file offset"); goto fail; } file_offset -= 4; fseek(fp, file_offset, SEEK_SET); p->linktype = DLT_PCAPNG; } return (1); fail: free(p->buffer); return (-1); }
dsk_err_t w32serial_call(DSK_PDRIVER pDriver, unsigned char *input, int inp_len, unsigned char *output, int *out_len) { word16 wire_len; word16 crc; byte var; byte wvar[2]; int n; dsk_err_t err; unsigned char *tmpbuf; W32SERIAL_REMOTE_DATA *self = (W32SERIAL_REMOTE_DATA *)pDriver->dr_remote; if (!self || self->super.rd_class != &rpc_w32serial) return DSK_ERR_BADPTR; /* CRC tbe input... */ wire_len = inp_len; CRC_Clear(); for (n = 0; n < inp_len; n++) CRC_Update(input[n]); crc = CRC_Done(); /* printf("rpc_w32serial: Input packet: "); for (n = 0; n < inp_len; n++) printf("%02x ", input[n]); printf("\n"); */ while (1) { /* Write SOH (start of request) */ err = wrbyte(self, SOH); if (err) return err; /* Write packet length (network byte order) */ wvar[0] = wire_len >> 8; wvar[1] = wire_len & 0xFF; err = write_bytes(self, 2, wvar); if (err) return err; err = write_bytes(self, inp_len, input); if (err) return err; wvar[0] = crc >> 8; wvar[1] = crc & 0xFF; err = write_bytes(self, 2, wvar); if (err) return err; /* err = read_bytes(self, 1, &var); if (err) return err; */ /* Wait 'til we get an ACK or a NAK. */ do { err = read_bytes(self, 1, &var); if (err) return err; } while(var != ACK && var != NAK); if (var == ACK) break; if (var == NAK) continue; } /* Outgoing packet sent. Await response */ while (1) { /* First byte of response must be STX. */ err = read_bytes(self, 1, &var); if (err) return err; if (var != STX) continue; err = read_bytes(self, 2, wvar); if (err) return err; wire_len = wvar[0]; wire_len = (wire_len << 8) | wvar[1]; tmpbuf = dsk_malloc(wire_len + 2); if (!tmpbuf) return DSK_ERR_NOMEM; CRC_Clear(); err = read_bytes(self, wire_len + 2, tmpbuf); if (err) { dsk_free(tmpbuf); return err; } for (n = 0; n < wire_len; n++) { CRC_Update(tmpbuf[n]); } crc = tmpbuf[wire_len]; crc = (crc << 8) | tmpbuf[wire_len + 1]; /* If CRC matches, send ACK and return. Else send NAK. */ if (crc == CRC_Done()) { /* printf("rpc_w32serial: Result packet: "); for (n = 0; n < wire_len; n++) printf("%02x ", tmpbuf[n]); printf("\n"); */ err = wrbyte(self, ACK); if (err) { dsk_free(tmpbuf); return err; } /* Copy packet to waiting output buffer */ if (wire_len < *out_len) *out_len = wire_len; memcpy(output, tmpbuf, *out_len); dsk_free(tmpbuf); return DSK_ERR_OK; } /* Packet was garbled. NAK it and try again. */ dsk_free(tmpbuf); err = wrbyte(self, NAK); if (err) return err; } /* Should never happen */ return DSK_ERR_NOTIMPL; }
int read_super(int fd, squashfs_super_block *sBlk, int *be, char *source) { squashfs_super_block sblk; read_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block), (char *) sBlk); /* Check it is a SQUASHFS superblock */ swap = 0; switch (sBlk->s_magic) { case SQUASHFS_MAGIC_LZMA: if (!lzma) goto bad; break; case SQUASHFS_MAGIC: break; case SQUASHFS_MAGIC_SWAP: case SQUASHFS_MAGIC_LZMA_SWAP: ERROR("Reading a different endian SQUASHFS filesystem on %s - ignoring -le/-be options\n", source); SQUASHFS_SWAP_SUPER_BLOCK(&sblk, sBlk); memcpy(sBlk, &sblk, sizeof(squashfs_super_block)); swap = 1; break; bad: default: ERROR("Can't find a SQUASHFS superblock on %s\n", source); goto failed_mount; } /* Check the MAJOR & MINOR versions */ if(sBlk->s_major != SQUASHFS_MAJOR || sBlk->s_minor > SQUASHFS_MINOR) { if(sBlk->s_major < 3) ERROR("Filesystem on %s is a SQUASHFS %d.%d filesystem. Appending\nto SQUASHFS %d.%d filesystems is not supported. Please convert it to a SQUASHFS 3.0 filesystem\n", source, sBlk->s_major, sBlk->s_minor, sBlk->s_major, sBlk->s_minor); else ERROR("Major/Minor mismatch, filesystem on %s is %d.%d, I support 3.0\n", source, sBlk->s_major, sBlk->s_minor); goto failed_mount; } #if __BYTE_ORDER == __BIG_ENDIAN *be = !swap; #else *be = swap; #endif printf("Found a valid %s%s SQUASHFS superblock on %s.\n", SQUASHFS_EXPORTABLE(sBlk->flags) ? "exportable " : "", *be ? "big endian" : "little endian", source); printf("\tInodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : ""); printf("\tData is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(sBlk->flags) ? "un" : ""); printf("\tFragments are %scompressed\n", SQUASHFS_UNCOMPRESSED_FRAGMENTS(sBlk->flags) ? "un" : ""); printf("\tCheck data is %spresent in the filesystem\n", SQUASHFS_CHECK_DATA(sBlk->flags) ? "" : "not "); printf("\tFragments are %spresent in the filesystem\n", SQUASHFS_NO_FRAGMENTS(sBlk->flags) ? "not " : ""); printf("\tAlways_use_fragments option is %sspecified\n", SQUASHFS_ALWAYS_FRAGMENTS(sBlk->flags) ? "" : "not "); printf("\tDuplicates are %sremoved\n", SQUASHFS_DUPLICATES(sBlk->flags) ? "" : "not "); printf("\tFilesystem size %.2f Kbytes (%.2f Mbytes)\n", sBlk->bytes_used / 1024.0, sBlk->bytes_used / (1024.0 * 1024.0)); printf("\tBlock size %d\n", sBlk->block_size); printf("\tNumber of fragments %d\n", sBlk->fragments); printf("\tNumber of inodes %d\n", sBlk->inodes); printf("\tNumber of uids %d\n", sBlk->no_uids); printf("\tNumber of gids %d\n", sBlk->no_guids); TRACE("sBlk->inode_table_start %llx\n", sBlk->inode_table_start); TRACE("sBlk->directory_table_start %llx\n", sBlk->directory_table_start); TRACE("sBlk->uid_start %llx\n", sBlk->uid_start); TRACE("sBlk->fragment_table_start %llx\n", sBlk->fragment_table_start); TRACE("sBlk->lookup_table_start %xllx\n", sBlk->lookup_table_start); printf("\n"); return TRUE; failed_mount: return FALSE; }
/* * Check whether this is a pcap-ng savefile and, if it is, extract the * relevant information from the header. */ pcap_t * pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf, int *err) { size_t amt_read; bpf_u_int32 total_length; bpf_u_int32 byte_order_magic; struct block_header *bhdrp; struct section_header_block *shbp; pcap_t *p; int swapped = 0; struct pcap_ng_sf *ps; int status; struct block_cursor cursor; struct interface_description_block *idbp; /* * Assume no read errors. */ *err = 0; /* * Check whether the first 4 bytes of the file are the block * type for a pcap-ng savefile. */ if (magic != BT_SHB) { /* * XXX - check whether this looks like what the block * type would be after being munged by mapping between * UN*X and DOS/Windows text file format and, if it * does, look for the byte-order magic number in * the appropriate place and, if we find it, report * this as possibly being a pcap-ng file transferred * between UN*X and Windows in text file format? */ return (NULL); /* nope */ } /* * OK, they are. However, that's just \n\r\r\n, so it could, * conceivably, be an ordinary text file. * * It could not, however, conceivably be any other type of * capture file, so we can read the rest of the putative * Section Header Block; put the block type in the common * header, read the rest of the common header and the * fixed-length portion of the SHB, and look for the byte-order * magic value. */ amt_read = fread(&total_length, 1, sizeof(total_length), fp); if (amt_read < sizeof(total_length)) { if (ferror(fp)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "error reading dump file: %s", pcap_strerror(errno)); *err = 1; return (NULL); /* fail */ } /* * Possibly a weird short text file, so just say * "not pcap-ng". */ return (NULL); } amt_read = fread(&byte_order_magic, 1, sizeof(byte_order_magic), fp); if (amt_read < sizeof(byte_order_magic)) { if (ferror(fp)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "error reading dump file: %s", pcap_strerror(errno)); *err = 1; return (NULL); /* fail */ } /* * Possibly a weird short text file, so just say * "not pcap-ng". */ return (NULL); } if (byte_order_magic != BYTE_ORDER_MAGIC) { byte_order_magic = SWAPLONG(byte_order_magic); if (byte_order_magic != BYTE_ORDER_MAGIC) { /* * Not a pcap-ng file. */ return (NULL); } swapped = 1; total_length = SWAPLONG(total_length); } /* * Check the sanity of the total length. */ if (total_length < sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct block_trailer)) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "Section Header Block in pcap-ng dump file has a length of %u < %lu", total_length, (unsigned long)(sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct block_trailer))); *err = 1; return (NULL); } /* * OK, this is a good pcap-ng file. * Allocate a pcap_t for it. */ p = pcap_open_offline_common(errbuf, sizeof (struct pcap_ng_sf)); if (p == NULL) { /* Allocation failed. */ *err = 1; return (NULL); } p->swapped = swapped; ps = p->priv; /* * What precision does the user want? */ switch (precision) { case PCAP_TSTAMP_PRECISION_MICRO: ps->user_tsresol = 1000000; break; case PCAP_TSTAMP_PRECISION_NANO: ps->user_tsresol = 1000000000; break; default: snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown time stamp resolution %u", precision); free(p); *err = 1; return (NULL); } p->opt.tstamp_precision = precision; /* * Allocate a buffer into which to read blocks. We default to * the maximum of: * * the total length of the SHB for which we read the header; * * 2K, which should be more than large enough for an Enhanced * Packet Block containing a full-size Ethernet frame, and * leaving room for some options. * * If we find a bigger block, we reallocate the buffer. */ p->bufsize = 2048; if (p->bufsize < (int)total_length) p->bufsize = total_length; p->buffer = malloc(p->bufsize); if (p->buffer == NULL) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory"); free(p); *err = 1; return (NULL); } /* * Copy the stuff we've read to the buffer, and read the rest * of the SHB. */ bhdrp = (struct block_header *)(void *)p->buffer; shbp = (struct section_header_block *)(void *)(p->buffer + sizeof(struct block_header)); bhdrp->block_type = magic; bhdrp->total_length = total_length; shbp->byte_order_magic = byte_order_magic; if (read_bytes(fp, p->buffer + (sizeof(magic) + sizeof(total_length) + sizeof(byte_order_magic)), total_length - (sizeof(magic) + sizeof(total_length) + sizeof(byte_order_magic)), 1, errbuf) == -1) goto fail; if (p->swapped) { /* * Byte-swap the fields we've read. */ shbp->major_version = SWAPSHORT((uint32_t)shbp->major_version); shbp->minor_version = SWAPSHORT((uint32_t)shbp->minor_version); /* * XXX - we don't care about the section length. */ } if (shbp->major_version != PCAP_NG_VERSION_MAJOR) { snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown pcap-ng savefile major version number %u", shbp->major_version); goto fail; } p->version_major = shbp->major_version; p->version_minor = shbp->minor_version; /* * Save the time stamp resolution the user requested. */ p->opt.tstamp_precision = precision; /* * Now start looking for an Interface Description Block. */ for (;;) { /* * Read the next block. */ status = read_block(fp, p, &cursor, errbuf); if (status == 0) { /* EOF - no IDB in this file */ snprintf(errbuf, PCAP_ERRBUF_SIZE, "the capture file has no Interface Description Blocks"); goto fail; } if (status == -1) goto fail; /* error */ switch (cursor.block_type) { case BT_IDB: /* * Get a pointer to the fixed-length portion of the * IDB. */ idbp = get_from_block_data(&cursor, sizeof(*idbp), errbuf); if (idbp == NULL) goto fail; /* error */ /* * Byte-swap it if necessary. */ if (p->swapped) { idbp->linktype = SWAPSHORT((uint16_t)idbp->linktype); idbp->snaplen = SWAPLONG(idbp->snaplen); } /* * Try to add this interface. */ if (!add_interface(p, &cursor, errbuf)) goto fail; goto done; case BT_EPB: case BT_SPB: case BT_PB: /* * Saw a packet before we saw any IDBs. That's * not valid, as we don't know what link-layer * encapsulation the packet has. */ snprintf(errbuf, PCAP_ERRBUF_SIZE, "the capture file has a packet block before any Interface Description Blocks"); goto fail; default: /* * Just ignore it. */ break; } } done: p->tzoff = 0; /* XXX - not used in pcap */ p->snapshot = idbp->snaplen; p->linktype = linktype_to_dlt(idbp->linktype); p->linktype_ext = 0; p->next_packet_op = pcap_ng_next_packet; p->cleanup_op = pcap_ng_cleanup; return (p); fail: free(ps->ifaces); free(p->buffer); free(p); *err = 1; return (NULL); }
long long read_filesystem(char *root_name, int fd, squashfs_super_block *sBlk, char **cinode_table, char **data_cache, char **cdirectory_table, char **directory_data_cache, unsigned int *last_directory_block, unsigned int *inode_dir_offset, unsigned int *inode_dir_file_size, unsigned int *root_inode_size, unsigned int *inode_dir_start_block, int *file_count, int *sym_count, int *dev_count, int *dir_count, int *fifo_count, int *sock_count, squashfs_uid *uids, unsigned short *uid_count, squashfs_uid *guids, unsigned short *guid_count, long long *uncompressed_file, unsigned int *uncompressed_inode, unsigned int *uncompressed_directory, unsigned int *inode_dir_inode_number, unsigned int *inode_dir_parent_inode, void (push_directory_entry)(char *, squashfs_inode, int, int), squashfs_fragment_entry **fragment_table, squashfs_inode **inode_lookup_table) { unsigned char *inode_table = NULL, *directory_table; long long start = sBlk->inode_table_start, end = sBlk->directory_table_start, root_inode_start = start + SQUASHFS_INODE_BLK(sBlk->root_inode); unsigned int root_inode_offset = SQUASHFS_INODE_OFFSET(sBlk->root_inode), root_inode_block, files; squashfs_inode_header inode; printf("Scanning existing filesystem...\n"); if(read_fragment_table(fd, sBlk, fragment_table) == 0) goto error; if(read_inode_lookup_table(fd, sBlk, inode_lookup_table) == 0) goto error; if((files = scan_inode_table(fd, start, end, root_inode_start, root_inode_offset, sBlk, &inode, &inode_table, &root_inode_block, root_inode_size, uncompressed_file, uncompressed_directory, file_count, sym_count, dev_count, dir_count, fifo_count, sock_count)) == 0) { ERROR("read_filesystem: inode table read failed\n"); goto error; } *uncompressed_inode = root_inode_block; printf("Read existing filesystem, %d inodes scanned\n", files); if(inode.base.inode_type == SQUASHFS_DIR_TYPE || inode.base.inode_type == SQUASHFS_LDIR_TYPE) { if(inode.base.inode_type == SQUASHFS_DIR_TYPE) { *inode_dir_start_block = inode.dir.start_block; *inode_dir_offset = inode.dir.offset; *inode_dir_file_size = inode.dir.file_size - 3; *inode_dir_inode_number = inode.dir.inode_number; *inode_dir_parent_inode = inode.dir.parent_inode; } else { *inode_dir_start_block = inode.ldir.start_block; *inode_dir_offset = inode.ldir.offset; *inode_dir_file_size = inode.ldir.file_size - 3; *inode_dir_inode_number = inode.ldir.inode_number; *inode_dir_parent_inode = inode.ldir.parent_inode; } if((directory_table = squashfs_readdir(fd, !root_name, *inode_dir_start_block, *inode_dir_offset, *inode_dir_file_size, last_directory_block, sBlk, push_directory_entry)) == NULL) { ERROR("read_filesystem: Could not read root directory\n"); goto error; } root_inode_start -= start; if((*cinode_table = (char *) malloc(root_inode_start)) == NULL) { ERROR("read_filesystem: failed to alloc space for existing filesystem inode table\n"); goto error; } read_bytes(fd, start, root_inode_start, *cinode_table); if((*cdirectory_table = (char *) malloc(*last_directory_block)) == NULL) { ERROR("read_filesystem: failed to alloc space for existing filesystem directory table\n"); goto error; } read_bytes(fd, sBlk->directory_table_start, *last_directory_block, *cdirectory_table); if((*data_cache = (char *) malloc(root_inode_offset + *root_inode_size)) == NULL) { ERROR("read_filesystem: failed to alloc inode cache\n"); goto error; } memcpy(*data_cache, inode_table + root_inode_block, root_inode_offset + *root_inode_size); if((*directory_data_cache = (char *) malloc(*inode_dir_offset + *inode_dir_file_size)) == NULL) { ERROR("read_filesystem: failed to alloc directory cache\n"); goto error; } memcpy(*directory_data_cache, directory_table, *inode_dir_offset + *inode_dir_file_size); if(!swap) read_bytes(fd, sBlk->uid_start, sBlk->no_uids * sizeof(squashfs_uid), (char *) uids); else { squashfs_uid uids_copy[sBlk->no_uids]; read_bytes(fd, sBlk->uid_start, sBlk->no_uids * sizeof(squashfs_uid), (char *) uids_copy); SQUASHFS_SWAP_DATA(uids, uids_copy, sBlk->no_uids, sizeof(squashfs_uid) * 8); } if(!swap) read_bytes(fd, sBlk->guid_start, sBlk->no_guids * sizeof(squashfs_uid), (char *) guids); else { squashfs_uid guids_copy[sBlk->no_guids]; read_bytes(fd, sBlk->guid_start, sBlk->no_guids * sizeof(squashfs_uid), (char *) guids_copy); SQUASHFS_SWAP_DATA(guids, guids_copy, sBlk->no_guids, sizeof(squashfs_uid) * 8); } *uid_count = sBlk->no_uids; *guid_count = sBlk->no_guids; free(inode_table); free(directory_table); return sBlk->inode_table_start; } error: return 0; }