<% /* * Copyright: * (C) 2006 by Derrell Lipman * All rights reserved * * License: * LGPL 2.1: http://creativecommons.org/licenses/LGPL/2.1/ */ /* * JSON-RPC mappings to the ldb ejs functions */ /* We'll be saving resources in the session */ jsonrpc_include("resources.esp"); /** * Local function to determine if the requested database is one which we allow * access to. * * @param dbRequested * Name of the database which is being requested to be opened * * @return * true if access is allowed; false otherwise. */ function accessAllowed(dbRequested) { /* Databases allowed to connect to */ dbAllowed = new Array(); dbAllowed[dbAllowed.length] = "sam.ldb"; for (var i = 0; i < dbAllowed.length; i++) { if (dbRequested == dbAllowed[i]) { return true; } } return false; } /** * Connect to a database * * @param params[0] * Database name * * @param params[1..n] * Option (e.g. "modules:modlist") * * @param error * An object of class JsonRpcError. * * @return * Success: The resource id to be used for future access to the database * Failure: error event * * @note * Credentials or session_info may be set up first. */ function _connect(params, error) { if (params.length < 1) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: [ ...]"); return error; } /* First, see if this database was already opened */ var resourceId = session.resources.find("ldb:" + params[0], error); if (resourceId != undefined) { /* It was. Give 'em the resource id */ return resourceId; } /* Ensure that the database name is one that is allowed to be opened */ if (! accessAllowed(params[0])) { error.setError(-1, "Invalid or disallowed database name"); return error; } /* Get access to loadparm functions */ var lp = loadparm_init(); /* Determine the private directory */ var private_dir = lp.get("private dir"); /* Database was not previously opened. Connect to it. */ ldb = ldb_init(); var ret = ldb.connect(private_dir + "/" + params[0]); if (ret && ldb.db) { return session.resources.set(ldb, "ldb:" + params[0], error); } else { error.setError(-1, "ldb.connect failed"); return error; } } jsonrpc.method.connect = _connect; /** * Close a database * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: Will only fail with invalid parameters, and throws an error */ function _close(params, error) { if (params.length != 1) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } var ret = ldb.close(); /* If close succeeded, release the stored resource */ if (ret) { session.resources.release(params[0], error); } return ret; } jsonrpc.method.close = _close; /** * Begin a transaction * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _transaction_start(params, error) { if (params.length != 1) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.transaction_start(); } jsonrpc.method.transaction_start = _transaction_start; /** * Cancel a transaction * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _transaction_cancel(params, error) { if (params.length != 1) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.transaction_cancel(); } jsonrpc.method.transaction_cancel = _transaction_cancel; /** * Commit a transaction * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _transaction_commit(params, error) { if (params.length != 1) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.transaction_commit(); } jsonrpc.method.transaction_commit = _transaction_commit; /** * Issue a Search request * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * Search expression * * @param params[2] * Base DN * * @param params[3] * Scope: "default", "base", "one" or "subtree" * * @param params[4] * Attributes: an array object * * @param error * An object of class JsonRpcError. * * @return * Success: found object * Failure: `undefined` * * @note * If params[4] is missing, assume no attributes * If params[3..4] are missing, also assume "default" scope * If params[2..4] are missing, also assume null base DN */ function _search(params, error) { if (params.length < 2 || params.length > 5) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: " + " [ [ []]]"); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } /* Retrieve parameters */ var expr = params[1]; var baseDN = params[2]; var scope = params[3]; var attrs = params[4]; /* Fill in optional parameters */ if (params.length < 3) baseDN = null; if (params.length < 4) scope = "one"; if (params.length < 5) attrs = null; /* Determine scope value */ if (scope == "base") { scope = ldb.SCOPE_BASE; } else if (scope == "one") { scope = ldb.SCOPE_ONE; } else if (scope == "subtree") { scope = ldb.SCOPE_SUBTREE; } else if (scope == "default") { scope = ldb.SCOPE_DEFAULT; } else { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "invalid scope: " + scope); return error; } return ldb.search(expr, baseDN, scope, attrs); } jsonrpc.method.search = _search; /** * Add data to the database * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * An LDIF string representing the data to be added * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _add(params, error) { if (params.length != 2) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.add(params[1]); } jsonrpc.method.add = _add; /** * Modify data in the database * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * An LDIF string representing the data to be modified * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _modify(params, error) { if (params.length != 2) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.modify(params[1]); } jsonrpc.method.modify = _modify; /** * Delete data from the database * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * The DN to be located and deleted * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _del(params, error) { if (params.length != 2) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.del(params[1]); } jsonrpc.method.del = _del; /** * Rename data in the database * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * The DN to be renamed * * @param params[2] * The new name for the DN being renamed * * @param error * An object of class JsonRpcError. * * @return * Success: True * Failure: False */ function _rename(params, error) { if (params.length != 3) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.rename(params[1], params[2]); } jsonrpc.method.rename = _rename; /** * Base64-encode a string * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * The string to be base64 encoded * * @param error * An object of class JsonRpcError. * * @return * Success: encoded string * Failure: `undefined` */ function _base64encode(params, error) { if (params.length != 2) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.base64encode(params[1]); } jsonrpc.method.base64encode = _base64encode; /** * Base64-decode a string * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * The string to be base64 decoded * * @param error * An object of class JsonRpcError. * * @return * Success: decoded string * Failure: `undefined` */ function _base64decode(params, error) { if (params.length != 2) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.base64decode(params[1]); } jsonrpc.method.base64decode = _base64decode; /** * escape a DN * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param params[1] * The DN to be escaped * * @param error * An object of class JsonRpcError. * * @return * Success: escaped string * Failure: undefined */ function _base64decode(params, error) { if (params.length != 2) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.base64decode(params[1]); } jsonrpc.method.base64decode = _base64decode; /** * Retrieve a description of the most recent error * * @param params[0] * The resource id of the open database, previously returned by connect() * * @param error * An object of class JsonRpcError. * * @return * The most recent error string for the ldb specified by the resource id */ function _errstring(params, error) { if (params.length != 1) { error.setError(jsonrpc.Constant.ErrorCode.ParameterMismatch, "usage: "); return error; } ldb = session.resources.get(params[0], error); if (ldb["__type"] == "_JsonRpcError") { return ldb; } return ldb.errstring(); } jsonrpc.method.errstring = _errstring; /* * Local Variables: * mode: c * End: */ %>