Fix more magic numbers

diff --git a/src/lib/eap_aka_sim/encode.c b/src/lib/eap_aka_sim/encode.c
index af7669ba4817fa8248d4618848c1370bd76982b3..89a5a8680be48fda9856b9521bcff566ad8280f5 100644 (file)
--- a/src/lib/eap_aka_sim/encode.c
+++ b/src/lib/eap_aka_sim/encode.c
@@ -119,7 +119,7 @@ static ssize_t encode_iv(fr_dbuff_t *dbuff, void *encoder_ctx)
 
        memcpy(packet_ctx->iv, (uint8_t *)&iv[0], sizeof(packet_ctx->iv));      /* ensures alignment */
 
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_IV, (4 + AKA_SIM_IV_SIZE) >> 2, 0, 0);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_IV, (4 + AKA_SIM_IV_SIZE) >> 2, 0x00, 0x00);
        FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, packet_ctx->iv, sizeof(packet_ctx->iv));
 
        FR_PROTO_HEX_DUMP(fr_dbuff_start(&work_dbuff), fr_dbuff_used(&work_dbuff), "Initialisation vector");
@@ -366,7 +366,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
         *      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
        case FR_CHECKCODE:
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0, 0);    /* Reserved */
+               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0x00, 0x00);      /* Reserved */
                FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, vp->vp_octets, vp->vp_length);
                goto done;
 
@@ -460,7 +460,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
         *      +---------------+---------------+-------------------------------+
         */
        case FR_TYPE_BOOL:
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0, 0);
+               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0x00, 0x00);      /* reserved bytes */
                break;
 
        /*
@@ -666,7 +666,7 @@ static inline ssize_t encode_tlv_internal(fr_dbuff_t *dbuff,
        fr_pair_t const         *vp = fr_cursor_current(cursor);
        fr_dict_attr_t const    *da = da_stack->da[depth];
 
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0, 0);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0x00, 0x00);
 
        value_dbuff = FR_DBUFF_NO_ADVANCE(&work_dbuff);
        fr_dbuff_marker(&value_start, &value_dbuff);
@@ -924,13 +924,13 @@ ssize_t fr_aka_sim_encode(request_t *request, fr_pair_t *to_encode, void *encode
 
        fr_dbuff_init_talloc(NULL, &dbuff, &tctx, 512, 1024);
 
-       fr_dbuff_in_bytes(&dbuff, subtype, 0, 0);
+       fr_dbuff_in_bytes(&dbuff, subtype, 0x00, 0x00);
 
        /*
         *      Add space in the packet for AT_MAC
         */
        if (do_hmac) {
-               FR_DBUFF_IN_BYTES_RETURN(&dbuff, FR_MAC, AKA_SIM_MAC_SIZE >> 2, 0, 0);
+               FR_DBUFF_IN_BYTES_RETURN(&dbuff, FR_MAC, AKA_SIM_MAC_SIZE >> 2, 0x00, 0x00);
                fr_dbuff_marker(&hmac, &dbuff);
                FR_DBUFF_MEMSET_RETURN(&dbuff, 0, 16);
        }

diff --git a/src/protocols/dhcpv4/base.c b/src/protocols/dhcpv4/base.c
index 1788875c46c507cf2028f383d9bb762eca9274cb..e1c791e117968d717687076119dfb3df8de8dca3 100644 (file)
--- a/src/protocols/dhcpv4/base.c
+++ b/src/protocols/dhcpv4/base.c
@@ -324,9 +324,9 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
 
        vp = fr_pair_find_by_da(&vps, attr_dhcp_opcode);
        if (vp) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t) vp->vp_uint8);
+               FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t) vp->vp_uint8);
        } else {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 1);       /* client message */
+               FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t)0x01); /* client message */
        }
 
        /* DHCP-Hardware-Type */
