static struct sol_mainloop_source *
event_create_source(sd_event *event)
{
struct sol_mainloop_source *source;
struct source_ctx *ctx;
ctx = malloc(sizeof(*ctx));
SOL_NULL_CHECK(ctx, NULL);
ctx->event = sd_event_ref(event);
ctx->fd_handler = sol_fd_add(sd_event_get_fd(event),
SOL_FD_FLAGS_IN | SOL_FD_FLAGS_HUP | SOL_FD_FLAGS_ERR,
on_sd_event_fd, ctx);
SOL_NULL_CHECK_GOTO(ctx->fd_handler, error_fd);
source = sol_mainloop_source_add(&source_type, ctx);
SOL_NULL_CHECK_GOTO(source, error_source);
return source;
error_source:
sol_fd_del(ctx->fd_handler);
error_fd:
sd_event_unref(ctx->event);
free(ctx);
return NULL;
}
int raw_export_new(
RawExport **ret,
sd_event *event,
RawExportFinished on_finished,
void *userdata) {
_cleanup_(raw_export_unrefp) RawExport *e = NULL;
int r;
assert(ret);
e = new0(RawExport, 1);
if (!e)
return -ENOMEM;
e->output_fd = e->input_fd = -1;
e->on_finished = on_finished;
e->userdata = userdata;
RATELIMIT_INIT(e->progress_rate_limit, 100 * USEC_PER_MSEC, 1);
e->last_percent = (unsigned) -1;
if (event)
e->event = sd_event_ref(event);
else {
r = sd_event_default(&e->event);
if (r < 0)
return r;
}
*ret = TAKE_PTR(e);
return 0;
}
int dkr_pull_new(
DkrPull **ret,
sd_event *event,
const char *index_url,
const char *image_root,
DkrPullFinished on_finished,
void *userdata) {
_cleanup_(dkr_pull_unrefp) DkrPull *i = NULL;
char *e;
int r;
assert(ret);
assert(index_url);
if (!http_url_is_valid(index_url))
return -EINVAL;
i = new0(DkrPull, 1);
if (!i)
return -ENOMEM;
i->on_finished = on_finished;
i->userdata = userdata;
i->image_root = strdup(image_root ?: "/var/lib/machines");
if (!i->image_root)
return -ENOMEM;
i->grow_machine_directory = path_startswith(i->image_root, "/var/lib/machines");
i->index_url = strdup(index_url);
if (!i->index_url)
return -ENOMEM;
e = endswith(i->index_url, "/");
if (e)
*e = 0;
if (event)
i->event = sd_event_ref(event);
else {
r = sd_event_default(&i->event);
if (r < 0)
return r;
}
r = curl_glue_new(&i->glue, i->event);
if (r < 0)
return r;
i->glue->on_finished = pull_job_curl_on_finished;
i->glue->userdata = i;
*ret = i;
i = NULL;
return 0;
}
GSource *g_sd_event_create_source(sd_event *event) {
SDEventSource *source;
source = (SDEventSource *)g_source_new(&event_funcs, sizeof(SDEventSource));
source->event = sd_event_ref(event);
source->pollfd.fd = sd_event_get_fd(event);
source->pollfd.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
g_source_add_poll((GSource *)source, &source->pollfd);
return (GSource *)source;
}
int dispd_dbus_new(struct dispd_dbus **out, sd_event *loop, sd_bus *bus)
{
struct dispd_dbus *dispd_dbus = calloc(1, sizeof(struct dispd_dbus));
if(!dispd_dbus) {
return log_ENOMEM();
}
dispd_dbus->bus = sd_bus_ref(bus);
dispd_dbus->loop = sd_event_ref(loop);
*out = dispd_dbus;
return 0;
}
int tar_pull_new(
TarPull **ret,
sd_event *event,
const char *image_root,
TarPullFinished on_finished,
void *userdata) {
_cleanup_(tar_pull_unrefp) TarPull *i = NULL;
int r;
assert(ret);
assert(event);
i = new0(TarPull, 1);
if (!i)
return -ENOMEM;
i->on_finished = on_finished;
i->userdata = userdata;
i->image_root = strdup(image_root ?: "/var/lib/machines");
if (!i->image_root)
return -ENOMEM;
i->grow_machine_directory = path_startswith(i->image_root, "/var/lib/machines");
if (event)
i->event = sd_event_ref(event);
else {
r = sd_event_default(&i->event);
if (r < 0)
return r;
}
r = curl_glue_new(&i->glue, i->event);
if (r < 0)
return r;
i->glue->on_finished = pull_job_curl_on_finished;
i->glue->userdata = i;
*ret = i;
i = NULL;
return 0;
}
static int pty_forward_done(PTYForward *f, int rcode) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
assert(f);
if (f->done)
return 0;
e = sd_event_ref(f->event);
f->done = true;
pty_forward_disconnect(f);
if (f->handler)
return f->handler(f, rcode, f->userdata);
else
return sd_event_exit(e, rcode < 0 ? EXIT_FAILURE : rcode);
}
int sd_ipv4acd_attach_event(sd_ipv4acd *acd, sd_event *event, int64_t priority) {
int r;
assert_return(acd, -EINVAL);
assert_return(!acd->event, -EBUSY);
if (event)
acd->event = sd_event_ref(event);
else {
r = sd_event_default(&acd->event);
if (r < 0)
return r;
}
acd->event_priority = priority;
return 0;
}
int sd_pppoe_attach_event(sd_pppoe *ppp, sd_event *event, int priority) {
int r;
assert_return(ppp, -EINVAL);
assert_return(!ppp->event, -EBUSY);
if (event)
ppp->event = sd_event_ref(event);
else {
r = sd_event_default(&ppp->event);
if (r < 0)
return r;
}
ppp->event_priority = priority;
return 0;
}
int sd_icmp6_nd_attach_event(sd_icmp6_nd *nd, sd_event *event, int priority) {
int r;
assert_return(nd, -EINVAL);
assert_return(!nd->event, -EBUSY);
if (event)
nd->event = sd_event_ref(event);
else {
r = sd_event_default(&nd->event);
if (r < 0)
return 0;
}
nd->event_priority = priority;
return 0;
}
int sd_ipv4acd_attach_event(sd_ipv4acd *ll, sd_event *event, int priority) {
int r;
assert_return(ll, -EINVAL);
assert_return(!ll->event, -EBUSY);
if (event)
ll->event = sd_event_ref(event);
else {
r = sd_event_default(&ll->event);
if (r < 0)
return r;
}
ll->event_priority = priority;
return 0;
}
int tar_import_new(
TarImport **ret,
sd_event *event,
const char *image_root,
TarImportFinished on_finished,
void *userdata) {
_cleanup_(tar_import_unrefp) TarImport *i = NULL;
int r;
assert(ret);
assert(event);
i = new0(TarImport, 1);
if (!i)
return -ENOMEM;
i->on_finished = on_finished;
i->userdata = userdata;
i->image_root = strdup(image_root ?: "/var/lib/machines");
if (!i->image_root)
return -ENOMEM;
if (event)
i->event = sd_event_ref(event);
else {
r = sd_event_default(&i->event);
if (r < 0)
return r;
}
r = curl_glue_new(&i->glue, i->event);
if (r < 0)
return r;
i->glue->on_finished = import_job_curl_on_finished;
i->glue->userdata = i;
*ret = i;
i = NULL;
return 0;
}
int sd_dhcp_client_attach_event(sd_dhcp_client *client, sd_event *event,
int priority) {
int r;
assert_return(client, -EINVAL);
assert_return(!client->event, -EBUSY);
if (event)
client->event = sd_event_ref(event);
else {
r = sd_event_default(&client->event);
if (r < 0)
return 0;
}
client->event_priority = priority;
return 0;
}
_public_ int sd_lldp_attach_event(sd_lldp *lldp, sd_event *event, int64_t priority) {
int r;
assert_return(lldp, -EINVAL);
assert_return(lldp->fd < 0, -EBUSY);
assert_return(!lldp->event, -EBUSY);
if (event)
lldp->event = sd_event_ref(event);
else {
r = sd_event_default(&lldp->event);
if (r < 0)
return r;
}
lldp->event_priority = priority;
return 0;
}
int tar_import_new(
TarImport **ret,
sd_event *event,
const char *image_root,
TarImportFinished on_finished,
void *userdata) {
_cleanup_(tar_import_unrefp) TarImport *i = NULL;
int r;
assert(ret);
i = new0(TarImport, 1);
if (!i)
return -ENOMEM;
i->input_fd = i->tar_fd = -1;
i->on_finished = on_finished;
i->userdata = userdata;
RATELIMIT_INIT(i->progress_rate_limit, 100 * USEC_PER_MSEC, 1);
i->last_percent = (unsigned) -1;
i->image_root = strdup(image_root ?: "/var/lib/machines");
if (!i->image_root)
return -ENOMEM;
i->grow_machine_directory = path_startswith(i->image_root, "/var/lib/machines");
if (event)
i->event = sd_event_ref(event);
else {
r = sd_event_default(&i->event);
if (r < 0)
return r;
}
*ret = i;
i = NULL;
return 0;
}
int sd_ipv4ll_attach_event(sd_ipv4ll *ll, sd_event *event, int priority) {
int r;
assert_return(ll, -EINVAL);
assert_return(!ll->event, -EBUSY);
if (event)
ll->event = sd_event_ref(event);
else {
r = sd_event_default(&ll->event);
if (r < 0) {
ipv4ll_stop(ll, IPV4LL_EVENT_STOP);
return r;
}
}
ll->event_priority = priority;
return 0;
}
int ctl_sink_new(struct ctl_sink **out,
sd_event *event)
{
struct ctl_sink *s;
if (!out || !event)
return cli_EINVAL();
s = calloc(1, sizeof(*s));
if (!s)
return cli_ENOMEM();
s->event = sd_event_ref(event);
s->fd = -1;
s->resolutions_cea = wfd_supported_res_cea;
s->resolutions_vesa = wfd_supported_res_vesa;
s->resolutions_hh = wfd_supported_res_hh;
*out = s;
return 0;
}
int curl_glue_new(CurlGlue **glue, sd_event *event) {
_cleanup_(curl_glue_unrefp) CurlGlue *g = NULL;
int r;
g = new0(CurlGlue, 1);
if (!g)
return -ENOMEM;
if (event)
g->event = sd_event_ref(event);
else {
r = sd_event_default(&g->event);
if (r < 0)
return r;
}
g->curl = curl_multi_init();
if (!g->curl)
return -ENOMEM;
if (curl_multi_setopt(g->curl, CURLMOPT_SOCKETDATA, g) != CURLM_OK)
return -EINVAL;
if (curl_multi_setopt(g->curl, CURLMOPT_SOCKETFUNCTION, curl_glue_socket_callback) != CURLM_OK)
return -EINVAL;
if (curl_multi_setopt(g->curl, CURLMOPT_TIMERDATA, g) != CURLM_OK)
return -EINVAL;
if (curl_multi_setopt(g->curl, CURLMOPT_TIMERFUNCTION, curl_glue_timer_callback) != CURLM_OK)
return -EINVAL;
*glue = g;
g = NULL;
return 0;
}
int tar_export_new(
TarExport **ret,
sd_event *event,
TarExportFinished on_finished,
void *userdata) {
_cleanup_(tar_export_unrefp) TarExport *e = NULL;
int r;
assert(ret);
e = new0(TarExport, 1);
if (!e)
return -ENOMEM;
e->output_fd = e->tar_fd = -1;
e->on_finished = on_finished;
e->userdata = userdata;
e->quota_referenced = (uint64_t) -1;
RATELIMIT_INIT(e->progress_rate_limit, 100 * USEC_PER_MSEC, 1);
e->last_percent = (unsigned) -1;
if (event)
e->event = sd_event_ref(event);
else {
r = sd_event_default(&e->event);
if (r < 0)
return r;
}
*ret = e;
e = NULL;
return 0;
}
int pty_forward_new(
sd_event *event,
int master,
PTYForwardFlags flags,
PTYForward **ret) {
_cleanup_(pty_forward_freep) PTYForward *f = NULL;
struct winsize ws;
int r;
f = new0(PTYForward, 1);
if (!f)
return -ENOMEM;
f->flags = flags;
if (event)
f->event = sd_event_ref(event);
else {
r = sd_event_default(&f->event);
if (r < 0)
return r;
}
if (!(flags & PTY_FORWARD_READ_ONLY)) {
r = fd_nonblock(STDIN_FILENO, true);
if (r < 0)
return r;
r = fd_nonblock(STDOUT_FILENO, true);
if (r < 0)
return r;
}
r = fd_nonblock(master, true);
if (r < 0)
return r;
f->master = master;
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) >= 0)
(void) ioctl(master, TIOCSWINSZ, &ws);
if (!(flags & PTY_FORWARD_READ_ONLY)) {
if (tcgetattr(STDIN_FILENO, &f->saved_stdin_attr) >= 0) {
struct termios raw_stdin_attr;
f->saved_stdin = true;
raw_stdin_attr = f->saved_stdin_attr;
cfmakeraw(&raw_stdin_attr);
raw_stdin_attr.c_oflag = f->saved_stdin_attr.c_oflag;
tcsetattr(STDIN_FILENO, TCSANOW, &raw_stdin_attr);
}
if (tcgetattr(STDOUT_FILENO, &f->saved_stdout_attr) >= 0) {
struct termios raw_stdout_attr;
f->saved_stdout = true;
raw_stdout_attr = f->saved_stdout_attr;
cfmakeraw(&raw_stdout_attr);
raw_stdout_attr.c_iflag = f->saved_stdout_attr.c_iflag;
raw_stdout_attr.c_lflag = f->saved_stdout_attr.c_lflag;
tcsetattr(STDOUT_FILENO, TCSANOW, &raw_stdout_attr);
}
r = sd_event_add_io(f->event, &f->stdin_event_source, STDIN_FILENO, EPOLLIN|EPOLLET, on_stdin_event, f);
if (r < 0 && r != -EPERM)
return r;
}
r = sd_event_add_io(f->event, &f->stdout_event_source, STDOUT_FILENO, EPOLLOUT|EPOLLET, on_stdout_event, f);
if (r == -EPERM)
/* stdout without epoll support. Likely redirected to regular file. */
f->stdout_writable = true;
else if (r < 0)
return r;
r = sd_event_add_io(f->event, &f->master_event_source, master, EPOLLIN|EPOLLOUT|EPOLLET, on_master_event, f);
if (r < 0)
return r;
r = sd_event_add_signal(f->event, &f->sigwinch_event_source, SIGWINCH, on_sigwinch_event, f);
if (r < 0)
return r;
*ret = f;
f = NULL;
return 0;
}
int main(int argc, char *argv[])
{
int result = 0;
struct cc_event_context *context = NULL;
sd_event *event = NULL;
struct cc_client_Calculator *instance1 = NULL, *instance2 = NULL;
double value = 3.14159265;
int32_t whole = 0;
int32_t fraction = 0;
CC_LOG_OPEN("simpleclient");
printf("Started simpleclient\n");
result = cc_backend_startup();
if (result < 0) {
printf("unable to startup the backend: %s\n", strerror(-result));
goto fail;
}
result = cc_client_Calculator_new(
"org.genivi.capic.Server:/instance1:org.genivi.capic.Calculator",
NULL, &instance1);
if (result < 0) {
printf("unable to create client instance '/instance1': %s\n", strerror(-result));
goto fail;
}
result = cc_client_Calculator_new(
"org.genivi.capic.Server:/instance2:org.genivi.capic.Calculator",
NULL, &instance2);
if (result < 0) {
printf("unable to create client instance '/instance2': %s\n", strerror(-result));
goto fail;
}
result = cc_backend_get_event_context(&context);
if (result < 0) {
printf("unable to get backend event context: %s\n", strerror(-result));
goto fail;
}
event = (sd_event *) cc_event_get_native(context);
assert(event);
sd_event_ref(event);
printf("invoking method instance1.split() with value=%g\n", value);
printf(
"expecting to receive whole=%d, fraction=%d\n", (int32_t)value,
(int32_t)((value - (double)(int32_t)value) * 1.0e+9));
result = cc_Calculator_split(instance1, value, &whole, &fraction);
if (result < 0) {
printf("failed while calling cc_Calculator_split(): %s\n", strerror(-result));
goto fail;
}
printf("received whole=%d, fraction=%d\n", whole, fraction);
printf("invoking method instance2.split() with value=%g\n", value);
printf(
"expecting to receive whole=%d, fraction=%d\n", (int32_t)value,
(int32_t)((value - (double)(int32_t)value) * 1.0e+9));
result = cc_Calculator_split_async(
instance2, value, &complete_Calculator_split);
if (result < 0) {
printf("unable to issue cc_Calculator_split_async(): %s\n", strerror(-result));
goto fail;
}
result = cc_Calculator_split(instance2, value, &whole, &fraction);
if (result >= 0) {
printf("invoking method with pending reply succeeded unexpectedly");
goto fail;
}
assert(result == -EBUSY);
result = sd_event_run(event, (uint64_t) -1);
if (result < 0) {
printf(
"unable to complete cc_Calculator_split_async(): %s\n", strerror(-result));
goto fail;
}
fail:
instance2 = cc_client_Calculator_free(instance2);
instance1 = cc_client_Calculator_free(instance1);
cc_backend_shutdown();
CC_LOG_CLOSE();
printf("exiting simpleclient\n");
return result;
}
int main(int argc, char *argv[])
{
int result = 0;
struct cc_event_context *context = NULL;
sd_event *event = NULL;
struct cc_server_Calculator *instance1 = NULL, *instance2 = NULL;
CC_LOG_OPEN("simpleserver");
printf("Started simpleserver\n");
result = cc_backend_startup();
if (result < 0) {
printf("unable to startup backend: %s\n", strerror(-result));
goto fail;
}
result = cc_server_Calculator_new(
"org.genivi.capic.Server:/instance1:org.genivi.capic.Calculator",
&impl1, NULL, &instance1);
if (result < 0) {
printf("unable to create server instance '/instance1': %s\n", strerror(-result));
goto fail;
}
result = cc_server_Calculator_new(
"org.genivi.capic.Server:/instance2:org.genivi.capic.Calculator",
&impl2, NULL, &instance2);
if (result < 0) {
printf("unable to create server instance '/instance2': %s\n", strerror(-result));
goto fail;
}
result = cc_backend_get_event_context(&context);
if (result < 0) {
printf("unable to get backend event context: %s\n", strerror(-result));
goto fail;
}
event = (sd_event *) cc_event_get_native(context);
assert(event);
sd_event_ref(event);
result = setup_signals(event);
if (result < 0) {
printf("unable to setup signal sources: %s\n", strerror(-result));
goto fail;
}
printf("entering main loop...\n");
result = sd_event_loop(event);
if (result < 0) {
printf("unable to run event loop: %s\n", strerror(-result));
goto fail;
}
fail:
if (event)
sd_event_unref(event);
instance2 = cc_server_Calculator_free(instance2);
instance1 = cc_server_Calculator_free(instance1);
cc_backend_shutdown();
CC_LOG_CLOSE();
printf("exiting simpleserver\n");
return result;
}
