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 <unistd.h>
30 #include <strings.h>
31 #include <string.h>
32 #include <dirent.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <sys/param.h>
36 #include <sys/errno.h>
37 #include <limits.h>
38 #include <libnvpair.h>
39 #include <dlfcn.h>
40 #include <libintl.h>
41 #include <sys/systeminfo.h>
42 #include <sys/fs_reparse.h>
43 #include "rp_plugin.h"
44
45 #define MAXISALEN 257 /* based on sysinfo(2) man page */
46
47 static rp_proto_handle_t rp_proto_handle;
48 static rp_proto_plugin_t *rp_proto_list;
49
50 int rp_plugin_init(void);
51 static void proto_plugin_fini(void);
52 static rp_plugin_ops_t *rp_find_protocol(const char *svctype);
53
54 extern int errno;
55 static int rp_plugin_inited = 0;
56
57 /*
58 * reparse_create()
59 *
60 * Create a symlink at the specified 'path' as a reparse point.
61 * This function will fail if path refers to an existing file system
62 * object or an object named string already exists at the given path.
63 *
64 * return 0 if ok else return error code.
65 */
66 int
67 reparse_create(const char *path, const char *data)
68 {
69 int err;
70 struct stat sbuf;
71
72 if (path == NULL || data == NULL)
73 return (EINVAL);
74
75 if ((err = reparse_validate(data)) != 0)
76 return (err);
77
78 /* check if object exists */
79 if (lstat(path, &sbuf) == 0)
80 return (EEXIST);
81
82 return (symlink(data, path) ? errno : 0);
83 }
84
85 /*
86 * reparse_unparse()
87 *
88 * Convert an nvlist back to a string format suitable to write
89 * to the reparse point symlink body. The string returned is in
90 * allocated memory and must be freed by the caller.
91 *
92 * return 0 if ok else return error code.
93 */
94 int
95 reparse_unparse(nvlist_t *nvl, char **stringp)
96 {
97 int err, buflen;
98 char *buf, *stype, *val;
99 nvpair_t *curr;
100
101 if (nvl == NULL || stringp == NULL ||
102 ((curr = nvlist_next_nvpair(nvl, NULL)) == NULL))
103 return (EINVAL);
104
105 buflen = SYMLINK_MAX;
106 if ((buf = malloc(buflen)) == NULL)
107 return (ENOMEM);
108
109 err = 0;
110 (void) snprintf(buf, buflen, "%s", FS_REPARSE_TAG_STR);
111 while (curr != NULL) {
112 if (!(stype = nvpair_name(curr))) {
113 err = EINVAL;
114 break;
115 }
116 if ((strlcat(buf, FS_TOKEN_START_STR, buflen) >= buflen) ||
117 (strlcat(buf, stype, buflen) >= buflen) ||
118 (strlcat(buf, ":", buflen) >= buflen) ||
119 (nvpair_value_string(curr, &val) != 0) ||
120 (strlcat(buf, val, buflen) >= buflen) ||
121 (strlcat(buf, FS_TOKEN_END_STR, buflen) >= buflen)) {
122 err = E2BIG;
123 break;
124 }
125 curr = nvlist_next_nvpair(nvl, curr);
126 }
127 if (err != 0) {
128 free(buf);
129 return (err);
130 }
131 if (strlcat(buf, FS_REPARSE_TAG_END_STR, buflen) >= buflen) {
132 free(buf);
133 return (E2BIG);
134 }
135
136 *stringp = buf;
137 return (0);
138 }
139
140 /*
141 * reparse_deref()
142 *
143 * Accepts the service-specific item from the reparse point and returns
144 * the service-specific data requested. The caller specifies the size
145 * of the buffer provided via *bufsz.
146 *
147 * if ok return 0 and *bufsz is updated to contain the actual length of
148 * the returned results, else return error code. If the error code is
149 * EOVERFLOW; results do not fit in the buffer, *bufsz will be updated
150 * to contain the number of bytes needed to hold the results.
151 */
152 int
153 reparse_deref(const char *svc_type, const char *svc_data, char *buf,
154 size_t *bufsz)
155 {
156 rp_plugin_ops_t *ops;
157
158 if ((svc_type == NULL) || (svc_data == NULL) || (buf == NULL) ||
159 (bufsz == NULL))
160 return (EINVAL);
161
162 ops = rp_find_protocol(svc_type);
163 if ((ops != NULL) && (ops->rpo_deref != NULL))
164 return (ops->rpo_deref(svc_type, svc_data, buf, bufsz));
165
166 /* no plugin, return error */
167 return (ENOTSUP);
168 }
169
170 /*
171 * reparse_delete()
172 *
173 * Delete a reparse point at a given pathname. It will fail if
174 * a reparse point does not exist at the given path or the pathname
175 * is not a symlink.
176 *
177 * return 0 if ok else return error code.
178 */
179 int
180 reparse_delete(const char *path)
181 {
182 struct stat sbuf;
183
184 if (path == NULL)
185 return (EINVAL);
186
187 /* check if object exists */
188 if (lstat(path, &sbuf) != 0)
189 return (errno);
190
191 if ((sbuf.st_mode & S_IFLNK) != S_IFLNK)
192 return (EINVAL);
193
194 return (unlink(path) ? errno : 0);
195 }
196
197 /*
198 * reparse_add()
199 *
200 * Add a service type entry to a nvlist with a copy of svc_data,
201 * replacing one of the same type if already present.
202 *
203 * return 0 if ok else return error code.
204 */
205 int
206 reparse_add(nvlist_t *nvl, const char *svc_type, const char *svc_data)
207 {
208 int err;
209 char *buf;
210 size_t bufsz;
211 rp_plugin_ops_t *ops;
212
213 if ((nvl == NULL) || (svc_type == NULL) || (svc_data == NULL))
214 return (EINVAL);
215
216 bufsz = SYMLINK_MAX; /* no need to mess around */
217 if ((buf = malloc(bufsz)) == NULL)
218 return (ENOMEM);
219
220 ops = rp_find_protocol(svc_type);
221 if ((ops != NULL) && (ops->rpo_form != NULL))
222 err = ops->rpo_form(svc_type, svc_data, buf, &bufsz);
223 else
224 err = ENOTSUP; /* no plugin */
225
226 if (err != 0) {
227 free(buf);
228 return (err);
229 }
230
231 err = nvlist_add_string(nvl, svc_type, buf);
232 free(buf);
233 return (err);
234 }
235
236 /*
237 * reparse_remove()
238 *
239 * Remove a service type entry from the nvlist, if present.
240 *
241 * return 0 if ok else return error code.
242 */
243 int
244 reparse_remove(nvlist_t *nvl, const char *svc_type)
245 {
246 if ((nvl == NULL) || (svc_type == NULL))
247 return (EINVAL);
248
249 return (nvlist_remove_all(nvl, svc_type));
250 }
251
252 /*
253 * Returns true if name is "." or "..", otherwise returns false.
254 */
255 static boolean_t
256 rp_is_dot_or_dotdot(const char *name)
257 {
258 if (*name != '.')
259 return (B_FALSE);
260
261 if (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))
262 return (B_TRUE);
263
264 return (B_FALSE);
265 }
266
267 static void
268 proto_plugin_fini()
269 {
270 rp_proto_plugin_t *p;
271
272 /*
273 * Protocols may call this framework during _fini
274 */
275 for (p = rp_proto_list; p != NULL; p = p->plugin_next) {
276 if (p->plugin_ops->rpo_fini)
277 p->plugin_ops->rpo_fini();
278 }
279 while ((p = rp_proto_list) != NULL) {
280 rp_proto_list = p->plugin_next;
281 if (p->plugin_handle != NULL)
282 (void) dlclose(p->plugin_handle);
283 free(p);
284 }
285
286 if (rp_proto_handle.rp_ops != NULL) {
287 free(rp_proto_handle.rp_ops);
288 rp_proto_handle.rp_ops = NULL;
289 }
290 rp_proto_handle.rp_num_proto = 0;
291 }
292
293 /*
294 * rp_plugin_init()
295 *
296 * Initialize the service type specific plugin modules.
297 * For each reparse service type, there should be a plugin library for it.
298 * This function walks /usr/lib/reparse directory for plugin libraries.
299 * For each plugin library found, initialize it and add it to the internal
300 * list of service type plugin. These are used for service type specific
301 * operations.
302 */
303 int
304 rp_plugin_init()
305 {
306 int err, ret = RP_OK;
307 char isa[MAXISALEN], dirpath[MAXPATHLEN], path[MAXPATHLEN];
308 int num_protos = 0;
309 rp_proto_handle_t *rp_hdl;
310 rp_proto_plugin_t *proto, *tmp;
311 rp_plugin_ops_t *plugin_ops;
312 struct stat st;
313 void *dlhandle;
314 DIR *dir;
315 struct dirent *dent;
316
317 #if defined(_LP64)
318 if (sysinfo(SI_ARCHITECTURE_64, isa, MAXISALEN) == -1)
319 isa[0] = '\0';
320 #else
321 isa[0] = '\0';
322 #endif
323
324 (void) snprintf(dirpath, MAXPATHLEN,
325 "%s/%s", RP_LIB_DIR, isa);
326
327 if ((dir = opendir(dirpath)) == NULL)
328 return (RP_NO_PLUGIN_DIR);
329
330 while ((dent = readdir(dir)) != NULL) {
331 if (rp_is_dot_or_dotdot(dent->d_name))
332 continue;
333
334 (void) snprintf(path, MAXPATHLEN,
335 "%s/%s", dirpath, dent->d_name);
336
337 /*
338 * If file doesn't exist, don't try to map it
339 */
340 if (stat(path, &st) < 0)
341 continue;
342 if ((dlhandle = dlopen(path, RTLD_FIRST|RTLD_LAZY)) == NULL)
343 continue;
344
345 plugin_ops = (rp_plugin_ops_t *)
346 dlsym(dlhandle, "rp_plugin_ops");
347 if (plugin_ops == NULL) {
348 (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
349 "Error in plugin ops for service type %s\n%s\n"),
350 dent->d_name, dlerror());
351 (void) dlclose(dlhandle);
352 continue;
353 }
354 proto = (rp_proto_plugin_t *)
355 calloc(1, sizeof (rp_proto_plugin_t));
356 if (proto == NULL) {
357 (void) dlclose(dlhandle);
358 (void) fprintf(stderr,
359 dgettext(TEXT_DOMAIN, "No memory for plugin %s\n"),
360 dent->d_name);
361 ret = RP_NO_MEMORY;
362 break;
363 }
364
365 proto->plugin_ops = plugin_ops;
366 proto->plugin_handle = dlhandle;
367 num_protos++;
368 proto->plugin_next = rp_proto_list;
369 rp_proto_list = proto;
370 }
371
372 (void) closedir(dir);
373
374 if ((num_protos == 0) && (ret == 0))
375 ret = RP_NO_PLUGIN;
376 /*
377 * There was an error, so cleanup prior to return of failure.
378 */
379 if (ret != RP_OK) {
380 proto_plugin_fini();
381 return (ret);
382 }
383
384 rp_proto_handle.rp_ops = (rp_plugin_ops_t **)calloc(num_protos,
385 sizeof (rp_plugin_ops_t *));
386 if (!rp_proto_handle.rp_ops) {
387 proto_plugin_fini();
388 return (RP_NO_MEMORY);
389 }
390
391 rp_hdl = &rp_proto_handle;
392 rp_hdl->rp_num_proto = 0;
393 for (tmp = rp_proto_list; rp_hdl->rp_num_proto < num_protos &&
394 tmp != NULL; tmp = tmp->plugin_next) {
395
396 err = RP_OK;
397 if (tmp->plugin_ops->rpo_init != NULL)
398 err = tmp->plugin_ops->rpo_init();
399 if (err != RP_OK)
400 continue;
401 rp_hdl->rp_ops[rp_hdl->rp_num_proto++] = tmp->plugin_ops;
402 }
403
404 return (rp_hdl->rp_num_proto > 0 ? RP_OK : RP_NO_PLUGIN);
405 }
406
407
408 /*
409 * find_protocol()
410 *
411 * Search the plugin list for the specified protocol and return the
412 * ops vector. return NULL if protocol is not defined.
413 */
414 static rp_plugin_ops_t *
415 rp_find_protocol(const char *svc_type)
416 {
417 int i;
418 rp_plugin_ops_t *ops = NULL;
419
420 if (svc_type == NULL)
421 return (NULL);
422
423 if (rp_plugin_inited == 0) {
424 if (rp_plugin_init() == RP_OK)
425 rp_plugin_inited = 1;
426 else
427 return (NULL);
428 }
429
430 for (i = 0; i < rp_proto_handle.rp_num_proto; i++) {
431 ops = rp_proto_handle.rp_ops[i];
432 if (ops->rpo_supports_svc(svc_type))
433 return (ops);
434
435 }
436 return (NULL);
437 }