switch to go vendoring

vendor/github.com/egirna/icap-client/parser.go

@@ -0,0 +1,179 @@
+package icapclient
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// getStatusWithCode prepares the status code and status text from two given strings
+func getStatusWithCode(str1, str2 string) (int, string, error) {
+
+	statusCode, err := strconv.Atoi(str1)
+
+	if err != nil {
+		return 0, "", err
+	}
+
+	status := strings.TrimSpace(str2)
+
+	return statusCode, status, nil
+}
+
+// getHeaderVal parses the header and its value from a tcp message string
+func getHeaderVal(str string) (string, string) {
+
+	headerVals := strings.SplitN(str, ":", 2)
+	header := headerVals[0]
+	val := ""
+
+	if len(headerVals) >= 2 {
+		val = strings.TrimSpace(headerVals[1])
+	}
+
+	return header, val
+
+}
+
+// isRequestLine determines if the tcp message string is a request line, i.e the first line of the message or not
+func isRequestLine(str string) bool {
+	return strings.Contains(str, ICAPVersion) || strings.Contains(str, HTTPVersion)
+}
+
+// setEncapsulatedHeaderValue generates the Encapsulated  values and assigns to the ICAP request string
+func setEncapsulatedHeaderValue(icapReqStr *string, httpReqStr, httpRespStr string) {
+	encpVal := " "
+
+	if strings.HasPrefix(*icapReqStr, MethodOPTIONS) { // if the request method is OPTIONS
+		if httpReqStr == "" && httpRespStr == "" { // the most common case for OPTIONS method, no Encapsulated body
+			encpVal += "null-body=0"
+		} else {
+			encpVal += "opt-body=0" // if there is an Encapsulated body
+		}
+	}
+
+	if strings.HasPrefix(*icapReqStr, MethodREQMOD) || strings.HasPrefix(*icapReqStr, MethodRESPMOD) { // if the request method is RESPMOD or REQMOD
+		re := regexp.MustCompile(DoubleCRLF)                // looking for the match of the string \r\n\r\n, as that is the expression that seperates each blocks, i.e headers and bodies
+		reqIndices := re.FindAllStringIndex(httpReqStr, -1) // getting the offsets of the matches, tells us the starting/ending point of headers and bodies
+
+		reqEndsAt := 0 // this is needed to calculate the response headers by adding the last offset of the request block
+		if reqIndices != nil {
+			encpVal += "req-hdr=0"
+			reqEndsAt = reqIndices[0][1]
+			if len(reqIndices) > 1 { // indicating there is a body present for the request block, as length would have been 1 for a single match of \r\n\r\n
+				encpVal += fmt.Sprintf(", req-body=%d", reqIndices[0][1]) // assigning the starting point of the body
+				reqEndsAt = reqIndices[1][1]
+			} else if httpRespStr == "" {
+				encpVal += fmt.Sprintf(", null-body=%d", reqIndices[0][1])
+			}
+			if httpRespStr != "" {
+				encpVal += ", "
+			}
+		}
+
+		respIndices := re.FindAllStringIndex(httpRespStr, -1)
+
+		if respIndices != nil {
+			encpVal += fmt.Sprintf("res-hdr=%d", reqEndsAt)
+			if len(respIndices) > 1 {
+				encpVal += fmt.Sprintf(", res-body=%d", reqEndsAt+respIndices[0][1])
+			} else {
+				encpVal += fmt.Sprintf(", null-body=%d", reqEndsAt+respIndices[0][1])
+			}
+		}
+
+	}
+
+	*icapReqStr = fmt.Sprintf(*icapReqStr, encpVal) // formatting the ICAP request Encapsulated header with the value
+}
+
+// replaceRequestURIWithActualURL replaces the just the escaped portion of the url with the entire URL in the dumped request message
+func replaceRequestURIWithActualURL(str *string, uri, url string) {
+	if uri == "" {
+		uri = "/"
+	}
+	*str = strings.Replace(*str, uri, url, 1)
+}
+
+// addFullBodyInPreviewIndicator adds 0; ieof\r\n\r\n which indicates the entire body fitted in preview
+func addFullBodyInPreviewIndicator(str *string) {
+	*str = strings.TrimSuffix(*str, DoubleCRLF)
+	*str += fullBodyEndIndicatorPreviewMode
+}
+
+// splitBodyAndHeader separates header and body from a http message
+func splitBodyAndHeader(str string) (string, string, bool) {
+	ss := strings.SplitN(str, DoubleCRLF, 2)
+
+	if len(ss) < 2 || ss[1] == "" {
+		return "", "", false
+	}
+
+	headerStr := ss[0]
+	bodyStr := ss[1]
+
+	return headerStr, bodyStr, true
+}
+
+// bodyAlreadyChunked determines if the http body is already chunked from the origin server or not
+func bodyAlreadyChunked(str string) bool {
+	_, bodyStr, ok := splitBodyAndHeader(str)
+
+	if !ok {
+		return false
+	}
+
+	r := regexp.MustCompile("\\r\\n0(\\r\\n)+$")
+	return r.MatchString(bodyStr)
+
+}
+
+// parsePreviewBodyBytes parses the preview portion of the body and only keeps that in the message
+func parsePreviewBodyBytes(str *string, pb int) {
+
+	headerStr, bodyStr, ok := splitBodyAndHeader(*str)
+
+	if !ok {
+		return
+	}
+
+	bodyStr = bodyStr[:pb]
+
+	*str = headerStr + DoubleCRLF + bodyStr
+}
+
+// addHexaBodyByteNotations adds the hexadecimal byte notaions in the messages
+// for example: Hello World, becomes
+// b
+// Hello World
+// 0
+func addHexaBodyByteNotations(bodyStr *string) {
+
+	bodyBytes := []byte(*bodyStr)
+
+	*bodyStr = fmt.Sprintf("%x%s%s%s", len(bodyBytes), CRLF, *bodyStr, bodyEndIndicator)
+}
+
+// mergeHeaderAndBody merges the header and body of the http message togather
+func mergeHeaderAndBody(src *string, headerStr, bodyStr string) {
+	*src = headerStr + DoubleCRLF + bodyStr
+}
+
+func chunkBodyByBytes(bdyByte []byte, cl int) []byte {
+
+	newBytes := []byte{}
+
+	for i := 0; i < len(bdyByte); i += cl {
+		end := i + cl
+		if end > len(bdyByte) {
+			end = len(bdyByte)
+		}
+
+		newBytes = append(newBytes, []byte(fmt.Sprintf("%x\r\n", len(bdyByte[i:end]))+string(bdyByte[i:end]))...)
+	}
+
+	newBytes = append(newBytes, []byte(bodyEndIndicator)...)
+
+	return newBytes
+}