s3:libsmb: get rid of cli_state_remote_name
[samba.git] / source3 / lib / netapi / cm.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  NetApi Support
4  *  Copyright (C) Guenther Deschner 2008
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include "includes.h"
21 #include "auth_info.h"
22
23 #include "lib/netapi/netapi.h"
24 #include "lib/netapi/netapi_private.h"
25 #include "libsmb/libsmb.h"
26 #include "rpc_client/cli_pipe.h"
27 #include "../libcli/smb/smbXcli_base.h"
28
29 /********************************************************************
30 ********************************************************************/
31
32 struct client_ipc_connection {
33         struct client_ipc_connection *prev, *next;
34         struct cli_state *cli;
35         struct client_pipe_connection *pipe_connections;
36 };
37
38 struct client_pipe_connection {
39         struct client_pipe_connection *prev, *next;
40         struct rpc_pipe_client *pipe;
41 };
42
43 /********************************************************************
44 ********************************************************************/
45
46 static struct client_ipc_connection *ipc_cm_find(
47         struct libnetapi_private_ctx *priv_ctx, const char *server_name)
48 {
49         struct client_ipc_connection *p;
50
51         for (p = priv_ctx->ipc_connections; p; p = p->next) {
52                 const char *remote_name = smbXcli_conn_remote_name(p->cli->conn);
53
54                 if (strequal(remote_name, server_name)) {
55                         return p;
56                 }
57         }
58
59         return NULL;
60 }
61
62 /********************************************************************
63 ********************************************************************/
64
65 static WERROR libnetapi_open_ipc_connection(struct libnetapi_ctx *ctx,
66                                             const char *server_name,
67                                             struct client_ipc_connection **pp)
68 {
69         struct libnetapi_private_ctx *priv_ctx;
70         struct user_auth_info *auth_info = NULL;
71         struct cli_state *cli_ipc = NULL;
72         struct client_ipc_connection *p;
73         NTSTATUS status;
74
75         if (!ctx || !pp || !server_name) {
76                 return WERR_INVALID_PARAM;
77         }
78
79         priv_ctx = (struct libnetapi_private_ctx *)ctx->private_data;
80
81         p = ipc_cm_find(priv_ctx, server_name);
82         if (p) {
83                 *pp = p;
84                 return WERR_OK;
85         }
86
87         auth_info = user_auth_info_init(ctx);
88         if (!auth_info) {
89                 return WERR_NOMEM;
90         }
91         auth_info->signing_state = SMB_SIGNING_DEFAULT;
92         set_cmdline_auth_info_use_kerberos(auth_info, ctx->use_kerberos);
93         set_cmdline_auth_info_username(auth_info, ctx->username);
94         if (ctx->password) {
95                 set_cmdline_auth_info_password(auth_info, ctx->password);
96         } else {
97                 set_cmdline_auth_info_getpass(auth_info);
98         }
99
100         if (ctx->username && ctx->username[0] &&
101             ctx->password && ctx->password[0] &&
102             ctx->use_kerberos) {
103                 set_cmdline_auth_info_fallback_after_kerberos(auth_info, true);
104         }
105
106         if (ctx->use_ccache) {
107                 set_cmdline_auth_info_use_ccache(auth_info, true);
108         }
109
110         status = cli_cm_open(ctx, NULL,
111                              server_name, "IPC$",
112                              auth_info,
113                              false, false,
114                              PROTOCOL_NT1,
115                              0, 0x20, &cli_ipc);
116         if (NT_STATUS_IS_OK(status)) {
117                 cli_set_username(cli_ipc, ctx->username);
118                 cli_set_password(cli_ipc, ctx->password);
119                 cli_set_domain(cli_ipc, ctx->workgroup);
120         } else {
121                 cli_ipc = NULL;
122         }
123         TALLOC_FREE(auth_info);
124
125         if (!cli_ipc) {
126                 libnetapi_set_error_string(ctx,
127                         "Failed to connect to IPC$ share on %s", server_name);
128                 return WERR_CAN_NOT_COMPLETE;
129         }
130
131         p = talloc_zero(ctx, struct client_ipc_connection);
132         if (p == NULL) {
133                 return WERR_NOMEM;
134         }
135
136         p->cli = cli_ipc;
137         DLIST_ADD(priv_ctx->ipc_connections, p);
138
139         *pp = p;
140
141         return WERR_OK;
142 }
143
144 /********************************************************************
145 ********************************************************************/
146
147 WERROR libnetapi_shutdown_cm(struct libnetapi_ctx *ctx)
148 {
149         struct libnetapi_private_ctx *priv_ctx =
150                 (struct libnetapi_private_ctx *)ctx->private_data;
151         struct client_ipc_connection *p;
152
153         for (p = priv_ctx->ipc_connections; p; p = p->next) {
154                 cli_shutdown(p->cli);
155         }
156
157         return WERR_OK;
158 }
159
160 /********************************************************************
161 ********************************************************************/
162
163 static NTSTATUS pipe_cm_find(struct client_ipc_connection *ipc,
164                              const struct ndr_syntax_id *interface,
165                              struct rpc_pipe_client **presult)
166 {
167         struct client_pipe_connection *p;
168
169         for (p = ipc->pipe_connections; p; p = p->next) {
170                 const char *ipc_remote_name;
171
172                 if (!rpc_pipe_np_smb_conn(p->pipe)) {
173                         return NT_STATUS_PIPE_EMPTY;
174                 }
175
176                 ipc_remote_name = smbXcli_conn_remote_name(ipc->cli->conn);
177
178                 if (strequal(ipc_remote_name, p->pipe->desthost)
179                     && ndr_syntax_id_equal(&p->pipe->abstract_syntax,
180                                            interface)) {
181                         *presult = p->pipe;
182                         return NT_STATUS_OK;
183                 }
184         }
185
186         return NT_STATUS_PIPE_NOT_AVAILABLE;
187 }
188
189 /********************************************************************
190 ********************************************************************/
191
192 static NTSTATUS pipe_cm_connect(TALLOC_CTX *mem_ctx,
193                                 struct client_ipc_connection *ipc,
194                                 const struct ndr_syntax_id *interface,
195                                 struct rpc_pipe_client **presult)
196 {
197         struct client_pipe_connection *p;
198         NTSTATUS status;
199
200         p = talloc_zero_array(mem_ctx, struct client_pipe_connection, 1);
201         if (!p) {
202                 return NT_STATUS_NO_MEMORY;
203         }
204
205         status = cli_rpc_pipe_open_noauth(ipc->cli, interface, &p->pipe);
206         if (!NT_STATUS_IS_OK(status)) {
207                 TALLOC_FREE(p);
208                 return status;
209         }
210
211         DLIST_ADD(ipc->pipe_connections, p);
212
213         *presult = p->pipe;
214         return NT_STATUS_OK;
215 }
216
217 /********************************************************************
218 ********************************************************************/
219
220 static NTSTATUS pipe_cm_open(TALLOC_CTX *ctx,
221                              struct client_ipc_connection *ipc,
222                              const struct ndr_syntax_id *interface,
223                              struct rpc_pipe_client **presult)
224 {
225         if (NT_STATUS_IS_OK(pipe_cm_find(ipc, interface, presult))) {
226                 return NT_STATUS_OK;
227         }
228
229         return pipe_cm_connect(ctx, ipc, interface, presult);
230 }
231
232 /********************************************************************
233 ********************************************************************/
234
235 WERROR libnetapi_open_pipe(struct libnetapi_ctx *ctx,
236                            const char *server_name,
237                            const struct ndr_syntax_id *interface,
238                            struct rpc_pipe_client **presult)
239 {
240         struct rpc_pipe_client *result = NULL;
241         NTSTATUS status;
242         WERROR werr;
243         struct client_ipc_connection *ipc = NULL;
244
245         if (!presult) {
246                 return WERR_INVALID_PARAM;
247         }
248
249         werr = libnetapi_open_ipc_connection(ctx, server_name, &ipc);
250         if (!W_ERROR_IS_OK(werr)) {
251                 return werr;
252         }
253
254         status = pipe_cm_open(ctx, ipc, interface, &result);
255         if (!NT_STATUS_IS_OK(status)) {
256                 libnetapi_set_error_string(ctx, "failed to open PIPE %s: %s",
257                         get_pipe_name_from_syntax(talloc_tos(), interface),
258                         get_friendly_nt_error_msg(status));
259                 return WERR_DEST_NOT_FOUND;
260         }
261
262         *presult = result;
263
264         return WERR_OK;
265 }
266
267 /********************************************************************
268 ********************************************************************/
269
270 WERROR libnetapi_get_binding_handle(struct libnetapi_ctx *ctx,
271                                     const char *server_name,
272                                     const struct ndr_syntax_id *interface,
273                                     struct dcerpc_binding_handle **binding_handle)
274 {
275         struct rpc_pipe_client *pipe_cli;
276         WERROR result;
277
278         *binding_handle = NULL;
279
280         result = libnetapi_open_pipe(ctx, server_name, interface, &pipe_cli);
281         if (!W_ERROR_IS_OK(result)) {
282                 return result;
283         }
284
285         *binding_handle = pipe_cli->binding_handle;
286
287         return WERR_OK;
288 }