Branch data Line data Source code
1 : : /*
2 : : SSSD
3 : :
4 : : ID-mapping library - conversion utilities
5 : :
6 : : Authors:
7 : : Sumit Bose <sbose@redhat.com>
8 : :
9 : : Copyright (C) 2012 Red Hat
10 : :
11 : : This program is free software; you can redistribute it and/or modify
12 : : it under the terms of the GNU General Public License as published by
13 : : the Free Software Foundation; either version 3 of the License, or
14 : : (at your option) any later version.
15 : :
16 : : This program is distributed in the hope that it will be useful,
17 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : GNU General Public License for more details.
20 : :
21 : : You should have received a copy of the GNU General Public License
22 : : along with this program. If not, see <http://www.gnu.org/licenses/>.
23 : : */
24 : :
25 : : #include <string.h>
26 : : #include <stdio.h>
27 : : #include <errno.h>
28 : : #include <ctype.h>
29 : :
30 : : #include "lib/idmap/sss_idmap.h"
31 : : #include "lib/idmap/sss_idmap_private.h"
32 : : #include "util/util.h"
33 : :
34 : : #define SID_ID_AUTHS 6
35 : : #define SID_SUB_AUTHS 15
36 : : struct sss_dom_sid {
37 : : uint8_t sid_rev_num;
38 : : int8_t num_auths; /* [range(0,15)] */
39 : : uint8_t id_auth[SID_ID_AUTHS]; /* highest order byte has index 0 */
40 : : uint32_t sub_auths[SID_SUB_AUTHS]; /* host byte-order */
41 : : };
42 : :
43 : 5 : enum idmap_error_code sss_idmap_bin_sid_to_dom_sid(struct sss_idmap_ctx *ctx,
44 : : const uint8_t *bin_sid,
45 : : size_t length,
46 : : struct sss_dom_sid **_dom_sid)
47 : : {
48 : : enum idmap_error_code err;
49 : : struct sss_dom_sid *dom_sid;
50 : 5 : size_t i = 0;
51 : 5 : size_t p = 0;
52 : : uint32_t val;
53 : :
54 [ + - ][ + - ]: 5 : CHECK_IDMAP_CTX(ctx, IDMAP_CONTEXT_INVALID);
[ + - ]
55 : :
56 [ + - ]: 5 : if (length > sizeof(struct sss_dom_sid)) return IDMAP_SID_INVALID;
57 : :
58 : 5 : dom_sid = ctx->alloc_func(sizeof(struct sss_dom_sid), ctx->alloc_pvt);
59 [ + - ]: 5 : if (dom_sid == NULL) {
60 : : return IDMAP_OUT_OF_MEMORY;
61 : : }
62 : 5 : memset(dom_sid, 0, sizeof(struct sss_dom_sid));
63 : :
64 : : /* Safely copy in the SID revision number */
65 : 5 : dom_sid->sid_rev_num = (uint8_t) *(bin_sid + p);
66 : 5 : p++;
67 : :
68 : : /* Safely copy in the number of sub auth values */
69 : 5 : dom_sid->num_auths = (uint8_t) *(bin_sid + p);
70 : 5 : p++;
71 : :
72 : : /* Make sure we aren't being told to read more bin_sid
73 : : * than can fit in the structure
74 : : */
75 [ + - ]: 5 : if (dom_sid->num_auths > SID_SUB_AUTHS) {
76 : : err = IDMAP_SID_INVALID;
77 : : goto done;
78 : : }
79 : :
80 : : /* Safely copy in the id_auth values */
81 [ + + ]: 35 : for (i = 0; i < SID_ID_AUTHS; i++) {
82 : 30 : dom_sid->id_auth[i] = (uint8_t) *(bin_sid + p);
83 : 30 : p++;
84 : : }
85 : :
86 : : /* Safely copy in the sub_auths values */
87 [ + + ]: 30 : for (i = 0; i < dom_sid->num_auths; i++) {
88 : : /* SID sub auth values in Active Directory are stored little-endian,
89 : : * we store them in host order */
90 : 25 : SAFEALIGN_COPY_UINT32(&val, bin_sid + p, &p);
91 : 25 : dom_sid->sub_auths[i] = le32toh(val);
92 : : }
93 : :
94 : 5 : *_dom_sid = dom_sid;
95 : 5 : err = IDMAP_SUCCESS;
96 : :
97 : : done:
98 [ - + ]: 5 : if (err != IDMAP_SUCCESS) {
99 : 5 : ctx->free_func(dom_sid, ctx->alloc_pvt);
100 : : }
101 : : return err;
102 : : }
103 : :
104 : 5 : enum idmap_error_code sss_idmap_dom_sid_to_bin_sid(struct sss_idmap_ctx *ctx,
105 : : struct sss_dom_sid *dom_sid,
106 : : uint8_t **_bin_sid,
107 : : size_t *_length)
108 : : {
109 : : enum idmap_error_code err;
110 : : uint8_t *bin_sid;
111 : : size_t length;
112 : 5 : size_t i = 0;
113 : 5 : size_t p = 0;
114 : : uint32_t val;
115 : :
116 [ + - ][ + - ]: 5 : CHECK_IDMAP_CTX(ctx, IDMAP_CONTEXT_INVALID);
[ + - ]
117 : :
118 [ + - ]: 5 : if (dom_sid->num_auths > SID_SUB_AUTHS) {
119 : : return IDMAP_SID_INVALID;
120 : : }
121 : :
122 : 5 : length = 2 + SID_ID_AUTHS + dom_sid->num_auths * 4;
123 : :
124 : 5 : bin_sid = ctx->alloc_func(length, ctx->alloc_pvt);
125 [ + - ]: 5 : if (bin_sid == NULL) {
126 : : return IDMAP_OUT_OF_MEMORY;
127 : : }
128 : :
129 : 5 : bin_sid[p] = dom_sid->sid_rev_num;
130 : 5 : p++;
131 : :
132 : 5 : bin_sid[p] = dom_sid->num_auths;
133 : 5 : p++;
134 : :
135 [ + + ]: 35 : for (i = 0; i < SID_ID_AUTHS; i++) {
136 : 30 : bin_sid[p] = dom_sid->id_auth[i];
137 : 30 : p++;
138 : : }
139 : :
140 [ + + ]: 30 : for (i = 0; i < dom_sid->num_auths; i++) {
141 [ + - ]: 25 : if (p + sizeof(uint32_t) > length) {
142 : : err = IDMAP_SID_INVALID;
143 : : goto done;
144 : : }
145 : 25 : val = htole32(dom_sid->sub_auths[i]);
146 : 25 : SAFEALIGN_COPY_UINT32(bin_sid + p, &val, &p);
147 : : }
148 : :
149 : 5 : *_bin_sid = bin_sid;
150 : 5 : *_length = length;
151 : :
152 : 5 : err = IDMAP_SUCCESS;
153 : : done:
154 [ - + ]: 5 : if (err != IDMAP_SUCCESS) {
155 : 5 : ctx->free_func(bin_sid, ctx->alloc_pvt);
156 : : }
157 : : return err;
158 : : }
159 : :
160 : 8 : enum idmap_error_code sss_idmap_dom_sid_to_sid(struct sss_idmap_ctx *ctx,
161 : : struct sss_dom_sid *dom_sid,
162 : : char **_sid)
163 : : {
164 : : enum idmap_error_code err;
165 : : char *sid_buf;
166 : : size_t sid_buf_len;
167 : : char *p;
168 : : int nc;
169 : : int8_t i;
170 : 8 : uint32_t id_auth_val = 0;
171 : :
172 [ + - ]: 8 : if (dom_sid->num_auths > SID_SUB_AUTHS) {
173 : : return IDMAP_SID_INVALID;
174 : : }
175 : :
176 : 8 : sid_buf_len = 25 + dom_sid->num_auths * 11;
177 : 8 : sid_buf = ctx->alloc_func(sid_buf_len, ctx->alloc_pvt);
178 [ + - ]: 8 : if (sid_buf == NULL) {
179 : : return IDMAP_OUT_OF_MEMORY;
180 : : }
181 : 8 : memset(sid_buf, 0, sid_buf_len);
182 : :
183 : : /* Only 32bits are used for the string representation */
184 : 24 : id_auth_val = (dom_sid->id_auth[2] << 24) +
185 : 16 : (dom_sid->id_auth[3] << 16) +
186 : 16 : (dom_sid->id_auth[4] << 8) +
187 : 8 : (dom_sid->id_auth[5]);
188 : :
189 : 8 : nc = snprintf(sid_buf, sid_buf_len, "S-%u-%lu", dom_sid->sid_rev_num,
190 : : (unsigned long) id_auth_val);
191 [ + - ][ + - ]: 8 : if (nc < 0 || nc >= sid_buf_len) {
192 : : err = IDMAP_SID_INVALID;
193 : : goto done;
194 : : }
195 : :
196 : :
197 : : /* Loop through the sub-auths, if any, prepending a hyphen
198 : : * for each one.
199 : : */
200 : : p = sid_buf;
201 [ + + ]: 48 : for (i = 0; i < dom_sid->num_auths ; i++) {
202 : 40 : p += nc;
203 : 40 : sid_buf_len -= nc;
204 : :
205 : 40 : nc = snprintf(p, sid_buf_len, "-%lu",
206 : 40 : (unsigned long) dom_sid->sub_auths[i]);
207 [ + - ][ + - ]: 40 : if (nc < 0 || nc >= sid_buf_len) {
208 : : err = IDMAP_SID_INVALID;
209 : : goto done;
210 : : }
211 : : }
212 : :
213 : 8 : *_sid = sid_buf;
214 : 8 : err = IDMAP_SUCCESS;
215 : :
216 : : done:
217 [ - + ]: 8 : if (err != IDMAP_SUCCESS) {
218 : 0 : ctx->free_func(sid_buf, ctx->alloc_pvt);
219 : : }
220 : :
221 : 8 : return err;
222 : : }
223 : :
224 : 9 : enum idmap_error_code sss_idmap_sid_to_dom_sid(struct sss_idmap_ctx *ctx,
225 : : const char *sid,
226 : : struct sss_dom_sid **_dom_sid)
227 : : {
228 : : enum idmap_error_code err;
229 : : unsigned long ul;
230 : : char *r;
231 : : char *end;
232 : : struct sss_dom_sid *dom_sid;
233 : :
234 [ + - ][ + - ]: 9 : CHECK_IDMAP_CTX(ctx, IDMAP_CONTEXT_INVALID);
[ + - ]
235 : :
236 [ + - ][ + - ]: 9 : if (sid == NULL || (sid[0] != 'S' && sid[0] != 's') || sid[1] != '-') {
[ + - ]
237 : : return IDMAP_SID_INVALID;
238 : : }
239 : :
240 : 9 : dom_sid = ctx->alloc_func(sizeof(struct sss_dom_sid), ctx->alloc_pvt);
241 [ + - ]: 9 : if (dom_sid == NULL) {
242 : : return IDMAP_OUT_OF_MEMORY;
243 : : }
244 : 9 : memset(dom_sid, 0, sizeof(struct sss_dom_sid));
245 : :
246 : :
247 [ + - ]: 9 : if (!isdigit(sid[2])) {
248 : : err = IDMAP_SID_INVALID;
249 : : goto done;
250 : : }
251 : 9 : errno = 0;
252 : 9 : ul = strtoul(sid + 2, &r, 10);
253 [ + - ][ + - ]: 9 : if (errno != 0 || r == NULL || *r != '-' || ul > UINT8_MAX) {
[ + - ][ + - ]
254 : : err = IDMAP_SID_INVALID;
255 : : goto done;
256 : : }
257 : 9 : dom_sid->sid_rev_num = (uint8_t) ul;
258 : 9 : r++;
259 : :
260 [ + - ]: 9 : if (!isdigit(*r)) {
261 : : err = IDMAP_SID_INVALID;
262 : : goto done;
263 : : }
264 : 9 : errno = 0;
265 : 9 : ul = strtoul(r, &r, 10);
266 [ + - ][ + - ]: 9 : if (errno != 0 || r == NULL || ul > UINT32_MAX) {
[ + - ]
267 : : err = IDMAP_SID_INVALID;
268 : : goto done;
269 : : }
270 : :
271 : : /* id_auth in the string should always be <2^32 in decimal */
272 : : /* store values in the same order as the binary representation */
273 : 9 : dom_sid->id_auth[0] = 0;
274 : 9 : dom_sid->id_auth[1] = 0;
275 : 9 : dom_sid->id_auth[2] = (ul & 0xff000000) >> 24;
276 : 9 : dom_sid->id_auth[3] = (ul & 0x00ff0000) >> 16;
277 : 9 : dom_sid->id_auth[4] = (ul & 0x0000ff00) >> 8;
278 : 9 : dom_sid->id_auth[5] = (ul & 0x000000ff);
279 : :
280 [ + - ]: 9 : if (*r == '\0') {
281 : : /* no sub auths given */
282 : : err = IDMAP_SUCCESS;
283 : : goto done;
284 : : }
285 : :
286 [ + - ]: 9 : if (*r != '-') {
287 : : err = IDMAP_SID_INVALID;
288 : : goto done;
289 : : }
290 : :
291 : : do {
292 [ + - ]: 44 : if (dom_sid->num_auths > SID_SUB_AUTHS) {
293 : : err = IDMAP_SID_INVALID;
294 : : goto done;
295 : : }
296 : :
297 : 44 : r++;
298 [ + - ]: 44 : if (!isdigit(*r)) {
299 : : err = IDMAP_SID_INVALID;
300 : : goto done;
301 : : }
302 : :
303 : 44 : errno = 0;
304 : 44 : ul = strtoul(r, &end, 10);
305 [ + - ][ + + ]: 44 : if (errno != 0 || ul > UINT32_MAX || end == NULL ||
[ + - ][ + - ]
306 : 43 : (*end != '\0' && *end != '-')) {
307 : : err = IDMAP_SID_INVALID;
308 : : goto done;
309 : : }
310 : :
311 : 43 : dom_sid->sub_auths[dom_sid->num_auths++] = ul;
312 : :
313 : 43 : r = end;
314 [ + + ]: 43 : } while (*r != '\0');
315 : :
316 : : err = IDMAP_SUCCESS;
317 : :
318 : : done:
319 [ + + ]: 9 : if (err != IDMAP_SUCCESS) {
320 : 1 : ctx->free_func(dom_sid, ctx->alloc_pvt);
321 : : } else {
322 : 9 : *_dom_sid = dom_sid;
323 : : }
324 : :
325 : : return err;
326 : : }
327 : :
328 : 3 : enum idmap_error_code sss_idmap_sid_to_bin_sid(struct sss_idmap_ctx *ctx,
329 : : const char *sid,
330 : : uint8_t **_bin_sid,
331 : : size_t *_length)
332 : : {
333 : : enum idmap_error_code err;
334 : 3 : struct sss_dom_sid *dom_sid = NULL;
335 : : size_t length;
336 : 3 : uint8_t *bin_sid = NULL;
337 : :
338 : 3 : err = sss_idmap_sid_to_dom_sid(ctx, sid, &dom_sid);
339 [ + - ]: 3 : if (err != IDMAP_SUCCESS) {
340 : : goto done;
341 : : }
342 : :
343 : 3 : err = sss_idmap_dom_sid_to_bin_sid(ctx, dom_sid, &bin_sid, &length);
344 [ + - ]: 3 : if (err != IDMAP_SUCCESS) {
345 : : goto done;
346 : : }
347 : :
348 : 3 : *_length = length;
349 : 3 : *_bin_sid = bin_sid;
350 : 3 : err = IDMAP_SUCCESS;
351 : :
352 : : done:
353 : 3 : ctx->free_func(dom_sid, ctx->alloc_pvt);
354 [ - + ]: 3 : if (err != IDMAP_SUCCESS) {
355 : 0 : ctx->free_func(bin_sid, ctx->alloc_pvt);
356 : : }
357 : :
358 : 3 : return err;
359 : : }
360 : :
361 : 3 : enum idmap_error_code sss_idmap_bin_sid_to_sid(struct sss_idmap_ctx *ctx,
362 : : const uint8_t *bin_sid,
363 : : size_t length,
364 : : char **_sid)
365 : : {
366 : : enum idmap_error_code err;
367 : 3 : struct sss_dom_sid *dom_sid = NULL;
368 : 3 : char *sid = NULL;
369 : :
370 : 3 : err = sss_idmap_bin_sid_to_dom_sid(ctx, bin_sid, length, &dom_sid);
371 [ + - ]: 3 : if (err != IDMAP_SUCCESS) {
372 : : goto done;
373 : : }
374 : :
375 : 3 : err = sss_idmap_dom_sid_to_sid(ctx, dom_sid, &sid);
376 [ + - ]: 3 : if (err != IDMAP_SUCCESS) {
377 : : goto done;
378 : : }
379 : :
380 : 3 : *_sid = sid;
381 : 3 : err = IDMAP_SUCCESS;
382 : :
383 : : done:
384 : 3 : ctx->free_func(dom_sid, ctx->alloc_pvt);
385 [ - + ]: 3 : if (err != IDMAP_SUCCESS) {
386 : 0 : ctx->free_func(sid, ctx->alloc_pvt);
387 : : }
388 : :
389 : 3 : return err;
390 : : }
391 : :
392 : 1 : enum idmap_error_code sss_idmap_sid_to_smb_sid(struct sss_idmap_ctx *ctx,
393 : : const char *sid,
394 : : struct dom_sid **_smb_sid)
395 : : {
396 : : enum idmap_error_code err;
397 : 1 : struct sss_dom_sid *dom_sid = NULL;
398 : 1 : struct dom_sid *smb_sid = NULL;
399 : :
400 : 1 : err = sss_idmap_sid_to_dom_sid(ctx, sid, &dom_sid);
401 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
402 : : goto done;
403 : : }
404 : :
405 : 1 : err = sss_idmap_dom_sid_to_smb_sid(ctx, dom_sid, &smb_sid);
406 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
407 : : goto done;
408 : : }
409 : :
410 : 1 : *_smb_sid = smb_sid;
411 : 1 : err = IDMAP_SUCCESS;
412 : :
413 : : done:
414 : 1 : ctx->free_func(dom_sid, ctx->alloc_pvt);
415 [ - + ]: 1 : if (err != IDMAP_SUCCESS) {
416 : 0 : ctx->free_func(smb_sid, ctx->alloc_pvt);
417 : : }
418 : :
419 : 1 : return err;
420 : : }
421 : :
422 : 1 : enum idmap_error_code sss_idmap_smb_sid_to_sid(struct sss_idmap_ctx *ctx,
423 : : struct dom_sid *smb_sid,
424 : : char **_sid)
425 : : {
426 : : enum idmap_error_code err;
427 : 1 : struct sss_dom_sid *dom_sid = NULL;
428 : 1 : char *sid = NULL;
429 : :
430 : 1 : err = sss_idmap_smb_sid_to_dom_sid(ctx, smb_sid, &dom_sid);
431 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
432 : : goto done;
433 : : }
434 : :
435 : 1 : err = sss_idmap_dom_sid_to_sid(ctx, dom_sid, &sid);
436 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
437 : : goto done;
438 : : }
439 : :
440 : 1 : *_sid = sid;
441 : 1 : err = IDMAP_SUCCESS;
442 : :
443 : : done:
444 : 1 : ctx->free_func(dom_sid, ctx->alloc_pvt);
445 [ - + ]: 1 : if (err != IDMAP_SUCCESS) {
446 : 0 : ctx->free_func(sid, ctx->alloc_pvt);
447 : : }
448 : :
449 : 1 : return err;
450 : : }
451 : :
452 : 3 : enum idmap_error_code sss_idmap_dom_sid_to_smb_sid(struct sss_idmap_ctx *ctx,
453 : : struct sss_dom_sid *dom_sid,
454 : : struct dom_sid **_smb_sid)
455 : : {
456 : : struct dom_sid *smb_sid;
457 : : size_t c;
458 : :
459 : 3 : smb_sid = ctx->alloc_func(sizeof(struct dom_sid), ctx->alloc_pvt);
460 [ + - ]: 3 : if (smb_sid == NULL) {
461 : : return IDMAP_OUT_OF_MEMORY;
462 : : }
463 : 3 : memset(smb_sid, 0, sizeof(struct dom_sid));
464 : :
465 : 3 : smb_sid->sid_rev_num = dom_sid->sid_rev_num;
466 : 3 : smb_sid->num_auths = dom_sid->num_auths;
467 [ + + ]: 21 : for (c = 0; c < SID_ID_AUTHS; c++) {
468 : 18 : smb_sid->id_auth[c] = dom_sid->id_auth[c];
469 : : }
470 [ + + ]: 48 : for (c = 0; c < SID_SUB_AUTHS; c++) {
471 : 45 : smb_sid->sub_auths[c] = dom_sid->sub_auths[c];
472 : : }
473 : :
474 : 3 : *_smb_sid = smb_sid;
475 : :
476 : 3 : return IDMAP_SUCCESS;
477 : : }
478 : :
479 : 3 : enum idmap_error_code sss_idmap_smb_sid_to_dom_sid(struct sss_idmap_ctx *ctx,
480 : : struct dom_sid *smb_sid,
481 : : struct sss_dom_sid **_dom_sid)
482 : : {
483 : : struct sss_dom_sid *dom_sid;
484 : : size_t c;
485 : :
486 : 3 : dom_sid = ctx->alloc_func(sizeof(struct sss_dom_sid), ctx->alloc_pvt);
487 [ + - ]: 3 : if (dom_sid == NULL) {
488 : : return IDMAP_OUT_OF_MEMORY;
489 : : }
490 : 3 : memset(dom_sid, 0, sizeof(struct sss_dom_sid));
491 : :
492 : 3 : dom_sid->sid_rev_num = smb_sid->sid_rev_num;
493 : 3 : dom_sid->num_auths = smb_sid->num_auths;
494 [ + + ]: 21 : for (c = 0; c < SID_ID_AUTHS; c++) {
495 : 18 : dom_sid->id_auth[c] = smb_sid->id_auth[c];
496 : : }
497 [ + + ]: 48 : for (c = 0; c < SID_SUB_AUTHS; c++) {
498 : 45 : dom_sid->sub_auths[c] = smb_sid->sub_auths[c];
499 : : }
500 : :
501 : 3 : *_dom_sid = dom_sid;
502 : :
503 : 3 : return IDMAP_SUCCESS;
504 : : }
505 : :
506 : 1 : enum idmap_error_code sss_idmap_bin_sid_to_smb_sid(struct sss_idmap_ctx *ctx,
507 : : const uint8_t *bin_sid,
508 : : size_t length,
509 : : struct dom_sid **_smb_sid)
510 : : {
511 : : enum idmap_error_code err;
512 : 1 : struct sss_dom_sid *dom_sid = NULL;
513 : 1 : struct dom_sid *smb_sid = NULL;
514 : :
515 : 1 : err = sss_idmap_bin_sid_to_dom_sid(ctx, bin_sid, length, &dom_sid);
516 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
517 : : goto done;
518 : : }
519 : :
520 : 1 : err = sss_idmap_dom_sid_to_smb_sid(ctx, dom_sid, &smb_sid);
521 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
522 : : goto done;
523 : : }
524 : :
525 : 1 : *_smb_sid = smb_sid;
526 : 1 : err = IDMAP_SUCCESS;
527 : :
528 : : done:
529 : 1 : ctx->free_func(dom_sid, ctx->alloc_pvt);
530 [ - + ]: 1 : if (err != IDMAP_SUCCESS) {
531 : 0 : ctx->free_func(smb_sid, ctx->alloc_pvt);
532 : : }
533 : :
534 : 1 : return err;
535 : : }
536 : :
537 : 1 : enum idmap_error_code sss_idmap_smb_sid_to_bin_sid(struct sss_idmap_ctx *ctx,
538 : : struct dom_sid *smb_sid,
539 : : uint8_t **_bin_sid,
540 : : size_t *_length)
541 : : {
542 : : enum idmap_error_code err;
543 : 1 : struct sss_dom_sid *dom_sid = NULL;
544 : 1 : uint8_t *bin_sid = NULL;
545 : : size_t length;
546 : :
547 : 1 : err = sss_idmap_smb_sid_to_dom_sid(ctx, smb_sid, &dom_sid);
548 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
549 : : goto done;
550 : : }
551 : :
552 : 1 : err = sss_idmap_dom_sid_to_bin_sid(ctx, dom_sid, &bin_sid, &length);
553 [ + - ]: 1 : if (err != IDMAP_SUCCESS) {
554 : : goto done;
555 : : }
556 : :
557 : 1 : *_bin_sid = bin_sid;
558 : 1 : *_length = length;
559 : 1 : err = IDMAP_SUCCESS;
560 : :
561 : : done:
562 : 1 : ctx->free_func(dom_sid, ctx->alloc_pvt);
563 [ - + ]: 1 : if (err != IDMAP_SUCCESS) {
564 : 0 : ctx->free_func(bin_sid, ctx->alloc_pvt);
565 : : }
566 : :
567 : 1 : return err;
568 : : }
|
