zishuo/rtsp-simple-server
1
0
Fork 0
mirror of https://github.com/aler9/rtsp-simple-server synced 2025-10-16 20:50:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

update golangci-lint (#3300)

Browse Source
This commit is contained in:
Alessandro Ros
2024-04-28 18:20:08 +02:00
committed by GitHub
parent 5d74906414
commit 1204f76eb7
27 changed files with 141 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.golangci.yml
View File

@@ -68,4 +68,3 @@ linters-settings:
disable: disable:
- fieldalignment - fieldalignment
- reflectvaluecompare - reflectvaluecompare
- shadow

6
internal/auth/manager.go
View File

@@ -275,13 +275,13 @@ func (m *Manager) authenticateJWT(req *Request) error {
return fmt.Errorf("JWT not provided") return fmt.Errorf("JWT not provided")
} }
var customClaims customClaims var cc customClaims
_, err = jwt.ParseWithClaims(v["jwt"][0], &customClaims, keyfunc) _, err = jwt.ParseWithClaims(v["jwt"][0], &cc, keyfunc)
if err != nil { if err != nil {
return err return err
} }
if !matchesPermission(customClaims.MediaMTXPermissions, req) { if !matchesPermission(cc.MediaMTXPermissions, req) {
return fmt.Errorf("user doesn't have permission to perform action") return fmt.Errorf("user doesn't have permission to perform action")
} }

4
internal/auth/manager_test.go
View File

