src/platform/IRIX/rcmd.c

   1 /*
   2  * Copyright (c) 1983 Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that the above copyright notice and this paragraph are
   7  * duplicated in all such forms and that any documentation,
   8  * advertising materials, and other materials related to such
   9  * distribution and use acknowledge that the software was developed
  10  * by the University of California, Berkeley.  The name of the
  11  * University may not be used to endorse or promote products derived
  12  * from this software without specific prior written permission.
  13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 #include <afsconfig.h>
  19 #include <afs/param.h>
  20
  21
  22 #ifdef aiws /*AIX*/
  23 #include <sys/types.h>
  24 #define MAXHOSTNAMELEN  64      /* use BSD's, not sys/param's */
  25 #define MAXPATHLEN      1024    /* from BSD */
  26 #include <sys/ioctl.h>          /* for SIOCSPGRP */
  27 #endif
  28 #include <stdio.h>
  29 #include <ctype.h>
  30 #include <pwd.h>
  31 #include <sys/param.h>
  32 #include <limits.h>
  33 #include <sys/file.h>
  34 #ifdef  AFS_SUN5_ENV
  35 #include <fcntl.h>
  36 #endif
  37 #include <unistd.h>             /* select() prototype */
  38 #include <sys/types.h>          /* fd_set on older platforms */
  39 #include <sys/time.h>           /* struct timeval, select() prototype */
  40 #ifndef FD_SET
  41 # include <sys/select.h>        /* fd_set on newer platforms */
  42 #endif
  43 #include <sys/signal.h>
  44 #include <sys/socket.h>
  45 #include <sys/stat.h>
  46 #include <netinet/in.h>
  47 #include <netdb.h>
  48 #include <errno.h>
  49 #if defined(AFS_HPUX_ENV)
  50 /* HPUX uses a different call to set[res][gu]ids: */
  51 #define seteuid(newEuid)        setresuid(-1, (newEuid), -1)
  52 #define setegid(newEgid)        setresgid(-1, (newEgid), -1)
  53 #endif /* defined(AFS_HPUX_ENV) */
  54 #ifdef  TCP_DEBUG
  55 #include <sys/syslog.h>
  56 #       define  DPRINTF(args)   afs_dprintf args
  57 afs_dprintf(args)
  58      char *args;
  59 {
  60     char **argv;
  61     char buf[BUFSIZ];
  62     static char prefix[] = "rcmd: ";
  63
  64     argv = &args;
  65     vsprintf(buf, argv[0], &argv[1]);
  66     syslog(LOG_DEBUG, "%s %s\n", prefix, buf);
  67 }
  68 #else
  69 #       define  DPRINTF(args)
  70 #endif
  71 #include <syslog.h>
  72 static _checkhost();
  73
  74 #ifdef AFS_HPUX102_ENV
  75 int
  76 rmcd(ahost, rport, locuser, remuser, cmd, fd2p)
  77      char **ahost;
  78      int rport;
  79      const char *locuser, *remuser, *cmd;
  80      int *fd2p;
  81 #else
  82 #ifdef  AFS_AIX32_ENV
  83 rcmd(ahost, rport, locuser, remuser, cmd, fd2p, retry)
  84      int retry;
  85 #else
  86 rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
  87 #endif
  88      char **ahost;
  89      u_short rport;
  90 #if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
  91      const char *locuser, *remuser, *cmd;
  92 #else
  93      char *locuser, *remuser, *cmd;
  94 #endif
  95      int *fd2p;
  96 #endif
  97 {
  98     int s, timo = 1, pid;
  99     sigset_t oldset;
 100     sigset_t sigBlock;
 101     int someSignals[100];
 102     struct servent *sp, *getservbyport();
 103     struct sockaddr_in sin, from;
 104     char c;
 105     int lport = IPPORT_RESERVED - 1;
 106     struct hostent *hp;
 107     fd_set reads;
 108
 109     memset(someSignals, 0, sizeof(someSignals));
 110     someSignals[0] = 1 << (SIGURG - 1);
 111     sigBlock = *((sigset_t *) someSignals);
 112
 113     pid = getpid();
 114     hp = gethostbyname(*ahost); /* CAUTION: this uses global static */
 115     /* storage.  ANY OTHER CALLS to gethostbyname (including from within
 116      * syslog, eg) will trash the contents of hp. BE CAREFUL! */
 117     if (hp == 0) {
 118         herror(*ahost);
 119         return (-1);
 120     }
 121     *ahost = hp->h_name;
 122     /* was: syslog(LOG_ERR, "rcmd: host=%s, rport=%d, luser=%s,ruser=%s,cmd=%s,fd2p=%s\n", *ahost,rport,locuser,remuser,cmd,fd2p)
 123      * but that trashes hp... */
 124     sigprocmask(SIG_BLOCK, &sigBlock, &oldset);
 125     for (;;) {
 126         s = rresvport(&lport);
 127         if (s < 0) {
 128             if (errno == EAGAIN)
 129                 fprintf(stderr, "socket: All ports in use\n");
 130             else
 131                 perror("rcmd: socket");
 132             sigprocmask(SIG_SETMASK, &oldset, (sigset_t *) 0);
 133             return (-1);
 134         }
 135 #ifdef  AFS_AIX32_ENV
 136 #ifndef aiws
 137         fcntl(s, F_SETOWN, pid);
 138 #else
 139         /* since AIX has no F_SETOWN, we just do the ioctl */
 140         (void)ioctl(s, SIOCSPGRP, &pid);
 141 #endif
 142 #else
 143 #if !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV)
 144         fcntl(s, F_SETOWN, pid);
 145 #endif /* !defined(AIX) */
 146 #endif
 147         sin.sin_family = hp->h_addrtype;
 148 #ifdef  AFS_OSF_ENV
 149         memcpy((caddr_t) & sin.sin_addr, hp->h_addr_list[0], hp->h_length);
 150 #else
 151         memcpy((caddr_t) & sin.sin_addr, hp->h_addr, hp->h_length);
 152 #endif
 153         sin.sin_port = rport;
 154         /* attempt to remote authenticate first... */
 155         sp = getservbyport((int)rport, "tcp");
 156         if (sp) {
 157             int ok = 0;
 158
 159             switch (ta_rauth(s, sp->s_name, sin.sin_addr)) {
 160             case 0:
 161 #ifndef AFS_SGI_ENV
 162                 fprintf(stderr, "No remote authentication\n");
 163 #endif
 164                 close(s);
 165                 s = rresvport(&lport);
 166                 if (s < 0) {
 167                     if (errno == EAGAIN)
 168                         fprintf(stderr, "socket: All ports in use\n");
 169                     else
 170                         perror("rcmd: socket");
 171                     sigprocmask(SIG_SETMASK, &oldset, (sigset_t *) 0);
 172                     return (-1);
 173                 }
 174 #if !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV)
 175                 fcntl(s, F_SETOWN, pid);
 176 #endif /* !defined(AIX) */
 177                 break;
 178             case 1:
 179                 ok = 1;
 180                 break;
 181             case -1:
 182                 fprintf(stderr, "Login incorrect.");
 183                 exit(1);
 184                 break;
 185             case -2:
 186                 fprintf(stderr, "internal failure, ta_rauth\n");
 187                 exit(errno);
 188                 break;
 189             case -3:
 190                 fprintf(stderr, "Cannot connect to remote machine\n");
 191                 exit(errno);
 192                 break;
 193             }
 194
 195             if (ok) {
 196                 break;          /* from for loop */
 197             }
 198         }
 199         if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
 200             break;
 201         (void)close(s);
 202         if (errno == EADDRINUSE) {
 203             lport--;
 204             continue;
 205         }
 206         if (errno == ECONNREFUSED && timo <= 16) {
 207 #ifdef  AFS_AIX32_ENV
 208             if (!retry) {
 209                 return (-2);
 210             }
 211 #endif
 212             sleep(timo);
 213             timo *= 2;
 214             continue;
 215         }
 216         if (hp->h_addr_list[1] != NULL) {
 217             int oerrno = errno;
 218
 219             fprintf(stderr, "connect to address %s: ",
 220                     inet_ntoa(sin.sin_addr));
 221             errno = oerrno;
 222             perror(0);
 223             hp->h_addr_list++;
 224             memcpy((caddr_t) & sin.sin_addr, hp->h_addr_list[0],
 225                    hp->h_length);
 226             fprintf(stderr, "Trying %s...\n", inet_ntoa(sin.sin_addr));
 227             continue;
 228         }
 229         perror(hp->h_name);
 230         sigprocmask(SIG_SETMASK, &oldset, (sigset_t *) 0);
 231         return (-1);
 232     }
 233     lport--;
 234     if (fd2p == 0) {
 235         write(s, "", 1);
 236         lport = 0;
 237     } else {
 238         char num[8];
 239         int s2 = rresvport(&lport), s3;
 240         int len = sizeof(from);
 241         int maxfd = -1;
 242
 243         if (s2 < 0)
 244             goto bad;
 245         listen(s2, 1);
 246         (void)sprintf(num, "%d", lport);
 247         if (write(s, num, strlen(num) + 1) != strlen(num) + 1) {
 248             perror("write: setting up stderr");
 249             (void)close(s2);
 250             goto bad;
 251         }
 252         FD_ZERO(&reads);
 253         FD_SET(s, &reads);
 254         if (maxfd < s)
 255             maxfd = s;
 256         FD_SET(s2, &reads);
 257         if (maxfd < s2)
 258             maxfd = s2;
 259         errno = 0;
 260         if (select(maxfd + 1, &reads, 0, 0, 0) < 1 || !FD_ISSET(s2, &reads)) {
 261             if (errno != 0)
 262                 perror("select: setting up stderr");
 263             else
 264                 fprintf(stderr,
 265                         "select: protocol failure in circuit setup.\n");
 266             (void)close(s2);
 267             goto bad;
 268         }
 269         s3 = accept(s2, (struct sockaddr *)&from, &len);
 270         (void)close(s2);
 271         if (s3 < 0) {
 272             perror("accept");
 273             lport = 0;
 274             goto bad;
 275         }
 276         *fd2p = s3;
 277         from.sin_port = ntohs((u_short) from.sin_port);
 278         if (from.sin_family != AF_INET || from.sin_port >= IPPORT_RESERVED
 279             || from.sin_port < IPPORT_RESERVED / 2) {
 280             fprintf(stderr, "socket: protocol failure in circuit setup.\n");
 281             goto bad2;
 282         }
 283     }
 284     (void)write(s, locuser, strlen(locuser) + 1);
 285     (void)write(s, remuser, strlen(remuser) + 1);
 286     (void)write(s, cmd, strlen(cmd) + 1);
 287     errno = 0;
 288     if (read(s, &c, 1) < 0) {
 289         perror(*ahost);
 290         goto bad2;
 291     }
 292     if (c != 0) {
 293 #ifdef  AFS_OSF_ENV
 294         /*
 295          *   Two different protocols seem to be used;
 296          *   one prepends a "message" byte with a "small"
 297          *   number; the other one just sends the message
 298          */
 299         if (isalnum(c))
 300             (void)write(2, &c, 1);
 301
 302 #endif
 303         while (read(s, &c, 1) == 1) {
 304             (void)write(2, &c, 1);
 305             if (c == '\n')
 306                 break;
 307         }
 308         goto bad2;
 309     }
 310     sigprocmask(SIG_SETMASK, &oldset, (sigset_t *) 0);
 311     return (s);
 312   bad2:
 313     if (lport)
 314         (void)close(*fd2p);
 315   bad:
 316     (void)close(s);
 317     sigprocmask(SIG_SETMASK, &oldset, (sigset_t *) 0);
 318     return (-1);
 319 }
 320
 321 #ifndef AFS_AIX32_ENV
 322 rresvport(alport)
 323      int *alport;
 324 {
 325     struct sockaddr_in sin;
 326     int s;
 327
 328     sin.sin_family = AF_INET;
 329     sin.sin_addr.s_addr = INADDR_ANY;
 330     s = socket(AF_INET, SOCK_STREAM, 0);
 331     if (s < 0)
 332         return (-1);
 333     for (;;) {
 334         sin.sin_port = htons((u_short) * alport);
 335         if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
 336             return (s);
 337         if (errno != EADDRINUSE) {
 338             (void)close(s);
 339             return (-1);
 340         }
 341         (*alport)--;
 342         if (*alport == IPPORT_RESERVED / 2) {
 343             (void)close(s);
 344             errno = EAGAIN;     /* close */
 345             return (-1);
 346         }
 347     }
 348 }
 349 #endif
 350
 351 int _check_rhosts_file = 1;
 352
 353 #if defined(AFS_HPUX102_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
 354 ruserok(rhost, superuser, ruser, luser)
 355      const char *rhost;
 356      int superuser;
 357      const char *ruser, *luser;
 358 #else
 359 ruserok(rhost, superuser, ruser, luser)
 360      int superuser;
 361      char *rhost;
 362      char *ruser, *luser;
 363 #endif
 364 {
 365     FILE *hostf;
 366     char fhost[MAXHOSTNAMELEN];
 367     int first = 1;
 368     char *sp, *p;
 369     int baselen = -1;
 370     int suid, sgid;
 371     int group_list_size = -1;
 372     gid_t groups[NGROUPS_MAX];
 373     sp = rhost;
 374     p = fhost;
 375     while (*sp) {
 376         if (*sp == '.') {
 377             if (baselen == -1)
 378                 baselen = sp - rhost;
 379             *p++ = *sp++;
 380         } else {
 381             *p++ = isupper(*sp) ? tolower(*sp++) : *sp++;
 382         }
 383     }
 384     *p = '\0';
 385     hostf = superuser ? (FILE *) 0 : fopen("/etc/hosts.equiv", "r");
 386   again:
 387     if (hostf) {
 388         if (!_validuser(hostf, fhost, luser, ruser, baselen)) {
 389             (void)fclose(hostf);
 390 #ifdef  AFS_OSF_ENV
 391             if (first == 0) {
 392                 (void)seteuid(suid);
 393                 (void)setegid(sgid);
 394                 if (group_list_size >= 0)
 395                     (void)setgroups(group_list_size, groups);
 396             }
 397 #endif
 398             return (0);
 399         }
 400         (void)fclose(hostf);
 401     }
 402     if (first == 1 && (_check_rhosts_file || superuser)) {
 403         struct stat sbuf;
 404         struct passwd *pwd, *getpwnam();
 405         char pbuf[MAXPATHLEN];
 406
 407         first = 0;
 408         suid = geteuid();
 409         sgid = getegid();
 410         group_list_size = getgroups(NGROUPS_MAX, groups);
 411         if ((pwd = getpwnam(luser)) == NULL)
 412             return (-1);
 413         if (setegid(pwd->pw_gid) >= 0)
 414             (void)initgroups(luser, pwd->pw_gid);
 415         (void)seteuid(pwd->pw_uid);
 416         (void)strcpy(pbuf, pwd->pw_dir);
 417         (void)strcat(pbuf, "/.rhosts");
 418         if ((hostf = fopen(pbuf, "r")) == NULL)
 419             goto bad;
 420         /*
 421          * if owned by someone other than user or root or if
 422          * writable by anyone but the owner, quit
 423          */
 424         if (fstat(fileno(hostf), &sbuf) || sbuf.st_uid
 425             && sbuf.st_uid != pwd->pw_uid || sbuf.st_mode & 022) {
 426             fclose(hostf);
 427             goto bad;
 428         }
 429         goto again;
 430     }
 431   bad:
 432     if (first == 0) {
 433         (void)seteuid(suid);
 434         (void)setegid(sgid);
 435         if (group_list_size >= 0)
 436             (void)setgroups(group_list_size, groups);
 437     }
 438     return (-1);
 439 }
 440
 441 /* don't make static, used by lpd(8) */
 442 _validuser(hostf, rhost, luser, ruser, baselen)
 443      char *rhost, *luser, *ruser;
 444      FILE *hostf;
 445      int baselen;
 446 {
 447     char *user;
 448     char ahost[MAXHOSTNAMELEN * 4];
 449     char *p;
 450 #ifdef  AFS_AIX32_ENV
 451 #include <arpa/nameser.h>
 452     int hostmatch, usermatch;
 453     char domain[MAXDNAME], *dp;
 454
 455     dp = NULL;
 456     if (getdomainname(domain, sizeof(domain)) == 0)
 457         dp = domain;
 458 #endif
 459     while (fgets(ahost, sizeof(ahost), hostf)) {
 460 #ifdef  AFS_AIX32_ENV
 461         hostmatch = usermatch = 0;
 462         p = ahost;
 463         if (*p == '#' || *p == '\n')    /* ignore comments and blanks */
 464             continue;
 465         while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0')
 466             p++;
 467         if (*p == ' ' || *p == '\t') {
 468             *p++ = '\0';
 469             while (*p == ' ' || *p == '\t')
 470                 p++;
 471             user = p;
 472             while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0')
 473                 p++;
 474         } else
 475             user = p;
 476         *p = '\0';
 477         /*
 478          *  + - anything goes
 479          *  +@<name> - group <name> allowed
 480          *  -@<name> - group <name> disallowed
 481          *  -<name> - host <name> disallowed
 482          */
 483         if (ahost[0] == '+' && ahost[1] == 0)
 484             hostmatch = 1;
 485         else if (ahost[0] == '+' && ahost[1] == '@')
 486             hostmatch = innetgr(ahost + 2, rhost, NULL, dp);
 487         else if (ahost[0] == '-' && ahost[1] == '@') {
 488             if (innetgr(ahost + 2, rhost, NULL, dp))
 489                 return (-1);
 490         } else if (ahost[0] == '-') {
 491             if (_checkhost(rhost, ahost + 1, baselen))
 492                 return (-1);
 493         } else
 494             hostmatch = _checkhost(rhost, ahost, baselen);
 495         if (user[0]) {
 496             if (user[0] == '+' && user[1] == 0)
 497                 usermatch = 1;
 498             else if (user[0] == '+' && user[1] == '@')
 499                 usermatch = innetgr(user + 2, NULL, ruser, dp);
 500             else if (user[0] == '-' && user[1] == '@') {
 501                 if (hostmatch && innetgr(user + 2, NULL, ruser, dp))
 502                     return (-1);
 503             } else if (user[0] == '-') {
 504                 if (hostmatch && !strcmp(user + 1, ruser))
 505                     return (-1);
 506             } else
 507                 usermatch = !strcmp(user, ruser);
 508         } else
 509             usermatch = !strcmp(ruser, luser);
 510         if (hostmatch && usermatch)
 511             return (0);
 512 #else
 513         p = ahost;
 514         while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0') {
 515             *p = isupper(*p) ? tolower(*p) : *p;
 516             p++;
 517         }
 518         if (*p == ' ' || *p == '\t') {
 519             *p++ = '\0';
 520             while (*p == ' ' || *p == '\t')
 521                 p++;
 522             user = p;
 523             while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0')
 524                 p++;
 525         } else
 526             user = p;
 527         *p = '\0';
 528         if (_checkhost(rhost, ahost, baselen)
 529             && !strcmp(ruser, *user ? user : luser)) {
 530             return (0);
 531         }
 532 #endif
 533     }
 534     return (-1);
 535 }
 536
 537 static
 538 _checkhost(rhost, lhost, len)
 539      char *rhost, *lhost;
 540      int len;
 541 {
 542     static char ldomain[MAXHOSTNAMELEN + 1];
 543     static char *domainp = NULL;
 544     static int nodomain = 0;
 545     char *cp;
 546
 547 #ifdef  AFS_AIX32_ENV
 548     struct hostent *hp;
 549     long addr;
 550
 551     /*
 552      * check for ip address and do a lookup to convert to hostname
 553      */
 554     if (isinet_addr(lhost) && (addr = inet_addr(lhost)) != -1
 555         && (hp = gethostbyaddr(&addr, sizeof(addr), AF_INET)))
 556         lhost = hp->h_name;
 557
 558 #endif
 559     if (len == -1) {
 560 #ifdef  AFS_AIX32_ENV
 561         /* see if hostname from file has a domain name */
 562         for (cp = lhost; *cp; ++cp) {
 563             if (*cp == '.') {
 564                 len = cp - lhost;
 565                 break;
 566             }
 567         }
 568 #endif
 569         return (!strcmp(rhost, lhost));
 570     }
 571     if (strncmp(rhost, lhost, len))
 572         return (0);
 573     if (!strcmp(rhost, lhost))
 574         return (1);
 575 #ifdef  AFS_AIX32_ENV
 576     if (*(lhost + len) != '\0' && *(rhost + len) != '\0')
 577 #else
 578     if (*(lhost + len) != '\0')
 579 #endif
 580         return (0);
 581     if (nodomain)
 582         return (0);
 583     if (!domainp) {
 584         if (gethostname(ldomain, sizeof(ldomain)) == -1) {
 585             nodomain = 1;
 586             return (0);
 587         }
 588         ldomain[MAXHOSTNAMELEN] = '\0';
 589         if ((domainp = strchr(ldomain, '.')) == NULL) {
 590             nodomain = 1;
 591             return (0);
 592         }
 593         for (cp = ++domainp; *cp; ++cp)
 594             if (isupper(*cp))
 595                 *cp = tolower(*cp);
 596     }
 597     return (!strcmp(domainp, rhost + len + 1));
 598 }