corrected code style errors

- add missing brackets around one-line statements
- add paretheses around return values

diff --git a/bin/dig/dig.c b/bin/dig/dig.c
index 93fa103216e89c4f0d906f3d9dc0b6a2ae13c500..89918f17b606dd35c64c818427391ec39f999c11 100644 (file)
--- a/bin/dig/dig.c
+++ b/bin/dig/dig.c
@@ -1500,9 +1500,9 @@ plus_tls_options(const char *cmd, const char *value, const bool state,
                goto invalid_option;
        }
 
-       return true;
+       return (true);
 invalid_option:
-       return false;
+       return (false);
 }
 
 /*%

diff --git a/fuzz/dns_master_load.c b/fuzz/dns_master_load.c
index 29e83dfc1e8dac5aa6c45672d0a50f13c004ba89..75dd0bc96669fddf8b99daf4d7cb90a9a2686479 100644 (file)
--- a/fuzz/dns_master_load.c
+++ b/fuzz/dns_master_load.c
@@ -53,7 +53,7 @@ LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
                               dns_dbtype_zone, dns_rdataclass_in, 0, NULL,
                               &db);
        if (result != ISC_R_SUCCESS) {
-               return 0;
+               return (0);
        }
 
        result = dns_db_beginload(db, &callbacks);

diff --git a/fuzz/fuzz.h b/fuzz/fuzz.h
index 49ad08fd6e61e1807d51977dcaffe9a37293d568..b34c6a26d7267cfd39b1cd1a1161170e748dd05f 100644 (file)
--- a/fuzz/fuzz.h
+++ b/fuzz/fuzz.h
@@ -38,7 +38,7 @@ LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
 
 #define CHECK(x)                    \
        if ((x) != ISC_R_SUCCESS) { \
-               return 0;           \
+               return (0);         \
        }
 
 ISC_LANG_ENDDECLS

diff --git a/fuzz/main.c b/fuzz/main.c
index 4bfc66e1c66c112d4c8c61f604be4ada9ea68a33..861987146bebe664d5fc078a06e051a074f2d691 100644 (file)
--- a/fuzz/main.c
+++ b/fuzz/main.c
@@ -101,7 +101,7 @@ main(int argc, char **argv) {
        ret = LLVMFuzzerInitialize(&argc, &argv);
        if (ret != 0) {
                fprintf(stderr, "LLVMFuzzerInitialize failure: %d\n", ret);
-               return 1;
+               return (1);
        }
 
        if (argv[1] != NULL && strcmp(argv[1], "-d") == 0) {
@@ -142,7 +142,7 @@ main(int argc, char **argv) {
        LLVMFuzzerInitialize(&argc, &argv);
        if (ret != 0) {
                fprintf(stderr, "LLVMFuzzerInitialize failure: %d\n", ret);
-               return 1;
+               return (1);
        }
 
 #ifdef __AFL_LOOP

diff --git a/lib/dns/compress.c b/lib/dns/compress.c
index 8951c4945faeeb088301d4165250402ad4adafc8..233a5af8665316b3c2d5e233b1ffe5cd71916785 100644 (file)
--- a/lib/dns/compress.c
+++ b/lib/dns/compress.c
@@ -227,7 +227,7 @@ insert_label(dns_compress_t *cctx, isc_buffer_t *buffer, const dns_name_t *name,
        unsigned int prefix_len = name->offsets[label];
        unsigned int coff = isc_buffer_usedlength(buffer) + prefix_len;
        if (coff >= 0x4000 || cctx->count > cctx->mask * 3 / 4) {
-               return false;
+               return (false);
        }
        for (;;) {
                unsigned int slot = slot_index(cctx, hash, probe);
@@ -236,7 +236,7 @@ insert_label(dns_compress_t *cctx, isc_buffer_t *buffer, const dns_name_t *name,
                        cctx->set[slot].hash = hash;
                        cctx->set[slot].coff = coff;
                        cctx->count++;
-                       return true;
+                       return (true);
                }
                /* he steals from the rich and gives to the poor */
                if (probe > probe_distance(cctx, slot)) {

diff --git a/lib/dns/kasp.c b/lib/dns/kasp.c
index 285ae0bb7f185fa57a70c80105bd7bc3ebf159f0..8a03a45cda175633bed778bd730a99756f2bb7da 100644 (file)
--- a/lib/dns/kasp.c
+++ b/lib/dns/kasp.c
@@ -593,7 +593,7 @@ dns_kasp_nsec3(dns_kasp_t *kasp) {
        REQUIRE(kasp != NULL);
        REQUIRE(kasp->frozen);
 
-       return kasp->nsec3;
+       return (kasp->nsec3);
 }
 
 void
@@ -621,7 +621,7 @@ dns_kasp_offlineksk(dns_kasp_t *kasp) {
        REQUIRE(kasp != NULL);
        REQUIRE(kasp->frozen);
 
-       return kasp->offlineksk;
+       return (kasp->offlineksk);
 }
 
 void
@@ -637,7 +637,7 @@ dns_kasp_cdnskey(dns_kasp_t *kasp) {
        REQUIRE(kasp != NULL);
        REQUIRE(kasp->frozen);
 
-       return kasp->cdnskey;
+       return (kasp->cdnskey);
 }
 
 void

diff --git a/lib/dns/keystore.c b/lib/dns/keystore.c
index 1d895bc350f16df7b1974397cff9e7f6bc48f2ef..275ca8d4456c61793ddead28d73f9e4f79b4959a 100644 (file)
--- a/lib/dns/keystore.c
+++ b/lib/dns/keystore.c
@@ -172,7 +172,7 @@ buildpkcs11label(const char *uri, const dns_name_t *zname, const char *policy,
        }
        /* key type + current time */
        isc_time_formatshorttimestamp(&now, timebuf, sizeof(timebuf));
-       return isc_buffer_printf(buf, "-%s-%s", ksk ? "ksk" : "zsk", timebuf);
+       return (isc_buffer_printf(buf, "-%s-%s", ksk ? "ksk" : "zsk", timebuf));
 }
 
 isc_result_t

