usr/src/cmd/fs.d/reparsed/reparsed.c

   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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * Reparsed daemon
  28  */
  29
  30 #include <stdio.h>
  31 #include <stdio_ext.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34 #include <signal.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38 #include <memory.h>
  39 #include <alloca.h>
  40 #include <ucontext.h>
  41 #include <errno.h>
  42 #include <syslog.h>
  43 #include <string.h>
  44 #include <strings.h>
  45 #include <door.h>
  46 #include <wait.h>
  47 #include <libintl.h>
  48 #include <locale.h>
  49 #include <sys/param.h>
  50 #include <sys/systeminfo.h>
  51 #include <sys/thread.h>
  52 #include <rpc/xdr.h>
  53 #include <priv.h>
  54 #include <sys/fs_reparse.h>
  55 #include <priv_utils.h>
  56 #include <rpcsvc/daemon_utils.h>
  57
  58 #define REPARSED_CMD_OPTS       "v"
  59 #define DOOR_RESULT_BUFSZ       (MAXPATHLEN + sizeof (reparsed_door_res_t))
  60 #define SAFETY_BUFFER           8*1024
  61
  62 static char *MyName;
  63 static int verbose = 0;
  64
  65 static int start_reparsed_svcs();
  66 static void daemonize(void);
  67 static void reparsed_door_call_error(int error, int buflen);
  68 static void reparsed_doorfunc(void *cookie, char *argp, size_t arg_size,
  69                         door_desc_t *dp, uint_t n_desc);
  70
  71 static void
  72 usage()
  73 {
  74         syslog(LOG_ERR, "Usage: %s", MyName);
  75         syslog(LOG_ERR, "\t[-v]\t\tverbose error messages)");
  76         exit(1);
  77 }
  78
  79 static void
  80 warn_hup(int i)
  81 {
  82         syslog(LOG_ERR, "SIGHUP received: ignored");
  83         (void) signal(SIGHUP, warn_hup);
  84 }
  85
  86 /*
  87  * Processing for daemonization
  88  */
  89 static void
  90 daemonize(void)
  91 {
  92         switch (fork()) {
  93         case -1:
  94                 syslog(LOG_ERR, "reparsed: can't fork - errno %d", errno);
  95                 exit(2);
  96                 /* NOTREACHED */
  97         case 0:         /* child */
  98                 break;
  99
 100         default:        /* parent */
 101                 _exit(0);
 102         }
 103         (void) chdir("/");
 104
 105         /*
 106          * Close stdin, stdout, and stderr.
 107          * Open again to redirect input+output
 108          */
 109         (void) close(0);
 110         (void) close(1);
 111         (void) close(2);
 112         (void) open("/dev/null", O_RDONLY);
 113         (void) open("/dev/null", O_WRONLY);
 114         (void) dup(1);
 115         (void) setsid();
 116 }
 117
 118 int
 119 main(int argc, char *argv[])
 120 {
 121         pid_t pid;
 122         int c, error;
 123         struct rlimit rlset;
 124         char *defval;
 125
 126         /*
 127          * There is no check for non-global zone and Trusted Extensions.
 128          * Reparsed works in both of these environments as long as the
 129          * services that use reparsed are supported.
 130          */
 131
 132         MyName = argv[0];
 133         if (geteuid() != 0) {
 134                 syslog(LOG_ERR, "%s must be run as root", MyName);
 135                 exit(1);
 136         }
 137
 138         while ((c = getopt(argc, argv, REPARSED_CMD_OPTS)) != EOF) {
 139                 switch (c) {
 140                 case 'v':
 141                         verbose++;
 142                         break;
 143                 default:
 144                         usage();
 145                 }
 146         }
 147
 148         daemonize();
 149         openlog(MyName, LOG_PID | LOG_NDELAY, LOG_DAEMON);
 150
 151         (void) _create_daemon_lock(REPARSED, DAEMON_UID, DAEMON_GID);
 152         (void) enable_extended_FILE_stdio(-1, -1);
 153         switch (_enter_daemon_lock(REPARSED)) {
 154         case 0:
 155                 break;
 156         case -1:
 157                 syslog(LOG_ERR, "Error locking for %s", REPARSED);
 158                 exit(2);
 159         default:
 160                 /* daemon was already running */
 161                 exit(0);
 162         }
 163
 164         (void) signal(SIGHUP, warn_hup);
 165
 166         /*
 167          * Make the process a privilege aware daemon.
 168          * Only "basic" privileges are required.
 169          *
 170          */
 171         if (__init_daemon_priv(PU_RESETGROUPS|PU_CLEARLIMITSET, 0, 0,
 172             (char *)NULL) == -1) {
 173                 syslog(LOG_ERR, "should be run with sufficient privileges");
 174                 exit(3);
 175         }
 176
 177         /*
 178          * Clear basic privileges not required by reparsed.
 179          */
 180         __fini_daemon_priv(PRIV_PROC_FORK, PRIV_PROC_EXEC, PRIV_PROC_SESSION,
 181             PRIV_FILE_LINK_ANY, PRIV_PROC_INFO, (char *)NULL);
 182
 183         return (start_reparsed_svcs());
 184 }
 185
 186 static void
 187 reparsed_door_call_error(int error, int buflen)
 188 {
 189         reparsed_door_res_t rpd_res;
 190
 191         memset(&rpd_res, 0, sizeof (reparsed_door_res_t));
 192         rpd_res.res_status = error;
 193         rpd_res.res_len = buflen;
 194         door_return((char *)&rpd_res, sizeof (reparsed_door_res_t), NULL, 0);
 195
 196         (void) door_return(NULL, 0, NULL, 0);
 197         /* NOTREACHED */
 198 }
 199
 200 /*
 201  *  reparsed_doorfunc
 202  *
 203  *  argp:  "service_type:service_data" string
 204  *  dp & n_desc: not used.
 205  */
 206 static void
 207 reparsed_doorfunc(void *cookie, char *argp, size_t arg_size,
 208     door_desc_t *dp, uint_t n_desc)
 209 {
 210         int err;
 211         size_t bufsz;
 212         char *svc_type, *svc_data;
 213         char *cp, *buf, *sbuf, res_buf[DOOR_RESULT_BUFSZ];
 214         reparsed_door_res_t *resp;
 215
 216         if ((argp == NULL) || (arg_size == 0)) {
 217                 reparsed_door_call_error(EINVAL, 0);
 218                 /* NOTREACHED */
 219         }
 220
 221         if (verbose)
 222                 syslog(LOG_NOTICE, "reparsed_door: [%s, %d]", argp, arg_size);
 223
 224         if ((svc_type = strdup(argp)) == NULL) {
 225                 reparsed_door_call_error(ENOMEM, 0);
 226                 /* NOTREACHED */
 227         }
 228
 229         /*
 230          * Door argument string comes in "service_type:service_data" format.
 231          * Need to break it into separate "service_type" and "service_data"
 232          * string before passing them to reparse_deref() to process them.
 233          */
 234         if ((cp = strchr(svc_type, ':')) == NULL) {
 235                 free(svc_type);
 236                 reparsed_door_call_error(EINVAL, 0);
 237                 /* NOTREACHED */
 238         }
 239         *cp++ = '\0';
 240         svc_data = cp;
 241
 242         /*
 243          * Setup buffer for reparse_deref(). 'bufsz' is the actual
 244          * buffer size to hold the result returned by reparse_deref().
 245          */
 246         resp = (reparsed_door_res_t *)res_buf;
 247         buf = resp->res_data;
 248         bufsz = sizeof (res_buf) - sizeof (reparsed_door_res_t);
 249
 250         /*
 251          * reparse_deref() calls the service type plugin library to process
 252          * the service data. The plugin library function should understand
 253          * the context of the service data and should be the one to XDR the
 254          * results before returning it to the caller.
 255          */
 256         err = reparse_deref(svc_type, svc_data, buf, &bufsz);
 257
 258         if (verbose)
 259                 syslog(LOG_NOTICE,
 260                     "reparsed_deref(svc_type: %s, data: %s, size: %d) -> %d",
 261                     svc_type, svc_data, bufsz, err);
 262
 263         switch (err) {
 264         case 0:
 265                 break;
 266
 267         case EOVERFLOW:
 268                 /*
 269                  * bufsz was returned with size needed by reparse_deref().
 270                  *
 271                  * We cannot use malloc() here because door_return() never
 272                  * returns, and memory allocated by malloc() would get leaked.
 273                  */
 274                 sbuf = alloca(bufsz + sizeof (reparsed_door_res_t));
 275                 if (sbuf == NULL || stack_inbounds(buf) == 0 ||
 276                     stack_inbounds(buf + sizeof (reparsed_door_res_t) +
 277                     SAFETY_BUFFER - 1) == 0) {
 278                         free(svc_type);
 279                         reparsed_door_call_error(ENOMEM, 0);
 280                         /* NOTREACHED */
 281                 }
 282
 283                 resp = (reparsed_door_res_t *)sbuf;
 284                 if ((err = reparse_deref(svc_type, svc_data, resp->res_data,
 285                     &bufsz)) == 0)
 286                         break;
 287
 288                 /* fall through */
 289
 290         default:
 291                 free(svc_type);
 292                 reparsed_door_call_error(err, 0);
 293                 /* NOTREACHED */
 294         }
 295
 296         free(svc_type);
 297
 298         if (verbose)
 299                 syslog(LOG_NOTICE, "reparsed_door_return <buf=%s> size=%d",
 300                     buf, bufsz);
 301
 302         resp->res_status = 0;
 303         resp->res_len = bufsz;
 304         (void) door_return((char *)resp, bufsz + sizeof (reparsed_door_res_t),
 305             NULL, 0);
 306
 307         (void) door_return(NULL, 0, NULL, 0);
 308         /* NOTREACHED */
 309 }
 310
 311 static int
 312 start_reparsed_svcs()
 313 {
 314         int doorfd;
 315         int dfd;
 316
 317         if ((doorfd = door_create(reparsed_doorfunc, NULL,
 318             DOOR_REFUSE_DESC|DOOR_NO_CANCEL)) == -1) {
 319                 syslog(LOG_ERR, "Unable to create door");
 320                 return (1);
 321         }
 322
 323         /*
 324          * Create a file system path for the door
 325          */
 326         if ((dfd = open(REPARSED_DOOR, O_RDWR|O_CREAT|O_TRUNC,
 327             S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1) {
 328                 syslog(LOG_ERR, "unable to open %s", REPARSED_DOOR);
 329                 (void) close(doorfd);
 330                 return (1);
 331         }
 332
 333         /*
 334          * Clean up any stale associations
 335          */
 336         (void) fdetach(REPARSED_DOOR);
 337
 338         /*
 339          * Register in the kernel namespace for door_ki_open().
 340          */
 341         if (fattach(doorfd, REPARSED_DOOR) == -1) {
 342                 syslog(LOG_ERR, "Unable to fattach door %s", REPARSED_DOOR);
 343                 (void) close(doorfd);
 344                 (void) close(dfd);
 345                 return (1);
 346         }
 347         (void) close(dfd);
 348
 349         /*
 350          * Wait for incoming calls
 351          */
 352         /*CONSTCOND*/
 353         while (1)
 354                 (void) pause();
 355
 356         syslog(LOG_ERR, "Door server exited");
 357         return (10);
 358 }