sbin/mount_portal/puffs_portal.c

   1 /*      $NetBSD: puffs_portal.c,v 1.2 2009/12/05 20:29:19 pooka Exp $   */
   2
   3 /*
   4  * Copyright (c) 2007  Antti Kantee.  All Rights Reserved.
   5  * Development was supported by the Finnish Cultural Foundation.
   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  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  17  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 #ifndef lint
  31 __RCSID("$NetBSD: puffs_portal.c,v 1.2 2009/12/05 20:29:19 pooka Exp $");
  32 #endif /* !lint */
  33
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36
  37 #include <assert.h>
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <mntopts.h>
  41 #include <paths.h>
  42 #include <poll.h>
  43 #include <puffs.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <util.h>
  49
  50 #include "portald.h"
  51
  52 struct portal_node {
  53         char *path;
  54         int fd;
  55 };
  56
  57 static void usage(void);
  58
  59 PUFFSOP_PROTOS(portal);
  60
  61 #define PORTAL_ROOT NULL
  62 #define METADATASIZE (sizeof(int) + sizeof(size_t))
  63
  64 qelem q;
  65 int readcfg, sigchild;
  66 const char *cfg;
  67
  68 static void
  69 usage()
  70 {
  71
  72         errx(1, "usage: %s [-o options] /path/portal.conf mount_point",
  73             getprogname());
  74 }
  75
  76 static void
  77 sighup(int sig)
  78 {
  79
  80         readcfg = 1;
  81 }
  82
  83 static void
  84 sigcry(int sig)
  85 {
  86
  87         sigchild = 1;
  88 }
  89
  90 static void
  91 portal_loopfn(struct puffs_usermount *pu)
  92 {
  93
  94         if (readcfg)
  95                 conf_read(&q, cfg);
  96         readcfg = 0;
  97
  98         if (sigchild) {
  99                 sigchild = 0;
 100                 while (waitpid(-1, NULL, WNOHANG) != -1)
 101                         continue;
 102         }
 103 }
 104
 105 #define PUFBUF_FD       1
 106 #define PUFBUF_DATA     2
 107
 108 #define CMSIZE (sizeof(struct cmsghdr) + sizeof(int))
 109
 110 /* receive file descriptor produced by our child process */
 111 static int
 112 readfd(struct puffs_framebuf *pufbuf, int fd, int *done)
 113 {
 114         struct cmsghdr *cmp;
 115         struct msghdr msg;
 116         struct iovec iov;
 117         ssize_t n;
 118         int error, rv;
 119
 120         rv = 0;
 121         cmp = emalloc(CMSG_SPACE(sizeof(int)));
 122
 123         iov.iov_base = &error;
 124         iov.iov_len = sizeof(int);
 125         msg.msg_iov = &iov;
 126         msg.msg_iovlen = 1;
 127         msg.msg_name = NULL;
 128         msg.msg_namelen = 0;
 129         msg.msg_control = cmp;
 130         msg.msg_controllen = CMSG_SPACE(sizeof(int));
 131
 132         n = recvmsg(fd, &msg, 0);
 133         if (n == -1) {
 134                 rv = errno;
 135                 goto out;
 136         }
 137         if (n == 0) {
 138                 rv = ECONNRESET;
 139                 goto out;
 140         }
 141
 142         /* the data for the server */
 143         puffs_framebuf_putdata_atoff(pufbuf, 0, &error, sizeof(int));
 144         if (error) {
 145                 rv = error;
 146                 goto out;
 147         }
 148         puffs_framebuf_putdata_atoff(pufbuf, sizeof(int),
 149             CMSG_DATA(cmp), sizeof(int));
 150         *done = 1;
 151
 152  out:
 153         free(cmp);
 154         return rv;
 155 }
 156
 157 /*
 158  * receive data from provider
 159  *
 160  * XXX: should read directly into the buffer and adjust offsets
 161  * instead of doing memcpy
 162  */
 163 static int
 164 readdata(struct puffs_framebuf *pufbuf, int fd, int *done)
 165 {
 166         char buf[1024];
 167         size_t max;
 168         ssize_t n;
 169         size_t moved;
 170
 171         /* don't override metadata */
 172         if (puffs_framebuf_telloff(pufbuf) == 0)
 173                 puffs_framebuf_seekset(pufbuf, METADATASIZE);
 174         puffs_framebuf_getdata_atoff(pufbuf, sizeof(int), &max, sizeof(size_t));
 175         moved = puffs_framebuf_tellsize(pufbuf) - METADATASIZE;
 176         assert(max >= moved);
 177         max -= moved;
 178
 179         do {
 180                 n = read(fd, buf, MIN(sizeof(buf), max));
 181                 if (n == 0) {
 182                         if (moved)
 183                                 break;
 184                         else
 185                                 return -1; /* caught by read */
 186                 }
 187                 if (n < 0) {
 188                         if (moved)
 189                                 return 0;
 190
 191                         if (errno != EAGAIN)
 192                                 return errno;
 193                         else
 194                                 return 0;
 195                 }
 196
 197                 puffs_framebuf_putdata(pufbuf, buf, n);
 198                 moved += n;
 199                 max -= n;
 200         } while (max > 0);
 201
 202         *done = 1;
 203
 204         return 0;
 205 }
 206
 207 static int
 208 portal_frame_rf(struct puffs_usermount *pu, struct puffs_framebuf *pufbuf,
 209         int fd, int *done)
 210 {
 211         int type;
 212
 213         if (puffs_framebuf_getdata_atoff(pufbuf, 0, &type, sizeof(int)) == -1)
 214                 return EINVAL;
 215
 216         if (type == PUFBUF_FD)
 217                 return readfd(pufbuf, fd, done);
 218         else if (type == PUFBUF_DATA)
 219                 return readdata(pufbuf, fd, done);
 220         else
 221                 abort();
 222 }
 223
 224 static int
 225 portal_frame_wf(struct puffs_usermount *pu, struct puffs_framebuf *pufbuf,
 226         int fd, int *done)
 227 {
 228         void *win;
 229         size_t pbsize, pboff, winlen;
 230         ssize_t n;
 231         int error;
 232
 233         pboff = puffs_framebuf_telloff(pufbuf);
 234         pbsize = puffs_framebuf_tellsize(pufbuf);
 235         error = 0;
 236
 237         do {
 238                 assert(pbsize > pboff);
 239                 winlen = pbsize - pboff;
 240                 if (puffs_framebuf_getwindow(pufbuf, pboff, &win, &winlen)==-1)
 241                         return errno;
 242                 n = write(fd, win, winlen);
 243                 if (n == 0) {
 244                         if (pboff != 0)
 245                                 break;
 246                         else
 247                                 return -1; /* caught by node_write */
 248                 }
 249                 if (n < 0) {
 250                         if (pboff != 0)
 251                                 break;
 252
 253                         if (errno != EAGAIN)
 254                                 return errno;
 255                         return 0;
 256                 }
 257
 258                 pboff += n;
 259                 puffs_framebuf_seekset(pufbuf, pboff);
 260         } while (pboff != pbsize);
 261
 262         *done = 1;
 263         puffs_framebuf_putdata_atoff(pufbuf, 0, &pboff, sizeof(size_t));
 264         return error;
 265 }
 266
 267 /* transfer file descriptor to master file server */
 268 static int
 269 sendfd(int s, int fd, int error)
 270 {
 271         struct cmsghdr *cmp;
 272         struct msghdr msg;
 273         struct iovec iov;
 274         ssize_t n;
 275         int rv;
 276
 277         rv = 0;
 278         cmp = emalloc(CMSG_LEN(sizeof(int)));
 279
 280         iov.iov_base = &error;
 281         iov.iov_len = sizeof(int);
 282
 283         msg.msg_iov = &iov;
 284         msg.msg_iovlen = 1;
 285         msg.msg_name = NULL;
 286         msg.msg_namelen = 0;
 287         if (error == 0) {
 288                 cmp->cmsg_level = SOL_SOCKET;
 289                 cmp->cmsg_type = SCM_RIGHTS;
 290                 cmp->cmsg_len = CMSG_LEN(sizeof(int));
 291
 292                 msg.msg_control = cmp;
 293                 msg.msg_controllen = CMSG_LEN(sizeof(int));
 294                 *(int *)CMSG_DATA(cmp) = fd;
 295         } else {
 296                 msg.msg_control = NULL;
 297                 msg.msg_controllen = 0;
 298         }
 299
 300         n = sendmsg(s, &msg, 0);
 301         if (n == -1)
 302                 rv = errno;
 303         else if (n < (ssize_t)sizeof(int))
 304                 rv = EPROTO;
 305
 306         free(cmp);
 307         return rv;
 308 }
 309
 310 /*
 311  * Produce I/O file descriptor by forking (like original portald).
 312  *
 313  * child: run provider and transfer produced fd to parent
 314  * parent: yield until child produces fd.  receive it and store it.
 315  */
 316 static int
 317 provide(struct puffs_usermount *pu, struct portal_node *portn,
 318         struct portal_cred *portc, char **v)
 319 {
 320         struct puffs_cc *pcc = puffs_cc_getcc(pu);
 321         struct puffs_framebuf *pufbuf;
 322         int s[2];
 323         int fd, error;
 324         int data;
 325
 326         pufbuf = puffs_framebuf_make();
 327         if (pufbuf == NULL)
 328                 return ENOMEM;
 329
 330         data = PUFBUF_FD;
 331         if (puffs_framebuf_putdata(pufbuf, &data, sizeof(int)) == -1)
 332                 goto bad;
 333
 334         if (socketpair(AF_LOCAL, SOCK_STREAM, 0, s) == -1)
 335                 goto bad;
 336
 337         switch (fork()) {
 338         case -1:
 339                 goto bad;
 340         case 0:
 341                 error = activate_argv(portc, portn->path, v, &fd);
 342                 sendfd(s[1], fd, error);
 343                 exit(0);
 344         default:
 345                 puffs_framev_addfd(pu, s[0], PUFFS_FBIO_READ);
 346                 puffs_framev_enqueue_directreceive(pcc, s[0], pufbuf, 0);
 347                 puffs_framev_removefd(pu, s[0], 0);
 348                 close(s[0]);
 349                 close(s[1]);
 350
 351                 if (puffs_framebuf_tellsize(pufbuf) < sizeof(int)) {
 352                         errno = EIO;
 353                         goto bad;
 354                 }
 355                 puffs_framebuf_getdata_atoff(pufbuf, 0, &error, sizeof(int));
 356                 if (error) {
 357                         errno = error;
 358                         goto bad;
 359                 }
 360
 361                 if (puffs_framebuf_tellsize(pufbuf) != 2*sizeof(int)) {
 362                         errno = EIO;
 363                         goto bad;
 364                 }
 365
 366                 puffs_framebuf_getdata_atoff(pufbuf, sizeof(int),
 367                     &fd, sizeof(int));
 368                 puffs_framebuf_destroy(pufbuf);
 369
 370                 data = 1;
 371                 if (ioctl(fd, FIONBIO, &data) == -1)
 372                         return errno;
 373
 374                 if (puffs_framev_addfd(pu, fd, PUFFS_FBIO_WRITE) == -1)
 375                         return errno;
 376
 377                 portn->fd = fd;
 378                 return 0;
 379         }
 380
 381  bad:
 382         puffs_framebuf_destroy(pufbuf);
 383         return errno;
 384 }
 385
 386 int
 387 main(int argc, char *argv[])
 388 {
 389         extern char *optarg;
 390         extern int optind;
 391         struct puffs_usermount *pu;
 392         struct puffs_ops *pops;
 393         mntoptparse_t mp;
 394         int pflags, mntflags;
 395         int detach;
 396         int ch;
 397
 398         setprogname(argv[0]);
 399
 400         mntflags = pflags = 0;
 401         detach = 1;
 402         while ((ch = getopt(argc, argv, "o:s")) != -1) {
 403                 switch (ch) {
 404                 case 'o':
 405                         mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
 406                         if (mp == NULL)
 407                                 err(1, "getmntopts");
 408                         freemntopts(mp);
 409                         break;
 410                 case 's': /* stay on top */
 411                         detach = 0;
 412                         break;
 413                 default:
 414                         usage();
 415                         /*NOTREACHED*/
 416                 }
 417         }
 418         pflags |= PUFFS_KFLAG_NOCACHE | PUFFS_KFLAG_LOOKUP_FULLPNBUF;
 419         if (pflags & PUFFS_FLAG_OPDUMP)
 420                 detach = 0;
 421         argc -= optind;
 422         argv += optind;
 423
 424         if (argc != 2)
 425                 usage();
 426
 427         PUFFSOP_INIT(pops);
 428
 429         PUFFSOP_SETFSNOP(pops, unmount);
 430         PUFFSOP_SETFSNOP(pops, sync);
 431         PUFFSOP_SETFSNOP(pops, statvfs);
 432
 433         PUFFSOP_SET(pops, portal, node, lookup);
 434         PUFFSOP_SET(pops, portal, node, getattr);
 435         PUFFSOP_SET(pops, portal, node, setattr);
 436         PUFFSOP_SET(pops, portal, node, open);
 437         PUFFSOP_SET(pops, portal, node, read);
 438         PUFFSOP_SET(pops, portal, node, write);
 439         PUFFSOP_SET(pops, portal, node, seek);
 440         PUFFSOP_SET(pops, portal, node, poll);
 441         PUFFSOP_SET(pops, portal, node, inactive);
 442         PUFFSOP_SET(pops, portal, node, reclaim);
 443
 444         pu = puffs_init(pops, _PATH_PUFFS, "portal", NULL, pflags);
 445         if (pu == NULL)
 446                 err(1, "init");
 447
 448         if (signal(SIGHUP, sighup) == SIG_ERR)
 449                 warn("cannot set sighup handler");
 450         if (signal(SIGCHLD, sigcry) == SIG_ERR)
 451                 err(1, "cannot set sigchild handler");
 452         if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
 453                 err(1, "cannot ignore sigpipe");
 454
 455         readcfg = 0;
 456         cfg = argv[0];
 457         if (*cfg != '/')
 458                 errx(1, "need absolute path for config");
 459         q.q_forw = q.q_back = &q;
 460         if (conf_read(&q, cfg) == -1)
 461                 err(1, "cannot read cfg \"%s\"", cfg);
 462
 463         puffs_ml_setloopfn(pu, portal_loopfn);
 464         puffs_framev_init(pu, portal_frame_rf, portal_frame_wf, NULL,NULL,NULL);
 465
 466         if (detach)
 467                 if (puffs_daemon(pu, 1, 1) == -1)
 468                         err(1, "puffs_daemon");
 469
 470         if (puffs_mount(pu,  argv[1], mntflags, PORTAL_ROOT) == -1)
 471                 err(1, "mount");
 472         if (puffs_mainloop(pu) == -1)
 473                 err(1, "mainloop");
 474
 475         return 0;
 476 }
 477
 478 static struct portal_node *
 479 makenode(const char *path)
 480 {
 481         struct portal_node *portn;
 482
 483         portn = emalloc(sizeof(struct portal_node));
 484         portn->path = estrdup(path);
 485         portn->fd = -1;
 486
 487         return portn;
 488 }
 489
 490 static void
 491 credtr(struct portal_cred *portc, const struct puffs_cred *puffc, int mode)
 492 {
 493         memset(portc, 0, sizeof(struct portal_cred));
 494
 495         portc->pcr_flag = mode;
 496         puffs_cred_getuid(puffc, &portc->pcr_uid);
 497         puffs_cred_getgid(puffc, &portc->pcr_gid);
 498         puffs_cred_getgroups(puffc, portc->pcr_groups,
 499             (short *)&portc->pcr_ngroups);
 500 }
 501
 502 /*
 503  * XXX: we could also simply already resolve the name at this stage
 504  * instead of deferring it to open.  But doing it in open is how the
 505  * original portald does it, and I don't want to introduce any funny
 506  * incompatibilities.
 507  */
 508 int
 509 portal_node_lookup(struct puffs_usermount *pu, puffs_cookie_t opc,
 510         struct puffs_newinfo *pni, const struct puffs_cn *pcn)
 511 {
 512         struct portal_node *portn;
 513
 514         assert(opc == PORTAL_ROOT);
 515
 516         if (pcn->pcn_nameiop != NAMEI_LOOKUP
 517             && pcn->pcn_nameiop != NAMEI_CREATE)
 518                 return EOPNOTSUPP;
 519
 520         portn = makenode(pcn->pcn_name);
 521         puffs_newinfo_setcookie(pni, portn);
 522         puffs_newinfo_setvtype(pni, VREG);
 523
 524         pcn->pcn_flags &= ~NAMEI_REQUIREDIR;
 525         pcn->pcn_consume = strlen(pcn->pcn_name) - pcn->pcn_namelen;
 526
 527         return 0;
 528 }
 529
 530 int fakeid = 3;
 531
 532 /* XXX: libpuffs'ize */
 533 int
 534 portal_node_getattr(struct puffs_usermount *pu, puffs_cookie_t opc,
 535         struct vattr *va, const struct puffs_cred *pcr)
 536 {
 537         struct timeval tv;
 538         struct timespec ts;
 539
 540         puffs_vattr_null(va);
 541         if (opc == PORTAL_ROOT) {
 542                 va->va_type = VDIR;
 543                 va->va_mode = 0777;
 544                 va->va_nlink = 2;
 545         } else {
 546                 va->va_type = VREG;
 547                 va->va_mode = 0666;
 548                 va->va_nlink = 1;
 549         }
 550         va->va_uid = va->va_gid = 0;
 551         va->va_fileid = fakeid++;
 552         va->va_size = va->va_bytes = 0;
 553         va->va_gen = 0;
 554         va->va_rdev = PUFFS_VNOVAL;
 555         va->va_blocksize = DEV_BSIZE;
 556
 557         gettimeofday(&tv, NULL);
 558         TIMEVAL_TO_TIMESPEC(&tv, &ts);
 559         va->va_atime = va->va_ctime = va->va_mtime = va->va_birthtime = ts;
 560
 561         return 0;
 562 }
 563
 564 /* for writing, just pretend we care */
 565 int
 566 portal_node_setattr(struct puffs_usermount *pu, puffs_cookie_t opc,
 567         const struct vattr *va, const struct puffs_cred *pcr)
 568 {
 569
 570         return 0;
 571 }
 572
 573 int
 574 portal_node_open(struct puffs_usermount *pu, puffs_cookie_t opc, int mode,
 575         const struct puffs_cred *pcr)
 576 {
 577         struct portal_node *portn = opc;
 578         struct portal_cred portc;
 579         char **v;
 580
 581         if (opc == PORTAL_ROOT)
 582                 return 0;
 583
 584         if (mode & O_NONBLOCK)
 585                 return EOPNOTSUPP;
 586
 587         v = conf_match(&q, portn->path);
 588         if (v == NULL)
 589                 return ENOENT;
 590
 591         credtr(&portc, pcr, mode);
 592         return provide(pu, portn, &portc, v);
 593 }
 594
 595 int
 596 portal_node_read(struct puffs_usermount *pu, puffs_cookie_t opc,
 597         uint8_t *buf, off_t offset, size_t *resid,
 598         const struct puffs_cred *pcr, int ioflag)
 599 {
 600         struct puffs_cc *pcc = puffs_cc_getcc(pu);
 601         struct portal_node *portn = opc;
 602         struct puffs_framebuf *pufbuf;
 603         size_t xfersize, winsize, boff;
 604         void *win;
 605         int rv, error;
 606         int data, dummy;
 607
 608         assert(opc != PORTAL_ROOT);
 609         error = 0;
 610
 611         /* if we can't (re-)enable it, treat it as EOF */
 612         rv = puffs_framev_enablefd(pu, portn->fd, PUFFS_FBIO_READ);
 613         if (rv == -1)
 614                 return 0;
 615
 616         pufbuf = puffs_framebuf_make();
 617         data = PUFBUF_DATA;
 618         puffs_framebuf_putdata(pufbuf, &data, sizeof(int));
 619         puffs_framebuf_putdata(pufbuf, resid, sizeof(size_t));
 620
 621         /* if we are doing nodelay, do read directly */
 622         if (ioflag & PUFFS_IO_NDELAY) {
 623                 rv = readdata(pufbuf, portn->fd, &dummy);
 624                 if (rv != 0) {
 625                         error = rv;
 626                         goto out;
 627                 }
 628         } else {
 629                 rv = puffs_framev_enqueue_directreceive(pcc,
 630                     portn->fd, pufbuf, 0);
 631
 632                 if (rv == -1) {
 633                         error = errno;
 634                         goto out;
 635                 }
 636         }
 637
 638         xfersize = puffs_framebuf_tellsize(pufbuf) - METADATASIZE;
 639         if (xfersize == 0) {
 640                 assert(ioflag & PUFFS_IO_NDELAY);
 641                 error = EAGAIN;
 642                 goto out;
 643         }
 644
 645         *resid -= xfersize;
 646         boff = 0;
 647         while (xfersize > 0) {
 648                 winsize = xfersize;
 649                 rv = puffs_framebuf_getwindow(pufbuf, METADATASIZE,
 650                     &win, &winsize);
 651                 assert(rv == 0);
 652                 assert(winsize > 0);
 653
 654                 memcpy(buf + boff, win, winsize);
 655                 xfersize -= winsize;
 656                 boff += winsize;
 657         }
 658
 659  out:
 660         puffs_framev_disablefd(pu, portn->fd, PUFFS_FBIO_READ);
 661         puffs_framebuf_destroy(pufbuf);
 662
 663         /* a trickery, from readdata() */
 664         if (error == -1)
 665                 return 0;
 666         return error;
 667 }
 668
 669 int
 670 portal_node_write(struct puffs_usermount *pu, puffs_cookie_t opc,
 671         uint8_t *buf, off_t offset, size_t *resid,
 672         const struct puffs_cred *pcr, int ioflag)
 673 {
 674         struct puffs_cc *pcc = puffs_cc_getcc(pu);
 675         struct portal_node *portn = opc;
 676         struct puffs_framebuf *pufbuf;
 677         size_t written;
 678         int error, rv, dummy;
 679
 680         assert(opc != PORTAL_ROOT);
 681
 682         pufbuf = puffs_framebuf_make();
 683         puffs_framebuf_putdata(pufbuf, buf, *resid);
 684
 685         error = 0;
 686         if (ioflag & PUFFS_IO_NDELAY) {
 687                 rv = portal_frame_wf(pu, pufbuf, portn->fd, &dummy);
 688                 if (rv) {
 689                         error = rv;
 690                         goto out;
 691                 }
 692         } else  {
 693                 rv = puffs_framev_enqueue_directsend(pcc, portn->fd, pufbuf, 0);
 694                 if (rv == -1) {
 695                         error = errno;
 696                         goto out;
 697                 }
 698         }
 699
 700         rv = puffs_framebuf_getdata_atoff(pufbuf, 0, &written, sizeof(size_t));
 701         assert(rv == 0);
 702         assert(written <= *resid);
 703         *resid -= written;
 704
 705  out:
 706         puffs_framebuf_destroy(pufbuf);
 707         if (error == -1)
 708                 error = 0;
 709         return 0;
 710 }
 711
 712 int
 713 portal_node_seek(struct puffs_usermount *pu, puffs_cookie_t opc,
 714         off_t oldoff, off_t newoff, const struct puffs_cred *pcr)
 715 {
 716         struct portal_node *portn = opc;
 717
 718         if (opc == PORTAL_ROOT || portn->fd == -1)
 719                 return EOPNOTSUPP;
 720
 721         if (lseek(portn->fd, newoff, SEEK_SET) == -1)
 722                 return errno;
 723         return 0;
 724 }
 725
 726 int
 727 portal_node_poll(struct puffs_usermount *pu, puffs_cookie_t opc, int *events)
 728 {
 729         struct puffs_cc *pcc = puffs_cc_getcc(pu);
 730         struct portal_node *portn = opc;
 731         int what;
 732         int rv;
 733
 734         what = 0;
 735         if (*events & POLLIN)
 736                 what |= PUFFS_FBIO_READ;
 737         if (*events & POLLOUT)
 738                 what |= PUFFS_FBIO_WRITE;
 739         if (*events & POLLERR)
 740                 what |= PUFFS_FBIO_ERROR;
 741
 742         rv = puffs_framev_enqueue_waitevent(pcc, portn->fd, &what);
 743         if (rv) {
 744                 *events = POLLERR;
 745                 return rv;
 746         }
 747
 748         *events = 0;
 749         if (what & PUFFS_FBIO_READ)
 750                 *events |= POLLIN;
 751         if (what & PUFFS_FBIO_WRITE)
 752                 *events |= POLLOUT;
 753         if (what & PUFFS_FBIO_ERROR)
 754                 *events |= POLLERR;
 755
 756         return 0;
 757 }
 758
 759 int
 760 portal_node_inactive(struct puffs_usermount *pu, puffs_cookie_t opc)
 761 {
 762
 763         if (opc == PORTAL_ROOT)
 764                 return 0;
 765
 766         puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N1);
 767         return 0;
 768 }
 769
 770 int
 771 portal_node_reclaim(struct puffs_usermount *pu, puffs_cookie_t opc)
 772 {
 773         struct portal_node *portn = opc;
 774
 775         if (portn->fd != -1) {
 776                 puffs_framev_removefd(pu, portn->fd, 0);
 777                 close(portn->fd);
 778         }
 779         free(portn->path);
 780         free(portn);
 781
 782         return 0;
 783 }