source4/scripting/ejs/ejsrpc.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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/appweb/ejs/ejs.h"
  25 #include "scripting/ejs/smbcalls.h"
  26 #include "librpc/gen_ndr/ndr_security.h"
  27 #include "librpc/gen_ndr/lsa.h"
  28 #include "librpc/gen_ndr/winreg.h"
  29 #include "scripting/ejs/ejsrpc.h"
  30 #include "libcli/security/proto.h"
  31
  32 /*
  33   set the switch var to be used by the next union switch
  34 */
  35 void ejs_set_switch(struct ejs_rpc *ejs, uint32_t switch_var)
  36 {
  37         ejs->switch_var = switch_var;
  38 }
  39
  40 /*
  41   panic in the ejs wrapper code
  42  */
  43 NTSTATUS ejs_panic(struct ejs_rpc *ejs, const char *why)
  44 {
  45         ejsSetErrorMsg(ejs->eid, "rpc_call '%s' failed - %s", ejs->callname, why);
  46         return NT_STATUS_INTERNAL_ERROR;
  47 }
  48
  49 /*
  50   start the ejs pull process for a structure
  51 */
  52 NTSTATUS ejs_pull_struct_start(struct ejs_rpc *ejs, struct MprVar **v, const char *name)
  53 {
  54         return mprGetVar(v, name);
  55 }
  56
  57
  58 /*
  59   start the ejs push process for a structure
  60 */
  61 NTSTATUS ejs_push_struct_start(struct ejs_rpc *ejs, struct MprVar **v, const char *name)
  62 {
  63         NDR_CHECK(mprSetVar(*v, name, mprObject(name)));
  64         return mprGetVar(v, name);
  65 }
  66
  67 /*
  68   pull a uint8 from a mpr variable to a C element
  69 */
  70 NTSTATUS ejs_pull_uint8(struct ejs_rpc *ejs,
  71                         struct MprVar *v, const char *name, uint8_t *r)
  72 {
  73         NDR_CHECK(mprGetVar(&v, name));
  74         *r = mprVarToInteger(v);
  75         return NT_STATUS_OK;
  76
  77 }
  78
  79 NTSTATUS ejs_push_uint8(struct ejs_rpc *ejs,
  80                         struct MprVar *v, const char *name, const uint8_t *r)
  81 {
  82         return mprSetVar(v, name, mprCreateIntegerVar(*r));
  83 }
  84
  85 /*
  86   pull a uint16 from a mpr variable to a C element
  87 */
  88 NTSTATUS ejs_pull_uint16(struct ejs_rpc *ejs,
  89                          struct MprVar *v, const char *name, uint16_t *r)
  90 {
  91         NDR_CHECK(mprGetVar(&v, name));
  92         *r = mprVarToInteger(v);
  93         return NT_STATUS_OK;
  94
  95 }
  96
  97 NTSTATUS ejs_push_uint16(struct ejs_rpc *ejs,
  98                          struct MprVar *v, const char *name, const uint16_t *r)
  99 {
 100         return mprSetVar(v, name, mprCreateIntegerVar(*r));
 101 }
 102
 103 /*
 104   pull a uint32 from a mpr variable to a C element
 105 */
 106 NTSTATUS ejs_pull_uint32(struct ejs_rpc *ejs,
 107                          struct MprVar *v, const char *name, uint32_t *r)
 108 {
 109         NDR_CHECK(mprGetVar(&v, name));
 110         *r = mprVarToInteger(v);
 111         return NT_STATUS_OK;
 112 }
 113
 114 NTSTATUS ejs_push_uint32(struct ejs_rpc *ejs,
 115                          struct MprVar *v, const char *name, const uint32_t *r)
 116 {
 117         return mprSetVar(v, name, mprCreateIntegerVar(*r));
 118 }
 119
 120 /*
 121   pull a int32 from a mpr variable to a C element
 122 */
 123 NTSTATUS ejs_pull_int32(struct ejs_rpc *ejs,
 124                          struct MprVar *v, const char *name, int32_t *r)
 125 {
 126         NDR_CHECK(mprGetVar(&v, name));
 127         *r = mprVarToInteger(v);
 128         return NT_STATUS_OK;
 129 }
 130
 131 NTSTATUS ejs_push_int32(struct ejs_rpc *ejs,
 132                          struct MprVar *v, const char *name, const int32_t *r)
 133 {
 134         return mprSetVar(v, name, mprCreateIntegerVar(*r));
 135 }
 136
 137 /*
 138   pull a uint32 from a mpr variable to a C element
 139 */
 140 NTSTATUS ejs_pull_time_t(struct ejs_rpc *ejs,
 141                          struct MprVar *v, const char *name, time_t *r)
 142 {
 143         NDR_CHECK(mprGetVar(&v, name));
 144         *r = mprVarToInteger(v);
 145         return NT_STATUS_OK;
 146 }
 147
 148 NTSTATUS ejs_push_time_t(struct ejs_rpc *ejs,
 149                          struct MprVar *v, const char *name, const time_t *r)
 150 {
 151         return mprSetVar(v, name, mprCreateIntegerVar(*r));
 152 }
 153
 154 NTSTATUS ejs_pull_hyper(struct ejs_rpc *ejs,
 155                         struct MprVar *v, const char *name, uint64_t *r)
 156 {
 157         NDR_CHECK(mprGetVar(&v, name));
 158         *r = mprVarToNumber(v);
 159         return NT_STATUS_OK;
 160 }
 161
 162 NTSTATUS ejs_push_hyper(struct ejs_rpc *ejs,
 163                         struct MprVar *v, const char *name, const uint64_t *r)
 164 {
 165         return mprSetVar(v, name, mprCreateNumberVar(*r));
 166 }
 167
 168 NTSTATUS ejs_pull_dlong(struct ejs_rpc *ejs,
 169                         struct MprVar *v, const char *name, int64_t *r)
 170 {
 171         return ejs_pull_hyper(ejs, v, name, (uint64_t *)r);
 172 }
 173
 174 NTSTATUS ejs_push_dlong(struct ejs_rpc *ejs,
 175                         struct MprVar *v, const char *name, const int64_t *r)
 176 {
 177         return ejs_push_hyper(ejs, v, name, (const uint64_t *)r);
 178 }
 179
 180 NTSTATUS ejs_pull_udlong(struct ejs_rpc *ejs,
 181                         struct MprVar *v, const char *name, uint64_t *r)
 182 {
 183         return ejs_pull_hyper(ejs, v, name, r);
 184 }
 185
 186 NTSTATUS ejs_push_udlong(struct ejs_rpc *ejs,
 187                         struct MprVar *v, const char *name, const uint64_t *r)
 188 {
 189         return ejs_push_hyper(ejs, v, name, r);
 190 }
 191
 192 NTSTATUS ejs_pull_NTTIME(struct ejs_rpc *ejs,
 193                         struct MprVar *v, const char *name, uint64_t *r)
 194 {
 195         return ejs_pull_hyper(ejs, v, name, r);
 196 }
 197
 198 NTSTATUS ejs_push_NTTIME(struct ejs_rpc *ejs,
 199                         struct MprVar *v, const char *name, const uint64_t *r)
 200 {
 201         return ejs_push_hyper(ejs, v, name, r);
 202 }
 203
 204 NTSTATUS ejs_push_WERROR(struct ejs_rpc *ejs,
 205                         struct MprVar *v, const char *name, const WERROR *r)
 206 {
 207         return ejs_push_string(ejs, v, name, win_errstr(*r));
 208 }
 209
 210 NTSTATUS ejs_push_NTSTATUS(struct ejs_rpc *ejs,
 211                            struct MprVar *v, const char *name, const NTSTATUS *r)
 212 {
 213         return ejs_push_string(ejs, v, name, nt_errstr(*r));
 214 }
 215
 216
 217 /*
 218   pull a enum from a mpr variable to a C element
 219   a enum is just treating as an unsigned integer at this level
 220 */
 221 NTSTATUS ejs_pull_enum(struct ejs_rpc *ejs,
 222                        struct MprVar *v, const char *name, unsigned *r)
 223 {
 224         NDR_CHECK(mprGetVar(&v, name));
 225         *r = mprVarToInteger(v);
 226         return NT_STATUS_OK;
 227
 228 }
 229
 230 NTSTATUS ejs_push_enum(struct ejs_rpc *ejs,
 231                        struct MprVar *v, const char *name, const unsigned *r)
 232 {
 233         return mprSetVar(v, name, mprCreateIntegerVar(*r));
 234 }
 235
 236
 237 /*
 238   pull a string
 239 */
 240 NTSTATUS ejs_pull_string(struct ejs_rpc *ejs,
 241                          struct MprVar *v, const char *name, const char **s)
 242 {
 243         NDR_CHECK(mprGetVar(&v, name));
 244         *s = mprToString(v);
 245         return NT_STATUS_OK;
 246 }
 247
 248 /*
 249   push a string
 250 */
 251 NTSTATUS ejs_push_string(struct ejs_rpc *ejs,
 252                          struct MprVar *v, const char *name, const char *s)
 253 {
 254         return mprSetVar(v, name, mprString(s));
 255 }
 256
 257 NTSTATUS ejs_pull_dom_sid(struct ejs_rpc *ejs,
 258                           struct MprVar *v, const char *name, struct dom_sid *r)
 259 {
 260         struct dom_sid *sid;
 261         NDR_CHECK(mprGetVar(&v, name));
 262         sid = dom_sid_parse_talloc(ejs, mprToString(v));
 263         NT_STATUS_HAVE_NO_MEMORY(sid);
 264         *r = *sid;
 265         return NT_STATUS_OK;
 266 }
 267
 268 NTSTATUS ejs_push_dom_sid(struct ejs_rpc *ejs,
 269                           struct MprVar *v, const char *name, const struct dom_sid *r)
 270 {
 271         char *sidstr = dom_sid_string(ejs, r);
 272         NT_STATUS_HAVE_NO_MEMORY(sidstr);
 273         return mprSetVar(v, name, mprString(sidstr));
 274 }
 275
 276 NTSTATUS ejs_pull_GUID(struct ejs_rpc *ejs,
 277                        struct MprVar *v, const char *name, struct GUID *r)
 278 {
 279         NDR_CHECK(mprGetVar(&v, name));
 280         return GUID_from_string(mprToString(v), r);
 281 }
 282
 283 NTSTATUS ejs_push_GUID(struct ejs_rpc *ejs,
 284                        struct MprVar *v, const char *name, const struct GUID *r)
 285 {
 286         char *guid = GUID_string(ejs, r);
 287         NT_STATUS_HAVE_NO_MEMORY(guid);
 288         return mprSetVar(v, name, mprString(guid));
 289 }
 290
 291 NTSTATUS ejs_push_null(struct ejs_rpc *ejs, struct MprVar *v, const char *name)
 292 {
 293         return mprSetVar(v, name, mprCreatePtrVar(NULL));
 294 }
 295
 296 BOOL ejs_pull_null(struct ejs_rpc *ejs, struct MprVar *v, const char *name)
 297 {
 298         NTSTATUS status = mprGetVar(&v, name);
 299         if (!NT_STATUS_IS_OK(status)) {
 300                 return False;
 301         }
 302         if (v->type == MPR_TYPE_PTR && v->ptr == NULL) {
 303                 return True;
 304         }
 305         return False;
 306 }
 307
 308 /*
 309   pull a lsa_String
 310 */
 311 NTSTATUS ejs_pull_lsa_String(struct ejs_rpc *ejs,
 312                              struct MprVar *v, const char *name, struct lsa_String *r)
 313 {
 314         return ejs_pull_string(ejs, v, name, &r->string);
 315 }
 316
 317 /*
 318   push a lsa_String
 319 */
 320 NTSTATUS ejs_push_lsa_String(struct ejs_rpc *ejs,
 321                              struct MprVar *v, const char *name, const struct lsa_String *r)
 322 {
 323         return ejs_push_string(ejs, v, name, r->string);
 324 }
 325
 326 /*
 327   pull a winreg_String
 328 */
 329 NTSTATUS ejs_pull_winreg_String(struct ejs_rpc *ejs,
 330                              struct MprVar *v, const char *name, struct winreg_String *r)
 331 {
 332         return ejs_pull_string(ejs, v, name, &r->name);
 333 }
 334
 335 /*
 336   push a winreg_String
 337 */
 338 NTSTATUS ejs_push_winreg_String(struct ejs_rpc *ejs,
 339                              struct MprVar *v, const char *name, const struct winreg_String *r)
 340 {
 341         return ejs_push_string(ejs, v, name, r->name);
 342 }
 343
 344 NTSTATUS ejs_pull_DATA_BLOB(struct ejs_rpc *ejs,
 345                             struct MprVar *v, const char *name, DATA_BLOB *r)
 346 {
 347         return NT_STATUS_NOT_IMPLEMENTED;
 348 }
 349
 350 NTSTATUS ejs_push_DATA_BLOB(struct ejs_rpc *ejs,
 351                             struct MprVar *v, const char *name,
 352                             const DATA_BLOB *r)
 353 {
 354         return NT_STATUS_NOT_IMPLEMENTED;
 355 }
 356
 357 NTSTATUS ejs_pull_BOOL(struct ejs_rpc *ejs,
 358                        struct MprVar *v, const char *name, BOOL *r)
 359 {
 360         NDR_CHECK(mprGetVar(&v, name));
 361         *r = mprVarToBool(v);
 362         return NT_STATUS_OK;
 363 }
 364
 365 NTSTATUS ejs_push_BOOL(struct ejs_rpc *ejs,
 366                        struct MprVar *v, const char *name, const BOOL *r)
 367 {
 368         return mprSetVar(v, name, mprCreateBoolVar(*r));
 369 }
 370
 371
 372 /*
 373   pull a uint8 array from a mpr variable to a C element - treating as a data blob
 374 */
 375 NTSTATUS ejs_pull_array_uint8(struct ejs_rpc *ejs,
 376                               struct MprVar *v, const char *name,
 377                               uint8_t *r, uint32_t length)
 378 {
 379         NTSTATUS status;
 380         DATA_BLOB *blob;
 381
 382         status = mprGetVar(&v, name);
 383         NT_STATUS_NOT_OK_RETURN(status);
 384
 385         blob = mprToDataBlob(v);
 386         if (blob == NULL) {
 387                 return NT_STATUS_OBJECT_NAME_INVALID;
 388         }
 389         if (blob->length != length) {
 390                 return NT_STATUS_INFO_LENGTH_MISMATCH;
 391         }
 392         memcpy(r, blob->data, length);
 393         return NT_STATUS_OK;
 394
 395 }
 396
 397 NTSTATUS ejs_push_array_uint8(struct ejs_rpc *ejs,
 398                               struct MprVar *v, const char *name,
 399                               const uint8_t *r, uint32_t length)
 400 {
 401         DATA_BLOB blob;
 402         blob.data = discard_const(r);
 403         blob.length = length;
 404         mprSetVar(v, name, mprDataBlob(blob));
 405         return NT_STATUS_OK;
 406 }