@@ -338,31 +338,31 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
                FR_DBUFF_IN_RETURN(&work_dbuff, original->htype);
 
        } else { /* we are ALWAYS ethernet */
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 1);
+               FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t)0x01);
        }
 
        /* DHCP-Hardware-Address-len */
        vp = fr_pair_find_by_da(&vps, attr_dhcp_hardware_address_length);
        if (vp) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, vp->vp_uint8);
+               FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint8);
 
        } else if (original) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, original->hlen);
+               FR_DBUFF_IN_RETURN(&work_dbuff, original->hlen);
 
        } else { /* we are ALWAYS ethernet */
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 6);
+               FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t)0x06);
        }
 
        /* DHCP-Hop-Count */
        vp = fr_pair_find_by_da(&vps, attr_dhcp_hop_count);
        if (vp) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, vp->vp_uint8);
+               FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint8);
 
        } else if (original) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, original->hops);
+               FR_DBUFF_IN_RETURN(&work_dbuff, original->hops);
 
        } else {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0);
+               FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t)0x00);
        }
 
        /* DHCP-Transaction-Id */
@@ -373,7 +373,7 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
        if (vp) {
                FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint16);
        } else {
-               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, 2);
+               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, sizeof(vp->vp_uint16));
        }
 
        /* DHCP-Flags */
@@ -381,21 +381,21 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
        if (vp) {
                FR_DBUFF_IN_RETURN(&work_dbuff, vp->vp_uint16);
        } else {
-               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, 2);
+               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, sizeof(vp->vp_uint16));
        }
 
        /* DHCP-Client-IP-Address */
        vp = fr_pair_find_by_da(&vps, attr_dhcp_client_ip_address);
        if (vp) {
-               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, 4);
+               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
        } else {
-               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, 4);
+               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, sizeof(vp->vp_ipv4addr));
        }
 
        /* DHCP-Your-IP-address */
        vp = fr_pair_find_by_da(&vps, attr_dhcp_your_ip_address);
        if (vp) {
-               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, 4);
+               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
        } else {
                FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t) INADDR_ANY);
        }
@@ -403,7 +403,7 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
        /* DHCP-Server-IP-Address */
        vp = fr_pair_find_by_da(&vps, attr_dhcp_server_ip_address);
        if (vp) {
-               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, 4);
+               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
        } else {
                FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t) INADDR_ANY);
        }
@@ -413,7 +413,7 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
         */
        vp = fr_pair_find_by_da(&vps, attr_dhcp_gateway_ip_address);
        if (vp) {
-               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, 4);
+               FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
 
        } else if (original) {  /* copy whatever value was in the original */
                FR_DBUFF_IN_MEMCPY_RETURN(&work_dbuff, (uint8_t const *)&original->giaddr, sizeof(original->giaddr));
@@ -472,9 +472,9 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
        FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t) DHCP_OPTION_MAGIC_NUMBER);
 
        if ((vp = fr_pair_find_by_da(&vps, attr_dhcp_message_type))) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_DHCP_MESSAGE_TYPE, 1, vp->vp_uint8);
+               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_DHCP_MESSAGE_TYPE, 0x01, vp->vp_uint8);
        } else {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_DHCP_MESSAGE_TYPE, 1, (uint8_t) code);
