Merge branch 't/compress'
[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 int 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 0;
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 ct->status = CL_RECEIVED_WELCOME;
349 return 0;
350 case CL_RECEIVED_WELCOME: /* send auth command */
351 if (!FD_ISSET(ct->scc.fd, &s->wfds))
352 return 0;
353 if (has_feature("sideband", ct)) {
354 ct->use_sideband = true;
355 sprintf(buf, AUTH_REQUEST_MSG "%s sideband", ct->user);
356 } else
357 sprintf(buf, AUTH_REQUEST_MSG "%s", ct->user);
358 PARA_INFO_LOG("--> %s\n", buf);
359 ret = write_buffer(ct->scc.fd, buf);
360 if (ret < 0)
361 goto out;
362 ct->status = CL_SENT_AUTH;
363 return 0;
364 case CL_SENT_AUTH:
365 /*
366 * Receive challenge and session keys, decrypt the challenge and
367 * send back the hash of the decrypted challenge.
368 */
369 {
370 /* decrypted challenge/session key buffer */
371 unsigned char crypt_buf[1024];
372 /* the SHA1 of the decrypted challenge */
373
374 if (ct->use_sideband) {
375 struct sb_buffer sbb;
376 ret = recv_sb(ct, &s->rfds, &sbb);
377 if (ret <= 0)
378 goto out;
379 if (sbb.band != SBD_CHALLENGE) {
380 ret = -E_BAD_BAND;
381 free(sbb.iov.iov_base);
382 goto out;
383 }
384 n = sbb.iov.iov_len;
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);
389 if (ret < 0)
390 goto out;
391 } else {
392 ret = client_recv_buffer(ct, &s->rfds, buf, sizeof(buf), &n);
393 if (ret < 0 || n == 0)
394 goto out;
395 PARA_INFO_LOG("<-- [challenge] (%zu bytes)\n", n);
396 ret = priv_decrypt(ct->key_file, crypt_buf,
397 (unsigned char *)buf, n);
398 if (ret < 0)
399 goto out;
400 }
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,
405 SESSION_KEY_LEN);
406 hash_to_asc(ct->challenge_hash, buf);
407 PARA_INFO_LOG("--> %s\n", buf);
408 ct->status = CL_RECEIVED_CHALLENGE;
409 return 0;
410 }
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);
415 if (ret != 0)
416 ct->challenge_hash = NULL;
417 if (ret <= 0)
418 goto out;
419 } else {
420 ret = write_all(ct->scc.fd, (char *)ct->challenge_hash, HASH_SIZE);
421 if (ret < 0)
422 goto out;
423 }
424 ct->status = CL_SENT_CH_RESPONSE;
425 goto out;
426 case CL_SENT_CH_RESPONSE: /* read server response */
427 {
428 if (ct->use_sideband) {
429 struct sb_buffer sbb;
430 ret = recv_sb(ct, &s->rfds, &sbb);
431 if (ret <= 0)
432 goto out;
433 free(sbb.iov.iov_base);
434 if (sbb.band != SBD_PROCEED)
435 ret = -E_BAD_BAND;
436 else
437 ct->status = CL_RECEIVED_PROCEED;
438 goto out;
439 }
440 ret = client_recv_buffer(ct, &s->rfds, buf, sizeof(buf), &n);
441 if (ret < 0 || n == 0)
442 goto out;
443 /* check if server has sent "Proceed" message */
444 ret = -E_CLIENT_AUTH;
445 if (n < PROCEED_MSG_LEN)
446 goto out;
447 if (!strstr(buf, PROCEED_MSG))
448 goto out;
449 ct->status = CL_RECEIVED_PROCEED;
450 return 0;
451 }
452 case CL_RECEIVED_PROCEED: /* concat args and send command */
453 {
454 int i;
455 char *command = NULL;
456 if (!FD_ISSET(ct->scc.fd, &s->wfds))
457 return 0;
458 if (ct->use_sideband) {
459 ret = send_sb_command(ct);
460 if (ret <= 0)
461 goto out;
462 ct->status = CL_SENT_COMMAND;
463 return 0;
464 }
465 for (i = 0; i < ct->conf.inputs_num; i++) {
466 char *tmp = command;
467 command = make_message("%s\n%s", command?
468 command : "", ct->conf.inputs[i]);
469 free(tmp);
470 }
471 command = para_strcat(command, EOC_MSG "\n");
472 PARA_DEBUG_LOG("--> %s\n", command);
473 ret = sc_send_buffer(&ct->scc, command);
474 free(command);
475 if (ret < 0)
476 goto out;
477 ct->status = CL_SENT_COMMAND;
478 return 0;
479 }
480 case CL_SENT_COMMAND:
481 {
482 char *buf2;
483 if (ct->use_sideband) {
484 struct sb_buffer sbb;
485 ret = recv_sb(ct, &s->rfds, &sbb);
486 if (ret <= 0)
487 goto out;
488 if (sbb.band == SBD_AWAITING_DATA) {
489 ct->status = CL_SENDING;
490 free(sbb.iov.iov_base);
491 goto out;
492 }
493 ct->status = CL_RECEIVING;
494 ret = dispatch_sbb(ct, &sbb);
495 goto out;
496 }
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);
500 if (n > 0) {
501 if (strstr(buf2, AWAITING_DATA_MSG)) {
502 free(buf2);
503 ct->status = CL_SENDING;
504 return 0;
505 }
506 ct->status = CL_RECEIVING;
507 btr_add_output(buf2, n, btrn);
508 } else
509 free(buf2);
510 goto out;
511 }
512 case CL_SENDING:
513 {
514 char *buf2;
515 size_t sz;
516 ret = btr_node_status(btrn, 0, BTR_NT_LEAF);
517 if (ret < 0)
518 goto out;
519 if (ret == 0)
520 return 0;
521 if (!FD_ISSET(ct->scc.fd, &s->wfds))
522 return 0;
523 sz = btr_next_buffer(btrn, &buf2);
524 ret = sc_send_bin_buffer(&ct->scc, buf2, sz);
525 if (ret < 0)
526 goto out;
527 btr_consume(btrn, sz);
528 return 0;
529 }
530 case CL_RECEIVING:
531 {
532 char *buf2;
533 ret = btr_node_status(btrn, 0, BTR_NT_ROOT);
534 if (ret < 0)
535 goto out;
536 if (ret == 0)
537 return 0;
538 /*
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.
541 */
542 if (!FD_ISSET(ct->scc.fd, &s->rfds))
543 return 0;
544 if (ct->use_sideband) {
545 struct sb_buffer sbb;
546 ret = recv_sb(ct, &s->rfds, &sbb);
547 if (ret > 0)
548 ret = dispatch_sbb(ct, &sbb);
549 goto out;
550 }
551 buf2 = para_malloc(CLIENT_BUFSIZE);
552 ret = client_recv_buffer(ct, &s->rfds, buf2, CLIENT_BUFSIZE, &n);
553 if (n > 0) {
554 buf2 = para_realloc(buf2, n);
555 btr_add_output(buf2, n, btrn);
556 } else
557 free(buf2);
558 goto out;
559 }
560 }
561 out:
562 if (ret < 0) {
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);
567 }
568 return ret;
569 }
570
571 /**
572 * Connect to para_server and register the client task.
573 *
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.
578 *
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.
581 *
582 * \return Standard.
583 */
584 int client_connect(struct client_task *ct, struct sched *s,
585 struct btr_node *parent, struct btr_node *child)
586 {
587 int ret;
588
589 PARA_NOTICE_LOG("connecting %s:%d\n", ct->conf.hostname_arg,
590 ct->conf.server_port_arg);
591 ct->scc.fd = -1;
592 ret = para_connect_simple(IPPROTO_TCP, ct->conf.hostname_arg,
593 ct->conf.server_port_arg);
594 if (ret < 0)
595 return ret;
596 ct->scc.fd = ret;
597 ret = mark_fd_nonblocking(ct->scc.fd);
598 if (ret < 0)
599 goto err_out;
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.post_select = client_post_select;
605 ct->task.error = 0;
606 sprintf(ct->task.status, "client");
607 register_task(s, &ct->task);
608 return 1;
609 err_out:
610 close(ct->scc.fd);
611 ct->scc.fd = -1;
612 return ret;
613 }
614
615 /**
616 * Parse a client configuration.
617 *
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.
622 *
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.
626 *
627 * Upon successful return, \a ct_ptr points to a dynamically allocated and
628 * initialized client task struct.
629 *
630 * \return The number of non-option arguments in \a argc/argv on success,
631 * negative on errors.
632 */
633 int client_parse_config(int argc, char *argv[], struct client_task **ct_ptr,
634 int *loglevel)
635 {
636 char *home = para_homedir();
637 int ret;
638 struct client_task *ct = para_calloc(sizeof(struct client_task));
639
640 *ct_ptr = ct;
641 ct->scc.fd = -1;
642 ret = -E_CLIENT_SYNTAX;
643 if (client_cmdline_parser(argc, argv, &ct->conf))
644 goto out;
645 HANDLE_VERSION_FLAG("client", ct->conf);
646
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) {
652 ret = -E_NO_CONFIG;
653 goto out;
654 }
655 if (ret) {
656 struct client_cmdline_parser_params params = {
657 .override = 0,
658 .initialize = 0,
659 .check_required = 0,
660 .check_ambiguity = 0,
661 .print_errors = 0
662 };
663 ret = -E_BAD_CONFIG;
664 if (client_cmdline_parser_config_file(ct->config_file,
665 &ct->conf, &params))
666 goto out;
667 }
668 ct->user = ct->conf.user_given?
669 para_strdup(ct->conf.user_arg) : para_logname();
670
671 if (ct->conf.key_file_given)
672 ct->key_file = para_strdup(ct->conf.key_file_arg);
673 else {
674 ct->key_file = make_message("%s/.paraslash/key.%s",
675 home, ct->user);
676 if (!file_exists(ct->key_file)) {
677 free(ct->key_file);
678 ct->key_file = make_message("%s/.ssh/id_rsa", home);
679 }
680 }
681
682 if (loglevel)
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;
688 out:
689 free(home);
690 if (ret < 0) {
691 PARA_ERROR_LOG("%s\n", para_strerror(-ret));
692 client_close(ct);
693 *ct_ptr = NULL;
694 }
695 return ret;
696 }
697
698 /**
699 * Parse the client configuration and open a connection to para_server.
700 *
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().
708 *
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.
712 *
713 * \return Standard.
714 */
715 int client_open(int argc, char *argv[], struct client_task **ct_ptr,
716 int *loglevel, struct btr_node *parent, struct btr_node *child,
717 struct sched *sched)
718 {
719 int ret = client_parse_config(argc, argv, ct_ptr, loglevel);
720
721 if (ret < 0)
722 return ret;
723 if (ret == 0) {
724 ret = -E_CLIENT_SYNTAX;
725 goto fail;
726 }
727 ret = client_connect(*ct_ptr, sched, parent, child);
728 if (ret < 0)
729 goto fail;
730 return 1;
731 fail:
732 client_close(*ct_ptr);
733 *ct_ptr = NULL;
734 return ret;
735 }