diff --git a/lib/dns/name.c b/lib/dns/name.c
index 03f12433c7bf8e86713d34525115b54cbaf8cbce..4c1390e7193a8587d531b02ec3c6a1690313e9e5 100644 (file)
--- a/lib/dns/name.c
+++ b/lib/dns/name.c
@@ -170,7 +170,7 @@ dns_name_isabsolute(const dns_name_t *name) {
 
        REQUIRE(DNS_NAME_VALID(name));
 
-       return name->attributes.absolute;
+       return (name->attributes.absolute);
 }
 
 #define hyphenchar(c) ((c) == 0x2d)

diff --git a/lib/dns/opensslecdsa_link.c b/lib/dns/opensslecdsa_link.c
index 7e0c4360b4c1491bfda82d4bf5e5afcb77580019..09bfb6dd27289a996a30b6b4f50cc210c58afc74 100644 (file)
--- a/lib/dns/opensslecdsa_link.c
+++ b/lib/dns/opensslecdsa_link.c
@@ -79,11 +79,11 @@ opensslecdsa_set_deterministic(EVP_PKEY_CTX *pctx, unsigned int key_alg) {
        params[2] = OSSL_PARAM_construct_end();
 
        if (EVP_PKEY_CTX_set_params(pctx, params) != 1) {
-               return dst__openssl_toresult2("EVP_PKEY_CTX_set_params",
-                                             DST_R_OPENSSLFAILURE);
+               return (dst__openssl_toresult2("EVP_PKEY_CTX_set_params",
+                                              DST_R_OPENSSLFAILURE));
        }
 
-       return ISC_R_SUCCESS;
+       return (ISC_R_SUCCESS);
 }
 #endif /* OPENSSL_VERSION_NUMBER >= 0x30200000L */
 

diff --git a/lib/dns/openssleddsa_link.c b/lib/dns/openssleddsa_link.c
index ffd298bfd11cb833b71b82a64fa390b733c45323..c666c0349a1e06ac60f8b131749bceddb2f800d0 100644 (file)
--- a/lib/dns/openssleddsa_link.c
+++ b/lib/dns/openssleddsa_link.c
@@ -63,7 +63,7 @@ openssleddsa_alg_info(unsigned int key_alg) {
                        .key_size = DNS_KEY_ED25519SIZE,
                        .sig_size = DNS_SIG_ED25519SIZE,
                };
-               return &ed25519_alginfo;
+               return (&ed25519_alginfo);
        }
 #if HAVE_OPENSSL_ED448
        if (key_alg == DST_ALG_ED448) {
@@ -73,10 +73,10 @@ openssleddsa_alg_info(unsigned int key_alg) {
                        .key_size = DNS_KEY_ED448SIZE,
                        .sig_size = DNS_SIG_ED448SIZE,
                };
-               return &ed448_alginfo;
+               return (&ed448_alginfo);
        }
 #endif /* HAVE_OPENSSL_ED448 */
