source/scripting/ejs/smbcalls_rpc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    provide interfaces to rpc calls from ejs scripts
   5
   6    Copyright (C) Andrew Tridgell 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "scripting/ejs/smbcalls.h"
  24 #include "lib/appweb/ejs/ejs.h"
  25 #include "librpc/gen_ndr/echo.h"
  26 #include "lib/cmdline/popt_common.h"
  27 #include "lib/messaging/irpc.h"
  28 #include "scripting/ejs/ejsrpc.h"
  29 #include "lib/util/dlinklist.h"
  30 #include "lib/events/events.h"
  31 #include "librpc/ndr/ndr_table.h"
  32 #include "auth/credentials/credentials.h"
  33 #include "librpc/rpc/dcerpc.h"
  34 #include "cluster/cluster.h"
  35
  36 /*
  37   state of a irpc 'connection'
  38 */
  39 struct ejs_irpc_connection {
  40         const char *server_name;
  41         struct server_id *dest_ids;
  42         struct messaging_context *msg_ctx;
  43 };
  44
  45 /*
  46   messaging clients need server IDs as well ...
  47  */
  48 #define EJS_ID_BASE 0x30000000
  49
  50 /*
  51   setup a context for talking to a irpc server
  52      example:
  53         status = irpc.connect("smb_server");
  54 */
  55 static int ejs_irpc_connect(MprVarHandle eid, int argc, char **argv)
  56 {
  57         NTSTATUS status;
  58         int i;
  59         struct event_context *ev;
  60         struct ejs_irpc_connection *p;
  61         struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
  62
  63         /* validate arguments */
  64         if (argc != 1) {
  65                 ejsSetErrorMsg(eid, "rpc_connect invalid arguments");
  66                 return -1;
  67         }
  68
  69         p = talloc(this, struct ejs_irpc_connection);
  70         if (p == NULL) {
  71                 return -1;
  72         }
  73
  74         p->server_name = argv[0];
  75
  76         ev = event_context_find(p);
  77
  78         /* create a messaging context, looping as we have no way to
  79            allocate temporary server ids automatically */
  80         for (i=0;i<10000;i++) {
  81                 p->msg_ctx = messaging_init(p,
  82                                             lp_messaging_path(p, global_loadparm),
  83                                             cluster_id(EJS_ID_BASE + i), ev);
  84                 if (p->msg_ctx) break;
  85         }
  86         if (p->msg_ctx == NULL) {
  87                 ejsSetErrorMsg(eid, "irpc_connect unable to create a messaging context");
  88                 talloc_free(p);
  89                 return -1;
  90         }
  91
  92         p->dest_ids = irpc_servers_byname(p->msg_ctx, p, p->server_name);
  93         if (p->dest_ids == NULL || p->dest_ids[0].id == 0) {
  94                 talloc_free(p);
  95                 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
  96         } else {
  97                 mprSetPtrChild(this, "irpc", p);
  98                 status = NT_STATUS_OK;
  99         }
 100
 101         mpr_Return(eid, mprNTSTATUS(status));
 102         return 0;
 103 }
 104
 105
 106 /*
 107   connect to an rpc server
 108      examples:
 109         status = rpc.connect("ncacn_ip_tcp:localhost");
 110         status = rpc.connect("ncacn_ip_tcp:localhost", "pipe_name");
 111 */
 112 static int ejs_rpc_connect(MprVarHandle eid, int argc, char **argv)
 113 {
 114         const char *binding, *pipe_name;
 115         const struct ndr_interface_table *iface;
 116         NTSTATUS status;
 117         struct dcerpc_pipe *p;
 118         struct cli_credentials *creds;
 119         struct event_context *ev;
 120         struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
 121         struct MprVar *credentials;
 122
 123         /* validate arguments */
 124         if (argc < 1) {
 125                 ejsSetErrorMsg(eid, "rpc_connect invalid arguments");
 126                 return -1;
 127         }
 128
 129         binding    = argv[0];
 130         if (strchr(binding, ':') == NULL) {
 131                 /* its an irpc connect */
 132                 return ejs_irpc_connect(eid, argc, argv);
 133         }
 134
 135         if (argc > 1) {
 136                 pipe_name = argv[1];
 137         } else {
 138                 pipe_name = mprToString(mprGetProperty(this, "pipe_name", NULL));
 139         }
 140
 141         iface = ndr_table_by_name(pipe_name);
 142         if (iface == NULL) {
 143                 status = NT_STATUS_OBJECT_NAME_INVALID;
 144                 goto done;
 145         }
 146
 147         credentials = mprGetProperty(this, "credentials", NULL);
 148         if (credentials) {
 149                 creds = (struct cli_credentials *)
 150                                 mprGetPtr(credentials, "creds");
 151         } else {
 152                 creds = cmdline_credentials;
 153         }
 154         if (creds == NULL) {
 155                 creds = cli_credentials_init(mprMemCtx());
 156                 cli_credentials_guess(creds);
 157                 cli_credentials_set_anonymous(creds);
 158         }
 159
 160         ev = event_context_find(mprMemCtx());
 161
 162         status = dcerpc_pipe_connect(this, &p, binding, iface, creds, ev);
 163         if (!NT_STATUS_IS_OK(status)) goto done;
 164
 165         /* callers don't allocate ref vars in the ejs interface */
 166         p->conn->flags |= DCERPC_NDR_REF_ALLOC;
 167
 168         /* by making the pipe a child of the connection variable, it will
 169            auto close when it goes out of scope in the script */
 170         mprSetPtrChild(this, "pipe", p);
 171
 172 done:
 173         mpr_Return(eid, mprNTSTATUS(status));
 174         return 0;
 175 }
 176
 177
 178 /*
 179   make an irpc call - called via the same interface as rpc
 180 */
 181 static int ejs_irpc_call(int eid, struct MprVar *io,
 182                          const struct ndr_interface_table *iface, int callnum,
 183                          ejs_pull_function_t ejs_pull, ejs_push_function_t ejs_push)
 184 {
 185         NTSTATUS status;
 186         void *ptr;
 187         struct ejs_rpc *ejs;
 188         const struct ndr_interface_call *call;
 189         struct ejs_irpc_connection *p;
 190         struct irpc_request **reqs;
 191         int i, count;
 192         struct MprVar *results;
 193
 194         p = (struct ejs_irpc_connection *)mprGetThisPtr(eid, "irpc");
 195
 196         ejs = talloc(mprMemCtx(), struct ejs_rpc);
 197         if (ejs == NULL) {
 198                 status = NT_STATUS_NO_MEMORY;
 199                 goto done;
 200         }
 201
 202         call = &iface->calls[callnum];
 203
 204         ejs->eid = eid;
 205         ejs->callname = call->name;
 206
 207         /* allocate the C structure */
 208         ptr = talloc_zero_size(ejs, call->struct_size);
 209         if (ptr == NULL) {
 210                 status = NT_STATUS_NO_MEMORY;
 211                 goto done;
 212         }
 213
 214         /* convert the mpr object into a C structure */
 215         status = ejs_pull(ejs, io, ptr);
 216         if (!NT_STATUS_IS_OK(status)) {
 217                 goto done;
 218         }
 219
 220         for (count=0;p->dest_ids[count].id;count++) /* noop */ ;
 221
 222         /* we need to make a call per server */
 223         reqs = talloc_array(ejs, struct irpc_request *, count);
 224         if (reqs == NULL) {
 225                 status = NT_STATUS_NO_MEMORY;
 226                 goto done;
 227         }
 228
 229         /* make the actual calls */
 230         for (i=0;i<count;i++) {
 231                 reqs[i] = irpc_call_send(p->msg_ctx, p->dest_ids[i],
 232                                          iface, callnum, ptr, ptr);
 233                 if (reqs[i] == NULL) {
 234                         status = NT_STATUS_NO_MEMORY;
 235                         goto done;
 236                 }
 237                 talloc_steal(reqs, reqs[i]);
 238         }
 239
 240         mprSetVar(io, "results", mprObject("results"));
 241         results = mprGetProperty(io, "results", NULL);
 242
 243         /* and receive the results, placing them in io.results[i] */
 244         for (i=0;i<count;i++) {
 245                 struct MprVar *output;
 246
 247                 status = irpc_call_recv(reqs[i]);
 248                 if (!NT_STATUS_IS_OK(status)) {
 249                         goto done;
 250                 }
 251                 status = ejs_push(ejs, io, ptr);
 252                 if (!NT_STATUS_IS_OK(status)) {
 253                         goto done;
 254                 }
 255
 256                 /* add to the results array */
 257                 output = mprGetProperty(io, "output", NULL);
 258                 if (output) {
 259                         char idx[16];
 260                         mprItoa(i, idx, sizeof(idx));
 261                         mprSetProperty(results, idx, output);
 262                         mprDeleteProperty(io, "output");
 263                 }
 264         }
 265         mprSetVar(results, "length", mprCreateIntegerVar(i));
 266
 267 done:
 268         talloc_free(ejs);
 269         mpr_Return(eid, mprNTSTATUS(status));
 270         if (NT_STATUS_EQUAL(status, NT_STATUS_INTERNAL_ERROR)) {
 271                 return -1;
 272         }
 273         return 0;
 274 }
 275
 276
 277 /*
 278   backend code for making an rpc call - this is called from the pidl generated ejs
 279   code
 280 */
 281  int ejs_rpc_call(int eid, int argc, struct MprVar **argv,
 282                   const struct ndr_interface_table *iface, int callnum,
 283                   ejs_pull_function_t ejs_pull, ejs_push_function_t ejs_push)
 284 {
 285         struct MprVar *io;
 286         struct dcerpc_pipe *p;
 287         NTSTATUS status;
 288         void *ptr;
 289         struct rpc_request *req;
 290         struct ejs_rpc *ejs;
 291         const struct ndr_interface_call *call;
 292
 293         if (argc != 1 || argv[0]->type != MPR_TYPE_OBJECT) {
 294                 ejsSetErrorMsg(eid, "rpc_call invalid arguments");
 295                 return -1;
 296         }
 297
 298         io       = argv[0];
 299
 300         if (mprGetThisPtr(eid, "irpc")) {
 301                 /* its an irpc call */
 302                 return ejs_irpc_call(eid, io, iface, callnum, ejs_pull, ejs_push);
 303         }
 304
 305         /* get the pipe info */
 306         p = mprGetThisPtr(eid, "pipe");
 307         if (p == NULL) {
 308                 ejsSetErrorMsg(eid, "rpc_call invalid pipe");
 309                 return -1;
 310         }
 311
 312         ejs = talloc(mprMemCtx(), struct ejs_rpc);
 313         if (ejs == NULL) {
 314                 status = NT_STATUS_NO_MEMORY;
 315                 goto done;
 316         }
 317
 318         call = &iface->calls[callnum];
 319
 320         ejs->eid = eid;
 321         ejs->callname = call->name;
 322
 323         /* allocate the C structure */
 324         ptr = talloc_zero_size(ejs, call->struct_size);
 325         if (ptr == NULL) {
 326                 status = NT_STATUS_NO_MEMORY;
 327                 goto done;
 328         }
 329
 330         /* convert the mpr object into a C structure */
 331         status = ejs_pull(ejs, io, ptr);
 332         if (!NT_STATUS_IS_OK(status)) {
 333                 goto done;
 334         }
 335
 336         /* make the actual call */
 337         req = dcerpc_ndr_request_send(p, NULL, iface, callnum, ptr, ptr);
 338
 339         /* if requested, print the structure */
 340         if (p->conn->flags & DCERPC_DEBUG_PRINT_IN) {
 341                 ndr_print_function_debug(call->ndr_print, call->name, NDR_IN, ptr);
 342         }
 343
 344         if (req == NULL) {
 345                 status = NT_STATUS_NO_MEMORY;
 346                 goto done;
 347         }
 348
 349         status = dcerpc_ndr_request_recv(req);
 350         if (!NT_STATUS_IS_OK(status)) {
 351                 goto done;
 352         }
 353
 354         /* print the 'out' structure, if needed */
 355         if (p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
 356                 ndr_print_function_debug(call->ndr_print, call->name, NDR_OUT, ptr);
 357         }
 358
 359         status = ejs_push(ejs, io, ptr);
 360
 361 done:
 362         talloc_free(ejs);
 363         mpr_Return(eid, mprNTSTATUS(status));
 364         if (NT_STATUS_EQUAL(status, NT_STATUS_INTERNAL_ERROR)) {
 365                 return -1;
 366         }
 367         return 0;
 368 }
 369
 370 /*
 371   hook called by generated RPC interfaces at the end of their init routines
 372   used to add generic operations on the pipe
 373 */
 374 int ejs_rpc_init(struct MprVar *obj, const char *name)
 375 {
 376         ndr_table_init();
 377
 378         mprSetStringCFunction(obj, "connect", ejs_rpc_connect);
 379         if (mprGetProperty(obj, "pipe_name", NULL) == NULL) {
 380                 mprSetVar(obj, "pipe_name", mprString(name));
 381         }
 382         return 0;
 383 }