+               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_DHCP_MESSAGE_TYPE, 0x01, (uint8_t)code);
        }
 
        /*
@@ -506,7 +506,7 @@ ssize_t fr_dhcpv4_encode_dbuff(fr_dbuff_t *dbuff, dhcp_packet_t *original, int c
                if (len <= 0) break;
        };
 
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_DHCP_END_OF_OPTIONS, 0);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_DHCP_END_OF_OPTIONS, 0x00);
 
        /*
         *      FIXME: if (fr_dbuff_used(&work_dbuff) > mms),

diff --git a/src/protocols/dhcpv6/base.c b/src/protocols/dhcpv6/base.c
index dc0d00a6941dacb44aaaaba846ed9c3cc7c23af9..dcb535d490e24f2a5e0def0a9602a66fa1617a3f 100644 (file)
--- a/src/protocols/dhcpv6/base.c
+++ b/src/protocols/dhcpv6/base.c
@@ -759,7 +759,7 @@ ssize_t     fr_dhcpv6_encode(fr_dbuff_t *dbuff, uint8_t const *original, size_t leng
                return -1;
        }
 
-       FR_DBUFF_IN_BYTES_RETURN(dbuff, (uint8_t) msg_type);
+       FR_DBUFF_IN_RETURN(dbuff, (uint8_t)msg_type);
 
        switch (msg_type) {
        case FR_DHCPV6_RELAY_REPLY:

diff --git a/src/protocols/internal/encode.c b/src/protocols/internal/encode.c
index ca8c682fcdc48c6912f276e9a3aa6efb83c4645d..094f28806c45f7500301be5b0b697e3033c79c01 100644 (file)
--- a/src/protocols/internal/encode.c
+++ b/src/protocols/internal/encode.c
@@ -71,7 +71,7 @@ static ssize_t internal_encode(fr_dbuff_t *dbuff,
        /*
         *      Zero out first encoding byte
         */
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0x00);
 
        switch (da->type) {
        /*

diff --git a/src/protocols/radius/base.c b/src/protocols/radius/base.c
index 71f2934f37d2a20b9d0886be5663e3c6858e4191..f103325d37311fda965266fc6e574de707832ea4 100644 (file)
--- a/src/protocols/radius/base.c
+++ b/src/protocols/radius/base.c
@@ -971,8 +971,8 @@ ssize_t fr_radius_encode_dbuff(fr_dbuff_t *dbuff, uint8_t const *original,
         *      later themselves, well, too bad.
         */
        if (code == FR_CODE_PROTOCOL_ERROR) {
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 241, 7, 4 /* Original-Packet-Code */,
-                                        0, 0, 0, original[0]);
+               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_EXTENDED_ATTRIBUTE_1, 0x07, 0x04 /* Original-Packet-Code */,
+                                        0x00, 0x00, 0x00, original[0]);
        }
 
        /*

diff --git a/src/protocols/radius/encode.c b/src/protocols/radius/encode.c
index 815966aacbd116d6e9b4c57836b276d1c1d1d8ec..8df0b8a24a6569425dc756c79412a4044d061b92 100644 (file)
--- a/src/protocols/radius/encode.c
+++ b/src/protocols/radius/encode.c
@@ -464,9 +464,9 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
         */
        if ((vp->da->type == FR_TYPE_STRING) && flag_has_tag(&vp->da->flags)) {
                if (packet_ctx->tag) {
-                       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, packet_ctx->tag);
+                       FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t)packet_ctx->tag);
                } else if (TAG_VALID(vp->vp_strvalue[0])) {
-                       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0);
+                       FR_DBUFF_IN_RETURN(&work_dbuff, (uint8_t)0x00);
                }
        }
 
@@ -521,7 +521,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
         */
        case FR_TYPE_IPV6_PREFIX:
                len = vp->vp_ip.prefix >> 3;    /* Convert bits to whole bytes */
-               FR_DBUFF_IN_BYTES_RETURN(&value_dbuff, 0, vp->vp_ip.prefix);
+               FR_DBUFF_IN_BYTES_RETURN(&value_dbuff, 0x00, vp->vp_ip.prefix);
                /* Only copy the minimum number of address bytes required */
                FR_DBUFF_IN_MEMCPY_RETURN(&value_dbuff, (uint8_t const *)vp->vp_ipv6addr, len);
                break;
@@ -530,7 +530,7 @@ static ssize_t encode_value(fr_dbuff_t *dbuff,
         *      Common encoder doesn't add reserved byte
         */
        case FR_TYPE_IPV4_PREFIX:
-               FR_DBUFF_IN_BYTES_RETURN(&value_dbuff, 0, vp->vp_ip.prefix);
+               FR_DBUFF_IN_BYTES_RETURN(&value_dbuff, 0x00, vp->vp_ip.prefix);
                FR_DBUFF_IN_MEMCPY_RETURN(&value_dbuff, (uint8_t const *)&vp->vp_ipv4addr, sizeof(vp->vp_ipv4addr));
                break;
 
@@ -794,7 +794,7 @@ static ssize_t encode_extended_hdr(fr_dbuff_t *dbuff,
        FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth++]->attr, 3 + extra);
        FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr);
 
