src/vfer_rcpd.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 * @file   vfer_rcpd.c
 * @author Ivan Beschastnikh
 * @brief  A server program that accepts one connection from vfer_rcp and receives or sends a file
 *
 * This program implements reliable transfer of data over the vfer protocol.
 *
 * -     05/06/06        ivan            added -vv option
 * -     04/30/06        ivan            made to use vfer_recvfile and vfer_sendfile
 * -     04/12/06        ivan            Added call to vfer_rcp_print_stats() at the end of each transmission and on exit
 * -     03/21/06        ivan            Added daemonizing support and rehashed usage to include start|stop
 * -     02/18/06        ivan            Changed name to vfer_rcpd.c. Added SIGINT handler to exit racefully, added
 *                                       support for daemonization via daemon() syscall - only on BSD and Linux
 * -     01/15/05        ivan            Branched from test_sndfile.c
 */

#include "vfer_rcp.h"

/**
 * @brief info structure used for parsing the command line arguments and options of test_rcpd
 */
typedef struct rcpd_info {
        char    user            [MAX_USER];
        char    home_dir        [MAX_PATH];
        int     frame_size;     /* frame size to use when sending files */
        int     port;           /* port to connect on */
        char    daemon;         /* 0: no , 1: yes */
} rcpd_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     rcpd_connect    ();

