Context Navigation

source: branches/samba-3.0/source/libsmb/cliconnect.c@ 140

Visit:

Last change on this file since 140 was 140, checked in by Paul Smedley, 17 years ago
Update branch to 3.0.31 release
File size: 57.9 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	client connect/disconnect routines
4	Copyright (C) Andrew Tridgell 1994-1998
5	Copyright (C) Andrew Bartlett 2001-2003
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	extern pstring user_socket_options;
25
26	static const struct {
27	int prot;
28	const char *name;
29	} prots[] = {
30	{PROTOCOL_CORE,"PC NETWORK PROGRAM 1.0"},
31	{PROTOCOL_COREPLUS,"MICROSOFT NETWORKS 1.03"},
32	{PROTOCOL_LANMAN1,"MICROSOFT NETWORKS 3.0"},
33	{PROTOCOL_LANMAN1,"LANMAN1.0"},
34	{PROTOCOL_LANMAN2,"LM1.2X002"},
35	{PROTOCOL_LANMAN2,"DOS LANMAN2.1"},
36	{PROTOCOL_LANMAN2,"LANMAN2.1"},
37	{PROTOCOL_LANMAN2,"Samba"},
38	{PROTOCOL_NT1,"NT LANMAN 1.0"},
39	{PROTOCOL_NT1,"NT LM 0.12"},
40	{-1,NULL}
41	};
42
43	static const char star_smbserver_name = "SMBSERVER";
44
45	/**
46	* Set the user session key for a connection
47	* @param cli The cli structure to add it too
48	* @param session_key The session key used. (A copy of this is taken for the cli struct)
49	*
50	*/
51
52	static void cli_set_session_key (struct cli_state *cli, const DATA_BLOB session_key)
53	{
54	cli->user_session_key = data_blob(session_key.data, session_key.length);
55	}
56
57	/****************************************************************************
58	Do an old lanman2 style session setup.
59	****************************************************************************/
60
61	static NTSTATUS cli_session_setup_lanman2(struct cli_state *cli,
62	const char *user,
63	const char *pass, size_t passlen,
64	const char *workgroup)
65	{
66	DATA_BLOB session_key = data_blob(NULL, 0);
67	DATA_BLOB lm_response = data_blob(NULL, 0);
68	fstring pword;
69	char *p;
70
71	if (passlen > sizeof(pword)-1) {
72	return NT_STATUS_INVALID_PARAMETER;
73	}
74
75	/* LANMAN servers predate NT status codes and Unicode and ignore those
76	smb flags so we must disable the corresponding default capabilities
77	that would otherwise cause the Unicode and NT Status flags to be
78	set (and even returned by the server) */
79
80	cli->capabilities &= ~(CAP_UNICODE \| CAP_STATUS32);
81
82	/* if in share level security then don't send a password now */
83	if (!(cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL))
84	passlen = 0;
85
86	if (passlen > 0 && (cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && passlen != 24) {
87	/* Encrypted mode needed, and non encrypted password supplied. */
88	lm_response = data_blob(NULL, 24);
89	if (!SMBencrypt(pass, cli->secblob.data,(uchar *)lm_response.data)) {
90	DEBUG(1, ("Password is > 14 chars in length, and is therefore incompatible with Lanman authentication\n"));
91	return NT_STATUS_ACCESS_DENIED;
92	}
93	} else if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && passlen == 24) {
94	/* Encrypted mode needed, and encrypted password supplied. */
95	lm_response = data_blob(pass, passlen);
96	} else if (passlen > 0) {
97	/* Plaintext mode needed, assume plaintext supplied. */
98	passlen = clistr_push(cli, pword, pass, sizeof(pword), STR_TERMINATE);
99	lm_response = data_blob(pass, passlen);
100	}
101
102	/* send a session setup command */
103	memset(cli->outbuf,'\0',smb_size);
104	set_message(cli->outbuf,10, 0, True);
105	SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
106	cli_setup_packet(cli);
107
108	SCVAL(cli->outbuf,smb_vwv0,0xFF);
109	SSVAL(cli->outbuf,smb_vwv2,cli->max_xmit);
110	SSVAL(cli->outbuf,smb_vwv3,2);
111	SSVAL(cli->outbuf,smb_vwv4,1);
112	SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
113	SSVAL(cli->outbuf,smb_vwv7,lm_response.length);
114
115	p = smb_buf(cli->outbuf);
116	memcpy(p,lm_response.data,lm_response.length);
117	p += lm_response.length;
118	p += clistr_push(cli, p, user, -1, STR_TERMINATE\|STR_UPPER);
119	p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE\|STR_UPPER);
120	p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
121	p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
122	cli_setup_bcc(cli, p);
123
124	if (!cli_send_smb(cli) \|\| !cli_receive_smb(cli)) {
125	return cli_nt_error(cli);
126	}
127
128	show_msg(cli->inbuf);
129
130	if (cli_is_error(cli)) {
131	return cli_nt_error(cli);
132	}
133
134	/* use the returned vuid from now on */
135	cli->vuid = SVAL(cli->inbuf,smb_uid);
136	fstrcpy(cli->user_name, user);
137
138	if (session_key.data) {
139	/* Have plaintext orginal */
140	cli_set_session_key(cli, session_key);
141	}
142
143	return NT_STATUS_OK;
144	}
145
146	/****************************************************************************
147	Work out suitable capabilities to offer the server.
148	****************************************************************************/
149
150	static uint32 cli_session_setup_capabilities(struct cli_state *cli)
151	{
152	uint32 capabilities = CAP_NT_SMBS;
153
154	if (!cli->force_dos_errors)
155	capabilities \|= CAP_STATUS32;
156
157	if (cli->use_level_II_oplocks)
158	capabilities \|= CAP_LEVEL_II_OPLOCKS;
159
160	capabilities \|= (cli->capabilities & (CAP_UNICODE\|CAP_LARGE_FILES\|CAP_LARGE_READX\|CAP_LARGE_WRITEX\|CAP_DFS));
161	return capabilities;
162	}
163
164	/****************************************************************************
165	Do a NT1 guest session setup.
166	****************************************************************************/
167
168	static NTSTATUS cli_session_setup_guest(struct cli_state *cli)
169	{
170	char *p;
171	uint32 capabilities = cli_session_setup_capabilities(cli);
172
173	memset(cli->outbuf, '\0', smb_size);
174	set_message(cli->outbuf,13,0,True);
175	SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
176	cli_setup_packet(cli);
177
178	SCVAL(cli->outbuf,smb_vwv0,0xFF);
179	SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
180	SSVAL(cli->outbuf,smb_vwv3,2);
181	SSVAL(cli->outbuf,smb_vwv4,cli->pid);
182	SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
183	SSVAL(cli->outbuf,smb_vwv7,0);
184	SSVAL(cli->outbuf,smb_vwv8,0);
185	SIVAL(cli->outbuf,smb_vwv11,capabilities);
186	p = smb_buf(cli->outbuf);
187	p += clistr_push(cli, p, "", -1, STR_TERMINATE); /* username */
188	p += clistr_push(cli, p, "", -1, STR_TERMINATE); /* workgroup */
189	p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
190	p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
191	cli_setup_bcc(cli, p);
192
193	if (!cli_send_smb(cli) \|\| !cli_receive_smb(cli)) {
194	return cli_nt_error(cli);
195	}
196
197	show_msg(cli->inbuf);
198
199	if (cli_is_error(cli)) {
200	return cli_nt_error(cli);
201	}
202
203	cli->vuid = SVAL(cli->inbuf,smb_uid);
204
205	p = smb_buf(cli->inbuf);
206	p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
207	p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), -1, STR_TERMINATE);
208	p += clistr_pull(cli, cli->server_domain, p, sizeof(fstring), -1, STR_TERMINATE);
209
210	if (strstr(cli->server_type, "Samba")) {
211	cli->is_samba = True;
212	}
213
214	fstrcpy(cli->user_name, "");
215
216	return NT_STATUS_OK;
217	}
218
219	/****************************************************************************
220	Do a NT1 plaintext session setup.
221	****************************************************************************/
222
223	static NTSTATUS cli_session_setup_plaintext(struct cli_state *cli,
224	const char user, const char pass,
225	const char *workgroup)
226	{
227	uint32 capabilities = cli_session_setup_capabilities(cli);
228	char *p;
229	fstring lanman;
230
231	fstr_sprintf( lanman, "Samba %s", SAMBA_VERSION_STRING);
232
233	memset(cli->outbuf, '\0', smb_size);
234	set_message(cli->outbuf,13,0,True);
235	SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
236	cli_setup_packet(cli);
237
238	SCVAL(cli->outbuf,smb_vwv0,0xFF);
239	SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
240	SSVAL(cli->outbuf,smb_vwv3,2);
241	SSVAL(cli->outbuf,smb_vwv4,cli->pid);
242	SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
243	SSVAL(cli->outbuf,smb_vwv8,0);
244	SIVAL(cli->outbuf,smb_vwv11,capabilities);
245	p = smb_buf(cli->outbuf);
246
247	/* check wether to send the ASCII or UNICODE version of the password */
248
249	if ( (capabilities & CAP_UNICODE) == 0 ) {
250	p += clistr_push(cli, p, pass, -1, STR_TERMINATE); /* password */
251	SSVAL(cli->outbuf,smb_vwv7,PTR_DIFF(p, smb_buf(cli->outbuf)));
252	} else {
253	/* For ucs2 passwords clistr_push calls ucs2_align, which causes
254	* the space taken by the unicode password to be one byte too
255	* long (as we're on an odd byte boundary here). Reduce the
256	* count by 1 to cope with this. Fixes smbclient against NetApp
257	* servers which can't cope. Fix from
258	* bryan.kolodziej@allenlund.com in bug #3840.
259	*/
260	p += clistr_push(cli, p, pass, -1, STR_UNICODE\|STR_TERMINATE); /* unicode password */
261	SSVAL(cli->outbuf,smb_vwv8,PTR_DIFF(p, smb_buf(cli->outbuf))-1);
262	}
263
264	p += clistr_push(cli, p, user, -1, STR_TERMINATE); /* username */
265	p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE); /* workgroup */
266	p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
267	p += clistr_push(cli, p, lanman, -1, STR_TERMINATE);
268	cli_setup_bcc(cli, p);
269
270	if (!cli_send_smb(cli) \|\| !cli_receive_smb(cli)) {
271	return cli_nt_error(cli);
272	}
273
274	show_msg(cli->inbuf);
275
276	if (cli_is_error(cli)) {
277	return cli_nt_error(cli);
278	}
279
280	cli->vuid = SVAL(cli->inbuf,smb_uid);
281	p = smb_buf(cli->inbuf);
282	p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
283	p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), -1, STR_TERMINATE);
284	p += clistr_pull(cli, cli->server_domain, p, sizeof(fstring), -1, STR_TERMINATE);
285	fstrcpy(cli->user_name, user);
286
287	if (strstr(cli->server_type, "Samba")) {
288	cli->is_samba = True;
289	}
290
291	return NT_STATUS_OK;
292	}
293
294	/****************************************************************************
295	do a NT1 NTLM/LM encrypted session setup - for when extended security
296	is not negotiated.
297	@param cli client state to create do session setup on
298	@param user username
299	@param pass either cleartext password (passlen !=24) or LM response.
300	@param ntpass NT response, implies ntpasslen >=24, implies pass is not clear
301	@param workgroup The user's domain.
302	****************************************************************************/
303
304	static NTSTATUS cli_session_setup_nt1(struct cli_state cli, const char user,
305	const char *pass, size_t passlen,
306	const char *ntpass, size_t ntpasslen,
307	const char *workgroup)
308	{
309	uint32 capabilities = cli_session_setup_capabilities(cli);
310	DATA_BLOB lm_response = data_blob(NULL, 0);
311	DATA_BLOB nt_response = data_blob(NULL, 0);
312	DATA_BLOB session_key = data_blob(NULL, 0);
313	NTSTATUS result;
314	char *p;
315
316	if (passlen == 0) {
317	/* do nothing - guest login */
318	} else if (passlen != 24) {
319	if (lp_client_ntlmv2_auth()) {
320	DATA_BLOB server_chal;
321	DATA_BLOB names_blob;
322	server_chal = data_blob(cli->secblob.data, MIN(cli->secblob.length, 8));
323
324	/* note that the 'workgroup' here is a best guess - we don't know
325	the server's domain at this point. The 'server name' is also
326	dodgy...
327	*/
328	names_blob = NTLMv2_generate_names_blob(cli->called.name, workgroup);
329
330	if (!SMBNTLMv2encrypt(user, workgroup, pass, &server_chal,
331	&names_blob,
332	&lm_response, &nt_response, &session_key)) {
333	data_blob_free(&names_blob);
334	data_blob_free(&server_chal);
335	return NT_STATUS_ACCESS_DENIED;
336	}
337	data_blob_free(&names_blob);
338	data_blob_free(&server_chal);
339
340	} else {
341	uchar nt_hash[16];
342	E_md4hash(pass, nt_hash);
343
344	#ifdef LANMAN_ONLY
345	nt_response = data_blob(NULL, 0);
346	#else
347	nt_response = data_blob(NULL, 24);
348	SMBNTencrypt(pass,cli->secblob.data,nt_response.data);
349	#endif
350	/* non encrypted password supplied. Ignore ntpass. */
351	if (lp_client_lanman_auth()) {
352	lm_response = data_blob(NULL, 24);
353	if (!SMBencrypt(pass,cli->secblob.data, lm_response.data)) {
354	/* Oops, the LM response is invalid, just put
355	the NT response there instead */
356	data_blob_free(&lm_response);
357	lm_response = data_blob(nt_response.data, nt_response.length);
358	}
359	} else {
360	/* LM disabled, place NT# in LM field instead */
361	lm_response = data_blob(nt_response.data, nt_response.length);
362	}
363
364	session_key = data_blob(NULL, 16);
365	#ifdef LANMAN_ONLY
366	E_deshash(pass, session_key.data);
367	memset(&session_key.data[8], '\0', 8);
368	#else
369	SMBsesskeygen_ntv1(nt_hash, NULL, session_key.data);
370	#endif
371	}
372	#ifdef LANMAN_ONLY
373	cli_simple_set_signing(cli, session_key, lm_response);
374	#else
375	cli_simple_set_signing(cli, session_key, nt_response);
376	#endif
377	} else {
378	/* pre-encrypted password supplied. Only used for
379	security=server, can't do
380	signing because we don't have original key */
381
382	lm_response = data_blob(pass, passlen);
383	nt_response = data_blob(ntpass, ntpasslen);
384	}
385
386	/* send a session setup command */
387	memset(cli->outbuf,'\0',smb_size);
388
389	set_message(cli->outbuf,13,0,True);
390	SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
391	cli_setup_packet(cli);
392
393	SCVAL(cli->outbuf,smb_vwv0,0xFF);
394	SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
395	SSVAL(cli->outbuf,smb_vwv3,2);
396	SSVAL(cli->outbuf,smb_vwv4,cli->pid);
397	SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
398	SSVAL(cli->outbuf,smb_vwv7,lm_response.length);
399	SSVAL(cli->outbuf,smb_vwv8,nt_response.length);
400	SIVAL(cli->outbuf,smb_vwv11,capabilities);
401	p = smb_buf(cli->outbuf);
402	if (lm_response.length) {
403	memcpy(p,lm_response.data, lm_response.length); p += lm_response.length;
404	}
405	if (nt_response.length) {
406	memcpy(p,nt_response.data, nt_response.length); p += nt_response.length;
407	}
408	p += clistr_push(cli, p, user, -1, STR_TERMINATE);
409
410	/* Upper case here might help some NTLMv2 implementations */
411	p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE\|STR_UPPER);
412	p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
413	p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
414	cli_setup_bcc(cli, p);
415
416	if (!cli_send_smb(cli) \|\| !cli_receive_smb(cli)) {
417	result = cli_nt_error(cli);
418	goto end;
419	}
420
421	/* show_msg(cli->inbuf); */
422
423	if (cli_is_error(cli)) {
424	result = cli_nt_error(cli);
425	goto end;
426	}
427
428	/* use the returned vuid from now on */
429	cli->vuid = SVAL(cli->inbuf,smb_uid);
430
431	p = smb_buf(cli->inbuf);
432	p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
433	p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), -1, STR_TERMINATE);
434	p += clistr_pull(cli, cli->server_domain, p, sizeof(fstring), -1, STR_TERMINATE);
435
436	if (strstr(cli->server_type, "Samba")) {
437	cli->is_samba = True;
438	}
439
440	fstrcpy(cli->user_name, user);
441
442	if (session_key.data) {
443	/* Have plaintext orginal */
444	cli_set_session_key(cli, session_key);
445	}
446
447	result = NT_STATUS_OK;
448	end:
449	data_blob_free(&lm_response);
450	data_blob_free(&nt_response);
451	data_blob_free(&session_key);
452	return result;
453	}
454
455	/****************************************************************************
456	Send a extended security session setup blob
457	****************************************************************************/
458
459	static BOOL cli_session_setup_blob_send(struct cli_state *cli, DATA_BLOB blob)
460	{
461	uint32 capabilities = cli_session_setup_capabilities(cli);
462	char *p;
463
464	capabilities \|= CAP_EXTENDED_SECURITY;
465
466	/* send a session setup command */
467	memset(cli->outbuf,'\0',smb_size);
468
469	set_message(cli->outbuf,12,0,True);
470	SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
471
472	cli_setup_packet(cli);
473
474	SCVAL(cli->outbuf,smb_vwv0,0xFF);
475	SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
476	SSVAL(cli->outbuf,smb_vwv3,2);
477	SSVAL(cli->outbuf,smb_vwv4,1);
478	SIVAL(cli->outbuf,smb_vwv5,0);
479	SSVAL(cli->outbuf,smb_vwv7,blob.length);
480	SIVAL(cli->outbuf,smb_vwv10,capabilities);
481	p = smb_buf(cli->outbuf);
482	memcpy(p, blob.data, blob.length);
483	p += blob.length;
484	p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
485	p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
486	cli_setup_bcc(cli, p);
487	return cli_send_smb(cli);
488	}
489
490	/****************************************************************************
491	Send a extended security session setup blob, returning a reply blob.
492	****************************************************************************/
493
494	static DATA_BLOB cli_session_setup_blob_receive(struct cli_state *cli)
495	{
496	DATA_BLOB blob2 = data_blob(NULL, 0);
497	char *p;
498	size_t len;
499
500	if (!cli_receive_smb(cli))
501	return blob2;
502
503	show_msg(cli->inbuf);
504
505	if (cli_is_error(cli) && !NT_STATUS_EQUAL(cli_nt_error(cli),
506	NT_STATUS_MORE_PROCESSING_REQUIRED)) {
507	return blob2;
508	}
509
510	/* use the returned vuid from now on */
511	cli->vuid = SVAL(cli->inbuf,smb_uid);
512
513	p = smb_buf(cli->inbuf);
514
515	blob2 = data_blob(p, SVAL(cli->inbuf, smb_vwv3));
516
517	p += blob2.length;
518	p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
519
520	/* w2k with kerberos doesn't properly null terminate this field */
521	len = smb_buflen(cli->inbuf) - PTR_DIFF(p, smb_buf(cli->inbuf));
522	p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), len, 0);
523
524	return blob2;
525	}
526
527	#ifdef HAVE_KRB5
528	/****************************************************************************
529	Send a extended security session setup blob, returning a reply blob.
530	****************************************************************************/
531
532	/* The following is calculated from :
533	* (smb_size-4) = 35
534	* (smb_wcnt * 2) = 24 (smb_wcnt == 12 in cli_session_setup_blob_send() )
535	* (strlen("Unix") + 1 + strlen("Samba") + 1) * 2 = 22 (unicode strings at
536	* end of packet.
537	*/
538
539	#define BASE_SESSSETUP_BLOB_PACKET_SIZE (35 + 24 + 22)
540
541	static BOOL cli_session_setup_blob(struct cli_state *cli, DATA_BLOB blob, DATA_BLOB session_key_krb5)
542	{
543	int32 remaining = blob.length;
544	int32 cur = 0;
545	DATA_BLOB send_blob = data_blob(NULL, 0);
546	int32 max_blob_size = 0;
547	DATA_BLOB receive_blob = data_blob(NULL, 0);
548
549	if (cli->max_xmit < BASE_SESSSETUP_BLOB_PACKET_SIZE + 1) {
550	DEBUG(0,("cli_session_setup_blob: cli->max_xmit too small "
551	"(was %u, need minimum %u)\n",
552	(unsigned int)cli->max_xmit,
553	BASE_SESSSETUP_BLOB_PACKET_SIZE));
554	cli_set_nt_error(cli, NT_STATUS_INVALID_PARAMETER);
555	return False;
556	}
557
558	max_blob_size = cli->max_xmit - BASE_SESSSETUP_BLOB_PACKET_SIZE;
559
560	while ( remaining > 0) {
561	if (remaining >= max_blob_size) {
562	send_blob.length = max_blob_size;
563	remaining -= max_blob_size;
564	} else {
565	DATA_BLOB null_blob = data_blob(NULL, 0);
566
567	send_blob.length = remaining;
568	remaining = 0;
569
570	/* This is the last packet in the sequence - turn signing on. */
571	cli_simple_set_signing(cli, session_key_krb5, null_blob);
572	}
573
574	send_blob.data = &blob.data[cur];
575	cur += send_blob.length;
576
577	DEBUG(10, ("cli_session_setup_blob: Remaining (%u) sending (%u) current (%u)\n",
578	(unsigned int)remaining,
579	(unsigned int)send_blob.length,
580	(unsigned int)cur ));
581
582	if (!cli_session_setup_blob_send(cli, send_blob)) {
583	DEBUG(0, ("cli_session_setup_blob: send failed\n"));
584	return False;
585	}
586
587	receive_blob = cli_session_setup_blob_receive(cli);
588	data_blob_free(&receive_blob);
589
590	if (cli_is_error(cli) &&
591	!NT_STATUS_EQUAL( cli_get_nt_error(cli),
592	NT_STATUS_MORE_PROCESSING_REQUIRED)) {
593	DEBUG(0, ("cli_session_setup_blob: recieve failed (%s)\n",
594	nt_errstr(cli_get_nt_error(cli)) ));
595	cli->vuid = 0;
596	return False;
597	}
598	}
599
600	return True;
601	}
602
603	/****************************************************************************
604	Use in-memory credentials cache
605	****************************************************************************/
606
607	static void use_in_memory_ccache(void) {
608	setenv(KRB5_ENV_CCNAME, "MEMORY:cliconnect", 1);
609	}
610
611	/****************************************************************************
612	Do a spnego/kerberos encrypted session setup.
613	****************************************************************************/
614
615	static ADS_STATUS cli_session_setup_kerberos(struct cli_state cli, const char principal, const char *workgroup)
616	{
617	DATA_BLOB negTokenTarg;
618	DATA_BLOB session_key_krb5;
619	int rc;
620
621	DEBUG(2,("Doing kerberos session setup\n"));
622
623	/* generate the encapsulated kerberos5 ticket */
624	rc = spnego_gen_negTokenTarg(principal, 0, &negTokenTarg, &session_key_krb5, 0, NULL);
625
626	if (rc) {
627	DEBUG(1, ("cli_session_setup_kerberos: spnego_gen_negTokenTarg failed: %s\n",
628	error_message(rc)));
629	return ADS_ERROR_KRB5(rc);
630	}
631
632	#if 0
633	file_save("negTokenTarg.dat", negTokenTarg.data, negTokenTarg.length);
634	#endif
635
636	if (!cli_session_setup_blob(cli, negTokenTarg, session_key_krb5)) {
637	data_blob_free(&negTokenTarg);
638	data_blob_free(&session_key_krb5);
639	return ADS_ERROR_NT(cli_nt_error(cli));
640	}
641
642	cli_set_session_key(cli, session_key_krb5);
643
644	data_blob_free(&negTokenTarg);
645	data_blob_free(&session_key_krb5);
646
647	if (cli_is_error(cli)) {
648	if (NT_STATUS_IS_OK(cli_nt_error(cli))) {
649	return ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
650	}
651	}
652	return ADS_ERROR_NT(cli_nt_error(cli));
653	}
654	#endif /* HAVE_KRB5 */
655
656
657	/****************************************************************************
658	Do a spnego/NTLMSSP encrypted session setup.
659	****************************************************************************/
660
661	static NTSTATUS cli_session_setup_ntlmssp(struct cli_state cli, const char user,
662	const char pass, const char domain)
663	{
664	struct ntlmssp_state *ntlmssp_state;
665	NTSTATUS nt_status;
666	int turn = 1;
667	DATA_BLOB msg1;
668	DATA_BLOB blob = data_blob(NULL, 0);
669	DATA_BLOB blob_in = data_blob(NULL, 0);
670	DATA_BLOB blob_out = data_blob(NULL, 0);
671
672	cli_temp_set_signing(cli);
673
674	if (!NT_STATUS_IS_OK(nt_status = ntlmssp_client_start(&ntlmssp_state))) {
675	return nt_status;
676	}
677	ntlmssp_want_feature(ntlmssp_state, NTLMSSP_FEATURE_SESSION_KEY);
678
679	if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_username(ntlmssp_state, user))) {
680	return nt_status;
681	}
682	if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_domain(ntlmssp_state, domain))) {
683	return nt_status;
684	}
685	if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_password(ntlmssp_state, pass))) {
686	return nt_status;
687	}
688
689	do {
690	nt_status = ntlmssp_update(ntlmssp_state,
691	blob_in, &blob_out);
692	data_blob_free(&blob_in);
693	if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED) \|\| NT_STATUS_IS_OK(nt_status)) {
694	if (turn == 1) {
695	/* and wrap it in a SPNEGO wrapper */
696	msg1 = gen_negTokenInit(OID_NTLMSSP, blob_out);
697	} else {
698	/* wrap it in SPNEGO */
699	msg1 = spnego_gen_auth(blob_out);
700	}
701
702	/* now send that blob on its way */
703	if (!cli_session_setup_blob_send(cli, msg1)) {
704	DEBUG(3, ("Failed to send NTLMSSP/SPNEGO blob to server!\n"));
705	nt_status = NT_STATUS_UNSUCCESSFUL;
706	} else {
707	blob = cli_session_setup_blob_receive(cli);
708
709	nt_status = cli_nt_error(cli);
710	if (cli_is_error(cli) && NT_STATUS_IS_OK(nt_status)) {
711	if (cli->smb_rw_error == READ_BAD_SIG) {
712	nt_status = NT_STATUS_ACCESS_DENIED;
713	} else {
714	nt_status = NT_STATUS_UNSUCCESSFUL;
715	}
716	}
717	}
718	data_blob_free(&msg1);
719	}
720
721	if (!blob.length) {
722	if (NT_STATUS_IS_OK(nt_status)) {
723	nt_status = NT_STATUS_UNSUCCESSFUL;
724	}
725	} else if ((turn == 1) &&
726	NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
727	DATA_BLOB tmp_blob = data_blob(NULL, 0);
728	/* the server might give us back two challenges */
729	if (!spnego_parse_challenge(blob, &blob_in,
730	&tmp_blob)) {
731	DEBUG(3,("Failed to parse challenges\n"));
732	nt_status = NT_STATUS_INVALID_PARAMETER;
733	}
734	data_blob_free(&tmp_blob);
735	} else {
736	if (!spnego_parse_auth_response(blob, nt_status,
737	&blob_in)) {
738	DEBUG(3,("Failed to parse auth response\n"));
739	if (NT_STATUS_IS_OK(nt_status)
740	\|\| NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED))
741	nt_status = NT_STATUS_INVALID_PARAMETER;
742	}
743	}
744	data_blob_free(&blob);
745	data_blob_free(&blob_out);
746	turn++;
747	} while (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED));
748
749	data_blob_free(&blob_in);
750
751	if (NT_STATUS_IS_OK(nt_status)) {
752
753	DATA_BLOB key = data_blob(ntlmssp_state->session_key.data,
754	ntlmssp_state->session_key.length);
755	DATA_BLOB null_blob = data_blob(NULL, 0);
756	BOOL res;
757
758	fstrcpy(cli->server_domain, ntlmssp_state->server_domain);
759	cli_set_session_key(cli, ntlmssp_state->session_key);
760
761	res = cli_simple_set_signing(cli, key, null_blob);
762
763	data_blob_free(&key);
764
765	if (res) {
766
767	/* 'resign' the last message, so we get the right sequence numbers
768	for checking the first reply from the server */
769	cli_calculate_sign_mac(cli);
770
771	if (!cli_check_sign_mac(cli)) {
772	nt_status = NT_STATUS_ACCESS_DENIED;
773	}
774	}
775	}
776
777	/* we have a reference conter on ntlmssp_state, if we are signing
778	then the state will be kept by the signing engine */
779
780	ntlmssp_end(&ntlmssp_state);
781
782	if (!NT_STATUS_IS_OK(nt_status)) {
783	cli->vuid = 0;
784	}
785	return nt_status;
786	}
787
788	/****************************************************************************
789	Do a spnego encrypted session setup.
790
791	user_domain: The shortname of the domain the user/machine is a member of.
792	dest_realm: The realm we're connecting to, if NULL we use our default realm.
793	****************************************************************************/
794
795	ADS_STATUS cli_session_setup_spnego(struct cli_state cli, const char user,
796	const char pass, const char user_domain,
797	const char * dest_realm)
798	{
799	char *principal = NULL;
800	char *OIDs[ASN1_MAX_OIDS];
801	int i;
802	BOOL got_kerberos_mechanism = False;
803	DATA_BLOB blob;
804
805	DEBUG(3,("Doing spnego session setup (blob length=%lu)\n", (unsigned long)cli->secblob.length));
806
807	/* the server might not even do spnego */
808	if (cli->secblob.length <= 16) {
809	DEBUG(3,("server didn't supply a full spnego negprot\n"));
810	goto ntlmssp;
811	}
812
813	#if 0
814	file_save("negprot.dat", cli->secblob.data, cli->secblob.length);
815	#endif
816
817	/* there is 16 bytes of GUID before the real spnego packet starts */
818	blob = data_blob(cli->secblob.data+16, cli->secblob.length-16);
819
820	/* The server sent us the first part of the SPNEGO exchange in the
821	* negprot reply. It is WRONG to depend on the principal sent in the
822	* negprot reply, but right now we do it. If we don't receive one,
823	* we try to best guess, then fall back to NTLM. */
824	if (!spnego_parse_negTokenInit(blob, OIDs, &principal)) {
825	data_blob_free(&blob);
826	return ADS_ERROR_NT(NT_STATUS_INVALID_PARAMETER);
827	}
828	data_blob_free(&blob);
829
830	/* make sure the server understands kerberos */
831	for (i=0;OIDs[i];i++) {
832	DEBUG(3,("got OID=%s\n", OIDs[i]));
833	if (strcmp(OIDs[i], OID_KERBEROS5_OLD) == 0 \|\|
834	strcmp(OIDs[i], OID_KERBEROS5) == 0) {
835	got_kerberos_mechanism = True;
836	}
837	free(OIDs[i]);
838	}
839
840	DEBUG(3,("got principal=%s\n", principal ? principal : "<null>"));
841
842	fstrcpy(cli->user_name, user);
843
844	#ifdef HAVE_KRB5
845	/* If password is set we reauthenticate to kerberos server
846	* and do not store results */
847
848	if (got_kerberos_mechanism && cli->use_kerberos) {
849	ADS_STATUS rc;
850
851	if (pass && *pass) {
852	int ret;
853
854	use_in_memory_ccache();
855	ret = kerberos_kinit_password(user, pass, 0 /* no time correction for now */, NULL);
856
857	if (ret){
858	SAFE_FREE(principal);
859	DEBUG(0, ("Kinit failed: %s\n", error_message(ret)));
860	if (cli->fallback_after_kerberos)
861	goto ntlmssp;
862	return ADS_ERROR_KRB5(ret);
863	}
864	}
865
866	/* If we get a bad principal, try to guess it if
867	we have a valid host NetBIOS name.
868	*/
869	if (strequal(principal, ADS_IGNORE_PRINCIPAL)) {
870	SAFE_FREE(principal);
871	}
872	if (principal == NULL &&
873	!is_ipaddress(cli->desthost) &&
874	!strequal(star_smbserver_name,
875	cli->desthost)) {
876	char *realm = NULL;
877	char *machine = NULL;
878	char *host = NULL;
879	DEBUG(3,("cli_session_setup_spnego: got a "
880	"bad server principal, trying to guess ...\n"));
881
882	host = strchr_m(cli->desthost, '.');
883	if (host) {
884	machine = SMB_STRNDUP(cli->desthost,
885	host - cli->desthost);
886	} else {
887	machine = SMB_STRDUP(cli->desthost);
888	}
889	if (machine == NULL) {
890	return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
891	}
892
893	if (dest_realm) {
894	realm = SMB_STRDUP(dest_realm);
895	strupper_m(realm);
896	} else {
897	realm = kerberos_get_default_realm_from_ccache();
898	}
899	if (realm && *realm) {
900	if (asprintf(&principal, "%s$@%s",
901	machine, realm) < 0) {
902	SAFE_FREE(machine);
903	SAFE_FREE(realm);
904	return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
905	}
906	DEBUG(3,("cli_session_setup_spnego: guessed "
907	"server principal=%s\n",
908	principal ? principal : "<null>"));
909	}
910	SAFE_FREE(machine);
911	SAFE_FREE(realm);
912	}
913
914	if (principal) {
915	rc = cli_session_setup_kerberos(cli, principal,
916	dest_realm);
917	if (ADS_ERR_OK(rc) \|\| !cli->fallback_after_kerberos) {
918	SAFE_FREE(principal);
919	return rc;
920	}
921	}
922	}
923	#endif
924
925	SAFE_FREE(principal);
926
927	ntlmssp:
928
929	return ADS_ERROR_NT(cli_session_setup_ntlmssp(cli, user, pass,
930	user_domain));
931	}
932
933	/****************************************************************************
934	Send a session setup. The username and workgroup is in UNIX character
935	format and must be converted to DOS codepage format before sending. If the
936	password is in plaintext, the same should be done.
937	****************************************************************************/
938
939	NTSTATUS cli_session_setup(struct cli_state *cli,
940	const char *user,
941	const char *pass, int passlen,
942	const char *ntpass, int ntpasslen,
943	const char *workgroup)
944	{
945	char *p;
946	fstring user2;
947
948	/* allow for workgroups as part of the username */
949	fstrcpy(user2, user);
950	if ((p=strchr_m(user2,'\\')) \|\| (p=strchr_m(user2,'/')) \|\|
951	(p=strchr_m(user2,*lp_winbind_separator()))) {
952	*p = 0;
953	user = p+1;
954	workgroup = user2;
955	}
956
957	if (cli->protocol < PROTOCOL_LANMAN1) {
958	return NT_STATUS_OK;
959	}
960
961	/* now work out what sort of session setup we are going to
962	do. I have split this into separate functions to make the
963	flow a bit easier to understand (tridge) */
964
965	/* if its an older server then we have to use the older request format */
966
967	if (cli->protocol < PROTOCOL_NT1) {
968	if (!lp_client_lanman_auth() && passlen != 24 && (*pass)) {
969	DEBUG(1, ("Server requested LM password but 'client lanman auth'"
970	" is disabled\n"));
971	return NT_STATUS_ACCESS_DENIED;
972	}
973
974	if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0 &&
975	!lp_client_plaintext_auth() && (*pass)) {
976	DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
977	" is disabled\n"));
978	return NT_STATUS_ACCESS_DENIED;
979	}
980
981	return cli_session_setup_lanman2(cli, user, pass, passlen,
982	workgroup);
983	}
984
985	/* if no user is supplied then we have to do an anonymous connection.
986	passwords are ignored */
987
988	if (!user \|\| !*user)
989	return cli_session_setup_guest(cli);
990
991	/* if the server is share level then send a plaintext null
992	password at this point. The password is sent in the tree
993	connect */
994
995	if ((cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) == 0)
996	return cli_session_setup_plaintext(cli, user, "", workgroup);
997
998	/* if the server doesn't support encryption then we have to use
999	plaintext. The second password is ignored */
1000
1001	if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0) {
1002	if (!lp_client_plaintext_auth() && (*pass)) {
1003	DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
1004	" is disabled\n"));
1005	return NT_STATUS_ACCESS_DENIED;
1006	}
1007	return cli_session_setup_plaintext(cli, user, pass, workgroup);
1008	}
1009
1010	/* if the server supports extended security then use SPNEGO */
1011
1012	if (cli->capabilities & CAP_EXTENDED_SECURITY) {
1013	ADS_STATUS status = cli_session_setup_spnego(cli, user, pass,
1014	workgroup, NULL);
1015	if (!ADS_ERR_OK(status)) {
1016	DEBUG(3, ("SPNEGO login failed: %s\n", ads_errstr(status)));
1017	return ads_ntstatus(status);
1018	}
1019	} else {
1020	NTSTATUS status;
1021
1022	/* otherwise do a NT1 style session setup */
1023	status = cli_session_setup_nt1(cli, user, pass, passlen,
1024	ntpass, ntpasslen, workgroup);
1025	if (!NT_STATUS_IS_OK(status)) {
1026	DEBUG(3,("cli_session_setup: NT1 session setup "
1027	"failed: %s\n", nt_errstr(status)));
1028	return status;
1029	}
1030	}
1031
1032	if (strstr(cli->server_type, "Samba")) {
1033	cli->is_samba = True;
1034	}
1035
1036	return NT_STATUS_OK;
1037	}
1038
1039	/****************************************************************************
1040	Send a uloggoff.
1041	*****************************************************************************/
1042
1043	BOOL cli_ulogoff(struct cli_state *cli)
1044	{
1045	memset(cli->outbuf,'\0',smb_size);
1046	set_message(cli->outbuf,2,0,True);
1047	SCVAL(cli->outbuf,smb_com,SMBulogoffX);
1048	cli_setup_packet(cli);
1049	SSVAL(cli->outbuf,smb_vwv0,0xFF);
1050	SSVAL(cli->outbuf,smb_vwv2,0); /* no additional info */
1051
1052	cli_send_smb(cli);
1053	if (!cli_receive_smb(cli))
1054	return False;
1055
1056	if (cli_is_error(cli)) {
1057	return False;
1058	}
1059
1060	cli->cnum = -1;
1061	return True;
1062	}
1063
1064	/****************************************************************************
1065	Send a tconX.
1066	****************************************************************************/
1067
1068	BOOL cli_send_tconX(struct cli_state *cli,
1069	const char share, const char dev, const char *pass, int passlen)
1070	{
1071	fstring fullshare, pword;
1072	char *p;
1073	memset(cli->outbuf,'\0',smb_size);
1074	memset(cli->inbuf,'\0',smb_size);
1075
1076	fstrcpy(cli->share, share);
1077
1078	/* in user level security don't send a password now */
1079	if (cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) {
1080	passlen = 1;
1081	pass = "";
1082	} else if (!pass) {
1083	DEBUG(1, ("Server not using user level security and no password supplied.\n"));
1084	return False;
1085	}
1086
1087	if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) &&
1088	*pass && passlen != 24) {
1089	if (!lp_client_lanman_auth()) {
1090	DEBUG(1, ("Server requested LANMAN password (share-level security) but 'client use lanman auth'"
1091	" is disabled\n"));
1092	return False;
1093	}
1094
1095	/*
1096	* Non-encrypted passwords - convert to DOS codepage before encryption.
1097	*/
1098	passlen = 24;
1099	SMBencrypt(pass,cli->secblob.data,(uchar *)pword);
1100	} else {
1101	if((cli->sec_mode & (NEGOTIATE_SECURITY_USER_LEVEL\|NEGOTIATE_SECURITY_CHALLENGE_RESPONSE)) == 0) {
1102	if (!lp_client_plaintext_auth() && (*pass)) {
1103	DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
1104	" is disabled\n"));
1105	return False;
1106	}
1107
1108	/*
1109	* Non-encrypted passwords - convert to DOS codepage before using.
1110	*/
1111	passlen = clistr_push(cli, pword, pass, sizeof(pword), STR_TERMINATE);
1112
1113	} else {
1114	if (passlen) {
1115	memcpy(pword, pass, passlen);
1116	}
1117	}
1118	}
1119
1120	slprintf(fullshare, sizeof(fullshare)-1,
1121	"\\\\%s\\%s", cli->desthost, share);
1122
1123	set_message(cli->outbuf,4, 0, True);
1124	SCVAL(cli->outbuf,smb_com,SMBtconX);
1125	cli_setup_packet(cli);
1126
1127	SSVAL(cli->outbuf,smb_vwv0,0xFF);
1128	SSVAL(cli->outbuf,smb_vwv2,TCONX_FLAG_EXTENDED_RESPONSE);
1129	SSVAL(cli->outbuf,smb_vwv3,passlen);
1130
1131	p = smb_buf(cli->outbuf);
1132	if (passlen) {
1133	memcpy(p,pword,passlen);
1134	}
1135	p += passlen;
1136	p += clistr_push(cli, p, fullshare, -1, STR_TERMINATE \|STR_UPPER);
1137	p += clistr_push(cli, p, dev, -1, STR_TERMINATE \|STR_UPPER \| STR_ASCII);
1138
1139	cli_setup_bcc(cli, p);
1140
1141	cli_send_smb(cli);
1142	if (!cli_receive_smb(cli))
1143	return False;
1144
1145	if (cli_is_error(cli))
1146	return False;
1147
1148	clistr_pull(cli, cli->dev, smb_buf(cli->inbuf), sizeof(fstring), -1, STR_TERMINATE\|STR_ASCII);
1149
1150	if (cli->protocol >= PROTOCOL_NT1 &&
1151	smb_buflen(cli->inbuf) == 3) {
1152	/* almost certainly win95 - enable bug fixes */
1153	cli->win95 = True;
1154	}
1155
1156	/* Make sure that we have the optional support 16-bit field. WCT > 2 */
1157	/* Avoids issues when connecting to Win9x boxes sharing files */
1158
1159	cli->dfsroot = False;
1160	if ( (CVAL(cli->inbuf, smb_wct))>2 && cli->protocol >= PROTOCOL_LANMAN2 )
1161	cli->dfsroot = (SVAL( cli->inbuf, smb_vwv2 ) & SMB_SHARE_IN_DFS) ? True : False;
1162
1163	cli->cnum = SVAL(cli->inbuf,smb_tid);
1164	return True;
1165	}
1166
1167	/****************************************************************************
1168	Send a tree disconnect.
1169	****************************************************************************/
1170
1171	BOOL cli_tdis(struct cli_state *cli)
1172	{
1173	memset(cli->outbuf,'\0',smb_size);
1174	set_message(cli->outbuf,0,0,True);
1175	SCVAL(cli->outbuf,smb_com,SMBtdis);
1176	SSVAL(cli->outbuf,smb_tid,cli->cnum);
1177	cli_setup_packet(cli);
1178
1179	cli_send_smb(cli);
1180	if (!cli_receive_smb(cli))
1181	return False;
1182
1183	if (cli_is_error(cli)) {
1184	return False;
1185	}
1186
1187	cli->cnum = -1;
1188	return True;
1189	}
1190
1191	/****************************************************************************
1192	Send a negprot command.
1193	****************************************************************************/
1194
1195	void cli_negprot_send(struct cli_state *cli)
1196	{
1197	char *p;
1198	int numprots;
1199
1200	if (cli->protocol < PROTOCOL_NT1)
1201	cli->use_spnego = False;
1202
1203	memset(cli->outbuf,'\0',smb_size);
1204
1205	/* setup the protocol strings */
1206	set_message(cli->outbuf,0,0,True);
1207
1208	p = smb_buf(cli->outbuf);
1209	for (numprots=0;
1210	prots[numprots].name && prots[numprots].prot<=cli->protocol;
1211	numprots++) {
1212	*p++ = 2;
1213	p += clistr_push(cli, p, prots[numprots].name, -1, STR_TERMINATE);
1214	}
1215
1216	SCVAL(cli->outbuf,smb_com,SMBnegprot);
1217	cli_setup_bcc(cli, p);
1218	cli_setup_packet(cli);
1219
1220	SCVAL(smb_buf(cli->outbuf),0,2);
1221
1222	cli_send_smb(cli);
1223	}
1224
1225	/****************************************************************************
1226	Send a negprot command.
1227	****************************************************************************/
1228
1229	BOOL cli_negprot(struct cli_state *cli)
1230	{
1231	char *p;
1232	int numprots;
1233	int plength;
1234
1235	if (cli->protocol < PROTOCOL_NT1)
1236	cli->use_spnego = False;
1237
1238	memset(cli->outbuf,'\0',smb_size);
1239
1240	/* setup the protocol strings */
1241	for (plength=0,numprots=0;
1242	prots[numprots].name && prots[numprots].prot<=cli->protocol;
1243	numprots++)
1244	plength += strlen(prots[numprots].name)+2;
1245
1246	set_message(cli->outbuf,0,plength,True);
1247
1248	p = smb_buf(cli->outbuf);
1249	for (numprots=0;
1250	prots[numprots].name && prots[numprots].prot<=cli->protocol;
1251	numprots++) {
1252	*p++ = 2;
1253	p += clistr_push(cli, p, prots[numprots].name, -1, STR_TERMINATE);
1254	}
1255
1256	SCVAL(cli->outbuf,smb_com,SMBnegprot);
1257	cli_setup_packet(cli);
1258
1259	SCVAL(smb_buf(cli->outbuf),0,2);
1260
1261	cli_send_smb(cli);
1262	if (!cli_receive_smb(cli))
1263	return False;
1264
1265	show_msg(cli->inbuf);
1266
1267	if (cli_is_error(cli) \|\|
1268	((int)SVAL(cli->inbuf,smb_vwv0) >= numprots)) {
1269	return(False);
1270	}
1271
1272	cli->protocol = prots[SVAL(cli->inbuf,smb_vwv0)].prot;
1273
1274	if ((cli->protocol < PROTOCOL_NT1) && cli->sign_info.mandatory_signing) {
1275	DEBUG(0,("cli_negprot: SMB signing is mandatory and the selected protocol level doesn't support it.\n"));
1276	return False;
1277	}
1278
1279	if (cli->protocol >= PROTOCOL_NT1) {
1280	struct timespec ts;
1281	/* NT protocol */
1282	cli->sec_mode = CVAL(cli->inbuf,smb_vwv1);
1283	cli->max_mux = SVAL(cli->inbuf, smb_vwv1+1);
1284	cli->max_xmit = IVAL(cli->inbuf,smb_vwv3+1);
1285	cli->sesskey = IVAL(cli->inbuf,smb_vwv7+1);
1286	cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1);
1287	cli->serverzone *= 60;
1288	/* this time arrives in real GMT */
1289	ts = interpret_long_date(cli->inbuf+smb_vwv11+1);
1290	cli->servertime = ts.tv_sec;
1291	cli->secblob = data_blob(smb_buf(cli->inbuf),smb_buflen(cli->inbuf));
1292	cli->capabilities = IVAL(cli->inbuf,smb_vwv9+1);
1293	if (cli->capabilities & CAP_RAW_MODE) {
1294	cli->readbraw_supported = True;
1295	cli->writebraw_supported = True;
1296	}
1297	/* work out if they sent us a workgroup */
1298	if (!(cli->capabilities & CAP_EXTENDED_SECURITY) &&
1299	smb_buflen(cli->inbuf) > 8) {
1300	clistr_pull(cli, cli->server_domain,
1301	smb_buf(cli->inbuf)+8, sizeof(cli->server_domain),
1302	smb_buflen(cli->inbuf)-8, STR_UNICODE\|STR_NOALIGN);
1303	}
1304
1305	/*
1306	* As signing is slow we only turn it on if either the client or
1307	* the server require it. JRA.
1308	*/
1309
1310	if (cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_REQUIRED) {
1311	/* Fail if server says signing is mandatory and we don't want to support it. */
1312	if (!cli->sign_info.allow_smb_signing) {
1313	DEBUG(0,("cli_negprot: SMB signing is mandatory and we have disabled it.\n"));
1314	return False;
1315	}
1316	cli->sign_info.negotiated_smb_signing = True;
1317	cli->sign_info.mandatory_signing = True;
1318	} else if (cli->sign_info.mandatory_signing && cli->sign_info.allow_smb_signing) {
1319	/* Fail if client says signing is mandatory and the server doesn't support it. */
1320	if (!(cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_ENABLED)) {
1321	DEBUG(1,("cli_negprot: SMB signing is mandatory and the server doesn't support it.\n"));
1322	return False;
1323	}
1324	cli->sign_info.negotiated_smb_signing = True;
1325	cli->sign_info.mandatory_signing = True;
1326	} else if (cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_ENABLED) {
1327	cli->sign_info.negotiated_smb_signing = True;
1328	}
1329
1330	if (cli->capabilities & (CAP_LARGE_READX\|CAP_LARGE_WRITEX)) {
1331	SAFE_FREE(cli->outbuf);
1332	SAFE_FREE(cli->inbuf);
1333	cli->outbuf = (char *)SMB_MALLOC(CLI_SAMBA_MAX_LARGE_READX_SIZE+LARGE_WRITEX_HDR_SIZE+SAFETY_MARGIN);
1334	cli->inbuf = (char *)SMB_MALLOC(CLI_SAMBA_MAX_LARGE_READX_SIZE+LARGE_WRITEX_HDR_SIZE+SAFETY_MARGIN);
1335	cli->bufsize = CLI_SAMBA_MAX_LARGE_READX_SIZE + LARGE_WRITEX_HDR_SIZE;
1336	}
1337
1338	} else if (cli->protocol >= PROTOCOL_LANMAN1) {
1339	cli->use_spnego = False;
1340	cli->sec_mode = SVAL(cli->inbuf,smb_vwv1);
1341	cli->max_xmit = SVAL(cli->inbuf,smb_vwv2);
1342	cli->max_mux = SVAL(cli->inbuf, smb_vwv3);
1343	cli->sesskey = IVAL(cli->inbuf,smb_vwv6);
1344	cli->serverzone = SVALS(cli->inbuf,smb_vwv10);
1345	cli->serverzone *= 60;
1346	/* this time is converted to GMT by make_unix_date */
1347	cli->servertime = cli_make_unix_date(cli,cli->inbuf+smb_vwv8);
1348	cli->readbraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x1) != 0);
1349	cli->writebraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x2) != 0);
1350	cli->secblob = data_blob(smb_buf(cli->inbuf),smb_buflen(cli->inbuf));
1351	} else {
1352	/* the old core protocol */
1353	cli->use_spnego = False;
1354	cli->sec_mode = 0;
1355	cli->serverzone = get_time_zone(time(NULL));
1356	}
1357
1358	cli->max_xmit = MIN(cli->max_xmit, CLI_BUFFER_SIZE);
1359
1360	/* a way to force ascii SMB */
1361	if (getenv("CLI_FORCE_ASCII"))
1362	cli->capabilities &= ~CAP_UNICODE;
1363
1364	return True;
1365	}
1366
1367	/****************************************************************************
1368	Send a session request. See rfc1002.txt 4.3 and 4.3.2.
1369	****************************************************************************/
1370
1371	BOOL cli_session_request(struct cli_state *cli,
1372	struct nmb_name calling, struct nmb_name called)
1373	{
1374	char *p;
1375	int len = 4;
1376
1377	memcpy(&(cli->calling), calling, sizeof(*calling));
1378	memcpy(&(cli->called ), called , sizeof(*called ));
1379
1380	/* put in the destination name */
1381	p = cli->outbuf+len;
1382	name_mangle(cli->called .name, p, cli->called .name_type);
1383	len += name_len(p);
1384
1385	/* and my name */
1386	p = cli->outbuf+len;
1387	name_mangle(cli->calling.name, p, cli->calling.name_type);
1388	len += name_len(p);
1389
1390	/* 445 doesn't have session request */
1391	if (cli->port == 445)
1392	return True;
1393
1394	/* send a session request (RFC 1002) */
1395	/* setup the packet length
1396	* Remove four bytes from the length count, since the length
1397	* field in the NBT Session Service header counts the number
1398	* of bytes which follow. The cli_send_smb() function knows
1399	* about this and accounts for those four bytes.
1400	* CRH.
1401	*/
1402	len -= 4;
1403	_smb_setlen(cli->outbuf,len);
1404	SCVAL(cli->outbuf,0,0x81);
1405
1406	cli_send_smb(cli);
1407	DEBUG(5,("Sent session request\n"));
1408
1409	if (!cli_receive_smb(cli))
1410	return False;
1411
1412	if (CVAL(cli->inbuf,0) == 0x84) {
1413	/* C. Hoch 9/14/95 Start */
1414	/* For information, here is the response structure.
1415	* We do the byte-twiddling to for portability.
1416	struct RetargetResponse{
1417	unsigned char type;
1418	unsigned char flags;
1419	int16 length;
1420	int32 ip_addr;
1421	int16 port;
1422	};
1423	*/
1424	int port = (CVAL(cli->inbuf,8)<<8)+CVAL(cli->inbuf,9);
1425	/* SESSION RETARGET */
1426	putip((char *)&cli->dest_ip,cli->inbuf+4);
1427
1428	cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip, port, LONG_CONNECT_TIMEOUT);
1429	if (cli->fd == -1)
1430	return False;
1431
1432	DEBUG(3,("Retargeted\n"));
1433
1434	set_socket_options(cli->fd,user_socket_options);
1435
1436	/* Try again */
1437	{
1438	static int depth;
1439	BOOL ret;
1440	if (depth > 4) {
1441	DEBUG(0,("Retarget recursion - failing\n"));
1442	return False;
1443	}
1444	depth++;
1445	ret = cli_session_request(cli, calling, called);
1446	depth--;
1447	return ret;
1448	}
1449	} /* C. Hoch 9/14/95 End */
1450
1451	if (CVAL(cli->inbuf,0) != 0x82) {
1452	/* This is the wrong place to put the error... JRA. */
1453	cli->rap_error = CVAL(cli->inbuf,4);
1454	return False;
1455	}
1456	return(True);
1457	}
1458
1459	/****************************************************************************
1460	Open the client sockets.
1461	****************************************************************************/
1462
1463	NTSTATUS cli_connect(struct cli_state cli, const char host, struct in_addr *ip)
1464	{
1465	int name_type = 0x20;
1466	char *p;
1467
1468	/* reasonable default hostname */
1469	if (!host) host = star_smbserver_name;
1470
1471	fstrcpy(cli->desthost, host);
1472
1473	/* allow hostnames of the form NAME#xx and do a netbios lookup */
1474	if ((p = strchr(cli->desthost, '#'))) {
1475	name_type = strtol(p+1, NULL, 16);
1476	*p = 0;
1477	}
1478
1479	if (!ip \|\| is_zero_ip(*ip)) {
1480	if (!resolve_name(cli->desthost, &cli->dest_ip, name_type)) {
1481	return NT_STATUS_BAD_NETWORK_NAME;
1482	}
1483	if (ip) *ip = cli->dest_ip;
1484	} else {
1485	cli->dest_ip = *ip;
1486	}
1487
1488	if (getenv("LIBSMB_PROG")) {
1489	cli->fd = sock_exec(getenv("LIBSMB_PROG"));
1490	} else {
1491	/* try 445 first, then 139 */
1492	int port = cli->port?cli->port:445;
1493	cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
1494	port, cli->timeout);
1495	if (cli->fd == -1 && cli->port == 0) {
1496	port = 139;
1497	cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
1498	port, cli->timeout);
1499	}
1500	if (cli->fd != -1)
1501	cli->port = port;
1502	}
1503	if (cli->fd == -1) {
1504	DEBUG(1,("Error connecting to %s (%s)\n",
1505	ip?inet_ntoa(*ip):host,strerror(errno)));
1506	return map_nt_error_from_unix(errno);
1507	}
1508
1509	set_socket_options(cli->fd,user_socket_options);
1510
1511	return NT_STATUS_OK;
1512	}
1513
1514	/**
1515	establishes a connection to after the negprot.
1516	@param output_cli A fully initialised cli structure, non-null only on success
1517	@param dest_host The netbios name of the remote host
1518	@param dest_ip (optional) The the destination IP, NULL for name based lookup
1519	@param port (optional) The destination port (0 for default)
1520	@param retry BOOL. Did this connection fail with a retryable error ?
1521
1522	*/
1523	NTSTATUS cli_start_connection(struct cli_state **output_cli,
1524	const char *my_name,
1525	const char *dest_host,
1526	struct in_addr *dest_ip, int port,
1527	int signing_state, int flags,
1528	BOOL *retry)
1529	{
1530	NTSTATUS nt_status;
1531	struct nmb_name calling;
1532	struct nmb_name called;
1533	struct cli_state *cli;
1534	struct in_addr ip;
1535
1536	if (retry)
1537	*retry = False;
1538
1539	if (!my_name)
1540	my_name = global_myname();
1541
1542	if (!(cli = cli_initialise())) {
1543	return NT_STATUS_NO_MEMORY;
1544	}
1545
1546	make_nmb_name(&calling, my_name, 0x0);
1547	make_nmb_name(&called , dest_host, 0x20);
1548
1549	if (cli_set_port(cli, port) != port) {
1550	cli_shutdown(cli);
1551	return NT_STATUS_UNSUCCESSFUL;
1552	}
1553
1554	cli_set_timeout(cli, 10000); /* 10 seconds. */
1555
1556	if (dest_ip)
1557	ip = *dest_ip;
1558	else
1559	ZERO_STRUCT(ip);
1560
1561	again:
1562
1563	DEBUG(3,("Connecting to host=%s\n", dest_host));
1564
1565	nt_status = cli_connect(cli, dest_host, &ip);
1566	if (!NT_STATUS_IS_OK(nt_status)) {
1567	DEBUG(1,("cli_start_connection: failed to connect to %s (%s). Error %s\n",
1568	nmb_namestr(&called), inet_ntoa(ip), nt_errstr(nt_status) ));
1569	cli_shutdown(cli);
1570	return nt_status;
1571	}
1572
1573	if (retry)
1574	*retry = True;
1575
1576	if (!cli_session_request(cli, &calling, &called)) {
1577	char *p;
1578	DEBUG(1,("session request to %s failed (%s)\n",
1579	called.name, cli_errstr(cli)));
1580	if ((p=strchr(called.name, '.')) && !is_ipaddress(called.name)) {
1581	*p = 0;
1582	goto again;
1583	}
1584	if (strcmp(called.name, star_smbserver_name)) {
1585	make_nmb_name(&called , star_smbserver_name, 0x20);
1586	goto again;
1587	}
1588	return NT_STATUS_BAD_NETWORK_NAME;
1589	}
1590
1591	cli_setup_signing_state(cli, signing_state);
1592
1593	if (flags & CLI_FULL_CONNECTION_DONT_SPNEGO)
1594	cli->use_spnego = False;
1595	else if (flags & CLI_FULL_CONNECTION_USE_KERBEROS)
1596	cli->use_kerberos = True;
1597
1598	if (!cli_negprot(cli)) {
1599	DEBUG(1,("failed negprot\n"));
1600	nt_status = cli_nt_error(cli);
1601	if (NT_STATUS_IS_OK(nt_status)) {
1602	nt_status = NT_STATUS_UNSUCCESSFUL;
1603	}
1604	cli_shutdown(cli);
1605	return nt_status;
1606	}
1607
1608	*output_cli = cli;
1609	return NT_STATUS_OK;
1610	}
1611
1612
1613	/**
1614	establishes a connection right up to doing tconX, password specified.
1615	@param output_cli A fully initialised cli structure, non-null only on success
1616	@param dest_host The netbios name of the remote host
1617	@param dest_ip (optional) The the destination IP, NULL for name based lookup
1618	@param port (optional) The destination port (0 for default)
1619	@param service (optional) The share to make the connection to. Should be 'unqualified' in any way.
1620	@param service_type The 'type' of serivice.
1621	@param user Username, unix string
1622	@param domain User's domain
1623	@param password User's password, unencrypted unix string.
1624	@param retry BOOL. Did this connection fail with a retryable error ?
1625	*/
1626
1627	NTSTATUS cli_full_connection(struct cli_state **output_cli,
1628	const char *my_name,
1629	const char *dest_host,
1630	struct in_addr *dest_ip, int port,
1631	const char service, const char service_type,
1632	const char user, const char domain,
1633	const char *password, int flags,
1634	int signing_state,
1635	BOOL *retry)
1636	{
1637	NTSTATUS nt_status;
1638	struct cli_state *cli = NULL;
1639	int pw_len = password ? strlen(password)+1 : 0;
1640
1641	*output_cli = NULL;
1642
1643	if (password == NULL) {
1644	password = "";
1645	}
1646
1647	nt_status = cli_start_connection(&cli, my_name, dest_host,
1648	dest_ip, port, signing_state, flags, retry);
1649
1650	if (!NT_STATUS_IS_OK(nt_status)) {
1651	return nt_status;
1652	}
1653
1654	nt_status = cli_session_setup(cli, user, password, pw_len, password,
1655	pw_len, domain);
1656	if (!NT_STATUS_IS_OK(nt_status)) {
1657
1658	if (!(flags & CLI_FULL_CONNECTION_ANONYMOUS_FALLBACK)) {
1659	DEBUG(1,("failed session setup with %s\n",
1660	nt_errstr(nt_status)));
1661	cli_shutdown(cli);
1662	return nt_status;
1663	}
1664
1665	nt_status = cli_session_setup(cli, "", "", 0, "", 0, domain);
1666	if (!NT_STATUS_IS_OK(nt_status)) {
1667	DEBUG(1,("anonymous failed session setup with %s\n",
1668	nt_errstr(nt_status)));
1669	cli_shutdown(cli);
1670	return nt_status;
1671	}
1672	}
1673
1674	if (service) {
1675	if (!cli_send_tconX(cli, service, service_type, password, pw_len)) {
1676	nt_status = cli_nt_error(cli);
1677	DEBUG(1,("failed tcon_X with %s\n", nt_errstr(nt_status)));
1678	cli_shutdown(cli);
1679	if (NT_STATUS_IS_OK(nt_status)) {
1680	nt_status = NT_STATUS_UNSUCCESSFUL;
1681	}
1682	return nt_status;
1683	}
1684	}
1685
1686	cli_init_creds(cli, user, domain, password);
1687
1688	*output_cli = cli;
1689	return NT_STATUS_OK;
1690	}
1691
1692	/****************************************************************************
1693	Attempt a NetBIOS session request, falling back to *SMBSERVER if needed.
1694	****************************************************************************/
1695
1696	BOOL attempt_netbios_session_request(struct cli_state *ppcli, const char srchost, const char *desthost,
1697	struct in_addr *pdest_ip)
1698	{
1699	struct nmb_name calling, called;
1700
1701	make_nmb_name(&calling, srchost, 0x0);
1702
1703	/*
1704	* If the called name is an IP address
1705	* then use *SMBSERVER immediately.
1706	*/
1707
1708	if(is_ipaddress(desthost)) {
1709	make_nmb_name(&called, star_smbserver_name, 0x20);
1710	} else {
1711	make_nmb_name(&called, desthost, 0x20);
1712	}
1713
1714	if (!cli_session_request(*ppcli, &calling, &called)) {
1715	NTSTATUS status;
1716	struct nmb_name smbservername;
1717
1718	make_nmb_name(&smbservername, star_smbserver_name, 0x20);
1719
1720	/*
1721	* If the name wasn't *SMBSERVER then
1722	* try with *SMBSERVER if the first name fails.
1723	*/
1724
1725	if (nmb_name_equal(&called, &smbservername)) {
1726
1727	/*
1728	* The name used was *SMBSERVER, don't bother with another name.
1729	*/
1730
1731	DEBUG(0,("attempt_netbios_session_request: %s rejected the session for name *SMBSERVER \
1732	with error %s.\n", desthost, cli_errstr(*ppcli) ));
1733	return False;
1734	}
1735
1736	/* Try again... */
1737	cli_shutdown(*ppcli);
1738
1739	*ppcli = cli_initialise();
1740	if (!*ppcli) {
1741	/* Out of memory... */
1742	return False;
1743	}
1744
1745	status = cli_connect(*ppcli, desthost, pdest_ip);
1746	if (!NT_STATUS_IS_OK(status) \|\|
1747	!cli_session_request(*ppcli, &calling, &smbservername)) {
1748	DEBUG(0,("attempt_netbios_session_request: %s rejected the session for \
1749	name SMBSERVER with error %s\n", desthost, cli_errstr(ppcli) ));
1750	return False;
1751	}
1752	}
1753
1754	return True;
1755	}
1756
1757
1758
1759
1760
1761	/****************************************************************************
1762	Send an old style tcon.
1763	****************************************************************************/
1764	NTSTATUS cli_raw_tcon(struct cli_state *cli,
1765	const char service, const char pass, const char *dev,
1766	uint16 max_xmit, uint16 tid)
1767	{
1768	char *p;
1769
1770	if (!lp_client_plaintext_auth() && (*pass)) {
1771	DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
1772	" is disabled\n"));
1773	return NT_STATUS_ACCESS_DENIED;
1774	}
1775
1776	memset(cli->outbuf,'\0',smb_size);
1777	memset(cli->inbuf,'\0',smb_size);
1778
1779	set_message(cli->outbuf, 0, 0, True);
1780	SCVAL(cli->outbuf,smb_com,SMBtcon);
1781	cli_setup_packet(cli);
1782
1783	p = smb_buf(cli->outbuf);
1784	*p++ = 4; p += clistr_push(cli, p, service, -1, STR_TERMINATE \| STR_NOALIGN);
1785	*p++ = 4; p += clistr_push(cli, p, pass, -1, STR_TERMINATE \| STR_NOALIGN);
1786	*p++ = 4; p += clistr_push(cli, p, dev, -1, STR_TERMINATE \| STR_NOALIGN);
1787
1788	cli_setup_bcc(cli, p);
1789
1790	cli_send_smb(cli);
1791	if (!cli_receive_smb(cli)) {
1792	return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
1793	}
1794
1795	if (cli_is_error(cli)) {
1796	return cli_nt_error(cli);
1797	}
1798
1799	*max_xmit = SVAL(cli->inbuf, smb_vwv0);
1800	*tid = SVAL(cli->inbuf, smb_vwv1);
1801
1802	return NT_STATUS_OK;
1803	}
1804
1805	/* Return a cli_state pointing at the IPC$ share for the given server */
1806
1807	struct cli_state get_ipc_connect(char server, struct in_addr *server_ip,
1808	struct user_auth_info *user_info)
1809	{
1810	struct cli_state *cli;
1811	pstring myname;
1812	NTSTATUS nt_status;
1813
1814	get_myname(myname);
1815
1816	nt_status = cli_full_connection(&cli, myname, server, server_ip, 0, "IPC$", "IPC",
1817	user_info->username, lp_workgroup(), user_info->password,
1818	CLI_FULL_CONNECTION_ANONYMOUS_FALLBACK, Undefined, NULL);
1819
1820	if (NT_STATUS_IS_OK(nt_status)) {
1821	return cli;
1822	} else if (is_ipaddress(server)) {
1823	/* windows 9* needs a correct NMB name for connections */
1824	fstring remote_name;
1825
1826	if (name_status_find("", 0, 0, server_ip, remote_name)) {
1827	cli = get_ipc_connect(remote_name, server_ip, user_info);
1828	if (cli)
1829	return cli;
1830	}
1831	}
1832	return NULL;
1833	}
1834
1835	/*
1836	* Given the IP address of a master browser on the network, return its
1837	* workgroup and connect to it.
1838	*
1839	* This function is provided to allow additional processing beyond what
1840	* get_ipc_connect_master_ip_bcast() does, e.g. to retrieve the list of master
1841	* browsers and obtain each master browsers' list of domains (in case the
1842	* first master browser is recently on the network and has not yet
1843	* synchronized with other master browsers and therefore does not yet have the
1844	* entire network browse list)
1845	*/
1846
1847	struct cli_state get_ipc_connect_master_ip(struct ip_service mb_ip, pstring workgroup, struct user_auth_info *user_info)
1848	{
1849	static fstring name;
1850	struct cli_state *cli;
1851	struct in_addr server_ip;
1852
1853	DEBUG(99, ("Looking up name of master browser %s\n",
1854	inet_ntoa(mb_ip->ip)));
1855
1856	/*
1857	* Do a name status query to find out the name of the master browser.
1858	* We use <01><02>__MSBROWSE__<02>#01 if *#00 fails because a domain
1859	* master browser will not respond to a wildcard query (or, at least,
1860	* an NT4 server acting as the domain master browser will not).
1861	*
1862	* We might be able to use ONLY the query on MSBROWSE, but that's not
1863	* yet been tested with all Windows versions, so until it is, leave
1864	* the original wildcard query as the first choice and fall back to
1865	* MSBROWSE if the wildcard query fails.
1866	*/
1867	if (!name_status_find("*", 0, 0x1d, mb_ip->ip, name) &&
1868	!name_status_find(MSBROWSE, 1, 0x1d, mb_ip->ip, name)) {
1869
1870	DEBUG(99, ("Could not retrieve name status for %s\n",
1871	inet_ntoa(mb_ip->ip)));
1872	return NULL;
1873	}
1874
1875	if (!find_master_ip(name, &server_ip)) {
1876	DEBUG(99, ("Could not find master ip for %s\n", name));
1877	return NULL;
1878	}
1879
1880	pstrcpy(workgroup, name);
1881
1882	DEBUG(4, ("found master browser %s, %s\n",
1883	name, inet_ntoa(mb_ip->ip)));
1884
1885	cli = get_ipc_connect(inet_ntoa(server_ip), &server_ip, user_info);
1886
1887	return cli;
1888
1889	}
1890
1891	/*
1892	* Return the IP address and workgroup of a master browser on the network, and
1893	* connect to it.
1894	*/
1895
1896	struct cli_state get_ipc_connect_master_ip_bcast(pstring workgroup, struct user_auth_info user_info)
1897	{
1898	struct ip_service *ip_list;
1899	struct cli_state *cli;
1900	int i, count;
1901
1902	DEBUG(99, ("Do broadcast lookup for workgroups on local network\n"));
1903
1904	/* Go looking for workgroups by broadcasting on the local network */
1905
1906	if (!name_resolve_bcast(MSBROWSE, 1, &ip_list, &count)) {
1907	DEBUG(99, ("No master browsers responded\n"));
1908	return False;
1909	}
1910
1911	for (i = 0; i < count; i++) {
1912	DEBUG(99, ("Found master browser %s\n", inet_ntoa(ip_list[i].ip)));
1913
1914	cli = get_ipc_connect_master_ip(&ip_list[i], workgroup, user_info);
1915	if (cli)
1916	return(cli);
1917	}
1918
1919	return NULL;
1920	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: