--- MiNT/src/unifs.c 2018/04/24 17:55:54 1.1.1.2 +++ MiNT/src/unifs.c 2018/04/24 17:58:54 1.1.1.6 @@ -1,6 +1,10 @@ /* -Copyright 1991,1992 Eric R. Smith. All rights reserved. +Copyright 1991,1992 Eric R. Smith. + +Copyright 1992,1993,1994 Atari Corporation. + +All rights reserved. */ @@ -36,7 +40,9 @@ static long ARGS_ON_STACK uni_rmdir P_(( static long ARGS_ON_STACK uni_remove P_((fcookie *dir, const char *name)); -static long ARGS_ON_STACK uni_getname P_((fcookie *root, fcookie *dir, char *pathname)); +static long ARGS_ON_STACK uni_getname P_((fcookie *root, fcookie *dir, + + char *pathname, int size)); static long ARGS_ON_STACK uni_rename P_((fcookie *olddir, char *oldname, @@ -60,13 +66,15 @@ static long ARGS_ON_STACK uni_symlink P_ static long ARGS_ON_STACK uni_readlink P_((fcookie *fc, char *buf, int buflen)); +static long ARGS_ON_STACK uni_fscntl P_((fcookie *dir, const char *name, int cmd, long arg)); + FILESYS uni_filesys = { (FILESYS *)0, - 0, + FS_LONGPATH, uni_root, @@ -80,7 +88,7 @@ FILESYS uni_filesys = { uni_pathconf, uni_dfree, nowritelabel, noreadlabel, - uni_symlink, uni_readlink, nohardlink, nofscntl, nodskchng + uni_symlink, uni_readlink, nohardlink, uni_fscntl, nodskchng }; @@ -120,6 +128,8 @@ typedef struct unifile { struct unifile *next; + short cdate, ctime; + } UNIFILE; @@ -130,6 +140,34 @@ static UNIFILE *u_root = 0; +static long do_ulookup P_((fcookie *, const char *, fcookie *, UNIFILE **)); + + + +FILESYS * + +get_filesys (dev) + + int dev; + +{ + + UNIFILE *u; + + + + for (u = u_root; u; u = u->next) + + if (u->dev == dev) + + return u->fs; + + return (FILESYS *) 0L; + +} + + + void unifs_init() @@ -152,6 +190,10 @@ unifs_init() u->dev = i; + u->cdate = datestamp; + + u->ctime = timestamp; + if (i == PROCDRV) { strcpy(u->name, "proc"); @@ -242,12 +284,40 @@ uni_lookup(dir, name, fc) { + return do_ulookup(dir, name, fc, (UNIFILE **)0); + +} + + + +/* worker function for uni_lookup; can also return the UNIFILE + + * pointer for the root directory + + */ + +static long + +do_ulookup(dir, name, fc, up) + + fcookie *dir; + + const char *name; + + fcookie *fc; + + UNIFILE **up; + +{ + UNIFILE *u; long drvs; FILESYS *fs; + fcookie *tmp; + extern long dosdrvs; @@ -272,7 +342,7 @@ uni_lookup(dir, name, fc) if (!*name || !strcmp(name, ".") || !strcmp(name, "..")) { - *fc = *dir; + dup_cookie(fc, dir); return 0; @@ -288,7 +358,7 @@ uni_lookup(dir, name, fc) for (u = u_root; u; u = u->next) { - if (!stricmp(name, u->name)) { + if (!strnicmp(name, u->name, NAME_MAX)) { if ( (u->mode & S_IFMT) == S_IFDIR ) { @@ -296,6 +366,8 @@ uni_lookup(dir, name, fc) fs = u->fs; + if (up) *up = u; + return (*fs->root)(u->dev,fc); } @@ -304,20 +376,22 @@ uni_lookup(dir, name, fc) return EPTHNF; - *fc = curproc->root[u->dev]; + tmp = &curproc->root[u->dev]; - if (!fc->fs) { /* drive changed? */ + if (!tmp->fs) { /* drive changed? */ - changedrv(fc->dev); + changedrv(tmp->dev); - *fc = curproc->root[u->dev]; + tmp = &curproc->root[u->dev]; - if (!fc->fs) + if (!tmp->fs) return EPTHNF; } + dup_cookie(fc, tmp); + } else { /* a symbolic link */ fc->fs = &uni_filesys; @@ -328,6 +402,8 @@ uni_lookup(dir, name, fc) } + if (up) *up = u; + return 0; } @@ -368,7 +444,7 @@ uni_getxattr(fc, xattr) xattr->index = fc->index; - xattr->dev = fc->dev; + xattr->dev = xattr->rdev = fc->dev; xattr->nlink = 1; @@ -406,9 +482,9 @@ uni_getxattr(fc, xattr) } - xattr->mtime = xattr->atime = xattr->ctime = 0; + xattr->mtime = xattr->atime = xattr->ctime = u->ctime; - xattr->mdate = xattr->adate = xattr->cdate = 0; + xattr->mdate = xattr->adate = xattr->cdate = u->cdate; return 0; @@ -522,10 +598,14 @@ uni_remove(dir, name) while (u) { - if (!strncmp(u->name, name, NAME_MAX)) { + if (!strnicmp(u->name, name, NAME_MAX)) { if ( (u->mode & S_IFMT) != S_IFLNK ) return EFILNF; + if (curproc->euid && (u->dev != curproc->euid)) + + return EACCDN; + kfree(u->data); if (lastu) @@ -556,10 +636,12 @@ uni_remove(dir, name) static long ARGS_ON_STACK -uni_getname(root, dir, pathname) +uni_getname(root, dir, pathname, size) fcookie *root, *dir; char *pathname; + int size; + { FILESYS *fs; @@ -570,12 +652,20 @@ uni_getname(root, dir, pathname) fcookie relto; + char tmppath[PATH_MAX]; + + long r; + UNUSED(root); + if (size <= 0) return ERANGE; + + + fs = dir->fs; if (dir->dev == UNIDRV) { @@ -594,10 +684,16 @@ uni_getname(root, dir, pathname) *pathname++ = '\\'; - for (n = u->name; *n; ) + if (--size <= 0) return ERANGE; + + for (n = u->name; *n; ) { *pathname++ = *n++; + if (--size <= 0) return ERANGE; + + } + break; } @@ -620,7 +716,37 @@ uni_getname(root, dir, pathname) if ((*fs->root)(dir->dev, &relto) == 0) { - return (*fs->getname)(&relto, dir, pathname); + if (!(fs->fsflags & FS_LONGPATH)) { + + r = (*fs->getname)(&relto, dir, tmppath, PATH_MAX); + + release_cookie(&relto); + + if (r) { + + return r; + + } + + if (strlen(tmppath) < size) { + + strcpy(pathname, tmppath); + + return 0; + + } else { + + return ERANGE; + + } + + } + + r = (*fs->getname)(&relto, dir, pathname, size); + + release_cookie(&relto); + + return r; } else { @@ -644,7 +770,35 @@ uni_getname(root, dir, pathname) - return (*fs->getname)(&curproc->root[dir->dev], dir, pathname); + if (!fs) { + + *pathname = 0; + + return 0; + + } + + if (!(fs->fsflags & FS_LONGPATH)) { + + r = (*fs->getname)(&curproc->root[dir->dev], dir, tmppath, PATH_MAX); + + if (r) return r; + + if (strlen(tmppath) < size) { + + strcpy(pathname, tmppath); + + return 0; + + } else { + + return ERANGE; + + } + + } + + return (*fs->getname)(&curproc->root[dir->dev], dir, pathname, size); } @@ -678,7 +832,7 @@ uni_rename(olddir, oldname, newdir, newn for (u = u_root; u; u = u->next) { - if (!stricmp(u->name, oldname)) + if (!strnicmp(u->name, oldname, NAME_MAX)) break; @@ -700,6 +854,12 @@ uni_rename(olddir, oldname, newdir, newn r = uni_lookup(newdir, newname, &fc); + if (r == 0) + + release_cookie(&fc); + + + if (r != EFILNF) { DEBUG(("uni_rename: error %ld", r)); @@ -840,7 +1000,7 @@ tryagain: } - *fc = curproc->root[u->dev]; + dup_cookie(fc, &curproc->root[u->dev]); if (!fc->fs) { /* drive not yet initialized */ @@ -872,7 +1032,13 @@ tryagain: namelen -= (int)sizeof(long); - if (namelen <= 0) return ERANGE; + if (namelen <= 0) { + + release_cookie(fc); + + return ERANGE; + + } *((long *)name) = index; @@ -882,10 +1048,14 @@ tryagain: strncpy(name, dirname, namelen-1); - if (strlen(name) < strlen(dirname)) + if (strlen(name) < strlen(dirname)) { + + release_cookie(fc); return ENAMETOOLONG; + } + return 0; } @@ -972,6 +1142,14 @@ uni_pathconf(dir, which) return DP_CASEINSENS; + case DP_MODEATTR: + + return DP_FT_DIR|DP_FT_LNK; + + case DP_XATTRFIELDS: + + return DP_INDEX|DP_DEV|DP_NLINK|DP_SIZE; + default: return EINVFN; @@ -1054,12 +1232,24 @@ uni_symlink(dir, name, to) r = uni_lookup(dir, name, &fc); - if (r == 0) return EACCDN; /* file already exists */ + if (r == 0) { + + release_cookie(&fc); + + return EACCDN; /* file already exists */ + + } if (r != EFILNF) return r; /* some other error */ + if (curproc->egid) + + return EACCDN; /* only members of admin group may do that */ + + + u = kmalloc(SIZEOF(UNIFILE)); if (!u) return EACCDN; @@ -1086,12 +1276,16 @@ uni_symlink(dir, name, to) u->mode = S_IFLNK | DEFAULT_DIRMODE; - u->dev = curproc->ruid; + u->dev = curproc->euid; u->next = u_root; u->fs = &uni_filesys; + u->cdate = datestamp; + + u->ctime = timestamp; + u_root = u; return 0; @@ -1134,3 +1328,323 @@ uni_readlink(fc, buf, buflen) } + + + + + + + + +/* uk: use these Dcntl's to install a new filesystem which is only visible + + * on drive u: + + * + + * FS_INSTALL: let the kernel know about the file system; it does NOT + + * get a device number. + + * FS_MOUNT: use Dcntl(FS_MOUNT, "u:\\foo", &descr) to make a directory + + * foo where the filesytem resides in; the file system now + + * gets its device number which is also written into the + + * dev_no field of the fs_descr structure. + + * FS_UNMOUNT: remove a file system's directory; this call closes all + + * open files, directory searches and directories on this + + * device. Make sure that the FS will not recognise any + + * accesses to this device, as fs->root will be called + + * during the reinitalisation! + + * FS_UNINSTALL: remove a file system completely from the kernel list, + + * but that will only be possible if there is no directory + + * associated with this file system. + + * This function allows it to write file systems as demons + + * which stay in memory only as long as needed. + + * + + * BUG: it is not possible yet to lock such a filesystem. + + */ + + + +/* here we start with gemdos only file system device numbers */ + +static curr_dev_no = 0x100; + + + + + + + +static long ARGS_ON_STACK + +uni_fscntl(dir, name, cmd, arg) + + fcookie *dir; + + const char *name; + + int cmd; + + long arg; + +{ + + fcookie fc; + + long r; + + + + extern struct kerinfo kernelinfo; + + extern FILESYS *active_fs; + + + + if (cmd == (int)FS_INSTALL) { /* install a new filesystem */ + + struct fs_descr *d = (struct fs_descr*)arg; + + FILESYS *fs; + + + + /* check if FS is installed already */ + + for (fs = active_fs; fs; fs = fs->next) + + if (d->file_system == fs) return 0L; + + /* include new file system into chain of file systems */ + + d->file_system->next = active_fs; + + active_fs = d->file_system; + + return (long)&kernelinfo; /* return pointer to kernel info as OK */ + + } else if (cmd == (int)FS_MOUNT) { /* install a new gemdos-only device for this FS */ + + struct fs_descr *d = (struct fs_descr*)arg; + + FILESYS *fs; + + UNIFILE *u; + + + + /* first check for existing names */ + + r = uni_lookup(dir, name, &fc); + + if (r == 0) { + + release_cookie(&fc); + + return EACCDN; /* name exists already */ + + } + + if (r != EFILNF) return r; /* some other error */ + + if (!d) return EACCDN; + + if (!d->file_system) return EACCDN; + + /* check if FS is installed */ + + for (fs = active_fs; fs; fs = fs->next) + + if (d->file_system == fs) break; + + if (!fs) return EACCDN; /* not installed, so return an error */ + + u = kmalloc(SIZEOF(UNIFILE)); + + if (!u) return EACCDN; + + strncpy(u->name, name, NAME_MAX); + + u->name[NAME_MAX] = 0; + + u->mode = S_IFDIR|DEFAULT_DIRMODE; + + u->data = 0; + + u->fs = d->file_system; + + /* now get the file system its own device number */ + + u->dev = d->dev_no = curr_dev_no++; + + /* chain new entry into unifile list */ + + u->next = u_root; + + u_root = u; + + return (long)u->dev; + + } else if (cmd == (int)FS_UNMOUNT) { /* remove a file system's directory */ + + struct fs_descr *d = (struct fs_descr*)arg; + + FILESYS *fs; + + UNIFILE *u; + + + + /* first check that directory exists */ + + /* use special uni_lookup mode to get the unifile entry */ + + r = do_ulookup(dir, name, &fc, &u); + + if (r != 0) return EFILNF; /* name does not exist */ + + if (!d) return EFILNF; + + if (!d->file_system) return EFILNF; + + if (d->file_system != fc.fs) + + return EFILNF; /* not the right name! */ + + release_cookie(&fc); + + + + if (!u || (u->fs != d->file_system)) + + return EFILNF; + + /* check if FS is installed */ + + for (fs = active_fs; fs; fs = fs->next) + + if (d->file_system == fs) break; + + if (!fs) return EACCDN; /* not installed, so return an error */ + + + + /* here comes the difficult part: we have to close all files on that + + * device, so we have to call changedrv(). The file system driver + + * has to make sure that further calls to fs.root() with this device + + * number will fail! + + * + + * Kludge: mark the directory as a link, so uni_remove will remove it. + + */ + + changedrv(u->dev); + + u->mode &= ~S_IFMT; + + u->mode |= S_IFLNK; + + return uni_remove(dir, name); + + } else if (cmd == (int)FS_UNINSTALL) { /* remove file system from kernel list */ + + struct fs_descr *d = (struct fs_descr*)arg; + + FILESYS *fs, *last_fs; + + UNIFILE *u; + + + + /* first check if there are any files or directories associated with + + * this file system + + */ + + for (u = u_root; u; u = u->next) + + if (u->fs == d->file_system) + + return EACCDN; /* we cannot remove it before unmount */ + + last_fs = 0; + + fs = active_fs; + + while (fs) { /* go through the list and remove the file system */ + + if (fs == d->file_system) { + + if (last_fs) + + last_fs->next = fs->next; + + else + + active_fs = fs->next; + + d->file_system->next = 0; + + return 0; + + } + + last_fs = fs; + + fs = fs->next; + + } + + return EFILNF; + + } else { + + /* see if we should just pass this along to another file system */ + + r = uni_lookup(dir, name, &fc); + + if (r == 0) { + + if (fc.fs != &uni_filesys) { + + r = (*fc.fs->fscntl)(&fc, ".", cmd, arg); + + release_cookie(&fc); + + return r; + + } + + release_cookie(&fc); + + } + + } + + return EINVFN; + +} +