sys/libprop/prop_kern.c

   1 /*      $NetBSD: prop_kern.c,v 1.17 2011/09/30 22:08:18 jym Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2006, 2009 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/types.h>
  33
  34 #include <libprop/proplib.h>
  35
  36 #if !defined(_KERNEL) && !defined(_STANDALONE)
  37 #include <sys/mman.h>
  38 #include <errno.h>
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42 #include <sys/ioctl.h>
  43
  44 static int
  45 _prop_object_externalize_to_pref(prop_object_t obj, struct plistref *pref,
  46                                  char **bufp)
  47 {
  48         char *buf;
  49
  50         switch (prop_object_type(obj)) {
  51         case PROP_TYPE_DICTIONARY:
  52                 buf = prop_dictionary_externalize(obj);
  53                 break;
  54         case PROP_TYPE_ARRAY:
  55                 buf = prop_array_externalize(obj);
  56                 break;
  57         default:
  58                 return (ENOTSUP);
  59         }
  60         if (buf == NULL) {
  61                 /* Assume we ran out of memory. */
  62                 return (ENOMEM);
  63         }
  64         pref->pref_plist = buf;
  65         pref->pref_len = strlen(buf) + 1;
  66
  67         *bufp = buf;
  68
  69         return (0);
  70 }
  71
  72 bool
  73 prop_array_externalize_to_pref(prop_array_t array, struct plistref *prefp)
  74 {
  75         char *buf;
  76         int rv;
  77
  78         rv = _prop_object_externalize_to_pref(array, prefp, &buf);
  79         if (rv != 0)
  80                 errno = rv;     /* pass up error value in errno */
  81         return (rv == 0);
  82 }
  83
  84 /*
  85  * prop_array_externalize_to_pref --
  86  *      Externalize an array into a plistref for sending to the kernel.
  87  */
  88 int
  89 prop_array_send_syscall(prop_array_t array, struct plistref *prefp)
  90 {
  91         if (prop_array_externalize_to_pref(array, prefp))
  92                 return 0;
  93         else
  94                 return errno;
  95 }
  96
  97 bool
  98 prop_dictionary_externalize_to_pref(prop_dictionary_t dict,
  99                                     struct plistref *prefp)
 100 {
 101         char *buf;
 102         int rv;
 103
 104         rv = _prop_object_externalize_to_pref(dict, prefp, &buf);
 105         if (rv != 0)
 106                 errno = rv;     /* pass up error value in errno */
 107         return (rv == 0);
 108 }
 109
 110 /*
 111  * prop_dictionary_externalize_to_pref --
 112  *      Externalize an dictionary into a plistref for sending to the kernel.
 113  */
 114 int
 115 prop_dictionary_send_syscall(prop_dictionary_t dict,
 116                              struct plistref *prefp)
 117 {
 118         if (prop_dictionary_externalize_to_pref(dict, prefp))
 119                 return 0;
 120         else
 121                 return errno;
 122 }
 123
 124 static int
 125 _prop_object_send_ioctl(prop_object_t obj, int fd, unsigned long cmd)
 126 {
 127         struct plistref pref;
 128         char *buf;
 129         int error;
 130
 131         error = _prop_object_externalize_to_pref(obj, &pref, &buf);
 132         if (error)
 133                 return (error);
 134
 135         if (ioctl(fd, cmd, &pref) == -1)
 136                 error = errno;
 137         else
 138                 error = 0;
 139
 140         free(buf);
 141
 142         return (error);
 143 }
 144
 145 /*
 146  * prop_array_send_ioctl --
 147  *      Send an array to the kernel using the specified ioctl.
 148  */
 149 int
 150 prop_array_send_ioctl(prop_array_t array, int fd, unsigned long cmd)
 151 {
 152         int rv;
 153
 154         rv = _prop_object_send_ioctl(array, fd, cmd);
 155         if (rv != 0) {
 156                 errno = rv;     /* pass up error value in errno */
 157                 return rv;
 158         } else
 159                 return 0;
 160 }
 161
 162 /*
 163  * prop_dictionary_send_ioctl --
 164  *      Send a dictionary to the kernel using the specified ioctl.
 165  */
 166 int
 167 prop_dictionary_send_ioctl(prop_dictionary_t dict, int fd, unsigned long cmd)
 168 {
 169         int rv;
 170
 171         rv = _prop_object_send_ioctl(dict, fd, cmd);
 172         if (rv != 0) {
 173                 errno = rv;     /* pass up error value in errno */
 174                 return rv;
 175         } else
 176                 return 0;
 177 }
 178
 179 static int
 180 _prop_object_internalize_from_pref(const struct plistref *pref,
 181                                    prop_type_t type, prop_object_t *objp)
 182 {
 183         prop_object_t obj = NULL;
 184         char *buf;
 185         int error = 0;
 186
 187         if (pref->pref_len == 0) {
 188                 /*
 189                  * This should never happen; we should always get the XML
 190                  * for an empty dictionary if it's really empty.
 191                  */
 192                 error = EIO;
 193                 goto out;
 194         } else {
 195                 buf = pref->pref_plist;
 196                 buf[pref->pref_len - 1] = '\0'; /* extra insurance */
 197                 switch (type) {
 198                 case PROP_TYPE_DICTIONARY:
 199                         obj = prop_dictionary_internalize(buf);
 200                         break;
 201                 case PROP_TYPE_ARRAY:
 202                         obj = prop_array_internalize(buf);
 203                         break;
 204                 default:
 205                         error = ENOTSUP;
 206                 }
 207                 (void) munmap(buf, pref->pref_len);
 208                 if (obj == NULL && error == 0)
 209                         error = EIO;
 210         }
 211
 212  out:
 213         if (error == 0)
 214                 *objp = obj;
 215         return (error);
 216 }
 217
 218 /*
 219  * prop_array_internalize_from_pref --
 220  *      Internalize a pref into a prop_array_t object.
 221  */
 222 bool
 223 prop_array_internalize_from_pref(const struct plistref *prefp,
 224                                  prop_array_t *arrayp)
 225 {
 226         int rv;
 227
 228         rv = _prop_object_internalize_from_pref(prefp, PROP_TYPE_ARRAY,
 229             (prop_object_t *)arrayp);
 230         if (rv != 0)
 231                 errno = rv;     /* pass up error value in errno */
 232         return (rv == 0);
 233 }
 234
 235 /*
 236  * prop_array_recv_syscall --
 237  *      Internalize an array received from the kernel as pref.
 238  */
 239 int
 240 prop_array_recv_syscall(const struct plistref *prefp,
 241                         prop_array_t *arrayp)
 242 {
 243         if (prop_array_internalize_from_pref(prefp, arrayp))
 244                 return 0;
 245         else
 246                 return errno;
 247 }
 248
 249 /*
 250  * prop_dictionary_internalize_from_pref --
 251  *      Internalize a pref into a prop_dictionary_t object.
 252  */
 253 bool
 254 prop_dictionary_internalize_from_pref(const struct plistref *prefp,
 255                                       prop_dictionary_t *dictp)
 256 {
 257         int rv;
 258
 259         rv = _prop_object_internalize_from_pref(prefp, PROP_TYPE_DICTIONARY,
 260             (prop_object_t *)dictp);
 261         if (rv != 0)
 262                 errno = rv;     /* pass up error value in errno */
 263         return (rv == 0);
 264 }
 265
 266 /*
 267  * prop_dictionary_recv_syscall --
 268  *      Internalize a dictionary received from the kernel as pref.
 269  */
 270 int
 271 prop_dictionary_recv_syscall(const struct plistref *prefp,
 272                              prop_dictionary_t *dictp)
 273 {
 274         if (prop_dictionary_internalize_from_pref(prefp, dictp))
 275                 return 0;
 276         else
 277                 return errno;
 278 }
 279
 280
 281 /*
 282  * prop_array_recv_ioctl --
 283  *      Receive an array from the kernel using the specified ioctl.
 284  */
 285 int
 286 prop_array_recv_ioctl(int fd, unsigned long cmd, prop_array_t *arrayp)
 287 {
 288         int rv;
 289         struct plistref pref;
 290
 291         rv = ioctl(fd, cmd, &pref);
 292         if (rv == -1)
 293                 return errno;
 294
 295         rv = _prop_object_internalize_from_pref(&pref, PROP_TYPE_ARRAY,
 296                             (prop_object_t *)arrayp);
 297         if (rv != 0) {
 298                 errno = rv;     /* pass up error value in errno */
 299                 return rv;
 300         } else
 301                 return 0;
 302 }
 303
 304 /*
 305  * prop_dictionary_recv_ioctl --
 306  *      Receive a dictionary from the kernel using the specified ioctl.
 307  */
 308 int
 309 prop_dictionary_recv_ioctl(int fd, unsigned long cmd, prop_dictionary_t *dictp)
 310 {
 311         int rv;
 312         struct plistref pref;
 313
 314         rv = ioctl(fd, cmd, &pref);
 315         if (rv == -1)
 316                 return errno;
 317
 318         rv = _prop_object_internalize_from_pref(&pref, PROP_TYPE_DICTIONARY,
 319                             (prop_object_t *)dictp);
 320         if (rv != 0) {
 321                 errno = rv;     /* pass up error value in errno */
 322                 return rv;
 323         } else
 324                 return 0;
 325 }
 326
 327 /*
 328  * prop_dictionary_sendrecv_ioctl --
 329  *      Combination send/receive a dictionary to/from the kernel using
 330  *      the specified ioctl.
 331  */
 332 int
 333 prop_dictionary_sendrecv_ioctl(prop_dictionary_t dict, int fd,
 334                                unsigned long cmd, prop_dictionary_t *dictp)
 335 {
 336         struct plistref pref;
 337         char *buf;
 338         int error;
 339
 340         error = _prop_object_externalize_to_pref(dict, &pref, &buf);
 341         if (error != 0) {
 342                 errno = error;
 343                 return error;
 344         }
 345
 346         if (ioctl(fd, cmd, &pref) == -1)
 347                 error = errno;
 348         else
 349                 error = 0;
 350
 351         free(buf);
 352
 353         if (error != 0)
 354                 return error;
 355
 356         error = _prop_object_internalize_from_pref(&pref, PROP_TYPE_DICTIONARY,
 357                             (prop_object_t *)dictp);
 358         if (error != 0) {
 359                 errno = error;     /* pass up error value in errno */
 360                 return error;
 361         } else
 362                 return 0;
 363 }
 364 #endif /* !_KERNEL && !_STANDALONE */
 365
 366 #if defined(_KERNEL)
 367 #include <sys/param.h>
 368 #include <sys/mman.h>
 369 #include <sys/errno.h>
 370 #include <sys/malloc.h>
 371 #include <sys/systm.h>
 372 #include <sys/proc.h>
 373 #include <sys/resource.h>
 374 #include <sys/objcache.h>
 375 #include <sys/ioccom.h>
 376 #include <vm/vm.h>
 377 #include <vm/vm_extern.h>
 378 #include <vm/vm_param.h>
 379
 380 #include "prop_object_impl.h"
 381
 382 /* Arbitrary limit ioctl input to 64KB */
 383 unsigned int prop_object_copyin_limit = 65536;
 384
 385 static int
 386 _prop_object_copyin(const struct plistref *pref, const prop_type_t type,
 387                           prop_object_t *objp)
 388 {
 389         prop_object_t obj = NULL;
 390         char *buf;
 391         int error;
 392
 393         /*
 394          * Allocate an extra byte so we can guarantee NUL-termination.
 395          *
 396          * Allow malloc to fail in case pmap would be exhausted.
 397          */
 398         buf = kmalloc(pref->pref_len + 1, M_TEMP, M_WAITOK);
 399         error = copyin(pref->pref_plist, buf, pref->pref_len);
 400         if (error) {
 401                 kfree(buf, M_TEMP);
 402                 return (error);
 403         }
 404         buf[pref->pref_len] = '\0';
 405
 406         switch (type) {
 407         case PROP_TYPE_ARRAY:
 408                 obj = prop_array_internalize(buf);
 409                 break;
 410         case PROP_TYPE_DICTIONARY:
 411                 obj = prop_dictionary_internalize(buf);
 412                 break;
 413         default:
 414                 error = ENOTSUP;
 415         }
 416
 417         kfree(buf, M_TEMP);
 418         if (obj == NULL) {
 419                 if (error == 0)
 420                         error = EIO;
 421         } else {
 422                 *objp = obj;
 423         }
 424         return (error);
 425 }
 426
 427
 428 static int
 429 _prop_object_copyin_ioctl(const struct plistref *pref, const prop_type_t type,
 430                           const u_long cmd, prop_object_t *objp)
 431 {
 432         if ((cmd & IOC_IN) == 0)
 433                 return (EFAULT);
 434
 435         return _prop_object_copyin(pref, type, objp);
 436 }
 437
 438 /*
 439  * prop_array_copyin --
 440  *      Copy in an array passed as a syscall arg.
 441  */
 442 int
 443 prop_array_copyin(const struct plistref *pref, prop_array_t *arrayp)
 444 {
 445         return (_prop_object_copyin(pref, PROP_TYPE_ARRAY,
 446                                           (prop_object_t *)arrayp));
 447 }
 448
 449 /*
 450  * prop_dictionary_copyin --
 451  *      Copy in a dictionary passed as a syscall arg.
 452  */
 453 int
 454 prop_dictionary_copyin(const struct plistref *pref, prop_dictionary_t *dictp)
 455 {
 456         return (_prop_object_copyin(pref, PROP_TYPE_DICTIONARY,
 457                                           (prop_object_t *)dictp));
 458 }
 459
 460
 461 /*
 462  * prop_array_copyin_ioctl --
 463  *      Copy in an array send with an ioctl.
 464  */
 465 int
 466 prop_array_copyin_ioctl(const struct plistref *pref, const u_long cmd,
 467                         prop_array_t *arrayp)
 468 {
 469         return (_prop_object_copyin_ioctl(pref, PROP_TYPE_ARRAY,
 470                                           cmd, (prop_object_t *)arrayp));
 471 }
 472
 473 /*
 474  * prop_dictionary_copyin_ioctl --
 475  *      Copy in a dictionary sent with an ioctl.
 476  */
 477 int
 478 prop_dictionary_copyin_ioctl(const struct plistref *pref, const u_long cmd,
 479                              prop_dictionary_t *dictp)
 480 {
 481         return (_prop_object_copyin_ioctl(pref, PROP_TYPE_DICTIONARY,
 482                                           cmd, (prop_object_t *)dictp));
 483 }
 484
 485 static int
 486 _prop_object_copyout(struct plistref *pref, prop_object_t obj)
 487 {
 488         struct proc *p = curproc;
 489         char *buf;
 490         size_t len, rlen;
 491         int error = 0;
 492         vm_offset_t uaddr;
 493
 494         switch (prop_object_type(obj)) {
 495         case PROP_TYPE_ARRAY:
 496                 buf = prop_array_externalize(obj);
 497                 break;
 498         case PROP_TYPE_DICTIONARY:
 499                 buf = prop_dictionary_externalize(obj);
 500                 break;
 501         default:
 502                 return (ENOTSUP);
 503         }
 504         if (buf == NULL)
 505                 return (ENOMEM);
 506
 507         len = strlen(buf) + 1;
 508         rlen = round_page(len);
 509
 510         /*
 511          * See sys_mmap() in sys/uvm/uvm_mmap.c.
 512          * Let's act as if we were calling mmap(0, ...)
 513          */
 514 #if 0
 515         uaddr = p->p_emul->e_vm_default_addr(p,
 516             (vaddr_t)p->p_vmspace->vm_daddr, rlen);
 517 #endif
 518         uaddr = round_page((vm_offset_t)p->p_vmspace->vm_daddr + maxdsiz);
 519
 520         error = vm_mmap(&p->p_vmspace->vm_map,
 521                          &uaddr, rlen,
 522                          VM_PROT_READ|VM_PROT_WRITE,
 523                          VM_PROT_READ|VM_PROT_WRITE,
 524                          MAP_PRIVATE|MAP_ANON,
 525                          NULL, 0);
 526         if (error == 0) {
 527                 error = copyout(buf, (char *)uaddr, len);
 528                 if (error == 0) {
 529                         pref->pref_plist = (char *)uaddr;
 530                         pref->pref_len   = len;
 531                 }
 532         }
 533
 534         kfree(buf, M_TEMP);
 535
 536         return (error);
 537 }
 538
 539 /*
 540  * prop_array_copyout --
 541  *      Copy out an array to a syscall arg.
 542  */
 543 int
 544 prop_array_copyout(struct plistref *pref, prop_array_t array)
 545 {
 546         return (_prop_object_copyout(pref, array));
 547 }
 548
 549 /*
 550  * prop_dictionary_copyout --
 551  *      Copy out a dictionary to a syscall arg.
 552  */
 553 int
 554 prop_dictionary_copyout(struct plistref *pref, prop_dictionary_t dict)
 555 {
 556         return (_prop_object_copyout(pref, dict));
 557 }
 558
 559 static int
 560 _prop_object_copyout_ioctl(struct plistref *pref, const u_long cmd,
 561                            prop_object_t obj)
 562 {
 563         if ((cmd & IOC_OUT) == 0)
 564                 return (EFAULT);
 565         return _prop_object_copyout(pref, obj);
 566 }
 567
 568
 569 /*
 570  * prop_array_copyout_ioctl --
 571  *      Copy out an array being received with an ioctl.
 572  */
 573 int
 574 prop_array_copyout_ioctl(struct plistref *pref, const u_long cmd,
 575                          prop_array_t array)
 576 {
 577         return (_prop_object_copyout_ioctl(pref, cmd, array));
 578 }
 579
 580 /*
 581  * prop_dictionary_copyout_ioctl --
 582  *      Copy out a dictionary being received with an ioctl.
 583  */
 584 int
 585 prop_dictionary_copyout_ioctl(struct plistref *pref, const u_long cmd,
 586                               prop_dictionary_t dict)
 587 {
 588         return (
 589             _prop_object_copyout_ioctl(pref, cmd, dict));
 590 }
 591 #endif /* _KERNEL */