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