Squid Web Proxy Cache

https://github.com/squid-cache/squid
Admin
Squid is a high-performance web proxy cache that speeds up web access by caching frequently...
Tokens:40,590
Snippets:693
Trust Score:7.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Preparing and Starting an Asynchronous Job

Source: https://github.com/squid-cache/squid/blob/master/src/base/AsyncJobs.dox

Demonstrates how to perform synchronous preparations on a job object before starting it asynchronously. This approach is used when custom initialization steps are required.

```C++
std::unique_ptr<MyJob> job(new MyJob(...)); // sync/blocking
job->prepare(...); // sync/blocking
job->prepareSomethingElse(...); // sync/blocking
AsyncStart(job.release()); // non-blocking
```

--------------------------------

### Starting a New Asynchronous Job

Source: https://github.com/squid-cache/squid/blob/master/src/base/AsyncJobs.dox

Illustrates the recommended way to start a new asynchronous job when complex preparations are not needed. This is a concise, non-blocking method.

```C++
AsyncJob::Start(new MyJob(...));
```

--------------------------------

### Function Signature Example

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Example of a function signature with Doxygen parameter descriptions.

```C++
/**
 \param g	 The buffer to be used
 \param glen	 Length of buffer provided
 \param state	 Object of type X storing foo
 */
void
fubar(char *g, int glen, void *state) {
```

--------------------------------

### SIP Proxy-Authenticate Header Example

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

Example of a SIP Proxy-Authenticate header used to challenge a client for Digest Authentication. This header includes the realm, nonce, and algorithm.

```sip
SIP/2.0 407 Proxy Authentication Required
Proxy-Authenticate: Digest realm="example.com"
     ,nonce="3bada1a0", algorithm="md5"
Content-Length: 0
```

--------------------------------

### Doxygen Return Value Documentation Example (return)

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Use the \return tag to describe the object or state returned by a function, especially when it's context-dependent.

```c++
/**
 \return	Description of the returned object and its content.
 */
```

--------------------------------

### Doxygen Function Parameter Documentation Example

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Document function parameters using the \param tag, specifying direction ([in], [out], [in,out]) and a description. Ensure parameter names match between definition and declaration.

```c++
/**
 \param g[out]		Buffer to receive something
 \param glen[in]	Length of buffer available to write
 */
void
X::getFubar(char *g, int glen)
...
```

--------------------------------

### Doxygen Return Value Documentation Example (retval)

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Use the \retval tag to document specific return values and their meanings. This is suitable for discrete return codes.

```c++
/**
 \retval 0	when FUBAR does not start with 'F'
 \retval 1	when FUBAR starts with F
 */
int
X::saidFubar()
...
```

--------------------------------

### SIP Proxy-Authorization Header Example

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

Example of a SIP Proxy-Authorization header sent by a client to authenticate using Digest Authentication. It includes algorithm, nonce, realm, response, URI, and username.

```sip
INVITE sip:97226491335@example.com SIP/2.0
Proxy-Authorization: Digest algorithm="md5",nonce="3bada1a0"
     ,opaque="",realm="example.com"
     ,response="f3ce87e6984557cd0fecc26f3c5e97a4"
     ,uri="sip:97226491335@10.0.69.38",username="12345678"
From: <sip:12345678@example.com>
To: <sip:97226491335@example.com>
```

--------------------------------

### Proxy Protocol v1 Example

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

An example of a Proxy Protocol v1 header line preceding an HTTP request. This format is human-readable and uses CRLF line endings.

```text
PROXY TCP4 192.168.0.1 192.168.0.11 56324 443\r\nGET / HTTP/1.1\r\nHost: 192.168.0.11\r\n\r\n
```

--------------------------------

### RADIUS Access-Request with Digest Attributes Example

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

Example of a RADIUS Access-Request packet containing Digest Authentication attributes. This includes User-Name, Digest-Response, Digest-Realm, Digest-Nonce, and Digest-Method.

```radius
Code = 1 (Access-Request)
Attributes:
NAS-IP-Address = a 0 45 26 (10.0.69.38)
NAS-Port-Type = 5 (Virtual)
User-Name = "12345678"
Digest-Response = "f3ce87e6984557cd0fecc26f3c5e97a4"
Digest-Realm = "example.com"
Digest-Nonce = "3bada1a0"
Digest-Method = "INVITE"

```

--------------------------------

### Proxy Protocol v2 Address Union

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

Illustrates a union structure for casting proxy address data to native socket structures. This example shows the structure for TCP/UDP over IPv4, which has a length of 12 bytes.

