s3: Implement wbcGetpwsid
[ira/wip.git] / source3 / lib / winbind_util.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Winbind Utility functions
4
5    Copyright (C) Gerald (Jerry) Carter   2007
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 "includes.h"
22
23 #if defined(WITH_WINBIND)
24
25 #include "nsswitch/libwbclient/wbclient.h"
26
27 struct passwd * winbind_getpwnam(const char * name)
28 {
29         wbcErr result;
30         struct passwd * tmp_pwd = NULL;
31         struct passwd * pwd = NULL;
32
33         result = wbcGetpwnam(name, &tmp_pwd);
34         if (result != WBC_ERR_SUCCESS)
35                 return pwd;
36
37         pwd = tcopy_passwd(talloc_tos(), tmp_pwd);
38
39         wbcFreeMemory(tmp_pwd);
40
41         return pwd;
42 }
43
44 struct passwd * winbind_getpwsid(const DOM_SID *sid)
45 {
46         wbcErr result;
47         struct passwd * tmp_pwd = NULL;
48         struct passwd * pwd = NULL;
49         struct wbcDomainSid dom_sid;
50
51         memcpy(&dom_sid, sid, sizeof(dom_sid));
52
53         result = wbcGetpwsid(&dom_sid, &tmp_pwd);
54         if (result != WBC_ERR_SUCCESS)
55                 return pwd;
56
57         pwd = tcopy_passwd(talloc_tos(), tmp_pwd);
58
59         wbcFreeMemory(tmp_pwd);
60
61         return pwd;
62 }
63
64 /* Call winbindd to convert a name to a sid */
65
66 bool winbind_lookup_name(const char *dom_name, const char *name, DOM_SID *sid, 
67                          enum lsa_SidType *name_type)
68 {
69         struct wbcDomainSid dom_sid;
70         wbcErr result;
71         enum wbcSidType type;   
72
73         result = wbcLookupName(dom_name, name, &dom_sid, &type);
74         if (result != WBC_ERR_SUCCESS)
75                 return false;
76
77         memcpy(sid, &dom_sid, sizeof(DOM_SID)); 
78         *name_type = (enum lsa_SidType)type;    
79
80         return true;    
81 }
82
83 /* Call winbindd to convert sid to name */
84
85 bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const DOM_SID *sid, 
86                         const char **domain, const char **name,
87                         enum lsa_SidType *name_type)
88 {
89         struct wbcDomainSid dom_sid;
90         wbcErr result;
91         enum wbcSidType type;
92         char *domain_name = NULL;
93         char *account_name = NULL;
94
95         memcpy(&dom_sid, sid, sizeof(dom_sid)); 
96
97         result = wbcLookupSid(&dom_sid, &domain_name, &account_name, &type);
98         if (result != WBC_ERR_SUCCESS)
99                 return false;
100
101         /* Copy out result */
102
103         if (domain) {           
104                 *domain = talloc_strdup(mem_ctx, domain_name);
105         }
106         if (name) {
107                 *name = talloc_strdup(mem_ctx, account_name);
108         }
109         *name_type = (enum lsa_SidType)type;
110
111         DEBUG(10, ("winbind_lookup_sid: SUCCESS: SID %s -> %s %s\n", 
112                    sid_string_dbg(sid), domain_name, account_name));
113
114         wbcFreeMemory(domain_name);
115         wbcFreeMemory(account_name);
116         
117         if ((domain && !*domain) || (name && !*name)) {         
118                 DEBUG(0,("winbind_lookup_sid: talloc() failed!\n"));
119                 return false;
120         }       
121
122
123         return true;
124 }
125
126 /* Ping winbindd to see it is alive */
127
128 bool winbind_ping(void)
129 {
130         wbcErr result = wbcPing();
131
132         return (result == WBC_ERR_SUCCESS);
133 }
134
135 /* Call winbindd to convert SID to uid */
136
137 bool winbind_sid_to_uid(uid_t *puid, const DOM_SID *sid)
138 {
139         struct wbcDomainSid dom_sid;
140         wbcErr result;
141
142         memcpy(&dom_sid, sid, sizeof(dom_sid)); 
143
144         result = wbcSidToUid(&dom_sid, puid);   
145
146         return (result == WBC_ERR_SUCCESS);     
147 }
148
149 /* Call winbindd to convert uid to sid */
150
151 bool winbind_uid_to_sid(DOM_SID *sid, uid_t uid)
152 {
153         struct wbcDomainSid dom_sid;
154         wbcErr result;
155
156         result = wbcUidToSid(uid, &dom_sid);
157         if (result == WBC_ERR_SUCCESS) {
158                 memcpy(sid, &dom_sid, sizeof(DOM_SID));
159         } else {
160                 sid_copy(sid, &global_sid_NULL);
161         }
162
163         return (result == WBC_ERR_SUCCESS);
164 }
165
166 /* Call winbindd to convert SID to gid */
167
168 bool winbind_sid_to_gid(gid_t *pgid, const DOM_SID *sid)
169 {
170         struct wbcDomainSid dom_sid;
171         wbcErr result;
172
173         memcpy(&dom_sid, sid, sizeof(dom_sid)); 
174
175         result = wbcSidToGid(&dom_sid, pgid);   
176
177         return (result == WBC_ERR_SUCCESS);     
178 }
179
180 /* Call winbindd to convert gid to sid */
181
182 bool winbind_gid_to_sid(DOM_SID *sid, gid_t gid)
183 {
184         struct wbcDomainSid dom_sid;
185         wbcErr result;
186
187         result = wbcGidToSid(gid, &dom_sid);
188         if (result == WBC_ERR_SUCCESS) {
189                 memcpy(sid, &dom_sid, sizeof(DOM_SID));
190         } else {
191                 sid_copy(sid, &global_sid_NULL);
192         }
193
194         return (result == WBC_ERR_SUCCESS);
195 }
196
197 /* Check for a trusted domain */
198
199 wbcErr wb_is_trusted_domain(const char *domain)
200 {
201         wbcErr result;
202         struct wbcDomainInfo *info = NULL;
203         
204         result = wbcDomainInfo(domain, &info);
205
206         if (WBC_ERROR_IS_OK(result)) {
207                 wbcFreeMemory(info);
208         }
209
210         return result;  
211 }
212
213 /* Lookup a set of rids in a given domain */
214
215 bool winbind_lookup_rids(TALLOC_CTX *mem_ctx,
216                          const DOM_SID *domain_sid,
217                          int num_rids, uint32 *rids,
218                          const char **domain_name,
219                          const char ***names, enum lsa_SidType **types)
220 {
221         const char *dom_name = NULL;
222         const char **namelist = NULL;
223         enum wbcSidType *name_types = NULL;
224         struct wbcDomainSid dom_sid;
225         wbcErr ret;
226         int i;  
227         
228         memcpy(&dom_sid, domain_sid, sizeof(struct wbcDomainSid));
229         
230         ret = wbcLookupRids(&dom_sid, num_rids, rids,
231                             &dom_name, &namelist, &name_types);
232         if (ret != WBC_ERR_SUCCESS) {           
233                 return false;
234         }       
235         
236         *domain_name = talloc_strdup(mem_ctx, dom_name);
237         *names       = TALLOC_ARRAY(mem_ctx, const char*, num_rids);
238         *types       = TALLOC_ARRAY(mem_ctx, enum lsa_SidType, num_rids);
239
240         for(i=0; i<num_rids; i++) {
241                 (*names)[i] = talloc_strdup(*names, namelist[i]);
242                 (*types)[i] = (enum lsa_SidType)name_types[i];
243         }
244
245         wbcFreeMemory(CONST_DISCARD(char*, dom_name));
246         wbcFreeMemory(namelist);
247         wbcFreeMemory(name_types);
248         
249         return true;    
250 }
251
252 /* Ask Winbind to allocate a new uid for us */
253
254 bool winbind_allocate_uid(uid_t *uid)
255 {
256         wbcErr ret;
257         
258         ret = wbcAllocateUid(uid);
259         
260         return (ret == WBC_ERR_SUCCESS);
261 }
262
263 /* Ask Winbind to allocate a new gid for us */
264
265 bool winbind_allocate_gid(gid_t *gid)
266 {
267         wbcErr ret;
268         
269         ret = wbcAllocateGid(gid);
270         
271         return (ret == WBC_ERR_SUCCESS);
272 }
273
274 #else      /* WITH_WINBIND */
275
276 struct passwd * winbind_getpwnam(const char * name)
277 {
278         return NULL;
279 }
280
281 struct passwd * winbind_getpwsid(const DOM_SID *sid)
282 {
283         return NULL;
284 }
285
286 bool winbind_lookup_name(const char *dom_name, const char *name, DOM_SID *sid, 
287                          enum lsa_SidType *name_type)
288 {
289         return false;
290 }
291
292 /* Call winbindd to convert sid to name */
293
294 bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const DOM_SID *sid, 
295                         const char **domain, const char **name,
296                         enum lsa_SidType *name_type)
297 {
298         return false;
299 }
300
301 /* Ping winbindd to see it is alive */
302
303 bool winbind_ping(void)
304 {
305         return false;
306 }
307
308 /* Call winbindd to convert SID to uid */
309
310 bool winbind_sid_to_uid(uid_t *puid, const DOM_SID *sid)
311 {
312         return false;
313 }
314
315 /* Call winbindd to convert uid to sid */
316
317 bool winbind_uid_to_sid(DOM_SID *sid, uid_t uid)
318 {
319         return false;
320 }
321
322 /* Call winbindd to convert SID to gid */
323
324 bool winbind_sid_to_gid(gid_t *pgid, const DOM_SID *sid)
325 {
326         return false;   
327 }
328
329 /* Call winbindd to convert gid to sid */
330
331 bool winbind_gid_to_sid(DOM_SID *sid, gid_t gid)
332 {
333         return false;
334 }
335
336 /* Check for a trusted domain */
337
338 wbcErr wb_is_trusted_domain(const char *domain)
339 {
340         return WBC_ERR_UNKNOWN_FAILURE;
341 }
342
343 /* Lookup a set of rids in a given domain */
344
345 bool winbind_lookup_rids(TALLOC_CTX *mem_ctx,
346                          const DOM_SID *domain_sid,
347                          int num_rids, uint32 *rids,
348                          const char **domain_name,
349                          const char ***names, enum lsa_SidType **types)
350 {
351         return false;
352 }
353
354 /* Ask Winbind to allocate a new uid for us */
355
356 bool winbind_allocate_uid(uid_t *uid)
357 {
358         return false;
359 }
360
361 /* Ask Winbind to allocate a new gid for us */
362
363 bool winbind_allocate_gid(gid_t *gid)
364 {
365         return false;
366 }
367
368 #endif     /* WITH_WINBIND */