sockaddr's now require length (K. Sklower);

[unix-history] / usr / src / lib / libc / net / rcmd.c

diff --git a/usr/src/lib/libc/net/rcmd.c b/usr/src/lib/libc/net/rcmd.c
index 78ed1e9..16c2cc6 100644 (file)
--- a/usr/src/lib/libc/net/rcmd.c
+++ b/usr/src/lib/libc/net/rcmd.c
@@ -1,92 +1,146 @@
-#ifndef lint
-static char sccsid[] = "@(#)rcmd.c     4.1 82/04/02";
-#endif
+/*
+ * Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)rcmd.c     5.19 (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */

 
 #include <stdio.h>
 
 #include <stdio.h>

-#include <sys/types.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <sys/param.h>
+#include <sys/file.h>
+#include <sys/signal.h>

 #include <sys/socket.h>
 #include <sys/socket.h>

-#include <net/in.h>
+#include <sys/stat.h>
+
+#include <netinet/in.h>
+
+#include <netdb.h>

 #include <errno.h>
 
 extern errno;
 #include <errno.h>
 
 extern errno;

-char   *index(), *sprintf();
-int    rcmdoptions;
+char   *index();

 
 rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
        char **ahost;
 
 rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
        char **ahost;

-       int rport;
+       u_short rport;

        char *locuser, *remuser, *cmd;
        int *fd2p;
 {
        char *locuser, *remuser, *cmd;
        int *fd2p;
 {

-       int s, addr, timo = 1;
+       int s, timo = 1, pid;
+       long oldmask;

        struct sockaddr_in sin, sin2, from;
        char c;
        struct sockaddr_in sin, sin2, from;
        char c;

-       short port;
+       int lport = IPPORT_RESERVED - 1;
+       struct hostent *hp;

 
 

-       addr = rhost(ahost);
-       if (addr == -1) {
-               fprintf(stderr, "%s: unknown host\n", *ahost);
+       pid = getpid();
+       hp = gethostbyname(*ahost);
+       if (hp == 0) {
+               herror(*ahost);

                return (-1);
        }
                return (-1);
        }

-retry:
-       s = rresvport(rcmdoptions|SO_KEEPALIVE);
-       if (s < 0)
-               return (-1);
-       sin.sin_family = AF_INET;
-       sin.sin_addr.s_addr = addr;
-       sin.sin_port = rport;
-#ifdef vax
-       sin.sin_port = htons(sin.sin_port);
-#endif
-       if (connect(s, &sin) < 0) {
+       *ahost = hp->h_name;
+       oldmask = sigblock(sigmask(SIGURG));
+       for (;;) {
+               s = rresvport(&lport);
+               if (s < 0) {
+                       if (errno == EAGAIN)
+                               fprintf(stderr, "socket: All ports in use\n");
+                       else
+                               perror("rcmd: socket");
+                       sigsetmask(oldmask);
+                       return (-1);
+               }
+               fcntl(s, F_SETOWN, pid);
+               sin.sin_family = hp->h_addrtype;
+               bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr, hp->h_length);
+               sin.sin_port = rport;
+               if (connect(s, (caddr_t)&sin, sizeof (sin), 0) >= 0)
+                       break;
+               (void) close(s);
+               if (errno == EADDRINUSE) {
+                       lport--;
+                       continue;
+               }

                if (errno == ECONNREFUSED && timo <= 16) {
                if (errno == ECONNREFUSED && timo <= 16) {

-                       (void) close(s);

                        sleep(timo);
                        timo *= 2;
                        sleep(timo);
                        timo *= 2;

-                       goto retry;
+                       continue;

                }
                }

-               perror(*ahost);
+               if (hp->h_addr_list[1] != NULL) {
+                       int oerrno = errno;
+
+                       fprintf(stderr,
+                           "connect to address %s: ", inet_ntoa(sin.sin_addr));
+                       errno = oerrno;
+                       perror(0);
+                       hp->h_addr_list++;
+                       bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr,
+                           hp->h_length);
+                       fprintf(stderr, "Trying %s...\n",
+                               inet_ntoa(sin.sin_addr));
+                       continue;
+               }
+               perror(hp->h_name);
+               sigsetmask(oldmask);

                return (-1);
        }
                return (-1);
        }

