Replace ENOTSUP by EOPNOTSUPP as this is what linux actually uses.
48 files changed:
</varlistentry>
<varlistentry>
</varlistentry>
<varlistentry>
- <term><constant>-ENOTSUP</constant></term>
+ <term><constant>-EOPNOTSUPP</constant></term>
<listitem><para>The selected clock is not supported by the event loop implementation.</para></listitem>
<listitem><para>The selected clock is not supported by the event loop implementation.</para></listitem>
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_SELINUX_CONTEXT))
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_SELINUX_CONTEXT))
- return synthetic_reply_method_errno(m, -ENOTSUP, NULL);
+ return synthetic_reply_method_errno(m, -EOPNOTSUPP, NULL);
return synthetic_reply_method_return(m, "y", creds->label, strlen(creds->label));
return synthetic_reply_method_return(m, "y", creds->label, strlen(creds->label));
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_PID))
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_PID))
- return synthetic_reply_method_errno(m, -ENOTSUP, NULL);
+ return synthetic_reply_method_errno(m, -EOPNOTSUPP, NULL);
return synthetic_reply_method_return(m, "u", (uint32_t) creds->pid);
return synthetic_reply_method_return(m, "u", (uint32_t) creds->pid);
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_EUID))
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_EUID))
- return synthetic_reply_method_errno(m, -ENOTSUP, NULL);
+ return synthetic_reply_method_errno(m, -EOPNOTSUPP, NULL);
return synthetic_reply_method_return(m, "u", (uint32_t) creds->euid);
return synthetic_reply_method_return(m, "u", (uint32_t) creds->euid);
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_UNIQUE_NAME))
return synthetic_reply_method_errno(m, r, &error);
if (!(creds->mask & SD_BUS_CREDS_UNIQUE_NAME))
- return synthetic_reply_method_errno(m, -ENOTSUP, NULL);
+ return synthetic_reply_method_errno(m, -EOPNOTSUPP, NULL);
return synthetic_reply_method_return(m, "s", creds->unique_name);
return synthetic_reply_method_return(m, "s", creds->unique_name);
/* The higher 32bit of the bus_flags fields are considered
* 'incompatible flags'. Refuse them all for now. */
if (hello->bus_flags > 0xFFFFFFFFULL)
/* The higher 32bit of the bus_flags fields are considered
* 'incompatible flags'. Refuse them all for now. */
if (hello->bus_flags > 0xFFFFFFFFULL)
r = job_finish_and_invalidate(j, JOB_INVALID, true);
else if (r == -EPROTO)
r = job_finish_and_invalidate(j, JOB_ASSERT, true);
r = job_finish_and_invalidate(j, JOB_INVALID, true);
else if (r == -EPROTO)
r = job_finish_and_invalidate(j, JOB_ASSERT, true);
- else if (r == -ENOTSUP)
+ else if (r == -EOPNOTSUPP)
r = job_finish_and_invalidate(j, JOB_UNSUPPORTED, true);
else if (r == -EAGAIN)
job_set_state(j, JOB_WAITING);
r = job_finish_and_invalidate(j, JOB_UNSUPPORTED, true);
else if (r == -EAGAIN)
job_set_state(j, JOB_WAITING);
}
if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {
}
if (socket_address_family(&p->address) != AF_LOCAL && p->address.type == SOCK_SEQPACKET) {
- log_syntax(unit, LOG_ERR, filename, line, ENOTSUP,
+ log_syntax(unit, LOG_ERR, filename, line, EOPNOTSUPP,
"Address family not supported, ignoring: %s", rvalue);
return 0;
}
"Address family not supported, ignoring: %s", rvalue);
return 0;
}
assert(u);
if (!u->instance)
assert(u);
if (!u->instance)
n = unit_name_unescape(u->instance);
if (!n)
n = unit_name_unescape(u->instance);
if (!n)
else {
e = getenv("XDG_RUNTIME_DIR");
if (!e)
else {
e = getenv("XDG_RUNTIME_DIR");
if (!e)
c = unit_get_exec_context(u);
if (!c)
c = unit_get_exec_context(u);
if (!c)
if (u->manager->running_as == SYSTEMD_SYSTEM) {
if (u->manager->running_as == SYSTEMD_SYSTEM) {
c = unit_get_exec_context(u);
if (!c)
c = unit_get_exec_context(u);
if (!c)
if (u->manager->running_as == SYSTEMD_SYSTEM) {
if (u->manager->running_as == SYSTEMD_SYSTEM) {
if (!c->user || streq(c->user, "root") || streq(c->user, "0"))
n = strdup("/root");
else
if (!c->user || streq(c->user, "root") || streq(c->user, "0"))
n = strdup("/root");
else
c = unit_get_exec_context(u);
if (!c)
c = unit_get_exec_context(u);
if (!c)
if (u->manager->running_as == SYSTEMD_SYSTEM) {
if (u->manager->running_as == SYSTEMD_SYSTEM) {
if (!c->user || streq(c->user, "root") || streq(c->user, "0"))
n = strdup("/bin/sh");
else
if (!c->user || streq(c->user, "root") || streq(c->user, "0"))
n = strdup("/bin/sh");
else
}
if (UNIT_VTABLE(u)->supported && !UNIT_VTABLE(u)->supported(u->manager))
}
if (UNIT_VTABLE(u)->supported && !UNIT_VTABLE(u)->supported(u->manager))
/* If it is stopped, but we cannot start it, then fail */
if (!UNIT_VTABLE(u)->start)
/* If it is stopped, but we cannot start it, then fail */
if (!UNIT_VTABLE(u)->start)
assert(signo < _NSIG);
if (!UNIT_VTABLE(u)->kill)
assert(signo < _NSIG);
if (!UNIT_VTABLE(u)->kill)
return UNIT_VTABLE(u)->kill(u, w, signo, error);
}
return UNIT_VTABLE(u)->kill(u, w, signo, error);
}
uint64_t sz, csize_shift, csize_mask;
if (!compressed)
uint64_t sz, csize_shift, csize_mask;
if (!compressed)
csize_shift = 64 - 2 - (HEADER_CLUSTER_BITS(header) - 8);
csize_mask = (1ULL << (HEADER_CLUSTER_BITS(header) - 8)) - 1;
csize_shift = 64 - 2 - (HEADER_CLUSTER_BITS(header) - 8);
csize_mask = (1ULL << (HEADER_CLUSTER_BITS(header) - 8)) - 1;
if (HEADER_VERSION(header) != 2 &&
HEADER_VERSION(header) != 3)
if (HEADER_VERSION(header) != 2 &&
HEADER_VERSION(header) != 3)
if (HEADER_CRYPT_METHOD(header) != 0)
if (HEADER_CRYPT_METHOD(header) != 0)
if (HEADER_CLUSTER_BITS(header) < 9) /* 512K */
return -EBADMSG;
if (HEADER_CLUSTER_BITS(header) < 9) /* 512K */
return -EBADMSG;
if (HEADER_VERSION(header) == 3) {
if (header->incompatible_features != 0)
if (HEADER_VERSION(header) == 3) {
if (header->incompatible_features != 0)
if (HEADER_HEADER_LENGTH(header) < sizeof(Header))
return -EBADMSG;
if (HEADER_HEADER_LENGTH(header) < sizeof(Header))
return -EBADMSG;
info = MHD_get_daemon_info(d->daemon, MHD_DAEMON_INFO_EPOLL_FD_LINUX_ONLY);
if (!info) {
log_error("µhttp returned NULL daemon info");
info = MHD_get_daemon_info(d->daemon, MHD_DAEMON_INFO_EPOLL_FD_LINUX_ONLY);
if (!info) {
log_error("µhttp returned NULL daemon info");
}
#else
log_error("Cannot decompress file. Compiled without compression support.");
}
#else
log_error("Cannot decompress file. Compiled without compression support.");
goto error;
#endif
} else {
goto error;
#endif
} else {
if (f->fss_start_usec == 0 ||
f->fss_interval_usec == 0)
if (f->fss_start_usec == 0 ||
f->fss_interval_usec == 0)
if (realtime < f->fss_start_usec)
return -ESTALE;
if (realtime < f->fss_start_usec)
return -ESTALE;
e = gcry_md_open(&f->hmac, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
if (e != 0)
e = gcry_md_open(&f->hmac, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
if (e != 0)
#endif
} else if (f->seal)
return -ENOKEY;
#endif
} else if (f->seal)
return -ENOKEY;
if (le32toh(f->header->compatible_flags) & ~HEADER_COMPATIBLE_SUPPORTED) {
log_error("Cannot verify file with unknown extensions.");
if (le32toh(f->header->compatible_flags) & ~HEADER_COMPATIBLE_SUPPORTED) {
log_error("Cannot verify file with unknown extensions.");
case ARG_INTERVAL:
case ARG_FORCE:
log_error("Forward-secure sealing not available.");
case ARG_INTERVAL:
case ARG_FORCE:
log_error("Forward-secure sealing not available.");
return r;
#else
log_error("Forward-secure sealing not available.");
return r;
#else
log_error("Forward-secure sealing not available.");
SD_BUS_ERROR_MAP(BUS_ERROR_DEVICE_IS_TAKEN, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_DEVICE_NOT_TAKEN, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_OPERATION_IN_PROGRESS, EINPROGRESS),
SD_BUS_ERROR_MAP(BUS_ERROR_DEVICE_IS_TAKEN, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_DEVICE_NOT_TAKEN, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_OPERATION_IN_PROGRESS, EINPROGRESS),
- SD_BUS_ERROR_MAP(BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, ENOTSUP),
+ SD_BUS_ERROR_MAP(BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED, EALREADY),
SD_BUS_ERROR_MAP(BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED, EALREADY),
int r;
if (streq(name, "org.freedesktop.DBus"))
int r;
if (streq(name, "org.freedesktop.DBus"))
r = bus_kernel_parse_unique_name(name, &id);
if (r < 0)
r = bus_kernel_parse_unique_name(name, &id);
if (r < 0)
assert_return(bus, -EINVAL);
assert_return(name, -EINVAL);
assert_return(bus, -EINVAL);
assert_return(name, -EINVAL);
- assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -ENOTSUP);
+ assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -EOPNOTSUPP);
assert_return(mask == 0 || creds, -EINVAL);
assert_return(!bus_pid_changed(bus), -ECHILD);
assert_return(service_name_is_valid(name), -EINVAL);
assert_return(mask == 0 || creds, -EINVAL);
assert_return(!bus_pid_changed(bus), -ECHILD);
assert_return(service_name_is_valid(name), -EINVAL);
_public_ int sd_bus_get_owner_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
assert_return(bus, -EINVAL);
_public_ int sd_bus_get_owner_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
assert_return(bus, -EINVAL);
- assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -ENOTSUP);
+ assert_return((mask & ~SD_BUS_CREDS_AUGMENT) <= _SD_BUS_CREDS_ALL, -EOPNOTSUPP);
assert_return(ret, -EINVAL);
assert_return(!bus_pid_changed(bus), -ECHILD);
assert_return(ret, -EINVAL);
assert_return(!bus_pid_changed(bus), -ECHILD);
int r;
assert_return(pid >= 0, -EINVAL);
int r;
assert_return(pid >= 0, -EINVAL);
- assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
+ assert_return(mask <= _SD_BUS_CREDS_ALL, -EOPNOTSUPP);
assert_return(ret, -EINVAL);
if (pid == 0)
assert_return(ret, -EINVAL);
if (pid == 0)
if (missing & SD_BUS_CREDS_AUDIT_SESSION_ID) {
r = audit_session_from_pid(pid, &c->audit_session_id);
if (r < 0) {
if (missing & SD_BUS_CREDS_AUDIT_SESSION_ID) {
r = audit_session_from_pid(pid, &c->audit_session_id);
if (r < 0) {
- if (r != -ENOTSUP && r != -ENXIO && r != -ENOENT && r != -EPERM && r != -EACCES)
+ if (r != -EOPNOTSUPP && r != -ENXIO && r != -ENOENT && r != -EPERM && r != -EACCES)
return r;
} else
c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
return r;
} else
c->mask |= SD_BUS_CREDS_AUDIT_SESSION_ID;
if (missing & SD_BUS_CREDS_AUDIT_LOGIN_UID) {
r = audit_loginuid_from_pid(pid, &c->audit_login_uid);
if (r < 0) {
if (missing & SD_BUS_CREDS_AUDIT_LOGIN_UID) {
r = audit_loginuid_from_pid(pid, &c->audit_login_uid);
if (r < 0) {
- if (r != -ENOTSUP && r != -ENXIO && r != -ENOENT && r != -EPERM && r != -EACCES)
+ if (r != -EOPNOTSUPP && r != -ENXIO && r != -ENOENT && r != -EPERM && r != -EACCES)
return r;
} else
c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
return r;
} else
c->mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID;
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.NoReply", ETIMEDOUT),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.IOError", EIO),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.BadAddress", EADDRNOTAVAIL),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.NoReply", ETIMEDOUT),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.IOError", EIO),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.BadAddress", EADDRNOTAVAIL),
- SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.NotSupported", ENOTSUP),
+ SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.NotSupported", EOPNOTSUPP),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.LimitsExceeded", ENOBUFS),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.AccessDenied", EACCES),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.AuthFailed", EACCES),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.LimitsExceeded", ENOBUFS),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.AccessDenied", EACCES),
SD_BUS_ERROR_MAP("org.freedesktop.DBus.Error.AuthFailed", EACCES),
case ECONNRESET:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_DISCONNECTED, "Disconnected");
case ECONNRESET:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_DISCONNECTED, "Disconnected");
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NOT_SUPPORTED, "Not supported");
case EADDRNOTAVAIL:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NOT_SUPPORTED, "Not supported");
case EADDRNOTAVAIL:
/* The higher 32bit of the bus_flags fields are considered
* 'incompatible flags'. Refuse them all for now. */
if (hello->bus_flags > 0xFFFFFFFFULL) {
/* The higher 32bit of the bus_flags fields are considered
* 'incompatible flags'. Refuse them all for now. */
if (hello->bus_flags > 0xFFFFFFFFULL) {
}
if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
}
if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
assert(allocated);
if (!bus || !bus->is_kernel)
assert(allocated);
if (!bus || !bus->is_kernel)
assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
else {
/* 64bit cookies are not supported on dbus1 */
if (cookie > 0xffffffffUL)
else {
/* 64bit cookies are not supported on dbus1 */
if (cookie > 0xffffffffUL)
return message_append_field_uint32(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) cookie);
}
return message_append_field_uint32(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) cookie);
}
t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
t->reply_cookie = BUS_MESSAGE_COOKIE(call);
if (t->reply_cookie == 0)
t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
t->reply_cookie = BUS_MESSAGE_COOKIE(call);
if (t->reply_cookie == 0)
r = message_append_reply_cookie(t, t->reply_cookie);
if (r < 0)
r = message_append_reply_cookie(t, t->reply_cookie);
if (r < 0)
return -EINVAL;
if (!m->allow_fds)
return -EINVAL;
if (!m->allow_fds)
copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
if (copy < 0)
copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
if (copy < 0)
if (cookie > 0xffffffffULL &&
!BUS_MESSAGE_IS_GVARIANT(m))
if (cookie > 0xffffffffULL &&
!BUS_MESSAGE_IS_GVARIANT(m))
/* In vtables the return signature of method calls is listed,
* let's check if they match if this is a response */
/* In vtables the return signature of method calls is listed,
* let's check if they match if this is a response */
assert_return(bus_type_is_trivial(type), -EINVAL);
assert_return(ptr, -EINVAL);
assert_return(size, -EINVAL);
assert_return(bus_type_is_trivial(type), -EINVAL);
assert_return(ptr, -EINVAL);
assert_return(size, -EINVAL);
- assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -ENOTSUP);
+ assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -EOPNOTSUPP);
r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
if (r <= 0)
r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
if (r <= 0)
/* Fallback for dbus1 connections: we
* unregister the name and wait for the
* response to come through for it */
/* Fallback for dbus1 connections: we
* unregister the name and wait for the
* response to come through for it */
+ if (r == -EOPNOTSUPP) {
/* Inform the service manager that we
* are going down, so that it will
/* Inform the service manager that we
* are going down, so that it will
assert(bus);
assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
assert(bus);
assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
- assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -ENOTSUP);
+ assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
assert(bus);
assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
assert(bus);
assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
- assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -ENOTSUP);
+ assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
else if (streq(d->result, "assert"))
r = -EPROTO;
else if (streq(d->result, "unsupported"))
else if (streq(d->result, "assert"))
r = -EPROTO;
else if (streq(d->result, "unsupported"))
else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
r = -EIO;
else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
r = -EIO;
if (r < 0)
return r;
if (r == 0)
if (r < 0)
return r;
if (r == 0)
}
/* If the cookie number isn't kept, then we know that no reply
}
/* If the cookie number isn't kept, then we know that no reply
assert_return(!bus_pid_changed(bus), -ECHILD);
if (!bus->is_kernel)
assert_return(!bus_pid_changed(bus), -ECHILD);
if (!bus->is_kernel)
if (!BUS_IS_OPEN(bus->state))
return -ENOTCONN;
if (!BUS_IS_OPEN(bus->state))
return -ENOTCONN;
};
assert_se(!sd_bus_error_is_set(&error));
};
assert_se(!sd_bus_error_is_set(&error));
- assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -ENOTSUP);
+ assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -EOPNOTSUPP);
assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(streq(error.message, "xxx"));
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(streq(error.message, "xxx"));
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
- assert_se(sd_bus_error_get_errno(&error) == ENOTSUP);
+ assert_se(sd_bus_error_get_errno(&error) == EOPNOTSUPP);
assert_se(sd_bus_error_is_set(&error));
sd_bus_error_free(&error);
assert_se(sd_bus_error_is_set(&error));
sd_bus_error_free(&error);
callback = time_exit_callback;
type = clock_to_event_source_type(clock);
callback = time_exit_callback;
type = clock_to_event_source_type(clock);
- assert_return(type >= 0, -ENOTSUP);
+ assert_return(type >= 0, -EOPNOTSUPP);
d = event_get_clock_data(e, type);
assert(d);
d = event_get_clock_data(e, type);
assert(d);
return from_user_dir("XDG_DESKTOP_DIR", buffer, ret);
}
return from_user_dir("XDG_DESKTOP_DIR", buffer, ret);
}
}
_public_ int sd_path_home(uint64_t type, const char *suffix, char **path) {
}
_public_ int sd_path_home(uint64_t type, const char *suffix, char **path) {
}
_public_ int sd_path_search(uint64_t type, const char *suffix, char ***paths) {
}
_public_ int sd_path_search(uint64_t type, const char *suffix, char ***paths) {
}
int sd_rtnl_message_is_broadcast(sd_rtnl_message *m) {
}
int sd_rtnl_message_is_broadcast(sd_rtnl_message *m) {
/* check that we support this message type */
r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
if (r < 0) {
/* check that we support this message type */
r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
if (r < 0) {
log_debug("sd-rtnl: ignored message with unknown type: %i",
new_msg->nlmsg_type);
log_debug("sd-rtnl: ignored message with unknown type: %i",
new_msg->nlmsg_type);
assert(type_system->types);
if (type > type_system->max)
assert(type_system->types);
if (type > type_system->max)
nl_type = &type_system->types[type];
if (nl_type->type == NLA_UNSPEC)
nl_type = &type_system->types[type];
if (nl_type->type == NLA_UNSPEC)
type = type_system_union->lookup(key);
if (type < 0)
type = type_system_union->lookup(key);
if (type < 0)
assert(type < type_system_union->num);
assert(type < type_system_union->num);
assert(ret);
if (protocol >= type_system_union->num)
assert(ret);
if (protocol >= type_system_union->num)
type_system = &type_system_union->type_systems[protocol];
if (type_system->max == 0)
type_system = &type_system_union->type_systems[protocol];
if (type_system->max == 0)
assert_return(!rtnl_pid_changed(rtnl), -ECHILD);
assert_return(rtnl_message_type_is_link(type) ||
rtnl_message_type_is_addr(type) ||
assert_return(!rtnl_pid_changed(rtnl), -ECHILD);
assert_return(rtnl_message_type_is_link(type) ||
rtnl_message_type_is_addr(type) ||
- rtnl_message_type_is_route(type), -ENOTSUP);
+ rtnl_message_type_is_route(type), -EOPNOTSUPP);
c = new0(struct match_callback, 1);
if (!c)
c = new0(struct match_callback, 1);
if (!c)
if (!supported) {
log_warning("Requested operation not supported, ignoring.");
if (!supported) {
log_warning("Requested operation not supported, ignoring.");
assert(s->user);
if (!s->seat)
assert(s->user);
if (!s->seat)
if (s->seat->active == s)
return 0;
if (s->seat->active == s)
return 0;
/* on seats with VTs, we let VTs manage session-switching */
if (seat_has_vts(s->seat)) {
if (!s->vtnr)
/* on seats with VTs, we let VTs manage session-switching */
if (seat_has_vts(s->seat)) {
if (!s->vtnr)
if (arg_transport != BUS_TRANSPORT_LOCAL &&
arg_transport != BUS_TRANSPORT_MACHINE) {
log_error("Login only supported on local machines.");
if (arg_transport != BUS_TRANSPORT_LOCAL &&
arg_transport != BUS_TRANSPORT_MACHINE) {
log_error("Login only supported on local machines.");
}
polkit_agent_open_if_enabled();
}
polkit_agent_open_if_enabled();
finish:
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
finish:
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
return 0;
#else
log_error("--image= is not supported, compiled without blkid support.");
return 0;
#else
log_error("--image= is not supported, compiled without blkid support.");
if (streq(fstype, "crypto_LUKS")) {
log_error("nspawn currently does not support LUKS disk images.");
if (streq(fstype, "crypto_LUKS")) {
log_error("nspawn currently does not support LUKS disk images.");
}
if (mount(what, p, fstype, MS_NODEV|(rw ? 0 : MS_RDONLY), NULL) < 0)
}
if (mount(what, p, fstype, MS_NODEV|(rw ? 0 : MS_RDONLY), NULL) < 0)
return 0;
#else
log_error("--image= is not supported, compiled without blkid support.");
return 0;
#else
log_error("--image= is not supported, compiled without blkid support.");
}
log_error("Path %s not known.", n);
}
log_error("Path %s not known.", n);
}
static void help(void) {
}
static void help(void) {
DnsServer *srv;
if (DNS_PACKET_QDCOUNT(p) > 1)
DnsServer *srv;
if (DNS_PACKET_QDCOUNT(p) > 1)
srv = dns_scope_get_dns_server(s);
if (!srv)
srv = dns_scope_get_dns_server(s);
if (!srv)
} else if (s->protocol == DNS_PROTOCOL_LLMNR) {
if (DNS_PACKET_QDCOUNT(p) > 1)
} else if (s->protocol == DNS_PROTOCOL_LLMNR) {
if (DNS_PACKET_QDCOUNT(p) > 1)
if (!ratelimit_test(&s->ratelimit))
return -EBUSY;
if (!ratelimit_test(&s->ratelimit))
return -EBUSY;
else if (S_ISBLK(buf.st_mode) || S_ISCHR(buf.st_mode))
q = fd_copy_node(dirfd(d), de->d_name, &buf, fdt, de->d_name);
else
else if (S_ISBLK(buf.st_mode) || S_ISCHR(buf.st_mode))
q = fd_copy_node(dirfd(d), de->d_name, &buf, fdt, de->d_name);
else
if (q == -EEXIST && merge)
q = 0;
if (q == -EEXIST && merge)
q = 0;
else if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode))
return fd_copy_node(fdf, from, &st, fdt, to);
else
else if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode))
return fd_copy_node(fdf, from, &st, fdt, to);
else
}
int copy_tree(const char *from, const char *to, bool merge) {
}
int copy_tree(const char *from, const char *to, bool merge) {
int r;
if (af != AF_INET)
int r;
if (af != AF_INET)
if (protocol != 0 && protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)
if (protocol != 0 && protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)
h = iptc_init("nat");
if (!h)
h = iptc_init("nat");
if (!h)
assert(add || !previous_remote);
if (af != AF_INET)
assert(add || !previous_remote);
if (af != AF_INET)
if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)
if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)
if (local_port <= 0)
return -EINVAL;
if (local_port <= 0)
return -EINVAL;
const char *out_interface,
const union in_addr_union *destination,
unsigned destination_prefixlen) {
const char *out_interface,
const union in_addr_union *destination,
unsigned destination_prefixlen) {
}
static inline int fw_add_local_dnat(
}
static inline int fw_add_local_dnat(
const union in_addr_union *remote,
uint16_t remote_port,
const union in_addr_union *previous_remote) {
const union in_addr_union *remote,
uint16_t remote_port,
const union in_addr_union *previous_remote) {
if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
log_error("Failed to enable unit: Unit %s is masked", *i);
if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
log_error("Failed to enable unit: Unit %s is masked", *i);
}
r = install_info_add_auto(&c, *i);
}
r = install_info_add_auto(&c, *i);
state = unit_file_get_state(scope, root_dir, *i);
if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
log_error("Failed to enable unit: Unit %s is masked", *i);
state = unit_file_get_state(scope, root_dir, *i);
if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
log_error("Failed to enable unit: Unit %s is masked", *i);
}
r = install_info_add_auto(&c, *i);
}
r = install_info_add_auto(&c, *i);
return rm_rf_dangerous(i->path, false, true, false);
default:
return rm_rf_dangerous(i->path, false, true, false);
default:
return -EROFS;
if (i->type != IMAGE_SUBVOLUME)
return -EROFS;
if (i->type != IMAGE_SUBVOLUME)
return btrfs_quota_limit(i->path, referenced_max);
}
return btrfs_quota_limit(i->path, referenced_max);
}
r = lsetfilecon(path, fcon);
/* If the FS doesn't support labels, then exit without warning */
r = lsetfilecon(path, fcon);
/* If the FS doesn't support labels, then exit without warning */
- if (r < 0 && errno == ENOTSUP)
+ if (r < 0 && errno == EOPNOTSUPP)
r = lsetxattr(path, "security.SMACK64", label, strlen(label), 0);
/* If the FS doesn't support labels, then exit without warning */
r = lsetxattr(path, "security.SMACK64", label, strlen(label), 0);
/* If the FS doesn't support labels, then exit without warning */
- if (r < 0 && errno == ENOTSUP)
+ if (r < 0 && errno == EOPNOTSUPP)
if (isempty(s)) {
free(s);
if (isempty(s)) {
free(s);
_cleanup_free_ UnitInfo *unit_infos = NULL;
if (!bus)
_cleanup_free_ UnitInfo *unit_infos = NULL;
if (!bus)
- return log_error_errno(ENOTSUP, "Unit name globbing without bus is not implemented.");
+ return log_error_errno(EOPNOTSUPP, "Unit name globbing without bus is not implemented.");
r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);
if (r < 0)
r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);
if (r < 0)
a == ACTION_HIBERNATE ||
a == ACTION_HYBRID_SLEEP)) {
r = reboot_with_logind(bus, a);
a == ACTION_HIBERNATE ||
a == ACTION_HYBRID_SLEEP)) {
r = reboot_with_logind(bus, a);
- if (r >= 0 || IN_SET(r, -ENOTSUP, -EINPROGRESS))
+ if (r >= 0 || IN_SET(r, -EOPNOTSUPP, -EINPROGRESS))
#define NULL_ADJTIME_LOCAL "0.0 0 0\n0\nLOCAL\n"
static BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map timedated_errors[] = {
#define NULL_ADJTIME_LOCAL "0.0 0 0\n0\nLOCAL\n"
static BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map timedated_errors[] = {
- SD_BUS_ERROR_MAP("org.freedesktop.timedate1.NoNTPSupport", ENOTSUP),
+ SD_BUS_ERROR_MAP("org.freedesktop.timedate1.NoNTPSupport", EOPNOTSUPP),
if (r > 0)
return -r; /* already warned */
if (r > 0)
return -r; /* already warned */
- else if (r == -ENOTSUP) {
+ else if (r == -EOPNOTSUPP) {
log_debug_errno(r, "ACLs not supported by file system at %s", path);
return 0;
} else if (r < 0)
log_debug_errno(r, "ACLs not supported by file system at %s", path);
return 0;
} else if (r < 0)