mirror of https://github.com/ossrs/srs.git
Merge remote-tracking branch 'upstream/feature/rtc' into rtc
xiaozhihong
5 years ago
commit
4f671b1de2
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,436 @@
|
||||
/**
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2013-2020 Lixin
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef SRS_APP_GB28181_HPP
|
||||
#define SRS_APP_GB28181_HPP
|
||||
|
||||
#include <srs_core.hpp>
|
||||
|
||||
#include <arpa/inet.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
|
||||
#include <srs_app_st.hpp>
|
||||
#include <srs_app_thread.hpp>
|
||||
#include <srs_app_listener.hpp>
|
||||
#include <srs_rtsp_stack.hpp>
|
||||
#include <srs_kernel_stream.hpp>
|
||||
#include <srs_app_log.hpp>
|
||||
#include <srs_kernel_file.hpp>
|
||||
#include <srs_protocol_json.hpp>
|
||||
#include <srs_app_gb28181_sip.hpp>
|
||||
|
||||
#define RTP_PORT_MODE_FIXED "fixed"
|
||||
#define RTP_PORT_MODE_RANDOM "random"
|
||||
|
||||
class SrsConfDirective;
|
||||
class SrsRtpPacket;
|
||||
class SrsRtmpClient;
|
||||
class SrsRawH264Stream;
|
||||
class SrsRawAacStream;
|
||||
struct SrsRawAacStreamCodec;
|
||||
class SrsSharedPtrMessage;
|
||||
class SrsAudioFrame;
|
||||
class SrsSimpleStream;
|
||||
class SrsPithyPrint;
|
||||
class SrsSimpleRtmpClient;
|
||||
class SrsSipStack;
|
||||
class SrsGb28181Manger;
|
||||
class SrsRtspJitter;
|
||||
class SrsSipRequest;
|
||||
class SrsGb28181RtmpMuxer;
|
||||
class SrsGb28181Config;
|
||||
class SrsGb28181PsRtpProcessor;
|
||||
class SrsGb28181SipService;
|
||||
class SrsGb28181StreamChannel;
|
||||
|
||||
//ps rtp header packet parse
|
||||
class SrsPsRtpPacket: public SrsRtpPacket
|
||||
{
|
||||
public:
|
||||
SrsPsRtpPacket();
|
||||
virtual ~SrsPsRtpPacket();
|
||||
public:
|
||||
virtual srs_error_t decode(SrsBuffer* stream);
|
||||
};
|
||||
|
||||
//randomly assigned ports receive gb28281 device streams
|
||||
class SrsPsRtpListener: public ISrsUdpHandler
|
||||
{
|
||||
private:
|
||||
SrsUdpListener* listener;
|
||||
SrsGb28181PsRtpProcessor* rtp_processor;
|
||||
int _port;
|
||||
public:
|
||||
SrsPsRtpListener(SrsGb28181Config* c, int p, std::string s);
|
||||
virtual ~SrsPsRtpListener();
|
||||
public:
|
||||
virtual int port();
|
||||
virtual srs_error_t listen();
|
||||
// Interface ISrsUdpHandler
|
||||
public:
|
||||
virtual srs_error_t on_udp_packet(const sockaddr* from, const int fromlen, char* buf, int nb_buf);
|
||||
};
|
||||
|
||||
//multiplexing service, single port receiving all gb28281 device streams
|
||||
class SrsGb28181RtpMuxService : public ISrsUdpHandler
|
||||
{
|
||||
private:
|
||||
SrsGb28181Config *config;
|
||||
SrsGb28181PsRtpProcessor *rtp_processor;
|
||||
public:
|
||||
SrsGb28181RtpMuxService(SrsConfDirective* c);
|
||||
virtual ~SrsGb28181RtpMuxService();
|
||||
|
||||
// Interface ISrsUdpHandler
|
||||
public:
|
||||
virtual srs_error_t on_udp_packet(const sockaddr* from, const int fromlen, char* buf, int nb_buf);
|
||||
};
|
||||
|
||||
|
||||
//process gb28281 RTP package, generate a completed PS stream data,
|
||||
//call the PS stream parser, parse the original video and audio
|
||||
class SrsGb28181PsRtpProcessor: public ISrsUdpHandler
|
||||
{
|
||||
private:
|
||||
SrsPithyPrint* pprint;
|
||||
SrsGb28181Config* config;
|
||||
std::map<std::string, SrsPsRtpPacket*> cache_ps_rtp_packet;
|
||||
std::map<std::string, SrsPsRtpPacket*> pre_packet;
|
||||
std::string channel_id;
|
||||
bool auto_create_channel;
|
||||
public:
|
||||
SrsGb28181PsRtpProcessor(SrsGb28181Config* c, std::string sid);
|
||||
virtual ~SrsGb28181PsRtpProcessor();
|
||||
private:
|
||||
bool can_send_ps_av_packet();
|
||||
void dispose();
|
||||
// Interface ISrsUdpHandler
|
||||
public:
|
||||
virtual srs_error_t on_udp_packet(const sockaddr* from, const int fromlen, char* buf, int nb_buf);
|
||||
};
|
||||
|
||||
//ps stream processing parsing interface
|
||||
class ISrsPsStreamHander
|
||||
{
|
||||
public:
|
||||
ISrsPsStreamHander();
|
||||
virtual ~ISrsPsStreamHander();
|
||||
public:
|
||||
virtual srs_error_t on_rtp_video(SrsSimpleStream* stream, int64_t dts)=0;
|
||||
virtual srs_error_t on_rtp_audio(SrsSimpleStream* stream, int64_t dts)=0;
|
||||
};
|
||||
|
||||
//analysis of PS stream and
|
||||
//extraction of H264 raw data and audio data
|
||||
//then process the flow through PS stream hander,
|
||||
//such as RTMP multiplexer, and composited into RTMP av stream
|
||||
class SrsPsStreamDemixer
|
||||
{
|
||||
public:
|
||||
// gb28181 program stream struct define
|
||||
struct SrsPsPacketStartCode
|
||||
{
|
||||
uint8_t start_code[3];
|
||||
uint8_t stream_id[1];
|
||||
};
|
||||
|
||||
struct SrsPsPacketHeader
|
||||
{
|
||||
SrsPsPacketStartCode start;// 4
|
||||
uint8_t info[9];
|
||||
uint8_t stuffing_length;
|
||||
};
|
||||
|
||||
struct SrsPsPacketBBHeader
|
||||
{
|
||||
SrsPsPacketStartCode start;
|
||||
uint16_t length;
|
||||
};
|
||||
|
||||
struct SrsPsePacket
|
||||
{
|
||||
SrsPsPacketStartCode start;
|
||||
uint16_t length;
|
||||
uint8_t info[2];
|
||||
uint8_t stuffing_length;
|
||||
};
|
||||
|
||||
struct SrsPsMapPacket
|
||||
{
|
||||
SrsPsPacketStartCode start;
|
||||
uint16_t length;
|
||||
};
|
||||
|
||||
private:
|
||||
SrsFileWriter ps_fw;
|
||||
SrsFileWriter video_fw;
|
||||
SrsFileWriter audio_fw;
|
||||
|
||||
bool first_keyframe_flag;
|
||||
bool wait_first_keyframe;
|
||||
bool audio_enable;
|
||||
std::string channel_id;
|
||||
|
||||
ISrsPsStreamHander *hander;
|
||||
public:
|
||||
SrsPsStreamDemixer(ISrsPsStreamHander *h, std::string sid, bool a, bool k);
|
||||
virtual ~SrsPsStreamDemixer();
|
||||
private:
|
||||
bool can_send_ps_av_packet();
|
||||
public:
|
||||
int64_t parse_ps_timestamp(const uint8_t* p);
|
||||
virtual srs_error_t on_ps_stream(char* ps_data, int ps_size, uint32_t timestamp, uint32_t ssrc);
|
||||
};
|
||||
|
||||
|
||||
//RTMP multiplexer, which processes the raw H264 / AAC,
|
||||
//then publish it to RTMP server
|
||||
class SrsGb28181RtmpMuxer : public ISrsCoroutineHandler,
|
||||
public ISrsConnection, public ISrsPsStreamHander
|
||||
{
|
||||
private:
|
||||
SrsPithyPrint* pprint;
|
||||
SrsGb28181StreamChannel *channel;
|
||||
int stream_idle_timeout;
|
||||
srs_utime_t recv_stream_time;
|
||||
private:
|
||||
std::string channel_id;
|
||||
std::string _rtmp_url;
|
||||
std::string video_ssrc;
|
||||
std::string audio_ssrc;
|
||||
|
||||
SrsGb28181Manger* gb28181_manger;
|
||||
SrsCoroutine* trd;
|
||||
SrsPsStreamDemixer* ps_demixer;
|
||||
srs_cond_t wait_ps_queue;
|
||||
|
||||
SrsSimpleRtmpClient* sdk;
|
||||
SrsRtspJitter* vjitter;
|
||||
SrsRtspJitter* ajitter;
|
||||
|
||||
SrsRawH264Stream* avc;
|
||||
std::string h264_sps;
|
||||
std::string h264_pps;
|
||||
bool h264_sps_changed;
|
||||
bool h264_pps_changed;
|
||||
bool h264_sps_pps_sent;
|
||||
|
||||
SrsRawAacStream* aac;
|
||||
std::string aac_specific_config;
|
||||
|
||||
public:
|
||||
std::queue<SrsPsRtpPacket*> ps_queue;
|
||||
|
||||
public:
|
||||
SrsGb28181RtmpMuxer(SrsGb28181Manger* m, std::string id, bool a, bool k);
|
||||
virtual ~SrsGb28181RtmpMuxer();
|
||||
|
||||
public:
|
||||
virtual srs_error_t serve();
|
||||
virtual void stop();
|
||||
|
||||
virtual std::string get_channel_id();
|
||||
virtual void ps_packet_enqueue(SrsPsRtpPacket *pkt);
|
||||
virtual void copy_channel(SrsGb28181StreamChannel *s);
|
||||
virtual void set_channel_peer_ip(std::string ip);
|
||||
virtual void set_channel_peer_port(int port);
|
||||
virtual int channel_peer_port();
|
||||
virtual std::string channel_peer_ip();
|
||||
virtual void set_rtmp_url(std::string url);
|
||||
virtual std::string rtmp_url();
|
||||
virtual SrsGb28181StreamChannel get_channel();
|
||||
|
||||
private:
|
||||
virtual srs_error_t do_cycle();
|
||||
virtual void destroy();
|
||||
|
||||
// Interface ISrsOneCycleThreadHandler
|
||||
public:
|
||||
virtual srs_error_t cycle();
|
||||
virtual std::string remote_ip();
|
||||
public:
|
||||
virtual srs_error_t on_rtp_video(SrsSimpleStream* stream, int64_t dts);
|
||||
virtual srs_error_t on_rtp_audio(SrsSimpleStream* stream, int64_t dts);
|
||||
private:
|
||||
virtual srs_error_t write_h264_sps_pps(uint32_t dts, uint32_t pts);
|
||||
virtual srs_error_t write_h264_ipb_frame(char* frame, int frame_size, uint32_t dts, uint32_t pts);
|
||||
virtual srs_error_t write_audio_raw_frame(char* frame, int frame_size, SrsRawAacStreamCodec* codec, uint32_t dts);
|
||||
virtual srs_error_t rtmp_write_packet(char type, uint32_t timestamp, char* data, int size);
|
||||
private:
|
||||
// Connect to RTMP server.
|
||||
virtual srs_error_t connect();
|
||||
// Close the connection to RTMP server.
|
||||
virtual void close();
|
||||
public:
|
||||
virtual void rtmp_close();
|
||||
};
|
||||
|
||||
//system parameter configuration of gb28281 module,
|
||||
//read file from configuration file to generate
|
||||
class SrsGb28181Config
|
||||
{
|
||||
public:
|
||||
std::string host;
|
||||
srs_utime_t rtp_idle_timeout;
|
||||
bool audio_enable;
|
||||
bool wait_keyframe;
|
||||
std::string output;
|
||||
int rtp_port_min;
|
||||
int rtp_port_max;
|
||||
int rtp_mux_port;
|
||||
|
||||
//sip config
|
||||
int sip_port;
|
||||
std::string sip_serial;
|
||||
std::string sip_realm;
|
||||
bool sip_enable;
|
||||
int sip_ack_timeout;
|
||||
int sip_keepalive_timeout;
|
||||
bool print_sip_message;
|
||||
bool sip_auto_play;
|
||||
bool sip_invite_port_fixed;
|
||||
|
||||
public:
|
||||
SrsGb28181Config(SrsConfDirective* c);
|
||||
virtual ~SrsGb28181Config();
|
||||
};
|
||||
|
||||
class SrsGb28181StreamChannel
|
||||
{
|
||||
private:
|
||||
std::string channel_id;
|
||||
std::string port_mode;
|
||||
std::string app;
|
||||
std::string stream;
|
||||
|
||||
std::string ip;
|
||||
int rtp_port;
|
||||
int rtmp_port;
|
||||
uint32_t ssrc;
|
||||
|
||||
//send rtp stream client local port
|
||||
int rtp_peer_port;
|
||||
//send rtp stream client local ip
|
||||
std::string rtp_peer_ip;
|
||||
|
||||
public:
|
||||
SrsGb28181StreamChannel();
|
||||
virtual ~SrsGb28181StreamChannel();
|
||||
|
||||
std::string get_channel_id() const { return channel_id; }
|
||||
std::string get_port_mode() const { return port_mode; }
|
||||
std::string get_app() const { return app; }
|
||||
std::string get_stream() const { return stream; }
|
||||
std::string get_ip() const { return ip; }
|
||||
int get_rtp_port() const { return rtp_port; }
|
||||
int get_rtmp_port() const { return rtmp_port; }
|
||||
uint32_t get_ssrc() const { return ssrc; }
|
||||
uint32_t get_rtp_peer_port() const { return rtp_peer_port; }
|
||||
std::string get_rtp_peer_ip() const { return rtp_peer_ip; }
|
||||
|
||||
void set_channel_id(const std::string &i) { channel_id = i; }
|
||||
void set_port_mode(const std::string &p) { port_mode = p; }
|
||||
void set_app(const std::string &a) { app = a; }
|
||||
void set_stream(const std::string &s) { stream = s; }
|
||||
void set_ip(const std::string &i) { ip = i; }
|
||||
void set_rtp_port( const int &p) { rtp_port = p; }
|
||||
void set_rtmp_port( const int &p) { rtmp_port = p; }
|
||||
void set_ssrc( const int &s) { ssrc = s;}
|
||||
void set_rtp_peer_ip( const std::string &p) { rtp_peer_ip = p; }
|
||||
void set_rtp_peer_port( const int &s) { rtp_peer_port = s;}
|
||||
|
||||
void copy(const SrsGb28181StreamChannel *s);
|
||||
void dumps(SrsJsonObject* obj);
|
||||
|
||||
};
|
||||
|
||||
// Global singleton instance.
|
||||
extern SrsGb28181Manger* _srs_gb28181;
|
||||
|
||||
//gb28181 module management, management of all RTMP multiplexers,
|
||||
//random assignment of RTP listeners, and external control interfaces
|
||||
class SrsGb28181Manger
|
||||
{
|
||||
private:
|
||||
SrsGb28181Config *config;
|
||||
// The key: port, value: whether used.
|
||||
std::map<int, bool> used_ports;
|
||||
std::map<uint32_t, SrsPsRtpListener*> rtp_pool;
|
||||
std::map<uint32_t, SrsGb28181RtmpMuxer*> rtmpmuxers_ssrc;
|
||||
std::map<std::string, SrsGb28181RtmpMuxer*> rtmpmuxers;
|
||||
SrsCoroutineManager* manager;
|
||||
|
||||
SrsGb28181SipService* sip_service;
|
||||
|
||||
public:
|
||||
SrsGb28181Manger(SrsConfDirective* c);
|
||||
virtual ~SrsGb28181Manger();
|
||||
|
||||
public:
|
||||
srs_error_t fetch_or_create_rtmpmuxer(std::string id, SrsGb28181RtmpMuxer** gb28181);
|
||||
SrsGb28181RtmpMuxer* fetch_rtmpmuxer(std::string id);
|
||||
SrsGb28181RtmpMuxer* fetch_rtmpmuxer_by_ssrc(uint32_t ssrc);
|
||||
void rtmpmuxer_map_by_ssrc(SrsGb28181RtmpMuxer*muxer, uint32_t ssrc);
|
||||
void rtmpmuxer_unmap_by_ssrc(uint32_t ssrc);
|
||||
uint32_t generate_ssrc(std::string id);
|
||||
uint32_t hash_code(std::string str);
|
||||
|
||||
void set_sip_service(SrsGb28181SipService *s) { sip_service = s; }
|
||||
SrsGb28181SipService* get_sip_service() { return sip_service; }
|
||||
|
||||
public:
|
||||
//stream channel api
|
||||
uint32_t create_stream_channel(SrsGb28181StreamChannel *channel);
|
||||
uint32_t delete_stream_channel(std::string id);
|
||||
uint32_t queue_stream_channel(std::string id, SrsJsonArray* arr);
|
||||
//sip api
|
||||
uint32_t notify_sip_invite(std::string id, std::string ip, int port, uint32_t ssrc);
|
||||
uint32_t notify_sip_bye(std::string id);
|
||||
uint32_t notify_sip_raw_data(std::string id, std::string data);
|
||||
uint32_t notify_sip_unregister(std::string id);
|
||||
|
||||
private:
|
||||
void destroy();
|
||||
|
||||
public:
|
||||
// Alloc a rtp port from local ports pool.
|
||||
// @param pport output the rtp port.
|
||||
void alloc_port(int* pport);
|
||||
// Free the alloced rtp port.
|
||||
void free_port(int lpmin, int lpmax);
|
||||
srs_error_t initialize();
|
||||
|
||||
SrsGb28181Config get_gb28181_config();
|
||||
srs_error_t start_ps_rtp_listen(std::string id, int port);
|
||||
void stop_rtp_listen(std::string id);
|
||||
|
||||
public:
|
||||
void remove(SrsGb28181RtmpMuxer* conn);
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -0,0 +1,471 @@
|
||||
/**
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2013-2020 Lixin
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <srs_app_gb28181_sip.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <netdb.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
#include <srs_app_config.hpp>
|
||||
#include <srs_kernel_error.hpp>
|
||||
|
||||
#include <srs_kernel_log.hpp>
|
||||
#include <srs_app_utility.hpp>
|
||||
#include <srs_core_autofree.hpp>
|
||||
#include <srs_kernel_buffer.hpp>
|
||||
#include <srs_kernel_stream.hpp>
|
||||
#include <srs_protocol_utility.hpp>
|
||||
#include <srs_kernel_utility.hpp>
|
||||
#include <srs_kernel_codec.hpp>
|
||||
#include <srs_app_pithy_print.hpp>
|
||||
#include <srs_sip_stack.hpp>
|
||||
#include <srs_app_gb28181.hpp>
|
||||
|
||||
|
||||
SrsGb28181SipSession::SrsGb28181SipSession(SrsGb28181SipService *c, SrsSipRequest* r)
|
||||
{
|
||||
caster = c;
|
||||
req = new SrsSipRequest();
|
||||
req->copy(r);
|
||||
|
||||
_register_status = SrsGb28181SipSessionUnkonw;
|
||||
_alive_status = SrsGb28181SipSessionUnkonw;
|
||||
_invite_status = SrsGb28181SipSessionUnkonw;
|
||||
_register_time = 0;
|
||||
_alive_time = 0;
|
||||
_invite_time = 0;
|
||||
_recv_rtp_time = 0;
|
||||
_reg_expires = 0;
|
||||
|
||||
_peer_ip = "";
|
||||
_peer_port = 0;
|
||||
|
||||
_from = NULL;
|
||||
_fromlen = 0;
|
||||
}
|
||||
|
||||
SrsGb28181SipSession::~SrsGb28181SipSession()
|
||||
{
|
||||
srs_freep(req);
|
||||
}
|
||||
|
||||
//gb28181 sip Service
|
||||
SrsGb28181SipService::SrsGb28181SipService(SrsConfDirective* c)
|
||||
{
|
||||
// TODO: FIXME: support reload.
|
||||
config = new SrsGb28181Config(c);
|
||||
sip = new SrsSipStack();
|
||||
|
||||
if (_srs_gb28181){
|
||||
_srs_gb28181->set_sip_service(this);
|
||||
}
|
||||
}
|
||||
|
||||
SrsGb28181SipService::~SrsGb28181SipService()
|
||||
{
|
||||
destroy();
|
||||
srs_freep(sip);
|
||||
srs_freep(config);
|
||||
}
|
||||
|
||||
void SrsGb28181SipService::set_stfd(srs_netfd_t fd)
|
||||
{
|
||||
lfd = fd;
|
||||
}
|
||||
|
||||
srs_error_t SrsGb28181SipService::on_udp_packet(const sockaddr* from, const int fromlen, char* buf, int nb_buf)
|
||||
{
|
||||
char address_string[64];
|
||||
char port_string[16];
|
||||
if(getnameinfo(from, fromlen,
|
||||
(char*)&address_string, sizeof(address_string),
|
||||
(char*)&port_string, sizeof(port_string),
|
||||
NI_NUMERICHOST|NI_NUMERICSERV)) {
|
||||
return srs_error_new(ERROR_SYSTEM_IP_INVALID, "bad address");
|
||||
}
|
||||
std::string peer_ip = std::string(address_string);
|
||||
int peer_port = atoi(port_string);
|
||||
|
||||
srs_error_t err = on_udp_sip(peer_ip, peer_port, buf, nb_buf, (sockaddr*)from, fromlen);
|
||||
if (err != srs_success) {
|
||||
return srs_error_wrap(err, "process udp");
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsGb28181SipService::on_udp_sip(string peer_ip, int peer_port,
|
||||
char* buf, int nb_buf, sockaddr* from, const int fromlen)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (config->print_sip_message)
|
||||
{
|
||||
srs_trace("gb28181: request peer_ip=%s, peer_port=%d nbbuf=%d", peer_ip.c_str(), peer_port, nb_buf);
|
||||
srs_trace("gb28181: request recv message=%s", buf);
|
||||
}
|
||||
|
||||
if (nb_buf < 10) {
|
||||
return err;
|
||||
}
|
||||
|
||||
SrsSipRequest* req = NULL;
|
||||
|
||||
if ((err = sip->parse_request(&req, buf, nb_buf)) != srs_success) {
|
||||
return srs_error_wrap(err, "parse sip request");
|
||||
}
|
||||
|
||||
if (config->print_sip_message)
|
||||
{
|
||||
srs_trace("gb28181: %s method=%s, uri=%s, version=%s ",
|
||||
req->get_cmdtype_str().c_str(), req->method.c_str(), req->uri.c_str(), req->version.c_str());
|
||||
srs_trace("gb28281: request client id=%s", req->sip_auth_id.c_str());
|
||||
}
|
||||
|
||||
req->peer_ip = peer_ip;
|
||||
req->peer_port = peer_port;
|
||||
SrsAutoFree(SrsSipRequest, req);
|
||||
|
||||
std::string session_id = req->sip_auth_id;
|
||||
|
||||
if (req->is_register()) {
|
||||
std::vector<std::string> serial = srs_string_split(srs_string_replace(req->uri,"sip:", ""), "@");
|
||||
if (serial.at(0) != config->sip_serial){
|
||||
srs_trace("gb28181: client:%s request serial and server serial inconformity(%s:%s)",
|
||||
req->sip_auth_id.c_str(), serial.at(0).c_str(), config->sip_serial.c_str());
|
||||
return err;
|
||||
}
|
||||
|
||||
srs_trace("gb28181: request peer_ip=%s, peer_port=%d", peer_ip.c_str(), peer_port, nb_buf);
|
||||
srs_trace("gb28181: request %s method=%s, uri=%s, version=%s ",
|
||||
req->get_cmdtype_str().c_str(), req->method.c_str(), req->uri.c_str(), req->version.c_str());
|
||||
srs_trace("gb28281: request client id=%s", req->sip_auth_id.c_str());
|
||||
|
||||
SrsGb28181SipSession* sip_session = create_sip_session(req);
|
||||
if (!sip_session) {
|
||||
srs_trace("gb28181: create sip session faild:%s", req->uri.c_str());
|
||||
return err;
|
||||
}
|
||||
|
||||
send_status(req, from, fromlen);
|
||||
sip_session->set_register_status(SrsGb28181SipSessionRegisterOk);
|
||||
sip_session->set_register_time(srs_get_system_time());
|
||||
sip_session->set_reg_expires(req->expires);
|
||||
sip_session->set_sockaddr(from);
|
||||
sip_session->set_sockaddr_len(fromlen);
|
||||
sip_session->set_peer_ip(peer_ip);
|
||||
sip_session->set_peer_port(peer_port);
|
||||
}else if (req->is_message()) {
|
||||
SrsGb28181SipSession* sip_session = fetch(session_id);
|
||||
if (!sip_session || sip_session->register_status() == SrsGb28181SipSessionUnkonw){
|
||||
srs_trace("gb28181: %s client not registered", req->sip_auth_id.c_str());
|
||||
return err;
|
||||
}
|
||||
|
||||
//reponse status
|
||||
send_status(req, from, fromlen);
|
||||
sip_session->set_register_status(SrsGb28181SipSessionRegisterOk);
|
||||
sip_session->set_register_time(srs_get_system_time());
|
||||
sip_session->set_alive_status(SrsGb28181SipSessionAliveOk);
|
||||
sip_session->set_alive_time(srs_get_system_time());
|
||||
sip_session->set_sockaddr(from);
|
||||
sip_session->set_sockaddr_len(fromlen);
|
||||
sip_session->set_peer_port(peer_port);
|
||||
sip_session->set_peer_ip(peer_ip);
|
||||
|
||||
//send invite, play client av
|
||||
//start ps rtp listen, recv ps stream
|
||||
if (config->sip_auto_play && sip_session->register_status() == SrsGb28181SipSessionRegisterOk &&
|
||||
sip_session->alive_status() == SrsGb28181SipSessionAliveOk &&
|
||||
sip_session->invite_status() == SrsGb28181SipSessionUnkonw)
|
||||
{
|
||||
//stop the possible stream and push a new stream
|
||||
//send_bye(req, from, fromlen);
|
||||
|
||||
SrsGb28181StreamChannel ch;
|
||||
ch.set_channel_id(session_id);
|
||||
ch.set_ip(config->host);
|
||||
ch.set_stream(session_id);
|
||||
ch.set_app("live");
|
||||
if (config->sip_invite_port_fixed){
|
||||
ch.set_port_mode(RTP_PORT_MODE_FIXED);
|
||||
}else {
|
||||
ch.set_port_mode(RTP_PORT_MODE_RANDOM);
|
||||
}
|
||||
|
||||
int code = _srs_gb28181->create_stream_channel(&ch);
|
||||
if (code == ERROR_SUCCESS){
|
||||
code = send_invite(req, ch.get_ip(),
|
||||
ch.get_rtp_port(), ch.get_ssrc());
|
||||
}
|
||||
|
||||
if (code == ERROR_SUCCESS){
|
||||
sip_session->set_invite_status(SrsGb28181SipSessionTrying);
|
||||
sip_session->set_invite_time(srs_get_system_time());
|
||||
}
|
||||
|
||||
}
|
||||
}else if (req->is_invite()) {
|
||||
SrsGb28181SipSession* sip_session = fetch(session_id);
|
||||
|
||||
srs_trace("gb28181: request peer_ip=%s, peer_port=%d", peer_ip.c_str(), peer_port, nb_buf);
|
||||
srs_trace("gb28181: request %s method=%s, uri=%s, version=%s ",
|
||||
req->get_cmdtype_str().c_str(), req->method.c_str(), req->uri.c_str(), req->version.c_str());
|
||||
srs_trace("gb28281: request client id=%s", req->sip_auth_id.c_str());
|
||||
|
||||
if (!sip_session){
|
||||
send_bye(req);
|
||||
srs_trace("gb28181: %s client not registered", req->sip_auth_id.c_str());
|
||||
return err;
|
||||
}
|
||||
|
||||
if (sip_session->register_status() == SrsGb28181SipSessionUnkonw ||
|
||||
sip_session->alive_status() == SrsGb28181SipSessionUnkonw) {
|
||||
srs_trace("gb28181: %s client not registered or not alive", req->sip_auth_id.c_str());
|
||||
return err;
|
||||
}
|
||||
|
||||
if (req->cmdtype == SrsSipCmdRespone && req->status == "200") {
|
||||
srs_trace("gb28181: INVITE response %s client status=%s", req->sip_auth_id.c_str(), req->status.c_str());
|
||||
send_ack(req, from, fromlen);
|
||||
sip_session->set_invite_status(SrsGb28181SipSessionInviteOk);
|
||||
sip_session->set_invite_time(srs_get_system_time());
|
||||
//Record tag and branch, which are required by the 'bye' command,
|
||||
sip_session->set_request(req);
|
||||
}else{
|
||||
sip_session->set_invite_status(SrsGb28181SipSessionUnkonw);
|
||||
sip_session->set_invite_time(0);
|
||||
}
|
||||
}else if (req->is_bye()) {
|
||||
srs_trace("gb28181: request peer_ip=%s, peer_port=%d", peer_ip.c_str(), peer_port, nb_buf);
|
||||
srs_trace("gb28181: request %s method=%s, uri=%s, version=%s ",
|
||||
req->get_cmdtype_str().c_str(), req->method.c_str(), req->uri.c_str(), req->version.c_str());
|
||||
srs_trace("gb28281: request client id=%s", req->sip_auth_id.c_str());
|
||||
|
||||
SrsGb28181SipSession* sip_session = fetch(session_id);
|
||||
send_status(req, from, fromlen);
|
||||
|
||||
if (!sip_session){
|
||||
srs_trace("gb28181: %s client not registered", req->sip_auth_id.c_str());
|
||||
return err;
|
||||
}
|
||||
|
||||
sip_session->set_invite_status(SrsGb28181SipSessionBye);
|
||||
sip_session->set_invite_time(0);
|
||||
|
||||
}else{
|
||||
srs_trace("gb28181: ingor request method=%s", req->method.c_str());
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int SrsGb28181SipService::send_message(sockaddr* from, int fromlen, std::stringstream& ss)
|
||||
{
|
||||
std::string str = ss.str();
|
||||
if (config->print_sip_message)
|
||||
srs_trace("gb28181: send_message:%s", str.c_str());
|
||||
srs_assert(!str.empty());
|
||||
|
||||
int ret = srs_sendto(lfd, (char*)str.c_str(), (int)str.length(), from, fromlen, SRS_UTIME_NO_TIMEOUT);
|
||||
if (ret <= 0){
|
||||
srs_trace("gb28181: send_message falid (%d)", ret);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int SrsGb28181SipService::send_ack(SrsSipRequest *req, sockaddr *f, int l)
|
||||
{
|
||||
srs_assert(req);
|
||||
|
||||
std::stringstream ss;
|
||||
|
||||
req->host = config->host;
|
||||
req->host_port = config->sip_port;
|
||||
req->realm = config->sip_realm;
|
||||
req->serial = config->sip_serial;
|
||||
|
||||
sip->resp_ack(ss, req);
|
||||
return send_message(f, l, ss);
|
||||
}
|
||||
|
||||
int SrsGb28181SipService::send_status(SrsSipRequest *req, sockaddr *f, int l)
|
||||
{
|
||||
srs_assert(req);
|
||||
|
||||
std::stringstream ss;
|
||||
|
||||
req->host = config->host;
|
||||
req->host_port = config->sip_port;
|
||||
req->realm = config->sip_realm;
|
||||
req->serial = config->sip_serial;
|
||||
|
||||
sip->resp_status(ss, req);
|
||||
return send_message(f, l, ss);
|
||||
}
|
||||
|
||||
|
||||
int SrsGb28181SipService::send_invite(SrsSipRequest *req, string ip, int port, uint32_t ssrc)
|
||||
{
|
||||
srs_assert(req);
|
||||
|
||||
SrsGb28181SipSession *sip_session = fetch(req->sip_auth_id);
|
||||
|
||||
if (!sip_session){
|
||||
return ERROR_GB28181_SESSION_IS_NOTEXIST;
|
||||
}
|
||||
|
||||
//if you are inviting or succeed in invite,
|
||||
//you cannot invite again. you need to 'bye' and try again
|
||||
if (sip_session->invite_status() == SrsGb28181SipSessionTrying ||
|
||||
sip_session->invite_status() == SrsGb28181SipSessionInviteOk){
|
||||
return ERROR_GB28281_SIP_IS_INVITING;
|
||||
}
|
||||
|
||||
req->host = config->host;
|
||||
req->host_port = config->sip_port;
|
||||
req->realm = config->sip_realm;
|
||||
req->serial = config->sip_serial;
|
||||
|
||||
std::stringstream ss;
|
||||
sip->req_invite(ss, req, ip, port, ssrc);
|
||||
|
||||
if (send_message(sip_session->sockaddr_from(), sip_session->sockaddr_fromlen(), ss) <= 0)
|
||||
{
|
||||
return ERROR_GB28281_SIP_INVITE_FAILED;
|
||||
}
|
||||
|
||||
sip_session->set_invite_status(SrsGb28181SipSessionTrying);
|
||||
|
||||
return ERROR_SUCCESS;
|
||||
|
||||
}
|
||||
|
||||
int SrsGb28181SipService::send_bye(SrsSipRequest *req)
|
||||
{
|
||||
srs_assert(req);
|
||||
|
||||
SrsGb28181SipSession *sip_session = fetch(req->sip_auth_id);
|
||||
|
||||
if (!sip_session){
|
||||
return ERROR_GB28181_SESSION_IS_NOTEXIST;
|
||||
}
|
||||
|
||||
//prame branch, from_tag, to_tag, call_id,
|
||||
//The parameter of 'bye' must be the same as 'invite'
|
||||
SrsSipRequest r = sip_session->request();
|
||||
req->copy(&r);
|
||||
|
||||
req->host = config->host;
|
||||
req->host_port = config->sip_port;
|
||||
req->realm = config->sip_realm;
|
||||
req->serial = config->sip_serial;
|
||||
|
||||
//get protocol stack
|
||||
std::stringstream ss;
|
||||
sip->req_bye(ss, req);
|
||||
|
||||
if (send_message(sip_session->sockaddr_from(), sip_session->sockaddr_fromlen(), ss) <= 0)
|
||||
{
|
||||
return ERROR_GB28281_SIP_BYE_FAILED;
|
||||
}
|
||||
|
||||
return ERROR_SUCCESS;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
int SrsGb28181SipService::send_sip_raw_data(SrsSipRequest *req, std::string data)
|
||||
{
|
||||
srs_assert(req);
|
||||
|
||||
SrsGb28181SipSession *sip_session = fetch(req->sip_auth_id);
|
||||
|
||||
if (!sip_session){
|
||||
return ERROR_GB28181_SESSION_IS_NOTEXIST;
|
||||
}
|
||||
|
||||
std::stringstream ss;
|
||||
ss << data;
|
||||
|
||||
if (send_message(sip_session->sockaddr_from(), sip_session->sockaddr_fromlen(), ss) <= 0)
|
||||
{
|
||||
return ERROR_GB28281_SIP_BYE_FAILED;
|
||||
}
|
||||
|
||||
return ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
SrsGb28181SipSession* SrsGb28181SipService::create_sip_session(SrsSipRequest *req)
|
||||
{
|
||||
SrsGb28181SipSession *sess = NULL;
|
||||
|
||||
std::map<std::string, SrsGb28181SipSession*>::iterator it = sessions.find(req->sip_auth_id);
|
||||
if (it == sessions.end()){
|
||||
sess = new SrsGb28181SipSession(this, req);
|
||||
}else{
|
||||
return it->second;
|
||||
}
|
||||
|
||||
sessions[req->sip_auth_id] = sess;
|
||||
return sess;
|
||||
}
|
||||
|
||||
SrsGb28181SipSession* SrsGb28181SipService::fetch(std::string sid)
|
||||
{
|
||||
std::map<std::string, SrsGb28181SipSession*>::iterator it = sessions.find(sid);
|
||||
if (it == sessions.end()){
|
||||
return NULL;
|
||||
}else{
|
||||
return it->second;
|
||||
}
|
||||
}
|
||||
|
||||
void SrsGb28181SipService::remove_session(std::string sid)
|
||||
{
|
||||
std::map<std::string, SrsGb28181SipSession*>::iterator it = sessions.find(sid);
|
||||
if (it != sessions.end()){
|
||||
srs_freep(it->second);
|
||||
sessions.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void SrsGb28181SipService::destroy()
|
||||
{
|
||||
//destory all sip session
|
||||
std::map<std::string, SrsGb28181SipSession*>::iterator it;
|
||||
for (it = sessions.begin(); it != sessions.end(); ++it) {
|
||||
srs_freep(it->second);
|
||||
}
|
||||
sessions.clear();
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,161 @@
|
||||
/**
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2013-2020 Lixin
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef SRS_APP_GB28181_SIP_HPP
|
||||
#define SRS_APP_GB28181_SIP_HPP
|
||||
|
||||
#include <srs_core.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
|
||||
#include <srs_app_log.hpp>
|
||||
#include <srs_sip_stack.hpp>
|
||||
#include <srs_app_gb28181.hpp>
|
||||
|
||||
|
||||
class SrsConfDirective;
|
||||
class SrsSipRequest;
|
||||
class SrsGb28181Config;
|
||||
class SrsSipStack;
|
||||
class SrsGb28181SipService;
|
||||
|
||||
enum SrsGb28281SipSessionStatusType{
|
||||
SrsGb28181SipSessionUnkonw = 0,
|
||||
SrsGb28181SipSessionRegisterOk = 1,
|
||||
SrsGb28181SipSessionAliveOk = 2,
|
||||
SrsGb28181SipSessionInviteOk = 3,
|
||||
SrsGb28181SipSessionTrying = 4,
|
||||
SrsGb28181SipSessionBye = 5,
|
||||
};
|
||||
|
||||
class SrsGb28181SipSession
|
||||
{
|
||||
private:
|
||||
//SrsSipRequest *req;
|
||||
SrsGb28181SipService *caster;
|
||||
std::string session_id;
|
||||
private:
|
||||
SrsGb28281SipSessionStatusType _register_status;
|
||||
SrsGb28281SipSessionStatusType _alive_status;
|
||||
SrsGb28281SipSessionStatusType _invite_status;
|
||||
srs_utime_t _register_time;
|
||||
srs_utime_t _alive_time;
|
||||
srs_utime_t _invite_time;
|
||||
srs_utime_t _recv_rtp_time;
|
||||
int _reg_expires;
|
||||
|
||||
std::string _peer_ip;
|
||||
int _peer_port;
|
||||
|
||||
sockaddr *_from;
|
||||
int _fromlen;
|
||||
SrsSipRequest *req;
|
||||
|
||||
public:
|
||||
void set_register_status(SrsGb28281SipSessionStatusType s) { _register_status = s;}
|
||||
void set_alive_status(SrsGb28281SipSessionStatusType s) { _alive_status = s;}
|
||||
void set_invite_status(SrsGb28281SipSessionStatusType s) { _invite_status = s;}
|
||||
void set_register_time(srs_utime_t t) { _register_time = t;}
|
||||
void set_alive_time(srs_utime_t t) { _alive_time = t;}
|
||||
void set_invite_time(srs_utime_t t) { _invite_time = t;}
|
||||
void set_recv_rtp_time(srs_utime_t t) { _recv_rtp_time = t;}
|
||||
void set_reg_expires(int e) { _reg_expires = e;}
|
||||
void set_peer_ip(std::string i) { _peer_ip = i;}
|
||||
void set_peer_port(int o) { _peer_port = o;}
|
||||
void set_sockaddr(sockaddr *f) { _from = f;}
|
||||
void set_sockaddr_len(int l) { _fromlen = l;}
|
||||
void set_request(SrsSipRequest *r) { req->copy(r);}
|
||||
|
||||
SrsGb28281SipSessionStatusType register_status() { return _register_status;}
|
||||
SrsGb28281SipSessionStatusType alive_status() { return _alive_status;}
|
||||
SrsGb28281SipSessionStatusType invite_status() { return _invite_status;}
|
||||
srs_utime_t register_time() { return _register_time;}
|
||||
srs_utime_t alive_time() { return _alive_time;}
|
||||
srs_utime_t invite_time() { return _invite_time;}
|
||||
srs_utime_t recv_rtp_time() { return _recv_rtp_time;}
|
||||
int reg_expires() { return _reg_expires;}
|
||||
std::string peer_ip() { return _peer_ip;}
|
||||
int peer_port() { return _peer_port;}
|
||||
sockaddr* sockaddr_from() { return _from;}
|
||||
int sockaddr_fromlen() { return _fromlen;}
|
||||
SrsSipRequest request() { return *req;}
|
||||
|
||||
public:
|
||||
SrsGb28181SipSession(SrsGb28181SipService *c, SrsSipRequest* r);
|
||||
virtual ~SrsGb28181SipSession();
|
||||
|
||||
};
|
||||
|
||||
class SrsGb28181SipService : public ISrsUdpHandler
|
||||
{
|
||||
private:
|
||||
SrsSipStack *sip;
|
||||
SrsGb28181Config *config;
|
||||
srs_netfd_t lfd;
|
||||
|
||||
std::map<std::string, SrsGb28181SipSession*> sessions;
|
||||
public:
|
||||
SrsGb28181SipService(SrsConfDirective* c);
|
||||
virtual ~SrsGb28181SipService();
|
||||
|
||||
// Interface ISrsUdpHandler
|
||||
public:
|
||||
virtual srs_error_t on_udp_packet(const sockaddr* from, const int fromlen, char* buf, int nb_buf);
|
||||
virtual void set_stfd(srs_netfd_t fd);
|
||||
private:
|
||||
void destroy();
|
||||
srs_error_t on_udp_sip(std::string host, int port, char* buf, int nb_buf, sockaddr* from, int fromlen);
|
||||
public:
|
||||
int send_message(sockaddr* f, int l, std::stringstream& ss);
|
||||
|
||||
int send_ack(SrsSipRequest *req, sockaddr *f, int l);
|
||||
int send_status(SrsSipRequest *req, sockaddr *f, int l);
|
||||
|
||||
int send_invite(SrsSipRequest *req, std::string ip, int port, uint32_t ssrc);
|
||||
int send_bye(SrsSipRequest *req);
|
||||
|
||||
// The SIP command is transmitted through HTTP API,
|
||||
// and the body content is transmitted to the device,
|
||||
// mainly for testing and debugging, For example, here is HTTP body:
|
||||
// BYE sip:34020000001320000003@3402000000 SIP/2.0
|
||||
// Via: SIP/2.0/UDP 39.100.155.146:15063;rport;branch=z9hG4bK34205410
|
||||
// From: <sip:34020000002000000001@3402000000>;tag=512355410
|
||||
// To: <sip:34020000001320000003@3402000000>;tag=680367414
|
||||
// Call-ID: 200003304
|
||||
// CSeq: 21 BYE
|
||||
// Max-Forwards: 70
|
||||
// User-Agent: SRS/4.0.4(Leo)
|
||||
// Content-Length: 0
|
||||
//
|
||||
//
|
||||
int send_sip_raw_data(SrsSipRequest *req, std::string data);
|
||||
|
||||
SrsGb28181SipSession* create_sip_session(SrsSipRequest *req);
|
||||
SrsGb28181SipSession* fetch(std::string id);
|
||||
void remove_session(std::string id);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -0,0 +1,775 @@
|
||||
/**
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2013-2020 Lixin
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <srs_sip_stack.hpp>
|
||||
|
||||
#if !defined(SRS_EXPORT_LIBRTMP)
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
|
||||
using namespace std;
|
||||
|
||||
#include <srs_protocol_io.hpp>
|
||||
#include <srs_kernel_stream.hpp>
|
||||
#include <srs_kernel_error.hpp>
|
||||
#include <srs_kernel_log.hpp>
|
||||
#include <srs_kernel_consts.hpp>
|
||||
#include <srs_core_autofree.hpp>
|
||||
#include <srs_kernel_utility.hpp>
|
||||
#include <srs_kernel_buffer.hpp>
|
||||
#include <srs_kernel_codec.hpp>
|
||||
#include <srs_rtsp_stack.hpp>
|
||||
|
||||
unsigned int srs_sip_random(int min,int max)
|
||||
{
|
||||
srand(int(time(0)));
|
||||
return rand() % (max - min + 1) + min;
|
||||
}
|
||||
|
||||
std::string srs_sip_get_form_to_uri(std::string msg)
|
||||
{
|
||||
//<sip:34020000002000000001@3402000000>;tag=536961166
|
||||
//sip:34020000002000000001@3402000000
|
||||
|
||||
size_t pos = msg.find("<");
|
||||
if (pos == string::npos) {
|
||||
return msg;
|
||||
}
|
||||
|
||||
msg = msg.substr(pos+1);
|
||||
|
||||
size_t pos2 = msg.find(">");
|
||||
if (pos2 == string::npos) {
|
||||
return msg;
|
||||
}
|
||||
|
||||
msg = msg.substr(0, pos2);
|
||||
return msg;
|
||||
}
|
||||
|
||||
std::string srs_sip_get_utc_date()
|
||||
{
|
||||
// clock time
|
||||
timeval tv;
|
||||
if (gettimeofday(&tv, NULL) == -1) {
|
||||
return "";
|
||||
}
|
||||
|
||||
// to calendar time
|
||||
struct tm* tm;
|
||||
if ((tm = gmtime(&tv.tv_sec)) == NULL) {
|
||||
return "";
|
||||
}
|
||||
|
||||
//Date: 2020-03-21T14:20:57.638
|
||||
std::string utc_date = "";
|
||||
char buffer[25] = {0};
|
||||
snprintf(buffer, 25,
|
||||
"%d-%02d-%02dT%02d:%02d:%02d.%03d",
|
||||
1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, (int)(tv.tv_usec / 1000));
|
||||
utc_date = buffer;
|
||||
return utc_date;
|
||||
}
|
||||
|
||||
|
||||
std::string srs_sip_get_param(std::string msg, std::string param)
|
||||
{
|
||||
std::vector<std::string> vec_params = srs_string_split(msg, ";");
|
||||
|
||||
for (vector<string>::iterator it = vec_params.begin(); it != vec_params.end(); ++it) {
|
||||
string value = *it;
|
||||
|
||||
size_t pos = value.find(param);
|
||||
if (pos == string::npos) {
|
||||
continue;
|
||||
}
|
||||
|
||||
std::vector<std::string> v_pram = srs_string_split(value, "=");
|
||||
|
||||
if (v_pram.size() > 0) {
|
||||
return v_pram.at(1);
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
SrsSipRequest::SrsSipRequest()
|
||||
{
|
||||
seq = 0;
|
||||
content_length = 0;
|
||||
sdp = NULL;
|
||||
transport = NULL;
|
||||
|
||||
method = "";
|
||||
uri = "";;
|
||||
version = "";;
|
||||
seq = 0;
|
||||
content_type = "";
|
||||
content_length = 0;
|
||||
call_id = "";
|
||||
from = "";
|
||||
to = "";
|
||||
via = "";
|
||||
from_tag = "";
|
||||
to_tag = "";
|
||||
contact = "";
|
||||
user_agent = "";
|
||||
branch = "";
|
||||
status = "";
|
||||
expires = 3600;
|
||||
max_forwards = 70;
|
||||
www_authenticate = "";
|
||||
authorization = "";
|
||||
cmdtype = SrsSipCmdRequest;
|
||||
|
||||
host = "127.0.0.1";;
|
||||
host_port = 5060;
|
||||
|
||||
serial = "";;
|
||||
realm = "";;
|
||||
|
||||
sip_auth_id = "";
|
||||
sip_auth_pwd = "";
|
||||
sip_username = "";
|
||||
peer_ip = "";
|
||||
peer_port = 0;
|
||||
}
|
||||
|
||||
SrsSipRequest::~SrsSipRequest()
|
||||
{
|
||||
srs_freep(sdp);
|
||||
srs_freep(transport);
|
||||
}
|
||||
|
||||
bool SrsSipRequest::is_register()
|
||||
{
|
||||
return method == SRS_SIP_METHOD_REGISTER;
|
||||
}
|
||||
|
||||
bool SrsSipRequest::is_invite()
|
||||
{
|
||||
return method == SRS_SIP_METHOD_INVITE;
|
||||
}
|
||||
|
||||
bool SrsSipRequest::is_ack()
|
||||
{
|
||||
return method == SRS_SIP_METHOD_ACK;
|
||||
}
|
||||
|
||||
bool SrsSipRequest::is_message()
|
||||
{
|
||||
return method == SRS_SIP_METHOD_MESSAGE;
|
||||
}
|
||||
|
||||
bool SrsSipRequest::is_bye()
|
||||
{
|
||||
return method == SRS_SIP_METHOD_BYE;
|
||||
}
|
||||
|
||||
std::string SrsSipRequest::get_cmdtype_str()
|
||||
{
|
||||
switch(cmdtype) {
|
||||
case SrsSipCmdRequest:
|
||||
return "request";
|
||||
case SrsSipCmdRespone:
|
||||
return "respone";
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
void SrsSipRequest::copy(SrsSipRequest* src)
|
||||
{
|
||||
if (!src){
|
||||
return;
|
||||
}
|
||||
|
||||
method = src->method;
|
||||
uri = src->uri;
|
||||
version = src->version;
|
||||
seq = src->seq;
|
||||
content_type = src->content_type;
|
||||
content_length = src->content_length;
|
||||
call_id = src->call_id;
|
||||
from = src->from;
|
||||
to = src->to;
|
||||
via = src->via;
|
||||
from_tag = src->from_tag;
|
||||
to_tag = src->to_tag;
|
||||
contact = src->contact;
|
||||
user_agent = src->user_agent;
|
||||
branch = src->branch;
|
||||
status = src->status;
|
||||
expires = src->expires;
|
||||
max_forwards = src->max_forwards;
|
||||
www_authenticate = src->www_authenticate;
|
||||
authorization = src->authorization;
|
||||
cmdtype = src->cmdtype;
|
||||
|
||||
host = src->host;
|
||||
host_port = src->host_port;
|
||||
|
||||
serial = src->serial;
|
||||
realm = src->realm;
|
||||
|
||||
sip_auth_id = src->sip_auth_id;
|
||||
sip_auth_pwd = src->sip_auth_pwd;
|
||||
sip_username = src->sip_username;
|
||||
peer_ip = src->peer_ip;
|
||||
peer_port = src->peer_port;
|
||||
}
|
||||
|
||||
SrsSipStack::SrsSipStack()
|
||||
{
|
||||
buf = new SrsSimpleStream();
|
||||
}
|
||||
|
||||
SrsSipStack::~SrsSipStack()
|
||||
{
|
||||
srs_freep(buf);
|
||||
}
|
||||
|
||||
srs_error_t SrsSipStack::parse_request(SrsSipRequest** preq, const char* recv_msg, int nb_len)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
SrsSipRequest* req = new SrsSipRequest();
|
||||
if ((err = do_parse_request(req, recv_msg)) != srs_success) {
|
||||
srs_freep(req);
|
||||
return srs_error_wrap(err, "recv message");
|
||||
}
|
||||
|
||||
*preq = req;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsSipStack::do_parse_request(SrsSipRequest* req, const char* recv_msg)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
std::vector<std::string> header_body = srs_string_split(recv_msg, SRS_RTSP_CRLFCRLF);
|
||||
std::string header = header_body.at(0);
|
||||
std::string body = "";
|
||||
|
||||
if (header_body.size() > 1){
|
||||
body = header_body.at(1);
|
||||
}
|
||||
|
||||
srs_info("sip: header=%s\n", header.c_str());
|
||||
srs_info("sip: body=%s\n", body.c_str());
|
||||
|
||||
// parse one by one.
|
||||
char* start = (char*)header.c_str();
|
||||
char* end = start + header.size();
|
||||
char* p = start;
|
||||
char* newline_start = start;
|
||||
std::string firstline = "";
|
||||
while (p < end) {
|
||||
if (p[0] == '\r' && p[1] == '\n'){
|
||||
p +=2;
|
||||
int linelen = (int)(p - newline_start);
|
||||
std::string oneline(newline_start, linelen);
|
||||
newline_start = p;
|
||||
|
||||
if (firstline == ""){
|
||||
firstline = oneline;
|
||||
srs_info("sip: first line=%s", firstline.c_str());
|
||||
}else{
|
||||
size_t pos = oneline.find(":");
|
||||
if (pos != string::npos){
|
||||
if (pos != 0) {
|
||||
//ex: CSeq: 100 MESSAGE header is 'CSeq:',content is '100 MESSAGE'
|
||||
std::string head = oneline.substr(0, pos+1);
|
||||
std::string content = oneline.substr(pos+1, oneline.length()-pos-1);
|
||||
content = srs_string_replace(content, "\r\n", "");
|
||||
content = srs_string_trim_start(content, " ");
|
||||
char *phead = (char*)head.c_str();
|
||||
|
||||
if (!strcasecmp(phead, "call-id:")) {
|
||||
std::vector<std::string> vec_callid = srs_string_split(content, " ");
|
||||
req->call_id = vec_callid.at(0);
|
||||
}
|
||||
else if (!strcasecmp(phead, "contact:")) {
|
||||
req->contact = content;
|
||||
}
|
||||
else if (!strcasecmp(phead, "content-encoding:")) {
|
||||
srs_trace("sip: message head %s content=%s", phead, content.c_str());
|
||||
}
|
||||
else if (!strcasecmp(phead, "content-length:")) {
|
||||
req->content_length = strtoul(content.c_str(), NULL, 10);
|
||||
}
|
||||
else if (!strcasecmp(phead, "content-type:")) {
|
||||
req->content_type = content;
|
||||
}
|
||||
else if (!strcasecmp(phead, "cseq:")) {
|
||||
std::vector<std::string> vec_seq = srs_string_split(content, " ");
|
||||
req->seq = strtoul(vec_seq.at(0).c_str(), NULL, 10);
|
||||
req->method = vec_seq.at(1);
|
||||
}
|
||||
else if (!strcasecmp(phead, "from:")) {
|
||||
content = srs_string_replace(content, "sip:", "");
|
||||
req->from = srs_sip_get_form_to_uri(content.c_str());
|
||||
if (srs_string_contains(content, "tag")) {
|
||||
req->from_tag = srs_sip_get_param(content.c_str(), "tag");
|
||||
}
|
||||
}
|
||||
else if (!strcasecmp(phead, "to:")) {
|
||||
content = srs_string_replace(content, "sip:", "");
|
||||
req->to = srs_sip_get_form_to_uri(content.c_str());
|
||||
if (srs_string_contains(content, "tag")) {
|
||||
req->to_tag = srs_sip_get_param(content.c_str(), "tag");
|
||||
}
|
||||
}
|
||||
else if (!strcasecmp(phead, "via:")) {
|
||||
std::vector<std::string> vec_seq = srs_string_split(content, ";");
|
||||
req->via = content;
|
||||
req->branch = srs_sip_get_param(content.c_str(), "branch");
|
||||
}
|
||||
else if (!strcasecmp(phead, "expires:")){
|
||||
req->expires = strtoul(content.c_str(), NULL, 10);
|
||||
}
|
||||
else if (!strcasecmp(phead, "user-agent:")){
|
||||
req->user_agent = content;
|
||||
}
|
||||
else if (!strcasecmp(phead, "max-forwards:")){
|
||||
req->max_forwards = strtoul(content.c_str(), NULL, 10);
|
||||
}
|
||||
else if (!strcasecmp(phead, "www-authenticate:")){
|
||||
req->www_authenticate = content;
|
||||
}
|
||||
else if (!strcasecmp(phead, "authorization:")){
|
||||
req->authorization = content;
|
||||
}
|
||||
else {
|
||||
//TODO: fixme
|
||||
srs_trace("sip: unkonw message head %s content=%s", phead, content.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}else{
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::string> method_uri_ver = srs_string_split(firstline, " ");
|
||||
//respone first line text:SIP/2.0 200 OK
|
||||
if (!strcasecmp(method_uri_ver.at(0).c_str(), "sip/2.0")) {
|
||||
req->cmdtype = SrsSipCmdRespone;
|
||||
//req->method= vec_seq.at(1);
|
||||
req->status = method_uri_ver.at(1);
|
||||
req->version = method_uri_ver.at(0);
|
||||
req->uri = req->from;
|
||||
|
||||
vector<string> str = srs_string_split(req->to, "@");
|
||||
req->sip_auth_id = srs_string_replace(str.at(0), "sip:", "");
|
||||
|
||||
}else {//request first line text :MESSAGE sip:34020000002000000001@3402000000 SIP/2.0
|
||||
req->cmdtype = SrsSipCmdRequest;
|
||||
req->method= method_uri_ver.at(0);
|
||||
req->uri = method_uri_ver.at(1);
|
||||
req->version = method_uri_ver.at(2);
|
||||
|
||||
vector<string> str = srs_string_split(req->from, "@");
|
||||
req->sip_auth_id = srs_string_replace(str.at(0), "sip:", "");
|
||||
}
|
||||
|
||||
req->sip_username = req->sip_auth_id;
|
||||
|
||||
srs_info("sip: method=%s uri=%s version=%s cmdtype=%s",
|
||||
req->method.c_str(), req->uri.c_str(), req->version.c_str(), req->get_cmdtype_str().c_str());
|
||||
srs_info("via=%s", req->via.c_str());
|
||||
srs_info("via_branch=%s", req->branch.c_str());
|
||||
srs_info("cseq=%d", req->seq);
|
||||
srs_info("contact=%s", req->contact.c_str());
|
||||
srs_info("from=%s", req->from.c_str());
|
||||
srs_info("to=%s", req->to.c_str());
|
||||
srs_info("callid=%s", req->call_id.c_str());
|
||||
srs_info("status=%s", req->status.c_str());
|
||||
srs_info("from_tag=%s", req->from_tag.c_str());
|
||||
srs_info("to_tag=%s", req->to_tag.c_str());
|
||||
srs_info("sip_auth_id=%s", req->sip_auth_id.c_str());
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
void SrsSipStack::resp_keepalive(std::stringstream& ss, SrsSipRequest *req){
|
||||
ss << SRS_SIP_VERSION <<" 200 OK" << SRS_RTSP_CRLF
|
||||
<< "Via: " << SRS_SIP_VERSION << "/UDP " << req->host << ":" << req->host_port << ";branch=" << req->branch << SRS_RTSP_CRLF
|
||||
<< "From: <sip:" << req->from.c_str() << ">;tag=" << req->from_tag << SRS_RTSP_CRLF
|
||||
<< "To: <sip:"<< req->to.c_str() << ">\r\n"
|
||||
<< "Call-ID: " << req->call_id << SRS_RTSP_CRLF
|
||||
<< "CSeq: " << req->seq << " " << req->method << SRS_RTSP_CRLF
|
||||
<< "Contact: "<< req->contact << SRS_RTSP_CRLF
|
||||
<< "Max-Forwards: 70" << SRS_RTSP_CRLF
|
||||
<< "User-Agent: "<< SRS_SIP_USER_AGENT << SRS_RTSP_CRLF
|
||||
<< "Content-Length: 0" << SRS_RTSP_CRLFCRLF;
|
||||
}
|
||||
|
||||
void SrsSipStack::resp_status(stringstream& ss, SrsSipRequest *req)
|
||||
{
|
||||
if (req->method == "REGISTER"){
|
||||
/*
|
||||
//request: sip-agent-----REGISTER------->sip-server
|
||||
REGISTER sip:34020000002000000001@3402000000 SIP/2.0
|
||||
Via: SIP/2.0/UDP 192.168.137.11:5060;rport;branch=z9hG4bK1371463273
|
||||
From: <sip:34020000001320000003@3402000000>;tag=2043466181
|
||||
To: <sip:34020000001320000003@3402000000>
|
||||
Call-ID: 1011047669
|
||||
CSeq: 1 REGISTER
|
||||
Contact: <sip:34020000001320000003@192.168.137.11:5060>
|
||||
Max-Forwards: 70
|
||||
User-Agent: IP Camera
|
||||
Expires: 3600
|
||||
Content-Length: 0
|
||||
|
||||
//response: sip-agent<-----200 OK--------sip-server
|
||||
SIP/2.0 200 OK
|
||||
Via: SIP/2.0/UDP 192.168.137.11:5060;rport;branch=z9hG4bK1371463273
|
||||
From: <sip:34020000001320000003@3402000000>
|
||||
To: <sip:34020000001320000003@3402000000>
|
||||
CSeq: 1 REGISTER
|
||||
Call-ID: 1011047669
|
||||
Contact: <sip:34020000001320000003@192.168.137.11:5060>
|
||||
User-Agent: SRS/4.0.4(Leo)
|
||||
Expires: 3600
|
||||
Content-Length: 0
|
||||
|
||||
*/
|
||||
if (req->authorization.empty()){
|
||||
//TODO: fixme supoort 401
|
||||
//return req_401_unauthorized(ss, req);
|
||||
}
|
||||
|
||||
ss << SRS_SIP_VERSION <<" 200 OK" << SRS_RTSP_CRLF
|
||||
<< "Via: " << req->via << SRS_RTSP_CRLF
|
||||
<< "From: <sip:"<< req->from << ">" << SRS_RTSP_CRLF
|
||||
<< "To: <sip:"<< req->to << ">" << SRS_RTSP_CRLF
|
||||
<< "CSeq: "<< req->seq << " " << req->method << SRS_RTSP_CRLF
|
||||
<< "Call-ID: " << req->call_id << SRS_RTSP_CRLF
|
||||
<< "Contact: " << req->contact << SRS_RTSP_CRLF
|
||||
<< "User-Agent: " << SRS_SIP_USER_AGENT << SRS_RTSP_CRLF
|
||||
<< "Expires: " << req->expires << SRS_RTSP_CRLF
|
||||
<< "Content-Length: 0" << SRS_RTSP_CRLFCRLF;
|
||||
}else{
|
||||
/*
|
||||
//request: sip-agnet-------MESSAGE------->sip-server
|
||||
MESSAGE sip:34020000002000000001@3402000000 SIP/2.0
|
||||
Via: SIP/2.0/UDP 192.168.137.11:5060;rport;branch=z9hG4bK1066375804
|
||||
From: <sip:34020000001320000003@3402000000>;tag=1925919231
|
||||
To: <sip:34020000002000000001@3402000000>
|
||||
Call-ID: 1185236415
|
||||
CSeq: 20 MESSAGE
|
||||
Content-Type: Application/MANSCDP+xml
|
||||
Max-Forwards: 70
|
||||
User-Agent: IP Camera
|
||||
Content-Length: 175
|
||||
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Notify>
|
||||
<CmdType>Keepalive</CmdType>
|
||||
<SN>1</SN>
|
||||
<DeviceID>34020000001320000003</DeviceID>
|
||||
<Status>OK</Status>
|
||||
<Info>
|
||||
</Info>
|
||||
</Notify>
|
||||
//response: sip-agent------200 OK --------> sip-server
|
||||
SIP/2.0 200 OK
|
||||
Via: SIP/2.0/UDP 192.168.137.11:5060;rport;branch=z9hG4bK1066375804
|
||||
From: <sip:34020000001320000003@3402000000>
|
||||
To: <sip:34020000002000000001@3402000000>
|
||||
CSeq: 20 MESSAGE
|
||||
Call-ID: 1185236415
|
||||
User-Agent: SRS/4.0.4(Leo)
|
||||
Content-Length: 0
|
||||
|
||||
*/
|
||||
|
||||
ss << SRS_SIP_VERSION <<" 200 OK" << SRS_RTSP_CRLF
|
||||
<< "Via: " << req->via << SRS_RTSP_CRLF
|
||||
<< "From: <sip:"<< req->from << ">" << SRS_RTSP_CRLF
|
||||
<< "To: <sip:"<< req->to << ">" << SRS_RTSP_CRLF
|
||||
<< "CSeq: "<< req->seq << " " << req->method << SRS_RTSP_CRLF
|
||||
<< "Call-ID: " << req->call_id << SRS_RTSP_CRLF
|
||||
<< "User-Agent: " << SRS_SIP_USER_AGENT << SRS_RTSP_CRLF
|
||||
<< "Content-Length: 0" << SRS_RTSP_CRLFCRLF;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void SrsSipStack::req_invite(stringstream& ss, SrsSipRequest *req, string ip, int port, uint32_t ssrc)
|
||||
{
|
||||
/*
|
||||
//request: sip-agent <-------INVITE------ sip-server
|
||||
INVITE sip:34020000001320000003@3402000000 SIP/2.0
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@39.100.155.146:15063>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>
|
||||
Call-ID: 200008805
|
||||
CSeq: 20 INVITE
|
||||
Content-Type: Application/SDP
|
||||
Contact: <sip:34020000001320000003@3402000000>
|
||||
Max-Forwards: 70
|
||||
User-Agent: SRS/4.0.4(Leo)
|
||||
Subject: 34020000001320000003:630886,34020000002000000001:0
|
||||
Content-Length: 164
|
||||
|
||||
v=0
|
||||
o=34020000001320000003 0 0 IN IP4 39.100.155.146
|
||||
s=Play
|
||||
c=IN IP4 39.100.155.146
|
||||
t=0 0
|
||||
m=video 9000 RTP/AVP 96
|
||||
a=recvonly
|
||||
a=rtpmap:96 PS/90000
|
||||
y=630886
|
||||
//response: sip-agent --------100 Trying--------> sip-server
|
||||
SIP/2.0 100 Trying
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport=15063;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@39.100.155.146:15063>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>
|
||||
Call-ID: 200008805
|
||||
CSeq: 20 INVITE
|
||||
User-Agent: IP Camera
|
||||
Content-Length: 0
|
||||
|
||||
//response: sip-agent -------200 OK--------> sip-server
|
||||
SIP/2.0 200 OK
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport=15063;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@39.100.155.146:15063>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>;tag=1083111311
|
||||
Call-ID: 200008805
|
||||
CSeq: 20 INVITE
|
||||
Contact: <sip:34020000001320000003@192.168.137.11:5060>
|
||||
Content-Type: application/sdp
|
||||
User-Agent: IP Camera
|
||||
Content-Length: 263
|
||||
|
||||
v=0
|
||||
o=34020000001320000003 1073 1073 IN IP4 192.168.137.11
|
||||
s=Play
|
||||
c=IN IP4 192.168.137.11
|
||||
t=0 0
|
||||
m=video 15060 RTP/AVP 96
|
||||
a=setup:active
|
||||
a=sendonly
|
||||
a=rtpmap:96 PS/90000
|
||||
a=username:34020000001320000003
|
||||
a=password:12345678
|
||||
a=filesize:0
|
||||
y=0000630886
|
||||
f=
|
||||
//request: sip-agent <------ ACK ------- sip-server
|
||||
ACK sip:34020000001320000003@3402000000 SIP/2.0
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@39.100.155.146:15063>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>
|
||||
Call-ID: 200008805
|
||||
CSeq: 20 ACK
|
||||
Max-Forwards: 70
|
||||
User-Agent: SRS/4.0.4(Leo)
|
||||
Content-Length: 0
|
||||
*/
|
||||
|
||||
std::stringstream sdp;
|
||||
sdp << "v=0" << SRS_RTSP_CRLF
|
||||
<< "o=" << req->sip_auth_id << " 0 0 IN IP4 " << ip << SRS_RTSP_CRLF
|
||||
<< "s=Play" << SRS_RTSP_CRLF
|
||||
<< "c=IN IP4 " << ip << SRS_RTSP_CRLF
|
||||
<< "t=0 0" << SRS_RTSP_CRLF
|
||||
//TODO 97 98 99 current no support
|
||||
//<< "m=video " << port <<" RTP/AVP 96 97 98 99" << SRS_RTSP_CRLF
|
||||
<< "m=video " << port <<" RTP/AVP 96" << SRS_RTSP_CRLF
|
||||
<< "a=recvonly" << SRS_RTSP_CRLF
|
||||
<< "a=rtpmap:96 PS/90000" << SRS_RTSP_CRLF
|
||||
//TODO: current no support
|
||||
//<< "a=rtpmap:97 MPEG4/90000" << SRS_RTSP_CRLF
|
||||
//<< "a=rtpmap:98 H264/90000" << SRS_RTSP_CRLF
|
||||
//<< "a=rtpmap:99 H265/90000" << SRS_RTSP_CRLF
|
||||
//<< "a=streamMode:MAIN\r\n"
|
||||
//<< "a=filesize:0\r\n"
|
||||
<< "y=" << ssrc << SRS_RTSP_CRLF;
|
||||
|
||||
|
||||
int rand = srs_sip_random(1000, 9999);
|
||||
std::stringstream from, to, uri, branch, from_tag;
|
||||
//"INVITE sip:34020000001320000001@3402000000 SIP/2.0\r\n
|
||||
uri << "sip:" << req->sip_auth_id << "@" << req->realm;
|
||||
//From: <sip:34020000002000000001@%s:%s>;tag=500485%d\r\n
|
||||
from << req->serial << "@" << req->host << ":" << req->host_port;
|
||||
to << req->sip_auth_id << "@" << req->realm;
|
||||
|
||||
req->from = from.str();
|
||||
req->to = to.str();
|
||||
req->uri = uri.str();
|
||||
|
||||
branch << "z9hG4bK3420" << rand;
|
||||
from_tag << "51235" << rand;
|
||||
req->branch = branch.str();
|
||||
req->from_tag = from_tag.str();
|
||||
|
||||
ss << "INVITE " << req->uri << " " << SRS_SIP_VERSION << SRS_RTSP_CRLF
|
||||
<< "Via: " << SRS_SIP_VERSION << "/UDP "<< req->host << ":" << req->host_port << ";rport;branch=" << req->branch << SRS_RTSP_CRLF
|
||||
<< "From: <sip:" << req->from << ">;tag=" << req->from_tag << SRS_RTSP_CRLF
|
||||
<< "To: <sip:" << req->to << ">" << SRS_RTSP_CRLF
|
||||
<< "Call-ID: 20000" << rand <<SRS_RTSP_CRLF
|
||||
<< "CSeq: 20 INVITE" << SRS_RTSP_CRLF
|
||||
<< "Content-Type: Application/SDP" << SRS_RTSP_CRLF
|
||||
<< "Contact: <sip:" << req->to << ">" << SRS_RTSP_CRLF
|
||||
<< "Max-Forwards: 70" << " \r\n"
|
||||
<< "User-Agent: " << SRS_SIP_USER_AGENT <<SRS_RTSP_CRLF
|
||||
<< "Subject: "<< req->sip_auth_id << ":" << ssrc << "," << req->serial << ":0" << SRS_RTSP_CRLF
|
||||
<< "Content-Length: " << sdp.str().length() << SRS_RTSP_CRLFCRLF
|
||||
<< sdp.str();
|
||||
}
|
||||
|
||||
|
||||
void SrsSipStack::req_401_unauthorized(std::stringstream& ss, SrsSipRequest *req)
|
||||
{
|
||||
/* sip-agent <-----401 Unauthorized ------ sip-server
|
||||
SIP/2.0 401 Unauthorized
|
||||
Via: SIP/2.0/UDP 192.168.137.92:5061;rport=61378;received=192.168.1.13;branch=z9hG4bK802519080
|
||||
From: <sip:34020000001320000004@192.168.137.92:5061>;tag=611442989
|
||||
To: <sip:34020000001320000004@192.168.137.92:5061>;tag=102092689
|
||||
CSeq: 1 REGISTER
|
||||
Call-ID: 1650345118
|
||||
User-Agent: LiveGBS v200228
|
||||
Contact: <sip:34020000002000000001@192.168.1.23:15060>
|
||||
Content-Length: 0
|
||||
WWW-Authenticate: Digest realm="3402000000",qop="auth",nonce="f1da98bd160f3e2efe954c6eedf5f75a"
|
||||
*/
|
||||
|
||||
ss << SRS_SIP_VERSION <<" 401 Unauthorized" << SRS_RTSP_CRLF
|
||||
//<< "Via: " << req->via << SRS_RTSP_CRLF
|
||||
<< "Via: " << req->via << ";rport=" << req->peer_port << ";received=" << req->peer_ip << ";branch=" << req->branch << SRS_RTSP_CRLF
|
||||
<< "From: <sip:"<< req->from << ">" << SRS_RTSP_CRLF
|
||||
<< "To: <sip:"<< req->to << ">" << SRS_RTSP_CRLF
|
||||
<< "CSeq: "<< req->seq << " " << req->method << SRS_RTSP_CRLF
|
||||
<< "Call-ID: " << req->call_id << SRS_RTSP_CRLF
|
||||
<< "Contact: " << req->contact << SRS_RTSP_CRLF
|
||||
<< "User-Agent: " << SRS_SIP_USER_AGENT << SRS_RTSP_CRLF
|
||||
<< "Content-Length: 0" << SRS_RTSP_CRLF
|
||||
<< "WWW-Authenticate: Digest realm=\"3402000000\",qop=\"auth\",nonce=\"f1da98bd160f3e2efe954c6eedf5f75a\"" << SRS_RTSP_CRLFCRLF;
|
||||
return;
|
||||
}
|
||||
|
||||
void SrsSipStack::resp_ack(std::stringstream& ss, SrsSipRequest *req){
|
||||
/*
|
||||
//request: sip-agent <------ ACK ------- sip-server
|
||||
ACK sip:34020000001320000003@3402000000 SIP/2.0
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@39.100.155.146:15063>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>
|
||||
Call-ID: 200008805
|
||||
CSeq: 20 ACK
|
||||
Max-Forwards: 70
|
||||
User-Agent: SRS/4.0.4(Leo)
|
||||
Content-Length: 0
|
||||
*/
|
||||
|
||||
ss << "ACK " << "sip:" << req->sip_auth_id << "@" << req->realm << " "<< SRS_SIP_VERSION << SRS_RTSP_CRLF
|
||||
<< "Via: " << SRS_SIP_VERSION << "/UDP " << req->host << ":" << req->host_port << ";rport;branch=" << req->branch << SRS_RTSP_CRLF
|
||||
<< "From: <sip:" << req->serial << "@" << req->host + ":" << req->host_port << ">;tag=" << req->from_tag << SRS_RTSP_CRLF
|
||||
<< "To: <sip:"<< req->sip_auth_id << "@" << req->realm << ">\r\n"
|
||||
<< "Call-ID: " << req->call_id << SRS_RTSP_CRLF
|
||||
<< "CSeq: " << req->seq << " ACK"<< SRS_RTSP_CRLF
|
||||
<< "Max-Forwards: 70" << SRS_RTSP_CRLF
|
||||
<< "User-Agent: "<< SRS_SIP_USER_AGENT << SRS_RTSP_CRLF
|
||||
<< "Content-Length: 0" << SRS_RTSP_CRLFCRLF;
|
||||
}
|
||||
|
||||
void SrsSipStack::req_bye(std::stringstream& ss, SrsSipRequest *req)
|
||||
{
|
||||
/*
|
||||
//request: sip-agent <------BYE------ sip-server
|
||||
BYE sip:34020000001320000003@3402000000 SIP/2.0
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@3402000000>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>;tag=1083111311
|
||||
Call-ID: 200008805
|
||||
CSeq: 79 BYE
|
||||
Max-Forwards: 70
|
||||
User-Agent: SRS/4.0.4(Leo)
|
||||
Content-Length: 0
|
||||
|
||||
//response: sip-agent ------200 OK ------> sip-server
|
||||
SIP/2.0 200 OK
|
||||
Via: SIP/2.0/UDP 39.100.155.146:15063;rport=15063;branch=z9hG4bK34208805
|
||||
From: <sip:34020000002000000001@3402000000>;tag=512358805
|
||||
To: <sip:34020000001320000003@3402000000>;tag=1083111311
|
||||
Call-ID: 200008805
|
||||
CSeq: 79 BYE
|
||||
User-Agent: IP Camera
|
||||
Content-Length: 0
|
||||
|
||||
*/
|
||||
|
||||
std::stringstream from, to, uri;
|
||||
uri << "sip:" << req->sip_auth_id << "@" << req->realm;
|
||||
from << req->serial << "@" << req->realm;
|
||||
to << req->sip_auth_id << "@" << req->realm;
|
||||
|
||||
req->from = from.str();
|
||||
req->to = to.str();
|
||||
req->uri = uri.str();
|
||||
|
||||
string to_tag, from_tag, branch;
|
||||
|
||||
if (req->branch.empty()){
|
||||
branch = "";
|
||||
}else {
|
||||
branch = ";branch=" + req->branch;
|
||||
}
|
||||
|
||||
if (req->from_tag.empty()){
|
||||
from_tag = "";
|
||||
}else {
|
||||
from_tag = ";tag=" + req->from_tag;
|
||||
}
|
||||
|
||||
if (req->to_tag.empty()){
|
||||
to_tag = "";
|
||||
}else {
|
||||
to_tag = ";tag=" + req->to_tag;
|
||||
}
|
||||
|
||||
int seq = srs_sip_random(22, 99);
|
||||
ss << "BYE " << req->uri << " "<< SRS_SIP_VERSION << SRS_RTSP_CRLF
|
||||
<< "Via: "<< SRS_SIP_VERSION << "/UDP "<< req->host << ":" << req->host_port << ";rport" << branch << SRS_RTSP_CRLF
|
||||
<< "From: <sip:" << req->from << ">" << from_tag << SRS_RTSP_CRLF
|
||||
<< "To: <sip:" << req->to << ">" << to_tag << SRS_RTSP_CRLF
|
||||
<< "Call-ID: " << req->call_id << SRS_RTSP_CRLF
|
||||
<< "CSeq: "<< seq <<" BYE" << SRS_RTSP_CRLF
|
||||
<< "Max-Forwards: 70" << SRS_RTSP_CRLF
|
||||
<< "User-Agent: " << SRS_SIP_USER_AGENT << SRS_RTSP_CRLF
|
||||
<< "Content-Length: 0" << SRS_RTSP_CRLFCRLF;
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -0,0 +1,147 @@
|
||||
/**
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2013-2020 Lixin
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef SRS_PROTOCOL_SIP_HPP
|
||||
#define SRS_PROTOCOL_SIP_HPP
|
||||
|
||||
#include <srs_core.hpp>
|
||||
|
||||
#if !defined(SRS_EXPORT_LIBRTMP)
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
|
||||
#include <srs_kernel_consts.hpp>
|
||||
#include <srs_rtsp_stack.hpp>
|
||||
|
||||
class SrsBuffer;
|
||||
class SrsSimpleStream;
|
||||
class SrsAudioFrame;
|
||||
|
||||
// SIP methods
|
||||
#define SRS_SIP_METHOD_REGISTER "REGISTER"
|
||||
#define SRS_SIP_METHOD_MESSAGE "MESSAGE"
|
||||
#define SRS_SIP_METHOD_INVITE "INVITE"
|
||||
#define SRS_SIP_METHOD_ACK "ACK"
|
||||
#define SRS_SIP_METHOD_BYE "BYE"
|
||||
|
||||
// SIP-Version
|
||||
#define SRS_SIP_VERSION "SIP/2.0"
|
||||
#define SRS_SIP_USER_AGENT RTMP_SIG_SRS_SERVER
|
||||
|
||||
|
||||
enum SrsSipCmdType{
|
||||
SrsSipCmdRequest=0,
|
||||
SrsSipCmdRespone=1
|
||||
};
|
||||
|
||||
class SrsSipRequest
|
||||
{
|
||||
public:
|
||||
//sip header member
|
||||
std::string method;
|
||||
std::string uri;
|
||||
std::string version;
|
||||
std::string status;
|
||||
|
||||
std::string via;
|
||||
std::string from;
|
||||
std::string to;
|
||||
std::string from_tag;
|
||||
std::string to_tag;
|
||||
std::string branch;
|
||||
|
||||
std::string call_id;
|
||||
long seq;
|
||||
|
||||
std::string contact;
|
||||
std::string user_agent;
|
||||
|
||||
std::string content_type;
|
||||
long content_length;
|
||||
|
||||
long expires;
|
||||
int max_forwards;
|
||||
|
||||
std::string www_authenticate;
|
||||
std::string authorization;
|
||||
|
||||
public:
|
||||
std::string serial;
|
||||
std::string realm;
|
||||
std::string sip_auth_id;
|
||||
std::string sip_auth_pwd;
|
||||
std::string sip_username;
|
||||
std::string peer_ip;
|
||||
int peer_port;
|
||||
std::string host;
|
||||
int host_port;
|
||||
SrsSipCmdType cmdtype;
|
||||
|
||||
public:
|
||||
SrsRtspSdp* sdp;
|
||||
SrsRtspTransport* transport;
|
||||
public:
|
||||
SrsSipRequest();
|
||||
virtual ~SrsSipRequest();
|
||||
public:
|
||||
virtual bool is_register();
|
||||
virtual bool is_invite();
|
||||
virtual bool is_message();
|
||||
virtual bool is_ack();
|
||||
virtual bool is_bye();
|
||||
|
||||
virtual void copy(SrsSipRequest* src);
|
||||
public:
|
||||
virtual std::string get_cmdtype_str();
|
||||
};
|
||||
|
||||
// The gb28181 sip protocol stack.
|
||||
class SrsSipStack
|
||||
{
|
||||
private:
|
||||
// The cached bytes buffer.
|
||||
SrsSimpleStream* buf;
|
||||
public:
|
||||
SrsSipStack();
|
||||
virtual ~SrsSipStack();
|
||||
public:
|
||||
virtual srs_error_t parse_request(SrsSipRequest** preq, const char *recv_msg, int nb_buf);
|
||||
protected:
|
||||
virtual srs_error_t do_parse_request(SrsSipRequest* req, const char *recv_msg);
|
||||
|
||||
public:
|
||||
virtual void resp_status(std::stringstream& ss, SrsSipRequest *req);
|
||||
virtual void resp_keepalive(std::stringstream& ss, SrsSipRequest *req);
|
||||
virtual void resp_ack(std::stringstream& ss, SrsSipRequest *req);
|
||||
|
||||
virtual void req_invite(std::stringstream& ss, SrsSipRequest *req, std::string ip, int port, uint32_t ssrc);
|
||||
virtual void req_bye(std::stringstream& ss, SrsSipRequest *req);
|
||||
virtual void req_401_unauthorized(std::stringstream& ss, SrsSipRequest *req);
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue