1 /* 2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * $DragonFly: src/sys/kern/kern_varsym.c,v 1.7 2006/06/05 07:26:10 dillon Exp $ 35 */ 36 37 /* 38 * This module implements variable storage and management for variant 39 * symlinks. These variables may also be used for general purposes. 40 */ 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/ucred.h> 46 #include <sys/resourcevar.h> 47 #include <sys/proc.h> 48 #include <sys/jail.h> 49 #include <sys/queue.h> 50 #include <sys/sysctl.h> 51 #include <sys/malloc.h> 52 #include <sys/varsym.h> 53 #include <sys/sysproto.h> 54 55 MALLOC_DEFINE(M_VARSYM, "varsym", "variable sets for variant symlinks"); 56 57 struct varsymset varsymset_sys; 58 59 /* 60 * Initialize the variant symlink subsystem 61 */ 62 static void 63 varsym_sysinit(void *dummy) 64 { 65 varsymset_init(&varsymset_sys, NULL); 66 } 67 SYSINIT(announce, SI_SUB_INTRINSIC, SI_ORDER_FIRST, varsym_sysinit, NULL); 68 69 /* 70 * varsymreplace() - called from namei 71 * 72 * Do variant symlink variable substitution 73 */ 74 int 75 varsymreplace(char *cp, int linklen, int maxlen) 76 { 77 int rlen; 78 int xlen; 79 int nlen; 80 int i; 81 varsym_t var; 82 83 rlen = linklen; 84 while (linklen > 1) { 85 if (cp[0] == '$' && cp[1] == '{') { 86 for (i = 2; i < linklen; ++i) { 87 if (cp[i] == '}') 88 break; 89 } 90 if (i < linklen && 91 (var = varsymfind(VARSYM_ALL_MASK, cp + 2, i - 2)) != NULL 92 ) { 93 xlen = i + 1; /* bytes to strike */ 94 nlen = strlen(var->vs_data); /* bytes to add */ 95 if (linklen + nlen - xlen >= maxlen) { 96 varsymdrop(var); 97 return(-1); 98 } 99 KKASSERT(linklen >= xlen); 100 if (linklen != xlen) 101 bcopy(cp + xlen, cp + nlen, linklen - xlen); 102 bcopy(var->vs_data, cp, nlen); 103 linklen += nlen - xlen; /* new relative length */ 104 rlen += nlen - xlen; /* returned total length */ 105 cp += nlen; /* adjust past replacement */ 106 linklen -= nlen; /* adjust past replacement */ 107 maxlen -= nlen; /* adjust past replacement */ 108 } else { 109 /* 110 * It's ok if i points to the '}', it will simply be 111 * skipped. i could also have hit linklen. 112 */ 113 cp += i; 114 linklen -= i; 115 maxlen -= i; 116 } 117 } else { 118 ++cp; 119 --linklen; 120 --maxlen; 121 } 122 } 123 return(rlen); 124 } 125 126 /* 127 * varsym_set() system call 128 * 129 * (int level, const char *name, const char *data) 130 */ 131 int 132 sys_varsym_set(struct varsym_set_args *uap) 133 { 134 char name[MAXVARSYM_NAME]; 135 char *buf; 136 int error; 137 138 if ((error = copyinstr(uap->name, name, sizeof(name), NULL)) != 0) 139 goto done2; 140 buf = malloc(MAXVARSYM_DATA, M_TEMP, M_WAITOK); 141 if (uap->data && 142 (error = copyinstr(uap->data, buf, MAXVARSYM_DATA, NULL)) != 0) 143 { 144 goto done1; 145 } 146 switch(uap->level) { 147 case VARSYM_SYS: 148 if (curthread->td_proc != NULL && curthread->td_proc->p_ucred->cr_prison != NULL) 149 uap->level = VARSYM_PRISON; 150 case VARSYM_PRISON: 151 if (curthread->td_proc != NULL && 152 (error = suser_cred(curthread->td_proc->p_ucred, PRISON_ROOT)) != 0) 153 break; 154 /* fall through */ 155 case VARSYM_USER: 156 /* XXX check jail / implement per-jail user */ 157 /* fall through */ 158 case VARSYM_PROC: 159 if (uap->data) { 160 (void)varsymmake(uap->level, name, NULL); 161 error = varsymmake(uap->level, name, buf); 162 } else { 163 error = varsymmake(uap->level, name, NULL); 164 } 165 break; 166 } 167 done1: 168 free(buf, M_TEMP); 169 done2: 170 return(error); 171 } 172 173 /* 174 * varsym_get() system call 175 * 176 * (int mask, const char *wild, char *buf, int bufsize) 177 */ 178 int 179 sys_varsym_get(struct varsym_get_args *uap) 180 { 181 char wild[MAXVARSYM_NAME]; 182 varsym_t sym; 183 int error; 184 int dlen; 185 186 if ((error = copyinstr(uap->wild, wild, sizeof(wild), NULL)) != 0) 187 goto done; 188 sym = varsymfind(uap->mask, wild, strlen(wild)); 189 if (sym == NULL) { 190 error = ENOENT; 191 goto done; 192 } 193 dlen = strlen(sym->vs_data); 194 if (dlen < uap->bufsize) { 195 copyout(sym->vs_data, uap->buf, dlen + 1); 196 } else if (uap->bufsize) { 197 copyout("", uap->buf, 1); 198 } 199 uap->sysmsg_result = dlen + 1; 200 varsymdrop(sym); 201 done: 202 return(error); 203 } 204 205 /* 206 * varsym_list() system call 207 * 208 * (int level, char *buf, int maxsize, int *marker) 209 */ 210 int 211 sys_varsym_list(struct varsym_list_args *uap) 212 { 213 struct varsymset *vss; 214 struct varsyment *ve; 215 struct proc *p; 216 int i; 217 int error; 218 int bytes; 219 int earlyterm; 220 int marker; 221 222 /* 223 * Get the marker from userspace. 224 */ 225 if ((error = copyin(uap->marker, &marker, sizeof(marker))) != 0) 226 goto done; 227 228 /* 229 * Figure out the varsym set. 230 */ 231 p = curproc; 232 vss = NULL; 233 234 switch (uap->level) { 235 case VARSYM_PROC: 236 if (p) 237 vss = &p->p_varsymset; 238 break; 239 case VARSYM_USER: 240 if (p) 241 vss = &p->p_ucred->cr_uidinfo->ui_varsymset; 242 break; 243 case VARSYM_SYS: 244 vss = &varsymset_sys; 245 break; 246 case VARSYM_PRISON: 247 if (p != NULL && p->p_ucred->cr_prison != NULL) 248 vss = &p->p_ucred->cr_prison->pr_varsymset; 249 break; 250 } 251 if (vss == NULL) { 252 error = EINVAL; 253 goto done; 254 } 255 256 /* 257 * Loop through the variables and dump them to uap->buf 258 */ 259 i = 0; 260 bytes = 0; 261 earlyterm = 0; 262 263 TAILQ_FOREACH(ve, &vss->vx_queue, ve_entry) { 264 varsym_t sym = ve->ve_sym; 265 int namelen = strlen(sym->vs_name); 266 int datalen = strlen(sym->vs_data); 267 int totlen = namelen + datalen + 2; 268 269 /* 270 * Skip to our index point 271 */ 272 if (i < marker) { 273 ++i; 274 continue; 275 } 276 277 /* 278 * Stop if there is insufficient space in the user buffer. 279 * If we haven't stored anything yet return EOVERFLOW. 280 * Note that the marker index (i) does not change. 281 */ 282 if (bytes + totlen > uap->maxsize) { 283 if (bytes == 0) 284 error = EOVERFLOW; 285 earlyterm = 1; 286 break; 287 } 288 289 error = copyout(sym->vs_name, uap->buf + bytes, namelen + 1); 290 if (error == 0) { 291 bytes += namelen + 1; 292 error = copyout(sym->vs_data, uap->buf + bytes, datalen + 1); 293 if (error == 0) 294 bytes += datalen + 1; 295 else 296 bytes -= namelen + 1; /* revert if error */ 297 } 298 if (error) { 299 earlyterm = 1; 300 break; 301 } 302 ++i; 303 } 304 305 /* 306 * Save the marker back. If no error occured and earlyterm is clear 307 * the marker is set to -1 indicating that the variable list has been 308 * exhausted. If no error occured the number of bytes loaded into 309 * the buffer will be returned, otherwise the syscall code returns -1. 310 */ 311 if (error == 0 && earlyterm == 0) 312 marker = -1; 313 else 314 marker = i; 315 if (error == 0) 316 error = copyout(&marker, uap->marker, sizeof(marker)); 317 uap->sysmsg_result = bytes; 318 done: 319 return(error); 320 } 321 322 /* 323 * Lookup a variant symlink. XXX use a hash table. 324 */ 325 static 326 struct varsyment * 327 varsymlookup(struct varsymset *vss, const char *name, int namelen) 328 { 329 struct varsyment *ve; 330 331 TAILQ_FOREACH(ve, &vss->vx_queue, ve_entry) { 332 varsym_t var = ve->ve_sym; 333 if (var->vs_namelen == namelen && 334 bcmp(name, var->vs_name, namelen) == 0 335 ) { 336 return(ve); 337 } 338 } 339 return(NULL); 340 } 341 342 varsym_t 343 varsymfind(int mask, const char *name, int namelen) 344 { 345 struct proc *p = curproc; 346 struct varsyment *ve = NULL; 347 varsym_t sym; 348 349 if ((mask & (VARSYM_PROC_MASK|VARSYM_USER_MASK)) && p != NULL) { 350 if (mask & VARSYM_PROC_MASK) 351 ve = varsymlookup(&p->p_varsymset, name, namelen); 352 if (ve == NULL && (mask & VARSYM_USER_MASK)) 353 ve = varsymlookup(&p->p_ucred->cr_uidinfo->ui_varsymset, name, namelen); 354 } 355 if (ve == NULL && (mask & VARSYM_SYS_MASK)) { 356 if (p != NULL && p->p_ucred->cr_prison) 357 ve = varsymlookup(&p->p_ucred->cr_prison->pr_varsymset, name, namelen); 358 else 359 ve = varsymlookup(&varsymset_sys, name, namelen); 360 } 361 if (ve) { 362 sym = ve->ve_sym; 363 ++sym->vs_refs; 364 return(sym); 365 } else { 366 return(NULL); 367 } 368 } 369 370 int 371 varsymmake(int level, const char *name, const char *data) 372 { 373 struct varsymset *vss = NULL; 374 struct varsyment *ve; 375 struct proc *p = curproc; 376 varsym_t sym; 377 int namelen = strlen(name); 378 int datalen; 379 int error; 380 381 switch(level) { 382 case VARSYM_PROC: 383 if (p) 384 vss = &p->p_varsymset; 385 break; 386 case VARSYM_USER: 387 if (p) 388 vss = &p->p_ucred->cr_uidinfo->ui_varsymset; 389 break; 390 case VARSYM_SYS: 391 vss = &varsymset_sys; 392 break; 393 case VARSYM_PRISON: 394 if (p != NULL && p->p_ucred->cr_prison != NULL) 395 vss = &p->p_ucred->cr_prison->pr_varsymset; 396 break; 397 } 398 if (vss == NULL) { 399 error = EINVAL; 400 } else if (data && vss->vx_setsize >= MAXVARSYM_SET) { 401 error = E2BIG; 402 } else if (data) { 403 datalen = strlen(data); 404 ve = malloc(sizeof(struct varsyment), M_VARSYM, M_WAITOK|M_ZERO); 405 sym = malloc(sizeof(struct varsym) + namelen + datalen + 2, M_VARSYM, M_WAITOK); 406 ve->ve_sym = sym; 407 sym->vs_refs = 1; 408 sym->vs_namelen = namelen; 409 sym->vs_name = (char *)(sym + 1); 410 sym->vs_data = sym->vs_name + namelen + 1; 411 strcpy(sym->vs_name, name); 412 strcpy(sym->vs_data, data); 413 TAILQ_INSERT_TAIL(&vss->vx_queue, ve, ve_entry); 414 vss->vx_setsize += sizeof(struct varsyment) + sizeof(struct varsym) + namelen + datalen + 8; 415 error = 0; 416 } else { 417 if ((ve = varsymlookup(vss, name, namelen)) != NULL) { 418 TAILQ_REMOVE(&vss->vx_queue, ve, ve_entry); 419 vss->vx_setsize -= sizeof(struct varsyment) + sizeof(struct varsym) + namelen + strlen(ve->ve_sym->vs_data) + 8; 420 varsymdrop(ve->ve_sym); 421 free(ve, M_VARSYM); 422 error = 0; 423 } else { 424 error = ENOENT; 425 } 426 } 427 return(error); 428 } 429 430 void 431 varsymdrop(varsym_t sym) 432 { 433 KKASSERT(sym->vs_refs > 0); 434 if (--sym->vs_refs == 0) { 435 free(sym, M_VARSYM); 436 } 437 } 438 439 static void 440 varsymdup(struct varsymset *vss, struct varsyment *ve) 441 { 442 struct varsyment *nve; 443 444 nve = malloc(sizeof(struct varsyment), M_VARSYM, M_WAITOK|M_ZERO); 445 nve->ve_sym = ve->ve_sym; 446 ++nve->ve_sym->vs_refs; 447 TAILQ_INSERT_TAIL(&vss->vx_queue, nve, ve_entry); 448 } 449 450 void 451 varsymset_init(struct varsymset *vss, struct varsymset *copy) 452 { 453 struct varsyment *ve; 454 455 TAILQ_INIT(&vss->vx_queue); 456 if (copy) { 457 TAILQ_FOREACH(ve, ©->vx_queue, ve_entry) { 458 varsymdup(vss, ve); 459 } 460 vss->vx_setsize = copy->vx_setsize; 461 } 462 } 463 464 void 465 varsymset_clean(struct varsymset *vss) 466 { 467 struct varsyment *ve; 468 469 while ((ve = TAILQ_FIRST(&vss->vx_queue)) != NULL) { 470 TAILQ_REMOVE(&vss->vx_queue, ve, ve_entry); 471 varsymdrop(ve->ve_sym); 472 free(ve, M_VARSYM); 473 } 474 vss->vx_setsize = 0; 475 } 476 477