lib/libc/db/recno/rec_get.c

   1 /*-
   2  * Copyright (c) 1990, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)rec_get.c        8.9 (Berkeley) 8/18/94
  30  * $FreeBSD: head/lib/libc/db/recno/rec_get.c 189387 2009-03-05 00:57:01Z delphij $
  31  */
  32
  33 #include <sys/types.h>
  34
  35 #include <errno.h>
  36 #include <stddef.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42 #include <db.h>
  43 #include "recno.h"
  44
  45 /*
  46  * __REC_GET -- Get a record from the btree.
  47  *
  48  * Parameters:
  49  *      dbp:    pointer to access method
  50  *      key:    key to find
  51  *      data:   data to return
  52  *      flag:   currently unused
  53  *
  54  * Returns:
  55  *      RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key not found.
  56  */
  57 int
  58 __rec_get(const DB *dbp, const DBT *key, DBT *data, unsigned int flags)
  59 {
  60         BTREE *t;
  61         EPG *e;
  62         recno_t nrec;
  63         int status;
  64
  65         t = dbp->internal;
  66
  67         /* Toss any page pinned across calls. */
  68         if (t->bt_pinned != NULL) {
  69                 mpool_put(t->bt_mp, t->bt_pinned, 0);
  70                 t->bt_pinned = NULL;
  71         }
  72
  73         /* Get currently doesn't take any flags, and keys of 0 are illegal. */
  74         if (flags || (nrec = *(recno_t *)key->data) == 0) {
  75                 errno = EINVAL;
  76                 return (RET_ERROR);
  77         }
  78
  79         /*
  80          * If we haven't seen this record yet, try to find it in the
  81          * original file.
  82          */
  83         if (nrec > t->bt_nrecs) {
  84                 if (F_ISSET(t, R_EOF | R_INMEM))
  85                         return (RET_SPECIAL);
  86                 if ((status = t->bt_irec(t, nrec)) != RET_SUCCESS)
  87                         return (status);
  88         }
  89
  90         --nrec;
  91         if ((e = __rec_search(t, nrec, SEARCH)) == NULL)
  92                 return (RET_ERROR);
  93
  94         status = __rec_ret(t, e, 0, NULL, data);
  95         if (F_ISSET(t, B_DB_LOCK))
  96                 mpool_put(t->bt_mp, e->page, 0);
  97         else
  98                 t->bt_pinned = e->page;
  99         return (status);
 100 }
 101
 102 /*
 103  * __REC_FPIPE -- Get fixed length records from a pipe.
 104  *
 105  * Parameters:
 106  *      t:      tree
 107  *      cnt:    records to read
 108  *
 109  * Returns:
 110  *      RET_ERROR, RET_SUCCESS
 111  */
 112 int
 113 __rec_fpipe(BTREE *t, recno_t top)
 114 {
 115         DBT data;
 116         recno_t nrec;
 117         size_t len;
 118         int ch;
 119         unsigned char *p;
 120
 121         if (t->bt_rdata.size < t->bt_reclen) {
 122                 t->bt_rdata.data = reallocf(t->bt_rdata.data, t->bt_reclen);
 123                 if (t->bt_rdata.data == NULL)
 124                         return (RET_ERROR);
 125                 t->bt_rdata.size = t->bt_reclen;
 126         }
 127         data.data = t->bt_rdata.data;
 128         data.size = t->bt_reclen;
 129
 130         for (nrec = t->bt_nrecs; nrec < top;) {
 131                 len = t->bt_reclen;
 132                 for (p = t->bt_rdata.data;; *p++ = ch)
 133                         if ((ch = getc(t->bt_rfp)) == EOF || !--len) {
 134                                 if (ch != EOF)
 135                                         *p = ch;
 136                                 if (len != 0)
 137                                         memset(p, t->bt_bval, len);
 138                                 if (__rec_iput(t,
 139                                     nrec, &data, 0) != RET_SUCCESS)
 140                                         return (RET_ERROR);
 141                                 ++nrec;
 142                                 break;
 143                         }
 144                 if (ch == EOF)
 145                         break;
 146         }
 147         if (nrec < top) {
 148                 F_SET(t, R_EOF);
 149                 return (RET_SPECIAL);
 150         }
 151         return (RET_SUCCESS);
 152 }
 153
 154 /*
 155  * __REC_VPIPE -- Get variable length records from a pipe.
 156  *
 157  * Parameters:
 158  *      t:      tree
 159  *      cnt:    records to read
 160  *
 161  * Returns:
 162  *      RET_ERROR, RET_SUCCESS
 163  */
 164 int
 165 __rec_vpipe(BTREE *t, recno_t top)
 166 {
 167         DBT data;
 168         recno_t nrec;
 169         size_t len;
 170         size_t sz;
 171         int bval, ch;
 172         unsigned char *p;
 173
 174         bval = t->bt_bval;
 175         for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
 176                 for (p = t->bt_rdata.data,
 177                     sz = t->bt_rdata.size;; *p++ = ch, --sz) {
 178                         if ((ch = getc(t->bt_rfp)) == EOF || ch == bval) {
 179                                 data.data = t->bt_rdata.data;
 180                                 data.size = p -
 181                                     (unsigned char *)t->bt_rdata.data;
 182                                 if (ch == EOF && data.size == 0)
 183                                         break;
 184                                 if (__rec_iput(t, nrec, &data, 0)
 185                                     != RET_SUCCESS)
 186                                         return (RET_ERROR);
 187                                 break;
 188                         }
 189                         if (sz == 0) {
 190                                 len = p - (unsigned char *)t->bt_rdata.data;
 191                                 t->bt_rdata.size += (sz = 256);
 192                                 t->bt_rdata.data = reallocf(t->bt_rdata.data,
 193                                     t->bt_rdata.size);
 194                                 if (t->bt_rdata.data == NULL)
 195                                         return (RET_ERROR);
 196                                 p = (unsigned char *)t->bt_rdata.data + len;
 197                         }
 198                 }
 199                 if (ch == EOF)
 200                         break;
 201         }
 202         if (nrec < top) {
 203                 F_SET(t, R_EOF);
 204                 return (RET_SPECIAL);
 205         }
 206         return (RET_SUCCESS);
 207 }
 208
 209 /*
 210  * __REC_FMAP -- Get fixed length records from a file.
 211  *
 212  * Parameters:
 213  *      t:      tree
 214  *      cnt:    records to read
 215  *
 216  * Returns:
 217  *      RET_ERROR, RET_SUCCESS
 218  */
 219 int
 220 __rec_fmap(BTREE *t, recno_t top)
 221 {
 222         DBT data;
 223         recno_t nrec;
 224         unsigned char *sp, *ep, *p;
 225         size_t len;
 226
 227         if (t->bt_rdata.size < t->bt_reclen) {
 228                 t->bt_rdata.data = reallocf(t->bt_rdata.data, t->bt_reclen);
 229                 if (t->bt_rdata.data == NULL)
 230                         return (RET_ERROR);
 231                 t->bt_rdata.size = t->bt_reclen;
 232         }
 233         data.data = t->bt_rdata.data;
 234         data.size = t->bt_reclen;
 235
 236         sp = (unsigned char *)t->bt_cmap;
 237         ep = (unsigned char *)t->bt_emap;
 238         for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
 239                 if (sp >= ep) {
 240                         F_SET(t, R_EOF);
 241                         return (RET_SPECIAL);
 242                 }
 243                 len = t->bt_reclen;
 244                 for (p = t->bt_rdata.data;
 245                     sp < ep && len > 0; *p++ = *sp++, --len);
 246                 if (len != 0)
 247                         memset(p, t->bt_bval, len);
 248                 if (__rec_iput(t, nrec, &data, 0) != RET_SUCCESS)
 249                         return (RET_ERROR);
 250         }
 251         t->bt_cmap = (caddr_t)sp;
 252         return (RET_SUCCESS);
 253 }
 254
 255 /*
 256  * __REC_VMAP -- Get variable length records from a file.
 257  *
 258  * Parameters:
 259  *      t:      tree
 260  *      cnt:    records to read
 261  *
 262  * Returns:
 263  *      RET_ERROR, RET_SUCCESS
 264  */
 265 int
 266 __rec_vmap(BTREE *t, recno_t top)
 267 {
 268         DBT data;
 269         unsigned char *sp, *ep;
 270         recno_t nrec;
 271         int bval;
 272
 273         sp = (unsigned char *)t->bt_cmap;
 274         ep = (unsigned char *)t->bt_emap;
 275         bval = t->bt_bval;
 276
 277         for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
 278                 if (sp >= ep) {
 279                         F_SET(t, R_EOF);
 280                         return (RET_SPECIAL);
 281                 }
 282                 for (data.data = sp; sp < ep && *sp != bval; ++sp);
 283                 data.size = sp - (unsigned char *)data.data;
 284                 if (__rec_iput(t, nrec, &data, 0) != RET_SUCCESS)
 285                         return (RET_ERROR);
 286                 ++sp;
 287         }
 288         t->bt_cmap = (caddr_t)sp;
 289         return (RET_SUCCESS);
 290 }