lib/librmt/rmtlib.c

   1 /*      $NetBSD: rmtlib.c,v 1.26 2012/03/21 10:10:37 matt Exp $ */
   2
   3 /*
   4  *      rmt --- remote tape emulator subroutines
   5  *
   6  *      Originally written by Jeff Lee, modified some by Arnold Robbins
   7  *
   8  *      WARNING:  The man page rmt(8) for /etc/rmt documents the remote mag
   9  *      tape protocol which rdump and rrestore use.  Unfortunately, the man
  10  *      page is *WRONG*.  The author of the routines I'm including originally
  11  *      wrote his code just based on the man page, and it didn't work, so he
  12  *      went to the rdump source to figure out why.  The only thing he had to
  13  *      change was to check for the 'F' return code in addition to the 'E',
  14  *      and to separate the various arguments with \n instead of a space.  I
  15  *      personally don't think that this is much of a problem, but I wanted to
  16  *      point it out.
  17  *      -- Arnold Robbins
  18  *
  19  *      Redone as a library that can replace open, read, write, etc, by
  20  *      Fred Fish, with some additional work by Arnold Robbins.
  21  */
  22
  23 /*
  24  *      MAXUNIT --- Maximum number of remote tape file units
  25  *
  26  *      READ --- Return the number of the read side file descriptor
  27  *      WRITE --- Return the number of the write side file descriptor
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __RCSID("$NetBSD: rmtlib.c,v 1.26 2012/03/21 10:10:37 matt Exp $");
  32
  33 #define RMTIOCTL        1
  34 /* #define USE_REXEC    1 */    /* rexec code courtesy of Dan Kegel, srs!dan */
  35
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38
  39 #ifdef RMTIOCTL
  40 #include <sys/ioctl.h>
  41 #include <sys/mtio.h>
  42 #endif
  43
  44 #include <assert.h>
  45 #include <errno.h>
  46 #include <fcntl.h>
  47 #include <signal.h>
  48 #include <stdarg.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53 #include <err.h>
  54
  55 #ifdef USE_REXEC
  56 #include <netdb.h>
  57 #endif
  58
  59 #define __RMTLIB_PRIVATE
  60 #include <rmt.h>                /* get prototypes for remapped functions */
  61
  62 #include "pathnames.h"
  63
  64 static  int     _rmt_close(int);
  65 static  int     _rmt_ioctl(int, unsigned long, void *);
  66 static  off_t   _rmt_lseek(int, off_t, int);
  67 static  int     _rmt_open(const char *, int, int);
  68 static  ssize_t _rmt_read(int, void *, size_t);
  69 static  ssize_t _rmt_write(int, const void *, size_t);
  70 static  int     command(int, const char *);
  71 static  int     remdev(const char *);
  72 static  void    rmtabort(int);
  73 static  int     status(int);
  74
  75
  76 #define BUFMAGIC        64      /* a magic number for buffer sizes */
  77 #define MAXUNIT         4
  78
  79 #define READ(fd)        (Ctp[fd][0])
  80 #define WRITE(fd)       (Ptc[fd][1])
  81
  82 static int Ctp[MAXUNIT][2] = { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1} };
  83 static int Ptc[MAXUNIT][2] = { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1} };
  84
  85
  86 /*
  87  *      rmtabort --- close off a remote tape connection
  88  */
  89 static void
  90 rmtabort(int fildes)
  91 {
  92
  93         close(READ(fildes));
  94         close(WRITE(fildes));
  95         READ(fildes) = -1;
  96         WRITE(fildes) = -1;
  97 }
  98
  99
 100 /*
 101  *      command --- attempt to perform a remote tape command
 102  */
 103 static int
 104 command(int fildes, const char *buf)
 105 {
 106         size_t blen;
 107         sig_t pstat;
 108
 109         _DIAGASSERT(buf != NULL);
 110
 111 /*
 112  *      save current pipe status and try to make the request
 113  */
 114
 115         blen = strlen(buf);
 116         pstat = signal(SIGPIPE, SIG_IGN);
 117         if ((size_t)write(WRITE(fildes), buf, blen) == blen) {
 118                 signal(SIGPIPE, pstat);
 119                 return 0;
 120         }
 121
 122 /*
 123  *      something went wrong. close down and go home
 124  */
 125
 126         signal(SIGPIPE, pstat);
 127         rmtabort(fildes);
 128
 129         errno = EIO;
 130         return -1;
 131 }
 132
 133
 134 /*
 135  *      status --- retrieve the status from the pipe
 136  */
 137 static int
 138 status(int fildes)
 139 {
 140         int i;
 141         char c, *cp;
 142         char buffer[BUFMAGIC];
 143
 144 /*
 145  *      read the reply command line
 146  */
 147
 148         for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++) {
 149                 if (read(READ(fildes), cp, 1) != 1) {
 150                         rmtabort(fildes);
 151                         errno = EIO;
 152                         return -1;
 153                 }
 154                 if (*cp == '\n') {
 155                         *cp = 0;
 156                         break;
 157                 }
 158         }
 159
 160         if (i == BUFMAGIC) {
 161                 rmtabort(fildes);
 162                 errno = EIO;
 163                 return -1;
 164         }
 165
 166 /*
 167  *      check the return status
 168  */
 169
 170         for (cp = buffer; *cp; cp++)
 171                 if (*cp != ' ')
 172                         break;
 173
 174         if (*cp == 'E' || *cp == 'F') {
 175                 errno = atoi(cp + 1);
 176                 while (read(READ(fildes), &c, 1) == 1)
 177                         if (c == '\n')
 178                                 break;
 179
 180                 if (*cp == 'F')
 181                         rmtabort(fildes);
 182
 183                 return -1;
 184         }
 185
 186 /*
 187  *      check for mis-synced pipes
 188  */
 189
 190         if (*cp != 'A') {
 191                 rmtabort(fildes);
 192                 errno = EIO;
 193                 return -1;
 194         }
 195
 196         return atoi(cp + 1);
 197 }
 198
 199
 200 #ifdef USE_REXEC
 201 /*
 202  * _rmt_rexec
 203  *
 204  * execute /etc/rmt on a remote system using rexec().
 205  * Return file descriptor of bidirectional socket for stdin and stdout
 206  * If username is NULL, or an empty string, uses current username.
 207  *
 208  * ADR: By default, this code is not used, since it requires that
 209  * the user have a .netrc file in his/her home directory, or that the
 210  * application designer be willing to have rexec prompt for login and
 211  * password info. This may be unacceptable, and .rhosts files for use
 212  * with rsh are much more common on BSD systems.
 213  */
 214
 215 static  int     _rmt_rexec(const char *, const char *);
 216
 217 static int
 218 _rmt_rexec(const char *host, const char *user)
 219 {
 220         struct servent *rexecserv;
 221
 222         _DIAGASSERT(host != NULL);
 223         /* user may be NULL */
 224
 225         rexecserv = getservbyname("exec", "tcp");
 226         if (rexecserv == NULL)
 227                 errx(1, "exec/tcp: service not available.");
 228         if ((user != NULL) && *user == '\0')
 229                 user = NULL;
 230         return rexec(&host, rexecserv->s_port, user, NULL,
 231             "/etc/rmt", NULL);
 232 }
 233 #endif /* USE_REXEC */
 234
 235
 236 /*
 237  *      _rmt_open --- open a magtape device on system specified, as given user
 238  *
 239  *      file name has the form [user@]system:/dev/????
 240 #ifdef COMPAT
 241  *      file name has the form system[.user]:/dev/????
 242 #endif
 243  */
 244
 245 #define MAXHOSTLEN      257     /* BSD allows very long host names... */
 246
 247 static int
 248 /*ARGSUSED*/
 249 _rmt_open(const char *path, int oflag, int mode)
 250 {
 251         int i;
 252         char buffer[BUFMAGIC];
 253         char host[MAXHOSTLEN];
 254         char device[BUFMAGIC];
 255         char login[BUFMAGIC];
 256         char *sys, *dev, *user;
 257         const char *rshpath, *rsh;
 258
 259         _DIAGASSERT(path != NULL);
 260
 261         sys = host;
 262         dev = device;
 263         user = login;
 264
 265 /*
 266  *      first, find an open pair of file descriptors
 267  */
 268
 269         for (i = 0; i < MAXUNIT; i++)
 270                 if (READ(i) == -1 && WRITE(i) == -1)
 271                         break;
 272
 273         if (i == MAXUNIT) {
 274                 errno = EMFILE;
 275                 return -1;
 276         }
 277
 278 /*
 279  *      pull apart system and device, and optional user
 280  *      don't munge original string
 281  *      if COMPAT is defined, also handle old (4.2) style person.site notation.
 282  */
 283
 284         while (*path != '@'
 285 #ifdef COMPAT
 286                         && *path != '.'
 287 #endif
 288                         && *path != ':') {
 289                 *sys++ = *path++;
 290         }
 291         *sys = '\0';
 292         path++;
 293
 294         if (*(path - 1) == '@') {
 295                 (void)strncpy(user, host, sizeof(login) - 1);
 296                                 /* saw user part of user@host */
 297                 sys = host;                     /* start over */
 298                 while (*path != ':') {
 299                         *sys++ = *path++;
 300                 }
 301                 *sys = '\0';
 302                 path++;
 303         }
 304 #ifdef COMPAT
 305         else if (*(path - 1) == '.') {
 306                 while (*path != ':') {
 307                         *user++ = *path++;
 308                 }
 309                 *user = '\0';
 310                 path++;
 311         }
 312 #endif
 313         else
 314                 *user = '\0';
 315
 316         while (*path) {
 317                 *dev++ = *path++;
 318         }
 319         *dev = '\0';
 320
 321 #ifdef USE_REXEC
 322 /*
 323  *      Execute the remote command using rexec
 324  */
 325         READ(i) = WRITE(i) = _rmt_rexec(host, login);
 326         if (READ(i) < 0)
 327                 return -1;
 328 #else
 329 /*
 330  *      setup the pipes for the 'rsh' command and fork
 331  */
 332
 333         if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
 334                 return -1;
 335
 336         switch (fork()) {
 337         case -1:
 338                 return -1;
 339
 340         case 0:
 341                 close(0);
 342                 dup(Ptc[i][0]);
 343                 close(Ptc[i][0]); close(Ptc[i][1]);
 344                 close(1);
 345                 dup(Ctp[i][1]);
 346                 close(Ctp[i][0]); close(Ctp[i][1]);
 347                 (void) setuid(getuid());
 348                 (void) setgid(getgid());
 349
 350                 if ((rshpath = getenv("RCMD_CMD")) == NULL)
 351                         rshpath = _PATH_RSH;
 352                 if ((rsh = strrchr(rshpath, '/')) == NULL)
 353                         rsh = rshpath;
 354                 else
 355                         rsh++;
 356
 357                 if (*login) {
 358                         execl(rshpath, rsh, host, "-l", login, _PATH_RMT, NULL);
 359                 } else {
 360                         execl(rshpath, rsh, host, _PATH_RMT, NULL);
 361                 }
 362
 363 /*
 364  *      bad problems if we get here
 365  */
 366
 367                 err(1, "Cannnot exec %s", rshpath);
 368                 /*FALLTHROUGH*/
 369         default:
 370                 break;
 371         }
 372
 373         close(Ptc[i][0]); close(Ctp[i][1]);
 374 #endif
 375
 376 /*
 377  *      now attempt to open the tape device
 378  */
 379
 380         (void)snprintf(buffer, sizeof(buffer), "O%s\n%d\n", device, oflag);
 381         if (command(i, buffer) == -1 || status(i) == -1)
 382                 return -1;
 383
 384         return i;
 385 }
 386
 387
 388 /*
 389  *      _rmt_close --- close a remote magtape unit and shut down
 390  */
 391 static int
 392 _rmt_close(int fildes)
 393 {
 394         int rc;
 395
 396         if (command(fildes, "C\n") != -1) {
 397                 rc = status(fildes);
 398
 399                 rmtabort(fildes);
 400                 return rc;
 401         }
 402
 403         return -1;
 404 }
 405
 406
 407 /*
 408  *      _rmt_read --- read a buffer from a remote tape
 409  */
 410 static ssize_t
 411 _rmt_read(int fildes, void *buf, size_t nbyte)
 412 {
 413         size_t rc;
 414         int rv;
 415         ssize_t nread;
 416         char *p;
 417         char buffer[BUFMAGIC];
 418
 419         _DIAGASSERT(buf != NULL);
 420
 421         (void)snprintf(buffer, sizeof buffer, "R%zu\n", nbyte);
 422         if (command(fildes, buffer) == -1 || (rv = status(fildes)) == -1)
 423                 return -1;
 424
 425         if (rv > (int)nbyte)
 426                 rv = (int)nbyte;
 427
 428         for (rc = rv, p = buf; rc > 0; rc -= nread, p += nread) {
 429                 if ((nread = read(READ(fildes), p, rc)) <= 0) {
 430                         rmtabort(fildes);
 431                         errno = EIO;
 432                         return -1;
 433                 }
 434         }
 435
 436         return rv;
 437 }
 438
 439
 440 /*
 441  *      _rmt_write --- write a buffer to the remote tape
 442  */
 443 static ssize_t
 444 _rmt_write(int fildes, const void *buf, size_t nbyte)
 445 {
 446         char buffer[BUFMAGIC];
 447         sig_t pstat;
 448
 449         _DIAGASSERT(buf != NULL);
 450
 451         (void)snprintf(buffer, sizeof buffer, "W%zu\n", nbyte);
 452         if (command(fildes, buffer) == -1)
 453                 return -1;
 454
 455         pstat = signal(SIGPIPE, SIG_IGN);
 456         if ((size_t)write(WRITE(fildes), buf, nbyte) == nbyte) {
 457                 signal(SIGPIPE, pstat);
 458                 return status(fildes);
 459         }
 460
 461         signal(SIGPIPE, pstat);
 462         rmtabort(fildes);
 463         errno = EIO;
 464         return -1;
 465 }
 466
 467
 468 /*
 469  *      _rmt_lseek --- perform an imitation lseek operation remotely
 470  */
 471 static off_t
 472 _rmt_lseek(int fildes, off_t offset, int whence)
 473 {
 474         char buffer[BUFMAGIC];
 475
 476         /*LONGLONG*/
 477         (void)snprintf(buffer, sizeof buffer, "L%lld\n%d\n", (long long)offset,
 478             whence);
 479         if (command(fildes, buffer) == -1)
 480                 return -1;
 481
 482         return status(fildes);
 483 }
 484
 485
 486 /*
 487  *      _rmt_ioctl --- perform raw tape operations remotely
 488  */
 489 #ifdef RMTIOCTL
 490 static int
 491 _rmt_ioctl(int fildes, unsigned long op, void *arg)
 492 {
 493         char c;
 494         int rv;
 495         size_t rc;
 496         ssize_t cnt;
 497         char buffer[BUFMAGIC], *p;
 498         struct mtop *mtop = arg;
 499
 500         _DIAGASSERT(arg != NULL);
 501
 502 /*
 503  *      MTIOCOP is the easy one. nothing is transfered in binary
 504  */
 505
 506         if (op == MTIOCTOP) {
 507                 (void)snprintf(buffer, sizeof buffer, "I%d\n%d\n",
 508                     mtop->mt_op, mtop->mt_count);
 509                 if (command(fildes, buffer) == -1)
 510                         return -1;
 511                 return status(fildes);
 512         }
 513
 514 /*
 515  *      we can only handle 2 ops, if not the other one, punt
 516  */
 517
 518         if (op != MTIOCGET) {
 519                 errno = EINVAL;
 520                 return -1;
 521         }
 522
 523 /*
 524  *      grab the status and read it directly into the structure
 525  *      this assumes that the status buffer is (hopefully) not
 526  *      padded and that 2 shorts fit in a long without any word
 527  *      alignment problems, ie - the whole struct is contiguous
 528  *      NOTE - this is probably NOT a good assumption.
 529  */
 530
 531         if (command(fildes, "S") == -1 || (rv = status(fildes)) == -1)
 532                 return -1;
 533
 534         memset(arg, 0, sizeof(struct mtget));
 535         for (rc = rv, p = arg; rc > 0; rc -= cnt, p += cnt) {
 536                 if ((cnt = read(READ(fildes), p, rc)) <= 0) {
 537                         rmtabort(fildes);
 538                         errno = EIO;
 539                         return -1;
 540                 }
 541         }
 542
 543 /*
 544  *      now we check for byte position. mt_type is a small integer field
 545  *      (normally) so we will check its magnitude. if it is larger than
 546  *      256, we will assume that the bytes are swapped and go through
 547  *      and reverse all the bytes
 548  */
 549
 550         if (((struct mtget *)(void *)p)->mt_type < 256)
 551                 return 0;
 552
 553         for (cnt = 0; cnt < rv; cnt += 2) {
 554                 c = p[cnt];
 555                 p[cnt] = p[cnt + 1];
 556                 p[cnt + 1] = c;
 557         }
 558
 559         return 0;
 560 }
 561 #endif /* RMTIOCTL */
 562
 563
 564 /*
 565  *      Added routines to replace open(), close(), lseek(), ioctl(), etc.
 566  *      The preprocessor can be used to remap these the rmtopen(), etc
 567  *      thus minimizing source changes:
 568  *
 569  *              #ifdef <something>
 570  *              #  define access rmtaccess
 571  *              #  define close rmtclose
 572  *              #  define creat rmtcreat
 573  *              #  define dup rmtdup
 574  *              #  define fcntl rmtfcntl
 575  *              #  define fstat rmtfstat
 576  *              #  define ioctl rmtioctl
 577  *              #  define isatty rmtisatty
 578  *              #  define lseek rmtlseek
 579  *              #  define lstat rmtlstat
 580  *              #  define open rmtopen
 581  *              #  define read rmtread
 582  *              #  define stat rmtstat
 583  *              #  define write rmtwrite
 584  *              #endif
 585  *
 586  *      -- Fred Fish
 587  *
 588  *      ADR --- I set up a <rmt.h> include file for this
 589  *
 590  */
 591
 592 /*
 593  *      Note that local vs remote file descriptors are distinquished
 594  *      by adding a bias to the remote descriptors.  This is a quick
 595  *      and dirty trick that may not be portable to some systems.
 596  */
 597
 598 #define REM_BIAS 128
 599
 600
 601 /*
 602  *      Test pathname to see if it is local or remote.  A remote device
 603  *      is any string that contains ":/dev/".  Returns 1 if remote,
 604  *      0 otherwise.
 605  */
 606
 607 static int
 608 remdev(const char *path)
 609 {
 610
 611         _DIAGASSERT(path != NULL);
 612
 613         if ((path = strchr(path, ':')) != NULL) {
 614                 if (strncmp(path + 1, "/dev/", 5) == 0) {
 615                         return 1;
 616                 }
 617         }
 618         return 0;
 619 }
 620
 621
 622 /*
 623  *      Open a local or remote file.  Looks just like open(2) to
 624  *      caller.
 625  */
 626 int
 627 rmtopen(const char *path, int oflag, ...)
 628 {
 629         mode_t mode;
 630         int fd;
 631         va_list ap;
 632         va_start(ap, oflag);
 633
 634         mode = va_arg(ap, mode_t);
 635         va_end(ap);
 636
 637         _DIAGASSERT(path != NULL);
 638
 639         if (remdev(path)) {
 640                 fd = _rmt_open(path, oflag, (int)mode);
 641
 642                 return (fd == -1) ? -1 : (fd + REM_BIAS);
 643         } else {
 644                 return open(path, oflag, mode);
 645         }
 646 }
 647
 648 /*
 649  *      Test pathname for specified access.  Looks just like access(2)
 650  *      to caller.
 651  */
 652
 653 int
 654 rmtaccess(const char *path, int amode)
 655 {
 656
 657         _DIAGASSERT(path != NULL);
 658
 659         if (remdev(path)) {
 660                 return 0;               /* Let /etc/rmt find out */
 661         } else {
 662                 return access(path, amode);
 663         }
 664 }
 665
 666
 667 /*
 668  *      Isrmt. Let a programmer know he has a remote device.
 669  */
 670 int
 671 isrmt(int fd)
 672 {
 673         int unbias = fd - REM_BIAS;
 674
 675         return (fd >= REM_BIAS) && unbias < MAXUNIT &&
 676             (WRITE(unbias) != -1 || READ(unbias) != -1);
 677 }
 678
 679
 680 /*
 681  *      Read from stream.  Looks just like read(2) to caller.
 682  */
 683 ssize_t
 684 rmtread(int fildes, void *buf, size_t nbyte)
 685 {
 686
 687         _DIAGASSERT(buf != NULL);
 688
 689         if (isrmt(fildes)) {
 690                 return _rmt_read(fildes - REM_BIAS, buf, nbyte);
 691         } else {
 692                 return read(fildes, buf, nbyte);
 693         }
 694 }
 695
 696
 697 /*
 698  *      Write to stream.  Looks just like write(2) to caller.
 699  */
 700 ssize_t
 701 rmtwrite(int fildes, const void *buf, size_t nbyte)
 702 {
 703
 704         _DIAGASSERT(buf != NULL);
 705
 706         if (isrmt(fildes)) {
 707                 return _rmt_write(fildes - REM_BIAS, buf, nbyte);
 708         } else {
 709                 return write(fildes, buf, nbyte);
 710         }
 711 }
 712
 713 /*
 714  *      Perform lseek on file.  Looks just like lseek(2) to caller.
 715  */
 716 off_t
 717 rmtlseek(int fildes, off_t offset, int whence)
 718 {
 719
 720         if (isrmt(fildes)) {
 721                 return _rmt_lseek(fildes - REM_BIAS, offset, whence);
 722         } else {
 723                 return lseek(fildes, offset, whence);
 724         }
 725 }
 726
 727
 728 /*
 729  *      Close a file.  Looks just like close(2) to caller.
 730  */
 731 int
 732 rmtclose(int fildes)
 733 {
 734
 735         if (isrmt(fildes)) {
 736                 return _rmt_close(fildes - REM_BIAS);
 737         } else {
 738                 return close(fildes);
 739         }
 740 }
 741
 742
 743 /*
 744  *      Do ioctl on file.  Looks just like ioctl(2) to caller.
 745  */
 746 int
 747 rmtioctl(int fildes, unsigned long request, ...)
 748 {
 749         void *arg;
 750         va_list ap;
 751         va_start(ap, request);
 752
 753         arg = va_arg(ap, void *);
 754         va_end(ap);
 755
 756         /* XXX: arg may be NULL ? */
 757
 758         if (isrmt(fildes)) {
 759 #ifdef RMTIOCTL
 760                 return _rmt_ioctl(fildes - REM_BIAS, request, arg);
 761 #else
 762                 errno = EOPNOTSUPP;
 763                 return -1;              /* For now (fnf) */
 764 #endif
 765         } else {
 766                 return ioctl(fildes, request, arg);
 767         }
 768 }
 769
 770
 771 /*
 772  *      Duplicate an open file descriptor.  Looks just like dup(2)
 773  *      to caller.
 774  */
 775 int
 776 rmtdup(int fildes)
 777 {
 778
 779         if (isrmt(fildes)) {
 780                 errno = EOPNOTSUPP;
 781                 return -1;              /* For now (fnf) */
 782         } else {
 783                 return dup(fildes);
 784         }
 785 }
 786
 787
 788 /*
 789  *      Get file status.  Looks just like fstat(2) to caller.
 790  */
 791 int
 792 rmtfstat(int fildes, struct stat *buf)
 793 {
 794
 795         _DIAGASSERT(buf != NULL);
 796
 797         if (isrmt(fildes)) {
 798                 errno = EOPNOTSUPP;
 799                 return -1;              /* For now (fnf) */
 800         } else {
 801                 return fstat(fildes, buf);
 802         }
 803 }
 804
 805
 806 /*
 807  *      Get file status.  Looks just like stat(2) to caller.
 808  */
 809 int
 810 rmtstat(const char *path, struct stat *buf)
 811 {
 812
 813         _DIAGASSERT(path != NULL);
 814         _DIAGASSERT(buf != NULL);
 815
 816         if (remdev(path)) {
 817                 errno = EOPNOTSUPP;
 818                 return -1;              /* For now (fnf) */
 819         } else {
 820                 return stat(path, buf);
 821         }
 822 }
 823
 824
 825 /*
 826  *      Create a file from scratch.  Looks just like creat(2) to the caller.
 827  */
 828 int
 829 rmtcreat(const char *path, mode_t mode)
 830 {
 831
 832         _DIAGASSERT(path != NULL);
 833
 834         if (remdev(path)) {
 835                 return rmtopen(path, O_WRONLY | O_CREAT, mode);
 836         } else {
 837                 return open(path, O_CREAT | O_TRUNC | O_WRONLY, mode);
 838         }
 839 }
 840
 841
 842 /*
 843  *      Rmtfcntl. Do a remote fcntl operation.
 844  */
 845 int
 846 rmtfcntl(int fd, int cmd, ...)
 847 {
 848         void *arg;
 849         va_list ap;
 850         va_start(ap, cmd);
 851
 852         arg = va_arg(ap, void *);
 853         va_end(ap);
 854
 855         /* XXX: arg may be NULL ? */
 856
 857         if (isrmt(fd)) {
 858                 errno = EOPNOTSUPP;
 859                 return -1;
 860         } else {
 861                 return fcntl(fd, cmd, arg);
 862         }
 863 }
 864
 865
 866 /*
 867  *      Rmtisatty.  Do the isatty function.
 868  */
 869 int
 870 rmtisatty(int fd)
 871 {
 872
 873         if (isrmt(fd))
 874                 return 0;
 875         else
 876                 return isatty(fd);
 877 }
 878
 879
 880 /*
 881  *      Get file status, even if symlink.  Looks just like lstat(2) to caller.
 882  */
 883 int
 884 rmtlstat(const char *path, struct stat *buf)
 885 {
 886
 887         _DIAGASSERT(path != NULL);
 888         _DIAGASSERT(buf != NULL);
 889
 890         if (remdev(path)) {
 891                 errno = EOPNOTSUPP;
 892                 return -1;              /* For now (fnf) */
 893         } else {
 894                 return lstat(path, buf);
 895         }
 896 }