Make error enum maintainable

kosmas-valianos · kosmas-valianos · commit 4ad9da62a5f7 · 2022-03-28T20:04:50.000+02:00
diff --git a/src/proxy_protocol.c b/src/proxy_protocol.c
@@ -190,7 +190,7 @@ static const char *errors[] = {
 
 const char *pp_strerror(int32_t error)
 {
-    if (error < ERR_HEAP_ALLOC || error > ERR_NULL)
+    if (error < -ERR_HEAP_ALLOC || error > ERR_NULL)
     {
         return NULL;
     }
@@ -752,7 +752,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
     uint8_t version = proxy_hdr_v2->ver_cmd >> 4;
     if (version != 0x2)
     {
-        return ERR_PP2_VERSION;
+        return -ERR_PP2_VERSION;
     }
     /* The lowest four bits represents the command
      * \x0 : LOCAL
@@ -769,7 +769,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
     }
     else
     {
-        return ERR_PP2_CMD;
+        return -ERR_PP2_CMD;
     }
 
     /* The 14th byte contains the transport protocol and address family */
@@ -794,21 +794,21 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
     }
     else
     {
-        return ERR_PP2_ADDR_FAMILY;
+        return -ERR_PP2_ADDR_FAMILY;
     }
     /* the lowest 4 bits contain the protocol */
     pp_info->transport_protocol = proxy_hdr_v2->fam & 0x0f;
     if (pp_info->transport_protocol > TRANSPORT_PROTOCOL_DGRAM)
     {
-        return ERR_PP2_TRANSPORT_PROTOCOL;
+        return -ERR_PP2_TRANSPORT_PROTOCOL;
     }
 
 
     /* The 15th and 16th bytes is the address length in bytes in network byte order */
     uint16_t len = ntohs(proxy_hdr_v2->len);
     if (buffer_length < sizeof(proxy_hdr_v2_t) + len)
     {
-        return ERR_PP2_LENGTH;
+        return -ERR_PP2_LENGTH;
     }
 
     /*
@@ -830,11 +830,11 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
     {
         if (!inet_ntop(fam, &addr->ipv4_addr.src_addr, pp_info->src_addr, sizeof(pp_info->src_addr)))
         {
-            return ERR_PP2_IPV4_SRC_IP;
+            return -ERR_PP2_IPV4_SRC_IP;
         }
         if (!inet_ntop(fam, &addr->ipv4_addr.dst_addr, pp_info->dst_addr, sizeof(pp_info->dst_addr)))
         {
-            return ERR_PP2_IPV4_DST_IP;
+            return -ERR_PP2_IPV4_DST_IP;
         }
 
         pp_info->src_port = ntohs(addr->ipv4_addr.src_port);
@@ -847,11 +847,11 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
     {
         if (!inet_ntop(fam, &addr->ipv6_addr.src_addr, pp_info->src_addr, sizeof(pp_info->src_addr)))
         {
-            return ERR_PP2_IPV6_SRC_IP;
+            return -ERR_PP2_IPV6_SRC_IP;
         }
         if (!inet_ntop(fam, &addr->ipv6_addr.dst_addr, pp_info->dst_addr, sizeof(pp_info->dst_addr)))
         {
-            return ERR_PP2_IPV6_DST_IP;
+            return -ERR_PP2_IPV6_DST_IP;
         }
 
         pp_info->src_port = ntohs(addr->ipv6_addr.src_port);
@@ -867,7 +867,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
     }
     else
     {
-        return ERR_PP2_LENGTH;
+        return -ERR_PP2_LENGTH;
     }
 
     /* TLVs */
@@ -879,7 +879,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
         uint16_t pp2_tlv_offset = 3 + pp2_tlv_len;
         if (pp2_tlv_offset > tlv_vectors_len)
         {
-            return ERR_PP2_TLV_LENGTH;
+            return -ERR_PP2_TLV_LENGTH;
         }
 
         switch (pp2_tlv->type)
@@ -888,14 +888,14 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
         case PP2_TYPE_AUTHORITY: /* UTF8 */
             if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
             {
-                return ERR_HEAP_ALLOC;
+                return -ERR_HEAP_ALLOC;
             }
             break;
         case PP2_TYPE_CRC32C: /* 32-bit number */
         {
             if (pp2_tlv_len != sizeof(uint32_t))
             {
-                return ERR_PP2_TYPE_CRC32C;
+                return -ERR_PP2_TYPE_CRC32C;
             }
 
             /* Received CRC32c checksum */
@@ -909,12 +909,12 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
             /* Verify that the calculated CRC32c checksum is the same as the received CRC32c checksum*/
             if (memcmp(&crc32c_chksum, &crc32c_calculated, 4))
             {
-                return ERR_PP2_TYPE_CRC32C;
+                return -ERR_PP2_TYPE_CRC32C;
             }
 
             if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, &crc32c_chksum))
             {
-                return ERR_HEAP_ALLOC;
+                return -ERR_HEAP_ALLOC;
             }
             break;
         }
