src/vsl_rcpd.c

Go to the documentation of this file.

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

/**
 * @file   vsl_rcpd.c
 * @author Nikolaus Rath
 * @brief  VSL file transfer server
 */

#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 info structure used for parsing the command line arguments and options of test_rcpd
 */
typedef struct vsl_rcpd_info {
    char        user            [MAX_USER];
    char        home_dir        [MAX_PATH];
} vsl_rcpd_info;


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

    /* Parse commandline */
    if ( argc < 2 ||
         strncmp(argv[1], MAGIC_PARM, sizeof(MAGIC_PARM)) != 0 ) {
        fprintf(stderr, "to be called by vsl_rcp only!\n");
        exit(1);
    }
    else if ( argc > 2 ) {
        FILE* fp;
        if ( (fp = fopen(argv[2], "w")) == NULL) {
            fprintf(stderr, "cannot open %s for writing: %s!\n",
                    argv[2], strerror(errno));
            exit(VSL_PERM);
        }
        if ( argc == 3 )
            vsl_debug(fp, NULL);
        else if ( argc == 4 )
            vsl_debug(fp, argv[3]);
    }

    /* find out and cache the username running this server */
    vsl_rcpd_info info;
    struct passwd *pwentry;
    int uid=getuid();
    if ((pwentry = getpwuid(uid)) == NULL) {
        fprintf(stderr, "failed getting password entry for uid(%d)\n", uid);
        exit(VSL_PERM);
    }
    if (strlen(pwentry->pw_dir) > MAX_PATH) {
        fprintf(stderr, "length of home dir must be less than %d\n", MAX_PATH);
        exit(VSL_PERM);
    }
    strncpy(info.home_dir, pwentry->pw_dir, MAX_PATH);
    strncpy(info.user, pwentry->pw_name, MAX_USER);

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

    /* Connect */
    if ( (ret = vsl_accept_ssh(&ssock)) != 0) {
        fprintf(stderr, "vsl_accept_ssh failed: %s!\n", vsl_errortext(ret));
        exit(VSL_TEMP);
    }
    // Close listening socket
    vfer_close(vfd);
    vfd = vsl_vferfd(&ssock);

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

    /* receive client msg */
    vsl_client_msg_t client_msg;
    vsl_server_msg_t server_msg;
    if ((ret = vsl_recv(&ssock, &client_msg, sizeof(vsl_client_msg_t))) < 0) {
        LOG( "failed to read client message: %s!", vsl_errortext(ret));
        goto CLEAN_UP;
    }
    client_msg.file_size = ntohl(client_msg.file_size);

    LOG("received: rpath[%s] from_remote[%d] file_size[%u]",
        client_msg.remote_path, client_msg.from_remote, client_msg.file_size);

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

    /* expand out the home directory truncation */
    char path[MAX_PATH * 2];
    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);
    }

    LOG( "path expanded to: %s", path);
    int fd;
    struct stat stat_buf;
    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) {
            LOG( "open for reading failed");
            /* send server msg to client */
            server_msg.status   = RCP_EOPEN;
            server_msg.status   = htonl(server_msg.status);
            if ((ret = vsl_send(&ssock, &server_msg, sizeof(vsl_server_msg_t))) < 0) {
                LOG("failed to send server msg to client [%s]", vsl_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 = vsl_send(&ssock, &server_msg, sizeof(vsl_server_msg_t))) < 0) {
                    LOG("failed to send server msg to client [%s]", vsl_errortext(ret));
                    goto CLEAN_UP;
                }
                server_msg.file_size    = ntohl(server_msg.file_size);
                if ((ret = vsl_sendfile(&ssock, fd, 0, server_msg.file_size)) < 0) {
                    LOG("vfer_sendfile failed [%s]", vsl_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 */
                    LOG( "writing to a new file");
                    break;
                case ENOTDIR: /* bad path (one of directories doesn't exist, bail */
                    LOG("bad path from client");
                    server_msg.status = RCP_ENOENT;
                default: /* something is wrong, bail */
                    LOG("stat failed");
                    /* send server msg to client */
                    server_msg.status = htonl(server_msg.status);
                    if ((ret = vsl_send(&ssock, &server_msg, sizeof(vsl_server_msg_t))) < 0) {
                        LOG("failed to send server msg to client [%s]", vsl_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) {
            LOG("open for writing failed");
            /* send server msg to client */
            server_msg.status = RCP_EOPEN;
            server_msg.status = htonl(server_msg.status);
            if ((ret = vsl_send(&ssock, &server_msg, sizeof(vsl_server_msg_t))) < 0) {
                LOG("failed to send server msg to client [%s]", vsl_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 = vsl_send(&ssock, &server_msg, sizeof(vsl_server_msg_t))) < 0) {
                LOG("failed to send server msg to client [%s]", vsl_errortext(ret));
                goto CLEAN_UP;
            }
            if ((ret = vsl_recvfile(&ssock, fd, 0, client_msg.file_size)) < 0){
                LOG("vfer_recvfile failed [%s]", vsl_errortext(ret));
                goto CLEAN_UP;
            }
        }
    }
CLEAN_UP:
    LOG("Closing the accepted socket");
    vsl_close(&ssock);
    vfer_close(vfd);
    if ( (ret = vsl_uninit()) != 0 )
        LOG("uninit failed: %s!", vsl_errortext(ret));
    close(fd);

    return 0;
} /* main() */

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

---