src/vfer_rcp.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 * @file   vfer_rcp.c
 * @author Ivan Beschastnikh
 * @brief  An rcp (remote copy) client, to be used with vfer_rcpd.c which implements the daemon
 *
 * This program implements reliable transfer of data to and from the
 * server running vfer_rcpd. It support scp style syntax.
 *
 * -     05/06/06        ivan            added -vv option
 * -     04/30/06        ivan            made to use vfer_recvfile and vfer_sendfile
 * -     04/12/06        ivan            Restructured main() and added call to vfer_rcp_print_stats()
 * -     02/18/06        ivan            Changed name to vfer_rcp.c
 * -     01/14/06        ivan            Branched from test_rcvfile.c, added scp-line command line parsing
 */

#include "vfer_rcp.h"

/**
 * @brief structure used for parsing the command line arguments and options of test_rcp
 */
typedef struct rcp_info {
        char local_path [MAX_PATH];
        char remote_path[MAX_PATH];
        char user       [MAX_USER];
        char host       [MAX_HOST];
        uint32_t frame_size;            /* frame size to use when sending files */
        int port;
        char from_remote;       /* 0: yes (get remote file to local sys), 1: no (put local file to remote sys)*/
} rcp_info;

extern char *optarg;
extern int optind;
extern int optopt;
extern int opterr;

void    print_help      (char* prog, int verbose);
int     parse_opts      (int argc, char** argv, FILE** testing_out);
int     rcp_connect     ();

/* global vars */
vfer_fd connect_skt;            /* vfer_fd for communicating with the vfer library */
rcp_info info;                  /* info structure with parsed command line arguments and options */
int fd;                         /* file descriptor used for reading\writing the local file */
int sig_mark = 0;               /* is set to 1 once a sigint is received */

/**
 * Prints a verbose or a non-verbose usage page
 *
 * @param prog program name to use in the help page
 * @param verbose controls whether the page is verbose(1) or not(0)
 */
void print_help(char* prog, int verbose) {
        printf("usage: %s [-h] [-v[v]] [-P port] [[user1@]host1:]file1 [[user2@]host2:]file2\n", prog);
        if (verbose == 0) return;
        printf("\t-h        brings up this help page                [optional]\n");
        printf("\t-v        verbose message printing                [optional]\n");
        printf("\t-vv       more verbose message printing           [optional]\n");
        printf("\t-P        specifies port to connect to            [optional]\n");
        printf("\tuser[1,2] username to use when connecting to host [optional]\n");
        printf("\thost[1,2] hostname of remote system\n");
        printf("\tfile[1,2] local, remote file path\n");
        printf("notes:\n");
        printf("\t- to do a remote->local copy specify the remote host and path first\n");
        printf("\t- to do a local->remote copy specify the local host and path first\n");
        printf("\t- one remote host is required (signaled with ':')\n");
        printf("\t- port is defaulted to 2046\n");
        printf("\t- username is defauled to user invoking the program but may be specified with '@'\n");
        printf("\t- username must match the user who started the remote host daemon\n");
        printf("\t- there is no other authentication with the remote daemon\n");
        printf("\t- remote->remote copying is not implemented\n");
        printf("\t- encryption is not implemented\n");
        printf("examples:\n");
        printf("\t%s /tmp/file.txt fred@work-computer.univ.edu:\n", prog);
        printf("\t\tcopy local file [/tmp/file.txt] to remote computer [work-computer.univ.edu] at remote path [~/] \n\n");
        printf("\t%s fred@work-computer.univ.edu:/tmp/file.txt ./\n", prog);
        printf("\t\tcopy remote file [/tmp/file.txt] at remote computer [work-computer.univ.edu] to local path [./] \n");
} /* print_help() */


/**
 * Parses the command line arguments and options to main()
 *
 * This function will print descriptive errors it finds to stdout
 *
 * @param argc is the argc argument to main
 * @param argv is the argv argument to main
 * @param testing_out is a FILE** type that is either set to NULL here or to 'stdout' depending on verbosity args
 * @return
 *      0 on success
 *      -1 on error
 *      -2 if help option was specified
 */
