*/
#include "includes.h"
-#include "lib/ejs/ejs.h"
+#include "lib/appweb/ejs/ejs.h"
#include "lib/ldb/include/ldb.h"
+/*
+ return a default mpr object
+*/
+struct MprVar mprObject(const char *name)
+{
+ return ejsCreateObj(name && *name?name:"(NULL)", MPR_DEFAULT_HASH_SIZE);
+}
+
+/*
+ find a mpr component, allowing for sub objects, using the '.' convention
+*/
+ NTSTATUS mprGetVar(struct MprVar **v, const char *name)
+{
+ const char *p = strchr(name, '.');
+ char *objname;
+ NTSTATUS status;
+ if (p == NULL) {
+ *v = mprGetProperty(*v, name, NULL);
+ if (*v == NULL) {
+ DEBUG(1,("mprGetVar unable to find '%s'\n", name));
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ return NT_STATUS_OK;
+ }
+ objname = talloc_strndup(mprMemCtx(), name, p-name);
+ NT_STATUS_HAVE_NO_MEMORY(objname);
+ *v = mprGetProperty(*v, objname, NULL);
+ NT_STATUS_HAVE_NO_MEMORY(*v);
+ status = mprGetVar(v, p+1);
+ talloc_free(objname);
+ return status;
+}
+
+
+/*
+ set a mpr component, allowing for sub objects, using the '.' convention
+ destroys 'val' after setting
+*/
+ NTSTATUS mprSetVar(struct MprVar *v, const char *name, struct MprVar val)
+{
+ const char *p = strchr(name, '.');
+ char *objname;
+ struct MprVar *v2;
+ NTSTATUS status;
+ if (p == NULL) {
+ v2 = mprSetProperty(v, name, &val);
+ if (v2 == NULL) {
+ DEBUG(1,("mprSetVar unable to set '%s'\n", name));
+ return NT_STATUS_INVALID_PARAMETER_MIX;
+ }
+ mprDestroyVar(&val);
+ return NT_STATUS_OK;
+ }
+ objname = talloc_strndup(mprMemCtx(), name, p-name);
+ if (objname == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ v2 = mprGetProperty(v, objname, NULL);
+ if (v2 == NULL) {
+ mprSetVar(v, objname, mprObject(objname));
+ v2 = mprGetProperty(v, objname, NULL);
+ }
+ status = mprSetVar(v2, p+1, val);
+ talloc_free(objname);
+ return status;
+}
+
+
+
/*
add an indexed array element to a property
*/
-static void mprAddArray(struct MprVar *var, int i, struct MprVar v)
+ void mprAddArray(struct MprVar *var, int i, struct MprVar v)
{
char idx[16];
mprItoa(i, idx, sizeof(idx));
- mprCreateProperty(var, idx, &v);
+ mprSetVar(var, idx, v);
+ mprSetVar(var, "length", mprCreateIntegerVar(i+1));
}
/*
struct MprVar var;
int i;
- var = mprCreateObjVar(name, MPR_DEFAULT_HASH_SIZE);
+ var = mprObject(name);
for (i=0;list && list[i];i++) {
- mprAddArray(&var, i, mprCreateStringVar(list[i], 1));
+ mprAddArray(&var, i, mprString(list[i]));
+ }
+ if (i==0) {
+ mprSetVar(&var, "length", mprCreateIntegerVar(i));
}
return var;
}
+/*
+ construct a MprVar from a string, using NULL if needed
+*/
+struct MprVar mprString(const char *s)
+{
+ if (s == NULL) {
+ return mprCreatePtrVar(NULL);
+ }
+ return mprCreateStringVar(s, True);
+}
+
/*
construct a string MprVar from a lump of data
*/
if (s == NULL) {
return mprCreateUndefinedVar();
}
- var = mprCreateStringVar(s, 1);
+ var = mprString(s);
talloc_free(s);
return var;
}
/*
turn a ldb_message into a ejs object variable
*/
-struct MprVar mprLdbMessage(struct ldb_message *msg)
+static struct MprVar mprLdbMessage(struct ldb_context *ldb, struct ldb_message *msg)
{
struct MprVar var;
int i;
need a special case for the single value case */
const char *multivalued[] = { "objectClass", "memberOf", "privilege",
"member", NULL };
- struct MprVar val;
- var = mprCreateObjVar(msg->dn, MPR_DEFAULT_HASH_SIZE);
+ var = mprObject(ldb_dn_linearize(msg, msg->dn));
for (i=0;i<msg->num_elements;i++) {
struct ldb_message_element *el = &msg->elements[i];
+ struct MprVar val;
+ const struct ldb_attrib_handler *attr;
+ struct ldb_val v;
+
+ attr = ldb_attrib_handler(ldb, el->name);
+ if (attr == NULL) {
+ goto failed;
+ }
+
if (el->num_values == 1 &&
!str_list_check_ci(multivalued, el->name)) {
- val = mprData(el->values[0].data, el->values[0].length);
+ if (attr->ldif_write_fn(ldb, msg, &el->values[0], &v) != 0) {
+ goto failed;
+ }
+ val = mprData(v.data, v.length);
} else {
int j;
- val = mprCreateObjVar(el->name, MPR_DEFAULT_HASH_SIZE);
+ val = mprObject(el->name);
for (j=0;j<el->num_values;j++) {
- mprAddArray(&val, j,
- mprData(el->values[j].data,
- el->values[j].length));
+ if (attr->ldif_write_fn(ldb, msg,
+ &el->values[j], &v) != 0) {
+ goto failed;
+ }
+ mprAddArray(&val, j, mprData(v.data, v.length));
}
}
- mprCreateProperty(&var, el->name, &val);
+ mprSetVar(&var, el->name, val);
}
/* add the dn if it is not already specified */
if (mprGetProperty(&var, "dn", 0) == 0) {
- val = mprCreateStringVar(msg->dn, 1);
- mprCreateProperty(&var, "dn", &val);
+ mprSetVar(&var, "dn", mprString(ldb_dn_linearize(msg, msg->dn)));
}
return var;
+failed:
+ return mprCreateUndefinedVar();
}
/*
turn an array of ldb_messages into a ejs object variable
*/
-struct MprVar mprLdbArray(struct ldb_message **msg, int count, const char *name)
+struct MprVar mprLdbArray(struct ldb_context *ldb,
+ struct ldb_message **msg, int count, const char *name)
{
struct MprVar res;
int i;
- res = mprCreateObjVar(name?name:"(NULL)", MPR_DEFAULT_HASH_SIZE);
+ res = mprObject(name);
for (i=0;i<count;i++) {
- mprAddArray(&res, i, mprLdbMessage(msg[i]));
+ mprAddArray(&res, i, mprLdbMessage(ldb, msg[i]));
+ }
+ if (i==0) {
+ mprSetVar(&res, "length", mprCreateIntegerVar(0));
}
- mprSetPropertyValue(&res, "length", mprCreateIntegerVar(i));
- return res;
+ return res;
}
*/
const char *mprToString(const struct MprVar *v)
{
- if (v->type != MPR_TYPE_STRING) return NULL;
+ if (!mprVarIsString(v->type)) return NULL;
return v->string;
}
*/
int mprToInt(const struct MprVar *v)
{
- if (v->type != MPR_TYPE_INT) return 0;
- return v->integer;
+ if (!mprVarIsNumber(v->type)) return 0;
+ return mprVarToNumber(v);
}
/*
return list;
}
+
+/*
+ turn a MprVar object variable into a string list
+ this assumes the object variable is an array of strings
+*/
+const char **mprToArray(TALLOC_CTX *mem_ctx, struct MprVar *v)
+{
+ const char **list = NULL;
+ struct MprVar *len;
+ int length, i;
+
+ len = mprGetProperty(v, "length", NULL);
+ if (len == NULL) {
+ return NULL;
+ }
+ length = mprToInt(len);
+
+ for (i=0;i<length;i++) {
+ char idx[16];
+ struct MprVar *vs;
+ mprItoa(i, idx, sizeof(idx));
+ vs = mprGetProperty(v, idx, NULL);
+ if (vs == NULL || vs->type != MPR_TYPE_STRING) {
+ talloc_free(list);
+ return NULL;
+ }
+ list = str_list_add(list, mprToString(vs));
+ }
+ talloc_steal(mem_ctx, list);
+ return list;
+}
+
/*
turn a NTSTATUS into a MprVar object with lots of funky properties
*/
struct MprVar mprNTSTATUS(NTSTATUS status)
{
- struct MprVar res, val;
+ struct MprVar res;
+
+ res = mprObject("ntstatus");
- res = mprCreateObjVar("ntstatus", MPR_DEFAULT_HASH_SIZE);
+ mprSetVar(&res, "errstr", mprString(nt_errstr(status)));
+ mprSetVar(&res, "v", mprCreateIntegerVar(NT_STATUS_V(status)));
+ mprSetVar(&res, "is_ok", mprCreateBoolVar(NT_STATUS_IS_OK(status)));
+ mprSetVar(&res, "is_err", mprCreateBoolVar(NT_STATUS_IS_ERR(status)));
- val = mprCreateStringVar(nt_errstr(status), 1);
- mprCreateProperty(&res, "errstr", &val);
+ return res;
+}
- val = mprCreateIntegerVar(NT_STATUS_V(status));
- mprCreateProperty(&res, "v", &val);
+/*
+ create a data-blob in a mpr variable
+*/
+struct MprVar mprDataBlob(DATA_BLOB blob)
+{
+ struct MprVar res;
+ DATA_BLOB *pblob = talloc(mprMemCtx(), DATA_BLOB);
+ *pblob = data_blob_talloc(pblob, blob.data, blob.length);
- val = mprCreateBoolVar(NT_STATUS_IS_OK(status));
- mprCreateProperty(&res, "is_ok", &val);
+ res = mprObject("DATA_BLOB");
- val = mprCreateBoolVar(NT_STATUS_IS_ERR(status));
- mprCreateProperty(&res, "is_err", &val);
+ mprSetVar(&res, "size", mprCreateIntegerVar(blob.length));
+ mprSetPtrChild(&res, "blob", pblob);
return res;
}
+/*
+ return a data blob from a mpr var created using mprDataBlob
+*/
+struct data_blob *mprToDataBlob(struct MprVar *v)
+{
+ return talloc_get_type(mprGetPtr(v, "blob"), struct data_blob);
+}
+
/*
turn a WERROR into a MprVar object with lots of funky properties
*/
struct MprVar mprWERROR(WERROR status)
{
- struct MprVar res, val;
-
- res = mprCreateObjVar("werror", MPR_DEFAULT_HASH_SIZE);
-
- val = mprCreateStringVar(win_errstr(status), 1);
- mprCreateProperty(&res, "errstr", &val);
-
- val = mprCreateIntegerVar(W_ERROR_V(status));
- mprCreateProperty(&res, "v", &val);
+ struct MprVar res;
- val = mprCreateBoolVar(W_ERROR_IS_OK(status));
- mprCreateProperty(&res, "is_ok", &val);
+ res = mprObject("werror");
- val = mprCreateBoolVar(True);
- mprCreateProperty(&res, "is_err", &val);
+ mprSetVar(&res, "errstr", mprString(win_errstr(status)));
+ mprSetVar(&res, "v", mprCreateIntegerVar(W_ERROR_V(status)));
+ mprSetVar(&res, "is_ok", mprCreateBoolVar(W_ERROR_IS_OK(status)));
+ mprSetVar(&res, "is_err", mprCreateBoolVar(!W_ERROR_IS_OK(status)));
return res;
}
*/
void mprSetPtr(struct MprVar *v, const char *propname, const void *p)
{
- struct MprVar val = mprCreatePtrVar(discard_const(p), NULL);
- mprCreateProperty(v, propname, &val);
+ mprSetVar(v, propname, mprCreatePtrVar(discard_const(p)));
+}
+
+/*
+ set a pointer in a existing MprVar, freeing it when the property goes away
+*/
+void mprSetPtrChild(struct MprVar *v, const char *propname, const void *p)
+{
+ mprSetVar(v, propname, mprCreatePtrVar(discard_const(p)));
+ v = mprGetProperty(v, propname, NULL);
+ v->allocatedData = 1;
+ talloc_steal(mprMemCtx(), p);
}
/*
}
return val->ptr;
}
+
+/*
+ set the return value then free the variable
+*/
+ void mpr_Return(int eid, struct MprVar v)
+{
+ ejsSetReturnValue(eid, v);
+ mprDestroyVar(&v);
+}
+
+/*
+ set the return value then free the variable
+*/
+void mpr_ReturnString(int eid, const char *s)
+{
+ mpr_Return(eid, mprString(s));
+}
+
+
+/*
+ set a C function in a variable
+*/
+ void mprSetCFunction(struct MprVar *obj, const char *name, MprCFunction fn)
+{
+ mprSetVar(obj, name, mprCreateCFunctionVar(fn, obj, MPR_VAR_SCRIPT_HANDLE));
+}
+
+/*
+ set a string C function in a variable
+*/
+ void mprSetStringCFunction(struct MprVar *obj, const char *name, MprStringCFunction fn)
+{
+ mprSetVar(obj, name, mprCreateStringCFunctionVar(fn, obj, MPR_VAR_SCRIPT_HANDLE));
+}
+
+/*
+ get a pointer in the current object
+*/
+void *mprGetThisPtr(int eid, const char *name)
+{
+ struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
+ return mprGetPtr(this, name);
+}
+
+/*
+ set a pointer as a child of the local object
+*/
+void mprSetThisPtr(int eid, const char *name, void *ptr)
+{
+ struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
+ mprSetPtrChild(this, name, ptr);
+}
+
+/*
+ used by object xxx_init() routines to allow for the caller
+ to supply a pre-existing object to add properties to,
+ or create a new object. This makes inheritance easy
+*/
+struct MprVar *mprInitObject(int eid, const char *name, int argc, struct MprVar **argv)
+{
+ if (argc > 0 && mprVarIsObject(argv[0]->type)) {
+ return argv[0];
+ }
+ mpr_Return(eid, mprObject(name));
+ return ejsGetReturnValue(eid);
+}