nsswitch: Move source3 files to top level dir.
[garming/samba-autobuild/.git] / nsswitch / libwbclient / wbc_util.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    Winbind client API
5
6    Copyright (C) Gerald (Jerry) Carter 2007-2008
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
28
29 /** @brief Ping winbindd to see if the daemon is running
30  *
31  * @return #wbcErr
32  **/
33
34 wbcErr wbcPing(void)
35 {
36         struct winbindd_request request;
37         struct winbindd_response response;
38
39         /* Initialize request */
40
41         ZERO_STRUCT(request);
42         ZERO_STRUCT(response);
43
44         return wbcRequestResponse(WINBINDD_PING, &request, &response);
45 }
46
47 wbcErr wbcInterfaceDetails(struct wbcInterfaceDetails **_details)
48 {
49         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
50         struct wbcInterfaceDetails *info;
51         struct wbcDomainInfo *domain = NULL;
52         struct winbindd_request request;
53         struct winbindd_response response;
54
55         /* Initialize request */
56
57         ZERO_STRUCT(request);
58         ZERO_STRUCT(response);
59
60         info = talloc(NULL, struct wbcInterfaceDetails);
61         BAIL_ON_PTR_ERROR(info, wbc_status);
62
63         /* first the interface version */
64         wbc_status = wbcRequestResponse(WINBINDD_INTERFACE_VERSION, NULL, &response);
65         BAIL_ON_WBC_ERROR(wbc_status);
66         info->interface_version = response.data.interface_version;
67
68         /* then the samba version and the winbind separator */
69         wbc_status = wbcRequestResponse(WINBINDD_INFO, NULL, &response);
70         BAIL_ON_WBC_ERROR(wbc_status);
71
72         info->winbind_version = talloc_strdup(info,
73                                               response.data.info.samba_version);
74         BAIL_ON_PTR_ERROR(info->winbind_version, wbc_status);
75         info->winbind_separator = response.data.info.winbind_separator;
76
77         /* then the local netbios name */
78         wbc_status = wbcRequestResponse(WINBINDD_NETBIOS_NAME, NULL, &response);
79         BAIL_ON_WBC_ERROR(wbc_status);
80
81         info->netbios_name = talloc_strdup(info,
82                                            response.data.netbios_name);
83         BAIL_ON_PTR_ERROR(info->netbios_name, wbc_status);
84
85         /* then the local workgroup name */
86         wbc_status = wbcRequestResponse(WINBINDD_DOMAIN_NAME, NULL, &response);
87         BAIL_ON_WBC_ERROR(wbc_status);
88
89         info->netbios_domain = talloc_strdup(info,
90                                         response.data.domain_name);
91         BAIL_ON_PTR_ERROR(info->netbios_domain, wbc_status);
92
93         wbc_status = wbcDomainInfo(info->netbios_domain, &domain);
94         if (wbc_status == WBC_ERR_DOMAIN_NOT_FOUND) {
95                 /* maybe it's a standalone server */
96                 domain = NULL;
97                 wbc_status = WBC_ERR_SUCCESS;
98         } else {
99                 BAIL_ON_WBC_ERROR(wbc_status);
100         }
101
102         if (domain) {
103                 info->dns_domain = talloc_strdup(info,
104                                                  domain->dns_name);
105                 wbcFreeMemory(domain);
106                 BAIL_ON_PTR_ERROR(info->dns_domain, wbc_status);
107         } else {
108                 info->dns_domain = NULL;
109         }
110
111         *_details = info;
112         info = NULL;
113
114         wbc_status = WBC_ERR_SUCCESS;
115
116 done:
117         talloc_free(info);
118         return wbc_status;
119 }
120
121
122 /* Lookup the current status of a trusted domain */
123 wbcErr wbcDomainInfo(const char *domain, struct wbcDomainInfo **dinfo)
124 {
125         struct winbindd_request request;
126         struct winbindd_response response;
127         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
128         struct wbcDomainInfo *info = NULL;
129
130         if (!domain || !dinfo) {
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         strncpy(request.domain_name, domain,
141                 sizeof(request.domain_name)-1);
142
143         wbc_status = wbcRequestResponse(WINBINDD_DOMAIN_INFO,
144                                         &request,
145                                         &response);
146         BAIL_ON_WBC_ERROR(wbc_status);
147
148         info = talloc(NULL, struct wbcDomainInfo);
149         BAIL_ON_PTR_ERROR(info, wbc_status);
150
151         info->short_name = talloc_strdup(info,
152                                          response.data.domain_info.name);
153         BAIL_ON_PTR_ERROR(info->short_name, wbc_status);
154
155         info->dns_name = talloc_strdup(info,
156                                        response.data.domain_info.alt_name);
157         BAIL_ON_PTR_ERROR(info->dns_name, wbc_status);
158
159         wbc_status = wbcStringToSid(response.data.domain_info.sid,
160                                     &info->sid);
161         BAIL_ON_WBC_ERROR(wbc_status);
162
163         if (response.data.domain_info.native_mode)
164                 info->domain_flags |= WBC_DOMINFO_DOMAIN_NATIVE;
165         if (response.data.domain_info.active_directory)
166                 info->domain_flags |= WBC_DOMINFO_DOMAIN_AD;
167         if (response.data.domain_info.primary)
168                 info->domain_flags |= WBC_DOMINFO_DOMAIN_PRIMARY;
169
170         *dinfo = info;
171
172         wbc_status = WBC_ERR_SUCCESS;
173
174  done:
175         if (!WBC_ERROR_IS_OK(wbc_status)) {
176                 talloc_free(info);
177         }
178
179         return wbc_status;
180 }
181
182
183 /* Resolve a NetbiosName via WINS */
184 wbcErr wbcResolveWinsByName(const char *name, char **ip)
185 {
186         struct winbindd_request request;
187         struct winbindd_response response;
188         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
189         char *ipaddr;
190
191         ZERO_STRUCT(request);
192         ZERO_STRUCT(response);
193
194         /* Send request */
195
196         strncpy(request.data.winsreq, name,
197                 sizeof(request.data.winsreq)-1);
198
199         wbc_status = wbcRequestResponse(WINBINDD_WINS_BYNAME,
200                                         &request,
201                                         &response);
202         BAIL_ON_WBC_ERROR(wbc_status);
203
204         /* Display response */
205
206         ipaddr = talloc_strdup(NULL, response.data.winsresp);
207         BAIL_ON_PTR_ERROR(ipaddr, wbc_status);
208
209         *ip = ipaddr;
210         wbc_status = WBC_ERR_SUCCESS;
211
212  done:
213         return wbc_status;
214 }
215
216 /* Resolve an IP address via WINS into a NetbiosName */
217 wbcErr wbcResolveWinsByIP(const char *ip, char **name)
218 {
219         struct winbindd_request request;
220         struct winbindd_response response;
221         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
222         char *name_str;
223
224         ZERO_STRUCT(request);
225         ZERO_STRUCT(response);
226
227         /* Send request */
228
229         strncpy(request.data.winsreq, ip,
230                 sizeof(request.data.winsreq)-1);
231
232         wbc_status = wbcRequestResponse(WINBINDD_WINS_BYIP,
233                                         &request,
234                                         &response);
235         BAIL_ON_WBC_ERROR(wbc_status);
236
237         /* Display response */
238
239         name_str = talloc_strdup(NULL, response.data.winsresp);
240         BAIL_ON_PTR_ERROR(name_str, wbc_status);
241
242         *name = name_str;
243         wbc_status = WBC_ERR_SUCCESS;
244
245  done:
246         return wbc_status;
247 }
248
249 /**
250  */
251
252 static wbcErr process_domain_info_string(TALLOC_CTX *ctx,
253                                          struct wbcDomainInfo *info,
254                                          char *info_string)
255 {
256         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
257         char *r = NULL;
258         char *s = NULL;
259
260         if (!info || !info_string) {
261                 wbc_status = WBC_ERR_INVALID_PARAM;
262                 BAIL_ON_WBC_ERROR(wbc_status);
263         }
264
265         r = info_string;
266
267         /* Short Name */
268         if ((s = strchr(r, '\\')) == NULL) {
269                 wbc_status = WBC_ERR_INVALID_RESPONSE;
270                 BAIL_ON_WBC_ERROR(wbc_status);
271         }
272         *s = '\0';
273         s++;
274
275         info->short_name = talloc_strdup(ctx, r);
276         BAIL_ON_PTR_ERROR(info->short_name, wbc_status);
277
278
279         /* DNS Name */
280         r = s;
281         if ((s = strchr(r, '\\')) == NULL) {
282                 wbc_status = WBC_ERR_INVALID_RESPONSE;
283                 BAIL_ON_WBC_ERROR(wbc_status);
284         }
285         *s = '\0';
286         s++;
287
288         info->dns_name = talloc_strdup(ctx, r);
289         BAIL_ON_PTR_ERROR(info->dns_name, wbc_status);
290
291         /* SID */
292         r = s;
293         if ((s = strchr(r, '\\')) == NULL) {
294                 wbc_status = WBC_ERR_INVALID_RESPONSE;
295                 BAIL_ON_WBC_ERROR(wbc_status);
296         }
297         *s = '\0';
298         s++;
299
300         wbc_status = wbcStringToSid(r, &info->sid);
301         BAIL_ON_WBC_ERROR(wbc_status);
302
303         /* Trust type */
304         r = s;
305         if ((s = strchr(r, '\\')) == NULL) {
306                 wbc_status = WBC_ERR_INVALID_RESPONSE;
307                 BAIL_ON_WBC_ERROR(wbc_status);
308         }
309         *s = '\0';
310         s++;
311
312         if (strcmp(r, "None") == 0) {
313                 info->trust_type = WBC_DOMINFO_TRUSTTYPE_NONE;
314         } else if (strcmp(r, "External") == 0) {
315                 info->trust_type = WBC_DOMINFO_TRUSTTYPE_EXTERNAL;
316         } else if (strcmp(r, "Forest") == 0) {
317                 info->trust_type = WBC_DOMINFO_TRUSTTYPE_FOREST;
318         } else if (strcmp(r, "In Forest") == 0) {
319                 info->trust_type = WBC_DOMINFO_TRUSTTYPE_IN_FOREST;
320         } else {
321                 wbc_status = WBC_ERR_INVALID_RESPONSE;
322                 BAIL_ON_WBC_ERROR(wbc_status);
323         }
324
325         /* Transitive */
326         r = s;
327         if ((s = strchr(r, '\\')) == NULL) {
328                 wbc_status = WBC_ERR_INVALID_RESPONSE;
329                 BAIL_ON_WBC_ERROR(wbc_status);
330         }
331         *s = '\0';
332         s++;
333
334         if (strcmp(r, "Yes") == 0) {
335                 info->trust_flags |= WBC_DOMINFO_TRUST_TRANSITIVE;
336         }
337
338         /* Incoming */
339         r = s;
340         if ((s = strchr(r, '\\')) == NULL) {
341                 wbc_status = WBC_ERR_INVALID_RESPONSE;
342                 BAIL_ON_WBC_ERROR(wbc_status);
343         }
344         *s = '\0';
345         s++;
346
347         if (strcmp(r, "Yes") == 0) {
348                 info->trust_flags |= WBC_DOMINFO_TRUST_INCOMING;
349         }
350
351         /* Outgoing */
352         r = s;
353         if ((s = strchr(r, '\\')) == NULL) {
354                 wbc_status = WBC_ERR_INVALID_RESPONSE;
355                 BAIL_ON_WBC_ERROR(wbc_status);
356         }
357         *s = '\0';
358         s++;
359
360         if (strcmp(r, "Yes") == 0) {
361                 info->trust_flags |= WBC_DOMINFO_TRUST_OUTGOING;
362         }
363
364         /* Online/Offline status */
365
366         r = s;
367         if (r == NULL) {
368                 wbc_status = WBC_ERR_INVALID_RESPONSE;
369                 BAIL_ON_WBC_ERROR(wbc_status);
370         }
371         if ( strcmp(r, "Offline") == 0) {
372                 info->domain_flags |= WBC_DOMINFO_DOMAIN_OFFLINE;
373         }
374
375         wbc_status = WBC_ERR_SUCCESS;
376
377  done:
378         return wbc_status;
379 }
380
381 /* Enumerate the domain trusts known by Winbind */
382 wbcErr wbcListTrusts(struct wbcDomainInfo **domains, size_t *num_domains)
383 {
384         struct winbindd_response response;
385         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
386         char *p = NULL;
387         char *q = NULL;
388         char *extra_data = NULL;
389         int count = 0;
390         struct wbcDomainInfo *d_list = NULL;
391         int i = 0;
392
393         *domains = NULL;
394         *num_domains = 0;
395
396         ZERO_STRUCT(response);
397
398         /* Send request */
399
400         wbc_status = wbcRequestResponse(WINBINDD_LIST_TRUSTDOM,
401                                         NULL,
402                                         &response);
403         BAIL_ON_WBC_ERROR(wbc_status);
404
405         /* Decode the response */
406
407         p = (char *)response.extra_data.data;
408
409         if (strlen(p) == 0) {
410                 /* We should always at least get back our
411                    own SAM domain */
412
413                 wbc_status = WBC_ERR_DOMAIN_NOT_FOUND;
414                 BAIL_ON_WBC_ERROR(wbc_status);
415         }
416
417         /* Count number of domains */
418
419         count = 0;
420         while (p) {
421                 count++;
422
423                 if ((q = strchr(p, '\n')) != NULL)
424                         q++;
425                 p = q;
426         }
427
428         d_list = talloc_array(NULL, struct wbcDomainInfo, count);
429         BAIL_ON_PTR_ERROR(d_list, wbc_status);
430
431         extra_data = strdup((char*)response.extra_data.data);
432         BAIL_ON_PTR_ERROR(extra_data, wbc_status);
433
434         p = extra_data;
435
436         /* Outer loop processes the list of domain information */
437
438         for (i=0; i<count && p; i++) {
439                 char *next = strchr(p, '\n');
440
441                 if (next) {
442                         *next = '\0';
443                         next++;
444                 }
445
446                 wbc_status = process_domain_info_string(d_list, &d_list[i], p);
447                 BAIL_ON_WBC_ERROR(wbc_status);
448
449                 p = next;
450         }
451
452         *domains = d_list;
453         *num_domains = i;
454
455  done:
456         if (!WBC_ERROR_IS_OK(wbc_status)) {
457                 if (d_list)
458                         talloc_free(d_list);
459                 if (extra_data)
460                         free(extra_data);
461         }
462
463         return wbc_status;
464 }
465
466 /* Enumerate the domain trusts known by Winbind */
467 wbcErr wbcLookupDomainController(const char *domain,
468                                  uint32_t flags,
469                                 struct wbcDomainControllerInfo **dc_info)
470 {
471         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
472         struct winbindd_request request;
473         struct winbindd_response response;
474         struct wbcDomainControllerInfo *dc = NULL;
475
476         /* validate input params */
477
478         if (!domain || !dc_info) {
479                 wbc_status = WBC_ERR_INVALID_PARAM;
480                 BAIL_ON_WBC_ERROR(wbc_status);
481         }
482
483         ZERO_STRUCT(request);
484         ZERO_STRUCT(response);
485
486         strncpy(request.domain_name, domain, sizeof(request.domain_name)-1);
487
488         request.flags = flags;
489
490         dc = talloc(NULL, struct wbcDomainControllerInfo);
491         BAIL_ON_PTR_ERROR(dc, wbc_status);
492
493         /* Send request */
494
495         wbc_status = wbcRequestResponse(WINBINDD_DSGETDCNAME,
496                                         &request,
497                                         &response);
498         BAIL_ON_WBC_ERROR(wbc_status);
499
500         dc->dc_name = talloc_strdup(dc, response.data.dc_name);
501         BAIL_ON_PTR_ERROR(dc->dc_name, wbc_status);
502
503         *dc_info = dc;
504
505 done:
506         if (!WBC_ERROR_IS_OK(wbc_status)) {
507                 talloc_free(dc);
508         }
509
510         return wbc_status;
511 }
512
513 static wbcErr wbc_create_domain_controller_info_ex(TALLOC_CTX *mem_ctx,
514                                                    const struct winbindd_response *resp,
515                                                    struct wbcDomainControllerInfoEx **_i)
516 {
517         wbcErr wbc_status = WBC_ERR_SUCCESS;
518         struct wbcDomainControllerInfoEx *i;
519         struct wbcGuid guid;
520
521         i = talloc(mem_ctx, struct wbcDomainControllerInfoEx);
522         BAIL_ON_PTR_ERROR(i, wbc_status);
523
524         i->dc_unc = talloc_strdup(i, resp->data.dsgetdcname.dc_unc);
525         BAIL_ON_PTR_ERROR(i->dc_unc, wbc_status);
526
527         i->dc_address = talloc_strdup(i, resp->data.dsgetdcname.dc_address);
528         BAIL_ON_PTR_ERROR(i->dc_address, wbc_status);
529
530         i->dc_address_type = resp->data.dsgetdcname.dc_address_type;
531
532         wbc_status = wbcStringToGuid(resp->data.dsgetdcname.domain_guid, &guid);
533         if (WBC_ERROR_IS_OK(wbc_status)) {
534                 i->domain_guid = talloc(i, struct wbcGuid);
535                 BAIL_ON_PTR_ERROR(i->domain_guid, wbc_status);
536
537                 *i->domain_guid = guid;
538         } else {
539                 i->domain_guid = NULL;
540         }
541
542         i->domain_name = talloc_strdup(i, resp->data.dsgetdcname.domain_name);
543         BAIL_ON_PTR_ERROR(i->domain_name, wbc_status);
544
545         if (resp->data.dsgetdcname.forest_name[0] != '\0') {
546                 i->forest_name = talloc_strdup(i,
547                         resp->data.dsgetdcname.forest_name);
548                 BAIL_ON_PTR_ERROR(i->forest_name, wbc_status);
549         } else {
550                 i->forest_name = NULL;
551         }
552
553         i->dc_flags = resp->data.dsgetdcname.dc_flags;
554
555         if (resp->data.dsgetdcname.dc_site_name[0] != '\0') {
556                 i->dc_site_name = talloc_strdup(i,
557                         resp->data.dsgetdcname.dc_site_name);
558                 BAIL_ON_PTR_ERROR(i->dc_site_name, wbc_status);
559         } else {
560                 i->dc_site_name = NULL;
561         }
562
563         if (resp->data.dsgetdcname.client_site_name[0] != '\0') {
564                 i->client_site_name = talloc_strdup(i,
565                         resp->data.dsgetdcname.client_site_name);
566                 BAIL_ON_PTR_ERROR(i->client_site_name, wbc_status);
567         } else {
568                 i->client_site_name = NULL;
569         }
570
571         *_i = i;
572         i = NULL;
573
574 done:
575         talloc_free(i);
576         return wbc_status;
577 }
578
579 /* Get extended domain controller information */
580 wbcErr wbcLookupDomainControllerEx(const char *domain,
581                                    struct wbcGuid *guid,
582                                    const char *site,
583                                    uint32_t flags,
584                                    struct wbcDomainControllerInfoEx **dc_info)
585 {
586         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
587         struct winbindd_request request;
588         struct winbindd_response response;
589
590         /* validate input params */
591
592         if (!domain || !dc_info) {
593                 wbc_status = WBC_ERR_INVALID_PARAM;
594                 BAIL_ON_WBC_ERROR(wbc_status);
595         }
596
597         ZERO_STRUCT(request);
598         ZERO_STRUCT(response);
599
600         request.data.dsgetdcname.flags = flags;
601
602         strncpy(request.data.dsgetdcname.domain_name, domain,
603                 sizeof(request.data.dsgetdcname.domain_name)-1);
604
605         if (site) {
606                 strncpy(request.data.dsgetdcname.site_name, site,
607                         sizeof(request.data.dsgetdcname.site_name)-1);
608         }
609
610         if (guid) {
611                 char *str = NULL;
612
613                 wbc_status = wbcGuidToString(guid, &str);
614                 BAIL_ON_WBC_ERROR(wbc_status);
615
616                 strncpy(request.data.dsgetdcname.domain_guid, str,
617                         sizeof(request.data.dsgetdcname.domain_guid)-1);
618
619                 wbcFreeMemory(str);
620         }
621
622         /* Send request */
623
624         wbc_status = wbcRequestResponse(WINBINDD_DSGETDCNAME,
625                                         &request,
626                                         &response);
627         BAIL_ON_WBC_ERROR(wbc_status);
628
629         if (dc_info) {
630                 wbc_status = wbc_create_domain_controller_info_ex(NULL,
631                                                                   &response,
632                                                                   dc_info);
633                 BAIL_ON_WBC_ERROR(wbc_status);
634         }
635
636         wbc_status = WBC_ERR_SUCCESS;
637 done:
638         return wbc_status;
639 }
640
641 /* Initialize a named blob and add to list of blobs */
642 wbcErr wbcAddNamedBlob(size_t *num_blobs,
643                        struct wbcNamedBlob **blobs,
644                        const char *name,
645                        uint32_t flags,
646                        uint8_t *data,
647                        size_t length)
648 {
649         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
650         struct wbcNamedBlob blob;
651
652         *blobs = talloc_realloc(NULL, *blobs, struct wbcNamedBlob,
653                                 *(num_blobs)+1);
654         BAIL_ON_PTR_ERROR(*blobs, wbc_status);
655
656         blob.name               = talloc_strdup(*blobs, name);
657         BAIL_ON_PTR_ERROR(blob.name, wbc_status);
658         blob.flags              = flags;
659         blob.blob.length        = length;
660         blob.blob.data          = (uint8_t *)talloc_memdup(*blobs, data, length);
661         BAIL_ON_PTR_ERROR(blob.blob.data, wbc_status);
662
663         (*(blobs))[*num_blobs] = blob;
664         *(num_blobs) += 1;
665
666         wbc_status = WBC_ERR_SUCCESS;
667 done:
668         if (!WBC_ERROR_IS_OK(wbc_status) && blobs) {
669                 wbcFreeMemory(*blobs);
670         }
671         return wbc_status;
672 }