Skip to content

Instantly share code, notes, and snippets.

@zmaril
Created December 20, 2016 18:06
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save zmaril/dd2a798f1b6cdb4fd2491b1db6e691b2 to your computer and use it in GitHub Desktop.
Save zmaril/dd2a798f1b6cdb4fd2491b1db6e691b2 to your computer and use it in GitHub Desktop.
[{:lines ["/* $OpenBSD: scp.c,v 1.187 2016/09/12 01:22:38 deraadt Exp $ */" 
          "/*" 
          "* scp - secure remote copy.  This is basically patched BSD rcp which" 
          "* uses ssh to do the data transfer (instead of using rcmd)." 
          "*" 
          "* NOTE: This version should NOT be suid root.  (This uses ssh to" 
          "* do the transfer and ssh has the necessary privileges.)" 
          "*" 
          "* 1995 Timo Rinne <tri@iki.fi>, Tatu Ylonen <ylo@cs.hut.fi>" 
          "*" 
          "* As far as I am concerned, the code I have written for this software" 
          "* can be used freely for any purpose.  Any derived versions of this" 
          "* software must be clearly marked as such, and if the derived work is" 
          "* incompatible with the protocol description in the RFC file, it must be" 
          "* called by a name other than \"ssh\" or \"Secure Shell\"." 
          "*/" 
          "/*" 
          "* Copyright (c) 1999 Theo de Raadt.  All rights reserved." 
          "* Copyright (c) 1999 Aaron Campbell.  All rights reserved." 
          "*" 
          "* Redistribution and use in source and binary forms, with or without" 
          "* modification, are permitted provided that the following conditions" 
          "* are met:" 
          "* 1. Redistributions of source code must retain the above copyright" 
          "*    notice, this list of conditions and the following disclaimer." 
          "* 2. Redistributions in binary form must reproduce the above copyright" 
          "*    notice, this list of conditions and the following disclaimer in the" 
          "*    documentation and/or other materials provided with the distribution." 
          "*" 
          "* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR" 
          "* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES" 
          "* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED." 
          "* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT," 
          "* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT" 
          "* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE," 
          "* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY" 
          "* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT" 
          "* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF" 
          "* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." 
          "*/" 
          "" 
          "/*" 
          "* Parts from:" 
          "*" 
          "* Copyright (c) 1983, 1990, 1992, 1993, 1995" 
          "*\tThe Regents of the University of California.  All rights reserved." 
          "*" 
          "* Redistribution and use in source and binary forms, with or without" 
          "* modification, are permitted provided that the following conditions" 
          "* are met:" 
          "* 1. Redistributions of source code must retain the above copyright" 
          "*    notice, this list of conditions and the following disclaimer." 
          "* 2. Redistributions in binary form must reproduce the above copyright" 
          "*    notice, this list of conditions and the following disclaimer in the" 
          "*    documentation and/or other materials provided with the distribution." 
          "* 3. Neither the name of the University nor the names of its contributors" 
          "*    may be used to endorse or promote products derived from this software" 
          "*    without specific prior written permission." 
          "*" 
          "* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND" 
          "* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE" 
          "* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE" 
          "* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE" 
          "* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL" 
          "* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS" 
          "* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)" 
          "* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT" 
          "* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY" 
          "* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF" 
          "* SUCH DAMAGE." 
          "*" 
          "*/" 
          ""], 
  :type :not-macro} 
 {:lines ["#include \"includes.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/source "includes.h"]]]} 
 {:lines [""], :type :not-macro} 
 {:lines ["#include <sys/types.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/header "sys/types.h"]]]} 
 {:lines ["#ifdef HAVE_SYS_STAT_H"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/ifdef 
            [:mcc/expression [:mcc/symbol "HAVE_SYS_STAT_H"]]]]} 
 {:lines ["# include <sys/stat.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/header "sys/stat.h"]]]} 
 {:lines ["#endif"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/endif]]} 
 {:lines ["#ifdef HAVE_POLL_H"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/ifdef 
            [:mcc/expression [:mcc/symbol "HAVE_POLL_H"]]]]} 
 {:lines ["#include <poll.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "poll.h"]]]} 
 {:lines ["#else"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/else]]} 
 {:lines ["# ifdef HAVE_SYS_POLL_H"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/ifdef 
            [:mcc/expression [:mcc/symbol "HAVE_SYS_POLL_H"]]]]} 
 {:lines ["#  include <sys/poll.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/header "sys/poll.h"]]]} 
 {:lines ["# endif"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/endif]]} 
 {:lines ["#endif"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/endif]]} 
 {:lines ["#ifdef HAVE_SYS_TIME_H"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/ifdef 
            [:mcc/expression [:mcc/symbol "HAVE_SYS_TIME_H"]]]]} 
 {:lines ["# include <sys/time.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/header "sys/time.h"]]]} 
 {:lines ["#endif"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/endif]]} 
 {:lines ["#include <sys/wait.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/header "sys/wait.h"]]]} 
 {:lines ["#include <sys/uio.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/header "sys/uio.h"]]]} 
 {:lines [""], :type :not-macro} 
 {:lines ["#include <ctype.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "ctype.h"]]]} 
 {:lines ["#include <dirent.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "dirent.h"]]]} 
 {:lines ["#include <errno.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "errno.h"]]]} 
 {:lines ["#include <fcntl.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "fcntl.h"]]]} 
 {:lines ["#include <limits.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "limits.h"]]]} 
 {:lines ["#include <locale.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "locale.h"]]]} 
 {:lines ["#include <pwd.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "pwd.h"]]]} 
 {:lines ["#include <signal.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "signal.h"]]]} 
 {:lines ["#include <stdarg.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "stdarg.h"]]]} 
 {:lines ["#include <stdio.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "stdio.h"]]]} 
 {:lines ["#include <stdlib.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "stdlib.h"]]]} 
 {:lines ["#include <string.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "string.h"]]]} 
 {:lines ["#include <time.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "time.h"]]]} 
 {:lines ["#include <unistd.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "unistd.h"]]]} 
 {:lines ["#if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H) && !defined(BROKEN_STRNVIS)"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/if 
            [:mcc/expression 
             [:mcc.expression.logical/and 
              [:mcc.expression/function-call 
               [:mcc/symbol "defined"
               [:mcc/symbol "HAVE_STRNVIS"]] 
              "&&" 
              [:mcc.expression/function-call 
               [:mcc/symbol "defined"
               [:mcc/symbol "HAVE_VIS_H"]] 
              "&&" 
              [:mcc.expression/prefix-operation 
               "!" 
               [:mcc.expression/function-call 
                [:mcc/symbol "defined"
                [:mcc/symbol "BROKEN_STRNVIS"]]]]]]]} 
 {:lines ["#include <vis.h>"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/header "vis.h"]]]} 
 {:lines ["#endif"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/endif]]} 
 {:lines [""], :type :not-macro} 
 {:lines ["#include \"xmalloc.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/source "xmalloc.h"]]]} 
 {:lines ["#include \"atomicio.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/source "atomicio.h"]]]} 
 {:lines ["#include \"pathnames.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/source "pathnames.h"]]]} 
 {:lines ["#include \"log.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/source "log.h"]]]} 
 {:lines ["#include \"misc.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/source "misc.h"]]]} 
 {:lines ["#include \"progressmeter.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include 
            [:mcc.macro.include/source "progressmeter.h"]]]} 
 {:lines ["#include \"utf8.h\""], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/include [:mcc.macro.include/source "utf8.h"]]]} 
 {:lines ["" "extern char *__progname;" ""], :type :not-macro} 
 {:lines ["#define COPY_BUFLEN\t16384"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/define 
            [:mcc.macro.define/value 
             [:mcc/symbol "COPY_BUFLEN"
             [:mcc/expression 
              [:mcc/literal [:mcc.literal/int "16384"]]]]]]} 
 {:lines ["" 
          "int do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout);" 
          "int do_cmd2(char *host, char *remuser, char *cmd, int fdin, int fdout);" 
          "" 
          "/* Struct for addargs */" 
          "arglist args;" 
          "arglist remote_remote_args;" 
          "" 
          "/* Bandwidth limit */" 
          "long long limit_kbps = 0;" 
          "struct bwlimit bwlimit;" 
          "" 
          "/* Name of current file being transferred. */" 
          "char *curfile;" 
          "" 
          "/* This is set to non-zero to enable verbose mode. */" 
          "int verbose_mode = 0;" 
          "" 
          "/* This is set to zero if the progressmeter is not desired. */" 
          "int showprogress = 1;" 
          "" 
          "/*" 
          "* This is set to non-zero if remote-remote copy should be piped" 
          "* through this process." 
          "*/" 
          "int throughlocal = 0;" 
          "" 
          "/* This is the program to execute for the secured connection. (\"ssh\" or -S) */" 
          "char *ssh_program = _PATH_SSH_PROGRAM;" 
          "" 
          "/* This is used to store the pid of ssh_program */" 
          "pid_t do_cmd_pid = -1;" 
          "" 
          "static void" 
          "killchild(int signo)" 
          "{" 
          "if (do_cmd_pid > 1) {" 
          "kill(do_cmd_pid, signo ? signo : SIGTERM);" 
          "waitpid(do_cmd_pid, NULL, 0);" 
          "}" 
          "" 
          "if (signo)" 
          "_exit(1);" 
          "exit(1);" 
          "}" 
          "" 
          "static void" 
          "suspchild(int signo)" 
          "{" 
          "int status;" 
          "" 
          "if (do_cmd_pid > 1) {" 
          "kill(do_cmd_pid, signo);" 
          "while (waitpid(do_cmd_pid, &status, WUNTRACED) == -1 &&" 
          "errno == EINTR)" 
          ";" 
          "kill(getpid(), SIGSTOP);" 
          "}" 
          "}" 
          "" 
          "static int" 
          "do_local_cmd(arglist *a)" 
          "{" 
          "u_int i;" 
          "int status;" 
          "pid_t pid;" 
          "" 
          "if (a->num == 0)" 
          "fatal(\"do_local_cmd: no arguments\");" 
          "" 
          "if (verbose_mode) {" 
          "fprintf(stderr, \"Executing:\");" 
          "for (i = 0; i < a->num; i++)" 
          "fmprintf(stderr, \" %s\", a->list[i]);" 
          "fprintf(stderr, \"\\n\");" 
          "}" 
          "if ((pid = fork()) == -1)" 
          "fatal(\"do_local_cmd: fork: %s\", strerror(errno));" 
          "" 
          "if (pid == 0) {" 
          "execvp(a->list[0], a->list);" 
          "perror(a->list[0]);" 
          "exit(1);" 
          "}" 
          "" 
          "do_cmd_pid = pid;" 
          "signal(SIGTERM, killchild);" 
          "signal(SIGINT, killchild);" 
          "signal(SIGHUP, killchild);" 
          "" 
          "while (waitpid(pid, &status, 0) == -1)" 
          "if (errno != EINTR)" 
          "fatal(\"do_local_cmd: waitpid: %s\", strerror(errno));" 
          "" 
          "do_cmd_pid = -1;" 
          "" 
          "if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)" 
          "return (-1);" 
          "" 
          "return (0);" 
          "}" 
          "" 
          "/*" 
          "* This function executes the given command as the specified user on the" 
          "* given host.  This returns < 0 if execution fails, and >= 0 otherwise. This" 
          "* assigns the input and output file descriptors on success." 
          "*/" 
          "" 
          "int" 
          "do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout)" 
          "{" 
          "int pin[2], pout[2], reserved[2];" 
          "" 
          "if (verbose_mode)" 
          "fmprintf(stderr," 
          "\"Executing: program %s host %s, user %s, command %s\\n\"," 
          "ssh_program, host," 
          "remuser ? remuser : \"(unspecified)\", cmd);" 
          "" 
          "/*" 
          "* Reserve two descriptors so that the real pipes won't get" 
          "* descriptors 0 and 1 because that will screw up dup2 below." 
          "*/" 
          "if (pipe(reserved) < 0)" 
          "fatal(\"pipe: %s\", strerror(errno));" 
          "" 
          "/* Create a socket pair for communicating with ssh. */" 
          "if (pipe(pin) < 0)" 
          "fatal(\"pipe: %s\", strerror(errno));" 
          "if (pipe(pout) < 0)" 
          "fatal(\"pipe: %s\", strerror(errno));" 
          "" 
          "/* Free the reserved descriptors. */" 
          "close(reserved[0]);" 
          "close(reserved[1]);" 
          "" 
          "signal(SIGTSTP, suspchild);" 
          "signal(SIGTTIN, suspchild);" 
          "signal(SIGTTOU, suspchild);" 
          "" 
          "/* Fork a child to execute the command on the remote host using ssh. */" 
          "do_cmd_pid = fork();" 
          "if (do_cmd_pid == 0) {" 
          "/* Child. */" 
          "close(pin[1]);" 
          "close(pout[0]);" 
          "dup2(pin[0], 0);" 
          "dup2(pout[1], 1);" 
          "close(pin[0]);" 
          "close(pout[1]);" 
          "" 
          "replacearg(&args, 0, \"%s\", ssh_program);" 
          "if (remuser != NULL) {" 
          "addargs(&args, \"-l\");" 
          "addargs(&args, \"%s\", remuser);" 
          "}" 
          "addargs(&args, \"--\");" 
          "addargs(&args, \"%s\", host);" 
          "addargs(&args, \"%s\", cmd);" 
          "" 
          "execvp(ssh_program, args.list);" 
          "perror(ssh_program);" 
          "exit(1);" 
          "} else if (do_cmd_pid == -1) {" 
          "fatal(\"fork: %s\", strerror(errno));" 
          "}" 
          "/* Parent.  Close the other side, and return the local side. */" 
          "close(pin[0]);" 
          "*fdout = pin[1];" 
          "close(pout[1]);" 
          "*fdin = pout[0];" 
          "signal(SIGTERM, killchild);" 
          "signal(SIGINT, killchild);" 
          "signal(SIGHUP, killchild);" 
          "return 0;" 
          "}" 
          "" 
          "/*" 
          "* This functions executes a command simlar to do_cmd(), but expects the" 
          "* input and output descriptors to be setup by a previous call to do_cmd()." 
          "* This way the input and output of two commands can be connected." 
          "*/" 
          "int" 
          "do_cmd2(char *host, char *remuser, char *cmd, int fdin, int fdout)" 
          "{" 
          "pid_t pid;" 
          "int status;" 
          "" 
          "if (verbose_mode)" 
          "fmprintf(stderr," 
          "\"Executing: 2nd program %s host %s, user %s, command %s\\n\"," 
          "ssh_program, host," 
          "remuser ? remuser : \"(unspecified)\", cmd);" 
          "" 
          "/* Fork a child to execute the command on the remote host using ssh. */" 
          "pid = fork();" 
          "if (pid == 0) {" 
          "dup2(fdin, 0);" 
          "dup2(fdout, 1);" 
          "" 
          "replacearg(&args, 0, \"%s\", ssh_program);" 
          "if (remuser != NULL) {" 
          "addargs(&args, \"-l\");" 
          "addargs(&args, \"%s\", remuser);" 
          "}" 
          "addargs(&args, \"--\");" 
          "addargs(&args, \"%s\", host);" 
          "addargs(&args, \"%s\", cmd);" 
          "" 
          "execvp(ssh_program, args.list);" 
          "perror(ssh_program);" 
          "exit(1);" 
          "} else if (pid == -1) {" 
          "fatal(\"fork: %s\", strerror(errno));" 
          "}" 
          "while (waitpid(pid, &status, 0) == -1)" 
          "if (errno != EINTR)" 
          "fatal(\"do_cmd2: waitpid: %s\", strerror(errno));" 
          "return 0;" 
          "}" 
          "" 
          "typedef struct {" 
          "size_t cnt;" 
          "char *buf;" 
          "} BUF;" 
          "" 
          "BUF *allocbuf(BUF *, int, int);" 
          "void lostconn(int);" 
          "int okname(char *);" 
          "void run_err(const char *,...);" 
          "void verifydir(char *);" 
          "" 
          "struct passwd *pwd;" 
          "uid_t userid;" 
          "int errs, remin, remout;" 
          "int pflag, iamremote, iamrecursive, targetshouldbedirectory;" 
          ""], 
  :type :not-macro} 
 {:lines ["#define\tCMDNEEDS\t64"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/define 
            [:mcc.macro.define/value 
             [:mcc/symbol "CMDNEEDS"
             [:mcc/expression [:mcc/literal [:mcc.literal/int "64"]]]]]]} 
 {:lines ["char cmd[CMDNEEDS];\t\t/* must hold \"rcp -r -p -d\\0\" */" 
          "" 
          "int response(void);" 
          "void rsource(char *, struct stat *);" 
          "void sink(int, char *[]);" 
          "void source(int, char *[]);" 
          "void tolocal(int, char *[]);" 
          "void toremote(char *, int, char *[]);" 
          "void usage(void);" 
          "" 
          "int" 
          "main(int argc, char **argv)" 
          "{" 
          "int ch, fflag, tflag, status, n;" 
          "char *targ, **newargv;" 
          "const char *errstr;" 
          "extern char *optarg;" 
          "extern int optind;" 
          "" 
          "/* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */" 
          "sanitise_stdfd();" 
          "" 
          "setlocale(LC_CTYPE, \"\");" 
          "" 
          "/* Copy argv, because we modify it */" 
          "newargv = xcalloc(MAXIMUM(argc + 1, 1), sizeof(*newargv));" 
          "for (n = 0; n < argc; n++)" 
          "newargv[n] = xstrdup(argv[n]);" 
          "argv = newargv;" 
          "" 
          "__progname = ssh_get_progname(argv[0]);" 
          "" 
          "memset(&args, '\\0', sizeof(args));" 
          "memset(&remote_remote_args, '\\0', sizeof(remote_remote_args));" 
          "args.list = remote_remote_args.list = NULL;" 
          "addargs(&args, \"%s\", ssh_program);" 
          "addargs(&args, \"-x\");" 
          "addargs(&args, \"-oForwardAgent=no\");" 
          "addargs(&args, \"-oPermitLocalCommand=no\");" 
          "addargs(&args, \"-oClearAllForwardings=yes\");" 
          "" 
          "fflag = tflag = 0;" 
          "while ((ch = getopt(argc, argv, \"dfl:prtvBCc:i:P:q12346S:o:F:\")) != -1)" 
          "switch (ch) {" 
          "/* User-visible flags. */" 
          "case '1':" 
          "case '2':" 
          "case '4':" 
          "case '6':" 
          "case 'C':" 
          "addargs(&args, \"-%c\", ch);" 
          "addargs(&remote_remote_args, \"-%c\", ch);" 
          "break;" 
          "case '3':" 
          "throughlocal = 1;" 
          "break;" 
          "case 'o':" 
          "case 'c':" 
          "case 'i':" 
          "case 'F':" 
          "addargs(&remote_remote_args, \"-%c\", ch);" 
          "addargs(&remote_remote_args, \"%s\", optarg);" 
          "addargs(&args, \"-%c\", ch);" 
          "addargs(&args, \"%s\", optarg);" 
          "break;" 
          "case 'P':" 
          "addargs(&remote_remote_args, \"-p\");" 
          "addargs(&remote_remote_args, \"%s\", optarg);" 
          "addargs(&args, \"-p\");" 
          "addargs(&args, \"%s\", optarg);" 
          "break;" 
          "case 'B':" 
          "addargs(&remote_remote_args, \"-oBatchmode=yes\");" 
          "addargs(&args, \"-oBatchmode=yes\");" 
          "break;" 
          "case 'l':" 
          "limit_kbps = strtonum(optarg, 1, 100 * 1024 * 1024," 
          "&errstr);" 
          "if (errstr != NULL)" 
          "usage();" 
          "limit_kbps *= 1024; /* kbps */" 
          "bandwidth_limit_init(&bwlimit, limit_kbps, COPY_BUFLEN);" 
          "break;" 
          "case 'p':" 
          "pflag = 1;" 
          "break;" 
          "case 'r':" 
          "iamrecursive = 1;" 
          "break;" 
          "case 'S':" 
          "ssh_program = xstrdup(optarg);" 
          "break;" 
          "case 'v':" 
          "addargs(&args, \"-v\");" 
          "addargs(&remote_remote_args, \"-v\");" 
          "verbose_mode = 1;" 
          "break;" 
          "case 'q':" 
          "addargs(&args, \"-q\");" 
          "addargs(&remote_remote_args, \"-q\");" 
          "showprogress = 0;" 
          "break;" 
          "" 
          "/* Server options. */" 
          "case 'd':" 
          "targetshouldbedirectory = 1;" 
          "break;" 
          "case 'f':\t/* \"from\" */" 
          "iamremote = 1;" 
          "fflag = 1;" 
          "break;" 
          "case 't':\t/* \"to\" */" 
          "iamremote = 1;" 
          "tflag = 1;"], 
  :type :not-macro} 
 {:lines ["#ifdef HAVE_CYGWIN"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/ifdef 
            [:mcc/expression [:mcc/symbol "HAVE_CYGWIN"]]]]} 
 {:lines ["setmode(0, O_BINARY);"], :type :not-macro} 
 {:lines ["#endif"], 
  :type :macro, 
  :parsed [:mcc/macro [:mcc.macro/endif]]} 
 {:lines ["break;" 
          "default:" 
          "usage();" 
          "}" 
          "argc -= optind;" 
          "argv += optind;" 
          "" 
          "if ((pwd = getpwuid(userid = getuid())) == NULL)" 
          "fatal(\"unknown user %u\", (u_int) userid);" 
          "" 
          "if (!isatty(STDOUT_FILENO))" 
          "showprogress = 0;" 
          "" 
          "if (pflag) {" 
          "/* Cannot pledge: -p allows setuid/setgid files... */" 
          "} else {" 
          "if (pledge(\"stdio rpath wpath cpath fattr tty proc exec\"," 
          "NULL) == -1) {" 
          "perror(\"pledge\");" 
          "exit(1);" 
          "}" 
          "}" 
          "" 
          "remin = STDIN_FILENO;" 
          "remout = STDOUT_FILENO;" 
          "" 
          "if (fflag) {" 
          "/* Follow \"protocol\", send data. */" 
          "(void) response();" 
          "source(argc, argv);" 
          "exit(errs != 0);" 
          "}" 
          "if (tflag) {" 
          "/* Receive data. */" 
          "sink(argc, argv);" 
          "exit(errs != 0);" 
          "}" 
          "if (argc < 2)" 
          "usage();" 
          "if (argc > 2)" 
          "targetshouldbedirectory = 1;" 
          "" 
          "remin = remout = -1;" 
          "do_cmd_pid = -1;" 
          "/* Command to be executed on remote system using \"ssh\". */" 
          "(void) snprintf(cmd, sizeof cmd, \"scp%s%s%s%s\"," 
          "verbose_mode ? \" -v\" : \"\"," 
          "iamrecursive ? \" -r\" : \"\", pflag ? \" -p\" : \"\"," 
          "targetshouldbedirectory ? \" -d\" : \"\");" 
          "" 
          "(void) signal(SIGPIPE, lostconn);" 
          "" 
          "if ((targ = colon(argv[argc - 1])))\t/* Dest is remote host. */" 
          "toremote(targ, argc, argv);" 
          "else {" 
          "if (targetshouldbedirectory)" 
          "verifydir(argv[argc - 1]);" 
          "tolocal(argc, argv);\t/* Dest is local host. */" 
          "}" 
          "/*" 
          "* Finally check the exit status of the ssh process, if one was forked" 
          "* and no error has occurred yet" 
          "*/" 
          "if (do_cmd_pid != -1 && errs == 0) {" 
          "if (remin != -1)" 
          "(void) close(remin);" 
          "if (remout != -1)" 
          "(void) close(remout);" 
          "if (waitpid(do_cmd_pid, &status, 0) == -1)" 
          "errs = 1;" 
          "else {" 
          "if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)" 
          "errs = 1;" 
          "}" 
          "}" 
          "exit(errs != 0);" 
          "}" 
          "" 
          "/* Callback from atomicio6 to update progress meter and limit bandwidth */" 
          "static int" 
          "scpio(void *_cnt, size_t s)" 
          "{" 
          "off_t *cnt = (off_t *)_cnt;" 
          "" 
          "*cnt += s;" 
          "if (limit_kbps > 0)" 
          "bandwidth_limit(&bwlimit, s);" 
          "return 0;" 
          "}" 
          "" 
          "static int" 
          "do_times(int fd, int verb, const struct stat *sb)" 
          "{" 
          "/* strlen(2^64) == 20; strlen(10^6) == 7 */" 
          "char buf[(20 + 7 + 2) * 2 + 2];" 
          "" 
          "(void)snprintf(buf, sizeof(buf), \"T%llu 0 %llu 0\\n\"," 
          "(unsigned long long) (sb->st_mtime < 0 ? 0 : sb->st_mtime)," 
          "(unsigned long long) (sb->st_atime < 0 ? 0 : sb->st_atime));" 
          "if (verb) {" 
          "fprintf(stderr, \"File mtime %lld atime %lld\\n\"," 
          "(long long)sb->st_mtime, (long long)sb->st_atime);" 
          "fprintf(stderr, \"Sending file timestamps: %s\", buf);" 
          "}" 
          "(void) atomicio(vwrite, fd, buf, strlen(buf));" 
          "return (response());" 
          "}" 
          "" 
          "void" 
          "toremote(char *targ, int argc, char **argv)" 
          "{" 
          "char *bp, *host, *src, *suser, *thost, *tuser, *arg;" 
          "arglist alist;" 
          "int i;" 
          "u_int j;" 
          "" 
          "memset(&alist, '\\0', sizeof(alist));" 
          "alist.list = NULL;" 
          "" 
          "*targ++ = 0;" 
          "if (*targ == 0)" 
          "targ = \".\";" 
          "" 
          "arg = xstrdup(argv[argc - 1]);" 
          "if ((thost = strrchr(arg, '@'))) {" 
          "/* user@host */" 
          "*thost++ = 0;" 
          "tuser = arg;" 
          "if (*tuser == '\\0')" 
          "tuser = NULL;" 
          "} else {" 
          "thost = arg;" 
          "tuser = NULL;" 
          "}" 
          "" 
          "if (tuser != NULL && !okname(tuser)) {" 
          "free(arg);" 
          "return;" 
          "}" 
          "" 
          "for (i = 0; i < argc - 1; i++) {" 
          "src = colon(argv[i]);" 
          "if (src && throughlocal) {\t/* extended remote to remote */" 
          "*src++ = 0;" 
          "if (*src == 0)" 
          "src = \".\";" 
          "host = strrchr(argv[i], '@');" 
          "if (host) {" 
          "*host++ = 0;" 
          "host = cleanhostname(host);" 
          "suser = argv[i];" 
          "if (*suser == '\\0')" 
          "suser = pwd->pw_name;" 
          "else if (!okname(suser))" 
          "continue;" 
          "} else {" 
          "host = cleanhostname(argv[i]);" 
          "suser = NULL;" 
          "}" 
          "xasprintf(&bp, \"%s -f %s%s\", cmd," 
          "*src == '-' ? \"-- \" : \"\", src);" 
          "if (do_cmd(host, suser, bp, &remin, &remout) < 0)" 
          "exit(1);" 
          "free(bp);" 
          "host = cleanhostname(thost);" 
          "xasprintf(&bp, \"%s -t %s%s\", cmd," 
          "*targ == '-' ? \"-- \" : \"\", targ);" 
          "if (do_cmd2(host, tuser, bp, remin, remout) < 0)" 
          "exit(1);" 
          "free(bp);" 
          "(void) close(remin);" 
          "(void) close(remout);" 
          "remin = remout = -1;" 
          "} else if (src) {\t/* standard remote to remote */" 
          "freeargs(&alist);" 
          "addargs(&alist, \"%s\", ssh_program);" 
          "addargs(&alist, \"-x\");" 
          "addargs(&alist, \"-oClearAllForwardings=yes\");" 
          "addargs(&alist, \"-n\");" 
          "for (j = 0; j < remote_remote_args.num; j++) {" 
          "addargs(&alist, \"%s\"," 
          "remote_remote_args.list[j]);" 
          "}" 
          "*src++ = 0;" 
          "if (*src == 0)" 
          "src = \".\";" 
          "host = strrchr(argv[i], '@');" 
          "" 
          "if (host) {" 
          "*host++ = 0;" 
          "host = cleanhostname(host);" 
          "suser = argv[i];" 
          "if (*suser == '\\0')" 
          "suser = pwd->pw_name;" 
          "else if (!okname(suser))" 
          "continue;" 
          "addargs(&alist, \"-l\");" 
          "addargs(&alist, \"%s\", suser);" 
          "} else {" 
          "host = cleanhostname(argv[i]);" 
          "}" 
          "addargs(&alist, \"--\");" 
          "addargs(&alist, \"%s\", host);" 
          "addargs(&alist, \"%s\", cmd);" 
          "addargs(&alist, \"%s\", src);" 
          "addargs(&alist, \"%s%s%s:%s\"," 
          "tuser ? tuser : \"\", tuser ? \"@\" : \"\"," 
          "thost, targ);" 
          "if (do_local_cmd(&alist) != 0)" 
          "errs = 1;" 
          "} else {\t/* local to remote */" 
          "if (remin == -1) {" 
          "xasprintf(&bp, \"%s -t %s%s\", cmd," 
          "*targ == '-' ? \"-- \" : \"\", targ);" 
          "host = cleanhostname(thost);" 
          "if (do_cmd(host, tuser, bp, &remin," 
          "&remout) < 0)" 
          "exit(1);" 
          "if (response() < 0)" 
          "exit(1);" 
          "free(bp);" 
          "}" 
          "source(1, argv + i);" 
          "}" 
          "}" 
          "free(arg);" 
          "}" 
          "" 
          "void" 
          "tolocal(int argc, char **argv)" 
          "{" 
          "char *bp, *host, *src, *suser;" 
          "arglist alist;" 
          "int i;" 
          "" 
          "memset(&alist, '\\0', sizeof(alist));" 
          "alist.list = NULL;" 
          "" 
          "for (i = 0; i < argc - 1; i++) {" 
          "if (!(src = colon(argv[i]))) {\t/* Local to local. */" 
          "freeargs(&alist);" 
          "addargs(&alist, \"%s\", _PATH_CP);" 
          "if (iamrecursive)" 
          "addargs(&alist, \"-r\");" 
          "if (pflag)" 
          "addargs(&alist, \"-p\");" 
          "addargs(&alist, \"--\");" 
          "addargs(&alist, \"%s\", argv[i]);" 
          "addargs(&alist, \"%s\", argv[argc-1]);" 
          "if (do_local_cmd(&alist))" 
          "++errs;" 
          "continue;" 
          "}" 
          "*src++ = 0;" 
          "if (*src == 0)" 
          "src = \".\";" 
          "if ((host = strrchr(argv[i], '@')) == NULL) {" 
          "host = argv[i];" 
          "suser = NULL;" 
          "} else {" 
          "*host++ = 0;" 
          "suser = argv[i];" 
          "if (*suser == '\\0')" 
          "suser = pwd->pw_name;" 
          "}" 
          "host = cleanhostname(host);" 
          "xasprintf(&bp, \"%s -f %s%s\"," 
          "cmd, *src == '-' ? \"-- \" : \"\", src);" 
          "if (do_cmd(host, suser, bp, &remin, &remout) < 0) {" 
          "free(bp);" 
          "++errs;" 
          "continue;" 
          "}" 
          "free(bp);" 
          "sink(1, argv + argc - 1);" 
          "(void) close(remin);" 
          "remin = remout = -1;" 
          "}" 
          "}" 
          "" 
          "void" 
          "source(int argc, char **argv)" 
          "{" 
          "struct stat stb;" 
          "static BUF buffer;" 
          "BUF *bp;" 
          "off_t i, statbytes;" 
          "size_t amt, nr;" 
          "int fd = -1, haderr, indx;" 
          "char *last, *name, buf[2048], encname[PATH_MAX];" 
          "int len;" 
          "" 
          "for (indx = 0; indx < argc; ++indx) {" 
          "name = argv[indx];" 
          "statbytes = 0;" 
          "len = strlen(name);" 
          "while (len > 1 && name[len-1] == '/')" 
          "name[--len] = '\\0';" 
          "if ((fd = open(name, O_RDONLY|O_NONBLOCK, 0)) < 0)" 
          "goto syserr;" 
          "if (strchr(name, '\\n') != NULL) {" 
          "strnvis(encname, name, sizeof(encname), VIS_NL);" 
          "name = encname;" 
          "}" 
          "if (fstat(fd, &stb) < 0) {" 
          "syserr:\t\t\trun_err(\"%s: %s\", name, strerror(errno));" 
          "goto next;" 
          "}" 
          "if (stb.st_size < 0) {" 
          "run_err(\"%s: %s\", name, \"Negative file size\");" 
          "goto next;" 
          "}" 
          "unset_nonblock(fd);" 
          "switch (stb.st_mode & S_IFMT) {" 
          "case S_IFREG:" 
          "break;" 
          "case S_IFDIR:" 
          "if (iamrecursive) {" 
          "rsource(name, &stb);" 
          "goto next;" 
          "}" 
          "/* FALLTHROUGH */" 
          "default:" 
          "run_err(\"%s: not a regular file\", name);" 
          "goto next;" 
          "}" 
          "if ((last = strrchr(name, '/')) == NULL)" 
          "last = name;" 
          "else" 
          "++last;" 
          "curfile = last;" 
          "if (pflag) {" 
          "if (do_times(remout, verbose_mode, &stb) < 0)" 
          "goto next;" 
          "}"], 
  :type :not-macro} 
 {:lines ["#define\tFILEMODEMASK\t(S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/define 
            [:mcc.macro.define/value 
             [:mcc/symbol "FILEMODEMASK"
             [:mcc/expression 
              [:mcc/expression 
               [:mcc.expression.bitwise/or 
                [:mcc/symbol "S_ISUID"
                [:mcc/symbol "S_ISGID"
                [:mcc/symbol "S_IRWXU"
                [:mcc/symbol "S_IRWXG"
                [:mcc/symbol "S_IRWXO"]]]]]]]} 
 {:lines ["snprintf(buf, sizeof buf, \"C%04o %lld %s\\n\"," 
          "(u_int) (stb.st_mode & FILEMODEMASK)," 
          "(long long)stb.st_size, last);" 
          "if (verbose_mode)" 
          "fmprintf(stderr, \"Sending file modes: %s\", buf);" 
          "(void) atomicio(vwrite, remout, buf, strlen(buf));" 
          "if (response() < 0)" 
          "goto next;" 
          "if ((bp = allocbuf(&buffer, fd, COPY_BUFLEN)) == NULL) {" 
          "next:\t\t\tif (fd != -1) {" 
          "(void) close(fd);" 
          "fd = -1;" 
          "}" 
          "continue;" 
          "}" 
          "if (showprogress)" 
          "start_progress_meter(curfile, stb.st_size, &statbytes);" 
          "set_nonblock(remout);" 
          "for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {" 
          "amt = bp->cnt;" 
          "if (i + (off_t)amt > stb.st_size)" 
          "amt = stb.st_size - i;" 
          "if (!haderr) {" 
          "if ((nr = atomicio(read, fd," 
          "bp->buf, amt)) != amt) {" 
          "haderr = errno;" 
          "memset(bp->buf + nr, 0, amt - nr);" 
          "}" 
          "}" 
          "/* Keep writing after error to retain sync */" 
          "if (haderr) {" 
          "(void)atomicio(vwrite, remout, bp->buf, amt);" 
          "memset(bp->buf, 0, amt);" 
          "continue;" 
          "}" 
          "if (atomicio6(vwrite, remout, bp->buf, amt, scpio," 
          "&statbytes) != amt)" 
          "haderr = errno;" 
          "}" 
          "unset_nonblock(remout);" 
          "" 
          "if (fd != -1) {" 
          "if (close(fd) < 0 && !haderr)" 
          "haderr = errno;" 
          "fd = -1;" 
          "}" 
          "if (!haderr)" 
          "(void) atomicio(vwrite, remout, \"\", 1);" 
          "else" 
          "run_err(\"%s: %s\", name, strerror(haderr));" 
          "(void) response();" 
          "if (showprogress)" 
          "stop_progress_meter();" 
          "}" 
          "}" 
          "" 
          "void" 
          "rsource(char *name, struct stat *statp)" 
          "{" 
          "DIR *dirp;" 
          "struct dirent *dp;" 
          "char *last, *vect[1], path[PATH_MAX];" 
          "" 
          "if (!(dirp = opendir(name))) {" 
          "run_err(\"%s: %s\", name, strerror(errno));" 
          "return;" 
          "}" 
          "last = strrchr(name, '/');" 
          "if (last == NULL)" 
          "last = name;" 
          "else" 
          "last++;" 
          "if (pflag) {" 
          "if (do_times(remout, verbose_mode, statp) < 0) {" 
          "closedir(dirp);" 
          "return;" 
          "}" 
          "}" 
          "(void) snprintf(path, sizeof path, \"D%04o %d %.1024s\\n\"," 
          "(u_int) (statp->st_mode & FILEMODEMASK), 0, last);" 
          "if (verbose_mode)" 
          "fmprintf(stderr, \"Entering directory: %s\", path);" 
          "(void) atomicio(vwrite, remout, path, strlen(path));" 
          "if (response() < 0) {" 
          "closedir(dirp);" 
          "return;" 
          "}" 
          "while ((dp = readdir(dirp)) != NULL) {" 
          "if (dp->d_ino == 0)" 
          "continue;" 
          "if (!strcmp(dp->d_name, \".\") || !strcmp(dp->d_name, \"..\"))" 
          "continue;" 
          "if (strlen(name) + 1 + strlen(dp->d_name) >= sizeof(path) - 1) {" 
          "run_err(\"%s/%s: name too long\", name, dp->d_name);" 
          "continue;" 
          "}" 
          "(void) snprintf(path, sizeof path, \"%s/%s\", name, dp->d_name);" 
          "vect[0] = path;" 
          "source(1, vect);" 
          "}" 
          "(void) closedir(dirp);" 
          "(void) atomicio(vwrite, remout, \"E\\n\", 2);" 
          "(void) response();" 
          "}" 
          "" 
          "void" 
          "sink(int argc, char **argv)" 
          "{" 
          "static BUF buffer;" 
          "struct stat stb;" 
          "enum {" 
          "YES, NO, DISPLAYED" 
          "} wrerr;" 
          "BUF *bp;" 
          "off_t i;" 
          "size_t j, count;" 
          "int amt, exists, first, ofd;" 
          "mode_t mode, omode, mask;" 
          "off_t size, statbytes;" 
          "unsigned long long ull;" 
          "int setimes, targisdir, wrerrno = 0;" 
          "char ch, *cp, *np, *targ, *why, *vect[1], buf[2048], visbuf[2048];" 
          "struct timeval tv[2];" 
          ""], 
  :type :not-macro} 
 {:lines ["#define\tatime\ttv[0]"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/define 
            [:mcc.macro.define/value 
             [:mcc/symbol "atime"
             [:mcc/expression 
              [:mcc.expression/array-subscript 
               [:mcc/symbol "tv"
               [:mcc/expression [:mcc/literal [:mcc.literal/int "0"]]]]]]]]} 
 {:lines ["#define\tmtime\ttv[1]"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/define 
            [:mcc.macro.define/value 
             [:mcc/symbol "mtime"
             [:mcc/expression 
              [:mcc.expression/array-subscript 
               [:mcc/symbol "tv"
               [:mcc/expression [:mcc/literal [:mcc.literal/int "1"]]]]]]]]} 
 {:lines ["#define\tSCREWUP(str)\t{ why = str; goto screwup; }"], 
  :type :macro, 
  :parsed [:mcc/macro 
           [:mcc.macro/define 
            [:mcc.macro.define/function 
             [:mcc/symbol "SCREWUP"
             [:mcc/symbol "str"
             [:mcc/statement 
              [:mcc.statement/expression 
               [:mcc/expression 
                [:mcc.expression/assignment 
                 [:mcc/symbol "why"
                 "=" 
                 [:mcc/symbol "str"]]]]] 
             [:mcc/statement 
              [:mcc.statement/goto 
               [:mcc.goto/label "goto" [:mcc/symbol "screwup"";"]]]]]]} 
 {:lines ["" 
          "setimes = targisdir = 0;" 
          "mask = umask(0);" 
          "if (!pflag)" 
          "(void) umask(mask);" 
          "if (argc != 1) {" 
          "run_err(\"ambiguous target\");" 
          "exit(1);" 
          "}" 
          "targ = *argv;" 
          "if (targetshouldbedirectory)" 
          "verifydir(targ);" 
          "" 
          "(void) atomicio(vwrite, remout, \"\", 1);" 
          "if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))" 
          "targisdir = 1;" 
          "for (first = 1;; first = 0) {" 
          "cp = buf;" 
          "if (atomicio(read, remin, cp, 1) != 1)" 
          "return;" 
          "if (*cp++ == '\\n')" 
          "SCREWUP(\"unexpected <newline>\");" 
          "do {" 
          "if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))" 
          "SCREWUP(\"lost connection\");" 
          "*cp++ = ch;" 
          "} while (cp < &buf[sizeof(buf) - 1] && ch != '\\n');" 
          "*cp = 0;" 
          "if (verbose_mode)" 
          "fmprintf(stderr, \"Sink: %s\", buf);" 
          "" 
          "if (buf[0] == '\\01' || buf[0] == '\\02') {" 
          "if (iamremote == 0) {" 
          "(void) snmprintf(visbuf, sizeof(visbuf)," 
          "NULL, \"%s\", buf + 1);" 
          "(void) atomicio(vwrite, STDERR_FILENO," 
          "visbuf, strlen(visbuf));" 
          "}" 
          "if (buf[0] == '\\02')" 
          "exit(1);" 
          "++errs;" 
          "continue;" 
          "}" 
          "if (buf[0] == 'E') {" 
          "(void) atomicio(vwrite, remout, \"\", 1);" 
          "return;" 
          "}" 
          "if (ch == '\\n')" 
          "*--cp = 0;" 
          "" 
          "cp = buf;" 
          "if (*cp == 'T') {" 
          "setimes++;" 
          "cp++;" 
          "if (!isdigit((unsigned char)*cp))" 
          "SCREWUP(\"mtime.sec not present\");" 
          "ull = strtoull(cp, &cp, 10);" 
          "if (!cp || *cp++ != ' ')" 
          "SCREWUP(\"mtime.sec not delimited\");" 
          "if ((time_t)ull < 0 ||" 
          "(unsigned long long)(time_t)ull != ull)"], 
  :type :not-macro}]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment