Save all the v2 SSL information

kosmas-valianos · kosmas-valianos · commit 99cdea0c7336 · 2022-03-21T16:46:30.000+01:00
diff --git a/Makefile b/Makefile
@@ -16,7 +16,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-CFLAGS := -Wall -Wextra -Wshadow -ansi -fshort-enums -fpic
+CFLAGS := -Wall -Wextra -Wshadow -Wimplicit-fallthrough=0 -ansi -fshort-enums -fpic
 
 all: build
 
diff --git a/src/proxy_protocol.c b/src/proxy_protocol.c
@@ -121,6 +121,20 @@ typedef struct
 
 #pragma pack()
 
+typedef struct
+{
+    uint8_t  type;
+    uint16_t length;
+    uint8_t  value[1];
+} tlv_t;
+
+struct _tlv_array_t
+{
+    uint32_t  len;  /* Number of elements  */
+    uint32_t  size; /* Allocated elements  */
+    tlv_t   **tlvs; /* Pointer to tlv_t* elements */
+};
+
 static const char *errors[] = {
     "No error",
     "Invalid PROXY protocol version given. Only 1 and 2 are valid",
@@ -246,21 +260,21 @@ static void tlv_array_clear(tlv_array_t *tlv_array)
     tlv_array->len = 0;
     tlv_array->size = 0;
     free(tlv_array->tlvs);
-
+    tlv_array->tlvs = NULL;
 }
 
 uint8_t *pp_info_get_tlv_value(const pp_info_t *pp_info, uint8_t type, uint8_t subtype, uint16_t *value_len_out)
 {
     *value_len_out = 0;
-    if (!pp_info->tlv_array.tlvs || !pp_info->tlv_array.len)
+    if (!pp_info->tlv_array->tlvs || !pp_info->tlv_array->len)
     {
         return NULL;
     }
 
     uint32_t i;
-    for (i = 0; i < pp_info->tlv_array.len; i++)
+    for (i = 0; i < pp_info->tlv_array->len; i++)
     {
-        tlv_t *tlv = pp_info->tlv_array.tlvs[i];
+        tlv_t *tlv = pp_info->tlv_array->tlvs[i];
         if (tlv->type == type)
         {
             if (subtype > 0)
@@ -281,15 +295,19 @@ uint8_t *pp_info_get_tlv_value(const pp_info_t *pp_info, uint8_t type, uint8_t s
 
 void pp_info_clear(pp_info_t *pp_info)
 {
-    tlv_array_clear(&pp_info->tlv_array);
+    if (pp_info->tlv_array)
+    {
+        tlv_array_clear(pp_info->tlv_array);
+        free(pp_info->tlv_array);
+    }
     memset(pp_info, 0, sizeof(*pp_info));
 }
 
 uint8_t *pp2_create_hdr(uint8_t fam, const pp_info_t *pp_info, uint32_t *pp2_hdr_len, uint32_t *error)
 {
     proxy_hdr_v2_t proxy_hdr_v2 = {
         .sig = "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A",
-        .ver_cmd = pp_info->v2local ? '\x20' : '\x21',
+        .ver_cmd = pp_info->pp2_info.local ? '\x20' : '\x21',
     };
 
     uint8_t transport_protocol = fam & 0x0f;
@@ -305,7 +323,7 @@ uint8_t *pp2_create_hdr(uint8_t fam, const pp_info_t *pp_info, uint32_t *pp2_hdr
     if (address_family == 0x0)
     {
         len = 0;
-        if (!pp_info->v2local)
+        if (!pp_info->pp2_info.local)
         {
             *error = ERR_PP2_TRANSPORT_FAMILY;
             return NULL;
@@ -526,7 +544,7 @@ static uint32_t crc32c(const uint8_t *buf, uint32_t len)
 }
 
 /* Verifies and parses a version 2 PROXY protocol header */
-static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
+static int32_t pp2_parse_hdr(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
 {
     const uint8_t *ppv2_hdr = pkt;
     const proxy_hdr_v2_t *proxy_hdr_v2 = (proxy_hdr_v2_t *) pkt;
@@ -551,11 +569,11 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
     uint8_t cmd = proxy_hdr_v2->ver_cmd & 0x0f;
     if (cmd == 0x0)
     {
-        pp_info->v2local = 1;
+        pp_info->pp2_info.local = 1;
     }
     else if (cmd == 0x1)
     {
-        pp_info->v2local = 0;
+        pp_info->pp2_info.local = 0;
     }
     else
     {
@@ -662,6 +680,10 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
 
     /* TLVs */
     /* Any TLV vector must be at least 3 bytes */
+    if (tlv_vectors_len > 3)
+    {
+        pp_info->tlv_array = malloc(sizeof(*pp_info->tlv_array));
+    }
     while (tlv_vectors_len > 3)
     {
         pp2_tlv_t *pp2_tlv = (pp2_tlv_t *) pkt;
@@ -676,7 +698,7 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
         {
         case PP2_TYPE_ALPN:      /* Byte sequence */
         case PP2_TYPE_AUTHORITY: /* UTF8 */
-            if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
+            if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
             {
                 return ERR_HEAP_ALLOC;
             }
@@ -702,7 +724,7 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
                 return ERR_PP2_TYPE_CRC32C;
             }
 
-            if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, &crc32c_chksum))
+            if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, &crc32c_chksum))
             {
                 return ERR_HEAP_ALLOC;
             }
@@ -715,20 +737,23 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
             {
                 return ERR_PP2_TYPE_UNIQUE_ID;
             }
-            if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
+            if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
             {
                 return ERR_HEAP_ALLOC;
             }
             break;
         case PP2_TYPE_SSL:
         {
             pp2_tlv_ssl_t *pp2_tlv_ssl = (pp2_tlv_ssl_t*)pp2_tlv->value;
-            /* TODO save client, verify in pp_info_t */
-            /*if (!(pp2_tlv_ssl->client & PP2_CLIENT_SSL || pp2_tlv_ssl->client & PP2_CLIENT_CERT_CONN || pp2_tlv_ssl->client & PP2_CLIENT_CERT_SESS))
-            {
-                break;
-            }*/
+
+            /* Set the pp2_ssl_info */
+            pp_info->pp2_info.pp2_ssl_info.ssl = !!(pp2_tlv_ssl->client & PP2_CLIENT_SSL);
+            pp_info->pp2_info.pp2_ssl_info.cert_in_connection = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_CONN);
+            pp_info->pp2_info.pp2_ssl_info.cert_in_session = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_SESS);
+            pp_info->pp2_info.pp2_ssl_info.cert_verified = !pp2_tlv_ssl->verify;
+
             uint16_t pp2_tlvs_ssl_len = pp2_tlv_len - sizeof(pp2_tlv_ssl->client) - sizeof(pp2_tlv_ssl->verify);
+            uint8_t tlv_ssl_version_found = 0;
             uint16_t pp2_sub_tlv_offset = 0;
             while (pp2_sub_tlv_offset < pp2_tlvs_ssl_len)
             {
@@ -737,17 +762,17 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
                 switch (pp2_sub_tlv_ssl->type)
                 {
                 case PP2_SUBTYPE_SSL_VERSION: /* US-ASCII */
+                    tlv_ssl_version_found = 1;
                 case PP2_SUBTYPE_SSL_CIPHER:  /* US-ASCII */
                 case PP2_SUBTYPE_SSL_SIG_ALG: /* US-ASCII */
                 case PP2_SUBTYPE_SSL_KEY_ALG: /* US-ASCII */
-                    /* +1 to save it as a string */
-                    if (!tlv_array_append_tlv_new_usascii(&pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))
+                    if (!tlv_array_append_tlv_new_usascii(pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))
                     {
                         return ERR_HEAP_ALLOC;
                     }
                     break;
                 case PP2_SUBTYPE_SSL_CN: /* UTF8 */
-                    if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))
+                    if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))
                     {
                         return ERR_HEAP_ALLOC;
                     }
@@ -758,14 +783,14 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
 
                 pp2_sub_tlv_offset += 3 + pp2_sub_tlv_ssl_len;
             }
-            if (pp2_sub_tlv_offset > pp2_tlvs_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;
             }
             break;
         }
         case PP2_TYPE_NETNS: /* US-ASCII */
-            if (!tlv_array_append_tlv_new_usascii(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
+            if (!tlv_array_append_tlv_new_usascii(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
             {
                 return ERR_HEAP_ALLOC;
             }
@@ -781,7 +806,7 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
             if (pp2_tlv_aws->type == PP2_SUBTYPE_AWS_VPCE_ID) /* US-ASCII */
             {
                 /* Example: \x1vpce-08d2bf15fac5001c9 */
-                if (!tlv_array_append_tlv_new_usascii(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
+                if (!tlv_array_append_tlv_new_usascii(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))
                 {
                     return ERR_HEAP_ALLOC;
                 }
@@ -799,7 +824,7 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
             if (pp2_tlv_azure->type == PP2_TYPE_AZURE) /* 32-bit number */
             {
                 tlv_t *tlv = tlv_new(pp2_tlv->type, pp2_tlv_len, pp2_tlv->value);
-                if (!tlv || !tlv_array_append_tlv(&pp_info->tlv_array, tlv))
+                if (!tlv || !tlv_array_append_tlv(pp_info->tlv_array, tlv))
                 {
                     return ERR_HEAP_ALLOC;
                 }
@@ -816,7 +841,7 @@ static int32_t ppv2_parse(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
     return sizeof(proxy_hdr_v2_t) + len;
 }
 
-static int32_t ppv1_parse(const uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
+static int32_t pp1_parse_hdr(const uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
 {
     char block[PP1_MAX_LENGHT] = { 0 };
     char *ptr = block;
@@ -979,11 +1004,11 @@ int32_t pp_parse_hdr(uint8_t *pkt, uint32_t pktlen, pp_info_t *pp_info)
     memset(pp_info, 0, sizeof(*pp_info));
     if (pktlen >= 16 && !memcmp(pkt, "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A", 12))
     {
-        return ppv2_parse(pkt, pktlen, pp_info);
+        return pp2_parse_hdr(pkt, pktlen, pp_info);
     }
     else if (pktlen >= 8 && !memcmp(pkt, "\x50\x52\x4F\x58\x59", 5))
     {
-        return ppv1_parse(pkt, pktlen, pp_info);;
+        return pp1_parse_hdr(pkt, pktlen, pp_info);;
     }
     else
     {
diff --git a/src/proxy_protocol.h b/src/proxy_protocol.h
@@ -81,28 +81,30 @@ enum
 /* PP2_TYPE_AZURE subtypes */
 #define PP2_SUBTYPE_AZURE_PRIVATEENDPOINT_LINKID 0x01
 
+typedef struct _tlv_array_t tlv_array_t;
+
 typedef struct
 {
-    uint8_t  type;
-    uint16_t length;
-    uint8_t  value[1];
-} tlv_t;
+    uint8_t ssl;                /* 1: client connected over SSL/TLS 0: otherwise */
+    uint8_t cert_in_connection; /* 1: client provided a certificate over the current connection 0: otherwise */
+    uint8_t cert_in_session;    /* 1: client provided a certificate at least once over the TLS session this connection belongs to 0: otherwise */
+    uint8_t cert_verified;      /* 1: client presented a certificate and it was successfully verified 1: otherwise */
+} pp2_ssl_info_t;
 
 typedef struct
 {
-    uint32_t  len;  /* Number of elements  */
-    uint32_t  size; /* Allocated elements  */
-    tlv_t   **tlvs; /* Pointer to tlv_t* elements */
-} tlv_array_t;
+    uint8_t        local; /* 1: LOCAL 0: PROXY */
+    pp2_ssl_info_t pp2_ssl_info;
+} pp2_info_t;
 
 typedef struct
 {
-    uint8_t     v2local; /* Used only in v2. 1: LOCAL 0: PROXY */
-    char        src_addr[108];
-    char        dst_addr[108];
-    uint16_t    src_port;
-    uint16_t    dst_port;
-    tlv_array_t tlv_array;
+    char         src_addr[108];
+    char         dst_addr[108];
+    uint16_t     src_port;
+    uint16_t     dst_port;
+    pp2_info_t   pp2_info;
+    tlv_array_t *tlv_array;
 } pp_info_t;
 
 const char *pp_strerror(int32_t error);
diff --git a/tests/test.c b/tests/test.c
@@ -127,7 +127,7 @@ static uint8_t pp_verify_tlvs(const pp_info_t *pp_info, const test_tlv_t (*expec
 
 static uint8_t pp_info_equal(const pp_info_t *pp_info_a, const pp_info_t *pp_info_b)
 {
-    if (pp_info_a->v2local != pp_info_b->v2local)
+    if (pp_info_a->pp2_info.local != pp_info_b->pp2_info.local)
     {
         return 0;
     }
@@ -147,6 +147,10 @@ static uint8_t pp_info_equal(const pp_info_t *pp_info_a, const pp_info_t *pp_inf
     {
         return 0;
     }
+    if (memcmp(&pp_info_a->pp2_info, &pp_info_b->pp2_info, sizeof(pp2_info_t)))
+    {
+        return 0;
+    }
     return 1;
 }
 
@@ -229,8 +233,8 @@ int main()
             .name = "v2 PROXY protocol header: LOCAL, AF_UNSPEC create and parse",
             .version = 2,
             .fam = '\x00',
-            .pp_info_in = { .v2local = 1 },
-            .pp_info_out_expected = { .v2local = 1 },
+            .pp_info_in = { .pp2_info.local = 1 },
+            .pp_info_out_expected = { .pp2_info.local = 1 },
         },
         {
             .name = "v2 PROXY protocol header: PROXY, TCP over IPv6 create and parse",
@@ -266,7 +270,14 @@ int main()
                 .src_addr = "192.168.10.100",
                 .dst_addr = "192.168.11.90",
                 .src_port = 42332,
-                .dst_port = 8080
+                .dst_port = 8080,
+                .pp2_info = { .local = 0, .pp2_ssl_info = {
+                        .ssl = 1,
+                        .cert_in_connection = 1,
+                        .cert_in_session = 1,
+                        .cert_verified = 1
+                    }
+                }
             },
             .expected_tlvs = {
                 {

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`# along with this program. If not, see <https://www.gnu.org/licenses/>.`
`17`	`17`	`#`
`18`	`18`
`19`		`-CFLAGS := -Wall -Wextra -Wshadow -ansi -fshort-enums -fpic`
	`19`	`+CFLAGS := -Wall -Wextra -Wshadow -Wimplicit-fallthrough=0 -ansi -fshort-enums -fpic`
`20`	`20`
`21`	`21`	`all: build`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -121,6 +121,20 @@ typedef struct`
`121`	`121`
`122`	`122`	`#pragma pack()`
`123`	`123`
	`124`	`+typedef struct`
	`125`	`+{`
	`126`	`+ uint8_t type;`
	`127`	`+ uint16_t length;`
	`128`	`+ uint8_t value[1];`
	`129`	`+} tlv_t;`
	`130`	`+`
	`131`	`+struct _tlv_array_t`
	`132`	`+{`
	`133`	`+ uint32_t len; /* Number of elements */`
	`134`	`+ uint32_t size; /* Allocated elements */`
	`135`	`+ tlv_t *tlvs; / Pointer to tlv_t* elements */`
	`136`	`+};`
	`137`	`+`
`124`	`138`	`static const char *errors[] = {`
`125`	`139`	`"No error",`
`126`	`140`	`"Invalid PROXY protocol version given. Only 1 and 2 are valid",`
`@@ -246,21 +260,21 @@ static void tlv_array_clear(tlv_array_t *tlv_array)`
`246`	`260`	`tlv_array->len = 0;`
`247`	`261`	`tlv_array->size = 0;`
`248`	`262`	`free(tlv_array->tlvs);`
`249`		`-`
	`263`	`+ tlv_array->tlvs = NULL;`
`250`	`264`	`}`
`251`	`265`
`252`	`266`	`uint8_t pp_info_get_tlv_value(const pp_info_t pp_info, uint8_t type, uint8_t subtype, uint16_t *value_len_out)`
`253`	`267`	`{`
`254`	`268`	`*value_len_out = 0;`
`255`		`- if (!pp_info->tlv_array.tlvs \|\| !pp_info->tlv_array.len)`
	`269`	`+ if (!pp_info->tlv_array->tlvs \|\| !pp_info->tlv_array->len)`
`256`	`270`	`{`
`257`	`271`	`return NULL;`
`258`	`272`	`}`
`259`	`273`
`260`	`274`	`uint32_t i;`
`261`		`- for (i = 0; i < pp_info->tlv_array.len; i++)`
	`275`	`+ for (i = 0; i < pp_info->tlv_array->len; i++)`
`262`	`276`	`{`
`263`		`- tlv_t *tlv = pp_info->tlv_array.tlvs[i];`
	`277`	`+ tlv_t *tlv = pp_info->tlv_array->tlvs[i];`
`264`	`278`	`if (tlv->type == type)`
`265`	`279`	`{`
`266`	`280`	`if (subtype > 0)`
`@@ -281,15 +295,19 @@ uint8_t pp_info_get_tlv_value(const pp_info_t pp_info, uint8_t type, uint8_t s`
`281`	`295`
`282`	`296`	`void pp_info_clear(pp_info_t *pp_info)`
`283`	`297`	`{`
`284`		`- tlv_array_clear(&pp_info->tlv_array);`
	`298`	`+ if (pp_info->tlv_array)`
	`299`	`+ {`
	`300`	`+ tlv_array_clear(pp_info->tlv_array);`
	`301`	`+ free(pp_info->tlv_array);`
	`302`	`+ }`
`285`	`303`	`memset(pp_info, 0, sizeof(*pp_info));`
`286`	`304`	`}`
`287`	`305`
`288`	`306`	`uint8_t pp2_create_hdr(uint8_t fam, const pp_info_t pp_info, uint32_t pp2_hdr_len, uint32_t error)`
`289`	`307`	`{`
`290`	`308`	`proxy_hdr_v2_t proxy_hdr_v2 = {`
`291`	`309`	`.sig = "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A",`
`292`		`- .ver_cmd = pp_info->v2local ? '\x20' : '\x21',`
	`310`	`+ .ver_cmd = pp_info->pp2_info.local ? '\x20' : '\x21',`
`293`	`311`	`};`
`294`	`312`
`295`	`313`	`uint8_t transport_protocol = fam & 0x0f;`
`@@ -305,7 +323,7 @@ uint8_t pp2_create_hdr(uint8_t fam, const pp_info_t pp_info, uint32_t *pp2_hdr`
`305`	`323`	`if (address_family == 0x0)`
`306`	`324`	`{`
`307`	`325`	`len = 0;`
`308`		`- if (!pp_info->v2local)`
	`326`	`+ if (!pp_info->pp2_info.local)`
`309`	`327`	`{`
`310`	`328`	`*error = ERR_PP2_TRANSPORT_FAMILY;`
`311`	`329`	`return NULL;`
`@@ -526,7 +544,7 @@ static uint32_t crc32c(const uint8_t *buf, uint32_t len)`
`526`	`544`	`}`
`527`	`545`
`528`	`546`	`/* Verifies and parses a version 2 PROXY protocol header */`
`529`		`-static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
	`547`	`+static int32_t pp2_parse_hdr(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`530`	`548`	`{`
`531`	`549`	`const uint8_t *ppv2_hdr = pkt;`
`532`	`550`	`const proxy_hdr_v2_t proxy_hdr_v2 = (proxy_hdr_v2_t ) pkt;`
`@@ -551,11 +569,11 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`551`	`569`	`uint8_t cmd = proxy_hdr_v2->ver_cmd & 0x0f;`
`552`	`570`	`if (cmd == 0x0)`
`553`	`571`	`{`
`554`		`- pp_info->v2local = 1;`
	`572`	`+ pp_info->pp2_info.local = 1;`
`555`	`573`	`}`
`556`	`574`	`else if (cmd == 0x1)`
`557`	`575`	`{`
`558`		`- pp_info->v2local = 0;`
	`576`	`+ pp_info->pp2_info.local = 0;`
`559`	`577`	`}`
`560`	`578`	`else`
`561`	`579`	`{`
`@@ -662,6 +680,10 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`662`	`680`
`663`	`681`	`/* TLVs */`
`664`	`682`	`/* Any TLV vector must be at least 3 bytes */`
	`683`	`+ if (tlv_vectors_len > 3)`
	`684`	`+ {`
	`685`	`+ pp_info->tlv_array = malloc(sizeof(*pp_info->tlv_array));`
	`686`	`+ }`
`665`	`687`	`while (tlv_vectors_len > 3)`
`666`	`688`	`{`
`667`	`689`	`pp2_tlv_t pp2_tlv = (pp2_tlv_t ) pkt;`
`@@ -676,7 +698,7 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`676`	`698`	`{`
`677`	`699`	`case PP2_TYPE_ALPN: /* Byte sequence */`
`678`	`700`	`case PP2_TYPE_AUTHORITY: /* UTF8 */`
`679`		`- if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
	`701`	`+ if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`680`	`702`	`{`
`681`	`703`	`return ERR_HEAP_ALLOC;`
`682`	`704`	`}`
`@@ -702,7 +724,7 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`702`	`724`	`return ERR_PP2_TYPE_CRC32C;`
`703`	`725`	`}`
`704`	`726`
`705`		`- if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, &crc32c_chksum))`
	`727`	`+ if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, &crc32c_chksum))`
`706`	`728`	`{`
`707`	`729`	`return ERR_HEAP_ALLOC;`
`708`	`730`	`}`
`@@ -715,20 +737,23 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`715`	`737`	`{`
`716`	`738`	`return ERR_PP2_TYPE_UNIQUE_ID;`
`717`	`739`	`}`
`718`		`- if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
	`740`	`+ if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`719`	`741`	`{`
`720`	`742`	`return ERR_HEAP_ALLOC;`
`721`	`743`	`}`
`722`	`744`	`break;`
`723`	`745`	`case PP2_TYPE_SSL:`
`724`	`746`	`{`
`725`	`747`	`pp2_tlv_ssl_t pp2_tlv_ssl = (pp2_tlv_ssl_t)pp2_tlv->value;`
`726`		`- /* TODO save client, verify in pp_info_t */`
`727`		`- /*if (!(pp2_tlv_ssl->client & PP2_CLIENT_SSL \|\| pp2_tlv_ssl->client & PP2_CLIENT_CERT_CONN \|\| pp2_tlv_ssl->client & PP2_CLIENT_CERT_SESS))`
`728`		`- {`
`729`		`- break;`
`730`		`- }*/`
	`748`	`+`
	`749`	`+ /* Set the pp2_ssl_info */`
	`750`	`+ pp_info->pp2_info.pp2_ssl_info.ssl = !!(pp2_tlv_ssl->client & PP2_CLIENT_SSL);`
	`751`	`+ pp_info->pp2_info.pp2_ssl_info.cert_in_connection = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_CONN);`
	`752`	`+ pp_info->pp2_info.pp2_ssl_info.cert_in_session = !!(pp2_tlv_ssl->client & PP2_CLIENT_CERT_SESS);`
	`753`	`+ pp_info->pp2_info.pp2_ssl_info.cert_verified = !pp2_tlv_ssl->verify;`
	`754`	`+`
`731`	`755`	`uint16_t pp2_tlvs_ssl_len = pp2_tlv_len - sizeof(pp2_tlv_ssl->client) - sizeof(pp2_tlv_ssl->verify);`
	`756`	`+ uint8_t tlv_ssl_version_found = 0;`
`732`	`757`	`uint16_t pp2_sub_tlv_offset = 0;`
`733`	`758`	`while (pp2_sub_tlv_offset < pp2_tlvs_ssl_len)`
`734`	`759`	`{`
`@@ -737,17 +762,17 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`737`	`762`	`switch (pp2_sub_tlv_ssl->type)`
`738`	`763`	`{`
`739`	`764`	`case PP2_SUBTYPE_SSL_VERSION: /* US-ASCII */`
	`765`	`+ tlv_ssl_version_found = 1;`
`740`	`766`	`case PP2_SUBTYPE_SSL_CIPHER: /* US-ASCII */`
`741`	`767`	`case PP2_SUBTYPE_SSL_SIG_ALG: /* US-ASCII */`
`742`	`768`	`case PP2_SUBTYPE_SSL_KEY_ALG: /* US-ASCII */`
`743`		`- /* +1 to save it as a string */`
`744`		`- if (!tlv_array_append_tlv_new_usascii(&pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))`
	`769`	`+ if (!tlv_array_append_tlv_new_usascii(pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))`
`745`	`770`	`{`
`746`	`771`	`return ERR_HEAP_ALLOC;`
`747`	`772`	`}`
`748`	`773`	`break;`
`749`	`774`	`case PP2_SUBTYPE_SSL_CN: /* UTF8 */`
`750`		`- if (!tlv_array_append_tlv_new(&pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))`
	`775`	`+ if (!tlv_array_append_tlv_new(pp_info->tlv_array, pp2_sub_tlv_ssl->type, pp2_sub_tlv_ssl_len, pp2_sub_tlv_ssl->value))`
`751`	`776`	`{`
`752`	`777`	`return ERR_HEAP_ALLOC;`
`753`	`778`	`}`
`@@ -758,14 +783,14 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`758`	`783`
`759`	`784`	`pp2_sub_tlv_offset += 3 + pp2_sub_tlv_ssl_len;`
`760`	`785`	`}`
`761`		`- if (pp2_sub_tlv_offset > pp2_tlvs_ssl_len)`
	`786`	`+ if (pp2_sub_tlv_offset > pp2_tlvs_ssl_len \|\| (pp_info->pp2_info.pp2_ssl_info.ssl && !tlv_ssl_version_found))`
`762`	`787`	`{`
`763`	`788`	`return ERR_PP2_TYPE_SSL;`
`764`	`789`	`}`
`765`	`790`	`break;`
`766`	`791`	`}`
`767`	`792`	`case PP2_TYPE_NETNS: /* US-ASCII */`
`768`		`- if (!tlv_array_append_tlv_new_usascii(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
	`793`	`+ if (!tlv_array_append_tlv_new_usascii(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`769`	`794`	`{`
`770`	`795`	`return ERR_HEAP_ALLOC;`
`771`	`796`	`}`
`@@ -781,7 +806,7 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`781`	`806`	`if (pp2_tlv_aws->type == PP2_SUBTYPE_AWS_VPCE_ID) /* US-ASCII */`
`782`	`807`	`{`
`783`	`808`	`/* Example: \x1vpce-08d2bf15fac5001c9 */`
`784`		`- if (!tlv_array_append_tlv_new_usascii(&pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
	`809`	`+ if (!tlv_array_append_tlv_new_usascii(pp_info->tlv_array, pp2_tlv->type, pp2_tlv_len, pp2_tlv->value))`
`785`	`810`	`{`
`786`	`811`	`return ERR_HEAP_ALLOC;`
`787`	`812`	`}`
`@@ -799,7 +824,7 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`799`	`824`	`if (pp2_tlv_azure->type == PP2_TYPE_AZURE) /* 32-bit number */`
`800`	`825`	`{`
`801`	`826`	`tlv_t *tlv = tlv_new(pp2_tlv->type, pp2_tlv_len, pp2_tlv->value);`
`802`		`- if (!tlv \|\| !tlv_array_append_tlv(&pp_info->tlv_array, tlv))`
	`827`	`+ if (!tlv \|\| !tlv_array_append_tlv(pp_info->tlv_array, tlv))`
`803`	`828`	`{`
`804`	`829`	`return ERR_HEAP_ALLOC;`
`805`	`830`	`}`
`@@ -816,7 +841,7 @@ static int32_t ppv2_parse(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`816`	`841`	`return sizeof(proxy_hdr_v2_t) + len;`
`817`	`842`	`}`
`818`	`843`
`819`		`-static int32_t ppv1_parse(const uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
	`844`	`+static int32_t pp1_parse_hdr(const uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`820`	`845`	`{`
`821`	`846`	`char block[PP1_MAX_LENGHT] = { 0 };`
`822`	`847`	`char *ptr = block;`
`@@ -979,11 +1004,11 @@ int32_t pp_parse_hdr(uint8_t pkt, uint32_t pktlen, pp_info_t pp_info)`
`979`	`1004`	`memset(pp_info, 0, sizeof(*pp_info));`
`980`	`1005`	`if (pktlen >= 16 && !memcmp(pkt, "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A", 12))`
`981`	`1006`	`{`
`982`		`- return ppv2_parse(pkt, pktlen, pp_info);`
	`1007`	`+ return pp2_parse_hdr(pkt, pktlen, pp_info);`
`983`	`1008`	`}`
`984`	`1009`	`else if (pktlen >= 8 && !memcmp(pkt, "\x50\x52\x4F\x58\x59", 5))`
`985`	`1010`	`{`
`986`		`- return ppv1_parse(pkt, pktlen, pp_info);;`
	`1011`	`+ return pp1_parse_hdr(pkt, pktlen, pp_info);;`
`987`	`1012`	`}`
`988`	`1013`	`else`
`989`	`1014`	`{`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ static uint8_t pp_verify_tlvs(const pp_info_t pp_info, const test_tlv_t (expec`
`127`	`127`
`128`	`128`	`static uint8_t pp_info_equal(const pp_info_t pp_info_a, const pp_info_t pp_info_b)`
`129`	`129`	`{`
`130`		`- if (pp_info_a->v2local != pp_info_b->v2local)`
	`130`	`+ if (pp_info_a->pp2_info.local != pp_info_b->pp2_info.local)`
`131`	`131`	`{`
`132`	`132`	`return 0;`
`133`	`133`	`}`
`@@ -147,6 +147,10 @@ static uint8_t pp_info_equal(const pp_info_t pp_info_a, const pp_info_t pp_inf`
`147`	`147`	`{`
`148`	`148`	`return 0;`
`149`	`149`	`}`
	`150`	`+ if (memcmp(&pp_info_a->pp2_info, &pp_info_b->pp2_info, sizeof(pp2_info_t)))`
	`151`	`+ {`
	`152`	`+ return 0;`
	`153`	`+ }`
`150`	`154`	`return 1;`
`151`	`155`	`}`
`152`	`156`
`@@ -229,8 +233,8 @@ int main()`
`229`	`233`	`.name = "v2 PROXY protocol header: LOCAL, AF_UNSPEC create and parse",`
`230`	`234`	`.version = 2,`
`231`	`235`	`.fam = '\x00',`
`232`		`- .pp_info_in = { .v2local = 1 },`
`233`		`- .pp_info_out_expected = { .v2local = 1 },`
	`236`	`+ .pp_info_in = { .pp2_info.local = 1 },`
	`237`	`+ .pp_info_out_expected = { .pp2_info.local = 1 },`
`234`	`238`	`},`
`235`	`239`	`{`
`236`	`240`	`.name = "v2 PROXY protocol header: PROXY, TCP over IPv6 create and parse",`
`@@ -266,7 +270,14 @@ int main()`
`266`	`270`	`.src_addr = "192.168.10.100",`
`267`	`271`	`.dst_addr = "192.168.11.90",`
`268`	`272`	`.src_port = 42332,`
`269`		`- .dst_port = 8080`
	`273`	`+ .dst_port = 8080,`
	`274`	`+ .pp2_info = { .local = 0, .pp2_ssl_info = {`
	`275`	`+ .ssl = 1,`
	`276`	`+ .cert_in_connection = 1,`
	`277`	`+ .cert_in_session = 1,`
	`278`	`+ .cert_verified = 1`
	`279`	`+ }`
	`280`	`+ }`
`270`	`281`	`},`
`271`	`282`	`.expected_tlvs = {`
`272`	`283`	`{`