r25026: Move param/param.h out of includes.h
[kai/samba-autobuild/.git] / 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 }