src/usr.bin/ssh/scp.c - diff

Return to scp.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/scp.c between version 1.68 and 1.68.2.4

version 1.68, 2001/04/22 12:34:05

version 1.68.2.4, 2002/06/02 22:56:10

Line 81

#include "atomicio.h"

#include "pathnames.h"

#include "log.h"

#include "scp-common.h"

#include "misc.h"

/* For progressmeter() -- number of seconds before xfer considered "stalled" */

#define STALLTIME 5

/* alarm() interval for updating progress meter */

#define PROGRESSTIME 1

/* Visual statistics about files as they are transferred. */

void progressmeter(int);

Line 93

Line 95

int getttywidth(void);

int do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout, int argc);

/* setup arguments for the call to ssh */

/* Struct for addargs */

void addargs(char *fmt, ...) __attribute__((format(printf, 1, 2)));

arglist args;

/* Time a transfer started. */

static struct timeval start;

Line 117

Line 119

/* This is the program to execute for the secured connection. ("ssh" or -S) */

char *ssh_program = _PATH_SSH_PROGRAM;

/* This is the list of arguments that scp passes to ssh */

struct {

char **list;

int num;

int nalloc;

} args;

* This function executes the given command as the specified user on the

* given host. This returns < 0 if execution fails, and >= 0 otherwise. This

Line 136

Line 131

int pin[2], pout[2], reserved[2];

if (verbose_mode)

fprintf(stderr, "Executing: program %s host %s, user %s, command %s\n",

fprintf(stderr,

ssh_program, host, remuser ? remuser : "(unspecified)", cmd);

"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

Line 167

Line 164

args.list[0] = ssh_program;

if (remuser != NULL)

addargs("-l%s", remuser);

addargs(&args, "-l%s", remuser);

addargs("%s", host);

addargs(&args, "%s", host);

addargs("%s", cmd);

addargs(&args, "%s", cmd);

execvp(ssh_program, args.list);

perror(ssh_program);

Line 222

Line 219

extern int optind;

args.list = NULL;

addargs("ssh"); /* overwritten with ssh_program */

addargs(&args, "ssh"); /* overwritten with ssh_program */

addargs("-x");

addargs(&args, "-x");

addargs("-oFallBackToRsh no");

addargs(&args, "-oForwardAgent no");

addargs(&args, "-oFallBackToRsh no");

addargs(&args, "-oClearAllForwardings yes");

fflag = tflag = 0;

while ((ch = getopt(argc, argv, "dfprtvBCc:i:P:q46S:o:")) != -1)

while ((ch = getopt(argc, argv, "dfprtvBCc:i:P:q46S:o:F:")) != -1)

switch (ch) {

/* User-visible flags. */

case '4':

case '6':

case 'C':

addargs("-%c", ch);

addargs(&args, "-%c", ch);

break;

case 'o':

case 'c':

case 'i':

addargs("-%c%s", ch, optarg);

case 'F':

addargs(&args, "-%c%s", ch, optarg);

break;

case 'P':

addargs("-p%s", optarg);

addargs(&args, "-p%s", optarg);

break;

case 'B':

addargs("-oBatchmode yes");

addargs(&args, "-oBatchmode yes");

break;

case 'p':

pflag = 1;

Line 256

ssh_program = xstrdup(optarg);

break;

case 'v':

addargs(&args, "-v");

verbose_mode = 1;

break;

case 'q':

Line 352

Line 353

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

src = colon(argv[i]);

if (src) { /* remote to remote */

static char *ssh_options =

"-x -o'FallBackToRsh no' "

"-o'ClearAllForwardings yes'";

*src++ = 0;

if (*src == 0)

src = ".";

host = strchr(argv[i], '@');

len = strlen(ssh_program) + strlen(argv[i]) +

strlen(src) + (tuser ? strlen(tuser) : 0) +

strlen(thost) + strlen(targ) + CMDNEEDS + 32;

strlen(thost) + strlen(targ) +

strlen(ssh_options) + CMDNEEDS + 20;

bp = xmalloc(len);

if (host) {

*host++ = 0;

Line 369

Line 374

else if (!okname(suser))

continue;

snprintf(bp, len,

"%s%s -x -o'FallBackToRsh no' -n "

"%s%s %s -n "

"-l %s %s %s %s '%s%s%s:%s'",

ssh_program, verbose_mode ? " -v" : "",

suser, host, cmd, src,

ssh_options, suser, host, cmd, src,

tuser ? tuser : "", tuser ? "@" : "",

thost, targ);

} else {

host = cleanhostname(argv[i]);

snprintf(bp, len,

"exec %s%s -x -o'FallBackToRsh no' -n %s "

"exec %s%s %s -n %s "

"%s %s '%s%s%s:%s'",

ssh_program, verbose_mode ? " -v" : "",

host, cmd, src,

ssh_options, host, cmd, src,

tuser ? tuser : "", tuser ? "@" : "",

thost, targ);

}

Line 479

Line 484

len = strlen(name);

while (len > 1 && name[len-1] == '/')

name[--len] = '\0';

if (strchr(name, '\n') != NULL) {

run_err("%s: skipping, filename contains a newline",

name);

goto next;

}

if ((fd = open(name, O_RDONLY, 0)) < 0)

goto syserr;

if (fstat(fd, &stb) < 0) {

Line 641

Line 651

#define atime tv[0]

#define mtime tv[1]

#define SCREWUP(str) { why = str; goto screwup; }

#define SCREWUP(str) do { why = str; goto screwup; } while (0)

setimes = targisdir = 0;

mask = umask(0);

Line 746

Line 756

cursize = need;

}

(void) snprintf(namebuf, need, "%s%s%s", targ,

*targ ? "/" : "", cp);

strcmp(targ, "/") ? "/" : "", cp);

np = namebuf;

} else

np = targ;

Line 784

Line 794

}

