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                              lp_client_max_protocol(),
 115                              0, 0x20, &cli_ipc);
 116         if (NT_STATUS_IS_OK(status)) {
 117                 cli_set_username(cli_ipc, ctx->username);
 118         } else {
 119                 cli_ipc = NULL;
 120         }
 121         TALLOC_FREE(auth_info);
 122
 123         if (!cli_ipc) {
 124                 libnetapi_set_error_string(ctx,
 125                         "Failed to connect to IPC$ share on %s", server_name);
 126                 return WERR_CAN_NOT_COMPLETE;
 127         }
 128
 129         p = talloc_zero(ctx, struct client_ipc_connection);
 130         if (p == NULL) {
 131                 return WERR_NOMEM;
 132         }
 133
 134         p->cli = cli_ipc;
 135         DLIST_ADD(priv_ctx->ipc_connections, p);
 136
 137         *pp = p;
 138
 139         return WERR_OK;
 140 }
 141
 142 /********************************************************************
 143 ********************************************************************/
 144
 145 WERROR libnetapi_shutdown_cm(struct libnetapi_ctx *ctx)
 146 {
 147         struct libnetapi_private_ctx *priv_ctx =
 148                 (struct libnetapi_private_ctx *)ctx->private_data;
 149         struct client_ipc_connection *p;
 150
 151         for (p = priv_ctx->ipc_connections; p; p = p->next) {
 152                 cli_shutdown(p->cli);
 153         }
 154
 155         return WERR_OK;
 156 }
 157
 158 /********************************************************************
 159 ********************************************************************/
 160
 161 static NTSTATUS pipe_cm_find(struct client_ipc_connection *ipc,
 162                              const struct ndr_interface_table *table,
 163                              struct rpc_pipe_client **presult)
 164 {
 165         struct client_pipe_connection *p;
 166
 167         for (p = ipc->pipe_connections; p; p = p->next) {
 168                 const char *ipc_remote_name;
 169
 170                 if (!rpccli_is_connected(p->pipe)) {
 171                         return NT_STATUS_PIPE_EMPTY;
 172                 }
 173
 174                 ipc_remote_name = smbXcli_conn_remote_name(ipc->cli->conn);
 175
 176                 if (strequal(ipc_remote_name, p->pipe->desthost)
 177                     && ndr_syntax_id_equal(&p->pipe->abstract_syntax,
 178                                            &table->syntax_id)) {
 179                         *presult = p->pipe;
 180                         return NT_STATUS_OK;
 181                 }
 182         }
 183
 184         return NT_STATUS_PIPE_NOT_AVAILABLE;
 185 }
 186
 187 /********************************************************************
 188 ********************************************************************/
 189
 190 static NTSTATUS pipe_cm_connect(TALLOC_CTX *mem_ctx,
 191                                 struct client_ipc_connection *ipc,
 192                                 const struct ndr_interface_table *table,
 193                                 struct rpc_pipe_client **presult)
 194 {
 195         struct client_pipe_connection *p;
 196         NTSTATUS status;
 197
 198         p = talloc_zero_array(mem_ctx, struct client_pipe_connection, 1);
 199         if (!p) {
 200                 return NT_STATUS_NO_MEMORY;
 201         }
 202
 203         status = cli_rpc_pipe_open_noauth(ipc->cli, table, &p->pipe);
 204         if (!NT_STATUS_IS_OK(status)) {
 205                 TALLOC_FREE(p);
 206                 return status;
 207         }
 208
 209         DLIST_ADD(ipc->pipe_connections, p);
 210
 211         *presult = p->pipe;
 212         return NT_STATUS_OK;
 213 }
 214
 215 /********************************************************************
 216 ********************************************************************/
 217
 218 static NTSTATUS pipe_cm_open(TALLOC_CTX *ctx,
 219                              struct client_ipc_connection *ipc,
 220                              const struct ndr_interface_table *table,
 221                              struct rpc_pipe_client **presult)
 222 {
 223         if (NT_STATUS_IS_OK(pipe_cm_find(ipc, table, presult))) {
 224                 return NT_STATUS_OK;
 225         }
 226
 227         return pipe_cm_connect(ctx, ipc, table, presult);
 228 }
 229
 230 /********************************************************************
 231 ********************************************************************/
 232
 233 WERROR libnetapi_open_pipe(struct libnetapi_ctx *ctx,
 234                            const char *server_name,
 235                            const struct ndr_interface_table *table,
 236                            struct rpc_pipe_client **presult)
 237 {
 238         struct rpc_pipe_client *result = NULL;
 239         NTSTATUS status;
 240         WERROR werr;
 241         struct client_ipc_connection *ipc = NULL;
 242
 243         if (!presult) {
 244                 return WERR_INVALID_PARAM;
 245         }
 246
 247         werr = libnetapi_open_ipc_connection(ctx, server_name, &ipc);
 248         if (!W_ERROR_IS_OK(werr)) {
 249                 return werr;
 250         }
 251
 252         status = pipe_cm_open(ctx, ipc, table, &result);
 253         if (!NT_STATUS_IS_OK(status)) {
 254                 libnetapi_set_error_string(ctx, "failed to open PIPE %s: %s",
 255                         table->name,
 256                         get_friendly_nt_error_msg(status));
 257                 return WERR_DEST_NOT_FOUND;
 258         }
 259
 260         *presult = result;
 261
 262         return WERR_OK;
 263 }
 264
 265 /********************************************************************
 266 ********************************************************************/
 267
 268 WERROR libnetapi_get_binding_handle(struct libnetapi_ctx *ctx,
 269                                     const char *server_name,
 270                                     const struct ndr_interface_table *table,
 271                                     struct dcerpc_binding_handle **binding_handle)
 272 {
 273         struct rpc_pipe_client *pipe_cli;
 274         WERROR result;
 275
 276         *binding_handle = NULL;
 277
 278         result = libnetapi_open_pipe(ctx, server_name, table, &pipe_cli);
 279         if (!W_ERROR_IS_OK(result)) {
 280                 return result;
 281         }
 282
 283         *binding_handle = pipe_cli->binding_handle;
 284
 285         return WERR_OK;
 286 }