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