Esempio n. 1
0
int path_to_inumber(struct unixfilesystem *fs, const char *pathname,uint16_t dirinumber){
	struct direntv6 buf;
	// The pathname is to a file
	if(plain_name(pathname)){
		int success = directory_findname(fs,pathname,dirinumber, &buf);
		if (success < 0){
			return -1;
		}
		// Return the inumber
		return buf.d_inumber;
	// The pathname is to a directory
	}else{
		// The first directory in the pathname
		char *dir = first(pathname);
		int success = directory_findname(fs, dir, dirinumber, &buf);
		// Check for errors
		if (success < 0){
			return -1;
		}
		// The rest of the pathname
		const char *restOfPath = rest(pathname);
		dirinumber = buf.d_inumber;
		free(dir);
		return path_to_inumber(fs,restOfPath,dirinumber);
	}
	
}
/*
 * Return the inumber associated with the specified pathname. This need 
 * handle absolute paths or normal path. Return a negative number if an error is encountered.
 */
int
pathname_lookup(struct unixfilesystem *fs, const char *pathname)
{
  //fprintf(stderr, "pathname_lookup(path=%s), unimplemented. Returing -1.\n", pathname);
  //return -1;
  struct direntv6 dirEnt;
  
  //printf("pathname = %s\n",pathname);
  
  /* handle normal name */
  
  if (pathname[0] != '/') {
      //printf("pathname_lookup find normal Name\n");
      int err = directory_findname(fs, pathname, fs->workDirInumber, &dirEnt);
      if (err < 0) {
          fprintf(stderr, "normal_name_lookup find dirName %s err");
          return -1;
      }
      return dirEnt.d_inumber;
  }
  
  int i, inumber = ROOT_INUMBER;
  char dirName[20];
  for (i = 0; pathname[i] != '\0';) {
      if (pathname[i] == '/') {
          
          i++;
          int cnt = 0;
          while (pathname[i] != '/' && pathname[i] != '\0') {
              dirName[cnt++] = pathname[i++];
              if (cnt > 14) {
                  fprintf(stderr, "pathname %s is illegal", pathname);
                  return -1;
              }
          }
          dirName[cnt] = '\0';
          /* after above loop, i must ended with pathname[i] == '/' or '\0' */
          
          if (dirName[0] == '\0') {
              //printf("pathname_lookup start disk from ROOT_DIR\n");
              return ROOT_INUMBER;
          }
          
          int err = directory_findname(fs, dirName, inumber, &dirEnt);
          if (err < 0) {
              fprintf(stderr, "pathname_lookup find dirName %s not exist %d\n", dirName, inumber);
              return -1;
          }
          
          inumber = dirEnt.d_inumber; 
          // inumber update to dirEnt.d_inumber leads to next directory
      }
  }
  return inumber;
}
Esempio n. 3
0
/*
 * Wrapper function to call directory_findname to get the inumber for the
 * given directory name.
 */
int name_to_inode_number(struct unixfilesystem *fs, const char *name, int dir)
{
  struct direntv6 file;
  int check = directory_findname(fs, name, dir, &file); 

  if(check == 0) return file.d_inumber;
  else return -1;
}
Esempio n. 4
0
/*
 * Return the inumber associated with the specified pathname. This need only
 * handle absolute paths. Return a negative number if an error is encountered.
 */
int
pathname_lookup(struct unixfilesystem *fs, const char *pathname)
{

    char* path = strdup(pathname);
    char* tok = NULL;
    tok = strtok(path,"/");
    int direntry = ROOT_INUMBER;
    while (tok != NULL)
    {
        struct direntv6 dirEnt;
        //printf("dirent: %s\n", dirEnt.d_name);
        if (directory_findname(fs, tok, direntry, &dirEnt) != 0)
            return direntry;
        direntry = dirEnt.d_inumber;
        tok = strtok(NULL,"/");
    }

    return direntry;

}
Esempio n. 5
0
/*
 * Return the inumber associated with the specified pathname. This need only
 * handle absolute paths. Return a negative number if an error is encountered.
 */
int
pathname_lookup(struct unixfilesystem *fs, const char *pathname)
{
	if(strcmp(pathname, "/") == 0) return ROOT_INUMBER;	//check if it's root
	struct direntv6 entry;
	
	int dirinumber = ROOT_INUMBER;
	char *path = malloc(strlen(pathname) + 1);
	memcpy(path, pathname, strlen(pathname) + 1); //copy pathname into path because strtok cannot be used on constant strings

	char *tokens = strtok(path, "/"); //tokenizes the string path
	
	while(tokens != NULL) {
		
		if(directory_findname(fs, tokens, dirinumber, &entry) <  0) return -1; //return negative value on failure
		dirinumber = entry.d_inumber;
		tokens = strtok(NULL, "/"); //read next token
	}

	free(path);
	return dirinumber;
}