source/scripting/ejs/smbcalls_sys.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    provide access to system functions
   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 "lib/ldb/include/ldb.h"
  26 #include "system/time.h"
  27 #include "system/network.h"
  28 #include "lib/socket/netif.h"
  29
  30 /*
  31   return the list of configured network interfaces
  32 */
  33 static int ejs_sys_interfaces(MprVarHandle eid, int argc, struct MprVar **argv)
  34 {
  35         int i, count = iface_count();
  36         struct MprVar ret = mprArray("interfaces");
  37         for (i=0;i<count;i++) {
  38                 mprAddArray(&ret, i, mprString(iface_n_ip(i)));
  39         }
  40         mpr_Return(eid, ret);
  41         return 0;
  42 }
  43
  44 /*
  45   return the hostname from gethostname()
  46 */
  47 static int ejs_sys_hostname(MprVarHandle eid, int argc, struct MprVar **argv)
  48 {
  49         char name[200];
  50         if (gethostname(name, sizeof(name)-1) == -1) {
  51                 ejsSetErrorMsg(eid, "gethostname failed - %s", strerror(errno));
  52                 return -1;
  53         }
  54         mpr_Return(eid, mprString(name));
  55         return 0;
  56 }
  57
  58
  59 /*
  60   return current time as seconds and microseconds
  61 */
  62 static int ejs_sys_gettimeofday(MprVarHandle eid, int argc, struct MprVar **argv)
  63 {
  64         struct timeval tv = timeval_current();
  65         struct MprVar v = mprObject("timeval");
  66         struct MprVar sec = mprCreateIntegerVar(tv.tv_sec);
  67         struct MprVar usec = mprCreateIntegerVar(tv.tv_usec);
  68
  69         mprCreateProperty(&v, "sec", &sec);
  70         mprCreateProperty(&v, "usec", &usec);
  71         mpr_Return(eid, v);
  72         return 0;
  73 }
  74
  75 /*
  76   return current time as a 64 bit nttime value
  77 */
  78 static int ejs_sys_nttime(MprVarHandle eid, int argc, struct MprVar **argv)
  79 {
  80         struct timeval tv = timeval_current();
  81         struct MprVar v = mprCreateNumberVar(timeval_to_nttime(&tv));
  82         mpr_Return(eid, v);
  83         return 0;
  84 }
  85
  86 /*
  87   return time as a 64 bit nttime value from a 32 bit time_t value
  88 */
  89 static int ejs_sys_unix2nttime(MprVarHandle eid, int argc, struct MprVar **argv)
  90 {
  91         NTTIME nt;
  92         struct MprVar v;
  93         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
  94                 ejsSetErrorMsg(eid, "sys_unix2nttime invalid arguments");
  95                 return -1;
  96         }
  97         unix_to_nt_time(&nt, mprVarToNumber(argv[0]));
  98         v = mprCreateNumberVar(nt);
  99         mpr_Return(eid, v);
 100         return 0;
 101 }
 102
 103 /*
 104   return the GMT time represented by the struct tm argument, as a time_t value
 105 */
 106 static int ejs_sys_gmmktime(MprVarHandle eid, int argc, struct MprVar **argv)
 107 {
 108         struct MprVar *o;
 109         struct tm tm;
 110         if (argc != 1 || !mprVarIsObject(argv[0]->type)) {
 111                 ejsSetErrorMsg(eid, "sys_gmmktime invalid arguments");
 112                 return -1;
 113         }
 114
 115         o = argv[0];
 116 #define TM_EL(n) tm.n = mprVarToNumber(mprGetProperty(o, #n, NULL))
 117         TM_EL(tm_sec);
 118         TM_EL(tm_min);
 119         TM_EL(tm_hour);
 120         TM_EL(tm_mday);
 121         TM_EL(tm_mon);
 122         TM_EL(tm_year);
 123         TM_EL(tm_wday);
 124         TM_EL(tm_yday);
 125         TM_EL(tm_isdst);
 126 #undef TM_EL
 127
 128         mpr_Return(eid, mprCreateIntegerVar(mktime(&tm)));
 129         return 0;
 130 }
 131
 132 /*
 133   return the given time as a gmtime structure
 134 */
 135 static int ejs_sys_gmtime(MprVarHandle eid, int argc, struct MprVar **argv)
 136 {
 137         time_t t;
 138         struct MprVar ret;
 139         struct tm *tm;
 140         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 141                 ejsSetErrorMsg(eid, "sys_gmtime invalid arguments");
 142                 return -1;
 143         }
 144         t = (time_t) mprVarToNumber(argv[0]);
 145         tm = gmtime(&t);
 146         if (tm == NULL) {
 147                 mpr_Return(eid, mprCreateUndefinedVar());
 148                 return 0;
 149         }
 150         ret = mprObject("gmtime");
 151 #define TM_EL(n) mprSetVar(&ret, #n, mprCreateIntegerVar(tm->n))
 152         TM_EL(tm_sec);
 153         TM_EL(tm_min);
 154         TM_EL(tm_hour);
 155         TM_EL(tm_mday);
 156         TM_EL(tm_mon);
 157         TM_EL(tm_year);
 158         TM_EL(tm_wday);
 159         TM_EL(tm_yday);
 160         TM_EL(tm_isdst);
 161 #undef TM_EL
 162
 163         mpr_Return(eid, ret);
 164         return 0;
 165 }
 166
 167 /*
 168   return the given NT time as a time_t value
 169 */
 170 static int ejs_sys_nttime2unix(MprVarHandle eid, int argc, struct MprVar **argv)
 171 {
 172         time_t t;
 173         struct MprVar v;
 174         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 175                 ejsSetErrorMsg(eid, "sys_ntgmtime invalid arguments");
 176                 return -1;
 177         }
 178         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 179         v = mprCreateNumberVar(t);
 180         mpr_Return(eid, v);
 181         return 0;
 182 }
 183
 184 /*
 185   return the given NT time as a gmtime structure
 186 */
 187 static int ejs_sys_ntgmtime(MprVarHandle eid, int argc, struct MprVar **argv)
 188 {
 189         time_t t;
 190         struct MprVar ret;
 191         struct tm *tm;
 192         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 193                 ejsSetErrorMsg(eid, "sys_ntgmtime invalid arguments");
 194                 return -1;
 195         }
 196         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 197         tm = gmtime(&t);
 198         if (tm == NULL) {
 199                 mpr_Return(eid, mprCreateUndefinedVar());
 200                 return 0;
 201         }
 202         ret = mprObject("gmtime");
 203 #define TM_EL(n) mprSetVar(&ret, #n, mprCreateIntegerVar(tm->n))
 204         TM_EL(tm_sec);
 205         TM_EL(tm_min);
 206         TM_EL(tm_hour);
 207         TM_EL(tm_mday);
 208         TM_EL(tm_mon);
 209         TM_EL(tm_year);
 210         TM_EL(tm_wday);
 211         TM_EL(tm_yday);
 212         TM_EL(tm_isdst);
 213 #undef TM_EL
 214
 215         mpr_Return(eid, ret);
 216         return 0;
 217 }
 218
 219 /*
 220   return a ldap time string from a nttime
 221 */
 222 static int ejs_sys_ldaptime(MprVarHandle eid, int argc, struct MprVar **argv)
 223 {
 224         char *s;
 225         time_t t;
 226         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 227                 ejsSetErrorMsg(eid, "sys_ldaptime invalid arguments");
 228                 return -1;
 229         }
 230         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 231         s = ldb_timestring(mprMemCtx(), t);
 232         mpr_Return(eid, mprString(s));
 233         talloc_free(s);
 234         return 0;
 235 }
 236
 237 /*
 238   return a http time string from a nttime
 239 */
 240 static int ejs_sys_httptime(MprVarHandle eid, int argc, struct MprVar **argv)
 241 {
 242         char *s;
 243         time_t t;
 244         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 245                 ejsSetErrorMsg(eid, "sys_httptime invalid arguments");
 246                 return -1;
 247         }
 248         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 249         s = http_timestring(mprMemCtx(), t);
 250         mpr_Return(eid, mprString(s));
 251         talloc_free(s);
 252         return 0;
 253 }
 254
 255 /*
 256   unlink a file
 257    ok = sys.unlink(fname);
 258 */
 259 static int ejs_sys_unlink(MprVarHandle eid, int argc, char **argv)
 260 {
 261         int ret;
 262         if (argc != 1) {
 263                 ejsSetErrorMsg(eid, "sys_unlink invalid arguments");
 264                 return -1;
 265         }
 266         ret = unlink(argv[0]);
 267         mpr_Return(eid, mprCreateBoolVar(ret == 0));
 268         return 0;
 269 }
 270
 271 /*
 272   load a file as a string
 273   usage:
 274      string = sys.file_load(filename);
 275 */
 276 static int ejs_sys_file_load(MprVarHandle eid, int argc, char **argv)
 277 {
 278         char *s;
 279         if (argc != 1) {
 280                 ejsSetErrorMsg(eid, "sys_file_load invalid arguments");
 281                 return -1;
 282         }
 283
 284         s = file_load(argv[0], NULL, mprMemCtx());
 285         mpr_Return(eid, mprString(s));
 286         talloc_free(s);
 287         return 0;
 288 }
 289
 290 /*
 291   save a file from a string
 292   usage:
 293      ok = sys.file_save(filename, str);
 294 */
 295 static int ejs_sys_file_save(MprVarHandle eid, int argc, char **argv)
 296 {
 297         BOOL ret;
 298         if (argc != 2) {
 299                 ejsSetErrorMsg(eid, "sys_file_save invalid arguments");
 300                 return -1;
 301         }
 302         ret = file_save(argv[0], argv[1], strlen(argv[1]));
 303         mpr_Return(eid, mprCreateBoolVar(ret));
 304         return 0;
 305 }
 306
 307 /*
 308   mkdir()
 309   usage:
 310      ok = sys.mkdir(dirname, mode);
 311 */
 312 static int ejs_sys_mkdir(MprVarHandle eid, int argc, struct MprVar **argv)
 313 {
 314         BOOL ret;
 315         char *name;
 316         if (argc != 2) {
 317                 ejsSetErrorMsg(eid, "sys_mkdir invalid arguments, need mkdir(dirname, mode)");
 318                 return -1;
 319         }
 320         if (!mprVarIsString(argv[0]->type)) {
 321                 ejsSetErrorMsg(eid, "sys_mkdir dirname not a string");
 322                 return -1;
 323         }
 324         if (!mprVarIsNumber(argv[1]->type)) {
 325                 ejsSetErrorMsg(eid, "sys_mkdir mode not a number");
 326                 return -1;
 327         }
 328         mprVarToString(&name, 0, NULL, argv[0]);
 329         ret = mkdir(name, mprVarToNumber(argv[1]));
 330         mpr_Return(eid, mprCreateBoolVar(ret == 0));
 331         return 0;
 332 }
 333
 334
 335 /*
 336   return fields of a stat() call
 337 */
 338 static struct MprVar mpr_stat(struct stat *st)
 339 {
 340         struct MprVar ret;
 341         ret = mprObject("stat");
 342
 343 #define ST_EL(n) mprSetVar(&ret, #n, mprCreateNumberVar(st->n))
 344         ST_EL(st_dev);
 345         ST_EL(st_ino);
 346         ST_EL(st_mode);
 347         ST_EL(st_nlink);
 348         ST_EL(st_uid);
 349         ST_EL(st_gid);
 350         ST_EL(st_rdev);
 351         ST_EL(st_size);
 352         ST_EL(st_blksize);
 353         ST_EL(st_blocks);
 354         ST_EL(st_atime);
 355         ST_EL(st_mtime);
 356         ST_EL(st_ctime);
 357
 358         return ret;
 359 }
 360
 361 /*
 362   usage:
 363       var st = sys.stat(filename);
 364   returns an object containing struct stat elements
 365 */
 366 static int ejs_sys_stat(MprVarHandle eid, int argc, char **argv)
 367 {
 368         struct stat st;
 369         /* validate arguments */
 370         if (argc != 1) {
 371                 ejsSetErrorMsg(eid, "sys.stat invalid arguments");
 372                 return -1;
 373         }
 374         if (stat(argv[0], &st) != 0) {
 375                 mpr_Return(eid, mprCreateUndefinedVar());
 376         } else {
 377                 mpr_Return(eid, mpr_stat(&st));
 378         }
 379         return 0;
 380 }
 381
 382 /*
 383   usage:
 384       var st = sys.lstat(filename);
 385   returns an object containing struct stat elements
 386 */
 387 static int ejs_sys_lstat(MprVarHandle eid, int argc, char **argv)
 388 {
 389         struct stat st;
 390         /* validate arguments */
 391         if (argc != 1) {
 392                 ejsSetErrorMsg(eid, "sys.stat invalid arguments");
 393                 return -1;
 394         }
 395         if (lstat(argv[0], &st) != 0) {
 396                 mpr_Return(eid, mprCreateUndefinedVar());
 397         } else {
 398                 mpr_Return(eid, mpr_stat(&st));
 399         }
 400         return 0;
 401 }
 402
 403 /*
 404   bitwise AND
 405   usage:
 406       var z = sys.bitAND(x, 0x70);
 407 */
 408 static int ejs_sys_bitAND(MprVarHandle eid, int argc, struct MprVar **argv)
 409 {
 410         int x, y, z;
 411
 412         if (argc != 2 ||
 413             !mprVarIsNumber(argv[0]->type) ||
 414             !mprVarIsNumber(argv[1]->type)) {
 415                 ejsSetErrorMsg(eid, "bitand invalid arguments");
 416                 return -1;
 417         }
 418         x = mprToInt(argv[0]);
 419         y = mprToInt(argv[1]);
 420         z = x & y;
 421
 422         mpr_Return(eid, mprCreateIntegerVar(z));
 423         return 0;
 424 }
 425
 426 /*
 427   bitwise OR
 428   usage:
 429       var z = sys.bitOR(x, 0x70);
 430 */
 431 static int ejs_sys_bitOR(MprVarHandle eid, int argc, struct MprVar **argv)
 432 {
 433         int x, y, z;
 434
 435         if (argc != 2 ||
 436             !mprVarIsNumber(argv[0]->type) ||
 437             !mprVarIsNumber(argv[1]->type)) {
 438                 ejsSetErrorMsg(eid, "bitand invalid arguments");
 439                 return -1;
 440         }
 441         x = mprToInt(argv[0]);
 442         y = mprToInt(argv[1]);
 443         z = x | y;
 444
 445         mpr_Return(eid, mprCreateIntegerVar(z));
 446         return 0;
 447 }
 448
 449 /*
 450   initialise sys ejs subsystem
 451 */
 452 static int ejs_sys_init(MprVarHandle eid, int argc, struct MprVar **argv)
 453 {
 454         struct MprVar *obj = mprInitObject(eid, "sys", argc, argv);
 455
 456         mprSetCFunction(obj, "interfaces", ejs_sys_interfaces);
 457         mprSetCFunction(obj, "hostname", ejs_sys_hostname);
 458         mprSetCFunction(obj, "nttime", ejs_sys_nttime);
 459         mprSetCFunction(obj, "gettimeofday", ejs_sys_gettimeofday);
 460         mprSetCFunction(obj, "unix2nttime", ejs_sys_unix2nttime);
 461         mprSetCFunction(obj, "gmmktime", ejs_sys_gmmktime);
 462         mprSetCFunction(obj, "gmtime", ejs_sys_gmtime);
 463         mprSetCFunction(obj, "nttime2unix", ejs_sys_nttime2unix);
 464         mprSetCFunction(obj, "ntgmtime", ejs_sys_ntgmtime);
 465         mprSetCFunction(obj, "ldaptime", ejs_sys_ldaptime);
 466         mprSetCFunction(obj, "httptime", ejs_sys_httptime);
 467         mprSetCFunction(obj, "mkdir", ejs_sys_mkdir);
 468         mprSetStringCFunction(obj, "unlink", ejs_sys_unlink);
 469         mprSetStringCFunction(obj, "file_load", ejs_sys_file_load);
 470         mprSetStringCFunction(obj, "file_save", ejs_sys_file_save);
 471         mprSetStringCFunction(obj, "stat", ejs_sys_stat);
 472         mprSetStringCFunction(obj, "lstat", ejs_sys_lstat);
 473         mprSetCFunction(obj, "bitAND", ejs_sys_bitAND);
 474         mprSetCFunction(obj, "bitOR", ejs_sys_bitOR);
 475
 476         return 0;
 477 }
 478
 479
 480 /*
 481   setup C functions that be called from ejs
 482 */
 483 NTSTATUS smb_setup_ejs_system(void)
 484 {
 485         ejsDefineCFunction(-1, "sys_init", ejs_sys_init, NULL, MPR_VAR_SCRIPT_HANDLE);
 486         return NT_STATUS_OK;
 487 }