```c
union proxy_addr {
    struct {        /* for TCP/UDP over IPv4, len = 12 */

```

--------------------------------

### WPAD Protocol Pseudo-code

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-cooper-webi-wpad-00.txt

This pseudo-code outlines the WPAD protocol for discovering proxy configuration files. It details the order of operations, including DHCP, SLP, and various DNS record lookups.

```pseudo-code
load_CFILE() {
/* MUST use DHCP */
curl = dhcp_query(/*WPAD option  (Section 5.4.1) */);
if (curl != null) {  /* DHCP succeeded */
   if isvalid (read_CFILE(curl))
      return SUCCESS;  /* valid CFILE */
}

/* Should use SLP */
slp_list = slp_query(/*(WPAD attributes  (Section 5.4.2)*/);
while (slp_list != null) {  /* test each curl  */
   if isvalid(read_CFILE(slp_list.curl_data))
      return SUCCESS;   /* valid CFILE */
   else
      slp_list = slp_list.next;
}

/* all the DNS mechanisms */
TGTDOM = gethostbyname(me);
TGTDOM = strip_leading_component(TGTDOM);

while (is_not_canonical(TGTDOM)) {

   /* SHOULD try DNS SRV records */
   dns_list = dns_query(/*QNAME=wpad.TGTDOM.,
                                   QTYPE=SRV (Section 5.4.4)*/);
   while (dns_list != null) { /* each TXT record */
      if isvalid(read_CFILE(dns_list, curl_data))
         return SUCCESS;   /* valid CFILE */
      else
         dns_list = dns_list.next;
   }

   /* SHOULD try DNS TXT records */
   dns_list = dns_query(/*QNAME=wpad.TGTDOM.,
                                   QTYPE=TXT (Section 5.4.5)*/);
   while (dns_list != null) { /* each TXT record */
      if isvalid(read_CFILE(dns_list, curl_data))
         return SUCCESS;   /* valid CFILE */
      else
         dns_list = dns_list.next;
   }

   /* MUST try DNS A records */
   dns_list = dns_query(/*QNAME=wpad.TGTDOM.,
                                   QTYPE=A  (Section 5.4.3)*/);

   while (dns_list != null) { /* check each A record */
      if isvalid(read_CFILE(dns_list, curl_data))
         return SUCCESS;   /* valid CFILE */
      else
         dns_list = dns_list.next;
   }

   /* Still no match, remove leading component and iterate */
   TGTDOM = strip_leading_component(TGTDOM);

} /* no A, TXT or SRV records for wpad.* */

return FAILED;  /* could not locate valid CFILE */
}
```

--------------------------------

### CARP Load Factor Multiplier Calculation (X_1)

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

Calculates the initial Load Factor Multiplier (X_1) for the first proxy in an array. All X_n values are 32-bit floating point numbers.

```c
X_1 = pow ((K*p_1), (1/K))
```

--------------------------------

### CARP Load Factor Multiplier Calculation (X_k)

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

Iteratively calculates the Load Factor Multiplier (X_k) for subsequent proxies in an array, considering the number of proxies (K) and their relative load distribution (P_k). All X_n values are 32-bit floating point numbers.

```c
X_k = ([K-k+1] * [P_k - P_{k-1}])/(X_1 * X_2 * ... * X_{k-1})
X_k += pow ((X_{k-1}, {K-k+1})
X_k = pow (X_k, {1/(K-k+1)})
```

--------------------------------

### CARP Hash Combination Logic

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

Combines URL hash with member proxy hash using XOR, followed by multiplication and bitwise rotation to produce a combined hash. All values are 32-bit unsigned integers.

```c
Combined_Hash = (URL_hash ^ MemberProxy_Hash) ;
Combined_Hash += Combined_Hash * 0x62531965 ;
Combined_Hash = _rotl(Combined_Hash, 21) ;
```

--------------------------------

### CARP v1.0 Hash Function for URL

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

This pseudocode describes the hash function used to generate a 32-bit unsigned integer for a given URL. It iterates through each character of the URL, applying a bitwise left rotate and addition.

```pseudocode
For (each char in URL):
	URL_Hash +=  _rotl(URL_Hash, 19) + char ;
```

--------------------------------

### Squid Fixed Width Integer Types

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Use these fixed-width integer types when specific bit widths are required. Include 'squid.h' to access them.

```c
int16_t    -  16 bit signed.
uint16_t  -  16 bit unsigned.
int32_t    -  32 bit signed.
uint32_t  -  32 bit unsigned.
int64_t    -  64 bit signed.
uint64_t  -  64 bit unsigned.
```

