src/basic/log.c

@@ -476,7 +476,7 @@ static int write_to_syslog(
                 IOVEC_MAKE_STRING(header_pid),
                 IOVEC_MAKE_STRING(buffer),
         };
-        const struct msghdr msghdr = {
+        struct msghdr msghdr = {
                 .msg_iov = iovec,
                 .msg_iovlen = ELEMENTSOF(iovec),
         };
@@ -608,24 +608,23 @@ static int write_to_journal(
                 const char *buffer) {
 
         char header[LINE_MAX];
+        struct iovec iovec[4] = {};
+        struct msghdr mh = {};
 
         if (journal_fd < 0)
                 return 0;
 
         log_do_header(header, sizeof(header), level, error, file, line, func, object_field, object, extra_field, extra);
 
-        struct iovec iovec[4] = {
+        iovec[0] = IOVEC_MAKE_STRING(header);
-                IOVEC_MAKE_STRING(header),
+        iovec[1] = IOVEC_MAKE_STRING("MESSAGE=");
-                IOVEC_MAKE_STRING("MESSAGE="),
+        iovec[2] = IOVEC_MAKE_STRING(buffer);
-                IOVEC_MAKE_STRING(buffer),
+        iovec[3] = IOVEC_MAKE_STRING("\n");
-                IOVEC_MAKE_STRING("\n"),
-        };
-        const struct msghdr msghdr = {
-                .msg_iov = iovec,
-                .msg_iovlen = ELEMENTSOF(iovec),
-        };
 
-        if (sendmsg(journal_fd, &msghdr, MSG_NOSIGNAL) < 0)
+        mh.msg_iov = iovec;
+        mh.msg_iovlen = ELEMENTSOF(iovec);
+
+        if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
                 return -errno;
 
         return 1;
@@ -919,8 +918,11 @@ int log_format_iovec(
                 VA_FORMAT_ADVANCE(format, ap);
 
                 iovec[(*n)++] = IOVEC_MAKE_STRING(m);
-                if (newline_separator)
+
-                        iovec[(*n)++] = IOVEC_MAKE((char *)&nl, 1);
+                if (newline_separator) {
+                        iovec[*n] = IOVEC_MAKE((char *)&nl, 1);
+                        (*n)++;
+                }
 
                 format = va_arg(ap, char *);
         }
@@ -957,9 +959,12 @@ int log_struct_internal(
 
                 if (journal_fd >= 0) {
                         char header[LINE_MAX];
-                        struct iovec iovec[17];
+                        struct iovec iovec[17] = {};
                         size_t n = 0;
                         int r;
+                        struct msghdr mh = {
+                                .msg_iov = iovec,
+                        };
                         bool fallback = false;
 
                         /* If the journal is available do structured logging.
@@ -972,12 +977,8 @@ int log_struct_internal(
                         if (r < 0)
                                 fallback = true;
                         else {
-                                const struct msghdr msghdr = {
+                                mh.msg_iovlen = n;
-                                        .msg_iov = iovec,
+                                (void) sendmsg(journal_fd, &mh, MSG_NOSIGNAL);
-                                        .msg_iovlen = n,
-                                };
-
-                                (void) sendmsg(journal_fd, &msghdr, MSG_NOSIGNAL);
                         }
 
                         va_end(ap);
@@ -1036,6 +1037,8 @@ int log_struct_iovec_internal(
                 size_t n_input_iovec) {
 
         PROTECT_ERRNO;
+        size_t i;
+        char *m;
 
         if (_likely_(LOG_PRI(level) > log_max_level) ||
             log_target == LOG_TARGET_NULL)
@@ -1049,35 +1052,36 @@ int log_struct_iovec_internal(
                                LOG_TARGET_JOURNAL) &&
             journal_fd >= 0) {
 
-                char header[LINE_MAX];
-                log_do_header(header, sizeof(header), level, error, file, line, func, NULL, NULL, NULL, NULL);
-
                 struct iovec iovec[1 + n_input_iovec*2];
-                iovec[0] = IOVEC_MAKE_STRING(header);
+                char header[LINE_MAX];
-                for (size_t i = 0; i < n_input_iovec; i++) {
+                struct msghdr mh = {
-                        iovec[1+i*2] = input_iovec[i];
-                        iovec[1+i*2+1] = IOVEC_MAKE_STRING("\n");
-                }
-
-                const struct msghdr msghdr = {
                         .msg_iov = iovec,
                         .msg_iovlen = 1 + n_input_iovec*2,
                 };
 
-                if (sendmsg(journal_fd, &msghdr, MSG_NOSIGNAL) >= 0)
+                log_do_header(header, sizeof(header), level, error, file, line, func, NULL, NULL, NULL, NULL);
+                iovec[0] = IOVEC_MAKE_STRING(header);
+
+                for (i = 0; i < n_input_iovec; i++) {
+                        iovec[1+i*2] = input_iovec[i];
+                        iovec[1+i*2+1] = IOVEC_MAKE_STRING("\n");
+                }
+
+                if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) >= 0)
                         return -ERRNO_VALUE(error);
         }
 
-        for (size_t i = 0; i < n_input_iovec; i++)
+        for (i = 0; i < n_input_iovec; i++)
-                if (memory_startswith(input_iovec[i].iov_base, input_iovec[i].iov_len, "MESSAGE=")) {
+                if (memory_startswith(input_iovec[i].iov_base, input_iovec[i].iov_len, "MESSAGE="))
-                        char *m = strndupa(input_iovec[i].iov_base + STRLEN("MESSAGE="),
+                        break;
-                                           input_iovec[i].iov_len - STRLEN("MESSAGE="));
 
-                        return log_dispatch_internal(level, error, file, line, func, NULL, NULL, NULL, NULL, m);
+        if (_unlikely_(i >= n_input_iovec)) /* Couldn't find MESSAGE=? */
-                }
+                return -ERRNO_VALUE(error);
 
-        /* Couldn't find MESSAGE=. */
+        m = strndupa(input_iovec[i].iov_base + STRLEN("MESSAGE="),
-        return -ERRNO_VALUE(error);
+                     input_iovec[i].iov_len - STRLEN("MESSAGE="));
+
+        return log_dispatch_internal(level, error, file, line, func, NULL, NULL, NULL, NULL, m);
 }
 
 int log_set_target_from_string(const char *e) {

src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c

@@ -134,7 +134,7 @@ _public_ void cryptsetup_token_dump(
                 const char *json /* validated 'systemd-tpm2' token if cryptsetup_token_validate is defined */) {
 
         int r;
-        uint32_t pcr_mask;
+        uint32_t i, pcr_mask;
         uint16_t pcr_bank;
         size_t decoded_blob_size;
         _cleanup_free_ char *base64_blob = NULL, *hex_policy_hash = NULL,
@@ -147,7 +147,7 @@ _public_ void cryptsetup_token_dump(
         if (r < 0)
                 return (void) crypt_log_debug_errno(cd, r, "Failed to parse " TOKEN_NAME " metadata: %m.");
 
-        for (uint32_t i = 0; i < TPM2_PCRS_MAX; i++) {
+        for (i = 0; i < TPM2_PCRS_MAX; i++) {
                 if ((pcr_mask & (UINT32_C(1) << i)) &&
                     ((r = strextendf_with_separator(&pcrs_str, ", ", "%" PRIu32, i)) < 0))
                         return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");

src/test/test-log.c

@@ -66,11 +66,11 @@ static void test_log_syntax(void) {
 }
 
 int main(int argc, char* argv[]) {
+        int target;
+
         test_file();
 
-        assert_se(log_info_errno(SYNTHETIC_ERRNO(EUCLEAN), "foo") == -EUCLEAN);
+        for (target = 0; target < _LOG_TARGET_MAX; target++) {
-
-        for (int target = 0; target < _LOG_TARGET_MAX; target++) {
                 log_set_target(target);
                 log_open();
 
@@ -79,5 +79,7 @@ int main(int argc, char* argv[]) {
                 test_log_syntax();
         }
 
+        assert_se(log_info_errno(SYNTHETIC_ERRNO(EUCLEAN), "foo") == -EUCLEAN);
+
         return 0;
 }

src/udev/udev-builtin-blkid.c

@@ -116,7 +116,8 @@ static int find_gpt_root(sd_device *dev, blkid_probe pr, bool test) {
 
         _cleanup_free_ char *root_id = NULL, *root_label = NULL;
         bool found_esp = false;
-        int r;
+        blkid_partlist pl;
+        int i, nvals, r;
 
         assert(pr);
 
@@ -125,12 +126,12 @@ static int find_gpt_root(sd_device *dev, blkid_probe pr, bool test) {
          * disk, and add a property indicating its partition UUID. */
 
         errno = 0;
-        blkid_partlist pl = blkid_probe_get_partitions(pr);
+        pl = blkid_probe_get_partitions(pr);
         if (!pl)
                 return errno_or_else(ENOMEM);
 
-        int nvals = blkid_partlist_numof_partitions(pl);
+        nvals = blkid_partlist_numof_partitions(pl);
-        for (int i = 0; i < nvals; i++) {
+        for (i = 0; i < nvals; i++) {
                 blkid_partition pp;
                 const char *stype, *sid, *label;
                 sd_id128_t type;
@@ -239,7 +240,7 @@ static int builtin_blkid(sd_device *dev, int argc, char *argv[], bool test) {
         bool noraid = false, is_gpt = false;
         _cleanup_close_ int fd = -1;
         int64_t offset = 0;
-        int r;
+        int nvals, i, r;
 
         static const struct option options[] = {
                 { "offset", required_argument, NULL, 'o' },
@@ -324,11 +325,11 @@ static int builtin_blkid(sd_device *dev, int argc, char *argv[], bool test) {
         (void) sd_device_get_property_value(dev, "ID_PART_GPT_AUTO_ROOT_UUID", &root_partition);
 
         errno = 0;
-        int nvals = blkid_probe_numof_values(pr);
+        nvals = blkid_probe_numof_values(pr);
         if (nvals < 0)
                 return log_device_debug_errno(dev, errno_or_else(ENOMEM), "Failed to get number of probed values: %m");
 
-        for (int i = 0; i < nvals; i++) {
+        for (i = 0; i < nvals; i++) {
                 if (blkid_probe_get_value(pr, i, &name, &data, NULL) < 0)
                         continue;
 

src/udev/udev-builtin-input_id.c

@@ -92,7 +92,7 @@ static void get_cap_mask(sd_device *pdev, const char* attr,
 
         memzero(bitmask, bitmask_size);
         i = 0;
-        while ((word = strrchr(text, ' '))) {
+        while ((word = strrchr(text, ' ')) != NULL) {
                 r = safe_atolu_full(word+1, 16, &val);
                 if (r < 0)
                         log_device_debug_errno(pdev, r, "Ignoring %s block which failed to parse: %m", attr);
@@ -101,7 +101,7 @@ static void get_cap_mask(sd_device *pdev, const char* attr,
                 else
                         log_device_debug(pdev, "Ignoring %s block %lX which is larger than maximum size", attr, val);
                 *word = '\0';
-                i++;
+                ++i;
         }
         r = safe_atolu_full(text, 16, &val);
         if (r < 0)
@@ -120,9 +120,9 @@ static void get_cap_mask(sd_device *pdev, const char* attr,
                 /* skip over leading zeros */
                 while (bitmask[val-1] == 0 && val > 0)
                         --val;
-                for (unsigned long j = 0; j < val; j++) {
+                for (i = 0; i < val; ++i) {
                         DISABLE_WARNING_FORMAT_NONLITERAL;
-                        log_device_debug(pdev, text, j * BITS_PER_LONG, bitmask[j]);
+                        log_device_debug(pdev, text, i * BITS_PER_LONG, bitmask[i]);
                         REENABLE_WARNING;
                 }
         }
@@ -153,6 +153,7 @@ static bool test_pointers(sd_device *dev,
                           const unsigned long* bitmask_rel,
                           const unsigned long* bitmask_props,
                           bool test) {
+        int button, axis;
         bool has_abs_coordinates = false;
         bool has_rel_coordinates = false;
         bool has_mt_coordinates = false;
@@ -192,7 +193,7 @@ static bool test_pointers(sd_device *dev,
         has_stylus = test_bit(BTN_STYLUS, bitmask_key);
         has_pen = test_bit(BTN_TOOL_PEN, bitmask_key);
         finger_but_no_pen = test_bit(BTN_TOOL_FINGER, bitmask_key) && !test_bit(BTN_TOOL_PEN, bitmask_key);
-        for (int button = BTN_MOUSE; button < BTN_JOYSTICK && !has_mouse_button; button++)
+        for (button = BTN_MOUSE; button < BTN_JOYSTICK && !has_mouse_button; button++)
                 has_mouse_button = test_bit(button, bitmask_key);
         has_rel_coordinates = test_bit(EV_REL, bitmask_ev) && test_bit(REL_X, bitmask_rel) && test_bit(REL_Y, bitmask_rel);
         has_mt_coordinates = test_bit(ABS_MT_POSITION_X, bitmask_abs) && test_bit(ABS_MT_POSITION_Y, bitmask_abs);
@@ -213,14 +214,14 @@ static bool test_pointers(sd_device *dev,
          * Catz Mad Catz M.M.O.TE). Skip those.
          */
         if (!test_bit(BTN_JOYSTICK - 1, bitmask_key)) {
-                for (int button = BTN_JOYSTICK; button < BTN_DIGI && !has_joystick_axes_or_buttons; button++)
+                for (button = BTN_JOYSTICK; button < BTN_DIGI && !has_joystick_axes_or_buttons; button++)
                         has_joystick_axes_or_buttons = test_bit(button, bitmask_key);
-                for (int button = BTN_TRIGGER_HAPPY1; button <= BTN_TRIGGER_HAPPY40 && !has_joystick_axes_or_buttons; button++)
+                for (button = BTN_TRIGGER_HAPPY1; button <= BTN_TRIGGER_HAPPY40 && !has_joystick_axes_or_buttons; button++)
                         has_joystick_axes_or_buttons = test_bit(button, bitmask_key);
-                for (int button = BTN_DPAD_UP; button <= BTN_DPAD_RIGHT && !has_joystick_axes_or_buttons; button++)
+                for (button = BTN_DPAD_UP; button <= BTN_DPAD_RIGHT && !has_joystick_axes_or_buttons; button++)
                         has_joystick_axes_or_buttons = test_bit(button, bitmask_key);
         }
-        for (int axis = ABS_RX; axis < ABS_PRESSURE && !has_joystick_axes_or_buttons; axis++)
+        for (axis = ABS_RX; axis < ABS_PRESSURE && !has_joystick_axes_or_buttons; axis++)
                 has_joystick_axes_or_buttons = test_bit(axis, bitmask_abs);
 
         if (has_abs_coordinates) {
@@ -284,8 +285,10 @@ static bool test_key(sd_device *dev,
                      const unsigned long* bitmask_ev,
                      const unsigned long* bitmask_key,
                      bool test) {
-
+        unsigned i;
-        bool found = false;
+        unsigned long found;
+        unsigned long mask;
+        bool ret = false;
 
         /* do we have any KEY_* capability? */
         if (!test_bit(EV_KEY, bitmask_ev)) {
@@ -294,32 +297,39 @@ static bool test_key(sd_device *dev,
         }
 
         /* only consider KEY_* here, not BTN_* */
-        for (size_t i = 0; i < BTN_MISC/BITS_PER_LONG && !found; i++) {
+        found = 0;
-                if (bitmask_key[i])
+        for (i = 0; i < BTN_MISC/BITS_PER_LONG; ++i) {
-                        found = true;
+                found |= bitmask_key[i];
-
+                log_device_debug(dev, "test_key: checking bit block %lu for any keys; found=%i", (unsigned long)i*BITS_PER_LONG, found > 0);
-                log_device_debug(dev, "test_key: checking bit block %zu for any keys; found=%s",
-                                 i * BITS_PER_LONG, yes_no(found));
         }
         /* If there are no keys in the lower block, check the higher blocks */
-        for (size_t block = 0; block < sizeof(high_key_blocks) / sizeof(struct range) && !found; block++)
+        if (!found) {
-                for (unsigned i = high_key_blocks[block].start; i < high_key_blocks[block].end && !found; i++)
+                unsigned block;
-                        if (test_bit(i, bitmask_key)) {
+                for (block = 0; block < (sizeof(high_key_blocks) / sizeof(struct range)); ++block) {
-                                log_device_debug(dev, "test_key: Found key %x in high block", i);
+                        for (i = high_key_blocks[block].start; i < high_key_blocks[block].end; ++i) {
-                                found = true;
+                                if (test_bit(i, bitmask_key)) {
+                                        log_device_debug(dev, "test_key: Found key %x in high block", i);
+                                        found = 1;
+                                        break;
+                                }
                         }
+                }
+        }
 
-        if (found)
+        if (found > 0) {
                 udev_builtin_add_property(dev, test, "ID_INPUT_KEY", "1");
+                ret = true;
+        }
 
         /* the first 32 bits are ESC, numbers, and Q to D; if we have all of
          * those, consider it a full keyboard; do not test KEY_RESERVED, though */
-        if (FLAGS_SET(bitmask_key[0], 0xFFFFFFFE)) {
+        mask = 0xFFFFFFFE;
+        if (FLAGS_SET(bitmask_key[0], mask)) {
                 udev_builtin_add_property(dev, test, "ID_INPUT_KEYBOARD", "1");
-                return true;
+                ret = true;
         }
 
-        return found;
+        return ret;
 }
 
 static int builtin_input_id(sd_device *dev, int argc, char *argv[], bool test) {

src/udev/udev-builtin-kmod.c

@@ -21,14 +21,16 @@ _printf_(6,0) static void udev_kmod_log(void *data, int priority, const char *fi
 }
 
 static int builtin_kmod(sd_device *dev, int argc, char *argv[], bool test) {
+        int i;
+
         if (!ctx)
                 return 0;
 
         if (argc < 3 || !streq(argv[1], "load"))
                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
-                                       "%s: expected: load <module>…", argv[0]);
+                                       "%s: expected: load <module>", argv[0]);
 
-        for (int i = 2; argv[i]; i++)
+        for (i = 2; argv[i]; i++)
                 (void) module_load_and_warn(ctx, argv[i], false);
 
         return 0;

src/udev/udev-builtin-net_id.c

@@ -78,23 +78,25 @@ struct virtfn_info {
 
 /* skip intermediate virtio devices */
 static sd_device *skip_virtio(sd_device *dev) {
+        sd_device *parent;
+
         /* there can only ever be one virtio bus per parent device, so we can
          * safely ignore any virtio buses. see
          * http://lists.linuxfoundation.org/pipermail/virtualization/2015-August/030331.html */
-        while (dev) {
+        for (parent = dev; parent; ) {
                 const char *subsystem;
 
-                if (sd_device_get_subsystem(dev, &subsystem) < 0)
+                if (sd_device_get_subsystem(parent, &subsystem) < 0)
                         break;
 
                 if (!streq(subsystem, "virtio"))
                         break;
 
-                if (sd_device_get_parent(dev, &dev) < 0)
+                if (sd_device_get_parent(parent, &parent) < 0)
                         return NULL;
         }
 
-        return dev;
+        return parent;
 }
 
 static int get_virtfn_info(sd_device *dev, struct netnames *names, struct virtfn_info *ret) {

src/udev/udev-builtin-path_id.c

@@ -80,19 +80,22 @@ static int format_lun_number(sd_device *dev, char **path) {
 }
 
 static sd_device *skip_subsystem(sd_device *dev, const char *subsys) {
+        sd_device *parent;
+
         assert(dev);
         assert(subsys);
 
-        for (;;) {
+        for (parent = dev; ; ) {
                 const char *subsystem;
 
-                if (sd_device_get_subsystem(dev, &subsystem) < 0)
+                if (sd_device_get_subsystem(parent, &subsystem) < 0)
                         break;
 
                 if (!streq(subsystem, subsys))
                         break;
 
-                if (sd_device_get_parent(dev, &dev) < 0)
+                dev = parent;
+                if (sd_device_get_parent(dev, &parent) < 0)
                         break;
         }
 
@@ -375,6 +378,7 @@ static sd_device *handle_scsi_hyperv(sd_device *parent, char **path, size_t guid
         const char *guid_str;
         _cleanup_free_ char *lun = NULL;
         char guid[39];
+        size_t i, k;
 
         assert(parent);
         assert(path);
@@ -392,8 +396,7 @@ static sd_device *handle_scsi_hyperv(sd_device *parent, char **path, size_t guid
         if (strlen(guid_str) < guid_str_len || guid_str[0] != '{' || guid_str[guid_str_len-1] != '}')
                 return NULL;
 
-        size_t k = 0;
+        for (i = 1, k = 0; i < guid_str_len-1; i++) {
-        for (size_t i = 1; i < guid_str_len-1; i++) {
                 if (guid_str[i] == '-')
                         continue;
                 guid[k++] = guid_str[i];
@@ -678,10 +681,11 @@ static int builtin_path_id(sd_device *dev, int argc, char *argv[], bool test) {
 
         {
                 char tag[UDEV_NAME_SIZE];
-                size_t i = 0;
+                size_t i;
+                const char *p;
 
                 /* compose valid udev tag name */
-                for (const char *p = path; *p; p++) {
+                for (p = path, i = 0; *p; p++) {
                         if ((*p >= '0' && *p <= '9') ||
                             (*p >= 'A' && *p <= 'Z') ||
                             (*p >= 'a' && *p <= 'z') ||

src/udev/udev-builtin-usb_id.c

@@ -405,8 +405,10 @@ fallback:
                 const char *usb_serial;
 
                 if (sd_device_get_sysattr_value(dev_usb, "serial", &usb_serial) >= 0) {
+                        const unsigned char *p;
+
                         /* http://msdn.microsoft.com/en-us/library/windows/hardware/gg487321.aspx */
-                        for (const unsigned char *p = (unsigned char*) usb_serial; *p != '\0'; p++)
+                        for (p = (unsigned char *) usb_serial; *p != '\0'; p++)
                                 if (*p < 0x20 || *p > 0x7f || *p == ',') {
                                         usb_serial = NULL;
                                         break;