@@ -923,11 +923,11 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
         case PP2_TYPE_UNIQUE_ID: /* Byte sequence */
             if (pp2_tlv_len > 128)
             {
-                return ERR_PP2_TYPE_UNIQUE_ID;
+                return -ERR_PP2_TYPE_UNIQUE_ID;
             }
             if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
             {
-                return ERR_HEAP_ALLOC;
+                return -ERR_HEAP_ALLOC;
             }
             break;
         case PP2_TYPE_SSL:
@@ -956,38 +956,38 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
                 case PP2_SUBTYPE_SSL_KEY_ALG: /* US-ASCII */
                     if (!tlv_array_append_tlv_new_usascii(&pp_info->pp2_info.tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))
                     {
-                        return ERR_HEAP_ALLOC;
+                        return -ERR_HEAP_ALLOC;
                     }
                     break;
                 case PP2_SUBTYPE_SSL_CN: /* UTF8 */
                     if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))
                     {
-                        return ERR_HEAP_ALLOC;
+                        return -ERR_HEAP_ALLOC;
                     }
                     break;
                 default:
-                    return ERR_PP2_TYPE_SSL;
+                    return -ERR_PP2_TYPE_SSL;
                 }
 
                 pp2_sub_tlv_offset += 3 + pp2_sub_tlv_ssl_len;
             }
             if (pp2_sub_tlv_offset > pp2_tlvs_ssl_len || (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))
             {
-                return ERR_PP2_TYPE_SSL;
+                return -ERR_PP2_TYPE_SSL;
             }
             break;
         }
         case PP2_TYPE_NETNS: /* US-ASCII */
             if (!tlv_array_append_tlv_new_usascii(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
             {
-                return ERR_HEAP_ALLOC;
+                return -ERR_HEAP_ALLOC;
             }
             break;
         case PP2_TYPE_AWS:
         {
             if (pp2_tlv_len < sizeof(pp2_tlv_aws_t))
             {
-                return ERR_PP2_TYPE_AWS;
+                return -ERR_PP2_TYPE_AWS;
             }
             pp2_tlv_aws_t *pp2_tlv_aws = (pp2_tlv_aws_t *) pp2_tlv->value;
             /* Connection is done through Private Link/Interface VPC endpoint */
@@ -996,7 +996,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
                 /* Example: \x1vpce-08d2bf15fac5001c9 */
                 if (!tlv_array_append_tlv_new_usascii(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
                 {
-                    return ERR_HEAP_ALLOC;
+                    return -ERR_HEAP_ALLOC;
                 }
             }
             break;
@@ -1005,7 +1005,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
         {
             if (pp2_tlv_len < sizeof(pp2_tlv_azure_t))
             {
-                return ERR_PP2_TYPE_AZURE;
+                return -ERR_PP2_TYPE_AZURE;
             }
             pp2_tlv_azure_t *pp2_tlv_azure = (pp2_tlv_azure_t *) pp2_tlv->value;
             /* Connection is done through Private Link service */
@@ -1014,7 +1014,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t
                 pp2_tlv_t *tlv = tlv_new(pp2_tlv->type, pp2_tlv_len, pp2_tlv->value);
                 if (!tlv || !tlv_array_append_tlv(&pp_info->pp2_info.tlv_array, tlv))
                 {
-                    return ERR_HEAP_ALLOC;
+                    return -ERR_HEAP_ALLOC;
                 }
             }
             break;
@@ -1039,22 +1039,22 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     char *block_end = strstr(block, CRLF);
     if (!block_end)
     {
-        return ERR_PP1_CRLF;
+        return -ERR_PP1_CRLF;
     }
     block_end += strlen(CRLF);
     pp1_hdr_len = block_end - block;
 
     /* PROXY */
     if (memcmp(block, "PROXY", 5))
     {
-        return ERR_PP1_PROXY;
+        return -ERR_PP1_PROXY;
     }
     ptr += 5;
 
     /* Exactly one space */
     if (*ptr != '\x20')
     {
-        return ERR_PP1_SPACE;
+        return -ERR_PP1_SPACE;
     }
     ptr++;
 
@@ -1069,7 +1069,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
             pp_info->transport_protocol = TRANSPORT_PROTOCOL_UNSPEC;
             return pp1_hdr_len;
         }
-        return ERR_PP1_TRANSPORT_FAMILY;
+        return -ERR_PP1_TRANSPORT_FAMILY;
     }
     uint8_t sa_family = AF_UNSPEC;
     if (!memcmp(ptr, "TCP4", 4))
@@ -1095,13 +1095,13 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     }
     else
     {
-        return ERR_PP1_TRANSPORT_FAMILY;;
+        return -ERR_PP1_TRANSPORT_FAMILY;;
     }
 
     /* Exactly one space */
     if (*ptr != '\x20')
     {
-        return ERR_PP1_SPACE;
+        return -ERR_PP1_SPACE;
     }
     ptr++;
 
@@ -1123,7 +1123,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     /* Exactly one space */
     if (*ptr != '\x20')
     {
-        return ERR_PP1_SPACE;
+        return -ERR_PP1_SPACE;
     }
     ptr++;
 
@@ -1145,51 +1145,51 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i
     /* Exactly one space */
     if (*ptr != '\x20')
     {
-        return ERR_PP1_SPACE;
+        return -ERR_PP1_SPACE;
     }
     ptr++;
 
     /* TCP source port represented as a decimal integer in the range [0..65535] inclusive */
     char *src_port_end = strchr(ptr, ' ');
     if (!src_port_end)
     {
-        return ERR_PP1_SRC_PORT;
+        return -ERR_PP1_SRC_PORT;
     }
     char src_port_str[6] = { 0 };
     uint16_t src_port_length = src_port_end - ptr;
     memcpy(src_port_str, ptr, src_port_length);
     if (!parse_port(src_port_str, &pp_info->src_port))
     {
-        return ERR_PP1_SRC_PORT;
+        return -ERR_PP1_SRC_PORT;
     }
     ptr += src_port_length;
 
     /* Exactly one space */
     if (*ptr != '\x20')
     {
-        return ERR_PP1_SPACE;
+        return -ERR_PP1_SPACE;
     }
     ptr++;
 
     /* TCP destination port represented as a decimal integer in the range [0..65535] inclusive */
     char *dst_port_end = strchr(ptr, '\r');
     if (!dst_port_end)
     {
-        return ERR_PP1_DST_PORT;
+        return -ERR_PP1_DST_PORT;
     }
     char dst_port_str[6] = { 0 };
     uint16_t dst_port_length = dst_port_end - ptr;
     memcpy(dst_port_str, ptr, dst_port_length);
     if (!parse_port(dst_port_str, &pp_info->dst_port))
     {
-        return ERR_PP1_DST_PORT;
+        return -ERR_PP1_DST_PORT;
     }
     ptr += dst_port_length;
 
     /* The CRLF sequence */
     if (*ptr != '\r' || *(ptr+1) != '\n')
     {
-        return ERR_PP1_CRLF;
+        return -ERR_PP1_CRLF;
     }
 
     return pp1_hdr_len;
diff --git a/src/proxy_protocol.h b/src/proxy_protocol.h
@@ -24,34 +24,34 @@
 enum
 {
     ERR_NULL,
-    ERR_PP_VERSION             = -1,
-    ERR_PP2_SIG                = -2,
-    ERR_PP2_VERSION            = -3,
-    ERR_PP2_CMD                = -4,
-    ERR_PP2_ADDR_FAMILY        = -5,
-    ERR_PP2_TRANSPORT_PROTOCOL = -6,
-    ERR_PP2_LENGTH             = -7,
-    ERR_PP2_IPV4_SRC_IP        = -8,
-    ERR_PP2_IPV4_DST_IP        = -9,
-    ERR_PP2_IPV6_SRC_IP        = -10,
-    ERR_PP2_IPV6_DST_IP        = -11,
-    ERR_PP2_TLV_LENGTH         = -12,
-    ERR_PP2_TYPE_CRC32C        = -13,
-    ERR_PP2_TYPE_SSL           = -14,
-    ERR_PP2_TYPE_UNIQUE_ID     = -15,
-    ERR_PP2_TYPE_AWS           = -16,
-    ERR_PP2_TYPE_AZURE         = -17,
-    ERR_PP1_CRLF               = -18,
-    ERR_PP1_PROXY              = -19,
-    ERR_PP1_SPACE              = -20,
-    ERR_PP1_TRANSPORT_FAMILY   = -21,
-    ERR_PP1_IPV4_SRC_IP        = -22,
-    ERR_PP1_IPV4_DST_IP        = -23,
-    ERR_PP1_IPV6_SRC_IP        = -24,
-    ERR_PP1_IPV6_DST_IP        = -25,
-    ERR_PP1_SRC_PORT           = -26,
-    ERR_PP1_DST_PORT           = -27,
-    ERR_HEAP_ALLOC             = -28,
+    ERR_PP_VERSION,
+    ERR_PP2_SIG,
+    ERR_PP2_VERSION,
+    ERR_PP2_CMD,
+    ERR_PP2_ADDR_FAMILY,
+    ERR_PP2_TRANSPORT_PROTOCOL,
+    ERR_PP2_LENGTH,
+    ERR_PP2_IPV4_SRC_IP,
+    ERR_PP2_IPV4_DST_IP,
+    ERR_PP2_IPV6_SRC_IP,
+    ERR_PP2_IPV6_DST_IP,
+    ERR_PP2_TLV_LENGTH,
+    ERR_PP2_TYPE_CRC32C,
+    ERR_PP2_TYPE_SSL,
+    ERR_PP2_TYPE_UNIQUE_ID,
+    ERR_PP2_TYPE_AWS,
+    ERR_PP2_TYPE_AZURE,
+    ERR_PP1_CRLF,
+    ERR_PP1_PROXY,
+    ERR_PP1_SPACE,
+    ERR_PP1_TRANSPORT_FAMILY,
+    ERR_PP1_IPV4_SRC_IP,
+    ERR_PP1_IPV4_DST_IP,
+    ERR_PP1_IPV6_SRC_IP,
+    ERR_PP1_IPV6_DST_IP,
+    ERR_PP1_SRC_PORT,
+    ERR_PP1_DST_PORT,
+    ERR_HEAP_ALLOC
 };
 
 /* Returns a descriptive error message
diff --git a/tests/test.c b/tests/test.c

Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ static const char *errors[] = {`
`190`	`190`
`191`	`191`	`const char *pp_strerror(int32_t error)`
`192`	`192`	`{`
`193`		`- if (error < ERR_HEAP_ALLOC \|\| error > ERR_NULL)`
	`193`	`+ if (error < -ERR_HEAP_ALLOC \|\| error > ERR_NULL)`
`194`	`194`	`{`
`195`	`195`	`return NULL;`
`196`	`196`	`}`
`@@ -752,7 +752,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`752`	`752`	`uint8_t version = proxy_hdr_v2->ver_cmd >> 4;`
`753`	`753`	`if (version != 0x2)`
`754`	`754`	`{`
`755`		`- return ERR_PP2_VERSION;`
	`755`	`+ return -ERR_PP2_VERSION;`
`756`	`756`	`}`
`757`	`757`	`/* The lowest four bits represents the command`
`758`	`758`	`* \x0 : LOCAL`
`@@ -769,7 +769,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`769`	`769`	`}`
`770`	`770`	`else`
`771`	`771`	`{`
`772`		`- return ERR_PP2_CMD;`
	`772`	`+ return -ERR_PP2_CMD;`
`773`	`773`	`}`
`774`	`774`
`775`	`775`	`/* The 14th byte contains the transport protocol and address family */`
`@@ -794,21 +794,21 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`794`	`794`	`}`
`795`	`795`	`else`
`796`	`796`	`{`
`797`		`- return ERR_PP2_ADDR_FAMILY;`
	`797`	`+ return -ERR_PP2_ADDR_FAMILY;`
`798`	`798`	`}`
`799`	`799`	`/* the lowest 4 bits contain the protocol */`
`800`	`800`	`pp_info->transport_protocol = proxy_hdr_v2->fam & 0x0f;`
`801`	`801`	`if (pp_info->transport_protocol > TRANSPORT_PROTOCOL_DGRAM)`
`802`	`802`	`{`
`803`		`- return ERR_PP2_TRANSPORT_PROTOCOL;`
	`803`	`+ return -ERR_PP2_TRANSPORT_PROTOCOL;`
`804`	`804`	`}`
`805`	`805`
`806`	`806`
`807`	`807`	`/* The 15th and 16th bytes is the address length in bytes in network byte order */`
`808`	`808`	`uint16_t len = ntohs(proxy_hdr_v2->len);`
`809`	`809`	`if (buffer_length < sizeof(proxy_hdr_v2_t) + len)`
`810`	`810`	`{`
`811`		`- return ERR_PP2_LENGTH;`
	`811`	`+ return -ERR_PP2_LENGTH;`
`812`	`812`	`}`
`813`	`813`
`814`	`814`	`/*`
`@@ -830,11 +830,11 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`830`	`830`	`{`
`831`	`831`	`if (!inet_ntop(fam, &addr->ipv4_addr.src_addr, pp_info->src_addr, sizeof(pp_info->src_addr)))`
`832`	`832`	`{`
`833`		`- return ERR_PP2_IPV4_SRC_IP;`
	`833`	`+ return -ERR_PP2_IPV4_SRC_IP;`
`834`	`834`	`}`
`835`	`835`	`if (!inet_ntop(fam, &addr->ipv4_addr.dst_addr, pp_info->dst_addr, sizeof(pp_info->dst_addr)))`
`836`	`836`	`{`
`837`		`- return ERR_PP2_IPV4_DST_IP;`
	`837`	`+ return -ERR_PP2_IPV4_DST_IP;`
`838`	`838`	`}`
`839`	`839`
`840`	`840`	`pp_info->src_port = ntohs(addr->ipv4_addr.src_port);`
`@@ -847,11 +847,11 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`847`	`847`	`{`
`848`	`848`	`if (!inet_ntop(fam, &addr->ipv6_addr.src_addr, pp_info->src_addr, sizeof(pp_info->src_addr)))`
`849`	`849`	`{`
`850`		`- return ERR_PP2_IPV6_SRC_IP;`
	`850`	`+ return -ERR_PP2_IPV6_SRC_IP;`
`851`	`851`	`}`
`852`	`852`	`if (!inet_ntop(fam, &addr->ipv6_addr.dst_addr, pp_info->dst_addr, sizeof(pp_info->dst_addr)))`
`853`	`853`	`{`
`854`		`- return ERR_PP2_IPV6_DST_IP;`
	`854`	`+ return -ERR_PP2_IPV6_DST_IP;`
`855`	`855`	`}`
`856`	`856`
`857`	`857`	`pp_info->src_port = ntohs(addr->ipv6_addr.src_port);`
`@@ -867,7 +867,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`867`	`867`	`}`
`868`	`868`	`else`
`869`	`869`	`{`
`870`		`- return ERR_PP2_LENGTH;`
	`870`	`+ return -ERR_PP2_LENGTH;`
`871`	`871`	`}`
`872`	`872`
`873`	`873`	`/* TLVs */`
`@@ -879,7 +879,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`879`	`879`	`uint16_t pp2_tlv_offset = 3 + pp2_tlv_len;`
`880`	`880`	`if (pp2_tlv_offset > tlv_vectors_len)`
`881`	`881`	`{`
`882`		`- return ERR_PP2_TLV_LENGTH;`
	`882`	`+ return -ERR_PP2_TLV_LENGTH;`
`883`	`883`	`}`
`884`	`884`
`885`	`885`	`switch (pp2_tlv->type)`
`@@ -888,14 +888,14 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`888`	`888`	`case PP2_TYPE_AUTHORITY: /* UTF8 */`
`889`	`889`	`if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`890`	`890`	`{`
`891`		`- return ERR_HEAP_ALLOC;`
	`891`	`+ return -ERR_HEAP_ALLOC;`
`892`	`892`	`}`
`893`	`893`	`break;`
`894`	`894`	`case PP2_TYPE_CRC32C: /* 32-bit number */`
`895`	`895`	`{`
`896`	`896`	`if (pp2_tlv_len != sizeof(uint32_t))`
`897`	`897`	`{`
`898`		`- return ERR_PP2_TYPE_CRC32C;`
	`898`	`+ return -ERR_PP2_TYPE_CRC32C;`
`899`	`899`	`}`
`900`	`900`
`901`	`901`	`/* Received CRC32c checksum */`
`@@ -909,12 +909,12 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`909`	`909`	`/* Verify that the calculated CRC32c checksum is the same as the received CRC32c checksum*/`
`910`	`910`	`if (memcmp(&crc32c_chksum, &crc32c_calculated, 4))`
`911`	`911`	`{`
`912`		`- return ERR_PP2_TYPE_CRC32C;`
	`912`	`+ return -ERR_PP2_TYPE_CRC32C;`
`913`	`913`	`}`
`914`	`914`
`915`	`915`	`if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, &crc32c_chksum))`
`916`	`916`	`{`
`917`		`- return ERR_HEAP_ALLOC;`
	`917`	`+ return -ERR_HEAP_ALLOC;`
`918`	`918`	`}`
`919`	`919`	`break;`
`920`	`920`	`}`
`@@ -923,11 +923,11 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`923`	`923`	`case PP2_TYPE_UNIQUE_ID: /* Byte sequence */`
`924`	`924`	`if (pp2_tlv_len > 128)`
`925`	`925`	`{`
`926`		`- return ERR_PP2_TYPE_UNIQUE_ID;`
	`926`	`+ return -ERR_PP2_TYPE_UNIQUE_ID;`
