2 Unix SMB/CIFS implementation.
3 client connect/disconnect routines
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Andrew Bartlett 2001-2003
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.
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.
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.
31 {PROTOCOL_CORE,"PC NETWORK PROGRAM 1.0"},
32 {PROTOCOL_COREPLUS,"MICROSOFT NETWORKS 1.03"},
33 {PROTOCOL_LANMAN1,"MICROSOFT NETWORKS 3.0"},
34 {PROTOCOL_LANMAN1,"LANMAN1.0"},
35 {PROTOCOL_LANMAN2,"LM1.2X002"},
36 {PROTOCOL_LANMAN2,"DOS LANMAN2.1"},
37 {PROTOCOL_LANMAN2,"Samba"},
38 {PROTOCOL_NT1,"NT LANMAN 1.0"},
39 {PROTOCOL_NT1,"NT LM 0.12"},
43 /****************************************************************************
44 Do an old lanman2 style session setup.
45 ****************************************************************************/
47 static BOOL cli_session_setup_lanman2(struct cli_state *cli, const char *user,
48 const char *pass, size_t passlen, const char *workgroup)
53 if (passlen > sizeof(pword)-1)
56 /* if in share level security then don't send a password now */
57 if (!(cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL))
60 if (passlen > 0 && (cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && passlen != 24) {
61 /* Encrypted mode needed, and non encrypted password supplied. */
63 SMBencrypt(pass,cli->secblob.data,(uchar *)pword);
64 } else if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && passlen == 24) {
65 /* Encrypted mode needed, and encrypted password supplied. */
66 memcpy(pword, pass, passlen);
67 } else if (passlen > 0) {
68 /* Plaintext mode needed, assume plaintext supplied. */
69 passlen = clistr_push(cli, pword, pass, sizeof(pword), STR_TERMINATE);
72 /* send a session setup command */
73 memset(cli->outbuf,'\0',smb_size);
74 set_message(cli->outbuf,10, 0, True);
75 SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
76 cli_setup_packet(cli);
78 SCVAL(cli->outbuf,smb_vwv0,0xFF);
79 SSVAL(cli->outbuf,smb_vwv2,cli->max_xmit);
80 SSVAL(cli->outbuf,smb_vwv3,2);
81 SSVAL(cli->outbuf,smb_vwv4,1);
82 SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
83 SSVAL(cli->outbuf,smb_vwv7,passlen);
85 p = smb_buf(cli->outbuf);
86 memcpy(p,pword,passlen);
88 p += clistr_push(cli, p, user, -1, STR_TERMINATE|STR_UPPER);
89 p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE|STR_UPPER);
90 p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
91 p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
92 cli_setup_bcc(cli, p);
95 if (!cli_receive_smb(cli))
100 if (cli_is_error(cli))
103 /* use the returned vuid from now on */
104 cli->vuid = SVAL(cli->inbuf,smb_uid);
105 fstrcpy(cli->user_name, user);
110 /****************************************************************************
111 Work out suitable capabilities to offer the server.
112 ****************************************************************************/
114 static uint32 cli_session_setup_capabilities(struct cli_state *cli)
116 uint32 capabilities = CAP_NT_SMBS;
118 if (!cli->force_dos_errors)
119 capabilities |= CAP_STATUS32;
121 if (cli->use_level_II_oplocks)
122 capabilities |= CAP_LEVEL_II_OPLOCKS;
124 if (cli->capabilities & CAP_UNICODE)
125 capabilities |= CAP_UNICODE;
127 if (cli->capabilities & CAP_LARGE_FILES)
128 capabilities |= CAP_LARGE_FILES;
133 /****************************************************************************
134 Do a NT1 guest session setup.
135 ****************************************************************************/
137 static BOOL cli_session_setup_guest(struct cli_state *cli)
140 uint32 capabilities = cli_session_setup_capabilities(cli);
142 set_message(cli->outbuf,13,0,True);
143 SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
144 cli_setup_packet(cli);
146 SCVAL(cli->outbuf,smb_vwv0,0xFF);
147 SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
148 SSVAL(cli->outbuf,smb_vwv3,2);
149 SSVAL(cli->outbuf,smb_vwv4,cli->pid);
150 SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
151 SSVAL(cli->outbuf,smb_vwv7,0);
152 SSVAL(cli->outbuf,smb_vwv8,0);
153 SIVAL(cli->outbuf,smb_vwv11,capabilities);
154 p = smb_buf(cli->outbuf);
155 p += clistr_push(cli, p, "", -1, STR_TERMINATE); /* username */
156 p += clistr_push(cli, p, "", -1, STR_TERMINATE); /* workgroup */
157 p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
158 p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
159 cli_setup_bcc(cli, p);
162 if (!cli_receive_smb(cli))
165 show_msg(cli->inbuf);
167 if (cli_is_error(cli))
170 cli->vuid = SVAL(cli->inbuf,smb_uid);
172 p = smb_buf(cli->inbuf);
173 p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
174 p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), -1, STR_TERMINATE);
175 p += clistr_pull(cli, cli->server_domain, p, sizeof(fstring), -1, STR_TERMINATE);
177 fstrcpy(cli->user_name, "");
182 /****************************************************************************
183 Do a NT1 plaintext session setup.
184 ****************************************************************************/
186 static BOOL cli_session_setup_plaintext(struct cli_state *cli, const char *user,
187 const char *pass, const char *workgroup)
189 uint32 capabilities = cli_session_setup_capabilities(cli);
193 fstr_sprintf( lanman, "Samba %s", VERSION );
195 set_message(cli->outbuf,13,0,True);
196 SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
197 cli_setup_packet(cli);
199 SCVAL(cli->outbuf,smb_vwv0,0xFF);
200 SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
201 SSVAL(cli->outbuf,smb_vwv3,2);
202 SSVAL(cli->outbuf,smb_vwv4,cli->pid);
203 SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
204 SSVAL(cli->outbuf,smb_vwv8,0);
205 SIVAL(cli->outbuf,smb_vwv11,capabilities);
206 p = smb_buf(cli->outbuf);
208 /* check wether to send the ASCII or UNICODE version of the password */
210 if ( (capabilities & CAP_UNICODE) == 0 ) {
211 p += clistr_push(cli, p, pass, -1, STR_TERMINATE); /* password */
212 SSVAL(cli->outbuf,smb_vwv7,PTR_DIFF(p, smb_buf(cli->outbuf)));
215 p += clistr_push(cli, p, pass, -1, STR_UNICODE|STR_TERMINATE); /* unicode password */
216 SSVAL(cli->outbuf,smb_vwv8,PTR_DIFF(p, smb_buf(cli->outbuf)));
219 p += clistr_push(cli, p, user, -1, STR_TERMINATE); /* username */
220 p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE); /* workgroup */
221 p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
222 p += clistr_push(cli, p, lanman, -1, STR_TERMINATE);
223 cli_setup_bcc(cli, p);
226 if (!cli_receive_smb(cli))
229 show_msg(cli->inbuf);
231 if (cli_is_error(cli))
234 cli->vuid = SVAL(cli->inbuf,smb_uid);
235 p = smb_buf(cli->inbuf);
236 p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
237 p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), -1, STR_TERMINATE);
238 p += clistr_pull(cli, cli->server_domain, p, sizeof(fstring), -1, STR_TERMINATE);
239 fstrcpy(cli->user_name, user);
244 static void set_cli_session_key (struct cli_state *cli, DATA_BLOB session_key)
246 memcpy(cli->user_session_key, session_key.data, MIN(session_key.length, sizeof(cli->user_session_key)));
249 /****************************************************************************
250 do a NT1 NTLM/LM encrypted session setup
251 @param cli client state to create do session setup on
253 @param pass *either* cleartext password (passlen !=24) or LM response.
254 @param ntpass NT response, implies ntpasslen >=24, implies pass is not clear
255 @param workgroup The user's domain.
256 ****************************************************************************/
258 static BOOL cli_session_setup_nt1(struct cli_state *cli, const char *user,
259 const char *pass, size_t passlen,
260 const char *ntpass, size_t ntpasslen,
261 const char *workgroup)
263 uint32 capabilities = cli_session_setup_capabilities(cli);
264 DATA_BLOB lm_response = data_blob(NULL, 0);
265 DATA_BLOB nt_response = data_blob(NULL, 0);
266 DATA_BLOB session_key = data_blob(NULL, 0);
271 if ((cli->capabilities & CAP_EXTENDED_SECURITY) && lp_client_ntlmv2_auth()) {
272 DATA_BLOB server_chal;
273 DATA_BLOB names_blob;
274 server_chal = data_blob(cli->secblob.data, MIN(cli->secblob.length, 8));
276 /* note that the 'workgroup' here is a best guess - we don't know
277 the server's domain at this point. The 'server name' is also
280 names_blob = NTLMv2_generate_names_blob(cli->called.name, workgroup);
282 if (!SMBNTLMv2encrypt(user, workgroup, pass, &server_chal,
284 &lm_response, &nt_response, &session_key)) {
285 data_blob_free(&names_blob);
286 data_blob_free(&server_chal);
289 data_blob_free(&names_blob);
290 data_blob_free(&server_chal);
294 E_md4hash(pass, nt_hash);
296 nt_response = data_blob(NULL, 24);
297 SMBNTencrypt(pass,cli->secblob.data,nt_response.data);
299 /* non encrypted password supplied. Ignore ntpass. */
300 if (lp_client_lanman_auth()) {
301 lm_response = data_blob(NULL, 24);
302 SMBencrypt(pass,cli->secblob.data, lm_response.data);
304 /* LM disabled, place NT# in LM field instead */
305 lm_response = data_blob(nt_response.data, nt_response.length);
308 session_key = data_blob(NULL, 16);
309 SMBsesskeygen_ntv1(nt_hash, NULL, session_key.data);
311 cli_simple_set_signing(cli, session_key.data, nt_response);
313 /* pre-encrypted password supplied. Only used for
314 security=server, can't do
315 signing because we don't have original key */
317 lm_response = data_blob(pass, passlen);
318 nt_response = data_blob(ntpass, ntpasslen);
321 /* send a session setup command */
322 memset(cli->outbuf,'\0',smb_size);
324 set_message(cli->outbuf,13,0,True);
325 SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
326 cli_setup_packet(cli);
328 SCVAL(cli->outbuf,smb_vwv0,0xFF);
329 SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
330 SSVAL(cli->outbuf,smb_vwv3,2);
331 SSVAL(cli->outbuf,smb_vwv4,cli->pid);
332 SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
333 SSVAL(cli->outbuf,smb_vwv7,lm_response.length);
334 SSVAL(cli->outbuf,smb_vwv8,nt_response.length);
335 SIVAL(cli->outbuf,smb_vwv11,capabilities);
336 p = smb_buf(cli->outbuf);
337 if (lm_response.length) {
338 memcpy(p,lm_response.data, lm_response.length); p += lm_response.length;
340 if (nt_response.length) {
341 memcpy(p,nt_response.data, nt_response.length); p += nt_response.length;
343 p += clistr_push(cli, p, user, -1, STR_TERMINATE);
344 p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE);
345 p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
346 p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
347 cli_setup_bcc(cli, p);
349 if (!cli_send_smb(cli) || !cli_receive_smb(cli)) {
354 show_msg(cli->inbuf);
356 if (cli_is_error(cli)) {
361 /* use the returned vuid from now on */
362 cli->vuid = SVAL(cli->inbuf,smb_uid);
364 p = smb_buf(cli->inbuf);
365 p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
366 p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), -1, STR_TERMINATE);
367 p += clistr_pull(cli, cli->server_domain, p, sizeof(fstring), -1, STR_TERMINATE);
369 fstrcpy(cli->user_name, user);
371 if (session_key.data) {
372 /* Have plaintext orginal */
373 set_cli_session_key(cli, session_key);
378 data_blob_free(&lm_response);
379 data_blob_free(&nt_response);
380 data_blob_free(&session_key);
384 /****************************************************************************
385 Send a extended security session setup blob
386 ****************************************************************************/
388 static BOOL cli_session_setup_blob_send(struct cli_state *cli, DATA_BLOB blob)
390 uint32 capabilities = cli_session_setup_capabilities(cli);
393 capabilities |= CAP_EXTENDED_SECURITY;
395 /* send a session setup command */
396 memset(cli->outbuf,'\0',smb_size);
398 set_message(cli->outbuf,12,0,True);
399 SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
401 cli_setup_packet(cli);
403 SCVAL(cli->outbuf,smb_vwv0,0xFF);
404 SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
405 SSVAL(cli->outbuf,smb_vwv3,2);
406 SSVAL(cli->outbuf,smb_vwv4,1);
407 SIVAL(cli->outbuf,smb_vwv5,0);
408 SSVAL(cli->outbuf,smb_vwv7,blob.length);
409 SIVAL(cli->outbuf,smb_vwv10,capabilities);
410 p = smb_buf(cli->outbuf);
411 memcpy(p, blob.data, blob.length);
413 p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
414 p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
415 cli_setup_bcc(cli, p);
416 return cli_send_smb(cli);
419 /****************************************************************************
420 Send a extended security session setup blob, returning a reply blob.
421 ****************************************************************************/
423 static DATA_BLOB cli_session_setup_blob_receive(struct cli_state *cli)
425 DATA_BLOB blob2 = data_blob(NULL, 0);
429 if (!cli_receive_smb(cli))
432 show_msg(cli->inbuf);
434 if (cli_is_error(cli) && !NT_STATUS_EQUAL(cli_nt_error(cli),
435 NT_STATUS_MORE_PROCESSING_REQUIRED)) {
439 /* use the returned vuid from now on */
440 cli->vuid = SVAL(cli->inbuf,smb_uid);
442 p = smb_buf(cli->inbuf);
444 blob2 = data_blob(p, SVAL(cli->inbuf, smb_vwv3));
447 p += clistr_pull(cli, cli->server_os, p, sizeof(fstring), -1, STR_TERMINATE);
449 /* w2k with kerberos doesn't properly null terminate this field */
450 len = smb_buflen(cli->inbuf) - PTR_DIFF(p, smb_buf(cli->inbuf));
451 p += clistr_pull(cli, cli->server_type, p, sizeof(fstring), len, 0);
458 /****************************************************************************
459 Send a extended security session setup blob, returning a reply blob.
460 ****************************************************************************/
462 static DATA_BLOB cli_session_setup_blob(struct cli_state *cli, DATA_BLOB blob)
464 DATA_BLOB blob2 = data_blob(NULL, 0);
465 if (!cli_session_setup_blob_send(cli, blob)) {
469 return cli_session_setup_blob_receive(cli);
472 /****************************************************************************
473 Use in-memory credentials cache
474 ****************************************************************************/
476 static void use_in_memory_ccache(void) {
477 setenv(KRB5_ENV_CCNAME, "MEMORY:cliconnect", 1);
480 /****************************************************************************
481 Do a spnego/kerberos encrypted session setup.
482 ****************************************************************************/
484 static BOOL cli_session_setup_kerberos(struct cli_state *cli, const char *principal, const char *workgroup)
486 DATA_BLOB blob2, negTokenTarg;
487 unsigned char session_key_krb5[16];
488 DATA_BLOB null_blob = data_blob(NULL, 0);
490 DEBUG(2,("Doing kerberos session setup\n"));
492 /* generate the encapsulated kerberos5 ticket */
493 negTokenTarg = spnego_gen_negTokenTarg(principal, 0, session_key_krb5);
495 if (!negTokenTarg.data)
499 file_save("negTokenTarg.dat", negTokenTarg.data, negTokenTarg.length);
502 cli_simple_set_signing(cli, session_key_krb5, null_blob);
504 blob2 = cli_session_setup_blob(cli, negTokenTarg);
506 /* we don't need this blob for kerberos */
507 data_blob_free(&blob2);
509 data_blob_free(&negTokenTarg);
511 return !cli_is_error(cli);
513 #endif /* HAVE_KRB5 */
516 /****************************************************************************
517 Do a spnego/NTLMSSP encrypted session setup.
518 ****************************************************************************/
520 static BOOL cli_session_setup_ntlmssp(struct cli_state *cli, const char *user,
521 const char *pass, const char *workgroup)
523 struct ntlmssp_client_state *ntlmssp_state;
528 DATA_BLOB blob_in = data_blob(NULL, 0);
531 cli_temp_set_signing(cli);
533 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_client_start(&ntlmssp_state))) {
537 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_username(ntlmssp_state, user))) {
540 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_domain(ntlmssp_state, workgroup))) {
543 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_password(ntlmssp_state, pass))) {
547 ntlmssp_state->use_ntlmv2 = lp_client_ntlmv2_auth();
549 if (cli->sign_info.negotiated_smb_signing
550 || cli->sign_info.mandatory_signing) {
551 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
552 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN;
556 nt_status = ntlmssp_client_update(ntlmssp_state,
558 data_blob_free(&blob_in);
559 if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
560 DATA_BLOB null_blob = data_blob(NULL, 0);
562 /* and wrap it in a SPNEGO wrapper */
563 msg1 = gen_negTokenInit(OID_NTLMSSP, blob_out);
565 /* wrap it in SPNEGO */
566 msg1 = spnego_gen_auth(blob_out);
569 cli_simple_set_signing(cli,
570 ntlmssp_state->session_key.data,
573 /* now send that blob on its way */
574 if (!cli_session_setup_blob_send(cli, msg1)) {
577 data_blob_free(&msg1);
579 blob = cli_session_setup_blob_receive(cli);
581 nt_status = cli_nt_error(cli);
585 if (NT_STATUS_IS_OK(nt_status)) {
586 nt_status = NT_STATUS_UNSUCCESSFUL;
588 } else if ((turn == 1) &&
589 NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
590 DATA_BLOB tmp_blob = data_blob(NULL, 0);
591 /* the server might give us back two challenges */
592 if (!spnego_parse_challenge(blob, &blob_in,
594 DEBUG(3,("Failed to parse challenges\n"));
595 nt_status = NT_STATUS_INVALID_PARAMETER;
597 data_blob_free(&tmp_blob);
599 if (!spnego_parse_auth_response(blob, nt_status,
601 DEBUG(3,("Failed to parse auth response\n"));
602 if (NT_STATUS_IS_OK(nt_status)
603 || NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED))
604 nt_status = NT_STATUS_INVALID_PARAMETER;
607 data_blob_free(&blob);
608 data_blob_free(&blob_out);
610 } while (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED));
612 if (NT_STATUS_IS_OK(nt_status)) {
613 fstrcpy(cli->server_domain, ntlmssp_state->server_domain);
614 set_cli_session_key(cli, ntlmssp_state->session_key);
617 /* we have a reference conter on ntlmssp_state, if we are signing
618 then the state will be kept by the signing engine */
620 if (!NT_STATUS_IS_OK(ntlmssp_client_end(&ntlmssp_state))) {
624 return (NT_STATUS_IS_OK(nt_status));
627 /****************************************************************************
628 Do a spnego encrypted session setup.
629 ****************************************************************************/
631 static BOOL cli_session_setup_spnego(struct cli_state *cli, const char *user,
632 const char *pass, const char *workgroup)
635 char *OIDs[ASN1_MAX_OIDS];
637 BOOL got_kerberos_mechanism = False;
640 DEBUG(2,("Doing spnego session setup (blob length=%lu)\n", (unsigned long)cli->secblob.length));
642 /* the server might not even do spnego */
643 if (cli->secblob.length <= 16) {
644 DEBUG(3,("server didn't supply a full spnego negprot\n"));
649 file_save("negprot.dat", cli->secblob.data, cli->secblob.length);
652 /* there is 16 bytes of GUID before the real spnego packet starts */
653 blob = data_blob(cli->secblob.data+16, cli->secblob.length-16);
655 /* the server sent us the first part of the SPNEGO exchange in the negprot
657 if (!spnego_parse_negTokenInit(blob, OIDs, &principal)) {
658 data_blob_free(&blob);
661 data_blob_free(&blob);
663 /* make sure the server understands kerberos */
664 for (i=0;OIDs[i];i++) {
665 DEBUG(3,("got OID=%s\n", OIDs[i]));
666 if (strcmp(OIDs[i], OID_KERBEROS5_OLD) == 0 ||
667 strcmp(OIDs[i], OID_KERBEROS5) == 0) {
668 got_kerberos_mechanism = True;
672 DEBUG(3,("got principal=%s\n", principal));
674 fstrcpy(cli->user_name, user);
677 /* If password is set we reauthenticate to kerberos server
678 * and do not store results */
680 if (got_kerberos_mechanism && cli->use_kerberos) {
684 use_in_memory_ccache();
685 ret = kerberos_kinit_password(user, pass, 0 /* no time correction for now */);
688 DEBUG(0, ("Kinit failed: %s\n", error_message(ret)));
693 return cli_session_setup_kerberos(cli, principal, workgroup);
701 return cli_session_setup_ntlmssp(cli, user, pass, workgroup);
704 /****************************************************************************
705 Send a session setup. The username and workgroup is in UNIX character
706 format and must be converted to DOS codepage format before sending. If the
707 password is in plaintext, the same should be done.
708 ****************************************************************************/
710 BOOL cli_session_setup(struct cli_state *cli,
712 const char *pass, int passlen,
713 const char *ntpass, int ntpasslen,
714 const char *workgroup)
719 /* allow for workgroups as part of the username */
720 fstrcpy(user2, user);
721 if ((p=strchr_m(user2,'\\')) || (p=strchr_m(user2,'/')) ||
722 (p=strchr_m(user2,*lp_winbind_separator()))) {
728 if (cli->protocol < PROTOCOL_LANMAN1)
731 /* now work out what sort of session setup we are going to
732 do. I have split this into separate functions to make the
733 flow a bit easier to understand (tridge) */
735 /* if its an older server then we have to use the older request format */
737 if (cli->protocol < PROTOCOL_NT1) {
738 if (!lp_client_lanman_auth() && passlen != 24 && (*pass)) {
739 DEBUG(1, ("Server requested LM password but 'client lanman auth'"
744 if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0 &&
745 !lp_client_plaintext_auth() && (*pass)) {
746 DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
751 return cli_session_setup_lanman2(cli, user, pass, passlen, workgroup);
754 /* if no user is supplied then we have to do an anonymous connection.
755 passwords are ignored */
758 return cli_session_setup_guest(cli);
760 /* if the server is share level then send a plaintext null
761 password at this point. The password is sent in the tree
764 if ((cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) == 0)
765 return cli_session_setup_plaintext(cli, user, "", workgroup);
767 /* if the server doesn't support encryption then we have to use
768 plaintext. The second password is ignored */
770 if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0) {
771 if (!lp_client_plaintext_auth() && (*pass)) {
772 DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
776 return cli_session_setup_plaintext(cli, user, pass, workgroup);
779 /* if the server supports extended security then use SPNEGO */
781 if (cli->capabilities & CAP_EXTENDED_SECURITY)
782 return cli_session_setup_spnego(cli, user, pass, workgroup);
784 /* otherwise do a NT1 style session setup */
786 return cli_session_setup_nt1(cli, user,
787 pass, passlen, ntpass, ntpasslen,
791 /****************************************************************************
793 *****************************************************************************/
795 BOOL cli_ulogoff(struct cli_state *cli)
797 memset(cli->outbuf,'\0',smb_size);
798 set_message(cli->outbuf,2,0,True);
799 SCVAL(cli->outbuf,smb_com,SMBulogoffX);
800 cli_setup_packet(cli);
801 SSVAL(cli->outbuf,smb_vwv0,0xFF);
802 SSVAL(cli->outbuf,smb_vwv2,0); /* no additional info */
805 if (!cli_receive_smb(cli))
808 return !cli_is_error(cli);
811 /****************************************************************************
813 ****************************************************************************/
814 BOOL cli_send_tconX(struct cli_state *cli,
815 const char *share, const char *dev, const char *pass, int passlen)
817 fstring fullshare, pword;
819 memset(cli->outbuf,'\0',smb_size);
820 memset(cli->inbuf,'\0',smb_size);
822 fstrcpy(cli->share, share);
824 /* in user level security don't send a password now */
825 if (cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) {
830 if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && *pass && passlen != 24) {
831 if (!lp_client_lanman_auth()) {
832 DEBUG(1, ("Server requested LANMAN password but 'client use lanman auth'"
838 * Non-encrypted passwords - convert to DOS codepage before encryption.
841 SMBencrypt(pass,cli->secblob.data,(uchar *)pword);
843 if((cli->sec_mode & (NEGOTIATE_SECURITY_USER_LEVEL|NEGOTIATE_SECURITY_CHALLENGE_RESPONSE)) == 0) {
844 if (!lp_client_plaintext_auth() && (*pass)) {
845 DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
851 * Non-encrypted passwords - convert to DOS codepage before using.
853 passlen = clistr_push(cli, pword, pass, sizeof(pword), STR_TERMINATE);
856 memcpy(pword, pass, passlen);
860 slprintf(fullshare, sizeof(fullshare)-1,
861 "\\\\%s\\%s", cli->desthost, share);
863 set_message(cli->outbuf,4, 0, True);
864 SCVAL(cli->outbuf,smb_com,SMBtconX);
865 cli_setup_packet(cli);
867 SSVAL(cli->outbuf,smb_vwv0,0xFF);
868 SSVAL(cli->outbuf,smb_vwv3,passlen);
870 p = smb_buf(cli->outbuf);
871 memcpy(p,pword,passlen);
873 p += clistr_push(cli, p, fullshare, -1, STR_TERMINATE |STR_UPPER);
874 fstrcpy(p, dev); p += strlen(dev)+1;
876 cli_setup_bcc(cli, p);
879 if (!cli_receive_smb(cli))
882 if (cli_is_error(cli))
885 clistr_pull(cli, cli->dev, smb_buf(cli->inbuf), sizeof(fstring), -1, STR_TERMINATE|STR_ASCII);
887 if (cli->protocol >= PROTOCOL_NT1 &&
888 smb_buflen(cli->inbuf) == 3) {
889 /* almost certainly win95 - enable bug fixes */
893 cli->cnum = SVAL(cli->inbuf,smb_tid);
897 /****************************************************************************
898 Send a tree disconnect.
899 ****************************************************************************/
901 BOOL cli_tdis(struct cli_state *cli)
903 memset(cli->outbuf,'\0',smb_size);
904 set_message(cli->outbuf,0,0,True);
905 SCVAL(cli->outbuf,smb_com,SMBtdis);
906 SSVAL(cli->outbuf,smb_tid,cli->cnum);
907 cli_setup_packet(cli);
910 if (!cli_receive_smb(cli))
913 return !cli_is_error(cli);
916 /****************************************************************************
917 Send a negprot command.
918 ****************************************************************************/
920 void cli_negprot_send(struct cli_state *cli)
925 if (cli->protocol < PROTOCOL_NT1)
926 cli->use_spnego = False;
928 memset(cli->outbuf,'\0',smb_size);
930 /* setup the protocol strings */
931 set_message(cli->outbuf,0,0,True);
933 p = smb_buf(cli->outbuf);
935 prots[numprots].name && prots[numprots].prot<=cli->protocol;
938 p += clistr_push(cli, p, prots[numprots].name, -1, STR_TERMINATE);
941 SCVAL(cli->outbuf,smb_com,SMBnegprot);
942 cli_setup_bcc(cli, p);
943 cli_setup_packet(cli);
945 SCVAL(smb_buf(cli->outbuf),0,2);
950 /****************************************************************************
951 Send a negprot command.
952 ****************************************************************************/
954 BOOL cli_negprot(struct cli_state *cli)
960 if (cli->protocol < PROTOCOL_NT1)
961 cli->use_spnego = False;
963 memset(cli->outbuf,'\0',smb_size);
965 /* setup the protocol strings */
966 for (plength=0,numprots=0;
967 prots[numprots].name && prots[numprots].prot<=cli->protocol;
969 plength += strlen(prots[numprots].name)+2;
971 set_message(cli->outbuf,0,plength,True);
973 p = smb_buf(cli->outbuf);
975 prots[numprots].name && prots[numprots].prot<=cli->protocol;
978 p += clistr_push(cli, p, prots[numprots].name, -1, STR_TERMINATE);
981 SCVAL(cli->outbuf,smb_com,SMBnegprot);
982 cli_setup_packet(cli);
984 SCVAL(smb_buf(cli->outbuf),0,2);
987 if (!cli_receive_smb(cli))
990 show_msg(cli->inbuf);
992 if (cli_is_error(cli) ||
993 ((int)SVAL(cli->inbuf,smb_vwv0) >= numprots)) {
997 cli->protocol = prots[SVAL(cli->inbuf,smb_vwv0)].prot;
999 if ((cli->protocol < PROTOCOL_NT1) && cli->sign_info.mandatory_signing) {
1000 DEBUG(1,("cli_negprot: SMB signing is mandatory and the selected protocol level doesn't support it.\n"));
1004 if (cli->protocol >= PROTOCOL_NT1) {
1006 cli->sec_mode = CVAL(cli->inbuf,smb_vwv1);
1007 cli->max_mux = SVAL(cli->inbuf, smb_vwv1+1);
1008 cli->max_xmit = IVAL(cli->inbuf,smb_vwv3+1);
1009 cli->sesskey = IVAL(cli->inbuf,smb_vwv7+1);
1010 cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1);
1011 cli->serverzone *= 60;
1012 /* this time arrives in real GMT */
1013 cli->servertime = interpret_long_date(cli->inbuf+smb_vwv11+1);
1014 cli->secblob = data_blob(smb_buf(cli->inbuf),smb_buflen(cli->inbuf));
1015 cli->capabilities = IVAL(cli->inbuf,smb_vwv9+1);
1016 if (cli->capabilities & CAP_RAW_MODE) {
1017 cli->readbraw_supported = True;
1018 cli->writebraw_supported = True;
1020 /* work out if they sent us a workgroup */
1021 if (!(cli->capabilities & CAP_EXTENDED_SECURITY) &&
1022 smb_buflen(cli->inbuf) > 8) {
1023 clistr_pull(cli, cli->server_domain,
1024 smb_buf(cli->inbuf)+8, sizeof(cli->server_domain),
1025 smb_buflen(cli->inbuf)-8, STR_UNICODE|STR_NOALIGN);
1028 if ((cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_REQUIRED)) {
1029 /* Fail if signing is mandatory and we don't want to support it. */
1030 if (!cli->sign_info.allow_smb_signing) {
1031 DEBUG(1,("cli_negprot: SMB signing is mandatory and we have disabled it.\n"));
1034 cli->sign_info.negotiated_smb_signing = True;
1037 if ((cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_ENABLED) && cli->sign_info.allow_smb_signing)
1038 cli->sign_info.negotiated_smb_signing = True;
1040 /* Fail if signing is mandatory and the server doesn't support it. */
1041 if (cli->sign_info.mandatory_signing && !(cli->sign_info.negotiated_smb_signing)) {
1042 DEBUG(1,("cli_negprot: SMB signing is mandatory and the server doesn't support it.\n"));
1046 } else if (cli->protocol >= PROTOCOL_LANMAN1) {
1047 cli->use_spnego = False;
1048 cli->sec_mode = SVAL(cli->inbuf,smb_vwv1);
1049 cli->max_xmit = SVAL(cli->inbuf,smb_vwv2);
1050 cli->sesskey = IVAL(cli->inbuf,smb_vwv6);
1051 cli->serverzone = SVALS(cli->inbuf,smb_vwv10);
1052 cli->serverzone *= 60;
1053 /* this time is converted to GMT by make_unix_date */
1054 cli->servertime = make_unix_date(cli->inbuf+smb_vwv8);
1055 cli->readbraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x1) != 0);
1056 cli->writebraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x2) != 0);
1057 cli->secblob = data_blob(smb_buf(cli->inbuf),smb_buflen(cli->inbuf));
1059 /* the old core protocol */
1060 cli->use_spnego = False;
1062 cli->serverzone = TimeDiff(time(NULL));
1065 cli->max_xmit = MIN(cli->max_xmit, CLI_BUFFER_SIZE);
1067 /* a way to force ascii SMB */
1068 if (getenv("CLI_FORCE_ASCII"))
1069 cli->capabilities &= ~CAP_UNICODE;
1074 /****************************************************************************
1075 Send a session request. See rfc1002.txt 4.3 and 4.3.2.
1076 ****************************************************************************/
1078 BOOL cli_session_request(struct cli_state *cli,
1079 struct nmb_name *calling, struct nmb_name *called)
1083 extern pstring user_socket_options;
1085 memcpy(&(cli->calling), calling, sizeof(*calling));
1086 memcpy(&(cli->called ), called , sizeof(*called ));
1088 /* put in the destination name */
1089 p = cli->outbuf+len;
1090 name_mangle(cli->called .name, p, cli->called .name_type);
1094 p = cli->outbuf+len;
1095 name_mangle(cli->calling.name, p, cli->calling.name_type);
1098 /* 445 doesn't have session request */
1099 if (cli->port == 445)
1102 /* send a session request (RFC 1002) */
1103 /* setup the packet length
1104 * Remove four bytes from the length count, since the length
1105 * field in the NBT Session Service header counts the number
1106 * of bytes which follow. The cli_send_smb() function knows
1107 * about this and accounts for those four bytes.
1111 _smb_setlen(cli->outbuf,len);
1112 SCVAL(cli->outbuf,0,0x81);
1115 DEBUG(5,("Sent session request\n"));
1117 if (!cli_receive_smb(cli))
1120 if (CVAL(cli->inbuf,0) == 0x84) {
1121 /* C. Hoch 9/14/95 Start */
1122 /* For information, here is the response structure.
1123 * We do the byte-twiddling to for portability.
1124 struct RetargetResponse{
1126 unsigned char flags;
1132 int port = (CVAL(cli->inbuf,8)<<8)+CVAL(cli->inbuf,9);
1133 /* SESSION RETARGET */
1134 putip((char *)&cli->dest_ip,cli->inbuf+4);
1136 cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip, port, LONG_CONNECT_TIMEOUT);
1140 DEBUG(3,("Retargeted\n"));
1142 set_socket_options(cli->fd,user_socket_options);
1149 DEBUG(0,("Retarget recursion - failing\n"));
1153 ret = cli_session_request(cli, calling, called);
1157 } /* C. Hoch 9/14/95 End */
1159 if (CVAL(cli->inbuf,0) != 0x82) {
1160 /* This is the wrong place to put the error... JRA. */
1161 cli->rap_error = CVAL(cli->inbuf,4);
1167 /****************************************************************************
1168 Open the client sockets.
1169 ****************************************************************************/
1171 BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip)
1173 extern pstring user_socket_options;
1174 int name_type = 0x20;
1177 /* reasonable default hostname */
1178 if (!host) host = "*SMBSERVER";
1180 fstrcpy(cli->desthost, host);
1182 /* allow hostnames of the form NAME#xx and do a netbios lookup */
1183 if ((p = strchr(cli->desthost, '#'))) {
1184 name_type = strtol(p+1, NULL, 16);
1188 if (!ip || is_zero_ip(*ip)) {
1189 if (!resolve_name(cli->desthost, &cli->dest_ip, name_type)) {
1192 if (ip) *ip = cli->dest_ip;
1197 if (getenv("LIBSMB_PROG")) {
1198 cli->fd = sock_exec(getenv("LIBSMB_PROG"));
1200 /* try 445 first, then 139 */
1201 int port = cli->port?cli->port:445;
1202 cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
1203 port, cli->timeout);
1204 if (cli->fd == -1 && cli->port == 0) {
1206 cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
1207 port, cli->timeout);
1212 if (cli->fd == -1) {
1213 DEBUG(1,("Error connecting to %s (%s)\n",
1214 ip?inet_ntoa(*ip):host,strerror(errno)));
1218 set_socket_options(cli->fd,user_socket_options);
1223 /****************************************************************************
1224 Initialise client credentials for authenticated pipe access.
1225 ****************************************************************************/
1227 static void init_creds(struct ntuser_creds *creds, const char* username,
1228 const char* domain, const char* password)
1230 ZERO_STRUCTP(creds);
1232 pwd_set_cleartext(&creds->pwd, password);
1234 fstrcpy(creds->user_name, username);
1235 fstrcpy(creds->domain, domain);
1238 creds->pwd.null_pwd = True;
1243 establishes a connection right up to doing tconX, password specified.
1244 @param output_cli A fully initialised cli structure, non-null only on success
1245 @param dest_host The netbios name of the remote host
1246 @param dest_ip (optional) The the destination IP, NULL for name based lookup
1247 @param port (optional) The destination port (0 for default)
1248 @param service (optional) The share to make the connection to. Should be 'unqualified' in any way.
1249 @param service_type The 'type' of serivice.
1250 @param user Username, unix string
1251 @param domain User's domain
1252 @param password User's password, unencrypted unix string.
1253 @param retry BOOL. Did this connection fail with a retryable error ?
1256 NTSTATUS cli_full_connection(struct cli_state **output_cli,
1257 const char *my_name,
1258 const char *dest_host,
1259 struct in_addr *dest_ip, int port,
1260 const char *service, const char *service_type,
1261 const char *user, const char *domain,
1262 const char *password, int flags,
1266 struct ntuser_creds creds;
1268 struct nmb_name calling;
1269 struct nmb_name called;
1270 struct cli_state *cli;
1277 my_name = global_myname();
1279 if (!(cli = cli_initialise(NULL)))
1280 return NT_STATUS_NO_MEMORY;
1282 make_nmb_name(&calling, my_name, 0x0);
1283 make_nmb_name(&called , dest_host, 0x20);
1285 if (cli_set_port(cli, port) != port) {
1287 return NT_STATUS_UNSUCCESSFUL;
1290 cli_set_timeout(cli, 10000); /* 10 seconds. */
1299 DEBUG(3,("Connecting to host=%s share=%s\n", dest_host, service));
1301 if (!cli_connect(cli, dest_host, &ip)) {
1302 DEBUG(1,("cli_full_connection: failed to connect to %s (%s)\n",
1303 nmb_namestr(&called), inet_ntoa(ip)));
1305 return NT_STATUS_UNSUCCESSFUL;
1311 if (!cli_session_request(cli, &calling, &called)) {
1313 DEBUG(1,("session request to %s failed (%s)\n",
1314 called.name, cli_errstr(cli)));
1315 if ((p=strchr(called.name, '.')) && !is_ipaddress(called.name)) {
1319 if (strcmp(called.name, "*SMBSERVER")) {
1320 make_nmb_name(&called , "*SMBSERVER", 0x20);
1323 return NT_STATUS_UNSUCCESSFUL;
1326 cli_setup_signing_state(cli, signing_state);
1328 if (flags & CLI_FULL_CONNECTION_DONT_SPNEGO)
1329 cli->use_spnego = False;
1330 else if (flags & CLI_FULL_CONNECTION_USE_KERBEROS)
1331 cli->use_kerberos = True;
1333 if (!cli_negprot(cli)) {
1334 DEBUG(1,("failed negprot\n"));
1335 nt_status = NT_STATUS_UNSUCCESSFUL;
1340 if (!cli_session_setup(cli, user, password, strlen(password)+1,
1341 password, strlen(password)+1,
1343 if ((flags & CLI_FULL_CONNECTION_ANNONYMOUS_FALLBACK)
1344 && cli_session_setup(cli, "", "", 0, "", 0, domain)) {
1346 nt_status = cli_nt_error(cli);
1347 DEBUG(1,("failed session setup with %s\n", nt_errstr(nt_status)));
1349 if (NT_STATUS_IS_OK(nt_status))
1350 nt_status = NT_STATUS_UNSUCCESSFUL;
1356 if (!cli_send_tconX(cli, service, service_type,
1357 password, strlen(password)+1)) {
1358 nt_status = cli_nt_error(cli);
1359 DEBUG(1,("failed tcon_X with %s\n", nt_errstr(nt_status)));
1361 if (NT_STATUS_IS_OK(nt_status)) {
1362 nt_status = NT_STATUS_UNSUCCESSFUL;
1368 init_creds(&creds, user, domain, password);
1369 cli_init_creds(cli, &creds);
1372 return NT_STATUS_OK;
1375 /****************************************************************************
1376 Attempt a NetBIOS session request, falling back to *SMBSERVER if needed.
1377 ****************************************************************************/
1379 BOOL attempt_netbios_session_request(struct cli_state *cli, const char *srchost, const char *desthost,
1380 struct in_addr *pdest_ip)
1382 struct nmb_name calling, called;
1384 make_nmb_name(&calling, srchost, 0x0);
1387 * If the called name is an IP address
1388 * then use *SMBSERVER immediately.
1391 if(is_ipaddress(desthost))
1392 make_nmb_name(&called, "*SMBSERVER", 0x20);
1394 make_nmb_name(&called, desthost, 0x20);
1396 if (!cli_session_request(cli, &calling, &called)) {
1397 struct nmb_name smbservername;
1399 make_nmb_name(&smbservername , "*SMBSERVER", 0x20);
1402 * If the name wasn't *SMBSERVER then
1403 * try with *SMBSERVER if the first name fails.
1406 if (nmb_name_equal(&called, &smbservername)) {
1409 * The name used was *SMBSERVER, don't bother with another name.
1412 DEBUG(0,("attempt_netbios_session_request: %s rejected the session for name *SMBSERVER \
1413 with error %s.\n", desthost, cli_errstr(cli) ));
1418 * We need to close the connection here but can't call cli_shutdown as
1419 * will free an allocated cli struct. cli_close_connection was invented
1420 * for this purpose. JRA. Based on work by "Kim R. Pedersen" <krp@filanet.dk>.
1423 cli_close_connection(cli);
1425 if (!cli_initialise(cli) ||
1426 !cli_connect(cli, desthost, pdest_ip) ||
1427 !cli_session_request(cli, &calling, &smbservername)) {
1428 DEBUG(0,("attempt_netbios_session_request: %s rejected the session for \
1429 name *SMBSERVER with error %s\n", desthost, cli_errstr(cli) ));
1441 /****************************************************************************
1442 Send an old style tcon.
1443 ****************************************************************************/
1444 NTSTATUS cli_raw_tcon(struct cli_state *cli,
1445 const char *service, const char *pass, const char *dev,
1446 uint16 *max_xmit, uint16 *tid)
1450 if (!lp_client_plaintext_auth() && (*pass)) {
1451 DEBUG(1, ("Server requested plaintext password but 'client use plaintext auth'"
1453 return NT_STATUS_ACCESS_DENIED;
1456 memset(cli->outbuf,'\0',smb_size);
1457 memset(cli->inbuf,'\0',smb_size);
1459 set_message(cli->outbuf, 0, 0, True);
1460 SCVAL(cli->outbuf,smb_com,SMBtcon);
1461 cli_setup_packet(cli);
1463 p = smb_buf(cli->outbuf);
1464 *p++ = 4; p += clistr_push(cli, p, service, -1, STR_TERMINATE | STR_NOALIGN);
1465 *p++ = 4; p += clistr_push(cli, p, pass, -1, STR_TERMINATE | STR_NOALIGN);
1466 *p++ = 4; p += clistr_push(cli, p, dev, -1, STR_TERMINATE | STR_NOALIGN);
1468 cli_setup_bcc(cli, p);
1471 if (!cli_receive_smb(cli)) {
1472 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
1475 if (cli_is_error(cli)) {
1476 return cli_nt_error(cli);
1479 *max_xmit = SVAL(cli->inbuf, smb_vwv0);
1480 *tid = SVAL(cli->inbuf, smb_vwv1);
1482 return NT_STATUS_OK;
1485 /* Return a cli_state pointing at the IPC$ share for the given server */
1487 struct cli_state *get_ipc_connect(char *server, struct in_addr *server_ip,
1488 struct user_auth_info *user_info)
1490 struct cli_state *cli;
1496 nt_status = cli_full_connection(&cli, myname, server, server_ip, 0, "IPC$", "IPC",
1497 user_info->username, lp_workgroup(), user_info->password,
1498 CLI_FULL_CONNECTION_ANNONYMOUS_FALLBACK, Undefined, NULL);
1500 if (NT_STATUS_IS_OK(nt_status)) {
1502 } else if (is_ipaddress(server)) {
1503 /* windows 9* needs a correct NMB name for connections */
1504 fstring remote_name;
1506 if (name_status_find("*", 0, 0, *server_ip, remote_name)) {
1507 cli = get_ipc_connect(remote_name, server_ip, user_info);
1515 /* Return the IP address and workgroup of a master browser on the
1518 struct cli_state *get_ipc_connect_master_ip_bcast(pstring workgroup, struct user_auth_info *user_info)
1520 struct ip_service *ip_list;
1521 struct cli_state *cli;
1523 struct in_addr server_ip;
1525 /* Go looking for workgroups by broadcasting on the local network */
1527 if (!name_resolve_bcast(MSBROWSE, 1, &ip_list, &count)) {
1531 for (i = 0; i < count; i++) {
1532 static fstring name;
1534 if (!name_status_find("*", 0, 0x1d, ip_list[i].ip, name))
1537 if (!find_master_ip(name, &server_ip))
1540 pstrcpy(workgroup, name);
1542 DEBUG(4, ("found master browser %s, %s\n",
1543 name, inet_ntoa(ip_list[i].ip)));
1545 cli = get_ipc_connect(inet_ntoa(server_ip), &server_ip, user_info);