Update to rev 231 of libassuan.
[gpgme.git] / assuan / assuan-handler.c
1 /* assuan-handler.c - dispatch commands 
2  *      Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Assuan.
5  *
6  * Assuan is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Assuan is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA. 
20  */
21
22 #include <config.h>
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "assuan-defs.h"
29
30
31
32 #define spacep(p)  (*(p) == ' ' || *(p) == '\t')
33 #define digitp(a) ((a) >= '0' && (a) <= '9')
34
35 static int my_strcasecmp (const char *a, const char *b);
36
37
38
39 static int
40 dummy_handler (assuan_context_t ctx, char *line)
41 {
42   return set_error (ctx, Server_Fault, "no handler registered");
43 }
44
45
46 static int
47 std_handler_nop (assuan_context_t ctx, char *line)
48 {
49   return 0; /* okay */
50 }
51   
52 static int
53 std_handler_cancel (assuan_context_t ctx, char *line)
54 {
55   if (ctx->cancel_notify_fnc)
56     ctx->cancel_notify_fnc (ctx);
57   return set_error (ctx, Not_Implemented, NULL); 
58 }
59
60 static int
61 std_handler_option (assuan_context_t ctx, char *line)
62 {
63   char *key, *value, *p;
64
65   for (key=line; spacep (key); key++)
66     ;
67   if (!*key)
68     return set_error (ctx, Syntax_Error, "argument required");
69   if (*key == '=')
70     return set_error (ctx, Syntax_Error, "no option name given");
71   for (value=key; *value && !spacep (value) && *value != '='; value++)
72     ;
73   if (*value)
74     {
75       if (spacep (value))
76         *value++ = 0; /* terminate key */
77       for (; spacep (value); value++)
78         ;
79       if (*value == '=')
80         {
81           *value++ = 0; /* terminate key */
82           for (; spacep (value); value++)
83             ;
84           if (!*value)
85             return set_error (ctx, Syntax_Error, "option argument expected");
86         }
87       if (*value)
88         {
89           for (p = value + strlen(value) - 1; p > value && spacep (p); p--)
90             ;
91           if (p > value)
92             *++p = 0; /* strip trailing spaces */
93         }
94     }
95
96   if (*key == '-' && key[1] == '-' && key[2])
97     key += 2; /* the double dashes are optional */
98   if (*key == '-')
99     return set_error (ctx, Syntax_Error,
100                       "option should not begin with one dash");
101
102   if (ctx->option_handler_fnc)
103     return ctx->option_handler_fnc (ctx, key, value);
104   return 0;
105 }
106   
107 static int
108 std_handler_bye (assuan_context_t ctx, char *line)
109 {
110   if (ctx->bye_notify_fnc)
111     ctx->bye_notify_fnc (ctx);
112   assuan_close_input_fd (ctx);
113   assuan_close_output_fd (ctx);
114   return -1; /* pretty simple :-) */
115 }
116   
117 static int
118 std_handler_auth (assuan_context_t ctx, char *line)
119 {
120   return set_error (ctx, Not_Implemented, NULL); 
121 }
122   
123 static int
124 std_handler_reset (assuan_context_t ctx, char *line)
125 {
126   if (ctx->reset_notify_fnc)
127     ctx->reset_notify_fnc (ctx);
128   assuan_close_input_fd (ctx);
129   assuan_close_output_fd (ctx);
130   _assuan_uds_close_fds (ctx);
131   return 0;
132 }
133   
134 static int
135 std_handler_end (assuan_context_t ctx, char *line)
136 {
137   return set_error (ctx, Not_Implemented, NULL); 
138 }
139
140 assuan_error_t
141 assuan_command_parse_fd (assuan_context_t ctx, char *line, int *rfd)
142 {
143   char *endp;
144
145   if ( (strncmp (line, "FD", 2) && strncmp (line, "fd", 2))
146        || (line[2] != '=' && line[2] != '\0'))
147     return set_error (ctx, Syntax_Error, "FD[=<n>] expected");
148   line += 2;
149   if (*line == '=')
150     {
151       line ++;
152       if (!digitp (*line))
153         return set_error (ctx, Syntax_Error, "number required");
154       *rfd = strtoul (line, &endp, 10);
155       /* Remove that argument so that a notify handler won't see it. */
156       memset (line, ' ', endp? (endp-line):strlen(line));
157
158       if (*rfd == ctx->inbound.fd)
159         return set_error (ctx, Parameter_Conflict, "fd same as inbound fd");
160       if (*rfd == ctx->outbound.fd)
161         return set_error (ctx, Parameter_Conflict, "fd same as outbound fd");
162       return 0;
163     }
164   else
165     /* Our peer has sent the file descriptor.  */
166     return assuan_receivefd (ctx, rfd);
167 }
168
169 /* Format is INPUT FD=<n> */
170 static int
171 std_handler_input (assuan_context_t ctx, char *line)
172 {
173   int rc, fd;
174
175   rc = assuan_command_parse_fd (ctx, line, &fd);
176   if (rc)
177     return rc;
178   ctx->input_fd = fd;
179   if (ctx->input_notify_fnc)
180     ctx->input_notify_fnc (ctx, line);
181   return 0;
182 }
183
184 /* Format is OUTPUT FD=<n> */
185 static int
186 std_handler_output (assuan_context_t ctx, char *line)
187 {
188   int rc, fd;
189
190   rc = assuan_command_parse_fd (ctx, line, &fd);
191   if (rc)
192     return rc;
193   ctx->output_fd = fd;
194   if (ctx->output_notify_fnc)
195     ctx->output_notify_fnc (ctx, line);
196   return 0;
197 }
198
199
200
201   
202
203 /* This is a table with the standard commands and handler for them.
204    The table is used to initialize a new context and associate strings
205    with default handlers */
206 static struct {
207   const char *name;
208   int (*handler)(assuan_context_t, char *line);
209   int always; /* always initialize this command */
210 } std_cmd_table[] = {
211   { "NOP",    std_handler_nop, 1 },
212   { "CANCEL", std_handler_cancel, 1 },
213   { "OPTION", std_handler_option, 1 },
214   { "BYE",    std_handler_bye, 1 },
215   { "AUTH",   std_handler_auth, 1 },
216   { "RESET",  std_handler_reset, 1 },
217   { "END",    std_handler_end, 1 },
218               
219   { "INPUT",  std_handler_input },
220   { "OUTPUT", std_handler_output },
221   { "OPTION", std_handler_option, 1 },
222   { NULL }
223 };
224
225
226 /**
227  * assuan_register_command:
228  * @ctx: the server context
229  * @cmd_name: A string with the command name
230  * @handler: The handler function to be called or NULL to use a default
231  *           handler.
232  * 
233  * Register a handler to be used for a given command.  Note that
234  * several default handlers are already regsitered with a new context.
235  * This function however allows to override them.
236  * 
237  * Return value: 0 on success or an error code
238  **/
239 int
240 assuan_register_command (assuan_context_t ctx,
241                          const char *cmd_name,
242                          int (*handler)(assuan_context_t, char *))
243 {
244   int i;
245   const char *s;
246
247   if (cmd_name && !*cmd_name)
248     cmd_name = NULL;
249
250   if (!cmd_name)
251     return _assuan_error (ASSUAN_Invalid_Value);
252
253   if (!handler)
254     { /* find a default handler. */
255       for (i=0; (s=std_cmd_table[i].name) && strcmp (cmd_name, s); i++)
256         ;
257       if (!s)
258         { /* Try again but case insensitive. */
259           for (i=0; (s=std_cmd_table[i].name)
260                     && my_strcasecmp (cmd_name, s); i++)
261             ;
262         }
263       if (s)
264         handler = std_cmd_table[i].handler;
265       if (!handler)
266         handler = dummy_handler; /* Last resort is the dummy handler. */
267     }
268   
269   if (!ctx->cmdtbl)
270     {
271       ctx->cmdtbl_size = 50;
272       ctx->cmdtbl = xtrycalloc ( ctx->cmdtbl_size, sizeof *ctx->cmdtbl);
273       if (!ctx->cmdtbl)
274         return _assuan_error (ASSUAN_Out_Of_Core);
275       ctx->cmdtbl_used = 0;
276     }
277   else if (ctx->cmdtbl_used >= ctx->cmdtbl_size)
278     {
279       struct cmdtbl_s *x;
280
281       x = xtryrealloc ( ctx->cmdtbl, (ctx->cmdtbl_size+10) * sizeof *x);
282       if (!x)
283         return _assuan_error (ASSUAN_Out_Of_Core);
284       ctx->cmdtbl = x;
285       ctx->cmdtbl_size += 50;
286     }
287
288   ctx->cmdtbl[ctx->cmdtbl_used].name = cmd_name;
289   ctx->cmdtbl[ctx->cmdtbl_used].handler = handler;
290   ctx->cmdtbl_used++;
291   return 0;
292 }
293
294 int
295 assuan_register_post_cmd_notify (assuan_context_t ctx,
296                                  void (*fnc)(assuan_context_t, int))
297 {
298   if (!ctx)
299     return _assuan_error (ASSUAN_Invalid_Value);
300   ctx->post_cmd_notify_fnc = fnc;
301   return 0;
302 }
303
304 int
305 assuan_register_bye_notify (assuan_context_t ctx,
306                             void (*fnc)(assuan_context_t))
307 {
308   if (!ctx)
309     return _assuan_error (ASSUAN_Invalid_Value);
310   ctx->bye_notify_fnc = fnc;
311   return 0;
312 }
313
314 int
315 assuan_register_reset_notify (assuan_context_t ctx,
316                               void (*fnc)(assuan_context_t))
317 {
318   if (!ctx)
319     return _assuan_error (ASSUAN_Invalid_Value);
320   ctx->reset_notify_fnc = fnc;
321   return 0;
322 }
323
324 int
325 assuan_register_cancel_notify (assuan_context_t ctx,
326                                void (*fnc)(assuan_context_t))
327 {
328   if (!ctx)
329     return _assuan_error (ASSUAN_Invalid_Value);
330   ctx->cancel_notify_fnc = fnc;
331   return 0;
332 }
333
334 int
335 assuan_register_option_handler (assuan_context_t ctx,
336                                int (*fnc)(assuan_context_t,
337                                           const char*, const char*))
338 {
339   if (!ctx)
340     return _assuan_error (ASSUAN_Invalid_Value);
341   ctx->option_handler_fnc = fnc;
342   return 0;
343 }
344
345 int
346 assuan_register_input_notify (assuan_context_t ctx,
347                               void (*fnc)(assuan_context_t, const char *))
348 {
349   if (!ctx)
350     return _assuan_error (ASSUAN_Invalid_Value);
351   ctx->input_notify_fnc = fnc;
352   return 0;
353 }
354
355 int
356 assuan_register_output_notify (assuan_context_t ctx,
357                               void (*fnc)(assuan_context_t, const char *))
358 {
359   if (!ctx)
360     return _assuan_error (ASSUAN_Invalid_Value);
361   ctx->output_notify_fnc = fnc;
362   return 0;
363 }
364
365
366 /* Helper to register the standards commands */
367 int
368 _assuan_register_std_commands (assuan_context_t ctx)
369 {
370   int i, rc;
371
372   for (i=0; std_cmd_table[i].name; i++)
373     {
374       if (std_cmd_table[i].always)
375         {
376           rc = assuan_register_command (ctx, std_cmd_table[i].name, NULL);
377           if (rc)
378             return rc;
379         }
380     } 
381   return 0;
382 }
383
384
385 \f
386 /* Process the special data lines.  The "D " has already been removed
387    from the line.  As all handlers this function may modify the line.  */
388 static int
389 handle_data_line (assuan_context_t ctx, char *line, int linelen)
390 {
391   return set_error (ctx, Not_Implemented, NULL);
392 }
393
394 /* like ascii_strcasecmp but assume that B is already uppercase */
395 static int
396 my_strcasecmp (const char *a, const char *b)
397 {
398     if (a == b)
399         return 0;
400
401     for (; *a && *b; a++, b++)
402       {
403         if (((*a >= 'a' && *a <= 'z')? (*a&~0x20):*a) != *b)
404             break;
405       }
406     return *a == *b? 0 : (((*a >= 'a' && *a <= 'z')? (*a&~0x20):*a) - *b);
407 }
408
409 /* Parse the line, break out the command, find it in the command
410    table, remove leading and white spaces from the arguments, call the
411    handler with the argument line and return the error */
412 static int 
413 dispatch_command (assuan_context_t ctx, char *line, int linelen)
414 {
415   char *p;
416   const char *s;
417   int shift, i;
418
419   if (*line == 'D' && line[1] == ' ') /* divert to special handler */
420     return handle_data_line (ctx, line+2, linelen-2);
421
422   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
423     ;
424   if (p==line)
425     return set_error (ctx, Syntax_Error, "leading white-space"); 
426   if (*p) 
427     { /* Skip over leading WS after the keyword */
428       *p++ = 0;
429       while ( *p == ' ' || *p == '\t')
430         p++;
431     }
432   shift = p - line;
433
434   for (i=0; (s=ctx->cmdtbl[i].name); i++)
435     {
436       if (!strcmp (line, s))
437         break;
438     }
439   if (!s)
440     { /* and try case insensitive */
441       for (i=0; (s=ctx->cmdtbl[i].name); i++)
442         {
443           if (!my_strcasecmp (line, s))
444             break;
445         }
446     }
447   if (!s)
448     return set_error (ctx, Unknown_Command, NULL);
449   line += shift;
450   linelen -= shift;
451
452 /*    fprintf (stderr, "DBG-assuan: processing %s `%s'\n", s, line); */
453   return ctx->cmdtbl[i].handler (ctx, line);
454 }
455
456
457
458 \f
459 static int
460 process_request (assuan_context_t ctx)
461 {
462   int rc;
463
464   if (ctx->in_inquire)
465     return _assuan_error (ASSUAN_Nested_Commands);
466
467   rc = _assuan_read_line (ctx);
468   if (rc)
469     return rc;
470   if (*ctx->inbound.line == '#' || !ctx->inbound.linelen)
471     return 0; /* comment line - ignore */
472
473   ctx->outbound.data.error = 0;
474   ctx->outbound.data.linelen = 0;
475   /* dispatch command and return reply */
476   rc = dispatch_command (ctx, ctx->inbound.line, ctx->inbound.linelen);
477   /* check from data write errors */
478   if (ctx->outbound.data.fp)
479     { /* Flush the data lines */
480       fclose (ctx->outbound.data.fp);
481       ctx->outbound.data.fp = NULL;
482       if (!rc && ctx->outbound.data.error)
483         rc = ctx->outbound.data.error;
484     }
485   else /* flush any data send w/o using the data fp */
486     {
487       assuan_send_data (ctx, NULL, 0);
488       if (!rc && ctx->outbound.data.error)
489         rc = ctx->outbound.data.error;
490     }
491   /* Error handling */
492   if (!rc)
493     {
494       rc = assuan_write_line (ctx, ctx->okay_line? ctx->okay_line : "OK");
495     }
496   else if (err_is_eof (rc))
497     { /* No error checking because the peer may have already disconnect. */ 
498       assuan_write_line (ctx, "OK closing connection");
499       ctx->finish_handler (ctx);
500     }
501   else 
502     {
503       char errline[300];
504
505       if (rc < 100)
506         sprintf (errline, "ERR %d server fault (%.50s)",
507                  _assuan_error (ASSUAN_Server_Fault), assuan_strerror (rc));
508       else
509         {
510           const char *text = ctx->err_no == rc? ctx->err_str:NULL;
511
512 #if defined(__GNUC__) && defined(__ELF__)
513           /* If we have weak symbol support we try to use the error
514              strings from libgpg-error without creating a dependency.
515              They are used for debugging purposes only, so there is no
516              problem if they are not available.  We need to make sure
517              that we are using ELF because only this guarantees that
518              weak symbol support is available in case GNU ld is not
519              used.  It seems that old gcc versions don't implement the
520              weak attribute properly but it works with the weak
521              pragma. */
522
523           unsigned int source, code;
524
525           int gpg_strerror_r (unsigned int err, char *buf, size_t buflen)
526             __attribute__ ((weak));
527           const char *gpg_strsource (unsigned int err)
528             __attribute__ ((weak));
529 #if !defined(HAVE_W32_SYSTEM) && __GNUC__ < 3
530 #pragma weak gpg_strerror_r
531 #pragma weak gpg_strsource
532 #endif
533
534           source = ((rc >> 24) & 0xff);
535           code = (rc & 0x00ffffff);
536           if (source && gpg_strsource && gpg_strerror_r)
537             {
538               /* Assume this is an libgpg-error. */
539               char ebuf[50];
540
541               gpg_strerror_r (rc, ebuf, sizeof ebuf );
542               sprintf (errline, "ERR %d %.50s <%.30s>%s%.100s",
543                        rc,
544                        ebuf,
545                        gpg_strsource (rc),
546                        text? " - ":"", text?text:"");
547             }
548           else
549 #endif /* __GNUC__  && __ELF__ */
550             sprintf (errline, "ERR %d %.50s%s%.100s",
551                      rc, assuan_strerror (rc), text? " - ":"", text?text:"");
552         }
553       rc = assuan_write_line (ctx, errline);
554     }
555
556   if (ctx->post_cmd_notify_fnc)
557     ctx->post_cmd_notify_fnc (ctx, rc);
558
559   ctx->confidential = 0;
560   if (ctx->okay_line)
561     {
562       xfree (ctx->okay_line);
563       ctx->okay_line = NULL;
564     }
565   return rc;
566 }
567
568 /**
569  * assuan_process:
570  * @ctx: assuan context
571  * 
572  * This function is used to handle the assuan protocol after a
573  * connection has been established using assuan_accept().  This is the
574  * main protocol handler.
575  * 
576  * Return value: 0 on success or an error code if the assuan operation
577  * failed.  Note, that no error is returned for operational errors.
578  **/
579 int
580 assuan_process (assuan_context_t ctx)
581 {
582   int rc;
583
584   do {
585     rc = process_request (ctx);
586   } while (!rc);
587
588   if (err_is_eof (rc))
589     rc = 0;
590
591   return rc;
592 }
593
594
595 /**
596  * assuan_process_next:
597  * @ctx: Assuan context
598  * 
599  * Same as assuan_process() but the user has to provide the outer
600  * loop.  He should loop as long as the return code is zero and stop
601  * otherwise; -1 is regular end.
602  * 
603  * See also: assuan_get_active_fds()
604  * Return value: -1 for end of server, 0 on success or an error code
605  **/
606 int 
607 assuan_process_next (assuan_context_t ctx)
608 {
609   return process_request (ctx);
610 }
611
612
613 /**
614  * assuan_get_active_fds:
615  * @ctx: Assuan context
616  * @what: 0 for read fds, 1 for write fds
617  * @fdarray: Caller supplied array to store the FDs
618  * @fdarraysize: size of that array
619  * 
620  * Return all active filedescriptors for the given context.  This
621  * function can be used to select on the fds and call
622  * assuan_process_next() if there is an active one.  The first fd in
623  * the array is the one used for the command connection.
624  *
625  * Note, that write FDs are not yet supported.
626  * 
627  * Return value: number of FDs active and put into @fdarray or -1 on
628  * error which is most likely a too small fdarray.
629  **/
630 int 
631 assuan_get_active_fds (assuan_context_t ctx, int what,
632                        int *fdarray, int fdarraysize)
633 {
634   int n = 0;
635
636   if (!ctx || fdarraysize < 2 || what < 0 || what > 1)
637     return -1;
638
639   if (!what)
640     {
641       if (ctx->inbound.fd != -1)
642         fdarray[n++] = ctx->inbound.fd;
643     }
644   else
645     {
646       if (ctx->outbound.fd != -1)
647         fdarray[n++] = ctx->outbound.fd;
648       if (ctx->outbound.data.fp)
649         fdarray[n++] = fileno (ctx->outbound.data.fp);
650     }
651
652   return n;
653 }
654
655
656 /* Two simple wrappers to make the expected function types match. */
657 #ifdef HAVE_FUNOPEN
658 static int
659 fun1_cookie_write (void *cookie, const char *buffer, int orig_size)
660 {
661   return _assuan_cookie_write_data (cookie, buffer, orig_size);
662 }
663 #endif /*HAVE_FUNOPEN*/
664 #ifdef HAVE_FOPENCOOKIE
665 static ssize_t
666 fun2_cookie_write (void *cookie, const char *buffer, size_t orig_size)
667 {
668   return _assuan_cookie_write_data (cookie, buffer, orig_size);
669 }
670 #endif /*HAVE_FOPENCOOKIE*/
671
672 /* Return a FP to be used for data output.  The FILE pointer is valid
673    until the end of a handler.  So a close is not needed.  Assuan does
674    all the buffering needed to insert the status line as well as the
675    required line wappping and quoting for data lines.
676
677    We use GNU's custom streams here.  There should be an alternative
678    implementaion for systems w/o a glibc, a simple implementation
679    could use a child process */
680 FILE *
681 assuan_get_data_fp (assuan_context_t ctx)
682 {
683 #if defined (HAVE_FOPENCOOKIE) || defined (HAVE_FUNOPEN)
684   if (ctx->outbound.data.fp)
685     return ctx->outbound.data.fp;
686   
687 #ifdef HAVE_FUNOPEN
688   ctx->outbound.data.fp = funopen (ctx, 0, fun1_cookie_write,
689                                    0, _assuan_cookie_write_flush);
690 #else
691   ctx->outbound.data.fp = funopen (ctx, 0, fun2_cookie_write,
692                                    0, _assuan_cookie_write_flush);
693 #endif                                   
694
695   ctx->outbound.data.error = 0;
696   return ctx->outbound.data.fp;
697 #else
698   errno = ENOSYS;
699   return NULL;
700 #endif
701 }
702
703
704 /* Set the text used for the next OK reponse.  This string is
705    automatically reset to NULL after the next command. */
706 assuan_error_t
707 assuan_set_okay_line (assuan_context_t ctx, const char *line)
708 {
709   if (!ctx)
710     return _assuan_error (ASSUAN_Invalid_Value);
711   if (!line)
712     {
713       xfree (ctx->okay_line);
714       ctx->okay_line = NULL;
715     }
716   else
717     {
718       /* FIXME: we need to use gcry_is_secure() to test whether
719          we should allocate the entire line in secure memory */
720       char *buf = xtrymalloc (3+strlen(line)+1);
721       if (!buf)
722         return _assuan_error (ASSUAN_Out_Of_Core);
723       strcpy (buf, "OK ");
724       strcpy (buf+3, line);
725       xfree (ctx->okay_line);
726       ctx->okay_line = buf;
727     }
728   return 0;
729 }
730
731
732
733 assuan_error_t
734 assuan_write_status (assuan_context_t ctx,
735                      const char *keyword, const char *text)
736 {
737   char buffer[256];
738   char *helpbuf;
739   size_t n;
740   assuan_error_t ae;
741
742   if ( !ctx || !keyword)
743     return _assuan_error (ASSUAN_Invalid_Value);
744   if (!text)
745     text = "";
746
747   n = 2 + strlen (keyword) + 1 + strlen (text) + 1;
748   if (n < sizeof (buffer))
749     {
750       strcpy (buffer, "S ");
751       strcat (buffer, keyword);
752       if (*text)
753         {
754           strcat (buffer, " ");
755           strcat (buffer, text);
756         }
757       ae = assuan_write_line (ctx, buffer);
758     }
759   else if ( (helpbuf = xtrymalloc (n)) )
760     {
761       strcpy (helpbuf, "S ");
762       strcat (helpbuf, keyword);
763       if (*text)
764         {
765           strcat (helpbuf, " ");
766           strcat (helpbuf, text);
767         }
768       ae = assuan_write_line (ctx, helpbuf);
769       xfree (helpbuf);
770     }
771   else
772     ae = 0;
773   return ae;
774 }