d886d1a5665f7e677c2a146812773f34bc40ebcd
[kai/samba.git] / services / samba / ldb.esp
1 <%
2 /*
3  * Copyright:
4  *   (C) 2006 by Derrell Lipman
5  *       All rights reserved
6  *
7  * License:
8  *   LGPL 2.1: http://creativecommons.org/licenses/LGPL/2.1/
9  */
10
11 /*
12  * JSON-RPC mappings to the ldb ejs functions
13  */
14
15 /* We'll be saving resources in the session */
16 jsonrpc_include("resources.esp");
17
18
19 /**
20  * Connect to a database
21  *
22  * @param params[0]
23  *   Database name
24  *
25  * @param params[1..n]
26  *   Option (e.g. "modules:modlist")
27  *
28  * @param error
29  *   An object of class JsonRpcError.
30  *
31  * @return
32  *   Success: The resource id to be used for future access to the database
33  *   Failure: -1
34  *
35  * @note
36  *   Credentials or session_info may be set up first.
37  */
38 function _connect(params, error)
39 {
40     if (params.length < 1)
41     {
42         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
43                        "usage: <db_name> [<option> ...]");
44         return error;
45     }
46
47     /* First, see if this database was already opened */
48     var resourceId = session.resources.find("ldb:" + params[0], error);
49     if (resourceId != undefined)
50     {
51         /* It was.  Give 'em the resource id */
52         return resourceId;
53     }
54
55     /* Database was not previously opened.  Connect to it. */
56     ldb = ldb_init();
57     var ret = ldb.connect(params[0]);
58     if (ret && ldb.db)
59     {
60         return session.resources.set(ldb, "ldb:" + params[0], error);
61     }
62     else
63     {
64         error.setError(-1, "ldb.connect failed");
65         return error;
66     }
67 }
68 jsonrpc.method.connect = _connect;
69
70
71 /**
72  * Close a database
73  *
74  * @param params[0]
75  *   The resource id of the open database, previously returned by connect()
76  *
77  * @param error
78  *   An object of class JsonRpcError.
79  *
80  * @return
81  *   Success: True
82  *   Failure: Will only fail with invalid parameters, and throws an error
83  */
84 function _close(params, error)
85 {
86     if (params.length != 1)
87     {
88         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
89                        "usage: <resource_id>");
90         return error;
91     }
92
93     ldb = session.resources.get(params[0], error);
94     if (ldb["__type"] == "_JsonRpcError")
95     {
96         return ldb;
97     }
98
99     var ret = ldb.close();
100     
101     /* If close succeeded, release the stored resource */
102     if (ret)
103     {
104         session.resources.release(params[0], error);
105     }
106
107     return ret;
108 }
109 jsonrpc.method.close = _close;
110
111
112 /**
113  * Begin a transaction
114  *
115  * @param params[0]
116  *   The resource id of the open database, previously returned by connect()
117  *
118  * @param error
119  *   An object of class JsonRpcError.
120  *
121  * @return
122  *   Success: True
123  *   Failure: False
124  */
125 function _transaction_start(params, error)
126 {
127     if (params.length != 1)
128     {
129         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
130                        "usage: <resource_id>");
131         return error;
132     }
133
134     ldb = session.resources.get(params[0], error);
135     if (ldb["__type"] == "_JsonRpcError")
136     {
137         return ldb;
138     }
139
140     return ldb.transaction_start();
141 }
142 jsonrpc.method.transaction_start = _transaction_start;
143
144
145 /**
146  * Cancel a transaction
147  *
148  * @param params[0]
149  *   The resource id of the open database, previously returned by connect()
150  *
151  * @param error
152  *   An object of class JsonRpcError.
153  *
154  * @return
155  *   Success: True
156  *   Failure: False
157  */
158 function _transaction_cancel(params, error)
159 {
160     if (params.length != 1)
161     {
162         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
163                        "usage: <resource_id>");
164         return error;
165     }
166
167     ldb = session.resources.get(params[0], error);
168     if (ldb["__type"] == "_JsonRpcError")
169     {
170         return ldb;
171     }
172
173     return ldb.transaction_cancel();
174 }
175 jsonrpc.method.transaction_cancel = _transaction_cancel;
176
177
178 /**
179  * Commit a transaction
180  *
181  * @param params[0]
182  *   The resource id of the open database, previously returned by connect()
183  *
184  * @param error
185  *   An object of class JsonRpcError.
186  *
187  * @return
188  *   Success: True
189  *   Failure: False
190  */
191 function _transaction_commit(params, error)
192 {
193     if (params.length != 1)
194     {
195         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
196                        "usage: <resource_id>");
197         return error;
198     }
199
200     ldb = session.resources.get(params[0], error);
201     if (ldb["__type"] == "_JsonRpcError")
202     {
203         return ldb;
204     }
205
206     return ldb.transaction_commit();
207 }
208 jsonrpc.method.transaction_commit = _transaction_commit;
209
210
211 /**
212  * Issue a Search request
213  *
214  * @param params[0]
215  *   The resource id of the open database, previously returned by connect()
216  *
217  * @param params[1]
218  *   Search expression
219  *
220  * @param params[2]
221  *   Base DN
222  *
223  * @param params[3]
224  *   Scope: "default", "base", "one" or "subtree"
225  *
226  * @param params[4]
227  *   Attributes: an array object
228  *
229  * @param error
230  *   An object of class JsonRpcError.
231  *
232  * @return
233  *   Success: found object
234  *   Failure: `undefined`
235  *
236  * @note
237  *   If params[4] is missing, assume no attributes
238  *   If params[3..4] are missing, also assume "default" scope
239  *   If params[2..4] are missing, also assume null base DN
240  */
241 function _search(params, error)
242 {
243     if (params.length < 2 || params.length > 5)
244     {
245         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
246                        "usage: " +
247                        "<resource_id> <expr> [<baseDN> [<scope> [<attrs>]]]");
248         return error;
249     }
250
251     ldb = session.resources.get(params[0], error);
252     if (ldb["__type"] == "_JsonRpcError")
253     {
254         return ldb;
255     }
256
257     /* Retrieve parameters */
258     var expr = params[1];
259     var baseDN = params[2];
260     var scope = params[3];
261     var attrs = params[4];
262
263     /* Fill in optional parameters */
264     if (params.length < 3) baseDN = null;
265     if (params.length < 4) scope = "one";
266     if (params.length < 5) attrs = null;
267
268     /* Determine scope value */
269     if (scope == "base")
270     {
271         scope = ldb.SCOPE_BASE;
272     }
273     else if (scope == "one")
274     {
275         scope = ldb.SCOPE_ONE;
276     }
277     else if (scope == "subtree")
278     {
279         scope = ldb.SCOPE_SUBTREE;
280     }
281     else if (scope == "default")
282     {
283         scope = ldb.SCOPE_DEFAULT;
284     }
285     else
286     {
287         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
288                        "invalid scope: " + scope);
289         return error;
290     }
291
292     return ldb.search(expr, baseDN, scope, attrs);
293 }
294 jsonrpc.method.search = _search;
295
296
297 /**
298  * Add data to the database
299  *
300  * @param params[0]
301  *   The resource id of the open database, previously returned by connect()
302  *
303  * @param params[1]
304  *   An LDIF string representing the data to be added
305  *
306  * @param error
307  *   An object of class JsonRpcError.
308  *
309  * @return
310  *   Success: True
311  *   Failure: False
312  */
313 function _add(params, error)
314 {
315     if (params.length != 2)
316     {
317         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
318                        "usage: <resource_id> <ldif>");
319         return error;
320     }
321
322     ldb = session.resources.get(params[0], error);
323     if (ldb["__type"] == "_JsonRpcError")
324     {
325         return ldb;
326     }
327
328     return ldb.add(params[1]);
329 }
330 jsonrpc.method.add = _add;
331
332
333 /**
334  * Modify data in the database
335  *
336  * @param params[0]
337  *   The resource id of the open database, previously returned by connect()
338  *
339  * @param params[1]
340  *   An LDIF string representing the data to be modified
341  *
342  * @param error
343  *   An object of class JsonRpcError.
344  *
345  * @return
346  *   Success: True
347  *   Failure: False
348  */
349 function _modify(params, error)
350 {
351     if (params.length != 2)
352     {
353         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
354                        "usage: <resource_id> <ldif>");
355         return error;
356     }
357
358     ldb = session.resources.get(params[0], error);
359     if (ldb["__type"] == "_JsonRpcError")
360     {
361         return ldb;
362     }
363
364     return ldb.modify(params[1]);
365 }
366 jsonrpc.method.modify = _modify;
367
368
369 /**
370  * Delete data from the database
371  *
372  * @param params[0]
373  *   The resource id of the open database, previously returned by connect()
374  *
375  * @param params[1]
376  *   The DN to be located and deleted
377  *
378  * @param error
379  *   An object of class JsonRpcError.
380  *
381  * @return
382  *   Success: True
383  *   Failure: False
384  */
385 function _del(params, error)
386 {
387     if (params.length != 2)
388     {
389         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
390                        "usage: <resource_id> <dn>");
391         return error;
392     }
393
394     ldb = session.resources.get(params[0], error);
395     if (ldb["__type"] == "_JsonRpcError")
396     {
397         return ldb;
398     }
399
400     return ldb.del(params[1]);
401 }
402 jsonrpc.method.del = _del;
403
404
405 /**
406  * Rename data in the database
407  *
408  * @param params[0]
409  *   The resource id of the open database, previously returned by connect()
410  *
411  * @param params[1]
412  *   The DN to be renamed
413  *
414  * @param params[2]
415  *   The new name for the DN being renamed
416  *
417  * @param error
418  *   An object of class JsonRpcError.
419  *
420  * @return
421  *   Success: True
422  *   Failure: False
423  */
424 function _rename(params, error)
425 {
426     if (params.length != 3)
427     {
428         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
429                        "usage: <resource_id> <old_dn> <new_dn>");
430         return error;
431     }
432
433     ldb = session.resources.get(params[0], error);
434     if (ldb["__type"] == "_JsonRpcError")
435     {
436         return ldb;
437     }
438
439     return ldb.rename(params[1], params[2]);
440 }
441 jsonrpc.method.rename = _rename;
442
443
444 /**
445  * Base64-encode a string
446  *
447  * @param params[0]
448  *   The resource id of the open database, previously returned by connect()
449  *
450  * @param params[1]
451  *   The string to be base64 encoded
452  *
453  * @param error
454  *   An object of class JsonRpcError.
455  *
456  * @return
457  *   Success: encoded string
458  *   Failure: `undefined`
459  */
460 function _base64encode(params, error)
461 {
462     if (params.length != 2)
463     {
464         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
465                        "usage: <resource_id> <string_to_be_encoded>");
466         return error;
467     }
468
469     ldb = session.resources.get(params[0], error);
470     if (ldb["__type"] == "_JsonRpcError")
471     {
472         return ldb;
473     }
474
475     return ldb.base64encode(params[1]);
476 }
477 jsonrpc.method.base64encode = _base64encode;
478
479
480 /**
481  * Base64-decode a string
482  *
483  * @param params[0]
484  *   The resource id of the open database, previously returned by connect()
485  *
486  * @param params[1]
487  *   The string to be base64 decoded
488  *
489  * @param error
490  *   An object of class JsonRpcError.
491  *
492  * @return
493  *   Success: decoded string
494  *   Failure: `undefined`
495  */
496 function _base64decode(params, error)
497 {
498     if (params.length != 2)
499     {
500         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
501                        "usage: <resource_id> <string_to_be_decoded>");
502         return error;
503     }
504
505     ldb = session.resources.get(params[0], error);
506     if (ldb["__type"] == "_JsonRpcError")
507     {
508         return ldb;
509     }
510
511     return ldb.base64decode(params[1]);
512 }
513 jsonrpc.method.base64decode = _base64decode;
514
515
516 /**
517  * escape a DN
518  *
519  * @param params[0]
520  *   The resource id of the open database, previously returned by connect()
521  *
522  * @param params[1]
523  *   The DN to be escaped
524  *
525  * @param error
526  *   An object of class JsonRpcError.
527  *
528  * @return
529  *   Success: escaped string
530  *   Failure: undefined
531  */
532 function _base64decode(params, error)
533 {
534     if (params.length != 2)
535     {
536         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
537                        "usage: <resource_id> <string_to_be_decoded>");
538         return error;
539     }
540
541     ldb = session.resources.get(params[0], error);
542     if (ldb["__type"] == "_JsonRpcError")
543     {
544         return ldb;
545     }
546
547     return ldb.base64decode(params[1]);
548 }
549 jsonrpc.method.base64decode = _base64decode;
550
551
552 /**
553  * Retrieve a description of the most recent error
554  *
555  * @param params[0]
556  *   The resource id of the open database, previously returned by connect()
557  *
558  * @param error
559  *   An object of class JsonRpcError.
560  *
561  * @return
562  *   The most recent error string for the ldb specified by the resource id
563  */
564 function _errstring(params, error)
565 {
566     if (params.length != 1)
567     {
568         error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch,
569                        "usage: <resource_id>");
570         return error;
571     }
572
573     ldb = session.resources.get(params[0], error);
574     if (ldb["__type"] == "_JsonRpcError")
575     {
576         return ldb;
577     }
578
579     return ldb.errstring();
580 }
581 jsonrpc.method.errstring = _errstring;
582
583
584
585
586 /*
587  * Local Variables:
588  * mode: c
589  * End:
590  */
591 %>