@@ -309,8 +309,8 @@ func TestAuthJWT(t *testing.T) {
httpServ := &http.Server{ httpServ := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
response, err := jwkSet.JSONPublic(r.Context()) response, err2 := jwkSet.JSONPublic(r.Context())
if err != nil { if err2 != nil {
w.WriteHeader(http.StatusInternalServerError) w.WriteHeader(http.StatusInternalServerError)
return return
} }

4
internal/core/api_test.go
View File

@@ -506,7 +506,7 @@ func TestAPIProtocolListGet(t *testing.T) {
go func() { go func() {
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
err := source.WritePacketRTP(medi, &rtp.Packet{ err2 := source.WritePacketRTP(medi, &rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 2, Version: 2,
Marker: true, Marker: true,
@@ -517,7 +517,7 @@ func TestAPIProtocolListGet(t *testing.T) {
}, },
Payload: []byte{5, 1, 2, 3, 4}, Payload: []byte{5, 1, 2, 3, 4},
}) })
require.NoError(t, err) require.NoError(t, err2)
}() }()
c := &webrtc.WHIPClient{ c := &webrtc.WHIPClient{

22
internal/core/core.go
View File

@@ -305,7 +305,7 @@ func (p *Core) createResources(initial bool) error {
AuthManager: p.authManager, AuthManager: p.authManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -325,7 +325,7 @@ func (p *Core) createResources(initial bool) error {
AuthManager: p.authManager, AuthManager: p.authManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -356,7 +356,7 @@ func (p *Core) createResources(initial bool) error {
AuthManager: p.authManager, AuthManager: p.authManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -415,7 +415,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -455,7 +455,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -486,7 +486,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -517,7 +517,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -549,7 +549,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -583,7 +583,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -610,7 +610,7 @@ func (p *Core) createResources(initial bool) error {
PathManager: p.pathManager, PathManager: p.pathManager,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }
@@ -643,7 +643,7 @@ func (p *Core) createResources(initial bool) error {
SRTServer: p.srtServer, SRTServer: p.srtServer,
Parent: p, Parent: p,
} }
err := i.Initialize() err = i.Initialize()
if err != nil { if err != nil {
return err return err
} }

4
internal/core/metrics_test.go
View File

@@ -169,10 +169,10 @@ webrtc_sessions_bytes_sent 0
tr := &http.Transport{} tr := &http.Transport{}
defer tr.CloseIdleConnections() defer tr.CloseIdleConnections()
hc := &http.Client{Transport: tr} hc2 := &http.Client{Transport: tr}
s := &webrtc.WHIPClient{ s := &webrtc.WHIPClient{
HTTPClient: hc, HTTPClient: hc2,
URL: su, URL: su,
Log: test.NilLogger, Log: test.NilLogger,
} }

10
internal/core/path_test.go
View File

@@ -425,7 +425,7 @@ func TestPathRunOnRead(t *testing.T) {
case <-writerTerminate: case <-writerTerminate:
return return
} }
err := source.WritePacketRTP(media0, &rtp.Packet{ err2 := source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 2, Version: 2,
Marker: true, Marker: true,
@@ -436,7 +436,7 @@ func TestPathRunOnRead(t *testing.T) {
}, },
Payload: []byte{5}, Payload: []byte{5},
}) })
require.NoError(t, err) require.NoError(t, err2)
i++ i++
} }
}() }()
@@ -525,7 +525,7 @@ func TestPathRecord(t *testing.T) {
defer source.Close() defer source.Close()
for i := 0; i < 4; i++ { for i := 0; i < 4; i++ {
err := source.WritePacketRTP(media0, &rtp.Packet{ err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 2, Version: 2,
Marker: true, Marker: true,
@@ -562,7 +562,7 @@ func TestPathRecord(t *testing.T) {
time.Sleep(500 * time.Millisecond) time.Sleep(500 * time.Millisecond)
for i := 4; i < 8; i++ { for i := 4; i < 8; i++ {
err := source.WritePacketRTP(media0, &rtp.Packet{ err = source.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 2, Version: 2,
Marker: true, Marker: true,
@@ -761,7 +761,7 @@ func TestPathOverridePublisher(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
if ca == "enabled" { if ca == "enabled" {
err := s1.Wait() err = s1.Wait()
require.EqualError(t, err, "EOF") require.EqualError(t, err, "EOF")
err = s2.WritePacketRTP(medi, &rtp.Packet{ err = s2.WritePacketRTP(medi, &rtp.Packet{

2
internal/formatprocessor/h264.go
View File

@@ -30,7 +30,7 @@ func rtpH264ExtractParams(payload []byte) ([]byte, []byte) {
return nil, payload return nil, payload
case h264.NALUTypeSTAPA: case h264.NALUTypeSTAPA:
payload := payload[1:] payload = payload[1:]
var sps []byte var sps []byte
var pps []byte var pps []byte

2
internal/formatprocessor/h265.go
View File

@@ -33,7 +33,7 @@ func rtpH265ExtractParams(payload []byte) ([]byte, []byte, []byte) {
return nil, nil, payload return nil, nil, payload
case h265.NALUType_AggregationUnit: case h265.NALUType_AggregationUnit:
payload := payload[2:] payload = payload[2:]
var vps []byte var vps []byte
var sps []byte var sps []byte
var pps []byte var pps []byte

3
internal/playback/mp4/presentation.go
View File

@@ -134,7 +134,8 @@ func (p *Presentation) marshalFtypAndMoov(w io.Writer) error {
stcosOffsets := make([]int, len(p.Tracks)) stcosOffsets := make([]int, len(p.Tracks))
for i, track := range p.Tracks { for i, track := range p.Tracks {
res, err := track.marshal(mw) var res *headerTrackMarshalResult
res, err = track.marshal(mw)
if err != nil { if err != nil {
return err return err
} }

3
internal/playback/mp4/track.go
View File

@@ -354,7 +354,8 @@ func (t *Track) marshal(w *mp4Writer) (*headerTrackMarshalResult, error) {
return nil, err return nil, err
} }
bs, err := av1.BitstreamMarshal([][]byte{codec.SequenceHeader}) var bs []byte
bs, err = av1.BitstreamMarshal([][]byte{codec.SequenceHeader})
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
internal/playback/on_get.go
View File

@@ -73,13 +73,14 @@ func seekAndMux(
segmentEnd = start.Add(segmentMaxElapsed) segmentEnd = start.Add(segmentMaxElapsed)
for _, seg := range segments[1:] { for _, seg := range segments[1:] {
f, err := os.Open(seg.Fpath) f, err = os.Open(seg.Fpath)
if err != nil { if err != nil {
return err return err
} }
defer f.Close() defer f.Close()
init, err := segmentFMP4ReadInit(f) var init *fmp4.Init
init, err = segmentFMP4ReadInit(f)
if err != nil { if err != nil {
return err return err
} }
@@ -90,7 +91,8 @@ func seekAndMux(
segmentStartOffset := seg.Start.Sub(start) segmentStartOffset := seg.Start.Sub(start)
segmentMaxElapsed, err := segmentFMP4MuxParts(f, segmentStartOffset, duration, firstInit, m) var segmentMaxElapsed time.Duration
segmentMaxElapsed, err = segmentFMP4MuxParts(f, segmentStartOffset, duration, firstInit, m)
if err != nil { if err != nil {
return err return err
} }

15
internal/playback/segment_fmp4.go
View File

@@ -159,7 +159,8 @@ func segmentFMP4ReadMaxDuration(
lastMoofPos := int64(-1) lastMoofPos := int64(-1)
for { for {
moofPos, err := r.Seek(0, io.SeekCurrent) var moofPos int64
moofPos, err = r.Seek(0, io.SeekCurrent)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@@ -423,9 +424,9 @@ func segmentFMP4SeekAndMuxParts(
e.SampleSize, e.SampleSize,
func() ([]byte, error) { func() ([]byte, error) {
payload := make([]byte, sampleSize) payload := make([]byte, sampleSize)
n, err := r.ReadAt(payload, int64(sampleOffset)) n, err2 := r.ReadAt(payload, int64(sampleOffset))
if err != nil { if err2 != nil {
return nil, err return nil, err2
} }
if n != int(sampleSize) { if n != int(sampleSize) {
return nil, fmt.Errorf("partial read") return nil, fmt.Errorf("partial read")
@@ -547,9 +548,9 @@ func segmentFMP4MuxParts(
e.SampleSize, e.SampleSize,
func() ([]byte, error) { func() ([]byte, error) {
payload := make([]byte, sampleSize) payload := make([]byte, sampleSize)
n, err := r.ReadAt(payload, int64(sampleOffset)) n, err2 := r.ReadAt(payload, int64(sampleOffset))
if err != nil { if err2 != nil {
return nil, err return nil, err2
} }
if n != int(sampleSize) { if n != int(sampleSize) {
return nil, fmt.Errorf("partial read") return nil, fmt.Errorf("partial read")

2
internal/playback/segment_fmp4_test.go
View File

@@ -60,7 +60,7 @@ func BenchmarkFMP4ReadInit(b *testing.B) {
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
func() { func() {
f, err := os.Open(f.Name()) f, err = os.Open(f.Name())
if err != nil { if err != nil {
panic(err) panic(err)
} }

2
internal/protocols/rtmp/chunk/chunk0.go
View File

@@ -32,7 +32,7 @@ func (c *Chunk0) Read(r io.Reader, maxBodyLen uint32, _ bool) error {
c.MessageStreamID = uint32(header[8])<<24 | uint32(header[9])<<16 | uint32(header[10])<<8 | uint32(header[11]) c.MessageStreamID = uint32(header[8])<<24 | uint32(header[9])<<16 | uint32(header[10])<<8 | uint32(header[11])
if c.Timestamp >= 0xFFFFFF { if c.Timestamp >= 0xFFFFFF {
_, err := io.ReadFull(r, header[:4]) _, err = io.ReadFull(r, header[:4])
if err != nil { if err != nil {
return err return err
} }

2
internal/protocols/rtmp/chunk/chunk3.go
View File

@@ -26,7 +26,7 @@ func (c *Chunk3) Read(r io.Reader, bodyLen uint32, hasExtendedTimestamp bool) er
c.ChunkStreamID = header[0] & 0x3F c.ChunkStreamID = header[0] & 0x3F
if hasExtendedTimestamp { if hasExtendedTimestamp {
_, err := io.ReadFull(r, header[:4]) _, err = io.ReadFull(r, header[:4])
if err != nil { if err != nil {
return err return err
} }

1
internal/protocols/rtmp/conn.go
View File

@@ -342,7 +342,6 @@ func (c *Conn) initializeServer() (*url.URL, bool, error) {
var rw io.ReadWriter var rw io.ReadWriter
if keyIn != nil { if keyIn != nil {
var err error
rw, err = newRC4ReadWriter(c.bc, keyIn, keyOut) rw, err = newRC4ReadWriter(c.bc, keyIn, keyOut)
if err != nil { if err != nil {
return nil, false, err return nil, false, err

80
internal/protocols/rtmp/conn_test.go
View File

@@ -28,37 +28,37 @@ func TestNewClientConn(t *testing.T) {
done := make(chan struct{}) done := make(chan struct{})
go func() { go func() {
conn, err := ln.Accept() conn, err2 := ln.Accept()
require.NoError(t, err) require.NoError(t, err2)
defer conn.Close() defer conn.Close()
bc := bytecounter.NewReadWriter(conn) bc := bytecounter.NewReadWriter(conn)
_, _, err = handshake.DoServer(bc, false) _, _, err2 = handshake.DoServer(bc, false)
require.NoError(t, err) require.NoError(t, err2)
mrw := message.NewReadWriter(bc, bc, true) mrw := message.NewReadWriter(bc, bc, true)
msg, err := mrw.Read() msg, err2 := mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.SetWindowAckSize{ require.Equal(t, &message.SetWindowAckSize{
Value: 2500000, Value: 2500000,
}, msg) }, msg)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.SetPeerBandwidth{ require.Equal(t, &message.SetPeerBandwidth{
Value: 2500000, Value: 2500000,
Type: 2, Type: 2,
}, msg) }, msg)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.SetChunkSize{ require.Equal(t, &message.SetChunkSize{
Value: 65536, Value: 65536,
}, msg) }, msg)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "connect", Name: "connect",
@@ -77,7 +77,7 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
err = mrw.Write(&message.CommandAMF0{ err2 = mrw.Write(&message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "_result", Name: "_result",
CommandID: 1, CommandID: 1,
@@ -94,12 +94,12 @@ func TestNewClientConn(t *testing.T) {
}, },
}, },
}) })
require.NoError(t, err) require.NoError(t, err2)
switch ca { switch ca {
case "read", "read nginx rtmp": case "read", "read nginx rtmp":
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "createStream", Name: "createStream",
@@ -109,7 +109,7 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
err = mrw.Write(&message.CommandAMF0{ err2 = mrw.Write(&message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "_result", Name: "_result",
CommandID: 2, CommandID: 2,
@@ -118,16 +118,16 @@ func TestNewClientConn(t *testing.T) {
float64(1), float64(1),
}, },
}) })
require.NoError(t, err) require.NoError(t, err2)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.UserControlSetBufferLength{ require.Equal(t, &message.UserControlSetBufferLength{
BufferLength: 0x64, BufferLength: 0x64,
}, msg) }, msg)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 4, ChunkStreamID: 4,
MessageStreamID: 0x1000000, MessageStreamID: 0x1000000,
@@ -139,7 +139,7 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
err = mrw.Write(&message.CommandAMF0{ err2 = mrw.Write(&message.CommandAMF0{
ChunkStreamID: 5, ChunkStreamID: 5,
MessageStreamID: 0x1000000, MessageStreamID: 0x1000000,
Name: "onStatus", Name: "onStatus",
@@ -158,11 +158,11 @@ func TestNewClientConn(t *testing.T) {
}, },
}, },
}) })
require.NoError(t, err) require.NoError(t, err2)
case "publish": case "publish":
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "releaseStream", Name: "releaseStream",
@@ -173,8 +173,8 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "FCPublish", Name: "FCPublish",
@@ -185,8 +185,8 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "createStream", Name: "createStream",
@@ -196,7 +196,7 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
err = mrw.Write(&message.CommandAMF0{ err2 = mrw.Write(&message.CommandAMF0{
ChunkStreamID: 3, ChunkStreamID: 3,
Name: "_result", Name: "_result",
CommandID: 4, CommandID: 4,
@@ -205,10 +205,10 @@ func TestNewClientConn(t *testing.T) {
float64(1), float64(1),
}, },
}) })
require.NoError(t, err) require.NoError(t, err2)
msg, err = mrw.Read() msg, err2 = mrw.Read()
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &message.CommandAMF0{ require.Equal(t, &message.CommandAMF0{
ChunkStreamID: 4, ChunkStreamID: 4,
MessageStreamID: 0x1000000, MessageStreamID: 0x1000000,
@@ -221,7 +221,7 @@ func TestNewClientConn(t *testing.T) {
}, },
}, msg) }, msg)
err = mrw.Write(&message.CommandAMF0{ err2 = mrw.Write(&message.CommandAMF0{
ChunkStreamID: 5, ChunkStreamID: 5,
MessageStreamID: 0x1000000, MessageStreamID: 0x1000000,
Name: "onStatus", Name: "onStatus",
@@ -235,7 +235,7 @@ func TestNewClientConn(t *testing.T) {
}, },
}, },
}) })
require.NoError(t, err) require.NoError(t, err2)
} }
close(done) close(done)
@@ -280,12 +280,12 @@ func TestNewServerConn(t *testing.T) {
done := make(chan struct{}) done := make(chan struct{})
go func() { go func() {
nconn, err := ln.Accept() nconn, err2 := ln.Accept()
require.NoError(t, err) require.NoError(t, err2)
defer nconn.Close() defer nconn.Close()
_, u, isPublishing, err := NewServerConn(nconn) _, u, isPublishing, err2 := NewServerConn(nconn)
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, &url.URL{ require.Equal(t, &url.URL{
Scheme: "rtmp", Scheme: "rtmp",

13
internal/protocols/rtmp/reader.go
View File

@@ -47,8 +47,8 @@ func hasVideo(md amf0.Object) (bool, error) {
v, ok := md.Get("videocodecid") v, ok := md.Get("videocodecid")
if !ok { if !ok {
// some Dahua cameras send width and height without videocodecid // some Dahua cameras send width and height without videocodecid
if v, ok := md.Get("width"); ok { if v2, ok := md.Get("width"); ok {
if vf, ok := v.(float64); ok && vf != 0 { if vf, ok := v2.(float64); ok && vf != 0 {
return true, nil return true, nil
} }
} }
@@ -219,7 +219,8 @@ func tracksFromMetadata(conn *Conn, payload []interface{}) (format.Format, forma
// format used by OBS < 29.1 to publish H265 // format used by OBS < 29.1 to publish H265
} else if msg.Type == message.VideoTypeAU && msg.IsKeyFrame { } else if msg.Type == message.VideoTypeAU && msg.IsKeyFrame {
nalus, err := h264.AVCCUnmarshal(msg.Payload) var nalus [][]byte
nalus, err = h264.AVCCUnmarshal(msg.Payload)
if err != nil { if err != nil {
if errors.Is(err, h264.ErrAVCCNoNALUs) { if errors.Is(err, h264.ErrAVCCNoNALUs) {
continue continue
@@ -271,7 +272,7 @@ func tracksFromMetadata(conn *Conn, payload []interface{}) (format.Format, forma
switch msg.FourCC { switch msg.FourCC {
case message.FourCCHEVC: case message.FourCCHEVC:
var hvcc mp4.HvcC var hvcc mp4.HvcC
_, err := mp4.Unmarshal(bytes.NewReader(msg.Config), uint64(len(msg.Config)), &hvcc, mp4.Context{}) _, err = mp4.Unmarshal(bytes.NewReader(msg.Config), uint64(len(msg.Config)), &hvcc, mp4.Context{})
if err != nil { if err != nil {
return nil, nil, fmt.Errorf("invalid H265 configuration: %w", err) return nil, nil, fmt.Errorf("invalid H265 configuration: %w", err)
} }
@@ -292,7 +293,7 @@ func tracksFromMetadata(conn *Conn, payload []interface{}) (format.Format, forma
case message.FourCCAV1: case message.FourCCAV1:
var av1c mp4.Av1C var av1c mp4.Av1C
_, err := mp4.Unmarshal(bytes.NewReader(msg.Config), uint64(len(msg.Config)), &av1c, mp4.Context{}) _, err = mp4.Unmarshal(bytes.NewReader(msg.Config), uint64(len(msg.Config)), &av1c, mp4.Context{})
if err != nil { if err != nil {
return nil, nil, fmt.Errorf("invalid AV1 configuration: %w", err) return nil, nil, fmt.Errorf("invalid AV1 configuration: %w", err)
} }
@@ -309,7 +310,7 @@ func tracksFromMetadata(conn *Conn, payload []interface{}) (format.Format, forma
default: // VP9 default: // VP9
var vpcc mp4.VpcC var vpcc mp4.VpcC
_, err := mp4.Unmarshal(bytes.NewReader(msg.Config), uint64(len(msg.Config)), &vpcc, mp4.Context{}) _, err = mp4.Unmarshal(bytes.NewReader(msg.Config), uint64(len(msg.Config)), &vpcc, mp4.Context{})
if err != nil { if err != nil {
return nil, nil, fmt.Errorf("invalid VP9 configuration: %w", err) return nil, nil, fmt.Errorf("invalid VP9 configuration: %w", err)
} }

24
internal/protocols/rtmp/reader_test.go
View File

@@ -147,12 +147,12 @@ func TestReadTracks(t *testing.T) {
IsStereo: true, IsStereo: true,
AACType: message.AudioAACTypeConfig, AACType: message.AudioAACTypeConfig,
Payload: func() []byte { Payload: func() []byte {
enc, err := mpeg4audio.Config{ enc, err2 := mpeg4audio.Config{
Type: 2, Type: 2,
SampleRate: 44100, SampleRate: 44100,
ChannelCount: 2, ChannelCount: 2,
}.Marshal() }.Marshal()
require.NoError(t, err) require.NoError(t, err2)
return enc return enc
}(), }(),
}, },
@@ -267,12 +267,12 @@ func TestReadTracks(t *testing.T) {
IsStereo: true, IsStereo: true,
AACType: message.AudioAACTypeConfig, AACType: message.AudioAACTypeConfig,
Payload: func() []byte { Payload: func() []byte {
enc, err := mpeg4audio.Config{ enc, err2 := mpeg4audio.Config{
Type: 2, Type: 2,
SampleRate: 44100, SampleRate: 44100,
ChannelCount: 2, ChannelCount: 2,
}.Marshal() }.Marshal()
require.NoError(t, err) require.NoError(t, err2)
return enc return enc
}(), }(),
}, },
@@ -302,12 +302,12 @@ func TestReadTracks(t *testing.T) {
IsStereo: true, IsStereo: true,
AACType: message.AudioAACTypeConfig, AACType: message.AudioAACTypeConfig,
Payload: func() []byte { Payload: func() []byte {
enc, err := mpeg4audio.Config{ enc, err2 := mpeg4audio.Config{
Type: 2, Type: 2,
SampleRate: 44100, SampleRate: 44100,
ChannelCount: 2, ChannelCount: 2,
}.Marshal() }.Marshal()
require.NoError(t, err) require.NoError(t, err2)
return enc return enc
}(), }(),
}, },
@@ -320,12 +320,12 @@ func TestReadTracks(t *testing.T) {
IsStereo: true, IsStereo: true,
AACType: message.AudioAACTypeConfig, AACType: message.AudioAACTypeConfig,
Payload: func() []byte { Payload: func() []byte {
enc, err := mpeg4audio.Config{ enc, err2 := mpeg4audio.Config{
Type: 2, Type: 2,
SampleRate: 44100, SampleRate: 44100,
ChannelCount: 2, ChannelCount: 2,
}.Marshal() }.Marshal()
require.NoError(t, err) require.NoError(t, err2)
return enc return enc
}(), }(),
DTS: 1 * time.Second, DTS: 1 * time.Second,
@@ -385,12 +385,12 @@ func TestReadTracks(t *testing.T) {
IsKeyFrame: true, IsKeyFrame: true,
Type: message.VideoTypeAU, Type: message.VideoTypeAU,
Payload: func() []byte { Payload: func() []byte {
avcc, err := h264.AVCCMarshal([][]byte{ avcc, err2 := h264.AVCCMarshal([][]byte{
test.FormatH265.VPS, test.FormatH265.VPS,
test.FormatH265.SPS, test.FormatH265.SPS,
test.FormatH265.PPS, test.FormatH265.PPS,
}) })
require.NoError(t, err) require.NoError(t, err2)
return avcc return avcc
}(), }(),
}, },
@@ -403,12 +403,12 @@ func TestReadTracks(t *testing.T) {
IsStereo: true, IsStereo: true,
AACType: message.AudioAACTypeConfig, AACType: message.AudioAACTypeConfig,
Payload: func() []byte { Payload: func() []byte {
enc, err := mpeg4audio.Config{ enc, err2 := mpeg4audio.Config{
Type: 2, Type: 2,
SampleRate: 44100, SampleRate: 44100,
ChannelCount: 2, ChannelCount: 2,
}.Marshal() }.Marshal()
require.NoError(t, err) require.NoError(t, err2)
return enc return enc
}(), }(),
}, },

2
internal/protocols/webrtc/whip_client.go
View File

@@ -191,7 +191,7 @@ outer:
for { for {
select { select {
case ca := <-c.pc.NewLocalCandidate(): case ca := <-c.pc.NewLocalCandidate():
err := c.patchCandidate(ctx, offer, res.ETag, ca) err = c.patchCandidate(ctx, offer, res.ETag, ca)
if err != nil { if err != nil {
c.deleteSession(context.Background()) //nolint:errcheck c.deleteSession(context.Background()) //nolint:errcheck
c.pc.Close() c.pc.Close()

10
internal/record/agent_test.go
View File

@@ -189,13 +189,13 @@ func TestAgent(t *testing.T) {
if ca == "fmp4" { if ca == "fmp4" {
func() { func() {
f, err := os.Open(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext)) f, err2 := os.Open(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext))
require.NoError(t, err) require.NoError(t, err2)
defer f.Close() defer f.Close()
var init fmp4.Init var init fmp4.Init
err = init.Unmarshal(f) err2 = init.Unmarshal(f)
require.NoError(t, err) require.NoError(t, err2)
require.Equal(t, fmp4.Init{ require.Equal(t, fmp4.Init{
Tracks: []*fmp4.InitTrack{ Tracks: []*fmp4.InitTrack{
@@ -252,7 +252,7 @@ func TestAgent(t *testing.T) {
_, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-16-25-000000."+ext)) _, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-16-25-000000."+ext))
require.NoError(t, err) require.NoError(t, err)
} else { } else {
_, err := os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext)) _, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-15-25-000000."+ext))
require.NoError(t, err) require.NoError(t, err)
_, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-16-25-000000."+ext)) _, err = os.Stat(filepath.Join(dir, "mypath", "2008-05-20_22-16-25-000000."+ext))

4
internal/servers/rtsp/session.go
View File

@@ -212,8 +212,8 @@ func (s *session) onSetup(c *conn, ctx *gortsplib.ServerHandlerOnSetupCtx,
if err != nil { if err != nil {
var terr auth.Error var terr auth.Error
if errors.As(err, &terr) { if errors.As(err, &terr) {
res, err := c.handleAuthError(terr) res, err2 := c.handleAuthError(terr)
return res, nil, err return res, nil, err2
} }
var terr2 defs.PathNoOnePublishingError var terr2 defs.PathNoOnePublishingError

6
internal/servers/srt/streamid_test.go
View File

@@ -52,10 +52,10 @@ func TestStreamIDUnmarshal(t *testing.T) {
}, },
} { } {
t.Run(ca.name, func(t *testing.T) { t.Run(ca.name, func(t *testing.T) {
var streamID streamID var sid streamID
err := streamID.unmarshal(ca.raw) err := sid.unmarshal(ca.raw)
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, ca.dec, streamID) require.Equal(t, ca.dec, sid)
}) })
} }
} }

25
internal/staticsources/rtsp/source_test.go
View File

@@ -55,8 +55,8 @@ func TestSource(t *testing.T) {
Handler: &testServer{ Handler: &testServer{
onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx, onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx,
) (*base.Response, *gortsplib.ServerStream, error) { ) (*base.Response, *gortsplib.ServerStream, error) {
err := auth.Validate(ctx.Request, "testuser", "testpass", nil, nil, "IPCAM", nonce) err2 := auth.Validate(ctx.Request, "testuser", "testpass", nil, nil, "IPCAM", nonce)
if err != nil { if err2 != nil {
return &base.Response{ //nolint:nilerr return &base.Response{ //nolint:nilerr
StatusCode: base.StatusUnauthorized, StatusCode: base.StatusUnauthorized,
Header: base.Header{ Header: base.Header{
@@ -77,7 +77,7 @@ func TestSource(t *testing.T) {
onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) { onPlay: func(_ *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
go func() { go func() {
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
err := stream.WritePacketRTP(media0, &rtp.Packet{ err2 := stream.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 0x02, Version: 0x02,
PayloadType: 96, PayloadType: 96,
@@ -88,7 +88,7 @@ func TestSource(t *testing.T) {
}, },
Payload: []byte{5, 1, 2, 3, 4}, Payload: []byte{5, 1, 2, 3, 4},
}) })
require.NoError(t, err) require.NoError(t, err2)
}() }()
return &base.Response{ return &base.Response{
@@ -105,15 +105,18 @@ func TestSource(t *testing.T) {
s.UDPRTCPAddress = "127.0.0.1:8003" s.UDPRTCPAddress = "127.0.0.1:8003"
case "tls": case "tls":
serverCertFpath, err := test.CreateTempFile(test.TLSCertPub) var serverCertFpath string
serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
require.NoError(t, err) require.NoError(t, err)
defer os.Remove(serverCertFpath) defer os.Remove(serverCertFpath)
serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey) var serverKeyFpath string
serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
require.NoError(t, err) require.NoError(t, err)
defer os.Remove(serverKeyFpath) defer os.Remove(serverKeyFpath)
cert, err := tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath) var cert tls.Certificate
cert, err = tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath)
require.NoError(t, err) require.NoError(t, err)
s.TLSConfig = &tls.Config{Certificates: []tls.Certificate{cert}} s.TLSConfig = &tls.Config{Certificates: []tls.Certificate{cert}}
@@ -181,8 +184,8 @@ func TestRTSPSourceNoPassword(t *testing.T) {
s := gortsplib.Server{ s := gortsplib.Server{
Handler: &testServer{ Handler: &testServer{
onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) { onDescribe: func(ctx *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
err := auth.Validate(ctx.Request, "testuser", "", nil, nil, "IPCAM", nonce) err2 := auth.Validate(ctx.Request, "testuser", "", nil, nil, "IPCAM", nonce)
if err != nil { if err2 != nil {
return &base.Response{ //nolint:nilerr return &base.Response{ //nolint:nilerr
StatusCode: base.StatusUnauthorized, StatusCode: base.StatusUnauthorized,
Header: base.Header{ Header: base.Header{
@@ -198,7 +201,7 @@ func TestRTSPSourceNoPassword(t *testing.T) {
onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) { onSetup: func(_ *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
go func() { go func() {
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
err := stream.WritePacketRTP(media0, &rtp.Packet{ err2 := stream.WritePacketRTP(media0, &rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 0x02, Version: 0x02,
PayloadType: 96, PayloadType: 96,
@@ -209,7 +212,7 @@ func TestRTSPSourceNoPassword(t *testing.T) {
}, },
Payload: []byte{5, 1, 2, 3, 4}, Payload: []byte{5, 1, 2, 3, 4},
}) })
require.NoError(t, err) require.NoError(t, err2)
}() }()
return &base.Response{ return &base.Response{

3
internal/staticsources/udp/source.go
View File

@@ -74,7 +74,8 @@ func (s *Source) Run(params defs.StaticSourceRunParams) error {
return err return err
} }
} else { } else {
tmp, err := net.ListenPacket(restrictnetwork.Restrict("udp", addr.String())) var tmp net.PacketConn
tmp, err = net.ListenPacket(restrictnetwork.Restrict("udp", addr.String()))
if err != nil { if err != nil {
return err return err
} }

16
internal/staticsources/webrtc/source_test.go
View File

@@ -69,12 +69,12 @@ func TestSource(t *testing.T) {
require.Equal(t, "/my/resource", r.URL.Path) require.Equal(t, "/my/resource", r.URL.Path)
require.Equal(t, "application/sdp", r.Header.Get("Content-Type")) require.Equal(t, "application/sdp", r.Header.Get("Content-Type"))
body, err := io.ReadAll(r.Body) body, err2 := io.ReadAll(r.Body)
require.NoError(t, err) require.NoError(t, err2)
offer := whipOffer(body) offer := whipOffer(body)
answer, err := pc.CreateFullAnswer(context.Background(), offer) answer, err2 := pc.CreateFullAnswer(context.Background(), offer)
require.NoError(t, err) require.NoError(t, err2)
w.Header().Set("Content-Type", "application/sdp") w.Header().Set("Content-Type", "application/sdp")
w.Header().Set("Accept-Patch", "application/trickle-ice-sdpfrag") w.Header().Set("Accept-Patch", "application/trickle-ice-sdpfrag")
@@ -84,10 +84,10 @@ func TestSource(t *testing.T) {
w.Write([]byte(answer.SDP)) w.Write([]byte(answer.SDP))
go func() { go func() {
err = pc.WaitUntilConnected(context.Background()) err3 := pc.WaitUntilConnected(context.Background())
require.NoError(t, err) require.NoError(t, err3)
err = tracks[0].WriteRTP(&rtp.Packet{ err3 = tracks[0].WriteRTP(&rtp.Packet{
Header: rtp.Header{ Header: rtp.Header{
Version: 2, Version: 2,
Marker: true, Marker: true,
@@ -98,7 +98,7 @@ func TestSource(t *testing.T) {
}, },
Payload: []byte{5, 2}, Payload: []byte{5, 2},
}) })
require.NoError(t, err) require.NoError(t, err3)
}() }()
default: default: