static
Clause conflicts(Clause a, Clause b)
{
if (!unit_clause(a) || !unit_clause(b))
return NULL;
else if (a->literals->sign == b->literals->sign)
return NULL;
else {
Clause empty = NULL;
Term a_atom = a->literals->atom;
Term b_atom = b->literals->atom;
Context ca = get_context();
Context cb = get_context();
Trail tr = NULL;
if (unify(a_atom, ca, b_atom, cb, &tr)) {
Ilist j = NULL;
undo_subst(tr);
empty = get_clause();
j = ilist_append(j, a->id);
j = ilist_append(j, 1);
j = ilist_append(j, b->id);
j = ilist_append(j, 1);
empty->justification = resolve_just(j, BINARY_RES_JUST);
upward_clause_links(empty);
assign_clause_id(empty);
}
free_context(ca);
free_context(cb);
return empty;
}
} /* conflicts */
int main(int argc, char *argv[])
{
int restart = 0;
int os_handler_installed = 0;
int rc = 0;
ddns_t *ctx = NULL;
do {
rc = init_context(&ctx);
if (rc != 0)
break;
if (!os_handler_installed) {
rc = os_install_signal_handler(ctx);
if (rc != 0) {
logit(LOG_WARNING,
"Failed installing OS signal handler: %s", errorcode_get_name(rc));
break;
}
os_handler_installed = 1;
}
rc = dyn_dns_main(ctx, argc, argv);
if (rc == RC_RESTART) {
restart = 1;
/* do some cleanup if restart requested */
rc = free_context(ctx);
if (rc != 0)
logit(LOG_WARNING,
"Failed cleaning up before restart: %s, ignoring...",
errorcode_get_name(rc));
} else {
/* Error, or OK. In either case exit outer loop. */
restart = 0;
}
}
while (restart);
if (rc != 0)
logit(LOG_WARNING, "Failed %sstarting daemon: %s", restart ? "re" : "", errorcode_get_name(rc));
/* Cleanup */
free_context(ctx);
os_close_dbg_output();
return (int)rc;
}
static void on_sequence_complete(GIO_ASYNCSEQ_HANDLE async_seq_handle, gpointer previous_result)
{
READ_CONTEXT* context = (READ_CONTEXT*)GIO_Async_Seq_GetContext(async_seq_handle);
GBytes* data = (GBytes*)previous_result;
const unsigned char* buffer;
size_t size;
if (data != NULL)
{
buffer = g_bytes_get_data(data, &size);
}
else
{
buffer = NULL;
size = 0;
}
/*Codes_SRS_BLEIO_GATT_13_032: [ BLEIO_gatt_read_char_by_uuid shall invoke on_bleio_gatt_attrib_read_complete when the read operation completes. ]*/
/*Codes_SRS_BLEIO_GATT_13_033: [ BLEIO_gatt_read_char_by_uuid shall pass the value of the callback_context parameter to on_bleio_gatt_attrib_read_complete as the context parameter when it is invoked. ]*/
/*Codes_SRS_BLEIO_GATT_13_034: [BLEIO_gatt_read_char_by_uuid, when successful, shall supply the data that has been read to the on_bleio_gatt_attrib_read_complete callback along with the value BLEIO_GATT_OK for the result parameter.]*/
context->on_read_complete(
(BLEIO_GATT_HANDLE)context->handle_data,
context->callback_context,
BLEIO_GATT_OK,
buffer,
size
);
g_bytes_unref(data);
free_context(context);
}
OPENVPN_EXPORT void
openvpn_plugin_close_v1(openvpn_plugin_handle_t handle)
{
struct down_root_context *context = (struct down_root_context *) handle;
if (DEBUG(context->verb))
{
fprintf(stderr, "DOWN-ROOT: close\n");
}
if (context->foreground_fd >= 0)
{
/* tell background process to exit */
if (send_control(context->foreground_fd, COMMAND_EXIT) == -1)
{
warn("DOWN-ROOT: Error signalling background process to exit");
}
/* wait for background process to exit */
if (context->background_pid > 0)
{
waitpid(context->background_pid, NULL, 0);
}
close(context->foreground_fd);
context->foreground_fd = -1;
}
free_context(context);
}
static ErlDrvData
exmpp_xml_start(ErlDrvPort port, char *command)
{
struct exmpp_xml_data *edd;
/* Set binary mode. */
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
/* Allocate driver data structure. */
edd = driver_alloc(sizeof(*edd));
if (edd == NULL)
return (ERL_DRV_ERROR_GENERAL);
/* Initialize generic context. */
if (init_context(&edd->ctx) != 0) {
driver_free(edd);
return (ERL_DRV_ERROR_GENERAL);
}
edd->ctx.make_attributes = exmpp_xml_cb_make_attributes;
/* Initialize driver instance's context. */
edd->parser = NULL;
/* Initialize the declared_nss list. */
edd->declared_nss = driver_alloc(sizeof(*(edd->declared_nss)));
if (edd->declared_nss == NULL) {
free_context(&edd->ctx);
driver_free(edd);
return (ERL_DRV_ERROR_GENERAL);
}
ei_x_new(edd->declared_nss);
return ((ErlDrvData)edd);
}
void touch(const char* path, const char* host, const char* username, const char* pass)
{
xafp_client_handle ctx = get_context(host, username, pass);
xafp_create_file(ctx, path);
free_context(ctx);
}
static void process_write_frontend(struct conn_context *ctx)
{
int front_fd;
char *buf;
int data_len;
int cpu_id;
int ret;
cpu_id = ctx->cpu_id;
front_fd = ctx->fd;
buf = ctx->buf;
data_len = ctx->data_len;
if (ctx->flags & PROXY_BACKEND_EVENT) {
printf("Write to front end socket while back end socket enabled\n");
goto free_back;
}
ret = write(front_fd, buf, data_len);
if (ret < 0) {
perror("Can't write front-end socket");
goto free_back;
}
print_d("Write %d to front end socket %d\n", data_len, front_fd);
wdata[cpu_id].trancnt++;
free_back:
process_close(ctx);
free_context(ctx);
return;
}
struct expr *
lambda(struct expr * e, struct context * context)
{
int i;
const struct list *lp, *la;
struct expr *pe, *pr;
struct context *ctx;
/* assume e is a valid func call expr */
ctx = new_context();
ctx->is_root_level = 0;
ctx->next = (struct context *) context;
dbgprintf("created new context\n");
for (i = 0, lp = e->v.list->v->v.list->next->v->v.list, la = e->v.list->next; lp && la; ++i, lp = lp->next, la = la->next) {
dbgprintf("evaluating arguments, iter %d\n", i);
pe = add_to_context(ctx, strdup(lp->v->v.atom->v), eval(la->v, context));
full_free_expr(pe);
}
dbgprintf("eval'ing e expr\n");
pr = eval(e->v.list->v->v.list->next->next->v, ctx);
free_expr(e);
free_context(ctx);
return pr;
}
struct mg_context *mg_start(mg_callback_t user_callback, void *user_data, int port) {
struct mg_context *ctx;
// Allocate context and initialize reasonable general case defaults.
// TODO(lsm): do proper error handling here.
ctx = (struct mg_context *) calloc(1, sizeof(*ctx));
ctx->user_callback = user_callback;
ctx->user_data = user_data;
if (!set_ports_option(ctx, port)) {
free_context(ctx);
return NULL;
}
// Ignore SIGPIPE signal, so if browser cancels the request, it
// won't kill the whole process.
(void) signal(SIGPIPE, SIG_IGN);
(void) pthread_mutex_init(&ctx->mutex, NULL);
(void) pthread_cond_init(&ctx->cond, NULL);
(void) pthread_cond_init(&ctx->sq_empty, NULL);
(void) pthread_cond_init(&ctx->sq_full, NULL);
// Start master (listening) thread
start_thread(ctx, (mg_thread_func_t) master_thread, ctx);
// Start worker threads
for (int i = 0; i < NUM_THREADS; i++) {
if (start_thread(ctx, (mg_thread_func_t) worker_thread, ctx) != 0) {
cry(fc(ctx), "Cannot start worker thread: %d", ERRNO);
} else {
ctx->num_threads++;
}
}
return ctx;
}
static int finish (bool abort)
{
context & ctx = get_context();
double elapsed = ctx.elapsed_time();
std::cout.precision(6);
std::cout << "-----------------------------------" << std::endl
<< "Results: total=" << ctx.total()
<< ", run=" << ctx.processed()
<< ", ok=" << ctx.passed()
<< ", failed=" << ctx.failed() << std::endl;
if (ctx.total() != ctx.processed())
std::cerr << "WARN: Incomplete tests" << std::endl;
std::cout << "Elapsed time: " << elapsed << " seconds" << std::endl;
std::cout << "Total result: "
<< (ctx.failed() > 0
? "FAILURE"
: (ctx.processed() == ctx.total()
? "SUCCESS"
: "INCOMPLETE"))
<< std::endl;
int r = ctx.result();
free_context();
if (abort)
::exit(r);
return r;
}
static void on_sequence_complete(GIO_ASYNCSEQ_HANDLE async_seq_handle, gpointer previous_result)
{
CONNECT_CONTEXT* context = (CONNECT_CONTEXT*)GIO_Async_Seq_GetContext(async_seq_handle);
context->handle_data->state = BLEIO_GATT_STATE_CONNECTED;
// fetch list of objects on the object manager
GList* objects_list = g_dbus_object_manager_get_objects(
(GDBusObjectManager*)context->handle_data->object_manager
);
if (objects_list == NULL)
{
on_sequence_error(async_seq_handle, NULL);
}
else
{
// iterate through each object and add each characteristic
// that is a child of the device object path to the map
g_list_foreach(objects_list, process_object, context);
g_list_free(objects_list);
/*Codes_SRS_BLEIO_GATT_13_011: [ When the connect operation to the device has been completed, the callback function pointed at by on_bleio_gatt_connect_complete shall be invoked. ]*/
/*Codes_SRS_BLEIO_GATT_13_012: [ When on_bleio_gatt_connect_complete is invoked the value passed in callback_context to BLEIO_gatt_connect shall be passed along to on_bleio_gatt_connect_complete. ]*/
/*Codes_SRS_BLEIO_GATT_13_013: [ The connect_result parameter of the on_bleio_gatt_connect_complete callback shall indicate the status of the connect operation. ]*/
// invoke the user's callback
context->on_connect_complete(
(BLEIO_GATT_HANDLE)context->handle_data,
context->callback_context,
BLEIO_GATT_CONNECT_OK
);
free_context(context);
}
}
static void process_write_backend(struct conn_context *ctx)
{
int ep_fd, end_fd;
int events = ctx->events;
char *buf;
int data_len;
int ret;
ep_fd = ctx->ep_fd;
end_fd = ctx->end_fd;
buf = ctx->buf;
data_len = ctx->data_len;
print_d("Process write event[%02x] on back-end socket %d\n", events, end_fd);
if (events & (EPOLLHUP | EPOLLERR)) {
printf("process_write_backend() with events HUP or ERR 0x%x\n", events);
goto free_back;
}
struct epoll_event evt;
if (!(ctx->flags & PROXY_BACKEND_EVENT))
{
printf("Write to back-end socket while back end socket not enabled\n");
goto free_back;
}
ret = write(end_fd, buf, data_len);
if (ret < 0) {
perror("process_write() can't write back end socket");
goto free_back;
}
print_d("Write %d to back-end socket %d\n", ret, end_fd);
ctx->handler = process_read_backend;
ctx->flags |= PROXY_BACKEND_EVENT;
evt.events = EPOLLIN | EPOLLHUP | EPOLLERR;
evt.data.ptr = ctx;
ret = epoll_ctl(ep_fd, EPOLL_CTL_MOD, end_fd, &evt);
if (ret < 0) {
perror("Unable to add client socket read event to epoll");
goto free_back;
}
goto back;
free_back:
process_close(ctx);
free_context(ctx);
back:
return;
}
static
Clause cd(Clause maj, Clause min)
{
if (!unit_clause(maj) || !unit_clause(min))
return NULL;
else if (!maj->literals->sign || !min->literals->sign)
return NULL;
else {
Term a = ARG(maj->literals->atom,0);
Term b = ARG(min->literals->atom,0);
if (ARITY(a) != 2)
return NULL;
else {
Clause resolvent = NULL;
Term a0 = ARG(a,0);
Term a1 = ARG(a,1);
Context ca = get_context();
Context cb = get_context();
Trail tr = NULL;
if (unify(a0, ca, b, cb, &tr)) {
Term r = apply(a1, ca);
Term r_atom = build_unary_term(SYMNUM(maj->literals->atom), r);
Literal r_literal = get_literal();
Ilist j = NULL;
r_literal->sign = TRUE;
r_literal->atom = r_atom;
resolvent = get_clause();
append_literal(resolvent, r_literal);
j = ilist_append(j, maj->id);
j = ilist_append(j, 1);
j = ilist_append(j, min->id);
j = ilist_append(j, 1);
resolvent->justification = resolve_just(j, BINARY_RES_JUST);
upward_clause_links(resolvent);
renumber_variables(resolvent, MAX_VARS);
undo_subst(tr);
}
free_context(ca);
free_context(cb);
return resolvent;
}
}
} /* cd */
static switch_status_t shout_file_close(switch_file_handle_t *handle)
{
shout_context_t *context = handle->private_info;
free_context(context);
return SWITCH_STATUS_SUCCESS;
}
int pcmrec_read_params(void) {
struct audiotest_thread_context *context;
struct itimerspec ts;
char *token;
int ret_val = 0;
if ((context = get_free_context()) == NULL) {
ret_val = -1;
} else {
context->config.sample_rate = 8000;
context->config.file_name = "/data/rec.wav";
context->config.rec_mode = 1;
context->type = AUDIOTEST_TEST_MOD_PCM_ENC;
g_terminate_early = 0;
struct audio_pvt_data *audio_data;
audio_data = (struct audio_pvt_data *) malloc(sizeof(struct audio_pvt_data));
if(!audio_data) {
printf("error allocating audio instance structure \n");
free_context(context);
ret_val = -1;
} else {
audio_data->g_rec_buf_size = 4096;
token = strtok(NULL, " ");
while (token != NULL) {
printf("%s \n", token);
if (!memcmp(token,"-rate=", (sizeof("-rate=") - 1))) {
context->config.sample_rate =
atoi(&token[sizeof("-rate=") - 1]);
} else if (!memcmp(token,"-rec_mode=", (sizeof("-rec_mode=") - 1))) {
context->config.rec_mode =
atoi(&token[sizeof("-rec_mode=") - 1]);
} else if (!memcmp(token,"-recbufsize=", (sizeof("-recbufsize=") - 1))) {
audio_data->g_rec_buf_size = atoi(&token[sizeof("-recbufsize=") - 1]);
} else if (!memcmp(token,"-id=", (sizeof("-id=") - 1))) {
context->cxt_id = atoi(&token[sizeof("-id=") - 1]);
} else if (!memcmp(token,"-timeout=", (sizeof("-timeout=") - 1))) {
audio_data->g_rec_timeout = atoi(&token[sizeof("-timeout=") - 1]);
memset(&ts, 0, sizeof(struct itimerspec));
printf("setting rec timeout to %d secs\n", audio_data->g_rec_timeout);
ts.it_value.tv_sec = audio_data->g_rec_timeout;
signal(SIGALRM, audiotest_alarm_handler);
setitimer(ITIMER_REAL, &ts, NULL);
} else {
context->config.file_name = token;
}
token = strtok(NULL, " ");
}
context->config.private_data = (struct audio_pvt_data *) audio_data;
printf("%s : sample_rate=%d rec_mode=%d\n",
__FUNCTION__, context->config.sample_rate,
context->config.rec_mode);
pthread_create( &context->thread, NULL, recpcm_thread, (void*) context);
}
}
return ret_val;
}
void rm(const char* path, const char* host, const char* username, const char* pass)
{
xafp_client_handle ctx = get_context(host, username, pass);
xafp_remove(ctx, path);
// Clean-up the session
free_context(ctx);
}
void mv(const char* path, const char* newPath, const char* host, const char* username, const char* pass, uint32_t offset=0)
{
xafp_client_handle ctx = get_context(host, username, pass);
xafp_rename_file(ctx, path, newPath);
// Clean-up the session
free_context(ctx);
}
/* PUBLIC */
void zap_clash(Clash p)
{
while (p != NULL) {
Clash q = p;
p = p->next;
if (q->clashable && !q->clashed)
free_context(q->sat_subst);
free_clash(q);
}
} /* zap_clash */
void mg_stop(struct mg_context *ctx) {
ctx->stop_flag = 1;
// Wait until mg_fini() stops
while (ctx->stop_flag != 2) {
// TODO(steineldar): Avoid busy waiting.
(void) sleep(0);
}
free_context(ctx);
}
void free_module(struct module* module) {
if (module) {
if (module->context) {
mod_free_context* free_context = dlsym(module->handle, "freeContext");
free_context(module->context);
}
dlclose(module->handle);
free(module);
}
};
void* recpcm_thread(void* arg) {
struct audiotest_thread_context *context =
(struct audiotest_thread_context*) arg;
int ret_val;
ret_val = wav_rec(&context->config);
free_context(context);
pthread_exit((void*) ret_val);
return NULL;
}
bool exists(const char* path, const char* host, const char* username, const char* pass)
{
xafp_client_handle ctx = get_context(host, username, pass);
bool res = !xafp_stat(ctx, path);
// Clean-up the session
free_context(ctx);
return res;
}
void* playmp3_thread(void* arg) {
struct audiotest_thread_context *context =
(struct audiotest_thread_context*) arg;
int ret_val;
ret_val = mp3_play(&context->config);
free_context(context);
pthread_exit((void*) ret_val);
return NULL;
}
void
free_settings(settings_t *settings)
{
bool autofree = settings->autofree;
if (settings->ctx)
free_context(settings->ctx);
memset(settings, 0, sizeof(settings_t));
if (autofree)
free(settings);
}
static void process_write(struct conn_context *client_ctx)
{
int ep_fd, fd;
int events = client_ctx->events;
int cpu_id = client_ctx->cpu_id;
int ret;
struct epoll_event evt;
ep_fd = client_ctx->ep_fd;
fd = client_ctx->fd;
print_d("Process write event[%02x]\n", events);
if (events & (EPOLLHUP | EPOLLERR)) {
printf("process_write() with events HUP or ERR\n");
goto free_back;
}
ret = write(fd, http_response, http_response_len);
if (ret < 0) {
wdata[cpu_id].write_cnt++;
perror("process_write() can't write client socket");
goto free_back;
}
print_d("Write %d to socket %d\n", ret, fd);
wdata[cpu_id].trancnt++;
if (!enable_keepalive)
goto free_back;
client_ctx->handler = process_read;
evt.events = EPOLLIN | EPOLLHUP | EPOLLERR;
evt.data.ptr = client_ctx;
ret = epoll_ctl(ep_fd, EPOLL_CTL_MOD, fd, &evt);
if (ret < 0) {
perror("Unable to add client socket read event to epoll");
goto free_back;
}
goto back;
free_back:
process_close(client_ctx);
free_context(client_ctx);
back:
return;
}
void cat(const char* path, void* pBuf, int len, const char* host, const char* username, const char* pass, uint32_t offset=0)
{
xafp_client_handle ctx = get_context(host, username, pass);
xafp_file_handle file = xafp_open_file(ctx, path, xafp_open_flag_read | xafp_open_flag_write);
if (file)
{
xafp_write_file(ctx, file, offset, pBuf, len);
xafp_close_file(ctx, file);
}
// Clean-up the session
free_context(ctx);
}
int mp3play_read_params(void) {
struct audiotest_thread_context *context;
struct itimerspec ts;
char *token;
int ret_val = 0;
printf("This option is not supported currently\n");
return -1;
if ((context = get_free_context()) == NULL) {
ret_val = -1;
} else {
context->config.file_name = "/data/test.mp3";
g_terminate_early = 0;
struct audio_pvt_data *audio_data;
audio_data = (struct audio_pvt_data *) malloc(sizeof(struct audio_pvt_data));
if(!audio_data) {
printf("error allocating audio instance structure \n");
free_context(context);
ret_val = -1;
} else {
token = strtok(NULL, " ");
while (token != NULL) {
if (!memcmp(token,"-id=", (sizeof("-id=")-1))) {
context->cxt_id = atoi(&token[sizeof("-id=") - 1]);
} else if (!memcmp(token,"-volume=", (sizeof("-volume=") - 1))) {
audio_data->g_test_volume = atoi(&token[sizeof("-volume=") - 1]);
} else if (!memcmp(token,"-timeout=", (sizeof("-timeout=") - 1))) {
audio_data->g_rec_timeout = atoi(&token[sizeof("-timeout=") - 1]);
memset(&ts, 0, sizeof(struct itimerspec));
printf("setting rec timeout to %d secs\n", audio_data->g_rec_timeout);
ts.it_value.tv_sec = audio_data->g_rec_timeout;
signal(SIGALRM, audiotest_alarm_handler);
setitimer(ITIMER_REAL, &ts, NULL);
} else {
context->config.file_name = token;
}
token = strtok(NULL, " ");
}
context->type = AUDIOTEST_TEST_MOD_MP3_DEC;
context->config.private_data = (struct audio_pvt_data *) audio_data;
pthread_create( &context->thread, NULL,
playmp3_thread, (void*) context);
}
}
return ret_val;
}
/* MUST be called with cs_error held */
static void
release_context(kherr_context * c)
{
if (IS_KHERR_CTX(c)) {
c->refcount--;
{
kherr_event * e;
e = QBOTTOM(c);
if (IS_KHERR_EVENT(e) && !(e->flags & KHERR_RF_COMMIT)) {
commit_event(c, e);
}
}
if (c->refcount == 0) {
kherr_context * p;
if (CTX_USES_OWN_PROGRESS(c)) {
set_and_notify_progress_change(c, 256, 256);
}
p = TPARENT(c);
#ifdef DEBUG
kherr_debug_printf(L"Posting KHERR_CTX_END for %p\n", (void *) c);
#endif
notify_ctx_event(KHERR_CTX_END, c, NULL, NULL, 0);
if (IS_KHERR_CTX(p)) {
kherr_event * e;
e = fold_context(c);
TDELCHILD(p, c);
if (e) {
add_event(p, e);
notify_ctx_event(KHERR_CTX_FOLDCHILD, p, NULL, e, 0);
}
release_context(p);
} else {
LDELETE(&ctx_root_list, c);
}
free_context(c);
}
}
}
OPENVPN_EXPORT openvpn_plugin_handle_t
openvpn_plugin_open_v1 (unsigned int *type_mask, const char *argv[], const char *envp[])
{
struct down_root_context *context;
/*
* Allocate our context
*/
context = (struct down_root_context *) calloc (1, sizeof (struct down_root_context));
if (!context)
goto error;
context->foreground_fd = -1;
/*
* Intercept the --up and --down callbacks
*/
*type_mask = OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_UP) | OPENVPN_PLUGIN_MASK (OPENVPN_PLUGIN_DOWN);
/*
* Make sure we have two string arguments: the first is the .so name,
* the second is the script command.
*/
if (string_array_len (argv) < 2)
{
fprintf (stderr, "DOWN-ROOT: need down script command\n");
goto error;
}
/*
* Save our argument in context
*/
context->command = build_command_line (&argv[1]);
/*
* Get verbosity level from environment
*/
{
const char *verb_string = get_env ("verb", envp);
if (verb_string)
context->verb = atoi (verb_string);
}
return (openvpn_plugin_handle_t) context;
error:
free_context (context);
return NULL;
}
static void
exmpp_xml_stop(ErlDrvData drv_data)
{
struct exmpp_xml_data *edd;
edd = (struct exmpp_xml_data *)drv_data;
/* Destroy the parser. */
destroy_parser(edd);
/* Free generic context. */
free_context(&edd->ctx);
/* Free driver data structure. */
driver_free(edd);
}