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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
package ipp
import (
"encoding/binary"
"encoding/hex"
"flag"
"hash/crc32"
"io"
"log"
"sync"
"golang.org/x/sys/unix"
)
var Trace = flag.Bool("ipp-trace", false, "log IPP protocol traces")
var Seq = flag.Int("ipp-seq", 0, "IPP sequence counter start value")
var crc8table = [256]byte{
0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc,
0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62,
0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff,
0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07,
0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a,
0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24,
0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9,
0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd,
0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50,
0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee,
0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73,
0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b,
0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16,
0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8,
0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35,
}
func crc8(bs ...byte) (x byte) {
for _, b := range bs {
x = crc8table[x^b]
}
return
}
type Handler func(seq, replyTo byte, msgType byte, msgData []byte)
type Session interface {
io.Closer
io.Writer
SendIPP(ippType byte, replyTo byte, ippData []byte) error
}
type session struct {
path string
fd int
handler Handler
mu sync.Mutex
nextSeqOut byte // mu
closed bool // mu
}
func Open(path string, handler Handler) (Session, error) {
fd, err := unix.Open(path, unix.O_RDWR|unix.O_NOCTTY, 0)
if err != nil {
return nil, err
}
termios, err := unix.IoctlGetTermios(fd, unix.TCGETS)
if err != nil {
return nil, err
}
termios.Iflag = unix.IGNBRK | unix.IGNPAR
termios.Oflag = 0
termios.Lflag = 0
termios.Cflag = unix.B115200 | unix.CS8 | unix.CREAD | unix.CLOCAL
// when VMIN>0, reads can take unacceptably long.
// nx sets VMIN=1 VTIME=10 and uses select + FIONREAD + nonblocking read
// and somehow seems to avoid this but i cannot replicate it here.
// with VMIN=0 VTIME=1, up to 100ms delay, but no more
termios.Cc[unix.VMIN] = 0
termios.Cc[unix.VTIME] = 1
if err = unix.IoctlSetTermios(fd, unix.TCSETS, termios); err != nil {
return nil, err
}
s := &session{
path: path,
fd: fd,
handler: handler,
nextSeqOut: byte(*Seq),
}
go s.readTask()
return s, nil
}
func (s *session) isClosed() bool {
s.mu.Lock()
defer s.mu.Unlock()
return s.closed
}
func (s *session) readTask() {
var bs [1 << 16]byte
var offset int
for {
nRead, err := unix.Read(s.fd, bs[offset:])
if err != nil {
if s.isClosed() {
break
}
panic(err)
}
nConsumed := s.handleMsg(bs[:offset+nRead])
offset = copy(bs[:], bs[nConsumed:offset+nRead])
}
}
func (s *session) handleMsg(bs []byte) (nConsumed int) {
expectedLen := 1
if len(bs) < expectedLen {
return
}
msgType := bs[0]
if msgType != 0xbc {
if *Trace {
log.Printf("skipping non-IPP message %s", hex.EncodeToString(bs))
}
nConsumed = len(bs)
return
}
expectedLen += 6
if len(bs) < expectedLen {
return
}
seq := bs[1] // seq
replyTo := bs[2]
ippType := bs[3]
ippLen := int(bs[4])<<8 + int(bs[5])
hdrCRC := bs[6]
expectedHdrCRC := crc8(bs[0:6]...)
if hdrCRC != expectedHdrCRC {
log.Printf("skipping IPP message %02x, expected crc8 %02x got %02x", ippType, expectedHdrCRC, hdrCRC)
nConsumed = len(bs)
return
}
expectedLen += ippLen
hasMsgCRC := ippType&0x80 != 0
if hasMsgCRC {
expectedLen += 4
}
if len(bs) < expectedLen {
return
}
nConsumed = expectedLen
ippData := bs[7 : 7+ippLen]
if hasMsgCRC {
msgCRC := binary.LittleEndian.Uint32(bs[7+ippLen : 7+ippLen+4])
expectedMsgCRC := ^crc32.ChecksumIEEE(ippData)
if msgCRC != expectedMsgCRC {
log.Printf("skipping IPP message %02x, expected crc32 %08x got %08x", expectedMsgCRC, msgCRC)
return
}
}
if *Trace {
var ellipsis string
if ippLen > 0 {
ellipsis = "..."
}
log.Printf("%s < %s%s%s", s.path, hex.EncodeToString(bs[:7]), ellipsis, hex.EncodeToString(bs[7+ippLen:expectedLen]))
}
if s.handler != nil {
s.handler(seq, replyTo, ippType, ippData)
}
return
}
func (s *session) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
s.closed = true
fd := s.fd
s.fd = -1
return unix.Close(fd)
}
func (s *session) Write(bs []byte) (int, error) {
if *Trace {
log.Printf("%s > %s", s.path, hex.EncodeToString(bs))
}
return unix.Write(s.fd, bs)
}
func (s *session) SendIPP(ippType byte, replyTo byte, ippData []byte) error {
s.mu.Lock()
s.nextSeqOut++
if s.nextSeqOut == 0 {
s.nextSeqOut++
}
seq := s.nextSeqOut
s.mu.Unlock()
ippLen := len(ippData)
ippHdr := []byte{0xbc, seq, replyTo, ippType, byte(ippLen >> 8), byte(ippLen), 0}
ippHdr[6] = crc8(ippHdr[:6]...)
var msgCRC []byte
if ippType&0x80 != 0 {
msgCRC = make([]byte, 4)
binary.LittleEndian.PutUint32(msgCRC, ^crc32.ChecksumIEEE(ippData))
}
if *Trace {
log.Printf("%s > %s%s%s", s.path, hex.EncodeToString(ippHdr), hex.EncodeToString(ippData), hex.EncodeToString(msgCRC))
}
if _, err := unix.Writev(s.fd, [][]byte{ippHdr, ippData, msgCRC}); err != nil {
return err
}
return nil
}
|