`927`	`927`	`}`
`928`	`928`	`if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`929`	`929`	`{`
`930`		`- return ERR_HEAP_ALLOC;`
	`930`	`+ return -ERR_HEAP_ALLOC;`
`931`	`931`	`}`
`932`	`932`	`break;`
`933`	`933`	`case PP2_TYPE_SSL:`
`@@ -956,38 +956,38 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`956`	`956`	`case PP2_SUBTYPE_SSL_KEY_ALG: /* US-ASCII */`
`957`	`957`	`if (!tlv_array_append_tlv_new_usascii(&pp_info->pp2_info.tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))`
`958`	`958`	`{`
`959`		`- return ERR_HEAP_ALLOC;`
	`959`	`+ return -ERR_HEAP_ALLOC;`
`960`	`960`	`}`
`961`	`961`	`break;`
`962`	`962`	`case PP2_SUBTYPE_SSL_CN: /* UTF8 */`
`963`	`963`	`if (!tlv_array_append_tlv_new(&pp_info->pp2_info.tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))`
`964`	`964`	`{`
`965`		`- return ERR_HEAP_ALLOC;`
	`965`	`+ return -ERR_HEAP_ALLOC;`
`966`	`966`	`}`
`967`	`967`	`break;`
`968`	`968`	`default:`
`969`		`- return ERR_PP2_TYPE_SSL;`
	`969`	`+ return -ERR_PP2_TYPE_SSL;`
