src/vsl_rcp.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */

/**
 * @file   vsl_rcp.c
 * @author Nikolaus Rath
 * @brief  VSL filetransfer client
 */

#include "vsl_rcp.h"
#include "vsl_api.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "vsl.h"
#include <pwd.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include "vfer.h"

/**
 * @brief structure used for parsing the command line arguments and options of test_rcp
 */
typedef struct vsl_rcp_info {
    char local_path[MAX_PATH];
    char remote_path[MAX_PATH];
    char cmd[MAX_PATH];
    char user[MAX_USER];
    char host[MAX_HOST];
    char from_remote;   /* 0: yes (get remote file to local sys),
                         * 1: no (put local file to remote sys)*/
    char logfile[MAX_PATH];
    int debug;
} vsl_rcp_info;


/* Prototypes */
void    print_help      (char* prog, int verbose);
int     parse_opts      (int argc, char** argv, vsl_rcp_info *t);


/**
 * 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]] [-c path_to_rcpd] [[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       even more verbose message printing      [optional]\n");
    printf("\t-l        only in combination with -v. Specifies the (remote) filename\n"
           "\t          where the server writes its debug output to. Defaults to\n"
           "\t          " DEBUGLOG "\t\t [optional]\n");
    printf("\t-c        pathname of vsl_rcpd on remote host     [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- one remote host is required (signaled with ':')\n");
    printf("\t- username is defauled to user invoking the program\n");
    printf("\t- remote->remote copying is not implemented\n");
} /* print_help() */


/**
 * Parses the command line arguments and options to main()
 *
 * This function will print descriptive errors it finds to stderr
 *
 * @param[in] argc is the argc argument to main
 * @param[in] argv is the argv argument to main
 * @param[out] info structure to store parsed arguments in
 * @return
 *      0 on success
 *      -1 on error
 *      -2 if help option was specified
 */
