summaryrefslogblamecommitdiff
path: root/user/gitlab-runner/posix-shell-escape.patch
blob: b454141edf1ded71d619e3c7c1466a247b03f246 (plain) (tree)









































































































































                                                                                                             
--- gitlab-runner-v12.1.0/helpers/shell_escape.go	2019-07-19 12:13:32.000000000 +0000
+++ gitlab-runner-v12.1.0/helpers/shell_escape.go	2020-04-26 23:12:59.813309281 +0000
@@ -4,7 +4,6 @@ package helpers
 
 import (
 	"bytes"
-	"encoding/hex"
 	"strings"
 )
 
@@ -13,35 +12,10 @@ import (
  */
 
 const (
-	ACK           = 6
-	TAB           = 9
-	LF            = 10
-	CR            = 13
-	US            = 31
-	SPACE         = 32
-	AMPERSTAND    = 38
 	SINGLE_QUOTE  = 39
-	PLUS          = 43
-	NINE          = 57
-	QUESTION      = 63
-	LOWERCASE_Z   = 90
-	OPEN_BRACKET  = 91
 	BACKSLASH     = 92
-	UNDERSCORE    = 95
-	CLOSE_BRACKET = 93
-	BACKTICK      = 96
-	TILDA         = 126
-	DEL           = 127
 )
 
-// ShellEscape is taken from https://github.com/solidsnack/shell-escape/blob/master/Text/ShellEscape/Bash.hs
-/*
-A Bash escaped string. The strings are wrapped in @$\'...\'@ if any
-bytes within them must be escaped; otherwise, they are left as is.
-Newlines and other control characters are represented as ANSI escape
-sequences. High bytes are represented as hex codes. Thus Bash escaped
-strings will always fit on one line and never contain non-ASCII bytes.
-*/
 func ShellEscape(str string) string {
 	if str == "" {
 		return "''"
@@ -50,85 +24,20 @@ func ShellEscape(str string) string {
 	out := bytes.NewBuffer(make([]byte, 0, len(str)*2))
 	i := 0
 	l := len(in)
-	escape := false
-
-	hex := func(char byte) {
-		escape = true
-
-		data := []byte{BACKSLASH, 'x', 0, 0}
-		hex.Encode(data[2:], []byte{char})
-		out.Write(data)
-	}
-
-	backslash := func(char byte) {
-		escape = true
-		out.Write([]byte{BACKSLASH, char})
-	}
-
-	escaped := func(str string) {
-		escape = true
-		out.WriteString(str)
-	}
-
-	quoted := func(char byte) {
-		escape = true
-		out.WriteByte(char)
-	}
-
-	literal := func(char byte) {
-		out.WriteByte(char)
-	}
 
+	out.WriteByte(SINGLE_QUOTE)
 	for i < l {
 		char := in[i]
-		switch {
-		case char == TAB:
-			escaped(`\t`)
-		case char == LF:
-			escaped(`\n`)
-		case char == CR:
-			escaped(`\r`)
-		case char <= US:
-			hex(char)
-		case char <= AMPERSTAND:
-			quoted(char)
-		case char == SINGLE_QUOTE:
-			backslash(char)
-		case char <= PLUS:
-			quoted(char)
-		case char <= NINE:
-			literal(char)
-		case char <= QUESTION:
-			quoted(char)
-		case char <= LOWERCASE_Z:
-			literal(char)
-		case char == OPEN_BRACKET:
-			quoted(char)
-		case char == BACKSLASH:
-			backslash(char)
-		case char <= CLOSE_BRACKET:
-			quoted(char)
-		case char == UNDERSCORE:
-			literal(char)
-		case char <= BACKTICK:
-			quoted(char)
-		case char <= TILDA:
-			quoted(char)
-		case char == DEL:
-			hex(char)
-		default:
-			hex(char)
+		if (char == SINGLE_QUOTE) {
+			out.Write([]byte{SINGLE_QUOTE, BACKSLASH, SINGLE_QUOTE, SINGLE_QUOTE})
+		} else {
+			out.WriteByte(char)
 		}
 		i++
 	}
+	out.WriteByte(SINGLE_QUOTE)
 
-	outStr := out.String()
-
-	if escape {
-		outStr = "$'" + outStr + "'"
-	}
-
-	return outStr
+	return out.String()
 }
 
 func ToBackslash(path string) string {