`970`	`970`	`}`
`971`	`971`
`972`	`972`	`pp2_sub_tlv_offset += 3 + pp2_sub_tlv_ssl_len;`
`973`	`973`	`}`
`974`	`974`	`if (pp2_sub_tlv_offset > pp2_tlvs_ssl_len \|\| (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))`
`975`	`975`	`{`
`976`		`- return ERR_PP2_TYPE_SSL;`
	`976`	`+ return -ERR_PP2_TYPE_SSL;`
`977`	`977`	`}`
`978`	`978`	`break;`
`979`	`979`	`}`
`980`	`980`	`case PP2_TYPE_NETNS: /* US-ASCII */`
`981`	`981`	`if (!tlv_array_append_tlv_new_usascii(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`982`	`982`	`{`
`983`		`- return ERR_HEAP_ALLOC;`
	`983`	`+ return -ERR_HEAP_ALLOC;`
`984`	`984`	`}`
`985`	`985`	`break;`
`986`	`986`	`case PP2_TYPE_AWS:`
`987`	`987`	`{`
`988`	`988`	`if (pp2_tlv_len < sizeof(pp2_tlv_aws_t))`
`989`	`989`	`{`
`990`		`- return ERR_PP2_TYPE_AWS;`
	`990`	`+ return -ERR_PP2_TYPE_AWS;`
`991`	`991`	`}`
`992`	`992`	`pp2_tlv_aws_t pp2_tlv_aws = (pp2_tlv_aws_t ) pp2_tlv->value;`
`993`	`993`	`/* Connection is done through Private Link/Interface VPC endpoint */`
`@@ -996,7 +996,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`996`	`996`	`/* Example: \x1vpce-08d2bf15fac5001c9 */`
`997`	`997`	`if (!tlv_array_append_tlv_new_usascii(&pp_info->pp2_info.tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`998`	`998`	`{`
`999`		`- return ERR_HEAP_ALLOC;`
	`999`	`+ return -ERR_HEAP_ALLOC;`
`1000`	`1000`	`}`
`1001`	`1001`	`}`
`1002`	`1002`	`break;`
`@@ -1005,7 +1005,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`1005`	`1005`	`{`
`1006`	`1006`	`if (pp2_tlv_len < sizeof(pp2_tlv_azure_t))`
`1007`	`1007`	`{`
`1008`		`- return ERR_PP2_TYPE_AZURE;`
	`1008`	`+ return -ERR_PP2_TYPE_AZURE;`
