/* 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.
*/
/*
* Copyright (c) 1987,1997, Prentice Hall
* All rights reserved.
*
* Redistribution and use of the MINIX operating system in source and
* binary forms, with or without modification, are permitted provided
* that the following conditions are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* - Neither the name of Prentice Hall nor the names of the software
* authors or contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* 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);
}