aaed14dd8cd408235e9aae1499ebecaa76129eb7
[sfrench/samba-autobuild/.git] / source4 / scripting / ejs / smbcalls_ldb.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 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 "lib/ldb/include/ldb.h"
27
28 /*
29   get the connected db
30  */
31 static struct ldb_context *ejs_get_ldb_context(int eid)
32 {
33         struct ldb_context *ldb = mprGetThisPtr(eid, "db");
34         if (ldb == NULL) {
35                 ejsSetErrorMsg(eid, "invalid ldb connection");
36         }
37         return ldb;
38 }
39
40 /*
41   perform an ldb search, returning an array of results
42
43   syntax:
44      res = ldb.search("expression");
45      var attrs = new Array("attr1", "attr2", "attr3");
46      ldb.search("expression", attrs);
47      var basedn = "cn=this,dc=is,dc=a,dc=test";
48      ldb.search("expression", attrs, ldb.SCOPE_SUBTREE, basedn);
49 */
50 static int ejs_ldbSearch(MprVarHandle eid, int argc, struct MprVar **argv)
51 {
52         const char **attrs = NULL;
53         const char *expression;
54         const char *base = NULL;
55         struct ldb_dn *basedn = NULL;
56         int scope = LDB_SCOPE_DEFAULT;
57         TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
58         struct ldb_context *ldb;
59         int ret;
60         struct ldb_message **res;
61
62         /* validate arguments */
63         if (argc < 1 || argc > 4) {
64                 ejsSetErrorMsg(eid, "ldb.search invalid number of arguments");
65                 goto failed;
66         }
67         if (argc > 3 && argv[3]->type != MPR_TYPE_OBJECT) {
68                 ejsSetErrorMsg(eid, "ldb.search attributes must be an object");
69                 goto failed;
70         }
71
72         ldb = ejs_get_ldb_context(eid);
73         if (ldb == NULL) {
74                 return -1;
75         }
76         
77         expression = mprToString(argv[0]);
78         if (argc > 1) {
79                 base = mprToString(argv[1]);
80                 /* a null basedn is valid */
81         }
82         if (base != NULL) {
83                 basedn = ldb_dn_explode(tmp_ctx, base);
84                 if (basedn == NULL) {
85                         ejsSetErrorMsg(eid, "ldb.search malformed base dn");
86                         goto failed;
87                 }
88         }
89         if (argc > 2) {
90                 scope = mprToInt(argv[2]);
91                 switch (scope) {
92                         case LDB_SCOPE_DEFAULT:
93                         case LDB_SCOPE_BASE:
94                         case LDB_SCOPE_ONELEVEL:
95                         case LDB_SCOPE_SUBTREE:
96                                 break; /* ok */
97                         default:
98                                 ejsSetErrorMsg(eid, "ldb.search invalid scope");
99                                 goto failed;
100                 }
101         }
102         if (argc > 3) {
103                 attrs = mprToList(tmp_ctx, argv[3]);
104         }
105         ret = ldb_search(ldb, basedn, scope, expression, attrs, &res);
106         if (ret == -1) {
107                 ejsSetErrorMsg(eid, "ldb.search failed - %s", ldb_errstring(ldb));
108                 mpr_Return(eid, mprCreateUndefinedVar());
109         } else {
110                 mpr_Return(eid, mprLdbArray(ldb, res, ret, "ldb_message"));
111         }
112
113         talloc_free(tmp_ctx);
114         return 0;
115
116 failed:
117         talloc_free(tmp_ctx);
118         return -1;
119 }
120
121
122 /*
123   perform an ldb add or modify
124 */
125 static int ejs_ldbAddModify(MprVarHandle eid, int argc, struct MprVar **argv,
126                             int fn(struct ldb_context *, const struct ldb_message *))
127 {
128         const char *ldifstring;
129         struct ldb_context *ldb;
130         struct ldb_ldif *ldif;
131         int ret = 0;
132
133         if (argc != 1) {
134                 ejsSetErrorMsg(eid, "ldb.add/modify invalid arguments");
135                 return -1;
136         }
137
138         ldifstring = mprToString(argv[0]);
139         if (ldifstring == NULL) {
140                 ejsSetErrorMsg(eid, "ldb.add/modify invalid arguments");
141                 return -1;
142         }
143
144         ldb = ejs_get_ldb_context(eid);
145         if (ldb == NULL) {
146                 return -1;
147         }
148
149         while ((ldif = ldb_ldif_read_string(ldb, &ldifstring))) {
150                 ret = fn(ldb, ldif->msg);
151                 talloc_free(ldif);
152                 if (ret != 0) break;
153         }
154
155         mpr_Return(eid, mprCreateBoolVar(ret == 0));
156         return 0;
157 }
158
159
160 /*
161   perform an ldb delete
162   usage:
163    ok = ldb.delete(dn);
164 */
165 static int ejs_ldbDelete(MprVarHandle eid, int argc, struct MprVar **argv)
166 {
167         struct ldb_dn *dn;
168         struct ldb_context *ldb;
169         int ret;
170
171         if (argc != 1) {
172                 ejsSetErrorMsg(eid, "ldb.delete invalid arguments");
173                 return -1;
174         }
175
176         ldb = ejs_get_ldb_context(eid);
177         if (ldb == NULL) {
178                 return -1;
179         }
180
181         dn = ldb_dn_explode(ldb, mprToString(argv[0]));
182         if (dn == NULL) {
183                 ejsSetErrorMsg(eid, "ldb.delete malformed dn");
184                 return -1;
185         }
186
187         ret = ldb_delete(ldb, dn);
188
189         talloc_free(dn);
190
191         mpr_Return(eid, mprCreateBoolVar(ret == 0));
192         return 0;
193 }
194
195 /*
196   perform an ldb rename
197   usage:
198    ok = ldb.rename(dn1, dn2);
199 */
200 static int ejs_ldbRename(MprVarHandle eid, int argc, struct MprVar **argv)
201 {
202         struct ldb_dn *dn1, *dn2;
203         struct ldb_context *ldb;
204         int ret;
205
206         if (argc != 2) {
207                 ejsSetErrorMsg(eid, "ldb.rename invalid arguments");
208                 return -1;
209         }
210
211         ldb = ejs_get_ldb_context(eid);
212         if (ldb == NULL) {
213                 return -1;
214         }
215
216         dn1 = ldb_dn_explode(ldb, mprToString(argv[0]));
217         dn2 = ldb_dn_explode(ldb, mprToString(argv[1]));
218         if (dn1 == NULL || dn2 == NULL) {
219                 ejsSetErrorMsg(eid, "ldb.rename invalid or malformed arguments");
220                 return -1;
221         }
222
223         ret = ldb_rename(ldb, dn1, dn2);
224
225         talloc_free(dn1);
226         talloc_free(dn2);
227
228         mpr_Return(eid, mprCreateBoolVar(ret == 0));
229         return 0;
230 }
231
232 /*
233   get last error message
234   usage:
235    ok = ldb.errstring();
236 */
237 static int ejs_ldbErrstring(MprVarHandle eid, int argc, struct MprVar **argv)
238 {
239         struct ldb_context *ldb;
240
241         ldb = ejs_get_ldb_context(eid);
242         if (ldb == NULL) {
243                 return -1;
244         }
245
246         mpr_Return(eid, mprString(ldb_errstring(ldb)));
247         return 0;
248 }
249
250 /*
251   perform an ldb modify
252
253   syntax:
254     ok = ldb.modify(ldifstring);
255 */
256 static int ejs_ldbAdd(MprVarHandle eid, int argc, struct MprVar **argv)
257 {
258         return ejs_ldbAddModify(eid, argc, argv, ldb_add);
259 }
260
261 /*
262   perform an ldb add
263
264   syntax:
265     ok = ldb.add(ldifstring);
266 */
267 static int ejs_ldbModify(MprVarHandle eid, int argc, struct MprVar **argv)
268 {
269         return ejs_ldbAddModify(eid, argc, argv, ldb_modify);
270 }
271
272 /*
273   connect to a database
274   usage:
275    ok = ldb.connect(dbfile);
276    ok = ldb.connect(dbfile, "modules:modlist");
277 */
278 static int ejs_ldbConnect(MprVarHandle eid, int argc, char **argv)
279 {
280         struct ldb_context *ldb;
281         const char *dbfile;
282
283         if (argc < 1) {
284                 ejsSetErrorMsg(eid, "ldb.connect invalid arguments");
285                 return -1;
286         }
287
288         dbfile = argv[0];
289
290         ldb = ldb_wrap_connect(mprMemCtx(), dbfile, 0, (const char **)(argv+1));
291         if (ldb == NULL) {
292                 ejsSetErrorMsg(eid, "ldb.connect failed to open %s", dbfile);
293         }
294
295         mprSetThisPtr(eid, "db", ldb);
296         mpr_Return(eid, mprCreateBoolVar(ldb != NULL));
297         return 0;
298 }
299
300
301 /*
302   initialise ldb ejs subsystem
303 */
304 static int ejs_ldb_init(MprVarHandle eid, int argc, struct MprVar **argv)
305 {
306         struct MprVar *ldb = mprInitObject(eid, "ldb", argc, argv);
307
308         mprSetStringCFunction(ldb, "connect", ejs_ldbConnect);
309         mprSetCFunction(ldb, "search", ejs_ldbSearch);
310         mprSetCFunction(ldb, "add", ejs_ldbAdd);
311         mprSetCFunction(ldb, "modify", ejs_ldbModify);
312         mprSetCFunction(ldb, "del", ejs_ldbDelete);
313         mprSetCFunction(ldb, "rename", ejs_ldbRename);
314         mprSetCFunction(ldb, "errstring", ejs_ldbErrstring);
315         mprSetVar(ldb, "SCOPE_BASE", mprCreateNumberVar(LDB_SCOPE_BASE));
316         mprSetVar(ldb, "SCOPE_ONE", mprCreateNumberVar(LDB_SCOPE_ONELEVEL));
317         mprSetVar(ldb, "SCOPE_SUBTREE", mprCreateNumberVar(LDB_SCOPE_SUBTREE));
318
319         return 0;
320 }
321
322
323 /*
324   setup C functions that be called from ejs
325 */
326 void smb_setup_ejs_ldb(void)
327 {
328         ejsDefineCFunction(-1, "ldb_init", ejs_ldb_init, NULL, MPR_VAR_SCRIPT_HANDLE);
329 }