xref: /illumos-gate/usr/src/lib/libcpc/common/subr.c (revision 7c478bd9)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <sys/types.h>
30 #include <sys/syscall.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <strings.h>
34 #include <unistd.h>
35 #include <errno.h>
36 #include <libintl.h>
37 #include <libnvpair.h>
38 #include <thread.h>
39 #include <synch.h>
40 
41 #include "libcpc.h"
42 #include "libcpc_impl.h"
43 
44 /*
45  * Pack a request set into a buffer using libnvpair. Size of buffer is returned
46  * in buflen.
47  */
48 char *
__cpc_pack_set(cpc_set_t * set,uint_t flags,size_t * buflen)49 __cpc_pack_set(cpc_set_t *set, uint_t flags, size_t *buflen)
50 {
51 	cpc_request_t	*req;
52 	nvlist_t	*setlist, **reqlist;
53 	size_t		packsize = 0;
54 	char		*buf = NULL;
55 	int		i;
56 	int		j;
57 
58 	if (nvlist_alloc(&setlist, 0, 0) == ENOMEM) {
59 		errno = ENOMEM;
60 		return (NULL);
61 	}
62 
63 	if ((reqlist = (nvlist_t **)malloc(set->cs_nreqs * sizeof (*reqlist)))
64 	    == NULL) {
65 		nvlist_free(setlist);
66 		errno = ENOMEM;
67 		return (NULL);
68 	}
69 
70 	bzero((void *)reqlist, set->cs_nreqs * sizeof (*reqlist));
71 
72 	i = 0;
73 	for (req = set->cs_request; req != NULL; req = req->cr_next) {
74 		if (nvlist_alloc(&reqlist[i], 0, 0) == ENOMEM)
75 			goto nomem;
76 
77 		if (nvlist_add_string(reqlist[i], "cr_event",
78 		    req->cr_event) != 0)
79 			goto nomem;
80 		if (nvlist_add_uint64(reqlist[i], "cr_preset",
81 		    req->cr_preset) != 0)
82 			goto nomem;
83 		if (nvlist_add_uint32(reqlist[i], "cr_flags",
84 		    req->cr_flags) != 0)
85 			goto nomem;
86 		if (nvlist_add_uint32(reqlist[i], "cr_index",
87 		    req->cr_index) != 0)
88 			goto nomem;
89 
90 		if (req->cr_nattrs != 0) {
91 			nvlist_t	*attrs;
92 
93 			if (nvlist_alloc(&attrs, NV_UNIQUE_NAME, 0) == ENOMEM)
94 				goto nomem;
95 
96 			for (j = 0; j < req->cr_nattrs; j++) {
97 				if (nvlist_add_uint64(attrs,
98 				    req->cr_attr[j].ka_name,
99 				    req->cr_attr[j].ka_val) != 0) {
100 					nvlist_free(attrs);
101 					goto nomem;
102 				}
103 			}
104 
105 			if (nvlist_add_nvlist(reqlist[i], "cr_attr",
106 			    attrs) != 0) {
107 				nvlist_free(attrs);
108 				goto nomem;
109 			}
110 
111 			nvlist_free(attrs);
112 		}
113 		i++;
114 	}
115 
116 	if (nvlist_add_nvlist_array(setlist, "reqs", reqlist,
117 	    set->cs_nreqs) != 0)
118 		goto nomem;
119 
120 	if (nvlist_add_uint32(setlist, "flags", flags) != 0)
121 		goto nomem;
122 
123 	if (nvlist_pack(setlist, &buf, &packsize, NV_ENCODE_NATIVE,
124 	    0) != 0)
125 		goto nomem;
126 
127 	for (i = 0; i < set->cs_nreqs; i++)
128 		nvlist_free(reqlist[i]);
129 
130 	nvlist_free(setlist);
131 	free(reqlist);
132 
133 	*buflen = packsize;
134 	return (buf);
135 
136 nomem:
137 	for (i = 0; i < set->cs_nreqs; i++) {
138 		if (reqlist[i] != 0)
139 			nvlist_free(reqlist[i]);
140 	}
141 	nvlist_free(setlist);
142 	free(reqlist);
143 	errno = ENOMEM;
144 	return (NULL);
145 }
146 
147 cpc_strhash_t *
__cpc_strhash_alloc(void)148 __cpc_strhash_alloc(void)
149 {
150 	cpc_strhash_t *p;
151 
152 	if ((p = malloc(sizeof (cpc_strhash_t))) == NULL)
153 		return (NULL);
154 
155 	p->str = "";
156 	p->cur = NULL;
157 	p->next = NULL;
158 
159 	return (p);
160 }
161 
162 void
__cpc_strhash_free(cpc_strhash_t * hash)163 __cpc_strhash_free(cpc_strhash_t *hash)
164 {
165 	cpc_strhash_t *p = hash, *f;
166 
167 	while (p != NULL) {
168 		f = p;
169 		p = p->next;
170 		free(f);
171 	}
172 }
173 
174 /*
175  * Insert a new key into the hash table.
176  *
177  * Returns 0 if key was unique and insert successful.
178  *
179  * Returns 1 if key was already in table and no insert took place.
180  *
181  * Returns -1 if out of memory.
182  */
183 int
__cpc_strhash_add(cpc_strhash_t * hash,char * key)184 __cpc_strhash_add(cpc_strhash_t *hash, char *key)
185 {
186 	cpc_strhash_t *p, *tmp;
187 
188 	for (p = hash; p != NULL; p = p->next) {
189 		if (strcmp(p->str, key) == 0)
190 			return (1);
191 	}
192 
193 	if ((p = malloc(sizeof (*p))) == NULL)
194 		return (-1);
195 
196 	p->str = key;
197 	tmp = hash->next;
198 	hash->next = p;
199 	p->next = tmp;
200 	/*
201 	 * The head node's current pointer must stay pointed at the first
202 	 * real node. We just inserted at the head.
203 	 */
204 	hash->cur = p;
205 
206 	return (0);
207 }
208 
209 char *
__cpc_strhash_next(cpc_strhash_t * hash)210 __cpc_strhash_next(cpc_strhash_t *hash)
211 {
212 	cpc_strhash_t *p;
213 
214 	if (hash->cur != NULL) {
215 		p = hash->cur;
216 		hash->cur = hash->cur->next;
217 		return (p->str);
218 	}
219 
220 	return (NULL);
221 }
222