Rework addition of Symbian splash screen to reduce the source impact (uses SVG from Bug 2414)
Notes: by using the OPTION SOURCEDIR parameter in the mifconv extension instructions, I can
arrange to use the same source file name in sfimage, without having to export over the original
Nokia file. This means that the name inside splashscreen.mbg is the same, which removes the need
for the conditional compilation in SplashScreen.cpp, and gets rid of sf_splashscreen.mmp.
/*
* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
/*
* zftp.c - builtin FTP client
*
* This file is part of zsh, the Z shell.
*
* Copyright (c) 1998 Peter Stephenson
* All rights reserved.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and to distribute modified versions of this software for any
* purpose, provided that the above copyright notice and the following
* two paragraphs appear in all copies of this software.
*
* In no event shall Peter Stephenson or the Zsh Development Group be liable
* to any party for direct, indirect, special, incidental, or consequential
* damages arising out of the use of this software and its documentation,
* even if Peter Stephenson and the Zsh Development Group have been advised of
* the possibility of such damage.
*
* Peter Stephenson and the Zsh Development Group specifically disclaim any
* warranties, including, but not limited to, the implied warranties of
* merchantability and fitness for a particular purpose. The software
* provided hereunder is on an "as is" basis, and Peter Stephenson and the
* Zsh Development Group have no obligation to provide maintenance,
* support, updates, enhancements, or modifications.
*
*/
/*
* TODO:
* should be eight-bit clean, but isn't.
* tracking of logical rather than physical directories, like nochaselinks
* (usually PWD returns physical directory).
* can signal handling be improved?
* maybe we should block CTRL-c on some more operations,
* otherwise you can get the connection closed prematurely.
* some way of turning off progress reports when backgrounded
* would be nice, but the shell doesn't make it easy to find that out.
* proxy/gateway connections if i knew what to do
* options to specify e.g. a non-standard port
*/
/* needed in prototypes for statics */
struct hostent;
struct in_addr;
struct sockaddr_in;
struct sockaddr_in6;
struct zftp_session;
typedef struct zftp_session *Zftp_session;
#include "tcp.h"
#include "zftp.mdh"
#include "zftp.pro"
/* it's a TELNET based protocol, but don't think I like doing this */
#ifndef __SYMBIAN32__
#include <arpa/telnet.h>
#else
#include "telnet.h"
#include "dummy.h"
#endif //__SYMBIAN32__
/*
* We use poll() in preference to select because some subset of manuals says
* that's the thing to do, plus it's a bit less fiddly. I don't actually
* have access to a system with poll but not select, however, though
* both bits of the code have been tested on a machine with both.
*/
#ifdef HAVE_POLL_H
#ifndef __SYMBIAN32__
# include <sys/poll.h>
#else
# include "poll.h"
#endif
#endif
#if defined(HAVE_POLL) && !defined(POLLIN) && !defined(POLLNORM)
# undef HAVE_POLL
#endif
#ifdef __SYMBIAN32__
#ifdef __WINSCW__
#pragma warn_unusedarg off
#endif//__WINSCW__
#endif//__SYMBIAN32__
#ifdef USE_LOCAL_H_ERRNO
int h_errno;
#endif
union zftp_sockaddr {
struct sockaddr a;
struct sockaddr_in in;
#ifdef SUPPORT_IPV6
struct sockaddr_in6 in6;
#endif
};
#ifdef USE_LOCAL_H_ERRNO
int h_errno;
#endif
/*
* For FTP block mode
*
* The server on our AIX machine here happily accepts block mode, takes the
* first connection, then at the second complains that it's got nowhere
* to send data. The same problem happens with ncftp, it's not just
* me. And a lot of servers don't even support block mode. So I'm not sure
* how widespread the supposed ability to leave open the data fd between
* transfers. Therefore, I've closed all connections after the transfer.
* But then what's the point in block mode? I only implemented it because
* it says in RFC959 that you need it to be able to restart transfers
* later in the file. However, it turns out that's not true for
* most servers --- but our AIX machine happily accepts the REST
* command and then dumps the whole file onto you. Sigh.
*
* Note on block sizes:
* Not quite sure how to optimize this: in principle
* we should handle blocks up to 65535 bytes, which
* is pretty big, and should presumably send blocks
* which are smaller to be on the safe side.
* Currently we send 32768 and use that also as
* the maximum to receive. No-one's complained yet. Of course,
* no-one's *used* it yet apart from me, but even so.
*/
struct zfheader {
char flags;
unsigned char bytes[2];
};
enum {
ZFHD_MARK = 16, /* restart marker */
ZFHD_ERRS = 32, /* suspected errors in block */
ZFHD_EOFB = 64, /* block is end of record */
ZFHD_EORB = 128 /* block is end of file */
};
typedef int (*readwrite_t)(int, char *, off_t, int);
struct zftpcmd {
const char *nam;
int (*fun) _((char *, char **, int));
int min, max, flags;
};
enum {
ZFTP_CONN = 0x0001, /* must be connected */
ZFTP_LOGI = 0x0002, /* must be logged in */
ZFTP_TBIN = 0x0004, /* set transfer type image */
ZFTP_TASC = 0x0008, /* set transfer type ASCII */
ZFTP_NLST = 0x0010, /* use NLST rather than LIST */
ZFTP_DELE = 0x0020, /* a delete rather than a make */
ZFTP_SITE = 0x0040, /* a site rather than a quote */
ZFTP_APPE = 0x0080, /* append rather than overwrite */
ZFTP_HERE = 0x0100, /* here rather than over there */
ZFTP_CDUP = 0x0200, /* CDUP rather than CWD */
ZFTP_REST = 0x0400, /* restart: set point in remote file */
ZFTP_RECV = 0x0800, /* receive rather than send */
ZFTP_TEST = 0x1000, /* test command, don't test */
ZFTP_SESS = 0x2000 /* session command, don't need status */
};
typedef struct zftpcmd *Zftpcmd;
static struct zftpcmd zftpcmdtab[] = {
{ "open", zftp_open, 0, 4, 0 },
{ "params", zftp_params, 0, 4, 0 },
{ "login", zftp_login, 0, 3, ZFTP_CONN },
{ "user", zftp_login, 0, 3, ZFTP_CONN },
{ "test", zftp_test, 0, 0, ZFTP_TEST },
{ "cd", zftp_cd, 1, 1, ZFTP_CONN|ZFTP_LOGI },
{ "cdup", zftp_cd, 0, 0, ZFTP_CONN|ZFTP_LOGI|ZFTP_CDUP },
{ "dir", zftp_dir, 0, -1, ZFTP_CONN|ZFTP_LOGI },
{ "ls", zftp_dir, 0, -1, ZFTP_CONN|ZFTP_LOGI|ZFTP_NLST },
{ "type", zftp_type, 0, 1, ZFTP_CONN|ZFTP_LOGI },
{ "ascii", zftp_type, 0, 0, ZFTP_CONN|ZFTP_LOGI|ZFTP_TASC },
{ "binary", zftp_type, 0, 0, ZFTP_CONN|ZFTP_LOGI|ZFTP_TBIN },
{ "mode", zftp_mode, 0, 1, ZFTP_CONN|ZFTP_LOGI },
{ "local", zftp_local, 0, -1, ZFTP_HERE },
{ "remote", zftp_local, 1, -1, ZFTP_CONN|ZFTP_LOGI },
{ "get", zftp_getput, 1, -1, ZFTP_CONN|ZFTP_LOGI|ZFTP_RECV },
{ "getat", zftp_getput, 2, 2, ZFTP_CONN|ZFTP_LOGI|ZFTP_RECV|ZFTP_REST },
{ "put", zftp_getput, 1, -1, ZFTP_CONN|ZFTP_LOGI },
{ "putat", zftp_getput, 2, 2, ZFTP_CONN|ZFTP_LOGI|ZFTP_REST },
{ "append", zftp_getput, 1, -1, ZFTP_CONN|ZFTP_LOGI|ZFTP_APPE },
{ "appendat", zftp_getput, 2, 2, ZFTP_CONN|ZFTP_LOGI|ZFTP_APPE|ZFTP_REST },
{ "delete", zftp_delete, 1, -1, ZFTP_CONN|ZFTP_LOGI },
{ "mkdir", zftp_mkdir, 1, 1, ZFTP_CONN|ZFTP_LOGI },
{ "rmdir", zftp_mkdir, 1, 1, ZFTP_CONN|ZFTP_LOGI|ZFTP_DELE },
{ "rename", zftp_rename, 2, 2, ZFTP_CONN|ZFTP_LOGI },
{ "quote", zftp_quote, 1, -1, ZFTP_CONN },
{ "site", zftp_quote, 1, -1, ZFTP_CONN|ZFTP_SITE },
{ "close", zftp_close, 0, 0, ZFTP_CONN },
{ "quit", zftp_close, 0, 0, ZFTP_CONN },
{ "session", zftp_session, 0, 1, ZFTP_SESS },
{ "rmsession", zftp_rmsession, 0, 1, ZFTP_SESS },
{ 0, 0, 0, 0, 0 }
};
static struct builtin bintab[] = {
BUILTIN("zftp", 0, bin_zftp, 1, -1, 0, NULL, NULL),
};
/*
* these are the non-special params to unset when a connection
* closes. any special params are handled, well, specially.
* currently there aren't any, which is the way I like it.
*/
static char *zfparams[] = {
"ZFTP_HOST", "ZFTP_PORT", "ZFTP_IP", "ZFTP_SYSTEM", "ZFTP_USER",
"ZFTP_ACCOUNT", "ZFTP_PWD", "ZFTP_TYPE", "ZFTP_MODE", NULL
};
/* flags for zfsetparam */
enum {
ZFPM_READONLY = 0x01, /* make parameter readonly */
ZFPM_IFUNSET = 0x02, /* only set if not already set */
ZFPM_INTEGER = 0x04 /* passed pointer to off_t */
};
/* Number of connections actually open */
static int zfnopen;
/*
* zcfinish = 0 keep going
* 1 line finished, alles klar
* 2 EOF
*/
static int zcfinish;
/* zfclosing is set if zftp_close() is active */
static int zfclosing;
/*
* Stuff about last message: last line of message and status code.
* The reply is also stored in $ZFTP_REPLY; we keep these separate
* for convenience.
*/
static char *lastmsg, lastcodestr[4];
static int lastcode;
/* remote system has size, mdtm commands */
enum {
ZFCP_UNKN = 0, /* dunno if it works on this server */
ZFCP_YUPP = 1, /* it does */
ZFCP_NOPE = 2 /* it doesn't */
};
/*
* We keep an fd open for communication between the main shell
* and forked off bits and pieces. This allows us to know
* if something happend in a subshell: mode changed, type changed,
* connection was closed. If something too substantial happened
* in a subshell --- connection opened, ZFTP_USER and ZFTP_PWD changed
* --- we don't try to track it because it's too complicated.
*/
enum {
ZFST_ASCI = 0x0000, /* type for next transfer is ASCII */
ZFST_IMAG = 0x0001, /* type for next transfer is image */
ZFST_TMSK = 0x0001, /* mask for type flags */
ZFST_TBIT = 0x0001, /* number of bits in type flags */
ZFST_CASC = 0x0000, /* current type is ASCII - default */
ZFST_CIMA = 0x0002, /* current type is image */
ZFST_STRE = 0x0000, /* stream mode - default */
ZFST_BLOC = 0x0004, /* block mode */
ZFST_MMSK = 0x0004, /* mask for mode flags */
ZFST_LOGI = 0x0008, /* user logged in */
ZFST_SYST = 0x0010, /* done system type check */
ZFST_NOPS = 0x0020, /* server doesn't understand PASV */
ZFST_NOSZ = 0x0040, /* server doesn't send `(XXXX bytes)' reply */
ZFST_TRSZ = 0x0080, /* tried getting 'size' from reply */
ZFST_CLOS = 0x0100 /* connection closed */
};
#define ZFST_TYPE(x) (x & ZFST_TMSK)
/*
* shift current type flags to match type flags: should be by
* the number of bits in the type flags
*/
#define ZFST_CTYP(x) ((x >> ZFST_TBIT) & ZFST_TMSK)
#define ZFST_MODE(x) (x & ZFST_MMSK)
/* fd containing status for all sessions and array for internal use */
static int zfstatfd = -1, *zfstatusp;
/* Preferences, read in from the `zftp_prefs' array variable */
enum {
ZFPF_SNDP = 0x01, /* Use send port mode */
ZFPF_PASV = 0x02, /* Try using passive mode */
ZFPF_DUMB = 0x04 /* Don't do clever things with variables */
};
/* The flags as stored internally. */
static int zfprefs;
/*
* Data node for linked list of sessions.
*
* Memory management notes:
* name is permanently allocated and remains for the life of the node.
* userparams is set directly by zftp_params and also freed with the node.
* params and its data are allocated when we need
* to save an existing session, and are freed when we switch back
* to that session.
* The node itself is deleted when we remove it from the list.
*/
struct zftp_session {
char *name; /* name of session */
char **params; /* parameters ordered as in zfparams */
char **userparams; /* user parameters set by zftp_params */
FILE *cin; /* control input file */
Tcp_session control; /* the control connection */
int dfd; /* data connection */
int has_size; /* understands SIZE? */
int has_mdtm; /* understands MDTM? */
};
/* List of active sessions */
static LinkList zfsessions;
/* Current session */
static Zftp_session zfsess;
/* Number of current session, corresponding to position in list */
static int zfsessno;
/* Total number of sessions */
static int zfsesscnt;
/*
* Bits and pieces for dealing with SIGALRM (and SIGPIPE, but that's
* easier). The complication is that SIGALRM may already be handled
* by the user setting TMOUT and possibly setting their own trap --- in
* fact, it's always handled by the shell when it's interactive. It's
* too difficult to use zsh's own signal handler --- either it would
* need rewriting to use a C function as a trap, or we would need a
* hack to make it callback via a hidden builtin from a function --- so
* just install our own, and use settrap() to restore the behaviour
* afterwards if necessary. However, the more that could be done by
* the main shell code, the better I would like it.
*
* Since we don't want to go through the palaver of changing between
* the main zsh signal handler and ours every time we start or stop the
* alarm, we keep the flag zfalarmed set to 1 while zftp is rigged to
* handle alarms. This is tested at the end of bin_zftp(), which is
* the entry point for all functions, and that restores the original
* handler for SIGALRM. To turn off the alarm temporarily in the zftp
* code we then just call alarm(0).
*
* If we could rely on having select() or some replacement, we would
* only need the alarm during zftp_open().
*/
/* flags for alarm set, alarm gone off */
int zfalarmed, zfdrrrring;
/* remember old alarm status */
time_t oaltime;
unsigned int oalremain;
/*
* Where to jump to when the alarm goes off. This is much
* easier than fiddling with error flags at every turn.
* Since we don't expect too many alarm's, the simple setjmp()
* mechanism should be good enough.
*
* gcc -O gives apparently spurious `may be clobbered by longjmp' warnings.
*/
jmp_buf zfalrmbuf;
/* The signal handler itself */
/**/
static RETSIGTYPE
zfhandler(int sig)
{
if (sig == SIGALRM) {
zfdrrrring = 1;
#ifdef ETIMEDOUT /* just in case */
errno = ETIMEDOUT;
#else
errno = EIO;
#endif
longjmp(zfalrmbuf, 1);
}
DPUTS(1, "zfhandler caught incorrect signal");
}
/* Set up for an alarm call */
/**/
static void
zfalarm(int tmout)
{
zfdrrrring = 0;
/*
* We need to do this even if tmout is zero, since there may
* be a non-zero timeout set in the main shell which we don't
* want to go off. This could be argued the other way, since
* if we don't get that it's probably harmless. But this looks safer.
*/
if (zfalarmed) {
alarm(tmout);
return;
}
#ifndef __SYMBIAN32__
signal(SIGALRM, zfhandler);
#endif
oalremain = alarm(tmout);
if (oalremain)
oaltime = time(NULL);
/*
* We'll leave sigtrapped, sigfuncs and TRAPXXX as they are; since the
* shell's handler doesn't get the signal, they don't matter.
*/
zfalarmed = 1;
}
/* Set up for a broken pipe */
/**/
static void
zfpipe()
{
/* Just ignore SIGPIPE and rely on getting EPIPE from the write. */
#ifndef __SYMBIAN32__
signal(SIGPIPE, SIG_IGN);
#endif
}
/* Unset the alarm, see above */
/**/
static void
zfunalarm(void)
{
if (oalremain) {
/*
* The alarm was previously set, so set it back, adjusting
* for the time used. Mostly the alarm was set to zero
* beforehand, so it would probably be best to reinstall
* the proper signal handler before resetting the alarm.
*
* I love the way alarm() uses unsigned int while time_t
* is probably something completely different.
*/
unsigned int tdiff = time(NULL) - oaltime;
alarm(oalremain < tdiff ? 1 : oalremain - tdiff);
} else
alarm(0);
if (sigtrapped[SIGALRM] || interact) {
if (sigfuncs[SIGALRM] || !sigtrapped[SIGALRM])
install_handler(SIGALRM);
else
signal_ignore(SIGALRM);
} else
signal_default(SIGALRM);
zfalarmed = 0;
}
/* Restore SIGPIPE handling to its usual status */
/**/
static void
zfunpipe()
{
if (sigtrapped[SIGPIPE]) {
if (sigfuncs[SIGPIPE])
install_handler(SIGPIPE);
else
signal_ignore(SIGPIPE);
} else
signal_default(SIGPIPE);
}
/*
* Same as movefd(), but don't mark the fd in the zsh tables,
* because we only want it closed by zftp. However, we still
* need to shift the fd's out of the way of the user-visible 0-9.
*/
/**/
static int
zfmovefd(int fd)
{
if (fd != -1 && fd < 10) {
#ifdef F_DUPFD
int fe = fcntl(fd, F_DUPFD, 10);
#else
int fe = zfmovefd(dup(fd));
#endif
close(fd);
fd = fe;
}
return fd;
}
/*
* set a non-special parameter.
* if ZFPM_IFUNSET, don't set if it already exists.
* if ZFPM_READONLY, make it readonly, but only when creating it.
* if ZFPM_INTEGER, val pointer is to off_t (NB not int), don't free.
*/
/**/
static void
zfsetparam(char *name, void *val, int flags)
{
Param pm = NULL;
int type = (flags & ZFPM_INTEGER) ? PM_INTEGER : PM_SCALAR;
if (!(pm = (Param) paramtab->getnode(paramtab, name))
|| (pm->flags & PM_UNSET)) {
/*
* just make it readonly when creating, in case user
* *really* knows what they're doing
*/
if ((pm = createparam(name, type)) && (flags & ZFPM_READONLY))
pm->flags |= PM_READONLY;
} else if (flags & ZFPM_IFUNSET) {
pm = NULL;
}
if (!pm || PM_TYPE(pm->flags) != type) {
/* parameters are funny, you just never know */
if (type == PM_SCALAR)
zsfree((char *)val);
return;
}
if (type == PM_INTEGER)
pm->gsu.i->setfn(pm, *(off_t *)val);
else
pm->gsu.s->setfn(pm, (char *)val);
}
/*
* Unset a ZFTP parameter when the connection is closed.
* We only do this with connection-specific parameters.
*/
/**/
static void
zfunsetparam(char *name)
{
Param pm;
if ((pm = (Param) paramtab->getnode(paramtab, name))) {
pm->flags &= ~PM_READONLY;
unsetparam_pm(pm, 0, 1);
}
}
/*
* Join command and arguments to make a proper TELNET command line.
* New line is in permanent storage.
*/
/**/
static char *
zfargstring(char *cmd, char **args)
{
int clen = strlen(cmd) + 3;
char *line, **aptr;
for (aptr = args; *aptr; aptr++)
clen += strlen(*aptr) + 1;
line = zalloc(clen);
strcpy(line, cmd);
for (aptr = args; *aptr; aptr++) {
strcat(line, " ");
strcat(line, *aptr);
}
strcat(line, "\r\n");
return line;
}
/*
* get a line on the control connection according to TELNET rules
* Return status is first digit of FTP reply code
*/
/**/
static int
zfgetline(char *ln, int lnsize, int tmout)
{
int ch, added = 0;
/* current line point */
char *pcur = ln, cmdbuf[3];
zcfinish = 0;
/* leave room for null byte */
lnsize--;
/* in case we return unexpectedly before getting anything */
ln[0] = '\0';
if (setjmp(zfalrmbuf)) {
alarm(0);
zwarnnam("zftp", "timeout getting response", NULL, 0);
return 6;
}
zfalarm(tmout);
/*
* We need to be more careful about errors here; we
* should do the stuff with errflag and so forth.
* We should probably holdintr() here, since if we don't
* get the message, the connection is going to be messed up.
* But then we get `frustrated user syndrome'.
*/
for (;;) {
ch = fgetc(zfsess->cin);
switch(ch) {
case EOF:
if (ferror(zfsess->cin) && errno == EINTR) {
clearerr(zfsess->cin);
continue;
}
zcfinish = 2;
break;
case '\r':
/* always precedes something else */
ch = fgetc(zfsess->cin);
if (ch == EOF) {
zcfinish = 2;
break;
}
if (ch == '\n') {
zcfinish = 1;
break;
}
if (ch == '\0') {
ch = '\r';
break;
}
/* not supposed to get here */
ch = '\r';
break;
case '\n':
/* not supposed to get here */
zcfinish = 1;
break;
case IAC:
/*
* oh great, now it's sending TELNET commands. try
* to persuade it not to.
*/
ch = fgetc(zfsess->cin);
switch (ch) {
case WILL:
case WONT:
ch = fgetc(zfsess->cin);
/* whatever it wants to do, stop it. */
cmdbuf[0] = (char)IAC;
cmdbuf[1] = (char)DONT;
cmdbuf[2] = ch;
write(zfsess->control->fd, cmdbuf, 3);
continue;
case DO:
case DONT:
ch = fgetc(zfsess->cin);
/* well, tough, we're not going to. */
cmdbuf[0] = (char)IAC;
cmdbuf[1] = (char)WONT;
cmdbuf[2] = ch;
write(zfsess->control->fd, cmdbuf, 3);
continue;
case EOF:
/* strange machine. */
zcfinish = 2;
break;
default:
break;
}
break;
}
if (zcfinish)
break;
if (added < lnsize) {
*pcur++ = ch;
added++;
}
/* junk it if we don't have room, but go on reading */
}
alarm(0);
*pcur = '\0';
/* if zcfinish == 2, at EOF, return that, else 0 */
return (zcfinish & 2);
}
/*
* Get a whole message from the server. A dash after
* the first line code means keep reading until we get
* a line with the same code followed by a space.
*
* Note that this returns an FTP status code, the first
* digit of the reply. There is also a pseudocode, 6, which
* means `there's no point trying anything, just yet'.
* We return it either if the connection is closed, or if
* we got a 530 (user not logged in), in which case whatever
* you're trying to do isn't going to work.
*/
/**/
static int
zfgetmsg(void)
{
char line[256], *ptr, *verbose;
int stopit, printing = 0, tmout;
if (!zfsess->control)
return 6;
zsfree(lastmsg);
lastmsg = NULL;
tmout = getiparam("ZFTP_TMOUT");
zfgetline(line, 256, tmout);
ptr = line;
if (zfdrrrring || !isdigit(STOUC(*ptr)) || !isdigit(STOUC(ptr[1])) ||
!isdigit(STOUC(ptr[2]))) {
/* timeout, or not talking FTP. not really interested. */
zcfinish = 2;
if (!zfclosing)
zfclose(0);
lastmsg = ztrdup("");
strcpy(lastcodestr, "000");
zfsetparam("ZFTP_REPLY", ztrdup(lastmsg), ZFPM_READONLY);
return 6;
}
strncpy(lastcodestr, ptr, 3);
ptr += 3;
lastcodestr[3] = '\0';
lastcode = atoi(lastcodestr);
zfsetparam("ZFTP_CODE", ztrdup(lastcodestr), ZFPM_READONLY);
stopit = (*ptr++ != '-');
queue_signals();
if (!(verbose = getsparam("ZFTP_VERBOSE")))
verbose = "";
if (strchr(verbose, lastcodestr[0])) {
/* print the whole thing verbatim */
printing = 1;
fputs(line, stderr);
} else if (strchr(verbose, '0') && !stopit) {
/* print multiline parts with the code stripped */
printing = 2;
fputs(ptr, stderr);
}
unqueue_signals();
if (printing)
fputc('\n', stderr);
while (zcfinish != 2 && !stopit) {
zfgetline(line, 256, tmout);
ptr = line;
if (zfdrrrring) {
line[0] = '\0';
break;
}
if (!strncmp(lastcodestr, line, 3)) {
if (line[3] == ' ') {
stopit = 1;
ptr += 4;
} else if (line[3] == '-')
ptr += 4;
} else if (!strncmp(" ", line, 4))
ptr += 4;
if (printing == 2) {
if (!stopit) {
fputs(ptr, stderr);
fputc('\n', stderr);
}
} else if (printing) {
fputs(line, stderr);
fputc('\n', stderr);
}
}
if (printing)
fflush(stderr);
/* The internal message is just the text. */
lastmsg = ztrdup(ptr);
/*
* The parameter is the whole thing, including the code.
*/
zfsetparam("ZFTP_REPLY", ztrdup(line), ZFPM_READONLY);
/*
* close the connection here if zcfinish == 2, i.e. EOF,
* or if we get a 421 (service not available, closing connection),
* but don't do it if it's expected (zfclosing set).
*/
if ((zcfinish == 2 || lastcode == 421) && !zfclosing) {
zcfinish = 2; /* don't need to tell server */
zfclose(0);
/* unexpected, so tell user */
zwarnnam("zftp", "remote server has closed connection", NULL, 0);
return 6;
}
if (lastcode == 530) {
/* user not logged in */
return 6;
}
/*
* May as well handle this here, though it's pretty uncommon.
* A 120 is something like "service ready in nnn minutes".
* It means we just hang around waiting for another reply.
*/
if (lastcode == 120) {
zwarnnam("zftp", "delay expected, waiting: %s", lastmsg, 0);
return zfgetmsg();
}
/* first digit of code determines success, failure, not in the mood... */
return lastcodestr[0] - '0';
}
/*
* Send a command and get the reply.
* The command is expected to have the \r\n already tacked on.
* Returns the status code for the reply.
*/
/**/
static int
zfsendcmd(char *cmd)
{
/*
* We use the fd directly; there's no point even using
* stdio with line buffering, since we always send the
* complete line in one string anyway.
*/
int ret, tmout;
if (!zfsess->control)
return 6;
tmout = getiparam("ZFTP_TMOUT");
if (setjmp(zfalrmbuf)) {
alarm(0);
zwarnnam("zftp", "timeout sending message", NULL, 0);
return 6;
}
zfalarm(tmout);
ret = write(zfsess->control->fd, cmd, strlen(cmd));
alarm(0);
if (ret <= 0) {
zwarnnam("zftp send", "failure sending control message: %e",
NULL, errno);
return 6;
}
return zfgetmsg();
}
/* Set up a data connection, return 1 for failure, 0 for success */
/**/
static int
zfopendata(char *name, union tcp_sockaddr *zdsockp, int *is_passivep)
{
if (!(zfprefs & (ZFPF_SNDP|ZFPF_PASV))) {
zwarnnam(name, "Must set preference S or P to transfer data", NULL, 0);
return 1;
}
zfsess->dfd = socket(zfsess->control->peer.a.sa_family, SOCK_STREAM, 0);
if (zfsess->dfd < 0) {
zwarnnam(name, "can't get data socket: %e", NULL, errno);
return 1;
}
if (!(zfstatusp[zfsessno] & ZFST_NOPS) && (zfprefs & ZFPF_PASV)) {
char *psv_cmd;
int err, salen;
#ifdef SUPPORT_IPV6
if(zfsess->control->peer.a.sa_family == AF_INET6)
psv_cmd = "EPSV\r\n";
else
#endif /* SUPPORT_IPV6 */
psv_cmd = "PASV\r\n";
if (zfsendcmd(psv_cmd) == 6)
return 1;
else if (lastcode >= 500 && lastcode <= 504) {
/*
* Fall back to send port mode. That will
* test the preferences for whether that's OK.
*/
zfstatusp[zfsessno] |= ZFST_NOPS;
zfclosedata();
return zfopendata(name, zdsockp, is_passivep);
}
zdsockp->a.sa_family = zfsess->control->peer.a.sa_family;
#ifdef SUPPORT_IPV6
if(zfsess->control->peer.a.sa_family == AF_INET6) {
/* see RFC 2428 for explanation */
char const *ptr, *end;
char delim, portbuf[6], *pbp;
unsigned long portnum;
ptr = strchr(lastmsg, '(');
if(!ptr) {
bad_epsv:
zwarnnam(name, "bad response to EPSV: %s", lastmsg, 0);
zfclosedata();
return 1;
}
delim = ptr[1];
if(delim < 33 || delim > 126 || ptr[2] != delim || ptr[3] != delim)
goto bad_epsv;
ptr += 4;
end = strchr(ptr, delim);
if(!end || end[1] != ')')
goto bad_epsv;
while(ptr != end && *ptr == '0')
ptr++;
if(ptr == end || (end-ptr) > 5 || !isdigit(STOUC(*ptr)))
goto bad_epsv;
memcpy(portbuf, ptr, (end-ptr));
portbuf[end-ptr] = 0;
portnum = strtoul(portbuf, &pbp, 10);
if(*pbp || portnum > 65535UL)
goto bad_epsv;
*zdsockp = zfsess->control->peer;
zdsockp->in6.sin6_port = htons((unsigned)portnum);
salen = sizeof(struct sockaddr_in6);
} else
#endif /* SUPPORT_IPV6 */
{
char *ptr;
int i, nums[6];
unsigned char iaddr[4], iport[2];
/*
* OK, now we need to know what port we're looking at,
* which is cunningly concealed in the reply.
* lastmsg already has the reply code expunged.
*/
for (ptr = lastmsg; *ptr; ptr++)
if (isdigit(STOUC(*ptr)))
break;
if (sscanf(ptr, "%d,%d,%d,%d,%d,%d",
nums, nums+1, nums+2, nums+3, nums+4, nums+5) != 6) {
zwarnnam(name, "bad response to PASV: %s", lastmsg, 0);
zfclosedata();
return 1;
}
for (i = 0; i < 4; i++)
iaddr[i] = STOUC(nums[i]);
iport[0] = STOUC(nums[4]);
iport[1] = STOUC(nums[5]);
memcpy(&zdsockp->in.sin_addr, iaddr, sizeof(iaddr));
memcpy(&zdsockp->in.sin_port, iport, sizeof(iport));
salen = sizeof(struct sockaddr_in);
}
/* we should timeout this connect */
do {
err = connect(zfsess->dfd, (struct sockaddr *)zdsockp, salen);
} while (err && errno == EINTR && !errflag);
if (err) {
zwarnnam(name, "connect failed: %e", NULL, errno);
zfclosedata();
return 1;
}
*is_passivep = 1;
} else {
#ifdef SUPPORT_IPV6
char portcmd[8+INET6_ADDRSTRLEN+9];
#else
char portcmd[40];
#endif
ZSOCKLEN_T len;
int ret;
if (!(zfprefs & ZFPF_SNDP)) {
zwarnnam(name, "only sendport mode available for data", NULL, 0);
return 1;
}
*zdsockp = zfsess->control->sock;
#ifdef SUPPORT_IPV6
if(zdsockp->a.sa_family == AF_INET6) {
zdsockp->in6.sin6_port = 0; /* to be set by bind() */
len = sizeof(struct sockaddr_in6);
} else
#endif /* SUPPORT_IPV6 */
{
zdsockp->in.sin_port = 0; /* to be set by bind() */
len = sizeof(struct sockaddr_in);
}
/* need to do timeout stuff and probably handle EINTR here */
if (bind(zfsess->dfd, (struct sockaddr *)zdsockp, len) < 0)
ret = 1;
else if (getsockname(zfsess->dfd, (struct sockaddr *)zdsockp,
&len) < 0)
ret = 2;
else if (listen(zfsess->dfd, 1) < 0)
ret = 3;
else
ret = 0;
if (ret) {
zwarnnam(name, "failure on data socket: %s: %e",
ret == 3 ? "listen" : ret == 2 ? "getsockname" : "bind",
errno);
zfclosedata();
return 1;
}
#ifdef SUPPORT_IPV6
if(zdsockp->a.sa_family == AF_INET6) {
/* see RFC 2428 for explanation */
strcpy(portcmd, "EPRT |2|");
zsh_inet_ntop(AF_INET6, &zdsockp->in6.sin6_addr,
portcmd+8, INET6_ADDRSTRLEN);
sprintf(strchr(portcmd, 0), "|%u|\r\n",
(unsigned)ntohs(zdsockp->in6.sin6_port));
} else
#endif /* SUPPORT_IPV6 */
{
unsigned char *addr = (unsigned char *) &zdsockp->in.sin_addr;
unsigned char *port = (unsigned char *) &zdsockp->in.sin_port;
sprintf(portcmd, "PORT %d,%d,%d,%d,%d,%d\r\n",
addr[0],addr[1],addr[2],addr[3],port[0],port[1]);
}
if (zfsendcmd(portcmd) >= 5) {
zwarnnam(name, "port command failed", NULL, 0);
zfclosedata();
return 1;
}
*is_passivep = 0;
}
return 0;
}
/* Close the data connection. */
/**/
static void
zfclosedata(void)
{
if (zfsess->dfd == -1)
return;
close(zfsess->dfd);
zfsess->dfd = -1;
}
/*
* Set up a data connection and use cmd to initiate a transfer.
* The actual data fd will be zfsess->dfd; the calling routine
* must handle the data itself.
* rest is a REST command to specify starting somewhere other
* then the start of the remote file.
* getsize is non-zero if we want to try to find the number
* of bytes in the reply to a RETR command.
*
* Return 0 on success, 1 on failure.
*/
/**/
static int
zfgetdata(char *name, char *rest, char *cmd, int getsize)
{
ZSOCKLEN_T len;
int newfd, is_passive;
union tcp_sockaddr zdsock;
if (zfopendata(name, &zdsock, &is_passive))
return 1;
/*
* Set position in remote file for get/put.
* According to RFC959, the restart command needs something
* called a marker which has previously been put into the data.
* Luckily for the real world, UNIX machines just interpret this
* as an offset into the byte stream.
*
* This has to be sent immediately before the data transfer, i.e.
* after all mucking around with types and sizes and so on.
*/
if (rest && zfsendcmd(rest) > 3) {
zfclosedata();
return 1;
}
if (zfsendcmd(cmd) > 2) {
zfclosedata();
return 1;
}
if (getsize || (!(zfstatusp[zfsessno] & ZFST_TRSZ) &&
!strncmp(cmd, "RETR", 4))) {
/*
* See if we got something like:
* Opening data connection for nortypix.gif (1234567 bytes).
* On the first RETR, always see if this works, Then we
* can avoid sending a special SIZE command beforehand.
*/
char *ptr = strstr(lastmsg, "bytes");
zfstatusp[zfsessno] |= ZFST_NOSZ|ZFST_TRSZ;
if (ptr) {
while (ptr > lastmsg && !isdigit(STOUC(*ptr)))
ptr--;
while (ptr > lastmsg && isdigit(STOUC(ptr[-1])))
ptr--;
if (isdigit(STOUC(*ptr))) {
zfstatusp[zfsessno] &= ~ZFST_NOSZ;
if (getsize) {
off_t sz = zstrtol(ptr, NULL, 10);
zfsetparam("ZFTP_SIZE", &sz, ZFPM_READONLY|ZFPM_INTEGER);
}
}
}
}
if (!is_passive) {
/*
* the current zfsess->dfd is the socket we opened, but we need
* to let the server set up a different fd for reading/writing.
* then we can close the fd we were listening for a connection on.
* don't expect me to understand this, i'm only the programmer.
*/
/* accept the connection */
len = sizeof(zdsock);
newfd = zfmovefd(accept(zfsess->dfd, (struct sockaddr *)&zdsock,
&len));
if (newfd < 0)
zwarnnam(name, "unable to accept data: %e", NULL, errno);
zfclosedata();
if (newfd < 0)
return 1;
zfsess->dfd = newfd; /* this is now the actual data fd */
} else {
/*
* We avoided dup'ing zfsess->dfd up to this point, to try to keep
* things simple, so we now need to move it out of the way
* of the user-visible fd's.
*/
zfsess->dfd = zfmovefd(zfsess->dfd);
}
/* more options, just to look professional */
#ifdef SO_LINGER
/*
* Since data can take arbitrary amounts of time to arrive,
* the socket can be made to hang around until it doesn't think
* anything is arriving.
*
* In BSD 4.3, you could only linger for infinity. Don't
* know if this has changed.
*/
{
struct linger li;
li.l_onoff = 1;
li.l_linger = 120;
setsockopt(zfsess->dfd, SOL_SOCKET, SO_LINGER,
(char *)&li, sizeof(li));
}
#endif
#if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
/* try to get high throughput, snigger */
{
int arg = IPTOS_THROUGHPUT;
setsockopt(zfsess->dfd, IPPROTO_IP, IP_TOS, (char *)&arg, sizeof(arg));
}
#endif
#if defined(F_SETFD) && defined(FD_CLOEXEC)
/* If the shell execs a program, we don't want this fd left open. */
fcntl(zfsess->dfd, F_SETFD, FD_CLOEXEC);
#endif
return 0;
}
/*
* Find out about a local or remote file and pass back the information.
*
* We could jigger this to use ls like ncftp does as a backup.
* But if the server is non-standard enough not to have SIZE and MDTM,
* there's a very good chance ls -l isn't going to do great things.
*
* if fd is >= 0, it is used for an fstat when remote is zero:
* this is because on a put we are taking input from fd 0.
*/
/**/
static int
zfstats(char *fnam, int remote, off_t *retsize, char **retmdtm, int fd)
{
off_t sz = -1;
char *mt = NULL;
int ret;
if (retsize)
*retsize = -1;
if (retmdtm)
*retmdtm = NULL;
if (remote) {
char *cmd;
if ((zfsess->has_size == ZFCP_NOPE && retsize) ||
(zfsess->has_mdtm == ZFCP_NOPE && retmdtm))
return 2;
/*
* File is coming from over there.
* Make sure we get the type right.
*/
zfsettype(ZFST_TYPE(zfstatusp[zfsessno]));
if (retsize) {
cmd = tricat("SIZE ", fnam, "\r\n");
ret = zfsendcmd(cmd);
zsfree(cmd);
if (ret == 6)
return 1;
else if (lastcode < 300) {
sz = zstrtol(lastmsg, 0, 10);
zfsess->has_size = ZFCP_YUPP;
} else if (lastcode >= 500 && lastcode <= 504) {
zfsess->has_size = ZFCP_NOPE;
return 2;
} else if (lastcode == 550)
return 1;
/* if we got a 550 from SIZE, the file doesn't exist */
}
if (retmdtm) {
cmd = tricat("MDTM ", fnam, "\r\n");
ret = zfsendcmd(cmd);
zsfree(cmd);
if (ret == 6)
return 1;
else if (lastcode < 300) {
mt = ztrdup(lastmsg);
zfsess->has_mdtm = ZFCP_YUPP;
} else if (lastcode >= 500 && lastcode <= 504) {
zfsess->has_mdtm = ZFCP_NOPE;
return 2;
} else if (lastcode == 550)
return 1;
}
} else {
/* File is over here */
struct stat statbuf;
struct tm *tm;
char tmbuf[20];
if ((fd == -1 ? stat(fnam, &statbuf) : fstat(fd, &statbuf)) < 0)
return 1;
/* make sure it's off_t, since this has to be a pointer */
sz = statbuf.st_size;
if (retmdtm) {
/* use gmtime() rather than localtime() for consistency */
tm = gmtime(&statbuf.st_mtime);
/*
* FTP format for data is YYYYMMDDHHMMSS
* Using tm directly is easier than worrying about
* incompatible strftime()'s.
*/
sprintf(tmbuf, "%04d%02d%02d%02d%02d%02d",
tm->tm_year + 1900, tm->tm_mon+1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
mt = ztrdup(tmbuf);
}
}
if (retsize)
*retsize = sz;
if (retmdtm)
*retmdtm = mt;
return 0;
}
/* Set parameters to say what's coming */
/**/
static void
zfstarttrans(char *nam, int recv, off_t sz)
{
off_t cnt = 0;
/*
* sz = -1 signifies error getting size. don't set ZFTP_SIZE if sz is
* zero, either: it probably came from an fstat() on a pipe, so it
* means we don't know and shouldn't tell the user porkies.
*/
if (sz > 0)
zfsetparam("ZFTP_SIZE", &sz, ZFPM_READONLY|ZFPM_INTEGER);
zfsetparam("ZFTP_FILE", ztrdup(nam), ZFPM_READONLY);
zfsetparam("ZFTP_TRANSFER", ztrdup(recv ? "G" : "P"), ZFPM_READONLY);
zfsetparam("ZFTP_COUNT", &cnt, ZFPM_READONLY|ZFPM_INTEGER);
}
/* Tidy up afterwards */
/**/
static void
zfendtrans()
{
zfunsetparam("ZFTP_SIZE");
zfunsetparam("ZFTP_FILE");
zfunsetparam("ZFTP_TRANSFER");
zfunsetparam("ZFTP_COUNT");
}
/* Read with timeout if recv is set. */
/**/
static int
zfread(int fd, char *bf, off_t sz, int tmout)
{
int ret;
if (!tmout)
return read(fd, bf, sz);
if (setjmp(zfalrmbuf)) {
alarm(0);
zwarnnam("zftp", "timeout on network read", NULL, 0);
return -1;
}
zfalarm(tmout);
ret = read(fd, bf, sz);
/* we don't bother turning off the whole alarm mechanism here */
alarm(0);
return ret;
}
/* Write with timeout if recv is not set. */
/**/
static int
zfwrite(int fd, char *bf, off_t sz, int tmout)
{
int ret;
if (!tmout)
return write(fd, bf, sz);
if (setjmp(zfalrmbuf)) {
alarm(0);
zwarnnam("zftp", "timeout on network write", NULL, 0);
return -1;
}
zfalarm(tmout);
ret = write(fd, bf, sz);
/* we don't bother turning off the whole alarm mechanism here */
alarm(0);
return ret;
}
static int zfread_eof;
/* Version of zfread when we need to read in block mode. */
/**/
static int
zfread_block(int fd, char *bf, off_t sz, int tmout)
{
int n;
struct zfheader hdr;
off_t blksz, cnt;
char *bfptr;
do {
/* we need the header */
do {
n = zfread(fd, (char *)&hdr, sizeof(hdr), tmout);
} while (n < 0 && errno == EINTR);
if (n != 3 && !zfdrrrring) {
zwarnnam("zftp", "failure reading FTP block header", NULL, 0);
return n;
}
/* size is stored in network byte order */
if (hdr.flags & ZFHD_EOFB)
zfread_eof = 1;
blksz = (hdr.bytes[0] << 8) | hdr.bytes[1];
if (blksz > sz) {
/*
* See comments in file headers
*/
zwarnnam("zftp", "block too large to handle", NULL, 0);
errno = EIO;
return -1;
}
bfptr = bf;
cnt = blksz;
while (cnt) {
n = zfread(fd, bfptr, cnt, tmout);
if (n > 0) {
bfptr += n;
cnt -= n;
} else if (n < 0 && (errflag || zfdrrrring || errno != EINTR))
return n;
else
break;
}
if (cnt) {
zwarnnam("zftp", "short data block", NULL, 0);
errno = EIO;
return -1;
}
} while ((hdr.flags & ZFHD_MARK) && !zfread_eof);
return (hdr.flags & ZFHD_MARK) ? 0 : blksz;
}
/* Version of zfwrite when we need to write in block mode. */
/**/
static int
zfwrite_block(int fd, char *bf, off_t sz, int tmout)
{
int n;
struct zfheader hdr;
off_t cnt;
char *bfptr;
/* we need the header */
do {
hdr.bytes[0] = (sz & 0xff00) >> 8;
hdr.bytes[1] = sz & 0xff;
hdr.flags = sz ? 0 : ZFHD_EOFB;
n = zfwrite(fd, (char *)&hdr, sizeof(hdr), tmout);
} while (n < 0 && errno == EINTR);
if (n != 3 && !zfdrrrring) {
zwarnnam("zftp", "failure writing FTP block header", NULL, 0);
return n;
}
bfptr = bf;
cnt = sz;
while (cnt) {
n = zfwrite(fd, bfptr, cnt, tmout);
if (n > 0) {
bfptr += n;
cnt -= n;
} else if (n < 0 && (errflag || zfdrrrring || errno != EINTR))
return n;
}
return sz;
}
/*
* Move stuff from fdin to fdout, tidying up the data connection
* when finished. The data connection could be either input or output:
* recv is 1 for receiving a file, 0 for sending.
*
* progress is 1 to use a progress meter.
* startat says how far in we're starting with a REST command.
*
* Since we're doing some buffering here anyway, we don't bother
* with a stdio layer.
*/
/**/
static int
zfsenddata(char *name, int recv, int progress, off_t startat)
{
#define ZF_BUFSIZE 32768
#define ZF_ASCSIZE (ZF_BUFSIZE/2)
/* ret = 2 signals the local read/write failed, so send abort */
int n, ret = 0, gotack = 0, fdin, fdout, fromasc = 0, toasc = 0;
int rtmout = 0, wtmout = 0;
char lsbuf[ZF_BUFSIZE], *ascbuf = NULL, *optr;
off_t sofar = 0, last_sofar = 0;
readwrite_t read_ptr = zfread, write_ptr = zfwrite;
Eprog prog;
if (progress && (prog = getshfunc("zftp_progress")) != &dummy_eprog) {
/*
* progress to set up: ZFTP_COUNT is zero.
* We do this here in case we needed to wait for a RETR
* command to tell us how many bytes are coming.
*/
int osc = sfcontext;
sfcontext = SFC_HOOK;
doshfunc("zftp_progress", prog, NULL, 0, 1);
sfcontext = osc;
/* Now add in the bit of the file we've got/sent already */
sofar = last_sofar = startat;
}
if (recv) {
fdin = zfsess->dfd;
fdout = 1;
rtmout = getiparam("ZFTP_TMOUT");
if (ZFST_CTYP(zfstatusp[zfsessno]) == ZFST_ASCI)
fromasc = 1;
if (ZFST_MODE(zfstatusp[zfsessno]) == ZFST_BLOC)
read_ptr = zfread_block;
} else {
fdin = 0;
fdout = zfsess->dfd;
wtmout = getiparam("ZFTP_TMOUT");
if (ZFST_CTYP(zfstatusp[zfsessno]) == ZFST_ASCI)
toasc = 1;
if (ZFST_MODE(zfstatusp[zfsessno]) == ZFST_BLOC)
write_ptr = zfwrite_block;
}
if (toasc)
ascbuf = zalloc(ZF_ASCSIZE);
zfpipe();
zfread_eof = 0;
while (!ret && !zfread_eof) {
n = (toasc) ? read_ptr(fdin, ascbuf, ZF_ASCSIZE, rtmout)
: read_ptr(fdin, lsbuf, ZF_BUFSIZE, rtmout);
if (n > 0) {
char *iptr;
if (toasc) {
/* \n -> \r\n it shouldn't happen to a dog. */
char *iptr = ascbuf, *optr = lsbuf;
int cnt = n;
while (cnt--) {
if (*iptr == '\n') {
*optr++ = '\r';
n++;
}
*optr++ = *iptr++;
}
}
if (fromasc && (iptr = memchr(lsbuf, '\r', n))) {
/* \r\n -> \n */
char *optr = iptr;
int cnt = n - (iptr - lsbuf);
while (cnt--) {
if (*iptr != '\r' || iptr[1] != '\n') {
*optr++ = *iptr;
} else
n--;
iptr++;
}
}
optr = lsbuf;
sofar += n;
for (;;) {
/*
* in principle, write can be interrupted after
* safely writing some bytes, and will return the
* number already written, which may not be the
* complete buffer. so make this robust. they call me
* `robustness stephenson'. in my dreams.
*/
int newn = write_ptr(fdout, optr, n, wtmout);
if (newn == n)
break;
if (newn < 0) {
/*
* The somewhat contorted test here (for write)
* and below (for read) means:
* real error if
* - errno is set and it's not just an interrupt, or
* - errflag is set, probably due to CTRL-c, or
* - zfdrrrring is set, due to the alarm going off.
* print an error message if
* - not a timeout, since that was reported, and
* either
* - a non-interactive shell, where we don't
* know what happened otherwise
* - or both of
* - not errflag, i.e. CTRL-c or what have you,
* since the user probably knows about that, and
* - not a SIGPIPE, since usually people are
* silent about those when going to pagers
* (if you quit less or more in the middle
* and see an error message you think `I
* shouldn't have done that').
*
* If we didn't print an error message here,
* and were going to do an abort (ret == 2)
* because the error happened on the local end
* of the connection, set ret to 3 and don't print
* the 'aborting...' either.
*
* There must be a better way of doing this.
*/
if (errno != EINTR || errflag || zfdrrrring) {
if (!zfdrrrring &&
(!interact || (!errflag && errno != EPIPE))) {
ret = recv ? 2 : 1;
zwarnnam(name, "write failed: %e", NULL, errno);
} else
ret = recv ? 3 : 1;
break;
}
continue;
}
optr += newn;
n -= newn;
}
} else if (n < 0) {
if (errno != EINTR || errflag || zfdrrrring) {
if (!zfdrrrring &&
(!interact || (!errflag && errno != EPIPE))) {
ret = recv ? 1 : 2;
zwarnnam(name, "read failed: %e", NULL, errno);
} else
ret = recv ? 1 : 3;
break;
}
} else
break;
if (!ret && sofar != last_sofar && progress &&
(prog = getshfunc("zftp_progress")) != &dummy_eprog) {
int osc = sfcontext;
zfsetparam("ZFTP_COUNT", &sofar, ZFPM_READONLY|ZFPM_INTEGER);
sfcontext = SFC_HOOK;
doshfunc("zftp_progress", prog, NULL, 0, 1);
sfcontext = osc;
last_sofar = sofar;
}
}
zfunpipe();
/*
* At this point any timeout was on the data connection,
* so we don't need to force the control connection to close.
*/
zfdrrrring = 0;
if (!errflag && !ret && !recv &&
ZFST_MODE(zfstatusp[zfsessno]) == ZFST_BLOC) {
/* send an end-of-file marker block */
ret = (zfwrite_block(fdout, lsbuf, 0, wtmout) < 0);
}
if (errflag || ret > 1) {
/*
* some error occurred, maybe a keyboard interrupt, or
* a local file/pipe handling problem.
* send an abort.
*
* safest to block all signals here? can get frustrating if
* we're waiting for an abort. don't I know. let's start
* off just by blocking SIGINT's.
*
* maybe the timeout for the abort should be shorter than
* for normal commands. and what about aborting after
* we had a timeout on the data connection, is that
* really a good idea?
*/
/* RFC 959 says this is what to send */
unsigned char msg[4] = { IAC, IP, IAC, SYNCH };
if (ret == 2)
zwarnnam(name, "aborting data transfer...", NULL, 0);
holdintr();
/* the following is black magic, as far as I'm concerned. */
/* what are we going to do if it fails? not a lot, actually. */
send(zfsess->control->fd, (char *)msg, 3, 0);
send(zfsess->control->fd, (char *)msg+3, 1, MSG_OOB);
zfsendcmd("ABOR\r\n");
if (lastcode == 226) {
/*
* 226 is supposed to mean the transfer got sent OK after
* all, and the abort got ignored, at least that's what
* rfc959 seems to be saying. but in fact what can happen
* is the transfer finishes (at least as far as the
* server's concerned) and it's response is waiting, then
* the abort gets sent, and we need to mop up a response to
* that. so actually in most cases we get two replies
* anyway. we could test if we had select() on all hosts.
*/
/* gotack = 1; */
/*
* we'd better leave errflag, since we don't know
* where it came from. maybe the user wants to abort
* a whole script or function.
*/
} else
ret = 1;
noholdintr();
}
if (toasc)
zfree(ascbuf, ZF_ASCSIZE);
zfclosedata();
if (!gotack && zfgetmsg() > 2)
ret = 1;
return ret != 0;
}
/* Open a new control connection, i.e. start a new FTP session */
/**/
static int
zftp_open(char *name, char **args, int flags)
{
struct protoent *zprotop;
struct servent *zservp;
struct hostent *zhostp = NULL;
char **addrp, *fname, *tmpptr, *portnam = "ftp";
char *hostnam, *hostsuffix;
int err, tmout, port = -1;
ZSOCKLEN_T len;
int herrno, af, hlen;
if (!*args) {
if (zfsess->userparams)
args = zfsess->userparams;
else {
zwarnnam(name, "no host specified", NULL, 0);
return 1;
}
}
/*
* Close the existing connection if any.
* Probably this is the safest thing to do. It's possible
* a `QUIT' will hang, though.
*/
if (zfsess->control)
zfclose(0);
hostnam = dupstring(args[0]);
/*
* Check for IPv6 address in square brackets (RFC2732).
* We are more lenient and allow any form for the host here.
*/
if (hostnam[0] == '[') {
hostnam++;
hostsuffix = strchr(hostnam, ']');
if (!hostsuffix || (hostsuffix[1] && hostsuffix[1] != ':')) {
zwarnnam(name, "Invalid host format: %s", hostnam, 0);
return 1;
}
*hostsuffix++ = '\0';
}
else
hostsuffix = hostnam;
if ((tmpptr = strchr(hostsuffix, ':'))) {
char *endptr;
*tmpptr++ = '\0';
port = (int)zstrtol(tmpptr, &endptr, 10);
/*
* If the port is not numeric, look it up by name below.
*/
if (*endptr) {
portnam = tmpptr;
port = -1;
}
#if defined(HAVE_NTOHS) && defined(HAVE_HTONS)
else {
port = (int)htons((unsigned short)port);
}
#endif
}
/* this is going to give 0. why bother? */
zprotop = getprotobyname("tcp");
if (!zprotop) {
zwarnnam(name, "Can't find protocol TCP (is your network functional)?",
NULL, 0);
return 1;
}
if (port < 0)
zservp = getservbyname(portnam, "tcp");
else
zservp = getservbyport(port, "tcp");
if (!zprotop || !zservp) {
zwarnnam(name, "Can't find port for service `%s'", portnam, 0);
return 1;
}
/* don't try talking to server yet */
zcfinish = 2;
/*
* This sets an alarm for the whole process, getting the host name
* as well as connecting. Arguably you could time them out separately.
*/
tmout = getiparam("ZFTP_TMOUT");
if (setjmp(zfalrmbuf)) {
char *hname;
alarm(0);
queue_signals();
if ((hname = getsparam("ZFTP_HOST")) && *hname)
zwarnnam(name, "timeout connecting to %s", hname, 0);
else
zwarnnam(name, "timeout on host name lookup", NULL, 0);
unqueue_signals();
zfclose(0);
return 1;
}
zfalarm(tmout);
#ifdef SUPPORT_IPV6
for(af=AF_INET6; 1; af = AF_INET)
# define SUCCEEDED() break
# define FAILED() if(af == AF_INET) { } else continue
#else
af = AF_INET;
# define SUCCEEDED() do { } while(0)
# define FAILED() do { } while(0)
#endif
{
off_t tcp_port;
zhostp = zsh_getipnodebyname(hostnam, af, 0, &herrno);
if (!zhostp || errflag) {
/* should use herror() here if available, but maybe
* needs configure test. on AIX it's present but not
* in headers.
*
* on the other hand, herror() is obsolete
*/
FAILED();
zwarnnam(name, "host not found: %s", hostnam, 0);
alarm(0);
return 1;
}
zfsetparam("ZFTP_HOST", ztrdup(zhostp->h_name), ZFPM_READONLY);
/* careful with pointer types */
#if defined(HAVE_NTOHS) && defined(HAVE_HTONS)
tcp_port = (off_t)ntohs((unsigned short)zservp->s_port);
#else
tcp_port = (off_t)zservp->s_port;
#endif
zfsetparam("ZFTP_PORT", &tcp_port, ZFPM_READONLY|ZFPM_INTEGER);
#ifdef SUPPORT_IPV6
if(af == AF_INET6) {
hlen = 16;
} else
#endif /* SUPPORT_IPV6 */
{
hlen = 4;
}
zfsess->control = tcp_socket(af, SOCK_STREAM, 0, ZTCP_ZFTP);
if (!(zfsess->control) || (zfsess->control->fd < 0)) {
if (zfsess->control) {
tcp_close(zfsess->control);
zfsess->control = NULL;
}
freehostent(zhostp);
zfunsetparam("ZFTP_HOST");
zfunsetparam("ZFTP_PORT");
FAILED();
zwarnnam(name, "socket failed: %e", NULL, errno);
alarm(0);
return 1;
}
/* counts as `open' so long as it's not negative */
zfnopen++;
/*
* now connect the socket. manual pages all say things like `this is
* all explained oh-so-wonderfully in some other manual page'. not.
*/
err = 1;
/* try all possible IP's */
for (addrp = zhostp->h_addr_list; err && *addrp; addrp++) {
if(hlen != zhostp->h_length)
zwarnnam(name, "address length mismatch", NULL, 0);
do {
err = tcp_connect(zfsess->control, *addrp, zhostp, zservp->s_port); } while (err && errno == EINTR && !errflag);
/* you can check whether it's worth retrying here */
}
if (err) {
freehostent(zhostp);
zfclose(0);
FAILED();
zwarnnam(name, "connect failed: %e", NULL, errno);
alarm(0);
return 1;
}
SUCCEEDED();
}
alarm(0);
{
#ifdef SUPPORT_IPV6
char pbuf[INET6_ADDRSTRLEN];
#else
char pbuf[INET_ADDRSTRLEN];
#endif
addrp--;
zsh_inet_ntop(af, *addrp, pbuf, sizeof(pbuf));
zfsetparam("ZFTP_IP", ztrdup(pbuf), ZFPM_READONLY);
}
freehostent(zhostp);
/* now we can talk to the control connection */
zcfinish = 0;
/*
* Move the fd out of the user-visible range. We need to do
* this after the connect() on some systems.
*/
zfsess->control->fd = zfmovefd(zfsess->control->fd);
#if defined(F_SETFD) && defined(FD_CLOEXEC)
/* If the shell execs a program, we don't want this fd left open. */
fcntl(zfsess->control->fd, F_SETFD, FD_CLOEXEC);
#endif
len = sizeof(zfsess->control->sock);
if (getsockname(zfsess->control->fd, (struct sockaddr *)&zfsess->control->sock, &len) < 0) {
zwarnnam(name, "getsockname failed: %e", NULL, errno);
zfclose(0);
return 1;
}
/* nice to get some options right, ignore if they don't work */
#ifdef SO_OOBINLINE
/*
* this says we want messages in line. maybe sophisticated people
* do clever things with SIGURG.
*/
len = 1;
setsockopt(zfsess->control->fd, SOL_SOCKET, SO_OOBINLINE,
(char *)&len, sizeof(len));
#endif
#if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
/* for control connection we want low delay. please don't laugh. */
len = IPTOS_LOWDELAY;
setsockopt(zfsess->control->fd, IPPROTO_IP, IP_TOS, (char *)&len, sizeof(len));
#endif
/*
* We use stdio with line buffering for convenience on input.
* On output, we can just dump a complete message to the fd via write().
*/
zfsess->cin = fdopen(zfsess->control->fd, "r");
if (!zfsess->cin) {
zwarnnam(name, "file handling error", NULL, 0);
zfclose(0);
return 1;
}
#ifdef _IONBF
setvbuf(zfsess->cin, NULL, _IONBF, 0);
#else
setlinebuf(zfsess->cin);
#endif
/*
* now see what the remote server has to say about that.
*/
if (zfgetmsg() >= 4) {
zfclose(0);
return 1;
}
zfsess->has_size = zfsess->has_mdtm = ZFCP_UNKN;
zfsess->dfd = -1;
/* initial status: open, ASCII data, stream mode 'n' stuff */
zfstatusp[zfsessno] = 0;
/*
* Open file for saving the current status.
* We keep this open at the end of the session because
* it is used to store the status for all sessions.
* However, it is closed whenever there are no connections open.
*/
if (zfstatfd == -1) {
zfstatfd = gettempfile(NULL, 1, &fname);
DPUTS(zfstatfd == -1, "zfstatfd not created");
#if defined(F_SETFD) && defined(FD_CLOEXEC)
/* If the shell execs a program, we don't want this fd left open. */
fcntl(zfstatfd, F_SETFD, FD_CLOEXEC);
#endif
unlink(fname);
}
if (zfsess->control->fd == -1) {
/* final paranoid check */
tcp_close(zfsess->control);
zfsess->control = NULL;
zfnopen--;
} else {
zfsetparam("ZFTP_MODE", ztrdup("S"), ZFPM_READONLY);
/* if remaining arguments, use them to log in. */
if (*++args)
return zftp_login(name, args, flags);
}
/* if something wayward happened, connection was already closed */
return !zfsess->control;
}
/*
* Read a parameter string, with a prompt if reading from stdin.
* The returned string is on the heap.
* If noecho, turn off ECHO mode while reading.
*/
/**/
static char *
zfgetinfo(char *prompt, int noecho)
{
int resettty = 0;
/* 256 characters should be enough, hardly worth allocating
* a password string byte by byte
*/
char instr[256], *strret;
int len;
/*
* Only print the prompt if getting info from a tty. Of
* course, we don't know if stderr has been redirected, but
* that seems a minor point.
*/
if (isatty(0)) {
if (noecho) {
/* hmmm... all this great big shell and we have to read
* something with no echo by ourselves.
* bin_read() is far to complicated for our needs.
* we could use zread(), but that relies on static
* variables, so someone doesn't want that to happen.
*
* this is modified from setcbreak() in utils.c,
* except I don't see any point in using cbreak mode
*/
struct ttyinfo ti;
ti = shttyinfo;
#ifdef HAS_TIO
ti.tio.c_lflag &= ~ECHO;
#else
ti.sgttyb.sg_flags &= ~ECHO;
#endif
settyinfo(&ti);
resettty = 1;
}
fflush(stdin);
fputs(prompt, stderr);
fflush(stderr);
}
fgets(instr, 256, stdin);
if (instr[len = strlen(instr)-1] == '\n')
instr[len] = '\0';
strret = dupstring(instr);
if (resettty) {
/* '\n' didn't get echoed */
fputc('\n', stdout);
fflush(stdout);
settyinfo(&shttyinfo);
}
return strret;
}
/*
* set params for an open with no arguments.
* this allows easy re-opens.
*/
/**/
static int
zftp_params(UNUSED(char *name), char **args, UNUSED(int flags))
{
char *prompts[] = { "Host: ", "User: ", "Password: ", "Account: " };
char **aptr, **newarr;
int i, j, len;
if (!*args) {
if (zfsess->userparams) {
for (aptr = zfsess->userparams, i = 0; *aptr; aptr++, i++) {
if (i == 2) {
len = strlen(*aptr);
for (j = 0; j < len; j++)
fputc('*', stdout);
fputc('\n', stdout);
} else
fprintf(stdout, "%s\n", *aptr);
}
return 0;
} else
return 1;
}
if (!strcmp(*args, "-")) {
if (zfsess->userparams)
freearray(zfsess->userparams);
zfsess->userparams = 0;
return 0;
}
len = arrlen(args);
newarr = (char **)zshcalloc((len+1)*sizeof(char *));
for (aptr = args, i = 0; *aptr && !errflag; aptr++, i++) {
char *str;
if (**aptr == '?')
str = zfgetinfo((*aptr)[1] ? (*aptr+1) : prompts[i], i == 2);
else
str = (**aptr == '\\') ? *aptr+1 : *aptr;
newarr[i] = ztrdup(str);
}
if (errflag) {
/* maybe user CTRL-c'd in the middle somewhere */
for (aptr = newarr; *aptr; aptr++)
zsfree(*aptr);
zfree(newarr, len+1);
return 1;
}
if (zfsess->userparams)
freearray(zfsess->userparams);
zfsess->userparams = newarr;
return 0;
}
/* login a user: often called as part of the open sequence */
/**/
static int
zftp_login(char *name, char **args, UNUSED(int flags))
{
char *ucmd, *passwd = NULL, *acct = NULL;
char *user, tbuf[2] = "X";
int stopit;
if ((zfstatusp[zfsessno] & ZFST_LOGI) && zfsendcmd("REIN\r\n") >= 4)
return 1;
zfstatusp[zfsessno] &= ~ZFST_LOGI;
if (*args) {
user = *args++;
} else {
user = zfgetinfo("User: ", 0);
}
ucmd = tricat("USER ", user, "\r\n");
stopit = 0;
if (zfsendcmd(ucmd) == 6)
stopit = 2;
while (!stopit && !errflag) {
switch (lastcode) {
case 230: /* user logged in */
case 202: /* command not implemented, don't care */
stopit = 1;
break;
case 331: /* need password */
if (*args)
passwd = *args++;
else
passwd = zfgetinfo("Password: ", 1);
zsfree(ucmd);
ucmd = tricat("PASS ", passwd, "\r\n");
if (zfsendcmd(ucmd) == 6)
stopit = 2;
break;
case 332: /* need account */
case 532:
if (*args)
acct = *args++;
else
acct = zfgetinfo("Account: ", 0);
zsfree(ucmd);
ucmd = tricat("ACCT ", passwd, "\r\n");
if (zfsendcmd(ucmd) == 6)
stopit = 2;
break;
case 421: /* service not available, so closed anyway */
case 501: /* syntax error */
case 503: /* bad commands */
case 530: /* not logged in */
case 550: /* random can't-do-that */
default: /* whatever, should flag this as bad karma */
/* need more diagnostics here */
stopit = 2;
break;
}
}
zsfree(ucmd);
if (!zfsess->control)
return 1;
if (stopit == 2 || (lastcode != 230 && lastcode != 202)) {
zwarnnam(name, "login failed", NULL, 0);
return 1;
}
if (*args) {
int cnt;
for (cnt = 0; *args; args++)
cnt++;
zwarnnam(name, "warning: %d comand arguments not used\n", NULL, cnt);
}
zfstatusp[zfsessno] |= ZFST_LOGI;
zfsetparam("ZFTP_USER", ztrdup(user), ZFPM_READONLY);
if (acct)
zfsetparam("ZFTP_ACCOUNT", ztrdup(acct), ZFPM_READONLY);
/*
* Now find out what system we're connected to. Some systems
* won't let us do this until we're logged in; it's fairly safe
* to delay it here for all systems.
*/
if (!(zfprefs & ZFPF_DUMB) && !(zfstatusp[zfsessno] & ZFST_SYST)) {
if (zfsendcmd("SYST\r\n") == 2) {
char *ptr = lastmsg, *eptr, *systype;
for (eptr = ptr; *eptr; eptr++)
;
systype = ztrduppfx(ptr, eptr-ptr);
if (!strncmp(systype, "UNIX Type: L8", 13)) {
/*
* Use binary for transfers. This simple test saves much
* hassle for all concerned, particularly me.
*
* We could set this based just on the UNIX part,
* but I don't really know the consequences of that.
*/
zfstatusp[zfsessno] |= ZFST_IMAG;
}
zfsetparam("ZFTP_SYSTEM", systype, ZFPM_READONLY);
}
zfstatusp[zfsessno] |= ZFST_SYST;
}
tbuf[0] = (ZFST_TYPE(zfstatusp[zfsessno]) == ZFST_ASCI) ? 'A' : 'I';
zfsetparam("ZFTP_TYPE", ztrdup(tbuf), ZFPM_READONLY);
/*
* Get the directory. This is possibly an unnecessary overhead, of
* course, but when you're being driven by shell functions there's
* just no way of telling.
*/
return zfgetcwd();
}
/*
* See if the server wants to tell us something. On a timeout, we usually
* have a `421 Timeout' or something such waiting for us, so we read
* it here. As well as being called explicitly by the user
* (precmd is a very good place for this, it's cheap since it has
* no network overhead), we call it in the bin_zftp front end if we
* have a connection and weren't going to call it anyway.
*
* Poll-free and select-free systems are few and far between these days,
* but I'm willing to consider suggestions.
*/
/**/
static int
zftp_test(UNUSED(char *name), UNUSED(char **args), UNUSED(int flags))
{
#if defined(HAVE_POLL) || defined(HAVE_SELECT)
int ret;
# ifdef HAVE_POLL
struct pollfd pfd;
# else
fd_set f;
struct timeval tv;
# endif /* HAVE_POLL */
if (!zfsess->control)
return 1;
# ifdef HAVE_POLL
# ifndef POLLIN
/* safety first, though I think POLLIN is more common */
# define POLLIN POLLNORM
# endif /* HAVE_POLL */
pfd.fd = zfsess->control->fd;
pfd.events = POLLIN;
if ((ret = poll(&pfd, 1, 0)) < 0 && errno != EINTR && errno != EAGAIN)
zfclose(0);
else if (ret > 0 && pfd.revents) {
/* handles 421 (maybe a bit noisily?) */
zfgetmsg();
}
# else
FD_ZERO(&f);
FD_SET(zfsess->control->fd, &f);
tv.tv_sec = 0;
tv.tv_usec = 0;
if ((ret = select(zfsess->control->fd +1, (SELECT_ARG_2_T) &f,
NULL, NULL, &tv)) < 0
&& errno != EINTR)
zfclose(0);
else if (ret > 0) {
/* handles 421 */
zfgetmsg();
}
# endif /* HAVE_POLL */
/* if we have no zfsess->control, then we've just been dumped out. */
return zfsess->control ? 0 : 2;
#else
zfwarnnam(name, "not supported on this system.", NULL, 0);
return 3;
#endif /* defined(HAVE_POLL) || defined(HAVE_SELECT) */
}
/* do ls or dir on the remote directory */
/**/
static int
zftp_dir(char *name, char **args, int flags)
{
/* maybe should be cleverer about handling arguments */
char *cmd;
int ret;
/*
* RFC959 says this must be ASCII or EBCDIC, not image format.
* I rather suspect on a UNIX server we get away handsomely
* with doing everything, including this, as image.
*/
zfsettype(ZFST_ASCI);
cmd = zfargstring((flags & ZFTP_NLST) ? "NLST" : "LIST", args);
ret = zfgetdata(name, NULL, cmd, 0);
zsfree(cmd);
if (ret)
return 1;
fflush(stdout); /* since we're now using fd 1 */
return zfsenddata(name, 1, 0, 0);
}
/* change the remote directory */
/**/
static int
zftp_cd(UNUSED(char *name), char **args, int flags)
{
/* change directory --- enhance to allow 'zftp cdup' */
int ret;
if ((flags & ZFTP_CDUP) || !strcmp(*args, "..") ||
!strcmp(*args, "../")) {
ret = zfsendcmd("CDUP\r\n");
} else {
char *cmd = tricat("CWD ", *args, "\r\n");
ret = zfsendcmd(cmd);
zsfree(cmd);
}
if (ret > 2)
return 1;
/* sometimes the directory may be in the response. usually not. */
if (zfgetcwd())
return 1;
return 0;
}
/* get the remote directory */
/**/
static int
zfgetcwd(void)
{
char *ptr, *eptr;
int endc;
Eprog prog;
if (zfprefs & ZFPF_DUMB)
return 1;
if (zfsendcmd("PWD\r\n") > 2) {
zfunsetparam("ZFTP_PWD");
return 1;
}
ptr = lastmsg;
while (*ptr == ' ')
ptr++;
if (!*ptr) /* ultra safe */
return 1;
if (*ptr == '"') {
ptr++;
endc = '"';
} else
endc = ' ';
for (eptr = ptr; *eptr && *eptr != endc; eptr++)
;
zfsetparam("ZFTP_PWD", ztrduppfx(ptr, eptr-ptr), ZFPM_READONLY);
/*
* This isn't so necessary if we're going to have a shell function
* front end. By putting it here, and in close when ZFTP_PWD is unset,
* we at least cover the bases.
*/
if ((prog = getshfunc("zftp_chpwd")) != &dummy_eprog) {
int osc = sfcontext;
sfcontext = SFC_HOOK;
doshfunc("zftp_chpwd", prog, NULL, 0, 1);
sfcontext = osc;
}
return 0;
}
/*
* Set the type for the next transfer, usually image (binary) or ASCII.
*/
/**/
static int
zfsettype(int type)
{
char buf[] = "TYPE X\r\n";
if (ZFST_TYPE(type) == ZFST_CTYP(zfstatusp[zfsessno]))
return 0;
buf[5] = (ZFST_TYPE(type) == ZFST_ASCI) ? 'A' : 'I';
if (zfsendcmd(buf) > 2)
return 1;
zfstatusp[zfsessno] &= ~(ZFST_TMSK << ZFST_TBIT);
/* shift the type left to set the current type bits */;
zfstatusp[zfsessno] |= type << ZFST_TBIT;
return 0;
}
/*
* Print or get a new type for the transfer.
* We don't actually set the type at this point.
*/
/**/
static int
zftp_type(char *name, char **args, int flags)
{
char *str, nt, tbuf[2] = "A";
if (flags & (ZFTP_TBIN|ZFTP_TASC)) {
nt = (flags & ZFTP_TBIN) ? 'I' : 'A';
} else if (!(str = *args)) {
/*
* Since this is supposed to be a low-level basis for
* an FTP system, just print the single code letter.
*/
printf("%c\n", (ZFST_TYPE(zfstatusp[zfsessno]) == ZFST_ASCI) ?
'A' : 'I');
fflush(stdout);
return 0;
} else {
nt = toupper(STOUC(*str));
/*
* RFC959 specifies other types, but these are the only
* ones we know what to do with.
*/
if (str[1] || (nt != 'A' && nt != 'B' && nt != 'I')) {
zwarnnam(name, "transfer type %s not recognised", str, 0);
return 1;
}
if (nt == 'B') /* binary = image */
nt = 'I';
}
zfstatusp[zfsessno] &= ~ZFST_TMSK;
zfstatusp[zfsessno] |= (nt == 'I') ? ZFST_IMAG : ZFST_ASCI;
tbuf[0] = nt;
zfsetparam("ZFTP_TYPE", ztrdup(tbuf), ZFPM_READONLY);
return 0;
}
/**/
static int
zftp_mode(char *name, char **args, UNUSED(int flags))
{
char *str, cmd[] = "MODE X\r\n";
int nt;
if (!(str = *args)) {
printf("%c\n", (ZFST_MODE(zfstatusp[zfsessno]) == ZFST_STRE) ?
'S' : 'B');
fflush(stdout);
return 0;
}
nt = str[0] = toupper(STOUC(*str));
if (str[1] || (nt != 'S' && nt != 'B')) {
zwarnnam(name, "transfer mode %s not recognised", str, 0);
return 1;
}
cmd[5] = (char) nt;
if (zfsendcmd(cmd) > 2)
return 1;
zfstatusp[zfsessno] &= ZFST_MMSK;
zfstatusp[zfsessno] |= (nt == 'S') ? ZFST_STRE : ZFST_BLOC;
zfsetparam("ZFTP_MODE", ztrdup(str), ZFPM_READONLY);
return 0;
}
/**/
static int
zftp_local(UNUSED(char *name), char **args, int flags)
{
int more = !!args[1], ret = 0, dofd = !*args;
while (*args || dofd) {
off_t sz;
char *mt;
int newret = zfstats(*args, !(flags & ZFTP_HERE), &sz, &mt,
dofd ? 0 : -1);
if (newret == 2) /* at least one is not implemented */
return 2;
else if (newret) {
ret = 1;
if (mt)
zsfree(mt);
args++;
continue;
}
if (more) {
fputs(*args, stdout);
fputc(' ', stdout);
}
#ifdef OFF_T_IS_64_BIT
printf("%s %s\n", output64(sz), mt);
#else
DPUTS(sizeof(sz) > 4, "Shell compiled with wrong off_t size");
printf("%ld %s\n", sz, mt);
#endif
zsfree(mt);
if (dofd)
break;
args++;
}
fflush(stdout);
return ret;
}
/*
* Generic transfer for get, put and append.
*
* Get sends all files to stdout, i.e. this is basically cat. It's up to a
* shell function driver to turn this into standard FTP-like commands.
*
* Put/append sends everything from stdin down the drai^H^H^Hata connection.
* Slightly weird with multiple files in that it tries to read
* a separate complete file from stdin each time, which is
* only even potentially useful interactively. But the only
* real alternative is just to allow one file at a time.
*/
/**/
static int
zftp_getput(char *name, char **args, int flags)
{
int ret = 0, recv = (flags & ZFTP_RECV), getsize = 0, progress = 1;
char *cmd = recv ? "RETR " : (flags & ZFTP_APPE) ? "APPE " : "STOR ";
Eprog prog;
/*
* At this point I'd like to set progress to 0 if we're
* backgrounded, since it's hard for the user to find out.
* It turns out it's hard enough for us to find out.
* The problem is that zsh clears it's job table, so we
* just don't know if we're some forked shell in a pipeline
* somewhere or in the background. This seems to me a problem.
*/
zfsettype(ZFST_TYPE(zfstatusp[zfsessno]));
if (recv)
fflush(stdout); /* since we may be using fd 1 */
for (; *args; args++) {
char *ln, *rest = NULL;
off_t startat = 0;
if (progress && (prog = getshfunc("zftp_progress")) != &dummy_eprog) {
off_t sz;
/*
* This calls the SIZE command to get the size for remote
* files. Some servers send the size with the reply to
* the transfer command (i.e. RETR), in which
* case we note the fact and don't call this
* next time. For that reason, the first call
* of zftp_progress is delayed until zfsenddata().
*/
if ((!(zfprefs & ZFPF_DUMB) &&
(zfstatusp[zfsessno] & (ZFST_NOSZ|ZFST_TRSZ)) != ZFST_TRSZ)
|| !recv) {
/* the final 0 is a local fd to fstat if recv is zero */
zfstats(*args, recv, &sz, NULL, 0);
/* even if it doesn't support SIZE, it may tell us */
if (recv && sz == -1)
getsize = 1;
} else
getsize = 1;
zfstarttrans(*args, recv, sz);
}
if (flags & ZFTP_REST) {
startat = zstrtol(args[1], NULL, 10);
rest = tricat("REST ", args[1], "\r\n");
}
ln = tricat(cmd, *args, "\r\n");
/* note zfsess->dfd doesn't exist till zfgetdata() creates it */
if (zfgetdata(name, rest, ln, getsize))
ret = 2;
else if (zfsenddata(name, recv, progress, startat))
ret = 1;
zsfree(ln);
/*
* The progress report isn't started till zfsenddata(), where
* it's the first item. Hence we send a final progress report
* if and only if we called zfsenddata();
*/
if (progress && ret != 2 &&
(prog = getshfunc("zftp_progress")) != &dummy_eprog) {
/* progress to finish: ZFTP_TRANSFER set to GF or PF */
int osc = sfcontext;
zfsetparam("ZFTP_TRANSFER", ztrdup(recv ? "GF" : "PF"),
ZFPM_READONLY);
sfcontext = SFC_HOOK;
doshfunc("zftp_progress", prog, NULL, 0, 1);
sfcontext = osc;
}
if (rest) {
zsfree(rest);
args++;
}
if (errflag)
break;
}
zfendtrans();
return ret != 0;
}
/*
* Delete a list of files on the server. We allow a list by analogy with
* `rm'.
*/
/**/
static int
zftp_delete(UNUSED(char *name), char **args, UNUSED(int flags))
{
int ret = 0;
char *cmd, **aptr;
for (aptr = args; *aptr; aptr++) {
cmd = tricat("DELE ", *aptr, "\r\n");
if (zfsendcmd(cmd) > 2)
ret = 1;
zsfree(cmd);
}
return ret;
}
/* Create or remove a directory on the server */
/**/
static int
zftp_mkdir(UNUSED(char *name), char **args, int flags)
{
int ret;
char *cmd = tricat((flags & ZFTP_DELE) ? "RMD " : "MKD ",
*args, "\r\n");
ret = (zfsendcmd(cmd) > 2);
zsfree(cmd);
return ret;
}
/* Rename a file on the server */
/**/
static int
zftp_rename(UNUSED(char *name), char **args, UNUSED(int flags))
{
int ret;
char *cmd;
cmd = tricat("RNFR ", args[0], "\r\n");
ret = 1;
if (zfsendcmd(cmd) == 3) {
zsfree(cmd);
cmd = tricat("RNTO ", args[1], "\r\n");
if (zfsendcmd(cmd) == 2)
ret = 0;
}
zsfree(cmd);
return ret;
}
/*
* Send random commands, either with SITE or literal.
* In the second case, the user better know what they're doing.
*/
/**/
static int
zftp_quote(UNUSED(char *name), char **args, int flags)
{
int ret = 0;
char *cmd;
cmd = (flags & ZFTP_SITE) ? zfargstring("SITE", args)
: zfargstring(args[0], args+1);
ret = (zfsendcmd(cmd) > 2);
zsfree(cmd);
return ret;
}
/*
* Close the connection, ending the session. With leaveparams,
* don't do anything to the external status (parameters, zftp_chpwd),
* probably because this isn't the current session.
*/
/**/
static void
zfclose(int leaveparams)
{
char **aptr;
Eprog prog;
if (!zfsess->control)
return;
zfclosing = 1;
if (zcfinish != 2) {
/*
* haven't had EOF from server, so send a QUIT and get the response.
* maybe we should set a shorter timeout for this to avoid
* CTRL-c rage.
*/
zfsendcmd("QUIT\r\n");
}
if (zfsess->cin) {
/*
* We fdopen'd the TCP control fd; since we can't fdclose it,
* we need to perform a full fclose, which invalidates the
* TCP fd. We need to do this before closing the FILE, since
* it's not usable afterwards.
*/
if (fileno(zfsess->cin) == zfsess->control->fd)
zfsess->control->fd = -1;
fclose(zfsess->cin);
zfsess->cin = NULL;
}
if (zfsess->control) {
zfnopen--;
tcp_close(zfsess->control);
/* We leak if the above failed */
zfsess->control = NULL;
}
if (zfstatfd != -1) {
zfstatusp[zfsessno] |= ZFST_CLOS;
if (!zfnopen) {
/* Write the final status in case this is a subshell */
lseek(zfstatfd, zfsessno*sizeof(int), 0);
write(zfstatfd, (char *)zfstatusp+zfsessno, sizeof(int));
close(zfstatfd);
zfstatfd = -1;
}
}
if (!leaveparams) {
/* Unset the non-special parameters */
for (aptr = zfparams; *aptr; aptr++)
zfunsetparam(*aptr);
/* Now ZFTP_PWD is unset. It's up to zftp_chpwd to notice. */
if ((prog = getshfunc("zftp_chpwd")) != &dummy_eprog) {
int osc = sfcontext;
sfcontext = SFC_HOOK;
doshfunc("zftp_chpwd", prog, NULL, 0, 1);
sfcontext = osc;
}
}
/* tidy up status variables, because mess is bad */
zfclosing = zfdrrrring = 0;
}
/* Safe front end to zftp_close() from within the package */
/**/
static int
zftp_close(UNUSED(char *name), UNUSED(char **args), UNUSED(int flags))
{
zfclose(0);
return 0;
}
/*
* Session management routines. A session consists of various
* internal variables describing the connection, the set of shell
* parameters --- the same set which is unset by closing a connection ---
* and the set of host/user parameters if set by zftp params.
*/
/*
* Switch to a new session, creating it if necessary.
* Sets zfsessno, zfsess and $ZFTP_SESSION; updates zfsesscnt and zfstatusp.
*/
/**/
static void
newsession(char *nm)
{
LinkNode nptr;
for (zfsessno = 0, nptr = firstnode(zfsessions);
nptr; zfsessno++, incnode(nptr)) {
zfsess = (Zftp_session) nptr->dat;
if (!strcmp(zfsess->name, nm))
break;
}
if (!nptr) {
zfsess = (Zftp_session) zshcalloc(sizeof(struct zftp_session));
zfsess->name = ztrdup(nm);
zfsess->dfd = -1;
zfsess->params = (char **) zshcalloc(sizeof(zfparams));
zaddlinknode(zfsessions, zfsess);
zfsesscnt++;
zfstatusp = (int *)zrealloc(zfstatusp, sizeof(int)*zfsesscnt);
zfstatusp[zfsessno] = 0;
}
zfsetparam("ZFTP_SESSION", ztrdup(zfsess->name), ZFPM_READONLY);
}
/* Save the existing session: this just means saving the parameters. */
static void
savesession()
{
char **ps, **pd, *val;
for (ps = zfparams, pd = zfsess->params; *ps; ps++, pd++) {
if (*pd)
zsfree(*pd);
queue_signals();
if ((val = getsparam(*ps)))
*pd = ztrdup(val);
else
*pd = NULL;
unqueue_signals();
}
*pd = NULL;
}
/*
* Switch to session nm, creating it if necessary.
* Just call newsession, then set up the session-specific parameters.
*/
/**/
static void
switchsession(char *nm)
{
char **ps, **pd;
newsession(nm);
for (ps = zfparams, pd = zfsess->params; *ps; ps++, pd++) {
if (*pd) {
/* Use the permanently allocated string for the parameter */
zfsetparam(*ps, *pd, ZFPM_READONLY);
*pd = NULL;
} else
zfunsetparam(*ps);
}
}
/**/
static void
freesession(Zftp_session sptr)
{
char **ps, **pd;
zsfree(sptr->name);
for (ps = zfparams, pd = zfsess->params; *ps; ps++, pd++)
if (*pd)
zsfree(*pd);
zfree(zfsess->params, sizeof(zfparams));
if (sptr->userparams)
freearray(sptr->userparams);
zfree(sptr, sizeof(struct zftp_session));
}
/**/
static int
zftp_session(UNUSED(char *name), char **args, UNUSED(int flags))
{
if (!*args) {
LinkNode nptr;
for (nptr = firstnode(zfsessions); nptr; incnode(nptr))
printf("%s\n", ((Zftp_session)nptr->dat)->name);
return 0;
}
/*
* Check if we are already in the required session: if so,
* it's a no-op, not an error.
*/
if (!strcmp(*args, zfsess->name))
return 0;
savesession();
switchsession(*args);
return 0;
}
/* Remove a session and free it */
/**/
static int
zftp_rmsession(UNUSED(char *name), char **args, UNUSED(int flags))
{
int no;
LinkNode nptr;
Zftp_session sptr = NULL;
char *newsess = NULL;
/* Find the session in the list: either the current one, or by name */
for (no = 0, nptr = firstnode(zfsessions); nptr; no++, incnode(nptr)) {
sptr = (Zftp_session) nptr->dat;
if ((!*args && sptr == zfsess) ||
(*args && !strcmp(sptr->name, *args)))
break;
}
if (!nptr)
return 1;
if (sptr == zfsess) {
/* Freeing current session: make sure it's closed */
zfclosedata();
zfclose(0);
/*
* Choose new session to switch to if any: first in list
* excluding the one just freed.
*/
if (zfsesscnt > 1) {
LinkNode newn = firstnode(zfsessions);
if (newn == nptr)
incnode(newn);
newsess = ((Zftp_session)newn->dat)->name;
}
} else {
Zftp_session oldsess = zfsess;
zfsess = sptr;
/*
* Freeing another session: don't need to switch, just
* tell zfclose() not to delete parameters etc.
*/
zfclosedata();
zfclose(1);
zfsess = oldsess;
}
remnode(zfsessions, nptr);
freesession(sptr);
/*
* Fix up array of status pointers.
*/
if (--zfsesscnt) {
/*
* Some remaining, so just shift up
*/
int *newstatusp = (int *)zalloc(sizeof(int)*zfsesscnt);
int *src, *dst, i;
for (i = 0, src = zfstatusp, dst = newstatusp; i < zfsesscnt;
i++, src++, dst++) {
if (i == no)
src++;
*dst = *src;
}
zfree(zfstatusp, sizeof(int)*(zfsesscnt+1));
zfstatusp = newstatusp;
/*
* Maybe we need to switch to one of the remaining sessions.
*/
if (newsess)
switchsession(newsess);
} else {
zfree(zfstatusp, sizeof(int));
zfstatusp = NULL;
/*
* We've just deleted the last session, so we need to
* start again from scratch.
*/
newsession("default");
}
return 0;
}
/* The builtin command frontend to the rest of the package */
/**/
static int
bin_zftp(char *name, char **args, UNUSED(Options ops), UNUSED(int func))
{
char fullname[20] = "zftp ";
char *cnam = *args++, *prefs, *ptr;
Zftpcmd zptr;
int n, ret = 0;
for (zptr = zftpcmdtab; zptr->nam; zptr++)
if (!strcmp(zptr->nam, cnam))
break;
if (!zptr->nam) {
zwarnnam(name, "no such subcommand: %s", cnam, 0);
return 1;
}
/* check number of arguments */
for (n = 0; args[n]; n++)
;
if (n < zptr->min || (zptr->max != -1 && n > zptr->max)) {
zwarnnam(name, "wrong no. of arguments for %s", cnam, 0);
return 1;
}
strcat(fullname, cnam);
if (zfstatfd != -1 && !(zptr->flags & ZFTP_SESS)) {
/* Get the status in case it was set by a forked process */
int oldstatus = zfstatusp[zfsessno];
lseek(zfstatfd, 0, 0);
read(zfstatfd, (char *)zfstatusp, sizeof(int)*zfsesscnt);
if (zfsess->control && (zfstatusp[zfsessno] & ZFST_CLOS)) {
/* got closed in subshell without us knowing */
zcfinish = 2;
zfclose(0);
} else {
/*
* fix up status types: unfortunately they may already
* have been looked at between being changed in the subshell
* and now, but we can't help that.
*/
if (ZFST_TYPE(oldstatus) != ZFST_TYPE(zfstatusp[zfsessno]))
zfsetparam("ZFTP_TYPE",
ztrdup(ZFST_TYPE(zfstatusp[zfsessno]) == ZFST_ASCI ?
"A" : "I"), ZFPM_READONLY);
if (ZFST_MODE(oldstatus) != ZFST_MODE(zfstatusp[zfsessno]))
zfsetparam("ZFTP_MODE",
ztrdup(ZFST_MODE(zfstatusp[zfsessno]) == ZFST_BLOC ?
"B" : "S"), ZFPM_READONLY);
}
}
#if defined(HAVE_SELECT) || defined (HAVE_POLL)
if (zfsess->control && !(zptr->flags & (ZFTP_TEST|ZFTP_SESS))) {
/*
* Test the connection for a bad fd or incoming message, but
* only if the connection was last heard of open, and
* if we are not about to call the test command anyway.
* Not worth it unless we have select() or poll().
*/
ret = zftp_test("zftp test", NULL, 0);
}
#endif
if ((zptr->flags & ZFTP_CONN) && !zfsess->control) {
if (ret != 2) {
/*
* with ret == 2, we just got dumped out in the test,
* so enough messages already.
*/
zwarnnam(fullname, "not connected.", NULL, 0);
}
return 1;
}
queue_signals();
if ((prefs = getsparam("ZFTP_PREFS"))) {
zfprefs = 0;
for (ptr = prefs; *ptr; ptr++) {
switch (toupper(STOUC(*ptr))) {
case 'S':
/* sendport */
zfprefs |= ZFPF_SNDP;
break;
case 'P':
/*
* passive
* If we have already been told to use sendport mode,
* we're never going to use passive mode.
*/
if (!(zfprefs & ZFPF_SNDP))
zfprefs |= ZFPF_PASV;
break;
case 'D':
/* dumb */
zfprefs |= ZFPF_DUMB;
break;
default:
zwarnnam(name, "preference %c not recognized", NULL, *ptr);
break;
}
}
}
unqueue_signals();
ret = (*zptr->fun)(fullname, args, zptr->flags);
if (zfalarmed)
zfunalarm();
if (zfdrrrring) {
/* had a timeout, close the connection */
zcfinish = 2; /* don't try sending QUIT */
zfclose(0);
}
if (zfstatfd != -1) {
/*
* Set the status in case another process needs to know,
* but only for the active session.
*/
lseek(zfstatfd, zfsessno*sizeof(int), 0);
write(zfstatfd, (char *)zfstatusp+zfsessno, sizeof(int));
}
return ret;
}
static void
zftp_cleanup(void)
{
/*
* There are various parameters hanging around, but they're
* all non-special so are entirely non-life-threatening.
*/
LinkNode nptr;
Zftp_session cursess = zfsess;
for (zfsessno = 0, nptr = firstnode(zfsessions); nptr;
zfsessno++, incnode(nptr)) {
zfsess = (Zftp_session)nptr->dat;
zfclosedata();
/*
* When closing the current session, do the usual unsetting,
* otherwise don't.
*/
zfclose(zfsess != cursess);
}
zsfree(lastmsg);
zfunsetparam("ZFTP_SESSION");
freelinklist(zfsessions, (FreeFunc) freesession);
zfree(zfstatusp, sizeof(int)*zfsesscnt);
deletebuiltins("zftp", bintab, sizeof(bintab)/sizeof(*bintab));
}
static int
zftpexithook(UNUSED(Hookdef d), UNUSED(void *dummy))
{
zftp_cleanup();
return 0;
}
/* The load/unload routines required by the zsh library interface */
/**/
int
setup_(UNUSED(Module m))
{
/* setup_ returns 0 for success. require_module returns 1 for success. */
return !require_module("", "zsh/net/tcp", 0, 0);
}
/**/
int
boot_(UNUSED(Module m))
{
int ret;
if ((ret = addbuiltins("zftp", bintab,
sizeof(bintab)/sizeof(*bintab))) == 1) {
/* if successful, set some default parameters */
off_t tmout_def = 60;
zfsetparam("ZFTP_VERBOSE", ztrdup("450"), ZFPM_IFUNSET);
zfsetparam("ZFTP_TMOUT", &tmout_def, ZFPM_IFUNSET|ZFPM_INTEGER);
zfsetparam("ZFTP_PREFS", ztrdup("PS"), ZFPM_IFUNSET);
/* default preferences if user deletes variable */
zfprefs = ZFPF_SNDP|ZFPF_PASV;
zfsessions = znewlinklist();
newsession("default");
addhookfunc("exit", zftpexithook);
}
return !ret;
}
/**/
int
cleanup_(UNUSED(Module m))
{
deletehookfunc("exit", zftpexithook);
zftp_cleanup();
return 0;
}
/**/
int
finish_(UNUSED(Module m))
{
return 0;
}