Merge branch 'dbus-1.4'
[platform/upstream/dbus.git] / dbus / dbus-marshal-validate.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-marshal-validate.c Validation routines for marshaled data
3  *
4  * Copyright (C) 2005 Red Hat, Inc.
5  *
6  * Licensed under the Academic Free License version 2.1
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program 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 General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #include <config.h>
25 #include "dbus-internals.h"
26 #include "dbus-marshal-validate.h"
27 #include "dbus-marshal-recursive.h"
28 #include "dbus-marshal-basic.h"
29 #include "dbus-signature.h"
30 #include "dbus-string.h"
31
32 /**
33  * @addtogroup DBusMarshal
34  *
35  * @{
36  */
37
38 /**
39  * Verifies that the range of type_str from type_pos to type_end is a
40  * valid signature.  If this function returns #TRUE, it will be safe
41  * to iterate over the signature with a types-only #DBusTypeReader.
42  * The range passed in should NOT include the terminating
43  * nul/DBUS_TYPE_INVALID.
44  *
45  * @param type_str the string
46  * @param type_pos where the typecodes start
47  * @param len length of typecodes
48  * @returns #DBUS_VALID if valid, reason why invalid otherwise
49  */
50 DBusValidity
51 _dbus_validate_signature_with_reason (const DBusString *type_str,
52                                       int               type_pos,
53                                       int               len)
54 {
55   const unsigned char *p;
56   const unsigned char *end;
57   int last;
58   int struct_depth;
59   int array_depth;
60   int dict_entry_depth;
61   DBusValidity result;
62
63   int element_count;
64   DBusList *element_count_stack;
65
66   result = DBUS_VALID;
67   element_count_stack = NULL;
68
69   if (!_dbus_list_append (&element_count_stack, _DBUS_INT_TO_POINTER (0)))
70     {
71       result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;
72       goto out;
73     }
74
75   _dbus_assert (type_str != NULL);
76   _dbus_assert (type_pos < _DBUS_INT32_MAX - len);
77   _dbus_assert (len >= 0);
78   _dbus_assert (type_pos >= 0);
79
80   if (len > DBUS_MAXIMUM_SIGNATURE_LENGTH)
81     {
82       result = DBUS_INVALID_SIGNATURE_TOO_LONG;
83       goto out;
84     }
85
86   p = _dbus_string_get_const_data_len (type_str, type_pos, 0);
87
88   end = _dbus_string_get_const_data_len (type_str, type_pos + len, 0);
89   struct_depth = 0;
90   array_depth = 0;
91   dict_entry_depth = 0;
92   last = DBUS_TYPE_INVALID;
93
94   while (p != end)
95     {
96       switch (*p)
97         {
98         case DBUS_TYPE_BYTE:
99         case DBUS_TYPE_BOOLEAN:
100         case DBUS_TYPE_INT16:
101         case DBUS_TYPE_UINT16:
102         case DBUS_TYPE_INT32:
103         case DBUS_TYPE_UINT32:
104         case DBUS_TYPE_UNIX_FD:
105         case DBUS_TYPE_INT64:
106         case DBUS_TYPE_UINT64:
107         case DBUS_TYPE_DOUBLE:
108         case DBUS_TYPE_STRING:
109         case DBUS_TYPE_OBJECT_PATH:
110         case DBUS_TYPE_SIGNATURE:
111         case DBUS_TYPE_VARIANT:
112           break;
113
114         case DBUS_TYPE_ARRAY:
115           array_depth += 1;
116           if (array_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)
117             {
118               result = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;
119               goto out;
120             }
121           break;
122
123         case DBUS_STRUCT_BEGIN_CHAR:
124           struct_depth += 1;
125
126           if (struct_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)
127             {
128               result = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;
129               goto out;
130             }
131           
132           if (!_dbus_list_append (&element_count_stack, 
133                              _DBUS_INT_TO_POINTER (0)))
134             {
135               result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;
136               goto out;
137             }
138
139           break;
140
141         case DBUS_STRUCT_END_CHAR:
142           if (struct_depth == 0)
143             {
144               result = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;
145               goto out;
146             }
147
148           if (last == DBUS_STRUCT_BEGIN_CHAR)
149             {
150               result = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;
151               goto out;
152             }
153
154           _dbus_list_pop_last (&element_count_stack);
155
156           struct_depth -= 1;
157           break;
158
159         case DBUS_DICT_ENTRY_BEGIN_CHAR:
160           if (last != DBUS_TYPE_ARRAY)
161             {
162               result = DBUS_INVALID_DICT_ENTRY_NOT_INSIDE_ARRAY;
163               goto out;
164             }
165             
166           dict_entry_depth += 1;
167
168           if (dict_entry_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)
169             {
170               result = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION;
171               goto out;
172             }
173
174           if (!_dbus_list_append (&element_count_stack, 
175                              _DBUS_INT_TO_POINTER (0)))
176             {
177               result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;
178               goto out;
179             }
180
181           break;
182
183         case DBUS_DICT_ENTRY_END_CHAR:
184           if (dict_entry_depth == 0)
185             {
186               result = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED;
187               goto out;
188             }
189             
190           dict_entry_depth -= 1;
191
192           element_count = 
193             _DBUS_POINTER_TO_INT (_dbus_list_pop_last (&element_count_stack));
194
195           if (element_count != 2)
196             {
197               if (element_count == 0)
198                 result = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;
199               else if (element_count == 1)
200                 result = DBUS_INVALID_DICT_ENTRY_HAS_ONLY_ONE_FIELD;
201               else
202                 result = DBUS_INVALID_DICT_ENTRY_HAS_TOO_MANY_FIELDS;
203               
204               goto out;
205             }
206           break;
207           
208         case DBUS_TYPE_STRUCT:     /* doesn't appear in signatures */
209         case DBUS_TYPE_DICT_ENTRY: /* ditto */
210         default:
211           result = DBUS_INVALID_UNKNOWN_TYPECODE;
212           goto out;
213         }
214
215       if (*p != DBUS_TYPE_ARRAY && 
216           *p != DBUS_DICT_ENTRY_BEGIN_CHAR && 
217           *p != DBUS_STRUCT_BEGIN_CHAR) 
218         {
219           element_count = 
220             _DBUS_POINTER_TO_INT (_dbus_list_pop_last (&element_count_stack));
221
222           ++element_count;
223
224           if (!_dbus_list_append (&element_count_stack, 
225                              _DBUS_INT_TO_POINTER (element_count)))
226             {
227               result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;
228               goto out;
229             }
230         }
231       
232       if (array_depth > 0)
233         {
234           if (*p == DBUS_TYPE_ARRAY && p != end)
235             {
236                const char *p1;
237                p1 = p + 1;
238                if (*p1 == DBUS_STRUCT_END_CHAR ||
239                    *p1 == DBUS_DICT_ENTRY_END_CHAR)
240                  {
241                    result = DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE;
242                    goto out;
243                  }
244             }
245           else
246             {
247               array_depth = 0;
248             }
249         }
250
251       if (last == DBUS_DICT_ENTRY_BEGIN_CHAR)
252         {
253           if (!(dbus_type_is_valid (*p) && dbus_type_is_basic (*p)))
254             {
255               result = DBUS_INVALID_DICT_KEY_MUST_BE_BASIC_TYPE;
256               goto out;
257             }
258         }
259
260       last = *p;
261       ++p;
262     }
263
264
265   if (array_depth > 0)
266     {
267       result = DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE;
268       goto out;
269     }
270     
271   if (struct_depth > 0)
272     {
273        result = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;
274        goto out;
275     }
276     
277   if (dict_entry_depth > 0)
278     {
279       result =  DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED;
280       goto out;
281     }
282     
283   _dbus_assert (last != DBUS_TYPE_ARRAY);
284   _dbus_assert (last != DBUS_STRUCT_BEGIN_CHAR);
285   _dbus_assert (last != DBUS_DICT_ENTRY_BEGIN_CHAR);
286
287   result = DBUS_VALID;
288
289 out:
290   _dbus_list_clear (&element_count_stack);
291   return result;
292 }
293
294 /* note: this function is also used to validate the header's values,
295  * since the header is a valid body with a particular signature.
296  */
297 static DBusValidity
298 validate_body_helper (DBusTypeReader       *reader,
299                       int                   byte_order,
300                       dbus_bool_t           walk_reader_to_end,
301                       int                   total_depth,
302                       const unsigned char  *p,
303                       const unsigned char  *end,
304                       const unsigned char **new_p)
305 {
306   int current_type;
307
308   /* The spec allows arrays and structs to each nest 32, for total
309    * nesting of 2*32. We want to impose the same limit on "dynamic"
310    * value nesting (not visible in the signature) which is introduced
311    * by DBUS_TYPE_VARIANT.
312    */
313   if (total_depth > (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH * 2))
314     {
315       return DBUS_INVALID_NESTED_TOO_DEEPLY;
316     }
317
318   while ((current_type = _dbus_type_reader_get_current_type (reader)) != DBUS_TYPE_INVALID)
319     {
320       const unsigned char *a;
321       int alignment;
322
323 #if 0
324       _dbus_verbose ("   validating value of type %s type reader %p type_pos %d p %p end %p %d remain\n",
325                      _dbus_type_to_string (current_type), reader, reader->type_pos, p, end,
326                      (int) (end - p));
327 #endif
328
329       /* Guarantee that p has one byte to look at */
330       if (p == end)
331         return DBUS_INVALID_NOT_ENOUGH_DATA;
332
333       switch (current_type)
334         {
335         case DBUS_TYPE_BYTE:
336           ++p;
337           break;
338
339         case DBUS_TYPE_BOOLEAN:
340         case DBUS_TYPE_INT16:
341         case DBUS_TYPE_UINT16:
342         case DBUS_TYPE_INT32:
343         case DBUS_TYPE_UINT32:
344         case DBUS_TYPE_UNIX_FD:
345         case DBUS_TYPE_INT64:
346         case DBUS_TYPE_UINT64:
347         case DBUS_TYPE_DOUBLE:
348           alignment = _dbus_type_get_alignment (current_type);
349           a = _DBUS_ALIGN_ADDRESS (p, alignment);
350           if (a >= end)
351             return DBUS_INVALID_NOT_ENOUGH_DATA;
352           while (p != a)
353             {
354               if (*p != '\0')
355                 return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;
356               ++p;
357             }
358           
359           if (current_type == DBUS_TYPE_BOOLEAN)
360             {
361               dbus_uint32_t v = _dbus_unpack_uint32 (byte_order,
362                                                      p);
363               if (!(v == 0 || v == 1))
364                 return DBUS_INVALID_BOOLEAN_NOT_ZERO_OR_ONE;
365             }
366           
367           p += alignment;
368           break;
369
370         case DBUS_TYPE_ARRAY:
371         case DBUS_TYPE_STRING:
372         case DBUS_TYPE_OBJECT_PATH:
373           {
374             dbus_uint32_t claimed_len;
375
376             a = _DBUS_ALIGN_ADDRESS (p, 4);
377             if (a + 4 > end)
378               return DBUS_INVALID_NOT_ENOUGH_DATA;
379             while (p != a)
380               {
381                 if (*p != '\0')
382                   return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;
383                 ++p;
384               }
385
386             claimed_len = _dbus_unpack_uint32 (byte_order, p);
387             p += 4;
388
389             /* p may now be == end */
390             _dbus_assert (p <= end);
391
392             if (current_type == DBUS_TYPE_ARRAY)
393               {
394                 int array_elem_type = _dbus_type_reader_get_element_type (reader);
395
396                 if (!dbus_type_is_valid (array_elem_type))
397                   {
398                     return DBUS_INVALID_UNKNOWN_TYPECODE;
399                   }
400
401                 alignment = _dbus_type_get_alignment (array_elem_type);
402
403                 a = _DBUS_ALIGN_ADDRESS (p, alignment);
404
405                 /* a may now be == end */
406                 if (a > end)
407                   return DBUS_INVALID_NOT_ENOUGH_DATA;
408
409                 while (p != a)
410                   {
411                     if (*p != '\0')
412                       return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;
413                     ++p;
414                   }
415               }
416
417             if (claimed_len > (unsigned long) (end - p))
418               return DBUS_INVALID_LENGTH_OUT_OF_BOUNDS;
419
420             if (current_type == DBUS_TYPE_OBJECT_PATH)
421               {
422                 DBusString str;
423                 _dbus_string_init_const_len (&str, p, claimed_len);
424                 if (!_dbus_validate_path (&str, 0,
425                                           _dbus_string_get_length (&str)))
426                   return DBUS_INVALID_BAD_PATH;
427
428                 p += claimed_len;
429               }
430             else if (current_type == DBUS_TYPE_STRING)
431               {
432                 DBusString str;
433                 _dbus_string_init_const_len (&str, p, claimed_len);
434                 if (!_dbus_string_validate_utf8 (&str, 0,
435                                                  _dbus_string_get_length (&str)))
436                   return DBUS_INVALID_BAD_UTF8_IN_STRING;
437
438                 p += claimed_len;
439               }
440             else if (current_type == DBUS_TYPE_ARRAY && claimed_len > 0)
441               {
442                 DBusTypeReader sub;
443                 DBusValidity validity;
444                 const unsigned char *array_end;
445                 int array_elem_type;
446
447                 if (claimed_len > DBUS_MAXIMUM_ARRAY_LENGTH)
448                   return DBUS_INVALID_ARRAY_LENGTH_EXCEEDS_MAXIMUM;
449                 
450                 /* Remember that the reader is types only, so we can't
451                  * use it to iterate over elements. It stays the same
452                  * for all elements.
453                  */
454                 _dbus_type_reader_recurse (reader, &sub);
455
456                 array_end = p + claimed_len;
457
458                 array_elem_type = _dbus_type_reader_get_element_type (reader);
459
460                 /* avoid recursive call to validate_body_helper if this is an array
461                  * of fixed-size elements
462                  */ 
463                 if (dbus_type_is_fixed (array_elem_type))
464                   {
465                     /* bools need to be handled differently, because they can
466                      * have an invalid value
467                      */
468                     if (array_elem_type == DBUS_TYPE_BOOLEAN)
469                       {
470                         dbus_uint32_t v;
471                         alignment = _dbus_type_get_alignment (array_elem_type);
472
473                         while (p < array_end)
474                           {
475                             v = _dbus_unpack_uint32 (byte_order, p);
476
477                             if (!(v == 0 || v == 1))
478                               return DBUS_INVALID_BOOLEAN_NOT_ZERO_OR_ONE;
479
480                             p += alignment;
481                           }
482                       }
483
484                     else
485                       {
486                         p = array_end;
487                       }
488                   }
489
490                 else
491                   {
492                     while (p < array_end)
493                       {
494                         validity = validate_body_helper (&sub, byte_order, FALSE,
495                                                          total_depth + 1,
496                                                          p, end, &p);
497                         if (validity != DBUS_VALID)
498                           return validity;
499                       }
500                   }
501
502                 if (p != array_end)
503                   return DBUS_INVALID_ARRAY_LENGTH_INCORRECT;
504               }
505
506             /* check nul termination */
507             if (current_type != DBUS_TYPE_ARRAY)
508               {
509                 if (p == end)
510                   return DBUS_INVALID_NOT_ENOUGH_DATA;
511
512                 if (*p != '\0')
513                   return DBUS_INVALID_STRING_MISSING_NUL;
514                 ++p;
515               }
516           }
517           break;
518
519         case DBUS_TYPE_SIGNATURE:
520           {
521             dbus_uint32_t claimed_len;
522             DBusString str;
523             DBusValidity validity;
524
525             claimed_len = *p;
526             ++p;
527
528             /* 1 is for nul termination */
529             if (claimed_len + 1 > (unsigned long) (end - p))
530               return DBUS_INVALID_SIGNATURE_LENGTH_OUT_OF_BOUNDS;
531
532             _dbus_string_init_const_len (&str, p, claimed_len);
533             validity =
534               _dbus_validate_signature_with_reason (&str, 0,
535                                                     _dbus_string_get_length (&str));
536
537             if (validity != DBUS_VALID)
538               return validity;
539
540             p += claimed_len;
541
542             _dbus_assert (p < end);
543             if (*p != DBUS_TYPE_INVALID)
544               return DBUS_INVALID_SIGNATURE_MISSING_NUL;
545
546             ++p;
547
548             _dbus_verbose ("p = %p end = %p claimed_len %u\n", p, end, claimed_len);
549           }
550           break;
551
552         case DBUS_TYPE_VARIANT:
553           {
554             /* 1 byte sig len, sig typecodes, align to
555              * contained-type-boundary, values.
556              */
557
558             /* In addition to normal signature validation, we need to be sure
559              * the signature contains only a single (possibly container) type.
560              */
561             dbus_uint32_t claimed_len;
562             DBusString sig;
563             DBusTypeReader sub;
564             DBusValidity validity;
565             int contained_alignment;
566             int contained_type;
567             DBusValidity reason;
568
569             claimed_len = *p;
570             ++p;
571
572             /* + 1 for nul */
573             if (claimed_len + 1 > (unsigned long) (end - p))
574               return DBUS_INVALID_VARIANT_SIGNATURE_LENGTH_OUT_OF_BOUNDS;
575
576             _dbus_string_init_const_len (&sig, p, claimed_len);
577             reason = _dbus_validate_signature_with_reason (&sig, 0,
578                                            _dbus_string_get_length (&sig));
579             if (!(reason == DBUS_VALID))
580               {
581                 if (reason == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
582                   return reason;
583                 else 
584                   return DBUS_INVALID_VARIANT_SIGNATURE_BAD;
585               }
586
587             p += claimed_len;
588             
589             if (*p != DBUS_TYPE_INVALID)
590               return DBUS_INVALID_VARIANT_SIGNATURE_MISSING_NUL;
591             ++p;
592
593             contained_type = _dbus_first_type_in_signature (&sig, 0);
594             if (contained_type == DBUS_TYPE_INVALID)
595               return DBUS_INVALID_VARIANT_SIGNATURE_EMPTY;
596             
597             contained_alignment = _dbus_type_get_alignment (contained_type);
598             
599             a = _DBUS_ALIGN_ADDRESS (p, contained_alignment);
600             if (a > end)
601               return DBUS_INVALID_NOT_ENOUGH_DATA;
602             while (p != a)
603               {
604                 if (*p != '\0')
605                   return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;
606                 ++p;
607               }
608
609             _dbus_type_reader_init_types_only (&sub, &sig, 0);
610
611             _dbus_assert (_dbus_type_reader_get_current_type (&sub) != DBUS_TYPE_INVALID);
612
613             validity = validate_body_helper (&sub, byte_order, FALSE,
614                                              total_depth + 1,
615                                              p, end, &p);
616             if (validity != DBUS_VALID)
617               return validity;
618
619             if (_dbus_type_reader_next (&sub))
620               return DBUS_INVALID_VARIANT_SIGNATURE_SPECIFIES_MULTIPLE_VALUES;
621
622             _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_INVALID);
623           }
624           break;
625
626         case DBUS_TYPE_DICT_ENTRY:
627         case DBUS_TYPE_STRUCT:
628           {
629             DBusTypeReader sub;
630             DBusValidity validity;
631
632             a = _DBUS_ALIGN_ADDRESS (p, 8);
633             if (a > end)
634               return DBUS_INVALID_NOT_ENOUGH_DATA;
635             while (p != a)
636               {
637                 if (*p != '\0')
638                   return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;
639                 ++p;
640               }
641
642             _dbus_type_reader_recurse (reader, &sub);
643
644             validity = validate_body_helper (&sub, byte_order, TRUE,
645                                              total_depth + 1,
646                                              p, end, &p);
647             if (validity != DBUS_VALID)
648               return validity;
649           }
650           break;
651
652         default:
653           _dbus_assert_not_reached ("invalid typecode in supposedly-validated signature");
654           break;
655         }
656
657 #if 0
658       _dbus_verbose ("   validated value of type %s type reader %p type_pos %d p %p end %p %d remain\n",
659                      _dbus_type_to_string (current_type), reader, reader->type_pos, p, end,
660                      (int) (end - p));
661 #endif
662
663       if (p > end)
664         {
665           _dbus_verbose ("not enough data!!! p = %p end = %p end-p = %d\n",
666                          p, end, (int) (end - p));
667           return DBUS_INVALID_NOT_ENOUGH_DATA;
668         }
669
670       if (walk_reader_to_end)
671         _dbus_type_reader_next (reader);
672       else
673         break;
674     }
675
676   if (new_p)
677     *new_p = p;
678
679   return DBUS_VALID;
680 }
681
682 /**
683  * Verifies that the range of value_str from value_pos to value_end is
684  * a legitimate value of type expected_signature.  If this function
685  * returns #TRUE, it will be safe to iterate over the values with
686  * #DBusTypeReader. The signature is assumed to be already valid.
687  *
688  * If bytes_remaining is not #NULL, then leftover bytes will be stored
689  * there and #DBUS_VALID returned. If it is #NULL, then
690  * #DBUS_INVALID_TOO_MUCH_DATA will be returned if bytes are left
691  * over.
692  *
693  * @param expected_signature the expected types in the value_str
694  * @param expected_signature_start where in expected_signature is the signature
695  * @param byte_order the byte order
696  * @param bytes_remaining place to store leftover bytes
697  * @param value_str the string containing the body
698  * @param value_pos where the values start
699  * @param len length of values after value_pos
700  * @returns #DBUS_VALID if valid, reason why invalid otherwise
701  */
702 DBusValidity
703 _dbus_validate_body_with_reason (const DBusString *expected_signature,
704                                  int               expected_signature_start,
705                                  int               byte_order,
706                                  int              *bytes_remaining,
707                                  const DBusString *value_str,
708                                  int               value_pos,
709                                  int               len)
710 {
711   DBusTypeReader reader;
712   const unsigned char *p;
713   const unsigned char *end;
714   DBusValidity validity;
715
716   _dbus_assert (len >= 0);
717   _dbus_assert (value_pos >= 0);
718   _dbus_assert (value_pos <= _dbus_string_get_length (value_str) - len);
719
720   _dbus_verbose ("validating body from pos %d len %d sig '%s'\n",
721                  value_pos, len, _dbus_string_get_const_data_len (expected_signature,
722                                                                   expected_signature_start,
723                                                                   0));
724
725   _dbus_type_reader_init_types_only (&reader,
726                                      expected_signature, expected_signature_start);
727
728   p = _dbus_string_get_const_data_len (value_str, value_pos, len);
729   end = p + len;
730
731   validity = validate_body_helper (&reader, byte_order, TRUE, 0, p, end, &p);
732   if (validity != DBUS_VALID)
733     return validity;
734   
735   if (bytes_remaining)
736     {
737       *bytes_remaining = end - p;
738       return DBUS_VALID;
739     }
740   else if (p < end)
741     return DBUS_INVALID_TOO_MUCH_DATA;
742   else
743     {
744       _dbus_assert (p == end);
745       return DBUS_VALID;
746     }
747 }
748
749 /**
750  * Determine wether the given character is valid as the first character
751  * in a name.
752  */
753 #define VALID_INITIAL_NAME_CHARACTER(c)         \
754   ( ((c) >= 'A' && (c) <= 'Z') ||               \
755     ((c) >= 'a' && (c) <= 'z') ||               \
756     ((c) == '_') )
757
758 /**
759  * Determine wether the given character is valid as a second or later
760  * character in a name
761  */
762 #define VALID_NAME_CHARACTER(c)                 \
763   ( ((c) >= '0' && (c) <= '9') ||               \
764     ((c) >= 'A' && (c) <= 'Z') ||               \
765     ((c) >= 'a' && (c) <= 'z') ||               \
766     ((c) == '_') )
767
768 /**
769  * Checks that the given range of the string is a valid object path
770  * name in the D-Bus protocol. Part of the validation ensures that
771  * the object path contains only ASCII.
772  *
773  * @todo this is inconsistent with most of DBusString in that
774  * it allows a start,len range that extends past the string end.
775  *
776  * @todo change spec to disallow more things, such as spaces in the
777  * path name
778  *
779  * @param str the string
780  * @param start first byte index to check
781  * @param len number of bytes to check
782  * @returns #TRUE if the byte range exists and is a valid name
783  */
784 dbus_bool_t
785 _dbus_validate_path (const DBusString  *str,
786                      int                start,
787                      int                len)
788 {
789   const unsigned char *s;
790   const unsigned char *end;
791   const unsigned char *last_slash;
792
793   _dbus_assert (start >= 0);
794   _dbus_assert (len >= 0);
795   _dbus_assert (start <= _dbus_string_get_length (str));
796   
797   if (len > _dbus_string_get_length (str) - start)
798     return FALSE;
799
800   if (len == 0)
801     return FALSE;
802
803   s = _dbus_string_get_const_data (str) + start;
804   end = s + len;
805
806   if (*s != '/')
807     return FALSE;
808   last_slash = s;
809   ++s;
810
811   while (s != end)
812     {
813       if (*s == '/')
814         {
815           if ((s - last_slash) < 2)
816             return FALSE; /* no empty path components allowed */
817
818           last_slash = s;
819         }
820       else
821         {
822           if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*s)))
823             return FALSE;
824         }
825
826       ++s;
827     }
828
829   if ((end - last_slash) < 2 &&
830       len > 1)
831     return FALSE; /* trailing slash not allowed unless the string is "/" */
832
833   return TRUE;
834 }
835
836 const char *
837 _dbus_validity_to_error_message (DBusValidity validity)
838 {
839   switch (validity)
840     {
841     case DBUS_VALIDITY_UNKNOWN_OOM_ERROR:                          return "Out of memory";
842     case DBUS_INVALID_FOR_UNKNOWN_REASON:                          return "Unknown reason";
843     case DBUS_VALID_BUT_INCOMPLETE:                                return "Valid but incomplete";
844     case DBUS_VALIDITY_UNKNOWN:                                    return "Validity unknown";
845     case DBUS_VALID:                                               return "Valid";
846     case DBUS_INVALID_UNKNOWN_TYPECODE:                            return "Unknown typecode";
847     case DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE:                  return "Missing array element type";
848     case DBUS_INVALID_SIGNATURE_TOO_LONG:                          return "Signature is too long";
849     case DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION:            return "Exceeded maximum array recursion";
850     case DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION:           return "Exceeded maximum struct recursion";
851     case DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED:                return "Struct ended but not started";
852     case DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED:                return "Struct started but not ended";
853     case DBUS_INVALID_STRUCT_HAS_NO_FIELDS:                        return "Struct has no fields";
854     case DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL:                   return "Alignment padding not null";
855     case DBUS_INVALID_BOOLEAN_NOT_ZERO_OR_ONE:                     return "Boolean is not zero or one";
856     case DBUS_INVALID_NOT_ENOUGH_DATA:                             return "Not enough data";
857     case DBUS_INVALID_TOO_MUCH_DATA:                               return "Too much data";
858     case DBUS_INVALID_BAD_BYTE_ORDER:                              return "Bad byte order";
859     case DBUS_INVALID_BAD_PROTOCOL_VERSION:                        return "Bad protocol version";
860     case DBUS_INVALID_BAD_MESSAGE_TYPE:                            return "Bad message type";
861     case DBUS_INVALID_BAD_SERIAL:                                  return "Bad serial";
862     case DBUS_INVALID_INSANE_FIELDS_ARRAY_LENGTH:                  return "Insane fields array length";
863     case DBUS_INVALID_INSANE_BODY_LENGTH:                          return "Insane body length";
864     case DBUS_INVALID_MESSAGE_TOO_LONG:                            return "Message too long";
865     case DBUS_INVALID_HEADER_FIELD_CODE:                           return "Header field code";
866     case DBUS_INVALID_HEADER_FIELD_HAS_WRONG_TYPE:                 return "Header field has wrong type";
867     case DBUS_INVALID_USES_LOCAL_INTERFACE:                        return "Uses local interface";
868     case DBUS_INVALID_USES_LOCAL_PATH:                             return "Uses local path";
869     case DBUS_INVALID_HEADER_FIELD_APPEARS_TWICE:                  return "Header field appears twice";
870     case DBUS_INVALID_BAD_DESTINATION:                             return "Bad destination";
871     case DBUS_INVALID_BAD_INTERFACE:                               return "Bad interface";
872     case DBUS_INVALID_BAD_MEMBER:                                  return "Bad member";
873     case DBUS_INVALID_BAD_ERROR_NAME:                              return "Bad error name";
874     case DBUS_INVALID_BAD_SENDER:                                  return "Bad sender";
875     case DBUS_INVALID_MISSING_PATH:                                return "Missing path";
876     case DBUS_INVALID_MISSING_INTERFACE:                           return "Missing interface";
877     case DBUS_INVALID_MISSING_MEMBER:                              return "Missing member";
878     case DBUS_INVALID_MISSING_ERROR_NAME:                          return "Missing error name";
879     case DBUS_INVALID_MISSING_REPLY_SERIAL:                        return "Missing reply serial";
880     case DBUS_INVALID_LENGTH_OUT_OF_BOUNDS:                        return "Length out of bounds";
881     case DBUS_INVALID_ARRAY_LENGTH_EXCEEDS_MAXIMUM:                return "Array length exceeds maximum";
882     case DBUS_INVALID_BAD_PATH:                                    return "Bad path";
883     case DBUS_INVALID_SIGNATURE_LENGTH_OUT_OF_BOUNDS:              return "Signature length out of bounds";
884     case DBUS_INVALID_BAD_UTF8_IN_STRING:                          return "Bad utf8 in string";
885     case DBUS_INVALID_ARRAY_LENGTH_INCORRECT:                      return "Array length incorrect";
886     case DBUS_INVALID_VARIANT_SIGNATURE_LENGTH_OUT_OF_BOUNDS:      return "Variant signature length out of bounds";
887     case DBUS_INVALID_VARIANT_SIGNATURE_BAD:                       return "Variant signature bad";
888     case DBUS_INVALID_VARIANT_SIGNATURE_EMPTY:                     return "Variant signature empty";
889     case DBUS_INVALID_VARIANT_SIGNATURE_SPECIFIES_MULTIPLE_VALUES: return "Variant signature specifies multiple values";
890     case DBUS_INVALID_VARIANT_SIGNATURE_MISSING_NUL:               return "Variant signature missing nul";
891     case DBUS_INVALID_STRING_MISSING_NUL:                          return "String missing nul";
892     case DBUS_INVALID_SIGNATURE_MISSING_NUL:                       return "Signature missing nul";
893     case DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION:       return "Exceeded maximum dict entry recursion";
894     case DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED:            return "Dict entry ended but not started";
895     case DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED:            return "Dict entry started but not ended";
896     case DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS:                    return "Dict entry has no fields";
897     case DBUS_INVALID_DICT_ENTRY_HAS_ONLY_ONE_FIELD:               return "Dict entry has only one field";
898     case DBUS_INVALID_DICT_ENTRY_HAS_TOO_MANY_FIELDS:              return "Dict entry has too many fields";
899     case DBUS_INVALID_DICT_ENTRY_NOT_INSIDE_ARRAY:                 return "Dict entry not inside array";
900     case DBUS_INVALID_DICT_KEY_MUST_BE_BASIC_TYPE:                 return "Dict key must be basic type";
901     case DBUS_INVALID_NESTED_TOO_DEEPLY:                           return "Variants cannot be used to create a hugely recursive tree of values";
902     default:
903       return "Invalid";
904     }
905 }
906
907 /**
908  * Checks that the given range of the string is a valid interface name
909  * in the D-Bus protocol. This includes a length restriction and an
910  * ASCII subset, see the specification.
911  *
912  * @todo this is inconsistent with most of DBusString in that
913  * it allows a start,len range that extends past the string end.
914  *
915  * @param str the string
916  * @param start first byte index to check
917  * @param len number of bytes to check
918  * @returns #TRUE if the byte range exists and is a valid name
919  */
920 dbus_bool_t
921 _dbus_validate_interface (const DBusString  *str,
922                           int                start,
923                           int                len)
924 {
925   const unsigned char *s;
926   const unsigned char *end;
927   const unsigned char *iface;
928   const unsigned char *last_dot;
929
930   _dbus_assert (start >= 0);
931   _dbus_assert (len >= 0);
932   _dbus_assert (start <= _dbus_string_get_length (str));
933
934   if (len > _dbus_string_get_length (str) - start)
935     return FALSE;
936
937   if (len > DBUS_MAXIMUM_NAME_LENGTH)
938     return FALSE;
939
940   if (len == 0)
941     return FALSE;
942
943   last_dot = NULL;
944   iface = _dbus_string_get_const_data (str) + start;
945   end = iface + len;
946   s = iface;
947
948   /* check special cases of first char so it doesn't have to be done
949    * in the loop. Note we know len > 0
950    */
951   if (_DBUS_UNLIKELY (*s == '.')) /* disallow starting with a . */
952     return FALSE;
953   else if (_DBUS_UNLIKELY (!VALID_INITIAL_NAME_CHARACTER (*s)))
954     return FALSE;
955   else
956     ++s;
957
958   while (s != end)
959     {
960       if (*s == '.')
961         {
962           if (_DBUS_UNLIKELY ((s + 1) == end))
963             return FALSE;
964           else if (_DBUS_UNLIKELY (!VALID_INITIAL_NAME_CHARACTER (*(s + 1))))
965             return FALSE;
966           last_dot = s;
967           ++s; /* we just validated the next char, so skip two */
968         }
969       else if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*s)))
970         {
971           return FALSE;
972         }
973
974       ++s;
975     }
976
977   if (_DBUS_UNLIKELY (last_dot == NULL))
978     return FALSE;
979
980   return TRUE;
981 }
982
983 /**
984  * Checks that the given range of the string is a valid member name
985  * in the D-Bus protocol. This includes a length restriction, etc.,
986  * see the specification.
987  *
988  * @todo this is inconsistent with most of DBusString in that
989  * it allows a start,len range that extends past the string end.
990  *
991  * @param str the string
992  * @param start first byte index to check
993  * @param len number of bytes to check
994  * @returns #TRUE if the byte range exists and is a valid name
995  */
996 dbus_bool_t
997 _dbus_validate_member (const DBusString  *str,
998                        int                start,
999                        int                len)
1000 {
1001   const unsigned char *s;
1002   const unsigned char *end;
1003   const unsigned char *member;
1004
1005   _dbus_assert (start >= 0);
1006   _dbus_assert (len >= 0);
1007   _dbus_assert (start <= _dbus_string_get_length (str));
1008
1009   if (len > _dbus_string_get_length (str) - start)
1010     return FALSE;
1011
1012   if (len > DBUS_MAXIMUM_NAME_LENGTH)
1013     return FALSE;
1014
1015   if (len == 0)
1016     return FALSE;
1017
1018   member = _dbus_string_get_const_data (str) + start;
1019   end = member + len;
1020   s = member;
1021
1022   /* check special cases of first char so it doesn't have to be done
1023    * in the loop. Note we know len > 0
1024    */
1025
1026   if (_DBUS_UNLIKELY (!VALID_INITIAL_NAME_CHARACTER (*s)))
1027     return FALSE;
1028   else
1029     ++s;
1030
1031   while (s != end)
1032     {
1033       if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*s)))
1034         {
1035           return FALSE;
1036         }
1037
1038       ++s;
1039     }
1040
1041   return TRUE;
1042 }
1043
1044 /**
1045  * Checks that the given range of the string is a valid error name
1046  * in the D-Bus protocol. This includes a length restriction, etc.,
1047  * see the specification.
1048  *
1049  * @todo this is inconsistent with most of DBusString in that
1050  * it allows a start,len range that extends past the string end.
1051  *
1052  * @param str the string
1053  * @param start first byte index to check
1054  * @param len number of bytes to check
1055  * @returns #TRUE if the byte range exists and is a valid name
1056  */
1057 dbus_bool_t
1058 _dbus_validate_error_name (const DBusString  *str,
1059                            int                start,
1060                            int                len)
1061 {
1062   /* Same restrictions as interface name at the moment */
1063   return _dbus_validate_interface (str, start, len);
1064 }
1065
1066 /**
1067  * Determine wether the given character is valid as the first character
1068  * in a bus name.
1069  */
1070 #define VALID_INITIAL_BUS_NAME_CHARACTER(c)         \
1071   ( ((c) >= 'A' && (c) <= 'Z') ||               \
1072     ((c) >= 'a' && (c) <= 'z') ||               \
1073     ((c) == '_') || ((c) == '-'))
1074
1075 /**
1076  * Determine wether the given character is valid as a second or later
1077  * character in a bus name
1078  */
1079 #define VALID_BUS_NAME_CHARACTER(c)                 \
1080   ( ((c) >= '0' && (c) <= '9') ||               \
1081     ((c) >= 'A' && (c) <= 'Z') ||               \
1082     ((c) >= 'a' && (c) <= 'z') ||               \
1083     ((c) == '_') || ((c) == '-'))
1084
1085 static dbus_bool_t
1086 _dbus_validate_bus_name_full (const DBusString  *str,
1087                               int                start,
1088                               int                len,
1089                               dbus_bool_t        is_namespace)
1090 {
1091   const unsigned char *s;
1092   const unsigned char *end;
1093   const unsigned char *iface;
1094   const unsigned char *last_dot;
1095
1096   _dbus_assert (start >= 0);
1097   _dbus_assert (len >= 0);
1098   _dbus_assert (start <= _dbus_string_get_length (str));
1099
1100   if (len > _dbus_string_get_length (str) - start)
1101     return FALSE;
1102
1103   if (len > DBUS_MAXIMUM_NAME_LENGTH)
1104     return FALSE;
1105
1106   if (len == 0)
1107     return FALSE;
1108
1109   last_dot = NULL;
1110   iface = _dbus_string_get_const_data (str) + start;
1111   end = iface + len;
1112   s = iface;
1113
1114   /* check special cases of first char so it doesn't have to be done
1115    * in the loop. Note we know len > 0
1116    */
1117   if (*s == ':')
1118   {
1119     /* unique name */
1120     ++s;
1121     while (s != end)
1122       {
1123         if (*s == '.')
1124           {
1125             if (_DBUS_UNLIKELY ((s + 1) == end))
1126               return FALSE;
1127             if (_DBUS_UNLIKELY (!VALID_BUS_NAME_CHARACTER (*(s + 1))))
1128               return FALSE;
1129             ++s; /* we just validated the next char, so skip two */
1130           }
1131         else if (_DBUS_UNLIKELY (!VALID_BUS_NAME_CHARACTER (*s)))
1132           {
1133             return FALSE;
1134           }
1135
1136         ++s;
1137       }
1138
1139     return TRUE;
1140   }
1141   else if (_DBUS_UNLIKELY (*s == '.')) /* disallow starting with a . */
1142     return FALSE;
1143   else if (_DBUS_UNLIKELY (!VALID_INITIAL_BUS_NAME_CHARACTER (*s)))
1144     return FALSE;
1145   else
1146     ++s;
1147
1148   while (s != end)
1149     {
1150       if (*s == '.')
1151         {
1152           if (_DBUS_UNLIKELY ((s + 1) == end))
1153             return FALSE;
1154           else if (_DBUS_UNLIKELY (!VALID_INITIAL_BUS_NAME_CHARACTER (*(s + 1))))
1155             return FALSE;
1156           last_dot = s;
1157           ++s; /* we just validated the next char, so skip two */
1158         }
1159       else if (_DBUS_UNLIKELY (!VALID_BUS_NAME_CHARACTER (*s)))
1160         {
1161           return FALSE;
1162         }
1163
1164       ++s;
1165     }
1166
1167   if (!is_namespace && _DBUS_UNLIKELY (last_dot == NULL))
1168     return FALSE;
1169
1170   return TRUE;
1171 }
1172
1173 /**
1174  * Checks that the given range of the string is a valid bus name in
1175  * the D-Bus protocol. This includes a length restriction, etc., see
1176  * the specification.
1177  *
1178  * @todo this is inconsistent with most of DBusString in that
1179  * it allows a start,len range that extends past the string end.
1180  *
1181  * @param str the string
1182  * @param start first byte index to check
1183  * @param len number of bytes to check
1184  * @returns #TRUE if the byte range exists and is a valid name
1185  */
1186 dbus_bool_t
1187 _dbus_validate_bus_name (const DBusString  *str,
1188                          int                start,
1189                          int                len)
1190 {
1191   return _dbus_validate_bus_name_full (str, start, len, FALSE);
1192 }
1193
1194 /**
1195  * Checks that the given range of the string is a prefix of a valid bus name in
1196  * the D-Bus protocol. Unlike _dbus_validate_bus_name(), this accepts strings
1197  * with only one period-separated component.
1198  *
1199  * @todo this is inconsistent with most of DBusString in that
1200  * it allows a start,len range that extends past the string end.
1201  *
1202  * @param str the string
1203  * @param start first byte index to check
1204  * @param len number of bytes to check
1205  * @returns #TRUE if the byte range exists and is a valid name
1206  */
1207 dbus_bool_t
1208 _dbus_validate_bus_namespace (const DBusString  *str,
1209                               int                start,
1210                               int                len)
1211 {
1212   return _dbus_validate_bus_name_full (str, start, len, TRUE);
1213 }
1214
1215 /**
1216  * Checks that the given range of the string is a valid message type
1217  * signature in the D-Bus protocol.
1218  *
1219  * @todo this is inconsistent with most of DBusString in that
1220  * it allows a start,len range that extends past the string end.
1221  *
1222  * @param str the string
1223  * @param start first byte index to check
1224  * @param len number of bytes to check
1225  * @returns #TRUE if the byte range exists and is a valid signature
1226  */
1227 dbus_bool_t
1228 _dbus_validate_signature (const DBusString  *str,
1229                           int                start,
1230                           int                len)
1231 {
1232   _dbus_assert (start >= 0);
1233   _dbus_assert (start <= _dbus_string_get_length (str));
1234   _dbus_assert (len >= 0);
1235
1236   if (len > _dbus_string_get_length (str) - start)
1237     return FALSE;
1238
1239   return _dbus_validate_signature_with_reason (str, start, len) == DBUS_VALID;
1240 }
1241
1242 /** define _dbus_check_is_valid_path() */
1243 DEFINE_DBUS_NAME_CHECK(path)
1244 /** define _dbus_check_is_valid_interface() */
1245 DEFINE_DBUS_NAME_CHECK(interface)
1246 /** define _dbus_check_is_valid_member() */
1247 DEFINE_DBUS_NAME_CHECK(member)
1248 /** define _dbus_check_is_valid_error_name() */
1249 DEFINE_DBUS_NAME_CHECK(error_name)
1250 /** define _dbus_check_is_valid_bus_name() */
1251 DEFINE_DBUS_NAME_CHECK(bus_name)
1252 /** define _dbus_check_is_valid_signature() */
1253 DEFINE_DBUS_NAME_CHECK(signature)
1254 /** define _dbus_check_is_valid_utf8() */
1255 DEFINE_DBUS_NAME_CHECK(utf8)
1256
1257 /** @} */
1258
1259 /* tests in dbus-marshal-validate-util.c */