diff options
Diffstat (limited to 'libftpconn')
| -rw-r--r-- | libftpconn/ftpcp.c | 272 | ||||
| -rw-r--r-- | libftpconn/ftpdir.c | 308 |
2 files changed, 580 insertions, 0 deletions
diff --git a/libftpconn/ftpcp.c b/libftpconn/ftpcp.c new file mode 100644 index 00000000..88567305 --- /dev/null +++ b/libftpconn/ftpcp.c @@ -0,0 +1,272 @@ +#include <unistd.h> +#include <string.h> +#include <errno.h> +#include <error.h> +#include <argp.h> +#include <netdb.h> +#include <fcntl.h> + +#include <version.h> + +#include <ftpconn.h> + +#define COPY_SZ 65536 + +const char *argp_program_version = STANDARD_HURD_VERSION (ftpcp); + +#define OPT_SRC_U -3 +#define OPT_SRC_A -4 +#define OPT_SRC_P -5 +#define OPT_DST_U -6 +#define OPT_DST_A -7 +#define OPT_DST_P -8 + + +static struct argp_option options[] = +{ + {"user", 'u', "USER",0, "User to login as on both ftp servers"}, + {"password", 'p', "PWD", 0, "USER's password"}, + {"account", 'a', "ACCT",0, "Account to login as"}, + {"src-user", OPT_SRC_U, "USER",0, "User to login as on the src ftp server"}, + {"src-password",OPT_SRC_P, "PWD", 0, "The src USER's password"}, + {"src-account", OPT_SRC_A, "ACCT",0, "Account to login as on the source server"}, + {"dst-user", OPT_DST_U, "USER",0, "User to login as on the dst ftp server"}, + {"dst-password",OPT_DST_P, "PWD", 0, "The dst USER's password"}, + {"dst-account", OPT_DST_A, "ACCT",0, "Account to login as on the source server"}, + {"debug", 'D', 0, 0, "Turn on debugging output for ftp connections"}, + {0, 0} +}; +static char *args_doc = "SRC [DST]"; +static char *doc = "Copy file SRC over ftp to DST." +"\vBoth SRC and DST may have the form HOST:FILE, FILE, or -, where - is standard" +" input for SRC or standard output for DST, and FILE is a local file."; + +/* customization hooks. */ +static struct ftp_conn_hooks conn_hooks = { 0 }; + +static void +cntl_debug (struct ftp_conn *conn, int type, const char *txt) +{ + char *type_str; + + switch (type) + { + case FTP_CONN_CNTL_DEBUG_CMD: type_str = "."; break; + case FTP_CONN_CNTL_DEBUG_REPLY: type_str = "="; break; + default: type_str = "?"; break; + } + + fprintf (stderr, "%s%s\n", type_str, txt); +} + +/* Return an ftp connection for the host NAME using PARAMS. If an error + occurrs, a message is printed the program exits. If CNAME is non-zero, + the host's canonical name, in mallocated storage, is returned in it. */ +struct ftp_conn * +get_host_conn (char *name, struct ftp_conn_params *params, char **cname) +{ + error_t err; + struct hostent *he; + struct ftp_conn *conn; + + he = gethostbyname (name); + if (! he) + error (10, 0, "%s: %s", name, hstrerror (h_errno)); + + params->addr = malloc (he->h_length); + if (! params->addr) + error (11, ENOMEM, "%s", name); + + bcopy (he->h_addr_list[0], params->addr, he->h_length); + params->addr_len = he->h_length; + params->addr_type = he->h_addrtype; + + err = ftp_conn_create (params, &conn_hooks, &conn); + if (err) + error (12, err, "%s", he->h_name); + + if (cname) + *cname = strdup (he->h_name); + + return conn; +} + +static void +cp (int src, const char *src_name, int dst, const char *dst_name) +{ + ssize_t rd; + static void *copy_buf = 0; + + if (! copy_buf) + { + copy_buf = valloc (COPY_SZ); + if (! copy_buf) + error (13, ENOMEM, "Cannot allocate copy buffer"); + } + + while ((rd = read (src, copy_buf, COPY_SZ)) > 0) + do + { + int wr = write (dst, copy_buf, rd); + if (wr < 0) + error (14, errno, "%s", dst_name); + rd -= wr; + } + while (rd > 0); + + if (rd != 0) + error (15, errno, "%s", src_name); +} + +struct epoint +{ + char *name; /* Name, of the form HOST:FILE, FILE, or -. */ + char *rmt_file; /* If NAME is remote, the FILE portion, or 0. */ + char *rmt_host; /* If NAME is remote, the HOST portion, or 0. */ + int fd; /* A file descriptor to use. */ + struct ftp_conn *conn; /* An ftp connection to use. */ + struct ftp_conn_params params; +}; + +int +main (int argc, char **argv) +{ + int i; + error_t err; + struct epoint epoints[2] = { {0}, {0} }; + struct ftp_conn_params def_params = { 0 }; /* default params */ + + /* Parse our options... */ + error_t parse_opt (int key, char *arg, struct argp_state *state) + { + switch (key) + { + case ARGP_KEY_ARG: + if (state->arg_num < 2) + epoints[state->arg_num].name = arg; + break; + + case ARGP_KEY_NO_ARGS: + argp_usage (state); + + case 'u': def_params.user = arg; break; + case 'p': def_params.pass = arg; break; + case 'a': def_params.acct = arg; break; + + case OPT_SRC_U: epoints[0].params.user = arg; break; + case OPT_SRC_P: epoints[0].params.pass = arg; break; + case OPT_SRC_A: epoints[0].params.acct = arg; break; + + case OPT_DST_U: epoints[1].params.user = arg; break; + case OPT_DST_P: epoints[1].params.pass = arg; break; + case OPT_DST_A: epoints[1].params.acct = arg; break; + + case 'D': conn_hooks.cntl_debug = cntl_debug; break; + + default: + return ARGP_ERR_UNKNOWN; + } + return 0; + } + struct argp argp = {options, parse_opt, args_doc, doc}; + + argp_parse (&argp, argc, argv, 0, 0, 0); + + for (i = 0; i < 2; i++) + { + char *rmt; + + if (! epoints[i].name) + epoints[i].name = "-"; + + rmt = strchr (epoints[i].name, ':'); + if (rmt) + { + *rmt++ = 0; + + if (! epoints[i].params.user) + epoints[i].params.user = def_params.user; + if (! epoints[i].params.pass) + epoints[i].params.pass = def_params.pass; + if (! epoints[i].params.acct) + epoints[i].params.acct = def_params.acct; + + epoints[i].conn = + get_host_conn (epoints[i].name, &epoints[i].params, + &epoints[i].name); + epoints[i].name = + realloc (epoints[i].name, + strlen (epoints[i].name) + 1 + strlen (rmt) + 1); + if (! epoints[i].name) + error (22, ENOMEM, "Cannot allocate name storage"); + + err = ftp_conn_set_type (epoints[i].conn, "I"); + if (err) + error (23, err, "%s: Cannot set connection type to binary", + epoints[i].name); + + strcat (epoints[i].name, ":"); + strcat (epoints[i].name, rmt); + + epoints[i].rmt_file = rmt; + } + else if (epoints[i].params.user + || epoints[i].params.pass + || epoints[i].params.acct) + error (20, 0, + "%s: Ftp login parameter specified for a local endpoint (%s,%s,%s)", + epoints[i].name, + epoints[i].params.user, + epoints[i].params.pass, + epoints[i].params.acct); + } + + if (epoints[0].conn && epoints[1].conn) + { + err = ftp_conn_rmt_copy (epoints[0].conn, epoints[0].rmt_file, + epoints[1].conn, epoints[1].rmt_file); + if (err) + error (30, err, "Remote copy"); + } + else + { + for (i = 0; i < 2; i++) + if (epoints[i].conn) + { + if (i == 0) + err = ftp_conn_start_retrieve (epoints[i].conn, + epoints[i].rmt_file, + &epoints[i].fd); + else + err = ftp_conn_start_store (epoints[i].conn, + epoints[i].rmt_file, + &epoints[i].fd); + if (err) + error (31, err, "%s", epoints[i].name); + } + else if (strcmp (epoints[i].name, "-") == 0) + epoints[i].fd = i; + else + { + int flags = (i == 0) ? O_RDONLY : (O_WRONLY | O_CREAT | O_TRUNC); + epoints[i].fd = open (epoints[i].name, flags, 0666); + if (epoints[i].fd < 0) + error (32, errno, "%s", epoints[i].name); + } + + cp (epoints[0].fd, epoints[0].name, epoints[1].fd, epoints[1].name); + + for (i = 0; i < 2; i++) + { + close (epoints[i].fd); + if (epoints[i].conn) + { + err = ftp_conn_finish_transfer (epoints[i].conn); + if (err) + error (31, err, "%s", epoints[i].name); + } + } + } + + exit (0); +} diff --git a/libftpconn/ftpdir.c b/libftpconn/ftpdir.c new file mode 100644 index 00000000..36d15df0 --- /dev/null +++ b/libftpconn/ftpdir.c @@ -0,0 +1,308 @@ +#include <unistd.h> +#include <string.h> +#include <error.h> +#include <argp.h> +#include <time.h> +#include <netdb.h> + +#include <version.h> + +#include <ftpconn.h> + +#define COPY_SZ 65536 + +const char *argp_program_version = STANDARD_HURD_VERSION (ftpdir); + +static struct argp_option options[] = +{ + {"user", 'u', "USER",0, "User to login as on ftp server"}, + {"password", 'p', "PWD", 0, "USER's password"}, + {"account", 'a', "ACCT",0, "Account to login as"}, + {"separator",'S', "SEP", 0, "String to separate multiple listings"}, + {"prefix", 'P', "PFX", 0, "String to proceed listings; the first and second" + " occurances of %s are replace by HOST and DIR"}, + {"host", 'h', "HOST",0, "Use HOST as a default host"}, + {"debug", 'D', 0, 0, "Turn on debugging output for ftp connections"}, + {"intepret", 'i', 0, 0, "Parse the directory output"}, + {0, 0} +}; +static char *args_doc = "[([HOST:]DIR | HOST:)...]"; +static char *doc = "Get a directory listing over ftp from HOST:DIR." +"\vIf HOST is not supplied in an argument any default value set by --host is" +" used; if DIR is not supplied, the default directory of HOST is used." +"\nIf multiple DIRs are supplied on the command line, each listing is" +" prefixed by a newline (or SEP) and a line containing HOST:DIR: (or PFX)."; + +/* customization hooks. */ +static struct ftp_conn_hooks conn_hooks = { 0 }; + +static void +cntl_debug (struct ftp_conn *conn, int type, const char *txt) +{ + char *type_str; + + switch (type) + { + case FTP_CONN_CNTL_DEBUG_CMD: type_str = "."; break; + case FTP_CONN_CNTL_DEBUG_REPLY: type_str = "="; break; + default: type_str = "?"; break; + } + + fprintf (stderr, "%s%s\n", type_str, txt); +} + +struct ftpdir_host +{ + char *name; + struct ftp_conn_params params; + struct ftp_conn *conn; + struct ftpdir_host *next; +}; + +/* Return an ftp connection for the host NAME using PARAMS, and add an entry + for it to *HOSTS. If a connection already exists in HOSTS, it is returned + instead of making a new one. If an error occurrs, a message is printed and + 0 is returned. */ +static struct ftpdir_host * +get_host_conn (char *name, struct ftp_conn_params *params, + struct ftpdir_host **hosts) +{ + error_t err; + struct ftpdir_host *h; + struct hostent *he; + + for (h = *hosts; h; h = h->next) + if (strcmp (h->name, name) == 0) + return h; + + he = gethostbyname (name); + if (! he) + { + error (0, 0, "%s: %s", name, hstrerror (h_errno)); + return 0; + } + + for (h = *hosts; h; h = h->next) + if (he->h_addrtype == h->params.addr_type + && he->h_length == h->params.addr_len + && bcmp (he->h_addr_list[0], h->params.addr, he->h_length) == 0) + return h; + + h = malloc (sizeof (struct ftpdir_host)); + if (! h) + { + error (0, ENOMEM, "%s", name); + return 0; + } + + h->params = *params; + h->params.addr = malloc (he->h_length); + h->name = strdup (he->h_name); + + if (!h->name || !h->params.addr) + err = ENOMEM; + else + { + bcopy (he->h_addr_list[0], h->params.addr, he->h_length); + h->params.addr_len = he->h_length; + h->params.addr_type = he->h_addrtype; + err = ftp_conn_create (&h->params, &conn_hooks, &h->conn); + } + + if (err) + { + error (0, err, "%s", he->h_name); + if (h->name) + free (h->name); + if (h->params.addr) + free (h->params.addr); + free (h); + return 0; + } + + h->next = *hosts; + *hosts = h; + + return h; +} + +static int +ftpdir (char *dir, struct ftpdir_host *host) +{ + int data; + int rd; + error_t err; + static void *copy_buf = 0; + struct ftp_conn *conn = host->conn; + char *host_name = host->name; + + err = ftp_conn_start_dir (conn, dir, &data); + if (err) + { + error (0, err, "%s:%s", host_name, dir); + return err; + } + + if (! copy_buf) + { + copy_buf = valloc (COPY_SZ); + if (! copy_buf) + error (12, ENOMEM, "Cannot allocate copy buffer"); + } + + while ((rd = read (data, copy_buf, COPY_SZ)) > 0) + do + { + int wr = write (1, copy_buf, rd); + if (wr < 0) + error (13, errno, "stdout"); + rd -= wr; + } + while (rd > 0); + if (rd != 0) + { + error (0, errno, "%s:%s", host_name, dir); + return errno; + } + + close (data); + + err = ftp_conn_finish_transfer (conn); + if (err) + { + error (0, err, "%s:%s", host_name, dir); + return err; + } + + return 0; +} + +static error_t +pdirent (const char *name, const struct stat *st, const char *symlink_target, + void *hook) +{ + char timebuf[20]; + strftime (timebuf, sizeof timebuf, "%Y-%m-%d %H:%M", localtime (&st->st_mtime)); + printf ("%6o %2d %5d %5d %6ld %s %s\n", + st->st_mode, st->st_nlink, st->st_uid, st->st_gid, st->st_size, + timebuf, name); + if (symlink_target) + printf (" -> %s\n", + symlink_target); + return 0; +} + +static error_t +ftpdir2 (char *dir, struct ftpdir_host *host) +{ + error_t err = ftp_conn_get_stats (host->conn, dir, 1, pdirent, 0); + if (err == ENOTDIR) + err = ftp_conn_get_stats (host->conn, dir, 0, pdirent, 0); + if (err) + error (0, err, "%s:%s", host->name, dir); + return err; +} + +int +main (int argc, char **argv) +{ + struct ftpdir_host *hosts = 0; + char *default_host = 0; + int interpret = 0; + struct ftp_conn_params params = { 0 }; + char *sep = "\n"; + char *pfx = "%s:%s:\n"; + int use_pfx = 0; + int errs = 0; + + /* Parse our options... */ + error_t parse_opt (int key, char *arg, struct argp_state *state) + { + switch (key) + { + case ARGP_KEY_ARG: + { + char *host, *dir; + + if (state->next < state->argc) + use_pfx = 1; /* Multiple arguments. */ + + dir = index (arg, ':'); + if (dir) + { + host = arg; + *dir++ = '\0'; + if (*host == '\0') + /* An argument of `:' */ + host = default_host; + } + else + { + host = default_host; + dir = arg; + } + + if (host) + { + struct ftpdir_host *h = get_host_conn (host, ¶ms, &hosts); + if (h) + { + if (state->arg_num > 0) + fputs (sep, stdout); + if (use_pfx) + printf (pfx, h->name, dir); + if (interpret) + errs |= ftpdir2 (dir, h); + else + errs |= ftpdir (dir, h); + } + errs = 1; + } + else + { + error (0, 0, "%s: No default host", arg); + errs = 1; + } + } + break; + + case ARGP_KEY_NO_ARGS: + if (default_host) + { + struct ftpdir_host *h = + get_host_conn (default_host, ¶ms, &hosts); + if (h) + errs |= ftpdir (0, h); + } + else + { + error (0, 0, "No default host"); + errs = 1; + } + break; + + return EINVAL; + + case 'u': params.user = arg; break; + case 'p': params.pass = arg; break; + case 'a': params.acct = arg; break; + case 'h': default_host = arg; break; + case 'D': conn_hooks.cntl_debug = cntl_debug; break; + case 'P': pfx = arg; use_pfx = 1; break; + case 'S': sep = arg; break; + case 'i': interpret = 1; break; + + default: + return ARGP_ERR_UNKNOWN; + } + return 0; + } + struct argp argp = {options, parse_opt, args_doc, doc}; + + argp_parse (&argp, argc, argv, 0, 0, 0); + + if (errs) + exit (10); + else + exit (0); +} |