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