Line data Source code
1 : /*
2 : Authors:
3 : Pavel Březina <pbrezina@redhat.com>
4 :
5 : Copyright (C) 2014 Red Hat
6 :
7 : This program is free software; you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation; either version 3 of the License, or
10 : (at your option) any later version.
11 :
12 : This program is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with this program. If not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #include <string.h>
22 :
23 : #include "lib/sifp/sss_sifp.h"
24 : #include "lib/sifp/sss_sifp_private.h"
25 :
26 : #define GET_ATTR(attrs, name, rtype, field, out, ret) do { \
27 : sss_sifp_attr *attr = sss_sifp_find_attr(attrs, name); \
28 : \
29 : if (attr == NULL) { \
30 : ret = SSS_SIFP_ATTR_MISSING; \
31 : break; \
32 : } \
33 : \
34 : if (attr->type != rtype) { \
35 : ret = SSS_SIFP_INCORRECT_TYPE; \
36 : break; \
37 : } \
38 : \
39 : if (attr->data.field == NULL) { \
40 : ret = SSS_SIFP_ATTR_NULL; \
41 : break; \
42 : } \
43 : \
44 : out = attr->data.field[0]; \
45 : \
46 : ret = SSS_SIFP_OK; \
47 : } while (0)
48 :
49 : #define GET_ATTR_ARRAY(attrs, name, rtype, field, out_num, out_val, ret) \
50 : do { \
51 : sss_sifp_attr *attr = sss_sifp_find_attr(attrs, name); \
52 : \
53 : if (attr == NULL) { \
54 : ret = SSS_SIFP_ATTR_MISSING; \
55 : break; \
56 : } \
57 : \
58 : if (attr->type != rtype) { \
59 : ret = SSS_SIFP_INCORRECT_TYPE; \
60 : break; \
61 : } \
62 : \
63 : if (attr->data.field == NULL) { \
64 : out_num = 0; \
65 : out_val = NULL; \
66 : ret = SSS_SIFP_ATTR_NULL; \
67 : break; \
68 : } \
69 : \
70 : out_num = attr->num_values; \
71 : out_val = attr->data.field; \
72 : \
73 : ret = SSS_SIFP_OK; \
74 : } while (0)
75 :
76 41 : static sss_sifp_attr *sss_sifp_find_attr(sss_sifp_attr **attrs,
77 : const char *name)
78 : {
79 : int i;
80 :
81 41 : if (attrs == NULL || name == NULL) {
82 0 : return NULL;
83 : }
84 :
85 53 : for (i = 0; attrs[i] != NULL; i++) {
86 53 : if (strcmp(attrs[i]->name, name) == 0) {
87 41 : return attrs[i];
88 : }
89 : }
90 :
91 0 : return NULL;
92 : }
93 :
94 : sss_sifp_error
95 1 : sss_sifp_find_attr_as_bool(sss_sifp_attr **attrs,
96 : const char *name,
97 : bool *_value)
98 : {
99 : sss_sifp_error ret;
100 1 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_BOOL, boolean, *_value, ret);
101 1 : return ret;
102 : }
103 :
104 : sss_sifp_error
105 1 : sss_sifp_find_attr_as_int16(sss_sifp_attr **attrs,
106 : const char *name,
107 : int16_t *_value)
108 : {
109 : sss_sifp_error ret;
110 1 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_INT16, int16, *_value, ret);
111 1 : return ret;
112 : }
113 :
114 : sss_sifp_error
115 1 : sss_sifp_find_attr_as_uint16(sss_sifp_attr **attrs,
116 : const char *name,
117 : uint16_t *_value)
118 : {
119 : sss_sifp_error ret;
120 1 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_UINT16, uint16, *_value, ret);
121 1 : return ret;
122 : }
123 :
124 : sss_sifp_error
125 1 : sss_sifp_find_attr_as_int32(sss_sifp_attr **attrs,
126 : const char *name,
127 : int32_t *_value)
128 : {
129 : sss_sifp_error ret;
130 1 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_INT32, int32, *_value, ret);
131 1 : return ret;
132 : }
133 :
134 : sss_sifp_error
135 8 : sss_sifp_find_attr_as_uint32(sss_sifp_attr **attrs,
136 : const char *name,
137 : uint32_t *_value)
138 : {
139 : sss_sifp_error ret;
140 8 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_UINT32, uint32, *_value, ret);
141 8 : return ret;
142 : }
143 :
144 : sss_sifp_error
145 1 : sss_sifp_find_attr_as_int64(sss_sifp_attr **attrs,
146 : const char *name,
147 : int64_t *_value)
148 : {
149 : sss_sifp_error ret;
150 1 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_INT64, int64, *_value, ret);
151 1 : return ret;
152 : }
153 :
154 : sss_sifp_error
155 1 : sss_sifp_find_attr_as_uint64(sss_sifp_attr **attrs,
156 : const char *name,
157 : uint64_t *_value)
158 : {
159 : sss_sifp_error ret;
160 1 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_UINT64, uint64, *_value, ret);
161 1 : return ret;
162 : }
163 :
164 : sss_sifp_error
165 12 : sss_sifp_find_attr_as_string(sss_sifp_attr **attrs,
166 : const char *name,
167 : const char **_value)
168 : {
169 : sss_sifp_error ret;
170 12 : const char *value = NULL;
171 :
172 12 : GET_ATTR(attrs, name, SSS_SIFP_ATTR_TYPE_STRING, str, value, ret);
173 :
174 12 : if (ret == SSS_SIFP_ATTR_NULL) {
175 0 : *_value = NULL;
176 0 : return ret;
177 : }
178 :
179 12 : *_value = value;
180 12 : return ret;
181 : }
182 :
183 : sss_sifp_error
184 1 : sss_sifp_find_attr_as_string_dict(sss_sifp_attr **attrs,
185 : const char *name,
186 : hash_table_t **_value)
187 : {
188 1 : sss_sifp_attr *attr = sss_sifp_find_attr(attrs, name);
189 :
190 1 : if (attr == NULL) {
191 0 : return SSS_SIFP_ATTR_MISSING;
192 : }
193 :
194 1 : if (attr->type != SSS_SIFP_ATTR_TYPE_STRING_DICT) {
195 0 : return SSS_SIFP_INCORRECT_TYPE;
196 : }
197 :
198 1 : if (attr->data.str_dict == NULL) {
199 0 : *_value = NULL;
200 0 : return SSS_SIFP_ATTR_NULL;
201 : }
202 :
203 1 : *_value = attr->data.str_dict;
204 :
205 1 : return SSS_SIFP_OK;
206 : }
207 :
208 : /**
209 : * @brief Find attribute in list and return its values.
210 : *
211 : * @param[in] attrs Attributes
212 : * @param[in] name Name of the attribute to find
213 : *
214 : * @return Attribute values or NULL if it is not found.
215 : */
216 : sss_sifp_error
217 2 : sss_sifp_find_attr_as_bool_array(sss_sifp_attr **attrs,
218 : const char *name,
219 : unsigned int *_num_values,
220 : bool **_value)
221 : {
222 : sss_sifp_error ret;
223 2 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_BOOL, boolean,
224 : *_num_values, *_value, ret);
225 2 : return ret;
226 : }
227 :
228 : sss_sifp_error
229 0 : sss_sifp_find_attr_as_int16_array(sss_sifp_attr **attrs,
230 : const char *name,
231 : unsigned int *_num_values,
232 : int16_t **_value)
233 : {
234 : sss_sifp_error ret;
235 0 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_INT16, int16,
236 : *_num_values, *_value, ret);
237 0 : return ret;
238 : }
239 :
240 : sss_sifp_error
241 0 : sss_sifp_find_attr_as_uint16_array(sss_sifp_attr **attrs,
242 : const char *name,
243 : unsigned int *_num_values,
244 : uint16_t **_value)
245 : {
246 : sss_sifp_error ret;
247 0 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_UINT16, uint16,
248 : *_num_values, *_value, ret);
249 0 : return ret;
250 : }
251 :
252 : sss_sifp_error
253 2 : sss_sifp_find_attr_as_int32_array(sss_sifp_attr **attrs,
254 : const char *name,
255 : unsigned int *_num_values,
256 : int32_t **_value)
257 : {
258 : sss_sifp_error ret;
259 2 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_INT32, int32,
260 : *_num_values, *_value, ret);
261 2 : return ret;
262 : }
263 :
264 : sss_sifp_error
265 2 : sss_sifp_find_attr_as_uint32_array(sss_sifp_attr **attrs,
266 : const char *name,
267 : unsigned int *_num_values,
268 : uint32_t **_value)
269 : {
270 : sss_sifp_error ret;
271 2 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_UINT32, uint32,
272 : *_num_values, *_value, ret);
273 2 : return ret;
274 : }
275 :
276 : sss_sifp_error
277 2 : sss_sifp_find_attr_as_int64_array(sss_sifp_attr **attrs,
278 : const char *name,
279 : unsigned int *_num_values,
280 : int64_t **_value)
281 : {
282 : sss_sifp_error ret;
283 2 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_INT64, int64,
284 : *_num_values, *_value, ret);
285 2 : return ret;
286 : }
287 :
288 : sss_sifp_error
289 2 : sss_sifp_find_attr_as_uint64_array(sss_sifp_attr **attrs,
290 : const char *name,
291 : unsigned int *_num_values,
292 : uint64_t **_value)
293 : {
294 : sss_sifp_error ret;
295 2 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_UINT64, uint64,
296 : *_num_values, *_value, ret);
297 2 : return ret;
298 : }
299 :
300 : sss_sifp_error
301 4 : sss_sifp_find_attr_as_string_array(sss_sifp_attr **attrs,
302 : const char *name,
303 : unsigned int *_num_values,
304 : const char * const **_value)
305 : {
306 : sss_sifp_error ret;
307 : char **value;
308 :
309 4 : GET_ATTR_ARRAY(attrs, name, SSS_SIFP_ATTR_TYPE_STRING, str,
310 : *_num_values, value, ret);
311 :
312 4 : if (ret == SSS_SIFP_OK || ret == SSS_SIFP_ATTR_NULL) {
313 4 : *_value = (const char * const *)value;
314 : }
315 :
316 4 : return ret;
317 : }
|
