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