+       lport--;

        if (fd2p == 0) {
                write(s, "", 1);
        if (fd2p == 0) {
                write(s, "", 1);

-               port = 0;
+               lport = 0;

        } else {
                char num[8];
        } else {
                char num[8];

-               int s2 = rresvport(rcmdoptions|SO_ACCEPTCONN);
+               int s2 = rresvport(&lport), s3;
+               int len = sizeof (from);

 
 

-               if (s2 < 0) {
-                       (void) close(s);
-                       return (-1);
+               if (s2 < 0)
+                       goto bad;
+               listen(s2, 1);
+               (void) sprintf(num, "%d", lport);
+               if (write(s, num, strlen(num)+1) != strlen(num)+1) {
+                       perror("write: setting up stderr");
+                       (void) close(s2);
+                       goto bad;

                }
                }

-               socketaddr(s2, &sin2);
-               port = sin2.sin_port;
-#if vax
-               port = htons((u_short)port);
-#endif
-               (void) sprintf(num, "%d", port);
-               (void) write(s, num, strlen(num)+1);
-               if (accept(s2, &from) < 0) {
+               s3 = accept(s2, &from, &len, 0);
+               (void) close(s2);
+               if (s3 < 0) {

                        perror("accept");
                        perror("accept");

+                       lport = 0;

                        goto bad;
                }
                        goto bad;
                }

-#if vax
-               from.sin_port = ntohs(from.sin_port);
-#endif
+               *fd2p = s3;
+               from.sin_port = ntohs((u_short)from.sin_port);

                if (from.sin_family != AF_INET ||
                    from.sin_port >= IPPORT_RESERVED) {
                        fprintf(stderr,
                            "socket: protocol failure in circuit setup.\n");
                if (from.sin_family != AF_INET ||
                    from.sin_port >= IPPORT_RESERVED) {
                        fprintf(stderr,
                            "socket: protocol failure in circuit setup.\n");

-                       goto bad;
+                       goto bad2;

                }
                }

-               *fd2p = s2;

        }
        (void) write(s, locuser, strlen(locuser)+1);
        (void) write(s, remuser, strlen(remuser)+1);
        (void) write(s, cmd, strlen(cmd)+1);
        if (read(s, &c, 1) != 1) {
                perror(*ahost);
        }
        (void) write(s, locuser, strlen(locuser)+1);
        (void) write(s, remuser, strlen(remuser)+1);
        (void) write(s, cmd, strlen(cmd)+1);
        if (read(s, &c, 1) != 1) {
                perror(*ahost);

-               goto bad;
+               goto bad2;

        }
        if (c != 0) {
                while (read(s, &c, 1) == 1) {
        }
        if (c != 0) {
                while (read(s, &c, 1) == 1) {


@@ -94,75 +148,176 @@ retry:
                        if (c == '\n')
                                break;
                }
                        if (c == '\n')
                                break;
                }

-               goto bad;
+               goto bad2;

        }
        }

+       sigsetmask(oldmask);

        return (s);
        return (s);

-bad:
-       if (port)
+bad2:
+       if (lport)

                (void) close(*fd2p);
                (void) close(*fd2p);

+bad:

        (void) close(s);
        (void) close(s);

+       sigsetmask(oldmask);

        return (-1);
 }
 
        return (-1);
 }
 

-rresvport(options)
-       int options;
+rresvport(alport)
+       int *alport;

 {
        struct sockaddr_in sin;
 {
        struct sockaddr_in sin;

-       short lport = IPPORT_RESERVED - 1;

        int s;
 
        int s;
 

+       sin.sin_family = AF_INET;
+       sin.sin_len = sizeof(sin);
+       sin.sin_addr.s_addr = INADDR_ANY;
+       s = socket(AF_INET, SOCK_STREAM, 0);
+       if (s < 0)
+               return (-1);

        for (;;) {
        for (;;) {

-               sin.sin_family = AF_INET;
-               sin.sin_port = lport;
-               sin.sin_addr.s_addr = 0;
-#ifdef vax
-               sin.sin_port = htons(sin.sin_port);
-#endif
-               s = socket(SOCK_STREAM, 0, &sin, options);
-               if (s >= 0)
+               sin.sin_port = htons((u_short)*alport);
+               if (bind(s, (caddr_t)&sin, sizeof (sin)) >= 0)

                        return (s);
                        return (s);

-               if (errno != EADDRINUSE && errno != EADDRNOTAVAIL) {
-                       perror("socket");
+               if (errno != EADDRINUSE) {
+                       (void) close(s);

                        return (-1);
                }
                        return (-1);
                }

-               lport--;
-               if (lport == IPPORT_RESERVED/2) {
-                       fprintf(stderr, "socket: All ports in use\n");
+               (*alport)--;
+               if (*alport == IPPORT_RESERVED/2) {
+                       (void) close(s);
+                       errno = EAGAIN;         /* close */

                        return (-1);
                }
        }
 }
 
                        return (-1);
                }
        }
 }
 

