// Read at most ipc->read.req_n bytes from the current seek position // in ipc->read.req_fileid. Return the bytes read from the file to // the caller in ipc->readRet, then update the seek position. Returns // the number of bytes successfully read, or < 0 on error. int serve_read(envid_t envid, union Fsipc *ipc) { struct Fsreq_read *req = &ipc->read; struct Fsret_read *ret = &ipc->readRet; struct OpenFile *o; int r; if (debug) cprintf("serve_read %08x %08x %08x\n", envid, req->req_fileid, req->req_n); // Look up the file id, read the bytes into 'ret', and update // the seek position. Be careful if req->req_n > PGSIZE // (remember that read is always allowed to return fewer bytes // than requested). Also, be careful because ipc is a union, // so filling in ret will overwrite req. // // Hint: Use file_read. // Hint: The seek position is stored in the struct Fd. // LAB 5: Your code here size_t toReadBytes, numBytesRead; if (ipc->read.req_n > PGSIZE) toReadBytes = PGSIZE; else toReadBytes = req->req_n; if ((r = openfile_lookup(envid, req->req_fileid, &o)) < 0) return r; // cprintf("toReadBytes=%d r=%x ret=%x o->o_fd->fd_offset=%d\n",toReadBytes,r,ret,o->o_fd->fd_offset); numBytesRead = file_read(o->o_file, (void*)ret, toReadBytes, o->o_fd->fd_offset); o->o_fd->fd_offset+=numBytesRead; return numBytesRead; panic("serve_read not implemented"); }
static gboolean commview_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header *pseudo_header, guint8 *pd, int length, int *err, gchar **err_info) { commview_header_t cv_hdr; int bytes_read; if(file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1) return FALSE; if(!commview_read_header(&cv_hdr, wth->random_fh, err, err_info)) { if(*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } if(length != cv_hdr.data_len) { *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("commview: record length %u doesn't match requested length %d", cv_hdr.data_len, length); return FALSE; } commview_set_pseudo_header(&cv_hdr, pseudo_header); bytes_read = file_read(pd, cv_hdr.data_len, wth->random_fh); if(bytes_read != cv_hdr.data_len) { *err = file_error(wth->random_fh, err_info); if(*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } return TRUE; }
static gboolean hcidump_process_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info) { struct dump_hdr dh; int bytes_read, packet_size; bytes_read = file_read(&dh, DUMP_HDR_SIZE, fh); if (bytes_read != DUMP_HDR_SIZE) { *err = file_error(fh, err_info); if (*err == 0 && bytes_read != 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } packet_size = GUINT16_FROM_LE(dh.len); if (packet_size > WTAP_MAX_PACKET_SIZE) { /* * Probably a corrupt capture file; don't blow up trying * to allocate space for an immensely-large packet. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("hcidump: File has %u-byte packet, bigger than maximum of %u", packet_size, WTAP_MAX_PACKET_SIZE); return FALSE; } phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS; phdr->ts.secs = GUINT32_FROM_LE(dh.ts_sec); phdr->ts.nsecs = GUINT32_FROM_LE(dh.ts_usec) * 1000; phdr->caplen = packet_size; phdr->len = packet_size; phdr->pseudo_header.p2p.sent = (dh.in ? FALSE : TRUE); return wtap_read_packet_bytes(fh, buf, packet_size, err, err_info); }
Value *FlashEspUpdateFn(const char *name, State * state, int argc, Expr * argv[]) { Value *ret = NULL; char *filename = NULL; void *data = NULL; size_t size; if (ReadArgs(state, argv, 1, &filename) < 0) { ErrorAbort(state, "ReadArgs() failed"); goto done; } if (filename == NULL || strlen(filename) == 0) { ErrorAbort(state, "filename argument to %s can't be empty", name); goto done; } if (file_read(filename, &data, &size)) { ErrorAbort(state, "file_read %s failed", filename); goto done; } if (flash_esp_update(data, size) != 0) { ErrorAbort(state, "flash_esp_update failed"); goto done; } /* no error */ ret = StringValue(strdup("t")); done: if (filename) free(filename); if (data) free(data); return ret; }
uint32_t load_sram(uint8_t* filename, uint32_t base_addr) { set_mcu_addr(base_addr); UINT bytes_read; DWORD filesize; file_open(filename, FA_READ); filesize = file_handle.fsize; if(file_res) { printf("load_sram: could not open %s, res=%d\n", filename, file_res); return 0; } for(;;) { bytes_read = file_read(); if (file_res || !bytes_read) break; FPGA_SELECT(); FPGA_TX_BYTE(0x98); for(int j=0; j<bytes_read; j++) { FPGA_TX_BYTE(file_buf[j]); FPGA_WAIT_RDY(); } FPGA_DESELECT(); } file_close(); return (uint32_t)filesize; }
int read (int fd, void *buffer, unsigned size) { if (not_valid(buffer) || not_valid(buffer+size) || fd == STDOUT_FILENO) exit (-1); lock_acquire(&file_lock); int count = 0, result = 0; if (fd == STDIN_FILENO) { while (count < size) { *((uint8_t *) (buffer + count)) = input_getc (); count++; } result = size; } else { struct file *file = get_file(fd); result = file ? file_read(file, buffer, size) : -1; } lock_release(&file_lock); return result; }
chd_error chd_file::read_metadata(chd_metadata_tag searchtag, UINT32 searchindex, dynamic_buffer &output, chd_metadata_tag &resulttag, UINT8 &resultflags) { // wrap this for clean reporting try { // if we didn't find it, just return metadata_entry metaentry; if (!metadata_find(searchtag, searchindex, metaentry)) throw CHDERR_METADATA_NOT_FOUND; // read the metadata output.resize(metaentry.length); file_read(metaentry.offset + METADATA_HEADER_SIZE, output, metaentry.length); resulttag = metaentry.metatag; resultflags = metaentry.flags; return CHDERR_NONE; } // just return errors catch (chd_error &err) { return err; } }
/* Read from a file. */ static int sys_read (int fd, void *buffer, unsigned size) { struct user_file *f; int ret = -1; #if PRINT_DEBUG printf ("[SYSCALL] SYS_READ: fd: %d, buffer: %p, size: %u\n", fd, buffer, size); #endif if (fd == STDIN_FILENO) { unsigned i; for (i = 0; i < size; ++i) *(uint8_t *)(buffer + i) = input_getc (); ret = size; } else if (fd == STDOUT_FILENO) ret = -1; else if (!is_user_vaddr (buffer) || !is_user_vaddr (buffer + size)) sys_exit (-1); else { f = file_by_fid (fd); if (f == NULL) ret = -1; else { lock_acquire (&file_lock); ret = file_read (f->file, buffer, size); lock_release (&file_lock); } } return ret; }
BRESULT sxsicd_readraw(SXSIDEV sxsi, long pos, void *buf) { CDINFO cdinfo; FILEH fh; long fpos; cdinfo = (CDINFO)sxsi->hdl; if (cdinfo->type != 2352) { return(FAILURE); } if (sxsi_prepare(sxsi) != SUCCESS) { return(FAILURE); } if ((pos < 0) || (pos >= sxsi->totals)) { return(FAILURE); } fh = ((CDINFO)sxsi->hdl)->fh; fpos = pos * 2352; if ((file_seek(fh, fpos, FSEEK_SET) != fpos) || (file_read(fh, buf, 2352) != 2352)) { return(FAILURE); } return(SUCCESS); }
GLuint create_shader(const char* filename, GLenum type) { const GLchar* source = file_read(filename); if (source == NULL) { fprintf(stderr, "Error opening %s: ", filename); perror(""); return 0; } GLuint res = glCreateShader(type); const GLchar* sources[2] = { source }; glShaderSource(res, 1, sources, NULL); free((void*)source); glCompileShader(res); GLint compile_ok = GL_FALSE; glGetShaderiv(res, GL_COMPILE_STATUS, &compile_ok); if (compile_ok == GL_FALSE) { fprintf(stderr, "%s:", filename); print_log(res); glDeleteShader(res); return 0; } return res; }
// Read at most ipc->read.req_n bytes from the current seek position // in ipc->read.req_fileid. Return the bytes read from the file to // the caller in ipc->readRet, then update the seek position. Returns // the number of bytes successfully read, or < 0 on error. int serve_read(envid_t envid, union Fsipc *ipc) { struct Fsreq_read *req = &ipc->read; struct Fsret_read *ret = &ipc->readRet; struct OpenFile *o; int r; char buf[PGSIZE]; if (debug) cprintf("serve_read %08x %08x %08x\n", envid, req->req_fileid, req->req_n); // Lab 5: Your code here: r = openfile_lookup(envid, req->req_fileid, &o); if(r<0) return r; //find read from curr offset r = file_read(o->o_file, ret->ret_buf, req->req_n, o->o_fd->fd_offset); if(r<0) return r; o->o_fd->fd_offset += r; return r; }
/** * Compile the shader from file 'filename', with error handling */ GLuint create_shader(const char* filename, GLenum type) { const GLchar* source = file_read(filename); if (source == NULL) { fprintf(stderr, "Error opening %s: ", filename); perror(""); return 0; } GLuint res = glCreateShader(type); const GLchar* sources[2] = { #ifdef GL_ES_VERSION_2_0 "#version 100\n" "#define GLES2\n", #else "#version 120\n", #endif source }; glShaderSource(res, 2, sources, NULL); free((void*)source); glCompileShader(res); GLint compile_ok = GL_FALSE; glGetShaderiv(res, GL_COMPILE_STATUS, &compile_ok); if (compile_ok == GL_FALSE) { fprintf(stderr, "%s:", filename); print_log(res); glDeleteShader(res); return 0; } return res; }
int main(int argc ,char *argv[]) { FileOperation *file_operation = NULL; char buf[1024] = {0}; char *file_name = "text.txt"; #if 0 file_operation = file_fd_create("test.txt"); file_write(file_operation, "hello world\n"); file_write(file_operation, "aaaaaaaaaaaaaaaa\n"); file_write(file_operation, "bbbbbbbbbbbbbbbbbbb\n"); file_write(file_operation, "ccccccccccccccccccc\n"); file_destroy(file_operation); #endif file_operation = file_fd_create("a.txt"); file_read(file_operation, buf, 1024); printf("buf(%s)\n", buf); file_destroy(file_operation); return 0; }
// Write req->req_n bytes from req->req_buf to req_fileid, starting at // the current seek position, and update the seek position // accordingly. Extend the file if necessary. Returns the number of // bytes written, or < 0 on error. int serve_write(envid_t envid, struct Fsreq_write *req) { if (debug) cprintf("serve_write %08x %08x %08x\n", envid, req->req_fileid, req->req_n); // LAB 5: Your code here. //panic("serve_write not implemented"); struct OpenFile *o; int r; int bytes = req->req_n; char buf[512] = {0}; if(bytes > PGSIZE) bytes = PGSIZE; if ((r = openfile_lookup(envid, req->req_fileid, &o)) < 0) return r; if((r = file_write(o->o_file, req->req_buf, bytes,o->o_fd->fd_offset)) >=0) { o->o_fd->fd_offset += r; } file_read(o->o_file, buf, bytes, 0); //o->o_fd->fd_offset += r; return r; }
conf* config_init(const char* config_file){ struct stat buf; conf* config=NULL; config=(conf*)malloc(sizeof(conf)); if (NULL==config) { free(config); config=NULL; printf("alloc memory failed!.\n"); return NULL; } memset(config,0,sizeof(conf)); memset(&buf,0,sizeof(struct stat)); if (stat(config_file,&buf)==-1) { free(config); config=NULL; return NULL; } config->size=buf.st_size; config->config_handle=file_open(config_file); if (config->config_handle==NULL) { printf("open config file failed: %p\n", config->config_handle); free(config); config=NULL; return (void*)0; } config->content=(char*)malloc(buf.st_size*sizeof(char)); config->origin_content=(char*)malloc(buf.st_size*sizeof(char)); file_read(config->config_handle,config->origin_content,buf.st_size); strncpy(config->content,config->origin_content,buf.st_size*sizeof(char)); config->vernier=0; return config; }
VikLoadType_t a_file_load ( VikAggregateLayer *top, VikViewport *vp, const gchar *filename_or_uri ) { g_return_val_if_fail ( vp != NULL, LOAD_TYPE_READ_FAILURE ); char *filename = (char *)filename_or_uri; if (strncmp(filename, "file://", 7) == 0) { // Consider replacing this with: // filename = g_filename_from_uri ( entry, NULL, NULL ); // Since this doesn't support URIs properly (i.e. will failure if is it has %20 characters in it) filename = filename + 7; g_debug ( "Loading file %s from URI %s", filename, filename_or_uri ); } FILE *f = xfopen ( filename ); if ( ! f ) return LOAD_TYPE_READ_FAILURE; VikLoadType_t load_answer = LOAD_TYPE_OTHER_SUCCESS; gchar *dirpath = g_path_get_dirname ( filename ); // Attempt loading the primary file type first - our internal .vik file: if ( check_magic ( f, VIK_MAGIC ) ) { if ( file_read ( top, f, dirpath, vp ) ) load_answer = LOAD_TYPE_VIK_SUCCESS; else load_answer = LOAD_TYPE_VIK_FAILURE_NON_FATAL; } else if ( a_jpg_magic_check ( filename ) ) { if ( ! a_jpg_load_file ( top, filename, vp ) ) load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE; } else { // For all other file types which consist of tracks, routes and/or waypoints, // must be loaded into a new TrackWaypoint layer (hence it be created) gboolean success = TRUE; // Detect load failures - mainly to remove the layer created as it's not required VikLayer *vtl = vik_layer_create ( VIK_LAYER_TRW, vp, FALSE ); vik_layer_rename ( vtl, a_file_basename ( filename ) ); // In fact both kml & gpx files start the same as they are in xml if ( a_file_check_ext ( filename, ".kml" ) && check_magic ( f, GPX_MAGIC ) ) { // Implicit Conversion if ( ! ( success = a_babel_convert_from ( VIK_TRW_LAYER(vtl), "-i kml", filename, NULL, NULL, NULL ) ) ) { load_answer = LOAD_TYPE_GPSBABEL_FAILURE; } } // NB use a extension check first, as a GPX file header may have a Byte Order Mark (BOM) in it // - which currently confuses our check_magic function else if ( a_file_check_ext ( filename, ".gpx" ) || check_magic ( f, GPX_MAGIC ) ) { if ( ! ( success = a_gpx_read_file ( VIK_TRW_LAYER(vtl), f ) ) ) { load_answer = LOAD_TYPE_GPX_FAILURE; } } else { // Try final supported file type if ( ! ( success = a_gpspoint_read_file ( VIK_TRW_LAYER(vtl), f, dirpath ) ) ) { // Failure here means we don't know how to handle the file load_answer = LOAD_TYPE_UNSUPPORTED_FAILURE; } } g_free ( dirpath ); // Clean up when we can't handle the file if ( ! success ) { // free up layer g_object_unref ( vtl ); } else { // Complete the setup from the successful load vik_layer_post_read ( vtl, vp, TRUE ); vik_aggregate_layer_add_layer ( top, vtl, FALSE ); vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(vtl), vp ); } } xfclose(f); return load_answer; }
static gint detect_version(wtap *wth, int *err, gchar **err_info) { gint bytes_read; guint16 payload_length; guint16 try_header_size; guint8 *buffer; gint64 file_offset; guint32 log_length; guint32 tag_length; guint16 tmp; file_offset = file_tell(wth->fh); bytes_read = file_read(&tmp, 2, wth->fh); if (bytes_read != 2) { *err = file_error(wth->fh, err_info); if (*err == 0 && bytes_read != 0) *err = WTAP_ERR_SHORT_READ; return -1; } payload_length = pletoh16(&tmp); bytes_read = file_read(&tmp, 2, wth->fh); if (bytes_read != 2) { *err = file_error(wth->fh, err_info); if (*err == 0 && bytes_read != 0) *err = WTAP_ERR_SHORT_READ; return -1; } try_header_size = pletoh16(&tmp); buffer = (guint8 *) g_malloc(5 * 4 + payload_length); bytes_read = file_read(buffer, 5 * 4 + payload_length, wth->fh); if (bytes_read != 5 * 4 + payload_length) { if (bytes_read != 4 * 4 + payload_length) { *err = file_error(wth->fh, err_info); if (*err == 0 && bytes_read != 0) *err = WTAP_ERR_SHORT_READ; g_free(buffer); return -1; } } if (try_header_size == 24) { tag_length = (guint32)strlen(buffer + 5 * 4 + 1) + 1; log_length = (guint32)strlen(buffer + 5 * 4 + 1 + tag_length) + 1; if (payload_length == 1 + tag_length + log_length) { g_free(buffer); return 2; } } tag_length = (guint32)strlen(buffer + 4 * 4 + 1) + 1; log_length = (guint32)strlen(buffer + 4 * 4 + 1 + tag_length) + 1; if (payload_length == 1 + tag_length + log_length) { if (file_seek(wth->fh, file_offset + 4 * 4 + 1 + tag_length + log_length, SEEK_SET, err) == -1) { g_free(buffer); return -1; } g_free(buffer); return 1; } g_free(buffer); return 0; }
int record_read_filtered(struct Record **R, struct File *F, struct Field *fld) { int len = 0; int flen = 0; int s = 0; int reject = 0; long int start_p = 0; struct String *str = 0; struct Record *Rfld = 0; if (F->idx >= F->size) { s = file_read(F); if (s) return s; } (*R) = 0; while (fld) { /* where do we start ? */ if (fld->start_p) { if (start_p < fld->start_p) { len = fld->start_p - start_p; start_p += len; flen = F->idx + len; if (flen >= F->size) { len = flen - F->size; s = file_read(F); if (s) goto err; } F->idx += len; } if (fld->left_q) { if (FCURC(F) == fld->left_q) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } } else if (fld->left_q) { if (FCURC(F) == fld->left_q) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } else goto err; } if (! str) { s = str_create(&str); if (s) goto err; } if (fld->end_p) { while (start_p <= fld->end_p) { if (fld->flag && ! reject) str_append_c(str, FCURC(F)); F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } else if (fld->right_q) { if (fld->flag && ! reject) s = file_fetch_until(F, str, fld->right_q); else s = file_skip_until(F, fld->right_q); if (s) goto err; F->idx++; start_p += str->idx + 1; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } if (fld->sep) { while (FCURC(F) != fld->sep) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } else if (fld->sep) { if (fld->flag && !reject) s = file_fetch_until(F, str, fld->sep); else s = file_skip_until(F, fld->sep); if (s) goto err; F->idx++; start_p += str->idx + 1; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } else { if (fld->flag && !reject) s = file_fetch_until(F, str, CH_NEWLINE); else s = file_skip_until(F, CH_NEWLINE); if (s) goto err; } if ((fld->flag & FFLAG_FILTER) && !reject) { s = fld->fop(fld->fltr_rule, str->buf, fld->fltr_v); /* reject this record */ if (s == 0) { reject = 1; break; } } if (fld->flag & FFLAG_CREATE) { if (! reject) { s = record_new(&Rfld, fld, str); if (s) goto err; record_add_field(R, Rfld); str = 0; Rfld = 0; } } else str_prune(str); fld = fld->next; } /* go to next row */ if (FCURC(F) != CH_NEWLINE) { s = file_skip_until(F, CH_NEWLINE); } F->idx++; s = 0; err: str_destroy(&str); if ((s && s != E_FILE_END) || reject) record_destroy(R); return s; }
/** * @return: * < 0 : success * < > 0 : fail */ int record_read2(struct Record *R, struct File *F, struct Field *fld) { int s = 0; int len = 0; int flen = 0; long int start_p = 0; struct String *str = 0; if (F->idx >= F->size) { s = file_read(F); if (s) return s; } while (fld) { str = R->v; /* where do we start ? */ if (fld->start_p) { if (start_p < fld->start_p) { len = fld->start_p - start_p; start_p += len; flen = F->idx + len; if (flen > F->size) { len = flen - F->size; s = file_read(F); if (s) goto err; } F->idx += len; } if (fld->left_q) { if (FCURC(F) == fld->left_q) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } } else if (fld->left_q) { if (FCURC(F) == fld->left_q) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } else goto err; } if (fld->end_p) { while (start_p <= fld->end_p) { str_append_c(str, FCURC(F)); F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } else if (fld->right_q) { s = file_fetch_until(F, str, fld->right_q); if (s) goto err; F->idx++; start_p += str->idx + 1; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } if (fld->sep) { while (FCURC(F) != fld->sep) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } else if (fld->sep) { s = file_fetch_until(F, str, fld->sep); if (s) goto err; F->idx++; start_p += str->idx + 1; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } else { s = file_fetch_until(F, str, CH_NEWLINE); if (s) goto err; } fld = fld->next; R = R->fld_next; } /* go to next row */ if (FCURC(F) != CH_NEWLINE) { file_fetch_until(F, str, CH_NEWLINE); } F->idx++; s = 0; err: return s; }
/** * @desc: touch if you dare! * priority in reading a record: * - start_p > left_q * - end_p > right_q > sep * @return: * < 0 : success * < !0 : fail. and R will be NULL */ int record_read(struct Record **R, struct File *F, struct Field *fld) { int s = 0; int len = 0; int flen = 0; long int start_p = 0; struct String *str = 0; struct Record *Rfld = 0; if (F->idx >= F->size) { s = file_read(F); if (s) return s; } (*R) = 0; while (fld) { /* where do we start ? */ if (fld->start_p) { if (start_p < fld->start_p) { len = fld->start_p - start_p; start_p += len; flen = F->idx + len; if (flen >= F->size) { len = flen - F->size; s = file_read(F); if (s) goto err; } F->idx += len; } if (fld->left_q) { if (FCURC(F) == fld->left_q) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } } else if (fld->left_q) { if (FCURC(F) == fld->left_q) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } else goto err; } /* create string for field data */ s = str_create(&str); if (s) return s; if (fld->end_p) { while (start_p <= fld->end_p) { str_append_c(str, FCURC(F)); F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } else if (fld->right_q) { s = file_fetch_until(F, str, fld->right_q); if (s) goto err; F->idx++; start_p += str->idx + 1; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } if (fld->sep) { while (FCURC(F) != fld->sep) { F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } F->idx++; start_p++; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } } else if (fld->sep) { s = file_fetch_until(F, str, fld->sep); if (s) goto err; F->idx++; start_p += str->idx + 1; if (F->idx >= F->size) { s = file_read(F); if (s) goto err; } } else { s = file_fetch_until(F, str, CH_NEWLINE); if (s) goto err; } s = record_new(&Rfld, fld, str); if (s) goto err; record_add_field(R, Rfld); str = 0; Rfld = 0; fld = fld->next; } /* go to next row */ if (FCURC(F) != CH_NEWLINE) { s = file_fetch_until(F, str, CH_NEWLINE); } F->idx++; return 0; err: str_destroy(&str); if (s && s != E_FILE_END) record_destroy(R); return s; }
static gboolean snoop_read_atm_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info) { struct snoop_atm_hdr atm_phdr; int bytes_read; guint8 vpi; guint16 vci; errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&atm_phdr, sizeof (struct snoop_atm_hdr), fh); if (bytes_read != sizeof (struct snoop_atm_hdr)) { *err = file_error(fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } vpi = atm_phdr.vpi; vci = pntohs(&atm_phdr.vci); /* * The lower 4 bits of the first byte of the header indicate * the type of traffic, as per the "atmioctl.h" header in * SunATM. */ switch (atm_phdr.flags & 0x0F) { case 0x01: /* LANE */ pseudo_header->atm.aal = AAL_5; pseudo_header->atm.type = TRAF_LANE; break; case 0x02: /* RFC 1483 LLC multiplexed traffic */ pseudo_header->atm.aal = AAL_5; pseudo_header->atm.type = TRAF_LLCMX; break; case 0x05: /* ILMI */ pseudo_header->atm.aal = AAL_5; pseudo_header->atm.type = TRAF_ILMI; break; case 0x06: /* Signalling AAL */ pseudo_header->atm.aal = AAL_SIGNALLING; pseudo_header->atm.type = TRAF_UNKNOWN; break; case 0x03: /* MARS (RFC 2022) */ pseudo_header->atm.aal = AAL_5; pseudo_header->atm.type = TRAF_UNKNOWN; break; case 0x04: /* IFMP (Ipsilon Flow Management Protocol; see RFC 1954) */ pseudo_header->atm.aal = AAL_5; pseudo_header->atm.type = TRAF_UNKNOWN; /* XXX - TRAF_IPSILON? */ break; default: /* * Assume it's AAL5, unless it's VPI 0 and VCI 5, in which * case assume it's AAL_SIGNALLING; we know nothing more * about it. * * XXX - is this necessary? Or are we guaranteed that * all signalling traffic has a type of 0x06? * * XXX - is this guaranteed to be AAL5? Or, if the type is * 0x00 ("raw"), might it be non-AAL5 traffic? */ if (vpi == 0 && vci == 5) pseudo_header->atm.aal = AAL_SIGNALLING; else pseudo_header->atm.aal = AAL_5; pseudo_header->atm.type = TRAF_UNKNOWN; break; } pseudo_header->atm.subtype = TRAF_ST_UNKNOWN; pseudo_header->atm.vpi = vpi; pseudo_header->atm.vci = vci; pseudo_header->atm.channel = (atm_phdr.flags & 0x80) ? 0 : 1; /* We don't have this information */ pseudo_header->atm.flags = 0; pseudo_header->atm.cells = 0; pseudo_header->atm.aal5t_u2u = 0; pseudo_header->atm.aal5t_len = 0; pseudo_header->atm.aal5t_chksum = 0; return TRUE; }
static int snoop_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info) { struct snooprec_hdr hdr; int bytes_read; guint32 rec_size; guint32 packet_size; guint32 orig_size; int header_size; /* Read record header. */ errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&hdr, sizeof hdr, fh); if (bytes_read != sizeof hdr) { *err = file_error(fh, err_info); if (*err == 0 && bytes_read != 0) *err = WTAP_ERR_SHORT_READ; return -1; } rec_size = g_ntohl(hdr.rec_len); orig_size = g_ntohl(hdr.orig_len); packet_size = g_ntohl(hdr.incl_len); if (orig_size > WTAP_MAX_PACKET_SIZE) { /* * Probably a corrupt capture file; don't blow up trying * to allocate space for an immensely-large packet. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("snoop: File has %u-byte original length, bigger than maximum of %u", orig_size, WTAP_MAX_PACKET_SIZE); return -1; } if (packet_size > WTAP_MAX_PACKET_SIZE) { /* * Probably a corrupt capture file; don't blow up trying * to allocate space for an immensely-large packet. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("snoop: File has %u-byte packet, bigger than maximum of %u", packet_size, WTAP_MAX_PACKET_SIZE); return -1; } if (packet_size > rec_size) { /* * Probably a corrupt capture file. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("snoop: File has %u-byte packet, bigger than record size %u", packet_size, rec_size); return -1; } switch (wth->file_encap) { case WTAP_ENCAP_ATM_PDUS: /* * This is an ATM packet, so the first four bytes are * the direction of the packet (transmit/receive), the * VPI, and the VCI; read them and generate the * pseudo-header from them. */ if (packet_size < sizeof (struct snoop_atm_hdr)) { /* * Uh-oh, the packet isn't big enough to even * have a pseudo-header. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("snoop: atmsnoop file has a %u-byte packet, too small to have even an ATM pseudo-header", packet_size); return -1; } if (!snoop_read_atm_pseudoheader(fh, &phdr->pseudo_header, err, err_info)) return -1; /* Read error */ /* * Don't count the pseudo-header as part of the packet. */ rec_size -= (guint32)sizeof (struct snoop_atm_hdr); orig_size -= (guint32)sizeof (struct snoop_atm_hdr); packet_size -= (guint32)sizeof (struct snoop_atm_hdr); break; case WTAP_ENCAP_ETHERNET: /* * If this is a snoop file, we assume there's no FCS in * this frame; if this is a Shomit file, we assume there * is. (XXX - or should we treat it a "maybe"?) */ if (wth->file_type == WTAP_FILE_SHOMITI) phdr->pseudo_header.eth.fcs_len = 4; else phdr->pseudo_header.eth.fcs_len = 0; break; case WTAP_ENCAP_IEEE_802_11_WITH_RADIO: if (packet_size < sizeof (shomiti_wireless_header)) { /* * Uh-oh, the packet isn't big enough to even * have a pseudo-header. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("snoop: Shomiti wireless file has a %u-byte packet, too small to have even a wireless pseudo-header", packet_size); return -1; } if (!snoop_read_shomiti_wireless_pseudoheader(fh, &phdr->pseudo_header, err, err_info, &header_size)) return -1; /* Read error */ /* * Don't count the pseudo-header as part of the packet. */ rec_size -= header_size; orig_size -= header_size; packet_size -= header_size; break; } phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->ts.secs = g_ntohl(hdr.ts_sec); phdr->ts.nsecs = g_ntohl(hdr.ts_usec) * 1000; phdr->caplen = packet_size; phdr->len = orig_size; if (rec_size < (sizeof hdr + packet_size)) { /* * What, *negative* padding? Bogus. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("snoop: File has %u-byte record with packet size of %u", rec_size, packet_size); return -1; } /* * Read the packet data. */ if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info)) return -1; /* failed */ /* * If this is ATM LANE traffic, try to guess what type of LANE * traffic it is based on the packet contents. */ if (wth->file_encap == WTAP_ENCAP_ATM_PDUS && phdr->pseudo_header.atm.type == TRAF_LANE) { atm_guess_lane_type(buffer_start_ptr(buf), packet_size, &phdr->pseudo_header); } return rec_size - ((guint)sizeof hdr + packet_size); }
/* * See * * http://www.opengroup.org/onlinepubs/9638599/apdxf.htm * * for the "dlpi.h" header file specified by The Open Group, which lists * the DL_ values for various protocols; Solaris 7 uses the same values. * * See * * http://www.iana.org/assignments/snoop-datalink-types/snoop-datalink-types.xml * * for the IETF list of snoop datalink types. * * The page at * * http://mrpink.lerc.nasa.gov/118x/support.html * * had links to modified versions of "tcpdump" and "libpcap" for SUNatm * DLPI support; they suggested that the 3.0 verson of SUNatm uses those * values. The Wayback Machine archived that page, but not the stuff * to which it linked, unfortunately. * * It also has a link to "convert.c", which is a program to convert files * from the format written by the "atmsnoop" program that comes with the * SunATM package to regular "snoop" format, claims that "SunATM 2.1 claimed * to be DL_FDDI (don't ask why). SunATM 3.0 claims to be DL_IPATM, which * is 0x12". * * It also says that "ATM Mac header is 12 bytes long.", and seems to imply * that in an "atmsnoop" file, the header contains 2 bytes (direction and * VPI?), 2 bytes of VCI, 6 bytes of something, and 2 bytes of Ethernet * type; if those 6 bytes are 2 bytes of DSAP, 2 bytes of LSAP, 1 byte * of LLC control, and 3 bytes of SNAP OUI, that'd mean that an ATM * pseudo-header in an "atmsnoop" file is probably 1 byte of direction, * 1 byte of VPI, and 2 bytes of VCI. * * The aforementioned page also has a link to some capture files from * "atmsnoop"; this version of "snoop.c" appears to be able to read them. * * Source to an "atmdump" package, which includes a modified version of * "libpcap" to handle SunATM DLPI and an ATM driver for FreeBSD, and * also includes "atmdump", which is a modified "tcpdump", was available * at * * ftp://ftp.cs.ndsu.nodak.edu/pub/freebsd/atm/atm-bpf.tgz * * (the host name is no longer valid) and that code also indicated that * DL_IPATM is used, and that an ATM packet handed up from the Sun driver * for the Sun SBus ATM card on Solaris 2.5.1 has 1 byte of direction, * 1 byte of VPI, 2 bytes of VCI, and then the ATM PDU, and suggests that * the direction flag is 0x80 for "transmitted" (presumably meaning * DTE->DCE) and presumably not 0x80 for "received" (presumably meaning * DCE->DTE). That code was used as the basis for the SunATM support in * later versions of libpcap and tcpdump, and it worked at the time the * development was done with the SunATM code on the system on which the * development was done. * * In fact, the "direction" byte appears to have some other stuff, perhaps * a traffic type, in the lower 7 bits, with the 8th bit indicating the * direction. That appears to be the case. * * I don't know what the encapsulation of any of the other types is, so I * leave them all as WTAP_ENCAP_UNKNOWN, except for those for which Brian * Ginsbach has supplied information about the way UNICOS/mp uses them. * I also don't know whether "snoop" can handle any of them (it presumably * can't handle ATM, otherwise Sun wouldn't have supplied "atmsnoop"; even * if it can't, this may be useful reference information for anybody doing * code to use DLPI to do raw packet captures on those network types. * * Once upon a time * * http://web.archive.org/web/20010906213807/http://www.shomiti.com/support/TNCapFileFormat.htm * * gave information on Shomiti's mutant flavor of snoop; Shomiti's Web site * is no longer available on the Wayback Machine. For some unknown reason, * they decided not to just Go With The DLPI Flow, and instead used the types * unspecified in RFC 1461 for their own nefarious purposes, such as * distinguishing 10MB from 100MB from 1000MB Ethernet and distinguishing * 4MB from 16MB Token Ring, and distinguishing both of them from the * "Shomiti" versions of same. */ int snoop_open(wtap *wth, int *err, gchar **err_info) { int bytes_read; char magic[sizeof snoop_magic]; struct snoop_hdr hdr; struct snooprec_hdr rec_hdr; guint padbytes; gboolean is_shomiti; static const int snoop_encap[] = { WTAP_ENCAP_ETHERNET, /* IEEE 802.3 */ WTAP_ENCAP_UNKNOWN, /* IEEE 802.4 Token Bus */ WTAP_ENCAP_TOKEN_RING, WTAP_ENCAP_UNKNOWN, /* IEEE 802.6 Metro Net */ WTAP_ENCAP_ETHERNET, WTAP_ENCAP_UNKNOWN, /* HDLC */ WTAP_ENCAP_UNKNOWN, /* Character Synchronous, e.g. bisync */ WTAP_ENCAP_UNKNOWN, /* IBM Channel-to-Channel */ WTAP_ENCAP_FDDI_BITSWAPPED, WTAP_ENCAP_NULL, /* Other */ WTAP_ENCAP_UNKNOWN, /* Frame Relay LAPF */ WTAP_ENCAP_UNKNOWN, /* Multi-protocol over Frame Relay */ WTAP_ENCAP_UNKNOWN, /* Character Async (e.g., SLIP and PPP?) */ WTAP_ENCAP_UNKNOWN, /* X.25 Classical IP */ WTAP_ENCAP_NULL, /* software loopback */ WTAP_ENCAP_UNKNOWN, /* not defined in "dlpi.h" */ WTAP_ENCAP_IP_OVER_FC, /* Fibre Channel */ WTAP_ENCAP_UNKNOWN, /* ATM */ WTAP_ENCAP_ATM_PDUS, /* ATM Classical IP */ WTAP_ENCAP_UNKNOWN, /* X.25 LAPB */ WTAP_ENCAP_UNKNOWN, /* ISDN */ WTAP_ENCAP_UNKNOWN, /* HIPPI */ WTAP_ENCAP_UNKNOWN, /* 100VG-AnyLAN Ethernet */ WTAP_ENCAP_UNKNOWN, /* 100VG-AnyLAN Token Ring */ WTAP_ENCAP_UNKNOWN, /* "ISO 8802/3 and Ethernet" */ WTAP_ENCAP_UNKNOWN, /* 100BaseT (but that's just Ethernet) */ WTAP_ENCAP_IP_OVER_IB, /* Infiniband */ }; #define NUM_SNOOP_ENCAPS (sizeof snoop_encap / sizeof snoop_encap[0]) #define SNOOP_PRIVATE_BIT 0x80000000 static const int snoop_private_encap[] = { WTAP_ENCAP_UNKNOWN, /* Not Used */ WTAP_ENCAP_UNKNOWN, /* IPv4 Tunnel Link */ WTAP_ENCAP_UNKNOWN, /* IPv6 Tunnel Link */ WTAP_ENCAP_UNKNOWN, /* Virtual network interface */ WTAP_ENCAP_UNKNOWN, /* IEEE 802.11 */ WTAP_ENCAP_IPNET, /* ipnet(7D) link */ WTAP_ENCAP_UNKNOWN, /* IPMP stub interface */ WTAP_ENCAP_UNKNOWN, /* 6to4 Tunnel Link */ }; #define NUM_SNOOP_PRIVATE_ENCAPS (sizeof snoop_private_encap / sizeof snoop_private_encap[0]) static const int shomiti_encap[] = { WTAP_ENCAP_ETHERNET, /* IEEE 802.3 */ WTAP_ENCAP_UNKNOWN, /* IEEE 802.4 Token Bus */ WTAP_ENCAP_TOKEN_RING, WTAP_ENCAP_UNKNOWN, /* IEEE 802.6 Metro Net */ WTAP_ENCAP_ETHERNET, WTAP_ENCAP_UNKNOWN, /* HDLC */ WTAP_ENCAP_UNKNOWN, /* Character Synchronous, e.g. bisync */ WTAP_ENCAP_UNKNOWN, /* IBM Channel-to-Channel */ WTAP_ENCAP_FDDI_BITSWAPPED, WTAP_ENCAP_UNKNOWN, /* Other */ WTAP_ENCAP_ETHERNET, /* Fast Ethernet */ WTAP_ENCAP_TOKEN_RING, /* 4MB 802.5 token ring */ WTAP_ENCAP_ETHERNET, /* Gigabit Ethernet */ WTAP_ENCAP_TOKEN_RING, /* "IEEE 802.5 Shomiti" */ WTAP_ENCAP_TOKEN_RING, /* "4MB IEEE 802.5 Shomiti" */ WTAP_ENCAP_UNKNOWN, /* Other */ WTAP_ENCAP_UNKNOWN, /* Other */ WTAP_ENCAP_UNKNOWN, /* Other */ WTAP_ENCAP_IEEE_802_11_WITH_RADIO, /* IEEE 802.11 with Radio Header */ WTAP_ENCAP_ETHERNET, /* 10 Gigabit Ethernet */ }; #define NUM_SHOMITI_ENCAPS (sizeof shomiti_encap / sizeof shomiti_encap[0]) int file_encap; gint64 saved_offset; /* Read in the string that should be at the start of a "snoop" file */ errno = WTAP_ERR_CANT_READ; bytes_read = file_read(magic, sizeof magic, wth->fh); if (bytes_read != sizeof magic) { *err = file_error(wth->fh, err_info); if (*err != 0 && *err != WTAP_ERR_SHORT_READ) return -1; return 0; } if (memcmp(magic, snoop_magic, sizeof snoop_magic) != 0) { return 0; } /* Read the rest of the header. */ errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&hdr, sizeof hdr, wth->fh); if (bytes_read != sizeof hdr) { *err = file_error(wth->fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return -1; } /* * Make sure it's a version we support. */ hdr.version = g_ntohl(hdr.version); switch (hdr.version) { case 2: /* Solaris 2.x and later snoop, and Shomiti Surveyor prior to 3.0, or 3.0 and later with NDIS card */ case 3: /* Surveyor 3.0 and later, with Shomiti CMM2 hardware */ case 4: /* Surveyor 3.0 and later, with Shomiti GAM hardware */ case 5: /* Surveyor 3.0 and later, with Shomiti THG hardware */ break; default: *err = WTAP_ERR_UNSUPPORTED; *err_info = g_strdup_printf("snoop: version %u unsupported", hdr.version); return -1; } /* * Oh, this is lovely. * * I suppose Shomiti could give a bunch of lawyerly noise about * how "well, RFC 1761 said they were unassigned, and that's * the standard, not the DLPI header file, so it's perfectly OK * for us to use them, blah blah blah", but it's still irritating * as hell that they used the unassigned-in-RFC-1761 values for * their own purposes - especially given that Sun also used * one of them in atmsnoop. * * We can't determine whether it's a Shomiti capture based on * the version number, as, according to their documentation on * their capture file format, Shomiti uses a version number of 2 * if the data "was captured using an NDIS card", which presumably * means "captured with an ordinary boring network card via NDIS" * as opposed to "captured with our whizzo special capture * hardware". * * The only way I can see to determine that is to check how much * padding there is in the first packet - if there's enough * padding for a Shomiti trailer, it's probably a Shomiti * capture, and otherwise, it's probably from Snoop. */ /* * Start out assuming it's not a Shomiti capture. */ is_shomiti = FALSE; /* Read first record header. */ saved_offset = file_tell(wth->fh); errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&rec_hdr, sizeof rec_hdr, wth->fh); if (bytes_read != sizeof rec_hdr) { *err = file_error(wth->fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return -1; /* * The file ends after the record header, which means this * is a capture with no packets. * * We assume it's a snoop file; the actual type of file is * irrelevant, as there are no records in it, and thus no * extra information if it's a Shomiti capture, and no * link-layer headers whose type we have to know, and no * Ethernet frames that might have an FCS. */ } else { /* * Compute the number of bytes of padding in the * record. If it's at least the size of a Shomiti * trailer record, we assume this is a Shomiti * capture. (Some atmsnoop captures appear * to have 4 bytes of padding, and at least one * snoop capture appears to have 6 bytes of padding; * the Shomiti header is larger than either of those.) */ if (g_ntohl(rec_hdr.rec_len) > (sizeof rec_hdr + g_ntohl(rec_hdr.incl_len))) { /* * Well, we have padding; how much? */ padbytes = g_ntohl(rec_hdr.rec_len) - ((guint)sizeof rec_hdr + g_ntohl(rec_hdr.incl_len)); /* * Is it at least the size of a Shomiti trailer? */ is_shomiti = (padbytes >= sizeof (struct shomiti_trailer)); } } /* * Seek back to the beginning of the first record. */ if (file_seek(wth->fh, saved_offset, SEEK_SET, err) == -1) return -1; hdr.network = g_ntohl(hdr.network); if (is_shomiti) { if (hdr.network >= NUM_SHOMITI_ENCAPS || shomiti_encap[hdr.network] == WTAP_ENCAP_UNKNOWN) { *err = WTAP_ERR_UNSUPPORTED_ENCAP; *err_info = g_strdup_printf("snoop: Shomiti network type %u unknown or unsupported", hdr.network); return -1; } file_encap = shomiti_encap[hdr.network]; /* This is a Shomiti file */ wth->file_type = WTAP_FILE_SHOMITI; } else if (hdr.network & SNOOP_PRIVATE_BIT) { if ((hdr.network^SNOOP_PRIVATE_BIT) >= NUM_SNOOP_PRIVATE_ENCAPS || snoop_private_encap[hdr.network^SNOOP_PRIVATE_BIT] == WTAP_ENCAP_UNKNOWN) { *err = WTAP_ERR_UNSUPPORTED_ENCAP; *err_info = g_strdup_printf("snoop: private network type %u unknown or unsupported", hdr.network); return -1; } file_encap = snoop_private_encap[hdr.network^SNOOP_PRIVATE_BIT]; /* This is a snoop file */ wth->file_type = WTAP_FILE_SNOOP; } else { if (hdr.network >= NUM_SNOOP_ENCAPS || snoop_encap[hdr.network] == WTAP_ENCAP_UNKNOWN) { *err = WTAP_ERR_UNSUPPORTED_ENCAP; *err_info = g_strdup_printf("snoop: network type %u unknown or unsupported", hdr.network); return -1; } file_encap = snoop_encap[hdr.network]; /* This is a snoop file */ wth->file_type = WTAP_FILE_SNOOP; } /* * We don't currently use the extra information in Shomiti * records, so we use the same routines to read snoop and * Shomiti files. */ wth->subtype_read = snoop_read; wth->subtype_seek_read = snoop_seek_read; wth->file_encap = file_encap; wth->snapshot_length = 0; /* not available in header */ wth->tsprecision = WTAP_FILE_TSPREC_USEC; return 1; }
static gboolean nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info) { union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header; nettl_t *nettl = (nettl_t *)wth->priv; gboolean fddihack = FALSE; int bytes_read; struct nettlrec_hdr rec_hdr; guint16 hdr_len; struct nettlrec_ns_ls_drv_eth_hdr drv_eth_hdr; guint32 length, caplen; int subsys; guint padlen; int datalen; guint8 dummyc[16]; int bytes_to_read; guint8 *pd; guint8 dummy[3]; errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&rec_hdr.hdr_len, sizeof rec_hdr.hdr_len, fh); if (bytes_read != sizeof rec_hdr.hdr_len) { *err = file_error(fh, err_info); if (*err == 0 && bytes_read != 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } hdr_len = g_ntohs(rec_hdr.hdr_len); if (hdr_len < NETTL_REC_HDR_LEN) { *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("nettl: record header length %u too short", hdr_len); return FALSE; } bytes_read = file_read(&rec_hdr.subsys, NETTL_REC_HDR_LEN - 2, fh); if (bytes_read != NETTL_REC_HDR_LEN - 2) { *err = file_error(fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } subsys = g_ntohs(rec_hdr.subsys); hdr_len -= NETTL_REC_HDR_LEN; if (file_seek(fh, hdr_len, SEEK_CUR, err) == -1) return FALSE; if ( (pntoh32(&rec_hdr.kind) & NETTL_HDR_PDU_MASK) == 0 ) { /* not actually a data packet (PDU) trace record */ phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_IP; length = pntoh32(&rec_hdr.length); caplen = pntoh32(&rec_hdr.caplen); padlen = 0; } else switch (subsys) { case NETTL_SUBSYS_LAN100 : case NETTL_SUBSYS_EISA100BT : case NETTL_SUBSYS_BASE100 : case NETTL_SUBSYS_GSC100BT : case NETTL_SUBSYS_PCI100BT : case NETTL_SUBSYS_SPP100BT : case NETTL_SUBSYS_100VG : case NETTL_SUBSYS_GELAN : case NETTL_SUBSYS_BTLAN : case NETTL_SUBSYS_INTL100 : case NETTL_SUBSYS_IGELAN : case NETTL_SUBSYS_IETHER : case NETTL_SUBSYS_IXGBE : case NETTL_SUBSYS_HSSN : case NETTL_SUBSYS_IGSSN : case NETTL_SUBSYS_ICXGBE : case NETTL_SUBSYS_IEXGBE : case NETTL_SUBSYS_IOCXGBE : case NETTL_SUBSYS_IQXGBE : case NETTL_SUBSYS_HPPB_FDDI : case NETTL_SUBSYS_EISA_FDDI : case NETTL_SUBSYS_PCI_FDDI : case NETTL_SUBSYS_HSC_FDDI : case NETTL_SUBSYS_TOKEN : case NETTL_SUBSYS_PCI_TR : case NETTL_SUBSYS_NS_LS_IP : case NETTL_SUBSYS_NS_LS_LOOPBACK : case NETTL_SUBSYS_NS_LS_TCP : case NETTL_SUBSYS_NS_LS_UDP : case NETTL_SUBSYS_HP_APAPORT : case NETTL_SUBSYS_HP_APALACP : case NETTL_SUBSYS_NS_LS_IPV6 : case NETTL_SUBSYS_NS_LS_ICMPV6 : case NETTL_SUBSYS_NS_LS_ICMP : case NETTL_SUBSYS_NS_LS_TELNET : case NETTL_SUBSYS_NS_LS_SCTP : if( (subsys == NETTL_SUBSYS_NS_LS_IP) || (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK) || (subsys == NETTL_SUBSYS_NS_LS_UDP) || (subsys == NETTL_SUBSYS_NS_LS_TCP) || (subsys == NETTL_SUBSYS_NS_LS_SCTP) || (subsys == NETTL_SUBSYS_NS_LS_IPV6)) { phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_IP; } else if (subsys == NETTL_SUBSYS_NS_LS_ICMP) { phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMP; } else if (subsys == NETTL_SUBSYS_NS_LS_ICMPV6) { phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6; } else if (subsys == NETTL_SUBSYS_NS_LS_TELNET) { phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_TELNET; } else if( (subsys == NETTL_SUBSYS_HPPB_FDDI) || (subsys == NETTL_SUBSYS_EISA_FDDI) || (subsys == NETTL_SUBSYS_PCI_FDDI) || (subsys == NETTL_SUBSYS_HSC_FDDI) ) { phdr->pkt_encap = WTAP_ENCAP_NETTL_FDDI; } else if( (subsys == NETTL_SUBSYS_PCI_TR) || (subsys == NETTL_SUBSYS_TOKEN) ) { phdr->pkt_encap = WTAP_ENCAP_NETTL_TOKEN_RING; } else { phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET; } length = pntoh32(&rec_hdr.length); caplen = pntoh32(&rec_hdr.caplen); /* HPPB FDDI has different inbound vs outbound trace records */ if (subsys == NETTL_SUBSYS_HPPB_FDDI) { if (pntoh32(&rec_hdr.kind) == NETTL_HDR_PDUIN) { /* inbound is very strange... there are an extra 3 bytes after the DSAP and SSAP for SNAP frames ??? */ fddihack=TRUE; padlen = 0; } else { /* outbound appears to have variable padding */ bytes_read = file_read(dummyc, 9, fh); if (bytes_read != 9) { *err = file_error(fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } /* padding is usually either a total 11 or 16 bytes??? */ padlen = (int)dummyc[8]; if (file_seek(fh, padlen, SEEK_CUR, err) == -1) return FALSE; padlen += 9; } } else if ( (subsys == NETTL_SUBSYS_PCI_FDDI) || (subsys == NETTL_SUBSYS_EISA_FDDI) || (subsys == NETTL_SUBSYS_HSC_FDDI) ) { /* other flavor FDDI cards have an extra 3 bytes of padding */ if (file_seek(fh, 3, SEEK_CUR, err) == -1) return FALSE; padlen = 3; } else if (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK) { /* LOOPBACK has an extra 26 bytes of padding */ if (file_seek(fh, 26, SEEK_CUR, err) == -1) return FALSE; padlen = 26; } else if (subsys == NETTL_SUBSYS_NS_LS_SCTP) { /* * SCTP 8 byte header that we will ignore... * 32 bit integer defines format * 1 = Log * 2 = ASCII * 3 = Binary (PDUs should be Binary format) * 32 bit integer defines type * 1 = Inbound * 2 = Outbound */ if (file_seek(fh, 8, SEEK_CUR, err) == -1) return FALSE; padlen = 8; } else { padlen = 0; } break; case NETTL_SUBSYS_NS_LS_DRIVER : /* XXX we dont know how to identify this as ethernet frames, so we assumes everything is. We will crash and burn for anything else */ /* for encapsulated 100baseT we do this */ phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET; bytes_read = file_read(&drv_eth_hdr, NS_LS_DRV_ETH_HDR_LEN, fh); if (bytes_read != NS_LS_DRV_ETH_HDR_LEN) { *err = file_error(fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } length = pntoh16(&drv_eth_hdr.length); caplen = pntoh16(&drv_eth_hdr.caplen); /* * XXX - is there a length field that would give the length * of this header, so that we don't have to check for * nettl files from HP-UX 11? * * And what are the extra two bytes? */ if (nettl->is_hpux_11) { if (file_seek(fh, 2, SEEK_CUR, err) == -1) return FALSE; } padlen = 0; break; case NETTL_SUBSYS_SX25L2: case NETTL_SUBSYS_SX25L3: /* * XXX - is the 24-byte padding actually a header with * packet lengths, time stamps, etc., just as is the case * for NETTL_SUBSYS_NS_LS_DRIVER? It might be * * guint8 caplen[2]; * guint8 length[2]; * guint8 xxc[4]; * guint8 sec[4]; * guint8 usec[4]; * guint8 xxd[4]; * * or something such as that - if it has 4 bytes before that * (making it 24 bytes), it'd be like struct * nettlrec_ns_ls_drv_eth_hdr but with 2 more bytes at the end. * * And is "from_dce" at xxa[0] in the nettlrec_hdr structure? */ phdr->pkt_encap = WTAP_ENCAP_NETTL_X25; length = pntoh32(&rec_hdr.length); caplen = pntoh32(&rec_hdr.caplen); padlen = 24; /* sizeof (struct nettlrec_sx25l2_hdr) - NETTL_REC_HDR_LEN + 4 */ if (file_seek(fh, padlen, SEEK_CUR, err) == -1) return FALSE; break; default: /* We're going to assume it's ethernet if we don't recognize the subsystem -- We'll probably spew junks and core if it isn't... */ wth->file_encap = WTAP_ENCAP_PER_PACKET; phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET; length = pntoh32(&rec_hdr.length); caplen = pntoh32(&rec_hdr.caplen); padlen = 0; break; } if (length < padlen) { *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("nettl: packet length %u in record header too short, less than %u", length, padlen); return FALSE; } phdr->rec_type = REC_TYPE_PACKET; phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN; phdr->len = length - padlen; if (caplen < padlen) { *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("nettl: captured length %u in record header too short, less than %u", caplen, padlen); return FALSE; } datalen = caplen - padlen; phdr->caplen = datalen; phdr->ts.secs = pntoh32(&rec_hdr.sec); phdr->ts.nsecs = pntoh32(&rec_hdr.usec) * 1000; pseudo_header->nettl.subsys = subsys; pseudo_header->nettl.devid = pntoh32(&rec_hdr.devid); pseudo_header->nettl.kind = pntoh32(&rec_hdr.kind); pseudo_header->nettl.pid = pntoh32(&rec_hdr.pid); pseudo_header->nettl.uid = pntoh16(&rec_hdr.uid); if (phdr->caplen > WTAP_MAX_PACKET_SIZE) { /* * Probably a corrupt capture file; don't blow up trying * to allocate space for an immensely-large packet. */ *err = WTAP_ERR_BAD_FILE; *err_info = g_strdup_printf("nettl: File has %u-byte packet, bigger than maximum of %u", phdr->caplen, WTAP_MAX_PACKET_SIZE); return FALSE; } /* * Read the packet data. */ buffer_assure_space(buf, datalen); pd = buffer_start_ptr(buf); errno = WTAP_ERR_CANT_READ; if (fddihack) { /* read in FC, dest, src, DSAP and SSAP */ bytes_to_read = 15; if (bytes_to_read > datalen) bytes_to_read = datalen; bytes_read = file_read(pd, bytes_to_read, fh); if (bytes_read != bytes_to_read) { if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } datalen -= bytes_read; if (datalen == 0) { /* There's nothing past the FC, dest, src, DSAP and SSAP */ return TRUE; } if (pd[13] == 0xAA) { /* it's SNAP, have to eat 3 bytes??? */ bytes_to_read = 3; if (bytes_to_read > datalen) bytes_to_read = datalen; bytes_read = file_read(dummy, bytes_to_read, fh); if (bytes_read != bytes_to_read) { if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } datalen -= bytes_read; if (datalen == 0) { /* There's nothing past the FC, dest, src, DSAP, SSAP, and 3 bytes to eat */ return TRUE; } } bytes_read = file_read(pd + 15, datalen, fh); } else bytes_read = file_read(pd, datalen, fh); if (bytes_read != datalen) { *err = file_error(fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return FALSE; } return TRUE; }
int nettl_open(wtap *wth, int *err, gchar **err_info) { struct nettl_file_hdr file_hdr; guint16 dummy[2]; int subsys; int bytes_read; nettl_t *nettl; memset(&file_hdr, 0, sizeof(file_hdr)); /* Read in the string that should be at the start of a HP file */ errno = WTAP_ERR_CANT_READ; bytes_read = file_read(file_hdr.magic, MAGIC_SIZE, wth->fh); if (bytes_read != MAGIC_SIZE) { *err = file_error(wth->fh, err_info); if (*err != 0 && *err != WTAP_ERR_SHORT_READ) return -1; return 0; } if (memcmp(file_hdr.magic, nettl_magic_hpux9, MAGIC_SIZE) && memcmp(file_hdr.magic, nettl_magic_hpux10, MAGIC_SIZE)) { return 0; } /* Read the rest of the file header */ bytes_read = file_read(file_hdr.file_name, FILE_HDR_SIZE - MAGIC_SIZE, wth->fh); if (bytes_read != FILE_HDR_SIZE - MAGIC_SIZE) { *err = file_error(wth->fh, err_info); if (*err == 0) *err = WTAP_ERR_SHORT_READ; return -1; } /* This is an nettl file */ wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NETTL; nettl = g_new(nettl_t,1); wth->priv = (void *)nettl; if (file_hdr.os_vers[2] == '1' && file_hdr.os_vers[3] == '1') nettl->is_hpux_11 = TRUE; else nettl->is_hpux_11 = FALSE; wth->subtype_read = nettl_read; wth->subtype_seek_read = nettl_seek_read; wth->snapshot_length = 0; /* not available */ /* read the first header to take a guess at the file encap */ bytes_read = file_read(dummy, 4, wth->fh); if (bytes_read != 4) { if (*err != 0) { return -1; } if (bytes_read != 0) { *err = WTAP_ERR_SHORT_READ; return -1; } return 0; } subsys = g_ntohs(dummy[1]); switch (subsys) { case NETTL_SUBSYS_HPPB_FDDI : case NETTL_SUBSYS_EISA_FDDI : case NETTL_SUBSYS_PCI_FDDI : case NETTL_SUBSYS_HSC_FDDI : wth->file_encap = WTAP_ENCAP_NETTL_FDDI; break; case NETTL_SUBSYS_TOKEN : case NETTL_SUBSYS_PCI_TR : wth->file_encap = WTAP_ENCAP_NETTL_TOKEN_RING; break; case NETTL_SUBSYS_NS_LS_IP : case NETTL_SUBSYS_NS_LS_LOOPBACK : case NETTL_SUBSYS_NS_LS_TCP : case NETTL_SUBSYS_NS_LS_UDP : case NETTL_SUBSYS_NS_LS_IPV6 : wth->file_encap = WTAP_ENCAP_NETTL_RAW_IP; break; case NETTL_SUBSYS_NS_LS_ICMP : wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMP; break; case NETTL_SUBSYS_NS_LS_ICMPV6 : wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6; break; case NETTL_SUBSYS_NS_LS_TELNET : wth->file_encap = WTAP_ENCAP_NETTL_RAW_TELNET; break; default: /* If this assumption is bad, the read will catch it */ wth->file_encap = WTAP_ENCAP_NETTL_ETHERNET; } if (file_seek(wth->fh, FILE_HDR_SIZE, SEEK_SET, err) == -1) { return -1; } wth->tsprecision = WTAP_FILE_TSPREC_USEC; return 1; }
static BOOLEAN read_config_file(EFI_LOADED_IMAGE *image, CHAR16 **options, UINT32 *options_size) { struct file *file; EFI_STATUS err; CHAR16 path[4096]; CHAR16 *u_buf, *q; char *a_buf, *p; UINT64 size; int i; err = get_path(image, path, sizeof(path)); if (err != TRUE) return FALSE; err = file_open(image, path, &file); if (err != EFI_SUCCESS) return FALSE; err = file_size(file, &size); if (err != EFI_SUCCESS) goto fail; /* * The config file contains ASCII characters, but the command * line parser expects arguments to be UTF-16. Convert them * once we've read them into 'a_buf'. */ /* Make sure we don't overflow the UINT32 */ if (size > 0xffffffff || (size * 2) > 0xffffffff ) { Print(L"Config file size too large. Ignoring.\n"); goto fail; } a_buf = malloc((UINTN)size); if (!a_buf) { Print(L"Failed to alloc buffer %d bytes\n", size); goto fail; } u_buf = malloc((UINTN)size * 2); if (!u_buf) { Print(L"Failed to alloc buffer %d bytes\n", size); free(a_buf); goto fail; } err = file_read(file, (UINTN *)&size, a_buf); if (err != EFI_SUCCESS) goto fail; Print(L"Using efilinux config file\n"); /* * Read one line. Stamp a NUL-byte into the buffer once we've * read the end of the first line. */ for (p = a_buf, i = 0; *p && *p != '\n' && i < size; p++, i++) ; if (*p == '\n') *p++ = '\0'; if (i == size && *p) { Print(L"Error: missing newline at end of config file?\n"); goto fail; } if ((p - a_buf) < size) Print(L"Warning: config file contains multiple lines?\n"); p = a_buf; q = u_buf; for (i = 0; i < size; i++) *q++ = *p++; free(a_buf); *options = u_buf; *options_size = (UINT32)size * 2; file_close(file); return TRUE; fail: file_close(file); return FALSE; }
int iseries_open (wtap * wth, int *err, gchar ** err_info) { int bytes_read; gint offset; char magic[ISERIES_LINE_LENGTH]; char unicodemagic[] = { '\x43', '\x00', '\x4F', '\x00', '\x4D', '\x00', '\x4D', '\x00', '\x55', '\x00', '\x4E', '\x00', '\x49', '\x00', '\x43', '\x00', '\x41' }; /* * Check that file starts with a valid iSeries COMMS TRACE header * by scanning for it in the first line */ errno = WTAP_ERR_CANT_READ; bytes_read = file_read (&magic, sizeof magic, wth->fh); if (bytes_read != sizeof magic) { *err = file_error (wth->fh, err_info); if (*err != 0 && *err != WTAP_ERR_SHORT_READ) return -1; return 0; } /* * Check if this is a UNICODE formatted file by scanning for the magic string */ offset=0; while ((unsigned)offset < (ISERIES_LINE_LENGTH - (sizeof unicodemagic))) { if (memcmp (magic + offset, unicodemagic, sizeof unicodemagic) == 0) { if (file_seek (wth->fh, 0, SEEK_SET, err) == -1) { return 0; } /* * Do some basic sanity checking to ensure we can handle the * contents of this trace */ if (!iseries_check_file_type (wth, err, err_info, ISERIES_FORMAT_UNICODE)) { if (*err == 0) return 0; else return -1; } wth->file_encap = WTAP_ENCAP_ETHERNET; wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_ISERIES; wth->snapshot_length = 0; wth->subtype_read = iseries_read; wth->subtype_seek_read = iseries_seek_read; wth->tsprecision = WTAP_FILE_TSPREC_USEC; if (file_seek (wth->fh, 0, SEEK_SET, err) == -1) { return 0; } return 1; } offset += 1; } /* * Check if this is a ASCII formatted file by scanning for the magic string */ offset=0; while (offset < (ISERIES_LINE_LENGTH - ISERIES_HDR_MAGIC_LEN)) { if (memcmp (magic + offset, ISERIES_HDR_MAGIC_STR, ISERIES_HDR_MAGIC_LEN) == 0) { if (file_seek (wth->fh, 0, SEEK_SET, err) == -1) { return 0; } /* * Do some basic sanity checking to ensure we can handle the * contents of this trace */ if (!iseries_check_file_type (wth, err, err_info, ISERIES_FORMAT_ASCII)) { if (*err == 0) return 0; else return -1; } wth->file_encap = WTAP_ENCAP_ETHERNET; wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_ISERIES; wth->snapshot_length = 0; wth->subtype_read = iseries_read; wth->subtype_seek_read = iseries_seek_read; wth->tsprecision = WTAP_FILE_TSPREC_USEC; if (file_seek (wth->fh, 0, SEEK_SET, err) == -1) { return 0; } return 1; } offset += 1; } /* Neither ASCII or UNICODE so not supported */ return 0; }
static bool try_load(ang_file *f) { byte savefile_head[SAVEFILE_HEAD_SIZE]; u32b block_version, block_size; char *block_name; while (TRUE) { size_t i; int (*loader)(void) = NULL; /* Load in the next header */ size_t size = file_read(f, (char *)savefile_head, SAVEFILE_HEAD_SIZE); if (!size) break; if (size != SAVEFILE_HEAD_SIZE || savefile_head[15] != 0) { note("Savefile is corrupted -- block header mangled."); return FALSE; } #define RECONSTRUCT_U32B(from) \ ((u32b) savefile_head[from]) | \ ((u32b) savefile_head[from+1] << 8) | \ ((u32b) savefile_head[from+2] << 16) | \ ((u32b) savefile_head[from+3] << 24); block_name = (char *) savefile_head; block_version = RECONSTRUCT_U32B(16); block_size = RECONSTRUCT_U32B(20); /* pad to 4 bytes */ if (block_size % 4) block_size += 4 - (block_size % 4); /* Find the right loader */ for (i = 0; i < N_ELEMENTS(loaders); i++) { if (streq(block_name, loaders[i].name) && block_version == loaders[i].version) { loader = loaders[i].load; } } if (!loader) { /* No loader found */ note("Savefile too old. Try importing it into an older Angband first."); return FALSE; } /* Allocate space for the buffer */ buffer = mem_alloc(block_size); buffer_pos = 0; buffer_check = 0; buffer_size = file_read(f, (char *) buffer, block_size); if (buffer_size != block_size) { note("Savefile is corrupted -- not enough bytes."); mem_free(buffer); return FALSE; } /* Try loading */ if (loader() != 0) { note("Savefile is corrupted."); mem_free(buffer); return FALSE; } mem_free(buffer); } /* Still alive */ if (p_ptr->chp >= 0) { /* Reset cause of death */ my_strcpy(p_ptr->died_from, "(alive and well)", sizeof(p_ptr->died_from)); } return TRUE; }
UINT8 fontpc88_read(const OEMCHAR *filename, UINT8 loading) { FILEH fh; UINT8 *work; OEMCHAR fname[MAX_PATH]; work = (UINT8 *)_MALLOC(0x20000, "pc88font"); if (work == NULL) { goto fr88_err1; } file_cpyname(fname, filename, NELEMENTS(fname)); // 第2水準以外を読む必要はある? if (loading & (FONT_ANK8 | FONTLOAD_ANK | FONT_KNJ1)) { // あったら読み込んでみる file_cutname(fname); file_catname(fname, pc88knj1name, NELEMENTS(fname)); fh = file_open_rb(fname); if (fh != FILEH_INVALID) { if (file_read(fh, work, 0x20000) == 0x20000) { // 8dot ANKを読む必要があるか if (loading & FONT_ANK8) { loading &= ~FONT_ANK8; fontdata_ank8store(work + 0x1000, 0, 256); } // 16dot ASCIIを読む必要があるか if (loading & FONT_ANK16a) { loading &= ~FONT_ANK16a; CopyMemory(fontrom + 0x80000, work + 0x0000, 16*128); } // 16dot ANK(0x80〜)を読む必要があるか if (loading & FONT_ANK16b) { loading &= ~FONT_ANK16b; CopyMemory(fontrom + 0x80800, work + 0x0800, 16*128); } // 第一水準漢字を読み込む? if (loading & FONT_KNJ1) { loading &= ~FONT_KNJ1; pc88knjcpy1(fontrom, work, 0x01, 0x30); fontdata_patchjis(); } } // クローズして セクション終わり file_close(fh); } } // 第2水準を読む必要はある? if (loading & FONT_KNJ2) { // あったら読み込んでみる file_cutname(fname); file_catname(fname, pc88knj2name, NELEMENTS(fname)); fh = file_open_rb(fname); if (fh != FILEH_INVALID) { if (file_read(fh, work, 0x20000) == 0x20000) { loading &= ~FONT_KNJ2; pc88knjcpy2(fontrom, work, 0x31, 0x56); } // クローズして セクション終わり file_close(fh); } } // ANKを読み込む必要はある? if (loading & (FONT_ANK8 | FONTLOAD_ANK)) { // あったら読み込んでみる file_cutname(fname); file_catname(fname, pc88ankname, NELEMENTS(fname)); fh = file_open_rb(fname); if (fh != FILEH_INVALID) { // 読み込んでみる if (file_read(fh, work, 0x1800) == 0x1800) { // 8dot ANKを読む必要があるか if (loading & FONT_ANK8) { loading &= ~FONT_ANK8; fontdata_ank8store(work + 0x0000, 0, 256); } // 16dot ASCIIを読む必要があるか if (loading & FONT_ANK16a) { loading &= ~FONT_ANK16a; CopyMemory(fontrom + 0x80000, work + 0x0800, 16*128); } // 16dot ANK(0x80〜)を読む必要があるか if (loading & FONT_ANK16b) { loading &= ~FONT_ANK16b; CopyMemory(fontrom + 0x80800, work + 0x1000, 16*128); } } // クローズして ANKは終わり file_close(fh); } } _MFREE(work); fr88_err1: return(loading); }
/* * Read a record trailer. * On success, returns the packet encapsulation type. * On error, returns -1 (which is WTAP_ENCAP_PER_PACKET, but we'd * never return that on success). * For metadata packets, returns 0 (which is WTAP_ENCAP_UNKNOWN, but * we'd never return that on success). */ static int netmon_read_rec_trailer(FILE_T fh, int trlr_size, int *err, gchar **err_info) { int bytes_read; union { struct netmonrec_2_1_trlr trlr_2_1; struct netmonrec_2_2_trlr trlr_2_2; struct netmonrec_2_3_trlr trlr_2_3; } trlr; guint16 network; int pkt_encap; errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&trlr, trlr_size, fh); if (bytes_read != trlr_size) { *err = file_error(fh, err_info); if (*err == 0 && bytes_read != 0) { *err = WTAP_ERR_SHORT_READ; } return -1; /* error */ } network = pletohs(trlr.trlr_2_1.network); if ((network & 0xF000) == NETMON_NET_PCAP_BASE) { /* * Converted pcap file - the LINKTYPE_ value * is the network value with 0xF000 masked off. */ network &= 0x0FFF; pkt_encap = wtap_pcap_encap_to_wtap_encap(network); if (pkt_encap == WTAP_ENCAP_UNKNOWN) { *err = WTAP_ERR_UNSUPPORTED_ENCAP; *err_info = g_strdup_printf("netmon: converted pcap network type %u unknown or unsupported", network); return -1; /* error */ } } else if (network < NUM_NETMON_ENCAPS) { /* * Regular NetMon encapsulation. */ pkt_encap = netmon_encap[network]; if (pkt_encap == WTAP_ENCAP_UNKNOWN) { *err = WTAP_ERR_UNSUPPORTED_ENCAP; *err_info = g_strdup_printf("netmon: network type %u unknown or unsupported", network); return -1; /* error */ } } else { /* * Special packet type for metadata. */ switch (network) { case NETMON_NET_NETEVENT: case NETMON_NET_NETWORK_INFO_EX: case NETMON_NET_PAYLOAD_HEADER: case NETMON_NET_NETWORK_INFO: case NETMON_NET_DNS_CACHE: case NETMON_NET_NETMON_FILTER: /* * Just ignore those record types, for * now. Tell our caller to read the next * record. */ return 0; default: *err = WTAP_ERR_UNSUPPORTED_ENCAP; *err_info = g_strdup_printf("netmon: network type %u unknown or unsupported", network); return -1; /* error */ } } return pkt_encap; /* success */ }