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 %>