sys/kern/kern_varsym.c

   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, &copy->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