1
0
mirror of https://github.com/rofafor/vdr-plugin-satip.git synced 2023-10-10 13:37:42 +02:00
vdr-plugin-satip/rtsp.c

324 lines
10 KiB
C
Raw Normal View History

2014-11-09 11:51:52 +01:00
/*
* rtsp.c: SAT>IP plugin for the Video Disk Recorder
*
* See the README file for copyright information and how to reach the author.
*
*/
#define __STDC_FORMAT_MACROS // Required for format specifiers
#include <inttypes.h>
#include "config.h"
2014-11-09 11:51:52 +01:00
#include "common.h"
2014-12-05 22:14:40 +01:00
#include "log.h"
2014-11-09 11:51:52 +01:00
#include "rtsp.h"
cSatipRtsp::cSatipRtsp(cSatipTunerIf &tunerP)
2014-11-16 16:02:30 +01:00
: tunerM(tunerP),
2014-12-16 21:35:49 +01:00
handleM(NULL),
2014-11-09 11:51:52 +01:00
headerListM(NULL)
{
2014-12-06 16:02:45 +01:00
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
2014-12-16 21:35:49 +01:00
Create();
2014-11-09 11:51:52 +01:00
}
cSatipRtsp::~cSatipRtsp()
{
2014-12-06 16:02:45 +01:00
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
2014-12-16 21:35:49 +01:00
Destroy();
2014-11-09 11:51:52 +01:00
}
size_t cSatipRtsp::HeaderCallback(void *ptrP, size_t sizeP, size_t nmembP, void *dataP)
{
cSatipRtsp *obj = reinterpret_cast<cSatipRtsp *>(dataP);
size_t len = sizeP * nmembP;
debug16("%s len=%zu", __PRETTY_FUNCTION__, len);
2014-11-09 11:51:52 +01:00
char *s, *p = (char *)ptrP;
char *r = strtok_r(p, "\r\n", &s);
2014-11-16 16:02:30 +01:00
while (obj && r) {
debug16("%s (%zu): %s", __PRETTY_FUNCTION__, len, r);
2014-11-09 11:51:52 +01:00
r = skipspace(r);
if (strstr(r, "com.ses.streamID")) {
int streamid = -1;
if (sscanf(r, "com.ses.streamID:%11d", &streamid) == 1)
2014-11-16 16:02:30 +01:00
obj->tunerM.SetStreamId(streamid);
2014-11-09 11:51:52 +01:00
}
else if (strstr(r, "Session:")) {
int timeout = -1;
char *session = NULL;
if (sscanf(r, "Session:%m[^;];timeout=%11d", &session, &timeout) == 2)
2014-11-16 16:02:30 +01:00
obj->tunerM.SetSessionTimeout(skipspace(session), timeout * 1000);
2014-11-09 11:51:52 +01:00
else if (sscanf(r, "Session:%m[^;]", &session) == 1)
2014-11-16 16:02:30 +01:00
obj->tunerM.SetSessionTimeout(skipspace(session), -1);
2014-11-09 11:51:52 +01:00
FREE_POINTER(session);
}
r = strtok_r(NULL, "\r\n", &s);
}
return len;
}
size_t cSatipRtsp::WriteCallback(void *ptrP, size_t sizeP, size_t nmembP, void *dataP)
{
cSatipRtsp *obj = reinterpret_cast<cSatipRtsp *>(dataP);
size_t len = sizeP * nmembP;
debug16("%s len=%zu", __PRETTY_FUNCTION__, len);
2014-11-09 11:51:52 +01:00
2014-11-16 16:02:30 +01:00
if (obj && (len > 0))
obj->tunerM.ProcessApplicationData((u_char*)ptrP, len);
2014-11-09 11:51:52 +01:00
return len;
}
int cSatipRtsp::DebugCallback(CURL *handleP, curl_infotype typeP, char *dataP, size_t sizeP, void *userPtrP)
{
cSatipRtsp *obj = reinterpret_cast<cSatipRtsp *>(userPtrP);
2014-11-16 16:02:30 +01:00
if (obj) {
2014-11-09 11:51:52 +01:00
switch (typeP) {
case CURLINFO_TEXT:
2014-12-06 16:02:45 +01:00
debug2("%s [device %d] RTSP INFO %.*s", __PRETTY_FUNCTION__, obj->tunerM.GetId(), (int)sizeP, dataP);
2014-11-09 11:51:52 +01:00
break;
case CURLINFO_HEADER_IN:
2014-12-06 16:02:45 +01:00
debug2("%s [device %d] RTSP HEAD <<< %.*s", __PRETTY_FUNCTION__, obj->tunerM.GetId(), (int)sizeP, dataP);
2014-11-09 11:51:52 +01:00
break;
case CURLINFO_HEADER_OUT:
2014-12-06 16:02:45 +01:00
debug2("%s [device %d] RTSP HEAD >>>\n%.*s", __PRETTY_FUNCTION__, obj->tunerM.GetId(), (int)sizeP, dataP);
2014-11-09 11:51:52 +01:00
break;
case CURLINFO_DATA_IN:
2014-12-06 16:02:45 +01:00
debug2("%s [device %d] RTSP DATA <<< %.*s", __PRETTY_FUNCTION__, obj->tunerM.GetId(), (int)sizeP, dataP);
2014-11-09 11:51:52 +01:00
break;
case CURLINFO_DATA_OUT:
2014-12-06 16:02:45 +01:00
debug2("%s [device %d] RTSP DATA >>>\n%.*s", __PRETTY_FUNCTION__, obj->tunerM.GetId(), (int)sizeP, dataP);
2014-11-09 11:51:52 +01:00
break;
default:
break;
}
}
return 0;
}
cString cSatipRtsp::RtspUnescapeString(const char *strP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, strP, tunerM.GetId());
2014-11-09 11:51:52 +01:00
if (handleM) {
char *p = curl_easy_unescape(handleM, strP, 0, NULL);
cString s = p;
curl_free(p);
return s;
}
return cString(strP);
}
2014-12-16 21:35:49 +01:00
void cSatipRtsp::Create(void)
{
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
if (!handleM)
handleM = curl_easy_init();
if (handleM) {
CURLcode res = CURLE_OK;
// Verbose output
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_VERBOSE, 1L);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_DEBUGFUNCTION, cSatipRtsp::DebugCallback);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_DEBUGDATA, this);
// No progress meter and no signaling
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_NOPROGRESS, 1L);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_NOSIGNAL, 1L);
// Set timeouts
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_TIMEOUT_MS, (long)eConnectTimeoutMs);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_CONNECTTIMEOUT_MS, (long)eConnectTimeoutMs);
// Set user-agent
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_USERAGENT, *cString::sprintf("vdr-%s/%s (device %d)", PLUGIN_NAME_I18N, VERSION, tunerM.GetId()));
}
}
void cSatipRtsp::Destroy(void)
{
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
if (handleM) {
// Cleanup curl stuff
if (headerListM) {
curl_slist_free_all(headerListM);
headerListM = NULL;
}
curl_easy_cleanup(handleM);
handleM = NULL;
}
}
void cSatipRtsp::Reset(void)
{
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
Destroy();
Create();
}
2014-11-09 11:51:52 +01:00
bool cSatipRtsp::Options(const char *uriP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, uriP, tunerM.GetId());
bool result = false;
2014-11-09 11:51:52 +01:00
if (handleM && !isempty(uriP)) {
long rc = 0;
cTimeMs processing(0);
2014-11-09 11:51:52 +01:00
CURLcode res = CURLE_OK;
if (!strstr(uriP, "?"))
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_URL, uriP);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_STREAM_URI, uriP);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_OPTIONS);
SATIP_CURL_EASY_PERFORM(handleM);
result = ValidateLatestResponse(&rc);
debug5("%s (%s) Response %ld in %" PRIu64 " ms [device %d]", __PRETTY_FUNCTION__, uriP, rc, processing.Elapsed(), tunerM.GetId());
2014-11-09 11:51:52 +01:00
}
return result;
2014-11-09 11:51:52 +01:00
}
bool cSatipRtsp::Setup(const char *uriP, int rtpPortP, int rtcpPortP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s, %d, %d) [device %d]", __PRETTY_FUNCTION__, uriP, rtpPortP, rtcpPortP, tunerM.GetId());
bool result = false;
2014-11-09 11:51:52 +01:00
if (handleM && !isempty(uriP)) {
long rc = 0;
cTimeMs processing(0);
2014-11-09 11:51:52 +01:00
CURLcode res = CURLE_OK;
cString transport = cString::sprintf("RTP/AVP;unicast;client_port=%d-%d", rtpPortP, rtcpPortP);
// Setup media stream
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_STREAM_URI, uriP);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_TRANSPORT, *transport);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_SETUP);
// Set header callback for catching the session and timeout
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_HEADERFUNCTION, cSatipRtsp::HeaderCallback);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEHEADER, this);
SATIP_CURL_EASY_PERFORM(handleM);
// Session id is now known - disable header parsing
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_HEADERFUNCTION, NULL);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEHEADER, NULL);
result = ValidateLatestResponse(&rc);
debug5("%s (%s, %d, %d) Response %ld in %" PRIu64 " ms [device %d]", __PRETTY_FUNCTION__, uriP, rtpPortP, rtcpPortP, rc, processing.Elapsed(), tunerM.GetId());
2014-11-09 11:51:52 +01:00
}
return result;
2014-11-09 11:51:52 +01:00
}
bool cSatipRtsp::SetSession(const char *sessionP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, sessionP, tunerM.GetId());
2014-11-09 11:51:52 +01:00
if (handleM) {
CURLcode res = CURLE_OK;
2014-12-06 16:02:45 +01:00
debug1("%s: session id quirk enabled [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
2014-11-09 11:51:52 +01:00
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_SESSION_ID, sessionP);
}
return true;
}
bool cSatipRtsp::Describe(const char *uriP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, uriP, tunerM.GetId());
bool result = false;
2014-11-09 11:51:52 +01:00
if (handleM && !isempty(uriP)) {
long rc = 0;
cTimeMs processing(0);
2014-11-09 11:51:52 +01:00
CURLcode res = CURLE_OK;
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_STREAM_URI, uriP);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_DESCRIBE);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEFUNCTION, cSatipRtsp::WriteCallback);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEDATA, this);
SATIP_CURL_EASY_PERFORM(handleM);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEFUNCTION, NULL);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEDATA, NULL);
result = ValidateLatestResponse(&rc);
debug5("%s (%s) Response %ld in %" PRIu64 " ms [device %d]", __PRETTY_FUNCTION__, uriP, rc, processing.Elapsed(), tunerM.GetId());
2014-11-09 11:51:52 +01:00
}
return result;
2014-11-09 11:51:52 +01:00
}
bool cSatipRtsp::Play(const char *uriP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, uriP, tunerM.GetId());
bool result = false;
2014-11-09 11:51:52 +01:00
if (handleM && !isempty(uriP)) {
long rc = 0;
cTimeMs processing(0);
2014-11-09 11:51:52 +01:00
CURLcode res = CURLE_OK;
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_STREAM_URI, uriP);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_PLAY);
SATIP_CURL_EASY_PERFORM(handleM);
result = ValidateLatestResponse(&rc);
debug5("%s (%s) Response %ld in %" PRIu64 " ms [device %d]", __PRETTY_FUNCTION__, uriP, rc, processing.Elapsed(), tunerM.GetId());
2014-11-09 11:51:52 +01:00
}
return result;
2014-11-09 11:51:52 +01:00
}
bool cSatipRtsp::Teardown(const char *uriP)
{
2014-12-07 16:27:53 +01:00
debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, uriP, tunerM.GetId());
bool result = false;
2014-11-09 11:51:52 +01:00
if (handleM && !isempty(uriP)) {
long rc = 0;
cTimeMs processing(0);
2014-11-09 11:51:52 +01:00
CURLcode res = CURLE_OK;
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_STREAM_URI, uriP);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_TEARDOWN);
SATIP_CURL_EASY_PERFORM(handleM);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_CLIENT_CSEQ, 1L);
SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_SESSION_ID, NULL);
result = ValidateLatestResponse(&rc);
debug5("%s (%s) Response %ld in %" PRIu64 " ms [device %d]", __PRETTY_FUNCTION__, uriP, rc, processing.Elapsed(), tunerM.GetId());
2014-11-09 11:51:52 +01:00
}
return result;
2014-11-09 11:51:52 +01:00
}
bool cSatipRtsp::ValidateLatestResponse(long *rcP)
2014-11-09 11:51:52 +01:00
{
bool result = false;
2014-11-09 11:51:52 +01:00
if (handleM) {
long rc = 0;
CURLcode res = CURLE_OK;
SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_RESPONSE_CODE, &rc);
if (rc == 200)
result = true;
2014-11-15 20:58:38 +01:00
else if (rc != 0) {
char *url = NULL;
SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_EFFECTIVE_URL, &url);
2014-11-21 22:56:03 +01:00
error("Detected invalid status code %ld: %s [device %d]", rc, url, tunerM.GetId());
2014-11-15 20:58:38 +01:00
}
if (rcP)
*rcP = rc;
2014-11-09 11:51:52 +01:00
}
2014-12-06 16:02:45 +01:00
debug1("%s result=%s [device %d]", __PRETTY_FUNCTION__, result ? "ok" : "failed", tunerM.GetId());
2014-11-09 11:51:52 +01:00
return result;
2014-11-09 11:51:52 +01:00
}