xref: /illumos-gate/usr/src/cmd/svc/configd/object.c (revision 6e1d2b42)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * This file only contains the transaction commit logic.
31  */
32 
33 #include <assert.h>
34 #include <alloca.h>
35 #include <errno.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <strings.h>
39 #include <sys/sysmacros.h>
40 #include "configd.h"
41 
42 #define	INVALID_OBJ_ID ((uint32_t)-1)
43 #define	INVALID_TYPE ((uint32_t)-1)
44 
45 struct tx_cmd {
46 	const struct rep_protocol_transaction_cmd *tx_cmd;
47 	const char	*tx_prop;
48 	uint32_t	*tx_values;
49 	uint32_t	tx_nvalues;
50 	uint32_t	tx_orig_value_id;
51 	char		tx_found;
52 	char		tx_processed;
53 	char		tx_bad;
54 };
55 
56 static int
tx_cmd_compare(const void * key,const void * elem_arg)57 tx_cmd_compare(const void *key, const void *elem_arg)
58 {
59 	const struct tx_cmd *elem = elem_arg;
60 
61 	return (strcmp((const char *)key, elem->tx_prop));
62 }
63 
64 struct tx_commit_data {
65 	uint32_t	txc_pg_id;
66 	uint32_t	txc_gen;
67 	uint32_t	txc_oldgen;
68 	short		txc_backend;
69 	backend_tx_t	*txc_tx;
70 	backend_query_t	*txc_inserts;
71 	size_t		txc_count;
72 	rep_protocol_responseid_t txc_result;
73 	struct tx_cmd	txc_cmds[1];		/* actually txc_count */
74 };
75 #define	TX_COMMIT_DATA_SIZE(count) \
76 	offsetof(struct tx_commit_data, txc_cmds[count])
77 
78 /*ARGSUSED*/
79 static int
tx_check_genid(void * data_arg,int columns,char ** vals,char ** names)80 tx_check_genid(void *data_arg, int columns, char **vals, char **names)
81 {
82 	tx_commit_data_t *data = data_arg;
83 	assert(columns == 1);
84 	if (atoi(vals[0]) != data->txc_oldgen)
85 		data->txc_result = REP_PROTOCOL_FAIL_NOT_LATEST;
86 	else
87 		data->txc_result = REP_PROTOCOL_SUCCESS;
88 	return (BACKEND_CALLBACK_CONTINUE);
89 }
90 
91 /*
92  * tx_process_property() is called once for each property in current
93  * property group generation.  Its purpose is threefold:
94  *
95  *	1. copy properties not mentioned in the transaction over unchanged.
96  *	2. mark DELETEd properties as seen (they will be left out of the new
97  *	   generation).
98  *	3. consistancy-check NEW, CLEAR, and REPLACE commands.
99  *
100  * Any consistancy problems set tx_bad, and seen properties are marked
101  * tx_found.  These is used later, in tx_process_cmds().
102  */
103 /*ARGSUSED*/
104 static int
tx_process_property(void * data_arg,int columns,char ** vals,char ** names)105 tx_process_property(void *data_arg, int columns, char **vals, char **names)
106 {
107 	tx_commit_data_t *data = data_arg;
108 	struct tx_cmd *elem;
109 
110 	const char *prop_name = vals[0];
111 	const char *prop_type = vals[1];
112 	const char *lnk_val_id = vals[2];
113 
114 	char *endptr;
115 
116 	assert(columns == 3);
117 
118 	elem = bsearch(prop_name, data->txc_cmds, data->txc_count,
119 	    sizeof (*data->txc_cmds), tx_cmd_compare);
120 
121 	if (elem == NULL) {
122 		backend_query_add(data->txc_inserts,
123 		    "INSERT INTO prop_lnk_tbl"
124 		    "    (lnk_pg_id, lnk_gen_id, lnk_prop_name, lnk_prop_type,"
125 		    "    lnk_val_id) "
126 		    "VALUES ( %d, %d, '%q', '%q', %Q );",
127 		    data->txc_pg_id, data->txc_gen, prop_name, prop_type,
128 		    lnk_val_id);
129 	} else {
130 		assert(!elem->tx_found);
131 		elem->tx_found = 1;
132 
133 		if (lnk_val_id != NULL) {
134 			errno = 0;
135 			elem->tx_orig_value_id =
136 			    strtoul(lnk_val_id, &endptr, 10);
137 			if (elem->tx_orig_value_id == 0 || *endptr != 0 ||
138 			    errno != 0) {
139 				return (BACKEND_CALLBACK_ABORT);
140 			}
141 		} else {
142 			elem->tx_orig_value_id = 0;
143 		}
144 
145 		switch (elem->tx_cmd->rptc_action) {
146 		case REP_PROTOCOL_TX_ENTRY_NEW:
147 			elem->tx_bad = 1;
148 			data->txc_result = REP_PROTOCOL_FAIL_EXISTS;
149 			break;
150 		case REP_PROTOCOL_TX_ENTRY_CLEAR:
151 			if (REP_PROTOCOL_BASE_TYPE(elem->tx_cmd->rptc_type) !=
152 			    prop_type[0] &&
153 			    REP_PROTOCOL_SUBTYPE(elem->tx_cmd->rptc_type) !=
154 			    prop_type[1]) {
155 				elem->tx_bad = 1;
156 				data->txc_result =
157 				    REP_PROTOCOL_FAIL_TYPE_MISMATCH;
158 			}
159 			break;
160 		case REP_PROTOCOL_TX_ENTRY_REPLACE:
161 			break;
162 		case REP_PROTOCOL_TX_ENTRY_DELETE:
163 			elem->tx_processed = 1;
164 			break;
165 		default:
166 			assert(0);
167 			break;
168 		}
169 	}
170 	return (BACKEND_CALLBACK_CONTINUE);
171 }
172 
173 /*
174  * tx_process_cmds() finishes the job tx_process_property() started:
175  *
176  *	1. if tx_process_property() marked a command as bad, we skip it.
177  *	2. if a DELETE, REPLACE, or CLEAR operated on a non-existant property,
178  *	    we mark it as bad.
179  *	3. we complete the work of NEW, REPLACE, and CLEAR, by inserting the
180  *	    appropriate values into the database.
181  *	4. we delete all replaced data, if it is no longer referenced.
182  *
183  * Finally, we check all of the commands, and fail if anything was marked bad.
184  */
185 static int
tx_process_cmds(tx_commit_data_t * data)186 tx_process_cmds(tx_commit_data_t *data)
187 {
188 	int idx;
189 	int r;
190 	int count = data->txc_count;
191 	struct tx_cmd *elem;
192 	uint32_t val_id = 0;
193 	uint8_t type[3];
194 
195 	backend_query_t *q;
196 	int do_delete;
197 
198 	/*
199 	 * For persistent pgs, we use backend_fail_if_seen to abort the
200 	 * deletion if there is a snapshot using our current state.
201 	 *
202 	 * All of the deletions in this function are safe, since
203 	 * rc_tx_commit() guarantees that all the data is in-cache.
204 	 */
205 	q = backend_query_alloc();
206 
207 	if (data->txc_backend != BACKEND_TYPE_NONPERSIST) {
208 		backend_query_add(q,
209 		    "SELECT 1 FROM snaplevel_lnk_tbl "
210 		    "    WHERE (snaplvl_pg_id = %d AND snaplvl_gen_id = %d); ",
211 		    data->txc_pg_id, data->txc_oldgen);
212 	}
213 	backend_query_add(q,
214 	    "DELETE FROM prop_lnk_tbl"
215 	    "    WHERE (lnk_pg_id = %d AND lnk_gen_id = %d)",
216 	    data->txc_pg_id, data->txc_oldgen);
217 	r = backend_tx_run(data->txc_tx, q, backend_fail_if_seen, NULL);
218 	backend_query_free(q);
219 
220 	if (r == REP_PROTOCOL_SUCCESS)
221 		do_delete = 1;
222 	else if (r == REP_PROTOCOL_DONE)
223 		do_delete = 0;		/* old gen_id is in use */
224 	else
225 		return (r);
226 
227 	for (idx = 0; idx < count; idx++) {
228 		elem = &data->txc_cmds[idx];
229 
230 		if (elem->tx_bad)
231 			continue;
232 
233 		switch (elem->tx_cmd->rptc_action) {
234 		case REP_PROTOCOL_TX_ENTRY_DELETE:
235 		case REP_PROTOCOL_TX_ENTRY_REPLACE:
236 		case REP_PROTOCOL_TX_ENTRY_CLEAR:
237 			if (!elem->tx_found) {
238 				elem->tx_bad = 1;
239 				continue;
240 			}
241 			break;
242 		case REP_PROTOCOL_TX_ENTRY_NEW:
243 			break;
244 		default:
245 			assert(0);
246 			break;
247 		}
248 
249 		if (do_delete &&
250 		    elem->tx_cmd->rptc_action != REP_PROTOCOL_TX_ENTRY_NEW &&
251 		    elem->tx_orig_value_id != 0) {
252 			/*
253 			 * delete the old values, if they are not in use
254 			 */
255 			q = backend_query_alloc();
256 			backend_query_add(q,
257 			    "SELECT 1 FROM prop_lnk_tbl "
258 			    "    WHERE (lnk_val_id = %d); "
259 			    "DELETE FROM value_tbl"
260 			    "    WHERE (value_id = %d)",
261 			    elem->tx_orig_value_id, elem->tx_orig_value_id);
262 			r = backend_tx_run(data->txc_tx, q,
263 			    backend_fail_if_seen, NULL);
264 			backend_query_free(q);
265 			if (r != REP_PROTOCOL_SUCCESS && r != REP_PROTOCOL_DONE)
266 				return (r);
267 		}
268 
269 		if (elem->tx_cmd->rptc_action == REP_PROTOCOL_TX_ENTRY_DELETE)
270 			continue;		/* no further work to do */
271 
272 		type[0] = REP_PROTOCOL_BASE_TYPE(elem->tx_cmd->rptc_type);
273 		type[1] = REP_PROTOCOL_SUBTYPE(elem->tx_cmd->rptc_type);
274 		type[2] = 0;
275 
276 		if (elem->tx_nvalues == 0) {
277 			r = backend_tx_run_update(data->txc_tx,
278 			    "INSERT INTO prop_lnk_tbl"
279 			    "    (lnk_pg_id, lnk_gen_id, "
280 			    "    lnk_prop_name, lnk_prop_type, lnk_val_id) "
281 			    "VALUES ( %d, %d, '%q', '%q', NULL );",
282 			    data->txc_pg_id, data->txc_gen, elem->tx_prop,
283 			    type);
284 		} else {
285 			uint32_t *v, i = 0;
286 			const char *str;
287 
288 			val_id = backend_new_id(data->txc_tx, BACKEND_ID_VALUE);
289 			if (val_id == 0)
290 				return (REP_PROTOCOL_FAIL_NO_RESOURCES);
291 			r = backend_tx_run_update(data->txc_tx,
292 			    "INSERT INTO prop_lnk_tbl "
293 			    "    (lnk_pg_id, lnk_gen_id, "
294 			    "    lnk_prop_name, lnk_prop_type, lnk_val_id) "
295 			    "VALUES ( %d, %d, '%q', '%q', %d );",
296 			    data->txc_pg_id, data->txc_gen, elem->tx_prop,
297 			    type, val_id);
298 
299 			v = elem->tx_values;
300 
301 			for (i = 0; i < elem->tx_nvalues; i++) {
302 				str = (const char *)&v[1];
303 
304 				/*
305 				 * Update values in backend,  imposing
306 				 * ordering via the value_order column.
307 				 * This ordering is then used in subseqent
308 				 * value retrieval operations.  We can
309 				 * safely assume that the repository schema
310 				 * has been upgraded (and hence has the
311 				 * value_order column in value_tbl),  since
312 				 * it is upgraded as soon as the repository
313 				 * is writable.
314 				 */
315 				r = backend_tx_run_update(data->txc_tx,
316 				    "INSERT INTO value_tbl (value_id, "
317 				    "value_type, value_value, "
318 				    "value_order) VALUES (%d, '%c', "
319 				    "'%q', '%d');\n",
320 				    val_id, elem->tx_cmd->rptc_type,
321 				    str, i);
322 				if (r != REP_PROTOCOL_SUCCESS)
323 					break;
324 
325 				/*LINTED alignment*/
326 				v = (uint32_t *)((caddr_t)str + TX_SIZE(*v));
327 			}
328 		}
329 		if (r != REP_PROTOCOL_SUCCESS)
330 			return (REP_PROTOCOL_FAIL_UNKNOWN);
331 		elem->tx_processed = 1;
332 	}
333 
334 	for (idx = 0; idx < count; idx++) {
335 		elem = &data->txc_cmds[idx];
336 
337 		if (elem->tx_bad)
338 			return (REP_PROTOCOL_FAIL_BAD_TX);
339 	}
340 	return (REP_PROTOCOL_SUCCESS);
341 }
342 
343 static boolean_t
check_string(uintptr_t loc,uint32_t len,uint32_t sz)344 check_string(uintptr_t loc, uint32_t len, uint32_t sz)
345 {
346 	const char *ptr = (const char *)loc;
347 
348 	if (len == 0 || len > sz || ptr[len - 1] != 0 || strlen(ptr) != len - 1)
349 		return (0);
350 	return (1);
351 }
352 
353 static int
tx_check_and_setup(tx_commit_data_t * data,const void * cmds_arg,uint32_t count)354 tx_check_and_setup(tx_commit_data_t *data, const void *cmds_arg,
355     uint32_t count)
356 {
357 	const struct rep_protocol_transaction_cmd *cmds;
358 	struct tx_cmd *cur;
359 	struct tx_cmd *prev = NULL;
360 
361 	uintptr_t loc;
362 	uint32_t sz, len;
363 	int idx;
364 
365 	loc = (uintptr_t)cmds_arg;
366 
367 	for (idx = 0; idx < count; idx++) {
368 		cur = &data->txc_cmds[idx];
369 
370 		cmds = (struct rep_protocol_transaction_cmd *)loc;
371 		cur->tx_cmd = cmds;
372 
373 		sz = cmds->rptc_size;
374 
375 		loc += REP_PROTOCOL_TRANSACTION_CMD_MIN_SIZE;
376 		sz -= REP_PROTOCOL_TRANSACTION_CMD_MIN_SIZE;
377 
378 		len = cmds->rptc_name_len;
379 		if (len <= 1 || !check_string(loc, len, sz)) {
380 			return (REP_PROTOCOL_FAIL_BAD_REQUEST);
381 		}
382 		cur->tx_prop = (const char *)loc;
383 
384 		len = TX_SIZE(len);
385 		loc += len;
386 		sz -= len;
387 
388 		cur->tx_nvalues = 0;
389 		cur->tx_values = (uint32_t *)loc;
390 
391 		while (sz > 0) {
392 			if (sz < sizeof (uint32_t))
393 				return (REP_PROTOCOL_FAIL_BAD_REQUEST);
394 
395 			cur->tx_nvalues++;
396 
397 			len = *(uint32_t *)loc;
398 			loc += sizeof (uint32_t);
399 			sz -= sizeof (uint32_t);
400 
401 			if (!check_string(loc, len, sz))
402 				return (REP_PROTOCOL_FAIL_BAD_REQUEST);
403 
404 			/*
405 			 * XXX here, we should be checking that the values
406 			 * match the purported type
407 			 */
408 
409 			len = TX_SIZE(len);
410 
411 			if (len > sz)
412 				return (REP_PROTOCOL_FAIL_BAD_REQUEST);
413 
414 			loc += len;
415 			sz -= len;
416 		}
417 
418 		if (prev != NULL && strcmp(prev->tx_prop, cur->tx_prop) >= 0)
419 			return (REP_PROTOCOL_FAIL_BAD_REQUEST);
420 
421 		prev = cur;
422 	}
423 	return (REP_PROTOCOL_SUCCESS);
424 }
425 
426 /*
427  * Free the memory associated with a tx_commit_data structure.
428  */
429 void
tx_commit_data_free(tx_commit_data_t * tx_data)430 tx_commit_data_free(tx_commit_data_t *tx_data)
431 {
432 	uu_free(tx_data);
433 }
434 
435 /*
436  * Parse the data of a REP_PROTOCOL_PROPERTYGRP_TX_COMMIT message into a
437  * more useful form.  The data in the message will be represented by a
438  * tx_commit_data_t structure which is allocated by this function.  The
439  * address of the allocated structure is returned to *tx_data and must be
440  * freed by calling tx_commit_data_free().
441  *
442  * Parameters:
443  *	cmds_arg	Address of the commands in the
444  *			REP_PROTOCOL_PROPERTYGRP_TX_COMMIT message.
445  *
446  *	cmds_sz		Number of message bytes at cmds_arg.
447  *
448  *	tx_data		Points to the place to receive the address of the
449  *			allocated memory.
450  *
451  * Fails with
452  *	_BAD_REQUEST
453  *	_NO_RESOURCES
454  */
455 int
tx_commit_data_new(const void * cmds_arg,size_t cmds_sz,tx_commit_data_t ** tx_data)456 tx_commit_data_new(const void *cmds_arg, size_t cmds_sz,
457     tx_commit_data_t **tx_data)
458 {
459 	const struct rep_protocol_transaction_cmd *cmds;
460 	tx_commit_data_t *data;
461 	uintptr_t loc;
462 	uint32_t count;
463 	uint32_t sz;
464 	int ret;
465 
466 	/*
467 	 * First, verify that the reported sizes make sense, and count
468 	 * the number of commands.
469 	 */
470 	count = 0;
471 	loc = (uintptr_t)cmds_arg;
472 
473 	while (cmds_sz > 0) {
474 		cmds = (struct rep_protocol_transaction_cmd *)loc;
475 
476 		if (cmds_sz <= REP_PROTOCOL_TRANSACTION_CMD_MIN_SIZE)
477 			return (REP_PROTOCOL_FAIL_BAD_REQUEST);
478 
479 		sz = cmds->rptc_size;
480 		if (sz <= REP_PROTOCOL_TRANSACTION_CMD_MIN_SIZE)
481 			return (REP_PROTOCOL_FAIL_BAD_REQUEST);
482 
483 		sz = TX_SIZE(sz);
484 		if (sz > cmds_sz)
485 			return (REP_PROTOCOL_FAIL_BAD_REQUEST);
486 
487 		loc += sz;
488 		cmds_sz -= sz;
489 		count++;
490 	}
491 
492 	data = uu_zalloc(TX_COMMIT_DATA_SIZE(count));
493 	if (data == NULL)
494 		return (REP_PROTOCOL_FAIL_NO_RESOURCES);
495 
496 	/*
497 	 * verify that everything looks okay, and set up our command
498 	 * datastructures.
499 	 */
500 	data->txc_count = count;
501 	ret = tx_check_and_setup(data, cmds_arg, count);
502 	if (ret == REP_PROTOCOL_SUCCESS) {
503 		*tx_data = data;
504 	} else {
505 		*tx_data = NULL;
506 		uu_free(data);
507 	}
508 	return (ret);
509 }
510 
511 /*
512  * The following are a set of accessor functions to retrieve data from a
513  * tx_commit_data_t that has been allocated by tx_commit_data_new().
514  */
515 
516 /*
517  * Return the action of the transaction command whose command number is
518  * cmd_no.  The action is placed at *action.
519  *
520  * Returns:
521  *	_FAIL_BAD_REQUEST	cmd_no is out of range.
522  */
523 int
tx_cmd_action(tx_commit_data_t * tx_data,size_t cmd_no,enum rep_protocol_transaction_action * action)524 tx_cmd_action(tx_commit_data_t *tx_data, size_t cmd_no,
525     enum rep_protocol_transaction_action *action)
526 {
527 	struct tx_cmd *cur;
528 
529 	assert(cmd_no < tx_data->txc_count);
530 	if (cmd_no >= tx_data->txc_count)
531 		return (REP_PROTOCOL_FAIL_BAD_REQUEST);
532 
533 	cur = &tx_data->txc_cmds[cmd_no];
534 	*action = cur->tx_cmd->rptc_action;
535 	return (REP_PROTOCOL_SUCCESS);
536 }
537 
538 /*
539  * Return the number of transaction commands held in tx_data.
540  */
541 size_t
tx_cmd_count(tx_commit_data_t * tx_data)542 tx_cmd_count(tx_commit_data_t *tx_data)
543 {
544 	return (tx_data->txc_count);
545 }
546 
547 /*
548  * Return the number of property values that are associated with the
549  * transaction command whose number is cmd_no.  The number of values is
550  * returned to *nvalues.
551  *
552  * Returns:
553  *	_FAIL_BAD_REQUEST	cmd_no is out of range.
554  */
555 int
tx_cmd_nvalues(tx_commit_data_t * tx_data,size_t cmd_no,uint32_t * nvalues)556 tx_cmd_nvalues(tx_commit_data_t *tx_data, size_t cmd_no, uint32_t *nvalues)
557 {
558 	struct tx_cmd *cur;
559 
560 	assert(cmd_no < tx_data->txc_count);
561 	if (cmd_no >= tx_data->txc_count)
562 		return (REP_PROTOCOL_FAIL_BAD_REQUEST);
563 
564 	cur = &tx_data->txc_cmds[cmd_no];
565 	*nvalues = cur->tx_nvalues;
566 	return (REP_PROTOCOL_SUCCESS);
567 }
568 
569 /*
570  * Return a pointer to the property name of the command whose number is
571  * cmd_no.  The property name pointer is returned to *pname.
572  *
573  * Returns:
574  *	_FAIL_BAD_REQUEST	cmd_no is out of range.
575  */
576 int
tx_cmd_prop(tx_commit_data_t * tx_data,size_t cmd_no,const char ** pname)577 tx_cmd_prop(tx_commit_data_t *tx_data, size_t cmd_no, const char **pname)
578 {
579 	struct tx_cmd *cur;
580 
581 	assert(cmd_no < tx_data->txc_count);
582 	if (cmd_no >= tx_data->txc_count)
583 		return (REP_PROTOCOL_FAIL_BAD_REQUEST);
584 
585 	cur = &tx_data->txc_cmds[cmd_no];
586 	*pname = cur->tx_prop;
587 	return (REP_PROTOCOL_SUCCESS);
588 }
589 
590 /*
591  * Return the property type of the property whose command number is
592  * cmd_no.  The property type is returned to *ptype.
593  *
594  * Returns:
595  *	_FAIL_BAD_REQUEST	cmd_no is out of range.
596  */
597 int
tx_cmd_prop_type(tx_commit_data_t * tx_data,size_t cmd_no,uint32_t * ptype)598 tx_cmd_prop_type(tx_commit_data_t *tx_data, size_t cmd_no, uint32_t *ptype)
599 {
600 	struct tx_cmd *cur;
601 
602 	assert(cmd_no < tx_data->txc_count);
603 	if (cmd_no >= tx_data->txc_count)
604 		return (REP_PROTOCOL_FAIL_BAD_REQUEST);
605 
606 	cur = &tx_data->txc_cmds[cmd_no];
607 	*ptype = cur->tx_cmd->rptc_type;
608 	return (REP_PROTOCOL_SUCCESS);
609 }
610 
611 /*
612  * This function is used to retrieve a property value from the transaction
613  * data.  val_no specifies which value is to be retrieved from the
614  * transaction command whose number is cmd_no.  A pointer to the specified
615  * value is placed in *val.
616  *
617  * Returns:
618  *	_FAIL_BAD_REQUEST	cmd_no or val_no is out of range.
619  */
620 int
tx_cmd_value(tx_commit_data_t * tx_data,size_t cmd_no,uint32_t val_no,const char ** val)621 tx_cmd_value(tx_commit_data_t *tx_data, size_t cmd_no, uint32_t val_no,
622     const char **val)
623 {
624 	const char *bp;
625 	struct tx_cmd *cur;
626 	uint32_t i;
627 	uint32_t value_len;
628 
629 	assert(cmd_no < tx_data->txc_count);
630 	if (cmd_no >= tx_data->txc_count)
631 		return (REP_PROTOCOL_FAIL_BAD_REQUEST);
632 
633 	cur = &tx_data->txc_cmds[cmd_no];
634 	assert(val_no < cur->tx_nvalues);
635 	if (val_no >= cur->tx_nvalues)
636 		return (REP_PROTOCOL_FAIL_BAD_REQUEST);
637 
638 	/* Find the correct value */
639 	bp = (char *)cur->tx_values;
640 	for (i = 0; i < val_no; i++) {
641 		/* LINTED alignment */
642 		value_len = *(uint32_t *)bp;
643 		bp += sizeof (uint32_t) + TX_SIZE(value_len);
644 	}
645 
646 	/* Bypass the count & return pointer to value. */
647 	bp += sizeof (uint32_t);
648 	*val = bp;
649 	return (REP_PROTOCOL_SUCCESS);
650 }
651 
652 int
object_tx_commit(rc_node_lookup_t * lp,tx_commit_data_t * data,uint32_t * gen)653 object_tx_commit(rc_node_lookup_t *lp, tx_commit_data_t *data, uint32_t *gen)
654 {
655 	uint32_t new_gen;
656 	int ret;
657 	rep_protocol_responseid_t r;
658 	backend_tx_t *tx;
659 	backend_query_t *q;
660 	int backend = lp->rl_backend;
661 
662 	ret = backend_tx_begin(backend, &tx);
663 	if (ret != REP_PROTOCOL_SUCCESS)
664 		return (ret);
665 
666 	/* Make sure the pg is up-to-date. */
667 	data->txc_oldgen = *gen;
668 	data->txc_backend = backend;
669 	data->txc_result = REP_PROTOCOL_FAIL_NOT_FOUND;
670 
671 	q = backend_query_alloc();
672 	backend_query_add(q, "SELECT pg_gen_id FROM pg_tbl WHERE (pg_id = %d);",
673 	    lp->rl_main_id);
674 	r = backend_tx_run(tx, q, tx_check_genid, data);
675 	backend_query_free(q);
676 
677 	if (r != REP_PROTOCOL_SUCCESS ||
678 	    (r = data->txc_result) != REP_PROTOCOL_SUCCESS) {
679 		backend_tx_rollback(tx);
680 		goto end;
681 	}
682 
683 	/* If the transaction is empty, cut out early. */
684 	if (data->txc_count == 0) {
685 		backend_tx_rollback(tx);
686 		r = REP_PROTOCOL_DONE;
687 		goto end;
688 	}
689 
690 	new_gen = backend_new_id(tx, BACKEND_ID_GENERATION);
691 	if (new_gen == 0) {
692 		backend_tx_rollback(tx);
693 		return (REP_PROTOCOL_FAIL_NO_RESOURCES);
694 	}
695 
696 	data->txc_pg_id = lp->rl_main_id;
697 	data->txc_gen = new_gen;
698 	data->txc_tx = tx;
699 
700 	r = backend_tx_run_update(tx,
701 	    "UPDATE pg_tbl SET pg_gen_id = %d "
702 	    "    WHERE (pg_id = %d AND pg_gen_id = %d);",
703 	    new_gen, lp->rl_main_id, *gen);
704 
705 	if (r != REP_PROTOCOL_SUCCESS) {
706 		backend_tx_rollback(tx);
707 		goto end;
708 	}
709 
710 	q = backend_query_alloc();
711 
712 	backend_query_add(q,
713 	    "SELECT lnk_prop_name, lnk_prop_type, lnk_val_id "
714 	    "FROM prop_lnk_tbl "
715 	    "WHERE (lnk_pg_id = %d AND lnk_gen_id = %d)",
716 	    lp->rl_main_id, *gen);
717 
718 	data->txc_inserts = backend_query_alloc();
719 	r = backend_tx_run(tx, q, tx_process_property, data);
720 	backend_query_free(q);
721 
722 	if (r == REP_PROTOCOL_DONE)
723 		r = REP_PROTOCOL_FAIL_UNKNOWN;		/* corruption */
724 
725 	if (r != REP_PROTOCOL_SUCCESS ||
726 	    (r = data->txc_result) != REP_PROTOCOL_SUCCESS) {
727 		backend_query_free(data->txc_inserts);
728 		backend_tx_rollback(tx);
729 		goto end;
730 	}
731 
732 	r = backend_tx_run(tx, data->txc_inserts, NULL, NULL);
733 	backend_query_free(data->txc_inserts);
734 
735 	if (r != REP_PROTOCOL_SUCCESS) {
736 		backend_tx_rollback(tx);
737 		goto end;
738 	}
739 
740 	r = tx_process_cmds(data);
741 	if (r != REP_PROTOCOL_SUCCESS) {
742 		backend_tx_rollback(tx);
743 		goto end;
744 	}
745 	r = backend_tx_commit(tx);
746 
747 	if (r == REP_PROTOCOL_SUCCESS)
748 		*gen = new_gen;
749 end:
750 	return (r);
751 }
752