--------------------------------

### CARP v1.0 Hash Function for Member Proxy Name

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

This pseudocode outlines the hash function for computing a 32-bit unsigned integer for a member proxy's name. It follows a similar pattern to the URL hash function, using bitwise left rotation.

```pseudocode
For (each char in MemberProxyName):
	MemberProxy_Hash +=  _rotl(MemberProxy_Hash, 19) + char ;
```

--------------------------------

### Security Info Component Structure

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-wilson-wccp-v2-12-oct-2001.txt

Details the structure of the Security Info Component, including Type, Length, Security Option, and Security Implementation fields. It supports no security or MD5 security.

```text
0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |             Type              |          Length               |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                         Security Option                       |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                     Security Implementation                   |
   |                               .                               |
   |                               .                               |
   |                               .                               |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```

--------------------------------

### WCCP Here I Am Packet Format

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-forster-wrec-wccp-v1-00.txt

Defines the structure of the WCCP 'Here I Am' packet, used by web caches to advertise their presence and capabilities to the router. Includes Type, Protocol Version, and Hash Revision fields.

```text
0                   1                   2                   3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                              Type                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         Protocol Version                      |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                          Hash Revision                        |
```

--------------------------------

### RADIUS Access-Accept with Digest-Response-Auth

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

RADIUS Access-Accept packet containing Digest-Response-Auth.

```text
Code = 2 (Access-Accept)
Attributes:
Digest-Response-Auth =
    "e644aa513effbfe1caff67103ff6433c"
```

--------------------------------

### Proxy Protocol v1/v2 Header Parsing

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

Sample C code to read and parse Proxy Protocol headers (v1 and v2) for TCP/UDP over IPv4, IPv6, and Unix domain sockets. The function is intended to be called upon a read event.

```c
struct sockaddr_storage from; /* already filled by accept() */
struct sockaddr_storage to;   /* already filled by getsockname() */
const char v2sig[12] = "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A";

/* returns 0 if needs to poll, <0 upon error or >0 if it did the job */
int read_evt(int fd)
{
    union {
        struct { 
            char line[108]; 
        } v1;
        struct {
            uint8_t sig[12];
            uint8_t ver_cmd;
            uint8_t fam;
            uint16_t len;
            union {
                struct {  /* for TCP/UDP over IPv4, len = 12 */
                    uint32_t src_addr;
                    uint32_t dst_addr;
                    uint16_t src_port;
                    uint16_t dst_port;
                } ip4;
                struct {  /* for TCP/UDP over IPv6, len = 36 */
                     uint8_t  src_addr[16];
                     uint8_t  dst_addr[16];
                     uint16_t src_port;
                     uint16_t dst_port;
                } ip6;
                struct {  /* for AF_UNIX sockets, len = 216 */
                     uint8_t src_addr[108];
                     uint8_t dst_addr[108];
                } unx;
            } addr;
        } v2;
    } hdr;

    int size, ret;

    do {
        ret = recv(fd, &hdr, sizeof(hdr), MSG_PEEK);
    } while (ret == -1 && errno == EINTR);

    if (ret == -1)
        return (errno == EAGAIN) ? 0 : -1;

    if (ret >= 16 && memcmp(&hdr.v2, v2sig, 12) == 0 &&
        (hdr.v2.ver_cmd & 0xF0) == 0x20) {
        size = 16 + hdr.v2.len;

```

--------------------------------

### Security Info Component Type and Options

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-wilson-wccp-v2-12-oct-2001.txt

Defines the Type value for the Security Info Component (WCCP2_SECURITY_INFO) and the available Security Options, including WCCP2_NO_SECURITY and WCCP2_MD5_SECURITY.

```text
Type

      WCCP2_SECURITY_INFO (0)

   Length

      Length of the remainder of the component.

   Security Option

      WCCP2_NO_SECURITY (0)
      WCCP2_MD5_SECURITY (1)
```

--------------------------------

### Input Validation Comments

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Illustrates Doxygen comments for input validation blocks within a function.

```C++
/** \par
 * When g is NULL or gen is 0 nothing is done */
if(g == NULL || glen < 1)
    return;

/** \par
 * When glen is longer than the accepted length it gets truncated */
if(glen > MAX_FOO) glen = MAX_FOO;
```

--------------------------------

### CARP Resultant Value Calculation

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

Calculates the final resultant value by multiplying the combined hash with the calculated Load Factor Multiplier for a specific proxy.

