xref: /titanic_41/usr/src/cmd/isns/isnsd/obj.c (revision 530e2b59e3a1e24b97617608e33a1786f2875502)
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 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <pthread.h>
31 #include <sys/types.h>
32 #include <sys/socket.h>
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
35 
36 #include "isns_server.h"
37 #include "isns_msgq.h"
38 #include "isns_htab.h"
39 #include "isns_cache.h"
40 #include "isns_pdu.h"
41 #include "isns_obj.h"
42 #include "isns_dd.h"
43 #include "isns_func.h"
44 #include "isns_dseng.h"
45 #include "isns_log.h"
46 #include "isns_scn.h"
47 #include "isns_utils.h"
48 #include "isns_esi.h"
49 
50 /*
51  * external variables
52  */
53 #ifdef DEBUG
54 extern int verbose_mc;
55 extern void print_object(char *, isns_obj_t *);
56 #endif
57 
58 extern msg_queue_t *sys_q;
59 extern msg_queue_t *scn_q;
60 
61 extern pthread_mutex_t el_mtx;
62 
63 extern int cache_flag;
64 
65 /*
66  * global data
67  */
68 
69 /*
70  * local variables
71  */
72 /* type of parent object */
73 const int TYPE_OF_PARENT[MAX_OBJ_TYPE_FOR_SIZE] = {
74 	0,
75 	0,
76 	ISCSI_PARENT_TYPE,
77 	PORTAL_PARENT_TYPE,
78 	PG_PARENT_TYPE,
79 	0,	/* OBJ_DD */
80 	0,	/* OBJ_DDS */
81 	0,	/* MAX_OBJ_TYPE */
82 	0,	/* OBJ_DUMMY1 */
83 	0,	/* OBJ_DUMMY2 */
84 	0,	/* OBJ_DUMMY3 */
85 	0,	/* OBJ_DUMMY4 */
86 	ASSOC_ISCSI_PARENT_TYPE,
87 	ASSOC_DD_PARENT_TYPE
88 };
89 
90 /* number of children object type */
91 const int NUM_OF_CHILD[MAX_OBJ_TYPE] = {
92 	0,
93 	MAX_ENTITY_CHILD,
94 	MAX_ISCSI_CHILD,
95 	MAX_PORTAL_CHILD,
96 	MAX_PG_CHILD,
97 	0,
98 	0
99 };
100 
101 /* type of a child object */
102 const int TYPE_OF_CHILD[MAX_OBJ_TYPE][MAX_CHILD_TYPE] = {
103 	{ 0, 0 },
104 	{ OBJ_ISCSI, OBJ_PORTAL },
105 	{ 0, 0 },
106 	{ 0, 0 },
107 	{ 0, 0 },
108 	{ 0, 0 },
109 	{ 0, 0 }
110 };
111 
112 /* number of attributes of certain type of object */
113 const int NUM_OF_ATTRS[MAX_OBJ_TYPE_FOR_SIZE] = {
114 	0,
115 	NUM_OF_ENTITY_ATTRS,
116 	NUM_OF_ISCSI_ATTRS,
117 	NUM_OF_PORTAL_ATTRS,
118 	NUM_OF_PG_ATTRS,
119 	NUM_OF_DD_ATTRS,
120 	NUM_OF_DDS_ATTRS,
121 	0,			/* MAX_OBJ_TYPE */
122 	0,			/* OBJ_DUMMY1 */
123 	0,			/* OBJ_DUMMY2 */
124 	0,			/* OBJ_DUMMY3 */
125 	0,			/* OBJ_DUMMY4 */
126 	NUM_OF_ASSOC_ISCSI_ATTRS,
127 	NUM_OF_ASSOC_DD_ATTRS
128 };
129 
130 /* the tag of UID of each type of object */
131 static const int UID_TAG[MAX_OBJ_TYPE_FOR_SIZE] = {
132 	0,
133 	ISNS_ENTITY_INDEX_ATTR_ID,
134 	ISNS_ISCSI_NODE_INDEX_ATTR_ID,
135 	ISNS_PORTAL_INDEX_ATTR_ID,
136 	ISNS_PG_INDEX_ATTR_ID,
137 	ISNS_DD_ID_ATTR_ID,
138 	ISNS_DD_SET_ID_ATTR_ID,
139 	0,			/* MAX_OBJ_TYPE */
140 	0,			/* OBJ_DUMMY1 */
141 	0,			/* OBJ_DUMMY2 */
142 	0,			/* OBJ_DUMMY3 */
143 	0,			/* OBJ_DUMMY4 */
144 	ISNS_DD_ISCSI_INDEX_ATTR_ID,
145 	ISNS_DD_ID_ATTR_ID
146 };
147 
148 /* the index of UID of each type of object */
149 const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE] = {
150 	0,
151 	ATTR_INDEX_ENTITY(ISNS_ENTITY_INDEX_ATTR_ID),
152 	ATTR_INDEX_ISCSI(ISNS_ISCSI_NODE_INDEX_ATTR_ID),
153 	ATTR_INDEX_PORTAL(ISNS_PORTAL_INDEX_ATTR_ID),
154 	ATTR_INDEX_PG(ISNS_PG_INDEX_ATTR_ID),
155 	ATTR_INDEX_DD(ISNS_DD_ID_ATTR_ID),
156 	ATTR_INDEX_DDS(ISNS_DD_SET_ID_ATTR_ID),
157 	0,			/* MAX_OBJ_TYPE */
158 	0,			/* OBJ_DUMMY1 */
159 	0,			/* OBJ_DUMMY2 */
160 	0,			/* OBJ_DUMMY3 */
161 	0,			/* OBJ_DUMMY4 */
162 	ATTR_INDEX_ASSOC_ISCSI(ISNS_DD_ISCSI_INDEX_ATTR_ID),
163 	ATTR_INDEX_ASSOC_DD(ISNS_DD_ID_ATTR_ID)
164 };
165 
166 /* the index of the key attributes of each type of object */
167 static const int KEY_ATTR_INDEX[MAX_OBJ_TYPE][MAX_KEY_ATTRS] = {
168 	{ 0 },
169 	{ ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID), 0 },
170 	{ ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID),
171 		0 },
172 	{ ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID),
173 		ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID),
174 		0 },
175 	{ ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID),
176 		ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID),
177 		ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID) },
178 	{ ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID), 0 },
179 	{ ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID), 0 }
180 };
181 
182 /* the operating methods for key attributes of each type of object */
183 static const int KEY_ATTR_OP[MAX_OBJ_TYPE][MAX_KEY_ATTRS] = {
184 	{ 0 },
185 	{ OP_STRING, 0 },
186 	{ OP_STRING, 0 },
187 	{ OP_MEMORY_IP6, OP_INTEGER, 0 },
188 	{ OP_STRING, OP_MEMORY_IP6, OP_INTEGER },
189 	{ OP_STRING, 0 },
190 	{ OP_STRING, 0 }
191 };
192 
193 /* the size of each type of object */
194 static const int SIZEOF_OBJ[MAX_OBJ_TYPE_FOR_SIZE] = {
195 	0,
196 	sizeof (isns_entity_t),
197 	sizeof (isns_iscsi_t),
198 	sizeof (isns_portal_t),
199 	sizeof (isns_pg_t),
200 	sizeof (isns_dd_t),
201 	sizeof (isns_dds_t),
202 	0,
203 	0,
204 	0,
205 	0,
206 	0,
207 	sizeof (isns_assoc_iscsi_t),
208 	sizeof (isns_assoc_dd_t)
209 };
210 
211 #ifdef DEBUG
212 const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE] = {
213 #else
214 static const int NUM_OF_REF[MAX_OBJ_TYPE_FOR_SIZE] = {
215 #endif
216 	0,
217 	0,
218 	0,
219 	0,
220 	PG_REF_COUNT,
221 	0,
222 	0,
223 	0,
224 	0,
225 	0,
226 	0,
227 	0,
228 	0,
229 	0
230 };
231 
232 /* the type of the reference object */
233 static const int TYPE_OF_REF[MAX_OBJ_TYPE][MAX_REF_COUNT + 1] = {
234 	{ 0 },
235 	{ 0 },
236 	{ OBJ_PG, OBJ_PORTAL, 0 },
237 	{ OBJ_PG, OBJ_ISCSI, 0 },
238 	{ 0, OBJ_ISCSI, OBJ_PORTAL },
239 	{ 0 },
240 	{ 0 }
241 };
242 
243 /* the operating method for match operation of the reference object */
244 #define	MAX_REF_MATCH	(2)
245 static const int REF_MATCH_OPS[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
246 	{ 0, 0 },
247 	{ 0, 0 },
248 	{ OP_STRING, 0 },
249 	{ OP_MEMORY_IP6, OP_INTEGER },
250 	{ 0, 0 },
251 	{ 0, 0 },
252 	{ 0, 0 }
253 };
254 
255 /* the index of the attribute of being matched object */
256 static const int REF_MATCH_ID1[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
257 	{ 0, 0 },
258 	{ 0, 0 },
259 	{ ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID), 0 },
260 	{ ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID),
261 		ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID) },
262 	{ 0, 0 },
263 	{ 0, 0 },
264 	{ 0, 0 }
265 };
266 
267 /* the index of the attribute of matching object */
268 static const int REF_MATCH_ID2[MAX_OBJ_TYPE][MAX_REF_MATCH] = {
269 	{ 0, 0 },
270 	{ 0, 0 },
271 	{ ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID), 0 },
272 	{ ATTR_INDEX_PG(ISNS_PG_PORTAL_IP_ADDR_ATTR_ID),
273 		ATTR_INDEX_PG(ISNS_PG_PORTAL_PORT_ATTR_ID) },
274 	{ 0, 0 },
275 	{ 0, 0 },
276 	{ 0, 0 }
277 };
278 
279 /*
280  * local functions.
281  */
282 static uint32_t get_reg_period();
283 static char *make_unique_name(int *, uint32_t);
284 static lookup_ctrl_t *set_lookup_ctrl(lookup_ctrl_t *, isns_obj_t *);
285 static int setup_ref_lcp(lookup_ctrl_t *,
286 	const isns_obj_t *, const isns_obj_t *);
287 static int setup_deref_lcp(lookup_ctrl_t *,
288 	const isns_obj_t *, isns_type_t);
289 static int cb_get_parent(void *, void *);
290 static int cb_node_child(void *, void *);
291 static int cb_set_ref(void *, void *);
292 static int cb_clear_ref(void *, void *);
293 static int cb_add_child(void *, void *);
294 static int cb_remove_child(void *, void *);
295 static int cb_verify_ref(void *, void *);
296 static int cb_ref_new2old(void *, void *);
297 static int cb_new_ref(void *, void *);
298 static int ref_new2old(
299 	lookup_ctrl_t *, isns_type_t, uint32_t, const isns_obj_t *);
300 static int ref_new2new(
301 	lookup_ctrl_t *, const isns_obj_t *, const isns_obj_t *);
302 static int new_ref(const isns_obj_t *, const isns_obj_t *);
303 static uint32_t setup_parent_lcp(lookup_ctrl_t *, isns_obj_t *);
304 static int set_obj_offline(isns_obj_t *);
305 static int copy_attrs(isns_obj_t *, const isns_obj_t *);
306 
307 static isns_obj_t *make_default_pg(const isns_obj_t *, const isns_obj_t *);
308 static isns_obj_t *(*const make_ref[MAX_OBJ_TYPE])
309 	(const isns_obj_t *, const isns_obj_t *) = {
310 		NULL,
311 		NULL,
312 		&make_default_pg,
313 		&make_default_pg,
314 		NULL,
315 		NULL,
316 		NULL
317 };
318 
319 static uint32_t entity_hval(void *, uint16_t, uint32_t *);
320 static uint32_t iscsi_hval(void *, uint16_t, uint32_t *);
321 static uint32_t portal_hval(void *, uint16_t, uint32_t *);
322 static uint32_t pg_hval(void *, uint16_t, uint32_t *);
323 static uint32_t dd_hval(void *, uint16_t, uint32_t *);
324 static uint32_t dds_hval(void *, uint16_t, uint32_t *);
325 static uint32_t (*const hval_func[MAX_OBJ_TYPE])
326 	(void *, uint16_t, uint32_t *) = {
327 		NULL,
328 		&entity_hval,
329 		&iscsi_hval,
330 		&portal_hval,
331 		&pg_hval,
332 		&dd_hval,
333 		&dds_hval
334 };
335 
336 /*
337  * ****************************************************************************
338  *
339  * entity_hval:
340  *	caculate the hash value of a network entity object.
341  *
342  * p	- the pointer pointers to network entity object or
343  *	  the lookup control data, both have the key attribute
344  *	  of a network entity object.
345  * chunk- which chunk of the hash table.
346  * flags- pointer to flags.
347  * return - the hash value.
348  *
349  * ****************************************************************************
350  */
351 static uint32_t
entity_hval(void * p,uint16_t chunk,uint32_t * flags)352 entity_hval(
353 	void *p,
354 	/* LINTED E_FUNC_ARG_UNUSED */
355 	uint16_t chunk,
356 	uint32_t *flags
357 )
358 {
359 	uchar_t *key;
360 	isns_obj_t *obj;
361 	lookup_ctrl_t *lcp;
362 
363 	if ((*flags & FLAGS_CTRL_MASK) == 0) {
364 		/* p pointers to a network entity object */
365 		obj = (isns_obj_t *)p;
366 		key = obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)].
367 		    value.ptr;
368 	} else {
369 		/* p is lookup control data */
370 		lcp = (lookup_ctrl_t *)p;
371 		key = lcp->data[0].ptr;
372 	}
373 
374 	return (htab_compute_hval(key));
375 }
376 
377 /*
378  * ****************************************************************************
379  *
380  * iscsi_hval:
381  *	caculate the hash value of an iscsi storage node object.
382  *
383  * p	- the pointer pointers to iscsi storage node object or
384  *	  the lookup control data, both have the key attribute
385  *	  of an iscsi storage node object.
386  * chunk- which chunk of the hash table.
387  * flags- pointer to flags.
388  * return - the hash value.
389  *
390  * ****************************************************************************
391  */
392 static uint32_t
iscsi_hval(void * p,uint16_t chunk,uint32_t * flags)393 iscsi_hval(
394 	void *p,
395 	/* LINTED E_FUNC_ARG_UNUSED */
396 	uint16_t chunk,
397 	uint32_t *flags
398 )
399 {
400 	uchar_t *key;
401 	isns_obj_t *obj;
402 	lookup_ctrl_t *lcp;
403 
404 	if ((*flags & FLAGS_CTRL_MASK) == 0) {
405 		/* p pointers to an iscsi storage node object */
406 		obj = (isns_obj_t *)p;
407 		key = obj->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)].
408 		    value.ptr;
409 	} else {
410 		/* p is lookup control data */
411 		lcp = (lookup_ctrl_t *)p;
412 		key = lcp->data[0].ptr;
413 	}
414 
415 	return (htab_compute_hval(key));
416 }
417 
418 /*
419  * ****************************************************************************
420  *
421  * portal_hval:
422  *	caculate the hash value of a portal object.
423  *
424  * p	- the pointer pointers to a portal object or the lookup control
425  *	  data, both have the key attributes of a portal object.
426  * chunk- which chunk of the hash table.
427  * flags- pointer to flags.
428  * return - the hash value.
429  *
430  * ****************************************************************************
431  */
432 static uint32_t
portal_hval(void * p,uint16_t chunk,uint32_t * flags)433 portal_hval(
434 	void *p,
435 	/* LINTED E_FUNC_ARG_UNUSED */
436 	uint16_t chunk,
437 	uint32_t *flags
438 )
439 {
440 	char buff[INET6_ADDRSTRLEN + 8] = { 0 };
441 	char buff2[8] = { 0 };
442 	uchar_t *key;
443 	isns_obj_t *obj;
444 	lookup_ctrl_t *lcp;
445 
446 	in6_addr_t *ip;
447 	uint32_t port;
448 
449 	if ((*flags & FLAGS_CTRL_MASK) == 0) {
450 		/* p pointers to a portal object */
451 		obj = (isns_obj_t *)p;
452 		ip = obj->attrs[ATTR_INDEX_PORTAL
453 		    (ISNS_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
454 		port = obj->attrs[ATTR_INDEX_PORTAL
455 		    (ISNS_PORTAL_PORT_ATTR_ID)].value.ui;
456 	} else {
457 		/* p is lookup control data */
458 		lcp = (lookup_ctrl_t *)p;
459 		ip = lcp->data[0].ip;
460 		port = lcp->data[1].ui;
461 	}
462 
463 	key = (uchar_t *)inet_ntop(AF_INET6, (void *)ip,
464 	    buff, sizeof (buff));
465 	(void) snprintf(buff2, sizeof (buff2), "%d", port);
466 	(void) strcat((char *)key, buff2);
467 
468 	return (htab_compute_hval(key));
469 }
470 
471 /*
472  * ****************************************************************************
473  *
474  * pg_hval:
475  *	caculate the hash value of a portal group object.
476  *
477  * p	- the pointer pointers to a portal group object or the lookup
478  *	  control data, both have the key attributes of a portal object.
479  * chunk- which chunk of the hash table.
480  * flags- pointer to flags.
481  * return - the hash value.
482  *
483  * ****************************************************************************
484  */
485 static uint32_t
pg_hval(void * p,uint16_t chunk,uint32_t * flags)486 pg_hval(
487 	void *p,
488 	uint16_t chunk,
489 	uint32_t *flags
490 )
491 {
492 	char buff[INET6_ADDRSTRLEN + 8] = { 0 };
493 	char buff2[8] = { 0 };
494 	uchar_t *key = NULL;
495 	isns_obj_t *obj;
496 	lookup_ctrl_t *lcp;
497 
498 	in6_addr_t *ip = NULL;
499 	uint32_t port;
500 
501 	if ((*flags & FLAGS_CTRL_MASK) == 0) {
502 		/* p is a portal group object */
503 		obj = (isns_obj_t *)p;
504 		if (chunk == 0) {
505 			/* the first chunk */
506 			key = obj->attrs[ATTR_INDEX_PG
507 			    (ISNS_PG_ISCSI_NAME_ATTR_ID)].value.ptr;
508 		} else {
509 			/* another chunk */
510 			ip = obj->attrs[ATTR_INDEX_PG
511 			    (ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)].value.ip;
512 			port = obj->attrs[ATTR_INDEX_PG
513 			    (ISNS_PG_PORTAL_PORT_ATTR_ID)].value.ui;
514 		}
515 	} else {
516 		/* p is a lookup control data */
517 		lcp = (lookup_ctrl_t *)p;
518 		/* clear the chunk flags */
519 		*flags &= ~FLAGS_CHUNK_MASK;
520 		if (lcp->op[0] == OP_STRING) {
521 			/* the first chunk */
522 			key = lcp->data[0].ptr;
523 		} else {
524 			/* another chunk */
525 			ip = lcp->data[0].ip;
526 			port = lcp->data[1].ui;
527 			*flags |= 1;
528 		}
529 	}
530 
531 	if (key == NULL) {
532 		key = (uchar_t *)inet_ntop(AF_INET6, (void *)ip,
533 		    buff, sizeof (buff));
534 		(void) snprintf(buff2, sizeof (buff2), "%d", port);
535 		(void) strcat((char *)key, buff2);
536 	}
537 
538 	return (htab_compute_hval(key));
539 }
540 
541 /*
542  * ****************************************************************************
543  *
544  * dd_hval:
545  *	caculate the hash value of a DD object.
546  *
547  * p	- the pointer pointers to a DD object or the lookup control data,
548  *	  both have the key attributes of a DD object.
549  * chunk- which chunk of the hash table.
550  * flags- pointer to flags.
551  * return - the hash value.
552  *
553  * ****************************************************************************
554  */
555 static uint32_t
dd_hval(void * p,uint16_t chunk,uint32_t * flags)556 dd_hval(
557 	void *p,
558 	/* LINTED E_FUNC_ARG_UNUSED */
559 	uint16_t chunk,
560 	uint32_t *flags
561 )
562 {
563 	uchar_t *key;
564 	isns_obj_t *obj;
565 	lookup_ctrl_t *lcp;
566 
567 	if ((*flags & FLAGS_CTRL_MASK) == 0) {
568 		/* p is a DD object */
569 		obj = (isns_obj_t *)p;
570 		key = obj->attrs[ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID)].
571 		    value.ptr;
572 	} else {
573 		/* p is a lookup control data */
574 		lcp = (lookup_ctrl_t *)p;
575 		key = lcp->data[0].ptr;
576 	}
577 
578 	return (htab_compute_hval(key));
579 }
580 
581 /*
582  * ****************************************************************************
583  *
584  * dds_hval:
585  *	caculate the hash value of a DD-set object.
586  *
587  * p	- the pointer pointers to a DD-set object or the lookup control data,
588  *	  both have the key attributes of a DD-set object.
589  * chunk- which chunk of the hash table.
590  * flags- pointer to flags.
591  * return - the hash value.
592  *
593  * ****************************************************************************
594  */
595 static uint32_t
dds_hval(void * p,uint16_t chunk,uint32_t * flags)596 dds_hval(
597 	void *p,
598 	/* LINTED E_FUNC_ARG_UNUSED */
599 	uint16_t chunk,
600 	uint32_t *flags
601 )
602 {
603 	uchar_t *key;
604 	isns_obj_t *obj;
605 	lookup_ctrl_t *lcp;
606 
607 	if ((*flags & FLAGS_CTRL_MASK) == 0) {
608 		/* p is a DD-set object */
609 		obj = (isns_obj_t *)p;
610 		key = obj->attrs[ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID)].
611 		    value.ptr;
612 	} else {
613 		/* p is lookup control data */
614 		lcp = (lookup_ctrl_t *)p;
615 		key = lcp->data[0].ptr;
616 	}
617 
618 	return (htab_compute_hval(key));
619 }
620 
621 /*
622  * ****************************************************************************
623  *
624  * obj_hval:
625  *	caculate the hash value of an object.
626  *
627  * p	- the pointer pointers to an object or lookup control data,
628  *	  both has the object type and the key attributes of an object.
629  * chunk- which chunk of the hash table.
630  * flags- pointer to flags.
631  * return - the hash value.
632  *
633  * ****************************************************************************
634  */
635 uint32_t
obj_hval(void * p,uint16_t chunk,uint32_t * flags)636 obj_hval(
637 	void *p,
638 	uint16_t chunk,
639 	uint32_t *flags
640 )
641 {
642 	isns_type_t type = ((isns_obj_t *)p)->type;
643 
644 	return (hval_func[type](p, chunk, flags));
645 }
646 
647 /*
648  * ****************************************************************************
649  *
650  * get_obj_uid:
651  *	get the UID of an object.
652  *
653  * p	- the pointer pointers to an object.
654  * return - the UID.
655  *
656  * ****************************************************************************
657  */
658 uint32_t
get_obj_uid(const void * p)659 get_obj_uid(
660 	const void *p
661 )
662 {
663 	isns_obj_t *obj = (isns_obj_t *)p;
664 	isns_attr_t *attr = &obj->attrs[UID_ATTR_INDEX[obj->type]];
665 	uint32_t uid = attr->value.ui;
666 	return (uid);
667 }
668 
669 /*
670  * ****************************************************************************
671  *
672  * set_obj_uid:
673  *	set the UID of an object.
674  *
675  * p	- the pointer pointers to an object.
676  * uid	- the UID.
677  * return - the UID.
678  *
679  * ****************************************************************************
680  */
681 uint32_t
set_obj_uid(void * p,uint32_t uid)682 set_obj_uid(
683 	void *p,
684 	uint32_t uid
685 )
686 {
687 	isns_obj_t *obj = (isns_obj_t *)p;
688 	isns_attr_t *attr = &obj->attrs[UID_ATTR_INDEX[obj->type]];
689 
690 	/* set the tag, len and value */
691 	attr->tag = UID_TAG[obj->type];
692 	attr->len = 4;
693 	attr->value.ui = uid;
694 
695 	return (uid);
696 }
697 
698 /*
699  * ****************************************************************************
700  *
701  * obj_cmp:
702  *	compare between two objects or an object with a lookup control data.
703  *
704  * p1	- the pointer points to an object.
705  * p2	- the pointer points to an object or a lookup control data.
706  * flags- 0: p2 is an object; otherwise p2 is a lookup control data.
707  * return - the comparsion result.
708  *
709  * ****************************************************************************
710  */
711 int
obj_cmp(void * p1,void * p2,int flags)712 obj_cmp(
713 	void *p1,
714 	void *p2,
715 	int flags
716 )
717 {
718 	isns_obj_t *obj = (isns_obj_t *)p1;
719 	lookup_ctrl_t buff = { 0 };
720 	lookup_ctrl_t *lcp;
721 	uint32_t uid;
722 
723 	if (flags == 0) {
724 		lcp = set_lookup_ctrl(&buff, (isns_obj_t *)p2);
725 	} else {
726 		lcp = (lookup_ctrl_t *)p2;
727 		uid = get_obj_uid(obj);
728 		/* the object are linked with decending order by */
729 		/* the object UID, if the object UID is greater than */
730 		/* or equal to the current UID, it needs to compare */
731 		/* for the next one. */
732 		if (lcp->curr_uid != 0 && uid >= lcp->curr_uid) {
733 			return (-1);
734 		}
735 	}
736 
737 	return (key_cmp(lcp, obj));
738 }
739 
740 /*
741  * ****************************************************************************
742  *
743  * replace_object:
744  *	replace an existing object with the new one.
745  *
746  * p1	- the pointer points to an object being replaced.
747  * p2	- the pointer points to a new object.
748  * uid_p- points to uid for returning.
749  * flag	- 0: do not free the source object, otherwise free it.
750  * return - error code.
751  *
752  * ****************************************************************************
753  */
754 int
replace_object(void * p1,void * p2,uint32_t * uid_p,int flag)755 replace_object(
756 	void *p1,
757 	void *p2,
758 	uint32_t *uid_p,
759 	int flag
760 )
761 {
762 	int ec = 0;
763 
764 #ifndef SKIP_SRC_AUTH
765 	uint32_t *pp_dst, *pp_src, swap;
766 #endif
767 	int online;
768 
769 	isns_obj_t *dst = (isns_obj_t *)p1;
770 	isns_obj_t *src = (isns_obj_t *)p2;
771 
772 	if (src->type == OBJ_DD || src->type == OBJ_DDS) {
773 		/* replace not allowed */
774 		return (ERR_NAME_IN_USE);
775 	}
776 
777 	online = is_obj_online(dst);
778 
779 	/* set cache update flag */
780 	SET_CACHE_UPDATED();
781 
782 	/* update parent uid */
783 #ifndef SKIP_SRC_AUTH
784 	pp_dst = get_parent_p(dst);
785 	if (pp_dst != NULL) {
786 		pp_src = get_parent_p(src);
787 		swap = *pp_dst;
788 		*pp_dst = *pp_src;
789 		if (swap != 0) {
790 			*pp_src = swap;
791 		}
792 	}
793 #endif
794 
795 	/* update all of attributes */
796 	if (copy_attrs(dst, src) != 0) {
797 		return (ISNS_RSP_INTERNAL_ERROR);
798 	}
799 
800 	/* free up the src object */
801 	if (flag != 0) {
802 		(void) free_object(src);
803 	} else if (online == 0) {
804 		(void) set_obj_uid(src, get_obj_uid(dst));
805 		(void) set_obj_offline(src);
806 	}
807 
808 	/* update data store */
809 	if (sys_q != NULL) {
810 		ec = write_data(DATA_UPDATE, dst);
811 	} else {
812 		/* we should never have duplicated entry in data store */
813 		ec = ISNS_RSP_INTERNAL_ERROR;
814 	}
815 
816 	/* trigger a scn */
817 	if (ec == 0) {
818 		if (scn_q != NULL) {
819 			(void) make_scn((online == 0) ?
820 			    ISNS_OBJECT_ADDED :
821 			    ISNS_OBJECT_UPDATED,
822 			    dst);
823 		}
824 		if (uid_p != NULL) {
825 			*uid_p = get_obj_uid(dst);
826 		}
827 	}
828 
829 	return (ec);
830 }
831 
832 /*
833  * ****************************************************************************
834  *
835  * add_object:
836  *	post function after adding a new object.
837  *
838  * p	- object which has been added.
839  * return - error code.
840  *
841  * ****************************************************************************
842  */
843 int
add_object(void * p)844 add_object(
845 	void *p
846 )
847 {
848 	int ec = 0;
849 
850 	isns_obj_t *obj = (isns_obj_t *)p;
851 
852 	/* add the new object to data store */
853 	if (sys_q != NULL) {
854 		ec = write_data(DATA_ADD, obj);
855 	}
856 
857 	/* trigger a scn */
858 	if (ec == 0 && scn_q != NULL) {
859 		(void) make_scn(ISNS_OBJECT_ADDED, obj);
860 	}
861 
862 	return (ec);
863 }
864 
865 /*
866  * ****************************************************************************
867  *
868  * obj_tab_init:
869  *	initialize the object hash tables.
870  *
871  * c	- points to the cache.
872  * return - error code.
873  *
874  * ****************************************************************************
875  */
876 int
obj_tab_init(struct cache * c)877 obj_tab_init(
878 	struct cache *c
879 )
880 {
881 	htab_t *t;
882 
883 	htab_init();
884 
885 	/*
886 	 * allocate an array of pointer for the object hash tables.
887 	 */
888 	c->t = (struct htab **)calloc(sizeof (struct htab *), MAX_OBJ_TYPE);
889 	if (c->t == NULL) {
890 		return (1);
891 	}
892 
893 	/*
894 	 * hash table for network entity objects.
895 	 */
896 	t = htab_create(UID_FLAGS_SEQ, 8, 1);
897 	if (t != NULL) {
898 		t->c = c;
899 		c->t[OBJ_ENTITY] = t;
900 	} else {
901 		return (1);
902 	}
903 
904 	/*
905 	 * hash table for iscsi storage node objects.
906 	 */
907 	t = htab_create(UID_FLAGS_SEQ, 8, 1);
908 	if (t != NULL) {
909 		t->c = c;
910 		c->t[OBJ_ISCSI] = t;
911 	} else {
912 		return (1);
913 	}
914 
915 	/*
916 	 * hash table for portal objects.
917 	 */
918 	t = htab_create(UID_FLAGS_SEQ, 8, 1);
919 	if (t != NULL) {
920 		t->c = c;
921 		c->t[OBJ_PORTAL] = t;
922 	} else {
923 		return (1);
924 	}
925 
926 	/*
927 	 * hash table for portal group objects.
928 	 */
929 	t = htab_create(UID_FLAGS_SEQ, 8, 2);
930 	if (t != NULL) {
931 		t->c = c;
932 		c->t[OBJ_PG] = t;
933 	} else {
934 		return (1);
935 	}
936 
937 	/*
938 	 * hash table for discovery domain objects.
939 	 */
940 	t = htab_create(0, 6, 1);
941 	if (t != NULL) {
942 		t->c = c;
943 		c->t[OBJ_DD] = t;
944 	} else {
945 		return (1);
946 	}
947 
948 	/*
949 	 * hash table for discovery domain set objects.
950 	 */
951 	t = htab_create(0, 4, 1);
952 	if (t != NULL) {
953 		t->c = c;
954 		c->t[OBJ_DDS] = t;
955 	} else {
956 		return (1);
957 	}
958 
959 	return (0);
960 }
961 
962 /*
963  * ****************************************************************************
964  *
965  * get_ref_np:
966  *	get the ref pointer of the portal group object.
967  *
968  * obj	- portal group object.
969  * return - ref pointer.
970  *
971  * ****************************************************************************
972  */
973 static uint32_t *
get_ref_np(isns_obj_t * obj,int n)974 get_ref_np(
975 	isns_obj_t *obj,
976 	int n
977 )
978 {
979 	uint32_t *refp =
980 	    obj->type == OBJ_PG ? &((isns_pg_t *)obj)->ref[n] : NULL;
981 
982 	return (refp);
983 }
984 
985 #ifdef DEBUG
986 uint32_t
987 #else
988 static uint32_t
989 #endif
get_ref_n(isns_obj_t * obj,int n)990 get_ref_n(
991 	isns_obj_t *obj,
992 	int n
993 )
994 {
995 	return (*get_ref_np(obj, n));
996 }
997 
998 static uint32_t *
get_ref_p(isns_obj_t * obj,isns_type_t rt)999 get_ref_p(
1000 	isns_obj_t *obj,
1001 	isns_type_t rt
1002 )
1003 {
1004 	isns_type_t t = obj->type;
1005 
1006 	int i = 0;
1007 	while (i < NUM_OF_REF[t]) {
1008 		if (rt == TYPE_OF_REF[t][i + 1]) {
1009 			return (get_ref_np(obj, i));
1010 		}
1011 		i ++;
1012 	}
1013 
1014 	return (NULL);
1015 }
1016 
1017 uint32_t
get_ref_t(isns_obj_t * obj,isns_type_t type)1018 get_ref_t(
1019 	isns_obj_t *obj,
1020 	isns_type_t type
1021 )
1022 {
1023 	uint32_t *refp = get_ref_p(obj, type);
1024 
1025 	if (refp != NULL) {
1026 		return (*refp);
1027 	/* LINTED E_NOP_ELSE_STMT */
1028 	} else {
1029 		ASSERT(0);
1030 	}
1031 
1032 	return (0);
1033 }
1034 
1035 /*
1036  * ****************************************************************************
1037  *
1038  * get_parent_p:
1039  *	get the pointer of the parent object.
1040  *
1041  * obj	- an object.
1042  * return - parent object pointer.
1043  *
1044  * ****************************************************************************
1045  */
1046 uint32_t *const
get_parent_p(const isns_obj_t * obj)1047 get_parent_p(
1048 	const isns_obj_t *obj
1049 )
1050 {
1051 	uint32_t *pp;
1052 	switch (obj->type) {
1053 	case OBJ_ISCSI:
1054 		pp = &((isns_iscsi_t *)obj)->puid;
1055 		break;
1056 	case OBJ_PORTAL:
1057 		pp = &((isns_portal_t *)obj)->puid;
1058 		break;
1059 	case OBJ_PG:
1060 		pp = &((isns_pg_t *)obj)->puid;
1061 		break;
1062 	case OBJ_ASSOC_ISCSI:
1063 		pp = &((isns_assoc_iscsi_t *)obj)->puid;
1064 		break;
1065 	case OBJ_ASSOC_DD:
1066 		pp = &((isns_assoc_dd_t *)obj)->puid;
1067 		break;
1068 	default:
1069 		pp = NULL;
1070 		break;
1071 	}
1072 
1073 	return (pp);
1074 }
1075 
1076 uint32_t
get_parent_uid(const isns_obj_t * obj)1077 get_parent_uid(
1078 	const isns_obj_t *obj
1079 )
1080 {
1081 	uint32_t *pp = get_parent_p(obj);
1082 	if (pp != NULL) {
1083 		return (*pp);
1084 	}
1085 
1086 	return (0);
1087 }
1088 
1089 /*
1090  * ****************************************************************************
1091  *
1092  * get_child_np:
1093  *	get the pointer of the UID array of the n'th child of an object.
1094  *
1095  * obj	- an object.
1096  * n	- the child index.
1097  * return - the pointer of the UID array.
1098  *
1099  * ****************************************************************************
1100  */
1101 static uint32_t **
get_child_np(isns_obj_t * obj,int n)1102 get_child_np(
1103 	isns_obj_t *obj,
1104 	int n
1105 )
1106 {
1107 	uint32_t **pp =
1108 	    obj->type == OBJ_ENTITY ? &((isns_entity_t *)obj)->cuid[n] : NULL;
1109 
1110 	return (pp);
1111 }
1112 
1113 /*
1114  * ****************************************************************************
1115  *
1116  * get_child_n:
1117  *	get the UID array of the n'th child of an object.
1118  *
1119  * obj	- an object.
1120  * n	- the child index.
1121  * return - the UID array.
1122  *
1123  * ****************************************************************************
1124  */
1125 #ifdef DEBUG
1126 uint32_t *
1127 #else
1128 static uint32_t *
1129 #endif
get_child_n(isns_obj_t * obj,int n)1130 get_child_n(
1131 	isns_obj_t *obj,
1132 	int n
1133 )
1134 {
1135 	uint32_t **pp = get_child_np(obj, n);
1136 
1137 	if (pp != NULL) {
1138 		return (*pp);
1139 	}
1140 
1141 	ASSERT(0);
1142 	return (NULL);
1143 }
1144 
1145 /*
1146  * ****************************************************************************
1147  *
1148  * get_child_p:
1149  *	get the pointer of the UID array of the child matching the type.
1150  *
1151  * base	- an object.
1152  * child_type	- the child object type.
1153  * return - the pointer of the UID array.
1154  *
1155  * ****************************************************************************
1156  */
1157 static uint32_t **
get_child_p(isns_obj_t * base,int child_type)1158 get_child_p(
1159 	isns_obj_t *base,
1160 	int child_type
1161 )
1162 {
1163 	uint32_t **pp = NULL;
1164 	int i = 0;
1165 	while (i < NUM_OF_CHILD[base->type]) {
1166 		if (child_type == TYPE_OF_CHILD[base->type][i]) {
1167 			pp = get_child_np(base, i);
1168 			break;
1169 		}
1170 		i ++;
1171 	}
1172 
1173 	return (pp);
1174 }
1175 
1176 /*
1177  * ****************************************************************************
1178  *
1179  * get_child_t:
1180  *	get the UID array of the child object matching the type.
1181  *
1182  * base	- an object.
1183  * child_type	- the child object type.
1184  * return - the UID array.
1185  *
1186  * ****************************************************************************
1187  */
1188 uint32_t *
get_child_t(isns_obj_t * base,int child_type)1189 get_child_t(
1190 	isns_obj_t *base,
1191 	int child_type
1192 )
1193 {
1194 	uint32_t **pp = get_child_p(base, child_type);
1195 
1196 	if (pp != NULL) {
1197 		return (*pp);
1198 	} else {
1199 		return (NULL);
1200 	}
1201 }
1202 
1203 /*
1204  * ****************************************************************************
1205  *
1206  * key_cmp:
1207  *	compare the object against the lookup control data.
1208  *
1209  * lcp	- the lookup control data.
1210  * obj	- an object.
1211  * return - comparison result.
1212  *
1213  * ****************************************************************************
1214  */
1215 int
key_cmp(lookup_ctrl_t * lcp,isns_obj_t * obj)1216 key_cmp(
1217 	lookup_ctrl_t *lcp,
1218 	isns_obj_t *obj
1219 )
1220 {
1221 	int i = 0;
1222 	int match = 1;
1223 	while (i < MAX_LOOKUP_CTRL && lcp->op[i] > 0 && match) {
1224 		isns_attr_t *attr = &obj->attrs[lcp->id[i]];
1225 		switch (lcp->op[i]) {
1226 			case OP_STRING:
1227 				match = (strcmp((const char *)lcp->data[i].ptr,
1228 				    (const char *)attr->value.ptr) == 0);
1229 				break;
1230 			case OP_INTEGER:
1231 				match = (lcp->data[i].ui == attr->value.ui);
1232 				break;
1233 			case OP_MEMORY_IP6:
1234 				match = !memcmp((void *)lcp->data[i].ip,
1235 				    (void *)attr->value.ip,
1236 				    sizeof (in6_addr_t));
1237 				break;
1238 			default:
1239 				ASSERT(0);
1240 				match = 0;
1241 				break;
1242 		}
1243 		i ++;
1244 	}
1245 
1246 	if (i && match) {
1247 		return (0);
1248 	} else {
1249 		return (1);
1250 	}
1251 }
1252 
1253 /*
1254  * ****************************************************************************
1255  *
1256  * set_lookup_ctrl:
1257  *	fill in the lookup control data for an object.
1258  *
1259  * lcp	- the lookup control data.
1260  * obj	- an object.
1261  * return - the lookup control data.
1262  *
1263  * ****************************************************************************
1264  */
1265 static lookup_ctrl_t *
set_lookup_ctrl(lookup_ctrl_t * lcp,isns_obj_t * obj)1266 set_lookup_ctrl(
1267 	lookup_ctrl_t *lcp,
1268 	isns_obj_t *obj
1269 )
1270 {
1271 	isns_type_t type = obj->type;
1272 	uint32_t id, op;
1273 	int i = 0;
1274 
1275 	lcp->type = type;
1276 	while (i < MAX_KEY_ATTRS) {
1277 		op = KEY_ATTR_OP[type][i];
1278 		if (op != 0) {
1279 			id = KEY_ATTR_INDEX[type][i];
1280 			lcp->id[i] = id;
1281 			lcp->op[i] = op;
1282 			lcp->data[i].ui = obj->attrs[id].value.ui;
1283 		} else {
1284 			break;
1285 		}
1286 		i ++;
1287 	}
1288 
1289 	return (lcp);
1290 }
1291 
1292 /*
1293  * ****************************************************************************
1294  *
1295  * assign_attr:
1296  *	assign an attribute.
1297  *
1298  * attr	- the attribute being assigned.
1299  * tmp	- the attribute.
1300  * return - error code.
1301  *
1302  * ****************************************************************************
1303  */
1304 int
assign_attr(isns_attr_t * attr,const isns_attr_t * tmp)1305 assign_attr(
1306 	isns_attr_t *attr,
1307 	const isns_attr_t *tmp
1308 )
1309 {
1310 	uint32_t t;
1311 
1312 	switch (tmp->tag) {
1313 	case ISNS_EID_ATTR_ID:
1314 	case ISNS_DD_SET_NAME_ATTR_ID:
1315 	case ISNS_DD_NAME_ATTR_ID:
1316 		if (tmp->len == 0 && attr->len == 0) {
1317 			int len;
1318 			char *name = make_unique_name(&len, tmp->tag);
1319 			if (name != NULL) {
1320 				attr->value.ptr = (uchar_t *)name;
1321 				attr->tag = tmp->tag;
1322 				attr->len = len;
1323 			} else {
1324 				/* memory exhausted */
1325 				return (1);
1326 			}
1327 		}
1328 	case ISNS_PORTAL_NAME_ATTR_ID:
1329 	case ISNS_ISCSI_NAME_ATTR_ID:
1330 	case ISNS_ISCSI_ALIAS_ATTR_ID:
1331 	case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
1332 	case ISNS_PG_ISCSI_NAME_ATTR_ID:
1333 	case ISNS_DD_ISCSI_NAME_ATTR_ID:
1334 		if (tmp->len == 0) {
1335 			return (0);
1336 		} else if (tmp->len >= attr->len) {
1337 			attr->value.ptr = realloc(
1338 			    attr->value.ptr, tmp->len + 1);
1339 		}
1340 		if (attr->value.ptr != NULL) {
1341 			(void) strncpy((char *)attr->value.ptr,
1342 			    (char *)tmp->value.ptr, tmp->len);
1343 			attr->value.ptr[tmp->len] = 0;
1344 			attr->tag = tmp->tag;
1345 			attr->len = tmp->len;
1346 		} else {
1347 			/* memory exhausted */
1348 			return (1);
1349 		}
1350 		break;
1351 	case ISNS_MGMT_IP_ADDR_ATTR_ID:
1352 	case ISNS_PORTAL_IP_ADDR_ATTR_ID:
1353 	case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
1354 		if (attr->value.ip == NULL) {
1355 			attr->value.ip = (in6_addr_t *)calloc(1, tmp->len);
1356 		}
1357 		if (attr->value.ip != NULL) {
1358 			(void) memcpy((void *)attr->value.ip,
1359 			    (void *)tmp->value.ip, tmp->len);
1360 			attr->tag = tmp->tag;
1361 			attr->len = tmp->len;
1362 		} else {
1363 			/* memory exhausted */
1364 			return (1);
1365 		}
1366 		break;
1367 	case ISNS_ENTITY_INDEX_ATTR_ID:
1368 	case ISNS_PORTAL_INDEX_ATTR_ID:
1369 	case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
1370 	case ISNS_PG_INDEX_ATTR_ID:
1371 	case ISNS_DD_SET_ID_ATTR_ID:
1372 	case ISNS_DD_ID_ATTR_ID:
1373 		if (attr->value.ui != 0) {
1374 			break;
1375 		}
1376 	case ISNS_ENTITY_PROTOCOL_ATTR_ID:
1377 	case ISNS_VERSION_RANGE_ATTR_ID:
1378 
1379 	case ISNS_PORTAL_PORT_ATTR_ID:
1380 	case ISNS_ESI_PORT_ATTR_ID:
1381 	case ISNS_SCN_PORT_ATTR_ID:
1382 
1383 	case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
1384 	case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
1385 
1386 	case ISNS_PG_PORTAL_PORT_ATTR_ID:
1387 	case ISNS_PG_TAG_ATTR_ID:
1388 
1389 	case ISNS_DD_SET_STATUS_ATTR_ID:
1390 	case ISNS_DD_ISCSI_INDEX_ATTR_ID:
1391 		attr->tag = tmp->tag;
1392 		attr->len = tmp->len;
1393 		attr->value.ui = tmp->value.ui;
1394 		break;
1395 	case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
1396 		attr->tag = tmp->tag;
1397 		attr->len = tmp->len;
1398 		attr->value.ui = tmp->value.ui;
1399 		t = get_reg_period();
1400 		if (attr->value.ui > t) {
1401 			attr->value.ui = t;
1402 		} else if (attr->value.ui < ONE_DAY) {
1403 			attr->value.ui = ONE_DAY;
1404 		}
1405 		break;
1406 	case ISNS_ESI_INTERVAL_ATTR_ID:
1407 		attr->tag = tmp->tag;
1408 		attr->len = tmp->len;
1409 		attr->value.ui = tmp->value.ui;
1410 		if (attr->value.ui > ONE_DAY) {
1411 			attr->value.ui = ONE_DAY;
1412 		} else if (attr->value.ui < MIN_ESI_INTVAL) {
1413 			attr->value.ui = MIN_ESI_INTVAL; /* 20 seconds */
1414 		}
1415 		break;
1416 	default:
1417 		ASSERT(0);
1418 		/* don't assign the attribute */
1419 		break;
1420 	}
1421 	return (0);
1422 }
1423 
1424 /*
1425  * ****************************************************************************
1426  *
1427  * copy_attrs:
1428  *	copy all of attributes from one object to another.
1429  *
1430  * dst	- the destination object.
1431  * tmp	- the source object.
1432  * return - error code.
1433  *
1434  * ****************************************************************************
1435  */
1436 static int
copy_attrs(isns_obj_t * dst,const isns_obj_t * src)1437 copy_attrs(
1438 	isns_obj_t *dst,
1439 	const isns_obj_t *src
1440 )
1441 {
1442 	int i = 0;
1443 	int n = NUM_OF_ATTRS[dst->type];
1444 
1445 	isns_attr_t *dst_attr;
1446 	const isns_attr_t *src_attr;
1447 
1448 	while (i < n) {
1449 		src_attr = &(src->attrs[i]);
1450 		if (src_attr->tag != 0) {
1451 			dst_attr = &(dst->attrs[i]);
1452 			if (assign_attr(dst_attr, src_attr) != 0) {
1453 				return (1);
1454 			}
1455 		}
1456 		i ++;
1457 	}
1458 
1459 	return (0);
1460 }
1461 
1462 /*
1463  * ****************************************************************************
1464  *
1465  * extract_attr:
1466  *	extract an attribute from a TLV format data.
1467  *
1468  * attr	- the attribute.
1469  * tlv	- the TLV format data.
1470  * return - error code.
1471  *
1472  * ****************************************************************************
1473  */
1474 int
extract_attr(isns_attr_t * attr,const isns_tlv_t * tlv,int flag)1475 extract_attr(
1476 	isns_attr_t *attr,
1477 	const isns_tlv_t *tlv,
1478 	int flag
1479 )
1480 {
1481 	int ec = 0;
1482 
1483 	uint32_t min_len = 4, max_len = 224;
1484 
1485 	switch (tlv->attr_id) {
1486 	case ISNS_EID_ATTR_ID:
1487 		min_len = 0;
1488 	case ISNS_PORTAL_NAME_ATTR_ID:
1489 	case ISNS_ISCSI_ALIAS_ATTR_ID:
1490 	case ISNS_DD_SET_NAME_ATTR_ID:
1491 	case ISNS_DD_NAME_ATTR_ID:
1492 		max_len = 256;
1493 	case ISNS_ISCSI_NAME_ATTR_ID:
1494 	case ISNS_PG_ISCSI_NAME_ATTR_ID:
1495 		if (tlv->attr_len < min_len || tlv->attr_len > max_len) {
1496 			ec = ISNS_RSP_MSG_FORMAT_ERROR;
1497 		} else {
1498 			attr->tag = tlv->attr_id;
1499 			attr->len = tlv->attr_len;
1500 			attr->value.ptr = (uchar_t *)&(tlv->attr_value[0]);
1501 		}
1502 		break;
1503 	case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
1504 		attr->tag = tlv->attr_id;
1505 		attr->len = tlv->attr_len;
1506 		attr->value.ptr = (uchar_t *)&(tlv->attr_value[0]);
1507 		break;
1508 	case ISNS_MGMT_IP_ADDR_ATTR_ID:
1509 	case ISNS_PORTAL_IP_ADDR_ATTR_ID:
1510 	case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
1511 		if (tlv->attr_len != 16) {
1512 			ec = ISNS_RSP_MSG_FORMAT_ERROR;
1513 		} else {
1514 			attr->tag = tlv->attr_id;
1515 			attr->len = tlv->attr_len;
1516 			attr->value.ip = (void *)&(tlv->attr_value[0]);
1517 		}
1518 		break;
1519 	case ISNS_ENTITY_PROTOCOL_ATTR_ID:
1520 	case ISNS_VERSION_RANGE_ATTR_ID:
1521 	case ISNS_ENTITY_REG_PERIOD_ATTR_ID:
1522 		/* fall throught */
1523 	case ISNS_PORTAL_PORT_ATTR_ID:
1524 	case ISNS_ESI_INTERVAL_ATTR_ID:
1525 	case ISNS_ESI_PORT_ATTR_ID:
1526 	case ISNS_SCN_PORT_ATTR_ID:
1527 		/* fall throught */
1528 	case ISNS_ISCSI_NODE_TYPE_ATTR_ID:
1529 		/* fall throught */
1530 	case ISNS_PG_PORTAL_PORT_ATTR_ID:
1531 		/* fall throught */
1532 	case ISNS_DD_SET_ID_ATTR_ID:
1533 	case ISNS_DD_SET_STATUS_ATTR_ID:
1534 		/* fall throught */
1535 	case ISNS_DD_ID_ATTR_ID:
1536 		if (tlv->attr_len != 4) {
1537 			ec = ISNS_RSP_MSG_FORMAT_ERROR;
1538 			break;
1539 		}
1540 	case ISNS_PG_TAG_ATTR_ID:
1541 		attr->tag = tlv->attr_id;
1542 		attr->len = tlv->attr_len;
1543 		if (tlv->attr_len == 4) {
1544 			attr->value.ui = ntohl(*(uint32_t *)
1545 			    &(tlv->attr_value[0]));
1546 		} else {
1547 			attr->value.ui = 0;
1548 		}
1549 		break;
1550 	case ISNS_ISCSI_SCN_BITMAP_ATTR_ID:
1551 		/* ignore scn bitmap attribute during object registration, */
1552 		/* it is registered by scn_reg message. */
1553 	case ISNS_ENTITY_ISAKMP_P1_ATTR_ID:
1554 	case ISNS_ENTITY_CERT_ATTR_ID:
1555 	case ISNS_PORTAL_SEC_BMP_ATTR_ID:
1556 	case ISNS_PORTAL_ISAKMP_P1_ATTR_ID:
1557 	case ISNS_PORTAL_ISAKMP_P2_ATTR_ID:
1558 	case ISNS_PORTAL_CERT_ATTR_ID:
1559 		break;
1560 	case ISNS_PORTAL_INDEX_ATTR_ID:
1561 	case ISNS_ISCSI_NODE_INDEX_ATTR_ID:
1562 	case ISNS_PG_INDEX_ATTR_ID:
1563 		if (flag == 0) {
1564 			if (tlv->attr_len != 4) {
1565 				ec = ISNS_RSP_MSG_FORMAT_ERROR;
1566 			} else {
1567 				attr->tag = tlv->attr_id;
1568 				attr->len = tlv->attr_len;
1569 				attr->value.ui = ntohl(*(uint32_t *)
1570 				    &(tlv->attr_value[0]));
1571 			}
1572 			break;
1573 		}
1574 	case ISNS_ENTITY_INDEX_ATTR_ID:
1575 	case ISNS_TIMESTAMP_ATTR_ID:
1576 	default:
1577 		if (flag == 0) {
1578 			ec = ISNS_RSP_INVALID_QRY;
1579 		} else {
1580 			ec = ISNS_RSP_INVALID_REGIS;
1581 		}
1582 		break;
1583 	}
1584 
1585 	return (ec);
1586 }
1587 
1588 /*
1589  * ****************************************************************************
1590  *
1591  * copy_attr:
1592  *	copy an attribute from a TLV format data.
1593  *
1594  * attr	- the attribute.
1595  * tlv	- the TLV format data.
1596  * return - error code.
1597  *
1598  * ****************************************************************************
1599  */
1600 static int
copy_attr(isns_attr_t * attr,const isns_tlv_t * tlv)1601 copy_attr(
1602 	isns_attr_t *attr,
1603 	const isns_tlv_t *tlv
1604 )
1605 {
1606 	int ec = 0;
1607 
1608 	isns_attr_t tmp = { 0 };
1609 
1610 	/* extract the attribute first */
1611 	ec = extract_attr(&tmp, tlv, 1);
1612 
1613 	/* assign the attribute */
1614 	if (ec == 0 && tmp.tag != 0) {
1615 		if (assign_attr(attr, &tmp) != 0) {
1616 			ec = ISNS_RSP_INTERNAL_ERROR;
1617 		}
1618 	}
1619 
1620 	return (ec);
1621 }
1622 
1623 /*
1624  * ****************************************************************************
1625  *
1626  * get_timestamp:
1627  *	get current timestamp.
1628  *
1629  * return - current timestamp.
1630  *
1631  * ****************************************************************************
1632  */
1633 uint32_t
get_timestamp()1634 get_timestamp(
1635 )
1636 {
1637 	uint32_t t;
1638 	int flag;
1639 
1640 	/* block the scheduler */
1641 	(void) pthread_mutex_lock(&el_mtx);
1642 
1643 	/* get most current time */
1644 	if (sys_q != NULL) {
1645 		/* need to wakeup idle */
1646 		flag = 1;
1647 	} else {
1648 		flag = 0;
1649 	}
1650 	t = get_stopwatch(flag);
1651 
1652 	/* unblock it */
1653 	(void) pthread_mutex_unlock(&el_mtx);
1654 
1655 	return (t);
1656 }
1657 
1658 /*
1659  * ****************************************************************************
1660  *
1661  * get_reg_period:
1662  *	get the longest registration period.
1663  *
1664  * return - the longest registration period.
1665  *
1666  * ****************************************************************************
1667  */
1668 static uint32_t
get_reg_period()1669 get_reg_period(
1670 )
1671 {
1672 	uint32_t t;
1673 	uint32_t period;
1674 
1675 	/* get most current time */
1676 	t = get_timestamp();
1677 
1678 	/* just one second before the end of the world */
1679 	period = INFINITY - t - 1;
1680 
1681 	return (period);
1682 }
1683 
1684 /*
1685  * ****************************************************************************
1686  *
1687  * obj_calloc:
1688  *	allocate memory space for an object.
1689  *
1690  * type	- the object type.
1691  * return - pointer of the object being allocated.
1692  *
1693  * ****************************************************************************
1694  */
1695 isns_obj_t *
obj_calloc(int type)1696 obj_calloc(
1697 	int type
1698 )
1699 {
1700 	isns_obj_t *obj = NULL;
1701 
1702 	obj = (isns_obj_t *)calloc(1, SIZEOF_OBJ[type]);
1703 	if (obj != NULL) {
1704 		obj->type = type;
1705 #ifdef DEBUG
1706 	if (verbose_mc) {
1707 		printf("object(%d) allocated\n", type);
1708 	}
1709 #endif
1710 	}
1711 
1712 	return (obj);
1713 }
1714 
1715 /*
1716  * ****************************************************************************
1717  *
1718  * make_default_entity:
1719  *	generate a default network entity object.
1720  *
1721  * return - pointer of the default network entity object.
1722  *
1723  * ****************************************************************************
1724  */
1725 isns_obj_t *
make_default_entity()1726 make_default_entity(
1727 )
1728 {
1729 	uint32_t t;
1730 
1731 	isns_obj_t *obj = obj_calloc(OBJ_ENTITY);
1732 	isns_attr_t *attr;
1733 	if (obj != NULL) {
1734 		int len;
1735 		char *eid = make_unique_name(&len, ISNS_EID_ATTR_ID);
1736 		if (!eid) {
1737 			free(obj);
1738 			return (NULL);
1739 		}
1740 		attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID)];
1741 
1742 		/* set default entity name */
1743 		attr->tag = ISNS_EID_ATTR_ID;
1744 		attr->len = len;
1745 		attr->value.ptr = (uchar_t *)eid;
1746 
1747 		/* set default registration period */
1748 		attr = &obj->attrs[
1749 		    ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
1750 		if (attr->tag == 0) {
1751 			attr->tag = ISNS_ENTITY_REG_PERIOD_ATTR_ID;
1752 			attr->len = 4;
1753 			t = get_reg_period();
1754 			attr->value.ui = t;
1755 		}
1756 	}
1757 
1758 	return (obj);
1759 }
1760 
1761 /*
1762  * ****************************************************************************
1763  *
1764  * make_default_pg:
1765  *	generate a default portal group object.
1766  *
1767  * iscsi  - the iscsi storage node object.
1768  * portal - the portal object.
1769  * return - pointer of the default portal group object.
1770  *
1771  * ****************************************************************************
1772  */
1773 static isns_obj_t *
make_default_pg(const isns_obj_t * p1,const isns_obj_t * p2)1774 make_default_pg(
1775 	const isns_obj_t *p1,
1776 	const isns_obj_t *p2
1777 )
1778 {
1779 	const isns_obj_t *iscsi, *portal;
1780 	const isns_attr_t *name, *addr, *port;
1781 	isns_obj_t *pg;
1782 
1783 	uchar_t *pg_name;
1784 	in6_addr_t *pg_addr;
1785 
1786 	isns_attr_t *attr;
1787 
1788 	uint32_t *refp;
1789 
1790 	if (p1->type == OBJ_ISCSI) {
1791 		iscsi = p1;
1792 		portal = p2;
1793 	} else {
1794 		iscsi = p2;
1795 		portal = p1;
1796 	}
1797 	name = &iscsi->attrs[ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID)];
1798 	addr = &portal->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_IP_ADDR_ATTR_ID)];
1799 	port = &portal->attrs[ATTR_INDEX_PORTAL(ISNS_PORTAL_PORT_ATTR_ID)];
1800 
1801 	pg = obj_calloc(OBJ_PG);
1802 	pg_name = (uchar_t *)malloc(name->len);
1803 	pg_addr = (in6_addr_t *)malloc(addr->len);
1804 	if (pg != NULL && pg_name != NULL && pg_addr != NULL) {
1805 		(void) strcpy((char *)pg_name, (char *)name->value.ptr);
1806 		attr = &pg->attrs[ATTR_INDEX_PG(ISNS_PG_ISCSI_NAME_ATTR_ID)];
1807 		attr->tag = ISNS_PG_ISCSI_NAME_ATTR_ID;
1808 		attr->len = name->len;
1809 		attr->value.ptr = pg_name;
1810 
1811 		(void) memcpy((void *)pg_addr,
1812 		    (void *)addr->value.ip, addr->len);
1813 		attr = &pg->attrs[ATTR_INDEX_PG(
1814 		    ISNS_PG_PORTAL_IP_ADDR_ATTR_ID)];
1815 		attr->tag = ISNS_PG_PORTAL_IP_ADDR_ATTR_ID;
1816 		attr->len = addr->len;
1817 		attr->value.ip = pg_addr;
1818 
1819 		attr = &pg->attrs[ATTR_INDEX_PG(
1820 		    ISNS_PG_PORTAL_PORT_ATTR_ID)];
1821 		attr->tag = ISNS_PG_PORTAL_PORT_ATTR_ID;
1822 		attr->len = port->len;
1823 		attr->value.ui = port->value.ui;
1824 
1825 		attr = &pg->attrs[ATTR_INDEX_PG(
1826 		    ISNS_PG_TAG_ATTR_ID)];
1827 		attr->tag = ISNS_PG_TAG_ATTR_ID;
1828 		attr->len = 4;
1829 		attr->value.ui = ISNS_DEFAULT_PGT;
1830 
1831 		refp = get_ref_p(pg, OBJ_ISCSI);
1832 		*refp = get_obj_uid(iscsi);
1833 
1834 		refp = get_ref_p(pg, OBJ_PORTAL);
1835 		*refp = get_obj_uid(portal);
1836 
1837 		(void) set_parent_obj(pg, get_parent_uid(iscsi));
1838 	} else {
1839 		free(pg);
1840 		free(pg_name);
1841 		free(pg_addr);
1842 		pg = NULL;
1843 	}
1844 
1845 	return (pg);
1846 }
1847 
1848 /*
1849  * ****************************************************************************
1850  *
1851  * reg_get_entity:
1852  *	parse the Operating Attributes of the DevAttrReg message and
1853  *	create the Network Entity object if it has one.
1854  *
1855  * p	- the pointer of the object for returning.
1856  * op	- the operating attributes.
1857  * op_len - the length of the operating attributes.
1858  * return - error code.
1859  *
1860  * ****************************************************************************
1861  */
1862 int
reg_get_entity(isns_obj_t ** p,isns_tlv_t ** op,uint16_t * op_len)1863 reg_get_entity(
1864 	isns_obj_t **p,
1865 	isns_tlv_t **op,
1866 	uint16_t *op_len
1867 )
1868 {
1869 	int ec = 0;
1870 
1871 	isns_tlv_t *tmp;
1872 	uint16_t tmp_len;
1873 	isns_attr_t *attr;
1874 
1875 	isns_obj_t *entity = NULL;
1876 
1877 	tmp = *op;
1878 	tmp_len = *op_len;
1879 
1880 	/* parse the entity object */
1881 	if (tmp_len >= 8 && IS_ENTITY_KEY(tmp->attr_id)) {
1882 		entity = obj_calloc(OBJ_ENTITY);
1883 		if (entity != NULL) {
1884 			do {
1885 				attr = &entity->attrs[
1886 				    ATTR_INDEX_ENTITY(tmp->attr_id)];
1887 				ec = copy_attr(attr, tmp);
1888 				NEXT_TLV(tmp, tmp_len);
1889 			} while (ec == 0 &&
1890 			    tmp_len >= 8 &&
1891 			    IS_ENTITY_ATTR(tmp->attr_id));
1892 		} else {
1893 			ec = ISNS_RSP_INTERNAL_ERROR;
1894 		}
1895 
1896 		if (ec == 0) {
1897 			/* set default registration period */
1898 			attr = &entity->attrs[
1899 			    ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)];
1900 			if (attr->tag == 0) {
1901 				attr->tag = ISNS_ENTITY_REG_PERIOD_ATTR_ID;
1902 				attr->len = 4;
1903 				attr->value.ui = get_reg_period();
1904 			}
1905 		} else if (entity != NULL) {
1906 			free(entity);
1907 			entity = NULL;
1908 		}
1909 	}
1910 
1911 	*p = entity;
1912 	*op = tmp;
1913 	*op_len = tmp_len;
1914 
1915 	return (ec);
1916 }
1917 
1918 /*
1919  * ****************************************************************************
1920  *
1921  * reg_get_iscsi:
1922  *	parse the Operating Attributes of the DevAttrReg message and
1923  *	create an iSCSI Storage Node object.
1924  *
1925  * p	- the pointer of the object for returning.
1926  * pg_key1 - the pointer of iscsi storage node name for returning.
1927  * op	- the operating attributes.
1928  * op_len - the length of the operating attributes.
1929  * return - error code.
1930  *
1931  * ****************************************************************************
1932  */
1933 static int
reg_get_iscsi(isns_obj_t ** p,isns_attr_t * pg_key1,isns_tlv_t ** op,uint16_t * op_len)1934 reg_get_iscsi(
1935 	isns_obj_t **p,
1936 	isns_attr_t *pg_key1,
1937 	isns_tlv_t **op,
1938 	uint16_t *op_len
1939 )
1940 {
1941 	int ec = 0;
1942 
1943 	isns_tlv_t *tmp;
1944 	uint16_t tmp_len;
1945 	isns_attr_t *attr;
1946 
1947 	isns_obj_t *obj = NULL;
1948 
1949 	tmp = *op;
1950 	tmp_len = *op_len;
1951 
1952 	/* keep the iscsi storage node name for */
1953 	/* parsing a pg object which is immediately */
1954 	/* followed with a PGT by the iscsi storage node */
1955 	pg_key1->tag = PG_KEY1;
1956 	pg_key1->len = tmp->attr_len;
1957 	pg_key1->value.ptr = (uchar_t *)&tmp->attr_value[0];
1958 
1959 	/* parse one iscsi storage node object */
1960 	obj = obj_calloc(OBJ_ISCSI);
1961 	if (obj != NULL) {
1962 		/* parse key & non-key attributes */
1963 		do {
1964 			attr = &obj->attrs[
1965 			    ATTR_INDEX_ISCSI(tmp->attr_id)];
1966 			ec = copy_attr(attr, tmp);
1967 			NEXT_TLV(tmp, tmp_len);
1968 		} while (ec == 0 &&
1969 		    tmp_len >= 8 &&
1970 		    IS_ISCSI_ATTR(tmp->attr_id));
1971 	} else {
1972 		/* no memory */
1973 		ec = ISNS_RSP_INTERNAL_ERROR;
1974 	}
1975 
1976 	*p = obj;
1977 	*op = tmp;
1978 	*op_len = tmp_len;
1979 
1980 	return (ec);
1981 }
1982 
1983 /*
1984  * ****************************************************************************
1985  *
1986  * reg_get_portal:
1987  *	parse the Operating Attributes of the DevAttrReg message and
1988  *	create a Portal object.
1989  *
1990  * p	- the pointer of the object for returning.
1991  * pg_key1 - the pointer of portal ip addr for returning.
1992  * pg_key2 - the pointer of portal port for returning.
1993  * op	- the operating attributes.
1994  * op_len - the length of the operating attributes.
1995  * return - error code.
1996  *
1997  * ****************************************************************************
1998  */
1999 static int
reg_get_portal(isns_obj_t ** p,isns_attr_t * pg_key1,isns_attr_t * pg_key2,isns_tlv_t ** op,uint16_t * op_len)2000 reg_get_portal(
2001 	isns_obj_t **p,
2002 	isns_attr_t *pg_key1,
2003 	isns_attr_t *pg_key2,
2004 	isns_tlv_t **op,
2005 	uint16_t *op_len
2006 )
2007 {
2008 	int ec = 0;
2009 
2010 	isns_tlv_t *tmp;
2011 	uint16_t tmp_len;
2012 	isns_attr_t *attr;
2013 
2014 	isns_obj_t *obj = NULL;
2015 
2016 	isns_tlv_t *ip;
2017 
2018 	tmp = *op;
2019 	tmp_len = *op_len;
2020 
2021 	/* keep the portal ip addr */
2022 	pg_key1->tag = PG_KEY2;
2023 	pg_key1->len = tmp->attr_len;
2024 	pg_key1->value.ip = (void *)&tmp->attr_value[0];
2025 	ip = tmp;
2026 
2027 	NEXT_TLV(tmp, tmp_len);
2028 	if (tmp_len > 8 &&
2029 	    tmp->attr_id == PORTAL_KEY2 &&
2030 	    tmp->attr_len == 4) {
2031 		/* keep the portal port */
2032 		pg_key2->tag = PG_KEY3;
2033 		pg_key2->len = tmp->attr_len;
2034 		pg_key2->value.ui = ntohl(*(uint32_t *)&tmp->attr_value[0]);
2035 
2036 		/* parse one portal object */
2037 		obj = obj_calloc(OBJ_PORTAL);
2038 		if (obj != NULL) {
2039 			/* copy ip addr attribute */
2040 			attr = &obj->attrs[
2041 			    ATTR_INDEX_PORTAL(ip->attr_id)];
2042 			ec = copy_attr(attr, ip);
2043 			/* copy port attribute */
2044 			if (ec == 0) {
2045 				attr = &obj->attrs[
2046 				    ATTR_INDEX_PORTAL(tmp->attr_id)];
2047 				ec = copy_attr(attr, tmp);
2048 			}
2049 			/* parse non-key attributes */
2050 			NEXT_TLV(tmp, tmp_len);
2051 			while (ec == 0 &&
2052 			    tmp_len >= 8 &&
2053 			    IS_PORTAL_ATTR(tmp->attr_id)) {
2054 				attr = &obj->attrs[
2055 				    ATTR_INDEX_PORTAL(
2056 				    tmp->attr_id)];
2057 				ec = copy_attr(attr, tmp);
2058 				NEXT_TLV(tmp, tmp_len);
2059 			}
2060 		} else {
2061 			/* no memory */
2062 			ec = ISNS_RSP_INTERNAL_ERROR;
2063 		}
2064 	} else {
2065 		/* ip address is not followed by port */
2066 		ec = ISNS_RSP_MSG_FORMAT_ERROR;
2067 	}
2068 
2069 	*p = obj;
2070 	*op = tmp;
2071 	*op_len = tmp_len;
2072 
2073 	return (ec);
2074 }
2075 
2076 /*
2077  * ****************************************************************************
2078  *
2079  * reg_get_pg:
2080  *	parse the Operating Attributes of the DevAttrReg message and
2081  *	create a Portal Group object.
2082  *
2083  * p	- the pointer of the object for returning.
2084  * op	- the operating attributes.
2085  * op_len - the length of the operating attributes.
2086  * return - error code.
2087  *
2088  * ****************************************************************************
2089  */
2090 static int
reg_get_pg(isns_obj_t ** p,isns_tlv_t ** op,uint16_t * op_len)2091 reg_get_pg(
2092 	isns_obj_t **p,
2093 	isns_tlv_t **op,
2094 	uint16_t *op_len
2095 )
2096 {
2097 	int ec = 0;
2098 
2099 	isns_tlv_t *tmp;
2100 	uint16_t tmp_len;
2101 	isns_attr_t *attr;
2102 
2103 	isns_obj_t *obj = NULL;
2104 
2105 	tmp = *op;
2106 	tmp_len = *op_len;
2107 
2108 	/* parse a complete pg object */
2109 	obj = obj_calloc(OBJ_PG);
2110 	if (obj != NULL) {
2111 		/* parse attributes */
2112 		do {
2113 			attr = &obj->attrs[
2114 			    ATTR_INDEX_PG(tmp->attr_id)];
2115 			ec = copy_attr(attr, tmp);
2116 			NEXT_TLV(tmp, tmp_len);
2117 		} while (ec == 0 &&
2118 		    tmp_len >= 8 &&
2119 		    IS_PG_ATTR(tmp->attr_id));
2120 	} else {
2121 		ec = ISNS_RSP_INTERNAL_ERROR;
2122 	}
2123 
2124 	*p = obj;
2125 	*op = tmp;
2126 	*op_len = tmp_len;
2127 
2128 	return (ec);
2129 }
2130 
2131 /*
2132  * ****************************************************************************
2133  *
2134  * reg_get_pg1:
2135  *	parse the Operating Attributes of the DevAttrReg message and
2136  *	create a Portal Group object which is followed to a Portal object.
2137  *
2138  * p	- the pointer of the object for returning.
2139  * pgt	- the size-3 array of pointers which have the pg portal ip addr, port
2140  *	  and the pg tag attributes.
2141  * op	- the operating attributes.
2142  * op_len - the length of the operating attributes.
2143  * return - error code.
2144  *
2145  * ****************************************************************************
2146  */
2147 static int
reg_get_pg1(isns_obj_t ** p,isns_attr_t const * pgt,isns_tlv_t ** op,uint16_t * op_len)2148 reg_get_pg1(
2149 	isns_obj_t **p,
2150 	isns_attr_t const *pgt,
2151 	isns_tlv_t **op,
2152 	uint16_t *op_len
2153 )
2154 {
2155 	int ec = 0;
2156 
2157 	isns_tlv_t *tmp;
2158 	uint16_t tmp_len;
2159 	isns_attr_t *attr;
2160 
2161 	isns_obj_t *obj = NULL;
2162 	int i = 0;
2163 
2164 	tmp = *op;
2165 	tmp_len = *op_len;
2166 
2167 	if (pgt[0].tag == PG_KEY2 &&
2168 	    pgt[1].tag == PG_KEY3) {
2169 		/* the pg iscsi storage node name is */
2170 		/* followed to a portal group tag */
2171 		obj = obj_calloc(OBJ_PG);
2172 		if (obj != NULL) {
2173 			/* copy pg iscsi storage node name */
2174 			attr = &obj->attrs[
2175 			    ATTR_INDEX_PG(tmp->attr_id)];
2176 			ec = copy_attr(attr, tmp);
2177 			/* copy pg ip addr, pg port & pgt */
2178 			while (ec == 0 && i < 3) {
2179 				attr = &obj->attrs[
2180 				    ATTR_INDEX_PG(pgt[i].tag)];
2181 				ec = assign_attr(attr, &pgt[i]);
2182 				i ++;
2183 			}
2184 			NEXT_TLV(tmp, tmp_len);
2185 		} else {
2186 			/* no memory */
2187 			ec = ISNS_RSP_INTERNAL_ERROR;
2188 		}
2189 	} else {
2190 		ec = ISNS_RSP_MSG_FORMAT_ERROR;
2191 	}
2192 
2193 	*p = obj;
2194 	*op = tmp;
2195 	*op_len = tmp_len;
2196 
2197 	return (ec);
2198 }
2199 
2200 /*
2201  * ****************************************************************************
2202  *
2203  * reg_get_pg2:
2204  *	parse the Operating Attributes of the DevAttrReg message and
2205  *	create a Portal Group object which is followed to a iSCSI
2206  *	Storage Node object.
2207  *
2208  * p	- the pointer of the object for returning.
2209  * pgt	- the size-3 array of pointers which have the pg iscsi storage
2210  *	  node name and the pg tag attributes.
2211  * op	- the operating attributes.
2212  * op_len - the length of the operating attributes.
2213  * return - error code.
2214  *
2215  * ****************************************************************************
2216  */
2217 static int
reg_get_pg2(isns_obj_t ** p,isns_attr_t const * pgt,isns_tlv_t ** op,uint16_t * op_len)2218 reg_get_pg2(
2219 	isns_obj_t **p,
2220 	isns_attr_t const *pgt,
2221 	isns_tlv_t **op,
2222 	uint16_t *op_len
2223 )
2224 {
2225 	int ec = 0;
2226 
2227 	isns_tlv_t *tmp;
2228 	uint16_t tmp_len;
2229 	isns_attr_t *attr;
2230 
2231 	isns_obj_t *obj = NULL;
2232 	int i = 0;
2233 
2234 	isns_tlv_t *ip;
2235 
2236 	tmp = *op;
2237 	tmp_len = *op_len;
2238 
2239 	/* keep ip address */
2240 	ip = tmp;
2241 	NEXT_TLV(tmp, tmp_len);
2242 
2243 	if (tmp_len > 8 &&
2244 	    /* expect pg portal port */
2245 	    tmp->attr_id == PG_KEY3 &&
2246 	    tmp->attr_len == 4 &&
2247 	    /* expect pg tag */
2248 	    pgt[2].tag == PG_PGT &&
2249 	    /* expect pg iscsi storage node name only */
2250 	    pgt[1].tag == 0 &&
2251 	    pgt[0].tag == PG_KEY1) {
2252 		/* the pg portal ip addr & port is followed */
2253 		/* to a pg tag and we have the iscsi storage */
2254 		/* node parsed previously */
2255 		obj = obj_calloc(OBJ_PG);
2256 		if (obj != NULL) {
2257 			/* copy the pg ip addr */
2258 			attr = &obj->attrs[
2259 			    ATTR_INDEX_PG(ip->attr_id)];
2260 			ec = copy_attr(attr, ip);
2261 			/* copy the pg port */
2262 			if (ec == 0) {
2263 				attr = &obj->attrs[
2264 				    ATTR_INDEX_PG(tmp->attr_id)];
2265 				ec = copy_attr(attr, tmp);
2266 			}
2267 			/* copy pg iscsi storage node name & pgt */
2268 			while (ec == 0 && i < 3) {
2269 				attr = &obj->attrs[
2270 				    ATTR_INDEX_PG(pgt[i].tag)];
2271 				ec = assign_attr(attr, &pgt[i]);
2272 				i += 2;
2273 			}
2274 			NEXT_TLV(tmp, tmp_len);
2275 		} else {
2276 			ec = ISNS_RSP_INTERNAL_ERROR;
2277 		}
2278 	} else {
2279 		ec = ISNS_RSP_MSG_FORMAT_ERROR;
2280 	}
2281 
2282 	*p = obj;
2283 	*op = tmp;
2284 	*op_len = tmp_len;
2285 
2286 	return (ec);
2287 }
2288 
2289 /*
2290  * ****************************************************************************
2291  *
2292  * reg_get_obj:
2293  *	parse and create one object from the rest of Operating Attributes
2294  *	of the DevAttrReg message, the object can be iSCSI Storage Node,
2295  *	Portal or Portal Group.
2296  *
2297  * p	- the pointer of the object for returning.
2298  * pgt	- an attribute array with size 3, the elements are:
2299  *	  0: the first pg key attribute, it is either the name of an
2300  *	     iscsi storage node object or the ip addr of a portal object.
2301  *	  1: the second pg key attribute, i.e. the portal port.
2302  *	  2: the portal group tag attribute.
2303  * op	- the operating attributes.
2304  * op_len - the length of the operating attributes.
2305  * return - error code.
2306  *
2307  * ****************************************************************************
2308  */
2309 int
reg_get_obj(isns_obj_t ** p,isns_attr_t * pgt,isns_tlv_t ** op,uint16_t * op_len)2310 reg_get_obj(
2311 	isns_obj_t **p,
2312 	isns_attr_t *pgt,
2313 	isns_tlv_t **op,
2314 	uint16_t *op_len
2315 )
2316 {
2317 	int ec = 0;
2318 
2319 	int derefd = 0;
2320 
2321 	uint32_t pg_tag;
2322 
2323 	if (*op_len == 0) {
2324 		*p = NULL;
2325 		return (0);
2326 	}
2327 
2328 	switch ((*op)->attr_id) {
2329 	case ISCSI_KEY:
2330 		ec = reg_get_iscsi(p, &pgt[0], op, op_len);
2331 		pgt[1].tag = 0;
2332 		pgt[2].tag = 0;
2333 		break;
2334 	case PORTAL_KEY1:
2335 		ec = reg_get_portal(p, &pgt[0], &pgt[1], op, op_len);
2336 		pgt[2].tag = 0;
2337 		break;
2338 	case PG_KEY1:
2339 		if (pgt[2].tag == PG_PGT) {
2340 			/* pg iscsi storage node name is */
2341 			/* followed to a pgt */
2342 			ec = reg_get_pg1(p, pgt, op, op_len);
2343 		} else {
2344 			/* a complete pg object */
2345 			ec = reg_get_pg(p, op, op_len);
2346 			pgt[0].tag = 0;
2347 			pgt[1].tag = 0;
2348 			pgt[2].tag = 0;
2349 		}
2350 		break;
2351 	case PG_KEY2:
2352 		/* pg portal ip addr is followed to a pgt */
2353 		ec = reg_get_pg2(p, pgt, op, op_len);
2354 		break;
2355 	case PG_PGT:
2356 		switch (pgt[0].tag) {
2357 		case 0:
2358 			/* portal group tag does not follow */
2359 			/* iscsi storage node or portal object */
2360 			*p = NULL;
2361 			ec = ISNS_RSP_MSG_FORMAT_ERROR;
2362 			break;
2363 		case PG_KEY1:
2364 		case PG_KEY2:
2365 			pgt[2].tag = PG_PGT;
2366 			pgt[2].len = (*op)->attr_len;
2367 			pg_tag = 0;
2368 			switch ((*op)->attr_len) {
2369 			case 4:
2370 				pg_tag = ntohl(*(uint32_t *)
2371 				    &(*op)->attr_value[0]);
2372 			case 0:
2373 				pgt[2].value.ui = pg_tag;
2374 				break;
2375 			default:
2376 				*p = NULL;
2377 				ec = ISNS_RSP_MSG_FORMAT_ERROR;
2378 				break;
2379 			}
2380 			if (ec == 0) {
2381 				derefd = 1;
2382 				NEXT_TLV(*op, *op_len);
2383 				ec = reg_get_obj(p, pgt, op, op_len);
2384 			}
2385 			break;
2386 		default:
2387 			/* should never happen */
2388 			ASSERT(0);
2389 			*p = NULL;
2390 			ec = ISNS_RSP_INTERNAL_ERROR;
2391 			break;
2392 		}
2393 		break;
2394 	default:
2395 		*p = NULL;
2396 		ec = ISNS_RSP_MSG_FORMAT_ERROR;
2397 		break;
2398 	}
2399 
2400 	if (ec == 0 && derefd == 0) {
2401 		ec = update_deref_obj(*p);
2402 	}
2403 
2404 	if (ec != 0 && *p != NULL) {
2405 		free_one_object(*p);
2406 		*p = NULL;
2407 	}
2408 
2409 	return (ec);
2410 }
2411 
2412 /*
2413  * ****************************************************************************
2414  *
2415  * reg_auth_src:
2416  *	Authorize the source attribute the DevAttrReg message.
2417  *	The update can only performed by the node who has the owenership.
2418  *
2419  * p	- the pointer of the object for returning.
2420  * pgt	- an attribute array with size 3, the elements are:
2421  *	  0: the first pg key attribute, it is either the name of an
2422  *	     iscsi storage node object or the ip addr of a portal object.
2423  *	  1: the second pg key attribute, i.e. the portal port.
2424  *	  2: the portal group tag attribute.
2425  * op	- the operating attributes.
2426  * op_len - the length of the operating attributes.
2427  * return - error code.
2428  *
2429  * ****************************************************************************
2430  */
2431 int
reg_auth_src(isns_type_t type,uint32_t uid,uchar_t * src)2432 reg_auth_src(
2433 	isns_type_t type,
2434 	uint32_t uid,
2435 	uchar_t *src
2436 )
2437 {
2438 	lookup_ctrl_t lc;
2439 	uint32_t puid;
2440 
2441 	puid = is_parent_there(src);
2442 
2443 	if (TYPE_OF_PARENT[type] != 0) {
2444 		SET_UID_LCP(&lc, type, uid);
2445 		uid = cache_lookup(&lc, NULL, cb_get_parent);
2446 		type = TYPE_OF_PARENT[type];
2447 	}
2448 
2449 	if (uid != 0 && puid == 0) {
2450 		SET_UID_LCP(&lc, type, uid);
2451 		uid = cache_lookup(&lc, NULL, cb_node_child);
2452 	}
2453 
2454 	if (puid != uid) {
2455 		return (0);
2456 	}
2457 
2458 	return (1);
2459 }
2460 
2461 /*
2462  * ****************************************************************************
2463  *
2464  * is_obj_online:
2465  *	determine if the object is currently registered with the server.
2466  *
2467  * obj - the object being checked.
2468  * return - 0: not registered, otherwise registered.
2469  *
2470  * ****************************************************************************
2471  */
2472 int
is_obj_online(const isns_obj_t * obj)2473 is_obj_online(
2474 	const isns_obj_t *obj
2475 )
2476 {
2477 	int online = 1;
2478 
2479 	switch (obj->type) {
2480 	case OBJ_ISCSI:
2481 		online = obj->attrs[ATTR_INDEX_ISCSI(
2482 		    ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui == 0 ? 0 : 1;
2483 		break;
2484 	default:
2485 		break;
2486 	}
2487 
2488 	return (online);
2489 }
2490 
2491 static int
set_obj_offline(isns_obj_t * obj)2492 set_obj_offline(
2493 	isns_obj_t *obj
2494 )
2495 {
2496 	switch (obj->type) {
2497 	case OBJ_ISCSI:
2498 		obj->attrs[ATTR_INDEX_ISCSI(
2499 		    ISNS_ISCSI_NODE_TYPE_ATTR_ID)].value.ui = 0;
2500 		break;
2501 	default:
2502 		break;
2503 	}
2504 
2505 	return (0);
2506 }
2507 
2508 /*
2509  * ****************************************************************************
2510  *
2511  * assoc_clone:
2512  *	clone the association object.
2513  *
2514  * p - the object being cloned.
2515  * clone_flag - 0: the object is being removed;
2516  *		1: only the association is being removed.
2517  * return - the clone object.
2518  *
2519  * ****************************************************************************
2520  */
2521 void *
assoc_clone(void * p,int clone_flag)2522 assoc_clone(
2523 	void *p,
2524 	int clone_flag
2525 )
2526 {
2527 	isns_type_t type;
2528 	isns_obj_t *clone;
2529 	const isns_attr_t *src_attr;
2530 	isns_attr_t *dst_attr;
2531 	uint32_t id, op;
2532 	int i = 0;
2533 
2534 	const isns_obj_t *obj;
2535 	uint32_t dd_flag;
2536 	int online;
2537 
2538 	int state;
2539 
2540 	obj = (isns_obj_t *)p;
2541 
2542 	if (obj->type != OBJ_ISCSI) {
2543 		return (NULL);
2544 	}
2545 
2546 	dd_flag = (get_dd_id(get_obj_uid(obj), ISNS_DEFAULT_DD_ID) == 0) ?
2547 	    0 : 1;
2548 	online = is_obj_online(obj);
2549 
2550 	state = (clone_flag << 2) | (dd_flag  << 1) | online;
2551 
2552 	/* clone_flag	dd_flag	online	action		*/
2553 	/* 0		0	0	ASSERT(0)	*/
2554 	/* 0		0	1	NULL		*/
2555 	/* 0		1	0	itself		*/
2556 	/* 0		1	1	clone it	*/
2557 	/* 1		0	0	NULL		*/
2558 	/* 1		0	1	itself		*/
2559 	/* 1		1	0	itself		*/
2560 	/* 1		1	1	itself		*/
2561 
2562 	switch (state) {
2563 	case 0:
2564 		ASSERT(0);
2565 	case 1:
2566 	case 4:
2567 		return (NULL);
2568 	case 2:
2569 	case 5:
2570 	case 6:
2571 	case 7:
2572 		return (p);
2573 	case 3:
2574 	default:
2575 		break;
2576 	}
2577 
2578 	type = obj->type;
2579 	clone = obj_calloc(type);
2580 
2581 	if (clone != NULL) {
2582 		id = UID_ATTR_INDEX[type];
2583 		src_attr = &(obj->attrs[id]);
2584 		dst_attr = &(clone->attrs[id]);
2585 		if (assign_attr(dst_attr, src_attr) != 0) {
2586 			free_one_object(clone);
2587 			return (NULL);
2588 		}
2589 
2590 		while (i < MAX_KEY_ATTRS) {
2591 			op = KEY_ATTR_OP[type][i];
2592 			if (op != 0) {
2593 				id = KEY_ATTR_INDEX[type][i];
2594 				src_attr = &(obj->attrs[id]);
2595 				dst_attr = &(clone->attrs[id]);
2596 				if (assign_attr(dst_attr, src_attr) != 0) {
2597 					free_one_object(clone);
2598 					return (NULL);
2599 				}
2600 			} else {
2601 				break;
2602 			}
2603 			i ++;
2604 		}
2605 	}
2606 
2607 	return ((void *)clone);
2608 }
2609 
2610 /*
2611  * ****************************************************************************
2612  *
2613  * free_one_object:
2614  *	free up one object.
2615  *
2616  * obj - the object being freed.
2617  *
2618  * ****************************************************************************
2619  */
2620 void
free_one_object(isns_obj_t * obj)2621 free_one_object(
2622 	isns_obj_t *obj
2623 )
2624 {
2625 	int i;
2626 	uint32_t *cuid;
2627 	if (obj == NULL) {
2628 		return;
2629 	}
2630 	for (i = 0; i < NUM_OF_ATTRS[obj->type]; i++) {
2631 		isns_attr_t *attr = &obj->attrs[i];
2632 		switch (attr->tag) {
2633 			case ISNS_EID_ATTR_ID:
2634 			case ISNS_ISCSI_NAME_ATTR_ID:
2635 			case ISNS_ISCSI_ALIAS_ATTR_ID:
2636 			case ISNS_ISCSI_AUTH_METHOD_ATTR_ID:
2637 			case ISNS_PG_ISCSI_NAME_ATTR_ID:
2638 			case ISNS_PORTAL_IP_ADDR_ATTR_ID:
2639 			case ISNS_PORTAL_NAME_ATTR_ID:
2640 			case ISNS_PG_PORTAL_IP_ADDR_ATTR_ID:
2641 			case ISNS_DD_SET_NAME_ATTR_ID:
2642 			case ISNS_DD_NAME_ATTR_ID:
2643 			case ISNS_DD_ISCSI_NAME_ATTR_ID:
2644 			case ISNS_DD_FC_PORT_NAME_ATTR_ID:
2645 			case ISNS_DD_PORTAL_IP_ADDR_ATTR_ID:
2646 #ifdef DEBUG
2647 				if (verbose_mc) {
2648 					printf("memory(%d) deallocated\n",
2649 					    attr->len);
2650 				}
2651 #endif
2652 				free(attr->value.ptr);
2653 				attr->value.ptr = NULL;
2654 				break;
2655 			default:
2656 				break;
2657 		}
2658 	}
2659 
2660 	/* free child uids */
2661 	i = 0;
2662 	while (i < NUM_OF_CHILD[obj->type]) {
2663 		cuid = get_child_n(obj, i);
2664 		free(cuid);
2665 		i ++;
2666 	}
2667 
2668 	/* at last, free the object itself */
2669 #ifdef DEBUG
2670 	if (verbose_mc) {
2671 		printf("object(%d) deallocated\n", obj->type);
2672 	}
2673 #endif
2674 	free(obj);
2675 }
2676 
2677 /*
2678  * ****************************************************************************
2679  *
2680  * free_object:
2681  *	free up one object.
2682  *
2683  * obj - the object being freed.
2684  *
2685  * ****************************************************************************
2686  */
2687 void
free_object(isns_obj_t * obj)2688 free_object(
2689 	isns_obj_t *obj
2690 )
2691 {
2692 	free_one_object(obj);
2693 }
2694 
2695 /*
2696  * ****************************************************************************
2697  *
2698  * set_parent_obj:
2699  *	set the parent object UID.
2700  *
2701  * obj - the child object.
2702  * puid- the parent object UID.
2703  * return - error code.
2704  *
2705  * ****************************************************************************
2706  */
2707 int
set_parent_obj(isns_obj_t * obj,uint32_t puid)2708 set_parent_obj(
2709 	isns_obj_t *obj,
2710 	uint32_t puid
2711 )
2712 {
2713 	uint32_t *const p = get_parent_p(obj);
2714 	if (p != NULL) {
2715 		*p = puid;
2716 	}
2717 
2718 	return (0);
2719 }
2720 
2721 /*
2722  * ****************************************************************************
2723  *
2724  * buff_child_obj:
2725  *	add a child object UID to the child object array.
2726  *
2727  * obj - the parent object.
2728  * child_type - the type of the child object.
2729  * number  - the number of the child object.
2730  * return - the length of the child object UID array.
2731  *
2732  * ****************************************************************************
2733  */
2734 int
buff_child_obj(const isns_type_t ptype,const isns_type_t ctype,const void * c,void const *** child)2735 buff_child_obj(
2736 	const isns_type_t ptype,
2737 	const isns_type_t ctype,
2738 	const void *c,
2739 	void const ***child
2740 )
2741 {
2742 	int ec = 0;
2743 
2744 	int i = 0;
2745 	void const ***pp, **p;
2746 	uint32_t num, new_num;
2747 
2748 	pp = NULL;
2749 	/* get the pointer of the array which the child belongs to */
2750 	while (i < NUM_OF_CHILD[ptype]) {
2751 		if (TYPE_OF_CHILD[ptype][i] == ctype) {
2752 			pp = &child[i];
2753 			break;
2754 		}
2755 		i ++;
2756 	}
2757 
2758 	/* the child type is not applicable */
2759 	if (pp == NULL) {
2760 		return (ec);
2761 	}
2762 
2763 	p = *pp;
2764 	/* get an empty slot from the uid array for this child */
2765 	if (p != NULL) {
2766 		num = (uint32_t)*p;
2767 		i = 0;
2768 		while (i < num) {
2769 			if (p[++i] == NULL) {
2770 				/* found it */
2771 				p[i] = c;
2772 				return (ec);
2773 			}
2774 		}
2775 		p = *pp;
2776 		new_num = num + 1;
2777 	} else {
2778 		num = 0;
2779 		new_num = 1;
2780 	}
2781 
2782 	/* the array is full, enlarge the child uid array */
2783 	p = (void const **)realloc(p, (new_num + 1) * sizeof (void *));
2784 	if (p != NULL) {
2785 		*pp = p;
2786 		*p = (void *)new_num;
2787 		p[new_num] = c;
2788 	} else {
2789 		ec = ISNS_RSP_INTERNAL_ERROR;
2790 	}
2791 
2792 	return (ec);
2793 }
2794 
2795 /*
2796  * ****************************************************************************
2797  *
2798  * update_child_object:
2799  *	update the child object of a network entity object.
2800  *
2801  * puid - the UID of the parent object, i.e. the network entity object.
2802  * child_type - the type of the child object.
2803  * child_uid  - the uid of the child object.
2804  * return - error code.
2805  *
2806  * ****************************************************************************
2807  */
2808 int
update_child_obj(const isns_type_t ptype,const uint32_t puid,void const *** child,int child_flag)2809 update_child_obj(
2810 	const isns_type_t ptype,
2811 	const uint32_t puid,
2812 	void const ***child,
2813 	int child_flag
2814 )
2815 {
2816 	int ec = 0;
2817 
2818 	lookup_ctrl_t lc;
2819 
2820 	SET_UID_LCP(&lc, ptype, puid);
2821 
2822 	lc.data[1].ptr = (uchar_t *)child;
2823 	lc.data[2].ui = child_flag;
2824 
2825 	ec = cache_lookup(&lc, NULL, cb_add_child);
2826 
2827 	return (ec);
2828 }
2829 
2830 int
update_ref_obj(const isns_obj_t * obj)2831 update_ref_obj(
2832 	const isns_obj_t *obj
2833 )
2834 {
2835 	uint32_t uid;
2836 	lookup_ctrl_t lc;
2837 	isns_type_t t;
2838 
2839 	t = obj->type;
2840 
2841 	if (TYPE_OF_REF[t][0] != 0) {
2842 		(void) setup_ref_lcp(&lc, obj, NULL);
2843 
2844 		lc.id[2] = t;
2845 		lc.data[2].ui = get_obj_uid(obj);
2846 
2847 		uid = 0;
2848 		do {
2849 			lc.curr_uid = uid;
2850 			(void) cache_lookup(&lc, &uid, cb_set_ref);
2851 		} while (uid != 0);
2852 	}
2853 
2854 	return (0);
2855 }
2856 
2857 /*
2858  * ****************************************************************************
2859  *
2860  * verify_ref_obj:
2861  *	update the reference bit of a portal group object.
2862  *
2863  * obj - the object being ref'ed.
2864  * return - error code.
2865  *
2866  * ****************************************************************************
2867  */
2868 int
verify_ref_obj(const isns_type_t ptype,const uint32_t puid,void const *** child)2869 verify_ref_obj(
2870 	const isns_type_t ptype,
2871 	const uint32_t puid,
2872 	void const ***child
2873 )
2874 {
2875 	int ec = 0;
2876 
2877 	lookup_ctrl_t lc;
2878 
2879 	SET_UID_LCP(&lc, ptype, puid);
2880 
2881 	lc.data[1].ptr = (uchar_t *)child;
2882 
2883 	ec = cache_lookup(&lc, NULL, cb_verify_ref);
2884 
2885 	return (ec);
2886 }
2887 
2888 int
update_deref_obj(isns_obj_t * obj)2889 update_deref_obj(
2890 	isns_obj_t *obj
2891 )
2892 {
2893 	int ec = 0;
2894 
2895 	isns_type_t t, rt;
2896 	lookup_ctrl_t lc;
2897 	int i, ref_count;
2898 
2899 	uint32_t uid, *refp;
2900 
2901 	t = obj->type;
2902 	i = ref_count = 0;
2903 	while (i < NUM_OF_REF[t]) {
2904 		rt = TYPE_OF_REF[t][i + 1];
2905 		(void) setup_deref_lcp(&lc, obj, rt);
2906 		uid = is_obj_there(&lc);
2907 		if (uid != 0) {
2908 			refp = get_ref_p(obj, lc.type);
2909 			*refp = uid;
2910 			ref_count ++;
2911 		}
2912 		i ++;
2913 	}
2914 
2915 	if (i > 0 && ref_count == 0) {
2916 		ec = ISNS_RSP_INVALID_REGIS;
2917 	}
2918 
2919 	return (ec);
2920 }
2921 
2922 /*
2923  * ****************************************************************************
2924  *
2925  * register_object:
2926  *	add one object to the object container.
2927  *
2928  * obj	- the object being added.
2929  * uid_p- the pointer for returning object UID.
2930  * update_p- the pointer for returning flag which indicates if the object
2931  *		is newly registered or updated with an existing one.
2932  * return - error code.
2933  *
2934  * ****************************************************************************
2935  */
2936 int
register_object(isns_obj_t * obj,uint32_t * uid_p,int * update_p)2937 register_object(
2938 	isns_obj_t *obj,
2939 	uint32_t *uid_p,
2940 	int *update_p
2941 )
2942 {
2943 	return (cache_add(obj, 0, uid_p, update_p));
2944 }
2945 
2946 /*
2947  * ****************************************************************************
2948  *
2949  * register_assoc:
2950  *	add one association object to the object container, the association
2951  *	object has only the information for discovery domain membership, i.e.
2952  *	a name and UID only.
2953  *
2954  * obj	- the association object being added.
2955  * uid_p- the pointer for returning object UID.
2956  * return - error code.
2957  *
2958  * ****************************************************************************
2959  */
2960 int
register_assoc(isns_obj_t * obj,uint32_t * uid_p)2961 register_assoc(
2962 	isns_obj_t *obj,
2963 	uint32_t *uid_p
2964 )
2965 {
2966 	return (cache_add(obj, 1, uid_p, NULL));
2967 }
2968 
2969 /*
2970  * ****************************************************************************
2971  *
2972  * is_obj_there:
2973  *	check if the object is registered or not.
2974  *
2975  * lcp	- the lookup control data.
2976  * return - the object UID.
2977  *
2978  * ****************************************************************************
2979  */
2980 uint32_t
is_obj_there(lookup_ctrl_t * lcp)2981 is_obj_there(
2982 	lookup_ctrl_t *lcp
2983 )
2984 {
2985 	uint32_t uid;
2986 
2987 	(void) cache_lookup(lcp, &uid, NULL);
2988 
2989 	return (uid);
2990 }
2991 
2992 uint32_t
is_parent_there(uchar_t * src)2993 is_parent_there(
2994 	uchar_t *src
2995 )
2996 {
2997 	lookup_ctrl_t lc;
2998 
2999 	lc.curr_uid = 0;
3000 	lc.type = OBJ_ISCSI;
3001 	lc.id[0] = ATTR_INDEX_ISCSI(ISNS_ISCSI_NAME_ATTR_ID);
3002 	lc.op[0] = OP_STRING;
3003 	lc.data[0].ptr = src;
3004 	lc.op[1] = 0;
3005 
3006 	return (cache_lookup(&lc, NULL, cb_get_parent));
3007 }
3008 
3009 /*
3010  * ****************************************************************************
3011  *
3012  * setup_ref_lcp:
3013  *	prepare the lookup control data for looking up a portal group
3014  *	object which references to a iscsi stroage node and/or a portal
3015  *	object.
3016  *
3017  * lcp	- the lookup control data.
3018  * iscsi- the ref'ed iscsi storage node object.
3019  * portal- the ref'ed portal object.
3020  * return - error code.
3021  *
3022  * ****************************************************************************
3023  */
3024 static int
setup_ref_lcp(lookup_ctrl_t * lcp,const isns_obj_t * iscsi,const isns_obj_t * portal)3025 setup_ref_lcp(
3026 	lookup_ctrl_t *lcp,
3027 	const isns_obj_t *iscsi,
3028 	const isns_obj_t *portal
3029 )
3030 {
3031 	int i = 0, j = 0;
3032 
3033 	lcp->curr_uid = 0;
3034 	lcp->type = TYPE_OF_REF[iscsi->type][0];
3035 
3036 	/* extrace the matching attributes from iscsi storage node object */
3037 	while (iscsi != NULL &&
3038 	    i < MAX_REF_MATCH &&
3039 	    REF_MATCH_OPS[iscsi->type][i] > 0) {
3040 		lcp->id[i] = REF_MATCH_ID2[iscsi->type][i];
3041 		lcp->op[i] = REF_MATCH_OPS[iscsi->type][i];
3042 		lcp->data[i].ptr = iscsi->attrs[
3043 		    REF_MATCH_ID1[iscsi->type][i]].value.ptr;
3044 		i ++;
3045 	}
3046 
3047 	/* extrace the matching attributes from portal object */
3048 	while (portal != NULL &&
3049 	    i < MAX_LOOKUP_CTRL &&
3050 	    j < MAX_REF_MATCH &&
3051 	    REF_MATCH_OPS[portal->type][j] > 0) {
3052 		lcp->id[i] = REF_MATCH_ID2[portal->type][j];
3053 		lcp->op[i] = REF_MATCH_OPS[portal->type][j];
3054 		lcp->data[i].ptr = portal->attrs[
3055 		    REF_MATCH_ID1[portal->type][j]].value.ptr;
3056 		j ++;
3057 		i ++;
3058 	}
3059 
3060 	if (i < MAX_LOOKUP_CTRL) {
3061 		lcp->op[i] = 0;
3062 	}
3063 
3064 	return (0);
3065 }
3066 
3067 static int
setup_deref_lcp(lookup_ctrl_t * lcp,const isns_obj_t * pg,isns_type_t t)3068 setup_deref_lcp(
3069 	lookup_ctrl_t *lcp,
3070 	const isns_obj_t *pg,
3071 	isns_type_t t
3072 )
3073 {
3074 	int i = 0;
3075 
3076 	lcp->curr_uid = 0;
3077 	lcp->type = t;
3078 
3079 	/* extrace the matching attributes from iscsi storage node object */
3080 	while (i < MAX_REF_MATCH &&
3081 	    REF_MATCH_OPS[t][i] > 0) {
3082 		lcp->id[i] = REF_MATCH_ID1[t][i];
3083 		lcp->op[i] = REF_MATCH_OPS[t][i];
3084 		lcp->data[i].ptr = pg->attrs[
3085 		    REF_MATCH_ID2[t][i]].value.ptr;
3086 		i ++;
3087 	}
3088 
3089 	if (i < MAX_LOOKUP_CTRL) {
3090 		lcp->op[i] = 0;
3091 	}
3092 
3093 	return (0);
3094 }
3095 
3096 /*
3097  * ****************************************************************************
3098  *
3099  * setup_parent_lcp:
3100  *	prepare the lookup control data for looking up parent object
3101  *	with a child object.
3102  *
3103  * lcp	- the lookup control data.
3104  * obj	- the child object.
3105  * return - parent object UID.
3106  *
3107  * ****************************************************************************
3108  */
3109 static uint32_t
setup_parent_lcp(lookup_ctrl_t * lcp,isns_obj_t * obj)3110 setup_parent_lcp(
3111 	lookup_ctrl_t *lcp,
3112 	isns_obj_t *obj
3113 )
3114 {
3115 	isns_type_t ptype;
3116 	uint32_t puid;
3117 
3118 	puid = get_parent_uid(obj);
3119 	if (puid != 0) {
3120 		ptype = TYPE_OF_PARENT[obj->type];
3121 		SET_UID_LCP(lcp, ptype, puid);
3122 		lcp->data[1].ui = obj->type;
3123 		lcp->data[2].ui = get_obj_uid(obj);
3124 	}
3125 
3126 	return (puid);
3127 }
3128 
3129 static int
cb_get_parent(void * p1,void * p2)3130 cb_get_parent(
3131 	void *p1,
3132 	/* LINTED E_FUNC_ARG_UNUSED */
3133 	void *p2
3134 )
3135 {
3136 	return (get_parent_uid(p1));
3137 }
3138 
3139 static int
cb_node_child(void * p1,void * p2)3140 cb_node_child(
3141 	void *p1,
3142 	/* LINTED E_FUNC_ARG_UNUSED */
3143 	void *p2
3144 )
3145 {
3146 	isns_obj_t *obj = (isns_obj_t *)p1;
3147 
3148 	uint32_t num, uid;
3149 
3150 	uint32_t *cuid = get_child_t(obj, OBJ_ISCSI);
3151 
3152 	if (cuid != NULL) {
3153 		num = *cuid;
3154 	} else {
3155 		num = 0;
3156 	}
3157 
3158 	while (num > 0) {
3159 		uid = *++cuid;
3160 		if (uid != 0) {
3161 			return (uid);
3162 		}
3163 		num --;
3164 	}
3165 
3166 	return (0);
3167 }
3168 
3169 /*
3170  * ****************************************************************************
3171  *
3172  * cb_set_ref:
3173  *	callback function which sets the reference bit to 1 according to
3174  *	the type of object.
3175  *
3176  * p1	- the object.
3177  * p2	- the lcp.
3178  * return - error code.
3179  *
3180  * ****************************************************************************
3181  */
3182 static int
cb_set_ref(void * p1,void * p2)3183 cb_set_ref(
3184 	void *p1,
3185 	void *p2
3186 )
3187 {
3188 	isns_obj_t *obj = (isns_obj_t *)p1;
3189 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3190 
3191 	isns_type_t t;
3192 	uint32_t u;
3193 
3194 	uint32_t *refp;
3195 
3196 	t = lcp->id[2];
3197 	u = lcp->data[2].ui;
3198 	refp = get_ref_p(obj, t);
3199 	*refp = u;
3200 
3201 	/* successful */
3202 	return (0);
3203 }
3204 
3205 /*
3206  * ****************************************************************************
3207  *
3208  * cb_clear_ref:
3209  *	callback function which clears the reference bit according to
3210  *	the type of object.
3211  *
3212  * p1	- the object.
3213  * p2	- the lcp.
3214  * return - 1: the object is no longer ref'ed, 0: otherwise.
3215  *
3216  * ****************************************************************************
3217  */
3218 static int
cb_clear_ref(void * p1,void * p2)3219 cb_clear_ref(
3220 	void *p1,
3221 	void *p2
3222 )
3223 {
3224 	isns_obj_t *obj = (isns_obj_t *)p1;
3225 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3226 
3227 	isns_type_t t;
3228 	uint32_t *refp;
3229 
3230 	int i = 0;
3231 	uint32_t ref;
3232 
3233 	t = lcp->data[2].ui;
3234 	refp = get_ref_p(obj, t);
3235 	*refp = 0;
3236 
3237 	while (i < NUM_OF_REF[obj->type]) {
3238 		ref = get_ref_n(obj, i);
3239 		if (ref != 0) {
3240 			return (0);
3241 		}
3242 		i ++;
3243 	}
3244 
3245 	return (1);
3246 }
3247 
3248 static int
cb_add_child(void * p1,void * p2)3249 cb_add_child(
3250 	void *p1,
3251 	void *p2
3252 )
3253 {
3254 	isns_obj_t *obj = (isns_obj_t *)p1;
3255 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3256 
3257 	const void ***child;
3258 	const void **vpp;
3259 	uint32_t vnum;
3260 	int child_flag;
3261 
3262 	uint32_t **upp, *up;
3263 	uint32_t num;
3264 
3265 	isns_obj_t *o;
3266 
3267 	int i = 0;
3268 
3269 	child = (const void ***)lcp->data[1].ptr;
3270 	child_flag = lcp->data[2].ui;
3271 
3272 	while (i < NUM_OF_CHILD[obj->type]) {
3273 		vpp = child[i];
3274 		if (vpp != NULL &&
3275 		    (vnum = (uint32_t)*vpp) > 0 &&
3276 		    *(vpp + 1) != NULL) {
3277 			upp = get_child_np(obj, i);
3278 			if (*upp == NULL) {
3279 				if (child_flag == 0 &&
3280 				    sizeof (typeof (**upp)) ==
3281 				    sizeof (typeof (**child))) {
3282 					*upp = (uint32_t *)vpp;
3283 					vpp = NULL;
3284 					child[i] = NULL;
3285 				}
3286 				num = vnum;
3287 			} else {
3288 				num = **upp + vnum;
3289 			}
3290 			if (vpp != NULL) {
3291 				/* copy required */
3292 				up = (uint32_t *)realloc(*upp,
3293 				    (num + 1) * sizeof (uint32_t));
3294 				if (up == NULL) {
3295 					return (ISNS_RSP_INTERNAL_ERROR);
3296 				}
3297 				*upp = up;
3298 				*up = num;
3299 				up += num;
3300 				vpp += vnum;
3301 				while (vnum > 0) {
3302 					if (*vpp == NULL) {
3303 						*up = 0;
3304 					} else if (child_flag == 0) {
3305 						*up = (uint32_t)*vpp;
3306 						*vpp = NULL;
3307 					} else {
3308 						o = (isns_obj_t *)*vpp;
3309 						*up = get_obj_uid(o);
3310 						if (is_obj_online(o) == 0) {
3311 							free_object(o);
3312 						}
3313 						*vpp = NULL;
3314 					}
3315 					up --;
3316 					vpp --;
3317 					vnum --;
3318 				}
3319 			}
3320 		}
3321 		i ++;
3322 	}
3323 
3324 	return (0);
3325 }
3326 
3327 /*
3328  * ****************************************************************************
3329  *
3330  * cb_remove_child:
3331  *	callback function which removes a child object UID from the
3332  *	children objet UID array of the parent object.
3333  *
3334  * p1	- the object.
3335  * p2	- the lcp.
3336  * return - 1: no more such type of child object, 0: otherwise.
3337  *
3338  * ****************************************************************************
3339  */
3340 static int
cb_remove_child(void * p1,void * p2)3341 cb_remove_child(
3342 	void *p1,
3343 	void *p2
3344 )
3345 {
3346 	isns_obj_t *obj = (isns_obj_t *)p1;
3347 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3348 	uint32_t child_type = lcp->data[1].ui;
3349 	uint32_t child_uid = lcp->data[2].ui;
3350 	uint32_t *cuidp, cuid, num_of_child = 0;
3351 	int i;
3352 
3353 	/* get the children object UID array */
3354 	cuidp = get_child_t(obj, child_type);
3355 	if (cuidp != NULL) {
3356 		num_of_child = *cuidp;
3357 	}
3358 
3359 	/* remove it */
3360 	while (num_of_child > 0) {
3361 		cuid = *++cuidp;
3362 		if (cuid == child_uid) {
3363 			*cuidp = 0;
3364 			break;
3365 		}
3366 		num_of_child --;
3367 	}
3368 
3369 	/* check if all of child object UIDs are removed */
3370 	i = 0;
3371 	while (i < NUM_OF_CHILD[obj->type]) {
3372 		cuidp = get_child_n(obj, i);
3373 		if (cuidp != NULL) {
3374 			num_of_child = *cuidp;
3375 			while (num_of_child > 0) {
3376 				cuid = *++cuidp;
3377 				if (cuid != 0) {
3378 					return (0);
3379 				}
3380 				num_of_child --;
3381 			}
3382 		}
3383 		i ++;
3384 	}
3385 
3386 	return (1);
3387 }
3388 
3389 static int
cb_verify_ref(void * p1,void * p2)3390 cb_verify_ref(
3391 	void *p1,
3392 	void *p2
3393 )
3394 {
3395 	int ec = 0;
3396 
3397 	isns_obj_t *parent = (isns_obj_t *)p1;
3398 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3399 
3400 	const void ***child;
3401 
3402 	const void **vpp;
3403 	const void *vp;
3404 	uint32_t vnum;
3405 
3406 	const void **evpp;
3407 	const void *evp;
3408 	uint32_t evnum;
3409 
3410 	isns_type_t pt; /* parent object type */
3411 	isns_type_t ct; /* child object type */
3412 	isns_type_t rt; /* ref object type */
3413 	isns_type_t et; /* peer object type */
3414 
3415 	uint32_t *up;
3416 	uint32_t u;
3417 	uint32_t unum;
3418 
3419 	lookup_ctrl_t lc;
3420 	uint8_t flag[MAX_OBJ_TYPE + 1] = { 0 };
3421 
3422 	int i, j, k;
3423 
3424 	pt = parent->type;
3425 
3426 	child = (const void ***)lcp->data[1].ptr;
3427 
3428 	for (i = 0; i < NUM_OF_CHILD[pt]; i++) {
3429 		ct = TYPE_OF_CHILD[pt][i];
3430 		rt = TYPE_OF_REF[ct][0];
3431 		if (rt == 0) {
3432 			continue;
3433 		}
3434 
3435 		et = TYPE_OF_REF[ct][1];
3436 		vpp = child[i];
3437 		if (vpp != NULL) {
3438 			vnum = (uint32_t)*vpp;
3439 			up = get_child_t(parent, et);
3440 			if (up != NULL) {
3441 				unum = *up;
3442 			} else {
3443 				unum = 0;
3444 			}
3445 		} else {
3446 			vnum = 0;
3447 		}
3448 
3449 		j = vnum;
3450 		while (j > 0) {
3451 			vp = vpp[j];
3452 			if (vp != NULL) {
3453 				(void) setup_ref_lcp(&lc, vp, NULL);
3454 				k = unum;
3455 				while (k > 0) {
3456 					u = up[k];
3457 					if (u != 0) {
3458 						ec = ref_new2old(
3459 						    &lc, et, u, vp);
3460 						if (ec != 0) {
3461 							return (ec);
3462 						}
3463 					}
3464 					k --;
3465 				} /* End of while each unum */
3466 			}
3467 			j --;
3468 		} /* End of while each vnum */
3469 
3470 		if (flag[ct] != 0) {
3471 			continue;
3472 		}
3473 
3474 		evnum = 0;
3475 		j = 0;
3476 		while (j < NUM_OF_CHILD[pt]) {
3477 			if (TYPE_OF_CHILD[pt][j] == et) {
3478 				evpp = child[j];
3479 				if (evpp != NULL) {
3480 					evnum = (uint32_t)*evpp;
3481 				}
3482 				break;
3483 			}
3484 			j ++;
3485 		}
3486 
3487 		j = vnum;
3488 		while (j > 0) {
3489 			vp = vpp[j];
3490 			k = evnum;
3491 			while (k > 0) {
3492 				evp = evpp[k];
3493 				if (vp != NULL && evp != NULL) {
3494 					(void) setup_ref_lcp(&lc, vp, evp);
3495 					ec = ref_new2new(&lc, vp, evp);
3496 					if (ec != 0) {
3497 						return (ec);
3498 					}
3499 				}
3500 				k --;
3501 			}
3502 			j --;
3503 		} /* End of while each vnum */
3504 
3505 		flag[et] = 1;
3506 	} /* End of for each type of child */
3507 
3508 	return (ec);
3509 }
3510 
3511 static int
cb_ref_new2old(void * p1,void * p2)3512 cb_ref_new2old(
3513 	void *p1,
3514 	void *p2
3515 )
3516 {
3517 	isns_obj_t *obj = (isns_obj_t *)p1;
3518 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3519 
3520 	isns_type_t et;
3521 	uint32_t uu;
3522 
3523 	uint32_t ref;
3524 
3525 	int match;
3526 
3527 	et = lcp->id[2];
3528 	uu = lcp->data[2].ui;
3529 
3530 	ref = get_ref_t(obj, et);
3531 
3532 	if (ref == uu) {
3533 		match = 1;
3534 	} else {
3535 		match = 0;
3536 	}
3537 
3538 	return (match);
3539 }
3540 
3541 static int
cb_new_ref(void * p1,void * p2)3542 cb_new_ref(
3543 	void *p1,
3544 	void *p2
3545 )
3546 {
3547 	int ec = 0;
3548 
3549 	lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2;
3550 	isns_obj_t *a = (isns_obj_t *)p1;
3551 	isns_obj_t *b = (isns_obj_t *)lcp->data[2].ptr;
3552 
3553 	ec = new_ref(a, b);
3554 
3555 	return (ec);
3556 }
3557 
3558 static int
ref_new2old(lookup_ctrl_t * lcp,isns_type_t et,uint32_t uu,const isns_obj_t * vp)3559 ref_new2old(
3560 	lookup_ctrl_t *lcp,
3561 	isns_type_t et,
3562 	uint32_t uu,
3563 	const isns_obj_t *vp
3564 )
3565 {
3566 	int ec = 0;
3567 
3568 	int match;
3569 	uint32_t uid;
3570 
3571 	lookup_ctrl_t lc;
3572 
3573 	lcp->id[2] = et;
3574 	lcp->data[2].ui = uu;
3575 
3576 	uid = 0;
3577 	do {
3578 		lcp->curr_uid = uid;
3579 		match = cache_lookup(lcp, &uid, cb_ref_new2old);
3580 	} while (match == 0 && uid != 0);
3581 
3582 	if (match == 0) {
3583 		/* no such ref, create a default one */
3584 		SET_UID_LCP(&lc, et, uu);
3585 
3586 		lc.data[2].ptr = (uchar_t *)vp;
3587 
3588 		ec = cache_lookup(&lc, NULL, cb_new_ref);
3589 	}
3590 
3591 	return (ec);
3592 }
3593 
3594 static int
ref_new2new(lookup_ctrl_t * lcp,const isns_obj_t * p1,const isns_obj_t * p2)3595 ref_new2new(
3596 	lookup_ctrl_t *lcp,
3597 	const isns_obj_t *p1,
3598 	const isns_obj_t *p2
3599 )
3600 {
3601 	int ec = 0;
3602 
3603 	if (is_obj_there(lcp) != 0) {
3604 		return (0);
3605 	}
3606 
3607 	ec = new_ref(p1, p2);
3608 
3609 	return (ec);
3610 }
3611 
3612 static int
new_ref(const isns_obj_t * p1,const isns_obj_t * p2)3613 new_ref(
3614 	const isns_obj_t *p1,
3615 	const isns_obj_t *p2
3616 )
3617 {
3618 	int ec = 0;
3619 
3620 	isns_obj_t *obj;
3621 
3622 	obj = make_ref[p1->type](p1, p2);
3623 	if (obj != NULL) {
3624 		ec = register_object(obj, NULL, NULL);
3625 	} else {
3626 		ec = ISNS_RSP_INTERNAL_ERROR;
3627 	}
3628 
3629 	return (ec);
3630 }
3631 
3632 /*
3633  * ****************************************************************************
3634  *
3635  * do_dereg:
3636  *	Physically remove an object along with the children objects,
3637  *	the reference object and the parent object recursively.
3638  *	Apporiate SCN is triggered.
3639  *
3640  * lcp	- the lookup control for the object being removed.
3641  * parent_flag	- 1: the object being removed is the parent object;
3642  *		  0: otherwise.
3643  * child_flag	- 1: the object being removed is a child object;
3644  *		  0: otherwise.
3645  * pending	- 1: do not remove the ESI entry immediately;
3646  *		  0: remove the ESI entry without any delay.
3647  * return - error code.
3648  *
3649  * ****************************************************************************
3650  */
3651 static int
do_dereg(lookup_ctrl_t * lcp,int parent_flag,int child_flag,int pending)3652 do_dereg(
3653 	lookup_ctrl_t *lcp,
3654 	int parent_flag,
3655 	int child_flag,
3656 	int pending
3657 )
3658 {
3659 	int ec = 0;
3660 
3661 	isns_obj_t *obj;
3662 	uint32_t *cuidp, num;
3663 	isns_type_t type;
3664 	uint32_t uid;
3665 	int i;
3666 
3667 	/* remove the object from object container */
3668 	obj = cache_remove(lcp, 0);
3669 
3670 	if (obj == NULL) {
3671 		return (0);
3672 	}
3673 
3674 	/* trigger a scn */
3675 	if (scn_q != NULL) {
3676 		(void) make_scn(ISNS_OBJECT_REMOVED, obj);
3677 	}
3678 
3679 	/* dereg children */
3680 	i = 0;
3681 	while (ec == 0 && !parent_flag &&
3682 	    i < NUM_OF_CHILD[obj->type]) {
3683 		type = TYPE_OF_CHILD[obj->type][i];
3684 		cuidp = get_child_n(obj, i);
3685 		if (cuidp != NULL) {
3686 			num = *cuidp;
3687 		} else {
3688 			num = 0;
3689 		}
3690 		while (ec == 0 && num > 0) {
3691 			uid = cuidp[num];
3692 			if (uid != 0) {
3693 				SET_UID_LCP(lcp, type, uid);
3694 				ec = do_dereg(lcp,
3695 				    parent_flag,
3696 				    1,
3697 				    pending);
3698 			}
3699 			num --;
3700 		}
3701 		i ++;
3702 	}
3703 
3704 	/* clear the ref bit on the ref'd object */
3705 	if (ec == 0 && TYPE_OF_REF[obj->type][0] > 0) {
3706 		uid = 0;
3707 		do {
3708 			(void) setup_ref_lcp(lcp, obj, NULL);
3709 			lcp->curr_uid = uid;
3710 			lcp->data[2].ui = obj->type;
3711 			if (cache_lookup(lcp, &uid, cb_clear_ref) != 0) {
3712 				UPDATE_LCP_UID(lcp, uid);
3713 				ec = do_dereg(lcp,
3714 				    parent_flag,
3715 				    child_flag,
3716 				    pending);
3717 			}
3718 		} while (uid != 0);
3719 	}
3720 
3721 	/* remove it from the parent */
3722 	if (ec == 0 && !child_flag &&
3723 	    TYPE_OF_PARENT[obj->type] > 0 &&
3724 	    (uid = setup_parent_lcp(lcp, obj)) != 0) {
3725 		if (cache_lookup(lcp, NULL, cb_remove_child) != 0) {
3726 			UPDATE_LCP_UID(lcp, uid);
3727 			ec = do_dereg(lcp,
3728 			    1,
3729 			    child_flag,
3730 			    0);
3731 		}
3732 	}
3733 
3734 	if (ec == 0 && !child_flag) {
3735 		/* remove it from persistent data store */
3736 		if (sys_q) {
3737 			ec = write_data(DATA_DELETE, obj);
3738 		}
3739 		/* remove esi event entry */
3740 		if (ec == 0) {
3741 			(void) esi_remove_obj(obj, pending);
3742 		}
3743 
3744 		/* save the parent uid for caller */
3745 		if (TYPE_OF_PARENT[obj->type] != 0) {
3746 			lcp->curr_uid = get_parent_uid(obj);
3747 		} else {
3748 			/* it's the parent itself */
3749 			lcp->curr_uid = get_obj_uid(obj);
3750 		}
3751 	}
3752 
3753 	/* remove this portal from scn registry */
3754 	if (ec == 0 &&
3755 	    obj->type == OBJ_PORTAL) {
3756 		(void) remove_scn_portal(get_obj_uid(obj));
3757 	}
3758 
3759 	/* free the object */
3760 	(void) free_object(obj);
3761 
3762 	return (ec);
3763 }
3764 
3765 /*
3766  * ****************************************************************************
3767  *
3768  * dereg_assoc:
3769  *	Remove one association object from object container.
3770  *
3771  * lcp	- the lookup control for the object being removed.
3772  * return - error code.
3773  *
3774  * ****************************************************************************
3775  */
3776 int
dereg_assoc(lookup_ctrl_t * lcp)3777 dereg_assoc(
3778 	lookup_ctrl_t *lcp
3779 )
3780 {
3781 	isns_obj_t *obj;
3782 
3783 	obj = cache_remove(lcp, 1);
3784 
3785 	/* free the object */
3786 	if (obj != NULL) {
3787 		free_object(obj);
3788 	}
3789 
3790 	return (0);
3791 }
3792 
3793 /*
3794  * ****************************************************************************
3795  *
3796  * dereg_object:
3797  *	Remove one object from object container.
3798  *
3799  * lcp	- the lookup control for the object being removed.
3800  * return - error code.
3801  *
3802  * ****************************************************************************
3803  */
3804 int
dereg_object(lookup_ctrl_t * lcp,int pending)3805 dereg_object(
3806 	lookup_ctrl_t *lcp,
3807 	int pending
3808 )
3809 {
3810 	return (do_dereg(lcp, 0, 0, pending));
3811 }
3812 
3813 /*
3814  * ****************************************************************************
3815  *
3816  * data_sync:
3817  *	Synchronize the cache with persistent data store.
3818  *	Flush the cache data to data store if the input ec is zero,
3819  *	retreat the changes in cache and ignore data store update
3820  *	if there is an error.
3821  *
3822  * ec	- error code.
3823  * return - error code.
3824  *
3825  * ****************************************************************************
3826  */
3827 int
data_sync(int ec)3828 data_sync(
3829 	int ec
3830 )
3831 {
3832 	/* cache is updated successfully, commit the data to data store */
3833 	if (IS_CACHE_UPDATED()) {
3834 		if (ec == 0) {
3835 			ec = write_data(DATA_COMMIT, NULL);
3836 		}
3837 		if (ec == 0) {
3838 			/* successful, trigger the SCN */
3839 			(void) queue_msg_set(scn_q, SCN_TRIGGER, (void *)NULL);
3840 		} else {
3841 			shutdown_server();
3842 		}
3843 	} else {
3844 		/* ignore all SCNs which have been generated */
3845 		(void) queue_msg_set(scn_q, SCN_IGNORE, (void *)NULL);
3846 
3847 		(void) write_data(DATA_RETREAT, NULL);
3848 	}
3849 
3850 	return (ec);
3851 }
3852 
3853 static pthread_mutex_t name_mtx[3] = {
3854 	PTHREAD_MUTEX_INITIALIZER,
3855 	PTHREAD_MUTEX_INITIALIZER,
3856 	PTHREAD_MUTEX_INITIALIZER
3857 };
3858 static const char *name_pattern[3] = {
3859 	"ENTITY_ID_%d",
3860 	"DD_%d",
3861 	"DD-Set_%d"
3862 };
3863 static uint32_t name_count[3] = {
3864 	0,
3865 	0,
3866 	0
3867 };
3868 
3869 /*
3870  * ****************************************************************************
3871  *
3872  * make_unique_name:
3873  *	make a default unique name for a newly registered network entity,
3874  *	discovery domain or discovery domain set object.
3875  *
3876  * len	- pointer of the length of the new name for returning.
3877  * tag	- which attribute of the new name is for.
3878  * return - the name being made.
3879  *
3880  * ****************************************************************************
3881  */
3882 static char *
make_unique_name(int * len,uint32_t tag)3883 make_unique_name(
3884 	int *len,
3885 	uint32_t tag
3886 )
3887 {
3888 	int i;
3889 	int count;
3890 	char name[32] = { 0 };
3891 
3892 	char *p;
3893 
3894 	lookup_ctrl_t lc;
3895 
3896 	lc.curr_uid = 0;
3897 
3898 	switch (tag) {
3899 	case ISNS_EID_ATTR_ID:
3900 		i = 0;
3901 		lc.type = OBJ_ENTITY;
3902 		lc.id[0] = ATTR_INDEX_ENTITY(ISNS_EID_ATTR_ID);
3903 		break;
3904 	case ISNS_DD_NAME_ATTR_ID:
3905 		i = 1;
3906 		lc.type = OBJ_DD;
3907 		lc.id[0] = ATTR_INDEX_DD(ISNS_DD_NAME_ATTR_ID);
3908 		break;
3909 	case ISNS_DD_SET_NAME_ATTR_ID:
3910 		i = 2;
3911 		lc.type = OBJ_DDS;
3912 		lc.id[0] = ATTR_INDEX_DDS(ISNS_DD_SET_NAME_ATTR_ID);
3913 		break;
3914 	default:
3915 		ASSERT(0);
3916 		break;
3917 	}
3918 
3919 	lc.op[0] = OP_STRING;
3920 	lc.op[1] = 0;
3921 	do {
3922 		(void) pthread_mutex_lock(&name_mtx[i]);
3923 		count = ++ name_count[i];
3924 		(void) pthread_mutex_unlock(&name_mtx[i]);
3925 		/* no more space, failure */
3926 		if (count == 0) {
3927 			return (NULL);
3928 		}
3929 		(void) sprintf(name, name_pattern[i], count);
3930 		lc.data[0].ptr = (uchar_t *)name;
3931 	} while (is_obj_there(&lc) != 0);
3932 
3933 	/* 4-bytes aligned length */
3934 	*len = strlen(name);
3935 	*len = *len + (4 - *len % 4);
3936 	p = (char *)malloc(*len);
3937 	if (p != NULL) {
3938 		(void) strcpy(p, name);
3939 	}
3940 	return (p);
3941 }
3942 
3943 #ifdef DEBUG
3944 void
obj_dump(void * p)3945 obj_dump(
3946 	void *p
3947 )
3948 {
3949 	print_object(NULL, (isns_obj_t *)p);
3950 }
3951 #endif
3952