/* global vars */
vfer_fd connect_skt;            /* vfer_socket structure for communicating with the vfer library */
vfer_fd listen_skt;             /* vfer_socket structure for listening */
rcpd_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]] [-d] [-P port] start|stop\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-d        start server as a daemon process        [optional]\n");
        printf("\t-P        specifies port on which to listen       [optional]\n");
        printf("\tstart     starts the server                       [start|stop required]\n");
        printf("\tstop      stops all currently running servers     [start|stop required]\n");
        printf("notes:\n");
        printf("\t- port is defaulted to 2046\n");
        printf("\t- username matching is the only authentication mechanism\n");
        printf("\t- remote->remote copying is not implemented\n");
        printf("\t- encryption is not implemented\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
 *      1 on success [stop service]
 *      0 on success [start service]
 *      -1 on error
 *      -2 if help option was specified
 */
int parse_opts(int argc, char** argv, FILE** testing_out) {
        int c;
        struct passwd *pwentry; /* for getting current username */
        int uid;
        int ret;

        opterr=0;               /* suppress error printing by getopt() */
        bzero(info.user,MAX_USER);
        bzero(info.home_dir,MAX_PATH);
        info.frame_size = MAX_FRAME_SIZE;
        info.port = DEFAULT_PORT;
        info.daemon = 0;
        *testing_out = NULL;
        while (1)
        {
                c = getopt (argc, argv, ":hvdP:");
                if (c == -1) break;
                switch (c) {
                case 'h':
                        return -2;
                        break;
                case 'P':
                        info.port = atoi(optarg);
                        break;
                case 'd':
                        info.daemon = 1;
                        break;
                case 'v':       /* allow for -vv for higher verbosity */
                        if (*testing_out == NULL) {
                                /* no api output but VFER_RCPD 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 != 1) {
                T_ERR("parse_opts", "exactly one non-option arg required");
                return -1;
        }

        /* check whether the user wants to start vferd or to start it */
        if (strlen(argv[optind]) == 5 && strncmp(argv[optind], "start", 5) == 0) {
                ret = 0;
        } else if (strlen(argv[optind]) == 4 && strncmp(argv[optind], "stop", 4) == 0) {
                ret = 1;
        } else {
                T_ERR("parse_opts", "non-option arg must be start/stop");
                return -1;
        }

        /* find out and cache the username running this server */
        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;
        }
        if (strlen(pwentry->pw_dir) > MAX_PATH) {
                T_ERR("parse_opts", "length of home dir must be less than %d", MAX_PATH);
                return -1;
        }

        strncpy(info.home_dir, pwentry->pw_dir, MAX_PATH);
        strncpy(info.user, pwentry->pw_name, MAX_USER);

        /* ret is either 0 or 1, set above when checking the non-optional argument */
        return ret;
} /* parse_opts() */

/**
 * This function makes preliminary api calls to vfer lib to create a
 * listening socket
 *
 * @return -1 on error
 * @return 0 on success
 */
int rcpd_connect() {

        struct sockaddr_in sa;
        int ret;

        bzero((char*)(&sa), sizeof(sa));
        sa.sin_family = AF_INET;
        sa.sin_addr.s_addr = htonl(INADDR_ANY);
        sa.sin_port = htons(info.port);

        if ((listen_skt = vfer_socket (SOCK_DGRAM)) < 0) {
                TEST_PRINT("rcpd_connect", "vfer_socket failed [%s]", vfer_errortext(listen_skt));
                close(fd);
                return -1;
        }

        if ((ret = vfer_bind  (listen_skt, (struct sockaddr*) &sa, sizeof(sa))) < 0) {
                TEST_PRINT("rcpd_connect", "vfer_bind failed [%s]", vfer_errortext(ret));
                close(fd);
                return -1;
        }
        if ((ret = vfer_listen (listen_skt, 3)) < 0) {
                TEST_PRINT("rcpd_connect", "vfer_listen failed [%s]", vfer_errortext(ret));
                close(fd);
                return -1;
        }
        return 0;
} /* rcpd_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;
        client_msg_t client_msg;
        server_msg_t server_msg;
        struct sockaddr_in sa_accepted;
        socklen_t accepted_len;
        char buf[INET_ADDRSTRLEN];
        struct stat stat_buf;
        char path[MAX_PATH * 2];
        struct sigaction sa;
        int pid;
        char fname[16];
        FILE* file;
        FILE* testing_out;
        DIR* dir;
        struct dirent* dir_e;
        vfer_stats stats;
        connect_skt = -1;

        ret = parse_opts(argc, argv, &testing_out);
        TEST_INIT("VFER_RCPD", "vfer_rcpd.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;
        } else if (ret == 1) {
                TEST_PRINT("main", "stopping all running vferd");
                dir = opendir("/tmp/");
                while ((dir_e = readdir(dir))) {
                        if (strncmp(dir_e->d_name, "vferd_", 6) == 0) {
                                pid = atoi(dir_e->d_name + 6);
                                printf("stopping vferd[%d]\n", pid);
                                if (kill((pid_t)(pid), SIGKILL) == -1) {
                                        T_ERR("main", "SIGKILL failed on vferd with pid[%d]", pid);
                                } else {
                                        TEST_PRINT("main", "stopped vferd with pid [%d]", pid);
                                }
                                sprintf(fname, "/tmp/%s", dir_e->d_name);
                                unlink(fname);
                        }
                }
                closedir(dir);
                return 0;
        } else if (ret != 0) {
                T_ERR("main", "parse_opts returned bad value, quitting");
                return -1;
        }

        /* else => ret == 0 */
        /* become a daemon if -d was specified on the cmd line */
        if (info.daemon == 1) {
                TEST_PRINT("main", "daemonizing ..");
                fflush(stdout);
                if (daemon(1,0) == -1) {
                        TEST_PRINT("main", "couldn't start as daemon, daemon() call failed");
                }
        }

        TEST_PRINT("main", "starting vferd");
        pid = (int) getpid();
        sprintf(fname, "/tmp/vferd_%d", pid);
        file = fopen(fname,"w");
        fclose(file);

        /* 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");
        }

        /* connect to the listening port */
        if (rcpd_connect() == -1) {
                return -1;
        }

        TEST_PRINT("main", "started with authenticating username: %s, home_dir: %s", info.user, info.home_dir);

        while (1) {
        retry_accept:
                if ((connect_skt = vfer_accept(listen_skt, (SA*)(&sa_accepted), &accepted_len)) < 0) {
                        if (connect_skt == VFER_TIMEOUT) {
                                TEST_PRINT("main", "vfer_accept timedout, retrying");
                                goto retry_accept;
                        }
                        TEST_PRINT("main", "vfer_accept failed [%s]", vfer_errortext(connect_skt));
                        vfer_close(listen_skt);
                        return 1;
                }

                TEST_PRINT("main", "vfer_accept successfull new connection: [%s : %d]",
                           inet_ntop(AF_INET, &(sa_accepted.sin_addr),buf, INET_ADDRSTRLEN),
                           ntohs(sa_accepted.sin_port));

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

                TEST_PRINT("main", "received: rpath[%s] local_uname[%s] recvd_uname[%s] from_remote[%d] file_size[%u]",
                           client_msg.remote_path, client_msg.local_name, client_msg.user, client_msg.from_remote, client_msg.file_size);

                server_msg.file_size = 0;
                server_msg.file_size = htonl(server_msg.file_size);

                /* verify user name */
                if (strncmp(info.user, client_msg.user, MAX_USER) != 0) {
                        TEST_PRINT("main", "remote connection gave bad username[%s]", client_msg.user);
                        server_msg.status = RCP_EUSER;
                        server_msg.status = htonl(server_msg.status);
                        if ((ret = vfer_send(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                                TEST_PRINT("main", "failed to send server msg to client [%s]", vfer_errortext(ret));
                        }
                        goto CLEAN_UP;
                }

                /* expand out the home directory truncation */
                if (client_msg.remote_path[0] == '~') {
                        strncpy(path, info.home_dir, MAX_PATH);
                        strncpy(path + strlen(path), client_msg.remote_path+1, MAX_PATH);
                } else {
                        strncpy(path, client_msg.remote_path, MAX_PATH);
                }

                TEST_PRINT("main", "path expanded to: %s", path);
                if (client_msg.from_remote == 0) {
                        /* send local file to client */
                        if ((fd = open(path, O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) == -1) {
                                TEST_PRINT("main", "open for reading failed");
                                perror("open for reading failed");
                                /* send server msg to client */
                                server_msg.status       = RCP_EOPEN;
                                server_msg.status       = htonl(server_msg.status);
                                if ((ret = vfer_send(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                                        TEST_PRINT("main", "failed to send server msg to client [%s]", vfer_errortext(ret));
                                        goto CLEAN_UP;
                                }
                        } else {
                                /* send server msg to client */
                                server_msg.status       = RCP_READY;
                                server_msg.file_size    = lseek(fd, 0, SEEK_END);
                                server_msg.file_size    = htonl(server_msg.file_size);
                                server_msg.status       = htonl(server_msg.status);
                                if ((ret = vfer_send(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                                        TEST_PRINT("main", "failed to send server msg to client [%s]", vfer_errortext(ret));
                                        goto CLEAN_UP;
                                }
                                server_msg.file_size    = ntohl(server_msg.file_size);
                                if ((ret = vfer_sendfile(connect_skt, fd, 0, server_msg.file_size)) < 0) {
                                        TEST_PRINT("main", "vfer_sendfile failed [%s]", vfer_errortext(ret));
                                        goto CLEAN_UP;
                                }
                        }
                } else { /* client_msg.from_remote == 1 */
                        /* receive file from client */

                        /* check if path ends if '/' */
                        if (path[strlen(path) - 1] == '/') {
                                /* append local_name to path and continue */
                                strncpy(path + strlen(path), client_msg.local_name, 2*MAX_PATH - strlen(path));
                        } else {
                                /* check if the path is an existing directory */
                                if (stat(path, &stat_buf) == -1) {
                                        server_msg.status = RCP_EOTHER;
                                        switch (errno) {
                                        case ENOENT:
                                                /* file that does not exist, great, continue */
                                                TEST_PRINT("main", "writing to a new file");
                                                break;
                                        case ENOTDIR: /* bad path (one of directories doesn't exist, bail */
                                                TEST_PRINT("main", "bad path from client");
                                                server_msg.status = RCP_ENOENT;
                                        default: /* something is wrong, bail */
                                                TEST_PRINT("main", "stat failed");
                                                /* send server msg to client */
                                                server_msg.status = htonl(server_msg.status);
                                                if ((ret = vfer_send(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                                                        TEST_PRINT("main", "failed to send server msg to client [%s]", vfer_errortext(ret));
                                                        goto CLEAN_UP;
                                                }
                                        }
                                } else {
                                        /* check if path is an existing directory */
                                        if (stat_buf.st_mode & S_IFDIR) {
                                                /* yes- append local_name to path and continue */
                                                path[strlen(path)] = '/';
                                                path[strlen(path)+1] = 0;
                                                strncpy(path + strlen(path), client_msg.local_name, 256 - strlen(path));
                                        }
                                }
                        }

                        if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) == -1) {
                                TEST_PRINT("main", "open for writing failed");
                                perror("open for writing failed");
                                /* send server msg to client */
                                server_msg.status = RCP_EOPEN;
                                server_msg.status = htonl(server_msg.status);
                                if ((ret = vfer_send(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                                        TEST_PRINT("main", "failed to send server msg to client [%s]", vfer_errortext(ret));
                                        goto CLEAN_UP;
                                }
                        } else {
                                /* send server msg to client */
                                server_msg.status = RCP_READY;
                                server_msg.status = htonl(server_msg.status);
                                if ((ret = vfer_send(connect_skt, &server_msg, sizeof(server_msg_t))) < 0) {
                                        TEST_PRINT("main", "failed to send server msg to client [%s]", vfer_errortext(ret));
                                        goto CLEAN_UP;
                                }
                                if ((ret = vfer_recvfile(connect_skt, fd, 0, client_msg.file_size)) < 0){
                                        TEST_PRINT("main","vfer_recvfile failed [%s]", vfer_errortext(ret));
                                        goto CLEAN_UP;
                                }
                        }
                }
        CLEAN_UP:
                TEST_PRINT("main", "Closing the accepted socket");
                vfer_close(connect_skt);
                stats = vfer_sockstats(connect_skt);
                connect_skt = -1;
                vfer_rcp_print_stats(&stats);   /* vfer_rcp_print_stats() is defined in vfer_rcp.h */
                close(fd);
        }

        return 0;
} /* main() */

---