```c
Resultant_value = Combined_Hash * X_k
```

--------------------------------

### WCCP Message Header Type Values

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-wilson-wccp-v2-12-oct-2001.txt

Lists the defined type values for WCCP messages, such as HERE_I_AM, I_SEE_YOU, REDIRECT_ASSIGN, and REMOVAL_QUERY.

```text
Type

      WCCP2_HERE_I_AM (10)
      WCCP2_I_SEE_YOU (11)
      WCCP2_REDIRECT_ASSIGN (12)
      WCCP2_REMOVAL_QUERY (13)
```

--------------------------------

### Proxy Protocol v2 Binary Header Signature

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

The constant 12-byte signature that marks the beginning of a Proxy Protocol version 2 binary header. This signature must not be treated as a null-terminated string due to the null byte at the 5th position.

```binary
\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A
```

--------------------------------

### WCCP Message Header Version and Length Fields

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-wilson-wccp-v2-12-oct-2001.txt

Specifies the values for the Version and Length fields within the WCCP Message Header. The version is fixed at 0x200, and Length denotes the message size excluding the header.

```text
Version

      0x200

   Length

      Length of the WCCP message not including the WCCP Message Header.
```

--------------------------------

### Accessing Cache Manager Menu

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/03_MajorComponents.dox

This code snippet shows the URL format for accessing the cache manager menu. It is used to retrieve read-only information about the Squid cache.

```text
http://hostname:3128/squid-internal-mgr/menu
```

--------------------------------

### Proxy Protocol v2 Header Structure

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

Defines the structure of the 16-byte version 2 header for the Proxy Protocol. This structure includes the signature, version and command byte, family byte, and the length of the following address information.

```c
struct proxy_hdr_v2 {
    uint8_t sig[12];  /* hex 0D 0A 0D 0A 00 0D 0A 51 55 49 54 0A */
    uint8_t ver_cmd;  /* protocol version and command */
    uint8_t fam;      /* protocol family and address */
    uint16_t len;     /* number of following bytes part of the header */
};
```

--------------------------------

### Function Processing and State Update Comments

Source: https://github.com/squid-cache/squid/blob/master/doc/Programming-Guide/02_CodingConventions.dox

Shows Doxygen comments for the main processing logic and state updates within a function.

```C++
/** \par
 * Appends up to MAX_FOO bytes from g onto the end of state->foo
 * then passes the state off to FUBAR.
 * No check for null-termination is done.
 */
memcpy(g, glen, state->foo_end_ptr );
state->foo_end_ptr += glen;
fubar(state);
}
```

--------------------------------

### CARP Member Hashing Operations

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-vinod-carp-v1-03.txt

These operations are used to further spread hash values across the hash space to differentiate between similar member names.

```c
MemberProxy_Hash += MemberProxy_Hash * 0x62531965 ;
MemberProxy_Hash = _rotl (MemberProxy_Hash, 21) ;
```

--------------------------------

### PROXY Protocol v1 Signature

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

This is the signature string for PROXY protocol version 1. It is identified by the ASCII representation 'PROXY'.

```text
\x50\x52\x4F\x58\x59
```

--------------------------------

### HTTP Digest Authentication Required Header

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

WWW-Authenticate header for HTTP Digest authentication.

```http
HTTP/1.1 407 Authentication Required
WWW-Authenticate: Digest realm="example.com",
    domain="/index.html",
	nonce="a3086ac8", algorithm="md5"
Content-Length: 0
```

--------------------------------

### WCCP Message Header Structure

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-wilson-wccp-v2-12-oct-2001.txt

Defines the structure of the WCCP Message Header, including fields for Type, Version, and Length. The length field specifies the size of the message excluding the header.

```text
0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                              Type                             |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |           Version             |          Length               |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```

--------------------------------

### SIP Digest Authentication Request Attributes

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

Attributes exchanged in a SIP Digest authentication request.

```text
Digest-URI = "sip:97226491335@example.com"
Digest-Algorithm = "md5"
Digest-Username =  "12345678"
SIP-AOR =  "sip:12345678@example.com"
```

--------------------------------

### SIP Digest Authentication Response Attributes

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

Attributes exchanged in a SIP Digest authentication response.

```text
Code = 2 (Access-Accept)
Attributes:
Digest-Response-Auth =
                "6303c41b0e2c3e524e413cafe8cce954"
```

--------------------------------

### PROXY Protocol TLV Structure

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

Defines the Type-Length-Value (TLV) vector structure used in PROXY protocol version 2 for additional information.

