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