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