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.9 2007/04/30 07:18:54 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/priv.h> 49 #include <sys/jail.h> 50 #include <sys/queue.h> 51 #include <sys/sysctl.h> 52 #include <sys/malloc.h> 53 #include <sys/varsym.h> 54 #include <sys/sysproto.h> 55 56 MALLOC_DEFINE(M_VARSYM, "varsym", "variable sets for variant symlinks"); 57 58 struct varsymset varsymset_sys; 59 60 /* 61 * Initialize the variant symlink subsystem 62 */ 63 static void 64 varsym_sysinit(void *dummy) 65 { 66 varsymset_init(&varsymset_sys, NULL); 67 } 68 SYSINIT(announce, SI_BOOT2_MACHDEP, SI_ORDER_FIRST, varsym_sysinit, NULL); 69 70 /* 71 * varsymreplace() - called from namei 72 * 73 * Do variant symlink variable substitution 74 */ 75 int 76 varsymreplace(char *cp, int linklen, int maxlen) 77 { 78 int rlen; 79 int xlen; 80 int nlen; 81 int i; 82 varsym_t var; 83 84 rlen = linklen; 85 while (linklen > 1) { 86 if (cp[0] == '$' && cp[1] == '{') { 87 for (i = 2; i < linklen; ++i) { 88 if (cp[i] == '}') 89 break; 90 } 91 if (i < linklen && 92 (var = varsymfind(VARSYM_ALL_MASK, cp + 2, i - 2)) != NULL 93 ) { 94 xlen = i + 1; /* bytes to strike */ 95 nlen = strlen(var->vs_data); /* bytes to add */ 96 if (linklen + nlen - xlen >= maxlen) { 97 varsymdrop(var); 98 return(-1); 99 } 100 KKASSERT(linklen >= xlen); 101 if (linklen != xlen) 102 bcopy(cp + xlen, cp + nlen, linklen - xlen); 103 bcopy(var->vs_data, cp, nlen); 104 linklen += nlen - xlen; /* new relative length */ 105 rlen += nlen - xlen; /* returned total length */ 106 cp += nlen; /* adjust past replacement */ 107 linklen -= nlen; /* adjust past replacement */ 108 maxlen -= nlen; /* adjust past replacement */ 109 } else { 110 /* 111 * It's ok if i points to the '}', it will simply be 112 * skipped. i could also have hit linklen. 113 */ 114 cp += i; 115 linklen -= i; 116 maxlen -= i; 117 } 118 } else { 119 ++cp; 120 --linklen; 121 --maxlen; 122 } 123 } 124 return(rlen); 125 } 126 127 /* 128 * varsym_set() system call 129 * 130 * (int level, const char *name, const char *data) 131 */ 132 int 133 sys_varsym_set(struct varsym_set_args *uap) 134 { 135 char name[MAXVARSYM_NAME]; 136 char *buf; 137 int error; 138 139 if ((error = copyinstr(uap->name, name, sizeof(name), NULL)) != 0) 140 goto done2; 141 buf = kmalloc(MAXVARSYM_DATA, M_TEMP, M_WAITOK); 142 if (uap->data && 143 (error = copyinstr(uap->data, buf, MAXVARSYM_DATA, NULL)) != 0) 144 { 145 goto done1; 146 } 147 switch(uap->level) { 148 case VARSYM_SYS: 149 if (curthread->td_proc != NULL && curthread->td_proc->p_ucred->cr_prison != NULL) 150 uap->level = VARSYM_PRISON; 151 case VARSYM_PRISON: 152 if (curthread->td_proc != NULL && 153 (error = priv_check_cred(curthread->td_proc->p_ucred, PRIV_ROOT, PRISON_ROOT)) != 0) 154 break; 155 /* fall through */ 156 case VARSYM_USER: 157 /* XXX check jail / implement per-jail user */ 158 /* fall through */ 159 case VARSYM_PROC: 160 if (uap->data) { 161 (void)varsymmake(uap->level, name, NULL); 162 error = varsymmake(uap->level, name, buf); 163 } else { 164 error = varsymmake(uap->level, name, NULL); 165 } 166 break; 167 } 168 done1: 169 kfree(buf, M_TEMP); 170 done2: 171 return(error); 172 } 173 174 /* 175 * varsym_get() system call 176 * 177 * (int mask, const char *wild, char *buf, int bufsize) 178 */ 179 int 180 sys_varsym_get(struct varsym_get_args *uap) 181 { 182 char wild[MAXVARSYM_NAME]; 183 varsym_t sym; 184 int error; 185 int dlen; 186 187 if ((error = copyinstr(uap->wild, wild, sizeof(wild), NULL)) != 0) 188 goto done; 189 sym = varsymfind(uap->mask, wild, strlen(wild)); 190 if (sym == NULL) { 191 error = ENOENT; 192 goto done; 193 } 194 dlen = strlen(sym->vs_data); 195 if (dlen < uap->bufsize) { 196 copyout(sym->vs_data, uap->buf, dlen + 1); 197 } else if (uap->bufsize) { 198 copyout("", uap->buf, 1); 199 } 200 uap->sysmsg_result = dlen + 1; 201 varsymdrop(sym); 202 done: 203 return(error); 204 } 205 206 /* 207 * varsym_list() system call 208 * 209 * (int level, char *buf, int maxsize, int *marker) 210 */ 211 int 212 sys_varsym_list(struct varsym_list_args *uap) 213 { 214 struct varsymset *vss; 215 struct varsyment *ve; 216 struct proc *p; 217 int i; 218 int error; 219 int bytes; 220 int earlyterm; 221 int marker; 222 223 /* 224 * Get the marker from userspace. 225 */ 226 if ((error = copyin(uap->marker, &marker, sizeof(marker))) != 0) 227 goto done; 228 229 /* 230 * Figure out the varsym set. 231 */ 232 p = curproc; 233 vss = NULL; 234 235 switch (uap->level) { 236 case VARSYM_PROC: 237 if (p) 238 vss = &p->p_varsymset; 239 break; 240 case VARSYM_USER: 241 if (p) 242 vss = &p->p_ucred->cr_uidinfo->ui_varsymset; 243 break; 244 case VARSYM_SYS: 245 vss = &varsymset_sys; 246 break; 247 case VARSYM_PRISON: 248 if (p != NULL && p->p_ucred->cr_prison != NULL) 249 vss = &p->p_ucred->cr_prison->pr_varsymset; 250 break; 251 } 252 if (vss == NULL) { 253 error = EINVAL; 254 goto done; 255 } 256 257 /* 258 * Loop through the variables and dump them to uap->buf 259 */ 260 i = 0; 261 bytes = 0; 262 earlyterm = 0; 263 264 TAILQ_FOREACH(ve, &vss->vx_queue, ve_entry) { 265 varsym_t sym = ve->ve_sym; 266 int namelen = strlen(sym->vs_name); 267 int datalen = strlen(sym->vs_data); 268 int totlen = namelen + datalen + 2; 269 270 /* 271 * Skip to our index point 272 */ 273 if (i < marker) { 274 ++i; 275 continue; 276 } 277 278 /* 279 * Stop if there is insufficient space in the user buffer. 280 * If we haven't stored anything yet return EOVERFLOW. 281 * Note that the marker index (i) does not change. 282 */ 283 if (bytes + totlen > uap->maxsize) { 284 if (bytes == 0) 285 error = EOVERFLOW; 286 earlyterm = 1; 287 break; 288 } 289 290 error = copyout(sym->vs_name, uap->buf + bytes, namelen + 1); 291 if (error == 0) { 292 bytes += namelen + 1; 293 error = copyout(sym->vs_data, uap->buf + bytes, datalen + 1); 294 if (error == 0) 295 bytes += datalen + 1; 296 else 297 bytes -= namelen + 1; /* revert if error */ 298 } 299 if (error) { 300 earlyterm = 1; 301 break; 302 } 303 ++i; 304 } 305 306 /* 307 * Save the marker back. If no error occured and earlyterm is clear 308 * the marker is set to -1 indicating that the variable list has been 309 * exhausted. If no error occured the number of bytes loaded into 310 * the buffer will be returned, otherwise the syscall code returns -1. 311 */ 312 if (error == 0 && earlyterm == 0) 313 marker = -1; 314 else 315 marker = i; 316 if (error == 0) 317 error = copyout(&marker, uap->marker, sizeof(marker)); 318 uap->sysmsg_result = bytes; 319 done: 320 return(error); 321 } 322 323 /* 324 * Lookup a variant symlink. XXX use a hash table. 325 */ 326 static 327 struct varsyment * 328 varsymlookup(struct varsymset *vss, const char *name, int namelen) 329 { 330 struct varsyment *ve; 331 332 TAILQ_FOREACH(ve, &vss->vx_queue, ve_entry) { 333 varsym_t var = ve->ve_sym; 334 if (var->vs_namelen == namelen && 335 bcmp(name, var->vs_name, namelen) == 0 336 ) { 337 return(ve); 338 } 339 } 340 return(NULL); 341 } 342 343 varsym_t 344 varsymfind(int mask, const char *name, int namelen) 345 { 346 struct proc *p = curproc; 347 struct varsyment *ve = NULL; 348 varsym_t sym; 349 350 if ((mask & (VARSYM_PROC_MASK|VARSYM_USER_MASK)) && p != NULL) { 351 if (mask & VARSYM_PROC_MASK) 352 ve = varsymlookup(&p->p_varsymset, name, namelen); 353 if (ve == NULL && (mask & VARSYM_USER_MASK)) 354 ve = varsymlookup(&p->p_ucred->cr_uidinfo->ui_varsymset, name, namelen); 355 } 356 if (ve == NULL && (mask & VARSYM_SYS_MASK)) { 357 if (p != NULL && p->p_ucred->cr_prison) 358 ve = varsymlookup(&p->p_ucred->cr_prison->pr_varsymset, name, namelen); 359 else 360 ve = varsymlookup(&varsymset_sys, name, namelen); 361 } 362 if (ve) { 363 sym = ve->ve_sym; 364 ++sym->vs_refs; 365 return(sym); 366 } else { 367 return(NULL); 368 } 369 } 370 371 int 372 varsymmake(int level, const char *name, const char *data) 373 { 374 struct varsymset *vss = NULL; 375 struct varsyment *ve; 376 struct proc *p = curproc; 377 varsym_t sym; 378 int namelen = strlen(name); 379 int datalen; 380 int error; 381 382 switch(level) { 383 case VARSYM_PROC: 384 if (p) 385 vss = &p->p_varsymset; 386 break; 387 case VARSYM_USER: 388 if (p) 389 vss = &p->p_ucred->cr_uidinfo->ui_varsymset; 390 break; 391 case VARSYM_SYS: 392 vss = &varsymset_sys; 393 break; 394 case VARSYM_PRISON: 395 if (p != NULL && p->p_ucred->cr_prison != NULL) 396 vss = &p->p_ucred->cr_prison->pr_varsymset; 397 break; 398 } 399 if (vss == NULL) { 400 error = EINVAL; 401 } else if (data && vss->vx_setsize >= MAXVARSYM_SET) { 402 error = E2BIG; 403 } else if (data) { 404 datalen = strlen(data); 405 ve = kmalloc(sizeof(struct varsyment), M_VARSYM, M_WAITOK|M_ZERO); 406 sym = kmalloc(sizeof(struct varsym) + namelen + datalen + 2, M_VARSYM, M_WAITOK); 407 ve->ve_sym = sym; 408 sym->vs_refs = 1; 409 sym->vs_namelen = namelen; 410 sym->vs_name = (char *)(sym + 1); 411 sym->vs_data = sym->vs_name + namelen + 1; 412 strcpy(sym->vs_name, name); 413 strcpy(sym->vs_data, data); 414 TAILQ_INSERT_TAIL(&vss->vx_queue, ve, ve_entry); 415 vss->vx_setsize += sizeof(struct varsyment) + sizeof(struct varsym) + namelen + datalen + 8; 416 error = 0; 417 } else { 418 if ((ve = varsymlookup(vss, name, namelen)) != NULL) { 419 TAILQ_REMOVE(&vss->vx_queue, ve, ve_entry); 420 vss->vx_setsize -= sizeof(struct varsyment) + sizeof(struct varsym) + namelen + strlen(ve->ve_sym->vs_data) + 8; 421 varsymdrop(ve->ve_sym); 422 kfree(ve, M_VARSYM); 423 error = 0; 424 } else { 425 error = ENOENT; 426 } 427 } 428 return(error); 429 } 430 431 void 432 varsymdrop(varsym_t sym) 433 { 434 KKASSERT(sym->vs_refs > 0); 435 if (--sym->vs_refs == 0) { 436 kfree(sym, M_VARSYM); 437 } 438 } 439 440 static void 441 varsymdup(struct varsymset *vss, struct varsyment *ve) 442 { 443 struct varsyment *nve; 444 445 nve = kmalloc(sizeof(struct varsyment), M_VARSYM, M_WAITOK|M_ZERO); 446 nve->ve_sym = ve->ve_sym; 447 ++nve->ve_sym->vs_refs; 448 TAILQ_INSERT_TAIL(&vss->vx_queue, nve, ve_entry); 449 } 450 451 void 452 varsymset_init(struct varsymset *vss, struct varsymset *copy) 453 { 454 struct varsyment *ve; 455 456 TAILQ_INIT(&vss->vx_queue); 457 if (copy) { 458 TAILQ_FOREACH(ve, ©->vx_queue, ve_entry) { 459 varsymdup(vss, ve); 460 } 461 vss->vx_setsize = copy->vx_setsize; 462 } 463 } 464 465 void 466 varsymset_clean(struct varsymset *vss) 467 { 468 struct varsyment *ve; 469 470 while ((ve = TAILQ_FIRST(&vss->vx_queue)) != NULL) { 471 TAILQ_REMOVE(&vss->vx_queue, ve, ve_entry); 472 varsymdrop(ve->ve_sym); 473 kfree(ve, M_VARSYM); 474 } 475 vss->vx_setsize = 0; 476 } 477 478