int parse_opts(int argc, char** argv, vsl_rcp_info* info) {
    int c;
    char* r;            /* remote path ptr */
    char* l;            /* local path ptr */
    char *cp, *cp2;
    struct passwd *pwentry;     /* for getting current username */
    int uid;

    /* getopt variables */
    extern char *optarg;
    extern int optind;
    extern int optopt;
    extern int opterr;

    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);
    strncpy(info->cmd, "vsl_rcpd", MAX_PATH);
    info->debug = 0;
    strncpy(info->logfile, DEBUGLOG, MAX_PATH);
    while (1) {
        c = getopt (argc, argv, ":hc:l:v");
        if (c == -1) break;
        switch (c) {
        case 'h':
            return -2;
            break;
        case 'c':
            strncpy(info->cmd, optarg, MAX_PATH);
            break;
        case 'l':
            strncpy(info->logfile, optarg, MAX_PATH);
            break;
        case 'v':
            if (info->debug == 0) {
                vsl_debug(stderr, NULL);
                info->debug=1;
            }
            else {
                vsl_debug(stderr, "pacC");
                info->debug=2;
            }
            break;
        case ':':
            fprintf(stderr,  "option %c missing value\n", optopt);
            return -1;
        case '?':
            fprintf(stderr,  "unknown option: %c\n", optopt);
            return -1;
        default:
            fprintf(stderr,  "getopt returned character code 0%o\n", c);
            return -1;
        }
    }
    if (argc - optind != 2) {
        fprintf(stderr,  "exactly two non-option args required\n");
        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) {
        fprintf(stderr,  "one of file paths must be local\n");
        return -1;
    } else if (cp == NULL && cp2 == NULL) {
        fprintf(stderr,  "one of file paths must be remote\n");
        return -1;
    }

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

    /* 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) {
            fprintf(stderr, "failed getting password entry for uid(%d)\n", uid);
            return -1;
        }
        if (strlen(pwentry->pw_name) > MAX_USER) {
            fprintf(stderr, "length of username must be less than %d\n", 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) {
            fprintf(stderr, "length of hostname must be less than %d\n", MAX_HOST);
            return -1;
        }
        strncpy(info->host, r, cp - r);
    } else {
        if (cp2 > cp) { /* ..:@.. */
            fprintf(stderr, "'@' must come before ':'\n");
            return -1;
        } else if (cp2 + 1 == cp) { /* ..@:.. */
            fprintf(stderr, "no hostname specified for remote path\n");
            return -1;
        } else if (cp2 == r) { /* @.. */
            fprintf(stderr, "missing username for remote path\n");
            return -1;
        }
        /* extract the host from between '@' and ':' chars */
        if (cp - cp2 > MAX_HOST) {
            fprintf(stderr, "length of hostname must be less than %d\n", MAX_HOST);
            return -1;
        }
        strncpy(info->host, cp2+1, cp - cp2 - 1);
        /* extract the username before the '@' char */
        if (cp2 - r > MAX_USER) {
            fprintf(stderr, "length of username must be less than %d\n", 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() */


/**
 * 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;

    /* Handle commandline */
    vsl_rcp_info info;
    if (argc == 1) {
        print_help(argv[0], 0);
        return 0;
    }
    if ( (ret = parse_opts(argc, argv, &info)) == -2) {
        print_help(argv[0], 1);
        return 0;
    } else if (ret == -1) {
        print_help(argv[0], 0);
        return -1;
    }

    /* construct client_msg */
    vsl_client_msg_t client_msg;
    int fd;
    char *c;
    strncpy(client_msg.remote_path, info.remote_path, MAX_PATH);
    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 (info.from_remote == 1) {
        if ((fd = open(info.local_path, O_RDONLY)) == -1) {
            fprintf(stderr, "couldn't open local file [%s] for reading\n", info.local_path);
            exit(1);
        }
        client_msg.file_size = lseek(fd, 0, SEEK_END);
        close(fd);
    } else {
        client_msg.file_size = 0;
    }

    /* Init sockets */
    vsl_sock sock;
    vfer_fd vfd;
    if ( (ret = vsl_init()) != 0) {
        fprintf(stderr, "cannot init vsl: %s!\n", vsl_errortext(ret));
        exit(1);
    }
    if ( (vfd = vfer_socket(SOCK_DGRAM)) < 0) {
        fprintf(stderr, "vfer_socket failed: %s!\n", vfer_errortext(vfd));
        exit(1);
    }
    if ( (ret = vsl_socket(&sock, vfd)) != 0) {
        fprintf(stderr, "vsl_socket failed: %s!\n", vsl_errortext(ret));
        exit(1);
    }

    /* connect to rcpd server */
    char errmsg[512] = "";
    int s_argc = 1;
    const char* s_argv[3];
    s_argv[0] = MAGIC_PARM;
    if ( info.debug > 0 ) {
        s_argc = 2;
        s_argv[1] = info.logfile;
    }
    if ( info.debug > 1 ) {
        s_argc = 3;
        s_argv[2] = "paCc";
    }
    if ( (ret = vsl_connect_ssh(&sock, info.host, info.user,
                                info.cmd, s_argc, s_argv,
                                errmsg)) != 0) {
        fprintf(stderr, "vsl_connect_ssh failed: %s!\n", vsl_errortext(ret));
        fprintf(stderr, "server said: %s!\n", errmsg);
        exit(1);
    }

    /* install a handler for SIGINT that will exit gracefully */
    struct sigaction sa;
    sa.sa_handler = &(sig_handler);
    if (sigaction(SIGINT, &sa, NULL) == -1)
        LOG("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 = vsl_send(&sock, &client_msg, sizeof(vsl_client_msg_t))) < 0) {
        fprintf(stderr, "send client msg failed [%s]\n", vsl_errortext(ret));
        goto CLEAN_UP_NO_STAT;
    }
    client_msg.file_size = ntohl(client_msg.file_size);

    /* receive server msg from rcpd server */
    vsl_server_msg_t server_msg;
    if ((ret = vsl_recv(&sock, &server_msg, sizeof(vsl_server_msg_t))) < 0) {
        fprintf(stderr, "receive server msg failed [%s]\n", vsl_errortext(ret));
        goto CLEAN_UP_NO_STAT;
    }
    server_msg.file_size = ntohl(server_msg.file_size);
    server_msg.status = ntohl(server_msg.status);

    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 = vsl_recvfile(&sock, fd, 0, server_msg.file_size)) < 0)
                fprintf(stderr,"vfer_recvfile failed [%s]\n", vsl_errortext(ret));

        } else {
            /* 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 = vsl_sendfile(&sock, fd, 0, client_msg.file_size)) < 0)
                fprintf(stderr, "vfer_sendfile failed [%s]\n", vsl_errortext(ret));
        }
        goto CLEAN_UP_STAT;

    case RCP_ENOENT:
        fprintf(stderr, "component of the path does not exist on remote file system\n");
        break;

    case RCP_EOPEN:
        if (info.from_remote == 0) {
            fprintf(stderr, "can't open remote file for reading\n");
        } else {
            fprintf(stderr, "can't open remote file for writing\n");
        }
        break;

    case RCP_ENOFILE:
        fprintf(stderr, "file doesn't exist on remote host\n");
        break;

    case RCP_EUSER:
        fprintf(stderr, "wrong username specified for remote host\n");
        break;

    case RCP_EOTHER:
        fprintf(stderr, "unspecified remote error\n");
        break;

    default:
        fprintf(stderr, "could not interpret server msg code\n");
        break;
    }

CLEAN_UP_NO_STAT:
    vsl_close(&sock);
    vsl_uninit();
    close(fd);
    return 0;

CLEAN_UP_STAT:
    ;
    vfer_stats stats;
    stats = vfer_sockstats(vsl_vferfd(&sock));
    if ( info.debug )
        vfer_rcp_print_stats(&stats);
    vsl_close(&sock);
    vfer_close(vfd);
    vsl_uninit();
    close(fd);
    return 0;
}


/*
 * Local Variables:
 * compile-command: "cd ..; make file_xfer"
 * compilation-search-path: ("..")
 * End:
 */

---