r17942: Jerry is right - when no site support is enabled
[tprouty/samba.git] / source / libads / cldap.c
1 /* 
2    Samba Unix/Linux SMB client library 
3    net ads cldap functions 
4    Copyright (C) 2001 Andrew Tridgell (tridge@samba.org)
5    Copyright (C) 2003 Jim McDonough (jmcd@us.ibm.com)
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 2 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, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
20 */
21
22 #include "includes.h"
23
24 /*
25   These seem to be strings as described in RFC1035 4.1.4 and can be:
26
27    - a sequence of labels ending in a zero octet
28    - a pointer
29    - a sequence of labels ending with a pointer
30
31   A label is a byte where the first two bits must be zero and the remaining
32   bits represent the length of the label followed by the label itself.
33   Therefore, the length of a label is at max 64 bytes.  Under RFC1035, a
34   sequence of labels cannot exceed 255 bytes.
35
36   A pointer consists of a 14 bit offset from the beginning of the data.
37
38   struct ptr {
39     unsigned ident:2; // must be 11
40     unsigned offset:14; // from the beginning of data
41   };
42
43   This is used as a method to compress the packet by eliminated duplicate
44   domain components.  Since a UDP packet should probably be < 512 bytes and a
45   DNS name can be up to 255 bytes, this actually makes a lot of sense.
46 */
47 static unsigned pull_netlogon_string(char *ret, const char *ptr,
48                                      const char *data)
49 {
50         char *pret = ret;
51         int followed_ptr = 0;
52         unsigned ret_len = 0;
53
54         memset(pret, 0, MAX_DNS_LABEL);
55         do {
56                 if ((*ptr & 0xc0) == 0xc0) {
57                         uint16 len;
58
59                         if (!followed_ptr) {
60                                 ret_len += 2;
61                                 followed_ptr = 1;
62                         }
63                         len = ((ptr[0] & 0x3f) << 8) | ptr[1];
64                         ptr = data + len;
65                 } else if (*ptr) {
66                         uint8 len = (uint8)*(ptr++);
67
68                         if ((pret - ret + len + 1) >= MAX_DNS_LABEL) {
69                                 DEBUG(1,("DC returning too long DNS name\n"));
70                                 return 0;
71                         }
72
73                         if (pret != ret) {
74                                 *pret = '.';
75                                 pret++;
76                         }
77                         memcpy(pret, ptr, len);
78                         pret += len;
79                         ptr += len;
80
81                         if (!followed_ptr) {
82                                 ret_len += (len + 1);
83                         }
84                 }
85         } while (*ptr);
86
87         return followed_ptr ? ret_len : ret_len + 1;
88 }
89
90 /*
91   do a cldap netlogon query
92 */
93 static int send_cldap_netlogon(int sock, const char *domain, 
94                                const char *hostname, unsigned ntversion)
95 {
96         ASN1_DATA data;
97         char ntver[4];
98 #ifdef CLDAP_USER_QUERY
99         char aac[4];
100
101         SIVAL(aac, 0, 0x00000180);
102 #endif
103         SIVAL(ntver, 0, ntversion);
104
105         memset(&data, 0, sizeof(data));
106
107         asn1_push_tag(&data,ASN1_SEQUENCE(0));
108         asn1_write_Integer(&data, 4);
109         asn1_push_tag(&data, ASN1_APPLICATION(3));
110         asn1_write_OctetString(&data, NULL, 0);
111         asn1_write_enumerated(&data, 0);
112         asn1_write_enumerated(&data, 0);
113         asn1_write_Integer(&data, 0);
114         asn1_write_Integer(&data, 0);
115         asn1_write_BOOLEAN2(&data, False);
116         asn1_push_tag(&data, ASN1_CONTEXT(0));
117
118         if (domain) {
119                 asn1_push_tag(&data, ASN1_CONTEXT(3));
120                 asn1_write_OctetString(&data, "DnsDomain", 9);
121                 asn1_write_OctetString(&data, domain, strlen(domain));
122                 asn1_pop_tag(&data);
123         }
124
125         asn1_push_tag(&data, ASN1_CONTEXT(3));
126         asn1_write_OctetString(&data, "Host", 4);
127         asn1_write_OctetString(&data, hostname, strlen(hostname));
128         asn1_pop_tag(&data);
129
130 #ifdef CLDAP_USER_QUERY
131         asn1_push_tag(&data, ASN1_CONTEXT(3));
132         asn1_write_OctetString(&data, "User", 4);
133         asn1_write_OctetString(&data, "SAMBA$", 6);
134         asn1_pop_tag(&data);
135
136         asn1_push_tag(&data, ASN1_CONTEXT(3));
137         asn1_write_OctetString(&data, "AAC", 4);
138         asn1_write_OctetString(&data, aac, 4);
139         asn1_pop_tag(&data);
140 #endif
141
142         asn1_push_tag(&data, ASN1_CONTEXT(3));
143         asn1_write_OctetString(&data, "NtVer", 5);
144         asn1_write_OctetString(&data, ntver, 4);
145         asn1_pop_tag(&data);
146
147         asn1_pop_tag(&data);
148
149         asn1_push_tag(&data,ASN1_SEQUENCE(0));
150         asn1_write_OctetString(&data, "NetLogon", 8);
151         asn1_pop_tag(&data);
152         asn1_pop_tag(&data);
153         asn1_pop_tag(&data);
154
155         if (data.has_error) {
156                 DEBUG(2,("Failed to build cldap netlogon at offset %d\n", (int)data.ofs));
157                 asn1_free(&data);
158                 return -1;
159         }
160
161         if (write(sock, data.data, data.length) != (ssize_t)data.length) {
162                 DEBUG(2,("failed to send cldap query (%s)\n", strerror(errno)));
163         }
164
165         asn1_free(&data);
166
167         return 0;
168 }
169
170 static SIG_ATOMIC_T gotalarm;
171                                                                                                                    
172 /***************************************************************
173  Signal function to tell us we timed out.
174 ****************************************************************/
175                                                                                                                    
176 static void gotalarm_sig(void)
177 {
178         gotalarm = 1;
179 }
180                                                                                                                    
181 /*
182   receive a cldap netlogon reply
183 */
184 static int recv_cldap_netlogon(int sock, struct cldap_netlogon_reply *reply)
185 {
186         int ret;
187         ASN1_DATA data;
188         DATA_BLOB blob;
189         DATA_BLOB os1, os2, os3;
190         int i1;
191         char *p;
192
193         blob = data_blob(NULL, 8192);
194         if (blob.data == NULL) {
195                 DEBUG(1, ("data_blob failed\n"));
196                 errno = ENOMEM;
197                 return -1;
198         }
199
200         /* Setup timeout */
201         gotalarm = 0;
202         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
203         alarm(lp_ldap_timeout());
204         /* End setup timeout. */
205  
206         ret = read(sock, blob.data, blob.length);
207
208         /* Teardown timeout. */
209         CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
210         alarm(0);
211
212         if (ret <= 0) {
213                 DEBUG(1,("no reply received to cldap netlogon\n"));
214                 data_blob_free(&blob);
215                 return -1;
216         }
217         blob.length = ret;
218
219         asn1_load(&data, blob);
220         asn1_start_tag(&data, ASN1_SEQUENCE(0));
221         asn1_read_Integer(&data, &i1);
222         asn1_start_tag(&data, ASN1_APPLICATION(4));
223         asn1_read_OctetString(&data, &os1);
224         asn1_start_tag(&data, ASN1_SEQUENCE(0));
225         asn1_start_tag(&data, ASN1_SEQUENCE(0));
226         asn1_read_OctetString(&data, &os2);
227         asn1_start_tag(&data, ASN1_SET);
228         asn1_read_OctetString(&data, &os3);
229         asn1_end_tag(&data);
230         asn1_end_tag(&data);
231         asn1_end_tag(&data);
232         asn1_end_tag(&data);
233         asn1_end_tag(&data);
234
235         if (data.has_error) {
236                 data_blob_free(&blob);
237                 asn1_free(&data);
238                 DEBUG(1,("Failed to parse cldap reply\n"));
239                 return -1;
240         }
241
242         p = (char *)os3.data;
243
244         reply->type = IVAL(p, 0); p += 4;
245         reply->flags = IVAL(p, 0); p += 4;
246
247         memcpy(&reply->guid.info, p, UUID_FLAT_SIZE);
248         p += UUID_FLAT_SIZE;
249
250         p += pull_netlogon_string(reply->forest, p, (const char *)os3.data);
251         p += pull_netlogon_string(reply->domain, p, (const char *)os3.data);
252         p += pull_netlogon_string(reply->hostname, p, (const char *)os3.data);
253         p += pull_netlogon_string(reply->netbios_domain, p, (const char *)os3.data);
254         p += pull_netlogon_string(reply->netbios_hostname, p, (const char *)os3.data);
255         p += pull_netlogon_string(reply->unk, p, (const char *)os3.data);
256
257         if (reply->type == SAMLOGON_AD_R) {
258                 p += pull_netlogon_string(reply->user_name, p, (const char *)os3.data);
259         } else {
260                 *reply->user_name = 0;
261         }
262
263         p += pull_netlogon_string(reply->server_site_name, p, (const char *)os3.data);
264         p += pull_netlogon_string(reply->client_site_name, p, (const char *)os3.data);
265
266         reply->version = IVAL(p, 0);
267         reply->lmnt_token = SVAL(p, 4);
268         reply->lm20_token = SVAL(p, 6);
269
270         data_blob_free(&os1);
271         data_blob_free(&os2);
272         data_blob_free(&os3);
273         data_blob_free(&blob);
274         
275         asn1_free(&data);
276
277         return 0;
278 }
279
280 /*******************************************************************
281   do a cldap netlogon query.  Always 389/udp
282 *******************************************************************/
283
284 BOOL ads_cldap_netlogon(const char *server, const char *realm,  struct cldap_netlogon_reply *reply)
285 {
286         int sock;
287         int ret;
288
289         sock = open_udp_socket(server, LDAP_PORT );
290         if (sock == -1) {
291                 DEBUG(2,("ads_cldap_netlogon: Failed to open udp socket to %s\n", 
292                          server));
293                 return False;
294         }
295
296         ret = send_cldap_netlogon(sock, realm, global_myname(), 6);
297         if (ret != 0) {
298                 return False;
299         }
300         ret = recv_cldap_netlogon(sock, reply);
301         close(sock);
302
303         if (ret == -1) {
304                 return False;
305         }
306
307         return True;
308 }
309
310