Compare commits

...
4 Commits
8 changed files with 162 additions and 111 deletions
+4
View File
@@ -251,6 +251,8 @@ func CardToEncoderPosition(port *serial.Port) (string, error) {
return "", fmt.Errorf("error sending ENQ to prompt device: %v", err) return "", fmt.Errorf("error sending ENQ to prompt device: %v", err)
} }
time.Sleep(delay)
//Check card position status //Check card position status
status, err := CheckDispenserStatus(port) status, err := CheckDispenserStatus(port)
if err != nil { if err != nil {
@@ -281,6 +283,8 @@ func CardOutOfMouth(port *serial.Port) (string, error) {
return "", fmt.Errorf("error sending ENQ to prompt device: %v", err) return "", fmt.Errorf("error sending ENQ to prompt device: %v", err)
} }
time.Sleep(delay)
//Check card position status //Check card position status
status, err := CheckDispenserStatus(port) status, err := CheckDispenserStatus(port)
if err != nil { if err != nil {
+8 -1
View File
@@ -19,8 +19,15 @@ func (lock *AssaLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
} }
// Checks heart beat of the Assa Abloy lock server and perform key encoding // Checks heart beat of the Assa Abloy lock server and perform key encoding
func (lock *AssaLockServer) LockSequence(conn net.Conn) error { func (lock *AssaLockServer) LockSequence() error {
const funcName = "AssaLockServer.LockSequence" const funcName = "AssaLockServer.LockSequence"
conn, err := InitializeServerConnection(lock.encoderAddr)
if err != nil {
return err
}
defer conn.Close()
resp, err := sendHeartbeatToServer(conn) resp, err := sendHeartbeatToServer(conn)
if err != nil { if err != nil {
return fmt.Errorf("[%s] heartbeat failed: %v", funcName, err) return fmt.Errorf("[%s] heartbeat failed: %v", funcName, err)
+1 -1
View File
@@ -35,7 +35,7 @@ var (
type ( type (
LockServer interface { LockServer interface {
BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error BuildCommand(doorReq DoorCardRequest, checkIn, checkOut time.Time) error
LockSequence(conn net.Conn) error LockSequence() error
} }
AssaLockServer struct { AssaLockServer struct {
+8 -1
View File
@@ -53,8 +53,15 @@ func (lock *OmniLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, check
} }
// Starts link to the Omnitec lock server and perform key encoding // Starts link to the Omnitec lock server and perform key encoding
func (lock *OmniLockServer) LockSequence(conn net.Conn) error { func (lock *OmniLockServer) LockSequence() error {
const funcName = "OmniLockServer.LockSequence" const funcName = "OmniLockServer.LockSequence"
conn, err := net.Dial("tcp", lock.encoderAddr)
if err != nil {
return err
}
defer conn.Close()
// Start the link with the lock server // Start the link with the lock server
regs, err := lock.linkStart(conn) regs, err := lock.linkStart(conn)
if err != nil { if err != nil {
+117 -85
View File
@@ -75,120 +75,152 @@ func (lock *SaltoLockServer) BuildCommand(req DoorCardRequest, checkIn, checkOut
return nil return nil
} }
// LockSequence performs the full ENQ/ACK handshake and command exchange // readFrame consumes a full frame starting with firstByte (expected STX).
func (lock *SaltoLockServer) LockSequence(conn net.Conn) error { // It reads up to ETX and then attempts to read a trailing LRC (or CR). timeout controls read deadlines.
log.Infof("Sending command: %q", string(lock.command)) func (lock *SaltoLockServer) readFrame(conn net.Conn, reader *bufio.Reader, firstByte byte, timeout time.Duration) ([]byte, error) {
frame := []byte{firstByte}
for {
conn.SetReadDeadline(time.Now().Add(timeout))
b, e := reader.ReadByte()
if e != nil {
return frame, fmt.Errorf("error reading frame body: %w", e)
}
frame = append(frame, b)
if b == ETX {
break
}
}
// read trailing LRC (or CR) if present (non-blocking w/ timeout)
conn.SetReadDeadline(time.Now().Add(timeout))
if lrc, e := reader.ReadByte(); e == nil {
frame = append(frame, lrc)
} else {
// Not fatal: some devices might omit LRC/CR — just log
log.Warnf("readFrame: no trailing LRC/CR: %v", e)
}
return frame, nil
}
// waitForAck waits for ACK or NAK. If STX frames are encountered they are drained
// using readFrame. drainedCount (if non-nil) accumulates the number of drained frames.
func (lock *SaltoLockServer) waitForAck(conn net.Conn, reader *bufio.Reader, timeout time.Duration, drainedCount *int) error {
deadline := time.Now().Add(timeout)
for {
conn.SetReadDeadline(time.Now().Add(time.Until(deadline)))
b, e := reader.ReadByte()
if e != nil {
return fmt.Errorf("error waiting for ACK/NAK: %w", e)
}
switch b {
case ACK:
return nil
case NAK:
return fmt.Errorf("received NAK")
case STX:
// stale or queued full response: consume it and continue waiting
frame, fe := lock.readFrame(conn, reader, b, timeout)
if fe != nil {
// if we can't consume frame, consider it an error
return fmt.Errorf("failed to consume queued STX frame: %w", fe)
}
if drainedCount != nil {
*drainedCount++
log.Infof("Drained queued frame #%d (while waiting for ACK): %q", *drainedCount, string(frame))
} else {
log.Infof("Drained queued frame (while waiting for ACK): %q", string(frame))
}
// loop to keep waiting for ACK
default:
// Unexpected byte while waiting for ACK. Log and continue reading.
log.Warnf("waitForAck: unexpected byte 0x%X while waiting for ACK; ignoring", b)
// keep looping until timeout or ACK/NAK
}
}
}
// LockSequence performs the full ENQ/ACK handshake and command exchange
func (lock *SaltoLockServer) LockSequence() error {
const timeout = 10 * time.Second const timeout = 10 * time.Second
var ( var (
err error resp []byte
resp []byte drained = 0 // count of stale frames consumed across waits
) )
reader := bufio.NewReader(conn)
conn, err := InitializeServerConnection(lock.encoderAddr)
if err != nil {
return err
}
defer conn.Close()
reader := bufio.NewReader(conn)
// 1. Send ENQ // 1. Send ENQ
log.Infof("Sending ENQ")
if _, e := conn.Write([]byte{ENQ}); e != nil { if _, e := conn.Write([]byte{ENQ}); e != nil {
return fmt.Errorf("failed to send ENQ: %w", e) return fmt.Errorf("failed to send ENQ: %w", e)
} }
// 2. Expect ACK // 2. Expect ACK (but drain any queued STX frames first)
conn.SetReadDeadline(time.Now().Add(timeout)) if e := lock.waitForAck(conn, reader, timeout, &drained); e != nil {
if b, e := reader.ReadByte(); e != nil {
return fmt.Errorf("error awaiting ACK to ENQ: %w", e) return fmt.Errorf("error awaiting ACK to ENQ: %w", e)
} else if b != ACK {
return fmt.Errorf("expected ACK after ENQ, got 0x%X", b)
} }
// 3. Send command frame // 3. Send command frame
log.Infof("Sending encoding command: %q", string(lock.command))
if _, e := conn.Write(lock.command); e != nil { if _, e := conn.Write(lock.command); e != nil {
return fmt.Errorf("failed to send command frame: %w", e) return fmt.Errorf("failed to send command frame: %w", e)
} }
// 4. Expect ACK to command // 4. Expect ACK to command (again drain any queued frames that might precede it)
conn.SetReadDeadline(time.Now().Add(timeout)) if e := lock.waitForAck(conn, reader, timeout, &drained); e != nil {
if b, e := reader.ReadByte(); e != nil {
return fmt.Errorf("error awaiting ACK to command: %w", e) return fmt.Errorf("error awaiting ACK to command: %w", e)
} else if b == NAK {
return fmt.Errorf("command rejected (NAK)")
} else if b != ACK {
return fmt.Errorf("expected ACK to command, got 0x%X", b)
} }
// 5. Expect STX // 5. Now read the *next* STX frame which should be the response to our command.
conn.SetReadDeadline(time.Now().Add(timeout))
stx, e := reader.ReadByte()
if e != nil {
return fmt.Errorf("error reading STX: %w", e)
}
resp = append(resp, stx)
if stx != STX {
err = fmt.Errorf("expected STX, got 0x%X", stx)
}
// 6. Read separator after STX
conn.SetReadDeadline(time.Now().Add(timeout))
if sep, e := reader.ReadByte(); e == nil {
resp = append(resp, sep)
} else if err == nil {
err = fmt.Errorf("error reading separator after STX: %w", e)
}
// 7. Read command code (e.g., CN, TD)
conn.SetReadDeadline(time.Now().Add(timeout))
b1, e1 := reader.ReadByte()
if e1 == nil {
resp = append(resp, b1)
} else if err == nil {
err = fmt.Errorf("error reading first response byte: %w", e1)
}
b2, e2 := reader.ReadByte()
if e2 == nil {
resp = append(resp, b2)
} else if err == nil {
err = fmt.Errorf("error reading second response byte: %w", e2)
}
switch {
case b1 == 'C' && b2 == 'N':
log.Infof("LockSequence: command response is CN (normal)")
case b1 == 'C' && b2 == 'C':
log.Infof("LockSequence: command response is CC (follow-up)")
case b1 == 'T' && b2 == 'D':
log.Warnf("LockSequence: command response is TD (room does not exist)")
if err == nil {
err = fmt.Errorf("lock response indicates room does not exist")
}
default:
log.Warnf("LockSequence: unexpected command response %q", string(resp))
if err == nil {
err = fmt.Errorf("error encoding keycard, unexpected response")
}
}
// 8. Read rest of message until ETX
for { for {
conn.SetReadDeadline(time.Now().Add(timeout)) conn.SetReadDeadline(time.Now().Add(20 * time.Second))
c, e := reader.ReadByte() b, e := reader.ReadByte()
if e != nil { if e != nil {
if err == nil { return fmt.Errorf("error reading response start: %w", e)
err = fmt.Errorf("error reading response body: %w", e)
}
break
} }
resp = append(resp, c) if b != STX {
if c == ETX { // If anything else arrives, it might be another control byte or noise;
break // log and keep consuming until we find STX.
log.Warnf("expected STX to start response but got 0x%X; ignoring", b)
continue
} }
// consume full response frame
frame, fe := lock.readFrame(conn, reader, b, timeout)
if fe != nil {
return fmt.Errorf("error reading response frame: %w", fe)
}
resp = append(resp, frame...)
break
} }
// 9. Optional: read trailing byte (LRC or CR) // parse the command code within response frame
conn.SetReadDeadline(time.Now().Add(timeout)) if len(resp) >= 4 {
if lrc, e := reader.ReadByte(); e == nil { // The command bytes are usually at indices 2 and 3 if separator is at index 1
resp = append(resp, lrc) sepIndex := 1
b1 := resp[sepIndex+1]
b2 := resp[sepIndex+2]
switch {
case b1 == 'C' && b2 == 'N':
log.Infof("LockSequence: command response is CN (normal)")
case b1 == 'C' && b2 == 'C':
log.Infof("LockSequence: command response is CC (follow-up)")
case b1 == 'T' && b2 == 'D':
log.Warnf("LockSequence: command response is TD (room does not exist)")
return fmt.Errorf("lock response indicates room does not exist")
default:
log.Warnf("LockSequence: unexpected command response %q", string(resp))
return fmt.Errorf("error encoding keycard, unexpected response")
}
} else { } else {
log.Warnf("LockSequence: failed to read trailing LRC/CR: %v", e) log.Warnf("LockSequence: response too short: %q", string(resp))
return fmt.Errorf("response too short")
} }
log.Infof("LockSequence: received response: %q", string(resp)) log.Infof("LockSequence: received response: %q", string(resp))
return err return nil
} }
+2 -2
View File
@@ -4,7 +4,6 @@ import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"net"
"net/http" "net/http"
"net/url" "net/url"
"time" "time"
@@ -36,7 +35,8 @@ func (lock *TLJLockServer) BuildCommand(doorReq DoorCardRequest, checkIn, checkO
return nil return nil
} }
func (lock *TLJLockServer) LockSequence(conn net.Conn) error { func (lock *TLJLockServer) LockSequence() error {
log.Infof("Sending command: %q", lock.command)
client := &http.Client{Timeout: 10 * time.Second} client := &http.Client{Timeout: 10 * time.Second}
resp, err := client.Get(lock.command) resp, err := client.Get(lock.command)
if err != nil { if err != nil {
+8 -19
View File
@@ -6,7 +6,6 @@ import (
"encoding/xml" "encoding/xml"
"fmt" "fmt"
"io" "io"
"net"
"net/http" "net/http"
"os" "os"
"os/exec" "os/exec"
@@ -30,7 +29,7 @@ import (
) )
const ( const (
buildVersion = "1.0.9" buildVersion = "1.0.13"
serviceName = "hardlink" serviceName = "hardlink"
customLayout = "2006-01-02 15:04:05 -0700" customLayout = "2006-01-02 15:04:05 -0700"
transactionUrl = "http://127.0.0.1:18181/start-transaction/" transactionUrl = "http://127.0.0.1:18181/start-transaction/"
@@ -53,14 +52,12 @@ type configRec struct {
// App holds shared resources. // App holds shared resources.
type App struct { type App struct {
dispPort *serial.Port dispPort *serial.Port
lockConn net.Conn
lockserver lockserver.LockServer lockserver lockserver.LockServer
} }
func newApp(dispPort *serial.Port, lockConn net.Conn, config configRec) *App { func newApp(dispPort *serial.Port, config configRec) *App {
return &App{ return &App{
dispPort: dispPort, dispPort: dispPort,
lockConn: lockConn,
lockserver: lockserver.NewLockServer(config.LockType, config.EncoderAddress, fatalError), lockserver: lockserver.NewLockServer(config.LockType, config.EncoderAddress, fatalError),
} }
} }
@@ -70,8 +67,6 @@ func main() {
config := readConfig() config := readConfig()
printer.Layout = readTicketLayout() printer.Layout = readTicketLayout()
printer.PrinterName = config.PrinterName printer.PrinterName = config.PrinterName
var lockConn net.Conn
lockserver.Cert = config.Cert lockserver.Cert = config.Cert
lockserver.LockServerURL = config.LockserverUrl lockserver.LockServerURL = config.LockserverUrl
@@ -103,25 +98,19 @@ func main() {
} }
log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status) log.Infof("Dispenser initialized on port %s, %s", config.DispenserPort, status)
// Initialize lock-server connection once // Test lock-server connection
switch strings.ToLower(config.LockType) { switch strings.ToLower(config.LockType) {
case lockserver.TLJ: case lockserver.TLJ:
default: default:
lockConn, err = lockserver.InitializeServerConnection(config.LockserverUrl) lockConn, err := lockserver.InitializeServerConnection(config.LockserverUrl)
if err != nil { if err != nil {
fatalError(err) fatalError(err)
} }
defer lockConn.Close() log.Infof("Connectting to lock server at %s", config.LockserverUrl)
log.Infof("Connected to lock server at %s", config.LockserverUrl) lockConn.Close()
} }
// db, err := payment.InitMSSQL(config.dbport, config.dbname, config.dbuser, config.dbpassword)
// if err != nil {
// fatalError(fmt.Errorf("DB init failed: %v", err))
// }
// defer db.Close()
if config.IsPayment { if config.IsPayment {
startClient := func() (*exec.Cmd, error) { startClient := func() (*exec.Cmd, error) {
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe") cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe")
@@ -181,7 +170,7 @@ func main() {
// Create App and wire routes // Create App and wire routes
// dispHandle := &serial.Port{} // Placeholder, replace with actual dispenser handle // dispHandle := &serial.Port{} // Placeholder, replace with actual dispenser handle
app := newApp(dispHandle, lockConn, config) app := newApp(dispHandle, config)
mux := http.NewServeMux() mux := http.NewServeMux()
setUpRoutes(app, mux) setUpRoutes(app, mux)
@@ -389,7 +378,7 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
app.lockserver.BuildCommand(doorReq, checkIn, checkOut) app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
// lock server sequence // lock server sequence
err = app.lockserver.LockSequence(app.lockConn) err = app.lockserver.LockSequence()
if err != nil { if err != nil {
logging.Error(serviceName, err.Error(), "Key encoding", string(op), "", "", 0) logging.Error(serviceName, err.Error(), "Key encoding", string(op), "", "", 0)
writeError(w, http.StatusBadGateway, err.Error()) writeError(w, http.StatusBadGateway, err.Error())
+13 -1
View File
@@ -2,8 +2,20 @@
builtVersion is a const in main.go builtVersion is a const in main.go
#### 1.0.13 - 21 August 2025
TCP/IP connection to the lock server is now established before encoding the keycard and closedafter the encoding is done.
#### 1.0.12 - 11 August 2024
added delay before checking dispenser status
#### 1.0.11 - 11 August 2024
updated Salto key encoding workflow
#### 1.0.10 - 08 August 2024
updated logging for TLJ locks
#### 1.0.9 - 08 August 2024 #### 1.0.9 - 08 August 2024
updated workflow for TLJ locks added TLJ lock server and implemented workflow for TLJ locks
#### 1.0.8 - 01 August 2024 #### 1.0.8 - 01 August 2024
improved error handling and logging in Salto improved error handling and logging in Salto