chore: auto-update Go modules

remove interactive global var.

.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+permissions:
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      -
+        name: Set up Go
+        uses: actions/setup-go@v5
+      -
+        name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+          distribution: goreleaser
+          version: '~> v2'
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/update-go-modules.yml

@@ -0,0 +1,30 @@
+name: Auto-Update Go Modules
+
+on:
+  schedule:
+    - cron: "0 0 * * 1" # Runs every Monday at midnight
+
+jobs:
+  update-go-modules:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: stable
+
+      - name: Update Dependencies
+        run: |
+          go get -u ./...
+          go mod tidy
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add go.mod go.sum
+          git commit -m "chore: auto-update Go modules"
+          git push

.gitignore

@@ -25,4 +25,7 @@ go.work.sum
 # env file
 .env
 
-cmd/aeiou
+# Added by goreleaser init:
+dist/
+
+cmd/codrcon

.goreleaser.yaml

@@ -0,0 +1,55 @@
+# This is an example .goreleaser.yml file with some sensible defaults.
+# Make sure to check the documentation at https://goreleaser.com
+
+# The lines below are called `modelines`. See `:help modeline`
+# Feel free to remove those if you don't want/need to use them.
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj
+
+version: 2
+
+before:
+  hooks:
+    # You may remove this if you don't use go modules.
+    - go mod tidy
+    # you may remove this if you don't need go generate
+    - go generate ./...
+
+builds:
+  - main: ./cmd/q3rcon/
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+    goarch:
+      - amd64
+
+archives:
+  - formats: ['tar.gz']
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{ .ProjectName }}_
+      {{- title .Os }}_
+      {{- if eq .Arch "amd64" }}x86_64
+      {{- else if eq .Arch "386" }}i386
+      {{- else }}{{ .Arch }}{{ end }}
+      {{- if .Arm }}v{{ .Arm }}{{ end }}
+    # use zip for windows archives
+    format_overrides:
+      - goos: windows
+        formats: ['zip']
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+
+release:
+  footer: >-
+
+    ---
+
+    Released by [GoReleaser](https://github.com/goreleaser/goreleaser).

CHANGELOG.md

@@ -11,9 +11,26 @@ Before any major/minor/patch bump all unit tests will be run to verify they pass
 
 -   [x]
 
+# [0.1.0] - 2024-11-29
+
+### Changed
+
+-   `-P` flag changed to `-r` for setting rcon password. This is to disambiguate it from the port (-p) flag.
+
+# [0.0.3] - 2024-11-24
+
+### Changed
+
+-   {Rcon}.login is no longer exported since it's called internally by the constructor.
+-   When checking the timeouts map the cmd is split from its arguments. This allows setting a timeout value for all `map mp_` for example.
+
+### Added
+
+-   Timeout values for commands in the timeouts map are now logged at Debug level.
+
 # [0.0.1] - 2024-11-04
 
 ### Added
 
--   Initial release, package implements Rcon using the Q3 procotocl.
+-   Initial release, package implements Rcon using the Q3 protocol.
 -   A basic CLI implementation accepting configuration flags.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Onyx and Iris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -52,16 +52,28 @@ func main() {
 }
 ```
 
-#### `WithDefaultTimeout(timeout time.Duration)`
+#### `WithLoginTimeout(timeout time.Duration)`
 
-You may want to change the default timeout if some of your responses are getting mixed together (stability can depend on connection to the server). For example, on LAN I can leave the default at 20ms, when connecting remotely I normally increase this to 50ms.
+If the server was just started or is currently performing a long operation like map rotating then it's possible to receive empty rcon responses. In which case you'll want to retry login. Use this functional option to set the max timeout for logins, it defaults to 5 seconds.
 
 For example:
 
 ```go
-	rcon, err := q3rcon.New(
-		host, port, password,
-		q3rcon.WithDefaultTimeout(50*time.Millisecond))
+rcon, err := q3rcon.New(
+	host, port, password,
+	q3rcon.WithLoginTimeout(2*time.Second))
+```
+
+#### `WithDefaultTimeout(timeout time.Duration)`
+
+You may want to change the default timeout if some of your responses are getting mixed together (stability can depend on connection to the server). For example, over localhost I can leave the default at 20ms, when connecting remotely I normally increase this to 50ms.
+
+For example:
+
+```go
+rcon, err := q3rcon.New(
+	host, port, password,
+	q3rcon.WithDefaultTimeout(50*time.Millisecond))
 ```
 
 #### `WithTimeouts(timeouts map[string]time.Duration)`
@@ -69,27 +81,27 @@ For example:
 Perhaps there are some requests that take a long time to receive a response but you want the whole response in one chunk. Pass a timeouts map, for example:
 
 ```go
-	timeouts := map[string]time.Duration{
-		"map_rotate":  1200 * time.Millisecond,
-		"map_restart": 1200 * time.Millisecond,
-	}
+timeouts := map[string]time.Duration{
+	"map_rotate":  1200 * time.Millisecond,
+	"map_restart": 1200 * time.Millisecond,
+}
 
-	rcon, err := q3rcon.New(
-		host, port, password,
-		q3rcon.WithTimeouts(timeouts))
+rcon, err := q3rcon.New(
+	host, port, password,
+	q3rcon.WithTimeouts(timeouts))
 ```
 
 ## Command line
 
-Pass `host`, `port` and `password` as flags, for example:
+Pass `host`, `port` and `rconpass` as flags, for example:
 
 ```
-q3rcon -h=localhost -p=30000 -P="rconpassword" "mapname"
+q3rcon -h=localhost -p=30000 -r="rconpassword" "mapname"
 ```
 
 -   `host` defaults to "localhost"
 -   `port` defaults to 28960
--   `password` defaults to ""
+-   `rconpass` defaults to ""
 
 Arguments following the flags will be sent as rcon commands. You may send multiple arguments.
 
@@ -98,13 +110,29 @@ Arguments following the flags will be sent as rcon commands. You may send multip
 Pass `interactive (-i shorthand)` flag to enable interactive mode, for example:
 
 ```
-q3rcon -h=localhost -p=30000 -P="rconpassword" -i
+q3rcon -h=localhost -p=30000 -r="rconpassword" -i
 ```
 
 If interactive mode is enabled, any arguments sent on the command line will be ignored.
 
-## `Logging`
+## Your own implementation
+
+The included CLI is a generic implementation, while it can be used out of the box you may find that some requests result in fragmented responses. The solution is to implement your own version, adjusting the timings with the functional options as detailed above. I could have increased the default timeouts but that would add unnecessary delay for most requests, so I decided to leave those details to the users of the package.
+
+Since you can include the q3rcon package into your own package you can easily make your own modifications, for example, I added [colour to the terminal][status] and [reformatted some of the responses][mapname].
+
+## Logging
 
 Log level may be set by passing the `-l` flag with a number from 0 up to 6 where
 
 0 = Panic, 1 = Fatal, 2 = Error, 3 = Warning, 4 = Info, 5 = Debug, 6 = Trace
+
+[status]: ./img/status.png
+[mapname]: ./img/mapname.png
+
+## Further Notes
+
+This rcon client is fully compatible with the [Q3 Rcon Proxy][q3rcon-proxy] package.
+
+
+[q3rcon-proxy]: https://github.com/onyx-and-iris/q3rcon-proxy/tree/dev

Taskfile.yml

@@ -0,0 +1,55 @@
+version: '3'
+
+vars:
+  PROGRAM: q3rcon
+  SHELL: '{{if eq .OS "Windows_NT"}}powershell{{end}}'
+  BIN_DIR: bin
+
+  WINDOWS: '{{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe'
+  LINUX: '{{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64'
+  GIT_COMMIT:
+    sh: git log -n 1 --format=%h
+
+tasks:
+  default:
+    desc: Build the q3rcon project
+    cmds:
+      - task: build
+
+  build:
+    desc: Build the q3rcon project
+    deps: [vet]
+    cmds:
+      - task: build-windows
+      - task: build-linux
+
+  vet:
+    desc: Vet the code
+    deps: [fmt]
+    cmds:
+      - go vet ./...
+
+  fmt:
+    desc: Fmt the code
+    cmds:
+      - go fmt ./...
+
+  build-windows:
+    desc: Build the q3rcon project for Windows
+    cmds:
+      - GOOS=windows GOARCH=amd64 go build -o {{.WINDOWS}} -ldflags="-X main.Version={{.GIT_COMMIT}}" ./cmd/{{.PROGRAM}}/
+
+  build-linux:
+    desc: Build the q3rcon project for Linux
+    cmds:
+      - GOOS=linux GOARCH=amd64 go build -o {{.LINUX}} -ldflags="-X main.Version={{.GIT_COMMIT}}" ./cmd/{{.PROGRAM}}/
+
+  test:
+    desc: Run tests
+    cmds:
+      - go test ./...
+
+  clean:
+    desc: Clean the build artifacts
+    cmds:
+      - '{{.SHELL}} rm -r {{.BIN_DIR}}'

cmd/q3rcon/main.go

@@ -14,22 +14,26 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-var interactive bool
+func exitOnError(err error) {
+	_, _ = fmt.Fprintf(os.Stderr, "Error: %s\n", err)
+	os.Exit(1)
+}
 
 func main() {
 	var (
-		host     string
-		port     int
-		password string
-		loglevel int
+		host        string
+		port        int
+		rconpass    string
+		interactive bool
+		loglevel    int
 	)
 
-	flag.StringVar(&host, "host", "localhost", "hostname of the server")
-	flag.StringVar(&host, "h", "localhost", "hostname of the server (shorthand)")
-	flag.IntVar(&port, "port", 28960, "port of the server")
-	flag.IntVar(&port, "p", 28960, "port of the server (shorthand)")
-	flag.StringVar(&password, "password", "", "hostname of the server")
-	flag.StringVar(&password, "P", "", "hostname of the server (shorthand)")
+	flag.StringVar(&host, "host", "localhost", "hostname of the gameserver")
+	flag.StringVar(&host, "h", "localhost", "hostname of the gameserver (shorthand)")
+	flag.IntVar(&port, "port", 28960, "port on which the gameserver resides, default is 28960")
+	flag.IntVar(&port, "p", 28960, "port on which the gameserver resides, default is 28960 (shorthand)")
+	flag.StringVar(&rconpass, "rconpass", os.Getenv("RCON_PASS"), "rcon password of the gameserver")
+	flag.StringVar(&rconpass, "r", os.Getenv("RCON_PASS"), "rcon password of the gameserver (shorthand)")
 
 	flag.BoolVar(&interactive, "interactive", false, "run in interactive mode")
 	flag.BoolVar(&interactive, "i", false, "run in interactive mode")
@@ -42,23 +46,49 @@ func main() {
 		log.SetLevel(log.Level(loglevel))
 	}
 
-	rcon, err := connectRcon(host, port, password)
+	if port < 1024 || port > 65535 {
+		exitOnError(fmt.Errorf("invalid port value, got: (%d) expected: in range 1024-65535", port))
+	}
+
+	if len(rconpass) < 8 {
+		exitOnError(fmt.Errorf("invalid rcon password, got: (%s) expected: at least 8 characters", rconpass))
+	}
+
+	rcon, err := connectRcon(host, port, rconpass)
 	if err != nil {
-		log.Fatal(err)
+		exitOnError(err)
 	}
 	defer rcon.Close()
 
-	if interactive {
-		fmt.Printf("Enter 'Q' to exit.\n>> ")
-		err := interactiveMode(rcon, os.Stdin)
-		if err != nil {
-			log.Fatal(err)
-		}
+	if !interactive {
+		runCommands(flag.Args(), rcon)
 		return
 	}
 
-	for _, arg := range flag.Args() {
-		resp, err := rcon.Send(arg)
+	fmt.Printf("Enter 'Q' to exit.\n>> ")
+	err = interactiveMode(rcon, os.Stdin)
+	if err != nil {
+		exitOnError(err)
+	}
+}
+
+func connectRcon(host string, port int, password string) (*q3rcon.Rcon, error) {
+	rcon, err := q3rcon.New(host, port, password)
+	if err != nil {
+		return nil, err
+	}
+	return rcon, nil
+}
+
+// runCommands runs the commands given in the flag.Args slice.
+// If no commands are given, it defaults to running the "status" command.
+func runCommands(commands []string, rcon *q3rcon.Rcon) {
+	if len(commands) == 0 {
+		commands = append(commands, "status")
+	}
+
+	for _, cmd := range commands {
+		resp, err := rcon.Send(cmd)
 		if err != nil {
 			log.Error(err)
 			continue
@@ -67,21 +97,12 @@ func main() {
 	}
 }
 
-func connectRcon(host string, port int, password string) (*q3rcon.Rcon, error) {
-	rcon, err := q3rcon.New(
-		host, port, password)
-	if err != nil {
-		return nil, err
-	}
-	return rcon, nil
-}
-
 // interactiveMode continuously reads from input until a quit signal is given.
 func interactiveMode(rcon *q3rcon.Rcon, input io.Reader) error {
 	scanner := bufio.NewScanner(input)
 	for scanner.Scan() {
 		cmd := scanner.Text()
-		if strings.ToUpper(cmd) == "Q" {
+		if strings.EqualFold(cmd, "Q") {
 			return nil
 		}
 
@@ -92,6 +113,7 @@ func interactiveMode(rcon *q3rcon.Rcon, input io.Reader) error {
 		}
 		fmt.Printf("%s>> ", resp)
 	}
+
 	if scanner.Err() != nil {
 		return scanner.Err()
 	}

go.mod

@@ -2,13 +2,6 @@ module github.com/onyx-and-iris/q3rcon
 
 go 1.23.0
 
-require (
-	github.com/fatih/color v1.18.0
-	github.com/sirupsen/logrus v1.9.3
-)
+require github.com/sirupsen/logrus v1.9.3
 
-require (
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	golang.org/x/sys v0.25.0 // indirect
-)
+require golang.org/x/sys v0.31.0 // indirect

go.sum

@@ -1,13 +1,6 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
@@ -16,10 +9,8 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/conn/conn.go

@@ -1,19 +1,15 @@
 package conn
 
 import (
-	"bytes"
 	"fmt"
 	"net"
-	"strings"
 	"time"
 
-	"github.com/onyx-and-iris/q3rcon/internal/packet"
 	log "github.com/sirupsen/logrus"
 )
 
 type UDPConn struct {
-	conn     *net.UDPConn
-	response packet.Response
+	conn *net.UDPConn
 }
 
 func New(host string, port int) (UDPConn, error) {
@@ -28,8 +24,7 @@ func New(host string, port int) (UDPConn, error) {
 	log.Infof("Outgoing address %s", conn.RemoteAddr())
 
 	return UDPConn{
-		conn:     conn,
-		response: packet.NewResponse(),
+		conn: conn,
 	}, nil
 }
 
@@ -42,39 +37,13 @@ func (c UDPConn) Write(buf []byte) (int, error) {
 	return n, nil
 }
 
-func (c UDPConn) Listen(timeout time.Duration, resp chan<- string, errChan chan<- error) {
-	c.conn.SetReadDeadline(time.Now().Add(timeout))
-	done := make(chan struct{})
-	var sb strings.Builder
-	buf := make([]byte, 2048)
-
-	for {
-		select {
-		case <-done:
-			resp <- sb.String()
-			return
-		default:
-			rlen, _, err := c.conn.ReadFromUDP(buf)
-			if err != nil {
-				e, ok := err.(net.Error)
-				if ok {
-					if e.Timeout() {
-						close(done)
-					} else {
-						errChan <- e
-						return
-					}
-				}
-			}
-			if rlen < len(c.response.Header()) {
-				continue
-			}
-
-			if bytes.HasPrefix(buf, c.response.Header()) {
-				sb.Write(buf[len(c.response.Header()):rlen])
-			}
-		}
+func (c UDPConn) ReadUntil(timeout time.Time, buf []byte) (int, error) {
+	c.conn.SetReadDeadline(timeout)
+	rlen, _, err := c.conn.ReadFromUDP(buf)
+	if err != nil {
+		return 0, err
 	}
+	return rlen, nil
 }
 
 func (c UDPConn) Close() error {

internal/packet/request.go

@@ -1,16 +1,23 @@
 package packet
 
-import "fmt"
+import (
+	"bytes"
+	"fmt"
+)
+
+const bufSz = 512
 
 type Request struct {
 	magic    []byte
 	password string
+	buf      *bytes.Buffer
 }
 
 func NewRequest(password string) Request {
 	return Request{
 		magic:    []byte{'\xff', '\xff', '\xff', '\xff'},
 		password: password,
+		buf:      bytes.NewBuffer(make([]byte, bufSz)),
 	}
 }
 
@@ -19,7 +26,8 @@ func (r Request) Header() []byte {
 }
 
 func (r Request) Encode(cmd string) []byte {
-	datagram := r.Header()
-	datagram = append(datagram, fmt.Sprintf(" %s %s", r.password, cmd)...)
-	return datagram
+	r.buf.Reset()
+	r.buf.Write(r.Header())
+	r.buf.WriteString(fmt.Sprintf(" %s %s", r.password, cmd))
+	return r.buf.Bytes()
 }

makefile

@@ -1,11 +1,11 @@
-program = q3rcon
+PROGRAM = q3rcon
 
 GO = @go
 BIN_DIR := bin
 
-WINDOWS=$(BIN_DIR)/$(program)_windows_amd64.exe
-LINUX=$(BIN_DIR)/$(program)_linux_amd64
-VERSION=$(shell git describe --tags --always --long --dirty)
+WINDOWS=$(BIN_DIR)/$(PROGRAM)_windows_amd64.exe
+LINUX=$(BIN_DIR)/$(PROGRAM)_linux_amd64
+VERSION=$(shell git log -n 1 --format=%h)
 
 .DEFAULT_GOAL := build
 
@@ -25,10 +25,10 @@ linux: $(LINUX)
 
 
 $(WINDOWS):
-	env GOOS=windows GOARCH=amd64 go build -v -o $(WINDOWS) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/q3rcon/
+	env GOOS=windows GOARCH=amd64 go build -v -o $(WINDOWS) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/$(PROGRAM)/
 
 $(LINUX):
-	env GOOS=linux GOARCH=amd64 go build -v -o $(LINUX) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/q3rcon/
+	env GOOS=linux GOARCH=amd64 go build -v -o $(LINUX) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/$(PROGRAM)/
 
 test:
 	$(GO) test ./...

option.go

@@ -0,0 +1,27 @@
+package q3rcon
+
+import "time"
+
+// Option is a functional option type that allows us to configure the VbanTxt.
+type Option func(*Rcon)
+
+// WithLoginTimeout is a functional option to set the login timeout
+func WithLoginTimeout(timeout time.Duration) Option {
+	return func(rcon *Rcon) {
+		rcon.loginTimeout = timeout
+	}
+}
+
+// WithDefaultTimeout is a functional option to set the default response timeout
+func WithDefaultTimeout(timeout time.Duration) Option {
+	return func(rcon *Rcon) {
+		rcon.defaultTimeout = timeout
+	}
+}
+
+// WithTimeouts is a functional option to set the timeouts for responses per command
+func WithTimeouts(timeouts map[string]time.Duration) Option {
+	return func(rcon *Rcon) {
+		rcon.timeouts = timeouts
+	}
+}

q3rcon.go

@@ -1,39 +1,28 @@
 package q3rcon
 
 import (
+	"bytes"
 	"errors"
+	"net"
 	"strings"
 	"time"
 
+	log "github.com/sirupsen/logrus"
+
 	"github.com/onyx-and-iris/q3rcon/internal/conn"
 	"github.com/onyx-and-iris/q3rcon/internal/packet"
 )
 
-// Option is a functional option type that allows us to configure the VbanTxt.
-type Option func(*Rcon)
-
-func WithDefaultTimeout(timeout time.Duration) Option {
-	return func(rcon *Rcon) {
-		rcon.defaultTimeout = timeout
-	}
-}
-
-// WithTimeouts is a functional option to set the timeouts for responses
-func WithTimeouts(timeouts map[string]time.Duration) Option {
-	return func(rcon *Rcon) {
-		rcon.timeouts = timeouts
-	}
-}
+const respBufSiz = 2048
 
 type Rcon struct {
 	conn     conn.UDPConn
 	request  packet.Request
 	response packet.Response
 
+	loginTimeout   time.Duration
 	defaultTimeout time.Duration
 	timeouts       map[string]time.Duration
-
-	resp chan string
 }
 
 func New(host string, port int, password string, options ...Option) (*Rcon, error) {
@@ -47,9 +36,11 @@ func New(host string, port int, password string, options ...Option) (*Rcon, erro
 	}
 
 	r := &Rcon{
-		conn:           conn,
-		request:        packet.NewRequest(password),
-		resp:           make(chan string),
+		conn:     conn,
+		request:  packet.NewRequest(password),
+		response: packet.NewResponse(),
+
+		loginTimeout:   5 * time.Second,
 		defaultTimeout: 20 * time.Millisecond,
 		timeouts:       make(map[string]time.Duration),
 	}
@@ -58,16 +49,15 @@ func New(host string, port int, password string, options ...Option) (*Rcon, erro
 		o(r)
 	}
 
-	err = r.Login()
-	if err != nil {
+	if err = r.login(); err != nil {
 		return nil, err
 	}
 
 	return r, nil
 }
 
-func (r Rcon) Login() error {
-	timeout := time.After(2 * time.Second)
+func (r Rcon) login() error {
+	timeout := time.After(r.loginTimeout)
 	for {
 		select {
 		case <-timeout:
@@ -90,24 +80,63 @@ func (r Rcon) Login() error {
 	}
 }
 
-func (r Rcon) Send(cmd string) (string, error) {
+func (r Rcon) Send(cmdWithArgs string) (string, error) {
+	cmd, _, _ := strings.Cut(string(cmdWithArgs), " ")
 	timeout, ok := r.timeouts[cmd]
 	if !ok {
 		timeout = r.defaultTimeout
+	} else {
+		log.Debugf("%s in timeouts map, using timeout %v", cmd, timeout)
 	}
 
-	e := make(chan error)
-	go r.conn.Listen(timeout, r.resp, e)
-	_, err := r.conn.Write(r.request.Encode(cmd))
+	respChan := make(chan string)
+	errChan := make(chan error)
+
+	go r.listen(timeout, respChan, errChan)
+
+	_, err := r.conn.Write(r.request.Encode(cmdWithArgs))
 	if err != nil {
 		return "", err
 	}
 
 	select {
-	case err := <-e:
+	case err := <-errChan:
 		return "", err
-	case resp := <-r.resp:
-		return strings.TrimPrefix(resp, string(r.response.Header())), nil
+	case resp := <-respChan:
+		return resp, nil
+	}
+}
+
+func (r Rcon) listen(timeout time.Duration, respChan chan<- string, errChan chan<- error) {
+	done := make(chan struct{})
+	respBuf := make([]byte, respBufSiz)
+	var sb strings.Builder
+
+	for {
+		select {
+		case <-done:
+			respChan <- sb.String()
+			return
+		default:
+			rlen, err := r.conn.ReadUntil(time.Now().Add(timeout), respBuf)
+			if err != nil {
+				e, ok := err.(net.Error)
+				if ok {
+					if e.Timeout() {
+						close(done)
+					} else {
+						errChan <- e
+						return
+					}
+				}
+			}
+
+			if rlen > len(r.response.Header()) {
+				if bytes.HasPrefix(respBuf, r.response.Header()) {
+					sb.Write(respBuf[len(r.response.Header()):rlen])
+				}
+			}
+		}
 	}
 }