source4/scripting/ejs/smbcalls_config.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    provide hooks into smbd C 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 "scripting/ejs/smbcalls.h"
  24 #include "lib/appweb/ejs/ejs.h"
  25 #include "param/loadparm.h"
  26 #include "system/network.h"
  27 #include "lib/socket/netif.h"
  28 #include "param/param.h"
  29
  30 /*
  31   return a list of defined services
  32 */
  33 static int ejs_lpServices(MprVarHandle eid, int argc, char **argv)
  34 {
  35         int i;
  36         const char **list = NULL;
  37         if (argc != 0) return -1;
  38
  39         for (i=0;i<lp_numservices();i++) {
  40                 list = str_list_add(list, lp_servicename(i));
  41         }
  42         talloc_steal(mprMemCtx(), list);
  43         mpr_Return(eid, mprList("services", list));
  44         return 0;
  45 }
  46
  47
  48 /*
  49   return a list of parameter categories
  50 */
  51 static int ejs_lpCategories(MprVarHandle eid, int argc, char **argv)
  52 {
  53         struct parm_struct *parm_table = lp_parm_table();
  54         int i;
  55         const char **list = NULL;
  56         if (argc != 0) return -1;
  57
  58         for (i=0;parm_table[i].label;i++) {
  59                 if (parm_table[i].class == P_SEPARATOR) {
  60                         list = str_list_add(list, parm_table[i].label);
  61                 }
  62         }
  63         talloc_steal(mprMemCtx(), list);
  64         mpr_Return(eid, mprList("categories", list));
  65         return 0;
  66 }
  67
  68
  69 /*
  70   allow access to loadparm variables from inside ejs scripts in web apps
  71
  72   can be called in 4 ways:
  73
  74     v = lp.get("type:parm");             gets a parametric variable
  75     v = lp.get("share", "type:parm");    gets a parametric variable on a share
  76     v = lp.get("parm");                  gets a global variable
  77     v = lp.get("share", "parm");         gets a share variable
  78
  79   the returned variable is a ejs object. It is an array object for lists.
  80 */
  81 static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
  82 {
  83         struct parm_struct *parm = NULL;
  84         void *parm_ptr = NULL;
  85         int i;
  86
  87         if (argc < 1) return -1;
  88
  89         if (argc == 2) {
  90                 /* its a share parameter */
  91                 int snum = lp_servicenumber(argv[0]);
  92                 if (snum == -1) {
  93                         mpr_Return(eid, mprCreateUndefinedVar());
  94                         return 0;
  95                 }
  96                 if (strchr(argv[1], ':')) {
  97                         /* its a parametric option on a share */
  98                         const char *type = talloc_strndup(mprMemCtx(),
  99                                                           argv[1],
 100                                                           strcspn(argv[1], ":"));
 101                         const char *option = strchr(argv[1], ':') + 1;
 102                         const char *value;
 103                         if (type == NULL || option == NULL) {
 104                                 mpr_Return(eid, mprCreateUndefinedVar());
 105                                 return 0;
 106                         }
 107                         value = lp_get_parametric(snum, type, option);
 108                         if (value == NULL) {
 109                                 mpr_Return(eid, mprCreateUndefinedVar());
 110                                 return 0;
 111                         }
 112                         mpr_ReturnString(eid, value);
 113                         return 0;
 114                 }
 115
 116                 parm = lp_parm_struct(argv[1]);
 117                 if (parm == NULL || parm->class == P_GLOBAL) {
 118                         mpr_Return(eid, mprCreateUndefinedVar());
 119                         return 0;
 120                 }
 121                 parm_ptr = lp_parm_ptr(snum, parm);
 122         } else if (strchr(argv[0], ':')) {
 123                 /* its a global parametric option */
 124                 const char *type = talloc_strndup(mprMemCtx(),
 125                                                   argv[0], strcspn(argv[0], ":"));
 126                 const char *option = strchr(argv[0], ':') + 1;
 127                 const char *value;
 128                 if (type == NULL || option == NULL) {
 129                         mpr_Return(eid, mprCreateUndefinedVar());
 130                         return 0;
 131                 }
 132                 value = lp_get_parametric(-1, type, option);
 133                 if (value == NULL) {
 134                         mpr_Return(eid, mprCreateUndefinedVar());
 135                         return 0;
 136                 }
 137                 mpr_ReturnString(eid, value);
 138                 return 0;
 139         } else {
 140                 /* its a global parameter */
 141                 parm = lp_parm_struct(argv[0]);
 142                 if (parm == NULL) {
 143                         mpr_Return(eid, mprCreateUndefinedVar());
 144                         return 0;
 145                 }
 146                 parm_ptr = lp_parm_ptr(-1, parm);
 147         }
 148
 149         if (parm == NULL || parm_ptr == NULL) {
 150                 mpr_Return(eid, mprCreateUndefinedVar());
 151                 return 0;
 152         }
 153
 154         /* construct and return the right type of ejs object */
 155         switch (parm->type) {
 156         case P_STRING:
 157         case P_USTRING:
 158                 mpr_ReturnString(eid, *(char **)parm_ptr);
 159                 break;
 160         case P_BOOL:
 161                 mpr_Return(eid, mprCreateBoolVar(*(BOOL *)parm_ptr));
 162                 break;
 163         case P_INTEGER:
 164         case P_OCTAL:
 165         case P_BYTES:
 166                 mpr_Return(eid, mprCreateIntegerVar(*(int *)parm_ptr));
 167                 break;
 168         case P_ENUM:
 169                 for (i=0; parm->enum_list[i].name; i++) {
 170                         if (*(int *)parm_ptr == parm->enum_list[i].value) {
 171                                 mpr_ReturnString(eid, parm->enum_list[i].name);
 172                                 return 0;
 173                         }
 174                 }
 175                 mpr_Return(eid, mprCreateUndefinedVar());
 176                 return 0;
 177         case P_LIST:
 178                 mpr_Return(eid, mprList(parm->label, *(const char ***)parm_ptr));
 179                 break;
 180         case P_SEP:
 181                 mpr_Return(eid, mprCreateUndefinedVar());
 182                 return 0;
 183         }
 184         return 0;
 185 }
 186
 187
 188 /*
 189   set a smb.conf parameter. Only sets in memory, not permanent
 190
 191   can be called in 4 ways:
 192
 193     ok = lp.set("parm", "value");
 194 */
 195 static int ejs_lpSet(MprVarHandle eid, int argc, char **argv)
 196 {
 197         if (argc != 2) {
 198                 ejsSetErrorMsg(eid, "lp.set invalid arguments");
 199                 return -1;
 200         }
 201
 202         mpr_Return(eid, mprCreateBoolVar(lp_set_cmdline(argv[0], argv[1])));
 203         return 0;
 204 }
 205
 206 /*
 207   reload smb.conf
 208
 209     ok = lp.reload();
 210 */
 211 static int ejs_lpReload(MprVarHandle eid, int argc, char **argv)
 212 {
 213         BOOL ret = lp_load();
 214         if (ret) {
 215                 unload_interfaces();
 216         }
 217         mpr_Return(eid, mprCreateBoolVar(ret));
 218         return 0;
 219 }
 220
 221 /*
 222   initialise loadparm ejs subsystem
 223 */
 224 static int ejs_loadparm_init(MprVarHandle eid, int argc, struct MprVar **argv)
 225 {
 226         struct MprVar *obj = mprInitObject(eid, "loadparm", argc, argv);
 227
 228         mprSetStringCFunction(obj, "get", ejs_lpGet);
 229         mprSetStringCFunction(obj, "set", ejs_lpSet);
 230         mprSetStringCFunction(obj, "reload", ejs_lpReload);
 231         mprSetStringCFunction(obj, "services", ejs_lpServices);
 232         mprSetStringCFunction(obj, "categories", ejs_lpCategories);
 233         return 0;
 234 }
 235
 236 /*
 237   setup C functions that be called from ejs
 238 */
 239 NTSTATUS smb_setup_ejs_config(void)
 240 {
 241         ejsDefineCFunction(-1, "loadparm_init", ejs_loadparm_init, NULL, MPR_VAR_SCRIPT_HANDLE);
 242         return NT_STATUS_OK;
 243 }