chiark / gitweb /
bus: parse uid/gid/pid/tid meta data from kdbus messages
[elogind.git] / src / libsystemd-bus / bus-signature.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2013 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <util.h>
23
24 #include "bus-signature.h"
25 #include "bus-type.h"
26
27 static int signature_element_length_internal(
28                 const char *s,
29                 bool allow_dict_entry,
30                 unsigned array_depth,
31                 unsigned struct_depth,
32                 size_t *l) {
33
34         int r;
35
36         assert(s);
37
38         if (bus_type_is_basic(*s) || *s == SD_BUS_TYPE_VARIANT) {
39                 *l = 1;
40                 return 0;
41         }
42
43         if (*s == SD_BUS_TYPE_ARRAY) {
44                 size_t t;
45
46                 if (array_depth >= 32)
47                         return -EINVAL;
48
49                 r = signature_element_length_internal(s + 1, true, array_depth+1, struct_depth, &t);
50                 if (r < 0)
51                         return r;
52
53                 *l = t + 1;
54                 return 0;
55         }
56
57         if (*s == SD_BUS_TYPE_STRUCT_BEGIN) {
58                 const char *p = s + 1;
59
60                 if (struct_depth >= 32)
61                         return -EINVAL;
62
63                 while (*p != SD_BUS_TYPE_STRUCT_END) {
64                         size_t t;
65
66                         r = signature_element_length_internal(p, false, array_depth, struct_depth+1, &t);
67                         if (r < 0)
68                                 return r;
69
70                         p += t;
71                 }
72
73                 *l = p - s + 1;
74                 return 0;
75         }
76
77         if (*s == SD_BUS_TYPE_DICT_ENTRY_BEGIN && allow_dict_entry) {
78                 const char *p = s + 1;
79                 unsigned n = 0;
80
81                 if (struct_depth >= 32)
82                         return -EINVAL;
83
84                 while (*p != SD_BUS_TYPE_DICT_ENTRY_END) {
85                         size_t t;
86
87                         if (n == 0 && !bus_type_is_basic(*p))
88                                 return -EINVAL;
89
90                         r = signature_element_length_internal(p, false, array_depth, struct_depth+1, &t);
91                         if (r < 0)
92                                 return r;
93
94                         p += t;
95                         n++;
96                 }
97
98                 if (n != 2)
99                         return -EINVAL;
100
101                 *l = p - s + 1;
102                 return 0;
103         }
104
105         return -EINVAL;
106 }
107
108
109 int signature_element_length(const char *s, size_t *l) {
110         return signature_element_length_internal(s, true, 0, 0, l);
111 }
112
113 bool signature_is_single(const char *s) {
114         int r;
115         size_t t;
116
117         assert(s);
118
119         r = signature_element_length(s, &t);
120         if (r < 0)
121                 return false;
122
123         return s[t] == 0;
124 }
125
126 bool signature_is_pair(const char *s) {
127         assert(s);
128
129         if (!bus_type_is_basic(*s))
130                 return false;
131
132         return signature_is_single(s + 1);
133 }
134
135 bool signature_is_valid(const char *s, bool allow_dict_entry) {
136         const char *p;
137         int r;
138
139         assert(s);
140
141         p = s;
142         while (*p) {
143                 size_t t;
144
145                 r = signature_element_length_internal(p, allow_dict_entry, 0, 0, &t);
146                 if (r < 0)
147                         return false;
148
149                 p += t;
150         }
151
152         return p - s <= 255;
153 }