int parse_opts(int argc, char** argv, FILE** testing_out) {
        int c;
        char* r;                /* remote path ptr */
        char* l;                /* local path ptr */
        char *cp, *cp2;
        struct passwd *pwentry; /* for getting current username */
        int uid;

        opterr=0;               /* suppress error printing by getopt() */
        bzero(info.local_path,MAX_PATH);
        bzero(info.remote_path,MAX_PATH);
        bzero(info.user,MAX_USER);
        bzero(info.host,MAX_HOST);
        info.frame_size = (uint32_t)(MAX_FRAME_SIZE);
        info.port = DEFAULT_PORT;
        *testing_out = NULL;
        while (1) {
                c = getopt (argc, argv, ":hvP:");
                if (c == -1) break;
                switch (c) {
                case 'h':
                        return -2;
                        break;
                case 'P':
                        info.port = atoi(optarg);
                        break;
                case 'v':       /* allow for -vv for higher verbosity */
                        if (*testing_out == NULL) {
                                /* no api output but VFER_RCP output */
                                *testing_out = stdout;
                                vfer_debug(stdout, stdout, "a");
                        } else {
                                vfer_debug(stdout, stdout, "aCcP");
                        }
                        break;
                case ':':
                        T_ERR("parse_opts", "option %c missing value", optopt);
                        return -1;
                case '?':
                        T_ERR("parse_opts", "unknown option: %c", optopt);
                        return -1;
                default:
                        T_ERR("parse_opts", "getopt returned character code 0%o", c);
                        return -1;
                }
        }
        if (argc - optind != 2) {
                T_ERR("parse_opts", "exactly two non-option args required");
                return -1;
        }

        /* detect which of 2 args is a local and remote path */
        cp = index(argv[optind], ':');
        cp2 = index(argv[optind+1], ':');
        if (cp != NULL && cp2 != NULL) {
                T_ERR("parse_opts", "one of file paths must be local");
                return -1;
        } else if (cp == NULL && cp2 == NULL) {
                T_ERR("parse_opts", "one of file paths must be remote");
                return -1;
        }

        /* set local and remote path pointers */
        if (cp != NULL) {
                if (cp == argv[optind]) { /* no hostname */
                        T_ERR("parse_opts", "no hostname specified for remote path");
                        return -1;
                }
                info.from_remote = 0;
                r=argv[optind];
                l=argv[optind+1];
        } else {
                if (cp2 == argv[optind+1]) { /* no hostname */
                        T_ERR("parse_opts", "no hostname specified for remote path");
                        return -1;
                }
                info.from_remote = 1;
                l=argv[optind];
                r=argv[optind+1];
        }
        /* printf ("r: %s\n",r);
           printf ("l: %s\n",l); */

        /* set the local path */
        strncpy(info.local_path, l, MAX_PATH);

        /* extract the remote path */
        /* note that ':' must be in string pointed to by r (checked above) */
        cp = index(r, ':');
        if (strlen(r) - 1 + r == cp) { /* ..: */
                /* printf("remote path set to ~/");  */
                strcpy(info.remote_path, "~/");
        } else {                /* ..:.. */
                strncpy(info.remote_path, cp+1, MAX_PATH);
        }

        /* extract the host */
        cp2 = index(r, '@');
        if (cp2 == NULL) {      /* ..:.. */
                /* set the username to the current user name
                 * implicitly as there is no @ symbol to tell us
                 * username explicitly */
                uid=getuid();
                if ((pwentry = getpwuid(uid)) == NULL) {
                        T_ERR("parse_opts", "failed getting password entry for uid(%d)", uid);
                        return -1;
                }
                if (strlen(pwentry->pw_name) > MAX_USER) {
                        T_ERR("parse_opts", "length of username must be less than %d", MAX_USER);
                        return -1;
                }
                strncpy(info.user, pwentry->pw_name, MAX_USER);
                /* set the hostname to everything before the ':' char */
                if (cp - r > MAX_HOST) {
                        T_ERR("parse_opts", "length of hostname must be less than %d", MAX_HOST);
                        return -1;
                }
                strncpy(info.host, r, cp - r);
        } else {
                if (cp2 > cp) { /* ..:@.. */
                        T_ERR("parse_opts", "'@' must come before ':'");
                        return -1;
                } else if (cp2 + 1 == cp) { /* ..@:.. */
                        T_ERR("parse_opts", "no hostname specified for remote path");
                        return -1;
                } else if (cp2 == r) { /* @.. */
                        T_ERR("parse_opts", "missing username for remote path");
                        return -1;
                }
                /* extract the host from between '@' and ':' chars */
                if (cp - cp2 > MAX_HOST) {
                        T_ERR("parse_opts", "length of hostname must be less than %d", MAX_HOST);
                        return -1;
                }
                strncpy(info.host, cp2+1, cp - cp2 - 1);
                /* extract the username before the '@' char */
                if (cp2 - r > MAX_USER) {
                        T_ERR("parse_opts", "length of username must be less than %d", MAX_USER);
                        return -1;
                }
                strncpy(info.user, r, cp2 - r);
        }

        /* check if local path is a directory, if so append filename from remote path */
        if (info.local_path[strlen(info.local_path) - 1] == '/') {
                cp = rindex(info.remote_path, '/');
                strncpy(info.local_path + strlen(info.local_path), cp+1, MAX_PATH - strlen(info.local_path));
        }

        return 0;
} /* parse_opts() */

