cee76f8b9449d8b9bcd1b9af1db83ec7bdf03354
[paraslash.git] / client_common.c
1 /*
2 * Copyright (C) 1997-2013 Andre Noll <maan@systemlinux.org>
3 *
4 * Licensed under the GPL v2. For licencing details see COPYING.
5 */
6
7 /** \file client_common.c Common functions of para_client and para_audiod. */
8
9 #include <regex.h>
10 #include <sys/types.h>
11
12 #include "para.h"
13 #include "error.h"
14 #include "list.h"
15 #include "sched.h"
16 #include "client.cmdline.h"
17 #include "crypt.h"
18 #include "net.h"
19 #include "fd.h"
20 #include "sideband.h"
21 #include "string.h"
22 #include "client.cmdline.h"
23 #include "client.h"
24 #include "buffer_tree.h"
25 #include "version.h"
26
27 /** The size of the receiving buffer. */
28 #define CLIENT_BUFSIZE 4000
29
30 /**
31 * Close the connection to para_server and deallocate per-command ressources.
32 *
33 * \param ct The client task.
34 *
35 * This frees all ressources of the current command but keeps the configuration
36 * in \p ct->conf.
37 *
38 * \sa \ref client_close().
39 */
40 void client_disconnect(struct client_task *ct)
41 {
42 if (!ct)
43 return;
44 if (ct->scc.fd >= 0)
45 close(ct->scc.fd);
46 free_argv(ct->features);
47 ct->features = NULL;
48 sc_free(ct->scc.recv);
49 ct->scc.recv = NULL;
50 sc_free(ct->scc.send);
51 ct->scc.send = NULL;
52 btr_remove_node(&ct->btrn);
53 }
54
55 /**
56 * Close the connection to para_server and free all resources.
57 *
58 * \param ct Pointer to the client data.
59 *
60 * \sa \ref client_open(), \ref client_disconnect().
61 */
62 void client_close(struct client_task *ct)
63 {
64 if (!ct)
65 return;
66 client_disconnect(ct);
67 free(ct->user);
68 free(ct->config_file);
69 free(ct->key_file);
70 client_cmdline_parser_free(&ct->conf);
71 free(ct->challenge_hash);
72 sb_free(ct->sbc);
73 free(ct);
74 }
75
76 /**
77 * The preselect hook for server commands.
78 *
79 * \param s Pointer to the scheduler.
80 * \param t Pointer to the task struct for this command.
81 *
82 * The task pointer must contain a pointer to the initialized client data
83 * structure as it is returned by client_open().
84 *
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.
87 *
88 * \sa register_task() client_open(), struct sched, struct task.
89 */
90 static void client_pre_select(struct sched *s, struct task *t)
91 {
92 int ret;
93 struct client_task *ct = container_of(t, struct client_task, task);
94 struct btr_node *btrn = ct->btrn;
95
96 if (ct->scc.fd < 0)
97 return;
98 switch (ct->status) {
99 case CL_CONNECTED:
100 case CL_SENT_AUTH:
101 case CL_SENT_CH_RESPONSE:
102 case CL_SENT_COMMAND:
103 para_fd_set(ct->scc.fd, &s->rfds, &s->max_fileno);
104 return;
105
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);
110 return;
111
112 case CL_RECEIVING:
113 ret = btr_node_status(btrn, 0, BTR_NT_ROOT);
114 if (ret != 0) {
115 if (ret < 0)
116 sched_min_delay(s);
117 else
118 para_fd_set(ct->scc.fd, &s->rfds,
119 &s->max_fileno);
120 }
121 return;
122 case CL_SENDING:
123 ret = btr_node_status(btrn, 0, BTR_NT_LEAF);
124 if (ret != 0) {
125 if (ret < 0)
126 sched_min_delay(s);
127 else
128 para_fd_set(ct->scc.fd, &s->wfds,
129 &s->max_fileno);
130 }
131 return;
132 }
133 }
134
135 static int client_recv_buffer(struct client_task *ct, fd_set *rfds,
136 char *buf, size_t sz, size_t *n)
137 {
138 int ret;
139
140 if (ct->status < CL_SENT_CH_RESPONSE)
141 return read_nonblock(ct->scc.fd, buf, sz, rfds, n);
142
143 *n = 0;
144 ret = sc_recv_buffer(&ct->scc, buf, sz);
145 /*
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.
149 */
150 if (ret == 0)
151 return -E_SERVER_EOF;
152 if (ret == -ERRNO_TO_PARA_ERROR(EAGAIN))
153 return 0;
154 if (ret < 0)
155 return ret;
156 *n = ret;
157 return 0;
158 }
159
160 static int send_sb(struct client_task *ct, void *buf, size_t numbytes,
161 enum sb_designator band, bool dont_free)
162 {
163 int ret, fd = ct->scc.fd;
164 struct iovec iov[2];
165
166 if (!ct->sbc) {
167 struct sb_buffer sbb;
168 sb_transformation trafo = ct->status < CL_RECEIVED_PROCEED?
169 NULL : sc_trafo;
170 sbb = (typeof(sbb))SBB_INIT(band, buf, numbytes);
171 ct->sbc = sb_new_send(&sbb, dont_free, trafo, ct->scc.send);
172 }
173 ret = sb_get_send_buffers(ct->sbc, iov);
174 ret = xwritev(fd, iov, ret);
175 if (ret < 0) {
176 sb_free(ct->sbc);
177 ct->sbc = NULL;
178 return ret;
179 }
180 if (sb_sent(ct->sbc, ret)) {
181 ct->sbc = NULL;
182 return 1;
183 }
184 return 0;
185 }
186
187 static int recv_sb(struct client_task *ct, fd_set *rfds,
188 struct sb_buffer *result)
189 {
190 int ret;
191 size_t n;
192 sb_transformation trafo;
193 void *trafo_context;
194 struct iovec iov;
195
196 if (!FD_ISSET(ct->scc.fd, rfds))
197 return 0;
198 if (ct->status < CL_SENT_CH_RESPONSE)
199 trafo = trafo_context = NULL;
200 else {
201 trafo = sc_trafo;
202 trafo_context = ct->scc.recv;
203 }
204 if (!ct->sbc)
205 ct->sbc = sb_new_recv(0, trafo, trafo_context);
206 again:
207 sb_get_recv_buffer(ct->sbc, &iov);
208 ret = read_nonblock(ct->scc.fd, iov.iov_base, iov.iov_len, rfds, &n);
209 if (ret < 0) {
210 sb_free(ct->sbc);
211 ct->sbc = NULL;
212 return ret;
213 }
214 if (n == 0)
215 return 0;
216 if (!sb_received(ct->sbc, n, result))
217 goto again;
218 ct->sbc = NULL;
219 return 1;
220 }
221
222
223 static char **parse_features(char *buf)
224 {
225 int i;
226 const char id[] = "\nFeatures: ";
227 char *p, *q, **features;
228
229 p = strstr(buf, id);
230 if (!p)
231 return NULL;
232 p += strlen(id);
233 q = strchr(p, '\n');
234 if (!q)
235 return NULL;
236 *q = '\0';
237 create_argv(p, ",", &features);
238 for (i = 0; features[i]; i++)
239 PARA_INFO_LOG("server feature: %s\n", features[i]);
240 return features;
241 }
242
243 static int dispatch_sbb(struct client_task *ct, struct sb_buffer *sbb)
244 {
245 int ret;
246 const char *designator[] = {SB_DESIGNATORS_ARRAY};
247
248 if (!sbb)
249 return 0;
250 if (sbb->band < NUM_SB_DESIGNATORS)
251 PARA_DEBUG_LOG("band: %s\n", designator[sbb->band]);
252
253 switch (sbb->band) {
254 case SBD_OUTPUT:
255 if (iov_valid(&sbb->iov))
256 btr_add_output(sbb->iov.iov_base, sbb->iov.iov_len,
257 ct->btrn);
258 ret = 1;
259 goto out;
260 case SBD_DEBUG_LOG:
261 case SBD_INFO_LOG:
262 case SBD_NOTICE_LOG:
263 case SBD_WARNING_LOG:
264 case SBD_ERROR_LOG:
265 case SBD_CRIT_LOG:
266 case SBD_EMERG_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);
270 }
271 ret = 1;
272 goto deallocate;
273 case SBD_EXIT__SUCCESS:
274 ret = -E_SERVER_CMD_SUCCESS;
275 goto deallocate;
276 case SBD_EXIT__FAILURE:
277 ret = -E_SERVER_CMD_FAILURE;
278 goto deallocate;
279 default:
280 PARA_ERROR_LOG("invalid band %d\n", sbb->band);
281 ret = -E_BAD_BAND;
282 goto deallocate;
283 }
284 deallocate:
285 free(sbb->iov.iov_base);
286 out:
287 sbb->iov.iov_base = NULL;
288 return ret;
289 }
290
291 static bool has_feature(const char *feature, struct client_task *ct)
292 {
293 return find_arg(feature, ct->features) >= 0? true : false;
294 }
295
296 static int send_sb_command(struct client_task *ct)
297 {
298 int i;
299 char *command, *p;
300 size_t len = 0;
301
302 if (ct->sbc)
303 return send_sb(ct, NULL, 0, 0, false);
304
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;
311 }
312 PARA_DEBUG_LOG("--> %s\n", command);
313 return send_sb(ct, command, len, SBD_COMMAND, false);
314 }
315
316 /**
317 * The post select hook for client commands.
318 *
319 * \param s Pointer to the scheduler.
320 * \param t Pointer to the task struct for this command.
321 *
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.
326 *
327 * \sa struct sched, struct task.
328 */
329 static void client_post_select(struct sched *s, struct task *t)
330 {
331 struct client_task *ct = container_of(t, struct client_task, task);
332 struct btr_node *btrn = ct->btrn;
333 int ret = 0;
334 size_t n;
335 char buf[CLIENT_BUFSIZE];
336
337 ret = task_get_notification(t);
338 if (ret < 0)
339 goto out;
340 if (ct->scc.fd < 0)
341 return;
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)
346 goto out;
347 ct->features = parse_features(buf);
348 if (!has_feature("sideband", ct)) {
349 PARA_ERROR_LOG("server has no sideband support\n");
350 ret = -E_INCOMPAT_FEAT;
351 goto out;
352 }
353 ct->status = CL_RECEIVED_WELCOME;
354 return;
355 case CL_RECEIVED_WELCOME: /* send auth command */
356 if (!FD_ISSET(ct->scc.fd, &s->wfds))
357 return;
358 sprintf(buf, AUTH_REQUEST_MSG "%s sideband", ct->user);
359 PARA_INFO_LOG("--> %s\n", buf);
360 ret = write_buffer(ct->scc.fd, buf);
361 if (ret < 0)
362 goto out;
363 ct->status = CL_SENT_AUTH;
364 return;
365 case CL_SENT_AUTH:
366 /*
367 * Receive challenge and session keys, decrypt the challenge and
368 * send back the hash of the decrypted challenge.
369 */
370 {
371 /* decrypted challenge/session key buffer */
372 unsigned char crypt_buf[1024];
373 struct sb_buffer sbb;
374
375 ret = recv_sb(ct, &s->rfds, &sbb);
376 if (ret <= 0)
377 goto out;
378 if (sbb.band != SBD_CHALLENGE) {
379 ret = -E_BAD_BAND;
380 free(sbb.iov.iov_base);
381 goto out;
382 }
383 n = sbb.iov.iov_len;
384 PARA_INFO_LOG("<-- [challenge] (%zu bytes)\n", n);
385 ret = priv_decrypt(ct->key_file, crypt_buf,
386 sbb.iov.iov_base, n);
387 free(sbb.iov.iov_base);
388 if (ret < 0)
389 goto out;
390 ct->challenge_hash = para_malloc(HASH_SIZE);
391 hash_function((char *)crypt_buf, CHALLENGE_SIZE, ct->challenge_hash);
392 ct->scc.send = sc_new(crypt_buf + CHALLENGE_SIZE, SESSION_KEY_LEN);
393 ct->scc.recv = sc_new(crypt_buf + CHALLENGE_SIZE + SESSION_KEY_LEN,
394 SESSION_KEY_LEN);
395 hash_to_asc(ct->challenge_hash, buf);
396 PARA_INFO_LOG("--> %s\n", buf);
397 ct->status = CL_RECEIVED_CHALLENGE;
398 return;
399 }
400 case CL_RECEIVED_CHALLENGE:
401 ret = send_sb(ct, ct->challenge_hash, HASH_SIZE,
402 SBD_CHALLENGE_RESPONSE, false);
403 if (ret != 0)
404 ct->challenge_hash = NULL;
405 if (ret <= 0)
406 goto out;
407 ct->status = CL_SENT_CH_RESPONSE;
408 goto out;
409 case CL_SENT_CH_RESPONSE: /* read server response */
410 {
411 struct sb_buffer sbb;
412 ret = recv_sb(ct, &s->rfds, &sbb);
413 if (ret <= 0)
414 goto out;
415 free(sbb.iov.iov_base);
416 if (sbb.band != SBD_PROCEED)
417 ret = -E_BAD_BAND;
418 else
419 ct->status = CL_RECEIVED_PROCEED;
420 goto out;
421 }
422 case CL_RECEIVED_PROCEED: /* concat args and send command */
423 {
424 if (!FD_ISSET(ct->scc.fd, &s->wfds))
425 return;
426 ret = send_sb_command(ct);
427 if (ret <= 0)
428 goto out;
429 ct->status = CL_SENT_COMMAND;
430 return;
431 }
432 case CL_SENT_COMMAND:
433 {
434 struct sb_buffer sbb;
435 ret = recv_sb(ct, &s->rfds, &sbb);
436 if (ret <= 0)
437 goto out;
438 if (sbb.band == SBD_AWAITING_DATA) {
439 ct->status = CL_SENDING;
440 free(sbb.iov.iov_base);
441 goto out;
442 }
443 ct->status = CL_RECEIVING;
444 ret = dispatch_sbb(ct, &sbb);
445 goto out;
446 }
447 case CL_SENDING:
448 {
449 char *buf2;
450 size_t sz;
451 ret = btr_node_status(btrn, 0, BTR_NT_LEAF);
452 if (ret < 0)
453 goto out;
454 if (ret == 0)
455 return;
456 if (!FD_ISSET(ct->scc.fd, &s->wfds))
457 return;
458 sz = btr_next_buffer(btrn, &buf2);
459 ret = sc_send_bin_buffer(&ct->scc, buf2, sz);
460 if (ret < 0)
461 goto out;
462 btr_consume(btrn, sz);
463 return;
464 }
465 case CL_RECEIVING:
466 {
467 struct sb_buffer sbb;
468 ret = btr_node_status(btrn, 0, BTR_NT_ROOT);
469 if (ret < 0)
470 goto out;
471 if (ret == 0)
472 return;
473 /*
474 * The FD_ISSET() is not strictly necessary, but is allows us
475 * to skip the malloc below if there is nothing to read anyway.
476 */
477 if (!FD_ISSET(ct->scc.fd, &s->rfds))
478 return;
479 ret = recv_sb(ct, &s->rfds, &sbb);
480 if (ret > 0)
481 ret = dispatch_sbb(ct, &sbb);
482 goto out;
483 }
484 }
485 out:
486 t->error = ret;
487 if (ret < 0)
488 btr_remove_node(&ct->btrn);
489 }
490
491 /**
492 * Connect to para_server and register the client task.
493 *
494 * \param ct The initialized client task structure.
495 * \param s The scheduler instance to register the client task to.
496 * \param parent The parent node of the client btr node.
497 * \param child The child node of the client node.
498 *
499 * The client task structure given by \a ct must be allocated and initialized
500 * by \ref client_parse_config() before this function is called.
501 *
502 * \return Standard.
503 */
504 int client_connect(struct client_task *ct, struct sched *s,
505 struct btr_node *parent, struct btr_node *child)
506 {
507 int ret;
508
509 PARA_NOTICE_LOG("connecting %s:%d\n", ct->conf.hostname_arg,
510 ct->conf.server_port_arg);
511 ct->scc.fd = -1;
512 ret = para_connect_simple(IPPROTO_TCP, ct->conf.hostname_arg,
513 ct->conf.server_port_arg);
514 if (ret < 0)
515 return ret;
516 ct->scc.fd = ret;
517 ret = mark_fd_nonblocking(ct->scc.fd);
518 if (ret < 0)
519 goto err_out;
520 ct->status = CL_CONNECTED;
521 ct->btrn = btr_new_node(&(struct btr_node_description)
522 EMBRACE(.name = "client", .parent = parent, .child = child));
523 ct->task.pre_select = client_pre_select;
524 ct->task.post_select = client_post_select;
525 ct->task.error = 0;
526 sprintf(ct->task.status, "client");
527 register_task(s, &ct->task);
528 return 1;
529 err_out:
530 close(ct->scc.fd);
531 ct->scc.fd = -1;
532 return ret;
533 }
534
535 /**
536 * Parse a client configuration.
537 *
538 * \param argc Usual argument count.
539 * \param argv Usual argument vector.
540 * \param ct_ptr Filled in by this function.
541 * \param loglevel If not \p NULL, the number of the loglevel is stored here.
542 *
543 * This checks the command line options given by \a argc and \a argv, sets
544 * default values for the user name and the name of the rsa key file and reads
545 * further options from the config file.
546 *
547 * Upon successful return, \a ct_ptr points to a dynamically allocated and
548 * initialized client task struct.
549 *
550 * \return The number of non-option arguments in \a argc/argv on success,
551 * negative on errors.
552 */
553 int client_parse_config(int argc, char *argv[], struct client_task **ct_ptr,
554 int *loglevel)
555 {
556 char *home = para_homedir();
557 int ret;
558 struct client_task *ct = para_calloc(sizeof(struct client_task));
559
560 *ct_ptr = ct;
561 ct->scc.fd = -1;
562 ret = -E_CLIENT_SYNTAX;
563 if (client_cmdline_parser(argc, argv, &ct->conf))
564 goto out;
565 HANDLE_VERSION_FLAG("client", ct->conf);
566
567 ct->config_file = ct->conf.config_file_given?
568 para_strdup(ct->conf.config_file_arg) :
569 make_message("%s/.paraslash/client.conf", home);
570 ret = file_exists(ct->config_file);
571 if (!ret && ct->conf.config_file_given) {
572 ret = -E_NO_CONFIG;
573 goto out;
574 }
575 if (ret) {
576 struct client_cmdline_parser_params params = {
577 .override = 0,
578 .initialize = 0,
579 .check_required = 0,
580 .check_ambiguity = 0,
581 .print_errors = 0
582 };
583 ret = -E_BAD_CONFIG;
584 if (client_cmdline_parser_config_file(ct->config_file,
585 &ct->conf, &params))
586 goto out;
587 }
588 ct->user = ct->conf.user_given?
589 para_strdup(ct->conf.user_arg) : para_logname();
590
591 if (ct->conf.key_file_given)
592 ct->key_file = para_strdup(ct->conf.key_file_arg);
593 else {
594 ct->key_file = make_message("%s/.paraslash/key.%s",
595 home, ct->user);
596 if (!file_exists(ct->key_file)) {
597 free(ct->key_file);
598 ct->key_file = make_message("%s/.ssh/id_rsa", home);
599 }
600 }
601
602 if (loglevel)
603 *loglevel = get_loglevel_by_name(ct->conf.loglevel_arg);
604 PARA_INFO_LOG("loglevel: %s\n", ct->conf.loglevel_arg);
605 PARA_INFO_LOG("config_file: %s\n", ct->config_file);
606 PARA_INFO_LOG("key_file: %s\n", ct->key_file);
607 ret = ct->conf.inputs_num;
608 out:
609 free(home);
610 if (ret < 0) {
611 PARA_ERROR_LOG("%s\n", para_strerror(-ret));
612 client_close(ct);
613 *ct_ptr = NULL;
614 }
615 return ret;
616 }
617
618 /**
619 * Parse the client configuration and open a connection to para_server.
620 *
621 * \param argc See \ref client_parse_config.
622 * \param argv See \ref client_parse_config.
623 * \param ct_ptr See \ref client_parse_config.
624 * \param loglevel See \ref client_parse_config.
625 * \param parent See \ref client_connect().
626 * \param child See \ref client_connect().
627 * \param sched See \ref client_connect().
628 *
629 * This function combines client_parse_config() and client_connect(). It is
630 * considered a syntax error if no command was given, i.e. if the number
631 * of non-option arguments is zero.
632 *
633 * \return Standard.
634 */
635 int client_open(int argc, char *argv[], struct client_task **ct_ptr,
636 int *loglevel, struct btr_node *parent, struct btr_node *child,
637 struct sched *sched)
638 {
639 int ret = client_parse_config(argc, argv, ct_ptr, loglevel);
640
641 if (ret < 0)
642 return ret;
643 if (ret == 0) {
644 ret = -E_CLIENT_SYNTAX;
645 goto fail;
646 }
647 ret = client_connect(*ct_ptr, sched, parent, child);
648 if (ret < 0)
649 goto fail;
650 return 1;
651 fail:
652 client_close(*ct_ptr);
653 *ct_ptr = NULL;
654 return ret;
655 }