//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * 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) {