static bool pak_close(pak_file_t *pak) { size_t itr; long tell; if (!pak) return false; /* * In insert mode we need to patch the header, and write * our directory entries at the end of the file. */ if (pak->insert) { if ((tell = fs_file_tell(pak->handle)) != 0) goto err; pak->header.dirlen = vec_size(pak->directories) * 64; pak->header.diroff = tell; /* patch header */ if (fs_file_seek (pak->handle, 0, SEEK_SET) != 0) goto err; fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle); /* write directories */ if (fs_file_seek (pak->handle, pak->header.diroff, SEEK_SET) != 0) goto err; for (itr = 0; itr < vec_size(pak->directories); itr++) { fs_file_write(&(pak->directories[itr]), sizeof(pak_directory_t), 1, pak->handle); } } vec_free (pak->directories); fs_file_close(pak->handle); mem_d (pak); return true; err: vec_free (pak->directories); fs_file_close(pak->handle); mem_d (pak); return false; }
/* * Extraction abilities. These work as you expect them to. */ static bool pak_extract_one(pak_file_t *pak, const char *file, const char *outdir) { pak_directory_t *dir = NULL; unsigned char *dat = NULL; char *local = NULL; FILE *out = NULL; if (!pak_exists(pak, file, &dir)) { return false; } if (!(dat = (unsigned char *)mem_a(dir->len))) goto err; /* * Generate the directory structure / tree that will be required * to store the extracted file. */ pak_tree_build(file); /* TODO portable path seperators */ util_asprintf(&local, "%s/%s", outdir, file); /* * Now create the file, if this operation fails. Then abort * It shouldn't fail though. */ if (!(out = fs_file_open(local, "wb"))) goto err; /* free memory for directory string */ mem_d(local); /* read */ if (fs_file_seek (pak->handle, dir->pos, SEEK_SET) != 0) goto err; fs_file_read (dat, 1, dir->len, pak->handle); fs_file_write(dat, 1, dir->len, out); fs_file_close(out); mem_d(dat); return true; err: if (dat) mem_d(dat); if (out) fs_file_close(out); return false; }
static pak_file_t *pak_open_write(const char *file) { pak_file_t *pak; if (!(pak = (pak_file_t*)mem_a(sizeof(pak_file_t)))) return NULL; /* * Generate the required directory structure / tree for * writing this PAK file too. */ pak_tree_build(file); if (!(pak->handle = fs_file_open(file, "wb"))) { /* * The directory tree that was created, needs to be * removed entierly if we failed to open a file. */ /* TODO backup directory clean */ mem_d(pak); return NULL; } memset(&(pak->header), 0, sizeof(pak_header_t)); /* * We're in "insert" mode, we need to do things like header * "patching" and writing the directories at the end of the * file. */ pak->insert = true; pak->header.magic = PAK_FOURCC; /* on BE systems we need to swap the byte order of the FOURCC */ util_endianswap(&pak->header.magic, 1, sizeof(uint32_t)); /* * We need to write out the header since files will be wrote out to * this even with directory entries, and that not wrote. The header * will need to be patched in later with a file_seek, and overwrite, * we could use offsets and other trickery. This is just easier. */ fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle); return pak; }
int sys_writepos(int fp, unsigned char *buf, size_t count) { struct file *f = file_get(fp); if(!f) return -EBADF; if(!count || !buf) { file_put(f); return -EINVAL; } if(!(f->flags & _FWRITE)) { file_put(f); return -EACCES; } if(f->flags & _FAPPEND) f->pos = f->inode->length; int ret = fs_file_write(f, buf, count); file_put(f); return ret; }
bool code_write(code_t *code, const char *filename, const char *lnofile) { prog_header_t code_header; fs_file_t *fp = NULL; code_create_header(code, &code_header, filename, lnofile); if (lnofile) { uint32_t version = 1; fp = fs_file_open(lnofile, "wb"); if (!fp) return false; util_endianswap(&version, 1, sizeof(version)); util_endianswap(code->linenums, vec_size(code->linenums), sizeof(code->linenums[0])); util_endianswap(code->columnnums, vec_size(code->columnnums), sizeof(code->columnnums[0])); if (fs_file_write("LNOF", 4, 1, fp) != 1 || fs_file_write(&version, sizeof(version), 1, fp) != 1 || fs_file_write(&code_header.defs.length, sizeof(code_header.defs.length), 1, fp) != 1 || fs_file_write(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 || fs_file_write(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 || fs_file_write(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 || fs_file_write(code->linenums, sizeof(code->linenums[0]), vec_size(code->linenums), fp) != vec_size(code->linenums) || fs_file_write(code->columnnums, sizeof(code->columnnums[0]), vec_size(code->columnnums), fp) != vec_size(code->columnnums)) { con_err("failed to write lno file\n"); } fs_file_close(fp); fp = NULL; } fp = fs_file_open(filename, "wb"); if (!fp) return false; if (1 != fs_file_write(&code_header, sizeof(prog_header_t) , 1 , fp) || vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) || vec_size(code->defs) != fs_file_write(code->defs, sizeof(prog_section_def_t) , vec_size(code->defs) , fp) || vec_size(code->fields) != fs_file_write(code->fields, sizeof(prog_section_field_t) , vec_size(code->fields) , fp) || vec_size(code->functions) != fs_file_write(code->functions, sizeof(prog_section_function_t) , vec_size(code->functions) , fp) || vec_size(code->globals) != fs_file_write(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) || vec_size(code->chars) != fs_file_write(code->chars, 1 , vec_size(code->chars) , fp)) { fs_file_close(fp); return false; } fs_file_close(fp); code_stats(filename, lnofile, code, &code_header); return true; }
/* * Insertion functions (the opposite of extraction). Yes for generating * PAKs. */ static bool pak_insert_one(pak_file_t *pak, const char *file) { pak_directory_t dir; unsigned char *dat; long len; FILE *fp; /* * We don't allow insertion on files that already exist within the * pak file. Weird shit can happen if we allow that ;). We also * don't allow insertion if the pak isn't opened in write mode. */ if (!pak || !file || !pak->insert || pak_exists(pak, file, NULL)) return false; if (!(fp = fs_file_open(file, "rb"))) return false; /* * Calculate the total file length, since it will be wrote to * the directory entry, and the actual contents of the file * to the PAK file itself. */ if (fs_file_seek(fp, 0, SEEK_END) != 0 || ((len = fs_file_tell(fp)) < 0)) goto err; if (fs_file_seek(fp, 0, SEEK_SET) != 0) goto err; dir.len = len; dir.pos = fs_file_tell(pak->handle); /* * We're limited to 56 bytes for a file name string, that INCLUDES * the directory and '/' seperators. */ if (strlen(file) >= 56) goto err; util_strncpy(dir.name, file, strlen(file)); /* * Allocate some memory for loading in the data that will be * redirected into the PAK file. */ if (!(dat = (unsigned char *)mem_a(dir.len))) goto err; fs_file_read (dat, dir.len, 1, fp); fs_file_close(fp); fs_file_write(dat, dir.len, 1, pak->handle); /* * Now add the directory to the directories vector, so pak_close * can actually write it. */ vec_push(pak->directories, dir); return true; err: fs_file_close(fp); return false; }