1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
package main
import (
"fmt"
"log"
"net"
"os"
"os/exec"
"strconv"
"strings"
)
const (
maximumCommandLength = 256
modeStatic = 0
modeDynamic = 1
)
func main() {
fingerPortOption := os.Getenv("GIGI_PORT")
modeOption := os.Getenv("GIGI_DYNAMIC")
mode := modeStatic
if fingerPortOption == "" {
fingerPortOption = "79"
}
if modeOption != "" {
if mode, _ = strconv.Atoi(modeOption); mode > 0 {
mode = modeDynamic
}
}
listener, listenerError := net.Listen("tcp", fmt.Sprintf(":%s", fingerPortOption))
if listenerError != nil {
log.Fatalf("error: %s\n", listenerError.Error())
}
for {
connection, connectionError := listener.Accept()
if connectionError != nil {
log.Println("warn: listener could not accept connection")
}
go handleConnection(connection, mode)
}
}
func handleConnection(connection net.Conn, mode int) {
defer connection.Close()
connectionReadBuffer := make([]byte, maximumCommandLength)
_, readError := connection.Read(connectionReadBuffer)
if readError != nil {
log.Println("warn: could not read from connection")
return
}
bufferContent := strings.ReplaceAll(
strings.ReplaceAll(
strings.ReplaceAll(string(connectionReadBuffer), "\x00", ""),
"\n", ""), "\r", "")
if len(bufferContent) == 0 {
bufferContent = "default"
}
var fileContent string
var fileReadError error
switch mode {
case modeDynamic:
fileContent, fileReadError = runFile(bufferContent)
default:
fileContent, fileReadError = readFile(bufferContent)
}
if fileReadError != nil {
log.Printf("warn: could not read from file: %s", bufferContent)
return
}
if _, connectionWriteError := connection.Write([]byte(fileContent)); connectionWriteError != nil {
log.Printf("warn: could not write to connection: %s", connectionWriteError.Error())
} else {
log.Printf("info: success: %s", bufferContent)
}
}
func readFile(filename string) (string, error) {
fileContent, fileReadError := os.ReadFile(fmt.Sprintf("./.gigi/%s", filename))
if fileReadError != nil {
fileContent, fileReadError = os.ReadFile("./.gigi/default")
if fileReadError != nil {
log.Printf("error: could not read from file: %s\n", filename)
return "", fileReadError
}
}
return string(fileContent), nil
}
func runFile(arguments string) (string, error) {
command := exec.Command("./.gigi/do", arguments)
commandOutput, commandError := command.Output()
if commandError != nil {
log.Printf("error: could not run command: %s\n", commandError)
return "", commandError
}
return string(commandOutput), nil
}
|