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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/utsname.h>
28 #include <fcntl.h>
29 #include <sys/param.h>
30 #include <unistd.h>
31 #include <stdarg.h>
32 #include <errno.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include "libnsctl.h"
38 #include <nsctl.h>
39 #include <sys/ncall/ncall.h>
40
41
42
43 /*
44 * Internal routine to fetch all the current nodes that are
45 * considered 'up'.
46 * Returns the number of ncall_info structures that are valid
47 * returned via the nodelist pointer, or -1 on an error.
48 * If the call succeeds, then the memory returned via the
49 * nodelist pointer needs to be freed by the caller.
50 */
51
52 static int
53 nsc_getcurrentnodes(ncall_node_t **nodelist)
54 {
55 ncall_node_t *mynodelist;
56 int size;
57 int fd;
58 int rc = -1;
59 int save_errno = 0;
60 int ioctlcmd;
61
62 if (nodelist == NULL) {
63 errno = EINVAL;
64 return (-1);
65 }
66 *nodelist = NULL;
67 if ((fd = open("/dev/ncall", O_RDONLY)) < 0) {
68 return (-1);
69 }
70 if ((size = ioctl(fd, NC_IOC_GETNETNODES, NULL)) < 1) {
71 size = 1;
72 ioctlcmd = NC_IOC_GETNODE;
73 } else {
74 ioctlcmd = NC_IOC_GETNETNODES;
75 }
76
77 mynodelist = malloc(size * sizeof (*mynodelist));
78 if (mynodelist == NULL) {
79 save_errno = ENOMEM;
80 } else {
81 rc = ioctl(fd, ioctlcmd, mynodelist);
82 if (rc < 0) {
83 save_errno = errno;
84 free(mynodelist);
85 } else {
86 /* fixup return value for single node ioctl */
87 if (ioctlcmd == NC_IOC_GETNODE)
88 rc = 1;
89 *nodelist = mynodelist;
90 }
91 }
92 close(fd);
93 errno = save_errno;
94 return (rc);
95 }
96
97
98 /*
99 * return the system id (the current value in the kernel
100 * currently running).
101 *
102 * on error return -1 and set errno.
103 */
104 int
105 nsc_getsystemid(int *id)
106 {
107 ncall_node_t node;
108 int rval = 0;
109 int save_errno = 0;
110 int fd;
111
112 *id = 0;
113
114 fd = open("/dev/ncall", O_RDONLY);
115 if (fd < 0)
116 return (-1);
117
118 memset(&node, 0, sizeof (node));
119
120 rval = ioctl(fd, NC_IOC_GETNODE, &node);
121 if (rval < 0)
122 save_errno = errno;
123 else {
124 *id = node.nc_nodeid;
125 /*
126 * Return 0, not the mirror node id as returned
127 * from the ioctl.
128 */
129 rval = 0;
130 }
131
132 close(fd);
133
134 errno = save_errno;
135 return (rval);
136 }
137
138
139 /*
140 * Runtime Solaris release checking.
141 *
142 * Compare the build release to the runtime release to check for an
143 * acceptable match.
144 *
145 * Arguments:
146 * build_ver - the string Solaris build release (e.g. "5.8")
147 * map - optional array of nsc_release_t defining
148 * acceptable build release / runtime release
149 * matches. If supplied, must end will a NULL
150 * array element. See src/head/nsctl.h for info.
151 * reqd - used to return the required OS versions if the
152 * return value is not -1. The returned string
153 * is readonly.
154 *
155 * Returns:
156 * TRUE - acceptable match
157 * FALSE - no match (component should not continue to run)
158 * -1 - error (errno is set)
159 */
160
161 int
162 nsc_check_release(const char *build_rel, nsc_release_t *map, char **reqd)
163 {
164 struct utsname uts;
165 nsc_release_t *mp;
166 const char *sep = ", ";
167 char *cp, *tofree, *last;
168 int rc;
169
170 if (reqd)
171 *reqd = NULL;
172
173 if (build_rel == NULL || *build_rel == '\0') {
174 errno = EINVAL;
175 return (-1);
176 }
177
178 /* assume that build_rel is the required release for now */
179 if (reqd)
180 *reqd = (char *)build_rel;
181
182 if (uname(&uts) < 0)
183 return (-1);
184
185 /* build release == runtime release is always acceptable */
186 if (strcmp(build_rel, uts.release) == 0)
187 return (TRUE);
188
189 if (map == NULL)
190 return (FALSE);
191
192 rc = FALSE;
193 tofree = NULL;
194
195 for (mp = map; mp->build != NULL && mp->runtime != NULL; mp++) {
196 if (strcmp(mp->build, build_rel) == 0) {
197 /*
198 * found an entry for this build release
199 * - search for a match in the runtime releases
200 */
201
202 /* reset reqd to this entry */
203 if (reqd)
204 *reqd = (char *)mp->runtime;
205
206 /*
207 * operate on a copy of the string since strtok
208 * is destructive.
209 */
210 tofree = cp = strdup(mp->runtime);
211 if (cp == NULL) {
212 errno = ENOMEM;
213 rc = -1;
214 break;
215 }
216
217 cp = strtok_r(cp, sep, &last);
218 while (cp != NULL) {
219 if (strcmp(cp, uts.release) == 0) {
220 rc = TRUE;
221 break;
222 }
223
224 cp = strtok_r(NULL, sep, &last);
225 }
226
227 break;
228 }
229 }
230
231 if (tofree)
232 free(tofree);
233
234 return (rc);
235 }
236
237
238 /*
239 * return the system id corresponding to name
240 *
241 * on error return -1 and set errno.
242 */
243 int
244 nsc_name_to_id(char *name, int *id)
245 {
246 ncall_node_t *nodes;
247 int rval = 0;
248 int nodecnt;
249 int slot;
250
251 *id = 0;
252
253 nodecnt = nsc_getcurrentnodes(&nodes);
254 if (nodecnt < 0) {
255 rval = -1;
256 } else {
257 for (slot = 0; slot < nodecnt; slot++) {
258 if (strcmp(name, nodes[slot].nc_nodename) == 0) {
259 *id = nodes[slot].nc_nodeid;
260 break;
261 }
262 }
263 if (slot >= nodecnt) {
264 errno = ENOENT;
265 rval = -1;
266 }
267 free(nodes);
268 }
269 return (rval);
270 }
271
272 /*
273 * return the node name corresponding to system id
274 *
275 * on error return -1 and set errno.
276 * The returned string has been strdup() and needs
277 * to be freed by the caller.
278 */
279 int
280 nsc_id_to_name(char **name, int id)
281 {
282 ncall_node_t *nodes;
283 int rval = 0;
284 int nodecnt;
285 int slot;
286 char *foundname;
287
288 *name = 0;
289 foundname = NULL;
290
291 nodecnt = nsc_getcurrentnodes(&nodes);
292 if (nodecnt < 0) {
293 rval = -1;
294 } else {
295 for (slot = 0; slot < nodecnt; slot++) {
296 if (nodes[slot].nc_nodeid == id) {
297 foundname = strdup(nodes[slot].nc_nodename);
298 if (foundname) {
299 *name = foundname;
300 } else {
301 errno = ENOMEM;
302 rval = -1;
303 }
304 break;
305 }
306 }
307 if (slot >= nodecnt) {
308 errno = ENOENT;
309 rval = -1;
310 }
311 free(nodes);
312 }
313 return (rval);
314 }