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

Last change on this file was 480, checked in by Silvan Scherrer, 15 years ago

Samba Server 3.5: trunk update to 3.5.4
File size: 10.7 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 "replace.h"
26#include "libwbclient.h"
27
28/* Convert a Windows SID to a Unix uid, allocating an uid if needed */
29wbcErr wbcSidToUid(const struct wbcDomainSid *sid, uid_t *puid)
30{
31 struct winbindd_request request;
32 struct winbindd_response response;
33 char *sid_string = NULL;
34 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
35
36 if (!sid || !puid) {
37 wbc_status = WBC_ERR_INVALID_PARAM;
38 BAIL_ON_WBC_ERROR(wbc_status);
39 }
40
41 /* Initialize request */
42
43 ZERO_STRUCT(request);
44 ZERO_STRUCT(response);
45
46 wbc_status = wbcSidToString(sid, &sid_string);
47 BAIL_ON_WBC_ERROR(wbc_status);
48
49 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
50 wbcFreeMemory(sid_string);
51
52 /* Make request */
53
54 wbc_status = wbcRequestResponse(WINBINDD_SID_TO_UID,
55 &request,
56 &response);
57 BAIL_ON_WBC_ERROR(wbc_status);
58
59 *puid = response.data.uid;
60
61 wbc_status = WBC_ERR_SUCCESS;
62
63 done:
64 return wbc_status;
65}
66
67/* Convert a Windows SID to a Unix uid if there already is a mapping */
68wbcErr wbcQuerySidToUid(const struct wbcDomainSid *sid,
69 uid_t *puid)
70{
71 return WBC_ERR_NOT_IMPLEMENTED;
72}
73
74/* Convert a Unix uid to a Windows SID, allocating a SID if needed */
75wbcErr wbcUidToSid(uid_t uid, struct wbcDomainSid *sid)
76{
77 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
78 struct winbindd_request request;
79 struct winbindd_response response;
80
81 if (!sid) {
82 wbc_status = WBC_ERR_INVALID_PARAM;
83 BAIL_ON_WBC_ERROR(wbc_status);
84 }
85
86 /* Initialize request */
87
88 ZERO_STRUCT(request);
89 ZERO_STRUCT(response);
90
91 request.data.uid = uid;
92
93 /* Make request */
94
95 wbc_status = wbcRequestResponse(WINBINDD_UID_TO_SID,
96 &request,
97 &response);
98 BAIL_ON_WBC_ERROR(wbc_status);
99
100 wbc_status = wbcStringToSid(response.data.sid.sid, sid);
101 BAIL_ON_WBC_ERROR(wbc_status);
102
103done:
104 return wbc_status;
105}
106
107/* Convert a Unix uid to a Windows SID if there already is a mapping */
108wbcErr wbcQueryUidToSid(uid_t uid,
109 struct wbcDomainSid *sid)
110{
111 return WBC_ERR_NOT_IMPLEMENTED;
112}
113
114/** @brief Convert a Windows SID to a Unix gid, allocating a gid if needed
115 *
116 * @param *sid Pointer to the domain SID to be resolved
117 * @param *pgid Pointer to the resolved gid_t value
118 *
119 * @return #wbcErr
120 *
121 **/
122
123wbcErr wbcSidToGid(const struct wbcDomainSid *sid, gid_t *pgid)
124{
125 struct winbindd_request request;
126 struct winbindd_response response;
127 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
128 char *sid_string = NULL;
129
130 if (!sid || !pgid) {
131 wbc_status = WBC_ERR_INVALID_PARAM;
132 BAIL_ON_WBC_ERROR(wbc_status);
133 }
134
135 /* Initialize request */
136
137 ZERO_STRUCT(request);
138 ZERO_STRUCT(response);
139
140 wbc_status = wbcSidToString(sid, &sid_string);
141 BAIL_ON_WBC_ERROR(wbc_status);
142
143 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
144 wbcFreeMemory(sid_string);
145
146 /* Make request */
147
148 wbc_status = wbcRequestResponse(WINBINDD_SID_TO_GID,
149 &request,
150 &response);
151 BAIL_ON_WBC_ERROR(wbc_status);
152
153 *pgid = response.data.gid;
154
155 wbc_status = WBC_ERR_SUCCESS;
156
157 done:
158 return wbc_status;
159}
160
161/* Convert a Windows SID to a Unix gid if there already is a mapping */
162
163wbcErr wbcQuerySidToGid(const struct wbcDomainSid *sid,
164 gid_t *pgid)
165{
166 return WBC_ERR_NOT_IMPLEMENTED;
167}
168
169/* Convert a Unix gid to a Windows SID, allocating a SID if needed */
170wbcErr wbcGidToSid(gid_t gid, struct wbcDomainSid *sid)
171{
172 struct winbindd_request request;
173 struct winbindd_response response;
174 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
175
176 if (!sid) {
177 wbc_status = WBC_ERR_INVALID_PARAM;
178 BAIL_ON_WBC_ERROR(wbc_status);
179 }
180
181 /* Initialize request */
182
183 ZERO_STRUCT(request);
184 ZERO_STRUCT(response);
185
186 request.data.gid = gid;
187
188 /* Make request */
189
190 wbc_status = wbcRequestResponse(WINBINDD_GID_TO_SID,
191 &request,
192 &response);
193 BAIL_ON_WBC_ERROR(wbc_status);
194
195 wbc_status = wbcStringToSid(response.data.sid.sid, sid);
196 BAIL_ON_WBC_ERROR(wbc_status);
197
198done:
199 return wbc_status;
200}
201
202/* Convert a Unix gid to a Windows SID if there already is a mapping */
203wbcErr wbcQueryGidToSid(gid_t gid,
204 struct wbcDomainSid *sid)
205{
206 return WBC_ERR_NOT_IMPLEMENTED;
207}
208
209/* Obtain a new uid from Winbind */
210wbcErr wbcAllocateUid(uid_t *puid)
211{
212 struct winbindd_request request;
213 struct winbindd_response response;
214 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
215
216 if (!puid)
217 return WBC_ERR_INVALID_PARAM;
218
219 /* Initialise request */
220
221 ZERO_STRUCT(request);
222 ZERO_STRUCT(response);
223
224 /* Make request */
225
226 wbc_status = wbcRequestResponsePriv(WINBINDD_ALLOCATE_UID,
227 &request, &response);
228 BAIL_ON_WBC_ERROR(wbc_status);
229
230 /* Copy out result */
231 *puid = response.data.uid;
232
233 wbc_status = WBC_ERR_SUCCESS;
234
235 done:
236 return wbc_status;
237}
238
239/* Obtain a new gid from Winbind */
240wbcErr wbcAllocateGid(gid_t *pgid)
241{
242 struct winbindd_request request;
243 struct winbindd_response response;
244 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
245
246 if (!pgid)
247 return WBC_ERR_INVALID_PARAM;
248
249 /* Initialise request */
250
251 ZERO_STRUCT(request);
252 ZERO_STRUCT(response);
253
254 /* Make request */
255
256 wbc_status = wbcRequestResponsePriv(WINBINDD_ALLOCATE_GID,
257 &request, &response);
258 BAIL_ON_WBC_ERROR(wbc_status);
259
260 /* Copy out result */
261 *pgid = response.data.gid;
262
263 wbc_status = WBC_ERR_SUCCESS;
264
265 done:
266 return wbc_status;
267}
268
269/* we can't include smb.h here... */
270#define _ID_TYPE_UID 1
271#define _ID_TYPE_GID 2
272
273/* Set an user id mapping */
274wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid)
275{
276 struct winbindd_request request;
277 struct winbindd_response response;
278 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
279 char *sid_string = NULL;
280
281 if (!sid) {
282 return WBC_ERR_INVALID_PARAM;
283 }
284
285 /* Initialise request */
286
287 ZERO_STRUCT(request);
288 ZERO_STRUCT(response);
289
290 /* Make request */
291
292 request.data.dual_idmapset.id = uid;
293 request.data.dual_idmapset.type = _ID_TYPE_UID;
294
295 wbc_status = wbcSidToString(sid, &sid_string);
296 BAIL_ON_WBC_ERROR(wbc_status);
297
298 strncpy(request.data.dual_idmapset.sid, sid_string,
299 sizeof(request.data.dual_idmapset.sid)-1);
300 wbcFreeMemory(sid_string);
301
302 wbc_status = wbcRequestResponsePriv(WINBINDD_SET_MAPPING,
303 &request, &response);
304 BAIL_ON_WBC_ERROR(wbc_status);
305
306 done:
307 return wbc_status;
308}
309
310/* Set a group id mapping */
311wbcErr wbcSetGidMapping(gid_t gid, const struct wbcDomainSid *sid)
312{
313 struct winbindd_request request;
314 struct winbindd_response response;
315 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
316 char *sid_string = NULL;
317
318 if (!sid) {
319 return WBC_ERR_INVALID_PARAM;
320 }
321
322 /* Initialise request */
323
324 ZERO_STRUCT(request);
325 ZERO_STRUCT(response);
326
327 /* Make request */
328
329 request.data.dual_idmapset.id = gid;
330 request.data.dual_idmapset.type = _ID_TYPE_GID;
331
332 wbc_status = wbcSidToString(sid, &sid_string);
333 BAIL_ON_WBC_ERROR(wbc_status);
334
335 strncpy(request.data.dual_idmapset.sid, sid_string,
336 sizeof(request.data.dual_idmapset.sid)-1);
337 wbcFreeMemory(sid_string);
338
339 wbc_status = wbcRequestResponsePriv(WINBINDD_SET_MAPPING,
340 &request, &response);
341 BAIL_ON_WBC_ERROR(wbc_status);
342
343 done:
344 return wbc_status;
345}
346
347/* Remove a user id mapping */
348wbcErr wbcRemoveUidMapping(uid_t uid, const struct wbcDomainSid *sid)
349{
350 struct winbindd_request request;
351 struct winbindd_response response;
352 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
353 char *sid_string = NULL;
354
355 if (!sid) {
356 return WBC_ERR_INVALID_PARAM;
357 }
358
359 /* Initialise request */
360
361 ZERO_STRUCT(request);
362 ZERO_STRUCT(response);
363
364 /* Make request */
365
366 request.data.dual_idmapset.id = uid;
367 request.data.dual_idmapset.type = _ID_TYPE_UID;
368
369 wbc_status = wbcSidToString(sid, &sid_string);
370 BAIL_ON_WBC_ERROR(wbc_status);
371
372 strncpy(request.data.dual_idmapset.sid, sid_string,
373 sizeof(request.data.dual_idmapset.sid)-1);
374 wbcFreeMemory(sid_string);
375
376 wbc_status = wbcRequestResponsePriv(WINBINDD_REMOVE_MAPPING,
377 &request, &response);
378 BAIL_ON_WBC_ERROR(wbc_status);
379
380 done:
381 return wbc_status;
382}
383
384/* Remove a group id mapping */
385wbcErr wbcRemoveGidMapping(gid_t gid, const struct wbcDomainSid *sid)
386{
387 struct winbindd_request request;
388 struct winbindd_response response;
389 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
390 char *sid_string = NULL;
391
392 if (!sid) {
393 return WBC_ERR_INVALID_PARAM;
394 }
395
396 /* Initialise request */
397
398 ZERO_STRUCT(request);
399 ZERO_STRUCT(response);
400
401 /* Make request */
402
403 request.data.dual_idmapset.id = gid;
404 request.data.dual_idmapset.type = _ID_TYPE_GID;
405
406 wbc_status = wbcSidToString(sid, &sid_string);
407 BAIL_ON_WBC_ERROR(wbc_status);
408
409 strncpy(request.data.dual_idmapset.sid, sid_string,
410 sizeof(request.data.dual_idmapset.sid)-1);
411 wbcFreeMemory(sid_string);
412
413 wbc_status = wbcRequestResponsePriv(WINBINDD_REMOVE_MAPPING,
414 &request, &response);
415 BAIL_ON_WBC_ERROR(wbc_status);
416
417 done:
418 return wbc_status;
419}
420
421/* Set the highwater mark for allocated uids. */
422wbcErr wbcSetUidHwm(uid_t uid_hwm)
423{
424 struct winbindd_request request;
425 struct winbindd_response response;
426 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
427
428 /* Initialise request */
429
430 ZERO_STRUCT(request);
431 ZERO_STRUCT(response);
432
433 /* Make request */
434
435 request.data.dual_idmapset.id = uid_hwm;
436 request.data.dual_idmapset.type = _ID_TYPE_UID;
437
438 wbc_status = wbcRequestResponsePriv(WINBINDD_SET_HWM,
439 &request, &response);
440 BAIL_ON_WBC_ERROR(wbc_status);
441
442 done:
443 return wbc_status;
444}
445
446/* Set the highwater mark for allocated gids. */
447wbcErr wbcSetGidHwm(gid_t gid_hwm)
448{
449 struct winbindd_request request;
450 struct winbindd_response response;
451 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
452
453 /* Initialise request */
454
455 ZERO_STRUCT(request);
456 ZERO_STRUCT(response);
457
458 /* Make request */
459
460 request.data.dual_idmapset.id = gid_hwm;
461 request.data.dual_idmapset.type = _ID_TYPE_GID;
462
463 wbc_status = wbcRequestResponsePriv(WINBINDD_SET_HWM,
464 &request, &response);
465 BAIL_ON_WBC_ERROR(wbc_status);
466
467 done:
468 return wbc_status;
469}
Note: See TracBrowser for help on using the repository browser.