source: branches/samba-3.3.x/source/nsswitch/libwbclient/wbc_idmap.c

Last change on this file was 206, checked in by Herwig Bauernfeind, 16 years ago

Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 12.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 Winbind client API
5
6 Copyright (C) Gerald (Jerry) Carter 2007
7
8
9 This library is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Lesser General Public
11 License as published by the Free Software Foundation; either
12 version 3 of the License, or (at your option) any later version.
13
14 This library is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Library General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21*/
22
23/* Required Headers */
24
25#include "libwbclient.h"
26
27/** @brief Convert a Windows SID to a Unix uid, allocating an uid if needed
28 *
29 * @param *sid Pointer to the domain SID to be resolved
30 * @param *puid Pointer to the resolved uid_t value
31 *
32 * @return #wbcErr
33 *
34 **/
35
36wbcErr wbcSidToUid(const struct wbcDomainSid *sid, uid_t *puid)
37{
38 struct winbindd_request request;
39 struct winbindd_response response;
40 char *sid_string = NULL;
41 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
42
43 if (!sid || !puid) {
44 wbc_status = WBC_ERR_INVALID_PARAM;
45 BAIL_ON_WBC_ERROR(wbc_status);
46 }
47
48 /* Initialize request */
49
50 ZERO_STRUCT(request);
51 ZERO_STRUCT(response);
52
53 wbc_status = wbcSidToString(sid, &sid_string);
54 BAIL_ON_WBC_ERROR(wbc_status);
55
56 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
57 wbcFreeMemory(sid_string);
58
59 /* Make request */
60
61 wbc_status = wbcRequestResponse(WINBINDD_SID_TO_UID,
62 &request,
63 &response);
64 BAIL_ON_WBC_ERROR(wbc_status);
65
66 *puid = response.data.uid;
67
68 wbc_status = WBC_ERR_SUCCESS;
69
70 done:
71 return wbc_status;
72}
73
74/** @brief Convert a Windows SID to a Unix uid if there already is a mapping
75 *
76 * @param *sid Pointer to the domain SID to be resolved
77 * @param *puid Pointer to the resolved uid_t value
78 *
79 * @return #wbcErr
80 *
81 **/
82
83wbcErr wbcQuerySidToUid(const struct wbcDomainSid *sid,
84 uid_t *puid)
85{
86 return WBC_ERR_NOT_IMPLEMENTED;
87}
88
89/** @brief Convert a Unix uid to a Windows SID, allocating a SID if needed
90 *
91 * @param uid Unix uid to be resolved
92 * @param *sid Pointer to the resolved domain SID
93 *
94 * @return #wbcErr
95 *
96 **/
97
98wbcErr wbcUidToSid(uid_t uid, struct wbcDomainSid *sid)
99{
100 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
101 struct winbindd_request request;
102 struct winbindd_response response;
103
104 if (!sid) {
105 wbc_status = WBC_ERR_INVALID_PARAM;
106 BAIL_ON_WBC_ERROR(wbc_status);
107 }
108
109 /* Initialize request */
110
111 ZERO_STRUCT(request);
112 ZERO_STRUCT(response);
113
114 request.data.uid = uid;
115
116 /* Make request */
117
118 wbc_status = wbcRequestResponse(WINBINDD_UID_TO_SID,
119 &request,
120 &response);
121 BAIL_ON_WBC_ERROR(wbc_status);
122
123 wbc_status = wbcStringToSid(response.data.sid.sid, sid);
124 BAIL_ON_WBC_ERROR(wbc_status);
125
126done:
127 return wbc_status;
128}
129
130/** @brief Convert a Unix uid to a Windows SID if there already is a mapping
131 *
132 * @param uid Unix uid to be resolved
133 * @param *sid Pointer to the resolved domain SID
134 *
135 * @return #wbcErr
136 *
137 **/
138
139wbcErr wbcQueryUidToSid(uid_t uid,
140 struct wbcDomainSid *sid)
141{
142 return WBC_ERR_NOT_IMPLEMENTED;
143}
144
145/** @brief Convert a Windows SID to a Unix gid, allocating a gid if needed
146 *
147 * @param *sid Pointer to the domain SID to be resolved
148 * @param *pgid Pointer to the resolved gid_t value
149 *
150 * @return #wbcErr
151 *
152 **/
153
154wbcErr wbcSidToGid(const struct wbcDomainSid *sid, gid_t *pgid)
155{
156 struct winbindd_request request;
157 struct winbindd_response response;
158 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
159 char *sid_string = NULL;
160
161 if (!sid || !pgid) {
162 wbc_status = WBC_ERR_INVALID_PARAM;
163 BAIL_ON_WBC_ERROR(wbc_status);
164 }
165
166 /* Initialize request */
167
168 ZERO_STRUCT(request);
169 ZERO_STRUCT(response);
170
171 wbc_status = wbcSidToString(sid, &sid_string);
172 BAIL_ON_WBC_ERROR(wbc_status);
173
174 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
175 wbcFreeMemory(sid_string);
176
177 /* Make request */
178
179 wbc_status = wbcRequestResponse(WINBINDD_SID_TO_GID,
180 &request,
181 &response);
182 BAIL_ON_WBC_ERROR(wbc_status);
183
184 *pgid = response.data.gid;
185
186 wbc_status = WBC_ERR_SUCCESS;
187
188 done:
189 return wbc_status;
190}
191
192/** @brief Convert a Windows SID to a Unix gid if there already is a mapping
193 *
194 * @param *sid Pointer to the domain SID to be resolved
195 * @param *pgid Pointer to the resolved gid_t value
196 *
197 * @return #wbcErr
198 *
199 **/
200
201wbcErr wbcQuerySidToGid(const struct wbcDomainSid *sid,
202 gid_t *pgid)
203{
204 return WBC_ERR_NOT_IMPLEMENTED;
205}
206
207/** @brief Convert a Unix gid to a Windows SID, allocating a SID if needed
208 *
209 * @param gid Unix gid to be resolved
210 * @param *sid Pointer to the resolved domain SID
211 *
212 * @return #wbcErr
213 *
214 **/
215
216wbcErr wbcGidToSid(gid_t gid, struct wbcDomainSid *sid)
217{
218 struct winbindd_request request;
219 struct winbindd_response response;
220 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
221
222 if (!sid) {
223 wbc_status = WBC_ERR_INVALID_PARAM;
224 BAIL_ON_WBC_ERROR(wbc_status);
225 }
226
227 /* Initialize request */
228
229 ZERO_STRUCT(request);
230 ZERO_STRUCT(response);
231
232 request.data.gid = gid;
233
234 /* Make request */
235
236 wbc_status = wbcRequestResponse(WINBINDD_GID_TO_SID,
237 &request,
238 &response);
239 BAIL_ON_WBC_ERROR(wbc_status);
240
241 wbc_status = wbcStringToSid(response.data.sid.sid, sid);
242 BAIL_ON_WBC_ERROR(wbc_status);
243
244done:
245 return wbc_status;
246}
247
248/** @brief Convert a Unix gid to a Windows SID if there already is a mapping
249 *
250 * @param gid Unix gid to be resolved
251 * @param *sid Pointer to the resolved domain SID
252 *
253 * @return #wbcErr
254 *
255 **/
256
257wbcErr wbcQueryGidToSid(gid_t gid,
258 struct wbcDomainSid *sid)
259{
260 return WBC_ERR_NOT_IMPLEMENTED;
261}
262
263/** @brief Obtain a new uid from Winbind
264 *
265 * @param *puid *pointer to the allocated uid
266 *
267 * @return #wbcErr
268 **/
269
270wbcErr wbcAllocateUid(uid_t *puid)
271{
272 struct winbindd_request request;
273 struct winbindd_response response;
274 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
275
276 if (!puid)
277 return WBC_ERR_INVALID_PARAM;
278
279 /* Initialise request */
280
281 ZERO_STRUCT(request);
282 ZERO_STRUCT(response);
283
284 /* Make request */
285
286 wbc_status = wbcRequestResponse(WINBINDD_ALLOCATE_UID,
287 &request, &response);
288 BAIL_ON_WBC_ERROR(wbc_status);
289
290 /* Copy out result */
291 *puid = response.data.uid;
292
293 wbc_status = WBC_ERR_SUCCESS;
294
295 done:
296 return wbc_status;
297}
298
299/** @brief Obtain a new gid from Winbind
300 *
301 * @param *pgid Pointer to the allocated gid
302 *
303 * @return #wbcErr
304 **/
305
306wbcErr wbcAllocateGid(gid_t *pgid)
307{
308 struct winbindd_request request;
309 struct winbindd_response response;
310 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
311
312 if (!pgid)
313 return WBC_ERR_INVALID_PARAM;
314
315 /* Initialise request */
316
317 ZERO_STRUCT(request);
318 ZERO_STRUCT(response);
319
320 /* Make request */
321
322 wbc_status = wbcRequestResponse(WINBINDD_ALLOCATE_GID,
323 &request, &response);
324 BAIL_ON_WBC_ERROR(wbc_status);
325
326 /* Copy out result */
327 *pgid = response.data.gid;
328
329 wbc_status = WBC_ERR_SUCCESS;
330
331 done:
332 return wbc_status;
333}
334
335/* we can't include smb.h here... */
336#define _ID_TYPE_UID 1
337#define _ID_TYPE_GID 2
338
339/** @brief Set an user id mapping
340 *
341 * @param uid Uid of the desired mapping.
342 * @param *sid Pointer to the sid of the diresired mapping.
343 *
344 * @return #wbcErr
345 **/
346wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid)
347{
348 struct winbindd_request request;
349 struct winbindd_response response;
350 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
351 char *sid_string = NULL;
352
353 if (!sid) {
354 return WBC_ERR_INVALID_PARAM;
355 }
356
357 /* Initialise request */
358
359 ZERO_STRUCT(request);
360 ZERO_STRUCT(response);
361
362 /* Make request */
363
364 request.data.dual_idmapset.id = uid;
365 request.data.dual_idmapset.type = _ID_TYPE_UID;
366
367 wbc_status = wbcSidToString(sid, &sid_string);
368 BAIL_ON_WBC_ERROR(wbc_status);
369
370 strncpy(request.data.dual_idmapset.sid, sid_string,
371 sizeof(request.data.dual_idmapset.sid)-1);
372 wbcFreeMemory(sid_string);
373
374 wbc_status = wbcRequestResponse(WINBINDD_SET_MAPPING,
375 &request, &response);
376 BAIL_ON_WBC_ERROR(wbc_status);
377
378 done:
379 return wbc_status;
380}
381
382/** @brief Set a group id mapping
383 *
384 * @param gid Gid of the desired mapping.
385 * @param *sid Pointer to the sid of the diresired mapping.
386 *
387 * @return #wbcErr
388 **/
389wbcErr wbcSetGidMapping(gid_t gid, const struct wbcDomainSid *sid)
390{
391 struct winbindd_request request;
392 struct winbindd_response response;
393 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
394 char *sid_string = NULL;
395
396 if (!sid) {
397 return WBC_ERR_INVALID_PARAM;
398 }
399
400 /* Initialise request */
401
402 ZERO_STRUCT(request);
403 ZERO_STRUCT(response);
404
405 /* Make request */
406
407 request.data.dual_idmapset.id = gid;
408 request.data.dual_idmapset.type = _ID_TYPE_GID;
409
410 wbc_status = wbcSidToString(sid, &sid_string);
411 BAIL_ON_WBC_ERROR(wbc_status);
412
413 strncpy(request.data.dual_idmapset.sid, sid_string,
414 sizeof(request.data.dual_idmapset.sid)-1);
415 wbcFreeMemory(sid_string);
416
417 wbc_status = wbcRequestResponse(WINBINDD_SET_MAPPING,
418 &request, &response);
419 BAIL_ON_WBC_ERROR(wbc_status);
420
421 done:
422 return wbc_status;
423}
424
425/** @brief Remove a user id mapping
426 *
427 * @param uid Uid of the mapping to remove.
428 * @param *sid Pointer to the sid of the mapping to remove.
429 *
430 * @return #wbcErr
431 **/
432wbcErr wbcRemoveUidMapping(uid_t uid, const struct wbcDomainSid *sid)
433{
434 struct winbindd_request request;
435 struct winbindd_response response;
436 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
437 char *sid_string = NULL;
438
439 if (!sid) {
440 return WBC_ERR_INVALID_PARAM;
441 }
442
443 /* Initialise request */
444
445 ZERO_STRUCT(request);
446 ZERO_STRUCT(response);
447
448 /* Make request */
449
450 request.data.dual_idmapset.id = uid;
451 request.data.dual_idmapset.type = _ID_TYPE_UID;
452
453 wbc_status = wbcSidToString(sid, &sid_string);
454 BAIL_ON_WBC_ERROR(wbc_status);
455
456 strncpy(request.data.dual_idmapset.sid, sid_string,
457 sizeof(request.data.dual_idmapset.sid)-1);
458 wbcFreeMemory(sid_string);
459
460 wbc_status = wbcRequestResponse(WINBINDD_REMOVE_MAPPING,
461 &request, &response);
462 BAIL_ON_WBC_ERROR(wbc_status);
463
464 done:
465 return wbc_status;
466}
467
468/** @brief Remove a group id mapping
469 *
470 * @param gid Gid of the mapping to remove.
471 * @param *sid Pointer to the sid of the mapping to remove.
472 *
473 * @return #wbcErr
474 **/
475wbcErr wbcRemoveGidMapping(gid_t gid, const struct wbcDomainSid *sid)
476{
477 struct winbindd_request request;
478 struct winbindd_response response;
479 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
480 char *sid_string = NULL;
481
482 if (!sid) {
483 return WBC_ERR_INVALID_PARAM;
484 }
485
486 /* Initialise request */
487
488 ZERO_STRUCT(request);
489 ZERO_STRUCT(response);
490
491 /* Make request */
492
493 request.data.dual_idmapset.id = gid;
494 request.data.dual_idmapset.type = _ID_TYPE_GID;
495
496 wbc_status = wbcSidToString(sid, &sid_string);
497 BAIL_ON_WBC_ERROR(wbc_status);
498
499 strncpy(request.data.dual_idmapset.sid, sid_string,
500 sizeof(request.data.dual_idmapset.sid)-1);
501 wbcFreeMemory(sid_string);
502
503 wbc_status = wbcRequestResponse(WINBINDD_REMOVE_MAPPING,
504 &request, &response);
505 BAIL_ON_WBC_ERROR(wbc_status);
506
507 done:
508 return wbc_status;
509}
510
511/** @brief Set the highwater mark for allocated uids.
512 *
513 * @param uid_hwm The new uid highwater mark value
514 *
515 * @return #wbcErr
516 **/
517wbcErr wbcSetUidHwm(uid_t uid_hwm)
518{
519 struct winbindd_request request;
520 struct winbindd_response response;
521 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
522
523 /* Initialise request */
524
525 ZERO_STRUCT(request);
526 ZERO_STRUCT(response);
527
528 /* Make request */
529
530 request.data.dual_idmapset.id = uid_hwm;
531 request.data.dual_idmapset.type = _ID_TYPE_UID;
532
533 wbc_status = wbcRequestResponse(WINBINDD_SET_HWM,
534 &request, &response);
535 BAIL_ON_WBC_ERROR(wbc_status);
536
537 done:
538 return wbc_status;
539}
540
541/** @brief Set the highwater mark for allocated gids.
542 *
543 * @param gid_hwm The new gid highwater mark value
544 *
545 * @return #wbcErr
546 **/
547wbcErr wbcSetGidHwm(gid_t gid_hwm)
548{
549 struct winbindd_request request;
550 struct winbindd_response response;
551 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
552
553 /* Initialise request */
554
555 ZERO_STRUCT(request);
556 ZERO_STRUCT(response);
557
558 /* Make request */
559
560 request.data.dual_idmapset.id = gid_hwm;
561 request.data.dual_idmapset.type = _ID_TYPE_GID;
562
563 wbc_status = wbcRequestResponse(WINBINDD_SET_HWM,
564 &request, &response);
565 BAIL_ON_WBC_ERROR(wbc_status);
566
567 done:
568 return wbc_status;
569}
Note: See TracBrowser for help on using the repository browser.