`1009`	`1009`	`}`
`1010`	`1010`	`pp2_tlv_azure_t pp2_tlv_azure = (pp2_tlv_azure_t ) pp2_tlv->value;`
`1011`	`1011`	`/* Connection is done through Private Link service */`
`@@ -1014,7 +1014,7 @@ static int32_t pp2_parse_hdr(uint8_t *buffer, uint32_t buffer_length, pp_info_t`
`1014`	`1014`	`pp2_tlv_t *tlv = tlv_new(pp2_tlv->type, pp2_tlv_len, pp2_tlv->value);`
`1015`	`1015`	`if (!tlv \|\| !tlv_array_append_tlv(&pp_info->pp2_info.tlv_array, tlv))`
`1016`	`1016`	`{`
`1017`		`- return ERR_HEAP_ALLOC;`
	`1017`	`+ return -ERR_HEAP_ALLOC;`
`1018`	`1018`	`}`
`1019`	`1019`	`}`
`1020`	`1020`	`break;`
`@@ -1039,22 +1039,22 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1039`	`1039`	`char *block_end = strstr(block, CRLF);`
`1040`	`1040`	`if (!block_end)`
`1041`	`1041`	`{`
`1042`		`- return ERR_PP1_CRLF;`
	`1042`	`+ return -ERR_PP1_CRLF;`
