static boolean_t contains_valid_dirs(char *dirs_str) { boolean_t rc = B_FALSE; boolean_t rc_validate_path = B_TRUE; char *tok_ptr; char *tok_lasts; if (dirs_str == NULL) { return (rc); } if ((tok_ptr = strtok_r(dirs_str, ",", &tok_lasts)) != NULL) { if (validate_path(tok_ptr)) { rc = B_TRUE; } else { rc_validate_path = B_FALSE; } while ((tok_ptr = strtok_r(NULL, ",", &tok_lasts)) != NULL) { if (validate_path(tok_ptr)) { rc = B_TRUE; } else { rc_validate_path = B_FALSE; } } } if (rc && !rc_validate_path) { (void) fprintf(stderr, gettext("%s: at least one valid " "directory path found\n"), progname); } return (rc); }
gchar * cockpit_package_resolve (GHashTable *listing, const gchar *package, const gchar *path) { CockpitPackage *mod; /* * This is *not* a security check. We're accessing files as the user. * What this does is prevent package authors from drawing outside the * lines. Keeps everyone honest. */ if (strstr (path, "../") || strstr (path, "/..") || !validate_path (path)) { g_message ("invalid 'path' used as a resource: %s", path); return NULL; } if (!validate_checksum (package) && !validate_package (package)) { g_message ("invalid 'package' name: %s", package); return NULL; } mod = g_hash_table_lookup (listing, package); if (mod == NULL) { g_debug ("resource package was not found: %s", package); return NULL; } return g_build_filename (mod->directory, path, NULL); }
static void fn_open(l4fdx_srv_obj srv_obj, struct internal_request *r) { struct file *f; struct l4fdx_result_t ret; struct l4fdx_client *c = srv_obj->client; int err, fid = -1; char const *path = r->open.path; if (c->basepath) { unsigned l = strlen(path); char *s = kmalloc(c->basepath_len + l + 1, GFP_KERNEL); if (!s) { err = -ENOMEM; goto out; } strncpy(s, c->basepath, c->basepath_len); strncpy(s + c->basepath_len, path, l); s[c->basepath_len + l] = 0; if (!validate_path(s, c->basepath_len + l)) { kfree(s); err = -EINVAL; goto out; } path = s; } call_fdx_event(c, "pre-open", path, UMH_WAIT_PROC); f = filp_open(path, r->open.flags & c->openflags_mask, r->open.mode); if (IS_ERR(f)) { err = PTR_ERR(f); } else { fid = set_free_fdxslot(c, f); if (fid == -1) { filp_close(f, NULL); err = -ENOMEM; } else err = 0; } if (c->flag_nogrow && err == 0) { struct kstat stat; int r = vfs_getattr(&f->f_path, &stat); c->max_file_size = r ? 0 : stat.size; } call_fdx_event(c, "post-open", path, UMH_WAIT_EXEC); if (c->basepath) kfree(path); out: ret.payload.fid = fid; ret.payload.ret = err; res_event(srv_obj, &ret, r->client_req_id); kfree(r); }
int cmd_renew(int argc, char **argv) { long long ts = renew_timeout(); off_t offset = 0; int opt, fd, r; optind = 0; while ((opt = getopt(argc, argv, "+hdr:o:t:")) != -1) { switch (opt) { case 'h': usage(); break; case 'd': debug++; break; case 'r': request = optarg; break; case 'o': offset = strtoul(optarg, 0, 0); break; case 't': ts = strtoll(optarg, 0, 0); break; } } if (argc - optind < 4) usage(); path = argv[optind++]; validate_path(path); id = argv[optind++]; validate_id(id); lease_ms = strtoul(argv[optind++], 0, 0); op_max_ms = strtoul(argv[optind++], 0, 0); validate_lease_params(lease_ms, op_max_ms); DEBUG("path '%s' offset %ld id '%s' lease_ms %ld op_max_ms %ld", path, offset, id, lease_ms, op_max_ms); if ((fd = open(path, O_RDWR | O_DIRECT)) < 0) panic("can't open '%s'", path); r = renew(fd, offset, id, &ts); close(fd); /* print out the last successful renewal timestamp, or zero for don't renew */ printf("%lld\n", ts); if (r == 1) { DEBUG("Succeeded"); return 0; } DEBUG("%s (%s)", "Failed", strerror(r)); return 1; }
static void do_cd (void) { char *p; p = arg_data [arg_cur++]; if (!p) { fprintf (vfserr, "Takes a directory argument\n"); return; } if (!g_ascii_strcasecmp (p, "..")) { guint lp; char **tmp; GString *newp = g_string_new (""); const char *ptr = g_path_skip_root (cur_dir); g_string_append_len (newp, cur_dir, ptr - cur_dir); tmp = g_strsplit_set (ptr, DIR_SEPARATORS, -1); lp = 0; if (!tmp [lp]) return; while (tmp [lp + 1] && strlen (tmp [lp + 1]) > 0) { g_string_append_printf (newp, "%s" G_DIR_SEPARATOR_S, tmp [lp]); lp++; } cur_dir = newp->str; g_string_free (newp, FALSE); } else if (!g_ascii_strcasecmp (p, ".")) { } else { char *newpath; if (g_path_is_absolute (p)) { if (!G_IS_DIR_SEPARATOR (p [strlen (p) - 1])) newpath = g_strconcat (p, G_DIR_SEPARATOR_S, NULL); else newpath = g_strdup (p); } else { char *ptr; ptr = get_regexp_name (p, cur_dir, TRUE); if (!ptr) { fprintf (vfserr, "Can't find '%s'\n", p); return; } newpath = g_strconcat (cur_dir, ptr, G_DIR_SEPARATOR_S, NULL); } if (validate_path (newpath)) { cur_dir = newpath; } else fprintf (vfserr, "Invalid path %s\n", newpath); } }
int cmd_acquire(int argc, char **argv) { int opt, fd, r, b = 0; off_t offset = 0; long long ts; optind = 0; while ((opt = getopt(argc, argv, "+hdr:bo:")) != -1) { switch (opt) { case 'h': usage(); break; case 'd': debug++; break; case 'r': request = optarg; break; case 'b': b = 1; break; case 'o': offset = strtoul(optarg, 0, 0); break; } } if (argc - optind < 4) usage(); path = argv[optind++]; validate_path(path); id = argv[optind++]; validate_id(id); lease_ms = strtoul(argv[optind++], 0, 0); op_max_ms = strtoul(argv[optind++], 0, 0); validate_lease_params(lease_ms, op_max_ms); DEBUG("path '%s' offset %ld id '%s' lease_ms %ld op_max_ms %ld", path, offset, id, lease_ms, op_max_ms); if ((fd = open(path, O_RDWR | O_DIRECT)) < 0) panic("can't open '%s'", path); r = acquire(fd, offset, id, b, &ts); close(fd); if (r == 1) { /* print last successful timestamp == aquire time */ printf("%lld", ts); DEBUG("Succeeded"); return 0; } else DEBUG("%s (%s)", "Failed", strerror(r)); return 1; }
/* vxdb.mount.get(string name[, string dst]) */ xmlrpc_value *m_vxdb_mount_get(xmlrpc_env *env, xmlrpc_value *p, void *c) { xmlrpc_value *params, *response = NULL; char *name, *dst; int rc; xid_t xid; params = method_init(env, p, c, VCD_CAP_MOUNT, M_OWNER); method_return_if_fault(env); xmlrpc_decompose_value(env, params, "{s:s,s:s,*}", "name", &name, "dst", &dst); method_return_if_fault(env); method_empty_params(1, &dst); if (dst && !validate_path(dst)) method_return_faultf(env, MEINVAL, "invalid dst value: %s", dst); if (!(xid = vxdb_getxid(name))) method_return_fault(env, MENOVPS); if (dst) rc = vxdb_prepare(&dbr, "SELECT src,dst,type,opts FROM mount " "WHERE xid = %d AND dst = '%s'", xid, dst); else rc = vxdb_prepare(&dbr, "SELECT src,dst,type,opts FROM mount " "WHERE xid = %d ORDER BY dst ASC", xid); if (rc != VXDB_OK) method_return_vxdb_fault(env); response = xmlrpc_array_new(env); vxdb_foreach_step(rc, dbr) xmlrpc_array_append_item(env, response, xmlrpc_build_value(env, "{s:s,s:s,s:s,s:s}", "src", vxdb_column_text(dbr, 0), "dst", vxdb_column_text(dbr, 1), "type", vxdb_column_text(dbr, 2), "opts", vxdb_column_text(dbr, 3))); if (rc != VXDB_DONE) method_set_vxdb_fault(env); vxdb_finalize(dbr); return response; }
/* * Name: dir_help * Purpose: To prompt the user and list the directory contents * Date: February 13, 1992 * Passed: window: pointer to current window */ int dir_help( WINDOW *window ) { char dname[MAX_COLS+2]; /* directory search pattern */ char stem[MAX_COLS+2]; /* directory stem */ char drive[_MAX_DRIVE]; /* splitpath drive buff */ char dir[_MAX_DIR]; /* splitpath dir buff */ char fname[_MAX_FNAME]; /* splitpath fname buff */ char ext[_MAX_EXT]; /* splitpath ext buff */ int rc; int file_mode; int bin_length; int prompt_line; if (window != NULL) { entab_linebuff( ); if (un_copy_line( window->ll, window, TRUE ) == ERROR) return( ERROR ); prompt_line = window->bottom_line; } else prompt_line = g_display.nlines; /* * search path or pattern */ dname[0] = '\0'; rc = get_name( dir1, prompt_line, dname, g_display.message_color ); if (rc == OK) { if (validate_path( dname, stem ) == OK) { rc = list_and_pick( dname, stem, window ); /* * if everything is everything, load in the file selected by user. */ if (rc == OK) { file_mode = TEXT; bin_length = 0; _splitpath( dname, drive, dir, fname, ext ); if (stricmp( ext, ".exe" ) == 0 || stricmp( ext, ".com" ) == 0) { file_mode = BINARY; bin_length = g_status.file_chunk; } if (window != NULL) attempt_edit_display( dname, LOCAL, file_mode, bin_length ); else attempt_edit_display( dname, GLOBAL, file_mode, bin_length ); } } else /* * invalid path or file name */ error( WARNING, window != NULL ? window->bottom_line : g_display.nlines, dir2 ); } return( rc ); }
/* * The function vfs_read provides the ability to read data from * an absolute path 'path,' which should specify an existing file. * It will attempt to read 'size' bytes starting at the specified * offset (offset) from the specified file (path) * on your filesystem into the memory address 'buf'. The return * value is the amount of bytes actually read; if the file is * smaller than size, vfs_read will simply return the most amount * of bytes it could read. * * HINT: You should be able to ignore 'fi' * */ static int vfs_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi) { if(validate_path(path) != 0) return -1; // Function variables char block[BLOCKSIZE]; memset(&block,0,BLOCKSIZE); int bytesread = 0; vcb vb = getvcb(); path++; // Parse offset into block and "into" block int offset_block = (int) (offset / 512); int offset_into_block = offset % 512; int buffer_offset = 0; // Read offset datablock into memory dread(offset_block + vb.db_start, block); // Memcpy the rest of the block or size amount, whichever bounds first while(size > 0 && offset_into_block < BLOCKSIZE){ buf[buffer_offset] = block[offset_into_block]; size--; offset_into_block++; buffer_offset++; bytesread++; } // The rest of the first block has been read, // size bytes remain to be read while(size > 0){ if(offset_into_block == BLOCKSIZE){ // Get next fat entry / data block offset offset_block = getfe(offset_block).next; // Read in next datablock to block memset(&block,0,BLOCKSIZE); dread(offset_block + vb.db_start, block); // Reset pointers offset_into_block = 0; } else{ // Read byte into buffer buf[buffer_offset] = block[offset_into_block]; size--; offset_into_block++; buffer_offset++; bytesread++; } } return bytesread; }
/* * Given an absolute path to a file (for example /a/b/myFile), vfs_create * will create a new file named myFile in the /a/b directory. * */ static int vfs_create(const char *path, mode_t mode, struct fuse_file_info *fi) { vcb vb = getvcb(); // Get our VCB, used to find start/end points of dirents. if(validate_path(path) != 0) // If the path is invalid, return an error. return -1; path++; // Increment path, getting rid of the leading /. int first_free = -1; // Index of first free dirent. // To create a file, we need to first read used dirents and search for a duplicate. for(int i = vb.de_start; i < vb.de_start+vb.de_length && first_free < 0; i++){ dirent de = getdirent(i); if(de.valid == 1){ if(strcmp(de.name, path) == 0) return -EEXIST; } else{ first_free = i; } } // File doesn't already exist. Next, check for free spaces. If free_flag != 0 first_free == idx of first free dirent. if(first_free >= 0){ // If free dirents exist... dirent new_file; // Creating a new dirent, and assign its fields. new_file.valid = 1; new_file.first_block = -1; // Used to indicate a file with no data. new_file.size = 0; new_file.userid = getuid(); new_file.groupid = getgid(); new_file.mode = mode; struct timespec newtime; clock_gettime(CLOCK_REALTIME, &newtime); new_file.access_time = newtime; new_file.modify_time = newtime; new_file.create_time = newtime; memset(new_file.name,0,sizeof(new_file.name)); //char file_name[27]; //memset(file_name,0,27); char file_name[512 - (3*sizeof(struct timespec)) - 24]; // Build the name string... memset(file_name,0,sizeof(file_name)); strcpy(file_name,path); // Save path in to filename. Note: path has already been incrimented, so we're good. strcpy(new_file.name, file_name); setdirent(first_free,new_file); // Finally, we write our new dirent to disk at the index of first_free. return 0; } return -1; // If we reached here, free_flag == 0, meaning no free dirents exist. }
static int build_path(ftp_session_t *session, const char *args) { int rc; char *p; memset(session->buffer, 0, sizeof(session->buffer)); if(validate_path(args) != 0) { errno = EINVAL; return -1; } if(args[0] == '/') { if(strlen(args) > sizeof(session->buffer)-1) { errno = ENAMETOOLONG; return -1; } strncpy(session->buffer, args, sizeof(session->buffer)); } else { if(strcmp(session->cwd, "/") == 0) rc = snprintf(session->buffer, sizeof(session->buffer), "/%s", args); else rc = snprintf(session->buffer, sizeof(session->buffer), "%s/%s", session->cwd, args); if(rc >= sizeof(session->buffer)) { errno = ENAMETOOLONG; return -1; } } p = session->buffer + strlen(session->buffer); while(p > session->buffer && *--p == '/') *p = 0; if(strlen(session->buffer) == 0) strcpy(session->buffer, "/"); return 0; }
int cmd_release(int argc, char **argv) { int opt, fd, r; int force = 0; off_t offset = 0; optind = 0; while ((opt = getopt(argc, argv, "+hdfo:")) != -1) { switch (opt) { case 'h': usage(); break; case 'd': debug++; break; case 'f': force++; break; case 'o': offset = strtoul(optarg, 0, 0); break; } } if (argc - optind < 2) usage(); path = argv[optind++]; validate_path(path); id = argv[optind++]; validate_id(id); DEBUG("path '%s' offset %ld id '%s' force %d", path, offset, id, force); if ((fd = open(path, O_RDWR | O_DIRECT)) < 0) panic("can't open '%s'", path); r = release(fd, offset, id, force); close(fd); if (r == 1) { DEBUG("Succeeded"); return 0; } else DEBUG("%s (%s)", "Failed", strerror(r)); return 1; }
/* * The function rename will rename a file or directory named by the * string 'oldpath' and rename it to the file name specified by 'newpath'. * * HINT: Renaming could also be moving in disguise * */ static int vfs_rename(const char *from, const char *to) { vcb vb = getvcb(); if(validate_path(from) != 0) return -1; from++; for(int i = vb.de_start; i < vb.de_start+vb.de_length;i++){ dirent de = getdirent(i); if(strcmp(de.name,from) == 0){ strcpy(de.name, to); return 0; } } return -1; }
/* * This function will update the file's last accessed time to * be ts[0] and will update the file's last modified time to be ts[1]. */ static int vfs_utimens(const char *file, const struct timespec ts[2]) { vcb vb = getvcb(); if(validate_path(file) != 0) return -1; // Invalid path. file++; for(int i = vb.de_start; i < vb.de_start+vb.de_length; i++){ dirent de = getdirent(i); if(strcmp(de.name,file)==0){ de.access_time = ts[0]; de.modify_time = ts[1]; setdirent(i,de); return 0; // Success } } return -1; // File not found. }
/* * This function will change the user and group of the file * to be uid and gid. This should only update the file's owner * and group. */ static int vfs_chown(const char *file, uid_t uid, gid_t gid) { vcb vb = getvcb(); if(validate_path(file) != 0) return -1; // Invalid path. file++; for(int i = vb.de_start; i < vb.de_start+vb.de_length; i++){ dirent de = getdirent(i); if(strcmp(de.name,file)==0){ de.userid = uid; de.groupid = gid; setdirent(i,de); return 0; // Success } } return -1; // File not found. }
/* * This function will change the permissions on the file * to be mode. This should only update the file's mode. * Only the permission bits of mode should be examined * (basically, the last 16 bits). You should do something like * * fcb->mode = (mode & 0x0000ffff); * */ static int vfs_chmod(const char *file, mode_t mode) { vcb vb = getvcb(); if(validate_path(file) != 0) return -1; // Invalid path. file++; for(int i = vb.de_start; i < vb.de_start+vb.de_length; i++){ dirent de = getdirent(i); if(strcmp(de.name,file)==0){ //de.mode = (mode & 0x0000ffff); de.mode = mode; setdirent(i,de); return 0; // Success } } return -1; // File not found. }
/** * This function deletes the last component of the path (e.g., /a/b/c you * need to remove the file 'c' from the directory /a/b). */ static int vfs_delete(const char *path) { vcb vb = getvcb(); // Get our VCB, used to find start/end points of dirents. if(validate_path(path) != 0) // If the path is invalid, return an error. return -1; path++; // Increment path, getting rid of the leading /. // To create a file, we need to first read used dirents and search for a duplicate. for(int i = vb.de_start; i < vb.de_start+vb.de_length; i++){ dirent de = getdirent(i); if(strcmp(de.name, path) == 0){ de.valid = 0; setdirent(i,de); return 0; } } return -EEXIST; /* 3600: NOTE THAT THE BLOCKS CORRESPONDING TO THE FILE SHOULD BE MARKED AS FREE, AND YOU SHOULD MAKE THEM AVAILABLE TO BE USED WITH OTHER FILES */ // TODO: Mark blocks as free. }
/* * This function will truncate the file at the given offset * (essentially, it should shorten the file to only be offset * bytes long). */ static int vfs_truncate(const char *file, off_t offset) { // First, we ensure thepath is valid. if(validate_path(file) != 0) return -1; file++; vcb vb = getvcb(); dirent de; int dirent_index = -1; for(int i = vb.de_start; i < vb.de_start + vb.de_length && dirent_index == -1; i++){ // Get matching dirent. de = getdirent(i); if(strcmp(de.name,file) == 0) dirent_index = i; } /* 3600: NOTE THAT ANY BLOCKS FREED BY THIS OPERATION SHOULD BE AVAILABLE FOR OTHER FILES TO USE. */ return 0; }
/* * Name: load_strokes * Purpose: load strokes from a file * Date: April 1, 1992 * Passed: window: pointer to current window * Notes: show the user a file pick list. I can never remember macro * file names or the directory in which they hide. might as well * give the user a file pick list. */ int load_strokes( WINDOW *window ) { register FILE *fp; /* file to be read */ char dname[MAX_COLS]; /* directory search pattern */ char stem[MAX_COLS]; /* directory stem */ register int rc; dname[0] = '\0'; /* * search path for macro file */ if (get_name( main21, window->bottom_line, dname, g_display.message_color ) == OK && *dname != '\0') { if (validate_path( dname, stem ) == OK) { rc = list_and_pick( dname, stem, window ); /* * if everything is everything, load in the file selected by user. */ if (rc == OK) { if ((fp = fopen( dname, "rb" )) != NULL && ceh.flag != ERROR) { fwrite( ¯o.first_stroke[0], sizeof(int), MAX_KEYS, fp ); fwrite( ¯o.strokes[0], sizeof(STROKES), STROKE_LIMIT, fp ); fclose( fp ); } if (ceh.flag == OK) connect_macros( ); } } else /* * invalid path or file name */ error( WARNING, window->bottom_line, main22 ); } return( OK ); }
/* * The function vfs_write will attempt to write 'size' bytes from * memory address 'buf' into a file specified by an absolute 'path'. * It should do so starting at the specified offset 'offset'. If * offset is beyond the current size of the file, you should pad the * file with 0s until you reach the appropriate length. * * You should return the number of bytes written. * * HINT: Ignore 'fi' */ static int vfs_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) { // First, we ensure thepath is valid. if(validate_path(path) != 0) return -1; vcb vb = getvcb(); path++; // Get rid of leading slash in path int byteswritten = 0; // Amount of bytes we've written to disk from buffer int num_pad = 0; // Amount of 0s we need to pad between EOF and offset int write_offset = 0; // variable to hold an offset for vfs_write. dirent de; int found_dirent = 0; int dirent_index = -1; for(int i = vb.de_start; i < vb.de_start + vb.de_length, found_dirent == 0; i++){ de = getdirent(i); if(de.valid == 1) if(strcmp(path,de.name)==0){ found_dirent = 1; dirent_index = i; } } if(found_dirent){ // Begin writing to disk. if(offset > de.size){ // Check for padding. num_pad = (offset - de.size); // Number of 0's to add. } if((size + offset) > de.size){ de.size = (size + offset); // Set the new size of the file. } // Update access modify times of file struct timespec newtime; clock_gettime(CLOCK_REALTIME, &newtime); de.access_time = newtime; de.modify_time = newtime; /* Next, since we have our dirent to write to, we must: - Check to see if the dirent has a FAT entry allocated. - Attempt to allocate one if necessary. x If the dirent has at least one FAT entry, begin writing: x Begin traversing offset, decrementing it as necessary until offset == 0. x Attempt to create new FAT entries if necessary. x Begin padding the file with zeros, if necessary, decrementing num_pad until it == 0. x Attempt to create new FAT entries if necessary. x Begin appending buf to file, decrementing size while doing so. x Attempt to create new FAT entries if necessary. x If, in any of the above cases, creating a new FAT entry fails, return -ENOSPC. */ // Check if found dirent has allocated FAT. If not, attempt to allocate one. if((int) de.first_block == -1){ char block[BLOCKSIZE]; int found_free = 0; for(int i = vb.fat_start;(i < vb.fat_start + ((int) (vb.fat_length/128))) && found_free == 0; i++){ // For each fat block... int block_index = (i-vb.fat_start)*128; memset(block,0,BLOCKSIZE); // Reset block. dread(i, block); // Read FAT Block into block. for(int j = 0; j < 128 && found_free == 0; j++){ fatent fe = getfe( block_index + j); if(fe.used == 0){ de.first_block = block_index + j; fe.used = 1; fe.eof = 1; fe.next = 0; found_free = 1; } } } if(found_free != 1){ return -ENOSPC; } } fatent fe = getfe(de.first_block); char block[BLOCKSIZE]; memset(block,0,BLOCKSIZE); // Expand file and pad 0's, if necessary. if(num_pad > 0){ int eof_fat_idx = get_eof_fe(&fe) + vb.db_start;// find index of eof dread(eof_fat_idx,block); int eof_data_idx; for(int i = 0; block[i] != EOF; i++) eof_data_idx++; eof_data_idx++; // Increment counter so block[eof_data_idx] == EOF. while(num_pad > 0){ if(eof_data_idx < BLOCKSIZE){ memset(&block[eof_data_idx],0,1); eof_data_idx++; num_pad--; if(num_pad == 0){ dwrite(eof_data_idx,block); memset(block,0,BLOCKSIZE); } } else{ dwrite(eof_fat_idx,block); memset(block,0,BLOCKSIZE); if(allocate_fat(&fe) != 0){ return -ENOSPC; } eof_fat_idx = get_eof_fe(&fe) + vb.db_start; eof_data_idx = 0; } } } // Now, we need to start writing size chars from buf into the file, starting at offset // Start by finding where offset is in the datablock. int offset_block = (int)(offset/512); int offset_into_block = offset % 512; int buffer_offset = 0; // Read in offset block, write at offset into block memset(block,0,BLOCKSIZE); dread(offset_block + vb.db_start, block); // Memcpy the rest of the block, or size bytes, whichever bounds first while(offset_into_block < BLOCKSIZE && size > 0){ memcpy(&block[offset_into_block], buf, 1); size--; buf++; buffer_offset++; offset_into_block++; byteswritten++; } // Write block rest of block dwrite(offset_block + vb.db_start, block); // While there remains bytes to be written... while(size > 0){ if(offset_into_block == BLOCKSIZE){ // Write block dwrite(offset_block + vb.db_start, block); // Allocate new fat/data block if(allocate_fat(&fe) != 0){ return -ENOSPC; } // reset offset_into_block offset_into_block = 0; offset_block = get_eof_fe(&fe); memset(block,0,BLOCKSIZE); } memcpy(&block[offset_into_block], &buf[buffer_offset], 1); size--; buffer_offset++; offset_into_block++; byteswritten++; } // Write the rest of size bytes dwrite(offset_block + vb.db_start, block); setdirent(dirent_index,de); return byteswritten; } else{ // No free dirents found return -1; } }
const fs::path& module_runtime_path(const std::string& dtype) { path_map& paths(module_paths()); path_map::iterator ipath(paths.find(dtype)); // Is this a valid dtype? if (ipath == paths.end()) { boost::format fmt("Invalid runtime path type “%1%”"); fmt % dtype; throw std::logic_error(fmt.str()); } Module& module = ipath->second; // Return cached result if previously determined. if(!module.realpath.empty()) return module.realpath; // dtype set explicitly in environment. if (getenv(module.envvar.c_str())) { fs::path dir(getenv(module.envvar.c_str())); if (validate_path(dir)) { module.realpath = boost::filesystem::canonical(dir); return module.realpath; } } // Full module path in environment + relative component if (getenv(module.module_envvar.c_str())) { fs::path home(getenv(module.module_envvar.c_str())); home /= module.relpath; if (validate_path(home)) { module.realpath = boost::filesystem::canonical(home); return module.realpath; } } // Full root path in environment + relative component if (getenv(module.root_envvar.c_str())) { fs::path home(getenv(module.root_envvar.c_str())); home /= module.relpath; if (validate_path(home)) { module.realpath = boost::filesystem::canonical(home); return module.realpath; } } // Full prefix is available only when configured explicitly. if (validate_path(module.install_prefix)) { // Full specific path. if (validate_path(module.abspath)) { module.realpath = boost::filesystem::canonical(module.abspath); return module.realpath; } // Full root path + relative component fs::path home(module.install_prefix); home /= module.relpath; if (validate_path(home)) { module.realpath = boost::filesystem::canonical(home); return module.realpath; } } else { fs::path module_lib_path; if (module.module_path) { module_lib_path = module.module_path(); } if (module_lib_path.has_parent_path()) { fs::path moduledir(module_lib_path.parent_path()); bool match = true; fs::path libdir(module.shlibpath); while(!libdir.empty()) { if (libdir.filename() == moduledir.filename()) { libdir = libdir.parent_path(); moduledir = moduledir.parent_path(); } else { match = false; break; } } if (match && validate_path(moduledir)) { moduledir /= module.relpath; if (validate_path(moduledir)) { module.realpath = boost::filesystem::canonical(moduledir); return module.realpath; } } } } boost::format fmt("Could not determine Bio-Formats runtime path for “%1%” directory"); fmt % dtype; throw std::runtime_error(fmt.str()); }
static gboolean package_checksum_file (GChecksum *checksum, GHashTable *depends, const gchar *root, const gchar *filename) { gchar *path = NULL; const gchar *string; GError *error = NULL; GChecksum *inner = NULL; GMappedFile *mapped = NULL; gboolean ret = FALSE; GList *output = NULL; GBytes *bytes; GList *l; if (!validate_path (filename)) { g_warning ("package has an invalid path name: %s", filename); goto out; } path = g_build_filename (root, filename, NULL); if (g_file_test (path, G_FILE_TEST_IS_DIR)) { ret = package_checksum_directory (checksum, depends, root, filename); goto out; } mapped = g_mapped_file_new (path, FALSE, &error); if (error) { g_warning ("couldn't open file: %s: %s", path, error->message); g_error_free (error); goto out; } bytes = g_mapped_file_get_bytes (mapped); output = cockpit_template_expand (bytes, gather_depends, depends); g_bytes_unref (bytes); inner = g_checksum_new (G_CHECKSUM_SHA1); for (l = output; l != NULL; l = g_list_next (l)) { g_checksum_update (inner, g_bytes_get_data (l->data, NULL), g_bytes_get_size (l->data)); } string = g_checksum_get_string (inner); /* * Place file name and hex checksum into checksum, * include the null terminators so these values * cannot be accidentally have a boundary discrepancy. */ g_checksum_update (checksum, (const guchar *)filename, strlen (filename) + 1); g_checksum_update (checksum, (const guchar *)string, strlen (string) + 1); ret = TRUE; out: g_list_free_full (output, (GDestroyNotify)g_bytes_unref); g_checksum_free (inner); if (mapped) g_mapped_file_unref (mapped); g_free (path); return ret; }
/* * * Given an absolute path to a file/directory (i.e., /foo ---all * paths will start with the root directory of the CS3600 file * system, "/"), you need to return the file attributes that is * similar stat system call. * * HINT: You must implement stbuf->stmode, stbuf->st_size, and * stbuf->st_blocks correctly. * */ static int vfs_getattr(const char *path, struct stat *stbuf) { fprintf(stderr, "vfs_getattr called\n"); // Do not mess with this code stbuf->st_nlink = 1; // hard links stbuf->st_rdev = 0; stbuf->st_blksize = BLOCKSIZE; /* 3600: YOU MUST UNCOMMENT BELOW AND IMPLEMENT THIS CORRECTLY */ /* if (The path represents the root directory) stbuf->st_mode = 0777 | S_IFDIR; else stbuf->st_mode = <<file mode>> | S_IFREG; stbuf->st_uid = // file uid stbuf->st_gid = // file gid stbuf->st_atime = // access time stbuf->st_mtime = // modify time stbuf->st_ctime = // create time stbuf->st_size = // file size stbuf->st_blocks = // file size in blocks */ if(strcmp(path, "/") == 0){ vcb vb = getvcb(); struct tm * tm1; struct tm * tm2; struct tm * tm3; tm1 = localtime(&((vb.access_time).tv_sec)); tm2 = localtime(&((vb.modify_time).tv_sec)); tm3 = localtime(&((vb.create_time).tv_sec)); stbuf->st_mode = 0777 | S_IFDIR; stbuf->st_uid = vb.userid; stbuf->st_gid = vb.groupid; stbuf->st_atime = mktime(tm1); stbuf->st_mtime = mktime(tm2); stbuf->st_ctime = mktime(tm3); stbuf->st_size = BLOCKSIZE; stbuf->st_blocks = 1; return 0; } else{ if(validate_path(path) != 0) // If the path is valid, we can proceed. return -1; path++; // char *filename = (char *) malloc(512 - (3 * sizeof(timespec)) - 24); for(int i = 1; i < 101; i++){ dirent de = getdirent(i); if(de.valid == 1){ if(strcmp(de.name, path) == 0){ struct tm * tm1; struct tm * tm2; struct tm * tm3; tm1 = localtime(&((de.access_time).tv_sec)); tm2 = localtime(&((de.modify_time).tv_sec)); tm3 = localtime(&((de.create_time).tv_sec)); stbuf->st_mode = de.mode | S_IFREG; stbuf->st_uid = de.userid; stbuf->st_gid = de.groupid; stbuf->st_atime = mktime(tm1); stbuf->st_mtime = mktime(tm2); stbuf->st_ctime = mktime(tm3); stbuf->st_size = de.size; stbuf->st_blocks = (de.size / BLOCKSIZE); return 0; }// End if }// End if }// End for loop return -ENOENT; } }
/* * Name: list_and_pick * Purpose: To show matching file names and let user pick a file * Date: February 13, 1992 * Passed: dname: directory search pattern * stem: stem of directory search pattern * window: pointer to current window * Returns: return code from pick. rc = OK, then edit a new file. * Notes: real work routine of this function. save the cwd and let the * user search upwards or downwards thru the directory structure. * since we are doing DOS directory functions, we need to check the * return code after each DOS call for critical errors. */ int list_and_pick( char *dname, char *stem, WINDOW *window ) { int rc; DTA dta; /* disk transfer address for findfirst */ DIRECTORY dir; /* contains all info for dir display */ unsigned int cnt; /* number of matching files */ FTYPE *flist, *p; /* pointer to list of matching files */ char cwd[MAX_COLS]; /* save the current working directory in this buff */ char dbuff[MAX_COLS]; /* temporary directory buff */ char prefix[MAX_COLS]; /* directory prefix */ int change_directory = FALSE; int stop; int len; int drive; /* * Some algorithms alloc the maximum possible number of files in * a directory, eg. 256 or 512. Let's count the number of matching * files so we know egxactly how much memory to request from calloc. * Depending on the op system, disk media, disk format, or version of DOS, * the max number of files may vary, anyway, also, additionally. */ rc = my_findfirst( &dta, dname, NORMAL | READ_ONLY | HIDDEN | SYSTEM | SUBDIRECTORY | ARCHIVE ); if (rc != ERROR) { for (cnt=1; (rc = my_findnext( &dta )) == OK;) ++cnt; flist = (FTYPE *)calloc( cnt, sizeof(FTYPE) ); } else flist = NULL; if (rc != ERROR && flist != NULL) { stop = FALSE; /* * If user entered drive name in search pattern, find out the drive and * directory stem. */ if (stem[1] == ':') { /* * If the second character of the search pattern is a ':', the * the first character of the pattern should be the drive. * Convert drive to lower case and get a numerical representation. * CAVEAT: In DOS v 2.x, there may be up to 63 logical drives. * my algorithm may blow up if the number of logical drives * is greater than 'Z'. * For DOS >= 3, the number of drives is limited to 26, I think. */ drive = stem[0]; if (drive < 'a') drive += 32; drive = drive - 'a' + 1; rc = get_current_directory( dbuff, drive ); if (rc == ERROR) stop = TRUE; else { /* * Put drive letter, ':', and '\' in front of current directory. */ prefix[0] = (char)(drive - 1 + 'a'); prefix[1] = ':'; prefix[2] = '\\'; prefix[3] = '\0'; assert( strlen( prefix ) + strlen( dbuff ) < MAX_COLS ); strcpy( cwd, prefix ); strcat( cwd, dbuff ); } /* * else get current directory from default drive */ } else { /* * 0 = default drive. */ drive = 0; rc = get_current_directory( dbuff, drive ); if (rc == ERROR) stop = TRUE; else { /* * Put a '\' in front of the current directory. */ prefix[0] = '\\'; prefix[1] = '\0'; assert( strlen( prefix ) + strlen( dbuff ) < MAX_COLS ); strcpy( cwd, prefix ); strcat( cwd, dbuff ); } } while (stop == FALSE) { /* * If we had enough memory, find all matching file names. Append * '\\' at the end of subdirectory names so user will know if * name is a directory. Might as well find everything, because * i also forget subdirectory names, too. * * when we get here, we have already done: 1) my_findfirst and * my_findnext, 2) counted the number of matching files, and * 3) allocated space. */ p = flist; cnt = 0; rc = my_findfirst( &dta, dname, NORMAL | READ_ONLY | HIDDEN | SYSTEM | SUBDIRECTORY | ARCHIVE ); if (rc != ERROR) { /* * p is pointer that walks down the file info structure. * save the file name, file size, and directory character, * if needed, for each matching file we find. */ assert( strlen( dta.name ) < 14 ); strcpy( p->fname, dta.name ); p->fsize = dta.size; if (dta.attrib & SUBDIRECTORY) strcat( p->fname, "\\" ); for (cnt=1; (rc = my_findnext( &dta )) == OK; ) { ++p; assert( strlen( dta.name ) < 14 ); strcpy( p->fname, dta.name ); p->fsize = dta.size; if (dta.attrib & SUBDIRECTORY) strcat( p->fname, "\\" ); cnt++; } } if (rc != ERROR) { shell_sort( flist, cnt ); /* * figure out number of rows, cols, etc... then display dir list */ setup_directory_window( &dir, cnt ); write_directory_list( flist, dir ); /* * Let user select file name or another search directory. * Save the choice in dbuff. rc == OK if user selected file or dir. */ rc = select_file( flist, stem, &dir ); assert( strlen( flist[dir.select].fname ) < MAX_COLS ); strcpy( dbuff, flist[dir.select].fname ); } /* * give memory back. */ free( flist ); if (rc == ERROR) stop = TRUE; else { len = strlen( dbuff ); /* * If the last character in a file name is '\' then let's * do a dir on selected directory. See the matching * else when the user selects a file. */ if (dbuff[len-1] == '\\') { /* * Stem has subdirectory path. dbuff has selected path. * Create a new dname with stem and dbuff. */ assert( strlen( stem ) + strlen( dbuff ) < MAX_COLS ); strcpy( dname, stem ); strcat( dname, dbuff ); len = strlen( dname ); strcpy( dbuff, dname ); /* * The last character in dbuff is '\', because we append the * '\' to every directory entry in the file list. Replace * it with a NULL char then we will have a valid path name. */ dbuff[len-1] = '\0'; /* * now let's change to the selected subdirectory. */ rc = set_current_directory( dbuff ); if (rc == OK) { /* * Every time we change directories, we need to get the * current directory so we will be sure to have the * correct path. */ rc = get_current_directory( dbuff, drive ); if (rc == OK) { assert( strlen( prefix ) + strlen( dbuff ) < MAX_COLS ); strcpy( dname, prefix ); strcat( dname, dbuff ); change_directory = TRUE; } } /* * Validate the new path and allocate memory for the * matching files. */ if (rc == OK) rc = validate_path( dname, stem ); if (rc == OK) { rc = my_findfirst( &dta, dname, NORMAL | READ_ONLY | HIDDEN | SYSTEM | SUBDIRECTORY | ARCHIVE ); if (rc != ERROR) { for (cnt=1; (rc = my_findnext( &dta )) == OK;) ++cnt; flist = (FTYPE *)calloc( cnt, sizeof(FTYPE) ); } } if (flist == NULL || rc == ERROR) { stop = TRUE; rc = ERROR; } } else { /* * user selected a file. store fname in dname and return. */ rc = OK; stop = TRUE; assert( strlen( stem ) + strlen( dbuff ) < MAX_COLS ); strcpy( dname, stem ); strcat( dname, dbuff ); } } } /* * Go back to the current directory if needed. */ if (change_directory) set_current_directory( cwd ); if (window != NULL) redraw_screen( window ); } else { /* * out of memory */ error( WARNING, window != NULL ? window->bottom_line : g_display.nlines, dir3 ); rc = ERROR; } return( rc ); }