Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/db/recno/rec_put.c	Lines:	0	99	0.0 %
Date:	2017-11-07	Branches:	0	74	0.0 %


/*	$OpenBSD: rec_put.c,v 1.11 2007/08/08 07:16:50 ray Exp $	*/

/*-
 * Copyright (c) 1990, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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. 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.
 */

#include <sys/types.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <db.h>
#include "recno.h"

/*
 * __REC_PUT -- Add a recno item to the tree.
 *
 * Parameters:
 *	dbp:	pointer to access method
 *	key:	key
 *	data:	data
 *	flag:	R_CURSOR, R_IAFTER, R_IBEFORE, R_NOOVERWRITE
 *
 * Returns:
 *	RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key is
 *	already in the tree and R_NOOVERWRITE specified.
 */
int
__rec_put(const DB *dbp, DBT *key, const DBT *data, u_int flags)
{
	BTREE *t;
	DBT fdata, tdata;
	recno_t nrec;
	int status;
	void *tp;

	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;
	}

	/*
	 * If using fixed-length records, and the record is long, return
	 * EINVAL.  If it's short, pad it out.  Use the record data return
	 * memory, it's only short-term.
	 */
	if (F_ISSET(t, R_FIXLEN) && data->size != t->bt_reclen) {
		if (data->size > t->bt_reclen)
			goto einval;

		if (t->bt_rdata.size < t->bt_reclen) {
			tp = realloc(t->bt_rdata.data, t->bt_reclen);
			if (tp == NULL)
				return (RET_ERROR);
			t->bt_rdata.data = tp;
			t->bt_rdata.size = t->bt_reclen;
		}
		memmove(t->bt_rdata.data, data->data, data->size);
		memset((char *)t->bt_rdata.data + data->size,
		    t->bt_bval, t->bt_reclen - data->size);
		fdata.data = t->bt_rdata.data;
		fdata.size = t->bt_reclen;
	} else {
		fdata.data = data->data;
		fdata.size = data->size;
	}

	switch (flags) {
	case R_CURSOR:
		if (!F_ISSET(&t->bt_cursor, CURS_INIT))
			goto einval;
		nrec = t->bt_cursor.rcursor;
		break;
	case R_SETCURSOR:
		if ((nrec = *(recno_t *)key->data) == 0)
			goto einval;
		break;
	case R_IAFTER:
		if ((nrec = *(recno_t *)key->data) == 0) {
			nrec = 1;
			flags = R_IBEFORE;
		}
		break;
	case 0:
	case R_IBEFORE:
		if ((nrec = *(recno_t *)key->data) == 0)
			goto einval;
		break;
	case R_NOOVERWRITE:
		if ((nrec = *(recno_t *)key->data) == 0)
			goto einval;
		if (nrec <= t->bt_nrecs)
			return (RET_SPECIAL);
		break;
	default:
einval:		errno = EINVAL;
		return (RET_ERROR);
	}

	/*
	 * Make sure that records up to and including the put record are
	 * already in the database.  If skipping records, create empty ones.
	 */
	if (nrec > t->bt_nrecs) {
		if (!F_ISSET(t, R_EOF | R_INMEM) &&
		    t->bt_irec(t, nrec) == RET_ERROR)
			return (RET_ERROR);
		if (nrec > t->bt_nrecs + 1) {
			if (F_ISSET(t, R_FIXLEN)) {
				if ((tdata.data =
				    (void *)malloc(t->bt_reclen)) == NULL)
					return (RET_ERROR);
				tdata.size = t->bt_reclen;
				memset(tdata.data, t->bt_bval, tdata.size);
			} else {
				tdata.data = NULL;
				tdata.size = 0;
			}
			while (nrec > t->bt_nrecs + 1)
				if (__rec_iput(t,
				    t->bt_nrecs, &tdata, 0) != RET_SUCCESS)
					return (RET_ERROR);
			if (F_ISSET(t, R_FIXLEN))
				free(tdata.data);
		}
	}

	if ((status = __rec_iput(t, nrec - 1, &fdata, flags)) != RET_SUCCESS)
		return (status);

	if (flags == R_SETCURSOR)
		t->bt_cursor.rcursor = nrec;

	F_SET(t, R_MODIFIED);
	return (__rec_ret(t, NULL, nrec, key, NULL));
}

