2 * Copyright (C) 1997-2007 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. */
16 #include "client.cmdline.h"
22 #include "client.cmdline.h"
26 * Rc4-encrypt data before sending.
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 Result-pointer that holds the encrypted data.
31 * \param private_data Contains the rc4 key.
33 static void rc4_send(unsigned long len
, const unsigned char *indata
,
34 unsigned char *outdata
, void *private_data
)
36 struct private_client_data
*pcd
= private_data
;
37 RC4(&pcd
->rc4_send_key
, len
, indata
, outdata
);
41 * Rc4-decrypt received data.
43 * Parameters are identical to those of rc4_send.
45 static void rc4_recv(unsigned long len
, const unsigned char *indata
,
46 unsigned char *outdata
, void *private_data
)
48 struct private_client_data
*pcd
= private_data
;
49 RC4(&pcd
->rc4_recv_key
, len
, indata
, outdata
);
53 * Close the connection to para_server and free all resources.
55 * \param pcd Pointer to the client data.
59 void client_close(struct private_client_data
*pcd
)
64 disable_crypt(pcd
->fd
);
68 free(pcd
->config_file
);
70 client_cmdline_parser_free(&pcd
->conf
);
74 /* connect to para_server and register the client task */
75 static int client_connect(struct private_client_data
*pcd
)
80 ret
= makesock(AF_UNSPEC
, IPPROTO_TCP
, 0, pcd
->conf
.hostname_arg
,
81 pcd
->conf
.server_port_arg
);
85 pcd
->status
= CL_CONNECTED
;
86 ret
= mark_fd_nonblocking(pcd
->fd
);
89 pcd
->task
.pre_select
= client_pre_select
;
90 pcd
->task
.post_select
= client_post_select
;
91 pcd
->task
.private_data
= pcd
;
92 sprintf(pcd
->task
.status
, "client");
93 register_task(&pcd
->task
);
102 * Open connection to para_server.
104 * \param argc Usual argument count.
105 * \param argv Usual argument vector.
106 * \param pcd_ptr Points to dynamically allocated and initialized private client data
107 * upon successful return.
109 * Check the command line options given by \a argc and argv, set default values
110 * for user name and rsa key file, read further option from the config file.
111 * Finally, establish a connection to para_server.
115 int client_open(int argc
, char *argv
[], struct private_client_data
**pcd_ptr
)
117 char *home
= para_homedir();
120 struct private_client_data
*pcd
=
121 para_calloc(sizeof(struct private_client_data
));
125 ret
= client_cmdline_parser(argc
, argv
, &pcd
->conf
);
126 HANDLE_VERSION_FLAG("client", pcd
->conf
);
127 ret
= -E_CLIENT_SYNTAX
;
128 if (!pcd
->conf
.inputs_num
)
130 pcd
->user
= pcd
->conf
.user_given
?
131 para_strdup(pcd
->conf
.user_arg
) : para_logname();
133 pcd
->key_file
= pcd
->conf
.key_file_given
?
134 para_strdup(pcd
->conf
.key_file_arg
) :
135 make_message("%s/.paraslash/key.%s", home
, pcd
->user
);
137 pcd
->config_file
= pcd
->conf
.config_file_given
?
138 para_strdup(pcd
->conf
.config_file_arg
) :
139 make_message("%s/.paraslash/client.conf", home
);
140 ret
= stat(pcd
->config_file
, &statbuf
);
141 if (ret
&& pcd
->conf
.config_file_given
) {
146 struct client_cmdline_parser_params params
= {
152 client_cmdline_parser_config_file(pcd
->config_file
,
153 &pcd
->conf
, ¶ms
);
156 PARA_INFO_LOG("loglevel: %d\n", pcd
->conf
.loglevel_arg
);
157 PARA_INFO_LOG("config_file: %s\n", pcd
->config_file
);
158 PARA_INFO_LOG("key_file: %s\n", pcd
->key_file
);
159 PARA_NOTICE_LOG("connecting %s:%d\n", pcd
->conf
.hostname_arg
,
160 pcd
->conf
.server_port_arg
);
161 ret
= client_connect(pcd
);
165 PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret
));
173 * The preselect hook for server commands.
175 * \param s Pointer to the scheduler.
176 * \param t Pointer to the task struct for this command.
178 * The task pointer must contain a pointer to the initialized client data
179 * structure as it is returned by client_open().
181 * This function checks the state of the connection and adds the file descriptor
182 * of the connection to the read or write fd set of \a s accordingly.
184 * \sa register_task() client_open(), struct sched, struct task.
186 void client_pre_select(struct sched
*s
, struct task
*t
)
188 struct private_client_data
*pcd
= t
->private_data
;
195 switch (pcd
->status
) {
198 case CL_SENT_CH_RESPONSE
:
199 case CL_SENT_COMMAND
:
200 para_fd_set(pcd
->fd
, &s
->rfds
, &s
->max_fileno
);
204 case CL_RECEIVED_WELCOME
:
205 case CL_RECEIVED_CHALLENGE
:
206 case CL_RECEIVED_PROCEED
:
207 para_fd_set(pcd
->fd
, &s
->wfds
, &s
->max_fileno
);
212 if (pcd
->loaded
< CLIENT_BUFSIZE
- 1) {
213 para_fd_set(pcd
->fd
, &s
->rfds
, &s
->max_fileno
);
218 if (*pcd
->in_loaded
) {
219 PARA_INFO_LOG("loaded: %zd\n", *pcd
->in_loaded
);
220 para_fd_set(pcd
->fd
, &s
->wfds
, &s
->max_fileno
);
223 if (*pcd
->in_error
) {
224 t
->ret
= *pcd
->in_error
;
225 s
->timeout
.tv_sec
= 0;
226 s
->timeout
.tv_usec
= 1;
233 static ssize_t
client_recv_buffer(struct private_client_data
*pcd
)
235 ssize_t ret
= recv_buffer(pcd
->fd
, pcd
->buf
+ pcd
->loaded
,
236 CLIENT_BUFSIZE
- pcd
->loaded
);
238 return -E_SERVER_EOF
;
246 * The post select hook for client commands.
248 * \param s Pointer to the scheduler.
249 * \param t Pointer to the task struct for this command.
251 * Depending on the current state of the connection and the status of the read
252 * and write fd sets of \a s, this function performs the necessary steps to
253 * authenticate the connection, to send the command given by \a t->private_data
254 * and to receive para_server's output, if any.
256 * \sa struct sched, struct task.
258 void client_post_select(struct sched
*s
, struct task
*t
)
260 struct private_client_data
*pcd
= t
->private_data
;
262 // PARA_INFO_LOG("status %d\n", pcd->status);
266 if (!pcd
->check_r
&& !pcd
->check_w
)
268 if (pcd
->check_r
&& !FD_ISSET(pcd
->fd
, &s
->rfds
))
270 if (pcd
->check_w
&& !FD_ISSET(pcd
->fd
, &s
->wfds
))
272 switch (pcd
->status
) {
273 case CL_CONNECTED
: /* receive welcome message */
274 t
->ret
= client_recv_buffer(pcd
);
276 pcd
->status
= CL_RECEIVED_WELCOME
;
278 case CL_RECEIVED_WELCOME
: /* send auth command */
279 sprintf(pcd
->buf
, "auth %s%s", pcd
->conf
.plain_given
?
280 "" : "rc4 ", pcd
->user
);
281 PARA_INFO_LOG("--> %s\n", pcd
->buf
);
282 t
->ret
= send_buffer(pcd
->fd
, pcd
->buf
);
284 pcd
->status
= CL_SENT_AUTH
;
286 case CL_SENT_AUTH
: /* receive challenge number */
288 t
->ret
= client_recv_buffer(pcd
);
292 t
->ret
= -E_INVALID_CHALLENGE
;
293 PARA_ERROR_LOG("received the following: %s\n", pcd
->buf
);
296 PARA_INFO_LOG("%s", "<-- [challenge]\n");
297 /* decrypt challenge number */
298 t
->ret
= para_decrypt_challenge(pcd
->key_file
, &pcd
->challenge_nr
,
299 (unsigned char *) pcd
->buf
, 64);
301 pcd
->status
= CL_RECEIVED_CHALLENGE
;
303 case CL_RECEIVED_CHALLENGE
: /* send decrypted challenge */
304 PARA_INFO_LOG("--> %lu\n", pcd
->challenge_nr
);
305 t
->ret
= send_va_buffer(pcd
->fd
, "%s%lu", CHALLENGE_RESPONSE_MSG
,
308 pcd
->status
= CL_SENT_CH_RESPONSE
;
310 case CL_SENT_CH_RESPONSE
: /* read server response */
312 size_t bytes_received
;
313 unsigned char rc4_buf
[2 * RC4_KEY_LEN
] = "";
315 t
->ret
= client_recv_buffer(pcd
);
318 bytes_received
= t
->ret
;
319 PARA_DEBUG_LOG("++++ server info ++++\n%s\n++++ end of server "
320 "info ++++\n", pcd
->buf
);
321 /* check if server has sent "Proceed" message */
322 t
->ret
= -E_CLIENT_AUTH
;
323 if (!strstr(pcd
->buf
, PROCEED_MSG
))
326 pcd
->status
= CL_RECEIVED_PROCEED
;
327 if (bytes_received
< PROCEED_MSG_LEN
+ 32)
329 PARA_INFO_LOG("%s", "decrypting session key\n");
330 t
->ret
= para_decrypt_buffer(pcd
->key_file
, rc4_buf
,
331 (unsigned char *)pcd
->buf
+ PROCEED_MSG_LEN
+ 1,
332 bytes_received
- PROCEED_MSG_LEN
- 1);
335 RC4_set_key(&pcd
->rc4_send_key
, RC4_KEY_LEN
, rc4_buf
);
336 RC4_set_key(&pcd
->rc4_recv_key
, RC4_KEY_LEN
, rc4_buf
+ RC4_KEY_LEN
);
337 enable_crypt(pcd
->fd
, rc4_recv
, rc4_send
, pcd
);
339 case CL_RECEIVED_PROCEED
: /* concat args and send command */
342 char *command
= NULL
;
343 for (i
= 0; i
< pcd
->conf
.inputs_num
; i
++) {
345 command
= make_message("%s\n%s", command
?
346 command
: "", pcd
->conf
.inputs
[i
]);
349 command
= para_strcat(command
, EOC_MSG
"\n");
350 PARA_DEBUG_LOG("--> %s\n", command
);
351 t
->ret
= send_buffer(pcd
->fd
, command
);
354 pcd
->status
= CL_SENT_COMMAND
;
357 case CL_SENT_COMMAND
:
359 t
->ret
= client_recv_buffer(pcd
);
362 t
->ret
= -E_HANDSHAKE_COMPLETE
;
363 if (strstr(pcd
->buf
, AWAITING_DATA_MSG
))
364 pcd
->status
= CL_SENDING
;
366 pcd
->status
= CL_RECEIVING
;
368 case CL_SENDING
: /* FIXME: might block */
369 PARA_INFO_LOG("loaded: %zd\n", *pcd
->in_loaded
);
370 t
->ret
= send_bin_buffer(pcd
->fd
, pcd
->inbuf
, *pcd
->in_loaded
);
376 t
->ret
= client_recv_buffer(pcd
);