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