/*
 * __REC_IPUT -- Add a recno item to the tree.
 *
 * Parameters:
 *	t:	tree
 *	nrec:	record number
 *	data:	data
 *
 * Returns:
 *	RET_ERROR, RET_SUCCESS
 */
int
__rec_iput(BTREE *t, recno_t nrec, const DBT *data, u_int flags)
{
	DBT tdata;
	EPG *e;
	PAGE *h;
	indx_t idx, nxtindex;
	pgno_t pg;
	u_int32_t nbytes;
	int dflags, status;
	char *dest, db[NOVFLSIZE];

	/*
	 * If the data won't fit on a page, store it on indirect pages.
	 *
	 * XXX
	 * If the insert fails later on, these pages aren't recovered.
	 */
	if (data->size > t->bt_ovflsize) {
		if (__ovfl_put(t, data, &pg) == RET_ERROR)
			return (RET_ERROR);
		tdata.data = db;
		tdata.size = NOVFLSIZE;
		*(pgno_t *)db = pg;
		*(u_int32_t *)(db + sizeof(pgno_t)) = data->size;
		dflags = P_BIGDATA;
		data = &tdata;
	} else
		dflags = 0;

	/* __rec_search pins the returned page. */
	if ((e = __rec_search(t, nrec,
	    nrec > t->bt_nrecs || flags == R_IAFTER || flags == R_IBEFORE ?
	    SINSERT : SEARCH)) == NULL)
		return (RET_ERROR);

	h = e->page;
	idx = e->index;

	/*
	 * Add the specified key/data pair to the tree.  The R_IAFTER and
	 * R_IBEFORE flags insert the key after/before the specified key.
	 *
	 * Pages are split as required.
	 */
	switch (flags) {
	case R_IAFTER:
		++idx;
		break;
	case R_IBEFORE:
		break;
	default:
		if (nrec < t->bt_nrecs &&
		    __rec_dleaf(t, h, idx) == RET_ERROR) {
			mpool_put(t->bt_mp, h, 0);
			return (RET_ERROR);
		}
		break;
	}

	/*
	 * If not enough room, split the page.  The split code will insert
	 * the key and data and unpin the current page.  If inserting into
	 * the offset array, shift the pointers up.
	 */
	nbytes = NRLEAFDBT(data->size);
	if (h->upper - h->lower < nbytes + sizeof(indx_t)) {
		status = __bt_split(t, h, NULL, data, dflags, nbytes, idx);
		if (status == RET_SUCCESS)
			++t->bt_nrecs;
		return (status);
	}

	if (idx < (nxtindex = NEXTINDEX(h)))
		memmove(h->linp + idx + 1, h->linp + idx,
		    (nxtindex - idx) * sizeof(indx_t));
	h->lower += sizeof(indx_t);

	h->linp[idx] = h->upper -= nbytes;
	dest = (char *)h + h->upper;
	WR_RLEAF(dest, data, dflags);

	++t->bt_nrecs;
	F_SET(t, B_MODIFIED);
	mpool_put(t->bt_mp, h, MPOOL_DIRTY);

	return (RET_SUCCESS);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: rec_put.c,v 1.11 2007/08/08 07:16:50 ray Exp $ */
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. Neither the name of the University nor the names of its contributors
16			* may be used to endorse or promote products derived from this software
17			* without specific prior written permission.
18			*
19			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29			* SUCH DAMAGE.
30			*/
31
32			#include <sys/types.h>
33
34			#include <errno.h>
35			#include <stdio.h>
36			#include <stdlib.h>
37			#include <string.h>
38
39			#include <db.h>
40			#include "recno.h"
41
42			/*
43			* __REC_PUT -- Add a recno item to the tree.
44			*
45			* Parameters:
46			* dbp: pointer to access method
47			* key: key
48			* data: data
49			* flag: R_CURSOR, R_IAFTER, R_IBEFORE, R_NOOVERWRITE
50			*
51			* Returns:
52			* RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key is
53			* already in the tree and R_NOOVERWRITE specified.
54			*/
55			int
56			__rec_put(const DB dbp, DBT key, const DBT *data, u_int flags)
57			{
58			BTREE *t;
59			DBT fdata, tdata;
60			recno_t nrec;
61			int status;
62			void *tp;
63
64			t = dbp->internal;
65
66			/* Toss any page pinned across calls. */
67			if (t->bt_pinned != NULL) {
68			mpool_put(t->bt_mp, t->bt_pinned, 0);
69			t->bt_pinned = NULL;
70			}
71
72			/*
73			* If using fixed-length records, and the record is long, return
74			* EINVAL. If it's short, pad it out. Use the record data return
75			* memory, it's only short-term.
76			*/
77			if (F_ISSET(t, R_FIXLEN) && data->size != t->bt_reclen) {
78			if (data->size > t->bt_reclen)
79			goto einval;
80
81			if (t->bt_rdata.size < t->bt_reclen) {
82			tp = realloc(t->bt_rdata.data, t->bt_reclen);
83			if (tp == NULL)
84			return (RET_ERROR);
85			t->bt_rdata.data = tp;
86			t->bt_rdata.size = t->bt_reclen;
87			}
88			memmove(t->bt_rdata.data, data->data, data->size);
89			memset((char *)t->bt_rdata.data + data->size,
90			t->bt_bval, t->bt_reclen - data->size);
91			fdata.data = t->bt_rdata.data;
92			fdata.size = t->bt_reclen;
93			} else {
94			fdata.data = data->data;
95			fdata.size = data->size;
96			}
97
98			switch (flags) {
99			case R_CURSOR:
100			if (!F_ISSET(&t->bt_cursor, CURS_INIT))
101			goto einval;
102			nrec = t->bt_cursor.rcursor;
103			break;
104			case R_SETCURSOR:
105			if ((nrec = (recno_t )key->data) == 0)
106			goto einval;
107			break;
108			case R_IAFTER:
109			if ((nrec = (recno_t )key->data) == 0) {
110			nrec = 1;
111			flags = R_IBEFORE;
112			}
113			break;
114			case 0:
115			case R_IBEFORE:
116			if ((nrec = (recno_t )key->data) == 0)
117			goto einval;
118			break;
119			case R_NOOVERWRITE:
120			if ((nrec = (recno_t )key->data) == 0)
121			goto einval;
122			if (nrec <= t->bt_nrecs)
123			return (RET_SPECIAL);
124			break;
125			default:
126			einval: errno = EINVAL;
127			return (RET_ERROR);
128			}
129
130			/*
131			* Make sure that records up to and including the put record are
132			* already in the database. If skipping records, create empty ones.
133			*/
134			if (nrec > t->bt_nrecs) {
135			if (!F_ISSET(t, R_EOF \| R_INMEM) &&
136			t->bt_irec(t, nrec) == RET_ERROR)
137			return (RET_ERROR);
138			if (nrec > t->bt_nrecs + 1) {
139			if (F_ISSET(t, R_FIXLEN)) {
140			if ((tdata.data =
141			(void *)malloc(t->bt_reclen)) == NULL)
142			return (RET_ERROR);
143			tdata.size = t->bt_reclen;
144			memset(tdata.data, t->bt_bval, tdata.size);
145			} else {
146			tdata.data = NULL;
147			tdata.size = 0;
148			}
149			while (nrec > t->bt_nrecs + 1)
150			if (__rec_iput(t,
151			t->bt_nrecs, &tdata, 0) != RET_SUCCESS)
152			return (RET_ERROR);
153			if (F_ISSET(t, R_FIXLEN))
154			free(tdata.data);
155			}
156			}
157
158			if ((status = __rec_iput(t, nrec - 1, &fdata, flags)) != RET_SUCCESS)
159			return (status);
160
161			if (flags == R_SETCURSOR)
162			t->bt_cursor.rcursor = nrec;
163
164			F_SET(t, R_MODIFIED);
165			return (__rec_ret(t, NULL, nrec, key, NULL));
166			}
167
168			/*
169			* __REC_IPUT -- Add a recno item to the tree.
170			*
171			* Parameters:
172			* t: tree
173			* nrec: record number
174			* data: data
175			*
176			* Returns:
177			* RET_ERROR, RET_SUCCESS
178			*/
179			int
180			__rec_iput(BTREE t, recno_t nrec, const DBT data, u_int flags)
181			{
182			DBT tdata;
183			EPG *e;
184			PAGE *h;
185			indx_t idx, nxtindex;
186			pgno_t pg;
187			u_int32_t nbytes;
188			int dflags, status;
189			char *dest, db[NOVFLSIZE];
190
191			/*
192			* If the data won't fit on a page, store it on indirect pages.
193			*
194			* XXX
195			* If the insert fails later on, these pages aren't recovered.
196			*/
197			if (data->size > t->bt_ovflsize) {
198			if (__ovfl_put(t, data, &pg) == RET_ERROR)
199			return (RET_ERROR);
200			tdata.data = db;
201			tdata.size = NOVFLSIZE;
202			(pgno_t )db = pg;
203			(u_int32_t )(db + sizeof(pgno_t)) = data->size;
204			dflags = P_BIGDATA;
205			data = &tdata;
206			} else
207			dflags = 0;
208
209			/* __rec_search pins the returned page. */
210			if ((e = __rec_search(t, nrec,
211			nrec > t->bt_nrecs \|\| flags == R_IAFTER \|\| flags == R_IBEFORE ?
212			SINSERT : SEARCH)) == NULL)
213			return (RET_ERROR);
214
215			h = e->page;
216			idx = e->index;
217
218			/*
219			* Add the specified key/data pair to the tree. The R_IAFTER and
220			* R_IBEFORE flags insert the key after/before the specified key.
221			*
222			* Pages are split as required.
223			*/
224			switch (flags) {
225			case R_IAFTER:
226			++idx;
227			break;
228			case R_IBEFORE:
229			break;
230			default:
231			if (nrec < t->bt_nrecs &&
232			__rec_dleaf(t, h, idx) == RET_ERROR) {
233			mpool_put(t->bt_mp, h, 0);
234			return (RET_ERROR);
235			}
236			break;
237			}
238
239			/*
240			* If not enough room, split the page. The split code will insert
241			* the key and data and unpin the current page. If inserting into
242			* the offset array, shift the pointers up.
243			*/
244			nbytes = NRLEAFDBT(data->size);
245			if (h->upper - h->lower < nbytes + sizeof(indx_t)) {
246			status = __bt_split(t, h, NULL, data, dflags, nbytes, idx);
247			if (status == RET_SUCCESS)
248			++t->bt_nrecs;
249			return (status);
250			}
251
252			if (idx < (nxtindex = NEXTINDEX(h)))
253			memmove(h->linp + idx + 1, h->linp + idx,
254			(nxtindex - idx) * sizeof(indx_t));
255			h->lower += sizeof(indx_t);
256
257			h->linp[idx] = h->upper -= nbytes;
258			dest = (char *)h + h->upper;
259			WR_RLEAF(dest, data, dflags);
260
261			++t->bt_nrecs;
262			F_SET(t, B_MODIFIED);
263			mpool_put(t->bt_mp, h, MPOOL_DIRTY);
264
265			return (RET_SUCCESS);
266			}