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 } 359