Remove macro hacks for internal vs. external functions. Part 1.
[libgcrypt.git] / src / sexp.c
1 /* sexp.c  -  S-Expression handling
2  * Copyright (C) 1999, 2000, 2001, 2002, 2003,
3  *               2004, 2006, 2007, 2008, 2011  Free Software Foundation, Inc.
4  * Copyright (C) 2013 g10 Code GmbH
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser general Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21  */
22
23
24 #include <config.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #include <ctype.h>
30 #include <errno.h>
31
32 #define GCRYPT_NO_MPI_MACROS 1
33 #include "g10lib.h"
34
35 typedef struct gcry_sexp *NODE;
36 typedef unsigned short DATALEN;
37
38 struct gcry_sexp
39 {
40   byte d[1];
41 };
42
43 #define ST_STOP  0
44 #define ST_DATA  1  /* datalen follows */
45 #define ST_HINT  2  /* datalen follows */
46 #define ST_OPEN  3
47 #define ST_CLOSE 4
48
49 /* the atoi macros assume that the buffer has only valid digits */
50 #define atoi_1(p)   (*(p) - '0' )
51 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
52                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
53 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
54
55 #define TOKEN_SPECIALS  "-./_:*+="
56
57 static gcry_err_code_t
58 do_vsexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
59                 const char *buffer, size_t length, int argflag,
60                 void **arg_list, va_list arg_ptr);
61
62 static gcry_err_code_t
63 do_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
64                const char *buffer, size_t length, int argflag,
65                void **arg_list, ...);
66
67 /* Return true if P points to a byte containing a whitespace according
68    to the S-expressions definition. */
69 #undef whitespacep
70 static GPG_ERR_INLINE int
71 whitespacep (const char *p)
72 {
73   switch (*p)
74     {
75     case ' ': case '\t': case '\v': case '\f': case '\r': case '\n': return 1;
76     default: return 0;
77     }
78 }
79
80
81 #if 0
82 static void
83 dump_mpi( gcry_mpi_t a )
84 {
85     char buffer[1000];
86     size_t n = 1000;
87
88     if( !a )
89         fputs("[no MPI]", stderr );
90     else if( gcry_mpi_print( GCRYMPI_FMT_HEX, buffer, &n, a ) )
91         fputs("[MPI too large to print]", stderr );
92     else
93         fputs( buffer, stderr );
94 }
95 #endif
96
97 static void
98 dump_string (const byte *p, size_t n, int delim )
99 {
100   for (; n; n--, p++ )
101     {
102       if ((*p & 0x80) || iscntrl( *p ) || *p == delim )
103         {
104           if( *p == '\n' )
105             log_printf ("\\n");
106           else if( *p == '\r' )
107             log_printf ("\\r");
108           else if( *p == '\f' )
109             log_printf ("\\f");
110           else if( *p == '\v' )
111             log_printf ("\\v");
112             else if( *p == '\b' )
113               log_printf ("\\b");
114           else if( !*p )
115             log_printf ("\\0");
116           else
117             log_printf ("\\x%02x", *p );
118         }
119       else
120         log_printf ("%c", *p);
121     }
122 }
123
124
125 void
126 _gcry_sexp_dump (const gcry_sexp_t a)
127 {
128   const byte *p;
129   int indent = 0;
130   int type;
131
132   if (!a)
133     {
134       log_printf ( "[nil]\n");
135       return;
136     }
137
138   p = a->d;
139   while ( (type = *p) != ST_STOP )
140     {
141       p++;
142       switch ( type )
143         {
144         case ST_OPEN:
145           log_printf ("%*s[open]\n", 2*indent, "");
146           indent++;
147           break;
148         case ST_CLOSE:
149           if( indent )
150             indent--;
151           log_printf ("%*s[close]\n", 2*indent, "");
152           break;
153         case ST_DATA: {
154           DATALEN n;
155           memcpy ( &n, p, sizeof n );
156           p += sizeof n;
157           log_printf ("%*s[data=\"", 2*indent, "" );
158           dump_string (p, n, '\"' );
159           log_printf ("\"]\n");
160           p += n;
161         }
162         break;
163         default:
164           log_printf ("%*s[unknown tag %d]\n", 2*indent, "", type);
165           break;
166         }
167     }
168 }
169
170 /****************
171  * Pass list through except when it is an empty list - in that case
172  * return NULL and release the passed list.
173  */
174 static gcry_sexp_t
175 normalize ( gcry_sexp_t list )
176 {
177   unsigned char *p;
178
179   if ( !list )
180     return NULL;
181   p = list->d;
182   if ( *p == ST_STOP )
183     {
184       /* this is "" */
185       sexp_release ( list );
186       return NULL;
187     }
188   if ( *p == ST_OPEN && p[1] == ST_CLOSE )
189     {
190       /* this is "()" */
191       sexp_release ( list );
192       return NULL;
193     }
194
195   return list;
196 }
197
198 /* Create a new S-expression object by reading LENGTH bytes from
199    BUFFER, assuming it is canonical encoded or autodetected encoding
200    when AUTODETECT is set to 1.  With FREEFNC not NULL, ownership of
201    the buffer is transferred to the newly created object.  FREEFNC
202    should be the freefnc used to release BUFFER; there is no guarantee
203    at which point this function is called; most likey you want to use
204    free() or gcry_free().
205
206    Passing LENGTH and AUTODETECT as 0 is allowed to indicate that
207    BUFFER points to a valid canonical encoded S-expression.  A LENGTH
208    of 0 and AUTODETECT 1 indicates that buffer points to a
209    null-terminated string.
210
211    This function returns 0 and and the pointer to the new object in
212    RETSEXP or an error code in which case RETSEXP is set to NULL.  */
213 gcry_err_code_t
214 _gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
215                   int autodetect, void (*freefnc)(void*) )
216 {
217   gcry_err_code_t errcode;
218   gcry_sexp_t se;
219
220   if (!retsexp)
221     return GPG_ERR_INV_ARG;
222   *retsexp = NULL;
223   if (autodetect < 0 || autodetect > 1 || !buffer)
224     return GPG_ERR_INV_ARG;
225
226   if (!length && !autodetect)
227     { /* What a brave caller to assume that there is really a canonical
228          encoded S-expression in buffer */
229       length = _gcry_sexp_canon_len (buffer, 0, NULL, &errcode);
230       if (!length)
231         return errcode;
232     }
233   else if (!length && autodetect)
234     { /* buffer is a string */
235       length = strlen ((char *)buffer);
236     }
237
238   errcode = do_sexp_sscan (&se, NULL, buffer, length, 0, NULL);
239   if (errcode)
240     return errcode;
241
242   *retsexp = se;
243   if (freefnc)
244     {
245       /* For now we release the buffer immediately.  As soon as we
246          have changed the internal represenation of S-expression to
247          the canoncial format - which has the advantage of faster
248          parsing - we will use this function as a closure in our
249          GCRYSEXP object and use the BUFFER directly.  */
250       freefnc (buffer);
251     }
252   return 0;
253 }
254
255 /* Same as gcry_sexp_create but don't transfer ownership */
256 gcry_err_code_t
257 _gcry_sexp_new (gcry_sexp_t *retsexp, const void *buffer, size_t length,
258                int autodetect)
259 {
260   return _gcry_sexp_create (retsexp, (void *)buffer, length, autodetect, NULL);
261 }
262
263
264 /****************
265  * Release resource of the given SEXP object.
266  */
267 void
268 _gcry_sexp_release( gcry_sexp_t sexp )
269 {
270   if (sexp)
271     {
272       if (gcry_is_secure (sexp))
273         {
274           /* Extra paranoid wiping. */
275           const byte *p = sexp->d;
276           int type;
277
278           while ( (type = *p) != ST_STOP )
279             {
280               p++;
281               switch ( type )
282                 {
283                 case ST_OPEN:
284                   break;
285                 case ST_CLOSE:
286                   break;
287                 case ST_DATA:
288                   {
289                     DATALEN n;
290                     memcpy ( &n, p, sizeof n );
291                     p += sizeof n;
292                     p += n;
293                   }
294                   break;
295                 default:
296                   break;
297                 }
298             }
299           wipememory (sexp->d, p - sexp->d);
300         }
301       gcry_free ( sexp );
302     }
303 }
304
305
306 /****************
307  * Make a pair from lists a and b, don't use a or b later on.
308  * Special behaviour:  If one is a single element list we put the
309  * element straight into the new pair.
310  */
311 gcry_sexp_t
312 _gcry_sexp_cons( const gcry_sexp_t a, const gcry_sexp_t b )
313 {
314   (void)a;
315   (void)b;
316
317   /* NYI: Implementation should be quite easy with our new data
318      representation */
319   BUG ();
320   return NULL;
321 }
322
323
324 /****************
325  * Make a list from all items in the array the end of the array is marked
326  * with a NULL.
327  */
328 gcry_sexp_t
329 _gcry_sexp_alist( const gcry_sexp_t *array )
330 {
331   (void)array;
332
333   /* NYI: Implementation should be quite easy with our new data
334      representation. */
335   BUG ();
336   return NULL;
337 }
338
339 /****************
340  * Make a list from all items, the end of list is indicated by a NULL
341  */
342 gcry_sexp_t
343 _gcry_sexp_vlist( const gcry_sexp_t a, ... )
344 {
345   (void)a;
346   /* NYI: Implementation should be quite easy with our new data
347      representation. */
348   BUG ();
349   return NULL;
350 }
351
352
353 /****************
354  * Append n to the list a
355  * Returns: a new ist (which maybe a)
356  */
357 gcry_sexp_t
358 _gcry_sexp_append( const gcry_sexp_t a, const gcry_sexp_t n )
359 {
360   (void)a;
361   (void)n;
362   /* NYI: Implementation should be quite easy with our new data
363      representation. */
364   BUG ();
365   return NULL;
366 }
367
368 gcry_sexp_t
369 _gcry_sexp_prepend( const gcry_sexp_t a, const gcry_sexp_t n )
370 {
371   (void)a;
372   (void)n;
373   /* NYI: Implementation should be quite easy with our new data
374      representation. */
375   BUG ();
376   return NULL;
377 }
378
379
380
381 /****************
382  * Locate token in a list. The token must be the car of a sublist.
383  * Returns: A new list with this sublist or NULL if not found.
384  */
385 gcry_sexp_t
386 _gcry_sexp_find_token( const gcry_sexp_t list, const char *tok, size_t toklen )
387 {
388   const byte *p;
389   DATALEN n;
390
391   if ( !list )
392     return NULL;
393
394   if ( !toklen )
395     toklen = strlen(tok);
396
397   p = list->d;
398   while ( *p != ST_STOP )
399     {
400       if ( *p == ST_OPEN && p[1] == ST_DATA )
401         {
402           const byte *head = p;
403
404           p += 2;
405           memcpy ( &n, p, sizeof n );
406           p += sizeof n;
407           if ( n == toklen && !memcmp( p, tok, toklen ) )
408             { /* found it */
409               gcry_sexp_t newlist;
410               byte *d;
411               int level = 1;
412
413               /* Look for the end of the list.  */
414               for ( p += n; level; p++ )
415                 {
416                   if ( *p == ST_DATA )
417                     {
418                         memcpy ( &n, ++p, sizeof n );
419                         p += sizeof n + n;
420                         p--; /* Compensate for later increment. */
421                     }
422                   else if ( *p == ST_OPEN )
423                     {
424                       level++;
425                     }
426                   else if ( *p == ST_CLOSE )
427                     {
428                       level--;
429                     }
430                   else if ( *p == ST_STOP )
431                     {
432                       BUG ();
433                     }
434                 }
435               n = p - head;
436
437               newlist = gcry_malloc ( sizeof *newlist + n );
438               if (!newlist)
439                 {
440                   /* No way to return an error code, so we can only
441                      return Not Found. */
442                   return NULL;
443                 }
444               d = newlist->d;
445               memcpy ( d, head, n ); d += n;
446               *d++ = ST_STOP;
447               return normalize ( newlist );
448             }
449           p += n;
450         }
451       else if ( *p == ST_DATA )
452         {
453           memcpy ( &n, ++p, sizeof n ); p += sizeof n;
454           p += n;
455         }
456       else
457         p++;
458     }
459   return NULL;
460 }
461
462 /****************
463  * Return the length of the given list
464  */
465 int
466 _gcry_sexp_length (const gcry_sexp_t list)
467 {
468   const byte *p;
469   DATALEN n;
470   int type;
471   int length = 0;
472   int level = 0;
473
474   if (!list)
475     return 0;
476
477   p = list->d;
478   while ((type=*p) != ST_STOP)
479     {
480       p++;
481       if (type == ST_DATA)
482         {
483           memcpy (&n, p, sizeof n);
484           p += sizeof n + n;
485           if (level == 1)
486             length++;
487         }
488       else if (type == ST_OPEN)
489         {
490           if (level == 1)
491             length++;
492           level++;
493         }
494       else if (type == ST_CLOSE)
495         {
496           level--;
497         }
498     }
499   return length;
500 }
501
502
503 /* Return the internal lengths offset of LIST.  That is the size of
504    the buffer from the first ST_OPEN, which is retruned at R_OFF, to
505    the corresponding ST_CLOSE inclusive.  */
506 static size_t
507 get_internal_buffer (const gcry_sexp_t list, size_t *r_off)
508 {
509   const unsigned char *p;
510   DATALEN n;
511   int type;
512   int level = 0;
513
514   *r_off = 0;
515   if (list)
516     {
517       p = list->d;
518       while ( (type=*p) != ST_STOP )
519         {
520           p++;
521           if (type == ST_DATA)
522             {
523               memcpy (&n, p, sizeof n);
524               p += sizeof n + n;
525             }
526           else if (type == ST_OPEN)
527             {
528               if (!level)
529                 *r_off = (p-1) - list->d;
530               level++;
531             }
532           else if ( type == ST_CLOSE )
533             {
534               level--;
535               if (!level)
536                 return p - list->d;
537             }
538         }
539     }
540   return 0; /* Not a proper list.  */
541 }
542
543
544
545 /* Extract the CAR of the given list.  May return NULL for bad lists
546    or memory failure.  */
547 gcry_sexp_t
548 _gcry_sexp_nth (const gcry_sexp_t list, int number)
549 {
550   const byte *p;
551   DATALEN n;
552   gcry_sexp_t newlist;
553   byte *d;
554   int level = 0;
555
556   if (!list || list->d[0] != ST_OPEN)
557     return NULL;
558   p = list->d;
559
560   while (number > 0)
561     {
562       p++;
563       if (*p == ST_DATA)
564         {
565           memcpy (&n, ++p, sizeof n);
566           p += sizeof n + n;
567           p--;
568           if (!level)
569             number--;
570         }
571       else if (*p == ST_OPEN)
572         {
573           level++;
574         }
575       else if (*p == ST_CLOSE)
576         {
577           level--;
578           if ( !level )
579             number--;
580         }
581       else if (*p == ST_STOP)
582         {
583           return NULL;
584         }
585     }
586   p++;
587
588   if (*p == ST_DATA)
589     {
590       memcpy (&n, p, sizeof n);
591       p += sizeof n;
592       newlist = gcry_malloc (sizeof *newlist + n + 1);
593       if (!newlist)
594         return NULL;
595       d = newlist->d;
596       memcpy (d, p, n);
597       d += n;
598       *d++ = ST_STOP;
599     }
600   else if (*p == ST_OPEN)
601     {
602       const byte *head = p;
603
604       level = 1;
605       do {
606         p++;
607         if (*p == ST_DATA)
608           {
609             memcpy (&n, ++p, sizeof n);
610             p += sizeof n + n;
611             p--;
612           }
613         else if (*p == ST_OPEN)
614           {
615             level++;
616           }
617         else if (*p == ST_CLOSE)
618           {
619             level--;
620           }
621         else if (*p == ST_STOP)
622           {
623             BUG ();
624           }
625       } while (level);
626       n = p + 1 - head;
627
628       newlist = gcry_malloc (sizeof *newlist + n);
629       if (!newlist)
630         return NULL;
631       d = newlist->d;
632       memcpy (d, head, n);
633       d += n;
634       *d++ = ST_STOP;
635     }
636   else
637     newlist = NULL;
638
639   return normalize (newlist);
640 }
641
642 gcry_sexp_t
643 _gcry_sexp_car (const gcry_sexp_t list)
644 {
645   return _gcry_sexp_nth (list, 0);
646 }
647
648
649 /* Helper to get data from the car.  The returned value is valid as
650    long as the list is not modified. */
651 static const char *
652 do_sexp_nth_data (const gcry_sexp_t list, int number, size_t *datalen)
653 {
654   const byte *p;
655   DATALEN n;
656   int level = 0;
657
658   *datalen = 0;
659   if ( !list )
660     return NULL;
661
662   p = list->d;
663   if ( *p == ST_OPEN )
664     p++;             /* Yep, a list. */
665   else if (number)
666     return NULL;     /* Not a list but N > 0 requested. */
667
668   /* Skip over N elements. */
669   while (number > 0)
670     {
671       if (*p == ST_DATA)
672         {
673           memcpy ( &n, ++p, sizeof n );
674           p += sizeof n + n;
675           p--;
676           if ( !level )
677             number--;
678         }
679       else if (*p == ST_OPEN)
680         {
681           level++;
682         }
683       else if (*p == ST_CLOSE)
684         {
685           level--;
686           if ( !level )
687             number--;
688         }
689       else if (*p == ST_STOP)
690         {
691           return NULL;
692         }
693       p++;
694     }
695
696   /* If this is data, return it.  */
697   if (*p == ST_DATA)
698     {
699       memcpy ( &n, ++p, sizeof n );
700       *datalen = n;
701       return (const char*)p + sizeof n;
702     }
703
704   return NULL;
705 }
706
707
708 /* Get data from the car.  The returned value is valid as long as the
709    list is not modified.  */
710 const char *
711 _gcry_sexp_nth_data (const gcry_sexp_t list, int number, size_t *datalen )
712 {
713   return do_sexp_nth_data (list, number, datalen);
714 }
715
716
717 /* Get the nth element of a list which needs to be a simple object.
718    The returned value is a malloced buffer and needs to be freed by
719    the caller.  This is basically the same as gcry_sexp_nth_data but
720    with an allocated result. */
721 void *
722 _gcry_sexp_nth_buffer (const gcry_sexp_t list, int number, size_t *rlength)
723 {
724   const char *s;
725   size_t n;
726   char *buf;
727
728   *rlength = 0;
729   s = do_sexp_nth_data (list, number, &n);
730   if (!s || !n)
731     return NULL;
732   buf = gcry_malloc (n);
733   if (!buf)
734     return NULL;
735   memcpy (buf, s, n);
736   *rlength = n;
737   return buf;
738 }
739
740
741 /* Get a string from the car.  The returned value is a malloced string
742    and needs to be freed by the caller.  */
743 char *
744 _gcry_sexp_nth_string (const gcry_sexp_t list, int number)
745 {
746   const char *s;
747   size_t n;
748   char *buf;
749
750   s = do_sexp_nth_data (list, number, &n);
751   if (!s || n < 1 || (n+1) < 1)
752     return NULL;
753   buf = gcry_malloc (n+1);
754   if (!buf)
755     return NULL;
756   memcpy (buf, s, n);
757   buf[n] = 0;
758   return buf;
759 }
760
761
762 /*
763  * Get a MPI from the car
764  */
765 gcry_mpi_t
766 _gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt)
767 {
768   size_t n;
769   gcry_mpi_t a;
770
771   if (mpifmt == GCRYMPI_FMT_OPAQUE)
772     {
773       char *p;
774
775       p = _gcry_sexp_nth_buffer (list, number, &n);
776       if (!p)
777         return NULL;
778
779       a = gcry_is_secure (list)? _gcry_mpi_snew (0) : _gcry_mpi_new (0);
780       if (a)
781         mpi_set_opaque (a, p, n*8);
782       else
783         gcry_free (p);
784     }
785   else
786     {
787       const char *s;
788
789       if (!mpifmt)
790         mpifmt = GCRYMPI_FMT_STD;
791
792       s = do_sexp_nth_data (list, number, &n);
793       if (!s)
794         return NULL;
795
796       if (_gcry_mpi_scan (&a, mpifmt, s, n, NULL))
797         return NULL;
798     }
799
800   return a;
801 }
802
803
804 /****************
805  * Get the CDR
806  */
807 gcry_sexp_t
808 _gcry_sexp_cdr(const gcry_sexp_t list)
809 {
810   const byte *p;
811   const byte *head;
812   DATALEN n;
813   gcry_sexp_t newlist;
814   byte *d;
815   int level = 0;
816   int skip = 1;
817
818   if (!list || list->d[0] != ST_OPEN)
819     return NULL;
820   p = list->d;
821
822   while (skip > 0)
823     {
824       p++;
825       if (*p == ST_DATA)
826         {
827           memcpy ( &n, ++p, sizeof n );
828           p += sizeof n + n;
829           p--;
830           if ( !level )
831             skip--;
832         }
833       else if (*p == ST_OPEN)
834         {
835           level++;
836         }
837       else if (*p == ST_CLOSE)
838         {
839           level--;
840           if ( !level )
841             skip--;
842         }
843       else if (*p == ST_STOP)
844         {
845           return NULL;
846         }
847     }
848   p++;
849
850   head = p;
851   level = 0;
852   do {
853     if (*p == ST_DATA)
854       {
855         memcpy ( &n, ++p, sizeof n );
856         p += sizeof n + n;
857         p--;
858       }
859     else if (*p == ST_OPEN)
860       {
861         level++;
862       }
863     else if (*p == ST_CLOSE)
864       {
865         level--;
866       }
867     else if (*p == ST_STOP)
868       {
869         return NULL;
870       }
871     p++;
872   } while (level);
873   n = p - head;
874
875   newlist = gcry_malloc (sizeof *newlist + n + 2);
876   if (!newlist)
877     return NULL;
878   d = newlist->d;
879   *d++ = ST_OPEN;
880   memcpy (d, head, n);
881   d += n;
882   *d++ = ST_CLOSE;
883   *d++ = ST_STOP;
884
885   return normalize (newlist);
886 }
887
888
889 gcry_sexp_t
890 _gcry_sexp_cadr ( const gcry_sexp_t list )
891 {
892   gcry_sexp_t a, b;
893
894   a = _gcry_sexp_cdr (list);
895   b = _gcry_sexp_car (a);
896   sexp_release (a);
897   return b;
898 }
899
900
901 static GPG_ERR_INLINE int
902 hextonibble (int s)
903 {
904   if (s >= '0' && s <= '9')
905     return s - '0';
906   else if (s >= 'A' && s <= 'F')
907     return 10 + s - 'A';
908   else if (s >= 'a' && s <= 'f')
909     return 10 + s - 'a';
910   else
911     return 0;
912 }
913
914
915 struct make_space_ctx
916 {
917   gcry_sexp_t sexp;
918   size_t allocated;
919   byte *pos;
920 };
921
922
923 static gpg_err_code_t
924 make_space ( struct make_space_ctx *c, size_t n )
925 {
926   size_t used = c->pos - c->sexp->d;
927
928   if ( used + n + sizeof(DATALEN) + 1 >= c->allocated )
929     {
930       gcry_sexp_t newsexp;
931       byte *newhead;
932       size_t newsize;
933
934       newsize = c->allocated + 2*(n+sizeof(DATALEN)+1);
935       if (newsize <= c->allocated)
936         return GPG_ERR_TOO_LARGE;
937       newsexp = gcry_realloc ( c->sexp, sizeof *newsexp + newsize - 1);
938       if (!newsexp)
939         return gpg_err_code_from_errno (errno);
940       c->allocated = newsize;
941       newhead = newsexp->d;
942       c->pos = newhead + used;
943       c->sexp = newsexp;
944     }
945   return 0;
946 }
947
948
949 /* Unquote STRING of LENGTH and store it into BUF.  The surrounding
950    quotes are must already be removed from STRING.  We assume that the
951    quoted string is syntacillay correct.  */
952 static size_t
953 unquote_string (const char *string, size_t length, unsigned char *buf)
954 {
955   int esc = 0;
956   const unsigned char *s = (const unsigned char*)string;
957   unsigned char *d = buf;
958   size_t n = length;
959
960   for (; n; n--, s++)
961     {
962       if (esc)
963         {
964           switch (*s)
965             {
966             case 'b':  *d++ = '\b'; break;
967             case 't':  *d++ = '\t'; break;
968             case 'v':  *d++ = '\v'; break;
969             case 'n':  *d++ = '\n'; break;
970             case 'f':  *d++ = '\f'; break;
971             case 'r':  *d++ = '\r'; break;
972             case '"':  *d++ = '\"'; break;
973             case '\'': *d++ = '\''; break;
974             case '\\': *d++ = '\\'; break;
975
976             case '\r':  /* ignore CR[,LF] */
977               if (n>1 && s[1] == '\n')
978                 {
979                   s++; n--;
980                 }
981               break;
982
983             case '\n':  /* ignore LF[,CR] */
984               if (n>1 && s[1] == '\r')
985                 {
986                   s++; n--;
987                 }
988               break;
989
990             case 'x': /* hex value */
991               if (n>2 && hexdigitp (s+1) && hexdigitp (s+2))
992                 {
993                   s++; n--;
994                   *d++ = xtoi_2 (s);
995                   s++; n--;
996                 }
997               break;
998
999             default:
1000               if (n>2 && octdigitp (s) && octdigitp (s+1) && octdigitp (s+2))
1001                 {
1002                   *d++ = (atoi_1 (s)*64) + (atoi_1 (s+1)*8) + atoi_1 (s+2);
1003                   s += 2;
1004                   n -= 2;
1005                 }
1006               break;
1007             }
1008           esc = 0;
1009         }
1010       else if( *s == '\\' )
1011         esc = 1;
1012       else
1013         *d++ = *s;
1014     }
1015
1016   return d - buf;
1017 }
1018
1019 /****************
1020  * Scan the provided buffer and return the S expression in our internal
1021  * format.  Returns a newly allocated expression.  If erroff is not NULL and
1022  * a parsing error has occurred, the offset into buffer will be returned.
1023  * If ARGFLAG is true, the function supports some printf like
1024  * expressions.
1025  *  These are:
1026  *      %m - MPI
1027  *      %s - string (no autoswitch to secure allocation)
1028  *      %d - integer stored as string (no autoswitch to secure allocation)
1029  *      %b - memory buffer; this takes _two_ arguments: an integer with the
1030  *           length of the buffer and a pointer to the buffer.
1031  *      %S - Copy an gcry_sexp_t here.  The S-expression needs to be a
1032  *           regular one, starting with a parenthesis.
1033  *           (no autoswitch to secure allocation)
1034  *  all other format elements are currently not defined and return an error.
1035  *  this includes the "%%" sequence becauce the percent sign is not an
1036  *  allowed character.
1037  * FIXME: We should find a way to store the secure-MPIs not in the string
1038  * but as reference to somewhere - this can help us to save huge amounts
1039  * of secure memory.  The problem is, that if only one element is secure, all
1040  * other elements are automagicaly copied to secure memory too, so the most
1041  * common operation gcry_sexp_cdr_mpi() will always return a secure MPI
1042  * regardless whether it is needed or not.
1043  */
1044 static gpg_err_code_t
1045 do_vsexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
1046                 const char *buffer, size_t length, int argflag,
1047                 void **arg_list, va_list arg_ptr)
1048 {
1049   gcry_err_code_t err = 0;
1050   static const char tokenchars[] =
1051     "abcdefghijklmnopqrstuvwxyz"
1052     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1053     "0123456789-./_:*+=";
1054   const char *p;
1055   size_t n;
1056   const char *digptr = NULL;
1057   const char *quoted = NULL;
1058   const char *tokenp = NULL;
1059   const char *hexfmt = NULL;
1060   const char *base64 = NULL;
1061   const char *disphint = NULL;
1062   const char *percent = NULL;
1063   int hexcount = 0;
1064   int quoted_esc = 0;
1065   int datalen = 0;
1066   size_t dummy_erroff;
1067   struct make_space_ctx c;
1068   int arg_counter = 0;
1069   int level = 0;
1070
1071   if (!erroff)
1072     erroff = &dummy_erroff;
1073
1074   /* Depending on whether ARG_LIST is non-zero or not, this macro gives
1075      us the next argument, either from the variable argument list as
1076      specified by ARG_PTR or from the argument array ARG_LIST.  */
1077 #define ARG_NEXT(storage, type)                          \
1078   do                                                     \
1079     {                                                    \
1080       if (!arg_list)                                     \
1081         storage = va_arg (arg_ptr, type);                \
1082       else                                               \
1083         storage = *((type *) (arg_list[arg_counter++])); \
1084     }                                                    \
1085   while (0)
1086
1087   /* The MAKE_SPACE macro is used before each store operation to
1088      ensure that the buffer is large enough.  It requires a global
1089      context named C and jumps out to the label LEAVE on error! It
1090      also sets ERROFF using the variables BUFFER and P.  */
1091 #define MAKE_SPACE(n)  do {                                                \
1092                             gpg_err_code_t _ms_err = make_space (&c, (n)); \
1093                             if (_ms_err)                                   \
1094                               {                                            \
1095                                 err = _ms_err;                             \
1096                                 *erroff = p - buffer;                      \
1097                                 goto leave;                                \
1098                               }                                            \
1099                        } while (0)
1100
1101   /* The STORE_LEN macro is used to store the length N at buffer P. */
1102 #define STORE_LEN(p,n) do {                                                \
1103                             DATALEN ashort = (n);                          \
1104                             memcpy ( (p), &ashort, sizeof(ashort) );       \
1105                             (p) += sizeof (ashort);                        \
1106                         } while (0)
1107
1108   /* We assume that the internal representation takes less memory than
1109      the provided one.  However, we add space for one extra datalen so
1110      that the code which does the ST_CLOSE can use MAKE_SPACE */
1111   c.allocated = length + sizeof(DATALEN);
1112   if (buffer && length && gcry_is_secure (buffer))
1113     c.sexp = gcry_malloc_secure (sizeof *c.sexp + c.allocated - 1);
1114   else
1115     c.sexp = gcry_malloc (sizeof *c.sexp + c.allocated - 1);
1116   if (!c.sexp)
1117     {
1118       err = gpg_err_code_from_errno (errno);
1119       *erroff = 0;
1120       goto leave;
1121     }
1122   c.pos = c.sexp->d;
1123
1124   for (p = buffer, n = length; n; p++, n--)
1125     {
1126       if (tokenp && !hexfmt)
1127         {
1128           if (strchr (tokenchars, *p))
1129             continue;
1130           else
1131             {
1132               datalen = p - tokenp;
1133               MAKE_SPACE (datalen);
1134               *c.pos++ = ST_DATA;
1135               STORE_LEN (c.pos, datalen);
1136               memcpy (c.pos, tokenp, datalen);
1137               c.pos += datalen;
1138               tokenp = NULL;
1139             }
1140         }
1141
1142       if (quoted)
1143         {
1144           if (quoted_esc)
1145             {
1146               switch (*p)
1147                 {
1148                 case 'b': case 't': case 'v': case 'n': case 'f':
1149                 case 'r': case '"': case '\'': case '\\':
1150                   quoted_esc = 0;
1151                   break;
1152
1153                 case '0': case '1': case '2': case '3': case '4':
1154                 case '5': case '6': case '7':
1155                   if (!((n > 2)
1156                         && (p[1] >= '0') && (p[1] <= '7')
1157                         && (p[2] >= '0') && (p[2] <= '7')))
1158                     {
1159                       *erroff = p - buffer;
1160                       /* Invalid octal value.  */
1161                       err = GPG_ERR_SEXP_BAD_QUOTATION;
1162                       goto leave;
1163                     }
1164                   p += 2;
1165                   n -= 2;
1166                   quoted_esc = 0;
1167                   break;
1168
1169                 case 'x':
1170                   if (!((n > 2) && hexdigitp (p+1) && hexdigitp (p+2)))
1171                     {
1172                       *erroff = p - buffer;
1173                       /* Invalid hex value.  */
1174                       err = GPG_ERR_SEXP_BAD_QUOTATION;
1175                       goto leave;
1176                     }
1177                   p += 2;
1178                   n -= 2;
1179                   quoted_esc = 0;
1180                   break;
1181
1182                 case '\r':
1183                   /* ignore CR[,LF] */
1184                   if (n && (p[1] == '\n'))
1185                     {
1186                       p++;
1187                       n--;
1188                     }
1189                   quoted_esc = 0;
1190                   break;
1191
1192                 case '\n':
1193                   /* ignore LF[,CR] */
1194                   if (n && (p[1] == '\r'))
1195                     {
1196                       p++;
1197                       n--;
1198                     }
1199                   quoted_esc = 0;
1200                   break;
1201
1202                 default:
1203                   *erroff = p - buffer;
1204                   /* Invalid quoted string escape.  */
1205                   err = GPG_ERR_SEXP_BAD_QUOTATION;
1206                   goto leave;
1207                 }
1208             }
1209           else if (*p == '\\')
1210             quoted_esc = 1;
1211           else if (*p == '\"')
1212             {
1213               /* Keep it easy - we know that the unquoted string will
1214                  never be larger. */
1215               unsigned char *save;
1216               size_t len;
1217
1218               quoted++; /* Skip leading quote.  */
1219               MAKE_SPACE (p - quoted);
1220               *c.pos++ = ST_DATA;
1221               save = c.pos;
1222               STORE_LEN (c.pos, 0); /* Will be fixed up later.  */
1223               len = unquote_string (quoted, p - quoted, c.pos);
1224               c.pos += len;
1225               STORE_LEN (save, len);
1226               quoted = NULL;
1227             }
1228         }
1229       else if (hexfmt)
1230         {
1231           if (isxdigit (*p))
1232             hexcount++;
1233           else if (*p == '#')
1234             {
1235               if ((hexcount & 1))
1236                 {
1237                   *erroff = p - buffer;
1238                   err = GPG_ERR_SEXP_ODD_HEX_NUMBERS;
1239                   goto leave;
1240                 }
1241
1242               datalen = hexcount / 2;
1243               MAKE_SPACE (datalen);
1244               *c.pos++ = ST_DATA;
1245               STORE_LEN (c.pos, datalen);
1246               for (hexfmt++; hexfmt < p; hexfmt++)
1247                 {
1248                   int tmpc;
1249
1250                   if (whitespacep (hexfmt))
1251                     continue;
1252                   tmpc = hextonibble (*(const unsigned char*)hexfmt);
1253                   for (hexfmt++; hexfmt < p && whitespacep (hexfmt); hexfmt++)
1254                     ;
1255                   if (hexfmt < p)
1256                     {
1257                       tmpc *= 16;
1258                       tmpc += hextonibble (*(const unsigned char*)hexfmt);
1259                     }
1260                   *c.pos++ = tmpc;
1261                 }
1262               hexfmt = NULL;
1263             }
1264           else if (!whitespacep (p))
1265             {
1266               *erroff = p - buffer;
1267               err = GPG_ERR_SEXP_BAD_HEX_CHAR;
1268               goto leave;
1269             }
1270         }
1271       else if (base64)
1272         {
1273           if (*p == '|')
1274             base64 = NULL;
1275         }
1276       else if (digptr)
1277         {
1278           if (digitp (p))
1279             ;
1280           else if (*p == ':')
1281             {
1282               datalen = atoi (digptr); /* FIXME: check for overflow.  */
1283               digptr = NULL;
1284               if (datalen > n - 1)
1285                 {
1286                   *erroff = p - buffer;
1287                   /* Buffer too short.  */
1288                   err = GPG_ERR_SEXP_STRING_TOO_LONG;
1289                   goto leave;
1290                 }
1291               /* Make a new list entry.  */
1292               MAKE_SPACE (datalen);
1293               *c.pos++ = ST_DATA;
1294               STORE_LEN (c.pos, datalen);
1295               memcpy (c.pos, p + 1, datalen);
1296               c.pos += datalen;
1297               n -= datalen;
1298               p += datalen;
1299             }
1300           else if (*p == '\"')
1301             {
1302               digptr = NULL; /* We ignore the optional length.  */
1303               quoted = p;
1304               quoted_esc = 0;
1305             }
1306           else if (*p == '#')
1307             {
1308               digptr = NULL; /* We ignore the optional length.  */
1309               hexfmt = p;
1310               hexcount = 0;
1311             }
1312           else if (*p == '|')
1313             {
1314               digptr = NULL; /* We ignore the optional length.  */
1315               base64 = p;
1316             }
1317           else
1318             {
1319               *erroff = p - buffer;
1320               err = GPG_ERR_SEXP_INV_LEN_SPEC;
1321               goto leave;
1322             }
1323         }
1324       else if (percent)
1325         {
1326           if (*p == 'm' || *p == 'M')
1327             {
1328               /* Insert an MPI.  */
1329               gcry_mpi_t m;
1330               size_t nm = 0;
1331               int mpifmt = *p == 'm'? GCRYMPI_FMT_STD: GCRYMPI_FMT_USG;
1332
1333               ARG_NEXT (m, gcry_mpi_t);
1334
1335               if (mpi_get_flag (m, GCRYMPI_FLAG_OPAQUE))
1336                 {
1337                   void *mp;
1338                   unsigned int nbits;
1339
1340                   mp = mpi_get_opaque (m, &nbits);
1341                   nm = (nbits+7)/8;
1342                   if (mp && nm)
1343                     {
1344                       MAKE_SPACE (nm);
1345                       if (!gcry_is_secure (c.sexp->d)
1346                           && mpi_get_flag (m, GCRYMPI_FLAG_SECURE))
1347                         {
1348                           /* We have to switch to secure allocation.  */
1349                           gcry_sexp_t newsexp;
1350                           byte *newhead;
1351
1352                           newsexp = gcry_malloc_secure (sizeof *newsexp
1353                                                         + c.allocated - 1);
1354                           if (!newsexp)
1355                             {
1356                               err = gpg_err_code_from_errno (errno);
1357                               goto leave;
1358                             }
1359                           newhead = newsexp->d;
1360                           memcpy (newhead, c.sexp->d, (c.pos - c.sexp->d));
1361                           c.pos = newhead + (c.pos - c.sexp->d);
1362                           gcry_free (c.sexp);
1363                           c.sexp = newsexp;
1364                         }
1365
1366                       *c.pos++ = ST_DATA;
1367                       STORE_LEN (c.pos, nm);
1368                       memcpy (c.pos, mp, nm);
1369                       c.pos += nm;
1370                     }
1371                 }
1372               else
1373                 {
1374                   if (_gcry_mpi_print (mpifmt, NULL, 0, &nm, m))
1375                     BUG ();
1376
1377                   MAKE_SPACE (nm);
1378                   if (!gcry_is_secure (c.sexp->d)
1379                       && mpi_get_flag ( m, GCRYMPI_FLAG_SECURE))
1380                     {
1381                       /* We have to switch to secure allocation.  */
1382                       gcry_sexp_t newsexp;
1383                       byte *newhead;
1384
1385                       newsexp = gcry_malloc_secure (sizeof *newsexp
1386                                                     + c.allocated - 1);
1387                       if (!newsexp)
1388                         {
1389                           err = gpg_err_code_from_errno (errno);
1390                           goto leave;
1391                         }
1392                       newhead = newsexp->d;
1393                       memcpy (newhead, c.sexp->d, (c.pos - c.sexp->d));
1394                       c.pos = newhead + (c.pos - c.sexp->d);
1395                       gcry_free (c.sexp);
1396                       c.sexp = newsexp;
1397                     }
1398
1399                   *c.pos++ = ST_DATA;
1400                   STORE_LEN (c.pos, nm);
1401                   if (_gcry_mpi_print (mpifmt, c.pos, nm, &nm, m))
1402                     BUG ();
1403                   c.pos += nm;
1404                 }
1405             }
1406           else if (*p == 's')
1407             {
1408               /* Insert an string.  */
1409               const char *astr;
1410               size_t alen;
1411
1412               ARG_NEXT (astr, const char *);
1413               alen = strlen (astr);
1414
1415               MAKE_SPACE (alen);
1416               *c.pos++ = ST_DATA;
1417               STORE_LEN (c.pos, alen);
1418               memcpy (c.pos, astr, alen);
1419               c.pos += alen;
1420             }
1421           else if (*p == 'b')
1422             {
1423               /* Insert a memory buffer.  */
1424               const char *astr;
1425               int alen;
1426
1427               ARG_NEXT (alen, int);
1428               ARG_NEXT (astr, const char *);
1429
1430               MAKE_SPACE (alen);
1431               if (alen
1432                   && !gcry_is_secure (c.sexp->d)
1433                   && gcry_is_secure (astr))
1434               {
1435                   /* We have to switch to secure allocation.  */
1436                   gcry_sexp_t newsexp;
1437                   byte *newhead;
1438
1439                   newsexp = gcry_malloc_secure (sizeof *newsexp
1440                                                 + c.allocated - 1);
1441                   if (!newsexp)
1442                     {
1443                       err = gpg_err_code_from_errno (errno);
1444                       goto leave;
1445                     }
1446                   newhead = newsexp->d;
1447                   memcpy (newhead, c.sexp->d, (c.pos - c.sexp->d));
1448                   c.pos = newhead + (c.pos - c.sexp->d);
1449                   gcry_free (c.sexp);
1450                   c.sexp = newsexp;
1451                 }
1452
1453               *c.pos++ = ST_DATA;
1454               STORE_LEN (c.pos, alen);
1455               memcpy (c.pos, astr, alen);
1456               c.pos += alen;
1457             }
1458           else if (*p == 'd')
1459             {
1460               /* Insert an integer as string.  */
1461               int aint;
1462               size_t alen;
1463               char buf[35];
1464
1465               ARG_NEXT (aint, int);
1466               sprintf (buf, "%d", aint);
1467               alen = strlen (buf);
1468               MAKE_SPACE (alen);
1469               *c.pos++ = ST_DATA;
1470               STORE_LEN (c.pos, alen);
1471               memcpy (c.pos, buf, alen);
1472               c.pos += alen;
1473             }
1474           else if (*p == 'u')
1475             {
1476               /* Insert an unsigned integer as string.  */
1477               unsigned int aint;
1478               size_t alen;
1479               char buf[35];
1480
1481               ARG_NEXT (aint, unsigned int);
1482               sprintf (buf, "%u", aint);
1483               alen = strlen (buf);
1484               MAKE_SPACE (alen);
1485               *c.pos++ = ST_DATA;
1486               STORE_LEN (c.pos, alen);
1487               memcpy (c.pos, buf, alen);
1488               c.pos += alen;
1489             }
1490           else if (*p == 'S')
1491             {
1492               /* Insert a gcry_sexp_t.  */
1493               gcry_sexp_t asexp;
1494               size_t alen, aoff;
1495
1496               ARG_NEXT (asexp, gcry_sexp_t);
1497               alen = get_internal_buffer (asexp, &aoff);
1498               if (alen)
1499                 {
1500                   MAKE_SPACE (alen);
1501                   memcpy (c.pos, asexp->d + aoff, alen);
1502                   c.pos += alen;
1503                 }
1504             }
1505           else
1506             {
1507               *erroff = p - buffer;
1508               /* Invalid format specifier.  */
1509               err = GPG_ERR_SEXP_INV_LEN_SPEC;
1510               goto leave;
1511             }
1512           percent = NULL;
1513         }
1514       else if (*p == '(')
1515         {
1516           if (disphint)
1517             {
1518               *erroff = p - buffer;
1519               /* Open display hint.  */
1520               err = GPG_ERR_SEXP_UNMATCHED_DH;
1521               goto leave;
1522             }
1523           MAKE_SPACE (0);
1524           *c.pos++ = ST_OPEN;
1525           level++;
1526         }
1527       else if (*p == ')')
1528         {
1529           /* Walk up.  */
1530           if (disphint)
1531             {
1532               *erroff = p - buffer;
1533               /* Open display hint.  */
1534               err = GPG_ERR_SEXP_UNMATCHED_DH;
1535               goto leave;
1536             }
1537           MAKE_SPACE (0);
1538           *c.pos++ = ST_CLOSE;
1539           level--;
1540         }
1541       else if (*p == '\"')
1542         {
1543           quoted = p;
1544           quoted_esc = 0;
1545         }
1546       else if (*p == '#')
1547         {
1548           hexfmt = p;
1549           hexcount = 0;
1550         }
1551       else if (*p == '|')
1552         base64 = p;
1553       else if (*p == '[')
1554         {
1555           if (disphint)
1556             {
1557               *erroff = p - buffer;
1558               /* Open display hint.  */
1559               err = GPG_ERR_SEXP_NESTED_DH;
1560               goto leave;
1561             }
1562           disphint = p;
1563         }
1564       else if (*p == ']')
1565         {
1566           if (!disphint)
1567             {
1568               *erroff = p - buffer;
1569               /* Open display hint.  */
1570               err = GPG_ERR_SEXP_UNMATCHED_DH;
1571               goto leave;
1572             }
1573           disphint = NULL;
1574         }
1575       else if (digitp (p))
1576         {
1577           if (*p == '0')
1578             {
1579               /* A length may not begin with zero.  */
1580               *erroff = p - buffer;
1581               err = GPG_ERR_SEXP_ZERO_PREFIX;
1582               goto leave;
1583             }
1584           digptr = p;
1585         }
1586       else if (strchr (tokenchars, *p))
1587         tokenp = p;
1588       else if (whitespacep (p))
1589         ;
1590       else if (*p == '{')
1591         {
1592           /* fixme: handle rescanning: we can do this by saving our
1593              current state and start over at p+1 -- Hmmm. At this
1594              point here we are in a well defined state, so we don't
1595              need to save it.  Great.  */
1596           *erroff = p - buffer;
1597           err = GPG_ERR_SEXP_UNEXPECTED_PUNC;
1598           goto leave;
1599         }
1600       else if (strchr ("&\\", *p))
1601         {
1602           /* Reserved punctuation.  */
1603           *erroff = p - buffer;
1604           err = GPG_ERR_SEXP_UNEXPECTED_PUNC;
1605           goto leave;
1606         }
1607       else if (argflag && (*p == '%'))
1608         percent = p;
1609       else
1610         {
1611           /* Bad or unavailable.  */
1612           *erroff = p - buffer;
1613           err = GPG_ERR_SEXP_BAD_CHARACTER;
1614           goto leave;
1615         }
1616     }
1617   MAKE_SPACE (0);
1618   *c.pos++ = ST_STOP;
1619
1620   if (level && !err)
1621     err = GPG_ERR_SEXP_UNMATCHED_PAREN;
1622
1623  leave:
1624   if (err)
1625     {
1626       /* Error -> deallocate.  */
1627       if (c.sexp)
1628         {
1629           /* Extra paranoid wipe on error. */
1630           if (gcry_is_secure (c.sexp))
1631             wipememory (c.sexp, sizeof (struct gcry_sexp) + c.allocated - 1);
1632           gcry_free (c.sexp);
1633         }
1634       /* This might be expected by existing code...  */
1635       *retsexp = NULL;
1636     }
1637   else
1638     *retsexp = normalize (c.sexp);
1639
1640   return err;
1641 #undef MAKE_SPACE
1642 #undef STORE_LEN
1643 }
1644
1645
1646 static gpg_err_code_t
1647 do_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
1648                const char *buffer, size_t length, int argflag,
1649                void **arg_list, ...)
1650 {
1651   gcry_err_code_t rc;
1652   va_list arg_ptr;
1653
1654   va_start (arg_ptr, arg_list);
1655   rc = do_vsexp_sscan (retsexp, erroff, buffer, length, argflag,
1656                        arg_list, arg_ptr);
1657   va_end (arg_ptr);
1658
1659   return rc;
1660 }
1661
1662
1663 gpg_err_code_t
1664 _gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff, const char *format, ...)
1665 {
1666   gcry_err_code_t rc;
1667   va_list arg_ptr;
1668
1669   va_start (arg_ptr, format);
1670   rc = do_vsexp_sscan (retsexp, erroff, format, strlen(format), 1,
1671                        NULL, arg_ptr);
1672   va_end (arg_ptr);
1673
1674   return rc;
1675 }
1676
1677
1678 gcry_err_code_t
1679 _gcry_sexp_vbuild (gcry_sexp_t *retsexp, size_t *erroff,
1680                    const char *format, va_list arg_ptr)
1681 {
1682   return do_vsexp_sscan (retsexp, erroff, format, strlen(format), 1,
1683                          NULL, arg_ptr);
1684 }
1685
1686
1687 /* Like gcry_sexp_build, but uses an array instead of variable
1688    function arguments.  */
1689 gcry_err_code_t
1690 _gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
1691                         const char *format, void **arg_list)
1692 {
1693   return do_sexp_sscan (retsexp, erroff, format, strlen(format), 1, arg_list);
1694 }
1695
1696
1697 gcry_err_code_t
1698 _gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
1699                   const char *buffer, size_t length)
1700 {
1701   return do_sexp_sscan (retsexp, erroff, buffer, length, 0, NULL);
1702 }
1703
1704 \f
1705 /* Figure out a suitable encoding for BUFFER of LENGTH.
1706    Returns: 0 = Binary
1707             1 = String possible
1708             2 = Token possible
1709 */
1710 static int
1711 suitable_encoding (const unsigned char *buffer, size_t length)
1712 {
1713   const unsigned char *s;
1714   int maybe_token = 1;
1715
1716   if (!length)
1717     return 1;
1718
1719   if (*buffer & 0x80)
1720     return 0; /* If the MSB is set we assume that buffer represents a
1721                  negative number.  */
1722   if (!*buffer)
1723     return 0; /* Starting with a zero is pretty much a binary string.  */
1724
1725   for (s=buffer; length; s++, length--)
1726     {
1727       if ( (*s < 0x20 || (*s >= 0x7f && *s <= 0xa0))
1728            && !strchr ("\b\t\v\n\f\r\"\'\\", *s))
1729         return 0; /*binary*/
1730       if ( maybe_token
1731            && !alphap (s) && !digitp (s)  && !strchr (TOKEN_SPECIALS, *s))
1732         maybe_token = 0;
1733     }
1734   s = buffer;
1735   if ( maybe_token && !digitp (s) )
1736     return 2;
1737   return 1;
1738 }
1739
1740
1741 static int
1742 convert_to_hex (const unsigned char *src, size_t len, char *dest)
1743 {
1744   int i;
1745
1746   if (dest)
1747     {
1748       *dest++ = '#';
1749       for (i=0; i < len; i++, dest += 2 )
1750         sprintf (dest, "%02X", src[i]);
1751       *dest++ = '#';
1752     }
1753   return len*2+2;
1754 }
1755
1756 static int
1757 convert_to_string (const unsigned char *s, size_t len, char *dest)
1758 {
1759   if (dest)
1760     {
1761       char *p = dest;
1762       *p++ = '\"';
1763       for (; len; len--, s++ )
1764         {
1765           switch (*s)
1766             {
1767             case '\b': *p++ = '\\'; *p++ = 'b';  break;
1768             case '\t': *p++ = '\\'; *p++ = 't';  break;
1769             case '\v': *p++ = '\\'; *p++ = 'v';  break;
1770             case '\n': *p++ = '\\'; *p++ = 'n';  break;
1771             case '\f': *p++ = '\\'; *p++ = 'f';  break;
1772             case '\r': *p++ = '\\'; *p++ = 'r';  break;
1773             case '\"': *p++ = '\\'; *p++ = '\"';  break;
1774             case '\'': *p++ = '\\'; *p++ = '\'';  break;
1775             case '\\': *p++ = '\\'; *p++ = '\\';  break;
1776             default:
1777               if ( (*s < 0x20 || (*s >= 0x7f && *s <= 0xa0)))
1778                 {
1779                   sprintf (p, "\\x%02x", *s);
1780                   p += 4;
1781                 }
1782               else
1783                 *p++ = *s;
1784             }
1785         }
1786       *p++ = '\"';
1787       return p - dest;
1788     }
1789   else
1790     {
1791       int count = 2;
1792       for (; len; len--, s++ )
1793         {
1794           switch (*s)
1795             {
1796             case '\b':
1797             case '\t':
1798             case '\v':
1799             case '\n':
1800             case '\f':
1801             case '\r':
1802             case '\"':
1803             case '\'':
1804             case '\\': count += 2; break;
1805             default:
1806               if ( (*s < 0x20 || (*s >= 0x7f && *s <= 0xa0)))
1807                 count += 4;
1808               else
1809                 count++;
1810             }
1811         }
1812       return count;
1813     }
1814 }
1815
1816
1817
1818 static int
1819 convert_to_token (const unsigned char *src, size_t len, char *dest)
1820 {
1821   if (dest)
1822     memcpy (dest, src, len);
1823   return len;
1824 }
1825
1826
1827 /****************
1828  * Print SEXP to buffer using the MODE.  Returns the length of the
1829  * SEXP in buffer or 0 if the buffer is too short (We have at least an
1830  * empty list consisting of 2 bytes).  If a buffer of NULL is provided,
1831  * the required length is returned.
1832  */
1833 size_t
1834 _gcry_sexp_sprint (const gcry_sexp_t list, int mode,
1835                    void *buffer, size_t maxlength )
1836 {
1837   static unsigned char empty[3] = { ST_OPEN, ST_CLOSE, ST_STOP };
1838   const unsigned char *s;
1839   char *d;
1840   DATALEN n;
1841   char numbuf[20];
1842   size_t len = 0;
1843   int i, indent = 0;
1844
1845   s = list? list->d : empty;
1846   d = buffer;
1847   while ( *s != ST_STOP )
1848     {
1849       switch ( *s )
1850         {
1851         case ST_OPEN:
1852           s++;
1853           if ( mode != GCRYSEXP_FMT_CANON )
1854             {
1855               if (indent)
1856                 len++;
1857               len += indent;
1858             }
1859           len++;
1860           if ( buffer )
1861             {
1862               if ( len >= maxlength )
1863                 return 0;
1864               if ( mode != GCRYSEXP_FMT_CANON )
1865                 {
1866                   if (indent)
1867                     *d++ = '\n';
1868                   for (i=0; i < indent; i++)
1869                     *d++ = ' ';
1870                 }
1871               *d++ = '(';
1872             }
1873           indent++;
1874           break;
1875         case ST_CLOSE:
1876           s++;
1877           len++;
1878           if ( buffer )
1879             {
1880               if ( len >= maxlength )
1881                 return 0;
1882               *d++ = ')';
1883             }
1884           indent--;
1885           if (*s != ST_OPEN && *s != ST_STOP && mode != GCRYSEXP_FMT_CANON)
1886             {
1887               len++;
1888               len += indent;
1889               if (buffer)
1890                 {
1891                   if (len >= maxlength)
1892                     return 0;
1893                   *d++ = '\n';
1894                   for (i=0; i < indent; i++)
1895                     *d++ = ' ';
1896                 }
1897             }
1898           break;
1899         case ST_DATA:
1900           s++;
1901           memcpy ( &n, s, sizeof n ); s += sizeof n;
1902           if (mode == GCRYSEXP_FMT_ADVANCED)
1903             {
1904               int type;
1905               size_t nn;
1906
1907               switch ( (type=suitable_encoding (s, n)))
1908                 {
1909                 case 1: nn = convert_to_string (s, n, NULL); break;
1910                 case 2: nn = convert_to_token (s, n, NULL); break;
1911                 default: nn = convert_to_hex (s, n, NULL); break;
1912                 }
1913               len += nn;
1914               if (buffer)
1915                 {
1916                   if (len >= maxlength)
1917                     return 0;
1918                   switch (type)
1919                     {
1920                     case 1: convert_to_string (s, n, d); break;
1921                     case 2: convert_to_token (s, n, d); break;
1922                     default: convert_to_hex (s, n, d); break;
1923                     }
1924                   d += nn;
1925                 }
1926               if (s[n] != ST_CLOSE)
1927                 {
1928                   len++;
1929                   if (buffer)
1930                     {
1931                       if (len >= maxlength)
1932                         return 0;
1933                       *d++ = ' ';
1934                     }
1935                 }
1936             }
1937           else
1938             {
1939               sprintf (numbuf, "%u:", (unsigned int)n );
1940               len += strlen (numbuf) + n;
1941               if ( buffer )
1942                 {
1943                   if ( len >= maxlength )
1944                     return 0;
1945                   d = stpcpy ( d, numbuf );
1946                   memcpy ( d, s, n ); d += n;
1947                 }
1948             }
1949           s += n;
1950           break;
1951         default:
1952           BUG ();
1953         }
1954     }
1955   if ( mode != GCRYSEXP_FMT_CANON )
1956     {
1957       len++;
1958       if (buffer)
1959         {
1960           if ( len >= maxlength )
1961             return 0;
1962           *d++ = '\n';
1963         }
1964     }
1965   if (buffer)
1966     {
1967       if ( len >= maxlength )
1968         return 0;
1969       *d++ = 0; /* for convenience we make a C string */
1970     }
1971   else
1972     len++; /* we need one byte more for this */
1973
1974   return len;
1975 }
1976
1977
1978 /* Scan a canonical encoded buffer with implicit length values and
1979    return the actual length this S-expression uses.  For a valid S-Exp
1980    it should never return 0.  If LENGTH is not zero, the maximum
1981    length to scan is given - this can be used for syntax checks of
1982    data passed from outside. errorcode and erroff may both be passed as
1983    NULL.  */
1984 size_t
1985 _gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
1986                       size_t *erroff, gcry_err_code_t *errcode)
1987 {
1988   const unsigned char *p;
1989   const unsigned char *disphint = NULL;
1990   unsigned int datalen = 0;
1991   size_t dummy_erroff;
1992   gcry_err_code_t dummy_errcode;
1993   size_t count = 0;
1994   int level = 0;
1995
1996   if (!erroff)
1997     erroff = &dummy_erroff;
1998   if (!errcode)
1999     errcode = &dummy_errcode;
2000
2001   *errcode = GPG_ERR_NO_ERROR;
2002   *erroff = 0;
2003   if (!buffer)
2004     return 0;
2005   if (*buffer != '(')
2006     {
2007       *errcode = GPG_ERR_SEXP_NOT_CANONICAL;
2008       return 0;
2009     }
2010
2011   for (p=buffer; ; p++, count++ )
2012     {
2013       if (length && count >= length)
2014         {
2015           *erroff = count;
2016           *errcode = GPG_ERR_SEXP_STRING_TOO_LONG;
2017           return 0;
2018         }
2019
2020       if (datalen)
2021         {
2022           if (*p == ':')
2023             {
2024               if (length && (count+datalen) >= length)
2025                 {
2026                   *erroff = count;
2027                   *errcode = GPG_ERR_SEXP_STRING_TOO_LONG;
2028                   return 0;
2029                 }
2030               count += datalen;
2031               p += datalen;
2032               datalen = 0;
2033             }
2034           else if (digitp(p))
2035             datalen = datalen*10 + atoi_1(p);
2036           else
2037             {
2038               *erroff = count;
2039               *errcode = GPG_ERR_SEXP_INV_LEN_SPEC;
2040               return 0;
2041             }
2042         }
2043       else if (*p == '(')
2044         {
2045           if (disphint)
2046             {
2047               *erroff = count;
2048               *errcode = GPG_ERR_SEXP_UNMATCHED_DH;
2049               return 0;
2050             }
2051           level++;
2052         }
2053       else if (*p == ')')
2054         { /* walk up */
2055           if (!level)
2056             {
2057               *erroff = count;
2058               *errcode = GPG_ERR_SEXP_UNMATCHED_PAREN;
2059               return 0;
2060             }
2061           if (disphint)
2062             {
2063               *erroff = count;
2064               *errcode = GPG_ERR_SEXP_UNMATCHED_DH;
2065               return 0;
2066             }
2067           if (!--level)
2068             return ++count; /* ready */
2069         }
2070       else if (*p == '[')
2071         {
2072           if (disphint)
2073             {
2074               *erroff = count;
2075               *errcode = GPG_ERR_SEXP_NESTED_DH;
2076               return 0;
2077             }
2078           disphint = p;
2079         }
2080       else if (*p == ']')
2081         {
2082           if ( !disphint )
2083             {
2084               *erroff = count;
2085               *errcode = GPG_ERR_SEXP_UNMATCHED_DH;
2086               return 0;
2087             }
2088           disphint = NULL;
2089         }
2090       else if (digitp (p) )
2091         {
2092           if (*p == '0')
2093             {
2094               *erroff = count;
2095               *errcode = GPG_ERR_SEXP_ZERO_PREFIX;
2096               return 0;
2097             }
2098           datalen = atoi_1 (p);
2099         }
2100       else if (*p == '&' || *p == '\\')
2101         {
2102           *erroff = count;
2103           *errcode = GPG_ERR_SEXP_UNEXPECTED_PUNC;
2104           return 0;
2105         }
2106       else
2107         {
2108           *erroff = count;
2109           *errcode = GPG_ERR_SEXP_BAD_CHARACTER;
2110           return 0;
2111         }
2112     }
2113 }
2114
2115
2116 /* Extract MPIs from an s-expression using a list of one letter
2117  * parameters.  The names of these parameters are given by the string
2118  * LIST.  Some special characters may be given to control the
2119  * conversion:
2120  *
2121  *    + :: Switch to unsigned integer format (default).
2122  *    - :: Switch to standard signed format.
2123  *    / :: Switch to opaque format.
2124  *    & :: Switch to buffer descriptor mode - see below.
2125  *    ? :: The previous parameter is optional.
2126  *
2127  * Unless in gcry_buffer_t mode for each parameter name a pointer to
2128  * an MPI variable is expected and finally a NULL is expected.
2129  * Example:
2130  *
2131  *   _gcry_sexp_extract_param (key, NULL, "n/x+ed",
2132  *                             &mpi_n, &mpi_x, &mpi_e, NULL)
2133  *
2134  * This stores the parameter "N" from KEY as an unsigned MPI into
2135  * MPI_N, the parameter "X" as an opaque MPI into MPI_X, and the
2136  * parameter "E" again as an unsigned MPI into MPI_E.
2137  *
2138  * If in buffer descriptor mode a pointer to gcry_buffer_t descriptor
2139  * is expected instead of a pointer to an MPI.  The caller may use two
2140  * different operation modes: If the DATA field of the provided buffer
2141  * descriptor is NULL, the function allocates a new buffer and stores
2142  * it at DATA; the other fields are set accordingly with OFF being 0.
2143  * If DATA is not NULL, the function assumes that DATA, SIZE, and OFF
2144  * describe a buffer where to but the data; on return the LEN field
2145  * receives the number of bytes copied to that buffer; if the buffer
2146  * is too small, the function immediately returns with an error code
2147  * (and LEN set to 0).
2148  *
2149  * PATH is an optional string used to locate a token.  The exclamation
2150  * mark separated tokens are used to via gcry_sexp_find_token to find
2151  * a start point inside SEXP.
2152  *
2153  * The function returns NULL on success.  On error an error code is
2154  * returned and the passed MPIs are either unchanged or set to NULL.
2155  */
2156 gpg_err_code_t
2157 _gcry_sexp_vextract_param (gcry_sexp_t sexp, const char *path,
2158                            const char *list, va_list arg_ptr)
2159 {
2160   gpg_err_code_t rc;
2161   const char *s;
2162   gcry_mpi_t *array[20];
2163   char arrayisdesc[20];
2164   int idx;
2165   gcry_sexp_t l1;
2166   int mode = '+'; /* Default to GCRYMPI_FMT_USG.  */
2167   gcry_sexp_t freethis = NULL;
2168
2169   memset (arrayisdesc, 0, sizeof arrayisdesc);
2170
2171   /* First copy all the args into an array.  This is required so that
2172      we are able to release already allocated MPIs if later an error
2173      was found.  */
2174   for (s=list, idx=0; *s && idx < DIM (array); s++)
2175     {
2176       if (*s == '&' || *s == '+' || *s == '-' || *s == '/' || *s == '?' )
2177         ;
2178       else
2179         {
2180           array[idx] = va_arg (arg_ptr, gcry_mpi_t *);
2181           if (!array[idx])
2182             return GPG_ERR_MISSING_VALUE; /* NULL pointer given.  */
2183           idx++;
2184         }
2185     }
2186   if (*s)
2187     return GPG_ERR_LIMIT_REACHED;  /* Too many list elements.  */
2188   if (va_arg (arg_ptr, gcry_mpi_t *))
2189     return GPG_ERR_INV_ARG;  /* Not enough list elemends.  */
2190
2191   /* Drill down.  */
2192   while (path && *path)
2193     {
2194       size_t n;
2195
2196       s = strchr (path, '!');
2197       if (s == path)
2198         {
2199           rc = GPG_ERR_NOT_FOUND;
2200           goto cleanup;
2201         }
2202       n = s? s - path : 0;
2203       l1 = _gcry_sexp_find_token (sexp, path, n);
2204       if (!l1)
2205         {
2206           rc = GPG_ERR_NOT_FOUND;
2207           goto cleanup;
2208         }
2209       sexp = l1; l1 = NULL;
2210       sexp_release (freethis);
2211       freethis = sexp;
2212       if (n)
2213         path += n + 1;
2214       else
2215         path = NULL;
2216     }
2217
2218
2219   /* Now extract all parameters.  */
2220   for (s=list, idx=0; *s; s++)
2221     {
2222       if (*s == '&' || *s == '+' || *s == '-' || *s == '/')
2223         mode = *s;
2224       else if (*s == '?')
2225         ; /* Only used via lookahead.  */
2226       else
2227         {
2228           l1 = _gcry_sexp_find_token (sexp, s, 1);
2229           if (!l1 && s[1] == '?')
2230             {
2231               /* Optional element not found.  */
2232               if (mode == '&')
2233                 {
2234                   gcry_buffer_t *spec = (gcry_buffer_t*)array[idx];
2235                   if (!spec->data)
2236                     {
2237                       spec->size = 0;
2238                       spec->off = 0;
2239                     }
2240                   spec->len = 0;
2241                 }
2242               else
2243                 *array[idx] = NULL;
2244             }
2245           else if (!l1)
2246             {
2247               rc = GPG_ERR_NO_OBJ;  /* List element not found.  */
2248               goto cleanup;
2249             }
2250            else
2251             {
2252               if (mode == '&')
2253                 {
2254                   gcry_buffer_t *spec = (gcry_buffer_t*)array[idx];
2255
2256                   if (spec->data)
2257                     {
2258                       const char *pbuf;
2259                       size_t nbuf;
2260
2261                       pbuf = _gcry_sexp_nth_data (l1, 1, &nbuf);
2262                       if (!pbuf || !nbuf)
2263                         {
2264                           rc = GPG_ERR_INV_OBJ;
2265                           goto cleanup;
2266                         }
2267                       if (spec->off + nbuf > spec->size)
2268                         {
2269                           rc = GPG_ERR_BUFFER_TOO_SHORT;
2270                           goto cleanup;
2271                         }
2272                       memcpy ((char*)spec->data + spec->off, pbuf, nbuf);
2273                       spec->len = nbuf;
2274                       arrayisdesc[idx] = 1;
2275                     }
2276                   else
2277                     {
2278                       spec->data = _gcry_sexp_nth_buffer (l1, 1, &spec->size);
2279                       if (!spec->data)
2280                         {
2281                           rc = GPG_ERR_INV_OBJ; /* Or out of core.  */
2282                           goto cleanup;
2283                         }
2284                       spec->len = spec->size;
2285                       spec->off = 0;
2286                       arrayisdesc[idx] = 2;
2287                     }
2288                 }
2289               else if (mode == '/')
2290                 *array[idx] = _gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_OPAQUE);
2291               else if (mode == '-')
2292                 *array[idx] = _gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_STD);
2293               else
2294                 *array[idx] = _gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
2295               sexp_release (l1); l1 = NULL;
2296               if (!*array[idx])
2297                 {
2298                   rc = GPG_ERR_INV_OBJ;  /* Conversion failed.  */
2299                   goto cleanup;
2300                 }
2301             }
2302           idx++;
2303         }
2304     }
2305
2306   sexp_release (freethis);
2307   return 0;
2308
2309  cleanup:
2310   sexp_release (freethis);
2311   sexp_release (l1);
2312   while (idx--)
2313     {
2314       if (!arrayisdesc[idx])
2315         {
2316           _gcry_mpi_release (*array[idx]);
2317           *array[idx] = NULL;
2318         }
2319       else if (!arrayisdesc[idx] == 1)
2320         {
2321           /* Caller provided buffer.  */
2322           gcry_buffer_t *spec = (gcry_buffer_t*)array[idx];
2323           spec->len = 0;
2324         }
2325       else
2326         {
2327           /* We might have allocated a buffer.  */
2328           gcry_buffer_t *spec = (gcry_buffer_t*)array[idx];
2329           gcry_free (spec->data);
2330           spec->data = NULL;
2331           spec->size = spec->off = spec->len = 0;
2332         }
2333      }
2334   return rc;
2335 }
2336
2337 gpg_error_t
2338 _gcry_sexp_extract_param (gcry_sexp_t sexp, const char *path,
2339                           const char *list, ...)
2340 {
2341   gcry_err_code_t rc;
2342   va_list arg_ptr;
2343
2344   va_start (arg_ptr, list);
2345   rc = _gcry_sexp_vextract_param (sexp, path, list, arg_ptr);
2346   va_end (arg_ptr);
2347   return gpg_error (rc);
2348 }