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