afdee28a659c7f0a659ff1f41ba5586d3443db8b
[kai/samba-autobuild/.git] / source4 / scripting / ejs / smbcalls_param.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    provide hooks into smbd C calls from ejs scripts
5
6    Copyright (C) Jelmer Vernooij 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/param.h"
26
27 /*
28   get parameter
29
30   value = param.get("name");
31   value = param.get("section", "name");
32 */
33 static int ejs_param_get(MprVarHandle eid, int argc, char **argv)
34 {
35         struct param_context *ctx;
36         const char *ret;
37         if (argc != 1 && argc != 2) {
38                 ejsSetErrorMsg(eid, "param.get invalid argument count");
39                 return -1;
40         }
41
42         ctx = mprGetThisPtr(eid, "param");
43         mprAssert(ctx);
44         
45         if (argc == 2) {
46                 ret = param_get_string(ctx, argv[0], argv[1]);
47         } else {
48                 ret = param_get_string(ctx, NULL, argv[0]);
49         }
50
51         if (ret) {
52                 mpr_Return(eid, mprString(ret));
53         } else {
54                 mpr_Return(eid, mprCreateUndefinedVar());
55         }
56         return 0;
57 }
58
59 /*
60   get list parameter
61
62   ok = param.get_list("name");
63   ok = param.get_list("section", "name");
64 */
65 static int ejs_param_get_list(MprVarHandle eid, int argc, char **argv)
66 {
67         struct param_context *ctx;
68         const char **ret;
69
70         if (argc != 1 && argc != 2) {
71                 ejsSetErrorMsg(eid, "param.get_list invalid argument count");
72                 return -1;
73         }
74
75         ctx = mprGetThisPtr(eid, "param");
76         mprAssert(ctx);
77         
78         if (argc == 2) {
79                 ret = param_get_string_list(ctx, argv[0], argv[1], NULL);
80         } else {
81                 ret = param_get_string_list(ctx, NULL, argv[0], NULL);
82         }
83
84         if (ret != NULL) {
85                 mpr_Return(eid, mprList("array", ret));
86         } else {
87                 mpr_Return(eid, mprCreateUndefinedVar());
88         }
89         return 0;
90 }
91
92 /*
93   set parameter
94
95   ok = param.set("name", "value");
96   ok = param.set("section", "name", "value");
97 */
98 static int ejs_param_set(MprVarHandle eid, int argc, struct MprVar **argv)
99 {
100         struct param_context *ctx;
101         const char **list;
102         const char *section, *paramname;
103         struct MprVar *value;
104         bool ret;
105         if (argc != 2 && argc != 3) {
106                 ejsSetErrorMsg(eid, "param.set invalid argument count");
107                 return -1;
108         }
109
110         ctx = mprGetThisPtr(eid, "param");
111         mprAssert(ctx);
112
113         
114         if (argc == 3) {
115                 section = mprToString(argv[0]);
116                 paramname = mprToString(argv[1]);
117                 value = argv[2];
118         } else {
119                 section = NULL;
120                 paramname = mprToString(argv[0]);
121                 value = argv[1];
122         }
123         
124         list = mprToList(mprMemCtx(), value);
125         if (list) {
126                 ret = param_set_string_list(ctx, section, paramname, list);
127         } else {
128                 ret = param_set_string(ctx, section, paramname, mprToString(value));
129         }
130
131         mpr_Return(eid, mprCreateBoolVar(ret));
132         return 0;
133 }
134
135 /* 
136   param data as a two-level array
137
138   data = param.data;
139   */
140 static int ejs_param_data(MprVarHandle eid, int argc, char **argv)
141 {
142         struct param_context *ctx;
143         struct MprVar ret;
144         struct param_section *sec;
145
146         if (argc != 0) {
147                 ejsSetErrorMsg(eid, "param.data does not take arguments");
148                 return -1;
149         }
150
151         ctx = mprGetThisPtr(eid, "param");
152         mprAssert(ctx);
153
154         ret = mprObject("array");
155
156         for (sec = ctx->sections; sec; sec = sec->next) {
157                 struct MprVar ps = mprObject("array");
158                 struct param *p;
159
160                 for (p = sec->parameters; p; p = p->next) {
161                         mprSetVar(&ps, p->name, mprString(p->value));
162                 }
163                 
164                 mprSetVar(&ret, sec->name, ps);
165         }
166
167         mpr_Return(eid, ret);
168         
169         return 0;
170 }
171
172 /*
173   load file
174   
175   ok = param.load(file);
176 */
177 static int ejs_param_load(MprVarHandle eid, int argc, char **argv)
178 {
179         struct param_context *ctx;
180         bool ret;
181
182         if (argc != 1) {
183                 ejsSetErrorMsg(eid, "param.load invalid argument count");
184                 return -1;
185         }
186
187         ctx = mprGetThisPtr(eid, "param");
188         mprAssert(ctx);
189
190         ret = param_read(ctx, argv[0]);
191         
192         mpr_Return(eid, mprCreateBoolVar(ret));
193         return 0;
194 }
195
196
197 /*
198   save file
199   
200   ok = param.save(file);
201 */
202 static int ejs_param_save(MprVarHandle eid, int argc, char **argv)
203 {
204         struct param_context *ctx;
205         bool ret;
206
207         if (argc != 1) {
208                 ejsSetErrorMsg(eid, "param.save invalid argument count");
209                 return -1;
210         }
211
212         ctx = mprGetThisPtr(eid, "param");
213         mprAssert(ctx);
214
215         ret = param_write(ctx, argv[0]);
216         
217         mpr_Return(eid, mprCreateBoolVar(ret));
218         return 0;
219 }
220
221 static void param_add_members(struct MprVar *obj)
222 {
223         mprSetStringCFunction(obj, "get", ejs_param_get);
224         mprSetStringCFunction(obj, "get_list", ejs_param_get_list);
225         mprSetCFunction(obj, "set", ejs_param_set);
226         mprSetStringCFunction(obj, "load", ejs_param_load);
227         mprSetStringCFunction(obj, "save", ejs_param_save);
228         mprSetStringCFunction(obj, "data", ejs_param_data);
229 }
230
231 /*
232   initialise param ejs subsystem
233 */
234 static int ejs_param_init(MprVarHandle eid, int argc, struct MprVar **argv)
235 {
236         struct MprVar *obj = mprInitObject(eid, "param", argc, argv);
237
238         mprSetPtrChild(obj, "param", param_init(mprMemCtx()));
239
240         param_add_members(obj);
241
242         return 0;
243 }
244
245 struct MprVar mprParam(struct param_context *ctx)
246 {
247         struct MprVar mpv = mprObject("param");
248         mprSetPtrChild(&mpv, "param", ctx);
249         param_add_members(&mpv);
250         return mpv;
251 }
252
253 /*
254   setup C functions that be called from ejs
255 */
256 void smb_setup_ejs_param(void)
257 {
258         ejsDefineCFunction(-1, "param_init", ejs_param_init, NULL, MPR_VAR_SCRIPT_HANDLE);
259 }