static NTSTATUS provider_rpc_connection(TALLOC_CTX *parent_ctx,
struct dcerpc_pipe **p,
const char *binding,
struct cli_credentials *credentials,
const struct ndr_interface_table *table,
struct loadparm_context *lp_ctx)
{
NTSTATUS status;
struct tevent_context *ev;
if (!binding) {
OC_DEBUG(3, "You must specify a ncacn binding string");
return NT_STATUS_INVALID_PARAMETER;
}
ev = tevent_context_init(parent_ctx);
tevent_loop_allow_nesting(ev);
status = dcerpc_pipe_connect(parent_ctx,
p, binding, table,
credentials, ev, lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
OC_DEBUG(3, "Failed to connect to remote server: %s %s",
binding, nt_errstr(status));
}
/* dcerpc_pipe_connect set errno, we have to unset it */
errno = 0;
return status;
}
int main(void) {
TALLOC_CTX *mem_ctx; // pointer to talloc context
struct tevent_context *ctx; // pointer to tevent context
struct tevent_req *event_req; // pointer to tevent request
// parent - top level talloc context
mem_ctx = talloc_new(NULL);
if (mem_ctx == NULL) {
fprintf(stderr, "Not enough memory.\n");
return -1;
}
ctx = tevent_context_init(mem_ctx);
// create tevent request, set callback and continue
if (foo_send(mem_ctx, &event_req) != 0) {
return -1;
}
printf("prg> I've created tevent request and now I continue.\n");
/******************************************************************************
* A FEW EXAMPLES OF FINISHIN REQUEST
/*****************************************************************************/
// mark request af finished immediatly
foo_done(mem_ctx, &event_req);
// mark request as finished after 1s
//tevent_req_set_endtime(event_req, ctx, tevent_timeval_current_ofs(1, 0));
tevent_loop_wait(ctx);
talloc_free(mem_ctx);
return EXIT_SUCCESS;
}
static PyObject *py_tevent_context_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
const char * const kwnames[] = { "name", NULL };
char *name = NULL;
struct tevent_context *ev;
TeventContext_Object *ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwnames, &name))
return NULL;
if (name == NULL) {
ev = tevent_context_init(NULL);
} else {
ev = tevent_context_init_byname(NULL, name);
}
if (ev == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
ret = PyObject_New(TeventContext_Object, type);
if (ret == NULL) {
PyErr_NoMemory();
talloc_free(ev);
return NULL;
}
ret->ev = ev;
return (PyObject *)ret;
}
/**
\details Initialize ldb_context to samdb, creates one for all emsmdbp
contexts
\param lp_ctx pointer to the loadparm context
*/
static struct ldb_context *samdb_init(struct loadparm_context *lp_ctx)
{
TALLOC_CTX *mem_ctx;
struct tevent_context *ev;
const char *samdb_url;
if (samdb_ctx) return samdb_ctx;
mem_ctx = talloc_autofree_context();
ev = tevent_context_init(mem_ctx);
if (!ev) {
OC_PANIC(false, ("Fail to initialize tevent_context\n"));
return NULL;
}
tevent_loop_allow_nesting(ev);
/* Retrieve samdb url (local or external) */
samdb_url = lpcfg_parm_string(lp_ctx, NULL, "dcerpc_mapiproxy", "samdb_url");
if (!samdb_url) {
samdb_ctx = samdb_connect(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0);
} else {
samdb_ctx = samdb_connect_url(mem_ctx, ev, lp_ctx, system_session(lp_ctx),
LDB_FLG_RECONNECT, samdb_url);
}
return samdb_ctx;
}
int mit_samba_context_init(struct mit_samba_context **_ctx)
{
NTSTATUS status;
struct mit_samba_context *ctx;
const char *s4_conf_file;
int ret;
struct samba_kdc_base_context base_ctx;
ctx = talloc_zero(NULL, struct mit_samba_context);
if (!ctx) {
ret = ENOMEM;
goto done;
}
base_ctx.ev_ctx = tevent_context_init(ctx);
if (!base_ctx.ev_ctx) {
ret = ENOMEM;
goto done;
}
tevent_loop_allow_nesting(base_ctx.ev_ctx);
base_ctx.lp_ctx = loadparm_init_global(false);
if (!base_ctx.lp_ctx) {
ret = ENOMEM;
goto done;
}
setup_logging("mitkdc", DEBUG_STDOUT);
/* init s4 configuration */
s4_conf_file = lpcfg_configfile(base_ctx.lp_ctx);
if (s4_conf_file) {
lpcfg_load(base_ctx.lp_ctx, s4_conf_file);
} else {
lpcfg_load_default(base_ctx.lp_ctx);
}
status = samba_kdc_setup_db_ctx(ctx, &base_ctx, &ctx->db_ctx);
if (!NT_STATUS_IS_OK(status)) {
ret = EINVAL;
goto done;
}
/* init heimdal's krb_context and log facilities */
ret = smb_krb5_init_context_basic(ctx,
ctx->db_ctx->lp_ctx,
&ctx->context);
if (ret) {
goto done;
}
ret = 0;
done:
if (ret) {
mit_samba_context_free(ctx);
} else {
*_ctx = ctx;
}
return ret;
}
/**
\details Initialize the EMSABP context and open connections to
Samba databases.
\param lp_ctx pointer to the loadparm context
\param tdb_ctx pointer to the EMSABP TDB context
\return Allocated emsabp_context on success, otherwise NULL
*/
_PUBLIC_ struct emsabp_context *emsabp_init(struct loadparm_context *lp_ctx,
TDB_CONTEXT *tdb_ctx)
{
TALLOC_CTX *mem_ctx;
struct emsabp_context *emsabp_ctx;
struct tevent_context *ev;
const char *samdb_url;
/* Sanity checks */
if (!lp_ctx) return NULL;
mem_ctx = talloc_named(NULL, 0, "emsabp_init");
emsabp_ctx = talloc_zero(mem_ctx, struct emsabp_context);
if (!emsabp_ctx) {
talloc_free(mem_ctx);
return NULL;
}
emsabp_ctx->mem_ctx = mem_ctx;
ev = tevent_context_init(mem_ctx);
if (!ev) {
talloc_free(mem_ctx);
return NULL;
}
tevent_loop_allow_nesting(ev);
/* Save a pointer to the loadparm context */
emsabp_ctx->lp_ctx = lp_ctx;
/* Retrieve samdb url (local or external) */
samdb_url = lpcfg_parm_string(lp_ctx, NULL, "dcerpc_mapiproxy", "samdb_url");
/* return an opaque context pointer on samDB database */
if (!samdb_url) {
emsabp_ctx->samdb_ctx = samdb_connect(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0);
} else {
emsabp_ctx->samdb_ctx = samdb_connect_url(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0, samdb_url);
}
if (!emsabp_ctx->samdb_ctx) {
talloc_free(mem_ctx);
DEBUG(0, ("[%s:%d]: Connection to \"sam.ldb\" failed\n", __FUNCTION__, __LINE__));
return NULL;
}
/* Reference the global TDB context to the current emsabp context */
emsabp_ctx->tdb_ctx = tdb_ctx;
/* Initialize a temporary (on-memory) TDB database to store
* temporary MId used within EMSABP */
emsabp_ctx->ttdb_ctx = emsabp_tdb_init_tmp(emsabp_ctx->mem_ctx);
if (!emsabp_ctx->ttdb_ctx) {
smb_panic("unable to create on-memory TDB database");
}
return emsabp_ctx;
}
static int
pmda_ctdb_daemon_connect(void)
{
const char *socket_name;
int ret;
ev = tevent_context_init(NULL);
if (ev == NULL) {
fprintf(stderr, "Failed to init event ctx\n");
return -1;
}
socket_name = getenv("CTDB_SOCKET");
if (socket_name == NULL) {
socket_name = CTDB_SOCKET;
}
ret = ctdb_client_init(ev, ev, socket_name, &client);
if (ret != 0) {
fprintf(stderr, "Failed to connect to ctdb daemon via %s\n",
socket_name);
goto err_ev;
}
ctdb_client_set_disconnect_callback(client, pmda_ctdb_disconnected,
NULL);
return 0;
err_ev:
talloc_free(ev);
client = NULL;
return -1;
}
static void
mock_server_child(void *data)
{
struct mock_server *mock = data;
struct tevent_context *loop;
struct sbus_connection *server;
bool stop_server = false;
TALLOC_CTX *ctx;
ctx = talloc_new(NULL);
loop = tevent_context_init(ctx);
verify_eq (sbus_new_server(ctx, loop, mock->dbus_address, false,
&server, on_accept_connection, mock), EOK);
tevent_add_fd(loop, ctx, mock->sync_fds[1], TEVENT_FD_READ,
on_sync_fd_written, &stop_server);
/* Synchronization point: test_dbus_setup_mock() should connect */
verify_eq (write(mock->sync_fds[1], "X", 1), 1);
/* Do the loop */
while(!stop_server) {
verify_eq (tevent_loop_once(loop), 0);
}
/* TODO: sbus doesn't support cleanup of a server */
talloc_free(ctx);
}
static bool net_g_lock_init(TALLOC_CTX *mem_ctx,
struct tevent_context **pev,
struct messaging_context **pmsg,
struct g_lock_ctx **pg_ctx)
{
struct tevent_context *ev = NULL;
struct messaging_context *msg = NULL;
struct g_lock_ctx *g_ctx = NULL;
ev = tevent_context_init(mem_ctx);
if (ev == NULL) {
d_fprintf(stderr, "ERROR: could not init event context\n");
goto fail;
}
msg = messaging_init(mem_ctx, ev);
if (msg == NULL) {
d_fprintf(stderr, "ERROR: could not init messaging context\n");
goto fail;
}
g_ctx = g_lock_ctx_init(mem_ctx, msg);
if (g_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init g_lock context\n");
goto fail;
}
*pev = ev;
*pmsg = msg;
*pg_ctx = g_ctx;
return true;
fail:
TALLOC_FREE(g_ctx);
TALLOC_FREE(msg);
TALLOC_FREE(ev);
return false;
}
/*
* Test set up
*/
static int setup(void **state)
{
struct ldbtest_ctx *test_ctx = NULL;
struct ldb_module *eol = NULL;
int rc;
test_ctx = talloc_zero(NULL, struct ldbtest_ctx);
assert_non_null(test_ctx);
test_ctx->ev = tevent_context_init(test_ctx);
assert_non_null(test_ctx->ev);
test_ctx->ldb = ldb_init(test_ctx, test_ctx->ev);
assert_non_null(test_ctx->ldb);
test_ctx->domain_sid = talloc_zero(test_ctx, struct dom_sid);
assert_non_null(test_ctx->domain_sid);
assert_true(string_to_sid(test_ctx->domain_sid, DOMAIN_SID));
ldb_set_opaque(test_ctx->ldb, "cache.domain_sid", test_ctx->domain_sid);
test_ctx->module = ldb_module_new(
test_ctx,
test_ctx->ldb,
"unique_object_sids",
&ldb_unique_object_sids_module_ops);
assert_non_null(test_ctx->module);
eol = ldb_module_new(test_ctx, test_ctx->ldb, "eol", &eol_ops);
assert_non_null(eol);
ldb_module_set_next(test_ctx->module, eol);
test_ctx->dbfile = talloc_strdup(test_ctx, "duptest.ldb");
assert_non_null(test_ctx->dbfile);
test_ctx->lockfile = talloc_asprintf(test_ctx, "%s-lock",
test_ctx->dbfile);
assert_non_null(test_ctx->lockfile);
test_ctx->dbpath = talloc_asprintf(test_ctx,
TEST_BE"://%s", test_ctx->dbfile);
assert_non_null(test_ctx->dbpath);
unlink_old_db(test_ctx);
rc = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
assert_int_equal(rc, LDB_SUCCESS);
rc = unique_object_sids_init(test_ctx->module);
assert_int_equal(rc, LDB_SUCCESS);
*state = test_ctx;
last_request = NULL;
return 0;
}
int main(int argc, char **argv)
{
lp_ctx = loadparm_init(NULL);
lp_load_default(lp_ctx);
setup_logging(argv[0], DEBUG_STDERR);
dcerpc_init(lp_ctx);
ev_ctx = tevent_context_init(lp_ctx);
gtk_init(&argc, &argv);
mainwin = create_mainwindow();
gtk_widget_show_all(mainwin);
return gtk_event_loop();
}
int main()
{
struct main_context *ctx = NULL;
int ret;
/* Create main context */
ctx = talloc_zero(NULL, struct main_context);
if (ctx == NULL) {
DEBUG("talloc_zero() failed");
goto fail;
}
ctx->is_sigint_enabled = 0;
/* Create main event context */
ctx->event_ctx = tevent_context_init(ctx);
if (ctx->event_ctx == NULL) {
DEBUG("talloc_context_init() failed");
goto fail;
}
/* Setup event handlers on event context */
ret = setup_event_handlers(ctx, ctx->event_ctx);
if (ret != EOK) {
DEBUG("setup_event_handlers() failed");
goto fail;
}
/* Enter event loop */
tevent_loop_wait(ctx->event_ctx);
ret = EXIT_SUCCESS;
goto done;
fail:
ret = EXIT_FAILURE;
done:
talloc_free(ctx);
return ret;
}
bool run_dbwrap_watch1(int dummy)
{
struct tevent_context *ev = NULL;
struct messaging_context *msg = NULL;
struct db_context *db = NULL;
const char *keystr = "key";
TDB_DATA key = string_term_tdb_data(keystr);
struct db_record *rec = NULL;
struct tevent_req *req = NULL;
NTSTATUS status;
bool ret = false;
ev = tevent_context_init(talloc_tos());
if (ev == NULL) {
fprintf(stderr, "tevent_context_init failed\n");
goto fail;
}
msg = messaging_init(ev, ev);
if (msg == NULL) {
fprintf(stderr, "messaging_init failed\n");
goto fail;
}
db = db_open(msg, "test_watch.tdb", 0, TDB_DEFAULT,
O_CREAT|O_RDWR, 0644, DBWRAP_LOCK_ORDER_1);
if (db == NULL) {
fprintf(stderr, "db_open failed: %s\n", strerror(errno));
goto fail;
}
dbwrap_watch_db(db, msg);
rec = dbwrap_fetch_locked(db, db, key);
if (rec == NULL) {
fprintf(stderr, "dbwrap_fetch_locked failed\n");
goto fail;
}
req = dbwrap_record_watch_send(talloc_tos(), ev, rec, msg);
if (req == NULL) {
fprintf(stderr, "dbwrap_record_watch_send failed\n");
goto fail;
}
TALLOC_FREE(rec);
status = dbwrap_store_int32(db, keystr, 1);
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "dbwrap_store_int32 failed: %s\n",
nt_errstr(status));
goto fail;
}
if (!tevent_req_poll(req, ev)) {
fprintf(stderr, "tevent_req_poll failed\n");
goto fail;
}
status = dbwrap_record_watch_recv(req, talloc_tos(), &rec);
if (!NT_STATUS_IS_OK(status)) {
fprintf(stderr, "dbwrap_record_watch_recv failed: %s\n",
nt_errstr(status));
goto fail;
}
ret = true;
fail:
TALLOC_FREE(req);
TALLOC_FREE(rec);
TALLOC_FREE(db);
TALLOC_FREE(msg);
TALLOC_FREE(ev);
return ret;
}
/*
initialise a cldap_sock
*/
NTSTATUS cldap_socket_init(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
const struct tsocket_address *local_addr,
const struct tsocket_address *remote_addr,
struct cldap_socket **_cldap)
{
struct cldap_socket *c = NULL;
struct tsocket_address *any = NULL;
NTSTATUS status;
int ret;
c = talloc_zero(mem_ctx, struct cldap_socket);
if (!c) {
goto nomem;
}
if (!ev) {
ev = tevent_context_init(c);
if (!ev) {
goto nomem;
}
c->event.allow_poll = true;
}
c->event.ctx = ev;
if (!local_addr) {
ret = tsocket_address_inet_from_strings(c, "ipv4",
NULL, 0,
&any);
if (ret != 0) {
status = map_nt_error_from_unix(errno);
goto nterror;
}
local_addr = any;
}
c->searches.idr = idr_init(c);
if (!c->searches.idr) {
goto nomem;
}
ret = tdgram_inet_udp_socket(local_addr, remote_addr,
c, &c->sock);
if (ret != 0) {
status = map_nt_error_from_unix(errno);
goto nterror;
}
talloc_free(any);
if (remote_addr) {
c->connected = true;
}
c->send_queue = tevent_queue_create(c, "cldap_send_queue");
if (!c->send_queue) {
goto nomem;
}
talloc_set_destructor(c, cldap_socket_destructor);
*_cldap = c;
return NT_STATUS_OK;
nomem:
status = NT_STATUS_NO_MEMORY;
nterror:
talloc_free(c);
return status;
}
/*
main program
*/
int main(int argc, const char *argv[])
{
TALLOC_CTX *mem_ctx;
struct tevent_context *ev_ctx;
struct messaging_context *msg_ctx;
struct db_context *db;
int unsafe_writes = 0;
struct poptOption popt_options[] = {
POPT_AUTOHELP
POPT_COMMON_SAMBA
{ "timelimit", 't', POPT_ARG_INT, &timelimit, 0, "timelimit", "INTEGER" },
{ "delay", 'D', POPT_ARG_INT, &torture_delay, 0, "delay (in seconds) between operations", "INTEGER" },
{ "verbose", 'v', POPT_ARG_NONE, &verbose, 0, "switch on verbose mode", NULL },
{ "db-name", 'N', POPT_ARG_STRING, &db_name, 0, "name of the test db", "NAME" },
{ "no-trans", 'n', POPT_ARG_NONE, &no_trans, 0, "use fetch_lock/record store instead of transactions", NULL },
{ "unsafe-writes", 'u', POPT_ARG_NONE, &unsafe_writes, 0, "do not use tdb transactions when writing", NULL },
POPT_TABLEEND
};
int opt;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
int tdb_flags;
int ret = 1;
mem_ctx = talloc_stackframe();
if (verbose) {
setbuf(stdout, (char *)NULL); /* don't buffer */
} else {
setlinebuf(stdout);
}
load_case_tables();
setup_logging(argv[0], DEBUG_STDERR);
lp_set_cmdline("log level", "0");
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
goto done;
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
lp_load_global(get_dyn_CONFIGFILE());
ev_ctx = tevent_context_init(mem_ctx);
if (ev_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init event context\n");
goto done;
}
msg_ctx = messaging_init(mem_ctx, procid_self(), ev_ctx);
if (msg_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init messaging context\n");
goto done;
}
if (unsafe_writes == 1) {
tdb_flags = TDB_NOSYNC;
} else {
tdb_flags = TDB_DEFAULT;
}
if (no_trans) {
tdb_flags |= TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH;
}
db = db_open(mem_ctx, db_name, 0, tdb_flags, O_RDWR | O_CREAT, 0644);
if (db == NULL) {
d_fprintf(stderr, "failed to open db '%s': %s\n", db_name,
strerror(errno));
goto done;
}
if (get_my_vnn() == NONCLUSTER_VNN) {
set_my_vnn(0);
}
pnn = get_my_vnn();
printf("Starting test on node %u. running for %u seconds. "
"sleep delay: %u seconds.\n", pnn, timelimit, torture_delay);
if (!verbose && (pnn == 0)) {
tevent_add_timer(ev_ctx, db, timeval_current_ofs(1, 0), each_second, db);
}
test_store_records(db, ev_ctx);
if (verbose || (pnn == 0)) {
if (success != true) {
printf("The test FAILED\n");
ret = 2;
} else {
printf("SUCCESS!\n");
ret = 0;
}
}
done:
talloc_free(mem_ctx);
return ret;
}
int main(int argc, char **argv)
{
TALLOC_CTX *mem_ctx = talloc_init("samba-dig");
struct tevent_context *ev;
struct dns_name_packet *dns_packet, *in_packet;
struct dns_name_question *question;
enum dns_qtype type;
enum ndr_err_code ndr_err;
struct tevent_req *req;
WERROR w_err;
DATA_BLOB out, in;
int ret = 0;
if (argc < 4) {
usage();
exit(1);
}
ev = tevent_context_init(mem_ctx);
setup_logging("samba-dig", DEBUG_STDERR);
debug_parse_levels("1");
DEBUG(1,("Querying %s for %s %s\n", argv[1], argv[2], argv[3]));
dns_packet = make_name_packet(mem_ctx, DNS_OPCODE_QUERY);
type = parse_qtype(argv[3]);
if (type == -1) {
DEBUG(0, ("Invalid DNS_QTYPE %s\n", argv[3]));
ret = 1;
goto error;
}
question = make_question(dns_packet, argv[2], type);
dns_packet->qdcount = 1;
dns_packet->questions = question;
NDR_PRINT_DEBUG(dns_name_packet, dns_packet);
ndr_err = ndr_push_struct_blob(&out, mem_ctx, dns_packet,
(ndr_push_flags_fn_t)ndr_push_dns_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0, ("Failed to marshall dns_name_packet: %d\n", ndr_err));
ret = 1;
goto error;
}
req = dns_udp_request_send(mem_ctx, ev, argv[1], out.data, out.length);
if (req == NULL) {
DEBUG(0, ("Failed to allocate memory for tevent_req\n"));
ret = 1;
goto error;
}
if (!tevent_req_poll(req, ev)) {
DEBUG(0, ("Error sending dns request\n"));
ret = 1;
goto error;
}
w_err = dns_udp_request_recv(req, mem_ctx, &in.data, &in.length);
if (!W_ERROR_IS_OK(w_err)) {
DEBUG(0, ("Error receiving dns request: %s\n", win_errstr(w_err)));
ret = 1;
goto error;
}
in_packet = talloc(mem_ctx, struct dns_name_packet);
ndr_err = ndr_pull_struct_blob(&in, in_packet, in_packet,
(ndr_pull_flags_fn_t)ndr_pull_dns_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0, ("Failed to unmarshall dns_name_packet: %d\n", ndr_err));
ret = 1;
goto error;
}
NDR_PRINT_DEBUG(dns_name_packet, in_packet);
error:
talloc_free(mem_ctx);
return ret;
}
static WERROR ask_forwarder(struct dns_server *dns,
TALLOC_CTX *mem_ctx,
struct dns_name_question *question,
struct dns_res_rec **answers, uint16_t *ancount,
struct dns_res_rec **nsrecs, uint16_t *nscount,
struct dns_res_rec **additional, uint16_t *arcount)
{
struct tevent_context *ev = tevent_context_init(mem_ctx);
struct dns_name_packet *out_packet, *in_packet;
uint16_t id = random();
DATA_BLOB out, in;
enum ndr_err_code ndr_err;
WERROR werr = WERR_OK;
struct tevent_req *req;
const char *forwarder = lpcfg_dns_forwarder(dns->task->lp_ctx);
if (!is_ipaddress(forwarder)) {
DEBUG(0, ("Invalid 'dns forwarder' setting '%s', needs to be "
"an IP address\n", forwarder));
return DNS_ERR(NAME_ERROR);
}
out_packet = talloc_zero(mem_ctx, struct dns_name_packet);
W_ERROR_HAVE_NO_MEMORY(out_packet);
out_packet->id = id;
out_packet->operation |= DNS_OPCODE_QUERY | DNS_FLAG_RECURSION_DESIRED;
out_packet->qdcount = 1;
out_packet->questions = question;
ndr_err = ndr_push_struct_blob(&out, mem_ctx, out_packet,
(ndr_push_flags_fn_t)ndr_push_dns_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return DNS_ERR(SERVER_FAILURE);
}
req = dns_udp_request_send(mem_ctx, ev, forwarder, out.data, out.length);
W_ERROR_HAVE_NO_MEMORY(req);
if(!tevent_req_poll(req, ev)) {
return DNS_ERR(SERVER_FAILURE);
}
werr = dns_udp_request_recv(req, mem_ctx, &in.data, &in.length);
W_ERROR_NOT_OK_RETURN(werr);
in_packet = talloc_zero(mem_ctx, struct dns_name_packet);
W_ERROR_HAVE_NO_MEMORY(in_packet);
ndr_err = ndr_pull_struct_blob(&in, in_packet, in_packet,
(ndr_pull_flags_fn_t)ndr_pull_dns_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return DNS_ERR(SERVER_FAILURE);
}
if (in_packet->id != id) {
DEBUG(0, ("DNS packet id mismatch: 0x%0x, expected 0x%0x\n",
in_packet->id, id));
return DNS_ERR(NAME_ERROR);
}
*ancount = in_packet->ancount;
*answers = talloc_move(mem_ctx, &in_packet->answers);
*nscount = in_packet->nscount;
*nsrecs = talloc_move(mem_ctx, &in_packet->nsrecs);
*arcount = in_packet->arcount;
*additional = talloc_move(mem_ctx, &in_packet->additional);
return werr;
}
/*
main program
*/
int main(int argc, const char *argv[])
{
struct ctdb_context *ctdb;
int interactive = 0;
struct poptOption popt_options[] = {
POPT_AUTOHELP
POPT_CTDB_CMDLINE
{ "interactive", 'i', POPT_ARG_NONE, &interactive, 0, "don't fork", NULL },
{ "public-addresses", 0, POPT_ARG_STRING, &options.public_address_list, 0, "public address list file", "filename" },
{ "public-interface", 0, POPT_ARG_STRING, &options.public_interface, 0, "public interface", "interface"},
{ "event-script-dir", 0, POPT_ARG_STRING, &options.event_script_dir, 0, "event script directory", "dirname" },
{ "logging", 0, POPT_ARG_STRING, &options.logging, 0, "logging method to be used", NULL },
{ "nlist", 0, POPT_ARG_STRING, &options.nlist, 0, "node list file", "filename" },
{ "notification-script", 0, POPT_ARG_STRING, &options.notification_script, 0, "notification script", "filename" },
{ "listen", 0, POPT_ARG_STRING, &options.myaddress, 0, "address to listen on", "address" },
{ "transport", 0, POPT_ARG_STRING, &options.transport, 0, "protocol transport", NULL },
{ "dbdir", 0, POPT_ARG_STRING, &options.db_dir, 0, "directory for the tdb files", NULL },
{ "dbdir-persistent", 0, POPT_ARG_STRING, &options.db_dir_persistent, 0, "directory for persistent tdb files", NULL },
{ "dbdir-state", 0, POPT_ARG_STRING, &options.db_dir_state, 0, "directory for internal state tdb files", NULL },
{ "reclock", 0, POPT_ARG_STRING, &options.recovery_lock, 0, "recovery lock", "lock" },
{ "pidfile", 0, POPT_ARG_STRING, &ctdbd_pidfile, 0, "location of PID file", "filename" },
{ "valgrinding", 0, POPT_ARG_NONE, &options.valgrinding, 0, "disable setscheduler SCHED_FIFO call, use mmap for tdbs", NULL },
{ "nosetsched", 0, POPT_ARG_NONE, &options.nosetsched, 0, "disable setscheduler SCHED_FIFO call, use mmap for tdbs", NULL },
{ "start-as-disabled", 0, POPT_ARG_NONE, &options.start_as_disabled, 0, "Node starts in disabled state", NULL },
{ "start-as-stopped", 0, POPT_ARG_NONE, &options.start_as_stopped, 0, "Node starts in stopped state", NULL },
{ "no-lmaster", 0, POPT_ARG_NONE, &options.no_lmaster, 0, "disable lmaster role on this node", NULL },
{ "no-recmaster", 0, POPT_ARG_NONE, &options.no_recmaster, 0, "disable recmaster role on this node", NULL },
{ "script-log-level", 0, POPT_ARG_INT, &options.script_log_level, 0, "log level of event script output", NULL },
{ "nopublicipcheck", 0, POPT_ARG_NONE, &options.no_publicipcheck, 0, "don't check we have/don't have the correct public ip addresses", NULL },
{ "max-persistent-check-errors", 0, POPT_ARG_INT,
&options.max_persistent_check_errors, 0,
"max allowed persistent check errors (default 0)", NULL },
{ "sloppy-start", 0, POPT_ARG_NONE, &fast_start, 0, "Do not perform full recovery on start", NULL },
POPT_TABLEEND
};
int opt, ret;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
struct tevent_context *ev;
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
exit(1);
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
talloc_enable_null_tracking();
fault_setup();
ev = tevent_context_init(NULL);
if (ev == NULL) {
DEBUG(DEBUG_ALERT,("tevent_context_init() failed\n"));
exit(1);
}
tevent_loop_allow_nesting(ev);
ctdb = ctdb_cmdline_init(ev);
ctdb->start_as_disabled = options.start_as_disabled;
ctdb->start_as_stopped = options.start_as_stopped;
script_log_level = options.script_log_level;
if (!ctdb_logging_init(ctdb, options.logging)) {
exit(1);
}
DEBUG(DEBUG_NOTICE,("CTDB starting on node\n"));
gettimeofday(&ctdb->ctdbd_start_time, NULL);
gettimeofday(&ctdb->last_recovery_started, NULL);
gettimeofday(&ctdb->last_recovery_finished, NULL);
ctdb->recovery_mode = CTDB_RECOVERY_NORMAL;
ctdb->recovery_master = (uint32_t)-1;
ctdb->upcalls = &ctdb_upcalls;
if (options.recovery_lock == NULL) {
DEBUG(DEBUG_WARNING, ("Recovery lock not set\n"));
}
ctdb->recovery_lock = options.recovery_lock;
TALLOC_FREE(ctdb->idr);
ret = reqid_init(ctdb, 0, &ctdb->idr);;
if (ret != 0) {
DEBUG(DEBUG_ALERT, ("reqid_init failed (%s)\n", strerror(ret)));
exit(1);
}
ctdb_tunables_set_defaults(ctdb);
ret = ctdb_set_transport(ctdb, options.transport);
if (ret == -1) {
DEBUG(DEBUG_ALERT,("ctdb_set_transport failed - %s\n", ctdb_errstr(ctdb)));
exit(1);
}
/* tell ctdb what address to listen on */
if (options.myaddress) {
ret = ctdb_set_address(ctdb, options.myaddress);
if (ret == -1) {
DEBUG(DEBUG_ALERT,("ctdb_set_address failed - %s\n", ctdb_errstr(ctdb)));
exit(1);
}
}
/* set ctdbd capabilities */
ctdb->capabilities = CTDB_CAP_DEFAULT;
if (options.no_lmaster != 0) {
ctdb->capabilities &= ~CTDB_CAP_LMASTER;
}
if (options.no_recmaster != 0) {
ctdb->capabilities &= ~CTDB_CAP_RECMASTER;
}
/* Initialise this node's PNN to the unknown value. This will
* be set to the correct value by either ctdb_add_node() as
* part of loading the nodes file or by
* ctdb_tcp_listen_automatic() when the transport is
* initialised. At some point we should de-optimise this and
* pull it out into ctdb_start_daemon() so it is done clearly
* and only in one place.
*/
ctdb->pnn = -1;
/* Default value for CTDB_BASE - don't override */
setenv("CTDB_BASE", CTDB_ETCDIR, 0);
/* tell ctdb what nodes are available */
if (options.nlist != NULL) {
ctdb->nodes_file = options.nlist;
} else {
ctdb->nodes_file =
talloc_asprintf(ctdb, "%s/nodes", getenv("CTDB_BASE"));
if (ctdb->nodes_file == NULL) {
DEBUG(DEBUG_ALERT,(__location__ " Out of memory\n"));
exit(1);
}
}
ctdb_load_nodes_file(ctdb);
ctdb->db_directory = options.db_dir;
mkdir_p_or_die(ctdb->db_directory, 0700);
ctdb->db_directory_persistent = options.db_dir_persistent;
mkdir_p_or_die(ctdb->db_directory_persistent, 0700);
ctdb->db_directory_state = options.db_dir_state;
mkdir_p_or_die(ctdb->db_directory_state, 0700);
if (options.public_interface) {
ctdb->default_public_interface = talloc_strdup(ctdb, options.public_interface);
CTDB_NO_MEMORY(ctdb, ctdb->default_public_interface);
}
if (options.event_script_dir != NULL) {
ctdb->event_script_dir = options.event_script_dir;
} else {
ctdb->event_script_dir = talloc_asprintf(ctdb, "%s/events.d",
getenv("CTDB_BASE"));
if (ctdb->event_script_dir == NULL) {
DEBUG(DEBUG_ALERT,(__location__ " Out of memory\n"));
exit(1);
}
}
if (options.notification_script != NULL) {
ret = ctdb_set_notification_script(ctdb, options.notification_script);
if (ret == -1) {
DEBUG(DEBUG_ALERT,("Unable to setup notification script\n"));
exit(1);
}
}
ctdb->valgrinding = (options.valgrinding == 1);
ctdb->do_setsched = (options.nosetsched != 1);
if (ctdb->valgrinding) {
ctdb->do_setsched = false;
}
ctdb->public_addresses_file = options.public_address_list;
ctdb->do_checkpublicip = (options.no_publicipcheck == 0);
if (options.max_persistent_check_errors < 0) {
ctdb->max_persistent_check_errors = 0xFFFFFFFFFFFFFFFFLL;
} else {
ctdb->max_persistent_check_errors = (uint64_t)options.max_persistent_check_errors;
}
/* start the protocol running (as a child) */
return ctdb_start_daemon(ctdb, interactive?false:true);
}
/**
* open connection so SAMR + Join Domain
* common code needed when adding or removing users
*/
static enum MAPISTATUS mapiadmin_samr_connect(struct mapiadmin_ctx *mapiadmin_ctx,
TALLOC_CTX *mem_ctx)
{
NTSTATUS status;
struct tevent_context *ev;
struct mapi_context *mapi_ctx;
struct mapi_profile *profile;
struct samr_Connect c;
struct samr_OpenDomain o;
struct samr_LookupDomain l;
struct policy_handle handle;
struct policy_handle domain_handle;
struct lsa_String name;
MAPI_RETVAL_IF(!mapiadmin_ctx, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->session, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->session->profile, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->session->profile->credentials, MAPI_E_NOT_INITIALIZED, NULL);
MAPI_RETVAL_IF(!mapiadmin_ctx->username, MAPI_E_NOT_INITIALIZED, NULL);
mapi_ctx = mapiadmin_ctx->session->mapi_ctx;
MAPI_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
profile = mapiadmin_ctx->session->profile;
mapiadmin_ctx->user_ctx = talloc_zero(mem_ctx, struct test_join);
MAPI_RETVAL_IF(!mapiadmin_ctx->user_ctx, MAPI_E_NOT_ENOUGH_RESOURCES ,NULL);
OC_DEBUG(3, "Connecting to SAMR");
ev = tevent_context_init(mem_ctx);
status = dcerpc_pipe_connect(mapiadmin_ctx->user_ctx,
&mapiadmin_ctx->user_ctx->p,
mapiadmin_ctx->dc_binding ?
mapiadmin_ctx->dc_binding :
mapiadmin_ctx->binding,
&ndr_table_samr,
profile->credentials, ev, mapi_ctx->lp_ctx);
MAPI_RETVAL_IF(!NT_STATUS_IS_OK(status), MAPI_E_CALL_FAILED, NULL);
profile = mapiadmin_ctx->session->profile;
c.in.system_name = NULL;
c.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
c.out.connect_handle = &handle;
status = dcerpc_samr_Connect_r(mapiadmin_ctx->user_ctx->p->binding_handle, mapiadmin_ctx->user_ctx, &c);
if (!NT_STATUS_IS_OK(status)) {
const char *errstr = nt_errstr(status);
if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
errstr = dcerpc_errstr(mapiadmin_ctx->user_ctx, mapiadmin_ctx->user_ctx->p->last_fault_code);
}
OC_DEBUG(3, "samr_Connect failed - %s", errstr);
return MAPI_E_CALL_FAILED;
}
OC_DEBUG(3, "Opening domain %s", profile->domain);
name.string = profile->domain;
l.in.connect_handle = &handle;
l.in.domain_name = &name;
l.out.sid = talloc(mem_ctx, struct dom_sid2 *);
talloc_steal(mapiadmin_ctx->user_ctx, l.out.sid);
status = dcerpc_samr_LookupDomain_r(mapiadmin_ctx->user_ctx->p->binding_handle, mapiadmin_ctx->user_ctx, &l);
if (!NT_STATUS_IS_OK(status)) {
OC_DEBUG(3, "LookupDomain failed - %s", nt_errstr(status));
return MAPI_E_CALL_FAILED;
}
mapiadmin_ctx->user_ctx->dom_sid = *l.out.sid;
mapiadmin_ctx->user_ctx->dom_netbios_name = talloc_strdup(mapiadmin_ctx->user_ctx, profile->domain);
if (!mapiadmin_ctx->user_ctx->dom_netbios_name) return MAPI_E_CALL_FAILED;
o.in.connect_handle = &handle;
o.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
o.in.sid = *l.out.sid;
o.out.domain_handle = &domain_handle;
status = dcerpc_samr_OpenDomain_r(mapiadmin_ctx->user_ctx->p->binding_handle, mapiadmin_ctx->user_ctx, &o);
if (!NT_STATUS_IS_OK(status)) {
OC_DEBUG(3, "OpenDomain failed - %s", nt_errstr(status));
return MAPI_E_CALL_FAILED;
}
mapiadmin_ctx->handle = talloc_memdup(mem_ctx, &domain_handle, sizeof (struct policy_handle));
errno = 0;
return MAPI_E_SUCCESS;
}
/**
\details Initialize the EMSMDBP context and open connections to
Samba databases.
\param lp_ctx pointer to the loadparm_context
\param username account name for current session
\param ldb_ctx pointer to the openchange dispatcher ldb database
\return Allocated emsmdbp_context pointer on success, otherwise
NULL
*/
_PUBLIC_ struct emsmdbp_context *emsmdbp_init(struct loadparm_context *lp_ctx,
const char *username,
void *ldb_ctx)
{
TALLOC_CTX *mem_ctx;
struct emsmdbp_context *emsmdbp_ctx;
struct tevent_context *ev;
enum mapistore_error ret;
/* Sanity Checks */
if (!lp_ctx) return NULL;
mem_ctx = talloc_named(NULL, 0, "emsmdbp_init");
emsmdbp_ctx = talloc_zero(mem_ctx, struct emsmdbp_context);
if (!emsmdbp_ctx) {
talloc_free(mem_ctx);
return NULL;
}
emsmdbp_ctx->mem_ctx = mem_ctx;
ev = tevent_context_init(mem_ctx);
if (!ev) {
talloc_free(mem_ctx);
return NULL;
}
tevent_loop_allow_nesting(ev);
/* Save a pointer to the loadparm context */
emsmdbp_ctx->lp_ctx = lp_ctx;
/* return an opaque context pointer on samDB database */
emsmdbp_ctx->samdb_ctx = samdb_connect(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0);
if (!emsmdbp_ctx->samdb_ctx) {
talloc_free(mem_ctx);
DEBUG(0, ("[%s:%d]: Connection to \"sam.ldb\" failed\n", __FUNCTION__, __LINE__));
return NULL;
}
/* Reference global OpenChange dispatcher database pointer within current context */
emsmdbp_ctx->oc_ctx = ldb_ctx;
/* Initialize the mapistore context */
emsmdbp_ctx->mstore_ctx = mapistore_init(mem_ctx, lp_ctx, NULL);
if (!emsmdbp_ctx->mstore_ctx) {
DEBUG(0, ("[%s:%d]: MAPISTORE initialization failed\n", __FUNCTION__, __LINE__));
talloc_free(mem_ctx);
return NULL;
}
ret = mapistore_set_connection_info(emsmdbp_ctx->mstore_ctx, emsmdbp_ctx->samdb_ctx, emsmdbp_ctx->oc_ctx, username);
if (ret != MAPISTORE_SUCCESS) {
DEBUG(0, ("[%s:%d]: MAPISTORE connection info initialization failed\n", __FUNCTION__, __LINE__));
talloc_free(mem_ctx);
return NULL;
}
talloc_set_destructor((void *)emsmdbp_ctx->mstore_ctx, (int (*)(void *))emsmdbp_mapi_store_destructor);
/* Initialize MAPI handles context */
emsmdbp_ctx->handles_ctx = mapi_handles_init(mem_ctx);
if (!emsmdbp_ctx->handles_ctx) {
DEBUG(0, ("[%s:%d]: MAPI handles context initialization failed\n", __FUNCTION__, __LINE__));
talloc_free(mem_ctx);
return NULL;
}
talloc_set_destructor((void *)emsmdbp_ctx->handles_ctx, (int (*)(void *))emsmdbp_mapi_handles_destructor);
return emsmdbp_ctx;
}
int main(int argc, const char **argv)
{
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
struct db_context *db;
uint16_t count;
const char *dbname;
const char *opname;
dbwrap_op op;
const char *keyname = "";
const char *keytype = "int32";
dbwrap_type type;
const char *valuestr = "0";
int32_t value = 0;
TALLOC_CTX *mem_ctx = talloc_stackframe();
int ret = 1;
load_case_tables();
DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
dbf = x_stderr;
AllowDebugChange = false;
lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
if ((argc < 3) || (argc > 6)) {
d_fprintf(stderr,
"USAGE: %s <database> <op> [<key> [<type> [<value>]]]\n"
" ops: fetch, store, delete, erase, listkeys\n"
" types: int32, uint32\n",
argv[0]);
goto done;
}
dbname = argv[1];
opname = argv[2];
if (strcmp(opname, "store") == 0) {
if (argc != 6) {
d_fprintf(stderr, "ERROR: operation 'store' requires "
"value argument\n");
goto done;
}
valuestr = argv[5];
keytype = argv[4];
keyname = argv[3];
op = OP_STORE;
} else if (strcmp(opname, "fetch") == 0) {
if (argc != 5) {
d_fprintf(stderr, "ERROR: operation 'fetch' requires "
"type but not value argument\n");
goto done;
}
op = OP_FETCH;
keytype = argv[4];
keyname = argv[3];
} else if (strcmp(opname, "delete") == 0) {
if (argc != 4) {
d_fprintf(stderr, "ERROR: operation 'delete' does "
"not allow type nor value argument\n");
goto done;
}
keyname = argv[3];
op = OP_DELETE;
} else if (strcmp(opname, "erase") == 0) {
if (argc != 3) {
d_fprintf(stderr, "ERROR: operation 'erase' does "
"not take a key argument\n");
goto done;
}
op = OP_ERASE;
} else if (strcmp(opname, "listkeys") == 0) {
if (argc != 3) {
d_fprintf(stderr, "ERROR: operation 'listkeys' does "
"not take a key argument\n");
goto done;
}
op = OP_LISTKEYS;
} else {
d_fprintf(stderr,
"ERROR: invalid op '%s' specified\n"
" supported ops: fetch, store, delete\n",
opname);
goto done;
}
if (strcmp(keytype, "int32") == 0) {
type = TYPE_INT32;
value = (int32_t)strtol(valuestr, NULL, 10);
} else if (strcmp(keytype, "uint32") == 0) {
type = TYPE_UINT32;
value = (int32_t)strtoul(valuestr, NULL, 10);
} else {
d_fprintf(stderr, "ERROR: invalid type '%s' specified.\n"
" supported types: int32, uint32\n",
keytype);
goto done;
}
evt_ctx = tevent_context_init(mem_ctx);
if (evt_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init event context\n");
goto done;
}
msg_ctx = messaging_init(mem_ctx, server_id_self(), evt_ctx);
if (msg_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init messaging context\n");
goto done;
}
db = db_open(mem_ctx, dbname, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
if (db == NULL) {
d_fprintf(stderr, "ERROR: could not open dbname\n");
goto done;
}
for (count = 0; dispatch_table[count].cmd != NULL; count++) {
if ((op == dispatch_table[count].op) &&
(type == dispatch_table[count].type))
{
ret = dispatch_table[count].cmd(db, keyname, &value);
break;
}
}
done:
TALLOC_FREE(mem_ctx);
return ret;
}
int main(int argc, const char **argv)
{
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
struct db_context *db;
uint16_t count;
const char *dbname;
const char *opname;
dbwrap_op op;
const char *keyname = "";
const char *keytype = "int32";
dbwrap_type type;
const char *valuestr = "0";
TALLOC_CTX *mem_ctx = talloc_stackframe();
int ret = 1;
struct poptOption popt_options[] = {
POPT_AUTOHELP
POPT_COMMON_SAMBA
POPT_TABLEEND
};
int opt;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
load_case_tables();
lp_set_cmdline("log level", "0");
setup_logging(argv[0], DEBUG_STDERR);
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
goto done;
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
lp_load_global(get_dyn_CONFIGFILE());
if ((extra_argc < 2) || (extra_argc > 5)) {
d_fprintf(stderr,
"USAGE: %s <database> <op> [<key> [<type> [<value>]]]\n"
" ops: fetch, store, delete, erase, listkeys\n"
" types: int32, uint32, string, hex\n",
argv[0]);
goto done;
}
dbname = extra_argv[0];
opname = extra_argv[1];
if (strcmp(opname, "store") == 0) {
if (extra_argc != 5) {
d_fprintf(stderr, "ERROR: operation 'store' requires "
"value argument\n");
goto done;
}
valuestr = extra_argv[4];
keytype = extra_argv[3];
keyname = extra_argv[2];
op = OP_STORE;
} else if (strcmp(opname, "fetch") == 0) {
if (extra_argc != 4) {
d_fprintf(stderr, "ERROR: operation 'fetch' requires "
"type but not value argument\n");
goto done;
}
op = OP_FETCH;
keytype = extra_argv[3];
keyname = extra_argv[2];
} else if (strcmp(opname, "delete") == 0) {
if (extra_argc != 3) {
d_fprintf(stderr, "ERROR: operation 'delete' does "
"not allow type nor value argument\n");
goto done;
}
keyname = extra_argv[2];
op = OP_DELETE;
} else if (strcmp(opname, "erase") == 0) {
if (extra_argc != 2) {
d_fprintf(stderr, "ERROR: operation 'erase' does "
"not take a key argument\n");
goto done;
}
op = OP_ERASE;
} else if (strcmp(opname, "listkeys") == 0) {
if (extra_argc != 2) {
d_fprintf(stderr, "ERROR: operation 'listkeys' does "
"not take a key argument\n");
goto done;
}
op = OP_LISTKEYS;
} else {
d_fprintf(stderr,
"ERROR: invalid op '%s' specified\n"
" supported ops: fetch, store, delete\n",
opname);
goto done;
}
if (strcmp(keytype, "int32") == 0) {
type = TYPE_INT32;
} else if (strcmp(keytype, "uint32") == 0) {
type = TYPE_UINT32;
} else if (strcmp(keytype, "string") == 0) {
type = TYPE_STRING;
} else if (strcmp(keytype, "hex") == 0) {
type = TYPE_HEX;
} else {
d_fprintf(stderr, "ERROR: invalid type '%s' specified.\n"
" supported types: int32, uint32, "
"string, hex\n",
keytype);
goto done;
}
evt_ctx = tevent_context_init(mem_ctx);
if (evt_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init event context\n");
goto done;
}
msg_ctx = messaging_init(mem_ctx, evt_ctx);
if (msg_ctx == NULL) {
d_fprintf(stderr, "ERROR: could not init messaging context\n");
goto done;
}
db = db_open(mem_ctx, dbname, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
if (db == NULL) {
d_fprintf(stderr, "ERROR: could not open dbname\n");
goto done;
}
for (count = 0; dispatch_table[count].cmd != NULL; count++) {
if ((op == dispatch_table[count].op) &&
(type == dispatch_table[count].type))
{
ret = dispatch_table[count].cmd(db, keyname, valuestr);
break;
}
}
done:
TALLOC_FREE(mem_ctx);
return ret;
}
int main(int argc, const char **argv)
{
poptContext pc;
int opt;
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
static struct poptOption long_options[] = {
/* POPT_AUTOHELP */
{ NULL, '\0', POPT_ARG_INCLUDE_TABLE, help_options,
0, "Help options:", NULL },
{ "timeout", 't', POPT_ARG_INT, &timeout, 't',
"Set timeout value in seconds", "TIMEOUT" },
POPT_COMMON_SAMBA
POPT_TABLEEND
};
TALLOC_CTX *frame = talloc_stackframe();
int ret = 0;
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
/* Parse command line arguments using popt */
pc = poptGetContext(
"smbcontrol", argc, (const char **)argv, long_options, 0);
poptSetOtherOptionHelp(pc, "[OPTION...] <destination> <message-type> "
"<parameters>");
if (argc == 1)
usage(pc);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
case 't': /* --timeout */
break;
default:
fprintf(stderr, "Invalid option\n");
poptPrintHelp(pc, stderr, 0);
break;
}
}
/* We should now have the remaining command line arguments in
argv. The argc parameter should have been decremented to the
correct value in the above switch statement. */
argv = (const char **)poptGetArgs(pc);
argc = 0;
if (argv != NULL) {
while (argv[argc] != NULL) {
argc++;
}
}
if (argc <= 1)
usage(pc);
lp_load_global(get_dyn_CONFIGFILE());
/* Need to invert sense of return code -- samba
* routines mostly return True==1 for success, but
* shell needs 0. */
if (!(evt_ctx = tevent_context_init(NULL)) ||
!(msg_ctx = messaging_init(NULL, evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
TALLOC_FREE(frame);
exit(1);
}
ret = !do_command(evt_ctx, msg_ctx, argc, argv);
TALLOC_FREE(frame);
return ret;
}
int main(int argc, char *argv[])
{
int ret;
struct ctdb_mutex_rados_state *cmr_state;
progname = argv[0];
if (argc != 5) {
fprintf(stderr, "Usage: %s <Ceph Cluster> <Ceph user> "
"<RADOS pool> <RADOS object>\n",
progname);
ret = -EINVAL;
goto err_out;
}
ret = setvbuf(stdout, NULL, _IONBF, 0);
if (ret != 0) {
fprintf(stderr, "Failed to configure unbuffered stdout I/O\n");
}
cmr_state = talloc_zero(NULL, struct ctdb_mutex_rados_state);
if (cmr_state == NULL) {
fprintf(stdout, CTDB_MUTEX_STATUS_ERROR);
ret = -ENOMEM;
goto err_out;
}
cmr_state->ceph_cluster_name = argv[1];
cmr_state->ceph_auth_name = argv[2];
cmr_state->pool_name = argv[3];
cmr_state->object = argv[4];
cmr_state->ppid = getppid();
if (cmr_state->ppid == 1) {
/*
* The original parent is gone and the process has
* been reparented to init. This can happen if the
* helper is started just as the parent is killed
* during shutdown. The error message doesn't need to
* be stellar, since there won't be anything around to
* capture and log it...
*/
fprintf(stderr, "%s: PPID == 1\n", progname);
ret = -EPIPE;
goto err_state_free;
}
cmr_state->ev = tevent_context_init(cmr_state);
if (cmr_state->ev == NULL) {
fprintf(stderr, "tevent_context_init failed\n");
fprintf(stdout, CTDB_MUTEX_STATUS_ERROR);
ret = -ENOMEM;
goto err_state_free;
}
/* wait for sigterm */
cmr_state->sig_ev = tevent_add_signal(cmr_state->ev, cmr_state, SIGTERM, 0,
ctdb_mutex_rados_sigterm_cb,
cmr_state);
if (cmr_state->sig_ev == NULL) {
fprintf(stderr, "Failed to create signal event\n");
fprintf(stdout, CTDB_MUTEX_STATUS_ERROR);
ret = -ENOMEM;
goto err_state_free;
}
/* periodically check parent */
cmr_state->timer_ev = tevent_add_timer(cmr_state->ev, cmr_state,
tevent_timeval_current_ofs(5, 0),
ctdb_mutex_rados_timer_cb,
cmr_state);
if (cmr_state->timer_ev == NULL) {
fprintf(stderr, "Failed to create timer event\n");
fprintf(stdout, CTDB_MUTEX_STATUS_ERROR);
ret = -ENOMEM;
goto err_state_free;
}
ret = ctdb_mutex_rados_ctx_create(cmr_state->ceph_cluster_name,
cmr_state->ceph_auth_name,
cmr_state->pool_name,
&cmr_state->ceph_cluster,
&cmr_state->ioctx);
if (ret < 0) {
fprintf(stdout, CTDB_MUTEX_STATUS_ERROR);
goto err_state_free;
}
ret = ctdb_mutex_rados_lock(cmr_state->ioctx, cmr_state->object);
if ((ret == -EEXIST) || (ret == -EBUSY)) {
fprintf(stdout, CTDB_MUTEX_STATUS_CONTENDED);
goto err_ctx_cleanup;
} else if (ret < 0) {
fprintf(stdout, CTDB_MUTEX_STATUS_ERROR);
goto err_ctx_cleanup;
}
cmr_state->holding_mutex = true;
fprintf(stdout, CTDB_MUTEX_STATUS_HOLDING);
/* wait for the signal / timer events to do their work */
ret = tevent_loop_wait(cmr_state->ev);
if (ret < 0) {
goto err_ctx_cleanup;
}
err_ctx_cleanup:
ctdb_mutex_rados_ctx_destroy(cmr_state->ceph_cluster,
cmr_state->ioctx);
err_state_free:
talloc_free(cmr_state);
err_out:
return ret ? 1 : 0;
}
void setup_simple(void)
{
errno_t ret;
char *conf_db;
const char *val[2];
val[1] = NULL;
fail_unless(test_ctx == NULL, "Simple context already initialized.");
test_ctx = talloc_zero(NULL, struct simple_test_ctx);
fail_unless(test_ctx != NULL, "Cannot create simple test context.");
test_ctx->ev = tevent_context_init(test_ctx);
fail_unless(test_ctx->ev != NULL, "Cannot create tevent context.");
test_ctx->ctx = talloc_zero(test_ctx, struct simple_ctx);
fail_unless(test_ctx->ctx != NULL, "Cannot create simple context.");
/* Create tests directory if it doesn't exist */
/* (relative to current dir) */
ret = mkdir(TESTS_PATH, 0775);
fail_if(ret == -1 && errno != EEXIST,
"Could not create %s directory", TESTS_PATH);
conf_db = talloc_asprintf(test_ctx, "%s/%s", TESTS_PATH, TEST_CONF_FILE);
fail_if(conf_db == NULL, "Out of memory, aborting!");
DEBUG(SSSDBG_TRACE_LIBS, "CONFDB: %s\n", conf_db);
/* Connect to the conf db */
ret = confdb_init(test_ctx, &test_ctx->confdb, conf_db);
fail_if(ret != EOK, "Could not initialize connection to the confdb");
val[0] = "LOCAL";
ret = confdb_add_param(test_ctx->confdb, true,
"config/sssd", "domains", val);
fail_if(ret != EOK, "Could not initialize domains placeholder");
val[0] = "local";
ret = confdb_add_param(test_ctx->confdb, true,
"config/domain/LOCAL", "id_provider", val);
fail_if(ret != EOK, "Could not initialize provider");
val[0] = "TRUE";
ret = confdb_add_param(test_ctx->confdb, true,
"config/domain/LOCAL", "enumerate", val);
fail_if(ret != EOK, "Could not initialize LOCAL domain");
val[0] = "TRUE";
ret = confdb_add_param(test_ctx->confdb, true,
"config/domain/LOCAL", "cache_credentials", val);
fail_if(ret != EOK, "Could not initialize LOCAL domain");
ret = sssd_domain_init(test_ctx, test_ctx->confdb, "local",
TESTS_PATH, &test_ctx->ctx->domain);
fail_if(ret != EOK, "Could not initialize connection to the sysdb (%d)", ret);
test_ctx->sysdb = test_ctx->ctx->domain->sysdb;
test_ctx->ctx->domain->case_sensitive = true;
test_ctx->ctx->domain->mpg = false; /* Simulate an LDAP domain better */
/* be_ctx */
test_ctx->be_ctx = talloc_zero(test_ctx, struct be_ctx);
fail_if(test_ctx->be_ctx == NULL, "Unable to setup be_ctx");
test_ctx->be_ctx->cdb = test_ctx->confdb;
test_ctx->be_ctx->ev = test_ctx->ev;
test_ctx->be_ctx->conf_path = "config/domain/LOCAL";
test_ctx->be_ctx->domain = test_ctx->ctx->domain;
test_ctx->ctx->be_ctx = test_ctx->be_ctx;
ret = sss_names_init(test_ctx->ctx->domain, test_ctx->confdb,
"LOCAL", &test_ctx->be_ctx->domain->names);
fail_if(ret != EOK, "Unable to setup domain names (%d)", ret);
}
int main(int argc, char *argv[])
{
struct tevent_context *evt_ctx;
struct messaging_context *msg_ctx;
pid_t pid;
int i, n;
char buf[12];
int ret;
load_case_tables();
setup_logging(argv[0], DEBUG_STDOUT);
lp_load(get_dyn_CONFIGFILE(),False,False,False,True);
if (!(evt_ctx = tevent_context_init(NULL)) ||
!(msg_ctx = messaging_init(NULL, procid_self(), evt_ctx))) {
fprintf(stderr, "could not init messaging context\n");
exit(1);
}
if (argc != 3) {
fprintf(stderr, "%s: Usage - %s pid count\n", argv[0],
argv[0]);
exit(1);
}
pid = atoi(argv[1]);
n = atoi(argv[2]);
messaging_register(msg_ctx, NULL, MSG_PONG, pong_message);
for (i=0;i<n;i++) {
messaging_send(msg_ctx, pid_to_procid(pid), MSG_PING,
&data_blob_null);
}
while (pong_count < i) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
/* Now test that the duplicate filtering code works. */
pong_count = 0;
strlcpy(buf, "1234567890", sizeof(buf));
for (i=0;i<n;i++) {
messaging_send(msg_ctx, messaging_server_id(msg_ctx), MSG_PING,
&data_blob_null);
messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
MSG_PING,(uint8 *)buf, 11);
}
for (i=0;i<n;i++) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
if (pong_count != 2) {
fprintf(stderr, "Duplicate filter failed (%d).\n", pong_count);
}
/* Speed testing */
pong_count = 0;
{
struct timeval tv = timeval_current();
size_t timelimit = n;
size_t ping_count = 0;
printf("Sending pings for %d seconds\n", (int)timelimit);
while (timeval_elapsed(&tv) < timelimit) {
if(NT_STATUS_IS_OK(messaging_send_buf(
msg_ctx, pid_to_procid(pid),
MSG_PING,
(uint8 *)buf, 11)))
ping_count++;
if(NT_STATUS_IS_OK(messaging_send(
msg_ctx, pid_to_procid(pid),
MSG_PING, &data_blob_null)))
ping_count++;
while (ping_count > pong_count + 20) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
}
printf("waiting for %d remaining replies (done %d)\n",
(int)(ping_count - pong_count), pong_count);
while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
ret = tevent_loop_once(evt_ctx);
if (ret != 0) {
break;
}
}
if (ping_count != pong_count) {
fprintf(stderr, "ping test failed! received %d, sent "
"%d\n", pong_count, (int)ping_count);
}
printf("ping rate of %.0f messages/sec\n",
(ping_count+pong_count)/timeval_elapsed(&tv));
}
return (0);
}
static int
pmda_ctdb_daemon_connect(void)
{
const char *socket_name;
int ret;
struct sockaddr_un addr;
ev = tevent_context_init(NULL);
if (ev == NULL) {
fprintf(stderr, "Failed to init event ctx\n");
return -1;
}
ctdb = ctdb_init(ev);
if (ctdb == NULL) {
fprintf(stderr, "Failed to init ctdb\n");
goto err_ev;
}
socket_name = getenv("CTDB_SOCKET");
if (socket_name == NULL) {
socket_name = CTDB_SOCKET;
}
ret = ctdb_set_socketname(ctdb, socket_name);
if (ret == -1) {
fprintf(stderr, "ctdb_set_socketname failed - %s\n",
ctdb_errstr(ctdb));
goto err_ctdb;
}
/*
* ctdb_socket_connect() sets a default queue callback handler that
* calls exit() if ctdbd is unavailable on recv, use our own wrapper to
* work around this
*/
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, ctdb->daemon.name, sizeof(addr.sun_path));
ctdb->daemon.sd = socket(AF_UNIX, SOCK_STREAM, 0);
if (ctdb->daemon.sd == -1) {
fprintf(stderr, "Failed to open client socket\n");
goto err_ctdb;
}
set_nonblocking(ctdb->daemon.sd);
set_close_on_exec(ctdb->daemon.sd);
if (connect(ctdb->daemon.sd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
fprintf(stderr, "Failed to connect to ctdb daemon via %s\n",
ctdb->daemon.name);
goto err_sd;
}
ctdb->daemon.queue = ctdb_queue_setup(ctdb, ctdb, ctdb->daemon.sd,
CTDB_DS_ALIGNMENT,
pmda_ctdb_q_read_cb, ctdb,
"to-ctdbd");
if (ctdb->daemon.queue == NULL) {
fprintf(stderr, "Failed to setup queue\n");
goto err_sd;
}
ctdb->pnn = ctdb_ctrl_getpnn(ctdb, timeval_current_ofs(3, 0),
CTDB_CURRENT_NODE);
if (ctdb->pnn == (uint32_t)-1) {
fprintf(stderr, "Failed to get ctdb pnn\n");
goto err_sd;
}
return 0;
err_sd:
close(ctdb->daemon.sd);
err_ctdb:
talloc_free(ctdb);
err_ev:
talloc_free(ev);
ctdb = NULL;
return -1;
}
/**
\details Initialize the named properties database or return pointer
to the existing one if already initialized/opened.
\param mem_ctx pointer to the memory context
\param ldb_ctx pointer on pointer to the ldb context the function
returns
\return MAPISTORE_SUCCESS on success, otherwise MAPISTORE error
*/
enum mapistore_error mapistore_namedprops_init(TALLOC_CTX *mem_ctx, struct ldb_context **_ldb_ctx)
{
int ret;
struct stat sb;
struct ldb_context *ldb_ctx = NULL;
struct ldb_ldif *ldif;
char *filename;
FILE *f;
struct tevent_context *ev;
char *database;
/* Sanity checks */
MAPISTORE_RETVAL_IF(!mem_ctx, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
MAPISTORE_RETVAL_IF(!_ldb_ctx, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
ev = tevent_context_init(mem_ctx);
MAPISTORE_RETVAL_IF(!ev, MAPISTORE_ERR_NO_MEMORY, NULL);
database = talloc_asprintf(mem_ctx, "%s/%s", mapistore_get_mapping_path(), MAPISTORE_DB_NAMED);
DEBUG(0, ("database = %s\n", database));
/* Step 1. Stat the database and populate it if it doesn't exist */
if (stat(database, &sb) == -1) {
ldb_ctx = mapistore_ldb_wrap_connect(ldb_ctx, ev, database, 0);
talloc_free(database);
MAPISTORE_RETVAL_IF(!ldb_ctx, MAPISTORE_ERR_DATABASE_INIT, NULL);
filename = talloc_asprintf(mem_ctx, "%s/mapistore_namedprops.ldif",
mapistore_namedprops_get_ldif_path());
f = fopen(filename, "r");
talloc_free(filename);
MAPISTORE_RETVAL_IF(!f, MAPISTORE_ERROR, NULL);
ldb_transaction_start(ldb_ctx);
while ((ldif = ldb_ldif_read_file(ldb_ctx, f))) {
struct ldb_message *normalized_msg;
ret = ldb_msg_normalize(ldb_ctx, mem_ctx, ldif->msg, &normalized_msg);
MAPISTORE_RETVAL_IF(ret, MAPISTORE_ERR_DATABASE_INIT, NULL);
ret = ldb_add(ldb_ctx, normalized_msg);
talloc_free(normalized_msg);
if (ret != LDB_SUCCESS) {
fclose(f);
MAPISTORE_RETVAL_IF(ret, MAPISTORE_ERR_DATABASE_INIT, NULL);
}
ldb_ldif_read_free(ldb_ctx, ldif);
}
ldb_transaction_commit(ldb_ctx);
fclose(f);
} else {
ldb_ctx = mapistore_ldb_wrap_connect(ldb_ctx, ev, database, 0);
talloc_free(database);
MAPISTORE_RETVAL_IF(!ldb_ctx, MAPISTORE_ERR_DATABASE_INIT, NULL);
}
*_ldb_ctx = ldb_ctx;
return MAPISTORE_SUCCESS;
}
NTSTATUS smb1cli_trans(TALLOC_CTX *mem_ctx, struct smbXcli_conn *conn,
uint8_t trans_cmd,
uint8_t additional_flags, uint8_t clear_flags,
uint16_t additional_flags2, uint16_t clear_flags2,
uint32_t timeout_msec,
uint32_t pid, uint16_t tid, uint16_t uid,
const char *pipe_name, uint16_t fid, uint16_t function,
int flags,
uint16_t *setup, uint8_t num_setup, uint8_t max_setup,
uint8_t *param, uint32_t num_param, uint32_t max_param,
uint8_t *data, uint32_t num_data, uint32_t max_data,
uint16_t *recv_flags2,
uint16_t **rsetup, uint8_t min_rsetup, uint8_t *num_rsetup,
uint8_t **rparam, uint32_t min_rparam, uint32_t *num_rparam,
uint8_t **rdata, uint32_t min_rdata, uint32_t *num_rdata)
{
TALLOC_CTX *frame = talloc_stackframe();
struct tevent_context *ev;
struct tevent_req *req;
NTSTATUS status = NT_STATUS_OK;
if (smbXcli_conn_has_async_calls(conn)) {
/*
* Can't use sync call while an async call is in flight
*/
status = NT_STATUS_INVALID_PARAMETER_MIX;
goto fail;
}
ev = tevent_context_init(frame);
if (ev == NULL) {
status = NT_STATUS_NO_MEMORY;
goto fail;
}
req = smb1cli_trans_send(frame, ev, conn, trans_cmd,
additional_flags, clear_flags,
additional_flags2, clear_flags2,
timeout_msec,
pid, tid, uid,
pipe_name, fid, function, flags,
setup, num_setup, max_setup,
param, num_param, max_param,
data, num_data, max_data);
if (req == NULL) {
status = NT_STATUS_NO_MEMORY;
goto fail;
}
if (!tevent_req_poll(req, ev)) {
status = map_nt_error_from_unix_common(errno);
goto fail;
}
status = smb1cli_trans_recv(req, mem_ctx, recv_flags2,
rsetup, min_rsetup, num_rsetup,
rparam, min_rparam, num_rparam,
rdata, min_rdata, num_rdata);
fail:
TALLOC_FREE(frame);
return status;
}
/*
main program
*/
int main(int argc, const char *argv[])
{
struct ctdb_context *ctdb;
struct ctdb_db_context *ctdb_db;
struct tevent_context *ev;
TDB_DATA key;
struct poptOption popt_options[] = {
POPT_AUTOHELP
{ "record", 'r', POPT_ARG_STRING, &TESTKEY, 0, "record", "string" },
POPT_TABLEEND
};
int opt;
const char **extra_argv;
int extra_argc = 0;
poptContext pc;
pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
default:
fprintf(stderr, "Invalid option %s: %s\n",
poptBadOption(pc, 0), poptStrerror(opt));
exit(1);
}
}
/* setup the remaining options for the main program to use */
extra_argv = poptGetArgs(pc);
if (extra_argv) {
extra_argv++;
while (extra_argv[extra_argc]) extra_argc++;
}
ev = tevent_context_init(NULL);
ctdb = ctdb_cmdline_client(ev, timeval_current_ofs(3, 0));
if (ctdb == NULL) {
printf("failed to connect to ctdb daemon.\n");
exit(1);
}
key.dptr = discard_const(TESTKEY);
key.dsize = strlen(TESTKEY);
/* attach to a specific database */
ctdb_db = ctdb_attach(ctdb, timeval_current_ofs(3, 0), "test.tdb",
false, 0);
if (!ctdb_db) {
fprintf(stderr, "ctdb_attach failed - %s\n", ctdb_errstr(ctdb));
exit(10);
}
printf("Waiting for cluster\n");
while (1) {
uint32_t recmode=1;
ctdb_ctrl_getrecmode(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, &recmode);
if (recmode == 0) break;
tevent_loop_once(ev);
}
fetch_readonly_once(ctdb, ctdb_db, key);
return 0;
}