`1043`	`1043`	`}`
`1044`	`1044`	`block_end += strlen(CRLF);`
`1045`	`1045`	`pp1_hdr_len = block_end - block;`
`1046`	`1046`
`1047`	`1047`	`/* PROXY */`
`1048`	`1048`	`if (memcmp(block, "PROXY", 5))`
`1049`	`1049`	`{`
`1050`		`- return ERR_PP1_PROXY;`
	`1050`	`+ return -ERR_PP1_PROXY;`
`1051`	`1051`	`}`
`1052`	`1052`	`ptr += 5;`
`1053`	`1053`
`1054`	`1054`	`/* Exactly one space */`
`1055`	`1055`	`if (*ptr != '\x20')`
`1056`	`1056`	`{`
`1057`		`- return ERR_PP1_SPACE;`
	`1057`	`+ return -ERR_PP1_SPACE;`
`1058`	`1058`	`}`
`1059`	`1059`	`ptr++;`
`1060`	`1060`
`@@ -1069,7 +1069,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1069`	`1069`	`pp_info->transport_protocol = TRANSPORT_PROTOCOL_UNSPEC;`
`1070`	`1070`	`return pp1_hdr_len;`
`1071`	`1071`	`}`
`1072`		`- return ERR_PP1_TRANSPORT_FAMILY;`
	`1072`	`+ return -ERR_PP1_TRANSPORT_FAMILY;`
