mirror of
https://github.com/ossrs/srs.git
synced 2025-02-15 04:42:04 +00:00
73dd8af4c9
For the DJI M30, there is a bug where empty NALU packets with a size of zero are causing issues with HLS streaming. This bug leads to random unpublish events due to the SRS disconnecting the connection for the HLS module when it fails to handle empty NALU packets. To address this bug, we have patched the system to ignore any empty NALU packets with a size of zero. Additionally, we have created a tool in the srs-bench to replay pcapng files captured by tcpdump or Wireshark. We have also added utest using mprotect and asan to detect any memory corruption. It is important to note that this bug has been fixed in versions 4.0.2716477f31004and 5.0.170939f6b484b. This patch specifically addresses the issue in SRS 6.0. Please be aware that there is another commit related to this bug that partially fixes the issue but still leaves a small problem for asan to detect memory corruption. This commit,577cd299e1, only ignores empty NALU packets but still reads beyond the memory. --------- Co-authored-by: chundonglinlin <chundonglinlin@163.com>
107 lines
2.9 KiB
Go
107 lines
2.9 KiB
Go
// Copyright 2012 Google, Inc. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the LICENSE file in the root of the source
|
|
// tree.
|
|
|
|
package gopacket
|
|
|
|
// LayerClass is a set of LayerTypes, used for grabbing one of a number of
|
|
// different types from a packet.
|
|
type LayerClass interface {
|
|
// Contains returns true if the given layer type should be considered part
|
|
// of this layer class.
|
|
Contains(LayerType) bool
|
|
// LayerTypes returns the set of all layer types in this layer class.
|
|
// Note that this may not be a fast operation on all LayerClass
|
|
// implementations.
|
|
LayerTypes() []LayerType
|
|
}
|
|
|
|
// Contains implements LayerClass.
|
|
func (l LayerType) Contains(a LayerType) bool {
|
|
return l == a
|
|
}
|
|
|
|
// LayerTypes implements LayerClass.
|
|
func (l LayerType) LayerTypes() []LayerType {
|
|
return []LayerType{l}
|
|
}
|
|
|
|
// LayerClassSlice implements a LayerClass with a slice.
|
|
type LayerClassSlice []bool
|
|
|
|
// Contains returns true if the given layer type should be considered part
|
|
// of this layer class.
|
|
func (s LayerClassSlice) Contains(t LayerType) bool {
|
|
return int(t) < len(s) && s[t]
|
|
}
|
|
|
|
// LayerTypes returns all layer types in this LayerClassSlice.
|
|
// Because of LayerClassSlice's implementation, this could be quite slow.
|
|
func (s LayerClassSlice) LayerTypes() (all []LayerType) {
|
|
for i := 0; i < len(s); i++ {
|
|
if s[i] {
|
|
all = append(all, LayerType(i))
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewLayerClassSlice creates a new LayerClassSlice by creating a slice of
|
|
// size max(types) and setting slice[t] to true for each type t. Note, if
|
|
// you implement your own LayerType and give it a high value, this WILL create
|
|
// a very large slice.
|
|
func NewLayerClassSlice(types []LayerType) LayerClassSlice {
|
|
var max LayerType
|
|
for _, typ := range types {
|
|
if typ > max {
|
|
max = typ
|
|
}
|
|
}
|
|
t := make([]bool, int(max+1))
|
|
for _, typ := range types {
|
|
t[typ] = true
|
|
}
|
|
return t
|
|
}
|
|
|
|
// LayerClassMap implements a LayerClass with a map.
|
|
type LayerClassMap map[LayerType]bool
|
|
|
|
// Contains returns true if the given layer type should be considered part
|
|
// of this layer class.
|
|
func (m LayerClassMap) Contains(t LayerType) bool {
|
|
return m[t]
|
|
}
|
|
|
|
// LayerTypes returns all layer types in this LayerClassMap.
|
|
func (m LayerClassMap) LayerTypes() (all []LayerType) {
|
|
for t := range m {
|
|
all = append(all, t)
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewLayerClassMap creates a LayerClassMap and sets map[t] to true for each
|
|
// type in types.
|
|
func NewLayerClassMap(types []LayerType) LayerClassMap {
|
|
m := LayerClassMap{}
|
|
for _, typ := range types {
|
|
m[typ] = true
|
|
}
|
|
return m
|
|
}
|
|
|
|
// NewLayerClass creates a LayerClass, attempting to be smart about which type
|
|
// it creates based on which types are passed in.
|
|
func NewLayerClass(types []LayerType) LayerClass {
|
|
for _, typ := range types {
|
|
if typ > maxLayerType {
|
|
// NewLayerClassSlice could create a very large object, so instead create
|
|
// a map.
|
|
return NewLayerClassMap(types)
|
|
}
|
|
}
|
|
return NewLayerClassSlice(types)
|
|
}
|