2 * Copyright (C) 1997-2013 Andre Noll <maan@systemlinux.org>
4 * Licensed under the GPL v2. For licencing details see COPYING.
7 /** \file client_common.c Common functions of para_client and para_audiod. */
10 #include <sys/types.h>
16 #include "client.cmdline.h"
22 #include "client.cmdline.h"
24 #include "buffer_tree.h"
27 /** The size of the receiving buffer. */
28 #define CLIENT_BUFSIZE 4000
31 * Close the connection to para_server and deallocate per-command ressources.
33 * \param ct The client task.
35 * This frees all ressources of the current command but keeps the configuration
38 * \sa \ref client_close().
40 void client_disconnect(struct client_task
*ct
)
46 free_argv(ct
->features
);
48 sc_free(ct
->scc
.recv
);
50 sc_free(ct
->scc
.send
);
52 btr_remove_node(&ct
->btrn
);
56 * Close the connection to para_server and free all resources.
58 * \param ct Pointer to the client data.
60 * \sa \ref client_open(), \ref client_disconnect().
62 void client_close(struct client_task
*ct
)
66 client_disconnect(ct
);
68 free(ct
->config_file
);
70 client_cmdline_parser_free(&ct
->conf
);
71 free(ct
->challenge_hash
);
77 * The preselect hook for server commands.
79 * \param s Pointer to the scheduler.
80 * \param t Pointer to the task struct for this command.
82 * The task pointer must contain a pointer to the initialized client data
83 * structure as it is returned by client_open().
85 * This function checks the state of the connection and adds the file descriptor
86 * of the connection to the read or write fd set of \a s accordingly.
88 * \sa register_task() client_open(), struct sched, struct task.
90 static void client_pre_select(struct sched
*s
, struct task
*t
)
93 struct client_task
*ct
= container_of(t
, struct client_task
, task
);
94 struct btr_node
*btrn
= ct
->btrn
;
101 case CL_SENT_CH_RESPONSE
:
102 case CL_SENT_COMMAND
:
103 para_fd_set(ct
->scc
.fd
, &s
->rfds
, &s
->max_fileno
);
106 case CL_RECEIVED_WELCOME
:
107 case CL_RECEIVED_PROCEED
:
108 case CL_RECEIVED_CHALLENGE
:
109 para_fd_set(ct
->scc
.fd
, &s
->wfds
, &s
->max_fileno
);
113 ret
= btr_node_status(btrn
, 0, BTR_NT_ROOT
);
118 para_fd_set(ct
->scc
.fd
, &s
->rfds
,
123 ret
= btr_node_status(btrn
, 0, BTR_NT_LEAF
);
128 para_fd_set(ct
->scc
.fd
, &s
->wfds
,
135 static int client_recv_buffer(struct client_task
*ct
, fd_set
*rfds
,
136 char *buf
, size_t sz
, size_t *n
)
140 if (ct
->status
< CL_SENT_CH_RESPONSE
)
141 return read_nonblock(ct
->scc
.fd
, buf
, sz
, rfds
, n
);
144 ret
= sc_recv_buffer(&ct
->scc
, buf
, sz
);
146 * sc_recv_buffer is used with blocking fds elsewhere, so it
147 * does not use the nonblock-API. Therefore we need to
148 * check for EOF and EAGAIN.
151 return -E_SERVER_EOF
;
152 if (ret
== -ERRNO_TO_PARA_ERROR(EAGAIN
))
160 static int send_sb(struct client_task
*ct
, void *buf
, size_t numbytes
,
161 enum sb_designator band
, bool dont_free
)
163 int ret
, fd
= ct
->scc
.fd
;
167 struct sb_buffer sbb
;
168 sb_transformation trafo
= ct
->status
< CL_RECEIVED_PROCEED
?
170 sbb
= (typeof(sbb
))SBB_INIT(band
, buf
, numbytes
);
171 ct
->sbc
= sb_new_send(&sbb
, dont_free
, trafo
, ct
->scc
.send
);
173 ret
= sb_get_send_buffers(ct
->sbc
, iov
);
174 ret
= xwritev(fd
, iov
, ret
);
180 if (sb_sent(ct
->sbc
, ret
)) {
187 static int recv_sb(struct client_task
*ct
, fd_set
*rfds
,
188 struct sb_buffer
*result
)
192 sb_transformation trafo
;
196 if (!FD_ISSET(ct
->scc
.fd
, rfds
))
198 if (ct
->status
< CL_SENT_CH_RESPONSE
)
199 trafo
= trafo_context
= NULL
;
202 trafo_context
= ct
->scc
.recv
;
205 ct
->sbc
= sb_new_recv(0, trafo
, trafo_context
);
207 sb_get_recv_buffer(ct
->sbc
, &iov
);
208 ret
= read_nonblock(ct
->scc
.fd
, iov
.iov_base
, iov
.iov_len
, rfds
, &n
);
216 if (!sb_received(ct
->sbc
, n
, result
))
223 static char **parse_features(char *buf
)
226 const char id
[] = "\nFeatures: ";
227 char *p
, *q
, **features
;
237 create_argv(p
, ",", &features
);
238 for (i
= 0; features
[i
]; i
++)
239 PARA_INFO_LOG("server feature: %s\n", features
[i
]);
243 static int dispatch_sbb(struct client_task
*ct
, struct sb_buffer
*sbb
)
246 const char *designator
[] = {SB_DESIGNATORS_ARRAY
};
250 if (sbb
->band
< NUM_SB_DESIGNATORS
)
251 PARA_DEBUG_LOG("band: %s\n", designator
[sbb
->band
]);
255 if (iov_valid(&sbb
->iov
))
256 btr_add_output(sbb
->iov
.iov_base
, sbb
->iov
.iov_len
,
263 case SBD_WARNING_LOG
:
267 if (iov_valid(&sbb
->iov
)) {
268 int ll
= sbb
->band
- SBD_DEBUG_LOG
;
269 para_log(ll
, "remote: %s", (char *)sbb
->iov
.iov_base
);
273 case SBD_EXIT__SUCCESS
:
274 ret
= -E_SERVER_CMD_SUCCESS
;
276 case SBD_EXIT__FAILURE
:
277 ret
= -E_SERVER_CMD_FAILURE
;
280 PARA_ERROR_LOG("invalid band %d\n", sbb
->band
);
285 free(sbb
->iov
.iov_base
);
287 sbb
->iov
.iov_base
= NULL
;
291 static bool has_feature(const char *feature
, struct client_task
*ct
)
293 return find_arg(feature
, ct
->features
) >= 0? true : false;
296 static int send_sb_command(struct client_task
*ct
)
303 return send_sb(ct
, NULL
, 0, 0, false);
305 for (i
= 0; i
< ct
->conf
.inputs_num
; i
++)
306 len
+= strlen(ct
->conf
.inputs
[i
]) + 1;
307 p
= command
= para_malloc(len
);
308 for (i
= 0; i
< ct
->conf
.inputs_num
; i
++) {
309 strcpy(p
, ct
->conf
.inputs
[i
]);
310 p
+= strlen(ct
->conf
.inputs
[i
]) + 1;
312 PARA_DEBUG_LOG("--> %s\n", command
);
313 return send_sb(ct
, command
, len
, SBD_COMMAND
, false);
317 * The post select hook for client commands.
319 * \param s Pointer to the scheduler.
320 * \param t Pointer to the task struct for this command.
322 * Depending on the current state of the connection and the status of the read
323 * and write fd sets of \a s, this function performs the necessary steps to
324 * authenticate the connection, to send the command given by \a t->private_data
325 * and to receive para_server's output, if any.
327 * \sa struct sched, struct task.
329 static int client_post_select(struct sched
*s
, struct task
*t
)
331 struct client_task
*ct
= container_of(t
, struct client_task
, task
);
332 struct btr_node
*btrn
= ct
->btrn
;
335 char buf
[CLIENT_BUFSIZE
];
337 ret
= task_get_notification(t
);
342 switch (ct
->status
) {
343 case CL_CONNECTED
: /* receive welcome message */
344 ret
= client_recv_buffer(ct
, &s
->rfds
, buf
, sizeof(buf
), &n
);
345 if (ret
< 0 || n
== 0)
347 ct
->features
= parse_features(buf
);
348 ct
->status
= CL_RECEIVED_WELCOME
;
350 case CL_RECEIVED_WELCOME
: /* send auth command */
351 if (!FD_ISSET(ct
->scc
.fd
, &s
->wfds
))
353 if (has_feature("sideband", ct
)) {
354 ct
->use_sideband
= true;
355 sprintf(buf
, AUTH_REQUEST_MSG
"%s sideband", ct
->user
);
357 sprintf(buf
, AUTH_REQUEST_MSG
"%s", ct
->user
);
358 PARA_INFO_LOG("--> %s\n", buf
);
359 ret
= write_buffer(ct
->scc
.fd
, buf
);
362 ct
->status
= CL_SENT_AUTH
;
366 * Receive challenge and session keys, decrypt the challenge and
367 * send back the hash of the decrypted challenge.
370 /* decrypted challenge/session key buffer */
371 unsigned char crypt_buf
[1024];
372 /* the SHA1 of the decrypted challenge */
374 if (ct
->use_sideband
) {
375 struct sb_buffer sbb
;
376 ret
= recv_sb(ct
, &s
->rfds
, &sbb
);
379 if (sbb
.band
!= SBD_CHALLENGE
) {
381 free(sbb
.iov
.iov_base
);
385 PARA_INFO_LOG("<-- [challenge] (%zu bytes)\n", n
);
386 ret
= priv_decrypt(ct
->key_file
, crypt_buf
,
387 sbb
.iov
.iov_base
, n
);
388 free(sbb
.iov
.iov_base
);
392 ret
= client_recv_buffer(ct
, &s
->rfds
, buf
, sizeof(buf
), &n
);
393 if (ret
< 0 || n
== 0)
395 PARA_INFO_LOG("<-- [challenge] (%zu bytes)\n", n
);
396 ret
= priv_decrypt(ct
->key_file
, crypt_buf
,
397 (unsigned char *)buf
, n
);
401 ct
->challenge_hash
= para_malloc(HASH_SIZE
);
402 hash_function((char *)crypt_buf
, CHALLENGE_SIZE
, ct
->challenge_hash
);
403 ct
->scc
.send
= sc_new(crypt_buf
+ CHALLENGE_SIZE
, SESSION_KEY_LEN
);
404 ct
->scc
.recv
= sc_new(crypt_buf
+ CHALLENGE_SIZE
+ SESSION_KEY_LEN
,
406 hash_to_asc(ct
->challenge_hash
, buf
);
407 PARA_INFO_LOG("--> %s\n", buf
);
408 ct
->status
= CL_RECEIVED_CHALLENGE
;
411 case CL_RECEIVED_CHALLENGE
:
412 if (ct
->use_sideband
) {
413 ret
= send_sb(ct
, ct
->challenge_hash
, HASH_SIZE
,
414 SBD_CHALLENGE_RESPONSE
, false);
416 ct
->challenge_hash
= NULL
;
420 ret
= write_all(ct
->scc
.fd
, (char *)ct
->challenge_hash
, HASH_SIZE
);
424 ct
->status
= CL_SENT_CH_RESPONSE
;
426 case CL_SENT_CH_RESPONSE
: /* read server response */
428 if (ct
->use_sideband
) {
429 struct sb_buffer sbb
;
430 ret
= recv_sb(ct
, &s
->rfds
, &sbb
);
433 free(sbb
.iov
.iov_base
);
434 if (sbb
.band
!= SBD_PROCEED
)
437 ct
->status
= CL_RECEIVED_PROCEED
;
440 ret
= client_recv_buffer(ct
, &s
->rfds
, buf
, sizeof(buf
), &n
);
441 if (ret
< 0 || n
== 0)
443 /* check if server has sent "Proceed" message */
444 ret
= -E_CLIENT_AUTH
;
445 if (n
< PROCEED_MSG_LEN
)
447 if (!strstr(buf
, PROCEED_MSG
))
449 ct
->status
= CL_RECEIVED_PROCEED
;
452 case CL_RECEIVED_PROCEED
: /* concat args and send command */
455 char *command
= NULL
;
456 if (!FD_ISSET(ct
->scc
.fd
, &s
->wfds
))
458 if (ct
->use_sideband
) {
459 ret
= send_sb_command(ct
);
462 ct
->status
= CL_SENT_COMMAND
;
465 for (i
= 0; i
< ct
->conf
.inputs_num
; i
++) {
467 command
= make_message("%s\n%s", command
?
468 command
: "", ct
->conf
.inputs
[i
]);
471 command
= para_strcat(command
, EOC_MSG
"\n");
472 PARA_DEBUG_LOG("--> %s\n", command
);
473 ret
= sc_send_buffer(&ct
->scc
, command
);
477 ct
->status
= CL_SENT_COMMAND
;
480 case CL_SENT_COMMAND
:
483 if (ct
->use_sideband
) {
484 struct sb_buffer sbb
;
485 ret
= recv_sb(ct
, &s
->rfds
, &sbb
);
488 if (sbb
.band
== SBD_AWAITING_DATA
) {
489 ct
->status
= CL_SENDING
;
490 free(sbb
.iov
.iov_base
);
493 ct
->status
= CL_RECEIVING
;
494 ret
= dispatch_sbb(ct
, &sbb
);
497 /* can not use "buf" here because we need a malloced buffer */
498 buf2
= para_malloc(CLIENT_BUFSIZE
);
499 ret
= client_recv_buffer(ct
, &s
->rfds
, buf2
, CLIENT_BUFSIZE
, &n
);
501 if (strstr(buf2
, AWAITING_DATA_MSG
)) {
503 ct
->status
= CL_SENDING
;
506 ct
->status
= CL_RECEIVING
;
507 btr_add_output(buf2
, n
, btrn
);
516 ret
= btr_node_status(btrn
, 0, BTR_NT_LEAF
);
521 if (!FD_ISSET(ct
->scc
.fd
, &s
->wfds
))
523 sz
= btr_next_buffer(btrn
, &buf2
);
524 ret
= sc_send_bin_buffer(&ct
->scc
, buf2
, sz
);
527 btr_consume(btrn
, sz
);
533 ret
= btr_node_status(btrn
, 0, BTR_NT_ROOT
);
539 * The FD_ISSET() is not strictly necessary, but is allows us
540 * to skip the malloc below if there is nothing to read anyway.
542 if (!FD_ISSET(ct
->scc
.fd
, &s
->rfds
))
544 if (ct
->use_sideband
) {
545 struct sb_buffer sbb
;
546 ret
= recv_sb(ct
, &s
->rfds
, &sbb
);
548 ret
= dispatch_sbb(ct
, &sbb
);
551 buf2
= para_malloc(CLIENT_BUFSIZE
);
552 ret
= client_recv_buffer(ct
, &s
->rfds
, buf2
, CLIENT_BUFSIZE
, &n
);
554 buf2
= para_realloc(buf2
, n
);
555 btr_add_output(buf2
, n
, btrn
);
563 if (!ct
->use_sideband
&& ret
!= -E_SERVER_EOF
&&
564 ret
!= -E_BTR_EOF
&& ret
!= -E_EOF
)
565 PARA_ERROR_LOG("%s\n", para_strerror(-ret
));
566 btr_remove_node(&ct
->btrn
);
572 * Connect to para_server and register the client task.
574 * \param ct The initialized client task structure.
575 * \param s The scheduler instance to register the client task to.
576 * \param parent The parent node of the client btr node.
577 * \param child The child node of the client node.
579 * The client task structure given by \a ct must be allocated and initialized
580 * by \ref client_parse_config() before this function is called.
584 int client_connect(struct client_task
*ct
, struct sched
*s
,
585 struct btr_node
*parent
, struct btr_node
*child
)
589 PARA_NOTICE_LOG("connecting %s:%d\n", ct
->conf
.hostname_arg
,
590 ct
->conf
.server_port_arg
);
592 ret
= para_connect_simple(IPPROTO_TCP
, ct
->conf
.hostname_arg
,
593 ct
->conf
.server_port_arg
);
597 ret
= mark_fd_nonblocking(ct
->scc
.fd
);
600 ct
->status
= CL_CONNECTED
;
601 ct
->btrn
= btr_new_node(&(struct btr_node_description
)
602 EMBRACE(.name
= "client", .parent
= parent
, .child
= child
));
603 ct
->task
.pre_select
= client_pre_select
;
604 ct
->task
.new_post_select
= client_post_select
;
606 sprintf(ct
->task
.status
, "client");
607 register_task(s
, &ct
->task
);
616 * Parse a client configuration.
618 * \param argc Usual argument count.
619 * \param argv Usual argument vector.
620 * \param ct_ptr Filled in by this function.
621 * \param loglevel If not \p NULL, the number of the loglevel is stored here.
623 * This checks the command line options given by \a argc and \a argv, sets
624 * default values for the user name and the name of the rsa key file and reads
625 * further options from the config file.
627 * Upon successful return, \a ct_ptr points to a dynamically allocated and
628 * initialized client task struct.
630 * \return The number of non-option arguments in \a argc/argv on success,
631 * negative on errors.
633 int client_parse_config(int argc
, char *argv
[], struct client_task
**ct_ptr
,
636 char *home
= para_homedir();
638 struct client_task
*ct
= para_calloc(sizeof(struct client_task
));
642 ret
= -E_CLIENT_SYNTAX
;
643 if (client_cmdline_parser(argc
, argv
, &ct
->conf
))
645 HANDLE_VERSION_FLAG("client", ct
->conf
);
647 ct
->config_file
= ct
->conf
.config_file_given
?
648 para_strdup(ct
->conf
.config_file_arg
) :
649 make_message("%s/.paraslash/client.conf", home
);
650 ret
= file_exists(ct
->config_file
);
651 if (!ret
&& ct
->conf
.config_file_given
) {
656 struct client_cmdline_parser_params params
= {
660 .check_ambiguity
= 0,
664 if (client_cmdline_parser_config_file(ct
->config_file
,
668 ct
->user
= ct
->conf
.user_given
?
669 para_strdup(ct
->conf
.user_arg
) : para_logname();
671 if (ct
->conf
.key_file_given
)
672 ct
->key_file
= para_strdup(ct
->conf
.key_file_arg
);
674 ct
->key_file
= make_message("%s/.paraslash/key.%s",
676 if (!file_exists(ct
->key_file
)) {
678 ct
->key_file
= make_message("%s/.ssh/id_rsa", home
);
683 *loglevel
= get_loglevel_by_name(ct
->conf
.loglevel_arg
);
684 PARA_INFO_LOG("loglevel: %s\n", ct
->conf
.loglevel_arg
);
685 PARA_INFO_LOG("config_file: %s\n", ct
->config_file
);
686 PARA_INFO_LOG("key_file: %s\n", ct
->key_file
);
687 ret
= ct
->conf
.inputs_num
;
691 PARA_ERROR_LOG("%s\n", para_strerror(-ret
));
699 * Parse the client configuration and open a connection to para_server.
701 * \param argc See \ref client_parse_config.
702 * \param argv See \ref client_parse_config.
703 * \param ct_ptr See \ref client_parse_config.
704 * \param loglevel See \ref client_parse_config.
705 * \param parent See \ref client_connect().
706 * \param child See \ref client_connect().
707 * \param sched See \ref client_connect().
709 * This function combines client_parse_config() and client_connect(). It is
710 * considered a syntax error if no command was given, i.e. if the number
711 * of non-option arguments is zero.
715 int client_open(int argc
, char *argv
[], struct client_task
**ct_ptr
,
716 int *loglevel
, struct btr_node
*parent
, struct btr_node
*child
,
719 int ret
= client_parse_config(argc
, argv
, ct_ptr
, loglevel
);
724 ret
= -E_CLIENT_SYNTAX
;
727 ret
= client_connect(*ct_ptr
, sched
, parent
, child
);
732 client_close(*ct_ptr
);