toolchain/gcc/newlib/libc/posix/telldir.c

   1 #ifndef HAVE_OPENDIR
   2
   3 /*
   4  * Copyright (c) 1983 Regents of the University of California.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #if defined(LIBC_SCCS) && !defined(lint)
  37 static char sccsid[] = "@(#)telldir.c   5.9 (Berkeley) 2/23/91";
  38 #endif /* LIBC_SCCS and not lint */
  39
  40 #include <sys/param.h>
  41 #include <dirent.h>
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44 #include <sys/lock.h>
  45
  46 /*
  47  * The option SINGLEUSE may be defined to say that a telldir
  48  * cookie may be used only once before it is freed. This option
  49  * is used to avoid having memory usage grow without bound.
  50  */
  51 #define SINGLEUSE
  52
  53 /*
  54  * One of these structures is malloced to describe the current directory
  55  * position each time telldir is called. It records the current magic
  56  * cookie returned by getdirentries and the offset within the buffer
  57  * associated with that return value.
  58  */
  59 struct ddloc {
  60         struct  ddloc *loc_next;/* next structure in list */
  61         long    loc_index;      /* key associated with structure */
  62         long    loc_seek;       /* magic cookie returned by getdirentries */
  63         long    loc_loc;        /* offset of entry in buffer */
  64         DIR    *loc_dirp;       /* DIR pointer */
  65 };
  66
  67 #define NDIRHASH        32      /* Num of hash lists, must be a power of 2 */
  68 #define LOCHASH(i)      ((i)&(NDIRHASH-1))
  69
  70 static long     dd_loccnt;      /* Index of entry for sequential readdir's */
  71 static struct   ddloc *dd_hash[NDIRHASH];   /* Hash list heads for ddlocs */
  72 __LOCK_INIT(static, dd_hash_lock);
  73
  74 /*
  75  * return a pointer into a directory
  76  */
  77
  78 #ifndef _ELIX_LEVEL || _ELIX_LEVEL >= 2
  79
  80 long
  81 _DEFUN(telldir, (dirp),
  82        DIR *dirp)
  83 {
  84         register int index;
  85         register struct ddloc *lp;
  86
  87         if ((lp = (struct ddloc *)malloc(sizeof(struct ddloc))) == NULL)
  88                 return (-1);
  89
  90 #ifdef HAVE_DD_LOCK
  91         __lock_acquire_recursive(dirp->dd_lock);
  92         __lock_acquire(dd_hash_lock);
  93 #endif
  94         index = dd_loccnt++;
  95         lp->loc_index = index;
  96         lp->loc_seek = dirp->dd_seek;
  97         lp->loc_loc = dirp->dd_loc;
  98         lp->loc_dirp = dirp;
  99         lp->loc_next = dd_hash[LOCHASH(index)];
 100         dd_hash[LOCHASH(index)] = lp;
 101 #ifdef HAVE_DD_LOCK
 102         __lock_release(dd_hash_lock);
 103         __lock_release_recursive(dirp->dd_lock);
 104 #endif
 105         return (index);
 106 }
 107
 108 #endif /* !_ELIX_LEVEL || _ELIX_LEVEL >= 2 */
 109
 110 /*
 111  * seek to an entry in a directory.
 112  * Only values returned by "telldir" should be passed to seekdir.
 113  */
 114 void
 115 _DEFUN(_seekdir, (dirp, loc),
 116         register DIR *dirp _AND
 117         long loc)
 118 {
 119         register struct ddloc *lp;
 120         register struct ddloc **prevlp;
 121         struct dirent *dp;
 122         extern long lseek();
 123
 124 #ifdef HAVE_DD_LOCK
 125         __lock_acquire(dd_hash_lock);
 126 #endif
 127         prevlp = &dd_hash[LOCHASH(loc)];
 128         lp = *prevlp;
 129         while (lp != NULL) {
 130                 if (lp->loc_index == loc)
 131                         break;
 132                 prevlp = &lp->loc_next;
 133                 lp = lp->loc_next;
 134         }
 135         if (lp == NULL) {
 136 #ifdef HAVE_DD_LOCK
 137                 __lock_release(dd_hash_lock);
 138 #endif
 139                 return;
 140         }
 141         if (lp->loc_loc == dirp->dd_loc && lp->loc_seek == dirp->dd_seek)
 142                 goto found;
 143         (void) lseek(dirp->dd_fd, lp->loc_seek, 0);
 144         dirp->dd_seek = lp->loc_seek;
 145         dirp->dd_loc = 0;
 146         while (dirp->dd_loc < lp->loc_loc) {
 147                 dp = readdir(dirp);
 148                 if (dp == NULL)
 149                         break;
 150         }
 151 found:
 152 #ifdef SINGLEUSE
 153         *prevlp = lp->loc_next;
 154         free((caddr_t)lp);
 155 #endif
 156 #ifdef HAVE_DD_LOCK
 157         __lock_release(dd_hash_lock);
 158 #endif
 159 }
 160
 161 /* clean out any hash entries from a closed directory */
 162 void
 163 _DEFUN(_cleanupdir, (dirp),
 164         register DIR *dirp)
 165 {
 166         int i;
 167
 168 #ifdef HAVE_DD_LOCK
 169         __lock_acquire(dd_hash_lock);
 170 #endif
 171         for (i = 0; i < NDIRHASH; ++i) {
 172                 register struct ddloc *lp;
 173                 register struct ddloc *prevlp;
 174                 lp = dd_hash[i];
 175                 while (lp != NULL && lp->loc_dirp == dirp) {
 176                         dd_hash[i] = lp->loc_next;
 177                         prevlp = lp;
 178                         free((caddr_t)lp);
 179                         lp = prevlp->loc_next;
 180                 }
 181                 prevlp = lp;
 182                 while (lp != NULL) {
 183                         lp = lp->loc_next;
 184                         if (lp != NULL && lp->loc_dirp == dirp) {
 185                                 prevlp->loc_next = lp->loc_next;
 186                                 free((caddr_t)lp);
 187                                 lp = prevlp;
 188                         }
 189                         else
 190                                 prevlp = lp;
 191                 }
 192         }
 193 #ifdef HAVE_DD_LOCK
 194         __lock_release(dd_hash_lock);
 195 #endif
 196
 197 }
 198 #endif /* ! HAVE_OPENDIR */