`1073`	`1073`	`}`
`1074`	`1074`	`uint8_t sa_family = AF_UNSPEC;`
`1075`	`1075`	`if (!memcmp(ptr, "TCP4", 4))`
`@@ -1095,13 +1095,13 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1095`	`1095`	`}`
`1096`	`1096`	`else`
`1097`	`1097`	`{`
`1098`		`- return ERR_PP1_TRANSPORT_FAMILY;;`
	`1098`	`+ return -ERR_PP1_TRANSPORT_FAMILY;;`
`1099`	`1099`	`}`
`1100`	`1100`
`1101`	`1101`	`/* Exactly one space */`
`1102`	`1102`	`if (*ptr != '\x20')`
`1103`	`1103`	`{`
`1104`		`- return ERR_PP1_SPACE;`
	`1104`	`+ return -ERR_PP1_SPACE;`
`1105`	`1105`	`}`
`1106`	`1106`	`ptr++;`
`1107`	`1107`
`@@ -1123,7 +1123,7 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1123`	`1123`	`/* Exactly one space */`
`1124`	`1124`	`if (*ptr != '\x20')`
`1125`	`1125`	`{`
`1126`		`- return ERR_PP1_SPACE;`
	`1126`	`+ return -ERR_PP1_SPACE;`
`1127`	`1127`	`}`
`1128`	`1128`	`ptr++;`
`1129`	`1129`
`@@ -1145,51 +1145,51 @@ static int32_t pp1_parse_hdr(const uint8_t *buffer, uint32_t buffer_length, pp_i`
`1145`	`1145`	`/* Exactly one space */`
`1146`	`1146`	`if (*ptr != '\x20')`
`1147`	`1147`	`{`
`1148`		`- return ERR_PP1_SPACE;`
	`1148`	`+ return -ERR_PP1_SPACE;`
