Line data Source code
1 : /* assuan-handler.c - dispatch commands
2 : Copyright (C) 2001, 2002, 2003, 2007, 2009,
3 : 2011 Free Software Foundation, Inc.
4 :
5 : This file is part of Assuan.
6 :
7 : Assuan is free software; you can redistribute it and/or modify it
8 : under the terms of the GNU Lesser General Public License as
9 : published by the Free Software Foundation; either version 2.1 of
10 : the License, or (at your option) any later version.
11 :
12 : Assuan is distributed in the hope that it will be useful, but
13 : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : Lesser General Public License for more details.
16 :
17 : You should have received a copy of the GNU Lesser General Public
18 : License along with this program; if not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #ifdef HAVE_CONFIG_H
22 : #include <config.h>
23 : #endif
24 :
25 : #include <stdlib.h>
26 : #include <stdio.h>
27 : #include <string.h>
28 : #include <errno.h>
29 :
30 : #include "assuan-defs.h"
31 : #include "debug.h"
32 :
33 :
34 : #define spacep(p) (*(p) == ' ' || *(p) == '\t')
35 : #define digitp(a) ((a) >= '0' && (a) <= '9')
36 :
37 : static int my_strcasecmp (const char *a, const char *b);
38 :
39 :
40 : #define PROCESS_DONE(ctx, rc) \
41 : ((ctx)->in_process_next ? assuan_process_done ((ctx), (rc)) : (rc))
42 :
43 : static gpg_error_t
44 0 : dummy_handler (assuan_context_t ctx, char *line)
45 : {
46 0 : return
47 0 : PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_ASSUAN_SERVER_FAULT,
48 : "no handler registered"));
49 : }
50 :
51 :
52 : static const char std_help_nop[] =
53 : "NOP\n"
54 : "\n"
55 : "No operation. Returns OK without any action.";
56 : static gpg_error_t
57 0 : std_handler_nop (assuan_context_t ctx, char *line)
58 : {
59 0 : return PROCESS_DONE (ctx, 0); /* okay */
60 : }
61 :
62 : static const char std_help_cancel[] =
63 : "CANCEL\n"
64 : "\n"
65 : "Run the server's cancel handler if one has been registered.";
66 : static gpg_error_t
67 0 : std_handler_cancel (assuan_context_t ctx, char *line)
68 : {
69 0 : if (ctx->cancel_notify_fnc)
70 : /* Return value ignored. */
71 0 : ctx->cancel_notify_fnc (ctx, line);
72 0 : return PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_NOT_IMPLEMENTED, NULL));
73 : }
74 :
75 : static const char std_help_option[] =
76 : "OPTION <NAME> [ [=] <VALUE> ]\n"
77 : "\n"
78 : "Set option <NAME> to configure server operation. Leading and\n"
79 : "trailing spaces around <NAME> and <VALUE> are allowed but should be\n"
80 : "ignored. For compatibility reasons, <NAME> may be prefixed with two\n"
81 : "dashes. The use of the equal sign is optional but suggested if\n"
82 : "<VALUE> is given.";
83 : static gpg_error_t
84 0 : std_handler_option (assuan_context_t ctx, char *line)
85 : {
86 : char *key, *value, *p;
87 :
88 0 : for (key=line; spacep (key); key++)
89 : ;
90 0 : if (!*key)
91 0 : return
92 0 : PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_ASS_SYNTAX, "argument required"));
93 0 : if (*key == '=')
94 0 : return
95 0 : PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_ASS_SYNTAX,
96 : "no option name given"));
97 0 : for (value=key; *value && !spacep (value) && *value != '='; value++)
98 : ;
99 0 : if (*value)
100 : {
101 0 : if (spacep (value))
102 0 : *value++ = 0; /* terminate key */
103 0 : for (; spacep (value); value++)
104 : ;
105 0 : if (*value == '=')
106 : {
107 0 : *value++ = 0; /* terminate key */
108 0 : for (; spacep (value); value++)
109 : ;
110 0 : if (!*value)
111 0 : return
112 0 : PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_ASS_SYNTAX,
113 : "option argument expected"));
114 : }
115 0 : if (*value)
116 : {
117 0 : for (p = value + strlen(value) - 1; p > value && spacep (p); p--)
118 : ;
119 0 : if (p > value)
120 0 : *++p = 0; /* strip trailing spaces */
121 : }
122 : }
123 :
124 0 : if (*key == '-' && key[1] == '-' && key[2])
125 0 : key += 2; /* the double dashes are optional */
126 0 : if (*key == '-')
127 0 : return PROCESS_DONE (ctx,
128 : set_error (ctx, GPG_ERR_ASS_SYNTAX,
129 : "option should not begin with one dash"));
130 :
131 0 : if (ctx->option_handler_fnc)
132 0 : return PROCESS_DONE (ctx, ctx->option_handler_fnc (ctx, key, value));
133 0 : return PROCESS_DONE (ctx, 0);
134 : }
135 :
136 : static const char std_help_bye[] =
137 : "BYE\n"
138 : "\n"
139 : "Close the connection. The server will reply with OK.";
140 : static gpg_error_t
141 2 : std_handler_bye (assuan_context_t ctx, char *line)
142 : {
143 2 : if (ctx->bye_notify_fnc)
144 : /* Return value ignored. */
145 0 : ctx->bye_notify_fnc (ctx, line);
146 2 : assuan_close_input_fd (ctx);
147 2 : assuan_close_output_fd (ctx);
148 : /* pretty simple :-) */
149 2 : ctx->process_complete = 1;
150 2 : return PROCESS_DONE (ctx, 0);
151 : }
152 :
153 : static const char std_help_auth[] =
154 : "AUTH\n"
155 : "\n"
156 : "Reserved for future extensions.";
157 : static gpg_error_t
158 0 : std_handler_auth (assuan_context_t ctx, char *line)
159 : {
160 0 : return PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_NOT_IMPLEMENTED, NULL));
161 : }
162 :
163 : static const char std_help_reset[] =
164 : "RESET\n"
165 : "\n"
166 : "Reset the connection but not any existing authentication. The server\n"
167 : "should release all resources associated with the connection.";
168 : static gpg_error_t
169 0 : std_handler_reset (assuan_context_t ctx, char *line)
170 : {
171 0 : gpg_error_t err = 0;
172 :
173 0 : if (ctx->reset_notify_fnc)
174 0 : err = ctx->reset_notify_fnc (ctx, line);
175 0 : if (! err)
176 : {
177 0 : assuan_close_input_fd (ctx);
178 0 : assuan_close_output_fd (ctx);
179 0 : _assuan_uds_close_fds (ctx);
180 : }
181 0 : return PROCESS_DONE (ctx, err);
182 : }
183 :
184 : static const char std_help_help[] =
185 : "HELP [<COMMAND>]\n"
186 : "\n"
187 : "Lists all commands that the server understands as comment lines on\n"
188 : "the status channel. If <COMMAND> is given, list detailed help for\n"
189 : "that command.";
190 : static gpg_error_t
191 0 : std_handler_help (assuan_context_t ctx, char *line)
192 : {
193 : unsigned int i;
194 : char buf[ASSUAN_LINELENGTH];
195 : const char *helpstr;
196 : size_t n;
197 :
198 0 : n = strcspn (line, " \t\n");
199 0 : if (!n)
200 : {
201 : /* Print all commands. If a help string is available and that
202 : starts with the command name, print the first line of the
203 : help string. */
204 0 : for (i = 0; i < ctx->cmdtbl_used; i++)
205 : {
206 0 : n = strlen (ctx->cmdtbl[i].name);
207 0 : helpstr = ctx->cmdtbl[i].helpstr;
208 0 : if (helpstr
209 0 : && !strncmp (ctx->cmdtbl[i].name, helpstr, n)
210 0 : && (!helpstr[n] || helpstr[n] == '\n' || helpstr[n] == ' ')
211 0 : && (n = strcspn (helpstr, "\n")) )
212 0 : snprintf (buf, sizeof (buf), "# %.*s", (int)n, helpstr);
213 : else
214 0 : snprintf (buf, sizeof (buf), "# %s", ctx->cmdtbl[i].name);
215 0 : buf[ASSUAN_LINELENGTH - 1] = '\0';
216 0 : assuan_write_line (ctx, buf);
217 : }
218 : }
219 : else
220 : {
221 : /* Print the help for the given command. */
222 0 : int c = line[n];
223 0 : line[n] = 0;
224 0 : for (i=0; ctx->cmdtbl[i].name; i++)
225 0 : if (!my_strcasecmp (line, ctx->cmdtbl[i].name))
226 0 : break;
227 0 : line[n] = c;
228 0 : if (!ctx->cmdtbl[i].name)
229 0 : return PROCESS_DONE (ctx, set_error (ctx,GPG_ERR_UNKNOWN_COMMAND,NULL));
230 0 : helpstr = ctx->cmdtbl[i].helpstr;
231 0 : if (!helpstr)
232 0 : return PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_NOT_FOUND, NULL));
233 : do
234 : {
235 0 : n = strcspn (helpstr, "\n");
236 0 : snprintf (buf, sizeof (buf), "# %.*s", (int)n, helpstr);
237 0 : helpstr += n;
238 0 : if (*helpstr == '\n')
239 0 : helpstr++;
240 0 : buf[ASSUAN_LINELENGTH - 1] = '\0';
241 0 : assuan_write_line (ctx, buf);
242 : }
243 0 : while (*helpstr);
244 : }
245 :
246 0 : return PROCESS_DONE (ctx, 0);
247 : }
248 :
249 : static const char std_help_end[] =
250 : "END\n"
251 : "\n"
252 : "Used by a client to mark the end of raw data.";
253 : static gpg_error_t
254 0 : std_handler_end (assuan_context_t ctx, char *line)
255 : {
256 0 : return PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_NOT_IMPLEMENTED, NULL));
257 : }
258 :
259 :
260 : gpg_error_t
261 6 : assuan_command_parse_fd (assuan_context_t ctx, char *line, assuan_fd_t *rfd)
262 : {
263 : char *endp;
264 :
265 6 : if ((strncmp (line, "FD", 2) && strncmp (line, "fd", 2))
266 6 : || (line[2] != '=' && line[2] != '\0' && !spacep(&line[2])))
267 0 : return set_error (ctx, GPG_ERR_ASS_SYNTAX, "FD[=<n>] expected");
268 6 : line += 2;
269 6 : if (*line == '=')
270 : {
271 0 : line ++;
272 0 : if (!digitp (*line))
273 0 : return set_error (ctx, GPG_ERR_ASS_SYNTAX, "number required");
274 : #if HAVE_W64_SYSTEM
275 : *rfd = (void*)strtoull (line, &endp, 10);
276 : #elif HAVE_W32_SYSTEM
277 : *rfd = (void*)strtoul (line, &endp, 10);
278 : #else
279 0 : *rfd = strtoul (line, &endp, 10);
280 : #endif
281 : /* Remove that argument so that a notify handler won't see it. */
282 0 : memset (line, ' ', endp? (endp-line):strlen(line));
283 :
284 0 : if (*rfd == ctx->inbound.fd)
285 0 : return set_error (ctx, GPG_ERR_ASS_PARAMETER, "fd same as inbound fd");
286 0 : if (*rfd == ctx->outbound.fd)
287 0 : return set_error (ctx, GPG_ERR_ASS_PARAMETER, "fd same as outbound fd");
288 0 : return 0;
289 : }
290 : else
291 : /* Our peer has sent the file descriptor. */
292 6 : return assuan_receivefd (ctx, rfd);
293 : }
294 :
295 :
296 : static const char std_help_input[] =
297 : "INPUT FD[=<N>]\n"
298 : "\n"
299 : "Used by a client to pass an input file descriptor to the server.\n"
300 : "The server opens <N> as a local file descriptor. Without <N>, the\n"
301 : "server opens the file descriptor just sent by the client using\n"
302 : "assuan_sendfd.";
303 : static gpg_error_t
304 6 : std_handler_input (assuan_context_t ctx, char *line)
305 : {
306 : gpg_error_t rc;
307 : assuan_fd_t fd, oldfd;
308 :
309 6 : rc = assuan_command_parse_fd (ctx, line, &fd);
310 6 : if (rc)
311 0 : return PROCESS_DONE (ctx, rc);
312 :
313 : #ifdef HAVE_W32CE_SYSTEM
314 : oldfd = fd;
315 : fd = _assuan_w32ce_finish_pipe ((int)fd, 0);
316 : if (fd == INVALID_HANDLE_VALUE)
317 : return PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_ASS_PARAMETER,
318 : "rvid conversion failed"));
319 : TRACE2 (ctx, ASSUAN_LOG_SYSIO, "std_handler_input", ctx,
320 : "turned RVID 0x%x into handle 0x%x", oldfd, fd);
321 : #endif
322 :
323 6 : if (ctx->input_notify_fnc)
324 : {
325 0 : oldfd = ctx->input_fd;
326 0 : ctx->input_fd = fd;
327 0 : rc = ctx->input_notify_fnc (ctx, line);
328 0 : if (rc)
329 0 : ctx->input_fd = oldfd;
330 : }
331 6 : else if (!rc)
332 6 : ctx->input_fd = fd;
333 6 : return PROCESS_DONE (ctx, rc);
334 : }
335 :
336 :
337 : static const char std_help_output[] =
338 : "OUTPUT FD[=<N>]\n"
339 : "\n"
340 : "Used by a client to pass an output file descriptor to the server.\n"
341 : "The server opens <N> as a local file descriptor. Without <N>, the\n"
342 : "server opens the file descriptor just sent by the client using\n"
343 : "assuan_sendfd.";
344 : static gpg_error_t
345 0 : std_handler_output (assuan_context_t ctx, char *line)
346 : {
347 : gpg_error_t rc;
348 : assuan_fd_t fd, oldfd;
349 :
350 0 : rc = assuan_command_parse_fd (ctx, line, &fd);
351 0 : if (rc)
352 0 : return PROCESS_DONE (ctx, rc);
353 :
354 : #ifdef HAVE_W32CE_SYSTEM
355 : oldfd = fd;
356 : fd = _assuan_w32ce_finish_pipe ((int)fd, 1);
357 : if (fd == INVALID_HANDLE_VALUE)
358 : return PROCESS_DONE (ctx, set_error (ctx, gpg_err_code_from_syserror (),
359 : "rvid conversion failed"));
360 : TRACE2 (ctx, ASSUAN_LOG_SYSIO, "std_handler_output", ctx,
361 : "turned RVID 0x%x into handle 0x%x", oldfd, fd);
362 : #endif
363 :
364 0 : if (ctx->output_notify_fnc)
365 : {
366 0 : oldfd = ctx->output_fd;
367 0 : ctx->output_fd = fd;
368 0 : rc = ctx->output_notify_fnc (ctx, line);
369 0 : if (rc)
370 0 : ctx->output_fd = oldfd;
371 : }
372 0 : else if (!rc)
373 0 : ctx->output_fd = fd;
374 0 : return PROCESS_DONE (ctx, rc);
375 : }
376 :
377 :
378 : /* This is a table with the standard commands and handler for them.
379 : The table is used to initialize a new context and associate strings
380 : with default handlers */
381 : static struct {
382 : const char *name;
383 : gpg_error_t (*handler)(assuan_context_t, char *line);
384 : const char *help;
385 : int always; /* always initialize this command */
386 : } std_cmd_table[] = {
387 : { "NOP", std_handler_nop, std_help_nop, 1 },
388 : { "CANCEL", std_handler_cancel, std_help_cancel, 1 },
389 : { "OPTION", std_handler_option, std_help_option, 1 },
390 : { "BYE", std_handler_bye, std_help_bye, 1 },
391 : { "AUTH", std_handler_auth, std_help_auth, 1 },
392 : { "RESET", std_handler_reset, std_help_reset, 1 },
393 : { "END", std_handler_end, std_help_end, 1 },
394 : { "HELP", std_handler_help, std_help_help, 1 },
395 :
396 : { "INPUT", std_handler_input, std_help_input, 0 },
397 : { "OUTPUT", std_handler_output, std_help_output, 0 },
398 : { } };
399 :
400 :
401 : /**
402 : * assuan_register_command:
403 : * @ctx: the server context
404 : * @cmd_name: A string with the command name
405 : * @handler: The handler function to be called or NULL to use a default
406 : * handler.
407 : * HELPSTRING
408 : *
409 : * Register a handler to be used for a given command. Note that
410 : * several default handlers are already regsitered with a new context.
411 : * This function however allows to override them.
412 : *
413 : * Return value: 0 on success or an error code
414 : **/
415 : gpg_error_t
416 23 : assuan_register_command (assuan_context_t ctx, const char *cmd_name,
417 : assuan_handler_t handler, const char *help_string)
418 : {
419 23 : int i, cmd_index = -1;
420 : const char *s;
421 :
422 23 : if (cmd_name && !*cmd_name)
423 0 : cmd_name = NULL;
424 :
425 23 : if (!cmd_name)
426 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
427 :
428 23 : if (!handler)
429 : { /* find a default handler. */
430 20 : for (i=0; (s=std_cmd_table[i].name) && strcmp (cmd_name, s); i++)
431 : ;
432 20 : if (!s)
433 : { /* Try again but case insensitive. */
434 0 : for (i=0; (s=std_cmd_table[i].name)
435 0 : && my_strcasecmp (cmd_name, s); i++)
436 : ;
437 : }
438 20 : if (s)
439 20 : handler = std_cmd_table[i].handler;
440 20 : if (!handler)
441 0 : handler = dummy_handler; /* Last resort is the dummy handler. */
442 : }
443 :
444 23 : if (!ctx->cmdtbl)
445 : {
446 2 : ctx->cmdtbl_size = 50;
447 2 : ctx->cmdtbl = _assuan_calloc (ctx, ctx->cmdtbl_size, sizeof *ctx->cmdtbl);
448 2 : if (!ctx->cmdtbl)
449 0 : return _assuan_error (ctx, gpg_err_code_from_syserror ());
450 2 : ctx->cmdtbl_used = 0;
451 : }
452 21 : else if (ctx->cmdtbl_used >= ctx->cmdtbl_size)
453 : {
454 : struct cmdtbl_s *x;
455 :
456 0 : x = _assuan_realloc (ctx, ctx->cmdtbl, (ctx->cmdtbl_size+10) * sizeof *x);
457 0 : if (!x)
458 0 : return _assuan_error (ctx, gpg_err_code_from_syserror ());
459 0 : ctx->cmdtbl = x;
460 0 : ctx->cmdtbl_size += 50;
461 : }
462 :
463 144 : for (i=0; i<ctx->cmdtbl_used; i++)
464 : {
465 121 : if (!my_strcasecmp (cmd_name, ctx->cmdtbl[i].name))
466 : {
467 0 : cmd_index = i;
468 0 : break;
469 : }
470 : }
471 :
472 23 : if (cmd_index == -1)
473 23 : cmd_index = ctx->cmdtbl_used++;
474 :
475 23 : ctx->cmdtbl[cmd_index].name = cmd_name;
476 23 : ctx->cmdtbl[cmd_index].handler = handler;
477 23 : ctx->cmdtbl[cmd_index].helpstr = help_string;
478 23 : return 0;
479 : }
480 :
481 : /* Return the name of the command currently processed by a handler.
482 : The string returned is valid until the next call to an assuan
483 : function on the same context. Returns NULL if no handler is
484 : executed or the command is not known. */
485 : const char *
486 0 : assuan_get_command_name (assuan_context_t ctx)
487 : {
488 0 : return ctx? ctx->current_cmd_name : NULL;
489 : }
490 :
491 : gpg_error_t
492 0 : assuan_register_pre_cmd_notify (assuan_context_t ctx,
493 : gpg_error_t (*fnc)(assuan_context_t,
494 : const char *cmd))
495 : {
496 0 : if (!ctx)
497 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
498 0 : ctx->pre_cmd_notify_fnc = fnc;
499 0 : return 0;
500 : }
501 :
502 : gpg_error_t
503 0 : assuan_register_post_cmd_notify (assuan_context_t ctx,
504 : void (*fnc)(assuan_context_t, gpg_error_t))
505 : {
506 0 : if (!ctx)
507 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
508 0 : ctx->post_cmd_notify_fnc = fnc;
509 0 : return 0;
510 : }
511 :
512 : gpg_error_t
513 0 : assuan_register_bye_notify (assuan_context_t ctx, assuan_handler_t fnc)
514 : {
515 0 : if (!ctx)
516 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
517 0 : ctx->bye_notify_fnc = fnc;
518 0 : return 0;
519 : }
520 :
521 : gpg_error_t
522 0 : assuan_register_reset_notify (assuan_context_t ctx, assuan_handler_t fnc)
523 : {
524 0 : if (!ctx)
525 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
526 0 : ctx->reset_notify_fnc = fnc;
527 0 : return 0;
528 : }
529 :
530 : gpg_error_t
531 0 : assuan_register_cancel_notify (assuan_context_t ctx, assuan_handler_t fnc)
532 : {
533 0 : if (!ctx)
534 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
535 0 : ctx->cancel_notify_fnc = fnc;
536 0 : return 0;
537 : }
538 :
539 : gpg_error_t
540 0 : assuan_register_option_handler (assuan_context_t ctx,
541 : gpg_error_t (*fnc)(assuan_context_t,
542 : const char*, const char*))
543 : {
544 0 : if (!ctx)
545 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
546 0 : ctx->option_handler_fnc = fnc;
547 0 : return 0;
548 : }
549 :
550 : gpg_error_t
551 0 : assuan_register_input_notify (assuan_context_t ctx, assuan_handler_t fnc)
552 : {
553 0 : if (!ctx)
554 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
555 0 : ctx->input_notify_fnc = fnc;
556 0 : return 0;
557 : }
558 :
559 : gpg_error_t
560 0 : assuan_register_output_notify (assuan_context_t ctx, assuan_handler_t fnc)
561 : {
562 0 : if (!ctx)
563 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
564 0 : ctx->output_notify_fnc = fnc;
565 0 : return 0;
566 : }
567 :
568 :
569 : /* Helper to register the standards commands */
570 : gpg_error_t
571 2 : _assuan_register_std_commands (assuan_context_t ctx)
572 : {
573 : gpg_error_t rc;
574 : int i;
575 :
576 22 : for (i = 0; std_cmd_table[i].name; i++)
577 : {
578 20 : if (std_cmd_table[i].always)
579 : {
580 16 : rc = assuan_register_command (ctx, std_cmd_table[i].name, NULL, NULL);
581 16 : if (rc)
582 0 : return rc;
583 : }
584 : }
585 2 : return 0;
586 : }
587 :
588 :
589 :
590 : /* Process the special data lines. The "D " has already been removed
591 : from the line. As all handlers this function may modify the line. */
592 : static gpg_error_t
593 0 : handle_data_line (assuan_context_t ctx, char *line, int linelen)
594 : {
595 0 : return set_error (ctx, GPG_ERR_NOT_IMPLEMENTED, NULL);
596 : }
597 :
598 : /* like ascii_strcasecmp but assume that B is already uppercase */
599 : static int
600 121 : my_strcasecmp (const char *a, const char *b)
601 : {
602 121 : if (a == b)
603 0 : return 0;
604 :
605 127 : for (; *a && *b; a++, b++)
606 : {
607 127 : if (((*a >= 'a' && *a <= 'z')? (*a&~0x20):*a) != *b)
608 121 : break;
609 : }
610 121 : return *a == *b? 0 : (((*a >= 'a' && *a <= 'z')? (*a&~0x20):*a) - *b);
611 : }
612 :
613 :
614 : /* Parse the line, break out the command, find it in the command
615 : table, remove leading and white spaces from the arguments, call the
616 : handler with the argument line and return the error. */
617 : static gpg_error_t
618 15 : dispatch_command (assuan_context_t ctx, char *line, int linelen)
619 : {
620 : gpg_error_t err;
621 : char *p;
622 : const char *s;
623 : int shift, i;
624 :
625 : /* Note that as this function is invoked by assuan_process_next as
626 : well, we need to hide non-critical errors with PROCESS_DONE. */
627 :
628 15 : if (*line == 'D' && line[1] == ' ') /* divert to special handler */
629 : /* FIXME: Depending on the final implementation of
630 : handle_data_line, this may be wrong here. For example, if a
631 : user callback is invoked, and that callback is responsible for
632 : calling assuan_process_done, then this is wrong. */
633 0 : return PROCESS_DONE (ctx, handle_data_line (ctx, line+2, linelen-2));
634 :
635 15 : for (p=line; *p && *p != ' ' && *p != '\t'; p++)
636 : ;
637 15 : if (p==line)
638 0 : return PROCESS_DONE
639 : (ctx, set_error (ctx, GPG_ERR_ASS_SYNTAX, "leading white-space"));
640 15 : if (*p)
641 : { /* Skip over leading WS after the keyword */
642 7 : *p++ = 0;
643 14 : while ( *p == ' ' || *p == '\t')
644 0 : p++;
645 : }
646 15 : shift = p - line;
647 :
648 131 : for (i=0; (s=ctx->cmdtbl[i].name); i++)
649 : {
650 131 : if (!strcmp (line, s))
651 15 : break;
652 : }
653 15 : if (!s)
654 : { /* and try case insensitive */
655 0 : for (i=0; (s=ctx->cmdtbl[i].name); i++)
656 : {
657 0 : if (!my_strcasecmp (line, s))
658 0 : break;
659 : }
660 : }
661 15 : if (!s)
662 0 : return PROCESS_DONE (ctx, set_error (ctx, GPG_ERR_ASS_UNKNOWN_CMD, NULL));
663 15 : line += shift;
664 : /* linelen -= shift; -- not needed. */
665 :
666 15 : if (ctx->pre_cmd_notify_fnc) {
667 0 : err = ctx->pre_cmd_notify_fnc(ctx, ctx->cmdtbl[i].name);
668 :
669 0 : if (err)
670 0 : return PROCESS_DONE(ctx, err);
671 : }
672 :
673 : /* fprintf (stderr, "DBG-assuan: processing %s `%s'\n", s, line); */
674 15 : ctx->current_cmd_name = ctx->cmdtbl[i].name;
675 15 : err = ctx->cmdtbl[i].handler (ctx, line);
676 15 : ctx->current_cmd_name = NULL;
677 15 : return err;
678 : }
679 :
680 :
681 : /* Call this to acknowledge the current command. */
682 : gpg_error_t
683 15 : assuan_process_done (assuan_context_t ctx, gpg_error_t rc)
684 : {
685 15 : if (!ctx->in_command)
686 0 : return _assuan_error (ctx, GPG_ERR_ASS_GENERAL);
687 :
688 15 : if (ctx->flags.force_close)
689 0 : ctx->process_complete = 1;
690 :
691 15 : ctx->in_command = 0;
692 :
693 : /* Check for data write errors. */
694 15 : if (ctx->outbound.data.fp)
695 : {
696 : /* Flush the data lines. */
697 0 : fclose (ctx->outbound.data.fp);
698 0 : ctx->outbound.data.fp = NULL;
699 0 : if (!rc && ctx->outbound.data.error)
700 0 : rc = ctx->outbound.data.error;
701 : }
702 : else
703 : {
704 : /* Flush any data send without using the data FP. */
705 15 : assuan_send_data (ctx, NULL, 0);
706 15 : if (!rc && ctx->outbound.data.error)
707 0 : rc = ctx->outbound.data.error;
708 : }
709 :
710 : /* Error handling. */
711 15 : if (!rc)
712 : {
713 15 : if (ctx->process_complete)
714 : {
715 : /* No error checking because the peer may have already
716 : disconnect. */
717 2 : assuan_write_line (ctx, "OK closing connection");
718 2 : ctx->finish_handler (ctx);
719 : }
720 : else
721 13 : rc = assuan_write_line (ctx, ctx->okay_line ? ctx->okay_line : "OK");
722 : }
723 : else
724 : {
725 : char errline[300];
726 0 : const char *text = ctx->err_no == rc ? ctx->err_str : NULL;
727 : char ebuf[50];
728 :
729 0 : if (ctx->flags.force_close)
730 0 : text = "[closing connection]";
731 :
732 0 : gpg_strerror_r (rc, ebuf, sizeof (ebuf));
733 0 : snprintf (errline, sizeof errline, "ERR %d %.50s <%.30s>%s%.100s",
734 : rc, ebuf, gpg_strsource (rc),
735 : text? " - ":"", text?text:"");
736 :
737 0 : rc = assuan_write_line (ctx, errline);
738 :
739 0 : if (ctx->flags.force_close)
740 0 : ctx->finish_handler (ctx);
741 : }
742 :
743 15 : if (ctx->post_cmd_notify_fnc)
744 0 : ctx->post_cmd_notify_fnc (ctx, rc);
745 :
746 15 : ctx->flags.confidential = 0;
747 15 : if (ctx->okay_line)
748 : {
749 0 : _assuan_free (ctx, ctx->okay_line);
750 0 : ctx->okay_line = NULL;
751 : }
752 :
753 15 : return rc;
754 : }
755 :
756 :
757 : static gpg_error_t
758 0 : process_next (assuan_context_t ctx)
759 : {
760 : gpg_error_t rc;
761 :
762 : /* What the next thing to do is depends on the current state.
763 : However, we will always first read the next line. The client is
764 : required to write full lines without blocking long after starting
765 : a partial line. */
766 0 : rc = _assuan_read_line (ctx);
767 0 : if (_assuan_error_is_eagain (ctx, rc))
768 0 : return 0;
769 0 : if (gpg_err_code (rc) == GPG_ERR_EOF)
770 : {
771 0 : ctx->process_complete = 1;
772 0 : return 0;
773 : }
774 0 : if (rc)
775 0 : return rc;
776 0 : if (*ctx->inbound.line == '#' || !ctx->inbound.linelen)
777 : /* Comment lines are ignored. */
778 0 : return 0;
779 :
780 : /* Now we have a line that really means something. It could be one
781 : of the following things: First, if we are not in a command
782 : already, it is the next command to dispatch. Second, if we are
783 : in a command, it can only be the response to an INQUIRE
784 : reply. */
785 :
786 0 : if (!ctx->in_command)
787 : {
788 0 : ctx->in_command = 1;
789 :
790 0 : ctx->outbound.data.error = 0;
791 0 : ctx->outbound.data.linelen = 0;
792 : /* Dispatch command and return reply. */
793 0 : ctx->in_process_next = 1;
794 0 : rc = dispatch_command (ctx, ctx->inbound.line, ctx->inbound.linelen);
795 0 : ctx->in_process_next = 0;
796 : }
797 0 : else if (ctx->in_inquire)
798 : {
799 : /* FIXME: Pick up the continuation. */
800 0 : rc = _assuan_inquire_ext_cb (ctx);
801 : }
802 : else
803 : {
804 : /* Should not happen. The client is sending data while we are
805 : in a command and not waiting for an inquire. We log an error
806 : and discard it. */
807 0 : TRACE0 (ctx, ASSUAN_LOG_DATA, "process_next", ctx,
808 : "unexpected client data");
809 0 : rc = 0;
810 : }
811 :
812 0 : return rc;
813 : }
814 :
815 :
816 : /* This function should be invoked when the assuan connected FD is
817 : ready for reading. If the equivalent to EWOULDBLOCK is returned
818 : (this should be done by the command handler), assuan_process_next
819 : should be invoked the next time the connected FD is readable.
820 : Eventually, the caller will finish by invoking assuan_process_done.
821 : DONE is set to 1 if the connection has ended. */
822 : gpg_error_t
823 0 : assuan_process_next (assuan_context_t ctx, int *done)
824 : {
825 : gpg_error_t rc;
826 :
827 0 : if (done)
828 0 : *done = 0;
829 0 : ctx->process_complete = 0;
830 : do
831 : {
832 0 : rc = process_next (ctx);
833 : }
834 0 : while (!rc && !ctx->process_complete && assuan_pending_line (ctx));
835 :
836 0 : if (done)
837 0 : *done = !!ctx->process_complete;
838 :
839 0 : return rc;
840 : }
841 :
842 :
843 :
844 : static gpg_error_t
845 21 : process_request (assuan_context_t ctx)
846 : {
847 : gpg_error_t rc;
848 :
849 21 : if (ctx->in_inquire)
850 0 : return _assuan_error (ctx, GPG_ERR_ASS_NESTED_COMMANDS);
851 :
852 : do
853 : {
854 21 : rc = _assuan_read_line (ctx);
855 : }
856 21 : while (_assuan_error_is_eagain (ctx, rc));
857 21 : if (gpg_err_code (rc) == GPG_ERR_EOF)
858 : {
859 0 : ctx->process_complete = 1;
860 0 : return 0;
861 : }
862 21 : if (rc)
863 0 : return rc;
864 21 : if (*ctx->inbound.line == '#' || !ctx->inbound.linelen)
865 6 : return 0; /* comment line - ignore */
866 :
867 15 : ctx->in_command = 1;
868 15 : ctx->outbound.data.error = 0;
869 15 : ctx->outbound.data.linelen = 0;
870 : /* dispatch command and return reply */
871 15 : rc = dispatch_command (ctx, ctx->inbound.line, ctx->inbound.linelen);
872 :
873 15 : return assuan_process_done (ctx, rc);
874 : }
875 :
876 : /**
877 : * assuan_process:
878 : * @ctx: assuan context
879 : *
880 : * This function is used to handle the assuan protocol after a
881 : * connection has been established using assuan_accept(). This is the
882 : * main protocol handler.
883 : *
884 : * Return value: 0 on success or an error code if the assuan operation
885 : * failed. Note, that no error is returned for operational errors.
886 : **/
887 : gpg_error_t
888 2 : assuan_process (assuan_context_t ctx)
889 : {
890 : gpg_error_t rc;
891 :
892 2 : ctx->process_complete = 0;
893 : do {
894 21 : rc = process_request (ctx);
895 21 : } while (!rc && !ctx->process_complete);
896 :
897 2 : return rc;
898 : }
899 :
900 :
901 : /**
902 : * assuan_get_active_fds:
903 : * @ctx: Assuan context
904 : * @what: 0 for read fds, 1 for write fds
905 : * @fdarray: Caller supplied array to store the FDs
906 : * @fdarraysize: size of that array
907 : *
908 : * Return all active filedescriptors for the given context. This
909 : * function can be used to select on the fds and call
910 : * assuan_process_next() if there is an active one. The first fd in
911 : * the array is the one used for the command connection.
912 : *
913 : * Note, that write FDs are not yet supported.
914 : *
915 : * Return value: number of FDs active and put into @fdarray or -1 on
916 : * error which is most likely a too small fdarray.
917 : **/
918 : int
919 0 : assuan_get_active_fds (assuan_context_t ctx, int what,
920 : assuan_fd_t *fdarray, int fdarraysize)
921 : {
922 0 : int n = 0;
923 :
924 0 : if (!ctx || fdarraysize < 2 || what < 0 || what > 1)
925 0 : return -1;
926 :
927 0 : if (!what)
928 : {
929 0 : if (ctx->inbound.fd != ASSUAN_INVALID_FD)
930 0 : fdarray[n++] = ctx->inbound.fd;
931 : }
932 : else
933 : {
934 0 : if (ctx->outbound.fd != ASSUAN_INVALID_FD)
935 0 : fdarray[n++] = ctx->outbound.fd;
936 0 : if (ctx->outbound.data.fp)
937 : #if defined(HAVE_W32CE_SYSTEM)
938 : fdarray[n++] = (void*)fileno (ctx->outbound.data.fp);
939 : #elif defined(HAVE_W32_SYSTEM)
940 : fdarray[n++] = (void*)_get_osfhandle (fileno (ctx->outbound.data.fp));
941 : #else
942 0 : fdarray[n++] = fileno (ctx->outbound.data.fp);
943 : #endif
944 : }
945 :
946 0 : return n;
947 : }
948 :
949 :
950 : /* Two simple wrappers to make the expected function types match. */
951 : #ifdef HAVE_FUNOPEN
952 : static int
953 : fun1_cookie_write (void *cookie, const char *buffer, int orig_size)
954 : {
955 : return _assuan_cookie_write_data (cookie, buffer, orig_size);
956 : }
957 : #endif /*HAVE_FUNOPEN*/
958 : #ifdef HAVE_FOPENCOOKIE
959 : static ssize_t
960 0 : fun2_cookie_write (void *cookie, const char *buffer, size_t orig_size)
961 : {
962 0 : return _assuan_cookie_write_data (cookie, buffer, orig_size);
963 : }
964 : #endif /*HAVE_FOPENCOOKIE*/
965 :
966 : /* Return a FP to be used for data output. The FILE pointer is valid
967 : until the end of a handler. So a close is not needed. Assuan does
968 : all the buffering needed to insert the status line as well as the
969 : required line wappping and quoting for data lines.
970 :
971 : We use GNU's custom streams here. There should be an alternative
972 : implementaion for systems w/o a glibc, a simple implementation
973 : could use a child process */
974 : FILE *
975 0 : assuan_get_data_fp (assuan_context_t ctx)
976 : {
977 : #if defined (HAVE_FOPENCOOKIE) || defined (HAVE_FUNOPEN)
978 0 : if (ctx->outbound.data.fp)
979 0 : return ctx->outbound.data.fp;
980 :
981 : #ifdef HAVE_FUNOPEN
982 : ctx->outbound.data.fp = funopen (ctx, 0, fun1_cookie_write,
983 : 0, _assuan_cookie_write_flush);
984 : #else
985 0 : ctx->outbound.data.fp = funopen (ctx, 0, fun2_cookie_write,
986 : 0, _assuan_cookie_write_flush);
987 : #endif
988 :
989 0 : ctx->outbound.data.error = 0;
990 0 : return ctx->outbound.data.fp;
991 : #else
992 : gpg_err_set_errno (ENOSYS);
993 : return NULL;
994 : #endif
995 : }
996 :
997 :
998 : /* Set the text used for the next OK response. This string is
999 : automatically reset to NULL after the next command. */
1000 : gpg_error_t
1001 0 : assuan_set_okay_line (assuan_context_t ctx, const char *line)
1002 : {
1003 0 : if (!ctx)
1004 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
1005 0 : if (!line)
1006 : {
1007 0 : _assuan_free (ctx, ctx->okay_line);
1008 0 : ctx->okay_line = NULL;
1009 : }
1010 : else
1011 : {
1012 : /* FIXME: we need to use gcry_is_secure() to test whether
1013 : we should allocate the entire line in secure memory */
1014 0 : char *buf = _assuan_malloc (ctx, 3 + strlen(line) + 1);
1015 0 : if (!buf)
1016 0 : return _assuan_error (ctx, gpg_err_code_from_syserror ());
1017 0 : strcpy (buf, "OK ");
1018 0 : strcpy (buf+3, line);
1019 0 : _assuan_free (ctx, ctx->okay_line);
1020 0 : ctx->okay_line = buf;
1021 : }
1022 0 : return 0;
1023 : }
1024 :
1025 :
1026 :
1027 : gpg_error_t
1028 0 : assuan_write_status (assuan_context_t ctx,
1029 : const char *keyword, const char *text)
1030 : {
1031 : char buffer[256];
1032 : char *helpbuf;
1033 : size_t n;
1034 : gpg_error_t ae;
1035 :
1036 0 : if ( !ctx || !keyword)
1037 0 : return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
1038 0 : if (!text)
1039 0 : text = "";
1040 :
1041 0 : n = 2 + strlen (keyword) + 1 + strlen (text) + 1;
1042 0 : if (n < sizeof (buffer))
1043 : {
1044 0 : strcpy (buffer, "S ");
1045 0 : strcat (buffer, keyword);
1046 0 : if (*text)
1047 : {
1048 0 : strcat (buffer, " ");
1049 0 : strcat (buffer, text);
1050 : }
1051 0 : ae = assuan_write_line (ctx, buffer);
1052 : }
1053 0 : else if ( (helpbuf = _assuan_malloc (ctx, n)) )
1054 : {
1055 0 : strcpy (helpbuf, "S ");
1056 0 : strcat (helpbuf, keyword);
1057 0 : if (*text)
1058 : {
1059 0 : strcat (helpbuf, " ");
1060 0 : strcat (helpbuf, text);
1061 : }
1062 0 : ae = assuan_write_line (ctx, helpbuf);
1063 0 : _assuan_free (ctx, helpbuf);
1064 : }
1065 : else
1066 0 : ae = 0;
1067 0 : return ae;
1068 : }
|
