break out special local mail processing (e.g., mapping to the

[unix-history] / usr / src / bin / rcp / rcp.c

diff --git a/usr/src/bin/rcp/rcp.c b/usr/src/bin/rcp/rcp.c
index dff2277..09cab59 100644 (file)
--- a/usr/src/bin/rcp/rcp.c
+++ b/usr/src/bin/rcp/rcp.c
@@ -1,133 +1,122 @@
 /*
 /*

- * Copyright (c) 1983 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1983, 1990, 1992, 1993
+ *     The 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 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * %sccs.include.redist.c%

  */
 
 #ifndef lint
  */
 
 #ifndef lint

-char copyright[] =
-"@(#) Copyright (c) 1983 The Regents of the University of California.\n\
- All rights reserved.\n";
+static char copyright[] =
+"@(#) Copyright (c) 1983, 1990, 1992, 1993\n\
+       The Regents of the University of California.  All rights reserved.\n";

 #endif /* not lint */
 
 #ifndef lint
 #endif /* not lint */
 
 #ifndef lint

-static char sccsid[] = "@(#)rcp.c      5.18 (Berkeley) %G%";
+static char sccsid[] = "@(#)rcp.c      8.2 (Berkeley) %G%";

 #endif /* not lint */
 
 #endif /* not lint */
 

-/*
- * rcp
- */

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

-#include <sys/file.h>

 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/stat.h>
 #include <sys/time.h>

-#include <sys/ioctl.h>
-#include <sys/dir.h>
-#include <sys/signal.h>
+#include <sys/socket.h>

 #include <netinet/in.h>
 #include <netinet/in.h>

-#include <pwd.h>
-#include <netdb.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+
+#include <ctype.h>
+#include <dirent.h>
+#include <err.h>

 #include <errno.h>
 #include <errno.h>

-#include <strings.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <pwd.h>
+#include <signal.h>

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

-#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string.h>
+#include <unistd.h>
+

 #include "pathnames.h"
 #include "pathnames.h"

+#include "extern.h"

 
 #ifdef KERBEROS
 
 #ifdef KERBEROS

-#include <kerberos/krb.h>
-
-char krb_realm[REALM_SZ];
-int use_kerberos = 1, encrypt = 0;
-CREDENTIALS cred;
-Key_schedule schedule;
+#include <kerberosIV/des.h>
+#include <kerberosIV/krb.h>
+
+char   dst_realm_buf[REALM_SZ];
+char   *dest_realm = NULL;
+int    use_kerberos = 1;
+CREDENTIALS    cred;
+Key_schedule   schedule;
+extern char    *krb_realmofhost();
+#define        OPTIONS "dfKk:prt"
+#else
+#define        OPTIONS "dfprt"

 #endif
 
 #endif
 

-extern int errno;
-extern char *sys_errlist[];

 struct passwd *pwd;
 struct passwd *pwd;

-int errs, pflag, port, rem, userid;
-int iamremote, iamrecursive, targetshouldbedirectory;
+u_short        port;
+uid_t  userid;
+int errs, rem;
+int pflag, iamremote, iamrecursive, targetshouldbedirectory;

 
 

-#define        CMDNEEDS        20
+#define        CMDNEEDS        64

 char cmd[CMDNEEDS];            /* must hold "rcp -r -p -d\0" */
 
 char cmd[CMDNEEDS];            /* must hold "rcp -r -p -d\0" */
 

-typedef struct _buf {
-       int     cnt;
-       char    *buf;
-} BUF;
-
+#ifdef KERBEROS
+int     kerberos __P((char **, char *, char *, char *));
+void    oldw __P((const char *, ...));
+#endif
+int     response __P((void));
+void    rsource __P((char *, struct stat *));
+void    sink __P((int, char *[]));
+void    source __P((int, char *[]));
+void    tolocal __P((int, char *[]));
+void    toremote __P((char *, int, char *[]));
+void    usage __P((void));
+
+int

 main(argc, argv)
        int argc;
 main(argc, argv)
        int argc;

-       char **argv;
+       char *argv[];

 {
 {

-       extern int optind;

        struct servent *sp;
        int ch, fflag, tflag;
        struct servent *sp;
        int ch, fflag, tflag;

-       char *targ, *colon();
-       struct passwd *getpwuid();
-       int lostconn();
+       char *targ, *shell;

 
 

+       fflag = tflag = 0;
+       while ((ch = getopt(argc, argv, OPTIONS)) != EOF)
+               switch(ch) {                    /* User-visible flags. */
+               case 'K':

 #ifdef KERBEROS
 #ifdef KERBEROS

-       sp = getservbyname("kshell", "tcp");
-       if (sp == NULL) {
-               use_kerberos = 0;
-               old_warning("kshell service unknown");
-               sp = getservbyname("kshell", "tcp");
-       }
-#else
-       sp = getservbyname("shell", "tcp");
+                       use_kerberos = 0;

 #endif
 #endif

-       if (!sp) {
-               (void)fprintf(stderr, "rcp: shell/tcp: unknown service\n");
-               exit(1);
-       }
-       port = sp->s_port;
-
-       if (!(pwd = getpwuid(userid = getuid()))) {
-               (void)fprintf(stderr, "rcp: unknown user %d.\n", userid);
-               exit(1);
-       }
-
-       fflag = tflag = 0;
-       while ((ch = getopt(argc, argv, "dfkprtx")) != EOF)
-               switch(ch) {
-               case 'd':
-                       targetshouldbedirectory = 1;
-                       break;
-               case 'f':                       /* "from" */
-                       fflag = 1;

                        break;
                        break;

-#ifdef KERBEROS
+#ifdef KERBEROS

                case 'k':
                case 'k':

-                       strncpy(krb_realm, ++argv, REALM_SZ);
+                       dest_realm = dst_realm_buf;
+                       (void)strncpy(dst_realm_buf, optarg, REALM_SZ);

                        break;
 #endif
                        break;
 #endif

-               case 'p':                       /* preserve access/mod times */
-                       ++pflag;
+               case 'p':
+                       pflag = 1;

                        break;
                case 'r':
                        break;
                case 'r':

-                       ++iamrecursive;
+                       iamrecursive = 1;
+                       break;
+                                               /* Server options. */
+               case 'd':
+                       targetshouldbedirectory = 1;
+                       break;
+               case 'f':                       /* "from" */
+                       iamremote = 1;
+                       fflag = 1;

                        break;
                case 't':                       /* "to" */
                        break;
                case 't':                       /* "to" */

+                       iamremote = 1;

                        tflag = 1;
                        break;
                        tflag = 1;
                        break;

-#ifdef KERBEROS
-               case 'x':
-                       encrypt = 1;
-                       des_set_key(cred.session, schedule);
-                       break;
-#endif

                case '?':
                default:
                        usage();
                case '?':
                default:
                        usage();


@@ -135,16 +124,36 @@ main(argc, argv)
        argc -= optind;
        argv += optind;
 
        argc -= optind;
        argv += optind;
 

-       if (fflag) {
-               iamremote = 1;
+#ifdef KERBEROS
+       if (use_kerberos) {
+               shell = "kshell";
+               if ((sp = getservbyname(shell, "tcp")) == NULL) {
+                       use_kerberos = 0;
+                       oldw("can't get entry for %s/tcp service", shell);
+                       sp = getservbyname(shell = "shell", "tcp");
+               }
+       } else
+               sp = getservbyname(shell = "shell", "tcp");
+#else
+       sp = getservbyname(shell = "shell", "tcp");
+#endif
+       if (sp == NULL)
+               errx(1, "%s/tcp: unknown service", shell);
+       port = sp->s_port;
+
+       if ((pwd = getpwuid(userid = getuid())) == NULL)
+               errx(1, "unknown user %d", (int)userid);
+
+       rem = STDIN_FILENO;             /* XXX */
+
+       if (fflag) {                    /* Follow "protocol", send data. */

                (void)response();
                (void)setuid(userid);
                source(argc, argv);
                exit(errs);
        }
 
                (void)response();
                (void)setuid(userid);
                source(argc, argv);
                exit(errs);
        }
 

-       if (tflag) {
-               iamremote = 1;
+       if (tflag) {                    /* Receive data. */

                (void)setuid(userid);
                sink(argc, argv);
                exit(errs);
                (void)setuid(userid);
                sink(argc, argv);
                exit(errs);


@@ -156,35 +165,44 @@ main(argc, argv)
                targetshouldbedirectory = 1;
 
        rem = -1;
                targetshouldbedirectory = 1;
 
        rem = -1;

-       (void)sprintf(cmd, "rcp%s%s%s", iamrecursive ? " -r" : "",
+       /* Command to be executed on remote system using "rsh". */
+#ifdef KERBEROS
+       (void)snprintf(cmd, sizeof(cmd),
+           "rcp%s%s%s%s", iamrecursive ? " -r" : "",
+           "",

            pflag ? " -p" : "", targetshouldbedirectory ? " -d" : "");
            pflag ? " -p" : "", targetshouldbedirectory ? " -d" : "");

+#else
+       (void)snprintf(cmd, sizeof(cmd), "rcp%s%s%s",
+           iamrecursive ? " -r" : "", pflag ? " -p" : "",
+           targetshouldbedirectory ? " -d" : "");
+#endif

 
        (void)signal(SIGPIPE, lostconn);
 
 
        (void)signal(SIGPIPE, lostconn);
 

-       if (targ = colon(argv[argc - 1]))
+       if (targ = colon(argv[argc - 1]))       /* Dest is remote host. */

                toremote(targ, argc, argv);
        else {
                toremote(targ, argc, argv);
        else {

-               tolocal(argc, argv);
+               tolocal(argc, argv);            /* Dest is local host. */

                if (targetshouldbedirectory)
                        verifydir(argv[argc - 1]);
        }
        exit(errs);
 }
 
                if (targetshouldbedirectory)
                        verifydir(argv[argc - 1]);
        }
        exit(errs);
 }
 

+void

 toremote(targ, argc, argv)
 toremote(targ, argc, argv)

-       char *targ;
+       char *targ, *argv[];

        int argc;
        int argc;

-       char **argv;

 {
 {

-       int i;
+       int i, len, tos;

        char *bp, *host, *src, *suser, *thost, *tuser;
        char *bp, *host, *src, *suser, *thost, *tuser;

-       char *colon(), *malloc();

 
        *targ++ = 0;
        if (*targ == 0)
                targ = ".";
 
 
        *targ++ = 0;
        if (*targ == 0)
                targ = ".";
 

-       if (thost = index(argv[argc - 1], '@')) {
+       if (thost = strchr(argv[argc - 1], '@')) {
+               /* user@host */

                *thost++ = 0;
                tuser = argv[argc - 1];
                if (*tuser == '\0')
                *thost++ = 0;
                tuser = argv[argc - 1];
                if (*tuser == '\0')


@@ -202,12 +220,12 @@ toremote(targ, argc, argv)
                        *src++ = 0;
                        if (*src == 0)
                                src = ".";
                        *src++ = 0;
                        if (*src == 0)
                                src = ".";

-                       host = index(argv[i], '@');
-                       if (!(bp = malloc((u_int)(strlen(_PATH_RSH) +
-                                   strlen(argv[i]) + strlen(src) +
-                                   strlen(tuser) + strlen(thost) +
-                                   strlen(targ)) + CMDNEEDS + 20)))
-                                       nospace();
+                       host = strchr(argv[i], '@');
+                       len = strlen(_PATH_RSH) + strlen(argv[i]) +
+                           strlen(src) + (tuser ? strlen(tuser) : 0) +
+                           strlen(thost) + strlen(targ) + CMDNEEDS + 20;
+                       if (!(bp = malloc(len)))
+                               err(1, NULL);

                        if (host) {
                                *host++ = 0;
                                suser = argv[i];
                        if (host) {
                                *host++ = 0;
                                suser = argv[i];


@@ -215,28 +233,30 @@ toremote(targ, argc, argv)
                                        suser = pwd->pw_name;
                                else if (!okname(suser))
                                        continue;
                                        suser = pwd->pw_name;
                                else if (!okname(suser))
                                        continue;

-                               (void)sprintf(bp,
+                               (void)snprintf(bp, len,

                                    "%s %s -l %s -n %s %s '%s%s%s:%s'",
                                    _PATH_RSH, host, suser, cmd, src,
                                    tuser ? tuser : "", tuser ? "@" : "",
                                    thost, targ);
                        } else
                                    "%s %s -l %s -n %s %s '%s%s%s:%s'",
                                    _PATH_RSH, host, suser, cmd, src,
                                    tuser ? tuser : "", tuser ? "@" : "",
                                    thost, targ);
                        } else

-                               (void)sprintf(bp, "%s %s -n %s %s '%s%s%s:%s'",
+                               (void)snprintf(bp, len,
+                                   "exec %s %s -n %s %s '%s%s%s:%s'",

                                    _PATH_RSH, argv[i], cmd, src,
                                    tuser ? tuser : "", tuser ? "@" : "",
                                    thost, targ);
                                    _PATH_RSH, argv[i], cmd, src,
                                    tuser ? tuser : "", tuser ? "@" : "",
                                    thost, targ);

-                       (void)susystem(bp);
+                       (void)susystem(bp, userid);

                        (void)free(bp);
                } else {                        /* local to remote */
                        if (rem == -1) {
                        (void)free(bp);
                } else {                        /* local to remote */
                        if (rem == -1) {

-                               if (!(bp = malloc((u_int)strlen(targ) +
-                                   CMDNEEDS + 20)))
-                                       nospace();
-                               (void)sprintf(bp, "%s -t %s", cmd, targ);
+                               len = strlen(targ) + CMDNEEDS + 20;
+                               if (!(bp = malloc(len)))
+                                       err(1, NULL);
+                               (void)snprintf(bp, len, "%s -t %s", cmd, targ);

                                host = thost;
 #ifdef KERBEROS
                                if (use_kerberos)
                                host = thost;
 #ifdef KERBEROS
                                if (use_kerberos)

-                                       kerberos(bp,
+                                       rem = kerberos(&host, bp,
+                                           pwd->pw_name,

                                            tuser ? tuser : pwd->pw_name);
                                else
 #endif
                                            tuser ? tuser : pwd->pw_name);
                                else
 #endif


@@ -245,6 +265,10 @@ toremote(targ, argc, argv)
                                            bp, 0);
                                if (rem < 0)
                                        exit(1);
                                            bp, 0);
                                if (rem < 0)
                                        exit(1);

+                               tos = IPTOS_THROUGHPUT;
+                               if (setsockopt(rem, IPPROTO_IP, IP_TOS,
+                                   &tos, sizeof(int)) < 0)
+                                       warn("TOS (ignored)");

                                if (response() < 0)
                                        exit(1);
                                (void)free(bp);
                                if (response() < 0)
                                        exit(1);
                                (void)free(bp);


@@ -255,353 +279,221 @@ toremote(targ, argc, argv)
        }
 }
 
        }
 }
 

+void

 tolocal(argc, argv)
        int argc;
 tolocal(argc, argv)
        int argc;

-       char **argv;
+       char *argv[];

 {
 {

-       int i;
+       int i, len, tos;

        char *bp, *host, *src, *suser;
        char *bp, *host, *src, *suser;

-       char *colon(), *malloc();

 
        for (i = 0; i < argc - 1; i++) {
 
        for (i = 0; i < argc - 1; i++) {

-               if (!(src = colon(argv[i]))) {  /* local to local */
-                       if (!(bp = malloc((u_int)(strlen(_PATH_CP) +
-                           strlen(argv[i]) + strlen(argv[argc - 1])) + 20)))
-                               nospace();
-                       (void)sprintf(bp, "%s%s%s %s %s", _PATH_CP,
+               if (!(src = colon(argv[i]))) {          /* Local to local. */
+                       len = strlen(_PATH_CP) + strlen(argv[i]) +
+                           strlen(argv[argc - 1]) + 20;
+                       if (!(bp = malloc(len)))
+                               err(1, NULL);
+                       (void)snprintf(bp, len, "exec %s%s%s %s %s", _PATH_CP,

                            iamrecursive ? " -r" : "", pflag ? " -p" : "",
                            argv[i], argv[argc - 1]);
                            iamrecursive ? " -r" : "", pflag ? " -p" : "",
                            argv[i], argv[argc - 1]);

-                       (void)susystem(bp);
+                       if (susystem(bp, userid))
+                               ++errs;

                        (void)free(bp);
                        continue;
                }
                *src++ = 0;
                if (*src == 0)
                        src = ".";
                        (void)free(bp);
                        continue;
                }
                *src++ = 0;
                if (*src == 0)
                        src = ".";

-               host = index(argv[i], '@');
-               if (host) {
+               if ((host = strchr(argv[i], '@')) == NULL) {
+                       host = argv[i];
+                       suser = pwd->pw_name;
+               } else {

                        *host++ = 0;
                        suser = argv[i];
                        if (*suser == '\0')
                                suser = pwd->pw_name;
                        else if (!okname(suser))
                                continue;
                        *host++ = 0;
                        suser = argv[i];
                        if (*suser == '\0')
                                suser = pwd->pw_name;
                        else if (!okname(suser))
                                continue;

-               } else {
-                       host = argv[i];
-                       suser = pwd->pw_name;

                }
                }

-               if (!(bp = malloc((u_int)(strlen(src)) + CMDNEEDS + 20)))
-                       nospace();
-               (void)sprintf(bp, "%s -f %s", cmd, src);
+               len = strlen(src) + CMDNEEDS + 20;
+               if ((bp = malloc(len)) == NULL)
+                       err(1, NULL);
+               (void)snprintf(bp, len, "%s -f %s", cmd, src);
+               rem = 

 #ifdef KERBEROS
 #ifdef KERBEROS

-               if (use_kerberos)
-                       kerberos(bp, suser);
-               else
+                   use_kerberos ? 
+                       kerberos(&host, bp, pwd->pw_name, suser) : 

 #endif
 #endif

-                       rem = rcmd(&host, port, pwd->pw_name, suser, bp, 0);
+                       rcmd(&host, port, pwd->pw_name, suser, bp, 0);

                (void)free(bp);
                (void)free(bp);

-               if (rem < 0)
+               if (rem < 0) {
+                       ++errs;

                        continue;
                        continue;

-               (void)setreuid(0, userid);
+               }
+               (void)seteuid(userid);
+               tos = IPTOS_THROUGHPUT;
+               if (setsockopt(rem, IPPROTO_IP, IP_TOS, &tos, sizeof(int)) < 0)
+                       warn("TOS (ignored)");

                sink(1, argv + argc - 1);
                sink(1, argv + argc - 1);

-               (void)setreuid(userid, 0);
+               (void)seteuid(0);

                (void)close(rem);
                rem = -1;
        }
 }
 
                (void)close(rem);
                rem = -1;
        }
 }
 

-#ifdef KERBEROS
-kerberos(bp, user)
-       char *bp, *user;
-{
-       struct servent *sp;
-       char *host;
-
-again: rem = KSUCCESS;
-       if (krb_realm[0] == '\0')
-               rem = krb_get_lrealm(krb_realm, 1);
-       if (rem == KSUCCESS) {
-               if (encrypt)
-                       rem = krcmd_mutual(&host, port, user, bp, 0,
-                           krb_realm, &cred, schedule);
-               else
-                       rem = krcmd(&host, port, user, bp, 0, krb_realm);
-       } else {
-               (void)fprintf(stderr,
-                   "rcp: error getting local realm %s\n", krb_err_txt[rem]);
-               exit(1);
-       }
-       if (rem < 0 && errno == ECONNREFUSED) {
-               use_kerberos = 0;
-               old_warning("remote host doesn't support Kerberos");
-               sp = getservbyname("shell", "tcp");
-               if (sp == NULL) {
-                       (void)fprintf(stderr,
-                           "rcp: unknown service shell/tcp\n");
-                       exit(1);
-               }
-               port = sp->s_port;
-               goto again;
-       }
-}
-#endif /* KERBEROS */
-
-verifydir(cp)
-       char *cp;
-{
-       struct stat stb;
-
-       if (stat(cp, &stb) >= 0) {
-               if ((stb.st_mode & S_IFMT) == S_IFDIR)
-                       return;
-               errno = ENOTDIR;
-       }
-       error("rcp: %s: %s.\n", cp, sys_errlist[errno]);
-       exit(1);
-}
-
-char *
-colon(cp)
-       register char *cp;
-{
-       for (; *cp; ++cp) {
-               if (*cp == ':')
-                       return(cp);
-               if (*cp == '/')
-                       return(0);
-       }
-       return(0);
-}
-
-okname(cp0)
-       char *cp0;
-{
-       register char *cp = cp0;
-       register int c;
-
-       do {
-               c = *cp;
-               if (c & 0200)
-                       goto bad;
-               if (!isalpha(c) && !isdigit(c) && c != '_' && c != '-')
-                       goto bad;
-       } while (*++cp);
-       return(1);
-bad:
-       (void)fprintf(stderr, "rcp: invalid user name %s\n", cp0);
-       return(0);
-}
-
-susystem(s)
-       char *s;
-{
-       int status, pid, w;
-       register int (*istat)(), (*qstat)();
-
-       if ((pid = vfork()) == 0) {
-               (void)setuid(userid);
-               execl(_PATH_BSHELL, "sh", "-c", s, (char *)0);
-               _exit(127);
-       }
-       istat = signal(SIGINT, SIG_IGN);
-       qstat = signal(SIGQUIT, SIG_IGN);
-       while ((w = wait(&status)) != pid && w != -1)
-               ;
-       if (w == -1)
-               status = -1;
-       (void)signal(SIGINT, istat);
-       (void)signal(SIGQUIT, qstat);
-       return(status);
-}
-
+void

 source(argc, argv)
        int argc;
 source(argc, argv)
        int argc;

-       char **argv;
+       char *argv[];

 {
        struct stat stb;
        static BUF buffer;
        BUF *bp;
        off_t i;
 {
        struct stat stb;
        static BUF buffer;
        BUF *bp;
        off_t i;

-       int x, readerr, f, amt;
+       int amt, fd, haderr, indx, result;

        char *last, *name, buf[BUFSIZ];
        char *last, *name, buf[BUFSIZ];

-       BUF *allocbuf();

 
 

-       for (x = 0; x < argc; x++) {
-               name = argv[x];
-               if ((f = open(name, O_RDONLY, 0)) < 0) {
-                       error("rcp: %s: %s\n", name, sys_errlist[errno]);
-                       continue;
+       for (indx = 0; indx < argc; ++indx) {
+                name = argv[indx];
+               if ((fd = open(name, O_RDONLY, 0)) < 0)
+                       goto syserr;
+               if (fstat(fd, &stb)) {
+syserr:                        run_err("%s: %s", name, strerror(errno));
+                       goto next;

                }
                }

-               if (fstat(f, &stb) < 0)
-                       goto notreg;
-               switch (stb.st_mode&S_IFMT) {
-
+               switch (stb.st_mode & S_IFMT) {

                case S_IFREG:
                        break;
                case S_IFREG:
                        break;

-

                case S_IFDIR:
                        if (iamrecursive) {
                case S_IFDIR:
                        if (iamrecursive) {

-                               (void)close(f);

                                rsource(name, &stb);
                                rsource(name, &stb);

-                               continue;
+                               goto next;

                        }
                        /* FALLTHROUGH */
                default:
                        }
                        /* FALLTHROUGH */
                default:

-notreg:                        (void)close(f);
-                       error("rcp: %s: not a plain file\n", name);
-                       continue;
+                       run_err("%s: not a regular file", name);
+                       goto next;

                }
                }

-               last = rindex(name, '/');
-               if (last == 0)
+               if ((last = strrchr(name, '/')) == NULL)

                        last = name;
                else
                        last = name;
                else

-                       last++;
+                       ++last;

                if (pflag) {
                        /*
                         * Make it compatible with possible future
                         * versions expecting microseconds.
                         */
                if (pflag) {
                        /*
                         * Make it compatible with possible future
                         * versions expecting microseconds.
                         */

-                       (void)sprintf(buf, "T%ld 0 %ld 0\n", stb.st_mtime,
-                           stb.st_atime);
+                       (void)snprintf(buf, sizeof(buf), "T%ld 0 %ld 0\n",
+                           stb.st_mtimespec.ts_sec, stb.st_atimespec.ts_sec);

                        (void)write(rem, buf, strlen(buf));
                        (void)write(rem, buf, strlen(buf));

-                       if (response() < 0) {
-                               (void)close(f);
-                               continue;
-                       }
+                       if (response() < 0)
+                               goto next;

                }
                }

-               (void)sprintf(buf, "C%04o %ld %s\n", stb.st_mode&07777,
-                   stb.st_size, last);
+#define        MODEMASK        (S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO)
+               (void)snprintf(buf, sizeof(buf), "C%04o %qd %s\n",
+                   stb.st_mode & MODEMASK, stb.st_size, last);

                (void)write(rem, buf, strlen(buf));
                (void)write(rem, buf, strlen(buf));

-               if (response() < 0) {
-                       (void)close(f);
+               if (response() < 0)
+                       goto next;
+               if ((bp = allocbuf(&buffer, fd, BUFSIZ)) == NULL) {
+next:                  (void)close(fd);

                        continue;
                }
                        continue;
                }

-               if ((bp = allocbuf(&buffer, f, BUFSIZ)) == 0) {
-                       (void)close(f);
-                       continue;
-               }
-               readerr = 0;
-               for (i = 0; i < stb.st_size; i += bp->cnt) {
+
+               /* Keep writing after an error so that we stay sync'd up. */
+               for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {

                        amt = bp->cnt;
                        if (i + amt > stb.st_size)
                                amt = stb.st_size - i;
                        amt = bp->cnt;
                        if (i + amt > stb.st_size)
                                amt = stb.st_size - i;

-                       if (readerr == 0 && read(f, bp->buf, amt) != amt)
-                               readerr = errno;
-                       (void)write(rem, bp->buf, amt);
+                       if (!haderr) {
+                               result = read(fd, bp->buf, amt);
+                               if (result != amt)
+                                       haderr = result >= 0 ? EIO : errno;
+                       }
+                       if (haderr)
+                               (void)write(rem, bp->buf, amt);
+                       else {
+                               result = write(rem, bp->buf, amt);
+                               if (result != amt)
+                                       haderr = result >= 0 ? EIO : errno;
+                       }

                }
                }

-               (void)close(f);
-               if (readerr == 0)
+               if (close(fd) && !haderr)
+                       haderr = errno;
+               if (!haderr)

                        (void)write(rem, "", 1);
                else
                        (void)write(rem, "", 1);
                else

-                       error("rcp: %s: %s\n", name, sys_errlist[readerr]);
+                       run_err("%s: %s", name, strerror(haderr));

                (void)response();
        }
 }
 
                (void)response();
        }
 }
 

+void

 rsource(name, statp)
        char *name;
        struct stat *statp;
 {
 rsource(name, statp)
        char *name;
        struct stat *statp;
 {

-       DIR *d;
-       struct direct *dp;
+       DIR *dirp;
+       struct dirent *dp;

        char *last, *vect[1], path[MAXPATHLEN];
 
        char *last, *vect[1], path[MAXPATHLEN];
 

-       if (!(d = opendir(name))) {
-               error("rcp: %s: %s\n", name, sys_errlist[errno]);
+       if (!(dirp = opendir(name))) {
+               run_err("%s: %s", name, strerror(errno));

                return;
        }
                return;
        }

-       last = rindex(name, '/');
+       last = strrchr(name, '/');

        if (last == 0)
                last = name;
        else
                last++;
        if (pflag) {
        if (last == 0)
                last = name;
        else
                last++;
        if (pflag) {

-               (void)sprintf(path, "T%ld 0 %ld 0\n", statp->st_mtime,
-                   statp->st_atime);
+               (void)snprintf(path, sizeof(path), "T%ld 0 %ld 0\n",
+                   statp->st_mtimespec.ts_sec, statp->st_atimespec.ts_sec);

                (void)write(rem, path, strlen(path));
                if (response() < 0) {
                (void)write(rem, path, strlen(path));
                if (response() < 0) {

-                       closedir(d);
+                       closedir(dirp);

                        return;
                }
        }
                        return;
                }
        }

-       (void)sprintf(path, "D%04o %d %s\n", statp->st_mode&07777, 0, last);
+       (void)snprintf(path, sizeof(path),
+           "D%04o %d %s\n", statp->st_mode & MODEMASK, 0, last);

        (void)write(rem, path, strlen(path));
        if (response() < 0) {
        (void)write(rem, path, strlen(path));
        if (response() < 0) {

-               closedir(d);
+               closedir(dirp);

                return;
        }
                return;
        }

-       while (dp = readdir(d)) {
+       while (dp = readdir(dirp)) {

                if (dp->d_ino == 0)
                        continue;
                if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
                        continue;
                if (strlen(name) + 1 + strlen(dp->d_name) >= MAXPATHLEN - 1) {
                if (dp->d_ino == 0)
                        continue;
                if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
                        continue;
                if (strlen(name) + 1 + strlen(dp->d_name) >= MAXPATHLEN - 1) {

-                       error("%s/%s: name too long.\n", name, dp->d_name);
+                       run_err("%s/%s: name too long", name, dp->d_name);

                        continue;
                }
                        continue;
                }

-               (void)sprintf(path, "%s/%s", name, dp->d_name);
+               (void)snprintf(path, sizeof(path), "%s/%s", name, dp->d_name);

                vect[0] = path;
                source(1, vect);
        }
                vect[0] = path;
                source(1, vect);
        }

-       closedir(d);
+       (void)closedir(dirp);

        (void)write(rem, "E\n", 2);
        (void)response();
 }
 
        (void)write(rem, "E\n", 2);
        (void)response();
 }
 

-response()
-{
-       register char *cp;
-       char ch, resp, rbuf[BUFSIZ];
-
-       if (read(rem, &resp, sizeof(resp)) != sizeof(resp))
-               lostconn();
-
-       cp = rbuf;
-       switch(resp) {
-       case 0:                         /* ok */
-               return(0);
-       default:
-               *cp++ = resp;
-               /* FALLTHROUGH */
-       case 1:                         /* error, followed by err msg */
-       case 2:                         /* fatal error, "" */
-               do {
-                       if (read(rem, &ch, sizeof(ch)) != sizeof(ch))
-                               lostconn();
-                       *cp++ = ch;
-               } while (cp < &rbuf[BUFSIZ] && ch != '\n');
-
-               if (!iamremote)
-                       (void)write(2, rbuf, cp - rbuf);
-               ++errs;
-               if (resp == 1)
-                       return(-1);
-               exit(1);
-       }
-       /*NOTREACHED*/
-}
-
-lostconn()
-{
-       if (!iamremote)
-               (void)fprintf(stderr, "rcp: lost connection\n");
-       exit(1);
-}
-
+void

 sink(argc, argv)
        int argc;
 sink(argc, argv)
        int argc;

-       char **argv;
+       char *argv[];

 {
 {

-       register char *cp;

        static BUF buffer;
        struct stat stb;
        struct timeval tv[2];
        static BUF buffer;
        struct stat stb;
        struct timeval tv[2];

-       BUF *bp, *allocbuf();
+       enum { YES, NO, DISPLAYED } wrerr;
+       BUF *bp;

        off_t i, j;
        off_t i, j;

-       char ch, *targ, *why;
-       int amt, count, exists, first, mask, mode;
-       int ofd, setimes, size, targisdir, wrerr;
-       char *np, *vect[1], buf[BUFSIZ], *malloc();
+       int amt, count, exists, first, mask, mode, ofd, omode;
+       int setimes, size, targisdir, wrerrno;
+       char ch, *cp, *np, *targ, *why, *vect[1], buf[BUFSIZ];

 
 #define        atime   tv[0]
 #define        mtime   tv[1]
 
 #define        atime   tv[0]
 #define        mtime   tv[1]


@@ -612,14 +504,14 @@ sink(argc, argv)
        if (!pflag)
                (void)umask(mask);
        if (argc != 1) {
        if (!pflag)
                (void)umask(mask);
        if (argc != 1) {

-               error("rcp: ambiguous target\n");
+               run_err("ambiguous target");

                exit(1);
        }
        targ = *argv;
        if (targetshouldbedirectory)
                verifydir(targ);
        (void)write(rem, "", 1);
                exit(1);
        }
        targ = *argv;
        if (targetshouldbedirectory)
                verifydir(targ);
        (void)write(rem, "", 1);

-       if (stat(targ, &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFDIR)
+       if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))

                targisdir = 1;
        for (first = 1;; first = 0) {
                cp = buf;
                targisdir = 1;
        for (first = 1;; first = 0) {
                cp = buf;


@@ -632,16 +524,15 @@ sink(argc, argv)
                                SCREWUP("lost connection");
                        *cp++ = ch;
                } while (cp < &buf[BUFSIZ - 1] && ch != '\n');
                                SCREWUP("lost connection");
                        *cp++ = ch;
                } while (cp < &buf[BUFSIZ - 1] && ch != '\n');

-               if (ch == '\n')
-                       *--cp;

                *cp = 0;
 
                if (buf[0] == '\01' || buf[0] == '\02') {
                        if (iamremote == 0)
                *cp = 0;
 
                if (buf[0] == '\01' || buf[0] == '\02') {
                        if (iamremote == 0)

-                               (void)write(2, buf + 1, strlen(buf + 1));
+                               (void)write(STDERR_FILENO,
+                                   buf + 1, strlen(buf + 1));

                        if (buf[0] == '\02')
                                exit(1);
                        if (buf[0] == '\02')
                                exit(1);

-                       errs++;
+                       ++errs;

                        continue;
                }
                if (buf[0] == 'E') {
                        continue;
                }
                if (buf[0] == 'E') {


@@ -649,6 +540,9 @@ sink(argc, argv)
                        return;
                }
 
                        return;
                }
 

+               if (ch == '\n')
+                       *--cp = 0;
+

 #define getnum(t) (t) = 0; while (isdigit(*cp)) (t) = (t) * 10 + (*cp++ - '0');
                cp = buf;
                if (*cp == 'T') {
 #define getnum(t) (t) = 0; while (isdigit(*cp)) (t) = (t) * 10 + (*cp++ - '0');
                cp = buf;
                if (*cp == 'T') {


@@ -678,7 +572,7 @@ sink(argc, argv)
                         * followed.
                         */
                        if (first) {
                         * followed.
                         */
                        if (first) {

-                               error("%s\n", cp);
+                               run_err("%s", cp);

                                exit(1);
                        }
                        SCREWUP("expected control record");
                                exit(1);
                        }
                        SCREWUP("expected control record");


@@ -691,63 +585,68 @@ sink(argc, argv)
                }
                if (*cp++ != ' ')
                        SCREWUP("mode not delimited");
                }
                if (*cp++ != ' ')
                        SCREWUP("mode not delimited");

-               size = 0;
-               while (isdigit(*cp))
+
+               for (size = 0; isdigit(*cp);)

                        size = size * 10 + (*cp++ - '0');
                if (*cp++ != ' ')
                        SCREWUP("size not delimited");
                if (targisdir) {
                        static char *namebuf;
                        static int cursize;
                        size = size * 10 + (*cp++ - '0');
                if (*cp++ != ' ')
                        SCREWUP("size not delimited");
                if (targisdir) {
                        static char *namebuf;
                        static int cursize;

-                       int need;
+                       size_t need;

 
                        need = strlen(targ) + strlen(cp) + 250;
                        if (need > cursize) {
 
                        need = strlen(targ) + strlen(cp) + 250;
                        if (need > cursize) {

-                               if (!(namebuf = malloc((u_int)need)))
-                                       error("out of memory");
+                               if (!(namebuf = malloc(need)))
+                                       run_err("%s", strerror(errno));

                        }
                        }

-                       (void)sprintf(namebuf, "%s%s%s", targ,
+                       (void)snprintf(namebuf, need, "%s%s%s", targ,

                            *targ ? "/" : "", cp);
                        np = namebuf;
                            *targ ? "/" : "", cp);
                        np = namebuf;

-               }
-               else
+               } else

                        np = targ;
                exists = stat(np, &stb) == 0;
                if (buf[0] == 'D') {
                        np = targ;
                exists = stat(np, &stb) == 0;
                if (buf[0] == 'D') {

+                       int mod_flag = pflag;

                        if (exists) {
                        if (exists) {

-                               if ((stb.st_mode&S_IFMT) != S_IFDIR) {
+                               if (!S_ISDIR(stb.st_mode)) {

                                        errno = ENOTDIR;
                                        goto bad;
                                }
                                if (pflag)
                                        (void)chmod(np, mode);
                                        errno = ENOTDIR;
                                        goto bad;
                                }
                                if (pflag)
                                        (void)chmod(np, mode);

-                       } else if (mkdir(np, mode) < 0)
-                               goto bad;
+                       } else {
+                               /* Handle copying from a read-only directory */
+                               mod_flag = 1;
+                               if (mkdir(np, mode | S_IRWXU) < 0)
+                                       goto bad;
+                       }

                        vect[0] = np;
                        sink(1, vect);
                        if (setimes) {
                                setimes = 0;
                                if (utimes(np, tv) < 0)
                        vect[0] = np;
                        sink(1, vect);
                        if (setimes) {
                                setimes = 0;
                                if (utimes(np, tv) < 0)

-                                   error("rcp: can't set times on %s: %s\n",
-                                       np, sys_errlist[errno]);
+                                   run_err("%s: set times: %s",
+                                       np, strerror(errno));

                        }
                        }

+                       if (mod_flag)
+                               (void)chmod(np, mode);

                        continue;
                }
                        continue;
                }

+               omode = mode;
+               mode |= S_IWRITE;

                if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
                if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {

-bad:                   error("rcp: %s: %s\n", np, sys_errlist[errno]);
+bad:                   run_err("%s: %s", np, strerror(errno));

                        continue;
                }
                        continue;
                }

-               if (exists && pflag)
-                       (void)fchmod(ofd, mode);

                (void)write(rem, "", 1);
                (void)write(rem, "", 1);

-               if ((bp = allocbuf(&buffer, ofd, BUFSIZ)) == 0) {
+               if ((bp = allocbuf(&buffer, ofd, BUFSIZ)) == NULL) {

                        (void)close(ofd);
                        continue;
                }
                cp = bp->buf;
                        (void)close(ofd);
                        continue;
                }
                cp = bp->buf;

-               count = 0;
-               wrerr = 0;
-               for (i = 0; i < size; i += BUFSIZ) {
+               wrerr = NO;
+               for (count = i = 0; i < size; i += BUFSIZ) {

                        amt = BUFSIZ;
                        if (i + amt > size)
                                amt = size - i;
                        amt = BUFSIZ;
                        if (i + amt > size)
                                amt = size - i;


@@ -755,8 +654,7 @@ bad:                        error("rcp: %s: %s\n", np, sys_errlist[errno]);
                        do {
                                j = read(rem, cp, amt);
                                if (j <= 0) {
                        do {
                                j = read(rem, cp, amt);
                                if (j <= 0) {

-                                       error("rcp: %s",
-                                           j ? sys_errlist[errno] :
+                                       run_err("%s", j ? strerror(errno) :

                                            "dropped connection");
                                        exit(1);
                                }
                                            "dropped connection");
                                        exit(1);
                                }


@@ -764,106 +662,202 @@ bad:                    error("rcp: %s: %s\n", np, sys_errlist[errno]);
                                cp += j;
                        } while (amt > 0);
                        if (count == bp->cnt) {
                                cp += j;
                        } while (amt > 0);
                        if (count == bp->cnt) {

-                               if (wrerr == 0 &&
-                                   write(ofd, bp->buf, count) != count)
-                                       wrerr++;
+                               /* Keep reading so we stay sync'd up. */
+                               if (wrerr == NO) {
+                                       j = write(ofd, bp->buf, count);
+                                       if (j != count) {
+                                               wrerr = YES;
+                                               wrerrno = j >= 0 ? EIO : errno; 
+                                       }
+                               }

                                count = 0;
                                cp = bp->buf;
                        }
                }
                                count = 0;
                                cp = bp->buf;
                        }
                }

-               if (count != 0 && wrerr == 0 &&
-                   write(ofd, bp->buf, count) != count)
-                       wrerr++;
-               if (ftruncate(ofd, size))
-                       error("rcp: can't truncate %s: %s\n", np,
-                           sys_errlist[errno]);
+               if (count != 0 && wrerr == NO &&
+                   (j = write(ofd, bp->buf, count)) != count) {
+                       wrerr = YES;
+                       wrerrno = j >= 0 ? EIO : errno; 
+               }
+               if (ftruncate(ofd, size)) {
+                       run_err("%s: truncate: %s", np, strerror(errno));
+                       wrerr = DISPLAYED;
+               }
+               if (pflag) {
+                       if (exists || omode != mode)
+                               if (fchmod(ofd, omode))
+                                       run_err("%s: set mode: %s",
+                                           np, strerror(errno));
+               } else {
+                       if (!exists && omode != mode)
+                               if (fchmod(ofd, omode & ~mask))
+                                       run_err("%s: set mode: %s",
+                                           np, strerror(errno));
+               }

                (void)close(ofd);
                (void)response();
                (void)close(ofd);
                (void)response();

-               if (setimes) {
+               if (setimes && wrerr == NO) {

                        setimes = 0;
                        setimes = 0;

-                       if (utimes(np, tv) < 0)
-                               error("rcp: can't set times on %s: %s\n",
-                                   np, sys_errlist[errno]);
-               }                                  
-               if (wrerr)
-                       error("rcp: %s: %s\n", np, sys_errlist[errno]);
-               else
+                       if (utimes(np, tv) < 0) {
+                               run_err("%s: set times: %s",
+                                   np, strerror(errno));
+                               wrerr = DISPLAYED;
+                       }
+               }
+               switch(wrerr) {
+               case YES:
+                       run_err("%s: %s", np, strerror(wrerrno));
+                       break;
+               case NO:

                        (void)write(rem, "", 1);
                        (void)write(rem, "", 1);

+                       break;
+               case DISPLAYED:
+                       break;
+               }

        }
 screwup:
        }
 screwup:

-       error("rcp: protocol screwup: %s\n", why);
+       run_err("protocol error: %s", why);

        exit(1);
 }
 
        exit(1);
 }
 

-BUF *
-allocbuf(bp, fd, blksize)
-       BUF *bp;
-       int fd, blksize;
+#ifdef KERBEROS
+int
+kerberos(host, bp, locuser, user)
+       char **host, *bp, *locuser, *user;

 {
 {

-       struct stat stb;
-       int size;
-       char *malloc();
+       struct servent *sp;

 
 

-       if (fstat(fd, &stb) < 0) {
-               error("rcp: fstat: %s\n", sys_errlist[errno]);
-               return(0);
-       }
-       size = roundup(stb.st_blksize, blksize);
-       if (size == 0)
-               size = blksize;
-       if (bp->cnt < size) {
-               if (bp->buf != 0)
-                       free(bp->buf);
-               bp->buf = (char *)malloc((u_int)size);
-               if (!bp->buf) {
-                       error("rcp: malloc: out of memory\n");
-                       return(0);
+again:
+       if (use_kerberos) {
+               rem = KSUCCESS;
+               errno = 0;
+               if (dest_realm == NULL)
+                       dest_realm = krb_realmofhost(*host);
+               rem = 
+                       krcmd(host, port, user, bp, 0, dest_realm);
+
+               if (rem < 0) {
+                       use_kerberos = 0;
+                       if ((sp = getservbyname("shell", "tcp")) == NULL)
+                               errx(1, "unknown service shell/tcp");
+                       if (errno == ECONNREFUSED)
+                           oldw("remote host doesn't support Kerberos");
+                       else if (errno == ENOENT)
+                           oldw("can't provide Kerberos authentication data");
+                       port = sp->s_port;
+                       goto again;

                }
                }

+       } else {
+               rem = rcmd(host, port, locuser, user, bp, 0);

        }
        }

-       bp->cnt = size;
-       return(bp);
+       return (rem);

 }
 }

+#endif /* KERBEROS */

 
 

-/* VARARGS1 */
-error(fmt, a1, a2, a3)
-       char *fmt;
-       int a1, a2, a3;
+int
+response()

 {
 {

-       int len;
-       char buf[BUFSIZ];
+       char ch, *cp, resp, rbuf[BUFSIZ];

 
 

-       ++errs;
-       buf[0] = 0x01;
-       (void)sprintf(buf + 1, fmt, a1, a2, a3);
-       len = strlen(buf);
-       (void)write(rem, buf, len);
-       if (!iamremote)
-               (void)write(2, buf + 1, len - 1);
+       if (read(rem, &resp, sizeof(resp)) != sizeof(resp))
+               lostconn(0);
+
+       cp = rbuf;
+       switch(resp) {
+       case 0:                         /* ok */
+               return (0);
+       default:
+               *cp++ = resp;
+               /* FALLTHROUGH */
+       case 1:                         /* error, followed by error msg */
+       case 2:                         /* fatal error, "" */
+               do {
+                       if (read(rem, &ch, sizeof(ch)) != sizeof(ch))
+                               lostconn(0);
+                       *cp++ = ch;
+               } while (cp < &rbuf[BUFSIZ] && ch != '\n');
+
+               if (!iamremote)
+                       (void)write(STDERR_FILENO, rbuf, cp - rbuf);
+               ++errs;
+               if (resp == 1)
+                       return (-1);
+               exit(1);
+       }
+       /* NOTREACHED */

 }
 
 }
 

-nospace()
+void
+usage()

 {
 {

-       (void)fprintf(stderr, "rcp: out of memory.\n");
+#ifdef KERBEROS
+       (void)fprintf(stderr, "%s\n\t%s\n",
+           "usage: rcp [-Kp] [-k realm] f1 f2",
+           "or: rcp [-Kpr] [-k realm] f1 ... fn directory");
+#else
+       (void)fprintf(stderr,
+           "usage: rcp [-p] f1 f2; or: rcp [-pr] f1 ... fn directory\n");
+#endif

        exit(1);
 }
 
        exit(1);
 }
 

+#if __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+

 #ifdef KERBEROS
 #ifdef KERBEROS

-old_warning(str)
-       char *str;
+void
+#if __STDC__
+oldw(const char *fmt, ...)
+#else
+oldw(fmt, va_alist)
+       char *fmt;
+        va_dcl
+#endif

 {
 {

-       (void)fprintf(stderr, "rcp: warning: %s, using standard rcp\n", str);
+       va_list ap;
+#if __STDC__
+       va_start(ap, fmt);
+#else
+       va_start(ap);
+#endif
+       (void)fprintf(stderr, "rcp: ");
+       (void)vfprintf(stderr, fmt, ap);
+       (void)fprintf(stderr, ", using standard rcp\n");
+       va_end(ap);

 }
 #endif
 
 }
 #endif
 

-usage()
+void
+#if __STDC__
+run_err(const char *fmt, ...)
+#else
+run_err(fmt, va_alist)
+       char *fmt;
+        va_dcl
+#endif

 {
 {

-#ifdef KERBEROS
-       (void)fprintf(stderr, "%s\n\t%s\n",
-           "usage: rcp [-k realm] [-px] f1 f2",
-           "or: rcp [-k realm] [-rpx] f1 ... fn directory");
+       static FILE *fp;
+       va_list ap;
+#if __STDC__
+       va_start(ap, fmt);

 #else
 #else

-       (void)fprintf(stderr,
-           "usage: rcp [-p] f1 f2; or: rcp [-rp] f1 ... fn directory\n");
+       va_start(ap);

 #endif
 #endif

-       exit(1);
+
+       ++errs;
+       if (fp == NULL && !(fp = fdopen(rem, "w")))
+               return;
+       (void)fprintf(fp, "%c", 0x01);
+       (void)fprintf(fp, "rcp: ");
+       (void)vfprintf(fp, fmt, ap);
+       (void)fprintf(fp, "\n");
+       (void)fflush(fp);
+
+       if (!iamremote)
+               vwarnx(fmt, ap);
+
+       va_end(ap);

 }
 }