static struct MprVar mprAliases(struct samba3_groupdb *db)
{
struct MprVar mpv = mprObject("array"), a, am;
int i, j;
for (i = 0; i < db->alias_count; i++) {
char *tmp;
a = mprObject("alias");
tmp = dom_sid_string(NULL, db->aliases[i].sid);
mprSetVar(&a, "sid", mprString(tmp));
talloc_free(tmp);
am = mprArray("array");
for (j = 0; j < db->aliases[i].member_count; j++) {
tmp = dom_sid_string(NULL, db->aliases[i].members[j]);
mprAddArray(&am, j, mprString(tmp));
talloc_free(tmp);
}
mprSetVar(&a, "members", am);
}
if (i == 0) {
mprSetVar(&mpv, "length", mprCreateIntegerVar(i));
}
return mpv;
}
static struct MprVar mprWinsEntries(struct samba3 *samba3)
{
struct MprVar mpv = mprArray("array");
int i, j;
for (i = 0; i < samba3->winsdb_count; i++) {
struct MprVar w = mprObject("wins_entry"), ips;
mprSetVar(&w, "name", mprString(samba3->winsdb_entries[i].name));
mprSetVar(&w, "nb_flags", mprCreateIntegerVar(samba3->winsdb_entries[i].nb_flags));
mprSetVar(&w, "type", mprCreateIntegerVar(samba3->winsdb_entries[i].type));
mprSetVar(&w, "ttl", mprCreateIntegerVar(samba3->winsdb_entries[i].ttl));
ips = mprObject("array");
for (j = 0; j < samba3->winsdb_entries[i].ip_count; j++) {
const char *addr;
addr = sys_inet_ntoa(samba3->winsdb_entries[i].ips[j]);
mprAddArray(&ips, j, mprString(addr));
}
mprSetVar(&w, "ips", ips);
mprAddArray(&mpv, i, w);
}
if (i == 0) {
mprSetVar(&mpv, "length", mprCreateIntegerVar(i));
}
return mpv;
}
static struct MprVar mprIdmapDb(struct samba3_idmapdb *db)
{
struct MprVar mpv = mprObject("idmapdb"), mps, mp;
int i;
mprSetVar(&mpv, "user_hwm", mprCreateIntegerVar(db->user_hwm));
mprSetVar(&mpv, "group_hwm", mprCreateIntegerVar(db->group_hwm));
mps = mprArray("array");
for (i = 0; i < db->mapping_count; i++) {
char *tmp;
mp = mprObject("idmap");
mprSetVar(&mp, "IDMAP_GROUP", mprCreateIntegerVar(IDMAP_GROUP));
mprSetVar(&mp, "IDMAP_USER", mprCreateIntegerVar(IDMAP_USER));
mprSetVar(&mp, "type", mprCreateIntegerVar(db->mappings[i].type));
mprSetVar(&mp, "unix_id", mprCreateIntegerVar(db->mappings[i].unix_id));
tmp = dom_sid_string(NULL, db->mappings[i].sid);
mprSetVar(&mp, "sid", mprString(tmp));
talloc_free(tmp);
mprAddArray(&mps, i, mp);
}
if (i == 0) {
mprSetVar(&mpv, "length", mprCreateIntegerVar(i));
}
mprSetVar(&mpv, "mappings", mps);
return mpv;
}
static struct MprVar mprDomainSecrets(struct samba3_domainsecrets *ds)
{
struct MprVar v, e = mprObject("domainsecrets");
char *tmp;
DATA_BLOB blob;
mprSetVar(&e, "name", mprString(ds->name));
tmp = dom_sid_string(NULL, &ds->sid);
mprSetVar(&e, "sid", mprString(tmp));
talloc_free(tmp);
tmp = GUID_string(NULL, &ds->guid);
mprSetVar(&e, "guid", mprString(tmp));
talloc_free(tmp);
mprSetVar(&e, "plaintext_pw", mprString(ds->plaintext_pw));
mprSetVar(&e, "last_change_time", mprCreateIntegerVar(ds->last_change_time));
mprSetVar(&e, "sec_channel_type", mprCreateIntegerVar(ds->sec_channel_type));
v = mprObject("hash_pw");
blob.data = ds->hash_pw.hash;
blob.length = 16;
mprSetVar(&v, "hash", mprDataBlob(blob));
mprSetVar(&v, "mod_time", mprCreateIntegerVar(ds->hash_pw.mod_time));
mprSetVar(&e, "hash_pw", v);
return e;
}
/*
Properties:
UserListCtx.Users[]
UserListCtx.ResumeIndex
UserListCtx.Count
UserListCtx.EndOfList
UserListCtx.Status
*/
struct MprVar mprUserListCtx(TALLOC_CTX *mem_ctx, struct libnet_UserList *list, NTSTATUS result)
{
const char *name = "UserListCtx";
NTSTATUS status;
bool endOfList;
struct MprVar mprListCtx, mprUserList;
struct MprVar mprUser, mprSid, mprUsername;
int i;
if (list == NULL || mem_ctx == NULL) {
mprListCtx = mprCreateNullVar();
goto done;
}
endOfList = (NT_STATUS_EQUAL(result, NT_STATUS_NO_MORE_ENTRIES) ||
NT_STATUS_IS_OK(result));
mprUserList = mprArray("Users");
for (i = 0; i < list->out.count; i++) {
struct userlist u = list->out.users[i];
/* get userlist fields */
mprSid = mprString(u.sid);
mprUsername = mprString(u.username);
/* create userlist object */
mprUser = mprObject("User");
mprSetVar(&mprUser, "Username", mprUsername);
mprSetVar(&mprUser, "SID", mprSid);
/* add the object to the array being constructed */
mprAddArray(&mprUserList, i, mprUser);
}
mprListCtx = mprObject(name);
status = mprSetVar(&mprListCtx, "Users", mprUserList);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprListCtx, "Count", mprCreateIntegerVar(list->out.count));
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprListCtx, "ResumeIndex", mprCreateIntegerVar((int)list->out.resume_index));
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprListCtx, "EndOfList", mprCreateBoolVar(endOfList));
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprListCtx, "Status", mprNTSTATUS(result));
done:
return mprListCtx;
}
static struct MprVar mprGroupMappings(struct samba3_groupdb *db)
{
struct MprVar mpv = mprArray("array"), g;
int i;
for (i = 0; i < db->groupmap_count; i++) {
char *tmp;
g = mprObject("group");
mprSetVar(&g, "gid", mprCreateIntegerVar(db->groupmappings[i].gid));
tmp = dom_sid_string(NULL, db->groupmappings[i].sid);
mprSetVar(&g, "sid", mprString(tmp));
talloc_free(tmp);
mprSetVar(&g, "sid_name_use", mprCreateIntegerVar(db->groupmappings[i].sid_name_use));
mprSetVar(&g, "nt_name", mprString(db->groupmappings[i].nt_name));
mprSetVar(&g, "comment", mprString(db->groupmappings[i].comment));
mprAddArray(&mpv, i, g);
}
if (i == 0) {
mprSetVar(&mpv, "length", mprCreateIntegerVar(i));
}
return mpv;
}
/*
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;
}
/*
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);
}
static int ejs_net_context(MprVarHandle eid, int argc, struct MprVar **argv)
{
TALLOC_CTX *event_mem_ctx = talloc_new(mprMemCtx());
struct cli_credentials *creds;
struct libnet_context *ctx;
struct MprVar obj;
struct event_context *ev;
if (!event_mem_ctx) {
ejsSetErrorMsg(eid, "talloc_new() failed");
return -1;
}
ev = event_context_find(event_mem_ctx);
ctx = libnet_context_init(ev);
/* IF we generated a new event context, it will be under here,
* and we need it to last as long as the libnet context, so
* make it a child */
talloc_steal(ctx, event_mem_ctx);
if (argc == 0 || (argc == 1 && argv[0]->type == MPR_TYPE_NULL)) {
creds = cli_credentials_init(ctx);
if (creds == NULL) {
ejsSetErrorMsg(eid, "cli_credential_init() failed");
talloc_free(ctx);
return -1;
}
cli_credentials_set_conf(creds);
cli_credentials_set_anonymous(creds);
} else if (argc == 1 && argv[0]->type == MPR_TYPE_OBJECT) {
/* get credential values from credentials object */
creds = mprGetPtr(argv[0], "creds");
if (creds == NULL) {
ejsSetErrorMsg(eid, "userAuth requires a 'creds' first parameter");
talloc_free(ctx);
return -1;
}
} else {
ejsSetErrorMsg(eid, "NetContext invalid arguments, this function requires an object.");
talloc_free(ctx);
return -1;
}
ctx->cred = creds;
obj = mprObject("NetCtx");
mprSetPtrChild(&obj, "ctx", ctx);
mprSetCFunction(&obj, "UserMgr", ejs_net_userman);
mprSetCFunction(&obj, "JoinDomain", ejs_net_join_domain);
mprSetCFunction(&obj, "SamSyncLdb", ejs_net_samsync_ldb);
mpr_Return(eid, obj);
return 0;
}
/*
Properties:
UserInfo.AccountName
UserInfo.FullName
UserInfo.Description
UserInfo.HomeDirectory
UserInfo.HomeDrive
UserInfo.Comment
UserInfo.LogonScript
UserInfo.AcctExpiry
UserInfo.AllowPasswordChange
UserInfo.ForcePasswordChange
*/
struct MprVar mprCreateUserInfo(TALLOC_CTX *mem_ctx, struct libnet_UserInfo *info)
{
const char *name = "UserInfo";
NTSTATUS status;
struct MprVar mprUserInfo;
struct MprVar mprAccountName, mprFullName, mprDescription;
struct MprVar mprHomeDir, mprHomeDrive, mprComment;
struct MprVar mprLogonScript;
struct MprVar mprAcctExpiry, mprAllowPassChange, mprForcePassChange;
if (info == NULL || mem_ctx == NULL) {
mprUserInfo = mprCreateNullVar();
goto done;
}
mprUserInfo = mprObject(name);
mprAccountName = mprString(info->out.account_name);
mprFullName = mprString(info->out.full_name);
mprDescription = mprString(info->out.description);
mprHomeDir = mprString(info->out.home_directory);
mprHomeDrive = mprString(info->out.home_drive);
mprComment = mprString(info->out.comment);
mprLogonScript = mprString(info->out.logon_script);
mprAcctExpiry = mprString(timestring(mem_ctx, info->out.acct_expiry->tv_sec));
mprAllowPassChange = mprString(timestring(mem_ctx, info->out.allow_password_change->tv_sec));
mprForcePassChange = mprString(timestring(mem_ctx, info->out.force_password_change->tv_sec));
status = mprSetVar(&mprUserInfo, "AccountName", mprAccountName);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "FullName", mprFullName);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "Description", mprDescription);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "HomeDirectory", mprHomeDir);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "HomeDrive", mprHomeDrive);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "Comment", mprComment);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "LogonScript", mprLogonScript);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "AcctExpiry", mprAcctExpiry);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "AllowPasswordChange", mprAllowPassChange);
if (!NT_STATUS_IS_OK(status)) goto done;
status = mprSetVar(&mprUserInfo, "ForcePasswordChange", mprForcePassChange);
if (!NT_STATUS_IS_OK(status)) goto done;
done:
return mprUserInfo;
}
/*
turn a WERROR into a MprVar object with lots of funky properties
*/
struct MprVar mprWERROR(WERROR status)
{
struct MprVar res;
res = mprObject("werror");
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;
}
/*
create a data-blob in a mpr variable
*/
struct MprVar mprDataBlob(DATA_BLOB blob)
{
struct MprVar res;
struct datablob *pblob = talloc(mprMemCtx(), struct datablob);
*pblob = data_blob_talloc(pblob, blob.data, blob.length);
res = mprObject("DATA_BLOB");
mprSetVar(&res, "size", mprCreateIntegerVar(blob.length));
mprSetPtrChild(&res, "blob", pblob);
return res;
}
/*
turn a NTSTATUS into a MprVar object with lots of funky properties
*/
struct MprVar mprNTSTATUS(NTSTATUS status)
{
struct MprVar res;
res = mprObject("ntstatus");
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)));
return res;
}
static struct MprVar mprSamAccounts(struct samba3 *samba3)
{
struct MprVar mpv = mprArray("array"), m;
int i;
for (i = 0; i < samba3->samaccount_count; i++) {
struct samba3_samaccount *a = &samba3->samaccounts[i];
DATA_BLOB blob;
m = mprObject("samba3_samaccount");
mprSetVar(&m, "logon_time", mprCreateIntegerVar(a->logon_time));
mprSetVar(&m, "logoff_time", mprCreateIntegerVar(a->logoff_time));
mprSetVar(&m, "kickoff_time", mprCreateIntegerVar(a->kickoff_time));
mprSetVar(&m, "bad_password_time", mprCreateIntegerVar(a->bad_password_time));
mprSetVar(&m, "pass_last_set_time", mprCreateIntegerVar(a->pass_last_set_time));
mprSetVar(&m, "pass_can_change_time", mprCreateIntegerVar(a->pass_can_change_time));
mprSetVar(&m, "pass_must_change_time", mprCreateIntegerVar(a->pass_must_change_time));
mprSetVar(&m, "user_rid", mprCreateIntegerVar(a->user_rid));
mprSetVar(&m, "group_rid", mprCreateIntegerVar(a->group_rid));
mprSetVar(&m, "acct_ctrl", mprCreateIntegerVar(a->acct_ctrl));
mprSetVar(&m, "logon_divs", mprCreateIntegerVar(a->logon_divs));
mprSetVar(&m, "bad_password_count", mprCreateIntegerVar(a->bad_password_count));
mprSetVar(&m, "logon_count", mprCreateIntegerVar(a->logon_count));
mprSetVar(&m, "username", mprString(a->username));
mprSetVar(&m, "domain", mprString(a->domain));
mprSetVar(&m, "nt_username", mprString(a->nt_username));
mprSetVar(&m, "dir_drive", mprString(a->dir_drive));
mprSetVar(&m, "munged_dial", mprString(a->munged_dial));
mprSetVar(&m, "fullname", mprString(a->fullname));
mprSetVar(&m, "homedir", mprString(a->homedir));
mprSetVar(&m, "logon_script", mprString(a->logon_script));
mprSetVar(&m, "profile_path", mprString(a->profile_path));
mprSetVar(&m, "acct_desc", mprString(a->acct_desc));
mprSetVar(&m, "workstations", mprString(a->workstations));
blob.length = 16;
blob.data = a->lm_pw.hash;
mprSetVar(&m, "lm_pw", mprDataBlob(blob));
blob.data = a->nt_pw.hash;
mprSetVar(&m, "nt_pw", mprDataBlob(blob));
mprAddArray(&mpv, i, m);
}
if (i == 0) {
mprSetVar(&mpv, "length", mprCreateIntegerVar(i));
}
return mpv;
}
static struct MprVar mprRegistry(struct samba3_regdb *reg)
{
struct MprVar mpv = mprObject("registry"), ks, vs, k, v;
int i, j;
ks = mprArray("array");
for (i = 0; i < reg->key_count; i++) {
k = mprObject("regkey");
mprSetVar(&k, "name", mprString(reg->keys[i].name));
vs = mprArray("array");
for (j = 0; j < reg->keys[i].value_count; j++) {
v = mprObject("regval");
mprSetVar(&v, "name", mprString(reg->keys[i].values[j].name));
mprSetVar(&v, "type", mprCreateIntegerVar(reg->keys[i].values[j].type));
mprSetVar(&v, "data", mprDataBlob(reg->keys[i].values[j].data));
mprAddArray(&vs, j, v);
}
mprSetVar(&k, "values", vs);
mprAddArray(&ks, i, k);
}
if (i == 0) {
mprSetVar(&ks, "length", mprCreateIntegerVar(i));
}
mprSetVar(&mpv, "keys", ks);
return mpv;
}
static struct MprVar mprPolicy(struct samba3_policy *pol)
{
struct MprVar mpv = mprObject("policy");
mprSetVar(&mpv, "min_password_length", mprCreateIntegerVar(pol->min_password_length));
mprSetVar(&mpv, "password_history", mprCreateIntegerVar(pol->password_history));
mprSetVar(&mpv, "user_must_logon_to_change_password", mprCreateIntegerVar(pol->user_must_logon_to_change_password));
mprSetVar(&mpv, "maximum_password_age", mprCreateIntegerVar(pol->maximum_password_age));
mprSetVar(&mpv, "minimum_password_age", mprCreateIntegerVar(pol->minimum_password_age));
mprSetVar(&mpv, "lockout_duration", mprCreateIntegerVar(pol->lockout_duration));
mprSetVar(&mpv, "reset_count_minutes", mprCreateIntegerVar(pol->reset_count_minutes));
mprSetVar(&mpv, "bad_lockout_minutes", mprCreateIntegerVar(pol->bad_lockout_minutes));
mprSetVar(&mpv, "disconnect_time", mprCreateIntegerVar(pol->disconnect_time));
mprSetVar(&mpv, "refuse_machine_password_change", mprCreateIntegerVar(pol->refuse_machine_password_change));
return mpv;
}
static int ejs_list(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_tree *tree;
char *mask;
uint16_t attribute;
MprVar result;
if (argc != 3) {
ejsSetErrorMsg(eid, "list(): invalid number of args");
return -1;
}
if (!IS_TREE_HANDLE(argv[0])) {
ejsSetErrorMsg(eid, "first arg is not a tree handle");
return -1;
}
tree = argv[0]->ptr;
if (!mprVarIsString(argv[1]->type)) {
ejsSetErrorMsg(eid, "arg 2 must be a string");
return -1;
}
mask = argv[1]->string;
if (!mprVarIsNumber(argv[2]->type)) {
ejsSetErrorMsg(eid, "arg 3 must be a number");
return -1;
}
attribute = mprVarToInteger(argv[2]);
result = mprObject("list");
smbcli_list(tree, mask, attribute, ejs_list_helper, &result);
mpr_Return(eid, result);
return 0;
}
static struct MprVar mprShares(struct samba3 *samba3)
{
struct MprVar mpv = mprArray("array"), s;
int i;
for (i = 0; i < samba3->share_count; i++) {
s = mprObject("share");
mprSetVar(&s, "name", mprString(samba3->shares[i].name));
/* FIXME: secdesc */
mprAddArray(&mpv, i, s);
}
if (i == 0) {
mprSetVar(&mpv, "length", mprCreateIntegerVar(i));
}
return mpv;
}
/*
initialise samba3 ejs subsystem
samba3 = samba3_read(libdir,smbconf)
*/
static int ejs_samba3_read(MprVarHandle eid, int argc, struct MprVar **argv)
{
struct MprVar mpv = mprObject("samba3");
struct samba3 *samba3;
NTSTATUS status;
if (argc < 2) {
ejsSetErrorMsg(eid, "samba3_read invalid arguments");
return -1;
}
status = samba3_read(mprToString(argv[0]), mprToString(argv[1]), mprMemCtx(), &samba3);
if (NT_STATUS_IS_ERR(status)) {
ejsSetErrorMsg(eid, "samba3_read: error");
return -1;
}
mprAssert(samba3);
mprSetPtrChild(&mpv, "samba3", samba3);
mprSetVar(&mpv, "winsentries", mprWinsEntries(samba3));
mprSetVar(&mpv, "samaccounts", mprSamAccounts(samba3));
mprSetVar(&mpv, "shares", mprShares(samba3));
mprSetVar(&mpv, "secrets", mprSecrets(&samba3->secrets));
mprSetVar(&mpv, "groupmappings", mprGroupMappings(&samba3->group));
mprSetVar(&mpv, "aliases", mprAliases(&samba3->group));
mprSetVar(&mpv, "idmapdb", mprIdmapDb(&samba3->idmap));
mprSetVar(&mpv, "policy", mprPolicy(&samba3->policy));
mprSetVar(&mpv, "registry", mprRegistry(&samba3->registry));
mprSetVar(&mpv, "configuration", mprParam(samba3->configuration));
mprSetCFunction(&mpv, "find_domainsecrets", ejs_find_domainsecrets);
mpr_Return(eid, mpv);
return 0;
}
/*
turn a ldb_message into a ejs object variable
*/
static struct MprVar mprLdbMessage(struct ldb_context *ldb, struct ldb_message *msg)
{
struct MprVar var;
int i;
/* we force some attributes to always be an array in the
returned structure. This makes the scripting easier, as you don't
need a special case for the single value case */
const char *multivalued[] = { "objectClass", "memberOf", "privilege",
"member", NULL };
var = mprObject(ldb_dn_alloc_linearized(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)) {
if (attr->ldif_write_fn(ldb, msg, &el->values[0], &v) != 0) {
goto failed;
}
/* FIXME: nasty hack, remove me when ejs will support
* arbitrary string and does not truncate on \0 */
if (strlen((char *)v.data) != v.length) {
val = mprDataBlob(v);
} else {
val = mprData(v.data, v.length);
}
} else {
int j;
val = mprArray(el->name);
for (j=0;j<el->num_values;j++) {
if (attr->ldif_write_fn(ldb, msg,
&el->values[j], &v) != 0) {
goto failed;
}
/* FIXME: nasty hack, remove me when ejs will support
* arbitrary string and does not truncate on \0 */
if (strlen((char *)v.data) != v.length) {
mprAddArray(&val, j, mprDataBlob(v));
} else {
mprAddArray(&val, j, mprData(v.data, v.length));
}
}
}
mprSetVar(&var, el->name, val);
}
/* add the dn if it is not already specified */
if (mprGetProperty(&var, "dn", 0) == 0) {
mprSetVar(&var, "dn", mprString(ldb_dn_alloc_linearized(msg, msg->dn)));
}
return var;
failed:
return mprCreateUndefinedVar();
}
static struct MprVar mprSecrets(struct samba3_secrets *sec)
{
struct MprVar mpv = mprObject("samba3_secrets"), es, e;
int i;
es = mprArray("array");
for (i = 0; i < sec->ldappw_count; i++) {
e = mprObject("ldappw");
mprSetVar(&e, "dn", mprString(sec->ldappws[i].dn));
mprSetVar(&e, "password", mprString(sec->ldappws[i].password));
mprAddArray(&es, i, e);
}
mprSetVar(&mpv, "ldappws", es);
es = mprArray("array");
for (i = 0; i < sec->domain_count; i++) {
mprAddArray(&es, i, mprDomainSecrets(&sec->domains[i]));
}
if (i == 0) {
mprSetVar(&es, "length", mprCreateIntegerVar(i));
}
mprSetVar(&mpv, "domains", es);
es = mprArray("trusted_domains");
for (i = 0; i < sec->trusted_domain_count; i++) {
struct MprVar ns;
char *tmp;
int j;
e = mprObject("trusted_domain");
ns = mprArray("array");
for (j = 0; j < sec->trusted_domains[i].uni_name_len; j++) {
mprAddArray(&ns, j, mprString(sec->trusted_domains[i].uni_name[j]));
}
mprSetVar(&e, "uni_name", ns);
mprSetVar(&e, "pass", mprString(sec->trusted_domains[i].pass));
mprSetVar(&e, "mod_time", mprCreateIntegerVar(sec->trusted_domains[i].mod_time));
tmp = dom_sid_string(NULL, &sec->trusted_domains[i].domain_sid);
mprSetVar(&e, "domains_sid", mprString(tmp));
talloc_free(tmp);
mprAddArray(&es, i, e);
}
if (i == 0) {
mprSetVar(&es, "length", mprCreateIntegerVar(i));
}
mprSetVar(&mpv, "trusted_domains", es);
es = mprArray("array");
for (i = 0; i < sec->afs_keyfile_count; i++) {
struct MprVar ks;
int j;
e = mprObject("afs_keyfile");
mprSetVar(&e, "cell", mprString(sec->afs_keyfiles[i].cell));
ks = mprArray("array");
for (j = 0; j < 8; j++) {
struct MprVar k = mprObject("entry");
DATA_BLOB blob;
mprSetVar(&k, "kvno", mprCreateIntegerVar(sec->afs_keyfiles[i].entry[j].kvno));
blob.data = (uint8_t*)sec->afs_keyfiles[i].entry[j].key;
blob.length = 8;
mprSetVar(&k, "key", mprDataBlob(blob));
mprAddArray(&ks, j, k);
}
mprSetVar(&e, "entry", ks);
mprSetVar(&e, "nkeys", mprCreateIntegerVar(sec->afs_keyfiles[i].nkeys));
mprAddArray(&es, i, e);
}
if (i == 0) {
mprSetVar(&es, "length", mprCreateIntegerVar(i));
}
mprSetVar(&mpv, "afs_keyfiles", es);
mprSetVar(&mpv, "ipc_cred", mprCredentials(sec->ipc_cred));
return mpv;
}
