X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=client_common.c;h=8c8d6622c801fac58a43a4a2047155e8fc0949bf;hp=934758dd8f8e5ed03ff2493fe18e0cd533fde977;hb=6979083be2c739e5ef66e4e6ccec991d7b2b7908;hpb=9609fd30e0d3db45ede3ab5c6bc3a77c15b6aef8 diff --git a/client_common.c b/client_common.c index 934758dd..8c8d6622 100644 --- a/client_common.c +++ b/client_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1997-2009 Andre Noll + * Copyright (C) 1997-2011 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -8,8 +8,6 @@ #include #include -#include -#include #include "para.h" #include "error.h" @@ -17,31 +15,53 @@ #include "sched.h" #include "client.cmdline.h" #include "crypt.h" -#include "rc4.h" #include "net.h" #include "fd.h" #include "string.h" #include "client.cmdline.h" #include "client.h" -#include "hash.h" #include "buffer_tree.h" +#include "version.h" /** The size of the receiving buffer. */ #define CLIENT_BUFSIZE 4000 +/** + * Close the connection to para_server and deallocate per-command ressources. + * + * \param ct The client task. + * + * This frees all ressources of the current command but keeps the configuration + * in \p ct->conf. + * + * \sa \ref client_close(). + */ +void client_disconnect(struct client_task *ct) +{ + if (!ct) + return; + if (ct->scc.fd >= 0) + close(ct->scc.fd); + sc_free(ct->scc.recv); + ct->scc.recv = NULL; + sc_free(ct->scc.send); + ct->scc.send = NULL; + btr_free_node(ct->btrn); + ct->btrn = NULL; +} + /** * Close the connection to para_server and free all resources. * * \param ct Pointer to the client data. * - * \sa client_open. + * \sa \ref client_open(), \ref client_disconnect(). */ void client_close(struct client_task *ct) { if (!ct) return; - if (ct->rc4c.fd >= 0) - close(ct->rc4c.fd); + client_disconnect(ct); free(ct->user); free(ct->config_file); free(ct->key_file); @@ -69,19 +89,19 @@ static void client_pre_select(struct sched *s, struct task *t) struct client_task *ct = container_of(t, struct client_task, task); struct btr_node *btrn = ct->btrn; - if (ct->rc4c.fd < 0) + if (ct->scc.fd < 0) return; switch (ct->status) { case CL_CONNECTED: case CL_SENT_AUTH: case CL_SENT_CH_RESPONSE: case CL_SENT_COMMAND: - para_fd_set(ct->rc4c.fd, &s->rfds, &s->max_fileno); + para_fd_set(ct->scc.fd, &s->rfds, &s->max_fileno); return; case CL_RECEIVED_WELCOME: case CL_RECEIVED_PROCEED: - para_fd_set(ct->rc4c.fd, &s->wfds, &s->max_fileno); + para_fd_set(ct->scc.fd, &s->wfds, &s->max_fileno); return; case CL_RECEIVING: @@ -90,7 +110,7 @@ static void client_pre_select(struct sched *s, struct task *t) if (ret < 0) sched_min_delay(s); else - para_fd_set(ct->rc4c.fd, &s->rfds, + para_fd_set(ct->scc.fd, &s->rfds, &s->max_fileno); } return; @@ -100,24 +120,36 @@ static void client_pre_select(struct sched *s, struct task *t) if (ret < 0) sched_min_delay(s); else - para_fd_set(ct->rc4c.fd, &s->wfds, + para_fd_set(ct->scc.fd, &s->wfds, &s->max_fileno); } return; } } -static ssize_t client_recv_buffer(struct client_task *ct, char *buf, size_t len) +static int client_recv_buffer(struct client_task *ct, fd_set *rfds, + char *buf, size_t sz, size_t *n) { - ssize_t ret; + int ret; if (ct->status < CL_SENT_CH_RESPONSE) - ret = recv_buffer(ct->rc4c.fd, buf, len); - else - ret = rc4_recv_buffer(&ct->rc4c, buf, len); + return read_nonblock(ct->scc.fd, buf, sz, rfds, n); + + *n = 0; + ret = sc_recv_buffer(&ct->scc, buf, sz); + /* + * sc_recv_buffer is used with blocking fds elsewhere, so it + * does not use the nonblock-API. Therefore we need to + * check for EOF and EAGAIN. + */ if (ret == 0) return -E_SERVER_EOF; - return ret; + if (ret == -ERRNO_TO_PARA_ERROR(EAGAIN)) + return 0; + if (ret < 0) + return ret; + *n = ret; + return 0; } /** @@ -138,80 +170,72 @@ static void client_post_select(struct sched *s, struct task *t) struct client_task *ct = container_of(t, struct client_task, task); struct btr_node *btrn = ct->btrn; int ret = 0; + size_t n; char buf[CLIENT_BUFSIZE]; t->error = 0; - if (ct->rc4c.fd < 0) + if (ct->scc.fd < 0) return; switch (ct->status) { case CL_CONNECTED: /* receive welcome message */ - if (!FD_ISSET(ct->rc4c.fd, &s->rfds)) - return; - ret = client_recv_buffer(ct, buf, sizeof(buf)); - if (ret < 0) - goto err; + ret = client_recv_buffer(ct, &s->rfds, buf, sizeof(buf), &n); + if (ret < 0 || n == 0) + goto out; ct->status = CL_RECEIVED_WELCOME; return; case CL_RECEIVED_WELCOME: /* send auth command */ sprintf(buf, AUTH_REQUEST_MSG "%s", ct->user); PARA_INFO_LOG("--> %s\n", buf); - if (!FD_ISSET(ct->rc4c.fd, &s->wfds)) + if (!FD_ISSET(ct->scc.fd, &s->wfds)) return; - ret = send_buffer(ct->rc4c.fd, buf); + ret = send_buffer(ct->scc.fd, buf); if (ret < 0) - goto err; + goto out; ct->status = CL_SENT_AUTH; return; case CL_SENT_AUTH: /* - * Receive challenge and rc4 keys, decrypt the challenge and + * Receive challenge and session keys, decrypt the challenge and * send back the hash of the decrypted challenge. */ { - /* decrypted challenge/rc4 buffer */ + /* decrypted challenge/session key buffer */ unsigned char crypt_buf[1024]; /* the SHA1 of the decrypted challenge */ - unsigned char challenge_sha1[HASH_SIZE]; + unsigned char challenge_hash[HASH_SIZE]; - if (!FD_ISSET(ct->rc4c.fd, &s->rfds)) - return; - ret = client_recv_buffer(ct, buf, sizeof(buf)); - if (ret < 0) - goto err; - PARA_INFO_LOG("<-- [challenge] (%d bytes)\n", ret); - ret = para_decrypt_buffer(ct->key_file, crypt_buf, - (unsigned char *)buf, ret); + ret = client_recv_buffer(ct, &s->rfds, buf, sizeof(buf), &n); + if (ret < 0 || n == 0) + goto out; + PARA_INFO_LOG("<-- [challenge] (%zu bytes)\n", n); + ret = priv_decrypt(ct->key_file, crypt_buf, + (unsigned char *)buf, n); if (ret < 0) - goto err; - sha1_hash((char *)crypt_buf, CHALLENGE_SIZE, challenge_sha1); - RC4_set_key(&ct->rc4c.send_key, RC4_KEY_LEN, - crypt_buf + CHALLENGE_SIZE); - RC4_set_key(&ct->rc4c.recv_key, RC4_KEY_LEN, - crypt_buf + CHALLENGE_SIZE + RC4_KEY_LEN); - hash_to_asc(challenge_sha1, buf); + goto out; + hash_function((char *)crypt_buf, CHALLENGE_SIZE, challenge_hash); + ct->scc.send = sc_new(crypt_buf + CHALLENGE_SIZE, SESSION_KEY_LEN); + ct->scc.recv = sc_new(crypt_buf + CHALLENGE_SIZE + SESSION_KEY_LEN, + SESSION_KEY_LEN); + hash_to_asc(challenge_hash, buf); PARA_INFO_LOG("--> %s\n", buf); - ret = send_bin_buffer(ct->rc4c.fd, (char *)challenge_sha1, + ret = send_bin_buffer(ct->scc.fd, (char *)challenge_hash, HASH_SIZE); if (ret < 0) - goto err; + goto out; ct->status = CL_SENT_CH_RESPONSE; return; } case CL_SENT_CH_RESPONSE: /* read server response */ { - size_t bytes_received; - if (!FD_ISSET(ct->rc4c.fd, &s->rfds)) - return; - ret = client_recv_buffer(ct, buf, sizeof(buf)); - if (ret < 0) - goto err; - bytes_received = ret; + ret = client_recv_buffer(ct, &s->rfds, buf, sizeof(buf), &n); + if (ret < 0 || n == 0) + goto out; /* check if server has sent "Proceed" message */ ret = -E_CLIENT_AUTH; - if (bytes_received < PROCEED_MSG_LEN) - goto err; + if (n < PROCEED_MSG_LEN) + goto out; if (!strstr(buf, PROCEED_MSG)) - goto err; + goto out; ct->status = CL_RECEIVED_PROCEED; return; } @@ -219,7 +243,7 @@ static void client_post_select(struct sched *s, struct task *t) { int i; char *command = NULL; - if (!FD_ISSET(ct->rc4c.fd, &s->wfds)) + if (!FD_ISSET(ct->scc.fd, &s->wfds)) return; for (i = 0; i < ct->conf.inputs_num; i++) { char *tmp = command; @@ -229,33 +253,30 @@ static void client_post_select(struct sched *s, struct task *t) } command = para_strcat(command, EOC_MSG "\n"); PARA_DEBUG_LOG("--> %s\n", command); - ret = rc4_send_buffer(&ct->rc4c, command); + ret = sc_send_buffer(&ct->scc, command); free(command); if (ret < 0) - goto err; + goto out; ct->status = CL_SENT_COMMAND; return; } case CL_SENT_COMMAND: { char *buf2; - if (!FD_ISSET(ct->rc4c.fd, &s->rfds)) - return; /* can not use "buf" here because we need a malloced buffer */ buf2 = para_malloc(CLIENT_BUFSIZE); - ret = client_recv_buffer(ct, buf2, CLIENT_BUFSIZE); - if (ret < 0) { - free(buf2); - goto err; - } - if (strstr(buf2, AWAITING_DATA_MSG)) { + ret = client_recv_buffer(ct, &s->rfds, buf2, CLIENT_BUFSIZE, &n); + if (n > 0) { + if (strstr(buf2, AWAITING_DATA_MSG)) { + free(buf2); + ct->status = CL_SENDING; + return; + } + ct->status = CL_RECEIVING; + btr_add_output(buf2, n, btrn); + } else free(buf2); - ct->status = CL_SENDING; - return; - } - ct->status = CL_RECEIVING; - btr_add_output(buf2, ret, btrn); - return; + goto out; } case CL_SENDING: { @@ -263,15 +284,15 @@ static void client_post_select(struct sched *s, struct task *t) size_t sz; ret = btr_node_status(btrn, 0, BTR_NT_LEAF); if (ret < 0) - goto err; + goto out; if (ret == 0) return; - if (!FD_ISSET(ct->rc4c.fd, &s->wfds)) + if (!FD_ISSET(ct->scc.fd, &s->wfds)) return; sz = btr_next_buffer(btrn, &buf2); - ret = rc4_send_bin_buffer(&ct->rc4c, buf2, sz); + ret = sc_send_bin_buffer(&ct->scc, buf2, sz); if (ret < 0) - goto err; + goto out; btr_consume(btrn, sz); return; } @@ -280,23 +301,26 @@ static void client_post_select(struct sched *s, struct task *t) char *buf2; ret = btr_node_status(btrn, 0, BTR_NT_ROOT); if (ret < 0) - goto err; + goto out; if (ret == 0) return; - if (!FD_ISSET(ct->rc4c.fd, &s->rfds)) + /* + * The FD_ISSET() is not strictly necessary, but is allows us + * to skip the malloc below if there is nothing to read anyway. + */ + if (!FD_ISSET(ct->scc.fd, &s->rfds)) return; buf2 = para_malloc(CLIENT_BUFSIZE); - ret = client_recv_buffer(ct, buf2, CLIENT_BUFSIZE); - if (ret < 0) { + ret = client_recv_buffer(ct, &s->rfds, buf2, CLIENT_BUFSIZE, &n); + if (n > 0) { + buf2 = para_realloc(buf2, n); + btr_add_output(buf2, n, btrn); + } else free(buf2); - goto err; - } - buf2 = para_realloc(buf2, ret); - btr_add_output(buf2, ret, btrn); - return; + goto out; } } -err: +out: t->error = ret; if (ret < 0) { if (ret != -E_SERVER_EOF && ret != -E_BTR_EOF) @@ -305,71 +329,81 @@ err: } } -/* connect to para_server and register the client task */ -static int client_connect(struct client_task *ct) +/** + * Connect to para_server and register the client task. + * + * \param ct The initialized client task structure. + * \param s The scheduler instance to register the client task to. + * \param parent The parent node of the client btr node. + * \param child The child node of the client node. + * + * The client task structure given by \a ct must be allocated and initialized + * by \ref client_parse_config() before this function is called. + * + * \return Standard. + */ +int client_connect(struct client_task *ct, struct sched *s, + struct btr_node *parent, struct btr_node *child) { int ret; - ct->rc4c.fd = -1; - ret = makesock(AF_UNSPEC, IPPROTO_TCP, 0, ct->conf.hostname_arg, + PARA_NOTICE_LOG("connecting %s:%d\n", ct->conf.hostname_arg, ct->conf.server_port_arg); + ct->scc.fd = -1; + ret = para_connect_simple(IPPROTO_TCP, ct->conf.hostname_arg, + ct->conf.server_port_arg); if (ret < 0) return ret; - ct->rc4c.fd = ret; - ct->status = CL_CONNECTED; - ret = mark_fd_nonblocking(ct->rc4c.fd); + ct->scc.fd = ret; + ret = mark_fd_nonblocking(ct->scc.fd); if (ret < 0) goto err_out; + ct->status = CL_CONNECTED; + ct->btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = "client", .parent = parent, .child = child)); ct->task.pre_select = client_pre_select; ct->task.post_select = client_post_select; + ct->task.error = 0; sprintf(ct->task.status, "client"); - register_task(&ct->task); + register_task(s, &ct->task); return 1; err_out: - close(ct->rc4c.fd); - ct->rc4c.fd = -1; + close(ct->scc.fd); + ct->scc.fd = -1; return ret; } /** - * Open connection to para_server. + * Parse a client configuration. * * \param argc Usual argument count. * \param argv Usual argument vector. - * \param ct_ptr Points to dynamically allocated and initialized client task - * struct upon successful return. + * \param ct_ptr Filled in by this function. * \param loglevel If not \p NULL, the number of the loglevel is stored here. * - * Check the command line options given by \a argc and argv, set default values - * for user name and rsa key file, read further option from the config file. - * Finally, establish a connection to para_server. + * This checks the command line options given by \a argc and \a argv, sets + * default values for the user name and the name of the rsa key file and reads + * further options from the config file. * - * \return Standard. + * Upon successful return, \a ct_ptr points to a dynamically allocated and + * initialized client task struct. + * + * \return The number of non-option arguments in \a argc/argv on success, + * negative on errors. */ -int client_open(int argc, char *argv[], struct client_task **ct_ptr, - int *loglevel, struct btr_node *parent, struct btr_node *child) +int client_parse_config(int argc, char *argv[], struct client_task **ct_ptr, + int *loglevel) { char *home = para_homedir(); int ret; struct client_task *ct = para_calloc(sizeof(struct client_task)); - ct->btrn = btr_new_node(&(struct btr_node_description) - EMBRACE(.name = "client", .parent = parent, .child = child)); *ct_ptr = ct; - ct->rc4c.fd = -1; + ct->scc.fd = -1; ret = -E_CLIENT_SYNTAX; if (client_cmdline_parser(argc, argv, &ct->conf)) goto out; HANDLE_VERSION_FLAG("client", ct->conf); - ret = -E_CLIENT_SYNTAX; - if (!ct->conf.inputs_num) - goto out; - ct->user = ct->conf.user_given? - para_strdup(ct->conf.user_arg) : para_logname(); - - ct->key_file = ct->conf.key_file_given? - para_strdup(ct->conf.key_file_arg) : - make_message("%s/.paraslash/key.%s", home, ct->user); ct->config_file = ct->conf.config_file_given? para_strdup(ct->conf.config_file_arg) : @@ -392,22 +426,71 @@ int client_open(int argc, char *argv[], struct client_task **ct_ptr, &ct->conf, ¶ms)) goto out; } + ct->user = ct->conf.user_given? + para_strdup(ct->conf.user_arg) : para_logname(); + + if (ct->conf.key_file_given) + ct->key_file = para_strdup(ct->conf.key_file_arg); + else { + ct->key_file = make_message("%s/.paraslash/key.%s", + home, ct->user); + if (!file_exists(ct->key_file)) { + free(ct->key_file); + ct->key_file = make_message("%s/.ssh/id_rsa", home); + } + } + if (loglevel) *loglevel = get_loglevel_by_name(ct->conf.loglevel_arg); PARA_INFO_LOG("loglevel: %s\n", ct->conf.loglevel_arg); PARA_INFO_LOG("config_file: %s\n", ct->config_file); PARA_INFO_LOG("key_file: %s\n", ct->key_file); - PARA_NOTICE_LOG("connecting %s:%d\n", ct->conf.hostname_arg, - ct->conf.server_port_arg); - ret = client_connect(ct); + ret = ct->conf.inputs_num; out: free(home); if (ret < 0) { PARA_ERROR_LOG("%s\n", para_strerror(-ret)); - btr_remove_node(ct->btrn); - btr_free_node(ct->btrn); client_close(ct); *ct_ptr = NULL; } return ret; } + +/** + * Parse the client configuration and open a connection to para_server. + * + * \param argc See \ref client_parse_config. + * \param argv See \ref client_parse_config. + * \param ct_ptr See \ref client_parse_config. + * \param loglevel See \ref client_parse_config. + * \param parent See \ref client_connect(). + * \param child See \ref client_connect(). + * \param sched See \ref client_connect(). + * + * This function combines client_parse_config() and client_connect(). It is + * considered a syntax error if no command was given, i.e. if the number + * of non-option arguments is zero. + * + * \return Standard. + */ +int client_open(int argc, char *argv[], struct client_task **ct_ptr, + int *loglevel, struct btr_node *parent, struct btr_node *child, + struct sched *sched) +{ + int ret = client_parse_config(argc, argv, ct_ptr, loglevel); + + if (ret < 0) + return ret; + if (ret == 0) { + ret = -E_CLIENT_SYNTAX; + goto fail; + } + ret = client_connect(*ct_ptr, sched, parent, child); + if (ret < 0) + goto fail; + return 1; +fail: + client_close(*ct_ptr); + *ct_ptr = NULL; + return ret; +}