mirror of
https://github.com/systemd/systemd.git
synced 2025-03-31 14:50:15 +03:00
Merge pull request #2357 from keszybz/warnings-2
Remove gcc warnings v2
This commit is contained in:
commit
5f0f8d749d
@ -114,13 +114,19 @@
|
||||
|
||||
</varlistentry>
|
||||
|
||||
<varlistentry>
|
||||
<term><constant>-EOPNOTSUPP</constant></term>
|
||||
|
||||
<listitem><para>Unsupported clock type.
|
||||
</para></listitem>
|
||||
</varlistentry>
|
||||
|
||||
<varlistentry>
|
||||
<term><constant>-ECHILD</constant></term>
|
||||
|
||||
<listitem><para>The event loop object was created in a
|
||||
different process.</para></listitem>
|
||||
</varlistentry>
|
||||
|
||||
</variablelist>
|
||||
</refsect1>
|
||||
|
||||
|
@ -323,7 +323,7 @@ int main(int argc, char *argv[]) {
|
||||
errno = 0;
|
||||
device = udev_device_new_from_subsystem_sysname(udev, ss, sysname);
|
||||
if (!device) {
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
log_error_errno(errno, "Failed to get backlight or LED device '%s:%s': %m", ss, sysname);
|
||||
else
|
||||
log_oom();
|
||||
|
@ -2051,7 +2051,7 @@ int btrfs_subvol_get_parent(int fd, uint64_t subvol_id, uint64_t *ret) {
|
||||
|
||||
args.key.nr_items = 256;
|
||||
if (ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args) < 0)
|
||||
return -errno;
|
||||
return negative_errno();
|
||||
|
||||
if (args.key.nr_items <= 0)
|
||||
break;
|
||||
|
@ -93,7 +93,7 @@ int cg_read_pid(FILE *f, pid_t *_pid) {
|
||||
if (feof(f))
|
||||
return 0;
|
||||
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
}
|
||||
|
||||
if (ul <= 0)
|
||||
@ -648,7 +648,7 @@ int cg_trim(const char *controller, const char *path, bool delete_root) {
|
||||
if (nftw(fs, trim_cb, 64, FTW_DEPTH|FTW_MOUNT|FTW_PHYS) != 0) {
|
||||
if (errno == ENOENT)
|
||||
r = 0;
|
||||
else if (errno != 0)
|
||||
else if (errno > 0)
|
||||
r = -errno;
|
||||
else
|
||||
r = -EIO;
|
||||
@ -2091,7 +2091,7 @@ int cg_kernel_controllers(Set *controllers) {
|
||||
if (feof(f))
|
||||
break;
|
||||
|
||||
if (ferror(f) && errno != 0)
|
||||
if (ferror(f) && errno > 0)
|
||||
return -errno;
|
||||
|
||||
return -EBADMSG;
|
||||
|
@ -33,6 +33,7 @@
|
||||
#include "fd-util.h"
|
||||
#include "macro.h"
|
||||
#include "string-util.h"
|
||||
#include "util.h"
|
||||
|
||||
int clock_get_hwclock(struct tm *tm) {
|
||||
_cleanup_close_ int fd = -1;
|
||||
@ -121,7 +122,8 @@ int clock_set_timezone(int *min) {
|
||||
* have read from the RTC.
|
||||
*/
|
||||
if (settimeofday(tv_null, &tz) < 0)
|
||||
return -errno;
|
||||
return negative_errno();
|
||||
|
||||
if (min)
|
||||
*min = minutesdelta;
|
||||
return 0;
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "macro.h"
|
||||
|
||||
static const struct errno_name* lookup_errno(register const char *str,
|
||||
register unsigned int len);
|
||||
register unsigned int len);
|
||||
|
||||
#include "errno-from-name.h"
|
||||
#include "errno-to-name.h"
|
||||
@ -48,8 +48,9 @@ int errno_from_name(const char *name) {
|
||||
|
||||
sc = lookup_errno(name, strlen(name));
|
||||
if (!sc)
|
||||
return 0;
|
||||
return -EINVAL;
|
||||
|
||||
assert(sc->id > 0);
|
||||
return sc->id;
|
||||
}
|
||||
|
||||
|
@ -119,16 +119,18 @@ char *cescape(const char *s) {
|
||||
return cescape_length(s, strlen(s));
|
||||
}
|
||||
|
||||
int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode) {
|
||||
int cunescape_one(const char *p, size_t length, uint32_t *ret, bool *eight_bit) {
|
||||
int r = 1;
|
||||
|
||||
assert(p);
|
||||
assert(*p);
|
||||
assert(ret);
|
||||
|
||||
/* Unescapes C style. Returns the unescaped character in ret,
|
||||
* unless we encountered a \u sequence in which case the full
|
||||
* unicode character is returned in ret_unicode, instead. */
|
||||
/* Unescapes C style. Returns the unescaped character in ret.
|
||||
* Sets *eight_bit to true if the escaped sequence either fits in
|
||||
* one byte in UTF-8 or is a non-unicode literal byte and should
|
||||
* instead be copied directly.
|
||||
*/
|
||||
|
||||
if (length != (size_t) -1 && length < 1)
|
||||
return -EINVAL;
|
||||
@ -190,7 +192,8 @@ int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode
|
||||
if (a == 0 && b == 0)
|
||||
return -EINVAL;
|
||||
|
||||
*ret = (char) ((a << 4U) | b);
|
||||
*ret = (a << 4U) | b;
|
||||
*eight_bit = true;
|
||||
r = 3;
|
||||
break;
|
||||
}
|
||||
@ -217,16 +220,7 @@ int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode
|
||||
if (c == 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (c < 128)
|
||||
*ret = c;
|
||||
else {
|
||||
if (!ret_unicode)
|
||||
return -EINVAL;
|
||||
|
||||
*ret = 0;
|
||||
*ret_unicode = c;
|
||||
}
|
||||
|
||||
*ret = c;
|
||||
r = 5;
|
||||
break;
|
||||
}
|
||||
@ -258,16 +252,7 @@ int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode
|
||||
if (!unichar_is_valid(c))
|
||||
return -EINVAL;
|
||||
|
||||
if (c < 128)
|
||||
*ret = c;
|
||||
else {
|
||||
if (!ret_unicode)
|
||||
return -EINVAL;
|
||||
|
||||
*ret = 0;
|
||||
*ret_unicode = c;
|
||||
}
|
||||
|
||||
*ret = c;
|
||||
r = 9;
|
||||
break;
|
||||
}
|
||||
@ -309,6 +294,7 @@ int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode
|
||||
return -EINVAL;
|
||||
|
||||
*ret = m;
|
||||
*eight_bit = true;
|
||||
r = 3;
|
||||
break;
|
||||
}
|
||||
@ -342,7 +328,7 @@ int cunescape_length_with_prefix(const char *s, size_t length, const char *prefi
|
||||
for (f = s, t = r + pl; f < s + length; f++) {
|
||||
size_t remaining;
|
||||
uint32_t u;
|
||||
char c;
|
||||
bool eight_bit = false;
|
||||
int k;
|
||||
|
||||
remaining = s + length - f;
|
||||
@ -365,7 +351,7 @@ int cunescape_length_with_prefix(const char *s, size_t length, const char *prefi
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
k = cunescape_one(f + 1, remaining - 1, &c, &u);
|
||||
k = cunescape_one(f + 1, remaining - 1, &u, &eight_bit);
|
||||
if (k < 0) {
|
||||
if (flags & UNESCAPE_RELAX) {
|
||||
/* Invalid escape code, let's take it literal then */
|
||||
@ -377,14 +363,13 @@ int cunescape_length_with_prefix(const char *s, size_t length, const char *prefi
|
||||
return k;
|
||||
}
|
||||
|
||||
if (c != 0)
|
||||
/* Non-Unicode? Let's encode this directly */
|
||||
*(t++) = c;
|
||||
else
|
||||
/* Unicode? Then let's encode this in UTF-8 */
|
||||
t += utf8_encode_unichar(t, u);
|
||||
|
||||
f += k;
|
||||
if (eight_bit)
|
||||
/* One byte? Set directly as specified */
|
||||
*(t++) = u;
|
||||
else
|
||||
/* Otherwise encode as multi-byte UTF-8 */
|
||||
t += utf8_encode_unichar(t, u);
|
||||
}
|
||||
|
||||
*t = 0;
|
||||
|
@ -45,7 +45,7 @@ size_t cescape_char(char c, char *buf);
|
||||
int cunescape(const char *s, UnescapeFlags flags, char **ret);
|
||||
int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret);
|
||||
int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret);
|
||||
int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode);
|
||||
int cunescape_one(const char *p, size_t length, uint32_t *ret, bool *eight_bit);
|
||||
|
||||
char *xescape(const char *s, const char *bad);
|
||||
|
||||
|
@ -108,8 +108,9 @@ int extract_first_word(const char **p, char **ret, const char *separators, Extra
|
||||
|
||||
if (flags & EXTRACT_CUNESCAPE) {
|
||||
uint32_t u;
|
||||
bool eight_bit = false;
|
||||
|
||||
r = cunescape_one(*p, (size_t) -1, &c, &u);
|
||||
r = cunescape_one(*p, (size_t) -1, &u, &eight_bit);
|
||||
if (r < 0) {
|
||||
if (flags & EXTRACT_CUNESCAPE_RELAX) {
|
||||
s[sz++] = '\\';
|
||||
@ -119,10 +120,10 @@ int extract_first_word(const char **p, char **ret, const char *separators, Extra
|
||||
} else {
|
||||
(*p) += r - 1;
|
||||
|
||||
if (c != 0)
|
||||
s[sz++] = c; /* normal explicit char */
|
||||
if (eight_bit)
|
||||
s[sz++] = u;
|
||||
else
|
||||
sz += utf8_encode_unichar(s + sz, u); /* unicode chars we'll encode as utf8 */
|
||||
sz += utf8_encode_unichar(s + sz, u);
|
||||
}
|
||||
} else
|
||||
s[sz++] = c;
|
||||
|
@ -165,7 +165,7 @@ int read_one_line_file(const char *fn, char **line) {
|
||||
if (!fgets(t, sizeof(t), f)) {
|
||||
|
||||
if (ferror(f))
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
t[0] = 0;
|
||||
}
|
||||
@ -1064,7 +1064,7 @@ int fflush_and_check(FILE *f) {
|
||||
fflush(f);
|
||||
|
||||
if (ferror(f))
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -481,7 +481,7 @@ int get_files_in_directory(const char *path, char ***list) {
|
||||
|
||||
errno = 0;
|
||||
de = readdir(d);
|
||||
if (!de && errno != 0)
|
||||
if (!de && errno > 0)
|
||||
return -errno;
|
||||
if (!de)
|
||||
break;
|
||||
|
@ -40,7 +40,7 @@ int glob_exists(const char *path) {
|
||||
if (k == GLOB_NOSPACE)
|
||||
return -ENOMEM;
|
||||
if (k != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return !strv_isempty(g.gl_pathv);
|
||||
}
|
||||
@ -58,7 +58,7 @@ int glob_extend(char ***strv, const char *path) {
|
||||
if (k == GLOB_NOSPACE)
|
||||
return -ENOMEM;
|
||||
if (k != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
if (strv_isempty(g.gl_pathv))
|
||||
return -ENOENT;
|
||||
|
||||
|
@ -219,7 +219,7 @@ int in_addr_to_string(int family, const union in_addr_union *u, char **ret) {
|
||||
errno = 0;
|
||||
if (!inet_ntop(family, u, x, l)) {
|
||||
free(x);
|
||||
return errno ? -errno : -EINVAL;
|
||||
return errno > 0 ? -errno : -EINVAL;
|
||||
}
|
||||
|
||||
*ret = x;
|
||||
@ -236,7 +236,7 @@ int in_addr_from_string(int family, const char *s, union in_addr_union *ret) {
|
||||
|
||||
errno = 0;
|
||||
if (inet_pton(family, s, ret) <= 0)
|
||||
return errno ? -errno : -EINVAL;
|
||||
return errno > 0 ? -errno : -EINVAL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -81,7 +81,7 @@ int parse_mode(const char *s, mode_t *ret) {
|
||||
|
||||
errno = 0;
|
||||
l = strtol(s, &x, 8);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -176,7 +176,7 @@ int parse_size(const char *t, uint64_t base, uint64_t *size) {
|
||||
|
||||
errno = 0;
|
||||
l = strtoull(p, &e, 10);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (e == p)
|
||||
return -EINVAL;
|
||||
@ -192,7 +192,7 @@ int parse_size(const char *t, uint64_t base, uint64_t *size) {
|
||||
char *e2;
|
||||
|
||||
l2 = strtoull(e, &e2, 10);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
|
||||
/* Ignore failure. E.g. 10.M is valid */
|
||||
@ -330,7 +330,7 @@ int safe_atou(const char *s, unsigned *ret_u) {
|
||||
|
||||
errno = 0;
|
||||
l = strtoul(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -352,7 +352,7 @@ int safe_atoi(const char *s, int *ret_i) {
|
||||
|
||||
errno = 0;
|
||||
l = strtol(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -374,7 +374,7 @@ int safe_atollu(const char *s, long long unsigned *ret_llu) {
|
||||
|
||||
errno = 0;
|
||||
l = strtoull(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -394,7 +394,7 @@ int safe_atolli(const char *s, long long int *ret_lli) {
|
||||
|
||||
errno = 0;
|
||||
l = strtoll(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -414,7 +414,7 @@ int safe_atou8(const char *s, uint8_t *ret) {
|
||||
|
||||
errno = 0;
|
||||
l = strtoul(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -438,7 +438,7 @@ int safe_atou16(const char *s, uint16_t *ret) {
|
||||
|
||||
errno = 0;
|
||||
l = strtoul(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -460,7 +460,7 @@ int safe_atoi16(const char *s, int16_t *ret) {
|
||||
|
||||
errno = 0;
|
||||
l = strtol(s, &x, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
if (!x || x == s || *x)
|
||||
return -EINVAL;
|
||||
@ -485,7 +485,7 @@ int safe_atod(const char *s, double *ret_d) {
|
||||
|
||||
errno = 0;
|
||||
d = strtod_l(s, &x, loc);
|
||||
if (errno != 0) {
|
||||
if (errno > 0) {
|
||||
freelocale(loc);
|
||||
return -errno;
|
||||
}
|
||||
|
@ -102,7 +102,7 @@ int path_make_absolute_cwd(const char *p, char **ret) {
|
||||
|
||||
cwd = get_current_dir_name();
|
||||
if (!cwd)
|
||||
return -errno;
|
||||
return negative_errno();
|
||||
|
||||
c = strjoin(cwd, "/", p, NULL);
|
||||
}
|
||||
|
@ -82,7 +82,7 @@ int rm_rf_children(int fd, RemoveFlags flags, struct stat *root_dev) {
|
||||
errno = 0;
|
||||
de = readdir(d);
|
||||
if (!de) {
|
||||
if (errno != 0 && ret == 0)
|
||||
if (errno > 0 && ret == 0)
|
||||
ret = -errno;
|
||||
return ret;
|
||||
}
|
||||
|
@ -128,7 +128,7 @@ int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
|
||||
|
||||
errno = 0;
|
||||
if (!fgets(line, sizeof(line), f))
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
truncate_nl(line);
|
||||
|
||||
@ -212,7 +212,7 @@ int ask_string(char **ret, const char *text, ...) {
|
||||
|
||||
errno = 0;
|
||||
if (!fgets(line, sizeof(line), stdin))
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
if (!endswith(line, "\n"))
|
||||
putchar('\n');
|
||||
|
@ -68,7 +68,7 @@ int parse_uid(const char *s, uid_t *ret) {
|
||||
if (!uid_is_valid(uid))
|
||||
return -ENXIO; /* we return ENXIO instead of EINVAL
|
||||
* here, to make it easy to distuingish
|
||||
* invalid numeric uids invalid
|
||||
* invalid numeric uids from invalid
|
||||
* strings. */
|
||||
|
||||
if (ret)
|
||||
|
@ -513,7 +513,7 @@ int on_ac_power(void) {
|
||||
|
||||
errno = 0;
|
||||
de = readdir(d);
|
||||
if (!de && errno != 0)
|
||||
if (!de && errno > 0)
|
||||
return -errno;
|
||||
|
||||
if (!de)
|
||||
|
@ -141,7 +141,7 @@ static int property_get_nice(
|
||||
else {
|
||||
errno = 0;
|
||||
n = getpriority(PRIO_PROCESS, 0);
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
n = 0;
|
||||
}
|
||||
|
||||
@ -1382,7 +1382,7 @@ int bus_exec_context_set_transient_property(
|
||||
dirs = &c->read_write_dirs;
|
||||
else if (streq(name, "ReadOnlyDirectories"))
|
||||
dirs = &c->read_only_dirs;
|
||||
else if (streq(name, "InaccessibleDirectories"))
|
||||
else /* "InaccessibleDirectories" */
|
||||
dirs = &c->inaccessible_dirs;
|
||||
|
||||
if (strv_length(l) == 0) {
|
||||
|
@ -2319,7 +2319,7 @@ int exec_context_load_environment(Unit *unit, const ExecContext *c, char ***l) {
|
||||
continue;
|
||||
|
||||
strv_free(r);
|
||||
return errno ? -errno : -EINVAL;
|
||||
return errno > 0 ? -errno : -EINVAL;
|
||||
}
|
||||
count = pglob.gl_pathc;
|
||||
if (count == 0) {
|
||||
@ -2683,7 +2683,7 @@ void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) {
|
||||
fputc('\n', f);
|
||||
}
|
||||
|
||||
if (c->syscall_errno != 0)
|
||||
if (c->syscall_errno > 0)
|
||||
fprintf(f,
|
||||
"%sSystemCallErrorNumber: %s\n",
|
||||
prefix, strna(errno_to_name(c->syscall_errno)));
|
||||
|
@ -233,7 +233,7 @@ static int have_ask_password(void) {
|
||||
|
||||
errno = 0;
|
||||
de = readdir(dir);
|
||||
if (!de && errno != 0)
|
||||
if (!de && errno > 0)
|
||||
return -errno;
|
||||
if (!de)
|
||||
return false;
|
||||
|
@ -502,7 +502,7 @@ static int write_root_shadow(const char *path, const struct spwd *p) {
|
||||
|
||||
errno = 0;
|
||||
if (putspent(p, f) != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return fflush_and_check(f);
|
||||
}
|
||||
|
@ -112,7 +112,7 @@ static int verify_tty(const char *name) {
|
||||
|
||||
errno = 0;
|
||||
if (isatty(fd) <= 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -69,7 +69,7 @@ int aufs_resolve(const char *path) {
|
||||
errno = 0;
|
||||
r = nftw(path, nftw_cb, 64, FTW_MOUNT|FTW_PHYS|FTW_ACTIONRETVAL);
|
||||
if (r == FTW_STOP)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -700,7 +700,7 @@ static int request_handler_file(
|
||||
if (fstat(fd, &st) < 0)
|
||||
return mhd_respondf(connection, MHD_HTTP_INTERNAL_SERVER_ERROR, "Failed to stat file: %m\n");
|
||||
|
||||
response = MHD_create_response_from_fd_at_offset(st.st_size, fd, 0);
|
||||
response = MHD_create_response_from_fd_at_offset64(st.st_size, fd, MHD_VERSION);
|
||||
if (!response)
|
||||
return respond_oom(connection);
|
||||
|
||||
@ -840,7 +840,7 @@ static int request_handler(
|
||||
assert(method);
|
||||
|
||||
if (!streq(method, "GET"))
|
||||
return mhd_respond(connection, MHD_HTTP_METHOD_NOT_ACCEPTABLE,
|
||||
return mhd_respond(connection, MHD_HTTP_NOT_ACCEPTABLE,
|
||||
"Unsupported method.\n");
|
||||
|
||||
|
||||
|
@ -587,7 +587,7 @@ static int request_handler(
|
||||
*connection_cls);
|
||||
|
||||
if (!streq(method, "POST"))
|
||||
return mhd_respond(connection, MHD_HTTP_METHOD_NOT_ACCEPTABLE,
|
||||
return mhd_respond(connection, MHD_HTTP_NOT_ACCEPTABLE,
|
||||
"Unsupported method.\n");
|
||||
|
||||
if (!streq(url, "/upload"))
|
||||
|
@ -26,6 +26,15 @@
|
||||
|
||||
#include "macro.h"
|
||||
|
||||
/* Compatiblity with libmicrohttpd < 0.9.38 */
|
||||
#ifndef MHD_HTTP_NOT_ACCEPTABLE
|
||||
#define MHD_HTTP_NOT_ACCEPTABLE MHD_HTTP_METHOD_NOT_ACCEPTABLE
|
||||
#endif
|
||||
|
||||
#if MHD_VERSION < 0x00094203
|
||||
#define MHD_create_response_from_fd_at_offset64 MHD_create_response_from_fd_at_offset
|
||||
#endif
|
||||
|
||||
void microhttpd_logger(void *arg, const char *fmt, va_list ap) _printf_(2, 0);
|
||||
|
||||
/* respond_oom() must be usable with return, hence this form. */
|
||||
|
@ -527,7 +527,7 @@ static int compose_open_fds(pid_t pid, char **open_fds) {
|
||||
errno = 0;
|
||||
stream = safe_fclose(stream);
|
||||
|
||||
if (errno != 0)
|
||||
if (errno > 0)
|
||||
return -errno;
|
||||
|
||||
*open_fds = buffer;
|
||||
|
@ -1330,7 +1330,7 @@ static int server_parse_proc_cmdline(Server *s) {
|
||||
|
||||
p = line;
|
||||
for(;;) {
|
||||
_cleanup_free_ char *word;
|
||||
_cleanup_free_ char *word = NULL;
|
||||
|
||||
r = extract_first_word(&p, &word, NULL, 0);
|
||||
if (r < 0)
|
||||
|
@ -1,3 +1,5 @@
|
||||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
||||
|
||||
/***
|
||||
This file is part of systemd.
|
||||
|
||||
@ -112,7 +114,7 @@ static NDiscPrefix *ndisc_prefix_unref(NDiscPrefix *prefix) {
|
||||
}
|
||||
|
||||
static int ndisc_prefix_new(sd_ndisc *nd, NDiscPrefix **ret) {
|
||||
_cleanup_free_ NDiscPrefix *prefix = NULL;
|
||||
NDiscPrefix *prefix;
|
||||
|
||||
assert(ret);
|
||||
|
||||
@ -125,8 +127,6 @@ static int ndisc_prefix_new(sd_ndisc *nd, NDiscPrefix **ret) {
|
||||
prefix->nd = nd;
|
||||
|
||||
*ret = prefix;
|
||||
prefix = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -314,7 +314,6 @@ static int ndisc_prefix_match(sd_ndisc *nd, const struct in6_addr *addr,
|
||||
LIST_FOREACH_SAFE(prefixes, prefix, p, nd->prefixes) {
|
||||
if (prefix->valid_until < time_now) {
|
||||
prefix = ndisc_prefix_unref(prefix);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -355,14 +354,13 @@ static int ndisc_prefix_update(sd_ndisc *nd, ssize_t len,
|
||||
|
||||
r = ndisc_prefix_match(nd, &prefix_opt->nd_opt_pi_prefix,
|
||||
prefix_opt->nd_opt_pi_prefix_len, &prefix);
|
||||
if (r < 0) {
|
||||
if (r != -EADDRNOTAVAIL)
|
||||
return r;
|
||||
|
||||
if (r < 0 && r != -EADDRNOTAVAIL)
|
||||
return r;
|
||||
/* if router advertisment prefix valid timeout is zero, the timeout
|
||||
callback will be called immediately to clean up the prefix */
|
||||
|
||||
/* if router advertisment prefix valid timeout is zero, the timeout
|
||||
callback will be called immediately to clean up the prefix */
|
||||
|
||||
if (r == -EADDRNOTAVAIL) {
|
||||
r = ndisc_prefix_new(nd, &prefix);
|
||||
if (r < 0)
|
||||
return r;
|
||||
@ -373,9 +371,9 @@ static int ndisc_prefix_update(sd_ndisc *nd, ssize_t len,
|
||||
sizeof(prefix->addr));
|
||||
|
||||
log_ndisc(nd, "New prefix "SD_NDISC_ADDRESS_FORMAT_STR"/%d lifetime %d expires in %s",
|
||||
SD_NDISC_ADDRESS_FORMAT_VAL(prefix->addr),
|
||||
prefix->len, lifetime_valid,
|
||||
format_timespan(time_string, FORMAT_TIMESPAN_MAX, lifetime_valid * USEC_PER_SEC, USEC_PER_SEC));
|
||||
SD_NDISC_ADDRESS_FORMAT_VAL(prefix->addr),
|
||||
prefix->len, lifetime_valid,
|
||||
format_timespan(time_string, FORMAT_TIMESPAN_MAX, lifetime_valid * USEC_PER_SEC, USEC_PER_SEC));
|
||||
|
||||
LIST_PREPEND(prefixes, nd->prefixes, prefix);
|
||||
|
||||
@ -386,17 +384,17 @@ static int ndisc_prefix_update(sd_ndisc *nd, ssize_t len,
|
||||
prefixlen = MIN(prefix->len, prefix_opt->nd_opt_pi_prefix_len);
|
||||
|
||||
log_ndisc(nd, "Prefix length mismatch %d/%d using %d",
|
||||
prefix->len,
|
||||
prefix_opt->nd_opt_pi_prefix_len,
|
||||
prefixlen);
|
||||
prefix->len,
|
||||
prefix_opt->nd_opt_pi_prefix_len,
|
||||
prefixlen);
|
||||
|
||||
prefix->len = prefixlen;
|
||||
}
|
||||
|
||||
log_ndisc(nd, "Update prefix "SD_NDISC_ADDRESS_FORMAT_STR"/%d lifetime %d expires in %s",
|
||||
SD_NDISC_ADDRESS_FORMAT_VAL(prefix->addr),
|
||||
prefix->len, lifetime_valid,
|
||||
format_timespan(time_string, FORMAT_TIMESPAN_MAX, lifetime_valid * USEC_PER_SEC, USEC_PER_SEC));
|
||||
SD_NDISC_ADDRESS_FORMAT_VAL(prefix->addr),
|
||||
prefix->len, lifetime_valid,
|
||||
format_timespan(time_string, FORMAT_TIMESPAN_MAX, lifetime_valid * USEC_PER_SEC, USEC_PER_SEC));
|
||||
}
|
||||
|
||||
r = sd_event_now(nd->event, clock_boottime_or_monotonic(), &time_now);
|
||||
@ -450,7 +448,7 @@ static int ndisc_ra_parse(sd_ndisc *nd, struct nd_router_advert *ra, ssize_t len
|
||||
nd->mtu = MAX(mtu, IP6_MIN_MTU);
|
||||
|
||||
log_ndisc(nd, "Router Advertisement link MTU %d using %d",
|
||||
mtu, nd->mtu);
|
||||
mtu, nd->mtu);
|
||||
}
|
||||
|
||||
break;
|
||||
|
@ -93,14 +93,14 @@ static int bus_error_name_to_errno(const char *name) {
|
||||
p = startswith(name, "System.Error.");
|
||||
if (p) {
|
||||
r = errno_from_name(p);
|
||||
if (r <= 0)
|
||||
if (r < 0)
|
||||
return EIO;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
if (additional_error_maps) {
|
||||
for (map = additional_error_maps; *map; map++) {
|
||||
if (additional_error_maps)
|
||||
for (map = additional_error_maps; *map; map++)
|
||||
for (m = *map;; m++) {
|
||||
/* For additional error maps the end marker is actually the end marker */
|
||||
if (m->code == BUS_ERROR_MAP_END_MARKER)
|
||||
@ -109,15 +109,13 @@ static int bus_error_name_to_errno(const char *name) {
|
||||
if (streq(m->name, name))
|
||||
return m->code;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m = __start_BUS_ERROR_MAP;
|
||||
while (m < __stop_BUS_ERROR_MAP) {
|
||||
/* For magic ELF error maps, the end marker might
|
||||
* appear in the middle of things, since multiple maps
|
||||
* might appear in the same section. Hence, let's skip
|
||||
* over it, but realign the pointer to the netx 8byte
|
||||
* over it, but realign the pointer to the next 8 byte
|
||||
* boundary, which is the selected alignment for the
|
||||
* arrays. */
|
||||
if (m->code == BUS_ERROR_MAP_END_MARKER) {
|
||||
@ -258,25 +256,24 @@ int bus_error_setfv(sd_bus_error *e, const char *name, const char *format, va_li
|
||||
|
||||
if (!name)
|
||||
return 0;
|
||||
if (!e)
|
||||
goto finish;
|
||||
|
||||
assert_return(!bus_error_is_dirty(e), -EINVAL);
|
||||
if (e) {
|
||||
assert_return(!bus_error_is_dirty(e), -EINVAL);
|
||||
|
||||
e->name = strdup(name);
|
||||
if (!e->name) {
|
||||
*e = BUS_ERROR_OOM;
|
||||
return -ENOMEM;
|
||||
e->name = strdup(name);
|
||||
if (!e->name) {
|
||||
*e = BUS_ERROR_OOM;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* If we hit OOM on formatting the pretty message, we ignore
|
||||
* this, since we at least managed to write the error name */
|
||||
if (format)
|
||||
(void) vasprintf((char**) &e->message, format, ap);
|
||||
|
||||
e->_need_free = 1;
|
||||
}
|
||||
|
||||
/* If we hit OOM on formatting the pretty message, we ignore
|
||||
* this, since we at least managed to write the error name */
|
||||
if (format)
|
||||
(void) vasprintf((char**) &e->message, format, ap);
|
||||
|
||||
e->_need_free = 1;
|
||||
|
||||
finish:
|
||||
return -bus_error_name_to_errno(name);
|
||||
}
|
||||
|
||||
@ -582,27 +579,29 @@ const char *bus_error_message(const sd_bus_error *e, int error) {
|
||||
return strerror(error);
|
||||
}
|
||||
|
||||
static bool map_ok(const sd_bus_error_map *map) {
|
||||
for (; map->code != BUS_ERROR_MAP_END_MARKER; map++)
|
||||
if (!map->name || map->code <=0)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
_public_ int sd_bus_error_add_map(const sd_bus_error_map *map) {
|
||||
const sd_bus_error_map **maps = NULL;
|
||||
unsigned n = 0;
|
||||
|
||||
assert_return(map, -EINVAL);
|
||||
assert_return(map_ok(map), -EINVAL);
|
||||
|
||||
if (additional_error_maps) {
|
||||
for (;; n++) {
|
||||
if (additional_error_maps[n] == NULL)
|
||||
break;
|
||||
|
||||
if (additional_error_maps)
|
||||
for (; additional_error_maps[n] != NULL; n++)
|
||||
if (additional_error_maps[n] == map)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
maps = realloc_multiply(additional_error_maps, sizeof(struct sd_bus_error_map*), n + 2);
|
||||
if (!maps)
|
||||
return -ENOMEM;
|
||||
|
||||
|
||||
maps[n] = map;
|
||||
maps[n+1] = NULL;
|
||||
|
||||
|
@ -270,8 +270,8 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
|
||||
struct bus_body_part *part;
|
||||
struct kdbus_item *d;
|
||||
const char *destination;
|
||||
bool well_known;
|
||||
uint64_t unique;
|
||||
bool well_known = false;
|
||||
uint64_t dst_id;
|
||||
size_t sz, dl;
|
||||
unsigned i;
|
||||
int r;
|
||||
@ -288,13 +288,21 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
|
||||
destination = m->destination ?: m->destination_ptr;
|
||||
|
||||
if (destination) {
|
||||
r = bus_kernel_parse_unique_name(destination, &unique);
|
||||
r = bus_kernel_parse_unique_name(destination, &dst_id);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (r == 0) {
|
||||
well_known = true;
|
||||
|
||||
well_known = r == 0;
|
||||
/* verify_destination_id will usually be 0, which makes the kernel
|
||||
* driver only look at the provided well-known name. Otherwise,
|
||||
* the kernel will make sure the provided destination id matches
|
||||
* the owner of the provided well-known-name, and fail if they
|
||||
* differ. Currently, this is only needed for bus-proxyd. */
|
||||
dst_id = m->verify_destination_id;
|
||||
}
|
||||
} else
|
||||
well_known = false;
|
||||
dst_id = KDBUS_DST_ID_BROADCAST;
|
||||
|
||||
sz = offsetof(struct kdbus_msg, items);
|
||||
|
||||
@ -332,15 +340,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
|
||||
((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0) |
|
||||
((m->header->type == SD_BUS_MESSAGE_SIGNAL) ? KDBUS_MSG_SIGNAL : 0);
|
||||
|
||||
if (well_known)
|
||||
/* verify_destination_id will usually be 0, which makes the kernel driver only look
|
||||
* at the provided well-known name. Otherwise, the kernel will make sure the provided
|
||||
* destination id matches the owner of the provided weel-known-name, and fail if they
|
||||
* differ. Currently, this is only needed for bus-proxyd. */
|
||||
m->kdbus->dst_id = m->verify_destination_id;
|
||||
else
|
||||
m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
|
||||
|
||||
m->kdbus->dst_id = dst_id;
|
||||
m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
|
||||
m->kdbus->cookie = m->header->dbus2.cookie;
|
||||
m->kdbus->priority = m->priority;
|
||||
|
@ -44,7 +44,15 @@ static void test_error(void) {
|
||||
assert_se(sd_bus_error_is_set(&error));
|
||||
sd_bus_error_free(&error);
|
||||
|
||||
/* Check with no error */
|
||||
assert_se(!sd_bus_error_is_set(&error));
|
||||
assert_se(sd_bus_error_setf(&error, NULL, "yyy %i", -1) == 0);
|
||||
assert_se(error.name == NULL);
|
||||
assert_se(error.message == NULL);
|
||||
assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
|
||||
assert_se(sd_bus_error_get_errno(&error) == 0);
|
||||
assert_se(!sd_bus_error_is_set(&error));
|
||||
|
||||
assert_se(sd_bus_error_setf(&error, SD_BUS_ERROR_FILE_NOT_FOUND, "yyy %i", -1) == -ENOENT);
|
||||
assert_se(streq(error.name, SD_BUS_ERROR_FILE_NOT_FOUND));
|
||||
assert_se(streq(error.message, "yyy -1"));
|
||||
@ -112,6 +120,16 @@ static void test_error(void) {
|
||||
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
|
||||
assert_se(sd_bus_error_get_errno(&error) == EIO);
|
||||
assert_se(sd_bus_error_is_set(&error));
|
||||
sd_bus_error_free(&error);
|
||||
|
||||
/* Check with no error */
|
||||
assert_se(!sd_bus_error_is_set(&error));
|
||||
assert_se(sd_bus_error_set_errnof(&error, 0, "Waldi %c", 'X') == 0);
|
||||
assert_se(error.name == NULL);
|
||||
assert_se(error.message == NULL);
|
||||
assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
|
||||
assert_se(sd_bus_error_get_errno(&error) == 0);
|
||||
assert_se(!sd_bus_error_is_set(&error));
|
||||
}
|
||||
|
||||
extern const sd_bus_error_map __start_BUS_ERROR_MAP[];
|
||||
@ -167,6 +185,16 @@ static const sd_bus_error_map test_errors4[] = {
|
||||
SD_BUS_ERROR_MAP_END
|
||||
};
|
||||
|
||||
static const sd_bus_error_map test_errors_bad1[] = {
|
||||
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", 0),
|
||||
SD_BUS_ERROR_MAP_END
|
||||
};
|
||||
|
||||
static const sd_bus_error_map test_errors_bad2[] = {
|
||||
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", -1),
|
||||
SD_BUS_ERROR_MAP_END
|
||||
};
|
||||
|
||||
static void test_errno_mapping_custom(void) {
|
||||
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error", NULL) == -5);
|
||||
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
|
||||
@ -190,6 +218,9 @@ static void test_errno_mapping_custom(void) {
|
||||
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-y", NULL) == -EIO);
|
||||
|
||||
assert_se(sd_bus_error_set(NULL, BUS_ERROR_NO_SUCH_UNIT, NULL) == -ENOENT);
|
||||
|
||||
assert_se(sd_bus_error_add_map(test_errors_bad1) == -EINVAL);
|
||||
assert_se(sd_bus_error_add_map(test_errors_bad2) == -EINVAL);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
|
@ -494,7 +494,7 @@ static int handle_uevent_line(sd_device *device, const char *key, const char *va
|
||||
|
||||
int device_read_uevent_file(sd_device *device) {
|
||||
_cleanup_free_ char *uevent = NULL;
|
||||
const char *syspath, *key, *value, *major = NULL, *minor = NULL;
|
||||
const char *syspath, *key = NULL, *value = NULL, *major = NULL, *minor = NULL;
|
||||
char *path;
|
||||
size_t uevent_len;
|
||||
unsigned i;
|
||||
|
@ -661,8 +661,10 @@ static int event_make_signal_data(
|
||||
d->priority = priority;
|
||||
|
||||
r = hashmap_put(e->signal_data, &d->priority, d);
|
||||
if (r < 0)
|
||||
if (r < 0) {
|
||||
free(d);
|
||||
return r;
|
||||
}
|
||||
|
||||
added = true;
|
||||
}
|
||||
@ -2751,6 +2753,12 @@ _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
|
||||
assert_return(e, -EINVAL);
|
||||
assert_return(usec, -EINVAL);
|
||||
assert_return(!event_pid_changed(e), -ECHILD);
|
||||
assert_return(IN_SET(clock,
|
||||
CLOCK_REALTIME,
|
||||
CLOCK_REALTIME_ALARM,
|
||||
CLOCK_MONOTONIC,
|
||||
CLOCK_BOOTTIME,
|
||||
CLOCK_BOOTTIME_ALARM), -EOPNOTSUPP);
|
||||
|
||||
if (!dual_timestamp_is_set(&e->timestamp)) {
|
||||
/* Implicitly fall back to now() if we never ran
|
||||
@ -2770,8 +2778,7 @@ _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
|
||||
*usec = e->timestamp.monotonic;
|
||||
break;
|
||||
|
||||
case CLOCK_BOOTTIME:
|
||||
case CLOCK_BOOTTIME_ALARM:
|
||||
default:
|
||||
*usec = e->timestamp_boottime;
|
||||
break;
|
||||
}
|
||||
|
@ -264,6 +264,30 @@ static void test_basic(void) {
|
||||
safe_close_pair(k);
|
||||
}
|
||||
|
||||
static void test_sd_event_now(void) {
|
||||
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
|
||||
uint64_t event_now;
|
||||
|
||||
assert_se(sd_event_new(&e) >= 0);
|
||||
assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) > 0);
|
||||
assert_se(sd_event_now(e, CLOCK_REALTIME, &event_now) > 0);
|
||||
assert_se(sd_event_now(e, CLOCK_REALTIME_ALARM, &event_now) > 0);
|
||||
assert_se(sd_event_now(e, CLOCK_BOOTTIME, &event_now) > 0);
|
||||
assert_se(sd_event_now(e, CLOCK_BOOTTIME_ALARM, &event_now) > 0);
|
||||
assert_se(sd_event_now(e, -1, &event_now) == -EOPNOTSUPP);
|
||||
assert_se(sd_event_now(e, 900 /* arbitrary big number */, &event_now) == -EOPNOTSUPP);
|
||||
|
||||
assert_se(sd_event_run(e, 0) == 0);
|
||||
|
||||
assert_se(sd_event_now(e, CLOCK_MONOTONIC, &event_now) == 0);
|
||||
assert_se(sd_event_now(e, CLOCK_REALTIME, &event_now) == 0);
|
||||
assert_se(sd_event_now(e, CLOCK_REALTIME_ALARM, &event_now) == 0);
|
||||
assert_se(sd_event_now(e, CLOCK_BOOTTIME, &event_now) == 0);
|
||||
assert_se(sd_event_now(e, CLOCK_BOOTTIME_ALARM, &event_now) == 0);
|
||||
assert_se(sd_event_now(e, -1, &event_now) == -EOPNOTSUPP);
|
||||
assert_se(sd_event_now(e, 900 /* arbitrary big number */, &event_now) == -EOPNOTSUPP);
|
||||
}
|
||||
|
||||
static int last_rtqueue_sigval = 0;
|
||||
static int n_rtqueue = 0;
|
||||
|
||||
@ -324,7 +348,11 @@ static void test_rtqueue(void) {
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
|
||||
log_set_max_level(LOG_DEBUG);
|
||||
log_parse_environment();
|
||||
|
||||
test_basic();
|
||||
test_sd_event_now();
|
||||
test_rtqueue();
|
||||
|
||||
return 0;
|
||||
|
@ -810,7 +810,7 @@ _public_ int sd_get_uids(uid_t **users) {
|
||||
|
||||
errno = 0;
|
||||
de = readdir(d);
|
||||
if (!de && errno != 0)
|
||||
if (!de && errno > 0)
|
||||
return -errno;
|
||||
|
||||
if (!de)
|
||||
|
@ -96,15 +96,6 @@ static const NLType rtnl_link_info_data_macvlan_types[] = {
|
||||
[IFLA_MACVLAN_FLAGS] = { .type = NETLINK_TYPE_U16 },
|
||||
};
|
||||
|
||||
static const NLType rtnl_link_bridge_management_types[] = {
|
||||
[IFLA_BRIDGE_FLAGS] = { .type = NETLINK_TYPE_U16 },
|
||||
[IFLA_BRIDGE_MODE] = { .type = NETLINK_TYPE_U16 },
|
||||
/*
|
||||
[IFLA_BRIDGE_VLAN_INFO] = { .type = NETLINK_TYPE_BINARY,
|
||||
.len = sizeof(struct bridge_vlan_info), },
|
||||
*/
|
||||
};
|
||||
|
||||
static const NLType rtnl_link_info_data_bridge_types[] = {
|
||||
[IFLA_BR_FORWARD_DELAY] = { .type = NETLINK_TYPE_U32 },
|
||||
[IFLA_BR_HELLO_TIME] = { .type = NETLINK_TYPE_U32 },
|
||||
|
@ -539,7 +539,7 @@ static int read_next_mapping(const char* filename,
|
||||
if (!fgets(line, sizeof(line), f)) {
|
||||
|
||||
if (ferror(f))
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -139,7 +139,7 @@ int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
|
||||
errno = 0;
|
||||
p = getpwuid(uid);
|
||||
if (!p)
|
||||
return errno ? -errno : -ENOENT;
|
||||
return errno > 0 ? -errno : -ENOENT;
|
||||
|
||||
return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
|
||||
}
|
||||
|
@ -124,7 +124,6 @@ int manager_get_seat_from_creds(Manager *m, sd_bus_message *message, const char
|
||||
return r;
|
||||
|
||||
seat = session->seat;
|
||||
|
||||
if (!seat)
|
||||
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "Session has no seat.");
|
||||
} else {
|
||||
@ -1111,7 +1110,7 @@ static int method_set_user_linger(sd_bus_message *message, void *userdata, sd_bu
|
||||
errno = 0;
|
||||
pw = getpwuid(uid);
|
||||
if (!pw)
|
||||
return errno ? -errno : -ENOENT;
|
||||
return errno > 0 ? -errno : -ENOENT;
|
||||
|
||||
r = bus_verify_polkit_async(
|
||||
message,
|
||||
@ -1995,7 +1994,7 @@ static int method_schedule_shutdown(sd_bus_message *message, void *userdata, sd_
|
||||
|
||||
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_TTY|SD_BUS_CREDS_UID, &creds);
|
||||
if (r >= 0) {
|
||||
const char *tty;
|
||||
const char *tty = NULL;
|
||||
|
||||
(void) sd_bus_creds_get_uid(creds, &m->scheduled_shutdown_uid);
|
||||
(void) sd_bus_creds_get_tty(creds, &tty);
|
||||
@ -2752,6 +2751,23 @@ int manager_send_changed(Manager *manager, const char *property, ...) {
|
||||
l);
|
||||
}
|
||||
|
||||
static int strdup_job(sd_bus_message *reply, char **job) {
|
||||
const char *j;
|
||||
char *copy;
|
||||
int r;
|
||||
|
||||
r = sd_bus_message_read(reply, "o", &j);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
copy = strdup(j);
|
||||
if (!copy)
|
||||
return -ENOMEM;
|
||||
|
||||
*job = copy;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int manager_start_slice(
|
||||
Manager *manager,
|
||||
const char *slice,
|
||||
@ -2767,6 +2783,7 @@ int manager_start_slice(
|
||||
|
||||
assert(manager);
|
||||
assert(slice);
|
||||
assert(job);
|
||||
|
||||
r = sd_bus_message_new_method_call(
|
||||
manager->bus,
|
||||
@ -2820,22 +2837,7 @@ int manager_start_slice(
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
if (job) {
|
||||
const char *j;
|
||||
char *copy;
|
||||
|
||||
r = sd_bus_message_read(reply, "o", &j);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
copy = strdup(j);
|
||||
if (!copy)
|
||||
return -ENOMEM;
|
||||
|
||||
*job = copy;
|
||||
}
|
||||
|
||||
return 1;
|
||||
return strdup_job(reply, job);
|
||||
}
|
||||
|
||||
int manager_start_scope(
|
||||
@ -2856,6 +2858,7 @@ int manager_start_scope(
|
||||
assert(manager);
|
||||
assert(scope);
|
||||
assert(pid > 1);
|
||||
assert(job);
|
||||
|
||||
r = sd_bus_message_new_method_call(
|
||||
manager->bus,
|
||||
@ -2930,22 +2933,7 @@ int manager_start_scope(
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
if (job) {
|
||||
const char *j;
|
||||
char *copy;
|
||||
|
||||
r = sd_bus_message_read(reply, "o", &j);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
copy = strdup(j);
|
||||
if (!copy)
|
||||
return -ENOMEM;
|
||||
|
||||
*job = copy;
|
||||
}
|
||||
|
||||
return 1;
|
||||
return strdup_job(reply, job);
|
||||
}
|
||||
|
||||
int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
|
||||
@ -2954,6 +2942,7 @@ int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error,
|
||||
|
||||
assert(manager);
|
||||
assert(unit);
|
||||
assert(job);
|
||||
|
||||
r = sd_bus_call_method(
|
||||
manager->bus,
|
||||
@ -2967,22 +2956,7 @@ int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error,
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
if (job) {
|
||||
const char *j;
|
||||
char *copy;
|
||||
|
||||
r = sd_bus_message_read(reply, "o", &j);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
copy = strdup(j);
|
||||
if (!copy)
|
||||
return -ENOMEM;
|
||||
|
||||
*job = copy;
|
||||
}
|
||||
|
||||
return 1;
|
||||
return strdup_job(reply, job);
|
||||
}
|
||||
|
||||
int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
|
||||
@ -2991,6 +2965,7 @@ int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, c
|
||||
|
||||
assert(manager);
|
||||
assert(unit);
|
||||
assert(job);
|
||||
|
||||
r = sd_bus_call_method(
|
||||
manager->bus,
|
||||
@ -3005,9 +2980,7 @@ int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, c
|
||||
if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
|
||||
sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
|
||||
|
||||
if (job)
|
||||
*job = NULL;
|
||||
|
||||
*job = NULL;
|
||||
sd_bus_error_free(error);
|
||||
return 0;
|
||||
}
|
||||
@ -3015,22 +2988,7 @@ int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, c
|
||||
return r;
|
||||
}
|
||||
|
||||
if (job) {
|
||||
const char *j;
|
||||
char *copy;
|
||||
|
||||
r = sd_bus_message_read(reply, "o", &j);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
copy = strdup(j);
|
||||
if (!copy)
|
||||
return -ENOMEM;
|
||||
|
||||
*job = copy;
|
||||
}
|
||||
|
||||
return 1;
|
||||
return strdup_job(reply, job);
|
||||
}
|
||||
|
||||
int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *error) {
|
||||
|
@ -412,13 +412,12 @@ static int user_start_slice(User *u) {
|
||||
u->manager->user_tasks_max,
|
||||
&error,
|
||||
&job);
|
||||
if (r < 0) {
|
||||
/* we don't fail due to this, let's try to continue */
|
||||
if (!sd_bus_error_has_name(&error, BUS_ERROR_UNIT_EXISTS))
|
||||
log_error_errno(r, "Failed to start user slice %s, ignoring: %s (%s)", u->slice, bus_error_message(&error, r), error.name);
|
||||
} else {
|
||||
if (r >= 0)
|
||||
u->slice_job = job;
|
||||
}
|
||||
else if (!sd_bus_error_has_name(&error, BUS_ERROR_UNIT_EXISTS))
|
||||
/* we don't fail due to this, let's try to continue */
|
||||
log_error_errno(r, "Failed to start user slice %s, ignoring: %s (%s)",
|
||||
u->slice, bus_error_message(&error, r), error.name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -868,7 +867,7 @@ int config_parse_tmpfs_size(
|
||||
|
||||
errno = 0;
|
||||
ul = strtoul(rvalue, &f, 10);
|
||||
if (errno != 0 || f != e) {
|
||||
if (errno > 0 || f != e) {
|
||||
log_syntax(unit, LOG_ERR, filename, line, errno, "Failed to parse percentage value, ignoring: %s", rvalue);
|
||||
return 0;
|
||||
}
|
||||
|
@ -910,7 +910,7 @@ static int method_map_from_machine_user(sd_bus_message *message, void *userdata,
|
||||
if (k < 0 && feof(f))
|
||||
break;
|
||||
if (k != 3) {
|
||||
if (ferror(f) && errno != 0)
|
||||
if (ferror(f) && errno > 0)
|
||||
return -errno;
|
||||
|
||||
return -EIO;
|
||||
@ -968,7 +968,7 @@ static int method_map_to_machine_user(sd_bus_message *message, void *userdata, s
|
||||
if (k < 0 && feof(f))
|
||||
break;
|
||||
if (k != 3) {
|
||||
if (ferror(f) && errno != 0)
|
||||
if (ferror(f) && errno > 0)
|
||||
return -errno;
|
||||
|
||||
return -EIO;
|
||||
@ -1028,7 +1028,7 @@ static int method_map_from_machine_group(sd_bus_message *message, void *groupdat
|
||||
if (k < 0 && feof(f))
|
||||
break;
|
||||
if (k != 3) {
|
||||
if (ferror(f) && errno != 0)
|
||||
if (ferror(f) && errno > 0)
|
||||
return -errno;
|
||||
|
||||
return -EIO;
|
||||
@ -1086,7 +1086,7 @@ static int method_map_to_machine_group(sd_bus_message *message, void *groupdata,
|
||||
if (k < 0 && feof(f))
|
||||
break;
|
||||
if (k != 3) {
|
||||
if (ferror(f) && errno != 0)
|
||||
if (ferror(f) && errno > 0)
|
||||
return -errno;
|
||||
|
||||
return -EIO;
|
||||
|
@ -1071,7 +1071,7 @@ int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, size_t *star
|
||||
/* Let's calculate the actual data size and update the field */
|
||||
rdlength = p->size - rdlength_offset - sizeof(uint16_t);
|
||||
if (rdlength > 0xFFFF) {
|
||||
r = ENOSPC;
|
||||
r = -ENOSPC;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
|
@ -71,7 +71,7 @@ static int lookup_key(const char *keyname, key_serial_t *ret) {
|
||||
|
||||
serial = request_key("user", keyname, NULL, 0);
|
||||
if (serial == -1)
|
||||
return -errno;
|
||||
return negative_errno();
|
||||
|
||||
*ret = serial;
|
||||
return 0;
|
||||
|
@ -156,7 +156,7 @@ static int iterate_dir(
|
||||
|
||||
errno = 0;
|
||||
de = readdir(d);
|
||||
if (!de && errno != 0)
|
||||
if (!de && errno > 0)
|
||||
return log_error_errno(errno, "Failed to read directory %s: %m", path);
|
||||
|
||||
if (!de)
|
||||
|
@ -280,7 +280,7 @@ static int putgrent_with_members(const struct group *gr, FILE *group) {
|
||||
|
||||
errno = 0;
|
||||
if (putgrent(&t, group) != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -288,7 +288,7 @@ static int putgrent_with_members(const struct group *gr, FILE *group) {
|
||||
|
||||
errno = 0;
|
||||
if (putgrent(gr, group) != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -330,7 +330,7 @@ static int putsgent_with_members(const struct sgrp *sg, FILE *gshadow) {
|
||||
|
||||
errno = 0;
|
||||
if (putsgent(&t, gshadow) != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -338,7 +338,7 @@ static int putsgent_with_members(const struct sgrp *sg, FILE *gshadow) {
|
||||
|
||||
errno = 0;
|
||||
if (putsgent(sg, gshadow) != 0)
|
||||
return errno ? -errno : -EIO;
|
||||
return errno > 0 ? -errno : -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -1075,7 +1075,7 @@ static int item_do_children(Item *i, const char *path, action_t action) {
|
||||
errno = 0;
|
||||
de = readdir(d);
|
||||
if (!de) {
|
||||
if (errno != 0 && r == 0)
|
||||
if (errno > 0 && r == 0)
|
||||
r = -errno;
|
||||
|
||||
break;
|
||||
|
@ -124,7 +124,7 @@ static int find_gpt_root(struct udev_device *dev, blkid_probe pr, bool test) {
|
||||
errno = 0;
|
||||
pl = blkid_probe_get_partitions(pr);
|
||||
if (!pl)
|
||||
return errno ? -errno : -ENOMEM;
|
||||
return errno > 0 ? -errno : -ENOMEM;
|
||||
|
||||
nvals = blkid_partlist_numof_partitions(pl);
|
||||
for (i = 0; i < nvals; i++) {
|
||||
|
@ -1652,7 +1652,8 @@ exit:
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
_cleanup_free_ char *cgroup = NULL;
|
||||
int r, fd_ctrl, fd_uevent;
|
||||
_cleanup_close_ int fd_ctrl = -1, fd_uevent = -1;
|
||||
int r;
|
||||
|
||||
log_set_target(LOG_TARGET_AUTO);
|
||||
log_parse_environment();
|
||||
|
Loading…
x
Reference in New Issue
Block a user