source4/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 "netif/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 a 64 bit nttime value
  62 */
  63 static int ejs_sys_nttime(MprVarHandle eid, int argc, struct MprVar **argv)
  64 {
  65         struct timeval tv = timeval_current();
  66         struct MprVar v = mprCreateNumberVar(timeval_to_nttime(&tv));
  67         mpr_Return(eid, v);
  68         return 0;
  69 }
  70
  71 /*
  72   return time as a 64 bit nttime value from a 32 bit time_t value
  73 */
  74 static int ejs_sys_unix2nttime(MprVarHandle eid, int argc, struct MprVar **argv)
  75 {
  76         NTTIME nt;
  77         struct MprVar v;
  78         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
  79                 ejsSetErrorMsg(eid, "sys_unix2nttime invalid arguments");
  80                 return -1;
  81         }
  82         unix_to_nt_time(&nt, mprVarToNumber(argv[0]));
  83         v = mprCreateNumberVar(nt);
  84         mpr_Return(eid, v);
  85         return 0;
  86 }
  87
  88 /*
  89   return the given time as a gmtime structure
  90 */
  91 static int ejs_sys_gmtime(MprVarHandle eid, int argc, struct MprVar **argv)
  92 {
  93         time_t t;
  94         struct MprVar ret;
  95         struct tm *tm;
  96         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
  97                 ejsSetErrorMsg(eid, "sys_gmtime invalid arguments");
  98                 return -1;
  99         }
 100         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 101         tm = gmtime(&t);
 102         if (tm == NULL) {
 103                 mpr_Return(eid, mprCreateUndefinedVar());
 104                 return 0;
 105         }
 106         ret = mprObject("gmtime");
 107 #define TM_EL(n) mprSetVar(&ret, #n, mprCreateIntegerVar(tm->n))
 108         TM_EL(tm_sec);
 109         TM_EL(tm_min);
 110         TM_EL(tm_hour);
 111         TM_EL(tm_mday);
 112         TM_EL(tm_mon);
 113         TM_EL(tm_year);
 114         TM_EL(tm_wday);
 115         TM_EL(tm_yday);
 116         TM_EL(tm_isdst);
 117
 118         mpr_Return(eid, ret);
 119         return 0;
 120 }
 121
 122 /*
 123   return a ldap time string from a nttime
 124 */
 125 static int ejs_sys_ldaptime(MprVarHandle eid, int argc, struct MprVar **argv)
 126 {
 127         char *s;
 128         time_t t;
 129         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 130                 ejsSetErrorMsg(eid, "sys_ldaptime invalid arguments");
 131                 return -1;
 132         }
 133         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 134         s = ldb_timestring(mprMemCtx(), t);
 135         mpr_Return(eid, mprString(s));
 136         talloc_free(s);
 137         return 0;
 138 }
 139
 140 /*
 141   return a http time string from a nttime
 142 */
 143 static int ejs_sys_httptime(MprVarHandle eid, int argc, struct MprVar **argv)
 144 {
 145         char *s;
 146         time_t t;
 147         if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
 148                 ejsSetErrorMsg(eid, "sys_httptime invalid arguments");
 149                 return -1;
 150         }
 151         t = nt_time_to_unix(mprVarToNumber(argv[0]));
 152         s = http_timestring(mprMemCtx(), t);
 153         mpr_Return(eid, mprString(s));
 154         talloc_free(s);
 155         return 0;
 156 }
 157
 158 /*
 159   unlink a file
 160    ok = sys.unlink(fname);
 161 */
 162 static int ejs_sys_unlink(MprVarHandle eid, int argc, char **argv)
 163 {
 164         int ret;
 165         if (argc != 1) {
 166                 ejsSetErrorMsg(eid, "sys_unlink invalid arguments");
 167                 return -1;
 168         }
 169         ret = unlink(argv[0]);
 170         mpr_Return(eid, mprCreateBoolVar(ret == 0));
 171         return 0;
 172 }
 173
 174 /*
 175   load a file as a string
 176   usage:
 177      string = sys.file_load(filename);
 178 */
 179 static int ejs_sys_file_load(MprVarHandle eid, int argc, char **argv)
 180 {
 181         char *s;
 182         if (argc != 1) {
 183                 ejsSetErrorMsg(eid, "sys_file_load invalid arguments");
 184                 return -1;
 185         }
 186
 187         s = file_load(argv[0], NULL, mprMemCtx());
 188         mpr_Return(eid, mprString(s));
 189         talloc_free(s);
 190         return 0;
 191 }
 192
 193 /*
 194   save a file from a string
 195   usage:
 196      ok = sys.file_save(filename, str);
 197 */
 198 static int ejs_sys_file_save(MprVarHandle eid, int argc, char **argv)
 199 {
 200         BOOL ret;
 201         if (argc != 2) {
 202                 ejsSetErrorMsg(eid, "sys_file_save invalid arguments");
 203                 return -1;
 204         }
 205         ret = file_save(argv[0], argv[1], strlen(argv[1]));
 206         mpr_Return(eid, mprCreateBoolVar(ret));
 207         return 0;
 208 }
 209
 210
 211 /*
 212   return fields of a stat() call
 213 */
 214 static struct MprVar mpr_stat(struct stat *st)
 215 {
 216         struct MprVar ret;
 217         ret = mprObject("stat");
 218
 219 #define ST_EL(n) mprSetVar(&ret, #n, mprCreateNumberVar(st->n))
 220         ST_EL(st_dev);
 221         ST_EL(st_ino);
 222         ST_EL(st_mode);
 223         ST_EL(st_nlink);
 224         ST_EL(st_uid);
 225         ST_EL(st_gid);
 226         ST_EL(st_rdev);
 227         ST_EL(st_size);
 228         ST_EL(st_blksize);
 229         ST_EL(st_blocks);
 230         ST_EL(st_atime);
 231         ST_EL(st_mtime);
 232         ST_EL(st_ctime);
 233
 234         return ret;
 235 }
 236
 237 /*
 238   usage:
 239       var st = sys.stat(filename);
 240   returns an object containing struct stat elements
 241 */
 242 static int ejs_sys_stat(MprVarHandle eid, int argc, char **argv)
 243 {
 244         struct stat st;
 245         /* validate arguments */
 246         if (argc != 1) {
 247                 ejsSetErrorMsg(eid, "sys.stat invalid arguments");
 248                 return -1;
 249         }
 250         if (stat(argv[0], &st) != 0) {
 251                 mpr_Return(eid, mprCreateUndefinedVar());
 252         } else {
 253                 mpr_Return(eid, mpr_stat(&st));
 254         }
 255         return 0;
 256 }
 257
 258 /*
 259   usage:
 260       var st = sys.lstat(filename);
 261   returns an object containing struct stat elements
 262 */
 263 static int ejs_sys_lstat(MprVarHandle eid, int argc, char **argv)
 264 {
 265         struct stat st;
 266         /* validate arguments */
 267         if (argc != 1) {
 268                 ejsSetErrorMsg(eid, "sys.stat invalid arguments");
 269                 return -1;
 270         }
 271         if (lstat(argv[0], &st) != 0) {
 272                 mpr_Return(eid, mprCreateUndefinedVar());
 273         } else {
 274                 mpr_Return(eid, mpr_stat(&st));
 275         }
 276         return 0;
 277 }
 278
 279 /*
 280   bitwise AND
 281   usage:
 282       var z = sys.bitAND(x, 0x70);
 283 */
 284 static int ejs_sys_bitAND(MprVarHandle eid, int argc, struct MprVar **argv)
 285 {
 286         int x, y, z;
 287
 288         if (argc != 2 ||
 289             !mprVarIsNumber(argv[0]->type) ||
 290             !mprVarIsNumber(argv[1]->type)) {
 291                 ejsSetErrorMsg(eid, "bitand invalid arguments");
 292                 return -1;
 293         }
 294         x = mprToInt(argv[0]);
 295         y = mprToInt(argv[1]);
 296         z = x & y;
 297
 298         mpr_Return(eid, mprCreateIntegerVar(z));
 299         return 0;
 300 }
 301
 302 /*
 303   bitwise OR
 304   usage:
 305       var z = sys.bitOR(x, 0x70);
 306 */
 307 static int ejs_sys_bitOR(MprVarHandle eid, int argc, struct MprVar **argv)
 308 {
 309         int x, y, z;
 310
 311         if (argc != 2 ||
 312             !mprVarIsNumber(argv[0]->type) ||
 313             !mprVarIsNumber(argv[1]->type)) {
 314                 ejsSetErrorMsg(eid, "bitand invalid arguments");
 315                 return -1;
 316         }
 317         x = mprToInt(argv[0]);
 318         y = mprToInt(argv[1]);
 319         z = x | y;
 320
 321         mpr_Return(eid, mprCreateIntegerVar(z));
 322         return 0;
 323 }
 324
 325 /*
 326   initialise sys ejs subsystem
 327 */
 328 static int ejs_sys_init(MprVarHandle eid, int argc, struct MprVar **argv)
 329 {
 330         struct MprVar *obj = mprInitObject(eid, "sys", argc, argv);
 331
 332         mprSetCFunction(obj, "interfaces", ejs_sys_interfaces);
 333         mprSetCFunction(obj, "hostname", ejs_sys_hostname);
 334         mprSetCFunction(obj, "nttime", ejs_sys_nttime);
 335         mprSetCFunction(obj, "unix2nttime", ejs_sys_unix2nttime);
 336         mprSetCFunction(obj, "gmtime", ejs_sys_gmtime);
 337         mprSetCFunction(obj, "ldaptime", ejs_sys_ldaptime);
 338         mprSetCFunction(obj, "httptime", ejs_sys_httptime);
 339         mprSetStringCFunction(obj, "unlink", ejs_sys_unlink);
 340         mprSetStringCFunction(obj, "file_load", ejs_sys_file_load);
 341         mprSetStringCFunction(obj, "file_save", ejs_sys_file_save);
 342         mprSetStringCFunction(obj, "stat", ejs_sys_stat);
 343         mprSetStringCFunction(obj, "lstat", ejs_sys_lstat);
 344         mprSetCFunction(obj, "bitAND", ejs_sys_bitAND);
 345         mprSetCFunction(obj, "bitOR", ejs_sys_bitOR);
 346
 347         return 0;
 348 }
 349
 350
 351 /*
 352   setup C functions that be called from ejs
 353 */
 354 void smb_setup_ejs_system(void)
 355 {
 356         ejsDefineCFunction(-1, "sys_init", ejs_sys_init, NULL, MPR_VAR_SCRIPT_HANDLE);
 357 }