void SO::RegisterProtocol(uint32_t protocolId)
{
_registeredProtocols[protocolId] = protocolId;
DirtyInfo di;
//1. Clear
di.propertyName = format("SOT_SC_CLEAR_DATA_%u", protocolId);
di.type = SOT_SC_CLEAR_DATA;
ADD_VECTOR_END(_dirtyPropsByProtocol[protocolId], di);
//2. Initial
di.propertyName = format("SOT_SC_INITIAL_DATA_%u", protocolId);
di.type = SOT_SC_INITIAL_DATA;
ADD_VECTOR_END(_dirtyPropsByProtocol[protocolId], di);
//3. Mark all properties as updated
FOR_MAP(_payload, string, Variant, i)
{
di.propertyName = MAP_KEY(i);
di.type = SOT_SC_UPDATE_DATA;
ADD_VECTOR_END(_dirtyPropsByProtocol[protocolId], di);
}
vector<uint32_t> AtomSTSC::GetEntries(uint32_t totalChunksCount) {
if ((_normalizedEntries.size() != 0) || (_stscEntries.size() == 0))
return _normalizedEntries;
//1. Expand the table
vector<uint32_t> samplesPerChunk;
for (uint32_t i = 0; i < _stscEntries.size() - 1; i++) {
for (uint32_t j = 0; j < _stscEntries[i + 1].firstChunk - _stscEntries[i].firstChunk; j++) {
ADD_VECTOR_END(samplesPerChunk, _stscEntries[i].samplesPerChunk);
}
}
uint32_t samplesPerChunkCount = (uint32_t) samplesPerChunk.size();
for (uint32_t i = 0; i < totalChunksCount - samplesPerChunkCount; i++) {
ADD_VECTOR_END(samplesPerChunk,
_stscEntries[_stscEntries.size() - 1].samplesPerChunk);
}
//2. build the final result based on the expanded table
samplesPerChunkCount = (uint32_t) samplesPerChunk.size();
for (uint32_t i = 0; i < samplesPerChunkCount; i++) {
for (uint32_t j = 0; j < samplesPerChunk[i]; j++) {
ADD_VECTOR_END(_normalizedEntries, i);
}
}
return _normalizedEntries;
}
bool AtomAFRT::ReadData() {
//FINEST("AFRT");
if (!ReadUInt32(_timeScale)) {
FATAL("Unable to read _timeScale");
return false;
}
//FINEST("_timeScale: %"PRIu32, _timeScale);
if (!ReadUInt8(_qualityEntryCount)) {
FATAL("Unable to read _qualityEntryCount");
return false;
}
//FINEST("_qualityEntryCount: %"PRIu8, _qualityEntryCount);
for (uint8_t i = 0; i < _qualityEntryCount; i++) {
string temp;
if (!ReadNullTerminatedString(temp)) {
FATAL("Unable to read QualitySegmentUrlModifiers");
return false;
}
//FINEST("%"PRIu8": QualitySegmentUrlModifiers: %s", i, STR(temp));
ADD_VECTOR_END(_qualitySegmentUrlModifiers, temp);
}
if (!ReadUInt32(_fragmentRunEntryCount)) {
FATAL("Unable to read _fragmentRunEntryCount");
return false;
}
//FINEST("_fragmentRunEntryCount: %"PRIu32, _fragmentRunEntryCount);
for (uint32_t i = 0; i < _fragmentRunEntryCount; i++) {
FRAGMENTRUNENTRY temp = {0, 0, 0, 0};
if (!ReadUInt32(temp.firstFragment)) {
FATAL("Unable to read FRAGMENTRUNENTRY.FirstFragment");
return false;
}
if (!ReadUInt64(temp.firstFragmentTimestamp)) {
FATAL("Unable to read FRAGMENTRUNENTRY.FirstFragmentTimestamp");
return false;
}
if (!ReadUInt32(temp.fragmentDuration)) {
FATAL("Unable to read FRAGMENTRUNENTRY.FragmentDuration");
return false;
}
if (temp.fragmentDuration == 0) {
if (!ReadUInt8(temp.discontinuityIndicator)) {
FATAL("Unable to read FRAGMENTRUNENTRY.DiscontinuityIndicator");
return false;
}
}
//FINEST("%"PRIu32": FRAGMENTRUNENTRY.FirstFragment: %"PRIu32"; FRAGMENTRUNENTRY.FirstFragmentTimestamp: %"PRIu64"; FRAGMENTRUNENTRY.FragmentDuration: %"PRIu32"; FRAGMENTRUNENTRY.DiscontinuityIndicator: %"PRIu8,
// i, temp.firstFragment, temp.firstFragmentTimestamp, temp.fragmentDuration, temp.discontinuityIndicator);
ADD_VECTOR_END(_fragmentRunEntryTable, temp);
}
return true;
}
bool AtomSTSC::ReadData() {
uint32_t count;
if (!ReadUInt32(count)) {
FATAL("Unable to read count");
return false;
}
if (count == 0)
return true;
for (uint32_t i = 0; i < count; i++) {
STSCEntry entry;
if (!ReadUInt32(entry.firstChunk)) {
FATAL("Unable to read first chunk");
return false;
}
if (!ReadUInt32(entry.samplesPerChunk)) {
FATAL("Unable to read first samples per chunk");
return false;
}
if (!ReadUInt32(entry.sampleDescriptionIndex)) {
FATAL("Unable to read first sample description index");
return false;
}
ADD_VECTOR_END(_stscEntries, entry);
}
return true;
}
void TSDocument::AddFrame(double pts, double dts, uint8_t frameType) {
uint64_t currentOffset = _pParser->GetTotalParsedBytes();
bool insert = false;
if (_lastOffset == 0) {
_lastOffset = currentOffset;
insert = true;
} else if ((currentOffset - _lastOffset) < 7 * 188) {
insert = false;
} else {
insert = true;
}
if (!insert)
return;
MediaFrame frame;
frame.cts = dts - pts;
frame.dts = dts;
frame.isBinaryHeader = false;
frame.isKeyFrame = true;
frame.length = 0;
frame.pts = pts;
frame.start = currentOffset + _chunkSizeDetectionCount;
frame.type = frameType;
ADD_VECTOR_END(_frames, frame);
_lastOffset = currentOffset;
}
BaseRTMPProtocol::BaseRTMPProtocol(uint64_t protocolType)
: BaseProtocol(protocolType) {
_handshakeCompleted = false;
_rtmpState = RTMP_STATE_NOT_INITIALIZED;
//TODO: Make use of winacksize which is in fact the value setted up for
//the nex bytes sent report
_winAckSize = RECEIVED_BYTES_COUNT_REPORT_CHUNK;
_nextReceivedBytesCountReport = _winAckSize;
for (uint32_t i = 0; i < MAX_CHANNELS_COUNT; i++) {
_channels[i].id = i;
_channels[i].Reset();
}
_selectedChannel = -1;
_inboundChunkSize = 128;
_outboundChunkSize = 128;
for (uint32_t i = 0; i < MAX_STREAMS_COUNT; i++) {
_streams[i] = NULL;
}
for (uint32_t i = MIN_AV_CHANNLES; i < MAX_AV_CHANNLES; i++)
ADD_VECTOR_END(_channelsPool, i);
_pSignaledRTMPOutNetStream = NULL;
_rxInvokes = 0;
_txInvokes = 0;
#ifdef ENFORCE_RTMP_OUTPUT_CHECKS
_pMonitor = new MonitorRTMPProtocol(MAX_STREAMS_COUNT, MAX_CHANNELS_COUNT);
#endif /* ENFORCE_RTMP_OUTPUT_CHECKS */
}
void IOHandlerManager::FreeToken(IOHandler *pIOHandler) {
IOHandlerManagerToken *pToken = pIOHandler->GetIOHandlerManagerToken();
pIOHandler->SetIOHandlerManagerToken(NULL);
pToken->pPayload = NULL;
pToken->validPayload = false;
ADD_VECTOR_END((*_pRecycledTokens), pToken);
}
bool FileLogLocation::OpenFile()
{
_canLog = false;
_fileStream.close();
_fileIsClosed = true;
double ts;
GETCLOCKS(ts);
ts = (ts / CLOCKS_PER_SECOND) * 1000;
string temp = format("%s.%"PRIu64".%"PRIu64, STR(_fileName), (uint64_t) getpid(), (uint64_t) ts);
ios_base::openmode openMode = ios_base::out | ios_base::binary | ios_base::trunc;
_fileStream.open(STR(temp), openMode);
if (_fileStream.fail())
return false;
_fileStream << "PID: " << getpid() << "; TIMESTAMP: " << time(NULL) << endl;
if (_fileHistorySize > 0)
{
ADD_VECTOR_END(_history, temp);
while (_history.size() > _fileHistorySize)
{
deleteFile(_history[0]);
_history.erase(_history.begin());
}
}
_currentLength = 0;
_canLog = true;
_fileIsClosed = false;
return true;
}
bool SDP::ParseSDP(SDP &sdp, string &raw) {
//FINEST("%s", STR(raw));
//1. Reset
sdp.Reset();
//2. Prepare the sections
sdp[SDP_SESSION].IsArray(false);
sdp[SDP_MEDIATRACKS].IsArray(true);
//3. Split the raw content into lines
replace(raw, "\r\n", "\n");
vector<string> lines;
split(raw, "\n", lines);
//4. Detect the media tracks indexes
vector<uint32_t> trackIndexes;
for (uint32_t i = 0; i < lines.size(); i++) {
trim(lines[i]);
if (lines[i].find("m=") == 0) {
ADD_VECTOR_END(trackIndexes, i);
}
}
if (trackIndexes.size() == 0) {
FATAL("No tracks found");
return false;
}
//5. Parse the header
if (!ParseSection(sdp[SDP_SESSION], lines, 0, trackIndexes[0])) {
FATAL("Unable to parse header");
return false;
}
//6. Parse the media sections
Variant media;
for (uint32_t i = 0; i < trackIndexes.size() - 1; i++) {
media.Reset();
media.IsArray(false);
if (!ParseSection(media, lines, trackIndexes[i], trackIndexes[i + 1] - trackIndexes[i])) {
FATAL("Unable to parse header");
return false;
}
sdp[SDP_MEDIATRACKS].PushToArray(media);
}
//7. Parse the last media section
media.Reset();
media.IsArray(false);
if (!ParseSection(media, lines,
trackIndexes[(uint32_t) trackIndexes.size() - 1],
(uint32_t) trackIndexes.size() - trackIndexes[(uint32_t) trackIndexes.size() - 1])) {
FATAL("Unable to parse header");
return false;
}
sdp[SDP_MEDIATRACKS].PushToArray(media);
return true;
}
vector<BaseOutStream *> BaseInStream::GetOutStreams() {
vector<BaseOutStream *> result;
LinkedListNode<BaseOutStream *> *pTemp = _pOutStreams;
while (pTemp != NULL) {
ADD_VECTOR_END(result, pTemp->info);
pTemp = pTemp->pPrev;
}
return result;
}
vector<BaseOutStream *> BaseInStream::GetOutStreams() {
vector<BaseOutStream *> result;
LinkedListNode<BaseOutStream *> *pIterator = _pOutStreams;
LinkedListNode<BaseOutStream *> *pCurrent = NULL;
while (pIterator != NULL) {
pCurrent = pIterator;
pIterator = pIterator->pPrev;
ADD_VECTOR_END(result, pCurrent->info);
}
return result;
}
vector<int32_t> AtomCTTS::GetEntries() {
if (_normalizedEntries.size() != 0)
return _normalizedEntries;
FOR_VECTOR_ITERATOR(CTTSEntry, _entries, i) {
for (uint32_t j = 0; j < VECTOR_VAL(i).sampleCount; j++) {
ADD_VECTOR_END(_normalizedEntries, VECTOR_VAL(i).sampleOffset);
}
}
return _normalizedEntries;
}
vector<uint32_t> AtomSTTS::GetEntries() {
if (_normalizedEntries.size() != 0)
return _normalizedEntries;
FOR_VECTOR_ITERATOR(STTSEntry, _sttsEntries, i) {
for (uint32_t j = 0; j < VECTOR_VAL(i).count; j++) {
ADD_VECTOR_END(_normalizedEntries, VECTOR_VAL(i).delta);
}
}
return _normalizedEntries;
}
bool AtomDREF::AtomCreated(BaseAtom *pAtom) {
switch (pAtom->GetTypeNumeric()) {
case A_URL:
ADD_VECTOR_END(_urls, (AtomURL *) pAtom);
return true;
default:
{
FATAL("Invalid atom type: %s", STR(pAtom->GetTypeString()));
return false;
}
}
}
ConsoleLogLocation::ConsoleLogLocation(Variant &configuration)
: BaseLogLocation(configuration) {
_allowColors = false;
ADD_VECTOR_END(_colors, FATAL_COLOR);
ADD_VECTOR_END(_colors, ERROR_COLOR);
ADD_VECTOR_END(_colors, WARNING_COLOR);
ADD_VECTOR_END(_colors, INFO_COLOR);
ADD_VECTOR_END(_colors, DEBUG_COLOR);
ADD_VECTOR_END(_colors, FINE_COLOR);
ADD_VECTOR_END(_colors, FINEST_COLOR);
}
BaseAtom * BoxAtom::GetPath(uint8_t depth, ...) {
vector<uint32_t> path;
va_list arguments;
va_start(arguments, depth);
for (uint8_t i = 0; i < depth; i++) {
uint32_t pathElement = va_arg(arguments, uint32_t);
ADD_VECTOR_END(path, pathElement);
}
va_end(arguments);
if (path.size() == 0)
return NULL;
return GetPath(path);
}
bool NetworkManager::GetInterface(vector<string> &netIFs) {
//return listFolder("/sys/class/net", netIFs, true, false, false);
string path = "/sys/class/net";
DIR *pDir = NULL;
pDir = opendir(STR(path));
if (pDir == NULL) {
int err = errno;
FATAL("Unable to open folder: %s %d %s", STR(path), err, strerror(err));
return false;
}
struct dirent *pDirent = NULL;
while ((pDirent = readdir(pDir)) != NULL) {
string entry = pDirent->d_name;
if ((entry == ".")
|| (entry == "..")) {
continue;
}
if (entry == "")
continue;
ADD_VECTOR_END(netIFs, entry);
//if (pDirent->d_type == DT_DIR) {
// ADD_VECTOR_END(netIFs, entry);
//}
}
closedir(pDir);
return true;
//ifstream ifs;
//string line, netif;
//ifs.open("/proc/net/dev", ifstream::in);
//if(ifs.is_open()){
// getline(ifs, line); //first line
// getline(ifs, line); //second line
// while(ifs.good()){
// getline(ifs, line);
// stringstream ss(line.substr(0, 6));
// ss >> netif;
// if(netif.length() > 0){
// netIF.push_back(netif);
// netif.clear();
// }
// }
//}
//ifs.close();
//return true;
}
bool AtomTRAF::AtomCreated(BaseAtom *pAtom) {
switch (pAtom->GetTypeNumeric()) {
case A_TFHD:
_pTFHD = (AtomTFHD *) pAtom;
return true;
case A_TRUN:
ADD_VECTOR_END(_runs, (AtomTRUN *) pAtom);
return true;
default:
{
FATAL("Invalid atom type: %s", STR(pAtom->GetTypeString()));
return false;
}
}
}
ConsoleLogLocation::ConsoleLogLocation(bool allowColors)
: BaseLogLocation() {
_allowColors = allowColors;
if (allowColors) {
if (_colors.size() <= 0) {
ADD_VECTOR_END(_colors, FATAL_COLOR);
ADD_VECTOR_END(_colors, ERROR_COLOR);
ADD_VECTOR_END(_colors, WARNING_COLOR);
ADD_VECTOR_END(_colors, INFO_COLOR);
ADD_VECTOR_END(_colors, DEBUG_COLOR);
ADD_VECTOR_END(_colors, FINE_COLOR);
ADD_VECTOR_END(_colors, FINEST_COLOR);
}
}
}
bool AtomSTCO::ReadData() {
uint32_t count;
if (!ReadUInt32(count)) {
FATAL("Unable to read count");
return false;
}
for (uint32_t i = 0; i < count; i++) {
uint32_t offset;
if (!ReadUInt32(offset)) {
FATAL("Unable to read offset");
return false;
}
ADD_VECTOR_END(_entries, offset);
}
return true;
}
bool AtomSTSS::ReadData() {
uint32_t count;
if (!ReadUInt32(count)) {
FATAL("Unable to read count");
return false;
}
for (uint32_t i = 0; i < count; i++) {
uint32_t sampleNumber;
if (!ReadUInt32(sampleNumber)) {
FATAL("Unable to read sample number");
return false;
}
ADD_VECTOR_END(_entries, sampleNumber);
}
return true;
}
bool BoxAtom::Read() {
while (CurrentPosition() != _start + _size) {
BaseAtom *pAtom = GetDoc()->ReadAtom(this);
if (pAtom == NULL) {
FATAL("Unable to read atom. Parent atom is %s",
STR(GetTypeString()));
return false;
}
if (!pAtom->IsIgnored()) {
if (!AtomCreated(pAtom)) {
FATAL("Unable to signal AtomCreated for atom %s (%"PRIx64")",
STR(GetTypeString()), _start);
return false;
}
}
ADD_VECTOR_END(_subAtoms, pAtom);
}
return true;
}
bool AtomCTTS::ReadData() {
uint32_t count;
if (!ReadUInt32(count)) {
FATAL("Unable to read count");
return false;
}
for (uint32_t i = 0; i < count; i++) {
CTTSEntry entry;
if (!ReadUInt32(entry.sampleCount)) {
FATAL("Unable to read sample count");
return false;
}
if (!ReadInt32(entry.sampleOffset)) {
FATAL("Unable to read sample offset");
return false;
}
ADD_VECTOR_END(_entries, entry);
}
return true;
}
bool AtomSTTS::ReadData() {
uint32_t entryCount;
if (!ReadUInt32(entryCount)) {
FATAL("Unable to read entry count");
return false;
}
for (uint32_t i = 0; i < entryCount; i++) {
STTSEntry entry;
if (!ReadUInt32(entry.count)) {
FATAL("Unable to read count");
return false;
}
if (!ReadUInt32(entry.delta)) {
FATAL("Unable to read delta");
return false;
}
ADD_VECTOR_END(_sttsEntries, entry);
}
return true;
}
AMF0Serializer::AMF0Serializer() {
if (_keysOrder.size() <= 0) {
ADD_VECTOR_END(_keysOrder, "app");
ADD_VECTOR_END(_keysOrder, "flashVer");
ADD_VECTOR_END(_keysOrder, "fmsVer");
ADD_VECTOR_END(_keysOrder, "swfUrl");
ADD_VECTOR_END(_keysOrder, "tcUrl");
ADD_VECTOR_END(_keysOrder, "fpad");
ADD_VECTOR_END(_keysOrder, "capabilities");
ADD_VECTOR_END(_keysOrder, "audioCodecs");
ADD_VECTOR_END(_keysOrder, "videoCodecs");
ADD_VECTOR_END(_keysOrder, "videoFunction");
ADD_VECTOR_END(_keysOrder, "pageUrl");
ADD_VECTOR_END(_keysOrder, "level");
ADD_VECTOR_END(_keysOrder, "code");
ADD_VECTOR_END(_keysOrder, "description");
ADD_VECTOR_END(_keysOrder, "details");
ADD_VECTOR_END(_keysOrder, "clientid");
ADD_VECTOR_END(_keysOrder, "duration");
ADD_VECTOR_END(_keysOrder, "width");
ADD_VECTOR_END(_keysOrder, "height");
ADD_VECTOR_END(_keysOrder, "videorate");
ADD_VECTOR_END(_keysOrder, "framerate");
ADD_VECTOR_END(_keysOrder, "videocodecid");
ADD_VECTOR_END(_keysOrder, "audiorate");
ADD_VECTOR_END(_keysOrder, "audiorate");
ADD_VECTOR_END(_keysOrder, "audiodelay");
ADD_VECTOR_END(_keysOrder, "audiocodecid");
ADD_VECTOR_END(_keysOrder, "canSeekToEnd");
ADD_VECTOR_END(_keysOrder, "creationdate");
}
}
void BoxAtom::SetChildAtom(BaseAtom *pChild) {
ADD_VECTOR_END(_subAtoms, pChild);
}
vector<uint64_t> DefaultProtocolFactory::HandledProtocols() {
vector<uint64_t> result;
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_UDP);
ADD_VECTOR_END(result, PT_INBOUND_SSL);
ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
#ifdef HAS_PROTOCOL_DNS
ADD_VECTOR_END(result, PT_INBOUND_DNS);
ADD_VECTOR_END(result, PT_OUTBOUND_DNS);
#endif /* HAS_PROTOCOL_DNS */
ADD_VECTOR_END(result, PT_TIMER);
#ifdef HAS_PROTOCOL_TS
ADD_VECTOR_END(result, PT_INBOUND_TS);
#endif /* HAS_PROTOCOL_TS */
#ifdef HAS_PROTOCOL_RTMP
ADD_VECTOR_END(result, PT_INBOUND_RTMP);
ADD_VECTOR_END(result, PT_INBOUND_RTMPS_DISC);
ADD_VECTOR_END(result, PT_OUTBOUND_RTMP);
ADD_VECTOR_END(result, PT_MONITOR_RTMP);
ADD_VECTOR_END(result, PT_RTMPE);
#ifdef HAS_PROTOCOL_HTTP
ADD_VECTOR_END(result, PT_INBOUND_HTTP_FOR_RTMP);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP_FOR_RTMP);
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_RTMP */
#ifdef HAS_PROTOCOL_HTTP
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
#endif /* HAS_PROTOCOL_HTTP */
#ifdef HAS_PROTOCOL_LIVEFLV
ADD_VECTOR_END(result, PT_INBOUND_LIVE_FLV);
ADD_VECTOR_END(result, PT_OUTBOUND_LIVE_FLV);
#endif /* HAS_PROTOCOL_LIVEFLV */
#ifdef HAS_PROTOCOL_VAR
ADD_VECTOR_END(result, PT_BIN_VAR);
ADD_VECTOR_END(result, PT_XML_VAR);
ADD_VECTOR_END(result, PT_JSON_VAR);
#endif /* HAS_PROTOCOL_VAR */
#ifdef HAS_PROTOCOL_RTP
ADD_VECTOR_END(result, PT_RTSP);
ADD_VECTOR_END(result, PT_RTCP);
ADD_VECTOR_END(result, PT_INBOUND_RTP);
ADD_VECTOR_END(result, PT_RTP_NAT_TRAVERSAL);
#endif /* HAS_PROTOCOL_RTP */
#ifdef HAS_PROTOCOL_CLI
ADD_VECTOR_END(result, PT_INBOUND_JSONCLI);
ADD_VECTOR_END(result, PT_HTTP_4_CLI);
#endif /* HAS_PROTOCOL_CLI */
#ifdef HAS_PROTOCOL_MMS
ADD_VECTOR_END(result, PT_OUTBOUND_MMS);
#endif /* HAS_PROTOCOL_MMS */
#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
ADD_VECTOR_END(result, PT_INBOUND_RAW_HTTP_STREAM);
#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
return result;
}
vector<uint64_t> DefaultProtocolFactory::ResolveProtocolChain(string name) {
vector<uint64_t> result;
if (false) {
}
#ifdef HAS_PROTOCOL_DNS
else if (name == CONF_PROTOCOL_INBOUND_DNS) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_DNS);
} else if (name == CONF_PROTOCOL_OUTBOUND_DNS) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_DNS);
}
#endif /* HAS_PROTOCOL_DNS */
#ifdef HAS_PROTOCOL_RTMP
else if (name == CONF_PROTOCOL_INBOUND_RTMP) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_RTMP);
} else if (name == CONF_PROTOCOL_OUTBOUND_RTMP) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_RTMP);
} else if (name == CONF_PROTOCOL_INBOUND_RTMPS) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_SSL);
ADD_VECTOR_END(result, PT_INBOUND_RTMPS_DISC);
}
#ifdef HAS_PROTOCOL_HTTP
else if (name == CONF_PROTOCOL_INBOUND_RTMPT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_INBOUND_HTTP_FOR_RTMP);
}
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_RTMP */
#ifdef HAS_PROTOCOL_TS
else if (name == CONF_PROTOCOL_INBOUND_TCP_TS) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_TS);
} else if (name == CONF_PROTOCOL_INBOUND_UDP_TS) {
ADD_VECTOR_END(result, PT_UDP);
ADD_VECTOR_END(result, PT_INBOUND_TS);
}
#endif /* HAS_PROTOCOL_TS */
#ifdef HAS_PROTOCOL_RTP
else if (name == CONF_PROTOCOL_INBOUND_RTSP) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_RTSP);
} else if (name == CONF_PROTOCOL_RTSP_RTCP) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_RTSP);
ADD_VECTOR_END(result, PT_RTCP);
} else if (name == CONF_PROTOCOL_UDP_RTCP) {
ADD_VECTOR_END(result, PT_UDP);
ADD_VECTOR_END(result, PT_RTCP);
} else if (name == CONF_PROTOCOL_INBOUND_RTSP_RTP) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_RTSP);
ADD_VECTOR_END(result, PT_INBOUND_RTP);
} else if (name == CONF_PROTOCOL_INBOUND_UDP_RTP) {
ADD_VECTOR_END(result, PT_UDP);
ADD_VECTOR_END(result, PT_INBOUND_RTP);
} else if (name == CONF_PROTOCOL_RTP_NAT_TRAVERSAL) {
ADD_VECTOR_END(result, PT_UDP);
ADD_VECTOR_END(result, PT_RTP_NAT_TRAVERSAL);
}
#endif /* HAS_PROTOCOL_RTP */
#ifdef HAS_PROTOCOL_HTTP
else if (name == CONF_PROTOCOL_OUTBOUND_HTTP) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
}
#endif /* HAS_PROTOCOL_HTTP */
#ifdef HAS_PROTOCOL_LIVEFLV
else if (name == CONF_PROTOCOL_INBOUND_LIVE_FLV) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_LIVE_FLV);
}
#endif /* HAS_PROTOCOL_LIVEFLV */
#ifdef HAS_PROTOCOL_VAR
else if (name == CONF_PROTOCOL_INBOUND_XML_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_XML_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_BIN_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_BIN_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_JSON_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_JSON_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_XML_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_XML_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_BIN_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_BIN_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_JSON_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_JSON_VAR);
}
#ifdef HAS_PROTOCOL_HTTP
else if (name == CONF_PROTOCOL_INBOUND_HTTP_XML_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_XML_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_HTTP_BIN_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_BIN_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_HTTP_JSON_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_JSON_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_HTTPS_XML_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_SSL);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_XML_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_HTTPS_BIN_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_SSL);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_BIN_VAR);
} else if (name == CONF_PROTOCOL_INBOUND_HTTPS_JSON_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_SSL);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_JSON_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_HTTP_XML_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
ADD_VECTOR_END(result, PT_XML_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_HTTP_BIN_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
ADD_VECTOR_END(result, PT_BIN_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_HTTP_JSON_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
ADD_VECTOR_END(result, PT_JSON_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_HTTPS_XML_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
ADD_VECTOR_END(result, PT_XML_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_HTTPS_BIN_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
ADD_VECTOR_END(result, PT_BIN_VAR);
} else if (name == CONF_PROTOCOL_OUTBOUND_HTTPS_JSON_VARIANT) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
ADD_VECTOR_END(result, PT_JSON_VAR);
}
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_VAR */
#ifdef HAS_PROTOCOL_CLI
else if (name == CONF_PROTOCOL_INBOUND_CLI_JSON) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_JSONCLI);
}
#ifdef HAS_PROTOCOL_HTTP
else if (name == CONF_PROTOCOL_INBOUND_HTTP_CLI_JSON) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_HTTP);
ADD_VECTOR_END(result, PT_HTTP_4_CLI);
ADD_VECTOR_END(result, PT_INBOUND_JSONCLI);
}
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_CLI */
#ifdef HAS_PROTOCOL_MMS
else if (name == CONF_PROTOCOL_OUTBOUND_MMS) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_OUTBOUND_MMS);
}
#endif /* HAS_PROTOCOL_MMS */
#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
else if (name == CONF_PROTOCOL_INBOUND_RAW_HTTP_STREAM) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_RAW_HTTP_STREAM);
} else if (name == CONF_PROTOCOL_INBOUND_RAW_HTTPS_STREAM) {
ADD_VECTOR_END(result, PT_TCP);
ADD_VECTOR_END(result, PT_INBOUND_SSL);
ADD_VECTOR_END(result, PT_INBOUND_RAW_HTTP_STREAM);
}
#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
else {
FATAL("Invalid protocol chain: %s.", STR(name));
}
return result;
}
vector<string> DefaultProtocolFactory::HandledProtocolChains() {
vector<string> result;
#ifdef HAS_PROTOCOL_DNS
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_DNS);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_DNS);
#endif /* HAS_PROTOCOL_DNS */
#ifdef HAS_PROTOCOL_RTMP
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTMP);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_RTMP);
#ifdef HAS_PROTOCOL_HTTP
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTMPS);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTMPT);
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_RTMP */
#ifdef HAS_PROTOCOL_TS
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_TCP_TS);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_UDP_TS);
#endif /* HAS_PROTOCOL_TS */
#ifdef HAS_PROTOCOL_HTTP
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP);
#endif /* HAS_PROTOCOL_HTTP */
#ifdef HAS_PROTOCOL_LIVEFLV
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_LIVE_FLV);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_LIVE_FLV);
#endif /* HAS_PROTOCOL_LIVEFLV */
#ifdef HAS_PROTOCOL_VAR
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_XML_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_BIN_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_JSON_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_XML_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_BIN_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_JSON_VARIANT);
#ifdef HAS_PROTOCOL_HTTP
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_XML_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_BIN_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_JSON_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTPS_XML_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTPS_BIN_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTPS_JSON_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP_XML_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP_BIN_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP_JSON_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTPS_XML_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTPS_BIN_VARIANT);
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTPS_JSON_VARIANT);
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_VAR */
#ifdef HAS_PROTOCOL_RTP
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTSP);
ADD_VECTOR_END(result, CONF_PROTOCOL_RTSP_RTCP);
ADD_VECTOR_END(result, CONF_PROTOCOL_UDP_RTCP);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTSP_RTP);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_UDP_RTP);
ADD_VECTOR_END(result, CONF_PROTOCOL_RTP_NAT_TRAVERSAL);
#endif /* HAS_PROTOCOL_RTP */
#ifdef HAS_PROTOCOL_CLI
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_CLI_JSON);
#ifdef HAS_PROTOCOL_HTTP
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_CLI_JSON);
#endif /* HAS_PROTOCOL_HTTP */
#endif /* HAS_PROTOCOL_CLI */
#ifdef HAS_PROTOCOL_MMS
ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_MMS);
#endif /* HAS_PROTOCOL_MMS */
#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RAW_HTTP_STREAM);
ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RAW_HTTPS_STREAM);
#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
return result;
}
bool SDP::ParseTransportLinePart(string raw, Variant &result) {
result.Reset();
result["original"] = raw;
//1. split after ';'
vector<string> parts;
split(raw, ";", parts);
//2. Construct the result
for (uint32_t i = 0; i < parts.size(); i++) {
string part = parts[i];
trim(part);
if (part == "")
continue;
string::size_type pos = part.find('=');
if (pos == string::npos) {
result[lowerCase(part)] = (bool)true;
continue;
}
result[lowerCase(part.substr(0, pos))] = part.substr(pos + 1);
}
vector<string> keys;
ADD_VECTOR_END(keys, "client_port");
ADD_VECTOR_END(keys, "server_port");
ADD_VECTOR_END(keys, "interleaved");
for (uint32_t i = 0; i < keys.size(); i++) {
string key = keys[i];
if (!result.HasKey(key))
continue;
parts.clear();
raw = (string) result[key];
split(raw, "-", parts);
if ((parts.size() != 2) && (parts.size() != 1)) {
FATAL("Invalid transport line: %s", STR(raw));
return false;
}
string all = "";
uint16_t data = 0;
uint16_t rtcp = 0;
if (parts.size() == 2) {
data = (uint16_t) atoi(STR(parts[0]));
rtcp = (uint16_t) atoi(STR(parts[1]));
if (((data % 2) != 0) || ((data + 1) != rtcp)) {
FATAL("Invalid transport line: %s", STR(raw));
return false;
}
all = format("%"PRIu16"-%"PRIu16, data, rtcp);
} else {
data = (uint16_t) atoi(STR(parts[0]));
all = format("%"PRIu16, data);
rtcp = 0;
}
if (all != raw) {
FATAL("Invalid transport line: %s", STR(raw));
return false;
}
result.RemoveKey(key);
result[key]["data"] = (uint16_t) data;
result[key]["rtcp"] = (uint16_t) rtcp;
result[key]["all"] = all;
}
return true;
}