omode = mode;

mode |= S_IWRITE;

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

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

bad: run_err("%s: %s", np, strerror(errno));

continue;

}

Line 808

Line 818

count += amt;

do {

j = read(remin, cp, amt);

if (j == -1 && (errno == EINTR || errno == EAGAIN)) {

if (j == -1 && (errno == EINTR ||

errno == EAGAIN)) {

continue;

} else if (j <= 0) {

run_err("%s", j ? strerror(errno) :

Line 839

Line 850

wrerr = YES;

wrerrno = j >= 0 ? EIO : errno;

}

#if 0

if (ftruncate(ofd, size)) {

run_err("%s: truncate: %s", np, strerror(errno));

wrerr = DISPLAYED;

}

#endif

if (pflag) {

if (exists || omode != mode)

if (fchmod(ofd, omode))

Line 886

Line 895

}

int

response()

response(void)

{

char ch, *cp, resp, rbuf[2048];

Line 919

Line 928

}

void

usage()

usage(void)

{

(void) fprintf(stderr, "usage: scp "

(void) fprintf(stderr,

"[-pqrvBC46] [-S ssh] [-P port] [-c cipher] [-i identity] f1 f2\n"

"usage: scp [-pqrvBC46] [-F config] [-S ssh] [-P port] [-c cipher] [-i identity]\n"

" [-o option] f1 f2\n"

" or: scp [options] f1 ... fn directory\n");

exit(1);

}

Line 932

Line 942

{

static FILE *fp;

va_list ap;

va_start(ap, fmt);

++errs;

if (fp == NULL && !(fp = fdopen(remout, "w")))

return;

(void) fprintf(fp, "%c", 0x01);

(void) fprintf(fp, "scp: ");

va_start(ap, fmt);

(void) vfprintf(fp, fmt, ap);

va_end(ap);

(void) fprintf(fp, "\n");

(void) fflush(fp);

if (!iamremote) {

va_start(ap, fmt);

vfprintf(stderr, fmt, ap);

va_end(ap);

fprintf(stderr, "\n");

}

va_end(ap);

}

void

Line 974

Line 986

cp = cp0;

do {

c = *cp;

c = (int)*cp;

if (c & 0200)

goto bad;

if (!isalpha(c) && !isdigit(c) &&

Line 1010

Line 1022

bp->buf = xmalloc(size);

else

bp->buf = xrealloc(bp->buf, size);

memset(bp->buf, 0, size);

bp->cnt = size;

return (bp);

}

Line 1019

Line 1032

int signo;

{

if (!iamremote)

fprintf(stderr, "lost connection\n");

write(STDERR_FILENO, "lost connection\n", 16);

exit(1);

if (signo)

_exit(1);

else

exit(1);

}

static void

void

alarmtimer(int wait)

{

struct itimerval itv;

itv.it_value.tv_sec = wait;

itv.it_value.tv_usec = 0;

itv.it_interval = itv.it_value;

setitimer(ITIMER_REAL, &itv, NULL);

}

void

updateprogressmeter(int ignore)

{

int save_errno = errno;

progressmeter(0);

signal(SIGALRM, updateprogressmeter);

alarm(PROGRESSTIME);

errno = save_errno;

}

int

static int

foregroundproc(void)

{

static pid_t pgrp = -1;

Line 1067

Line 1073

off_t cursize, abbrevsize;

double elapsed;

int ratio, barlength, i, remaining;

char buf[256];

char buf[512];

if (flag == -1) {

(void) gettimeofday(&start, (struct timezone *) 0);

Line 1093

Line 1099

i = barlength * ratio / 100;

snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),

"|%.*s%*s|", i,

"*****************************************************************************"

"*******************************************************"

"*****************************************************************************",

"*******************************************************"

"*******************************************************",

barlength - i, "");

}

i = 0;

Line 1150

Line 1161

if (flag == -1) {

signal(SIGALRM, updateprogressmeter);

alarmtimer(1);

alarm(PROGRESSTIME);

} else if (flag == 1) {

alarmtimer(0);

alarm(0);

atomicio(write, fileno(stdout), "\n", 1);

statbytes = 0;

}

Line 1167

Line 1178

return (winsize.ws_col ? winsize.ws_col : 80);

else

return (80);

}

void

addargs(char *fmt, ...)

{

va_list ap;

char buf[1024];

va_start(ap, fmt);

vsnprintf(buf, sizeof(buf), fmt, ap);

va_end(ap);

if (args.list == NULL) {

args.nalloc = 32;

args.num = 0;

args.list = xmalloc(args.nalloc * sizeof(char *));

} else if (args.num+2 >= args.nalloc) {

args.nalloc *= 2;

args.list = xrealloc(args.list, args.nalloc * sizeof(char *));

}

args.list[args.num++] = xstrdup(buf);

args.list[args.num] = NULL;

}