don't overflow doing long writes on ptc (from thomas@utah-cs)

[unix-history] / usr / src / sys / kern / vfs_lookup.c

diff --git a/usr/src/sys/kern/vfs_lookup.c b/usr/src/sys/kern/vfs_lookup.c
index 1e345a6..56202c0 100644 (file)
--- a/usr/src/sys/kern/vfs_lookup.c
+++ b/usr/src/sys/kern/vfs_lookup.c
@@ -1,4 +1,4 @@
-/*     vfs_lookup.c    4.37    83/04/22        */
+/*     vfs_lookup.c    6.2     83/09/09        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -160,7 +160,7 @@ dirloop2:
         */
        if (u.u_dent.d_name[0] == 0) {
                if (flag || lockparent) {
         */
        if (u.u_dent.d_name[0] == 0) {
                if (flag || lockparent) {

-                       u.u_error = ENOENT;
+                       u.u_error = EISDIR;

                        goto bad;
                }
                brelse(nbp);
                        goto bad;
                }
                brelse(nbp);


@@ -442,7 +442,7 @@ found:
         * and parent directories are removed before the `iget' for the
         * inode associated with ".." returns.  We hope that this occurs
         * infrequently since we cannot avoid this race condition without
         * and parent directories are removed before the `iget' for the
         * inode associated with ".." returns.  We hope that this occurs
         * infrequently since we cannot avoid this race condition without

-        * implementing a sophistocated deadlock detection algorithm.
+        * implementing a sophisticated deadlock detection algorithm.

         * Note also that this simple deadlock detection scheme will not
         * work if the file system has any hard links other than ".."
         * that point backwards in the directory structure.
         * Note also that this simple deadlock detection scheme will not
         * work if the file system has any hard links other than ".."
         * that point backwards in the directory structure.


@@ -743,30 +743,102 @@ blkatoff(ip, offset, res)
 /*
  * Check if a directory is empty or not.
  * Inode supplied must be locked.
 /*
  * Check if a directory is empty or not.
  * Inode supplied must be locked.

+ *
+ * Using a struct dirtemplate here is not precisely
+ * what we want, but better than using a struct direct.
+ *
+ * NB: does not handle corrupted directories.

  */
 dirempty(ip)
        register struct inode *ip;
 {
        register off_t off;
  */
 dirempty(ip)
        register struct inode *ip;
 {
        register off_t off;

-       struct direct dbuf;
-       register struct direct *dp = &dbuf;
+       struct dirtemplate dbuf;
+       register struct direct *dp = (struct direct *)&dbuf;

        int error, count;
        int error, count;

+#define        MINDIRSIZ (sizeof (struct dirtemplate) / 2)

 
        for (off = 0; off < ip->i_size; off += dp->d_reclen) {
 
        for (off = 0; off < ip->i_size; off += dp->d_reclen) {

-               error = rdwri(UIO_READ, ip, (caddr_t)dp,
-                       sizeof (struct direct), off, 1, &count);
-               count = sizeof (struct direct) - count;
-#define        MINDIRSIZ (sizeof (struct direct) - (MAXNAMLEN + 1))
-               if (error || count < MINDIRSIZ || count < DIRSIZ(dp))
+               error = rdwri(UIO_READ, ip, (caddr_t)dp, MINDIRSIZ,
+                   off, 1, &count);
+               /*
+                * Since we read MINDIRSIZ, residual must
+                * be 0 unless we're at end of file.
+                */
+               if (error || count != 0)

                        return (0);
                        return (0);

+               /* skip empty entries */

                if (dp->d_ino == 0)
                        continue;
                if (dp->d_ino == 0)
                        continue;

+               /* accept only "." and ".." */
+               if (dp->d_namlen > 2)
+                       return (0);

                if (dp->d_name[0] != '.')
                        return (0);
                if (dp->d_name[0] != '.')
                        return (0);

-               if (dp->d_namlen == 1 ||
-                   (dp->d_namlen == 2 && dp->d_name[1] == '.'))
+               /*
+                * At this point d_namlen must be 1 or 2.
+                * 1 implies ".", 2 implies ".." if second
+                * char is also "."
+                */
+               if (dp->d_namlen == 1 || dp->d_name[1] == '.')

                        continue;
                return (0);
        }
        return (1);
 }
                        continue;
                return (0);
        }
        return (1);
 }

+
+/*
+ * Check if source directory is in the path of the target directory.
+ * Target is supplied locked, source is unlocked.
+ * The target is always iput() before returning.
+ */
+checkpath(source, target)
+       struct inode *source, *target;
+{
+       struct dirtemplate dirbuf;
+       register struct inode *ip;
+       int error = 0;
+
+       ip = target;
+       if (ip->i_number == source->i_number) {
+               error = EEXIST;
+               goto out;
+       }
+       if (ip->i_number == ROOTINO)
+               goto out;
+
+       for (;;) {
+               if ((ip->i_mode&IFMT) != IFDIR) {
+                       error = ENOTDIR;
+                       break;
+               }
+               error = rdwri(UIO_READ, ip, (caddr_t)&dirbuf,
+                       sizeof (struct dirtemplate), (off_t)0, 1, (int *)0);
+               if (error != 0)
+                       break;
+               if (dirbuf.dotdot_namlen != 2 ||
+                   bcmp(dirbuf.dotdot_name, "..", 3) != 0) {
+                       error = ENOTDIR;
+                       break;
+               }
+               if (dirbuf.dotdot_ino == source->i_number) {
+                       error = EINVAL;
+                       break;
+               }
+               if (dirbuf.dotdot_ino == ROOTINO)
+                       break;
+               iput(ip);
+               ip = iget(ip->i_dev, ip->i_fs, dirbuf.dotdot_ino);
+               if (ip == NULL) {
+                       error = u.u_error;
+                       break;
+               }
+       }
+
+out:
+       if (error == ENOTDIR)
+               printf("checkpath: .. not a directory\n");
+       if (ip != NULL)
+               iput(ip);
+       return (error);
+}