static int ejs_unlink(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_tree *tree;
NTSTATUS result;
if (argc != 2) {
ejsSetErrorMsg(eid, "unlink(): 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;
}
result = smbcli_unlink(tree, argv[1]->string);
mpr_Return(eid, mprNTSTATUS(result));
return 0;
}
/* Perform a tree disconnect
tree_disconnect(tree);
*/
static int ejs_cli_tree_disconnect(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_tree *tree;
NTSTATUS status;
/* Argument parsing */
if (argc != 1) {
ejsSetErrorMsg(eid, "tree_disconnect invalid arguments");
return -1;
}
if (!mprVarIsPtr(argv[0]->type)) {
ejsSetErrorMsg(eid, "first arg is not a tree handle");
return -1;
}
tree = argv[0]->ptr;
status = smb_tree_disconnect(tree);
if (!NT_STATUS_IS_OK(status)) {
ejsSetErrorMsg(eid, "tree_disconnect: %s", nt_errstr(status));
return -1;
}
talloc_free(tree);
return 0;
}
/* Perform a ulogoff
session_logoff(session);
*/
static int ejs_cli_session_logoff(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_session *session;
NTSTATUS status;
/* Argument parsing */
if (argc != 1) {
ejsSetErrorMsg(eid, "session_logoff invalid arguments");
return -1;
}
if (!mprVarIsPtr(argv[0]->type)) {
ejsSetErrorMsg(eid, "first arg is not a session handle");
return -1;
}
session = argv[0]->ptr;
status = smb_raw_ulogoff(session);
if (!NT_STATUS_IS_OK(status)) {
ejsSetErrorMsg(eid, "session_logoff: %s", nt_errstr(status));
return -1;
}
talloc_free(session);
return 0;
}
static int ejs_cli_connect(MprVarHandle eid, int argc, char **argv)
{
struct smbcli_socket *sock;
struct smbcli_transport *transport;
struct nbt_name calling, called;
NTSTATUS result;
if (argc != 1) {
ejsSetErrorMsg(eid, "connect invalid arguments");
return -1;
}
/* Socket connect */
sock = smbcli_sock_init(NULL, NULL);
if (!sock) {
ejsSetErrorMsg(eid, "socket initialisation failed");
return -1;
}
if (!smbcli_sock_connect_byname(sock, argv[0], 0)) {
ejsSetErrorMsg(eid, "socket connect failed");
return -1;
}
transport = smbcli_transport_init(sock, sock, False);
if (!transport) {
ejsSetErrorMsg(eid, "transport init failed");
return -1;
}
/* Send a netbios session request */
make_nbt_name_client(&calling, lp_netbios_name());
nbt_choose_called_name(NULL, &called, argv[0], NBT_NAME_SERVER);
if (!smbcli_transport_connect(transport, &calling, &called)) {
ejsSetErrorMsg(eid, "transport establishment failed");
return -1;
}
result = smb_raw_negotiate(transport, lp_maxprotocol());
if (!NT_STATUS_IS_OK(result)) {
mpr_Return(eid, mprNTSTATUS(result));
return 0;
}
/* Return a socket object */
mpr_Return(eid, mprCreatePtrVar(transport));
return 0;
}
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;
}
static int ejs_resolve_name(MprVarHandle eid, int argc, struct MprVar **argv)
{
int result = -1;
struct nbt_name name;
TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
NTSTATUS nt_status;
const char *reply_addr;
/* validate arguments */
if (argc < 2 || argc > 3) {
ejsSetErrorMsg(eid, "resolveName invalid arguments");
goto done;
}
if (argv[0]->type != MPR_TYPE_OBJECT) {
ejsSetErrorMsg(eid, "resolvename invalid arguments");
goto done;
}
if (argv[1]->type != MPR_TYPE_STRING) {
ejsSetErrorMsg(eid, "resolveName invalid arguments");
goto done;
}
if (argc == 2) {
make_nbt_name_client(&name, mprToString(argv[1]));
} else {
if (!mprVarIsNumber(argv[1]->type)) {
ejsSetErrorMsg(eid, "resolveName invalid arguments");
goto done;
}
make_nbt_name(&name, mprToString(argv[1]), mprToInt(argv[2]));
}
result = 0;
nt_status = resolve_name(&name, tmp_ctx, &reply_addr, event_context_find(tmp_ctx));
if (NT_STATUS_IS_OK(nt_status)) {
mprSetPropertyValue(argv[0], "value", mprString(reply_addr));
}
mpr_Return(eid, mprNTSTATUS(nt_status));
done:
talloc_free(tmp_ctx);
return result;
}
static void test_ejs_exception(const char *reason)
{
Ejs *ep = ejsPtr(eid);
ejsSetErrorMsg(eid, "%s", reason);
fprintf(stderr, "%s", ep->error);
ejs_error = 127;
}
static int ejs_net_join_domain(MprVarHandle eid, int argc, struct MprVar **argv)
{
TALLOC_CTX *mem_ctx;
struct libnet_context *ctx;
struct libnet_Join *join;
NTSTATUS status;
ctx = mprGetThisPtr(eid, "ctx");
mem_ctx = talloc_new(mprMemCtx());
join = talloc(mem_ctx, struct libnet_Join);
if (!join) {
talloc_free(mem_ctx);
return -1;
}
/* prepare parameters for the join */
join->in.netbios_name = NULL;
join->in.join_type = SEC_CHAN_WKSTA;
join->in.domain_name = cli_credentials_get_domain(ctx->cred);
join->in.level = LIBNET_JOIN_AUTOMATIC;
join->out.error_string = NULL;
if (argc == 1 && argv[0]->type == MPR_TYPE_OBJECT) {
MprVar *netbios_name = mprGetProperty(argv[0], "netbios_name", NULL);
MprVar *domain_name = mprGetProperty(argv[0], "domain_name", NULL);
MprVar *join_type = mprGetProperty(argv[0], "join_type", NULL);
if (netbios_name) {
join->in.netbios_name = mprToString(netbios_name);
}
if (domain_name) {
join->in.domain_name = mprToString(domain_name);
}
if (join_type) {
join->in.join_type = mprToInt(join_type);
}
}
if (!join->in.domain_name) {
ejsSetErrorMsg(eid, "a domain must be specified for to join");
talloc_free(mem_ctx);
return -1;
}
/* do the domain join */
status = libnet_Join(ctx, join, join);
if (!NT_STATUS_IS_OK(status)) {
MprVar error_string = mprString(join->out.error_string);
mprSetPropertyValue(argv[0], "error_string", error_string);
mpr_Return(eid, mprCreateBoolVar(False));
} else {
mpr_Return(eid, mprCreateBoolVar(True));
}
talloc_free(mem_ctx);
return 0;
}
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;
}
/* Perform a connection close
disconnect(conn);
*/
static int ejs_cli_disconnect(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_sock *sock;
/* Argument parsing */
if (argc != 1) {
ejsSetErrorMsg(eid, "disconnect invalid arguments");
return -1;
}
if (!mprVarIsPtr(argv[0]->type)) {
ejsSetErrorMsg(eid, "first arg is not a connect handle");
return -1;
}
sock = argv[0]->ptr;
talloc_free(sock);
return 0;
}
static int ejs_tree_connect(MprVarHandle eid, int argc, char **argv)
{
struct cli_credentials *creds;
struct smb_composite_connect io;
struct smbcli_tree *tree;
char *hostname, *sharename;
NTSTATUS result;
TALLOC_CTX *mem_ctx;
if (argc != 2) {
ejsSetErrorMsg(eid, "tree_connect(): invalid number of args");
return -1;
}
/* Set up host, share destination */
mem_ctx = talloc_new(mprMemCtx());
smbcli_parse_unc(argv[0], mem_ctx, &hostname, &sharename);
/* Set up credentials */
creds = cli_credentials_init(NULL);
cli_credentials_set_conf(creds);
cli_credentials_parse_string(creds, argv[1], CRED_SPECIFIED);
/* Do connect */
io.in.dest_host = hostname;
io.in.port = 0;
io.in.called_name = strupper_talloc(mem_ctx, hostname);
io.in.service = sharename;
io.in.service_type = "?????";
io.in.credentials = creds;
io.in.fallback_to_anonymous = False;
io.in.workgroup = lp_workgroup();
result = smb_composite_connect(&io, mem_ctx, NULL);
tree = io.out.tree;
talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(result)) {
mpr_Return(eid, mprNTSTATUS(result));
return 0;
}
mpr_Return(eid, mprCreatePtrVar(tree));
return 0;
}
void espError(EspRequest *ep, char *fmt, ...)
{
va_list args;
char *buf;
mprAssert(ep);
mprAssert(fmt);
va_start(args, fmt);
mprAllocVsprintf(&buf, MPR_MAX_HEAP_SIZE, fmt, args);
ejsSetErrorMsg(ep->eid, buf);
mprFree(buf);
va_end(args);
}
/*
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;
}
static int ejs_tree_disconnect(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_tree *tree;
NTSTATUS result;
if (argc != 1) {
ejsSetErrorMsg(eid,
"tree_disconnect(): invalid number of args");
return -1;
}
if (!IS_TREE_HANDLE(argv[0])) {
ejsSetErrorMsg(eid, "first arg is not a tree handle");
return -1;
}
tree = talloc_check_name(argv[0]->ptr, "struct smbcli_tree");
result = smb_tree_disconnect(tree);
mpr_Return(eid, mprNTSTATUS(result));
return 0;
}
static int ejs_find_domainsecrets(MprVarHandle eid, int argc, struct MprVar **argv)
{
struct samba3 *samba3 = NULL;
struct samba3_domainsecrets *sec;
if (argc < 1) {
ejsSetErrorMsg(eid, "find_domainsecrets invalid arguments");
return -1;
}
samba3 = mprGetThisPtr(eid, "samba3");
mprAssert(samba3);
sec = samba3_find_domainsecrets(samba3, mprToString(argv[0]));
if (sec == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
} else {
mpr_Return(eid, mprDomainSecrets(sec));
}
return 0;
}
static int ejs_cli_ssetup(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_transport *transport;
struct smbcli_session *session;
struct smb_composite_sesssetup setup;
struct cli_credentials *creds;
NTSTATUS status;
int result = -1;
/* Argument parsing */
if (argc < 1 || argc > 4) {
ejsSetErrorMsg(eid, "session_setup invalid arguments");
return -1;
}
if (!mprVarIsPtr(argv[0]->type)) {
ejsSetErrorMsg(eid, "first arg is not a connect handle");
return -1;
}
transport = argv[0]->ptr;
creds = cli_credentials_init(transport);
cli_credentials_set_conf(creds);
if (argc == 4) {
/* DOMAIN, USERNAME, PASSWORD form */
if (!mprVarIsString(argv[1]->type)) {
ejsSetErrorMsg(eid, "arg 1 must be a string");
goto done;
}
cli_credentials_set_domain(creds, argv[1]->string,
CRED_SPECIFIED);
if (!mprVarIsString(argv[2]->type)) {
ejsSetErrorMsg(eid, "arg 2 must be a string");
goto done;
}
cli_credentials_set_username(creds, argv[2]->string,
CRED_SPECIFIED);
if (!mprVarIsString(argv[3]->type)) {
ejsSetErrorMsg(eid, "arg 3 must be a string");
goto done;
}
cli_credentials_set_password(creds, argv[3]->string,
CRED_SPECIFIED);
} else if (argc == 3) {
/* USERNAME, PASSWORD form */
if (!mprVarIsString(argv[1]->type)) {
ejsSetErrorMsg(eid, "arg1 must be a string");
goto done;
}
cli_credentials_set_username(creds, argv[1]->string,
CRED_SPECIFIED);
if (!mprVarIsString(argv[2]->type)) {
ejsSetErrorMsg(eid, "arg2 must be a string");
goto done;
}
cli_credentials_set_password(creds, argv[2]->string,
CRED_SPECIFIED);
} else if (argc == 2) {
/* DOMAIN/USERNAME%PASSWORD form */
cli_credentials_parse_string(creds, argv[1]->string,
CRED_SPECIFIED);
} else {
/* Anonymous connection */
cli_credentials_set_anonymous(creds);
}
/* Do session setup */
session = smbcli_session_init(transport, transport, False);
if (!session) {
ejsSetErrorMsg(eid, "session init failed");
return -1;
}
setup.in.sesskey = transport->negotiate.sesskey;
setup.in.capabilities = transport->negotiate.capabilities;
setup.in.credentials = creds;
setup.in.workgroup = lp_workgroup();
status = smb_composite_sesssetup(session, &setup);
if (!NT_STATUS_IS_OK(status)) {
ejsSetErrorMsg(eid, "session_setup: %s", nt_errstr(status));
return -1;
}
session->vuid = setup.out.vuid;
/* Return a session object */
mpr_Return(eid, mprCreatePtrVar(session));
result = 0;
done:
talloc_free(creds);
return result;
}
static int ejs_cli_tree_connect(MprVarHandle eid, int argc, MprVar **argv)
{
struct smbcli_session *session;
struct smbcli_tree *tree;
union smb_tcon tcon;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
const char *password = "";
/* Argument parsing */
if (argc != 2) {
ejsSetErrorMsg(eid, "tree_connect invalid arguments");
return -1;
}
if (!mprVarIsPtr(argv[0]->type)) {
ejsSetErrorMsg(eid, "first arg is not a session handle");
return -1;
}
session = argv[0]->ptr;
tree = smbcli_tree_init(session, session, False);
if (!tree) {
ejsSetErrorMsg(eid, "tree init failed");
return -1;
}
mem_ctx = talloc_init("tcon");
if (!mem_ctx) {
ejsSetErrorMsg(eid, "talloc_init failed");
return -1;
}
/* Do tree connect */
tcon.generic.level = RAW_TCON_TCONX;
tcon.tconx.in.flags = 0;
if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) {
tcon.tconx.in.password = data_blob(NULL, 0);
} else if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
tcon.tconx.in.password = data_blob_talloc(mem_ctx, NULL, 24);
if (session->transport->negotiate.secblob.length < 8) {
ejsSetErrorMsg(eid, "invalid security blob");
return -1;
}
SMBencrypt(password, session->transport->negotiate.secblob.data, tcon.tconx.in.password.data);
} else {
tcon.tconx.in.password = data_blob_talloc(mem_ctx, password, strlen(password)+1);
}
tcon.tconx.in.path = argv[1]->string;
tcon.tconx.in.device = "?????";
status = smb_tree_connect(tree, mem_ctx, &tcon);
if (!NT_STATUS_IS_OK(status)) {
ejsSetErrorMsg(eid, "tree_connect: %s", nt_errstr(status));
return -1;
}
tree->tid = tcon.tconx.out.tid;
talloc_free(mem_ctx);
mpr_Return(eid, mprCreatePtrVar(tree));
return 0;
}
