e921b114757442fbe24820e4c81c9dddd422adb0
[ira/wip.git] / source / scripting / ejs / mprutil.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    utility functions for manipulating mpr variables in ejs calls
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 "lib/appweb/ejs/ejs.h"
25 #include "lib/ldb/include/ldb.h"
26 #include "scripting/ejs/smbcalls.h"
27
28 /*
29   return a default mpr object
30 */
31 struct MprVar mprObject(const char *name)
32 {
33         return ejsCreateObj(name && *name?name:"(NULL)", MPR_DEFAULT_HASH_SIZE);
34 }
35
36 /*
37   return a empty mpr array
38 */
39 struct MprVar mprArray(const char *name)
40 {
41         return ejsCreateArray(name && *name?name:"(NULL)", 0);
42 }
43
44 /*
45   find a mpr component, allowing for sub objects, using the '.' convention
46 */
47  NTSTATUS mprGetVar(struct MprVar **v, const char *name)
48 {
49         const char *p = strchr(name, '.');
50         char *objname;
51         NTSTATUS status;
52         if (p == NULL) {
53                 *v = mprGetProperty(*v, name, NULL);
54                 if (*v == NULL) {
55                         DEBUG(1,("mprGetVar unable to find '%s'\n", name));
56                         return NT_STATUS_INVALID_PARAMETER;
57                 }
58                 return NT_STATUS_OK;
59         }
60         objname = talloc_strndup(mprMemCtx(), name, p-name);
61         NT_STATUS_HAVE_NO_MEMORY(objname);
62         *v = mprGetProperty(*v, objname, NULL);
63         NT_STATUS_HAVE_NO_MEMORY(*v);
64         status = mprGetVar(v, p+1);
65         talloc_free(objname);
66         return status;
67 }
68
69
70 /*
71   set a mpr component, allowing for sub objects, using the '.' convention
72   destroys 'val' after setting
73 */
74  NTSTATUS mprSetVar(struct MprVar *v, const char *name, struct MprVar val)
75 {
76         const char *p = strchr(name, '.');
77         char *objname;
78         struct MprVar *v2;
79         NTSTATUS status;
80         if (p == NULL) {
81                 v2 = mprSetProperty(v, name, &val);
82                 if (v2 == NULL) {
83                         DEBUG(1,("mprSetVar unable to set '%s'\n", name));
84                         return NT_STATUS_INVALID_PARAMETER_MIX;
85                 }
86                 mprDestroyVar(&val);
87                 return NT_STATUS_OK;
88         }
89         objname = talloc_strndup(mprMemCtx(), name, p-name);
90         if (objname == NULL) {
91                 return NT_STATUS_NO_MEMORY;
92         }
93         v2 = mprGetProperty(v, objname, NULL);
94         if (v2 == NULL) {
95                 mprSetVar(v, objname, mprObject(objname));
96                 v2 = mprGetProperty(v, objname, NULL);
97         }
98         status = mprSetVar(v2, p+1, val);
99         talloc_free(objname);
100         return status;
101 }
102
103
104
105 /*
106   add an indexed array element to a property
107 */
108  void mprAddArray(struct MprVar *var, int i, struct MprVar v)
109 {
110         char idx[16];
111         mprItoa(i, idx, sizeof(idx));
112         mprSetVar(var, idx, v);
113 }
114
115 /*
116   construct a MprVar from a list
117 */
118 struct MprVar mprList(const char *name, const char **list)
119 {
120         struct MprVar var;
121         int i;
122
123         var = mprArray(name);
124         for (i=0;list && list[i];i++) {
125                 mprAddArray(&var, i, mprString(list[i]));
126         }
127         return var;
128 }
129
130 /*
131   construct a MprVar from a string, using NULL if needed
132 */
133 struct MprVar mprString(const char *s)
134 {
135         if (s == NULL) {
136                 return mprCreatePtrVar(NULL);
137         }
138         return mprCreateStringVar(s, True);
139 }
140
141 /*
142   construct a string MprVar from a lump of data
143 */
144 struct MprVar mprData(const uint8_t *p, size_t length)
145 {
146         struct MprVar var;
147         char *s = talloc_strndup(mprMemCtx(), (const char *)p, length);
148         if (s == NULL) {
149                 return mprCreateUndefinedVar();
150         }
151         var = mprString(s);
152         talloc_free(s);
153         return var;
154 }
155
156 /*
157   turn a ldb_message into a ejs object variable
158 */
159 static struct MprVar mprLdbMessage(struct ldb_context *ldb, struct ldb_message *msg)
160 {
161         struct MprVar var;
162         int i;
163         /* we force some attributes to always be an array in the
164            returned structure. This makes the scripting easier, as you don't 
165            need a special case for the single value case */
166         const char *multivalued[] = { "objectClass", "memberOf", "privilege", 
167                                             "member", NULL };
168
169         var = mprObject(ldb_dn_linearize(msg, msg->dn));
170
171         for (i=0;i<msg->num_elements;i++) {
172                 struct ldb_message_element *el = &msg->elements[i];
173                 struct MprVar val;
174                 const struct ldb_attrib_handler *attr;
175                 struct ldb_val v;
176
177                 attr = ldb_attrib_handler(ldb, el->name);
178                 if (attr == NULL) {
179                         goto failed;
180                 }
181
182                 if (el->num_values == 1 &&
183                     !str_list_check_ci(multivalued, el->name)) {
184                         if (attr->ldif_write_fn(ldb, msg, &el->values[0], &v) != 0) {
185                                 goto failed;
186                         }
187                         /* FIXME: nasty hack, remove me when ejs will support
188                          * arbitrary string and does not truncate on \0 */
189                         if (strlen((char *)v.data) != v.length) {
190                                 val = mprDataBlob(v);
191                         } else {
192                                 val = mprData(v.data, v.length);
193                         }
194                 } else {
195                         int j;
196                         val = mprArray(el->name);
197                         for (j=0;j<el->num_values;j++) {
198                                 if (attr->ldif_write_fn(ldb, msg, 
199                                                         &el->values[j], &v) != 0) {
200                                         goto failed;
201                                 }
202                                 /* FIXME: nasty hack, remove me when ejs will support
203                                  * arbitrary string and does not truncate on \0 */
204                                 if (strlen((char *)v.data) != v.length) {
205                                         mprAddArray(&val, j, mprDataBlob(v));
206                                 } else {
207                                         mprAddArray(&val, j, mprData(v.data, v.length));
208                                 }
209                         }
210                 }
211                 mprSetVar(&var, el->name, val);
212         }
213
214         /* add the dn if it is not already specified */
215         if (mprGetProperty(&var, "dn", 0) == 0) {
216                 mprSetVar(&var, "dn", mprString(ldb_dn_linearize(msg, msg->dn)));
217         }
218         
219         return var;             
220 failed:
221         return mprCreateUndefinedVar();
222 }
223
224
225 /*
226   turn an array of ldb_messages into a ejs object variable
227 */
228 struct MprVar mprLdbArray(struct ldb_context *ldb, 
229                           struct ldb_message **msg, int count, const char *name)
230 {
231         struct MprVar res;
232         int i;
233
234         res = mprArray(name);
235         for (i=0;i<count;i++) {
236                 mprAddArray(&res, i, mprLdbMessage(ldb, msg[i]));
237         }
238         return res;
239 }
240
241
242 /*
243   turn a MprVar string variable into a const char *
244  */
245 const char *mprToString(struct MprVar *v)
246 {
247         if (v->trigger) {
248                 mprReadProperty(v, 0);
249         }
250         if (!mprVarIsString(v->type)) return NULL;
251         return v->string;
252 }
253
254 /*
255   turn a MprVar integer variable into an int
256  */
257 int mprToInt(struct MprVar *v)
258 {
259         if (v->trigger) {
260                 mprReadProperty(v, 0);
261         }
262         if (!mprVarIsNumber(v->type)) return 0;
263         return mprVarToNumber(v);
264 }
265
266 /*
267   turn a MprVar object variable into a string list
268   this assumes the object variable consists only of strings
269 */
270 const char **mprToList(TALLOC_CTX *mem_ctx, struct MprVar *v)
271 {
272         const char **list = NULL;
273         struct MprVar *el;
274
275         if (v->type != MPR_TYPE_OBJECT ||
276             v->properties == NULL) {
277                 return NULL;
278         }
279         for (el=mprGetFirstProperty(v, MPR_ENUM_DATA);
280              el;
281              el=mprGetNextProperty(v, el, MPR_ENUM_DATA)) {
282                 const char *s = mprToString(el);
283                 if (s) {
284                         list = str_list_add(list, s);
285                 }
286         }
287         talloc_steal(mem_ctx, list);
288         return list;
289 }
290
291
292 /*
293   turn a MprVar object variable into a string list
294   this assumes the object variable is an array of strings
295 */
296 const char **mprToArray(TALLOC_CTX *mem_ctx, struct MprVar *v)
297 {
298         const char **list = NULL;
299         struct MprVar *len;
300         int length, i;
301
302         len = mprGetProperty(v, "length", NULL);
303         if (len == NULL) {
304                 return NULL;
305         }
306         length = mprToInt(len);
307
308         for (i=0;i<length;i++) {
309                 char idx[16];
310                 struct MprVar *vs;
311                 mprItoa(i, idx, sizeof(idx));           
312                 vs = mprGetProperty(v, idx, NULL);
313                 if (vs == NULL || vs->type != MPR_TYPE_STRING) {
314                         talloc_free(list);
315                         return NULL;
316                 }
317                 list = str_list_add(list, mprToString(vs));
318         }
319         talloc_steal(mem_ctx, list);
320         return list;
321 }
322
323 /*
324   turn a NTSTATUS into a MprVar object with lots of funky properties
325 */
326 struct MprVar mprNTSTATUS(NTSTATUS status)
327 {
328         struct MprVar res;
329
330         res = mprObject("ntstatus");
331
332         mprSetVar(&res, "errstr", mprString(nt_errstr(status)));
333         mprSetVar(&res, "v", mprCreateIntegerVar(NT_STATUS_V(status)));
334         mprSetVar(&res, "is_ok", mprCreateBoolVar(NT_STATUS_IS_OK(status)));
335         mprSetVar(&res, "is_err", mprCreateBoolVar(NT_STATUS_IS_ERR(status)));
336
337         return res;
338 }
339
340 /*
341   create a data-blob in a mpr variable
342 */
343 struct MprVar mprDataBlob(DATA_BLOB blob)
344 {
345         struct MprVar res;
346         struct datablob *pblob = talloc(mprMemCtx(), struct datablob);
347         *pblob = data_blob_talloc(pblob, blob.data, blob.length);
348
349         res = mprObject("DATA_BLOB");
350
351         mprSetVar(&res, "size", mprCreateIntegerVar(blob.length));
352         mprSetPtrChild(&res, "blob", pblob);
353
354         return res;
355 }
356
357 /*
358   return a data blob from a mpr var created using mprDataBlob
359 */
360 struct datablob *mprToDataBlob(struct MprVar *v)
361 {
362         return talloc_get_type(mprGetPtr(v, "blob"), struct datablob);
363 }
364
365 /*
366   turn a WERROR into a MprVar object with lots of funky properties
367 */
368 struct MprVar mprWERROR(WERROR status)
369 {
370         struct MprVar res;
371
372         res = mprObject("werror");
373
374         mprSetVar(&res, "errstr", mprString(win_errstr(status)));
375         mprSetVar(&res, "v", mprCreateIntegerVar(W_ERROR_V(status)));
376         mprSetVar(&res, "is_ok", mprCreateBoolVar(W_ERROR_IS_OK(status)));
377         mprSetVar(&res, "is_err", mprCreateBoolVar(!W_ERROR_IS_OK(status)));
378
379         return res;
380 }
381
382
383 /*
384   set a pointer in a existing MprVar
385 */
386 void mprSetPtr(struct MprVar *v, const char *propname, const void *p)
387 {
388         mprSetVar(v, propname, mprCreatePtrVar(discard_const(p)));
389 }
390
391 /*
392   set a pointer in a existing MprVar, freeing it when the property goes away
393 */
394 void mprSetPtrChild(struct MprVar *v, const char *propname, const void *p)
395 {
396         mprSetVar(v, propname, mprCreatePtrVar(discard_const(p)));
397         v = mprGetProperty(v, propname, NULL);
398         v->allocatedData = 1;
399         talloc_steal(mprMemCtx(), p);
400 }
401
402 /*
403   get a pointer from a MprVar
404 */
405 void *mprGetPtr(struct MprVar *v, const char *propname)
406 {
407         struct MprVar *val;
408         val = mprGetProperty(v, propname, NULL);
409         if (val == NULL) {
410                 return NULL;
411         }
412         if (val->type != MPR_TYPE_PTR) {
413                 return NULL;
414         }
415         return val->ptr;
416 }
417
418 /*
419   set the return value then free the variable
420 */
421  void mpr_Return(int eid, struct MprVar v)
422
423         ejsSetReturnValue(eid, v);
424         mprDestroyVar(&v);
425 }
426
427 /*
428   set the return value then free the variable
429 */
430 void mpr_ReturnString(int eid, const char *s)
431
432         mpr_Return(eid, mprString(s));
433 }
434
435
436 /*
437   set a C function in a variable
438 */
439  void mprSetCFunction(struct MprVar *obj, const char *name, MprCFunction fn)
440 {
441         mprSetVar(obj, name, mprCreateCFunctionVar(fn, obj, MPR_VAR_SCRIPT_HANDLE));
442 }
443
444 /*
445   set a string C function in a variable
446 */
447  void mprSetStringCFunction(struct MprVar *obj, const char *name, MprStringCFunction fn)
448 {
449         mprSetVar(obj, name, mprCreateStringCFunctionVar(fn, obj, MPR_VAR_SCRIPT_HANDLE));
450 }
451
452 /*
453   get a pointer in the current object
454 */
455 void *mprGetThisPtr(int eid, const char *name)
456 {
457         struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
458         return mprGetPtr(this, name);
459 }
460
461 /*
462   set a pointer as a child of the local object
463 */
464 void mprSetThisPtr(int eid, const char *name, void *ptr)
465 {
466         struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
467         mprSetPtrChild(this, name, ptr);
468 }
469
470 /*
471   used by object xxx_init() routines to allow for the caller
472   to supply a pre-existing object to add properties to,
473   or create a new object. This makes inheritance easy
474 */
475 struct MprVar *mprInitObject(int eid, const char *name, int argc, struct MprVar **argv)
476 {
477         if (argc > 0 && mprVarIsObject(argv[0]->type)) {
478                 return argv[0];
479         }
480         mpr_Return(eid, mprObject(name));
481         return ejsGetReturnValue(eid);
482 }