-ruserok(rhost, ruser, luser)
-       char *rhost, *ruser, *luser;
+int    _check_rhosts_file = 1;
+
+ruserok(rhost, superuser, ruser, luser)
+       char *rhost;
+       int superuser;
+       char *ruser, *luser;

 {
        FILE *hostf;
 {
        FILE *hostf;

-       char ahost[32];
+       char fhost[MAXHOSTNAMELEN];

        int first = 1;
        int first = 1;

+       register char *sp, *p;
+       int baselen = -1;

 
 

-       hostf = fopen("/etc/hosts.equiv", "r");
+       sp = rhost;
+       p = fhost;
+       while (*sp) {
+               if (*sp == '.') {
+                       if (baselen == -1)
+                               baselen = sp - rhost;
+                       *p++ = *sp++;
+               } else {
+                       *p++ = isupper(*sp) ? tolower(*sp++) : *sp++;
+               }
+       }
+       *p = '\0';
+       hostf = superuser ? (FILE *)0 : fopen("/etc/hosts.equiv", "r");

 again:
        if (hostf) {
 again:
        if (hostf) {

-               while (fgets(ahost, sizeof (ahost), hostf)) {
-                       char *user;
-                       if (index(ahost, '\n'))
-                               *index(ahost, '\n') = 0;
-                       user = index(ahost, ' ');
-                       if (user)
-                               *user++ = 0;
-                       if (!strcmp(rhost, ahost) &&
-                           !strcmp(ruser, user ? user : luser))
-                               goto ok;
+               if (!_validuser(hostf, fhost, luser, ruser, baselen)) {
+                       (void) fclose(hostf);
+                       return(0);

                }
                (void) fclose(hostf);
        }
                }
                (void) fclose(hostf);
        }

-       if (first == 1) {
+       if (first == 1 && (_check_rhosts_file || superuser)) {
+               struct stat sbuf;
+               struct passwd *pwd;
+               char pbuf[MAXPATHLEN];
+

                first = 0;
                first = 0;

-               hostf = fopen(".rhosts", "r");
+               if ((pwd = getpwnam(luser)) == NULL)
+                       return(-1);
+               (void)strcpy(pbuf, pwd->pw_dir);
+               (void)strcat(pbuf, "/.rhosts");
+               if ((hostf = fopen(pbuf, "r")) == NULL)
+                       return(-1);
+               /*
+                * if owned by someone other than user or root or if
+                * writeable by anyone but the owner, quit
+                */
+               if (fstat(fileno(hostf), &sbuf) ||
+                   sbuf.st_uid && sbuf.st_uid != pwd->pw_uid ||
+                   sbuf.st_mode&022) {
+                       fclose(hostf);
+                       return(-1);
+               }

                goto again;
        }
        return (-1);
                goto again;
        }
        return (-1);

-ok:
-       (void) fclose(hostf);
-       return (0);
+}
+
+static
+_validuser(hostf, rhost, luser, ruser, baselen)
+       char *rhost, *luser, *ruser;
+       FILE *hostf;
+       int baselen;
+{
+       char *user;
+       char ahost[MAXHOSTNAMELEN];
+       register char *p;
+
+       while (fgets(ahost, sizeof (ahost), hostf)) {
+               p = ahost;
+               while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0') {
+                       *p = isupper(*p) ? tolower(*p) : *p;
+                       p++;
+               }
+               if (*p == ' ' || *p == '\t') {
+                       *p++ = '\0';
+                       while (*p == ' ' || *p == '\t')
+                               p++;
+                       user = p;
+                       while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0')
+                               p++;
+               } else
+                       user = p;
+               *p = '\0';
+               if (_checkhost(rhost, ahost, baselen) &&
+                   !strcmp(ruser, *user ? user : luser)) {
+                       return (0);
+               }
+       }
+       return (-1);
+}
+
+static
+_checkhost(rhost, lhost, len)
+       char *rhost, *lhost;
+       int len;
+{
+       static char ldomain[MAXHOSTNAMELEN + 1];
+       static char *domainp = NULL;
+       static int nodomain = 0;
+       register char *cp;
+
+       if (len == -1)
+               return(!strcmp(rhost, lhost));
+       if (strncmp(rhost, lhost, len))
+               return(0);
+       if (!strcmp(rhost, lhost))
+               return(1);
+       if (*(lhost + len) != '\0')
+               return(0);
+       if (nodomain)
+               return(0);
+       if (!domainp) {
+               if (gethostname(ldomain, sizeof(ldomain)) == -1) {
+                       nodomain = 1;
+                       return(0);
+               }
+               ldomain[MAXHOSTNAMELEN] = NULL;
+               if ((domainp = index(ldomain, '.')) == (char *)NULL) {
+                       nodomain = 1;
+                       return(0);
+               }
+               for (cp = ++domainp; *cp; ++cp)
+                       if (isupper(*cp))
+                               *cp = tolower(*cp);
+       }
+       return(!strcmp(domainp, rhost + len +1));

 }
 }