2020-11-09 05:23:58 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
2015-10-25 14:08:25 +01:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <stdbool.h>
|
2015-11-30 21:43:37 +01:00
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdint.h>
|
2015-10-27 01:02:30 +01:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/uio.h>
|
2015-10-25 14:08:25 +01:00
|
|
|
|
2015-11-30 21:43:37 +01:00
|
|
|
#include "macro.h"
|
2015-10-25 14:08:25 +01:00
|
|
|
#include "time-util.h"
|
|
|
|
|
|
|
|
int flush_fd(int fd);
|
|
|
|
|
|
|
|
ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll);
|
|
|
|
int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll);
|
|
|
|
int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll);
|
|
|
|
|
|
|
|
int pipe_eof(int fd);
|
|
|
|
|
|
|
|
int fd_wait_for_event(int fd, int event, usec_t timeout);
|
|
|
|
|
|
|
|
ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length);
|
2015-10-27 01:02:30 +01:00
|
|
|
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, size_t n) {
|
|
|
|
size_t j, r = 0;
|
2015-10-27 01:02:30 +01:00
|
|
|
|
|
|
|
for (j = 0; j < n; j++)
|
|
|
|
r += i[j].iov_len;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
static inline size_t IOVEC_INCREMENT(struct iovec *i, size_t n, size_t k) {
|
|
|
|
size_t j;
|
2015-10-27 01:02:30 +01:00
|
|
|
|
|
|
|
for (j = 0; j < n; j++) {
|
|
|
|
size_t sub;
|
|
|
|
|
|
|
|
if (_unlikely_(k <= 0))
|
|
|
|
break;
|
|
|
|
|
|
|
|
sub = MIN(i[j].iov_len, k);
|
|
|
|
i[j].iov_len -= sub;
|
|
|
|
i[j].iov_base = (uint8_t*) i[j].iov_base + sub;
|
|
|
|
k -= sub;
|
|
|
|
}
|
|
|
|
|
|
|
|
return k;
|
|
|
|
}
|
2016-01-26 19:02:12 +01:00
|
|
|
|
|
|
|
static inline bool FILE_SIZE_VALID(uint64_t l) {
|
|
|
|
/* ftruncate() and friends take an unsigned file size, but actually cannot deal with file sizes larger than
|
|
|
|
* 2^63 since the kernel internally handles it as signed value. This call allows checking for this early. */
|
|
|
|
|
|
|
|
return (l >> 63) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool FILE_SIZE_VALID_OR_INFINITY(uint64_t l) {
|
|
|
|
|
|
|
|
/* Same as above, but allows one extra value: -1 as indication for infinity. */
|
|
|
|
|
|
|
|
if (l == (uint64_t) -1)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return FILE_SIZE_VALID(l);
|
|
|
|
|
|
|
|
}
|
2017-09-21 13:52:34 +02:00
|
|
|
|
|
|
|
#define IOVEC_INIT(base, len) { .iov_base = (base), .iov_len = (len) }
|
|
|
|
#define IOVEC_MAKE(base, len) (struct iovec) IOVEC_INIT(base, len)
|
|
|
|
#define IOVEC_INIT_STRING(string) IOVEC_INIT((char*) string, strlen(string))
|
|
|
|
#define IOVEC_MAKE_STRING(string) (struct iovec) IOVEC_INIT_STRING(string)
|
2018-12-05 18:38:39 +01:00
|
|
|
|
|
|
|
char* set_iovec_string_field(struct iovec *iovec, size_t *n_iovec, const char *field, const char *value);
|
2019-06-21 14:48:02 +02:00
|
|
|
char* set_iovec_string_field_free(struct iovec *iovec, size_t *n_iovec, const char *field, char *value);
|
2019-06-25 15:54:44 +02:00
|
|
|
|
|
|
|
struct iovec_wrapper {
|
|
|
|
struct iovec *iovec;
|
|
|
|
size_t count;
|
|
|
|
size_t size_bytes;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct iovec_wrapper *iovw_new(void);
|
|
|
|
struct iovec_wrapper *iovw_free(struct iovec_wrapper *iovw);
|
|
|
|
struct iovec_wrapper *iovw_free_free(struct iovec_wrapper *iovw);
|
|
|
|
void iovw_free_contents(struct iovec_wrapper *iovw, bool free_vectors);
|
|
|
|
int iovw_put(struct iovec_wrapper *iovw, void *data, size_t len);
|
2019-06-25 16:57:06 +02:00
|
|
|
int iovw_put_string_field(struct iovec_wrapper *iovw, const char *field, const char *value);
|
|
|
|
int iovw_put_string_field_free(struct iovec_wrapper *iovw, const char *field, char *value);
|
2019-06-25 15:54:44 +02:00
|
|
|
void iovw_rebase(struct iovec_wrapper *iovw, char *old, char *new);
|
|
|
|
size_t iovw_size(struct iovec_wrapper *iovw);
|