| 0,0 → 1,331 |
|---|
| /* This file contains the procedures that look up path names in the directory |
| * system and determine the inode number that goes with a given path name. |
| */ |
| |
| /* Methods: |
| * eat_path: the 'main' routine of the path-to-inode conversion mechanism |
| * last_dir: find the final directory on a given path |
| * advance: parse one component of a path name |
| * search_dir: search a directory for a string and return its inode number |
| * search_dir_ex: used for extended versions |
| */ |
| |
| |
| #include <string.h> |
| #include "fs.h" |
| #include "block.h" |
| #include "file.h" |
| #include "fproc.h" |
| #include "inode.h" |
| #include "super.h" |
| |
| |
| static char *get_name(char *old_name, char *string, int string_length); |
| |
| inode_t *eat_path(char *path) |
| { |
| |
| /* Parse the path 'path' and put its inode in the inode table. If not possible, |
| * return NIL_INODE as function value and an error code in 'err_code'. |
| */ |
| |
| register inode_t *ldip, *rip; |
| super_block_t *sp; |
| int name_len; |
| char string[name_len]; /* hold 1 path component name here */ |
| |
| name_len = NAME_MAX; |
| if ((sp = get_super()) == NIL_SUPER) |
| return NIL_INODE; |
| |
| if (sp->s_extend) { |
| name_len = NAME_MAX_EX; |
| } |
| |
| /* First open the path down to the final directory. */ |
| if ( (ldip = last_dir(path, string, name_len)) == NIL_INODE) |
| return NIL_INODE; /* we couldn't open final directory */ |
| |
| /* The path consisting only of "/" is a special case, check for it. */ |
| if (string[0] == '\0') |
| return ldip; |
| |
| /* Get final component of the path. */ |
| rip = advance(ldip, string, name_len); |
| put_inode(ldip); |
| |
| return rip; |
| } |
| |
| inode_t *last_dir(char *path, char *string, int string_length) |
| { |
| |
| /* Given a path, 'path', located in the fs address space, parse it as |
| * far as the last directory, fetch the inode for the last directory into |
| * the inode table, and return a pointer to the inode. In |
| * addition, return the final component of the path in 'string'. |
| * If the last directory can't be opened, return NIL_INODE and |
| * the reason for failure in 'err_code'. |
| */ |
| |
| register inode_t *rip; |
| register char *new_name; |
| register inode_t *new_ip; |
| |
| /* Is the path absolute or relative? Initialize 'rip' accordingly. */ |
| rip = (*path == '/' ? fp->fp_rootdir : fp->fp_workdir); |
| |
| /* If dir has been removed or path is empty, return FS_ENOENT. */ |
| if (rip->i_nlinks == 0 || *path == '\0') { |
| err_code = FS_ENOENT; |
| return NIL_INODE; |
| } |
| |
| dup_inode(rip); /* inode will be returned with put_inode */ |
| |
| /* Scan the path component by component. */ |
| while (TRUE) { |
| /* Extract one component. */ |
| if ( (new_name = get_name(path, string, string_length)) == (char*) 0) { |
| put_inode(rip); /* bad path in user space */ |
| return NIL_INODE; |
| } |
| if (*new_name == '\0') |
| { |
| if ( (rip->i_mode & I_TYPE) == I_DIRECTORY) |
| return rip; /* normal exit */ |
| else { |
| /* last file of path prefix is not a directory */ |
| put_inode(rip); |
| err_code = FS_ENOTDIR; |
| return NIL_INODE; |
| } |
| } |
| /* There is more path. Keep parsing. */ |
| new_ip = advance(rip, string, string_length); |
| put_inode(rip); |
| |
| if (new_ip == NIL_INODE) { |
| return NIL_INODE; |
| } |
| /* The call to advance() succeeded. Fetch next component. */ |
| path = new_name; |
| rip = new_ip; |
| } |
| } |
| |
| char *get_name(char *old_name, char *string, int string_length) |
| { |
| |
| /* Given a pointer to a path name in fs space, 'old_name', copy the next |
| * component to 'string' and pad with zeros. A pointer to that part of |
| * the name as yet unparsed is returned. Roughly speaking, |
| * 'get_name' = 'old_name' - 'string'. |
| * |
| * This routine follows the standard convention that /usr/ast, /usr//ast, |
| * //usr///ast and /usr/ast/ are all equivalent. |
| */ |
| |
| register int c; |
| register char *np, *rnp; |
| |
| np = string; /* 'np' points to current position */ |
| rnp = old_name; /* 'rnp' points to unparsed string */ |
| while ((c = *rnp) == '/') |
| rnp++; /* skip leading slashes */ |
| |
| /* Copy the unparsed path, 'old_name', to the array, 'string'. */ |
| while ( rnp < &old_name[PATH_MAX] && c != '/' && c != '\0') { |
| if (np < &string[string_length]) |
| *np++ = c; |
| |
| c = *++rnp; /* advance to next character */ |
| } |
| |
| /* To make /usr/ast/ equivalent to /usr/ast, skip trailing slashes. */ |
| while (c == '/' && rnp < &old_name[PATH_MAX]) |
| c = *++rnp; |
| |
| /* Padding with zeroes */ |
| if (np < &string[string_length]) |
| *np = '\0'; /* Terminate string */ |
| |
| if (rnp >= &old_name[PATH_MAX]) { |
| err_code = FS_ENAMETOOLONG; |
| return((char *) 0); |
| } |
| |
| return rnp; |
| } |
| |
| inode_t *advance(inode_t *dirp, char *string, int string_length) |
| { |
| |
| /* Given a directory and a component of a path, look up the component in |
| * the directory, find the inode, open it, and return a pointer to its inode |
| * slot. If it can't be done, return NIL_INODE. |
| */ |
| |
| register inode_t *rip; |
| int r; |
| ino_t numb; |
| |
| /* If 'string' is empty, yield same inode straight away. */ |
| if (string[0] == '\0') |
| return get_inode((int) dirp->i_num); |
| |
| /* Check for NIL_INODE. */ |
| if (dirp == NIL_INODE) |
| return NIL_INODE; |
| |
| /* If 'string' is not present in the directory, signal error. */ |
| if (dirp->i_sp->s_extend) { |
| r = search_dir_ex(dirp, string, &numb, LOOK_UP); |
| } |
| else { |
| r = search_dir(dirp, string, &numb, LOOK_UP); |
| } |
| if (r != OK) { |
| err_code = r; |
| return NIL_INODE; |
| } |
| |
| /* Don't go beyond the current root directory */ |
| if (dirp == fp->fp_rootdir && strcmp(string, "..") == 0) |
| return(get_inode((int) dirp->i_num)); |
| |
| /* The component has been found in the directory. Get inode. */ |
| if ( (rip = get_inode((int) numb)) == NIL_INODE) |
| return NIL_INODE; |
| |
| return rip; /* return pointer to inode's component */ |
| } |
| |
| int search_dir(register inode_t *ldir_ptr, char string[NAME_MAX], ino_t *numb, int flag) |
| { |
| |
| /* This function searches the directory whose inode is pointed to by 'ldip': |
| * if (flag == LOOK_UP) search for 'string' and return inode # in 'numb'; |
| * if (flag == IS_EMPTY) return OK if only . and .. in dir else ENOTEMPTY; |
| */ |
| |
| register direct_t *dp; |
| register block_t *bp; |
| int r, match; |
| offset_t pos; |
| unsigned old_slots; |
| block_num_t b; |
| |
| /* If 'ldir_ptr' is not a pointer to a dir inode, error. */ |
| if ((ldir_ptr->i_mode & I_TYPE) != I_DIRECTORY) |
| return FS_ENOTDIR; |
| |
| r = OK; |
| |
| /* Step through the directory one block at a time. */ |
| old_slots = (unsigned)(ldir_ptr->i_size/DIR_ENTRY_SIZE); |
| match = 0; /* set when a string match occurs */ |
| |
| for (pos = 0; pos < ldir_ptr->i_size; pos += BLOCK_SIZE) { |
| b = read_map(ldir_ptr, pos); /* get block number */ |
| |
| /* Since directories don't have holes, 'b' cannot be NO_BLOCK. */ |
| bp = get_block(b); /* get a dir block */ |
| |
| /* Search a directory block. */ |
| for (dp = &bp->b.b__dir[0]; dp < &bp->b.b__dir[NR_DIR_ENTRIES]; dp++) { |
| |
| /* Match occurs if string found. */ |
| if (dp->d_ino != 0) { |
| if (flag == IS_EMPTY) { |
| /* If this test succeeds, dir is not empty. */ |
| if (strcmp(dp->d_name, "." ) != 0 && |
| strcmp(dp->d_name, "..") != 0) |
| match = 1; |
| } |
| else { |
| if (fs_strncmp(dp->d_name, string, NAME_MAX) == 0) |
| match = 1; |
| } |
| } |
| |
| if (match) { |
| /* LOOK_UP or DELETE found what it wanted. */ |
| r = OK; |
| if (flag == IS_EMPTY) { |
| r = FS_ENOTEMPTY; |
| } |
| else { |
| *numb = (int) dp->d_ino; |
| } |
| return r; |
| } |
| } |
| } |
| |
| /* The whole directory has now been searched. */ |
| return(flag == IS_EMPTY ? OK : FS_ENOENT); |
| } |
| |
| int search_dir_ex(register inode_t *ldir_ptr, char string[NAME_MAX_EX], ino_t *numb, int flag) |
| { |
| |
| /* Same as above, but for extened directory etries - 30 chars in name of file. */ |
| |
| register directex_t *dp; |
| register block_t *bp; |
| int r, match; |
| offset_t pos; |
| unsigned old_slots; |
| block_num_t b; |
| |
| /* If 'ldir_ptr' is not a pointer to a dir inode, error. */ |
| if ( (ldir_ptr->i_mode & I_TYPE) != I_DIRECTORY) |
| return FS_ENOTDIR; |
| |
| r = OK; |
| |
| /* Step through the directory one block at a time. */ |
| old_slots = (unsigned)(ldir_ptr->i_size/DIR_ENTRY_SIZE_EX); |
| match = 0; /* set when a string match occurs */ |
| |
| for (pos = 0; pos < ldir_ptr->i_size; pos += BLOCK_SIZE) { |
| b = read_map(ldir_ptr, pos); /* get block number */ |
| |
| /* Since directories don't have holes, 'b' cannot be NO_BLOCK. */ |
| bp = get_block(b); /* get a dir block */ |
| |
| /* Search a directory block. */ |
| for (dp = &bp->b.b__direx[0]; dp < &bp->b.b__direx[NR_DIR_ENTRIES_EX]; dp++) { |
| |
| /* Match occurs if string found. */ |
| if (dp->d_ino != 0) { |
| if (flag == IS_EMPTY) { |
| /* If this test succeeds, dir is not empty. */ |
| if (strcmp(dp->d_name, "." ) != 0 && |
| strcmp(dp->d_name, "..") != 0) match = 1; |
| } |
| else { |
| if (fs_strncmp(dp->d_name, string, NAME_MAX_EX) == 0) |
| match = 1; |
| } |
| } |
| |
| if (match) { |
| /* LOOK_UP or DELETE found what it wanted. */ |
| r = OK; |
| if (flag == IS_EMPTY) { |
| r = FS_ENOTEMPTY; |
| } |
| else { |
| *numb = (int)dp->d_ino; |
| } |
| return r; |
| } |
| } |
| } |
| |
| /* The whole directory has now been searched. */ |
| return(flag == IS_EMPTY ? OK : FS_ENOENT); |
| } |
| |