treewide: tighten variable scope in loops (#18372)

Also use _cleanup_free_ in one more place.

src/basic/cgroup-util.c

@@ -1131,8 +1131,8 @@ static const char *skip_slices(const char *p) {
 }
 
 int cg_path_get_unit(const char *path, char **ret) {
+        _cleanup_free_ char *unit = NULL;
         const char *e;
-        char *unit;
         int r;
 
         assert(path);
@@ -1145,12 +1145,10 @@ int cg_path_get_unit(const char *path, char **ret) {
                 return r;
 
         /* We skipped over the slices, don't accept any now */
-        if (endswith(unit, ".slice")) {
-                free(unit);
+        if (endswith(unit, ".slice"))
                 return -ENXIO;
-        }
 
-        *ret = unit;
+        *ret = TAKE_PTR(unit);
         return 0;
 }
 

src/basic/fd-util.c

@@ -91,11 +91,9 @@ void safe_close_pair(int p[static 2]) {
 }
 
 void close_many(const int fds[], size_t n_fd) {
-        size_t i;
-
         assert(fds || n_fd <= 0);
 
-        for (i = 0; i < n_fd; i++)
+        for (size_t i = 0; i < n_fd; i++)
                 safe_close(fds[i]);
 }
 
@@ -179,11 +177,9 @@ int fd_cloexec(int fd, bool cloexec) {
 }
 
 _pure_ static bool fd_in_set(int fd, const int fdset[], size_t n_fdset) {
-        size_t i;
-
         assert(n_fdset == 0 || fdset);
 
-        for (i = 0; i < n_fdset; i++)
+        for (size_t i = 0; i < n_fdset; i++)
                 if (fdset[i] == fd)
                         return true;
 

src/basic/format-util.c

@@ -43,7 +43,7 @@ char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
                 { "K", UINT64_C(1000) },
         };
         const suffix_table *table;
-        size_t n, i;
+        size_t n;
 
         assert_cc(ELEMENTSOF(table_iec) == ELEMENTSOF(table_si));
 
@@ -53,7 +53,7 @@ char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
         table = flag & FORMAT_BYTES_USE_IEC ? table_iec : table_si;
         n = ELEMENTSOF(table_iec);
 
-        for (i = 0; i < n; i++)
+        for (size_t i = 0; i < n; i++)
                 if (t >= table[i].factor) {
                         if (flag & FORMAT_BYTES_BELOW_POINT) {
                                 snprintf(buf, l,

src/basic/io-util.c

@@ -319,16 +319,14 @@ int iovw_put_string_field_free(struct iovec_wrapper *iovw, const char *field, ch
 }
 
 void iovw_rebase(struct iovec_wrapper *iovw, char *old, char *new) {
-        size_t i;
-
-        for (i = 0; i < iovw->count; i++)
+        for (size_t i = 0; i < iovw->count; i++)
                 iovw->iovec[i].iov_base = (char *)iovw->iovec[i].iov_base - old + new;
 }
 
 size_t iovw_size(struct iovec_wrapper *iovw) {
-        size_t n = 0, i;
+        size_t n = 0;
 
-        for (i = 0; i < iovw->count; i++)
+        for (size_t i = 0; i < iovw->count; i++)
                 n += iovw->iovec[i].iov_len;
 
         return n;

src/basic/parse-util.c

@@ -593,14 +593,13 @@ int safe_atod(const char *s, double *ret_d) {
 }
 
 int parse_fractional_part_u(const char **p, size_t digits, unsigned *res) {
-        size_t i;
         unsigned val = 0;
         const char *s;
 
         s = *p;
 
         /* accept any number of digits, strtoull is limited to 19 */
-        for (i=0; i < digits; i++,s++) {
+        for (size_t i = 0; i < digits; i++,s++) {
                 if (*s < '0' || *s > '9') {
                         if (i == 0)
                                 return -EINVAL;

src/basic/rlimit-util.c

@@ -50,13 +50,13 @@ int setrlimit_closest(int resource, const struct rlimit *rlim) {
 }
 
 int setrlimit_closest_all(const struct rlimit *const *rlim, int *which_failed) {
-        int i, r;
+        int r;
 
         assert(rlim);
 
         /* On failure returns the limit's index that failed in *which_failed, but only if non-NULL */
 
-        for (i = 0; i < _RLIMIT_MAX; i++) {
+        for (int i = 0; i < _RLIMIT_MAX; i++) {
                 if (!rlim[i])
                         continue;
 

src/basic/sigbus.c

@@ -23,12 +23,10 @@ static void* volatile sigbus_queue[SIGBUS_QUEUE_MAX];
 static volatile sig_atomic_t n_sigbus_queue = 0;
 
 static void sigbus_push(void *addr) {
-        unsigned u;
-
         assert(addr);
 
         /* Find a free place, increase the number of entries and leave, if we can */
-        for (u = 0; u < SIGBUS_QUEUE_MAX; u++)
+        for (size_t u = 0; u < SIGBUS_QUEUE_MAX; u++)
                 if (__sync_bool_compare_and_swap(&sigbus_queue[u], NULL, addr)) {
                         __sync_fetch_and_add(&n_sigbus_queue, 1);
                         return;

src/basic/signal-util.c

@@ -15,9 +15,9 @@ int reset_all_signal_handlers(void) {
                 .sa_handler = SIG_DFL,
                 .sa_flags = SA_RESTART,
         };
-        int sig, r = 0;
+        int r = 0;
 
-        for (sig = 1; sig < _NSIG; sig++) {
+        for (int sig = 1; sig < _NSIG; sig++) {
 
                 /* These two cannot be caught... */
                 if (IN_SET(sig, SIGKILL, SIGSTOP))

src/basic/string-util.c

@@ -862,9 +862,8 @@ char *strextend_with_separator_internal(char **x, const char *separator, ...) {
 }
 
 char *strrep(const char *s, unsigned n) {
-        size_t l;
         char *r, *p;
-        unsigned i;
+        size_t l;
 
         assert(s);
 
@@ -873,7 +872,7 @@ char *strrep(const char *s, unsigned n) {
         if (!r)
                 return NULL;
 
-        for (i = 0; i < n; i++)
+        for (unsigned i = 0; i < n; i++)
                 p = stpcpy(p, s);
 
         *p = 0;

src/basic/time-util.c

@@ -493,7 +493,6 @@ char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
                 { "us",    1               },
         };
 
-        size_t i;
         char *p = buf;
         bool something = false;
 
@@ -514,7 +513,7 @@ char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
 
         /* The result of this function can be parsed with parse_sec */
 
-        for (i = 0; i < ELEMENTSOF(table); i++) {
+        for (size_t i = 0; i < ELEMENTSOF(table); i++) {
                 int k = 0;
                 size_t n;
                 bool done = false;
@@ -962,9 +961,8 @@ static const char* extract_multiplier(const char *p, usec_t *multiplier) {
                 { "us",      1ULL            },
                 { "µs",      1ULL            },
         };
-        size_t i;
 
-        for (i = 0; i < ELEMENTSOF(table); i++) {
+        for (size_t i = 0; i < ELEMENTSOF(table); i++) {
                 char *e;
 
                 e = startswith(p, table[i].suffix);

src/basic/tmpfile-util.c

@@ -132,7 +132,6 @@ int tempfn_random(const char *p, const char *extra, char **ret) {
         const char *fn;
         char *t, *x;
         uint64_t u;
-        unsigned i;
 
         assert(ret);
 
@@ -162,7 +161,7 @@ int tempfn_random(const char *p, const char *extra, char **ret) {
         x = stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), extra), fn);
 
         u = random_u64();
-        for (i = 0; i < 16; i++) {
+        for (unsigned i = 0; i < 16; i++) {
                 *(x++) = hexchar(u & 0xF);
                 u >>= 4;
         }
@@ -176,7 +175,6 @@ int tempfn_random(const char *p, const char *extra, char **ret) {
 int tempfn_random_child(const char *p, const char *extra, char **ret) {
         char *t, *x;
         uint64_t u;
-        unsigned i;
         int r;
 
         assert(ret);
@@ -205,7 +203,7 @@ int tempfn_random_child(const char *p, const char *extra, char **ret) {
                 x = stpcpy(stpcpy(stpcpy(t, p), "/.#"), extra);
 
         u = random_u64();
-        for (i = 0; i < 16; i++) {
+        for (unsigned i = 0; i < 16; i++) {
                 *(x++) = hexchar(u & 0xF);
                 u >>= 4;
         }

src/basic/unit-file.c

@@ -580,7 +580,6 @@ static const char * const rlmap_initrd[] = {
 
 const char* runlevel_to_target(const char *word) {
         const char * const *rlmap_ptr;
-        size_t i;
 
         if (!word)
                 return NULL;
@@ -593,7 +592,7 @@ const char* runlevel_to_target(const char *word) {
 
         rlmap_ptr = in_initrd() ? rlmap_initrd : rlmap;
 
-        for (i = 0; rlmap_ptr[i]; i += 2)
+        for (size_t i = 0; rlmap_ptr[i]; i += 2)
                 if (streq(word, rlmap_ptr[i]))
                         return rlmap_ptr[i+1];
 

src/basic/utf8.c

@@ -81,7 +81,7 @@ static size_t utf8_encoded_expected_len(uint8_t c) {
 /* decode one unicode char */
 int utf8_encoded_to_unichar(const char *str, char32_t *ret_unichar) {
         char32_t unichar;
-        size_t len, i;
+        size_t len;
 
         assert(str);
 
@@ -110,7 +110,7 @@ int utf8_encoded_to_unichar(const char *str, char32_t *ret_unichar) {
                 return -EINVAL;
         }
 
-        for (i = 1; i < len; i++) {
+        for (size_t i = 1; i < len; i++) {
                 if (((char32_t)str[i] & 0xc0) != 0x80)
                         return -EINVAL;
 
@@ -302,14 +302,12 @@ char *ascii_is_valid(const char *str) {
 }
 
 char *ascii_is_valid_n(const char *str, size_t len) {
-        size_t i;
-
         /* Very similar to ascii_is_valid(), but checks exactly len
          * bytes and rejects any NULs in that range. */
 
         assert(str);
 
-        for (i = 0; i < len; i++)
+        for (size_t i = 0; i < len; i++)
                 if ((unsigned char) str[i] >= 128 || str[i] == 0)
                         return NULL;
 
@@ -436,7 +434,6 @@ size_t utf16_encode_unichar(char16_t *out, char32_t c) {
 
 char16_t *utf8_to_utf16(const char *s, size_t length) {
         char16_t *n, *p;
-        size_t i;
         int r;
 
         assert(s);
@@ -447,7 +444,7 @@ char16_t *utf8_to_utf16(const char *s, size_t length) {
 
         p = n;
 
-        for (i = 0; i < length;) {
+        for (size_t i = 0; i < length;) {
                 char32_t unichar;
                 size_t e;
 
@@ -505,7 +502,7 @@ static int utf8_unichar_to_encoded_len(char32_t unichar) {
 /* validate one encoded unicode char and return its length */
 int utf8_encoded_valid_unichar(const char *str, size_t length /* bytes */) {
         char32_t unichar;
-        size_t len, i;
+        size_t len;
         int r;
 
         assert(str);
@@ -526,7 +523,7 @@ int utf8_encoded_valid_unichar(const char *str, size_t length /* bytes */) {
                 return 1;
 
         /* check if expected encoded chars are available */
-        for (i = 0; i < len; i++)
+        for (size_t i = 0; i < len; i++)
                 if ((str[i] & 0x80) != 0x80)
                         return -EINVAL;
 

src/basic/virt.c

@@ -159,10 +159,9 @@ static int detect_vm_dmi(void) {
                 /* https://wiki.freebsd.org/bhyve */
                 { "BHYVE",               VIRTUALIZATION_BHYVE     },
         };
-        unsigned i;
         int r;
 
-        for (i = 0; i < ELEMENTSOF(dmi_vendors); i++) {
+        for (size_t i = 0; i < ELEMENTSOF(dmi_vendors); i++) {
                 _cleanup_free_ char *s = NULL;
                 unsigned j;