`1149`	`1149`	`}`
`1150`	`1150`	`ptr++;`
`1151`	`1151`
`1152`	`1152`	`/* TCP source port represented as a decimal integer in the range [0..65535] inclusive */`
`1153`	`1153`	`char *src_port_end = strchr(ptr, ' ');`
`1154`	`1154`	`if (!src_port_end)`
`1155`	`1155`	`{`
`1156`		`- return ERR_PP1_SRC_PORT;`
	`1156`	`+ return -ERR_PP1_SRC_PORT;`
`1157`	`1157`	`}`
`1158`	`1158`	`char src_port_str[6] = { 0 };`
`1159`	`1159`	`uint16_t src_port_length = src_port_end - ptr;`
`1160`	`1160`	`memcpy(src_port_str, ptr, src_port_length);`
`1161`	`1161`	`if (!parse_port(src_port_str, &pp_info->src_port))`
`1162`	`1162`	`{`
`1163`		`- return ERR_PP1_SRC_PORT;`
	`1163`	`+ return -ERR_PP1_SRC_PORT;`
`1164`	`1164`	`}`
`1165`	`1165`	`ptr += src_port_length;`
`1166`	`1166`
`1167`	`1167`	`/* Exactly one space */`
`1168`	`1168`	`if (*ptr != '\x20')`
`1169`	`1169`	`{`
`1170`		`- return ERR_PP1_SPACE;`
	`1170`	`+ return -ERR_PP1_SPACE;`
`1171`	`1171`	`}`
`1172`	`1172`	`ptr++;`
`1173`	`1173`
`1174`	`1174`	`/* TCP destination port represented as a decimal integer in the range [0..65535] inclusive */`
`1175`	`1175`	`char *dst_port_end = strchr(ptr, '\r');`
`1176`	`1176`	`if (!dst_port_end)`
`1177`	`1177`	`{`
`1178`		`- return ERR_PP1_DST_PORT;`
	`1178`	`+ return -ERR_PP1_DST_PORT;`
`1179`	`1179`	`}`
`1180`	`1180`	`char dst_port_str[6] = { 0 };`
`1181`	`1181`	`uint16_t dst_port_length = dst_port_end - ptr;`
`1182`	`1182`	`memcpy(dst_port_str, ptr, dst_port_length);`
`1183`	`1183`	`if (!parse_port(dst_port_str, &pp_info->dst_port))`
`1184`	`1184`	`{`
`1185`		`- return ERR_PP1_DST_PORT;`
	`1185`	`+ return -ERR_PP1_DST_PORT;`
`1186`	`1186`	`}`
`1187`	`1187`	`ptr += dst_port_length;`
`1188`	`1188`
`1189`	`1189`	`/* The CRLF sequence */`
`1190`	`1190`	`if (ptr != '\r' \|\| (ptr+1) != '\n')`
`1191`	`1191`	`{`
`1192`		`- return ERR_PP1_CRLF;`
	`1192`	`+ return -ERR_PP1_CRLF;`
`1193`	`1193`	`}`
`1194`	`1194`
`1195`	`1195`	`return pp1_hdr_len;`