Merge commit 'meins/next' into next
[paraslash.git] / client_common.c
1 /*
2 * Copyright (C) 1997-2009 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 #include <dirent.h>
12 #include <openssl/rc4.h>
13
14 #include "para.h"
15 #include "error.h"
16 #include "list.h"
17 #include "sched.h"
18 #include "client.cmdline.h"
19 #include "crypt.h"
20 #include "rc4.h"
21 #include "net.h"
22 #include "fd.h"
23 #include "string.h"
24 #include "client.cmdline.h"
25 #include "client.h"
26 #include "hash.h"
27
28 /**
29 * Close the connection to para_server and free all resources.
30 *
31 * \param ct Pointer to the client data.
32 *
33 * \sa client_open.
34 */
35 void client_close(struct client_task *ct)
36 {
37 if (!ct)
38 return;
39 if (ct->rc4c.fd >= 0)
40 close(ct->rc4c.fd);
41 free(ct->buf);
42 free(ct->user);
43 free(ct->config_file);
44 free(ct->key_file);
45 client_cmdline_parser_free(&ct->conf);
46 free(ct);
47 }
48
49 /**
50 * The preselect hook for server commands.
51 *
52 * \param s Pointer to the scheduler.
53 * \param t Pointer to the task struct for this command.
54 *
55 * The task pointer must contain a pointer to the initialized client data
56 * structure as it is returned by client_open().
57 *
58 * This function checks the state of the connection and adds the file descriptor
59 * of the connection to the read or write fd set of \a s accordingly.
60 *
61 * \sa register_task() client_open(), struct sched, struct task.
62 */
63 static void client_pre_select(struct sched *s, struct task *t)
64 {
65 struct client_task *ct = container_of(t, struct client_task, task);
66
67 ct->check_r = 0;
68 ct->check_w = 0;
69 if (ct->rc4c.fd < 0)
70 return;
71 switch (ct->status) {
72 case CL_CONNECTED:
73 case CL_SENT_AUTH:
74 case CL_SENT_CH_RESPONSE:
75 case CL_SENT_COMMAND:
76 para_fd_set(ct->rc4c.fd, &s->rfds, &s->max_fileno);
77 ct->check_r = 1;
78 return;
79
80 case CL_RECEIVED_WELCOME:
81 case CL_RECEIVED_CHALLENGE:
82 case CL_RECEIVED_PROCEED:
83 para_fd_set(ct->rc4c.fd, &s->wfds, &s->max_fileno);
84 ct->check_w = 1;
85 return;
86
87 case CL_RECEIVING:
88 if (ct->loaded < CLIENT_BUFSIZE - 1) {
89 para_fd_set(ct->rc4c.fd, &s->rfds, &s->max_fileno);
90 ct->check_r = 1;
91 }
92 return;
93 case CL_SENDING:
94 if (!ct->in_loaded) /* stdin task not yet started */
95 return;
96 if (*ct->in_loaded) {
97 PARA_INFO_LOG("loaded: %zd\n", *ct->in_loaded);
98 para_fd_set(ct->rc4c.fd, &s->wfds, &s->max_fileno);
99 ct->check_w = 1;
100 } else {
101 if (*ct->in_error) {
102 t->error = *ct->in_error;
103 s->timeout.tv_sec = 0;
104 s->timeout.tv_usec = 1;
105 }
106 }
107 return;
108 }
109 }
110
111 static ssize_t client_recv_buffer(struct client_task *ct)
112 {
113 ssize_t ret;
114
115 if (ct->status < CL_SENT_CH_RESPONSE)
116 ret = recv_buffer(ct->rc4c.fd, ct->buf + ct->loaded,
117 CLIENT_BUFSIZE - ct->loaded);
118 else
119 ret = rc4_recv_buffer(&ct->rc4c, ct->buf + ct->loaded,
120 CLIENT_BUFSIZE - ct->loaded);
121 if (!ret)
122 return -E_SERVER_EOF;
123 if (ret > 0)
124 ct->loaded += ret;
125 return ret;
126 }
127
128 /**
129 * The post select hook for client commands.
130 *
131 * \param s Pointer to the scheduler.
132 * \param t Pointer to the task struct for this command.
133 *
134 * Depending on the current state of the connection and the status of the read
135 * and write fd sets of \a s, this function performs the necessary steps to
136 * authenticate the connection, to send the command given by \a t->private_data
137 * and to receive para_server's output, if any.
138 *
139 * \sa struct sched, struct task.
140 */
141 static void client_post_select(struct sched *s, struct task *t)
142 {
143 struct client_task *ct = container_of(t, struct client_task, task);
144 unsigned char crypt_buf[1024];
145
146 t->error = 0;
147 if (ct->rc4c.fd < 0)
148 return;
149 if (!ct->check_r && !ct->check_w)
150 return;
151 if (ct->check_r && !FD_ISSET(ct->rc4c.fd, &s->rfds))
152 return;
153 if (ct->check_w && !FD_ISSET(ct->rc4c.fd, &s->wfds))
154 return;
155 switch (ct->status) {
156 case CL_CONNECTED: /* receive welcome message */
157 t->error = client_recv_buffer(ct);
158 if (t->error < 0)
159 goto err;
160 ct->status = CL_RECEIVED_WELCOME;
161 return;
162 case CL_RECEIVED_WELCOME: /* send auth command */
163 sprintf(ct->buf, AUTH_REQUEST_MSG "%s", ct->user);
164 PARA_INFO_LOG("--> %s\n", ct->buf);
165 t->error = send_buffer(ct->rc4c.fd, ct->buf);
166 if (t->error < 0)
167 goto err;
168 ct->status = CL_SENT_AUTH;
169 return;
170 case CL_SENT_AUTH: /* receive challenge and rc4 keys */
171 ct->loaded = 0;
172 t->error = client_recv_buffer(ct);
173 if (t->error < 0)
174 goto err;
175 PARA_INFO_LOG("<-- [challenge] (%d bytes)\n", t->error);
176 /* decrypt challenge/rc4 buffer */
177 t->error = para_decrypt_buffer(ct->key_file, crypt_buf,
178 (unsigned char *)ct->buf, t->error);
179 if (t->error < 0)
180 goto err;
181 ct->status = CL_RECEIVED_CHALLENGE;
182 RC4_set_key(&ct->rc4c.send_key, RC4_KEY_LEN,
183 crypt_buf + CHALLENGE_SIZE);
184 RC4_set_key(&ct->rc4c.recv_key, RC4_KEY_LEN,
185 crypt_buf + CHALLENGE_SIZE + RC4_KEY_LEN);
186 return;
187 case CL_RECEIVED_CHALLENGE:
188 {
189 unsigned char challenge_sha1[HASH_SIZE];
190 /* send sha1 of decrypted challenge */
191 sha1_hash((char *)crypt_buf, CHALLENGE_SIZE, challenge_sha1);
192 hash_to_asc(challenge_sha1, ct->buf);
193 PARA_INFO_LOG("--> %s\n", ct->buf);
194 t->error = send_bin_buffer(ct->rc4c.fd, (char *)challenge_sha1,
195 HASH_SIZE);
196 if (t->error < 0)
197 goto err;
198 ct->status = CL_SENT_CH_RESPONSE;
199 return;
200 }
201 case CL_SENT_CH_RESPONSE: /* read server response */
202 {
203 size_t bytes_received;
204 ct->loaded = 0;
205 t->error = client_recv_buffer(ct);
206 if (t->error < 0)
207 goto err;
208 bytes_received = t->error;
209 /* check if server has sent "Proceed" message */
210 t->error = -E_CLIENT_AUTH;
211 if (bytes_received < PROCEED_MSG_LEN)
212 goto err;
213 if (!strstr(ct->buf, PROCEED_MSG))
214 goto err;
215 ct->status = CL_RECEIVED_PROCEED;
216 t->error = 0;
217 return;
218 }
219 case CL_RECEIVED_PROCEED: /* concat args and send command */
220 {
221 int i;
222 char *command = NULL;
223 for (i = 0; i < ct->conf.inputs_num; i++) {
224 char *tmp = command;
225 command = make_message("%s\n%s", command?
226 command : "", ct->conf.inputs[i]);
227 free(tmp);
228 }
229 command = para_strcat(command, EOC_MSG "\n");
230 PARA_DEBUG_LOG("--> %s\n", command);
231 t->error = rc4_send_buffer(&ct->rc4c, command);
232 free(command);
233 if (t->error < 0)
234 goto err;
235 ct->status = CL_SENT_COMMAND;
236 return;
237 }
238 case CL_SENT_COMMAND:
239 ct->loaded = 0;
240 t->error = client_recv_buffer(ct);
241 if (t->error < 0)
242 goto err;
243 if (strstr(ct->buf, AWAITING_DATA_MSG))
244 ct->status = CL_SENDING;
245 else
246 ct->status = CL_RECEIVING;
247 return;
248 case CL_SENDING:
249 PARA_INFO_LOG("loaded: %zd\n", *ct->in_loaded);
250 t->error = rc4_send_bin_buffer(&ct->rc4c, ct->inbuf,
251 *ct->in_loaded);
252 if (t->error < 0)
253 goto err;
254 *ct->in_loaded = 0;
255 return;
256 case CL_RECEIVING:
257 t->error = client_recv_buffer(ct);
258 if (t->error < 0)
259 goto err;
260 return;
261 }
262 err:
263 if (t->error != -E_SERVER_EOF)
264 PARA_ERROR_LOG("%s\n", para_strerror(-t->error));
265 }
266
267 /* connect to para_server and register the client task */
268 static int client_connect(struct client_task *ct)
269 {
270 int ret;
271
272 ct->rc4c.fd = -1;
273 ret = makesock(AF_UNSPEC, IPPROTO_TCP, 0, ct->conf.hostname_arg,
274 ct->conf.server_port_arg);
275 if (ret < 0)
276 return ret;
277 ct->rc4c.fd = ret;
278 ct->status = CL_CONNECTED;
279 ret = mark_fd_nonblocking(ct->rc4c.fd);
280 if (ret < 0)
281 goto err_out;
282 ct->task.pre_select = client_pre_select;
283 ct->task.post_select = client_post_select;
284 sprintf(ct->task.status, "client");
285 register_task(&ct->task);
286 return 1;
287 err_out:
288 close(ct->rc4c.fd);
289 ct->rc4c.fd = -1;
290 return ret;
291 }
292
293 /**
294 * Open connection to para_server.
295 *
296 * \param argc Usual argument count.
297 * \param argv Usual argument vector.
298 * \param ct_ptr Points to dynamically allocated and initialized client task
299 * struct upon successful return.
300 * \param loglevel If not \p NULL, the number of the loglevel is stored here.
301 *
302 * Check the command line options given by \a argc and argv, set default values
303 * for user name and rsa key file, read further option from the config file.
304 * Finally, establish a connection to para_server.
305 *
306 * \return Standard.
307 */
308 int client_open(int argc, char *argv[], struct client_task **ct_ptr,
309 int *loglevel)
310 {
311 char *home = para_homedir();
312 int ret;
313 struct client_task *ct = para_calloc(sizeof(struct client_task));
314
315 ct->buf = para_malloc(CLIENT_BUFSIZE);
316 *ct_ptr = ct;
317 ct->rc4c.fd = -1;
318 ret = -E_CLIENT_SYNTAX;
319 if (client_cmdline_parser(argc, argv, &ct->conf))
320 goto out;
321 HANDLE_VERSION_FLAG("client", ct->conf);
322 ret = -E_CLIENT_SYNTAX;
323 if (!ct->conf.inputs_num)
324 goto out;
325 ct->user = ct->conf.user_given?
326 para_strdup(ct->conf.user_arg) : para_logname();
327
328 ct->key_file = ct->conf.key_file_given?
329 para_strdup(ct->conf.key_file_arg) :
330 make_message("%s/.paraslash/key.%s", home, ct->user);
331
332 ct->config_file = ct->conf.config_file_given?
333 para_strdup(ct->conf.config_file_arg) :
334 make_message("%s/.paraslash/client.conf", home);
335 ret = file_exists(ct->config_file);
336 if (!ret && ct->conf.config_file_given) {
337 ret = -E_NO_CONFIG;
338 goto out;
339 }
340 if (ret) {
341 struct client_cmdline_parser_params params = {
342 .override = 0,
343 .initialize = 0,
344 .check_required = 0,
345 .check_ambiguity = 0,
346 .print_errors = 0
347 };
348 ret = -E_BAD_CONFIG;
349 if (client_cmdline_parser_config_file(ct->config_file,
350 &ct->conf, &params))
351 goto out;
352 }
353 if (loglevel)
354 *loglevel = get_loglevel_by_name(ct->conf.loglevel_arg);
355 PARA_INFO_LOG("loglevel: %s\n", ct->conf.loglevel_arg);
356 PARA_INFO_LOG("config_file: %s\n", ct->config_file);
357 PARA_INFO_LOG("key_file: %s\n", ct->key_file);
358 PARA_NOTICE_LOG("connecting %s:%d\n", ct->conf.hostname_arg,
359 ct->conf.server_port_arg);
360 ret = client_connect(ct);
361 out:
362 free(home);
363 if (ret < 0) {
364 PARA_ERROR_LOG("%s\n", para_strerror(-ret));
365 client_close(ct);
366 *ct_ptr = NULL;
367 }
368 return ret;
369 }