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