/**
 * Sets up the connect_skt for sending and receiving files by
 * doing all the socket api stuff
 */
int rcp_connect() {

        struct sockaddr_in client_sa;
        struct sockaddr_in server_sa;
        char hostname_buf[256];
        char local_ip[INET_ADDRSTRLEN];
        char remote_ip[INET_ADDRSTRLEN];
        struct hostent* h;
        int ret;

        /* find out local hostname */
        if (gethostname(hostname_buf, 256) == -1) {
                perror("gethostname");
                close(fd);
                return -1;
        }
        /* get the remote ip */
        if ((h = gethostbyname((const char*)(info.host))) == NULL) {
                perror("gethostbyname");
                close(fd);
                return -1;
        }
        if (h->h_addr_list != 0) {
                inet_ntop(h->h_addrtype, (h->h_addr_list)[0], remote_ip, sizeof(remote_ip));
        }
        /* get the local ip */
        if ((h = gethostbyname((const char*)(hostname_buf))) == NULL) {
                perror("gethostbyname");
                close(fd);
                return -1;
        }
        if (h->h_addr_list != 0) {
                inet_ntop(h->h_addrtype, (h->h_addr_list)[0], local_ip, sizeof(local_ip));
        }

        TEST_PRINT("rcp_connect","remote (%s : %s)", info.host, remote_ip);
        TEST_PRINT("rcp_connect","local  (%s : %s)", hostname_buf, local_ip);

        /* setup sockaddr structure for client */
        bzero((char*)(&client_sa), sizeof(client_sa));
        client_sa.sin_port = htons(0);
        client_sa.sin_family = AF_INET;
        if (inet_pton(AF_INET, local_ip, &client_sa.sin_addr) != 1) {
                TEST_PRINT("rcp_connect","inet_pton failed");
                close(fd);
                return -1;
        }
        /* setup sockaddr structure for server */
        bzero((char*)(&server_sa), sizeof(server_sa));
        server_sa.sin_family = AF_INET;
        server_sa.sin_port = htons(info.port);
        if (inet_pton(AF_INET, remote_ip, &server_sa.sin_addr) != 1) {
                TEST_PRINT("rcp_connect","inet_pton failed");
                close(fd);
                return -1;
        }
        /* create the socket structure */
        if ((connect_skt = vfer_socket (SOCK_DGRAM)) < 0) {
                TEST_PRINT("rcp_connect","vfer_socket failed [%s]", vfer_errortext(connect_skt));
                close(fd);
                return -1;
        }
        /* bind the socket to a local addr */
        if (vfer_bind  (connect_skt, (struct sockaddr*) &client_sa, sizeof(client_sa)) < 0) {
                TEST_PRINT("rcp_connect","vfer_bind failed [%s]", vfer_errortext(connect_skt));
                close(fd);
                return -1;
        }

        /* connect on the socket */
        if ((ret = vfer_connect (connect_skt, (SA*) (&server_sa), sizeof(server_sa))) < 0) {
                TEST_PRINT("rcp_connect","vfer_connect failed [%s]", vfer_errortext(ret));
                close(fd);
                return -1;
        }
        return 0;
} /* rcp_connect() */

/**
 * This function is a catcher of SIGINT signal, installed in main()
 */
void sig_handler(int sig) {
        exit(1);
} /* sig_handler() */

/**
 * main
 */