```c
struct {
    uint8_t type;
    uint8_t length_hi;
    uint8_t length_lo;
    uint8_t value[0];
} tlv;
```

--------------------------------

### PROXY Protocol v2 Signature

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

This is the signature block for PROXY protocol version 2. It must be present at the beginning of the header for version 2 identification.

```text
\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A\x02
```

--------------------------------

### RADIUS Access-Request with Digest Attributes

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

RADIUS Access-Request packet including Digest authentication attributes.

```text
Code = 1 (Access-Request)
Attributes:
NAS-IP-Address = a 0 45 26 (10.0.69.38)
NAS-Port-Type = 5 (Virtual)
User-Name = "12345678"
Digest-Response = "f052b68058b2987aba493857ae1ab002"
Digest-Realm = "example.com"
Digest-Nonce = "a3086ac8"
Digest-Method = "GET"
Digest-URI = "/index.html"
Digest-Algorithm = "md5"
Digest-Username =  "12345678"
```

--------------------------------

### HTTP Digest Authentication Authorization Header

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/draft-ietf-radext-digest-auth-06.txt

Authorization header for HTTP Digest authentication.

```http
GET /index.html HTTP/1.1
Authorization: Digest algorithm="md5",nonce="a3086ac8"
           ,opaque="",realm="example.com"
           ,response="f052b68058b2987aba493857ae1ab002"
           ,uri="/index.html",username="12345678"
```

--------------------------------

### Parse Proxy Protocol v2 Header

Source: https://github.com/squid-cache/squid/blob/master/doc/rfc/proxy-protocol.txt

Parses the version 2 Proxy Protocol header, extracting source and destination addresses for both IPv4 and IPv6 TCP connections. Handles unsupported commands and truncated headers.

```c
          if (ret < size)
              return -1; /* truncated or too large header */

          switch (hdr.v2.ver_cmd & 0xF) {
          case 0x01: /* PROXY command */
              switch (hdr.v2.fam) {
              case 0x11:  /* TCPv4 */
                  ((struct sockaddr_in *)&from)->sin_family = AF_INET;
                  ((struct sockaddr_in *)&from)->sin_addr.s_addr =
                      hdr.v2.addr.ip4.src_addr;
                  ((struct sockaddr_in *)&from)->sin_port =
                      hdr.v2.addr.ip4.src_port;
                  ((struct sockaddr_in *)&to)->sin_family = AF_INET;
                  ((struct sockaddr_in *)&to)->sin_addr.s_addr =
                      hdr.v2.addr.ip4.dst_addr;
                  ((struct sockaddr_in *)&to)->sin_port =
                      hdr.v2.addr.ip4.dst_port;
                  goto done;
              case 0x21:  /* TCPv6 */
                  ((struct sockaddr_in6 *)&from)->sin6_family = AF_INET6;
                  memcpy(&((struct sockaddr_in6 *)&from)->sin6_addr,
                      hdr.v2.addr.ip6.src_addr, 16);
                  ((struct sockaddr_in6 *)&from)->sin6_port =
                      hdr.v2.addr.ip6.src_port;
                  ((struct sockaddr_in6 *)&to)->sin6_family = AF_INET6;
                  memcpy(&((struct sockaddr_in6 *)&to)->sin6_addr,
                      hdr.v2.addr.ip6.dst_addr, 16);
                  ((struct sockaddr_in6 *)&to)->sin6_port =
                      hdr.v2.addr.ip6.dst_port;
                  goto done;
              }
              /* unsupported protocol, keep local connection address */
              break;
          case 0x00: /* LOCAL command */
              /* keep local connection address for LOCAL */
              break;
          default:
              return -1; /* not a supported command */
          }
      }
      else if (ret >= 8 && memcmp(hdr.v1.line, "PROXY", 5) == 0) {
          char *end = memchr(hdr.v1.line, '\r', ret - 1);
          if (!end || end[1] != '\n')
              return -1; /* partial or invalid header */
          *end = '\0'; /* terminate the string to ease parsing */
          size = end + 2 - hdr.v1.line; /* skip header + CRLF */
          /* parse the V1 header using favorite address parsers like inet_pton.
           * return -1 upon error, or simply fall through to accept.
           */
      }
      else {
          /* Wrong protocol */
          return -1;
      }

  done:
      /* we need to consume the appropriate amount of data from the socket */
      do {
          ret = recv(fd, &hdr, size, 0);
      } while (ret == -1 && errno == EINTR);
      return (ret >= 0) ? 1 : -1;
  }

```
Tokens:
Raw