xref: /freebsd/lib/libc/db/recno/rec_get.c (revision 39beb93c3f8bdbf72a61fda42300b5ebed7390c8)
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  * 4. 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 
30 #if defined(LIBC_SCCS) && !defined(lint)
31 static char sccsid[] = "@(#)rec_get.c	8.9 (Berkeley) 8/18/94";
32 #endif /* LIBC_SCCS and not lint */
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include <sys/types.h>
37 
38 #include <errno.h>
39 #include <stddef.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <unistd.h>
44 
45 #include <db.h>
46 #include "recno.h"
47 
48 /*
49  * __REC_GET -- Get a record from the btree.
50  *
51  * Parameters:
52  *	dbp:	pointer to access method
53  *	key:	key to find
54  *	data:	data to return
55  *	flag:	currently unused
56  *
57  * Returns:
58  *	RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key not found.
59  */
60 int
61 __rec_get(dbp, key, data, flags)
62 	const DB *dbp;
63 	const DBT *key;
64 	DBT *data;
65 	u_int flags;
66 {
67 	BTREE *t;
68 	EPG *e;
69 	recno_t nrec;
70 	int status;
71 
72 	t = dbp->internal;
73 
74 	/* Toss any page pinned across calls. */
75 	if (t->bt_pinned != NULL) {
76 		mpool_put(t->bt_mp, t->bt_pinned, 0);
77 		t->bt_pinned = NULL;
78 	}
79 
80 	/* Get currently doesn't take any flags, and keys of 0 are illegal. */
81 	if (flags || (nrec = *(recno_t *)key->data) == 0) {
82 		errno = EINVAL;
83 		return (RET_ERROR);
84 	}
85 
86 	/*
87 	 * If we haven't seen this record yet, try to find it in the
88 	 * original file.
89 	 */
90 	if (nrec > t->bt_nrecs) {
91 		if (F_ISSET(t, R_EOF | R_INMEM))
92 			return (RET_SPECIAL);
93 		if ((status = t->bt_irec(t, nrec)) != RET_SUCCESS)
94 			return (status);
95 	}
96 
97 	--nrec;
98 	if ((e = __rec_search(t, nrec, SEARCH)) == NULL)
99 		return (RET_ERROR);
100 
101 	status = __rec_ret(t, e, 0, NULL, data);
102 	if (F_ISSET(t, B_DB_LOCK))
103 		mpool_put(t->bt_mp, e->page, 0);
104 	else
105 		t->bt_pinned = e->page;
106 	return (status);
107 }
108 
109 /*
110  * __REC_FPIPE -- Get fixed length records from a pipe.
111  *
112  * Parameters:
113  *	t:	tree
114  *	cnt:	records to read
115  *
116  * Returns:
117  *	RET_ERROR, RET_SUCCESS
118  */
119 int
120 __rec_fpipe(t, top)
121 	BTREE *t;
122 	recno_t top;
123 {
124 	DBT data;
125 	recno_t nrec;
126 	size_t len;
127 	int ch;
128 	u_char *p;
129 
130 	if (t->bt_rdata.size < t->bt_reclen) {
131 		t->bt_rdata.data = t->bt_rdata.data == NULL ?
132 		    malloc(t->bt_reclen) :
133 		    reallocf(t->bt_rdata.data, t->bt_reclen);
134 		if (t->bt_rdata.data == NULL)
135 			return (RET_ERROR);
136 		t->bt_rdata.size = t->bt_reclen;
137 	}
138 	data.data = t->bt_rdata.data;
139 	data.size = t->bt_reclen;
140 
141 	for (nrec = t->bt_nrecs; nrec < top;) {
142 		len = t->bt_reclen;
143 		for (p = t->bt_rdata.data;; *p++ = ch)
144 			if ((ch = getc(t->bt_rfp)) == EOF || !--len) {
145 				if (ch != EOF)
146 					*p = ch;
147 				if (len != 0)
148 					memset(p, t->bt_bval, len);
149 				if (__rec_iput(t,
150 				    nrec, &data, 0) != RET_SUCCESS)
151 					return (RET_ERROR);
152 				++nrec;
153 				break;
154 			}
155 		if (ch == EOF)
156 			break;
157 	}
158 	if (nrec < top) {
159 		F_SET(t, R_EOF);
160 		return (RET_SPECIAL);
161 	}
162 	return (RET_SUCCESS);
163 }
164 
165 /*
166  * __REC_VPIPE -- Get variable length records from a pipe.
167  *
168  * Parameters:
169  *	t:	tree
170  *	cnt:	records to read
171  *
172  * Returns:
173  *	RET_ERROR, RET_SUCCESS
174  */
175 int
176 __rec_vpipe(t, top)
177 	BTREE *t;
178 	recno_t top;
179 {
180 	DBT data;
181 	recno_t nrec;
182 	size_t len;
183 	size_t sz;
184 	int bval, ch;
185 	u_char *p;
186 
187 	bval = t->bt_bval;
188 	for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
189 		for (p = t->bt_rdata.data,
190 		    sz = t->bt_rdata.size;; *p++ = ch, --sz) {
191 			if ((ch = getc(t->bt_rfp)) == EOF || ch == bval) {
192 				data.data = t->bt_rdata.data;
193 				data.size = p - (u_char *)t->bt_rdata.data;
194 				if (ch == EOF && data.size == 0)
195 					break;
196 				if (__rec_iput(t, nrec, &data, 0)
197 				    != RET_SUCCESS)
198 					return (RET_ERROR);
199 				break;
200 			}
201 			if (sz == 0) {
202 				len = p - (u_char *)t->bt_rdata.data;
203 				t->bt_rdata.size += (sz = 256);
204 				t->bt_rdata.data = t->bt_rdata.data == NULL ?
205 				    malloc(t->bt_rdata.size) :
206 				    reallocf(t->bt_rdata.data, t->bt_rdata.size);
207 				if (t->bt_rdata.data == NULL)
208 					return (RET_ERROR);
209 				p = (u_char *)t->bt_rdata.data + len;
210 			}
211 		}
212 		if (ch == EOF)
213 			break;
214 	}
215 	if (nrec < top) {
216 		F_SET(t, R_EOF);
217 		return (RET_SPECIAL);
218 	}
219 	return (RET_SUCCESS);
220 }
221 
222 /*
223  * __REC_FMAP -- Get fixed length records from a file.
224  *
225  * Parameters:
226  *	t:	tree
227  *	cnt:	records to read
228  *
229  * Returns:
230  *	RET_ERROR, RET_SUCCESS
231  */
232 int
233 __rec_fmap(t, top)
234 	BTREE *t;
235 	recno_t top;
236 {
237 	DBT data;
238 	recno_t nrec;
239 	u_char *sp, *ep, *p;
240 	size_t len;
241 
242 	if (t->bt_rdata.size < t->bt_reclen) {
243 		t->bt_rdata.data = t->bt_rdata.data == NULL ?
244 		    malloc(t->bt_reclen) :
245 		    reallocf(t->bt_rdata.data, t->bt_reclen);
246 		if (t->bt_rdata.data == NULL)
247 			return (RET_ERROR);
248 		t->bt_rdata.size = t->bt_reclen;
249 	}
250 	data.data = t->bt_rdata.data;
251 	data.size = t->bt_reclen;
252 
253 	sp = (u_char *)t->bt_cmap;
254 	ep = (u_char *)t->bt_emap;
255 	for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
256 		if (sp >= ep) {
257 			F_SET(t, R_EOF);
258 			return (RET_SPECIAL);
259 		}
260 		len = t->bt_reclen;
261 		for (p = t->bt_rdata.data;
262 		    sp < ep && len > 0; *p++ = *sp++, --len);
263 		if (len != 0)
264 			memset(p, t->bt_bval, len);
265 		if (__rec_iput(t, nrec, &data, 0) != RET_SUCCESS)
266 			return (RET_ERROR);
267 	}
268 	t->bt_cmap = (caddr_t)sp;
269 	return (RET_SUCCESS);
270 }
271 
272 /*
273  * __REC_VMAP -- Get variable length records from a file.
274  *
275  * Parameters:
276  *	t:	tree
277  *	cnt:	records to read
278  *
279  * Returns:
280  *	RET_ERROR, RET_SUCCESS
281  */
282 int
283 __rec_vmap(t, top)
284 	BTREE *t;
285 	recno_t top;
286 {
287 	DBT data;
288 	u_char *sp, *ep;
289 	recno_t nrec;
290 	int bval;
291 
292 	sp = (u_char *)t->bt_cmap;
293 	ep = (u_char *)t->bt_emap;
294 	bval = t->bt_bval;
295 
296 	for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
297 		if (sp >= ep) {
298 			F_SET(t, R_EOF);
299 			return (RET_SPECIAL);
300 		}
301 		for (data.data = sp; sp < ep && *sp != bval; ++sp);
302 		data.size = sp - (u_char *)data.data;
303 		if (__rec_iput(t, nrec, &data, 0) != RET_SUCCESS)
304 			return (RET_ERROR);
305 		++sp;
306 	}
307 	t->bt_cmap = (caddr_t)sp;
308 	return (RET_SUCCESS);
309 }
310