projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4_4_Lite1 release
[unix-history] / usr / src / lib / libc / db / recno / rec_open.c
diff --git a/usr/src/lib/libc/db/recno/rec_open.c b/usr/src/lib/libc/db/recno/rec_open.c
index c452a98..2a0f354 100644 (file)
--- a/usr/src/lib/libc/db/recno/rec_open.c
+++ b/usr/src/lib/libc/db/recno/rec_open.c
@@ -1,33 +1,61 @@
 /*-
 /*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * Mike Olson.
  *
  *
  * This code is derived from software contributed to Berkeley by
  * Mike Olson.
  *
- * %sccs.include.redist.c%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 THE REGENTS 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.
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)rec_open.c 5.4 (Berkeley) %G%";
+static char sccsid[] = "@(#)rec_open.c 8.6 (Berkeley) 2/22/94";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
-#include <fcntl.h>
+
 #include <errno.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <limits.h>
 #include <limits.h>
-#include <db.h>
-#include <unistd.h>
-#include <stdio.h>
 #include <stddef.h>
 #include <stddef.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <db.h>
 #include "recno.h"
 
 DB *
 #include "recno.h"
 
 DB *
-__rec_open(fname, flags, mode, openinfo)
+__rec_open(fname, flags, mode, openinfo, dflags)
        const char *fname;
        const char *fname;
-       int flags, mode;
+       int flags, mode, dflags;
        const RECNOINFO *openinfo;
 {
        BTREE *t;
        const RECNOINFO *openinfo;
 {
        BTREE *t;
@@ -35,26 +63,29 @@ __rec_open(fname, flags, mode, openinfo)
        DB *dbp;
        PAGE *h;
        struct stat sb;
        DB *dbp;
        PAGE *h;
        struct stat sb;
-       int rfd;
+       int rfd, sverrno;
 
        /* Open the user's file -- if this fails, we're done. */
 
        /* Open the user's file -- if this fails, we're done. */
-       if ((rfd = open(fname, flags, mode)) < 0)
+       if (fname != NULL && (rfd = open(fname, flags, mode)) < 0)
                return (NULL);
 
        /* Create a btree in memory (backed by disk). */
                return (NULL);
 
        /* Create a btree in memory (backed by disk). */
+       dbp = NULL;
        if (openinfo) {
        if (openinfo) {
-               if (openinfo->flags & ~(R_FIXEDLEN|R_NOKEY|R_SNAPSHOT)) {
-                       errno = EINVAL;
-                       goto err;
-               }
+               if (openinfo->flags & ~(R_FIXEDLEN | R_NOKEY | R_SNAPSHOT))
+                       goto einval;
                btopeninfo.flags = 0;
                btopeninfo.cachesize = openinfo->cachesize;
                btopeninfo.flags = 0;
                btopeninfo.cachesize = openinfo->cachesize;
-               btopeninfo.psize = 0;
+               btopeninfo.maxkeypage = 0;
+               btopeninfo.minkeypage = 0;
+               btopeninfo.psize = openinfo->psize;
                btopeninfo.compare = NULL;
                btopeninfo.compare = NULL;
+               btopeninfo.prefix = NULL;
                btopeninfo.lorder = openinfo->lorder;
                btopeninfo.lorder = openinfo->lorder;
-               dbp = __bt_open(NULL, O_RDWR, S_IRUSR | S_IWUSR, &btopeninfo);
+               dbp = __bt_open(openinfo->bfname,
+                   O_RDWR, S_IRUSR | S_IWUSR, &btopeninfo, dflags);
        } else
        } else
-               dbp = __bt_open(NULL, O_RDWR, S_IRUSR | S_IWUSR, NULL);
+               dbp = __bt_open(NULL, O_RDWR, S_IRUSR | S_IWUSR, NULL, dflags);
        if (dbp == NULL)
                goto err;
 
        if (dbp == NULL)
                goto err;
 
@@ -66,52 +97,86 @@ __rec_open(fname, flags, mode, openinfo)
         */
        t = dbp->internal;
        if (openinfo) {
         */
        t = dbp->internal;
        if (openinfo) {
-               if (openinfo->flags & R_FIXEDLEN)
-                       t->bt_flags |= BTF_FIXEDLEN;
-
-               t->bt_reclen = openinfo->reclen;
-               if (t->bt_reclen == 0) {
-                       errno = EINVAL;
-                       goto err;
+               if (openinfo->flags & R_FIXEDLEN) {
+                       SET(t, R_FIXLEN);
+                       t->bt_reclen = openinfo->reclen;
+                       if (t->bt_reclen == 0)
+                               goto einval;
                }
                }
-
                t->bt_bval = openinfo->bval;
        } else
                t->bt_bval = '\n';
 
                t->bt_bval = openinfo->bval;
        } else
                t->bt_bval = '\n';
 
