r = sd_bus_message_new_method_call(
bus,
+ &msg,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "SetEnvironment",
- &msg);
+ "SetEnvironment");
if (r < 0)
return r;
r = sd_bus_message_new_signal(
b,
+ &n,
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
- "NameLost",
- &n);
+ "NameLost");
} else if (streq(new_owner, a->unique_name)) {
r = sd_bus_message_new_signal(
b,
+ &n,
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
- "NameAcquired",
- &n);
+ "NameAcquired");
} else
return 0;
n = sd_bus_message_unref(n);
r = sd_bus_message_new_signal(
b,
+ &n,
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
- "NameAcquired",
- &n);
+ "NameAcquired");
if (r < 0) {
log_error("Failed to allocate initial NameAcquired message: %s", strerror(-r));
return r;
assert(a->pipe_fd >= 0);
- r = sd_event_add_io(u->manager->event, a->pipe_fd, EPOLLIN, automount_dispatch_io, u, &a->pipe_event_source);
+ r = sd_event_add_io(u->manager->event, &a->pipe_event_source, a->pipe_fd, EPOLLIN, automount_dispatch_io, u);
if (r < 0)
return r;
}
close_nointr_nofail(ioctl_fd);
ioctl_fd = -1;
- r = sd_event_add_io(UNIT(a)->manager->event, p[0], EPOLLIN, automount_dispatch_io, a, &a->pipe_event_source);
+ r = sd_event_add_io(UNIT(a)->manager->event, &a->pipe_event_source, p[0], EPOLLIN, automount_dispatch_io, a);
if (r < 0)
goto fail;
if (n->event_source)
r = sd_event_source_set_enabled(n->event_source, SD_EVENT_ON);
else
- r = sd_event_add_io(UNIT(n)->manager->event, n->starter_fd, EPOLLIN, busname_dispatch_io, n, &n->event_source);
+ r = sd_event_add_io(UNIT(n)->manager->event, &n->event_source, n->starter_fd, EPOLLIN, busname_dispatch_io, n);
if (r < 0) {
log_warning_unit(UNIT(n)->id, "Failed to watch starter fd: %s", strerror(-r));
busname_unwatch_fd(n);
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "JobNew",
- &m);
+ "JobNew");
if (r < 0)
return r;
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "JobRemoved",
- &m);
+ "JobRemoved");
if (r < 0)
return r;
assert(bus);
- r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged", &message);
+ r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
if (r < 0)
return r;
assert(bus);
assert(times);
- r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished", &message);
+ r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
if (r < 0)
return r;
assert(bus);
- r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading", &message);
+ r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
if (r < 0)
return r;
r = sd_bus_message_new_signal(
UNIT(s)->manager->api_bus,
+ &m,
p,
"org.freedesktop.systemd1.Scope",
- "RequestStop",
- &m);
+ "RequestStop");
if (r < 0)
return r;
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "UnitNew",
- &m);
+ "UnitNew");
if (r < 0)
return r;
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "UnitRemoved",
- &m);
+ "UnitRemoved");
if (r < 0)
return r;
log_debug("D-Bus activation failed for %s: %s", name, bus_error_message(&error, r));
- r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Activator", "ActivationFailure", &reply);
+ r = sd_bus_message_new_signal(bus, &reply, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Activator", "ActivationFailure");
if (r < 0) {
bus_log_create_error(r);
return 0;
return -errno;
}
- r = sd_event_add_io(m->event, fd, EPOLLIN, bus_on_connection, m, &s);
+ r = sd_event_add_io(m->event, &s, fd, EPOLLIN, bus_on_connection, m);
if (r < 0) {
log_error("Failed to allocate event source: %s", strerror(-r));
return r;
if (r < 0)
goto fail;
- r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_monitor), EPOLLIN, device_dispatch_io, m, &m->udev_event_source);
+ r = sd_event_add_io(m->event, &m->udev_event_source, udev_monitor_get_fd(m->udev_monitor), EPOLLIN, device_dispatch_io, m);
if (r < 0)
goto fail;
}
if (j->unit->job_timeout <= 0)
return 0;
- r = sd_event_add_monotonic(j->manager->event, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j, &j->timer_event_source);
+ r = sd_event_add_monotonic(j->manager->event, &j->timer_event_source, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j);
if (r < 0)
return r;
if (j->timer_event_source)
j->timer_event_source = sd_event_source_unref(j->timer_event_source);
- r = sd_event_add_monotonic(j->manager->event, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j, &j->timer_event_source);
+ r = sd_event_add_monotonic(j->manager->event, &j->timer_event_source, j->begin_usec + j->unit->job_timeout, 0, job_dispatch_timer, j);
if (r < 0)
log_debug("Failed to restart timeout for job: %s", strerror(-r));
_cleanup_rtnl_message_unref_ sd_rtnl_message *ipv4 = NULL, *ipv6 = NULL;
int r;
- r = sd_rtnl_message_new_addr(rtnl, RTM_NEWADDR, if_loopback, AF_INET, &ipv4);
+ r = sd_rtnl_message_new_addr(rtnl, &ipv4, RTM_NEWADDR, if_loopback, AF_INET);
if (r < 0)
return r;
if (!socket_ipv6_is_supported())
return 0;
- r = sd_rtnl_message_new_addr(rtnl, RTM_NEWADDR, if_loopback, AF_INET6, &ipv6);
+ r = sd_rtnl_message_new_addr(rtnl, &ipv6, RTM_NEWADDR, if_loopback, AF_INET6);
if (r < 0)
return r;
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
int r;
- r = sd_rtnl_message_new_link(rtnl, RTM_SETLINK, if_loopback, &req);
+ r = sd_rtnl_message_new_link(rtnl, &req, RTM_SETLINK, if_loopback);
if (r < 0)
return r;
ipv4_address.s_addr = htonl(INADDR_LOOPBACK);
- r = sd_rtnl_open(0, &rtnl);
+ r = sd_rtnl_open(&rtnl, 0);
if (r < 0)
return r;
return 0;
next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
- return sd_event_add_monotonic(m->event, next, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
+ return sd_event_add_monotonic(m->event, &m->jobs_in_progress_event_source, next, 0, manager_dispatch_jobs_in_progress, m);
}
#define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
if (m->idle_pipe[2] < 0)
return 0;
- r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
+ r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
if (r < 0) {
log_error("Failed to watch idle pipe: %s", strerror(-r));
return r;
return 0;
}
- r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
+ r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
if (r < 0) {
log_error("Failed to create time change event source: %s", strerror(-r));
return r;
if (m->signal_fd < 0)
return -errno;
- r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
+ r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
if (r < 0)
return r;
if (r < 0)
goto fail;
- r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
+ r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
if (r < 0)
goto fail;
}
if (!m->notify_event_source) {
- r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
+ r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
if (r < 0) {
log_error("Failed to allocate notify event source: %s", strerror(-r));
return -errno;
return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
}
- return sd_event_add_monotonic(UNIT(m)->manager->event, now(CLOCK_MONOTONIC) + m->timeout_usec, 0, mount_dispatch_timer, m, &m->timer_event_source);
+ return sd_event_add_monotonic(UNIT(m)->manager->event, &m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec, 0, mount_dispatch_timer, m);
}
static void mount_unwatch_control_pid(Mount *m) {
if (!m->proc_self_mountinfo)
return -errno;
- r = sd_event_add_io(m->event, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m, &m->mount_event_source);
+ r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
if (r < 0)
goto fail;
goto fail;
}
- r = sd_event_add_io(s->unit->manager->event, s->inotify_fd, EPOLLIN, handler, s, &s->event_source);
+ r = sd_event_add_io(s->unit->manager->event, &s->event_source, s->inotify_fd, EPOLLIN, handler, s);
if (r < 0)
goto fail;
return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
}
- return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_stop_usec, 0, scope_dispatch_timer, s, &s->timer_event_source);
+ return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_stop_usec, 0, scope_dispatch_timer, s);
}
static void scope_set_state(Scope *s, ScopeState state) {
r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ONESHOT);
} else {
- r = sd_event_add_monotonic(UNIT(s)->manager->event, s->watchdog_timestamp.monotonic + s->watchdog_usec, 0, service_dispatch_watchdog, s, &s->watchdog_event_source);
+ r = sd_event_add_monotonic(UNIT(s)->manager->event, &s->watchdog_event_source, s->watchdog_timestamp.monotonic + s->watchdog_usec, 0, service_dispatch_watchdog, s);
if (r < 0) {
log_warning_unit(UNIT(s)->id, "%s failed to add watchdog timer: %s", UNIT(s)->id, strerror(-r));
return;
return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
}
- return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + usec, 0, service_dispatch_timer, s, &s->timer_event_source);
+ return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + usec, 0, service_dispatch_timer, s);
}
#ifdef HAVE_SYSV_COMPAT
return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
}
- return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s, &s->timer_event_source);
+ return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s);
}
static int socket_instantiate_service(Socket *s) {
if (p->event_source)
r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
else
- r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
+ r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
if (r < 0) {
log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
}
- return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, swap_dispatch_timer, s, &s->timer_event_source);
+ return sd_event_add_monotonic(UNIT(s)->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, swap_dispatch_timer, s);
}
static int swap_add_device_links(Swap *s) {
if (!m->proc_swaps)
return errno == ENOENT ? 0 : -errno;
- r = sd_event_add_io(m->event, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m, &m->swap_event_source);
+ r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
if (r < 0)
goto fail;
r = sd_event_source_set_enabled(t->monotonic_event_source, SD_EVENT_ONESHOT);
} else
- r = sd_event_add_monotonic(UNIT(t)->manager->event, t->next_elapse_monotonic, t->accuracy_usec, timer_dispatch, t, &t->monotonic_event_source);
+ r = sd_event_add_monotonic(UNIT(t)->manager->event, &t->monotonic_event_source, t->next_elapse_monotonic, t->accuracy_usec, timer_dispatch, t);
if (r < 0)
goto fail;
r = sd_event_source_set_enabled(t->realtime_event_source, SD_EVENT_ONESHOT);
} else
- r = sd_event_add_realtime(UNIT(t)->manager->event, t->next_elapse_realtime, t->accuracy_usec, timer_dispatch, t, &t->realtime_event_source);
+ r = sd_event_add_realtime(UNIT(t)->manager->event, &t->realtime_event_source, t->next_elapse_realtime, t->accuracy_usec, timer_dispatch, t);
if (r < 0)
goto fail;
return 0;
}
- r = sd_event_add_io(s->event, s->dev_kmsg_fd, EPOLLIN, dispatch_dev_kmsg, s, &s->dev_kmsg_event_source);
+ r = sd_event_add_io(s->event, &s->dev_kmsg_event_source, s->dev_kmsg_fd, EPOLLIN, dispatch_dev_kmsg, s);
if (r < 0) {
/* This will fail with EPERM on older kernels where
return -errno;
}
- r = sd_event_add_io(s->event, s->native_fd, EPOLLIN, process_datagram, s, &s->native_event_source);
+ r = sd_event_add_io(s->event, &s->native_event_source, s->native_fd, EPOLLIN, process_datagram, s);
if (r < 0) {
log_error("Failed to add native server fd to event loop: %s", strerror(-r));
return r;
sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
- r = sd_event_add_signal(s->event, SIGUSR1, dispatch_sigusr1, s, &s->sigusr1_event_source);
+ r = sd_event_add_signal(s->event, &s->sigusr1_event_source, SIGUSR1, dispatch_sigusr1, s);
if (r < 0)
return r;
- r = sd_event_add_signal(s->event, SIGUSR2, dispatch_sigusr2, s, &s->sigusr2_event_source);
+ r = sd_event_add_signal(s->event, &s->sigusr2_event_source, SIGUSR2, dispatch_sigusr2, s);
if (r < 0)
return r;
- r = sd_event_add_signal(s->event, SIGTERM, dispatch_sigterm, s, &s->sigterm_event_source);
+ r = sd_event_add_signal(s->event, &s->sigterm_event_source, SIGTERM, dispatch_sigterm, s);
if (r < 0)
return r;
- r = sd_event_add_signal(s->event, SIGINT, dispatch_sigterm, s, &s->sigint_event_source);
+ r = sd_event_add_signal(s->event, &s->sigint_event_source, SIGINT, dispatch_sigterm, s);
if (r < 0)
return r;
when += s->sync_interval_usec;
if (!s->sync_event_source) {
- r = sd_event_add_monotonic(s->event, when, 0, server_dispatch_sync, s, &s->sync_event_source);
+ r = sd_event_add_monotonic(s->event, &s->sync_event_source, when, 0, server_dispatch_sync, s);
if (r < 0)
return r;
return -errno;
}
- r = sd_event_add_io(s->event, s->hostname_fd, 0, dispatch_hostname_change, s, &s->hostname_event_source);
+ r = sd_event_add_io(s->event, &s->hostname_event_source, s->hostname_fd, 0, dispatch_hostname_change, s);
if (r < 0) {
log_error("Failed to register hostname fd in event loop: %s", strerror(-r));
return r;
goto fail;
}
- r = sd_event_add_io(s->event, fd, EPOLLIN, stdout_stream_process, stream, &stream->event_source);
+ r = sd_event_add_io(s->event, &stream->event_source, fd, EPOLLIN, stdout_stream_process, stream);
if (r < 0) {
log_error("Failed to add stream to event loop: %s", strerror(-r));
goto fail;
} else
fd_nonblock(s->stdout_fd, 1);
- r = sd_event_add_io(s->event, s->stdout_fd, EPOLLIN, stdout_stream_new, s, &s->stdout_event_source);
+ r = sd_event_add_io(s->event, &s->stdout_event_source, s->stdout_fd, EPOLLIN, stdout_stream_new, s);
if (r < 0) {
log_error("Failed to add stdout server fd to event source: %s", strerror(-r));
return r;
return -errno;
}
- r = sd_event_add_io(s->event, s->syslog_fd, EPOLLIN, process_datagram, s, &s->syslog_event_source);
+ r = sd_event_add_io(s->event, &s->syslog_event_source, s->syslog_fd, EPOLLIN, process_datagram, s);
if (r < 0) {
log_error("Failed to add syslog server fd to event loop: %s", strerror(-r));
return r;
next_timeout += (random_u32() & 0x1fffff);
- r = sd_event_add_monotonic(client->event, next_timeout,
+ r = sd_event_add_monotonic(client->event,
+ &client->timeout_resend,
+ next_timeout,
10 * USEC_PER_MSEC,
- client_timeout_resend, client,
- &client->timeout_resend);
+ client_timeout_resend, client);
if (r < 0)
goto error;
assert(client);
assert(client->event);
- r = sd_event_add_io(client->event, client->fd, EPOLLIN, io_callback,
- client, &client->receive_message);
+ r = sd_event_add_io(client->event, &client->receive_message,
+ client->fd, EPOLLIN, io_callback,
+ client);
if (r < 0)
goto error;
if (r < 0)
goto error;
- r = sd_event_add_monotonic(client->event, usec, 0,
- client_timeout_resend, client,
- &client->timeout_resend);
+ r = sd_event_add_monotonic(client->event,
+ &client->timeout_resend,
+ usec, 0,
+ client_timeout_resend, client);
if (r < 0)
goto error;
if (next_timeout < usec)
return -EINVAL;
- r = sd_event_add_monotonic(client->event, next_timeout,
+ r = sd_event_add_monotonic(client->event,
+ &client->timeout_t1,
+ next_timeout,
10 * USEC_PER_MSEC,
- client_timeout_t1, client,
- &client->timeout_t1);
+ client_timeout_t1, client);
if (r < 0)
return r;
if (next_timeout < usec)
return -EINVAL;
- r = sd_event_add_monotonic(client->event, next_timeout,
+ r = sd_event_add_monotonic(client->event,
+ &client->timeout_t2,
+ next_timeout,
10 * USEC_PER_MSEC,
- client_timeout_t2, client,
- &client->timeout_t2);
+ client_timeout_t2, client);
if (r < 0)
return r;
if (next_timeout < usec)
return -EINVAL;
- r = sd_event_add_monotonic(client->event, next_timeout,
+ r = sd_event_add_monotonic(client->event,
+ &client->timeout_expire, next_timeout,
10 * USEC_PER_MSEC,
- client_timeout_expire, client,
- &client->timeout_expire);
+ client_timeout_expire, client);
if (r < 0)
return r;
client->state = DHCP_STATE_REQUESTING;
client->attempt = 1;
- r = sd_event_add_monotonic(client->event, time_now, 0,
+ r = sd_event_add_monotonic(client->event,
+ &client->timeout_resend,
+ time_now, 0,
client_timeout_resend,
- client,
- &client->timeout_resend);
+ client);
if (r < 0)
goto error;
r = sd_bus_message_new_method_call(
bus,
+ &m,
name,
"/",
"org.freedesktop.DBus.Peer",
- "GetMachineId", &m);
+ "GetMachineId");
if (r < 0)
return r;
assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
assert_return(!bus_pid_changed(bus), -ECHILD);
- r = sd_bus_message_new_signal(bus, path, interface, member, &m);
+ r = sd_bus_message_new_signal(bus, &m, path, interface, member);
if (r < 0)
return r;
assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
assert_return(!bus_pid_changed(bus), -ECHILD);
- r = sd_bus_message_new_method_call(bus, destination, path, interface, member, &m);
+ r = sd_bus_message_new_method_call(bus, &m, destination, path, interface, member);
if (r < 0)
return r;
if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
return 0;
- r = sd_bus_message_new_method_error(call, e, &m);
+ r = sd_bus_message_new_method_error(call, &m, e);
if (r < 0)
return r;
assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
assert_return(!bus_pid_changed(bus), -ECHILD);
- r = sd_bus_message_new_method_call(bus, destination, path, "org.freedesktop.DBus.Properties", "Set", &m);
+ r = sd_bus_message_new_method_call(bus, &m, destination, path, "org.freedesktop.DBus.Properties", "Set");
if (r < 0)
return r;
return c;
}
-_public_ int sd_bus_creds_new_from_pid(pid_t pid, uint64_t mask, sd_bus_creds **ret) {
+_public_ int sd_bus_creds_new_from_pid(sd_bus_creds **ret, pid_t pid, uint64_t mask) {
sd_bus_creds *c;
int r;
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
- "NameOwnerChanged",
- &m);
+ "NameOwnerChanged");
if (r < 0)
return r;
_public_ int sd_bus_message_new_signal(
sd_bus *bus,
+ sd_bus_message **m,
const char *path,
const char *interface,
- const char *member,
- sd_bus_message **m) {
+ const char *member) {
sd_bus_message *t;
int r;
_public_ int sd_bus_message_new_method_call(
sd_bus *bus,
+ sd_bus_message **m,
const char *destination,
const char *path,
const char *interface,
- const char *member,
- sd_bus_message **m) {
+ const char *member) {
sd_bus_message *t;
int r;
_public_ int sd_bus_message_new_method_error(
sd_bus_message *call,
- const sd_bus_error *e,
- sd_bus_message **m) {
+ sd_bus_message **m,
+ const sd_bus_error *e) {
sd_bus_message *t;
int r;
bus_error_setfv(&error, name, format, ap);
va_end(ap);
- return sd_bus_message_new_method_error(call, &error, m);
+ return sd_bus_message_new_method_error(call, m, &error);
}
_public_ int sd_bus_message_new_method_errno(
sd_bus_message *call,
+ sd_bus_message **m,
int error,
- const sd_bus_error *p,
- sd_bus_message **m) {
+ const sd_bus_error *p) {
_cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
if (sd_bus_error_is_set(p))
- return sd_bus_message_new_method_error(call, p, m);
+ return sd_bus_message_new_method_error(call, m, p);
sd_bus_error_set_errno(&berror, error);
- return sd_bus_message_new_method_error(call, &berror, m);
+ return sd_bus_message_new_method_error(call, m, &berror);
}
_public_ int sd_bus_message_new_method_errnof(
bus_error_set_errnofv(&berror, error, format, ap);
va_end(ap);
- return sd_bus_message_new_method_error(call, &berror, m);
+ return sd_bus_message_new_method_error(call, m, &berror);
}
int bus_message_new_synthetic_error(
switch ((*m)->header->type) {
case SD_BUS_MESSAGE_SIGNAL:
- r = sd_bus_message_new_signal(bus, (*m)->path, (*m)->interface, (*m)->member, &n);
+ r = sd_bus_message_new_signal(bus, &n, (*m)->path, (*m)->interface, (*m)->member);
if (r < 0)
return r;
break;
case SD_BUS_MESSAGE_METHOD_CALL:
- r = sd_bus_message_new_method_call(bus, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member, &n);
+ r = sd_bus_message_new_method_call(bus, &n, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member);
if (r < 0)
return r;
if (!n)
return 0;
- r = sd_bus_message_new_signal(bus, path, "org.freedesktop.DBus.Properties", "PropertiesChanged", &m);
+ r = sd_bus_message_new_signal(bus, &m, path, "org.freedesktop.DBus.Properties", "PropertiesChanged");
if (r < 0)
return r;
if (m)
m = sd_bus_message_unref(m);
- r = sd_bus_message_new_signal(bus, path, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded", &m);
+ r = sd_bus_message_new_signal(bus, &m, path, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
if (r < 0)
return r;
if (strv_isempty(interfaces))
return 0;
- r = sd_bus_message_new_signal(bus, path, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved", &m);
+ r = sd_bus_message_new_signal(bus, &m, path, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
if (r < 0)
return r;
r = sd_bus_message_new_method_call(
bus,
+ &pk,
"org.freedesktop.PolicyKit1",
"/org/freedesktop/PolicyKit1/Authority",
"org.freedesktop.PolicyKit1.Authority",
- "CheckAuthorization",
- &pk);
+ "CheckAuthorization");
if (r < 0)
return r;
if (r < 0)
r = sd_bus_get_owner(bus, argv[1], _SD_BUS_CREDS_ALL, &creds);
else
- r = sd_bus_creds_new_from_pid(pid, _SD_BUS_CREDS_ALL, &creds);
+ r = sd_bus_creds_new_from_pid(&creds, pid, _SD_BUS_CREDS_ALL);
if (r < 0) {
log_error("Failed to get credentials: %s", strerror(-r));
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
- "Hello",
- &m);
+ "Hello");
if (r < 0)
return r;
/* Then, synthesize a Disconnected message */
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/DBus/Local",
"org.freedesktop.DBus.Local",
- "Disconnected",
- &m);
+ "Disconnected");
if (r < 0)
return r;
return 0;
if (!bus->input_io_event_source) {
- r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
+ r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
if (r < 0)
return r;
assert(bus->output_fd >= 0);
if (!bus->output_io_event_source) {
- r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
+ r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
if (r < 0)
return r;
bus->event_priority = priority;
- r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
+ r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus);
if (r < 0)
goto fail;
if (r < 0)
goto fail;
- r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
+ r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
if (r < 0)
goto fail;
FILE *f;
};
-_public_ int sd_memfd_new(const char *name, sd_memfd **m) {
+_public_ int sd_memfd_new(sd_memfd **m, const char *name) {
struct kdbus_cmd_memfd_make *cmd;
struct kdbus_item *item;
return 0;
}
-_public_ int sd_memfd_make(int fd, sd_memfd **m) {
+_public_ int sd_memfd_new_from_fd(sd_memfd **m, int fd) {
sd_memfd *n;
uint64_t sz;
return r;
}
-_public_ int sd_memfd_new_and_map(const char *name, sd_memfd **m, size_t sz, void **p) {
+_public_ int sd_memfd_new_and_map(sd_memfd **m, const char *name, size_t sz, void **p) {
sd_memfd *n;
int r;
- r = sd_memfd_new(name, &n);
+ r = sd_memfd_new(&n, name);
if (r < 0)
return r;
r = sd_bus_message_new_method_call(
bus,
+ &q,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
- "ExitClient1",
- &q);
+ "ExitClient1");
if (r < 0)
log_error("Failed to allocate method call: %s", strerror(-r));
else
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd.test",
"/foo/bar/waldo/piep",
"org.object.test",
- "Foobar",
- &m);
+ "Foobar");
if (r < 0) {
log_error("Failed to allocate method call: %s", strerror(-r));
goto finish;
r = sd_bus_message_new_signal(
bus,
+ &m,
"/foobar",
"foo.bar",
- "Notify",
- &m);
+ "Notify");
if (r < 0) {
log_error("Failed to allocate signal: %s", strerror(-r));
goto finish;
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.DBus.Peer",
- "GetMachineId",
- &m);
+ "GetMachineId");
if (r < 0) {
log_error("Failed to allocate method call: %s", strerror(-r));
goto finish;
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
- "Slow",
- &m);
+ "Slow");
if (r < 0) {
log_error("Failed to allocate method call: %s", strerror(-r));
goto finish;
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
- "Slow",
- &m);
+ "Slow");
if (r < 0) {
log_error("Failed to allocate method call: %s", strerror(-r));
goto finish;
r = sd_bus_message_new_method_call(
bus,
+ &q,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
- "ExitClient2",
- &q);
+ "ExitClient2");
if (r < 0) {
log_error("Failed to allocate method call: %s", strerror(-r));
goto finish;
assert_se(sd_bus_open_system(&bus) >= 0);
- assert_se(sd_bus_message_new_method_call(bus, "a.service.name", "/an/object/path", "an.interface.name", "AMethodName", &m) >= 0);
+ assert_se(sd_bus_message_new_method_call(bus, &m, "a.service.name", "/an/object/path", "an.interface.name", "AMethodName") >= 0);
printf("after message_new_method_call: refcount %u\n", REFCNT_GET(bus->n_ref));
assert_se(sd_bus_open_system(&bus) >= 0);
- assert_se(sd_bus_message_new_signal(bus, "/an/object/path", "an.interface.name", "Name", &m) >= 0);
+ assert_se(sd_bus_message_new_signal(bus, &m, "/an/object/path", "an.interface.name", "Name") >= 0);
printf("after message_new_signal: refcount %u\n", REFCNT_GET(bus->n_ref));
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
int r;
- r = sd_bus_creds_new_from_pid(0, _SD_BUS_CREDS_ALL, &creds);
+ r = sd_bus_creds_new_from_pid(&creds, 0, _SD_BUS_CREDS_ALL);
assert_se(r >= 0);
bus_creds_dump(creds, NULL);
creds = sd_bus_creds_unref(creds);
- r = sd_bus_creds_new_from_pid(1, _SD_BUS_CREDS_ALL, &creds);
+ r = sd_bus_creds_new_from_pid(&creds, 1, _SD_BUS_CREDS_ALL);
if (r != -EACCES) {
assert_se(r >= 0);
putchar('\n');
assert_se(sd_bus_open_system(&bus) >= 0);
bus->message_version = 2; /* dirty hack to enable gvariant*/
- assert_se(sd_bus_message_new_method_call(bus, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName", &m) >= 0);
+ assert_se(sd_bus_message_new_method_call(bus, &m, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName") >= 0);
assert_se(sd_bus_message_append(m,
"a(usv)", 3,
m = sd_bus_message_unref(m);
- assert_se(sd_bus_message_new_method_call(bus, "a.x", "/a/x", "a.x", "Ax", &m) >= 0);
+ assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0);
assert_se(sd_bus_message_append(m, "as", 0) >= 0);
_cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
uint8_t *p;
- assert_se(sd_bus_message_new_method_call(b, ":1.1", "/", "benchmark.server", "Work", &m) >= 0);
+ assert_se(sd_bus_message_new_method_call(b, &m, ":1.1", "/", "benchmark.server", "Work") >= 0);
assert_se(sd_bus_message_append_array_space(m, 'y', sz, (void**) &p) >= 0);
memset(p, 0x80, sz);
}
b->use_memfd = 1;
- assert_se(sd_bus_message_new_method_call(b, ":1.1", "/", "benchmark.server", "Exit", &x) >= 0);
+ assert_se(sd_bus_message_new_method_call(b, &x, ":1.1", "/", "benchmark.server", "Exit") >= 0);
assert_se(sd_bus_message_append(x, "t", csize) >= 0);
assert_se(sd_bus_send(b, x, NULL) >= 0);
}
b->use_memfd = 1;
- assert_se(sd_bus_message_new_method_call(b, ":1.1", "/", "benchmark.server", "Exit", &x) >= 0);
+ assert_se(sd_bus_message_new_method_call(b, &x, ":1.1", "/", "benchmark.server", "Exit") >= 0);
assert_se(sd_bus_message_append(x, "t", csize) >= 0);
assert_se(sd_bus_send(b, x, NULL) >= 0);
r = sd_bus_request_name(a, "net.x0pointer.foobar", 0);
assert_se(r >= 0);
- r = sd_bus_message_new_method_call(b, "net.x0pointer.foobar", "/a/path", "an.inter.face", "AMethod", &m);
+ r = sd_bus_message_new_method_call(b, &m, "net.x0pointer.foobar", "/a/path", "an.inter.face", "AMethod");
assert_se(r >= 0);
assert_se(pipe2(pipe_fds, O_CLOEXEC) >= 0);
_cleanup_fclose_ FILE *ms = NULL;
size_t first_size = 0, second_size = 0, third_size = 0;
- r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", &m);
+ r = sd_bus_message_new_method_call(NULL, &m, "foobar.waldo", "/", "foobar.waldo", "Piep");
assert_se(r >= 0);
r = sd_bus_message_append(m, "s", "a string");
r = sd_bus_message_peek_type(m, NULL, NULL);
assert_se(r == 0);
- r = sd_bus_message_new_method_call(NULL, "foobar.waldo", "/", "foobar.waldo", "Piep", ©);
+ r = sd_bus_message_new_method_call(NULL, ©, "foobar.waldo", "/", "foobar.waldo", "Piep");
assert_se(r >= 0);
r = sd_bus_message_rewind(m, true);
bus_match_dump(&root, 0);
- assert_se(sd_bus_message_new_signal(NULL, "/foo/bar", "bar.x", "waldo", &m) >= 0);
+ assert_se(sd_bus_message_new_signal(NULL, &m, "/foo/bar", "bar.x", "waldo") >= 0);
assert_se(sd_bus_message_append(m, "ssss", "one", "two", "/prefix/three", "prefix.four") >= 0);
assert_se(bus_message_seal(m, 1, 0) >= 0);
log_set_max_level(LOG_DEBUG);
- r = sd_memfd_new(NULL, &m);
+ r = sd_memfd_new(&m, NULL);
if (r == -ENOENT)
return EXIT_TEST_SKIP;
sd_memfd_free(m);
/* new sd_memfd, same underlying memfd */
- r = sd_memfd_make(fd, &m);
+ r = sd_memfd_new_from_fd(&m, fd);
assert_se(r >= 0);
/* we did truncate it to 6 */
} else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
r = sd_bus_message_new_method_error(
m,
- &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."),
- &reply);
+ &reply,
+ &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
if (r < 0) {
log_error("Failed to allocate return: %s", strerror(-r));
goto fail;
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
- "Exit",
- &m);
+ "Exit");
if (r < 0) {
log_error("Failed to allocate method call: %s", strerror(-r));
return r;
r = sd_bus_start(b);
assert_se(r >= 0);
- r = sd_bus_message_new_method_call(b, ":1.1", "/a/path", "an.inter.face", "AMethod", &m);
+ r = sd_bus_message_new_method_call(b, &m, ":1.1", "/a/path", "an.inter.face", "AMethod");
assert_se(r >= 0);
r = sd_bus_message_open_container(m, 'r', "aysay");
memset(p+1, 'L', FIRST_ARRAY-2);
p[FIRST_ARRAY-1] = '>';
- r = sd_memfd_new_and_map(NULL, &f, STRING_SIZE, (void**) &s);
+ r = sd_memfd_new_and_map(&f, NULL, STRING_SIZE, (void**) &s);
assert_se(r >= 0);
s[0] = '<';
sd_memfd_free(f);
- r = sd_memfd_new_and_map(NULL, &f, SECOND_ARRAY, (void**) &p);
+ r = sd_memfd_new_and_map(&f, NULL, SECOND_ARRAY, (void**) &p);
assert_se(r >= 0);
p[0] = '<';
_public_ int sd_event_add_io(
sd_event *e,
+ sd_event_source **ret,
int fd,
uint32_t events,
sd_event_io_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
sd_event_source *s;
int r;
static int event_add_time_internal(
sd_event *e,
+ sd_event_source **ret,
EventSourceType type,
int *timer_fd,
clockid_t id,
uint64_t usec,
uint64_t accuracy,
sd_event_time_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
sd_event_source *s;
int r;
}
_public_ int sd_event_add_monotonic(sd_event *e,
+ sd_event_source **ret,
uint64_t usec,
uint64_t accuracy,
sd_event_time_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
- return event_add_time_internal(e, SOURCE_MONOTONIC, &e->monotonic_fd, CLOCK_MONOTONIC, &e->monotonic_earliest, &e->monotonic_latest, usec, accuracy, callback, userdata, ret);
+ return event_add_time_internal(e, ret, SOURCE_MONOTONIC, &e->monotonic_fd, CLOCK_MONOTONIC, &e->monotonic_earliest, &e->monotonic_latest, usec, accuracy, callback, userdata);
}
_public_ int sd_event_add_realtime(sd_event *e,
+ sd_event_source **ret,
uint64_t usec,
uint64_t accuracy,
sd_event_time_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
- return event_add_time_internal(e, SOURCE_REALTIME, &e->realtime_fd, CLOCK_REALTIME, &e->realtime_earliest, &e->monotonic_latest, usec, accuracy, callback, userdata, ret);
+ return event_add_time_internal(e, ret, SOURCE_REALTIME, &e->realtime_fd, CLOCK_REALTIME, &e->realtime_earliest, &e->monotonic_latest, usec, accuracy, callback, userdata);
}
static int event_update_signal_fd(sd_event *e) {
_public_ int sd_event_add_signal(
sd_event *e,
+ sd_event_source **ret,
int sig,
sd_event_signal_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
sd_event_source *s;
sigset_t ss;
_public_ int sd_event_add_child(
sd_event *e,
+ sd_event_source **ret,
pid_t pid,
int options,
sd_event_child_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
sd_event_source *s;
int r;
_public_ int sd_event_add_defer(
sd_event *e,
+ sd_event_source **ret,
sd_event_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
sd_event_source *s;
int r;
_public_ int sd_event_add_exit(
sd_event *e,
+ sd_event_source **ret,
sd_event_handler_t callback,
- void *userdata,
- sd_event_source **ret) {
+ void *userdata) {
sd_event_source *s;
int r;
if (pid == 0)
_exit(0);
- assert_se(sd_event_add_child(sd_event_source_get_event(s), pid, WEXITED, child_handler, INT_TO_PTR('f'), &p) >= 0);
+ assert_se(sd_event_add_child(sd_event_source_get_event(s), &p, pid, WEXITED, child_handler, INT_TO_PTR('f')) >= 0);
assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
sd_event_source_unref(s);
assert_se(sigemptyset(&ss) >= 0);
assert_se(sigaddset(&ss, SIGUSR1) >= 0);
assert_se(sigprocmask(SIG_BLOCK, &ss, NULL) >= 0);
- assert_se(sd_event_add_signal(sd_event_source_get_event(s), SIGUSR1, signal_handler, INT_TO_PTR('e'), &p) >= 0);
+ assert_se(sd_event_add_signal(sd_event_source_get_event(s), &p, SIGUSR1, signal_handler, INT_TO_PTR('e')) >= 0);
assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
raise(SIGUSR1);
if (do_quit) {
sd_event_source *p;
- assert_se(sd_event_add_defer(sd_event_source_get_event(s), defer_handler, INT_TO_PTR('d'), &p) >= 0);
+ assert_se(sd_event_add_defer(sd_event_source_get_event(s), &p, defer_handler, INT_TO_PTR('d')) >= 0);
assert_se(sd_event_source_set_enabled(p, SD_EVENT_ONESHOT) >= 0);
} else {
assert(!got_c);
/* Test whether we cleanly can destroy an io event source from its own handler */
got_unref = false;
- assert_se(sd_event_add_io(e, k[0], EPOLLIN, unref_handler, NULL, &t) >= 0);
+ assert_se(sd_event_add_io(e, &t, k[0], EPOLLIN, unref_handler, NULL) >= 0);
assert_se(write(k[1], &ch, 1) == 1);
assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
assert_se(got_unref);
/* Add a oneshot handler, trigger it, re-enable it, and trigger
* it again. */
- assert_se(sd_event_add_io(e, d[0], EPOLLIN, io_handler, INT_TO_PTR('d'), &w) >= 0);
+ assert_se(sd_event_add_io(e, &w, d[0], EPOLLIN, io_handler, INT_TO_PTR('d')) >= 0);
assert_se(sd_event_source_set_enabled(w, SD_EVENT_ONESHOT) >= 0);
assert_se(write(d[1], &ch, 1) >= 0);
assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
assert_se(sd_event_run(e, (uint64_t) -1) >= 1);
assert_se(got_d == 2);
- assert_se(sd_event_add_io(e, a[0], EPOLLIN, io_handler, INT_TO_PTR('a'), &x) >= 0);
- assert_se(sd_event_add_io(e, b[0], EPOLLIN, io_handler, INT_TO_PTR('b'), &y) >= 0);
- assert_se(sd_event_add_monotonic(e, 0, 0, time_handler, INT_TO_PTR('c'), &z) >= 0);
- assert_se(sd_event_add_exit(e, exit_handler, INT_TO_PTR('g'), &q) >= 0);
+ assert_se(sd_event_add_io(e, &x, a[0], EPOLLIN, io_handler, INT_TO_PTR('a')) >= 0);
+ assert_se(sd_event_add_io(e, &y, b[0], EPOLLIN, io_handler, INT_TO_PTR('b')) >= 0);
+ assert_se(sd_event_add_monotonic(e, &z, 0, 0, time_handler, INT_TO_PTR('c')) >= 0);
+ assert_se(sd_event_add_exit(e, &q, exit_handler, INT_TO_PTR('g')) >= 0);
assert_se(sd_event_source_set_priority(x, 99) >= 0);
assert_se(sd_event_source_set_enabled(y, SD_EVENT_ONESHOT) >= 0);
_public_ int sd_resolve_getaddrinfo(
sd_resolve *resolve,
+ sd_resolve_query **_q,
const char *node,
const char *service,
- const struct addrinfo *hints,
- sd_resolve_query **_q) {
+ const struct addrinfo *hints) {
AddrInfoRequest req = {};
struct msghdr mh = {};
_public_ int sd_resolve_getnameinfo(
sd_resolve *resolve,
+ sd_resolve_query**_q,
const struct sockaddr *sa, socklen_t salen,
int flags,
- int gethost, int getserv,
- sd_resolve_query**_q) {
+ int gethost, int getserv) {
NameInfoRequest req = {};
struct msghdr mh = {};
static int resolve_res(
sd_resolve *resolve,
+ sd_resolve_query **_q,
QueryType qtype,
const char *dname,
- int class, int type,
- sd_resolve_query **_q) {
+ int class, int type) {
struct msghdr mh = {};
struct iovec iov[2];
return 0;
}
-_public_ int sd_resolve_res_query(sd_resolve *resolve, const char *dname, int class, int type, sd_resolve_query** q) {
- return resolve_res(resolve, REQUEST_RES_QUERY, dname, class, type, q);
+_public_ int sd_resolve_res_query(sd_resolve *resolve, sd_resolve_query** q, const char *dname, int class, int type) {
+ return resolve_res(resolve, q, REQUEST_RES_QUERY, dname, class, type);
}
-_public_ int sd_resolve_res_search(sd_resolve *resolve, const char *dname, int class, int type, sd_resolve_query** q) {
- return resolve_res(resolve, REQUEST_RES_SEARCH, dname, class, type, q);
+_public_ int sd_resolve_res_search(sd_resolve *resolve, sd_resolve_query** q, const char *dname, int class, int type) {
+ return resolve_res(resolve, q, REQUEST_RES_SEARCH, dname, class, type);
}
_public_ int sd_resolve_res_done(sd_resolve_query* q, unsigned char **answer) {
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_CANONNAME;
- r = sd_resolve_getaddrinfo(resolve, argc >= 2 ? argv[1] : "www.heise.de", NULL, &hints, &q1);
+ r = sd_resolve_getaddrinfo(resolve, &q1, argc >= 2 ? argv[1] : "www.heise.de", NULL, &hints);
if (r < 0)
log_error("sd_resolve_getaddrinfo(): %s\n", strerror(-r));
sa.sin_addr.s_addr = inet_addr(argc >= 3 ? argv[2] : "193.99.144.71");
sa.sin_port = htons(80);
- r = sd_resolve_getnameinfo(resolve, (struct sockaddr*) &sa, sizeof(sa), 0, true, true, &q2);
+ r = sd_resolve_getnameinfo(resolve, &q2, (struct sockaddr*) &sa, sizeof(sa), 0, true, true);
if (r < 0)
log_error("sd_resolve_getnameinfo(): %s\n", strerror(-r));
/* Make a res_query() call */
- r = sd_resolve_res_query(resolve, "_xmpp-client._tcp.gmail.com", C_IN, T_SRV, &q3);
+ r = sd_resolve_res_query(resolve, &q3, "_xmpp-client._tcp.gmail.com", C_IN, T_SRV);
if (r < 0)
log_error("sd_resolve_res_query(): %s\n", strerror(-r));
return 0;
}
-int sd_rtnl_message_new_route(sd_rtnl *rtnl, uint16_t nlmsg_type,
- unsigned char rtm_family,
- sd_rtnl_message **ret) {
+int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret,
+ uint16_t nlmsg_type, unsigned char rtm_family) {
struct rtmsg *rtm;
int r;
return 0;
}
-int sd_rtnl_message_new_link(sd_rtnl *rtnl, uint16_t nlmsg_type, int index,
- sd_rtnl_message **ret) {
+int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret,
+ uint16_t nlmsg_type, int index) {
struct ifinfomsg *ifi;
int r;
return 0;
}
-int sd_rtnl_message_new_addr(sd_rtnl *rtnl, uint16_t nlmsg_type, int index,
- unsigned char family,
- sd_rtnl_message **ret) {
+int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret,
+ uint16_t nlmsg_type, int index,
+ unsigned char family) {
struct ifaddrmsg *ifa;
int r;
assert(ifindex > 0);
assert(name);
- r = sd_rtnl_message_new_link(rtnl, RTM_SETLINK, ifindex, &message);
+ r = sd_rtnl_message_new_link(rtnl, &message, RTM_SETLINK, ifindex);
if (r < 0)
return r;
if (!alias && !mac && mtu == 0)
return 0;
- r = sd_rtnl_message_new_link(rtnl, RTM_SETLINK, ifindex, &message);
+ r = sd_rtnl_message_new_link(rtnl, &message, RTM_SETLINK, ifindex);
if (r < 0)
return r;
return rtnl->original_pid != getpid();
}
-int sd_rtnl_open(uint32_t groups, sd_rtnl **ret) {
+int sd_rtnl_open(sd_rtnl **ret, uint32_t groups) {
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
socklen_t addrlen;
int r;
return r;
}
- r = sd_event_add_io(rtnl->event, rtnl->fd, 0, io_callback, rtnl, &rtnl->io_event_source);
+ r = sd_event_add_io(rtnl->event, &rtnl->io_event_source, rtnl->fd, 0, io_callback, rtnl);
if (r < 0)
goto fail;
if (r < 0)
goto fail;
- r = sd_event_add_monotonic(rtnl->event, 0, 0, time_callback, rtnl, &rtnl->time_event_source);
+ r = sd_event_add_monotonic(rtnl->event, &rtnl->time_event_source, 0, 0, time_callback, rtnl);
if (r < 0)
goto fail;
if (r < 0)
goto fail;
- r = sd_event_add_exit(rtnl->event, exit_callback, rtnl, &rtnl->exit_event_source);
+ r = sd_event_add_exit(rtnl->event, &rtnl->exit_event_source, exit_callback, rtnl);
if (r < 0)
goto fail;
void *data;
/* we'd really like to test NEWLINK, but let's not mess with the running kernel */
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, ifindex, &message) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, ifindex) >= 0);
assert(sd_rtnl_message_append_string(message, IFLA_IFNAME, name) >= 0);
assert(sd_rtnl_message_append_ether_addr(message, IFLA_ADDRESS, ether_aton(mac)) >= 0);
assert(sd_rtnl_message_append_u32(message, IFLA_MTU, mtu) >= 0);
assert(mtu == *(unsigned int *) data);
}
-
static void test_link_get(sd_rtnl *rtnl, int ifindex) {
sd_rtnl_message *m;
sd_rtnl_message *r;
void *data;
uint16_t type;
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, ifindex, &m) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
assert(m);
/* u8 test cases */
void *data;
int r;
- r = sd_rtnl_message_new_route(NULL, RTM_NEWROUTE, AF_INET, &req);
+ r = sd_rtnl_message_new_route(NULL, &req, RTM_NEWROUTE, AF_INET);
if (r < 0) {
log_error("Could not create RTM_NEWROUTE message: %s", strerror(-r));
return;
static void test_multiple(void) {
sd_rtnl *rtnl1, *rtnl2;
- assert(sd_rtnl_open(0, &rtnl1) >= 0);
- assert(sd_rtnl_open(0, &rtnl2) >= 0);
+ assert(sd_rtnl_open(&rtnl1, 0) >= 0);
+ assert(sd_rtnl_open(&rtnl2, 0) >= 0);
rtnl1 = sd_rtnl_unref(rtnl1);
rtnl2 = sd_rtnl_unref(rtnl2);
ifname = strdup("lo2");
assert(ifname);
- assert(sd_rtnl_open(0, &rtnl) >= 0);
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, ifindex, &m) >= 0);
+ assert(sd_rtnl_open(&rtnl, 0) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
assert(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, NULL) >= 0);
ifname = strdup("lo");
assert(ifname);
- assert(sd_rtnl_open(0, &rtnl) >= 0);
+ assert(sd_rtnl_open(&rtnl, 0) >= 0);
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, ifindex, &m) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
assert(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, &serial) >= 0);
_cleanup_rtnl_message_unref_ sd_rtnl_message *m1 = NULL, *m2 = NULL;
int counter = 0;
- assert(sd_rtnl_open(0, &rtnl) >= 0);
+ assert(sd_rtnl_open(&rtnl, 0) >= 0);
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, ifindex, &m1) >= 0);
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, ifindex, &m2) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &m1, RTM_GETLINK, ifindex) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &m2, RTM_GETLINK, ifindex) >= 0);
counter ++;
assert(sd_rtnl_call_async(rtnl, m1, &pipe_handler, &counter, 0, NULL) >= 0);
uint16_t type;
void *data;
- assert(sd_rtnl_message_new_link(NULL, RTM_NEWLINK, 0, &m) >= 0);
+ assert(sd_rtnl_message_new_link(NULL, &m, RTM_NEWLINK, 0) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0);
assert(sd_rtnl_message_open_container(m, IFLA_LINKINFO) == -ENOTSUP);
static void test_match(void) {
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
- assert(sd_rtnl_open(0, &rtnl) >= 0);
+ assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(sd_rtnl_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
assert(sd_rtnl_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
test_container();
- assert(sd_rtnl_open(0, &rtnl) >= 0);
+ assert(sd_rtnl_open(&rtnl, 0) >= 0);
assert(rtnl);
if_loopback = (int) if_nametoindex("lo");
test_link_configure(rtnl, if_loopback);
- assert(sd_rtnl_message_new_link(rtnl, RTM_GETLINK, if_loopback, &m) >= 0);
+ assert(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
assert(m);
assert(sd_rtnl_message_get_type(m, &type) >= 0);
polkit_agent_open_if_enabled();
- r = sd_bus_message_new_method_call(bus,
+ r = sd_bus_message_new_method_call(
+ bus,
+ &m,
"org.freedesktop.locale1",
"/org/freedesktop/locale1",
"org.freedesktop.locale1",
- "SetLocale", &m);
+ "SetLocale");
if (r < 0)
return bus_log_create_error(r);
}
assert(c_set + c_unset == _LOCALE_MAX);
- r = sd_bus_message_new_method_call(bus,
+ r = sd_bus_message_new_method_call(bus, &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "UnsetAndSetEnvironment", &m);
+ "UnsetAndSetEnvironment");
if (r < 0)
return r;
goto fail;
}
- r = sd_event_add_io(b->manager->event, b->fd, EPOLLIN, button_dispatch, b, &b->event_source);
+ r = sd_event_add_io(b->manager->event, &b->event_source, b->fd, EPOLLIN, button_dispatch, b);
if (r < 0) {
log_error("Failed to add button event: %s", strerror(-r));
goto fail;
r = sd_bus_message_new_method_call(
manager->bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "StartTransientUnit",
- &m);
+ "StartTransientUnit");
if (r < 0)
return r;
}
if (!i->event_source) {
- r = sd_event_add_io(i->manager->event, i->fifo_fd, 0, inhibitor_dispatch_fifo, i, &i->event_source);
+ r = sd_event_add_io(i->manager->event, &i->event_source, i->fifo_fd, 0, inhibitor_dispatch_fifo, i);
if (r < 0)
return r;
return -ENOMEM;
r = sd_bus_message_new_signal(
- sd->session->manager->bus, path,
+ sd->session->manager->bus,
+ &m, path,
"org.freedesktop.login1.Session",
- (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice",
- &m);
+ (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice");
if (!m)
return r;
return;
if (!s->timer_event_source)
- sd_event_add_monotonic(s->manager->event, now(CLOCK_MONOTONIC) + RELEASE_USEC, 0, release_timeout_callback, s, &s->timer_event_source);
+ sd_event_add_monotonic(s->manager->event, &s->timer_event_source, now(CLOCK_MONOTONIC) + RELEASE_USEC, 0, release_timeout_callback, s);
}
bool session_is_active(Session *s) {
}
if (!s->fifo_event_source) {
- r = sd_event_add_io(s->manager->event, s->fifo_fd, 0, session_dispatch_fifo, s, &s->fifo_event_source);
+ r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s);
if (r < 0)
return r;
sigaddset(&mask, SIGUSR1);
sigprocmask(SIG_BLOCK, &mask, NULL);
- r = sd_event_add_signal(s->manager->event, SIGUSR1, session_vt_fn, s, &s->vt_source);
+ r = sd_event_add_signal(s->manager->event, &s->vt_source, SIGUSR1, session_vt_fn, s);
if (r < 0)
goto error;
return -errno;
}
- r = sd_event_add_io(m->event, m->console_active_fd, 0, manager_dispatch_console, m, &m->console_active_event_source);
+ r = sd_event_add_io(m->event, &m->console_active_event_source, m->console_active_fd, 0, manager_dispatch_console, m);
if (r < 0) {
log_error("Failed to watch foreground console");
return r;
if (r < 0)
return r;
- r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_seat_monitor), EPOLLIN, manager_dispatch_seat_udev, m, &m->udev_seat_event_source);
+ r = sd_event_add_io(m->event, &m->udev_seat_event_source, udev_monitor_get_fd(m->udev_seat_monitor), EPOLLIN, manager_dispatch_seat_udev, m);
if (r < 0)
return r;
if (r < 0)
return r;
- r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_device_monitor), EPOLLIN, manager_dispatch_device_udev, m, &m->udev_device_event_source);
+ r = sd_event_add_io(m->event, &m->udev_device_event_source, udev_monitor_get_fd(m->udev_device_monitor), EPOLLIN, manager_dispatch_device_udev, m);
if (r < 0)
return r;
if (r < 0)
return r;
- r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_button_monitor), EPOLLIN, manager_dispatch_button_udev, m, &m->udev_button_event_source);
+ r = sd_event_add_io(m->event, &m->udev_button_event_source, udev_monitor_get_fd(m->udev_button_monitor), EPOLLIN, manager_dispatch_button_udev, m);
if (r < 0)
return r;
}
if (r < 0)
return r;
- r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m, &m->udev_vcsa_event_source);
+ r = sd_event_add_io(m->event, &m->udev_vcsa_event_source, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m);
if (r < 0)
return r;
}
if (!m->idle_action_event_source) {
- r = sd_event_add_monotonic(m->event, elapse, USEC_PER_SEC*30, manager_dispatch_idle_action, m, &m->idle_action_event_source);
+ r = sd_event_add_monotonic(m->event, &m->idle_action_event_source, elapse, USEC_PER_SEC*30, manager_dispatch_idle_action, m);
if (r < 0) {
log_error("Failed to add idle event source: %s", strerror(-r));
return r;
r = sd_bus_message_new_method_call(
manager->bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "StartTransientUnit",
- &m);
+ "StartTransientUnit");
if (r < 0)
return r;
assert(link->manager);
assert(link->manager->rtnl);
- r = sd_rtnl_message_new_addr(link->manager->rtnl, RTM_DELADDR,
- link->ifindex, address->family, &req);
+ r = sd_rtnl_message_new_addr(link->manager->rtnl, &req, RTM_DELADDR,
+ link->ifindex, address->family);
if (r < 0) {
log_error("Could not allocate RTM_DELADDR message: %s",
strerror(-r));
assert(link->manager);
assert(link->manager->rtnl);
- r = sd_rtnl_message_new_addr(link->manager->rtnl, RTM_NEWADDR,
- link->ifindex, address->family, &req);
+ r = sd_rtnl_message_new_addr(link->manager->rtnl, &req, RTM_NEWADDR,
+ link->ifindex, address->family);
if (r < 0) {
log_error("Could not allocate RTM_NEWADDR message: %s",
strerror(-r));
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.hostname1",
"/org/freedesktop/hostname1",
"org.freedesktop.hostname1",
- "SetHostname",
- &m);
+ "SetHostname");
if (r < 0)
return r;
log_debug_link(link, "setting MTU: %" PRIu32, mtu);
- r = sd_rtnl_message_new_link(link->manager->rtnl, RTM_SETLINK,
- link->ifindex, &req);
+ r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
+ RTM_SETLINK, link->ifindex);
if (r < 0) {
log_error_link(link, "Could not allocate RTM_SETLINK message");
return r;
log_debug_link(link, "bringing link up");
- r = sd_rtnl_message_new_link(link->manager->rtnl, RTM_SETLINK,
- link->ifindex, &req);
+ r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
+ RTM_SETLINK, link->ifindex);
if (r < 0) {
log_error_link(link, "Could not allocate RTM_SETLINK message");
return r;
log_debug_link(link, "requesting link status");
- r = sd_rtnl_message_new_link(link->manager->rtnl, RTM_GETLINK,
- link->ifindex, &req);
+ r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
+ RTM_GETLINK, link->ifindex);
if (r < 0) {
log_error_link(link, "Could not allocate RTM_GETLINK message");
return r;
sd_event_set_watchdog(m->event, true);
- r = sd_rtnl_open(RTMGRP_LINK | RTMGRP_IPV4_IFADDR, &m->rtnl);
+ r = sd_rtnl_open(&m->rtnl, RTMGRP_LINK | RTMGRP_IPV4_IFADDR);
if (r < 0)
return r;
}
r = sd_event_add_io(m->event,
+ &m->udev_event_source,
udev_monitor_get_fd(m->udev_monitor),
EPOLLIN, manager_dispatch_link_udev,
- m, &m->udev_event_source);
+ m);
if (r < 0)
return r;
assert(link);
assert(callback);
- r = sd_rtnl_message_new_link(netdev->manager->rtnl, RTM_SETLINK,
- link->ifindex, &req);
+ r = sd_rtnl_message_new_link(netdev->manager->rtnl, &req,
+ RTM_SETLINK, link->ifindex);
if (r < 0) {
log_error_netdev(netdev,
"Could not allocate RTM_SETLINK message: %s",
assert(netdev->manager);
assert(netdev->manager->rtnl);
- r = sd_rtnl_message_new_link(netdev->manager->rtnl, RTM_NEWLINK, 0, &req);
+ r = sd_rtnl_message_new_link(netdev->manager->rtnl, &req, RTM_NEWLINK, 0);
if (r < 0) {
log_error_netdev(netdev,
"Could not allocate RTM_NEWLINK message: %s",
assert(link->ifindex > 0);
assert(route->family == AF_INET || route->family == AF_INET6);
- r = sd_rtnl_message_new_route(link->manager->rtnl, RTM_NEWROUTE,
- route->family, &req);
+ r = sd_rtnl_message_new_route(link->manager->rtnl, &req,
+ RTM_NEWROUTE, route->family);
if (r < 0) {
log_error("Could not create RTM_NEWROUTE message: %s", strerror(-r));
return r;
strncpy(iface_name+3, arg_machine, IFNAMSIZ - 3);
- r = sd_rtnl_open(0, &rtnl);
+ r = sd_rtnl_open(&rtnl, 0);
if (r < 0) {
log_error("Failed to connect to netlink: %s", strerror(-r));
return r;
}
- r = sd_rtnl_message_new_link(rtnl, RTM_NEWLINK, 0, &m);
+ r = sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0);
if (r < 0) {
log_error("Failed to allocate netlink message: %s", strerror(-r));
return r;
return -errno;
}
- r = sd_rtnl_open(0, &rtnl);
+ r = sd_rtnl_open(&rtnl, 0);
if (r < 0) {
log_error("Failed to connect to netlink: %s", strerror(-r));
return r;
}
- r = sd_rtnl_message_new_link(rtnl, RTM_SETLINK, 0, &m);
+ r = sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, 0);
if (r < 0) {
log_error("Failed to allocate netlink message: %s", strerror(-r));
return r;
if (strv_isempty(arg_network_interfaces))
return 0;
- r = sd_rtnl_open(0, &rtnl);
+ r = sd_rtnl_open(&rtnl, 0);
if (r < 0) {
log_error("Failed to connect to netlink: %s", strerror(-r));
return r;
return -EBUSY;
}
- r = sd_rtnl_message_new_link(rtnl, RTM_NEWLINK, ifi, &m);
+ r = sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, ifi);
if (r < 0) {
log_error("Failed to allocate netlink message: %s", strerror(-r));
return r;
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "StartTransientUnit", &m);
+ "StartTransientUnit");
if (r < 0)
return r;
if (c->server_event_source)
r = sd_event_source_set_io_events(c->server_event_source, a);
else if (c->server_fd >= 0)
- r = sd_event_add_io(event, c->server_fd, a, traffic_cb, c, &c->server_event_source);
+ r = sd_event_add_io(event, &c->server_event_source, c->server_fd, a, traffic_cb, c);
else
r = 0;
if (c->client_event_source)
r = sd_event_source_set_io_events(c->client_event_source, b);
else if (c->client_fd >= 0)
- r = sd_event_add_io(event, c->client_fd, b, traffic_cb, c, &c->client_event_source);
+ r = sd_event_add_io(event, &c->client_event_source, c->client_fd, b, traffic_cb, c);
else
r = 0;
r = connect(c->client_fd, &sa.sa, salen);
if (r < 0) {
if (errno == EINPROGRESS) {
- r = sd_event_add_io(event, c->client_fd, EPOLLOUT, connect_cb, c, &c->client_event_source);
+ r = sd_event_add_io(event, &c->client_event_source, c->client_fd, EPOLLOUT, connect_cb, c);
if (r < 0) {
log_error("Failed to add connection socket: %s", strerror(-r));
goto fail;
return r;
}
- r = sd_event_add_io(event, fd, EPOLLIN, accept_cb, context, &source);
+ r = sd_event_add_io(event, &source, fd, EPOLLIN, accept_cb, context);
if (r < 0) {
log_error("Failed to add event source: %s", strerror(-r));
return r;
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "SetUnitProperties",
- &m);
+ "SetUnitProperties");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- method,
- &m);
+ method);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "SetEnvironment",
- &m);
+ "SetEnvironment");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- method,
- &m);
+ method);
if (r < 0)
return bus_log_create_error(r);
/* Message object */
-int sd_bus_message_new_signal(sd_bus *bus, const char *path, const char *interface, const char *member, sd_bus_message **m);
-int sd_bus_message_new_method_call(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message **m);
+int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member);
+int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member);
int sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **m);
-int sd_bus_message_new_method_error(sd_bus_message *call, const sd_bus_error *e, sd_bus_message **m);
+int sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e);
int sd_bus_message_new_method_errorf(sd_bus_message *call, sd_bus_message **m, const char *name, const char *format, ...) _sd_printf_(4, 5);
-int sd_bus_message_new_method_errno(sd_bus_message *call, int error, const sd_bus_error *e, sd_bus_message **m);
+int sd_bus_message_new_method_errno(sd_bus_message *call, sd_bus_message **m, int error, const sd_bus_error *e);
int sd_bus_message_new_method_errnof(sd_bus_message *call, sd_bus_message **m, int error, const char *format, ...) _sd_printf_(4, 5);
sd_bus_message* sd_bus_message_ref(sd_bus_message *m);
/* Credential handling */
-int sd_bus_creds_new_from_pid(pid_t pid, uint64_t creds_mask, sd_bus_creds **ret);
+int sd_bus_creds_new_from_pid(sd_bus_creds **ret, pid_t pid, uint64_t creds_mask);
sd_bus_creds *sd_bus_creds_ref(sd_bus_creds *c);
sd_bus_creds *sd_bus_creds_unref(sd_bus_creds *c);
uint64_t sd_bus_creds_get_mask(const sd_bus_creds *c);
sd_event* sd_event_ref(sd_event *e);
sd_event* sd_event_unref(sd_event *e);
-int sd_event_add_io(sd_event *e, int fd, uint32_t events, sd_event_io_handler_t callback, void *userdata, sd_event_source **s);
-int sd_event_add_monotonic(sd_event *e, uint64_t usec, uint64_t accuracy, sd_event_time_handler_t callback, void *userdata, sd_event_source **s);
-int sd_event_add_realtime(sd_event *e, uint64_t usec, uint64_t accuracy, sd_event_time_handler_t callback, void *userdata, sd_event_source **s);
-int sd_event_add_signal(sd_event *e, int sig, sd_event_signal_handler_t callback, void *userdata, sd_event_source **s);
-int sd_event_add_child(sd_event *e, pid_t pid, int options, sd_event_child_handler_t callback, void *userdata, sd_event_source **s);
-int sd_event_add_defer(sd_event *e, sd_event_handler_t callback, void *userdata, sd_event_source **s);
-int sd_event_add_exit(sd_event *e, sd_event_handler_t callback, void *userdata, sd_event_source **s);
+int sd_event_add_io(sd_event *e, sd_event_source **s, int fd, uint32_t events, sd_event_io_handler_t callback, void *userdata);
+int sd_event_add_monotonic(sd_event *e, sd_event_source **s, uint64_t usec, uint64_t accuracy, sd_event_time_handler_t callback, void *userdata);
+int sd_event_add_realtime(sd_event *e, sd_event_source **s, uint64_t usec, uint64_t accuracy, sd_event_time_handler_t callback, void *userdata);
+int sd_event_add_signal(sd_event *e, sd_event_source **s, int sig, sd_event_signal_handler_t callback, void *userdata);
+int sd_event_add_child(sd_event *e, sd_event_source **s, pid_t pid, int options, sd_event_child_handler_t callback, void *userdata);
+int sd_event_add_defer(sd_event *e, sd_event_source **s, sd_event_handler_t callback, void *userdata);
+int sd_event_add_exit(sd_event *e, sd_event_source **s, sd_event_handler_t callback, void *userdata);
int sd_event_run(sd_event *e, uint64_t timeout);
int sd_event_loop(sd_event *e);
int sd_journal_reliable_fd(sd_journal *j);
int sd_journal_get_catalog(sd_journal *j, char **text);
-int sd_journal_get_catalog_for_message_id(sd_id128_t id, char **ret);
+int sd_journal_get_catalog_for_message_id(sd_id128_t id, char **text);
#define SD_JOURNAL_FOREACH(j) \
if (sd_journal_seek_head(j) >= 0) \
typedef struct sd_memfd sd_memfd;
-int sd_memfd_new(const char *name, sd_memfd **m);
-int sd_memfd_new_and_map(const char *name, sd_memfd **m, size_t sz, void **p);
-int sd_memfd_make(int fd, sd_memfd **m);
+int sd_memfd_new(sd_memfd **m, const char *name);
+int sd_memfd_new_from_fd(sd_memfd **m, int fd);
+int sd_memfd_new_and_map(sd_memfd **m, const char *name, size_t sz, void **p);
void sd_memfd_free(sd_memfd *m);
* getaddrinfo(3). The function returns a new query object. When the
* query is completed you may retrieve the results using
* sd_resolve_getaddrinfo_done(). */
-int sd_resolve_getaddrinfo(sd_resolve *resolve, const char *node, const char *service, const struct addrinfo *hints, sd_resolve_query **q);
+int sd_resolve_getaddrinfo(sd_resolve *resolve, sd_resolve_query **q, const char *node, const char *service, const struct addrinfo *hints);
/** Retrieve the results of a preceding sd_resolve_getaddrinfo()
* call. Returns a addrinfo structure and a return value compatible
* query is completed you may retrieve the results using
* sd_resolve_getnameinfo_done(). Set gethost (resp. getserv) to non-zero
* if you want to query the hostname (resp. the service name). */
-int sd_resolve_getnameinfo(sd_resolve *resolve, const struct sockaddr *sa, socklen_t salen, int flags, int gethost, int getserv, sd_resolve_query **q);
+int sd_resolve_getnameinfo(sd_resolve *resolve, sd_resolve_query **q, const struct sockaddr *sa, socklen_t salen, int flags, int gethost, int getserv);
/** Retrieve the results of a preceding sd_resolve_getnameinfo()
* call. Returns the hostname and the service name in ret_host and
* compatible with the ones of libc's res_query(3). The function returns a new
* query object. When the query is completed you may retrieve the results using
* sd_resolve_res_done(). */
-int sd_resolve_res_query(sd_resolve *resolve, const char *dname, int class, int type, sd_resolve_query **q);
+int sd_resolve_res_query(sd_resolve *resolve, sd_resolve_query **q, const char *dname, int class, int type);
/** Issue an resolver query on the specified session. The arguments are
* compatible with the ones of libc's res_search(3). The function returns a new
* query object. When the query is completed you may retrieve the results using
* sd_resolve_res_done(). */
-int sd_resolve_res_search(sd_resolve *resolve, const char *dname, int class, int type, sd_resolve_query **q);
+int sd_resolve_res_search(sd_resolve *resolve, sd_resolve_query **q, const char *dname, int class, int type);
/** Retrieve the results of a preceding sd_resolve_res_query() or
* resolve_res_search call. The query object q is destroyed by this
typedef int (*sd_rtnl_message_handler_t)(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata);
/* bus */
-int sd_rtnl_open(uint32_t groups, sd_rtnl **nl);
+int sd_rtnl_open(sd_rtnl **nl, uint32_t groups);
sd_rtnl *sd_rtnl_ref(sd_rtnl *nl);
sd_rtnl *sd_rtnl_unref(sd_rtnl *nl);
int sd_rtnl_detach_event(sd_rtnl *nl);
/* messages */
-int sd_rtnl_message_new_link(sd_rtnl *rtnl, uint16_t msg_type, int index,
- sd_rtnl_message **ret);
-int sd_rtnl_message_new_addr(sd_rtnl *rtnl, uint16_t msg_type, int index,
- unsigned char family, sd_rtnl_message **ret);
-int sd_rtnl_message_new_route(sd_rtnl *rtnl, uint16_t nlmsg_type,
- unsigned char rtm_family, sd_rtnl_message **ret);
+int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t msg_type, int index);
+int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t msg_type, int index,
+ unsigned char family);
+int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t nlmsg_type,
+ unsigned char rtm_family);
sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m);
sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m);
if (r < 0)
return r;
- r = sd_rtnl_open(0, &ctx->rtnl);
+ r = sd_rtnl_open(&ctx->rtnl, 0);
if (r < 0)
return r;
strscpy(name, IFNAMSIZ, event->name);
- r = sd_rtnl_open(0, &rtnl);
+ r = sd_rtnl_open(&rtnl, 0);
if (r < 0)
return r;
~ianmdlvl / elogind.git / commitdiff