-       return NULL;
+       return (NULL);
 }
 
 static isc_result_t
@@ -344,7 +344,7 @@ openssleddsa_fromdns(dst_key_t *key, isc_buffer_t *data) {
        len = r.length;
        ret = raw_key_to_ossl(alginfo, 0, r.base, &len, &pkey);
        if (ret != ISC_R_SUCCESS) {
-               return ret;
+               return (ret);
        }
 
        isc_buffer_forward(data, len);

diff --git a/lib/dns/transport.c b/lib/dns/transport.c
index 52bb6bce39fb21bcb42a9b3bd573f86e30ef3642..b647d1b76c715bfd7825e0da4e40a8e71155104a 100644 (file)
--- a/lib/dns/transport.c
+++ b/lib/dns/transport.c
@@ -358,7 +358,7 @@ dns_transport_get_prefer_server_ciphers(const dns_transport_t *transport,
        }
 
        UNREACHABLE();
-       return false;
+       return (false);
 }
 
 void
@@ -377,7 +377,7 @@ dns_transport_get_always_verify_remote(dns_transport_t *transport) {
        REQUIRE(transport->type == DNS_TRANSPORT_TLS ||
                transport->type == DNS_TRANSPORT_HTTP);
 
-       return transport->tls.always_verify_remote;
+       return (transport->tls.always_verify_remote);
 }
 
 isc_result_t

diff --git a/lib/dns/xfrin.c b/lib/dns/xfrin.c
index 99599b8772ba05bb9e06f867b0aad1faccd26e9d..76d04a848020cded43d05cd092febd8b7de15c48 100644 (file)
--- a/lib/dns/xfrin.c
+++ b/lib/dns/xfrin.c
@@ -1448,11 +1448,11 @@ static const char *
 request_type(dns_xfrin_t *xfr) {
        switch (xfr->reqtype) {
        case dns_rdatatype_soa:
-               return "SOA";
+               return ("SOA");
        case dns_rdatatype_axfr:
-               return "AXFR";
+               return ("AXFR");
        case dns_rdatatype_ixfr:
-               return "IXFR";
+               return ("IXFR");
        default:
                ISC_UNREACHABLE();
        }

diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index ada88d4608000458f0ff9ff74b0ae1c84df9a961..ed5763654f9822fb6654f4fa9ddc65e7f62d2752 100644 (file)
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -20724,7 +20724,7 @@ do_checkds(dns_zone_t *zone, dst_key_t *key, isc_stdtime_t now,
                             count, dst_key_id(key));
 
                if (count != num) {
-                       return false;
+                       return (false);
                }
        } else {
                (void)dst_key_getnum(key, DST_NUM_DSDELCOUNT, &count);
@@ -20736,7 +20736,7 @@ do_checkds(dns_zone_t *zone, dst_key_t *key, isc_stdtime_t now,
                             count, dst_key_id(key));
 
                if (count != num) {
-                       return false;
+                       return (false);
                }
        }
 
@@ -20755,10 +20755,10 @@ do_checkds(dns_zone_t *zone, dst_key_t *key, isc_stdtime_t now,
                dns_zone_log(zone, ISC_LOG_WARNING,
                             "checkds: checkds for key %u failed: %s",
                             dst_key_id(key), isc_result_totext(result));
-               return false;
+               return (false);
        }
 
-       return true;
+       return (true);
 }
 
 static isc_result_t

diff --git a/lib/isc/netmgr/http.c b/lib/isc/netmgr/http.c
index 2ebf9055ddbc6295dc2617121b49e1e42c2b68bb..8927bf31a1c100020fa490f1a036e99eb04e0d7b 100644 (file)
--- a/lib/isc/netmgr/http.c
+++ b/lib/isc/netmgr/http.c
@@ -2583,7 +2583,7 @@ isc_nm_http_endpoints_new(isc_mem_t *mctx) {
        atomic_init(&eps->in_use, false);
        eps->magic = HTTP_ENDPOINTS_MAGIC;
 
-       return eps;
+       return (eps);
 }
 
 void

diff --git a/lib/isc/picohttpparser.c b/lib/isc/picohttpparser.c
index 59f5ff1a180e32ae342d5ecce63a3d6ebf4c7926..593e09991c375b1178eb37a1be59a3fbf280c4b7 100644 (file)
--- a/lib/isc/picohttpparser.c
+++ b/lib/isc/picohttpparser.c
@@ -54,16 +54,16 @@
 
 #define IS_PRINTABLE_ASCII(c) ((unsigned char)(c) - 040u < 0137u)
 