-       if (extra) FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0);    /* flags start off at zero */
+       if (extra) FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, 0x00); /* flags start off at zero */
 
        FR_PROTO_STACK_PRINT(da_stack, depth);
 
@@ -881,7 +881,7 @@ static ssize_t encode_concat(fr_dbuff_t *dbuff,
                fr_dbuff_marker_t       hdr;
 
                fr_dbuff_marker(&hdr, &work_dbuff);
-               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t) da_stack->da[depth]->attr, 2);
+               FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t) da_stack->da[depth]->attr, 0x02);
 
                left = slen;
 
@@ -943,7 +943,7 @@ static ssize_t encode_rfc_hdr_internal(fr_dbuff_t *dbuff,
                break;
        }
 
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr, 2);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr, 0x02);
 
        slen = encode_value(&FR_DBUFF_MAX(&work_dbuff, 253), da_stack, depth, cursor, encoder_ctx);
        if (slen <= 0) return slen;
@@ -1080,13 +1080,13 @@ static ssize_t encode_wimax_hdr(fr_dbuff_t *dbuff,
        /*
         *      Build the Vendor-Specific header
         */
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_VENDOR_SPECIFIC, 9);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_VENDOR_SPECIFIC, 0x09);
        FR_DBUFF_IN_RETURN(&work_dbuff, (uint32_t) fr_dict_vendor_num_by_da(vp->da));
 
        /*
         *      Encode the first attribute
         */
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr, 3, 0);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)da_stack->da[depth]->attr, 0x03, 0x00);
 
        /*
         *      "outlen" can be larger than 255 because of the "continuation" byte.
@@ -1152,7 +1152,7 @@ static ssize_t encode_vsa_hdr(fr_dbuff_t *dbuff,
        /*
         *      Build the Vendor-Specific header
         */
-       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_VENDOR_SPECIFIC, 6);
+       FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, FR_VENDOR_SPECIFIC, 0x06);
 
        /*
         *      Now process the vendor ID part (which is one attribute deeper)
@@ -1237,7 +1237,7 @@ static ssize_t encode_rfc_hdr(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsign
         */
        if (vp->da == attr_message_authenticator) {
                FR_DBUFF_IN_BYTES_RETURN(&work_dbuff, (uint8_t)vp->da->attr, 18);
-               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, 16);
+               FR_DBUFF_MEMSET_RETURN(&work_dbuff, 0, RADIUS_MESSAGE_AUTHENTICATOR_LENGTH);
 
                FR_PROTO_HEX_DUMP(fr_dbuff_current(&start) + 2, RADIUS_MESSAGE_AUTHENTICATOR_LENGTH,
                                  "message-authenticator");

diff --git a/src/protocols/vmps/vmps.c b/src/protocols/vmps/vmps.c
index d129e67a0314ff094e0c344c5cd38e8c70e2c204..1ca4eaa7af66f9b89a41f58001cd6015b5bb669f 100644 (file)
--- a/src/protocols/vmps/vmps.c
+++ b/src/protocols/vmps/vmps.c
@@ -282,7 +282,7 @@ ssize_t fr_vmps_encode(fr_dbuff_t *dbuff, uint8_t const *original,
        fr_dbuff_in_bytes(&work_dbuff, FR_VQP_VERSION,                  /* Version */
                                        code,                           /* Opcode */
                                        FR_ERROR_CODE_VALUE_NO_ERROR,   /* Response Code */
-                                       0);                             /* Data Count */
+                                       0x00);                          /* Data Count */
 
        if (original) {
                fr_dbuff_in_memcpy(&work_dbuff, original + 4, 4);