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