-#define CHECK_EOF()           \
-       if (buf == buf_end) { \
-               *ret = -2;    \
-               return NULL;  \
+#define CHECK_EOF()            \
+       if (buf == buf_end) {  \
+               *ret = -2;     \
+               return (NULL); \
        }
 
 #define EXPECT_CHAR_NO_CHECK(ch) \
        if (*buf++ != ch) {      \
                *ret = -1;       \
-               return NULL;     \
+               return (NULL);   \
        }
 
 #define EXPECT_CHAR(ch) \
@@ -88,7 +88,7 @@
                                    *buf == '\177')                       \
                                {                                         \
                                        *ret = -1;                        \
-                                       return NULL;                      \
+                                       return (NULL);                    \
                                }                                         \
                        }                                                 \
                        ++buf;                                            \
@@ -138,7 +138,7 @@ findchar_fast(const char *buf, const char *buf_end, const char *ranges,
        (void)ranges;
        (void)ranges_size;
 #endif
-       return buf;
+       return (buf);
 }
 
 static const char *
@@ -207,11 +207,11 @@ FOUND_CTL:
                ++buf;
        } else {
                *ret = -1;
-               return NULL;
+               return (NULL);
        }
        *token = token_start;
 
-       return buf;
+       return (buf);
 }
 
 static const char *
@@ -234,19 +234,19 @@ is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret) {
                        ret_cnt = 0;
                }
                if (ret_cnt == 2) {
-                       return buf;
+                       return (buf);
                }
        }
 
        *ret = -2;
-       return NULL;
+       return (NULL);
 }
 
 #define PARSE_INT(valp_, mul_)          \
        if (*buf < '0' || '9' < *buf) { \
                buf++;                  \
                *ret = -1;              \
-               return NULL;            \
+               return (NULL);          \
        }                               \
        *(valp_) = (mul_) * (*buf++ - '0');
 
@@ -289,14 +289,14 @@ parse_token(const char *buf, const char *buf_end, const char **token,
                        break;
                } else if (!token_char_map[(unsigned char)*buf]) {
                        *ret = -1;
-                       return NULL;
+                       return (NULL);
                }
                ++buf;
                CHECK_EOF();
        }
        *token = buf_start;
        *token_len = buf - buf_start;
-       return buf;
+       return (buf);
 }
 
 /* returned pointer is always within [buf, buf_end), or null */