-       t->bt_flags = BTF_RECNO;
-       t->bt_reof = 0;
+       SET(t, R_RECNO);
+       if (fname == NULL)
+               SET(t, R_EOF | R_INMEM);
+       else
+               t->bt_rfd = rfd;
+       t->bt_rcursor = 0;
 
 
-       /*
-        * In 4.4BSD stat(2) returns true for ISSOCK on pipes.  Until
-        * then, this is fairly close.  Pipes are read-only.
-        */
-       if (lseek(rfd, 0L, SEEK_CUR) == -1 && errno == ESPIPE) {
-               SET(t, BTF_RDONLY);
-               if ((t->bt_rfp = fdopen(rfd, "r")) == NULL)
-                       goto err;
-               t->bt_irec = ISSET(t, BTF_FIXEDLEN) ? __rec_fpipe : __rec_vpipe;
-       } else {
-               if (fstat(rfd, &sb))
-                       goto err;
-               if (!(flags & (O_RDWR | O_WRONLY)))
-                       SET(t, BTF_RDONLY);
-               if (sb.st_size > UINT_MAX) {
-                       errno = EFBIG;
-                       goto err;
+       if (fname != NULL) {
+               /*
+                * In 4.4BSD, stat(2) returns true for ISSOCK on pipes.
+                * Unfortunately, that's not portable, so we use lseek
+                * and check the errno values.
+                */
+               errno = 0;
+               if (lseek(rfd, (off_t)0, SEEK_CUR) == -1 && errno == ESPIPE) {
+                       switch (flags & O_ACCMODE) {
+                       case O_RDONLY:
+                               SET(t, R_RDONLY);
+                               break;
+                       default:
+                               goto einval;
+                       }
+slow:                  if ((t->bt_rfp = fdopen(rfd, "r")) == NULL)
+                               goto err;
+                       SET(t, R_CLOSEFP);
+                       t->bt_irec =
+                           ISSET(t, R_FIXLEN) ? __rec_fpipe : __rec_vpipe;
+               } else {
+                       switch (flags & O_ACCMODE) {
+                       case O_RDONLY:
+                               SET(t, R_RDONLY);
+                               break;
+                       case O_RDWR:
+                               break;
+                       default:
+                               goto einval;
+                       }
+
+                       if (fstat(rfd, &sb))
+                               goto err;
+                       /*
+                        * Kluge -- we'd like to test to see if the file is too
+                        * big to mmap.  Since, we don't know what size or type
+                        * off_t's or size_t's are, what the largest unsigned
+                        * integral type is, or what random insanity the local
+                        * C compiler will perpetrate, doing the comparison in
+                        * a portable way is flatly impossible.  Hope that mmap
+                        * fails if the file is too large.
+                        */
+                       if (sb.st_size == 0)
+                               SET(t, R_EOF);
+                       else {
+                               t->bt_msize = sb.st_size;
+                               if ((t->bt_smap = mmap(NULL, t->bt_msize,
+                                   PROT_READ, MAP_PRIVATE, rfd,
+                                   (off_t)0)) == (caddr_t)-1)
+                                       goto slow;
+                               t->bt_cmap = t->bt_smap;
+                               t->bt_emap = t->bt_smap + sb.st_size;
+                               t->bt_irec = ISSET(t, R_FIXLEN) ?
+                                   __rec_fmap : __rec_vmap;
+                               SET(t, R_MEMMAPPED);
+                       }
                }
                }
-               if ((t->bt_smap = mmap(NULL,
-                   (size_t)sb.st_size, PROT_READ, 0, rfd, (off_t)0)) == NULL)
-                       goto err;
-               t->bt_emap = t->bt_smap + sb.st_size;
-               t->bt_rfd = rfd;
-               t->bt_rfp = NULL;
-               t->bt_irec = ISSET(t, BTF_FIXEDLEN) ? __rec_fmap : __rec_vmap;
        }
 
        /* Use the recno routines. */
        dbp->close = __rec_close;
        dbp->del = __rec_delete;
        }
 
        /* Use the recno routines. */
        dbp->close = __rec_close;
        dbp->del = __rec_delete;
+       dbp->fd = __rec_fd;
        dbp->get = __rec_get;
        dbp->put = __rec_put;
        dbp->seq = __rec_seq;
        dbp->get = __rec_get;
        dbp->put = __rec_put;
        dbp->seq = __rec_seq;
@@ -127,12 +192,39 @@ __rec_open(fname, flags, mode, openinfo)
                mpool_put(t->bt_mp, h, 0);
 
        if (openinfo && openinfo->flags & R_SNAPSHOT &&
                mpool_put(t->bt_mp, h, 0);
 
        if (openinfo && openinfo->flags & R_SNAPSHOT &&
+           !ISSET(t, R_EOF | R_INMEM) &&
            t->bt_irec(t, MAX_REC_NUMBER) == RET_ERROR)
                 goto err;
        return (dbp);
 
            t->bt_irec(t, MAX_REC_NUMBER) == RET_ERROR)
                 goto err;
        return (dbp);
 
-err:   if (dbp)
-               __bt_close(dbp);
-       (void)close(rfd);
+einval:        errno = EINVAL;
+err:   sverrno = errno;
+       if (dbp != NULL)
+               (void)__bt_close(dbp);
+       if (fname != NULL)
+               (void)close(rfd);
+       errno = sverrno;
        return (NULL);
 }
        return (NULL);
 }
+
+int
+__rec_fd(dbp)
+       const DB *dbp;
+{
+       BTREE *t;
+
+       t = dbp->internal;
+
+       /* Toss any page pinned across calls. */
+       if (t->bt_pinned != NULL) {
+               mpool_put(t->bt_mp, t->bt_pinned, 0);
+               t->bt_pinned = NULL;
+       }
+
+       /* In-memory database can't have a file descriptor. */
+       if (ISSET(t, R_INMEM)) {
+               errno = ENOENT;
+               return (-1);
+       }
+       return (t->bt_rfd);
+}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.