99aa74c67b9a525eaecac5f5e7b5d87a26d5f417
[kai/samba.git] / source3 / libsmb / libsmb_server.c
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 SMBC_check_server(SMBCCTX * context,
46                   SMBCSRV * server) 
47 {
48         if (!cli_state_is_connected(server->cli)) {
49                 return 1;
50         }
51
52         return 0;
53 }
54
55 /* 
56  * Remove a server from the cached server list it's unused.
57  * On success, 0 is returned. 1 is returned if the server could not be removed.
58  * 
59  * Also useable outside libsmbclient
60  */
61 int
62 SMBC_remove_unused_server(SMBCCTX * context,
63                           SMBCSRV * srv)
64 {
65         SMBCFILE * file;
66
67         /* are we being fooled ? */
68         if (!context || !context->internal->initialized || !srv) {
69                 return 1;
70         }
71
72         /* Check all open files/directories for a relation with this server */
73         for (file = context->internal->files; file; file = file->next) {
74                 if (file->srv == srv) {
75                         /* Still used */
76                         DEBUG(3, ("smbc_remove_usused_server: "
77                                   "%p still used by %p.\n",
78                                   srv, file));
79                         return 1;
80                 }
81         }
82
83         DLIST_REMOVE(context->internal->servers, srv);
84
85         cli_shutdown(srv->cli);
86         srv->cli = NULL;
87
88         DEBUG(3, ("smbc_remove_usused_server: %p removed.\n", srv));
89
90         smbc_getFunctionRemoveCachedServer(context)(context, srv);
91
92         SAFE_FREE(srv);
93         return 0;
94 }
95
96 /****************************************************************
97  * Call the auth_fn with fixed size (fstring) buffers.
98  ***************************************************************/
99 static void
100 SMBC_call_auth_fn(TALLOC_CTX *ctx,
101                   SMBCCTX *context,
102                   const char *server,
103                   const char *share,
104                   char **pp_workgroup,
105                   char **pp_username,
106                   char **pp_password)
107 {
108         fstring workgroup;
109         fstring username;
110         fstring password;
111         smbc_get_auth_data_with_context_fn auth_with_context_fn;
112
113         strlcpy(workgroup, *pp_workgroup, sizeof(workgroup));
114         strlcpy(username, *pp_username, sizeof(username));
115         strlcpy(password, *pp_password, sizeof(password));
116
117         /* See if there's an authentication with context function provided */
118         auth_with_context_fn = smbc_getFunctionAuthDataWithContext(context);
119         if (auth_with_context_fn)
120         {
121             (* auth_with_context_fn)(context,
122                                      server, share,
123                                      workgroup, sizeof(workgroup),
124                                      username, sizeof(username),
125                                      password, sizeof(password));
126         }
127         else
128         {
129             smbc_getFunctionAuthData(context)(server, share,
130                                               workgroup, sizeof(workgroup),
131                                               username, sizeof(username),
132                                               password, sizeof(password));
133         }
134
135         TALLOC_FREE(*pp_workgroup);
136         TALLOC_FREE(*pp_username);
137         TALLOC_FREE(*pp_password);
138
139         *pp_workgroup = talloc_strdup(ctx, workgroup);
140         *pp_username = talloc_strdup(ctx, username);
141         *pp_password = talloc_strdup(ctx, password);
142 }
143
144
145 void
146 SMBC_get_auth_data(const char *server, const char *share,
147                    char *workgroup_buf, int workgroup_buf_len,
148                    char *username_buf, int username_buf_len,
149                    char *password_buf, int password_buf_len)
150 {
151         /* Default function just uses provided data.  Nothing to do. */
152 }
153
154
155
156 SMBCSRV *
157 SMBC_find_server(TALLOC_CTX *ctx,
158                  SMBCCTX *context,
159                  const char *server,
160                  const char *share,
161                  char **pp_workgroup,
162                  char **pp_username,
163                  char **pp_password)
164 {
165         SMBCSRV *srv;
166         int auth_called = 0;
167
168         if (!pp_workgroup || !pp_username || !pp_password) {
169                 return NULL;
170         }
171
172 check_server_cache:
173
174         srv = smbc_getFunctionGetCachedServer(context)(context,
175                                                        server, share,
176                                                        *pp_workgroup,
177                                                        *pp_username);
178
179         if (!auth_called && !srv && (!*pp_username || !(*pp_username)[0] ||
180                                      !*pp_password || !(*pp_password)[0])) {
181                 SMBC_call_auth_fn(ctx, context, server, share,
182                                   pp_workgroup, pp_username, pp_password);
183
184                 /*
185                  * However, smbc_auth_fn may have picked up info relating to
186                  * an existing connection, so try for an existing connection
187                  * again ...
188                  */
189                 auth_called = 1;
190                 goto check_server_cache;
191
192         }
193
194         if (srv) {
195                 if (smbc_getFunctionCheckServer(context)(context, srv)) {
196                         /*
197                          * This server is no good anymore
198                          * Try to remove it and check for more possible
199                          * servers in the cache
200                          */
201                         if (smbc_getFunctionRemoveUnusedServer(context)(context,
202                                                                         srv)) { 
203                                 /*
204                                  * We could not remove the server completely,
205                                  * remove it from the cache so we will not get
206                                  * it again. It will be removed when the last
207                                  * file/dir is closed.
208                                  */
209                                 smbc_getFunctionRemoveCachedServer(context)(context,
210                                                                             srv);
211                         }
212
213                         /*
214                          * Maybe there are more cached connections to this
215                          * server
216                          */
217                         goto check_server_cache;
218                 }
219
220                 return srv;
221         }
222
223         return NULL;
224 }
225
226 /*
227  * Connect to a server, possibly on an existing connection
228  *
229  * Here, what we want to do is: If the server and username
230  * match an existing connection, reuse that, otherwise, establish a
231  * new connection.
232  *
233  * If we have to create a new connection, call the auth_fn to get the
234  * info we need, unless the username and password were passed in.
235  */
236
237 static SMBCSRV *
238 SMBC_server_internal(TALLOC_CTX *ctx,
239             SMBCCTX *context,
240             bool connect_if_not_found,
241             const char *server,
242             const char *share,
243             char **pp_workgroup,
244             char **pp_username,
245             char **pp_password,
246             bool *in_cache)
247 {
248         SMBCSRV *srv=NULL;
249         char *workgroup = NULL;
250         struct cli_state *c = NULL;
251         const char *server_n = server;
252         int is_ipc = (share != NULL && strcmp(share, "IPC$") == 0);
253         uint32 fs_attrs = 0;
254         const char *username_used;
255         NTSTATUS status;
256         char *newserver, *newshare;
257         int flags = 0;
258
259         ZERO_STRUCT(c);
260         *in_cache = false;
261
262         if (server[0] == 0) {
263                 errno = EPERM;
264                 return NULL;
265         }
266
267         /* Look for a cached connection */
268         srv = SMBC_find_server(ctx, context, server, share,
269                                pp_workgroup, pp_username, pp_password);
270
271         /*
272          * If we found a connection and we're only allowed one share per
273          * server...
274          */
275         if (srv &&
276             *share != '\0' &&
277             smbc_getOptionOneSharePerServer(context)) {
278
279                 /*
280                  * ... then if there's no current connection to the share,
281                  * connect to it.  SMBC_find_server(), or rather the function
282                  * pointed to by context->get_cached_srv_fn which
283                  * was called by SMBC_find_server(), will have issued a tree
284                  * disconnect if the requested share is not the same as the
285                  * one that was already connected.
286                  */
287
288                 /*
289                  * Use srv->cli->desthost and srv->cli->share instead of
290                  * server and share below to connect to the actual share,
291                  * i.e., a normal share or a referred share from
292                  * 'msdfs proxy' share.
293                  */
294                 if (!cli_state_has_tcon(srv->cli)) {
295                         /* Ensure we have accurate auth info */
296                         SMBC_call_auth_fn(ctx, context,
297                                           smbXcli_conn_remote_name(srv->cli->conn),
298                                           srv->cli->share,
299                                           pp_workgroup,
300                                           pp_username,
301                                           pp_password);
302
303                         if (!*pp_workgroup || !*pp_username || !*pp_password) {
304                                 errno = ENOMEM;
305                                 cli_shutdown(srv->cli);
306                                 srv->cli = NULL;
307                                 smbc_getFunctionRemoveCachedServer(context)(context,
308                                                                             srv);
309                                 return NULL;
310                         }
311
312                         /*
313                          * We don't need to renegotiate encryption
314                          * here as the encryption context is not per
315                          * tid.
316                          */
317
318                         status = cli_tree_connect(srv->cli,
319                                                   srv->cli->share,
320                                                   "?????",
321                                                   *pp_password,
322                                                   strlen(*pp_password)+1);
323                         if (!NT_STATUS_IS_OK(status)) {
324                                 errno = map_errno_from_nt_status(status);
325                                 cli_shutdown(srv->cli);
326                                 srv->cli = NULL;
327                                 smbc_getFunctionRemoveCachedServer(context)(context,
328                                                                             srv);
329                                 srv = NULL;
330                         }
331
332                         /* Determine if this share supports case sensitivity */
333                         if (is_ipc) {
334                                 DEBUG(4,
335                                       ("IPC$ so ignore case sensitivity\n"));
336                                 status = NT_STATUS_OK;
337                         } else {
338                                 status = cli_get_fs_attr_info(c, &fs_attrs);
339                         }
340
341                         if (!NT_STATUS_IS_OK(status)) {
342                                 DEBUG(4, ("Could not retrieve "
343                                           "case sensitivity flag: %s.\n",
344                                           nt_errstr(status)));
345
346                                 /*
347                                  * We can't determine the case sensitivity of
348                                  * the share. We have no choice but to use the
349                                  * user-specified case sensitivity setting.
350                                  */
351                                 if (smbc_getOptionCaseSensitive(context)) {
352                                         cli_set_case_sensitive(c, True);
353                                 } else {
354                                         cli_set_case_sensitive(c, False);
355                                 }
356                         } else if (!is_ipc) {
357                                 DEBUG(4,
358                                       ("Case sensitive: %s\n",
359                                        (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
360                                         ? "True"
361                                         : "False")));
362                                 cli_set_case_sensitive(
363                                         c,
364                                         (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
365                                          ? True
366                                          : False));
367                         }
368
369                         /*
370                          * Regenerate the dev value since it's based on both
371                          * server and share
372                          */
373                         if (srv) {
374                                 const char *remote_name =
375                                         smbXcli_conn_remote_name(srv->cli->conn);
376
377                                 srv->dev = (dev_t)(str_checksum(remote_name) ^
378                                                    str_checksum(srv->cli->share));
379                         }
380                 }
381         }
382
383         /* If we have a connection... */
384         if (srv) {
385
386                 /* ... then we're done here.  Give 'em what they came for. */
387                 *in_cache = true;
388                 goto done;
389         }
390
391         /* If we're not asked to connect when a connection doesn't exist... */
392         if (! connect_if_not_found) {
393                 /* ... then we're done here. */
394                 return NULL;
395         }
396
397         if (!*pp_workgroup || !*pp_username || !*pp_password) {
398                 errno = ENOMEM;
399                 return NULL;
400         }
401
402         DEBUG(4,("SMBC_server: server_n=[%s] server=[%s]\n", server_n, server));
403
404         DEBUG(4,(" -> server_n=[%s] server=[%s]\n", server_n, server));
405
406         status = NT_STATUS_UNSUCCESSFUL;
407
408         if (smbc_getOptionUseKerberos(context)) {
409                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
410         }
411
412         if (smbc_getOptionFallbackAfterKerberos(context)) {
413                 flags |= CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS;
414         }
415
416         if (smbc_getOptionUseCCache(context)) {
417                 flags |= CLI_FULL_CONNECTION_USE_CCACHE;
418         }
419
420         if (smbc_getOptionUseNTHash(context)) {
421                 flags |= CLI_FULL_CONNECTION_USE_NT_HASH;
422         }
423
424         if (share == NULL || *share == '\0' || is_ipc) {
425                 /*
426                  * Try 139 first for IPC$
427                  */
428                 status = cli_connect_nb(server_n, NULL, NBT_SMB_PORT, 0x20,
429                                         smbc_getNetbiosName(context),
430                                         SMB_SIGNING_DEFAULT, flags, &c);
431         }
432
433         if (!NT_STATUS_IS_OK(status)) {
434                 /*
435                  * No IPC$ or 139 did not work
436                  */
437                 status = cli_connect_nb(server_n, NULL, 0, 0x20,
438                                         smbc_getNetbiosName(context),
439                                         SMB_SIGNING_DEFAULT, flags, &c);
440         }
441
442         if (!NT_STATUS_IS_OK(status)) {
443                 errno = map_errno_from_nt_status(status);
444                 return NULL;
445         }
446
447         cli_set_timeout(c, smbc_getTimeout(context));
448
449         status = smbXcli_negprot(c->conn, c->timeout, PROTOCOL_CORE,
450                                  PROTOCOL_NT1);
451
452         if (!NT_STATUS_IS_OK(status)) {
453                 cli_shutdown(c);
454                 errno = ETIMEDOUT;
455                 return NULL;
456         }
457
458         username_used = *pp_username;
459
460         if (!NT_STATUS_IS_OK(cli_session_setup(c, username_used,
461                                                *pp_password,
462                                                strlen(*pp_password),
463                                                *pp_password,
464                                                strlen(*pp_password),
465                                                *pp_workgroup))) {
466
467                 /* Failed.  Try an anonymous login, if allowed by flags. */
468                 username_used = "";
469
470                 if (smbc_getOptionNoAutoAnonymousLogin(context) ||
471                     !NT_STATUS_IS_OK(cli_session_setup(c, username_used,
472                                                        *pp_password, 1,
473                                                        *pp_password, 0,
474                                                        *pp_workgroup))) {
475
476                         cli_shutdown(c);
477                         errno = EPERM;
478                         return NULL;
479                 }
480         }
481
482         status = cli_init_creds(c, username_used,
483                                 *pp_workgroup, *pp_password);
484         if (!NT_STATUS_IS_OK(status)) {
485                 errno = map_errno_from_nt_status(status);
486                 cli_shutdown(c);
487                 return NULL;
488         }
489
490         DEBUG(4,(" session setup ok\n"));
491
492         /* here's the fun part....to support 'msdfs proxy' shares
493            (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL
494            here before trying to connect to the original share.
495            cli_check_msdfs_proxy() will fail if it is a normal share. */
496
497         if ((smb1cli_conn_capabilities(c->conn) & CAP_DFS) &&
498                         cli_check_msdfs_proxy(ctx, c, share,
499                                 &newserver, &newshare,
500                                 /* FIXME: cli_check_msdfs_proxy() does
501                                    not support smbc_smb_encrypt_level type */
502                                 context->internal->smb_encryption_level ?
503                                         true : false,
504                                 *pp_username,
505                                 *pp_password,
506                                 *pp_workgroup)) {
507                 cli_shutdown(c);
508                 srv = SMBC_server_internal(ctx, context, connect_if_not_found,
509                                 newserver, newshare, pp_workgroup,
510                                 pp_username, pp_password, in_cache);
511                 TALLOC_FREE(newserver);
512                 TALLOC_FREE(newshare);
513                 return srv;
514         }
515
516         /* must be a normal share */
517
518         status = cli_tree_connect(c, share, "?????", *pp_password,
519                                   strlen(*pp_password)+1);
520         if (!NT_STATUS_IS_OK(status)) {
521                 errno = map_errno_from_nt_status(status);
522                 cli_shutdown(c);
523                 return NULL;
524         }
525
526         DEBUG(4,(" tconx ok\n"));
527
528         /* Determine if this share supports case sensitivity */
529         if (is_ipc) {
530                 DEBUG(4, ("IPC$ so ignore case sensitivity\n"));
531                 status = NT_STATUS_OK;
532         } else {
533                 status = cli_get_fs_attr_info(c, &fs_attrs);
534         }
535
536         if (!NT_STATUS_IS_OK(status)) {
537                 DEBUG(4, ("Could not retrieve case sensitivity flag: %s.\n",
538                           nt_errstr(status)));
539
540                 /*
541                  * We can't determine the case sensitivity of the share. We
542                  * have no choice but to use the user-specified case
543                  * sensitivity setting.
544                  */
545                 if (smbc_getOptionCaseSensitive(context)) {
546                         cli_set_case_sensitive(c, True);
547                 } else {
548                         cli_set_case_sensitive(c, False);
549                 }
550         } else if (!is_ipc) {
551                 DEBUG(4, ("Case sensitive: %s\n",
552                           (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
553                            ? "True"
554                            : "False")));
555                 cli_set_case_sensitive(c,
556                                        (fs_attrs & FILE_CASE_SENSITIVE_SEARCH
557                                         ? True
558                                         : False));
559         }
560
561         if (context->internal->smb_encryption_level) {
562                 /* Attempt UNIX smb encryption. */
563                 if (!NT_STATUS_IS_OK(cli_force_encryption(c,
564                                                           username_used,
565                                                           *pp_password,
566                                                           *pp_workgroup))) {
567
568                         /*
569                          * context->smb_encryption_level == 1
570                          * means don't fail if encryption can't be negotiated,
571                          * == 2 means fail if encryption can't be negotiated.
572                          */
573
574                         DEBUG(4,(" SMB encrypt failed\n"));
575
576                         if (context->internal->smb_encryption_level == 2) {
577                                 cli_shutdown(c);
578                                 errno = EPERM;
579                                 return NULL;
580                         }
581                 }
582                 DEBUG(4,(" SMB encrypt ok\n"));
583         }
584
585         /*
586          * Ok, we have got a nice connection
587          * Let's allocate a server structure.
588          */
589
590         srv = SMB_MALLOC_P(SMBCSRV);
591         if (!srv) {
592                 cli_shutdown(c);
593                 errno = ENOMEM;
594                 return NULL;
595         }
596
597         ZERO_STRUCTP(srv);
598         srv->cli = c;
599         srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
600         srv->no_pathinfo = False;
601         srv->no_pathinfo2 = False;
602         srv->no_nt_session = False;
603
604 done:
605         if (!pp_workgroup || !*pp_workgroup || !**pp_workgroup) {
606                 workgroup = talloc_strdup(ctx, smbc_getWorkgroup(context));
607         } else {
608                 workgroup = *pp_workgroup;
609         }
610         if(!workgroup) {
611                 if (c != NULL) {
612                         cli_shutdown(c);
613                 }
614                 SAFE_FREE(srv);
615                 return NULL;
616         }
617
618         /* set the credentials to make DFS work */
619         smbc_set_credentials_with_fallback(context,
620                                            workgroup,
621                                            *pp_username,
622                                            *pp_password);
623
624         return srv;
625 }
626
627 SMBCSRV *
628 SMBC_server(TALLOC_CTX *ctx,
629                 SMBCCTX *context,
630                 bool connect_if_not_found,
631                 const char *server,
632                 const char *share,
633                 char **pp_workgroup,
634                 char **pp_username,
635                 char **pp_password)
636 {
637         SMBCSRV *srv=NULL;
638         bool in_cache = false;
639
640         srv = SMBC_server_internal(ctx, context, connect_if_not_found,
641                         server, share, pp_workgroup,
642                         pp_username, pp_password, &in_cache);
643
644         if (!srv) {
645                 return NULL;
646         }
647         if (in_cache) {
648                 return srv;
649         }
650
651         /* Now add it to the cache (internal or external)  */
652         /* Let the cache function set errno if it wants to */
653         errno = 0;
654         if (smbc_getFunctionAddCachedServer(context)(context, srv,
655                                                 server, share,
656                                                 *pp_workgroup,
657                                                 *pp_username)) {
658                 int saved_errno = errno;
659                 DEBUG(3, (" Failed to add server to cache\n"));
660                 errno = saved_errno;
661                 if (errno == 0) {
662                         errno = ENOMEM;
663                 }
664                 SAFE_FREE(srv);
665                 return NULL;
666         }
667
668         DEBUG(2, ("Server connect ok: //%s/%s: %p\n",
669                 server, share, srv));
670
671         DLIST_ADD(context->internal->servers, srv);
672         return srv;
673 }
674
675 /*
676  * Connect to a server for getting/setting attributes, possibly on an existing
677  * connection.  This works similarly to SMBC_server().
678  */
679 SMBCSRV *
680 SMBC_attr_server(TALLOC_CTX *ctx,
681                  SMBCCTX *context,
682                  const char *server,
683                  const char *share,
684                  char **pp_workgroup,
685                  char **pp_username,
686                  char **pp_password)
687 {
688         int flags;
689         struct cli_state *ipc_cli = NULL;
690         struct rpc_pipe_client *pipe_hnd = NULL;
691         NTSTATUS nt_status;
692         SMBCSRV *srv=NULL;
693         SMBCSRV *ipc_srv=NULL;
694
695         /*
696          * Use srv->cli->desthost and srv->cli->share instead of
697          * server and share below to connect to the actual share,
698          * i.e., a normal share or a referred share from
699          * 'msdfs proxy' share.
700          */
701         srv = SMBC_server(ctx, context, true, server, share,
702                         pp_workgroup, pp_username, pp_password);
703         if (!srv) {
704                 return NULL;
705         }
706         server = smbXcli_conn_remote_name(srv->cli->conn);
707         share = srv->cli->share;
708
709         /*
710          * See if we've already created this special connection.  Reference
711          * our "special" share name '*IPC$', which is an impossible real share
712          * name due to the leading asterisk.
713          */
714         ipc_srv = SMBC_find_server(ctx, context, server, "*IPC$",
715                                    pp_workgroup, pp_username, pp_password);
716         if (!ipc_srv) {
717
718                 /* We didn't find a cached connection.  Get the password */
719                 if (!*pp_password || (*pp_password)[0] == '\0') {
720                         /* ... then retrieve it now. */
721                         SMBC_call_auth_fn(ctx, context, server, share,
722                                           pp_workgroup,
723                                           pp_username,
724                                           pp_password);
725                         if (!*pp_workgroup || !*pp_username || !*pp_password) {
726                                 errno = ENOMEM;
727                                 return NULL;
728                         }
729                 }
730
731                 flags = 0;
732                 if (smbc_getOptionUseKerberos(context)) {
733                         flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
734                 }
735                 if (smbc_getOptionUseCCache(context)) {
736                         flags |= CLI_FULL_CONNECTION_USE_CCACHE;
737                 }
738
739                 nt_status = cli_full_connection(&ipc_cli,
740                                                 lp_netbios_name(), server,
741                                                 NULL, 0, "IPC$", "?????",
742                                                 *pp_username,
743                                                 *pp_workgroup,
744                                                 *pp_password,
745                                                 flags,
746                                                 SMB_SIGNING_DEFAULT);
747                 if (! NT_STATUS_IS_OK(nt_status)) {
748                         DEBUG(1,("cli_full_connection failed! (%s)\n",
749                                  nt_errstr(nt_status)));
750                         errno = ENOTSUP;
751                         return NULL;
752                 }
753
754                 if (context->internal->smb_encryption_level) {
755                         /* Attempt UNIX smb encryption. */
756                         if (!NT_STATUS_IS_OK(cli_force_encryption(ipc_cli,
757                                                                   *pp_username,
758                                                                   *pp_password,
759                                                                   *pp_workgroup))) {
760
761                                 /*
762                                  * context->smb_encryption_level ==
763                                  * 1 means don't fail if encryption can't be
764                                  * negotiated, == 2 means fail if encryption
765                                  * can't be negotiated.
766                                  */
767
768                                 DEBUG(4,(" SMB encrypt failed on IPC$\n"));
769
770                                 if (context->internal->smb_encryption_level == 2) {
771                                         cli_shutdown(ipc_cli);
772                                         errno = EPERM;
773                                         return NULL;
774                                 }
775                         }
776                         DEBUG(4,(" SMB encrypt ok on IPC$\n"));
777                 }
778
779                 ipc_srv = SMB_MALLOC_P(SMBCSRV);
780                 if (!ipc_srv) {
781                         errno = ENOMEM;
782                         cli_shutdown(ipc_cli);
783                         return NULL;
784                 }
785
786                 ZERO_STRUCTP(ipc_srv);
787                 ipc_srv->cli = ipc_cli;
788
789                 nt_status = cli_rpc_pipe_open_noauth(
790                         ipc_srv->cli, &ndr_table_lsarpc.syntax_id, &pipe_hnd);
791                 if (!NT_STATUS_IS_OK(nt_status)) {
792                         DEBUG(1, ("cli_nt_session_open fail!\n"));
793                         errno = ENOTSUP;
794                         cli_shutdown(ipc_srv->cli);
795                         free(ipc_srv);
796                         return NULL;
797                 }
798
799                 /*
800                  * Some systems don't support
801                  * SEC_FLAG_MAXIMUM_ALLOWED, but NT sends 0x2000000
802                  * so we might as well do it too.
803                  */
804
805                 nt_status = rpccli_lsa_open_policy(
806                         pipe_hnd,
807                         talloc_tos(),
808                         True,
809                         GENERIC_EXECUTE_ACCESS,
810                         &ipc_srv->pol);
811
812                 if (!NT_STATUS_IS_OK(nt_status)) {
813                         errno = SMBC_errno(context, ipc_srv->cli);
814                         cli_shutdown(ipc_srv->cli);
815                         return NULL;
816                 }
817
818                 /* now add it to the cache (internal or external) */
819
820                 errno = 0;      /* let cache function set errno if it likes */
821                 if (smbc_getFunctionAddCachedServer(context)(context, ipc_srv,
822                                                              server,
823                                                              "*IPC$",
824                                                              *pp_workgroup,
825                                                              *pp_username)) {
826                         DEBUG(3, (" Failed to add server to cache\n"));
827                         if (errno == 0) {
828                                 errno = ENOMEM;
829                         }
830                         cli_shutdown(ipc_srv->cli);
831                         free(ipc_srv);
832                         return NULL;
833                 }
834
835                 DLIST_ADD(context->internal->servers, ipc_srv);
836         }
837
838         return ipc_srv;
839 }