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)
37static 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 */
64int
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 */
123int
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 */
179int
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 */
236int
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 */
286int
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