int main (int argc, char **argv) {
        int ret;
        char* c;
        client_msg_t client_msg;
        server_msg_t server_msg;
        vfer_stats stats;
        FILE* testing_out;
        struct sigaction sa;
        connect_skt = -1;

        if (argc == 1) {
                print_help(argv[0], 0);
                return 0;
        }

        ret = parse_opts(argc, argv, &testing_out);
        TEST_INIT("VFER_RCP", "vfer_rcp.c", testing_out, stdout);

        if (ret == -2) {
                print_help(argv[0], 1);
                return 0;
        } else if (ret == -1) {
                print_help(argv[0], 0);
                return -1;
        }

        TEST_PRINT("main", "parsed: from_remote[%d] lpath[%s] uname[%s] host[%s] port[%d] rpath[%s]",
                   info.from_remote, info.local_path, info.user, info.host, info.port, info.remote_path);

        /* construct client_msg */
        strncpy(client_msg.remote_path, info.remote_path, MAX_PATH);
        strncpy(client_msg.user, info.user, MAX_USER);
        strncpy(client_msg.user, info.user, MAX_USER);
        client_msg.from_remote = info.from_remote;

        if ((c = rindex(info.local_path, '/')) == NULL) {
                strncpy(client_msg.local_name, info.local_path, MAX_PATH);
        } else {
                strncpy(client_msg.local_name, c+1, MAX_PATH);
        }

        /* if we are sending a local file, record and send the file's size to the server */
        if (info.from_remote == 1) {
                if ((fd = open(info.local_path, O_RDONLY)) == -1) {
                        TEST_PRINT("main", "couldn't open local file [%s] for reading", info.local_path);
                        return -1;
                }
                client_msg.file_size = lseek(fd, 0, SEEK_END);
                close(fd);
        } else {
                client_msg.file_size = 0;
        }

        /* connect to rcpd server */
        if (rcp_connect() == -1) {
                return -1;
        }
        TEST_PRINT("main","connected!");

        /* install a handler for SIGINT that will exit gracefully */
        sa.sa_handler = &(sig_handler);
        if (sigaction(SIGINT, &sa, NULL) == -1) {
                TEST_PRINT("main", "couldn't install a signal handler for SIGINT");
        }

        /* send client msg to rcpd server */
        client_msg.file_size = htonl(client_msg.file_size);
        if ((ret = vfer_send(connect_skt, &client_msg, sizeof(client_msg_t))) < 0) {
                TEST_PRINT("main", "send client msg failed [%s]", vfer_errortext(ret));
                goto CLEAN_UP_NO_STAT;
        }
        client_msg.file_size = ntohl(client_msg.file_size);

        /* receive server msg from rcpd server */
        if ((ret = vfer_recv(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                TEST_PRINT("main", "receive server msg failed [%s]", vfer_errortext(ret));
                goto CLEAN_UP_NO_STAT;
        }
        server_msg.file_size    = ntohl(server_msg.file_size);
        server_msg.status       = ntohl(server_msg.status);

        TEST_PRINT("main", "received server msg with status[%u] file_size[%u]", server_msg.status, server_msg.file_size);

        switch (server_msg.status) {
        case RCP_READY:
                if (info.from_remote == 0) {
                        /* receive remote file */
                        if ((fd = open(info.local_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) == -1) {
                                perror("open for writing failed");
                                goto CLEAN_UP_NO_STAT;
                        }
                        if ((ret = vfer_recvfile(connect_skt, fd, 0, server_msg.file_size)) < 0){
                                TEST_PRINT("main","vfer_recvfile failed [%s]", vfer_errortext(ret));
                                goto CLEAN_UP_STAT;
                        }

                } else { /* info.from_remote == 1 */
                        /* send local file */
                        if ((fd = open(info.local_path, O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) == -1) {
                                perror("open for reading failed");
                                goto CLEAN_UP_NO_STAT;
                        }

                        if ((ret = vfer_sendfile(connect_skt, fd, 0, client_msg.file_size)) < 0) {
                                TEST_PRINT("main","vfer_sendfile failed [%s]", vfer_errortext(ret));
                                goto CLEAN_UP_STAT;
                        }
                }
                goto CLEAN_UP_STAT;
        case RCP_ENOENT:
                T_ERR("main", "component of the path does not exist on remote file system");
                break;
        case RCP_EOPEN:
                if (info.from_remote == 0) {
                        T_ERR("main", "can't open remote file for reading");
                } else {
                        T_ERR("main", "can't open remote file for writing");
                }
                break;
        case RCP_ENOFILE:
                T_ERR("main", "file doesn't exist on remote host");
                break;
        case RCP_EUSER:
                T_ERR("main", "wrong username specified for remote host");
                break;
        case RCP_EOTHER:
                T_ERR("main", "unspecified remote error");
                break;
        default:
                T_ERR("main", "could not interpret server msg code");
                break;
        }
 CLEAN_UP_NO_STAT:
        vfer_close(connect_skt);
        close(fd);
        return 0;
 CLEAN_UP_STAT:
        vfer_close(connect_skt);
        stats = vfer_sockstats(connect_skt);
        connect_skt = -1;
        if (test_out != NULL)
            vfer_rcp_print_stats(&stats);
        close(fd);
        return 0;
} /* main() */

---