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/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_BOOT2_MACHDEP, 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 = kmalloc(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     kfree(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 = kmalloc(sizeof(struct varsyment), M_VARSYM, M_WAITOK|M_ZERO);
 405         sym = kmalloc(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             kfree(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         kfree(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 = kmalloc(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, &copy->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         kfree(ve, M_VARSYM);
 473     }
 474     vss->vx_setsize = 0;
 475 }
 476