Update deps

vendor/github.com/kardianos/service/.gitignore

@@ -0,0 +1 @@
+.vscode/

vendor/github.com/kardianos/service/service.go

@@ -94,6 +94,8 @@ const (
 	optionUpstartScript = "UpstartScript"
 	optionLaunchdConfig = "LaunchdConfig"
 	optionOpenRCScript  = "OpenRCScript"
+
+	optionLogDirectory = "LogDirectory"
 )
 
 // Status represents service status as an byte value
@@ -134,6 +136,8 @@ type Config struct {
 
 	// System specific options.
 	Option KeyValue
+
+	EnvVars map[string]string
 }
 
 var (
@@ -184,6 +188,8 @@ func New(i Interface, c *Config) (Service, error) {
 //    - Restart       string (always)           - How shall service be restarted.
 //    - SuccessExitStatus string ()             - The list of exit status that shall be considered as successful,
 //                                                in addition to the default ones.
+//    - LogDirectory string(/var/log)           - The path to the log files directory
+//
 //  * Linux (systemd)
 //    - LimitNOFILE   int    (-1)               - Maximum open files (ulimit -n)
 //                                                (https://serverfault.com/questions/628610/increasing-nproc-for-processes-launched-by-systemd-on-centos-7)

vendor/github.com/kardianos/service/service_aix.go

@@ -159,11 +159,15 @@ func (s *aixService) Install() error {
 	if err = os.Chmod(confPath, 0755); err != nil {
 		return err
 	}
+	rcd := "/etc/rc"
+	if _, err = os.Stat("/etc/rc.d/rc2.d"); err == nil {
+		rcd = "/etc/rc.d/rc"
+	}
 	for _, i := range [...]string{"2", "3"} {
-		if err = os.Symlink(confPath, "/etc/rc"+i+".d/S50"+s.Name); err != nil {
+		if err = os.Symlink(confPath, rcd+i+".d/S50"+s.Name); err != nil {
 			continue
 		}
-		if err = os.Symlink(confPath, "/etc/rc"+i+".d/K02"+s.Name); err != nil {
+		if err = os.Symlink(confPath, rcd+i+".d/K02"+s.Name); err != nil {
 			continue
 		}
 	}

vendor/github.com/kardianos/service/service_darwin.go

@@ -20,19 +20,25 @@ import (
 
 const maxPathSize = 32 * 1024
 
-const version = "darwin-launchd"
+const (
+	version                   = "darwin-launchd"
+	defaultDarwinLogDirectory = "/var/log"
+)
 
 type darwinSystem struct{}
 
 func (darwinSystem) String() string {
 	return version
 }
+
 func (darwinSystem) Detect() bool {
 	return true
 }
+
 func (darwinSystem) Interactive() bool {
 	return interactive
 }
+
 func (darwinSystem) New(i Interface, c *Config) (Service, error) {
 	s := &darwinLaunchdService{
 		i:      i,
@@ -106,6 +112,28 @@ func (s *darwinLaunchdService) getServiceFilePath() (string, error) {
 	return "/Library/LaunchDaemons/" + s.Name + ".plist", nil
 }
 
+func (s *darwinLaunchdService) logDir() (string, error) {
+	if customDir := s.Option.string(optionLogDirectory, ""); customDir != "" {
+		return customDir, nil
+	}
+	if !s.userService {
+		return defaultDarwinLogDirectory, nil
+	}
+	return s.getHomeDir()
+}
+
+func (s *darwinLaunchdService) getLogPaths() (string, string, error) {
+	logDir, err := s.logDir()
+	if err != nil {
+		return "", "", err
+	}
+	return s.getLogPath(logDir, "out"), s.getLogPath(logDir, "err"), nil
+}
+
+func (s *darwinLaunchdService) getLogPath(logDir, logType string) string {
+	return fmt.Sprintf("%s/%s.%s.log", logDir, s.Name, logType)
+}
+
 func (s *darwinLaunchdService) template() *template.Template {
 	functions := template.FuncMap{
 		"bool": func(v bool) string {
@@ -120,9 +148,8 @@ func (s *darwinLaunchdService) template() *template.Template {
 
 	if customConfig != "" {
 		return template.Must(template.New("").Funcs(functions).Parse(customConfig))
-	} else {
-		return template.Must(template.New("").Funcs(functions).Parse(launchdConfig))
 	}
+	return template.Must(template.New("").Funcs(functions).Parse(launchdConfig))
 }
 
 func (s *darwinLaunchdService) Install() error {
@@ -154,20 +181,23 @@ func (s *darwinLaunchdService) Install() error {
 		return err
 	}
 
+	stdOutPath, stdErrPath, _ := s.getLogPaths()
 	var to = &struct {
 		*Config
 		Path string
 
 		KeepAlive, RunAtLoad bool
 		SessionCreate        bool
-		StandardOut          bool
-		StandardError        bool
+		StandardOutPath      string
+		StandardErrorPath    string
 	}{
-		Config:        s.Config,
-		Path:          path,
-		KeepAlive:     s.Option.bool(optionKeepAlive, optionKeepAliveDefault),
-		RunAtLoad:     s.Option.bool(optionRunAtLoad, optionRunAtLoadDefault),
-		SessionCreate: s.Option.bool(optionSessionCreate, optionSessionCreateDefault),
+		Config:            s.Config,
+		Path:              path,
+		KeepAlive:         s.Option.bool(optionKeepAlive, optionKeepAliveDefault),
+		RunAtLoad:         s.Option.bool(optionRunAtLoad, optionRunAtLoadDefault),
+		SessionCreate:     s.Option.bool(optionSessionCreate, optionSessionCreateDefault),
+		StandardOutPath:   stdOutPath,
+		StandardErrorPath: stdErrPath,
 	}
 
 	return s.template().Execute(f, to)
@@ -216,6 +246,7 @@ func (s *darwinLaunchdService) Start() error {
 	}
 	return run("launchctl", "load", confPath)
 }
+
 func (s *darwinLaunchdService) Stop() error {
 	confPath, err := s.getServiceFilePath()
 	if err != nil {
@@ -223,6 +254,7 @@ func (s *darwinLaunchdService) Stop() error {
 	}
 	return run("launchctl", "unload", confPath)
 }
+
 func (s *darwinLaunchdService) Restart() error {
 	err := s.Stop()
 	if err != nil {
@@ -233,9 +265,7 @@ func (s *darwinLaunchdService) Restart() error {
 }
 
 func (s *darwinLaunchdService) Run() error {
-	var err error
-
-	err = s.i.Start(s)
+	err := s.i.Start(s)
 	if err != nil {
 		return err
 	}
@@ -255,44 +285,63 @@ func (s *darwinLaunchdService) Logger(errs chan<- error) (Logger, error) {
 	}
 	return s.SystemLogger(errs)
 }
+
 func (s *darwinLaunchdService) SystemLogger(errs chan<- error) (Logger, error) {
 	return newSysLogger(s.Name, errs)
 }
 
-var launchdConfig = `<?xml version='1.0' encoding='UTF-8'?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
-"http://www.apple.com/DTDs/PropertyList-1.0.dtd" >
-<plist version='1.0'>
-  <dict>
-    <key>Label</key>
-    <string>{{html .Name}}</string>
-    <key>ProgramArguments</key>
-    <array>
-      <string>{{html .Path}}</string>
-    {{range .Config.Arguments}}
-      <string>{{html .}}</string>
-    {{end}}
-    </array>
-    {{if .UserName}}<key>UserName</key>
-    <string>{{html .UserName}}</string>{{end}}
-    {{if .ChRoot}}<key>RootDirectory</key>
-    <string>{{html .ChRoot}}</string>{{end}}
-    {{if .WorkingDirectory}}<key>WorkingDirectory</key>
-    <string>{{html .WorkingDirectory}}</string>{{end}}
-    <key>SessionCreate</key>
-    <{{bool .SessionCreate}}/>
-    <key>KeepAlive</key>
-    <{{bool .KeepAlive}}/>
-    <key>RunAtLoad</key>
-    <{{bool .RunAtLoad}}/>
-    <key>Disabled</key>
-    <false/>
-    
-    <key>StandardOutPath</key>
-    <string>/usr/local/var/log/{{html .Name}}.out.log</string>
-    <key>StandardErrorPath</key>
-    <string>/usr/local/var/log/{{html .Name}}.err.log</string>
-  
-  </dict>
+var launchdConfig = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Disabled</key>
+	<false/>
+	{{- if .EnvVars}}
+	<key>EnvironmentVariables</key>
+	<dict>
+		{{- range $k, $v := .EnvVars}}
+		<key>{{html $k}}</key>
+		<string>{{html $v}}</string>
+		{{- end}}
+	</dict>
+	{{- end}}
+	<key>KeepAlive</key>
+	<{{bool .KeepAlive}}/>
+	<key>Label</key>
+	<string>{{html .Name}}</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>{{html .Path}}</string>
+		{{- if .Config.Arguments}}
+		{{- range .Config.Arguments}}
+		<string>{{html .}}</string>
+		{{- end}}
+	{{- end}}
+	</array>
+	{{- if .ChRoot}}
+	<key>RootDirectory</key>
+	<string>{{html .ChRoot}}</string>
+	{{- end}}
+	<key>RunAtLoad</key>
+	<{{bool .RunAtLoad}}/>
+	<key>SessionCreate</key>
+	<{{bool .SessionCreate}}/>
+	{{- if .StandardErrorPath}}
+	<key>StandardErrorPath</key>
+	<string>{{html .StandardErrorPath}}</string>
+	{{- end}}
+	{{- if .StandardOutPath}}
+	<key>StandardOutPath</key>
+	<string>{{html .StandardOutPath}}</string>
+	{{- end}}
+	{{- if .UserName}}
+	<key>UserName</key>
+	<string>{{html .UserName}}</string>
+	{{- end}}
+	{{- if .WorkingDirectory}}
+	<key>WorkingDirectory</key>
+	<string>{{html .WorkingDirectory}}</string>
+	{{- end}}
+</dict>
 </plist>
 `

vendor/github.com/kardianos/service/service_openrc_linux.go

@@ -60,9 +60,8 @@ func (s *openrc) template() *template.Template {
 
 	if customScript != "" {
 		return template.Must(template.New("").Funcs(tf).Parse(customScript))
-	} else {
-		return template.Must(template.New("").Funcs(tf).Parse(openRCScript))
 	}
+	return template.Must(template.New("").Funcs(tf).Parse(openRCScript))
 }
 
 func newOpenRCService(i Interface, platform string, c *Config) (Service, error) {
@@ -113,10 +112,12 @@ func (s *openrc) Install() error {
 
 	var to = &struct {
 		*Config
-		Path string
+		Path         string
+		LogDirectory string
 	}{
 		s.Config,
 		path,
+		s.Option.string(optionLogDirectory, defaultLogDirectory),
 	}
 
 	err = s.template().Execute(f, to)
@@ -227,7 +228,11 @@ command={{.Path|cmdEscape}}
 command_args="{{range .Arguments}}{{.}} {{end}}"
 {{- end }}
 name=$(basename $(readlink -f $command))
-supervise_daemon_args="--stdout /var/log/${name}.log --stderr /var/log/${name}.err"
+supervise_daemon_args="--stdout {{.LogDirectory}}/${name}.log --stderr {{.LogDirectory}}/${name}.err"
+
+{{range $k, $v := .EnvVars -}}
+export {{$k}}={{$v}}
+{{end -}}
 
 {{- if .Dependencies }}
 depend() {

vendor/github.com/kardianos/service/service_systemd_linux.go

@@ -90,7 +90,7 @@ func (s *systemd) unitName() string {
 }
 
 func (s *systemd) getSystemdVersion() int64 {
-	_, out, err := runWithOutput("systemctl", "--version")
+	_, out, err := s.runWithOutput("systemctl", "--version")
 	if err != nil {
 		return -1
 	}
@@ -128,9 +128,8 @@ func (s *systemd) template() *template.Template {
 
 	if customScript != "" {
 		return template.Must(template.New("").Funcs(tf).Parse(customScript))
-	} else {
-		return template.Must(template.New("").Funcs(tf).Parse(systemdScript))
 	}
+	return template.Must(template.New("").Funcs(tf).Parse(systemdScript))
 }
 
 func (s *systemd) isUserService() bool {
@@ -168,6 +167,7 @@ func (s *systemd) Install() error {
 		Restart              string
 		SuccessExitStatus    string
 		LogOutput            bool
+		LogDirectory         string
 	}{
 		s.Config,
 		path,
@@ -178,6 +178,7 @@ func (s *systemd) Install() error {
 		s.Option.string(optionRestart, "always"),
 		s.Option.string(optionSuccessExitStatus, ""),
 		s.Option.bool(optionLogOutput, optionLogOutputDefault),
+		s.Option.string(optionLogDirectory, defaultLogDirectory),
 	}
 
 	err = s.template().Execute(f, to)
@@ -234,7 +235,7 @@ func (s *systemd) Run() (err error) {
 }
 
 func (s *systemd) Status() (Status, error) {
-	exitCode, out, err := runWithOutput("systemctl", "is-active", s.unitName())
+	exitCode, out, err := s.runWithOutput("systemctl", "is-active", s.unitName())
 	if exitCode == 0 && err != nil {
 		return StatusUnknown, err
 	}
@@ -244,7 +245,7 @@ func (s *systemd) Status() (Status, error) {
 		return StatusRunning, nil
 	case strings.HasPrefix(out, "inactive"):
 		// inactive can also mean its not installed, check unit files
-		exitCode, out, err := runWithOutput("systemctl", "list-unit-files", "-t", "service", s.unitName())
+		exitCode, out, err := s.runWithOutput("systemctl", "list-unit-files", "-t", "service", s.unitName())
 		if exitCode == 0 && err != nil {
 			return StatusUnknown, err
 		}
@@ -275,6 +276,13 @@ func (s *systemd) Restart() error {
 	return s.runAction("restart")
 }
 
+func (s *systemd) runWithOutput(command string, arguments ...string) (int, string, error) {
+	if s.isUserService() {
+		arguments = append(arguments, "--user")
+	}
+	return runWithOutput(command, arguments...)
+}
+
 func (s *systemd) run(action string, args ...string) error {
 	if s.isUserService() {
 		return run("systemctl", append([]string{action, "--user"}, args...)...)
@@ -302,8 +310,8 @@ ExecStart={{.Path|cmdEscape}}{{range .Arguments}} {{.|cmd}}{{end}}
 {{if .ReloadSignal}}ExecReload=/bin/kill -{{.ReloadSignal}} "$MAINPID"{{end}}
 {{if .PIDFile}}PIDFile={{.PIDFile|cmd}}{{end}}
 {{if and .LogOutput .HasOutputFileSupport -}}
-StandardOutput=file:/var/log/{{.Name}}.out
-StandardError=file:/var/log/{{.Name}}.err
+StandardOutput=file:{{.LogDirectory}}/{{.Name}}.out
+StandardError=file:{{.LogDirectory}}/{{.Name}}.err
 {{- end}}
 {{if gt .LimitNOFILE -1 }}LimitNOFILE={{.LimitNOFILE}}{{end}}
 {{if .Restart}}Restart={{.Restart}}{{end}}
@@ -311,6 +319,10 @@ StandardError=file:/var/log/{{.Name}}.err
 RestartSec=120
 EnvironmentFile=-/etc/sysconfig/{{.Name}}
 
+{{range $k, $v := .EnvVars -}}
+Environment={{$k}}={{$v}}
+{{end -}}
+
 [Install]
 WantedBy=multi-user.target
 `

vendor/github.com/kardianos/service/service_sysv_linux.go

@@ -58,9 +58,8 @@ func (s *sysv) template() *template.Template {
 
 	if customScript != "" {
 		return template.Must(template.New("").Funcs(tf).Parse(customScript))
-	} else {
-		return template.Must(template.New("").Funcs(tf).Parse(sysvScript))
 	}
+	return template.Must(template.New("").Funcs(tf).Parse(sysvScript))
 }
 
 func (s *sysv) Install() error {
@@ -86,10 +85,12 @@ func (s *sysv) Install() error {
 
 	var to = &struct {
 		*Config
-		Path string
+		Path         string
+		LogDirectory string
 	}{
 		s.Config,
 		path,
+		s.Option.string(optionLogDirectory, defaultLogDirectory),
 	}
 
 	err = s.template().Execute(f, to)
@@ -203,8 +204,12 @@ cmd="{{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}"
 
 name=$(basename $(readlink -f $0))
 pid_file="/var/run/$name.pid"
-stdout_log="/var/log/$name.log"
-stderr_log="/var/log/$name.err"
+stdout_log="{{.LogDirectory}}/$name.log"
+stderr_log="{{.LogDirectory}}/$name.err"
+
+{{range $k, $v := .EnvVars -}}
+export {{$k}}={{$v}}
+{{end -}}
 
 [ -e /etc/sysconfig/$name ] && . /etc/sysconfig/$name
 

vendor/github.com/kardianos/service/service_unix.go

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a zlib-style
 // license that can be found in the LICENSE file.
 
+//go:build linux || darwin || solaris || aix || freebsd
 // +build linux darwin solaris aix freebsd
 
 package service
@@ -16,6 +17,8 @@ import (
 	"syscall"
 )
 
+const defaultLogDirectory = "/var/log"
+
 func newSysLogger(name string, errs chan<- error) (Logger, error) {
 	w, err := syslog.New(syslog.LOG_INFO, name)
 	if err != nil {

vendor/github.com/kardianos/service/service_upstart_linux.go

@@ -152,12 +152,14 @@ func (s *upstart) Install() error {
 		HasKillStanza   bool
 		HasSetUIDStanza bool
 		LogOutput       bool
+		LogDirectory    string
 	}{
 		s.Config,
 		path,
 		s.hasKillStanza(),
 		s.hasSetUIDStanza(),
 		s.Option.bool(optionLogOutput, optionLogOutputDefault),
+		s.Option.string(optionLogDirectory, defaultLogDirectory),
 	}
 
 	return s.template().Execute(f, to)
@@ -254,8 +256,8 @@ end script
 # Start
 script
 	{{if .LogOutput}}
-	stdout_log="/var/log/{{.Name}}.out"
-	stderr_log="/var/log/{{.Name}}.err"
+	stdout_log="{{.LogDirectory}}/{{.Name}}.out"
+	stderr_log="{{.LogDirectory}}/{{.Name}}.err"
 	{{end}}
 	
 	if [ -f "/etc/sysconfig/{{.Name}}" ]; then

vendor/github.com/kardianos/service/service_windows.go

@@ -149,11 +149,11 @@ func (l WindowsLogger) NInfof(eventID uint32, format string, a ...interface{}) e
 var interactive = false
 
 func init() {
-	var err error
-	interactive, err = svc.IsAnInteractiveSession()
+	isService, err := svc.IsWindowsService()
 	if err != nil {
 		panic(err)
 	}
+	interactive = !isService
 }
 
 func (ws *windowsService) String() string {
@@ -222,6 +222,49 @@ loop:
 	return false, 0
 }
 
+func lowPrivMgr() (*mgr.Mgr, error) {
+	h, err := windows.OpenSCManager(nil, nil, windows.SC_MANAGER_CONNECT|windows.SC_MANAGER_ENUMERATE_SERVICE)
+	if err != nil {
+		return nil, err
+	}
+	return &mgr.Mgr{Handle: h}, nil
+}
+
+func lowPrivSvc(m *mgr.Mgr, name string) (*mgr.Service, error) {
+	h, err := windows.OpenService(
+		m.Handle, syscall.StringToUTF16Ptr(name),
+		windows.SERVICE_QUERY_CONFIG|windows.SERVICE_QUERY_STATUS|windows.SERVICE_START|windows.SERVICE_STOP)
+	if err != nil {
+		return nil, err
+	}
+	return &mgr.Service{Handle: h, Name: name}, nil
+}
+
+func (ws *windowsService) setEnvironmentVariablesInRegistry() error {
+	if len(ws.EnvVars) == 0 {
+		return nil
+	}
+
+	k, _, err := registry.CreateKey(
+		registry.LOCAL_MACHINE, `SYSTEM\CurrentControlSet\Services\`+ws.Name,
+		registry.QUERY_VALUE|registry.SET_VALUE|registry.CREATE_SUB_KEY)
+	if err != nil {
+		return fmt.Errorf("failed creating env var registry key, err = %v", err)
+	}
+	envStrings := make([]string, 0, len(ws.EnvVars))
+	for k, v := range ws.EnvVars {
+		envStrings = append(envStrings, k+"="+v)
+	}
+
+	if err := k.SetStringsValue("Environment", envStrings); err != nil {
+		return fmt.Errorf("failed setting env var registry key, err = %v", err)
+	}
+	if err := k.Close(); err != nil {
+		return fmt.Errorf("failed closing env var registry key, err = %v", err)
+	}
+	return nil
+}
+
 func (ws *windowsService) Install() error {
 	exepath, err := ws.execPath()
 	if err != nil {
@@ -233,6 +276,11 @@ func (ws *windowsService) Install() error {
 		return err
 	}
 	defer m.Disconnect()
+
+	if err := ws.setEnvironmentVariablesInRegistry(); err != nil {
+		return err
+	}
+
 	s, err := m.OpenService(ws.Name)
 	if err == nil {
 		s.Close()
@@ -356,13 +404,13 @@ func (ws *windowsService) Run() error {
 }
 
 func (ws *windowsService) Status() (Status, error) {
-	m, err := mgr.Connect()
+	m, err := lowPrivMgr()
 	if err != nil {
 		return StatusUnknown, err
 	}
 	defer m.Disconnect()
 
-	s, err := m.OpenService(ws.Name)
+	s, err := lowPrivSvc(m, ws.Name)
 	if err != nil {
 		if errno, ok := err.(syscall.Errno); ok && errno == errnoServiceDoesNotExist {
 			return StatusUnknown, ErrNotInstalled
@@ -397,13 +445,13 @@ func (ws *windowsService) Status() (Status, error) {
 }
 
 func (ws *windowsService) Start() error {
-	m, err := mgr.Connect()
+	m, err := lowPrivMgr()
 	if err != nil {
 		return err
 	}
 	defer m.Disconnect()
 
-	s, err := m.OpenService(ws.Name)
+	s, err := lowPrivSvc(m, ws.Name)
 	if err != nil {
 		return err
 	}
@@ -412,13 +460,13 @@ func (ws *windowsService) Start() error {
 }
 
 func (ws *windowsService) Stop() error {
-	m, err := mgr.Connect()
+	m, err := lowPrivMgr()
 	if err != nil {
 		return err
 	}
 	defer m.Disconnect()
 
-	s, err := m.OpenService(ws.Name)
+	s, err := lowPrivSvc(m, ws.Name)
 	if err != nil {
 		return err
 	}
@@ -428,13 +476,13 @@ func (ws *windowsService) Stop() error {
 }
 
 func (ws *windowsService) Restart() error {
-	m, err := mgr.Connect()
+	m, err := lowPrivMgr()
 	if err != nil {
 		return err
 	}
 	defer m.Disconnect()
 
-	s, err := m.OpenService(ws.Name)
+	s, err := lowPrivSvc(m, ws.Name)
 	if err != nil {
 		return err
 	}

vendor/github.com/lucas-clemente/quic-go/connection.go

@@ -209,7 +209,7 @@ type connection struct {
 
 	peerParams *wire.TransportParameters
 
-	timer *utils.Timer
+	timer connectionTimer
 	// keepAlivePingSent stores whether a keep alive PING is in flight.
 	// It is reset as soon as we receive a packet from the peer.
 	keepAlivePingSent bool
@@ -223,10 +223,9 @@ type connection struct {
 }
 
 var (
-	_                       Connection      = &connection{}
-	_                       EarlyConnection = &connection{}
-	_                       streamSender    = &connection{}
-	deadlineSendImmediately                 = time.Time{}.Add(42 * time.Millisecond) // any value > time.Time{} and before time.Now() is fine
+	_ Connection      = &connection{}
+	_ EarlyConnection = &connection{}
+	_ streamSender    = &connection{}
 )
 
 var newConnection = func(
@@ -548,7 +547,7 @@ func (s *connection) preSetup() {
 func (s *connection) run() error {
 	defer s.ctxCancel()
 
-	s.timer = utils.NewTimer()
+	s.timer = *newTimer()
 
 	handshaking := make(chan struct{})
 	go func() {
@@ -765,17 +764,12 @@ func (s *connection) maybeResetTimer() {
 		}
 	}
 
-	if ackAlarm := s.receivedPacketHandler.GetAlarmTimeout(); !ackAlarm.IsZero() {
-		deadline = utils.MinTime(deadline, ackAlarm)
-	}
-	if lossTime := s.sentPacketHandler.GetLossDetectionTimeout(); !lossTime.IsZero() {
-		deadline = utils.MinTime(deadline, lossTime)
-	}
-	if !s.pacingDeadline.IsZero() {
-		deadline = utils.MinTime(deadline, s.pacingDeadline)
-	}
-
-	s.timer.Reset(deadline)
+	s.timer.SetTimer(
+		deadline,
+		s.receivedPacketHandler.GetAlarmTimeout(),
+		s.sentPacketHandler.GetLossDetectionTimeout(),
+		s.pacingDeadline,
+	)
 }
 
 func (s *connection) idleTimeoutStartTime() time.Time {
@@ -1678,7 +1672,7 @@ func (s *connection) sendPackets() error {
 			}
 			// We can at most send a single ACK only packet.
 			// There will only be a new ACK after receiving new packets.
-			// SendAck is only returned when we're congestion limited, so we don't need to set the pacingt timer.
+			// SendAck is only returned when we're congestion limited, so we don't need to set the pacinggs timer.
 			return s.maybeSendAckOnlyPacket()
 		case ackhandler.SendPTOInitial:
 			if err := s.sendProbePacket(protocol.EncryptionInitial); err != nil {

vendor/github.com/lucas-clemente/quic-go/connection_timer.go

@@ -0,0 +1,51 @@
+package quic
+
+import (
+	"time"
+
+	"github.com/lucas-clemente/quic-go/internal/utils"
+)
+
+var deadlineSendImmediately = time.Time{}.Add(42 * time.Millisecond) // any value > time.Time{} and before time.Now() is fine
+
+type connectionTimer struct {
+	timer *utils.Timer
+	last  time.Time
+}
+
+func newTimer() *connectionTimer {
+	return &connectionTimer{timer: utils.NewTimer()}
+}
+
+func (t *connectionTimer) SetRead() {
+	if deadline := t.timer.Deadline(); deadline != deadlineSendImmediately {
+		t.last = deadline
+	}
+	t.timer.SetRead()
+}
+
+func (t *connectionTimer) Chan() <-chan time.Time {
+	return t.timer.Chan()
+}
+
+// SetTimer resets the timer.
+// It makes sure that the deadline is strictly increasing.
+// This prevents busy-looping in cases where the timer fires, but we can't actually send out a packet.
+// This doesn't apply to the pacing deadline, which can be set multiple times to deadlineSendImmediately.
+func (t *connectionTimer) SetTimer(idleTimeoutOrKeepAlive, ackAlarm, lossTime, pacing time.Time) {
+	deadline := idleTimeoutOrKeepAlive
+	if !ackAlarm.IsZero() && ackAlarm.Before(deadline) && ackAlarm.After(t.last) {
+		deadline = ackAlarm
+	}
+	if !lossTime.IsZero() && lossTime.Before(deadline) && lossTime.After(t.last) {
+		deadline = lossTime
+	}
+	if !pacing.IsZero() && pacing.Before(deadline) {
+		deadline = pacing
+	}
+	t.timer.Reset(deadline)
+}
+
+func (t *connectionTimer) Stop() {
+	t.timer.Stop()
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/timer.go

@@ -47,6 +47,10 @@ func (t *Timer) SetRead() {
 	t.read = true
 }
 
+func (t *Timer) Deadline() time.Time {
+	return t.deadline
+}
+
 // Stop stops the timer
 func (t *Timer) Stop() {
 	t.t.Stop()

vendor/github.com/marten-seemann/qtls-go1-18/handshake_server.go

@@ -270,7 +270,7 @@ func (hs *serverHandshakeState) processClientHello() error {
 
 	hs.ecdheOk = supportsECDHE(c.config, hs.clientHello.supportedCurves, hs.clientHello.supportedPoints)
 
-	if hs.ecdheOk {
+	if hs.ecdheOk && len(hs.clientHello.supportedPoints) > 0 {
 		// Although omitting the ec_point_formats extension is permitted, some
 		// old OpenSSL version will refuse to handshake if not present.
 		//
@@ -351,6 +351,13 @@ func supportsECDHE(c *config, supportedCurves []CurveID, supportedPoints []uint8
 			break
 		}
 	}
+	// Per RFC 8422, Section 5.1.2, if the Supported Point Formats extension is
+	// missing, uncompressed points are supported. If supportedPoints is empty,
+	// the extension must be missing, as an empty extension body is rejected by
+	// the parser. See https://go.dev/issue/49126.
+	if len(supportedPoints) == 0 {
+		supportsPointFormat = true
+	}
 
 	return supportsCurve && supportsPointFormat
 }

vendor/github.com/marten-seemann/qtls-go1-19/handshake_server.go

@@ -270,7 +270,7 @@ func (hs *serverHandshakeState) processClientHello() error {
 
 	hs.ecdheOk = supportsECDHE(c.config, hs.clientHello.supportedCurves, hs.clientHello.supportedPoints)
 
-	if hs.ecdheOk {
+	if hs.ecdheOk && len(hs.clientHello.supportedPoints) > 0 {
 		// Although omitting the ec_point_formats extension is permitted, some
 		// old OpenSSL version will refuse to handshake if not present.
 		//
@@ -351,6 +351,13 @@ func supportsECDHE(c *config, supportedCurves []CurveID, supportedPoints []uint8
 			break
 		}
 	}
+	// Per RFC 8422, Section 5.1.2, if the Supported Point Formats extension is
+	// missing, uncompressed points are supported. If supportedPoints is empty,
+	// the extension must be missing, as an empty extension body is rejected by
+	// the parser. See https://go.dev/issue/49126.
+	if len(supportedPoints) == 0 {
+		supportsPointFormat = true
+	}
 
 	return supportsCurve && supportsPointFormat
 }