Line data Source code
1 : /*
2 : Unix SMB/Netbios implementation.
3 : SMB client library implementation
4 : Copyright (C) Andrew Tridgell 1998
5 : Copyright (C) Richard Sharpe 2000, 2002
6 : Copyright (C) John Terpstra 2000
7 : Copyright (C) Tom Jansen (Ninja ISD) 2002
8 : Copyright (C) Derrell Lipman 2003-2008
9 : Copyright (C) Jeremy Allison 2007, 2008
10 : Copyright (C) SATOH Fumiyasu <fumiyas@osstech.co.jp> 2009.
11 :
12 : This program is free software; you can redistribute it and/or modify
13 : it under the terms of the GNU General Public License as published by
14 : the Free Software Foundation; either version 3 of the License, or
15 : (at your option) any later version.
16 :
17 : This program is distributed in the hope that it will be useful,
18 : but WITHOUT ANY WARRANTY; without even the implied warranty of
19 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 : GNU General Public License for more details.
21 :
22 : You should have received a copy of the GNU General Public License
23 : along with this program. If not, see <http://www.gnu.org/licenses/>.
24 : */
25 :
26 : #include "includes.h"
27 : #include "libsmb/libsmb.h"
28 : #include "libsmbclient.h"
29 : #include "libsmb_internal.h"
30 : #include "../librpc/gen_ndr/ndr_lsa.h"
31 : #include "rpc_client/cli_pipe.h"
32 : #include "rpc_client/cli_lsarpc.h"
33 : #include "libcli/security/security.h"
34 : #include "libsmb/nmblib.h"
35 : #include "../libcli/smb/smbXcli_base.h"
36 :
37 : /*
38 : * Check a server for being alive and well.
39 : * returns 0 if the server is in shape. Returns 1 on error
40 : *
41 : * Also useable outside libsmbclient to enable external cache
42 : * to do some checks too.
43 : */
44 : int
45 0 : SMBC_check_server(SMBCCTX * context,
46 : SMBCSRV * server)
47 : {
48 : time_t now;
49 :
50 0 : if (!cli_state_is_connected(server->cli)) {
51 0 : return 1;
52 : }
53 :
54 0 : now = time_mono(NULL);
55 :
56 0 : if (server->last_echo_time == (time_t)0 ||
57 0 : now > server->last_echo_time +
58 0 : (server->cli->timeout/1000)) {
59 0 : unsigned char data[16] = {0};
60 0 : NTSTATUS status = cli_echo(server->cli,
61 : 1,
62 : data_blob_const(data, sizeof(data)));
63 0 : if (!NT_STATUS_IS_OK(status)) {
64 0 : bool ok = false;
65 : /*
66 : * Some SMB2 servers (not Samba or Windows)
67 : * check the session status on SMB2_ECHO and return
68 : * NT_STATUS_USER_SESSION_DELETED
69 : * if the session was not set. That's OK, they still
70 : * replied.
71 : * BUG: https://bugzilla.samba.org/show_bug.cgi?id=13218
72 : */
73 0 : if (smbXcli_conn_protocol(server->cli->conn) >=
74 : PROTOCOL_SMB2_02) {
75 0 : if (NT_STATUS_EQUAL(status,
76 : NT_STATUS_USER_SESSION_DELETED)) {
77 0 : ok = true;
78 : }
79 : }
80 : /*
81 : * Some NetApp servers return
82 : * NT_STATUS_INVALID_PARAMETER.That's OK, they still
83 : * replied.
84 : * BUG: https://bugzilla.samba.org/show_bug.cgi?id=13007
85 : */
86 0 : if (NT_STATUS_EQUAL(status,
87 : NT_STATUS_INVALID_PARAMETER)) {
88 0 : ok = true;
89 : }
90 0 : if (!ok) {
91 0 : return 1;
92 : }
93 : }
94 0 : server->last_echo_time = now;
95 : }
96 0 : return 0;
97 : }
98 :
99 : /*
100 : * Remove a server from the cached server list it's unused.
101 : * On success, 0 is returned. 1 is returned if the server could not be removed.
102 : *
103 : * Also useable outside libsmbclient
104 : */
105 : int
106 0 : SMBC_remove_unused_server(SMBCCTX * context,
107 : SMBCSRV * srv)
108 : {
109 : SMBCFILE * file;
110 :
111 : /* are we being fooled ? */
112 0 : if (!context || !context->internal->initialized || !srv) {
113 0 : return 1;
114 : }
115 :
116 : /* Check all open files/directories for a relation with this server */
117 0 : for (file = context->internal->files; file; file = file->next) {
118 0 : if (file->srv == srv) {
119 : /* Still used */
120 0 : DEBUG(3, ("smbc_remove_usused_server: "
121 : "%p still used by %p.\n",
122 : srv, file));
123 0 : return 1;
124 : }
125 : }
126 :
127 0 : DLIST_REMOVE(context->internal->servers, srv);
128 :
129 0 : cli_shutdown(srv->cli);
130 0 : srv->cli = NULL;
131 :
132 0 : DEBUG(3, ("smbc_remove_usused_server: %p removed.\n", srv));
133 :
134 0 : smbc_getFunctionRemoveCachedServer(context)(context, srv);
135 :
136 0 : SAFE_FREE(srv);
137 0 : return 0;
138 : }
139 :
140 : /****************************************************************
141 : * Call the auth_fn with fixed size (fstring) buffers.
142 : ***************************************************************/
143 : static void
144 0 : SMBC_call_auth_fn(TALLOC_CTX *ctx,
145 : SMBCCTX *context,
146 : const char *server,
147 : const char *share,
148 : char **pp_workgroup,
149 : char **pp_username,
150 : char **pp_password)
151 : {
152 0 : fstring workgroup = { 0 };
153 0 : fstring username = { 0 };
154 0 : fstring password = { 0 };
155 : smbc_get_auth_data_with_context_fn auth_with_context_fn;
156 :
157 0 : if (*pp_workgroup != NULL) {
158 0 : strlcpy(workgroup, *pp_workgroup, sizeof(workgroup));
159 : }
160 0 : if (*pp_username != NULL) {
161 0 : strlcpy(username, *pp_username, sizeof(username));
162 : }
163 0 : if (*pp_password != NULL) {
164 0 : strlcpy(password, *pp_password, sizeof(password));
165 : }
166 :
167 : /* See if there's an authentication with context function provided */
168 0 : auth_with_context_fn = smbc_getFunctionAuthDataWithContext(context);
169 0 : if (auth_with_context_fn)
170 : {
171 0 : (* auth_with_context_fn)(context,
172 : server, share,
173 : workgroup, sizeof(workgroup),
174 : username, sizeof(username),
175 : password, sizeof(password));
176 : }
177 : else
178 : {
179 0 : smbc_getFunctionAuthData(context)(server, share,
180 : workgroup, sizeof(workgroup),
181 : username, sizeof(username),
182 : password, sizeof(password));
183 : }
184 :
185 0 : TALLOC_FREE(*pp_workgroup);
186 0 : TALLOC_FREE(*pp_username);
187 0 : TALLOC_FREE(*pp_password);
188 :
189 0 : *pp_workgroup = talloc_strdup(ctx, workgroup);
190 0 : *pp_username = talloc_strdup(ctx, username);
191 0 : *pp_password = talloc_strdup(ctx, password);
192 0 : }
193 :
194 :
195 : void
196 0 : SMBC_get_auth_data(const char *server, const char *share,
197 : char *workgroup_buf, int workgroup_buf_len,
198 : char *username_buf, int username_buf_len,
199 : char *password_buf, int password_buf_len)
200 : {
201 : /* Default function just uses provided data. Nothing to do. */
202 0 : }
203 :
204 :
205 :
206 : SMBCSRV *
207 0 : SMBC_find_server(TALLOC_CTX *ctx,
208 : SMBCCTX *context,
209 : const char *server,
210 : const char *share,
211 : char **pp_workgroup,
212 : char **pp_username,
213 : char **pp_password)
214 : {
215 : SMBCSRV *srv;
216 0 : int auth_called = 0;
217 :
218 0 : if (!pp_workgroup || !pp_username || !pp_password) {
219 0 : return NULL;
220 : }
221 :
222 0 : check_server_cache:
223 :
224 0 : srv = smbc_getFunctionGetCachedServer(context)(context,
225 : server, share,
226 : *pp_workgroup,
227 : *pp_username);
228 :
229 0 : if (!auth_called && !srv && (!*pp_username || !(*pp_username)[0] ||
230 0 : !*pp_password || !(*pp_password)[0])) {
231 0 : SMBC_call_auth_fn(ctx, context, server, share,
232 : pp_workgroup, pp_username, pp_password);
233 :
234 : /*
235 : * However, smbc_auth_fn may have picked up info relating to
236 : * an existing connection, so try for an existing connection
237 : * again ...
238 : */
239 0 : auth_called = 1;
240 0 : goto check_server_cache;
241 :
242 : }
243 :
244 0 : if (srv) {
245 0 : if (smbc_getFunctionCheckServer(context)(context, srv)) {
246 : /*
247 : * This server is no good anymore
248 : * Try to remove it and check for more possible
249 : * servers in the cache
250 : */
251 0 : if (smbc_getFunctionRemoveUnusedServer(context)(context,
252 : srv)) {
253 : /*
254 : * We could not remove the server completely,
255 : * remove it from the cache so we will not get
256 : * it again. It will be removed when the last
257 : * file/dir is closed.
258 : */
259 0 : smbc_getFunctionRemoveCachedServer(context)(context,
260 : srv);
261 : }
262 :
263 : /*
264 : * Maybe there are more cached connections to this
265 : * server
266 : */
267 0 : goto check_server_cache;
268 : }
269 :
270 0 : return srv;
271 : }
272 :
273 0 : return NULL;
274 : }
275 :
276 0 : static struct cli_credentials *SMBC_auth_credentials(TALLOC_CTX *mem_ctx,
277 : SMBCCTX *context,
278 : const char *domain,
279 : const char *username,
280 : const char *password)
281 : {
282 0 : struct cli_credentials *creds = NULL;
283 0 : bool use_kerberos = false;
284 0 : bool fallback_after_kerberos = false;
285 0 : bool use_ccache = false;
286 0 : bool pw_nt_hash = false;
287 :
288 0 : use_kerberos = smbc_getOptionUseKerberos(context);
289 0 : fallback_after_kerberos = smbc_getOptionFallbackAfterKerberos(context);
290 0 : use_ccache = smbc_getOptionUseCCache(context);
291 0 : pw_nt_hash = smbc_getOptionUseNTHash(context);
292 :
293 0 : creds = cli_session_creds_init(mem_ctx,
294 : username,
295 : domain,
296 : NULL, /* realm */
297 : password,
298 : use_kerberos,
299 : fallback_after_kerberos,
300 : use_ccache,
301 : pw_nt_hash);
302 0 : if (creds == NULL) {
303 0 : return NULL;
304 : }
305 :
306 0 : switch (context->internal->smb_encryption_level) {
307 0 : case SMBC_ENCRYPTLEVEL_DEFAULT:
308 : /* Use the config option */
309 0 : break;
310 0 : case SMBC_ENCRYPTLEVEL_NONE:
311 0 : (void)cli_credentials_set_smb_encryption(
312 : creds,
313 : SMB_ENCRYPTION_OFF,
314 : CRED_SPECIFIED);
315 0 : break;
316 0 : case SMBC_ENCRYPTLEVEL_REQUEST:
317 0 : (void)cli_credentials_set_smb_encryption(
318 : creds,
319 : SMB_ENCRYPTION_DESIRED,
320 : CRED_SPECIFIED);
321 0 : break;
322 0 : case SMBC_ENCRYPTLEVEL_REQUIRE:
323 : default:
324 0 : (void)cli_credentials_set_smb_encryption(
325 : creds,
326 : SMB_ENCRYPTION_REQUIRED,
327 : CRED_SPECIFIED);
328 0 : break;
329 : }
330 :
331 :
332 0 : return creds;
333 : }
334 :
335 : /*
336 : * Connect to a server, possibly on an existing connection
337 : *
338 : * Here, what we want to do is: If the server and username
339 : * match an existing connection, reuse that, otherwise, establish a
340 : * new connection.
341 : *
342 : * If we have to create a new connection, call the auth_fn to get the
343 : * info we need, unless the username and password were passed in.
344 : */
345 :
346 : static SMBCSRV *
347 0 : SMBC_server_internal(TALLOC_CTX *ctx,
348 : SMBCCTX *context,
349 : bool connect_if_not_found,
350 : const char *server,
351 : uint16_t port,
352 : const char *share,
353 : char **pp_workgroup,
354 : char **pp_username,
355 : char **pp_password,
356 : bool *in_cache)
357 : {
358 0 : SMBCSRV *srv=NULL;
359 0 : char *workgroup = NULL;
360 0 : struct cli_state *c = NULL;
361 0 : const char *server_n = server;
362 0 : int is_ipc = (share != NULL && strcmp(share, "IPC$") == 0);
363 0 : uint32_t fs_attrs = 0;
364 0 : const char *username_used = NULL;
365 0 : const char *password_used = NULL;
366 : NTSTATUS status;
367 : char *newserver, *newshare;
368 0 : int flags = 0;
369 0 : struct smbXcli_tcon *tcon = NULL;
370 0 : int signing_state = SMB_SIGNING_DEFAULT;
371 0 : struct cli_credentials *creds = NULL;
372 :
373 0 : *in_cache = false;
374 :
375 0 : if (server[0] == 0) {
376 0 : errno = EPERM;
377 0 : return NULL;
378 : }
379 :
380 : /* Look for a cached connection */
381 0 : srv = SMBC_find_server(ctx, context, server, share,
382 : pp_workgroup, pp_username, pp_password);
383 :
384 : /*
385 : * If we found a connection and we're only allowed one share per
386 : * server...
387 : */
388 0 : if (srv &&
389 0 : share != NULL && *share != '\0' &&
390 0 : smbc_getOptionOneSharePerServer(context)) {
391 :
392 : /*
393 : * ... then if there's no current connection to the share,
394 : * connect to it. SMBC_find_server(), or rather the function
395 : * pointed to by context->get_cached_srv_fn which
396 : * was called by SMBC_find_server(), will have issued a tree
397 : * disconnect if the requested share is not the same as the
398 : * one that was already connected.
399 : */
400 :
401 : /*
402 : * Use srv->cli->desthost and srv->cli->share instead of
403 : * server and share below to connect to the actual share,
404 : * i.e., a normal share or a referred share from
405 : * 'msdfs proxy' share.
406 : */
407 0 : if (!cli_state_has_tcon(srv->cli)) {
408 : /* Ensure we have accurate auth info */
409 0 : SMBC_call_auth_fn(ctx, context,
410 0 : smbXcli_conn_remote_name(srv->cli->conn),
411 0 : srv->cli->share,
412 : pp_workgroup,
413 : pp_username,
414 : pp_password);
415 :
416 0 : if (!*pp_workgroup || !*pp_username || !*pp_password) {
417 0 : errno = ENOMEM;
418 0 : cli_shutdown(srv->cli);
419 0 : srv->cli = NULL;
420 0 : smbc_getFunctionRemoveCachedServer(context)(context,
421 : srv);
422 0 : return NULL;
423 : }
424 :
425 : /*
426 : * We don't need to renegotiate encryption
427 : * here as the encryption context is not per
428 : * tid.
429 : */
430 :
431 0 : status = cli_tree_connect(srv->cli,
432 0 : srv->cli->share,
433 : "?????",
434 : *pp_password);
435 0 : if (!NT_STATUS_IS_OK(status)) {
436 0 : cli_shutdown(srv->cli);
437 0 : errno = map_errno_from_nt_status(status);
438 0 : srv->cli = NULL;
439 0 : smbc_getFunctionRemoveCachedServer(context)(context,
440 : srv);
441 0 : srv = NULL;
442 0 : goto not_found;
443 : }
444 :
445 : /* Determine if this share supports case sensitivity */
446 0 : if (is_ipc) {
447 0 : DEBUG(4,
448 : ("IPC$ so ignore case sensitivity\n"));
449 0 : status = NT_STATUS_OK;
450 : } else {
451 0 : status = cli_get_fs_attr_info(srv->cli, &fs_attrs);
452 : }
453 :
454 0 : if (!NT_STATUS_IS_OK(status)) {
455 0 : DEBUG(4, ("Could not retrieve "
456 : "case sensitivity flag: %s.\n",
457 : nt_errstr(status)));
458 :
459 : /*
460 : * We can't determine the case sensitivity of
461 : * the share. We have no choice but to use the
462 : * user-specified case sensitivity setting.
463 : */
464 0 : if (smbc_getOptionCaseSensitive(context)) {
465 0 : cli_set_case_sensitive(srv->cli, true);
466 : } else {
467 0 : cli_set_case_sensitive(srv->cli, false);
468 : }
469 0 : } else if (!is_ipc) {
470 0 : DEBUG(4,
471 : ("Case sensitive: %s\n",
472 : (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
473 : ? "True"
474 : : "False")));
475 0 : cli_set_case_sensitive(
476 : srv->cli,
477 : (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
478 : ? True
479 0 : : False));
480 : }
481 :
482 : /*
483 : * Regenerate the dev value since it's based on both
484 : * server and share
485 : */
486 0 : if (srv) {
487 0 : const char *remote_name =
488 0 : smbXcli_conn_remote_name(srv->cli->conn);
489 :
490 0 : srv->dev = (dev_t)(str_checksum(remote_name) ^
491 0 : str_checksum(srv->cli->share));
492 : }
493 : }
494 : }
495 :
496 0 : not_found:
497 :
498 : /* If we have a connection... */
499 0 : if (srv) {
500 :
501 : /* ... then we're done here. Give 'em what they came for. */
502 0 : *in_cache = true;
503 0 : goto done;
504 : }
505 :
506 : /* If we're not asked to connect when a connection doesn't exist... */
507 0 : if (! connect_if_not_found) {
508 : /* ... then we're done here. */
509 0 : return NULL;
510 : }
511 :
512 0 : if (!*pp_workgroup || !*pp_username || !*pp_password) {
513 0 : errno = ENOMEM;
514 0 : return NULL;
515 : }
516 :
517 0 : DEBUG(4,("SMBC_server: server_n=[%s] server=[%s]\n", server_n, server));
518 :
519 0 : DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
520 :
521 0 : status = NT_STATUS_UNSUCCESSFUL;
522 :
523 0 : if (context->internal->smb_encryption_level > SMBC_ENCRYPTLEVEL_NONE) {
524 0 : signing_state = SMB_SIGNING_REQUIRED;
525 : }
526 :
527 0 : if (port == 0) {
528 0 : if (share == NULL || *share == '\0' || is_ipc) {
529 : /*
530 : * Try 139 first for IPC$
531 : */
532 0 : status = cli_connect_nb(server_n, NULL, NBT_SMB_PORT, 0x20,
533 : smbc_getNetbiosName(context),
534 : signing_state, flags, &c);
535 : }
536 : }
537 :
538 0 : if (!NT_STATUS_IS_OK(status)) {
539 : /*
540 : * No IPC$ or 139 did not work
541 : */
542 0 : status = cli_connect_nb(server_n, NULL, port, 0x20,
543 : smbc_getNetbiosName(context),
544 : signing_state, flags, &c);
545 : }
546 :
547 0 : if (!NT_STATUS_IS_OK(status)) {
548 0 : if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
549 0 : DBG_ERR("NetBIOS support disabled, unable to connect");
550 : }
551 :
552 0 : errno = map_errno_from_nt_status(status);
553 0 : return NULL;
554 : }
555 :
556 0 : cli_set_timeout(c, smbc_getTimeout(context));
557 :
558 0 : status = smbXcli_negprot(c->conn, c->timeout,
559 0 : lp_client_min_protocol(),
560 0 : lp_client_max_protocol());
561 0 : if (!NT_STATUS_IS_OK(status)) {
562 0 : cli_shutdown(c);
563 0 : errno = map_errno_from_nt_status(status);
564 0 : return NULL;
565 : }
566 :
567 0 : if (smbXcli_conn_protocol(c->conn) >= PROTOCOL_SMB2_02) {
568 : /* Ensure we ask for some initial credits. */
569 0 : smb2cli_conn_set_max_credits(c->conn, DEFAULT_SMB2_MAX_CREDITS);
570 : }
571 :
572 0 : username_used = *pp_username;
573 0 : password_used = *pp_password;
574 :
575 0 : creds = SMBC_auth_credentials(c,
576 : context,
577 : *pp_workgroup,
578 : username_used,
579 : password_used);
580 0 : if (creds == NULL) {
581 0 : cli_shutdown(c);
582 0 : errno = ENOMEM;
583 0 : return NULL;
584 : }
585 :
586 0 : status = cli_session_setup_creds(c, creds);
587 0 : if (!NT_STATUS_IS_OK(status)) {
588 :
589 : /* Failed. Try an anonymous login, if allowed by flags. */
590 0 : username_used = "";
591 0 : password_used = "";
592 :
593 0 : if (smbc_getOptionNoAutoAnonymousLogin(context) ||
594 0 : !NT_STATUS_IS_OK(cli_session_setup_anon(c))) {
595 :
596 0 : cli_shutdown(c);
597 0 : errno = map_errno_from_nt_status(status);
598 0 : return NULL;
599 : }
600 : }
601 :
602 0 : DEBUG(4,(" session setup ok\n"));
603 :
604 : /* here's the fun part....to support 'msdfs proxy' shares
605 : (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL
606 : here before trying to connect to the original share.
607 : cli_check_msdfs_proxy() will fail if it is a normal share. */
608 :
609 0 : if (smbXcli_conn_dfs_supported(c->conn) &&
610 0 : cli_check_msdfs_proxy(ctx, c, share,
611 : &newserver, &newshare,
612 : creds)) {
613 0 : cli_shutdown(c);
614 0 : srv = SMBC_server_internal(ctx, context, connect_if_not_found,
615 : newserver, port, newshare, pp_workgroup,
616 : pp_username, pp_password, in_cache);
617 0 : TALLOC_FREE(newserver);
618 0 : TALLOC_FREE(newshare);
619 0 : return srv;
620 : }
621 :
622 : /* must be a normal share */
623 :
624 0 : status = cli_tree_connect_creds(c, share, "?????", creds);
625 0 : if (!NT_STATUS_IS_OK(status)) {
626 0 : cli_shutdown(c);
627 0 : errno = map_errno_from_nt_status(status);
628 0 : return NULL;
629 : }
630 :
631 0 : DEBUG(4,(" tconx ok\n"));
632 :
633 0 : if (smbXcli_conn_protocol(c->conn) >= PROTOCOL_SMB2_02) {
634 0 : tcon = c->smb2.tcon;
635 : } else {
636 0 : tcon = c->smb1.tcon;
637 : }
638 :
639 : /* Determine if this share supports case sensitivity */
640 0 : if (is_ipc) {
641 0 : DEBUG(4, ("IPC$ so ignore case sensitivity\n"));
642 0 : status = NT_STATUS_OK;
643 : } else {
644 0 : status = cli_get_fs_attr_info(c, &fs_attrs);
645 : }
646 :
647 0 : if (!NT_STATUS_IS_OK(status)) {
648 0 : DEBUG(4, ("Could not retrieve case sensitivity flag: %s.\n",
649 : nt_errstr(status)));
650 :
651 : /*
652 : * We can't determine the case sensitivity of the share. We
653 : * have no choice but to use the user-specified case
654 : * sensitivity setting.
655 : */
656 0 : if (smbc_getOptionCaseSensitive(context)) {
657 0 : cli_set_case_sensitive(c, True);
658 : } else {
659 0 : cli_set_case_sensitive(c, False);
660 : }
661 0 : } else if (!is_ipc) {
662 0 : DEBUG(4, ("Case sensitive: %s\n",
663 : (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
664 : ? "True"
665 : : "False")));
666 0 : smbXcli_tcon_set_fs_attributes(tcon, fs_attrs);
667 : }
668 :
669 : /*
670 : * Ok, we have got a nice connection
671 : * Let's allocate a server structure.
672 : */
673 :
674 0 : srv = SMB_MALLOC_P(SMBCSRV);
675 0 : if (!srv) {
676 0 : cli_shutdown(c);
677 0 : errno = ENOMEM;
678 0 : return NULL;
679 : }
680 :
681 0 : ZERO_STRUCTP(srv);
682 0 : DLIST_ADD(srv->cli, c);
683 0 : srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
684 0 : srv->no_pathinfo = False;
685 0 : srv->no_pathinfo2 = False;
686 0 : srv->no_pathinfo3 = False;
687 0 : srv->no_nt_session = False;
688 :
689 0 : done:
690 0 : if (!pp_workgroup || !*pp_workgroup || !**pp_workgroup) {
691 0 : workgroup = talloc_strdup(ctx, smbc_getWorkgroup(context));
692 : } else {
693 0 : workgroup = *pp_workgroup;
694 : }
695 0 : if(!workgroup) {
696 0 : if (c != NULL) {
697 0 : cli_shutdown(c);
698 : }
699 0 : SAFE_FREE(srv);
700 0 : return NULL;
701 : }
702 :
703 : /* set the credentials to make DFS work */
704 0 : smbc_set_credentials_with_fallback(context,
705 : workgroup,
706 : *pp_username,
707 : *pp_password);
708 :
709 0 : return srv;
710 : }
711 :
712 : SMBCSRV *
713 0 : SMBC_server(TALLOC_CTX *ctx,
714 : SMBCCTX *context,
715 : bool connect_if_not_found,
716 : const char *server,
717 : uint16_t port,
718 : const char *share,
719 : char **pp_workgroup,
720 : char **pp_username,
721 : char **pp_password)
722 : {
723 0 : SMBCSRV *srv=NULL;
724 0 : bool in_cache = false;
725 :
726 0 : srv = SMBC_server_internal(ctx, context, connect_if_not_found,
727 : server, port, share, pp_workgroup,
728 : pp_username, pp_password, &in_cache);
729 :
730 0 : if (!srv) {
731 0 : return NULL;
732 : }
733 0 : if (in_cache) {
734 0 : return srv;
735 : }
736 :
737 : /* Now add it to the cache (internal or external) */
738 : /* Let the cache function set errno if it wants to */
739 0 : errno = 0;
740 0 : if (smbc_getFunctionAddCachedServer(context)(context, srv,
741 : server, share,
742 : *pp_workgroup,
743 : *pp_username)) {
744 0 : int saved_errno = errno;
745 0 : DEBUG(3, (" Failed to add server to cache\n"));
746 0 : errno = saved_errno;
747 0 : if (errno == 0) {
748 0 : errno = ENOMEM;
749 : }
750 0 : SAFE_FREE(srv);
751 0 : return NULL;
752 : }
753 :
754 0 : DEBUG(2, ("Server connect ok: //%s/%s: %p\n",
755 : server, share, srv));
756 :
757 0 : DLIST_ADD(context->internal->servers, srv);
758 0 : return srv;
759 : }
760 :
761 : /*
762 : * Connect to a server for getting/setting attributes, possibly on an existing
763 : * connection. This works similarly to SMBC_server().
764 : */
765 : SMBCSRV *
766 0 : SMBC_attr_server(TALLOC_CTX *ctx,
767 : SMBCCTX *context,
768 : const char *server,
769 : uint16_t port,
770 : const char *share,
771 : char **pp_workgroup,
772 : char **pp_username,
773 : char **pp_password)
774 : {
775 : int flags;
776 0 : struct cli_state *ipc_cli = NULL;
777 0 : struct rpc_pipe_client *pipe_hnd = NULL;
778 : NTSTATUS nt_status;
779 0 : SMBCSRV *srv=NULL;
780 0 : SMBCSRV *ipc_srv=NULL;
781 :
782 : /*
783 : * Use srv->cli->desthost and srv->cli->share instead of
784 : * server and share below to connect to the actual share,
785 : * i.e., a normal share or a referred share from
786 : * 'msdfs proxy' share.
787 : */
788 0 : srv = SMBC_server(ctx, context, true, server, port, share,
789 : pp_workgroup, pp_username, pp_password);
790 0 : if (!srv) {
791 0 : return NULL;
792 : }
793 0 : server = smbXcli_conn_remote_name(srv->cli->conn);
794 0 : share = srv->cli->share;
795 :
796 : /*
797 : * See if we've already created this special connection. Reference
798 : * our "special" share name '*IPC$', which is an impossible real share
799 : * name due to the leading asterisk.
800 : */
801 0 : ipc_srv = SMBC_find_server(ctx, context, server, "*IPC$",
802 : pp_workgroup, pp_username, pp_password);
803 0 : if (!ipc_srv) {
804 0 : struct cli_credentials *creds = NULL;
805 :
806 : /* We didn't find a cached connection. Get the password */
807 0 : if (!*pp_password || (*pp_password)[0] == '\0') {
808 : /* ... then retrieve it now. */
809 0 : SMBC_call_auth_fn(ctx, context, server, share,
810 : pp_workgroup,
811 : pp_username,
812 : pp_password);
813 0 : if (!*pp_workgroup || !*pp_username || !*pp_password) {
814 0 : errno = ENOMEM;
815 0 : return NULL;
816 : }
817 : }
818 :
819 0 : flags = 0;
820 :
821 0 : creds = SMBC_auth_credentials(NULL,
822 : context,
823 : *pp_workgroup,
824 : *pp_username,
825 : *pp_password);
826 0 : if (creds == NULL) {
827 0 : errno = ENOMEM;
828 0 : return NULL;
829 : }
830 :
831 0 : nt_status = cli_full_connection_creds(&ipc_cli,
832 : lp_netbios_name(), server,
833 : NULL, 0, "IPC$", "?????",
834 : creds,
835 : flags);
836 0 : if (! NT_STATUS_IS_OK(nt_status)) {
837 0 : TALLOC_FREE(creds);
838 0 : DEBUG(1,("cli_full_connection failed! (%s)\n",
839 : nt_errstr(nt_status)));
840 0 : errno = ENOTSUP;
841 0 : return NULL;
842 : }
843 0 : talloc_steal(ipc_cli, creds);
844 :
845 0 : ipc_srv = SMB_MALLOC_P(SMBCSRV);
846 0 : if (!ipc_srv) {
847 0 : errno = ENOMEM;
848 0 : cli_shutdown(ipc_cli);
849 0 : return NULL;
850 : }
851 :
852 0 : ZERO_STRUCTP(ipc_srv);
853 0 : DLIST_ADD(ipc_srv->cli, ipc_cli);
854 :
855 0 : nt_status = cli_rpc_pipe_open_noauth(
856 : ipc_srv->cli, &ndr_table_lsarpc, &pipe_hnd);
857 0 : if (!NT_STATUS_IS_OK(nt_status)) {
858 0 : DEBUG(1, ("cli_nt_session_open fail!\n"));
859 0 : errno = ENOTSUP;
860 0 : cli_shutdown(ipc_srv->cli);
861 0 : free(ipc_srv);
862 0 : return NULL;
863 : }
864 :
865 : /*
866 : * Some systems don't support
867 : * SEC_FLAG_MAXIMUM_ALLOWED, but NT sends 0x2000000
868 : * so we might as well do it too.
869 : */
870 :
871 0 : nt_status = rpccli_lsa_open_policy(
872 : pipe_hnd,
873 : talloc_tos(),
874 : True,
875 : GENERIC_EXECUTE_ACCESS,
876 : &ipc_srv->pol);
877 :
878 0 : if (!NT_STATUS_IS_OK(nt_status)) {
879 0 : cli_shutdown(ipc_srv->cli);
880 0 : free(ipc_srv);
881 0 : errno = cli_status_to_errno(nt_status);
882 0 : return NULL;
883 : }
884 :
885 : /* now add it to the cache (internal or external) */
886 :
887 0 : errno = 0; /* let cache function set errno if it likes */
888 0 : if (smbc_getFunctionAddCachedServer(context)(context, ipc_srv,
889 : server,
890 : "*IPC$",
891 : *pp_workgroup,
892 : *pp_username)) {
893 0 : DEBUG(3, (" Failed to add server to cache\n"));
894 0 : if (errno == 0) {
895 0 : errno = ENOMEM;
896 : }
897 0 : cli_shutdown(ipc_srv->cli);
898 0 : free(ipc_srv);
899 0 : return NULL;
900 : }
901 :
902 0 : DLIST_ADD(context->internal->servers, ipc_srv);
903 : }
904 :
905 0 : return ipc_srv;
906 : }
|