@@ -306,7 +306,7 @@ parse_http_version(const char *buf, const char *buf_end, int *minor_version,
        /* we want at least [HTTP/1.<two chars>] to try to parse */
        if (buf_end - buf < 9) {
                *ret = -2;
-               return NULL;
+               return (NULL);
        }
        EXPECT_CHAR_NO_CHECK('H');
        EXPECT_CHAR_NO_CHECK('T');
@@ -316,7 +316,7 @@ parse_http_version(const char *buf, const char *buf_end, int *minor_version,
        EXPECT_CHAR_NO_CHECK('1');
        EXPECT_CHAR_NO_CHECK('.');
        PARSE_INT(minor_version, 1);
-       return buf;
+       return (buf);
 }
 
 static const char *
@@ -334,7 +334,7 @@ parse_headers(const char *buf, const char *buf_end, struct phr_header *headers,
                }
                if (*num_headers == max_headers) {
                        *ret = -1;
-                       return NULL;
+                       return (NULL);
                }
                if (!(*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) {
                        /* parsing name, but do not discard SP before colon, see
@@ -345,11 +345,11 @@ parse_headers(const char *buf, const char *buf_end, struct phr_header *headers,
                                               &headers[*num_headers].name_len,
                                               ':', ret)) == NULL)
                        {
-                               return NULL;
+                               return (NULL);
                        }
                        if (headers[*num_headers].name_len == 0) {
                                *ret = -1;
-                               return NULL;
+                               return (NULL);
                        }
                        ++buf;
                        for (;; ++buf) {
@@ -367,7 +367,7 @@ parse_headers(const char *buf, const char *buf_end, struct phr_header *headers,
                if ((buf = get_token_to_eol(buf, buf_end, &value, &value_len,
                                            ret)) == NULL)
                {
-                       return NULL;
+                       return (NULL);
                }
                /* remove trailing SPs and HTABs */
                const char *value_end = value + value_len;
@@ -380,7 +380,7 @@ parse_headers(const char *buf, const char *buf_end, struct phr_header *headers,
                headers[*num_headers].value = value;
                headers[*num_headers].value_len = value_end - value;
        }
-       return buf;
+       return (buf);
 }
 
 static const char *
@@ -401,7 +401,7 @@ parse_request(const char *buf, const char *buf_end, const char **method,
        if ((buf = parse_token(buf, buf_end, method, method_len, ' ', ret)) ==
            NULL)
        {
-               return NULL;
+               return (NULL);
        }
        do {
                ++buf;
@@ -414,12 +414,12 @@ parse_request(const char *buf, const char *buf_end, const char **method,
        } while (*buf == ' ');
        if (*method_len == 0 || *path_len == 0) {
                *ret = -1;
-               return NULL;
+               return (NULL);
        }
        if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) ==
            NULL)
        {
-               return NULL;
+               return (NULL);
        }
        if (*buf == '\015') {
                ++buf;
@@ -428,11 +428,11 @@ parse_request(const char *buf, const char *buf_end, const char **method,
                ++buf;
        } else {
                *ret = -1;
-               return NULL;
+               return (NULL);
        }
 
-       return parse_headers(buf, buf_end, headers, num_headers, max_headers,
-                            ret);
+       return (parse_headers(buf, buf_end, headers, num_headers, max_headers,
+                             ret));
 }
 
 int
@@ -454,14 +454,14 @@ phr_parse_request(const char *buf_start, size_t len, const char **method,
        /* if last_len != 0, check if the request is complete (a fast
           countermeasure againt slowloris */
        if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-               return r;
+               return (r);
        }
 
        if ((buf = parse_request(buf, buf_end, method, method_len, path,
                                 path_len, minor_version, headers, num_headers,
                                 max_headers, &r)) == NULL)
        {
-               return r;
+               return (r);
        }
 
        return (int)(buf - buf_start);
@@ -476,12 +476,12 @@ parse_response(const char *buf, const char *buf_end, int *minor_version,
        if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) ==
            NULL)
        {
-               return NULL;
+               return (NULL);
        }
        /* skip space */
        if (*buf != ' ') {
                *ret = -1;
-               return NULL;
+               return (NULL);
        }
        do {
                ++buf;
@@ -491,13 +491,13 @@ parse_response(const char *buf, const char *buf_end, int *minor_version,
         * char> to try to parse */
        if (buf_end - buf < 4) {
                *ret = -2;
-               return NULL;
+               return (NULL);
        }
        PARSE_INT_3(status);
 
        /* get message including preceding space */
        if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) {
-               return NULL;
+               return (NULL);
        }
        if (*msg_len == 0) {
                /* ok */
@@ -513,11 +513,11 @@ parse_response(const char *buf, const char *buf_end, int *minor_version,
        } else {
                /* garbage found after status code */
                *ret = -1;
-               return NULL;
+               return (NULL);
        }
 
-       return parse_headers(buf, buf_end, headers, num_headers, max_headers,
-                            ret);
+       return (parse_headers(buf, buf_end, headers, num_headers, max_headers,
+                             ret));
 }
 
 int
@@ -538,14 +538,14 @@ phr_parse_response(const char *buf_start, size_t len, int *minor_version,
        /* if last_len != 0, check if the response is complete (a fast
           countermeasure against slowloris */
        if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-               return r;
+               return (r);
        }
 
        if ((buf = parse_response(buf, buf_end, minor_version, status, msg,
                                  msg_len, headers, num_headers, max_headers,
                                  &r)) == NULL)
        {
-               return r;
+               return (r);
        }
 
        return (int)(buf - buf_start);
@@ -563,13 +563,13 @@ phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers,
        /* if last_len != 0, check if the response is complete (a fast
           countermeasure against slowloris */
        if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-               return r;
+               return (r);
        }
 
        if ((buf = parse_headers(buf, buf_end, headers, num_headers,
                                 max_headers, &r)) == NULL)
        {
-               return r;
+               return (r);
        }
 
        return (int)(buf - buf_start);
@@ -587,13 +587,13 @@ enum {
 static int
 decode_hex(int ch) {
        if ('0' <= ch && ch <= '9') {
-               return ch - '0';
+               return (ch - '0');
        } else if ('A' <= ch && ch <= 'F') {
-               return ch - 'A' + 0xa;
+               return (ch - 'A' + 0xa);
        } else if ('a' <= ch && ch <= 'f') {
-               return ch - 'a' + 0xa;
+               return (ch - 'a' + 0xa);
        } else {
-               return -1;
+               return (-1);
        }
 }
 
@@ -608,8 +608,9 @@ phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf,
                case CHUNKED_IN_CHUNK_SIZE:
                        for (;; ++src) {
                                int v;
-                               if (src == bufsz)
+                               if (src == bufsz) {
                                        goto Exit;
+                               }
                                if ((v = decode_hex(buf[src])) == -1) {
                                        if (decoder->_hex_count == 0) {
                                                ret = -1;
@@ -632,10 +633,12 @@ phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf,
                        /* RFC 7230 A.2 "Line folding in chunk extensions is
                         * disallowed" */
                        for (;; ++src) {
-                               if (src == bufsz)
+                               if (src == bufsz) {
                                        goto Exit;
-                               if (buf[src] == '\012')
+                               }
+                               if (buf[src] == '\012') {
                                        break;
+                               }
                        }
                        ++src;
                        if (decoder->bytes_left_in_chunk == 0) {
@@ -652,16 +655,18 @@ phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf,
                case CHUNKED_IN_CHUNK_DATA: {
                        size_t avail = bufsz - src;
                        if (avail < decoder->bytes_left_in_chunk) {
-                               if (dst != src)
+                               if (dst != src) {
                                        memmove(buf + dst, buf + src, avail);
+                               }
                                src += avail;
                                dst += avail;
                                decoder->bytes_left_in_chunk -= avail;
                                goto Exit;
                        }
-                       if (dst != src)
+                       if (dst != src) {
                                memmove(buf + dst, buf + src,
                                        decoder->bytes_left_in_chunk);
+                       }
                        src += decoder->bytes_left_in_chunk;
                        dst += decoder->bytes_left_in_chunk;
                        decoder->bytes_left_in_chunk = 0;
@@ -670,10 +675,12 @@ phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf,
                /* fallthru */
                case CHUNKED_IN_CHUNK_CRLF:
                        for (;; ++src) {
-                               if (src == bufsz)
+                               if (src == bufsz) {
                                        goto Exit;
-                               if (buf[src] != '\015')
+                               }
+                               if (buf[src] != '\015') {
                                        break;
+                               }
                        }
                        if (buf[src] != '\012') {
                                ret = -1;
@@ -684,21 +691,26 @@ phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf,
                        break;
                case CHUNKED_IN_TRAILERS_LINE_HEAD:
                        for (;; ++src) {
-                               if (src == bufsz)
+                               if (src == bufsz) {
                                        goto Exit;
-                               if (buf[src] != '\015')
+                               }
+                               if (buf[src] != '\015') {
                                        break;
+                               }
                        }
-                       if (buf[src++] == '\012')
+                       if (buf[src++] == '\012') {
                                goto Complete;
+                       }
                        decoder->_state = CHUNKED_IN_TRAILERS_LINE_MIDDLE;
                /* fallthru */
                case CHUNKED_IN_TRAILERS_LINE_MIDDLE:
                        for (;; ++src) {
-                               if (src == bufsz)
+                               if (src == bufsz) {
                                        goto Exit;
-                               if (buf[src] == '\012')
+                               }
+                               if (buf[src] == '\012') {
                                        break;
+                               }
                        }
                        ++src;
                        decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
@@ -711,15 +723,16 @@ phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf,
 Complete:
        ret = bufsz - src;
 Exit:
-       if (dst != src)
+       if (dst != src) {
                memmove(buf + dst, buf + src, bufsz - src);
+       }
        *_bufsz = dst;
-       return ret;
+       return (ret);
 }
 
 int
 phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder) {
-       return decoder->_state == CHUNKED_IN_CHUNK_DATA;
+       return (decoder->_state == CHUNKED_IN_CHUNK_DATA);
 }
 
 #undef CHECK_EOF

diff --git a/lib/isc/string.c b/lib/isc/string.c
index 7603ac2b25e0c22ee52c6b3f82adb8c77681f1d9..e6a9ad822ebc4239ab7cb090d092a0e636c5ceb4 100644 (file)
--- a/lib/isc/string.c
+++ b/lib/isc/string.c
@@ -133,11 +133,13 @@ strnstr(const char *s, const char *find, size_t slen) {
                len = strlen(find);
                do {
                        do {
-                               if (slen-- < 1 || (sc = *s++) == '\0')
+                               if (slen-- < 1 || (sc = *s++) == '\0') {
                                        return (NULL);
+                               }
                        } while (sc != c);
-                       if (len > slen)
+                       if (len > slen) {
                                return (NULL);
+                       }
                } while (strncmp(s, find, len) != 0);
                s--;
        }

diff --git a/lib/isccc/ccmsg.c b/lib/isccc/ccmsg.c
index d964a8f123f28138488b387b081d0a9c1041bb2d..a883455a66725b9cbfc32d45828de4d967ffdd3b 100644 (file)
--- a/lib/isccc/ccmsg.c
+++ b/lib/isccc/ccmsg.c
@@ -53,22 +53,22 @@ try_parse_message(isccc_ccmsg_t *ccmsg) {
 
        uint32_t len = 0;
        if (isc_buffer_peekuint32(ccmsg->buffer, &len) != ISC_R_SUCCESS) {
-               return ISC_R_NOMORE;
+               return (ISC_R_NOMORE);
        }
        if (len == 0) {
-               return ISC_R_UNEXPECTEDEND;
+               return (ISC_R_UNEXPECTEDEND);
        }
        if (len > ccmsg->maxsize) {
-               return ISC_R_RANGE;
+               return (ISC_R_RANGE);
        }
        if (isc_buffer_remaininglength(ccmsg->buffer) < sizeof(uint32_t) + len)
        {
-               return ISC_R_NOMORE;
+               return (ISC_R_NOMORE);
        }
        /* Skip the size we just peeked */
        isc_buffer_forward(ccmsg->buffer, sizeof(uint32_t));
        ccmsg->size = len;
-       return ISC_R_SUCCESS;
+       return (ISC_R_SUCCESS);
 }
 
 static void

diff --git a/lib/isccfg/parser.c b/lib/isccfg/parser.c
index c4598a7fd33fd3b29735c23a3839d8ab1f077727..c735d074a4fe42be0789dc3150598303a75c4196 100644 (file)
--- a/lib/isccfg/parser.c
+++ b/lib/isccfg/parser.c
@@ -1144,7 +1144,7 @@ cfg_obj_isduration(const cfg_obj_t *obj) {
 uint32_t
 cfg_obj_asduration(const cfg_obj_t *obj) {
        REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_duration);
-       return isccfg_duration_toseconds(&(obj->value.duration));
+       return (isccfg_duration_toseconds(&(obj->value.duration)));
 }
 
 static isc_result_t

diff --git a/lib/ns/client.c b/lib/ns/client.c
index 76293eda453e0ff9ba6c90d8d2e383c5f9160a36..df20be335b3328d445c787c8c7dea52103f9835b 100644 (file)
--- a/lib/ns/client.c
+++ b/lib/ns/client.c
@@ -149,7 +149,7 @@ ns_client_transport_type(const ns_client_t *client) {
         * When DoQ support this had to be removed to get correct DoQ entries.
         */
        if (!TCP_CLIENT(client)) {
-               return DNS_TRANSPORT_UDP;
+               return (DNS_TRANSPORT_UDP);
        }
 
        INSIST(client->handle != NULL);
@@ -159,31 +159,31 @@ ns_client_transport_type(const ns_client_t *client) {
        case isc_nm_udplistener:
        case isc_nm_proxyudpsocket:
        case isc_nm_proxyudplistener:
-               return DNS_TRANSPORT_UDP;
+               return (DNS_TRANSPORT_UDP);
        case isc_nm_tlssocket:
        case isc_nm_tlslistener:
-               return DNS_TRANSPORT_TLS;
+               return (DNS_TRANSPORT_TLS);
        case isc_nm_httpsocket:
        case isc_nm_httplistener:
-               return DNS_TRANSPORT_HTTP;
+               return (DNS_TRANSPORT_HTTP);
        case isc_nm_streamdnslistener:
        case isc_nm_streamdnssocket:
        case isc_nm_proxystreamlistener:
        case isc_nm_proxystreamsocket:
                /* If it isn't DoT, it is DNS-over-TCP */
                if (isc_nm_has_encryption(client->handle)) {
-                       return DNS_TRANSPORT_TLS;
+                       return (DNS_TRANSPORT_TLS);
                }
                FALLTHROUGH;
        case isc_nm_tcpsocket:
        case isc_nm_tcplistener:
-               return DNS_TRANSPORT_TCP;
+               return (DNS_TRANSPORT_TCP);
        case isc_nm_maxsocket:
        case isc_nm_nonesocket:
                UNREACHABLE();
        }
 
-       return DNS_TRANSPORT_UDP;
+       return (DNS_TRANSPORT_UDP);
 }
 
 void

diff --git a/lib/ns/listenlist.c b/lib/ns/listenlist.c
index 8e04c4f2ac1d7e5fdac65f1b34864c60248f99fb..6e66fbe12243ab0fc109fe9c234c66f830e3aca0 100644 (file)
--- a/lib/ns/listenlist.c
+++ b/lib/ns/listenlist.c
@@ -218,8 +218,8 @@ ns_listenelt_create(isc_mem_t *mctx, in_port_t port, dns_acl_t *acl,
                    const ns_listen_tls_params_t *tls_params,
                    isc_tlsctx_cache_t *tlsctx_cache, isc_nm_proxy_type_t proxy,
                    ns_listenelt_t **target) {
-       return listenelt_create(mctx, port, acl, family, false, tls, tls_params,
-                               tlsctx_cache, proxy, target);
+       return (listenelt_create(mctx, port, acl, family, false, tls,
+                                tls_params, tlsctx_cache, proxy, target));
 }
 
 isc_result_t

diff --git a/lib/ns/query.c b/lib/ns/query.c
index 94d0859afa8f54779efacca3ba33981e2594c421..107c6ef23c47e1ff29c3c0da4a12036ebbb9d11c 100644 (file)
--- a/lib/ns/query.c
+++ b/lib/ns/query.c
@@ -609,8 +609,9 @@ log_response(ns_client_t *client, dns_rcode_t rcode) {
        isc_buffer_t b;
        int level = ISC_LOG_INFO;
 
-       if (!isc_log_wouldlog(level))
+       if (!isc_log_wouldlog(level)) {
                return;
+       }
 
        dns_name_format(client->query.origqname, namebuf, sizeof(namebuf));
        dns_rdataclass_format(client->message->rdclass, classbuf,

diff --git a/tests/bench/ascii.c b/tests/bench/ascii.c
index e2123cb294f7eea79e8bf13c76d47975a390eb88..2899b53b559ed239798810d5a8e0f89fd63ce2bc 100644 (file)
--- a/tests/bench/ascii.c
+++ b/tests/bench/ascii.c
@@ -70,10 +70,10 @@ static bool
 cmp_tolower1(void *va, void *vb, unsigned int size) {
        for (uint8_t *a = va, *b = vb; size-- > 0; a++, b++) {
                if (TOLOWER(*a) != TOLOWER(*b)) {
-                       return false;
+                       return (false);
                }
        }
-       return true;
+       return (true);
 }
 
 static bool oldskool_result;

diff --git a/tests/bench/qpmulti.c b/tests/bench/qpmulti.c
index 6e0a544eee83337ff7e05a25a0ec39c2df69c7e8..a72b4c6161d0df80f4464aad3964c583466a0815 100644 (file)
--- a/tests/bench/qpmulti.c
+++ b/tests/bench/qpmulti.c
@@ -77,7 +77,7 @@ rand_zipf(uint32_t max, double skew) {
                double ratio = sample <= 1 ? pow(sample, -s)
                                           : pow(sample, -s) / pow(invB, -s);
                if (ratio > (double)isc_random32() / UINT32_MAX) {
-                       return sample - 1;
+                       return (sample - 1);
                }
        }
 }

diff --git a/tests/irs/resconf_test.c b/tests/irs/resconf_test.c
index 367898f8c2a164795e9410c01ec755d1ea964eb9..770e980feb40b3aef4bd05c82e414a465cbba8a3 100644 (file)
--- a/tests/irs/resconf_test.c
+++ b/tests/irs/resconf_test.c
@@ -68,15 +68,15 @@ check_ndots(irs_resconf_t *resconf) {
 static isc_result_t
 check_options(irs_resconf_t *resconf) {
        if (irs_resconf_getattempts(resconf) != 3) {
-               return ISC_R_BADNUMBER; /* default value only */
+               return (ISC_R_BADNUMBER); /* default value only */
        }
 
        if (irs_resconf_getndots(resconf) != 2) {
-               return ISC_R_BADNUMBER;
+               return (ISC_R_BADNUMBER);
        }
 
        if (irs_resconf_gettimeout(resconf) != 1) {
-               return ISC_R_BADNUMBER;
+               return (ISC_R_BADNUMBER);
        }
 
        return (ISC_R_SUCCESS);