sip/SipServer.h

#ifndef __SIPSERVER_H__
#define __SIPSERVER_H__

extern "C" {
#include <osip2/osip_mt.h>
#include <eXosip2/eXosip.h>
}

#include <map>
#include <string>
#include <thread>
#include <chrono>
#include <mutex>
#include <tuple>

#include "./Message/GBXmlParser.h"
#include "sip_header.h"

using namespace std;

enum DeviceType {
    DEVICE_TYPE_UNKNOWN,
    DEVICE_TYPE_IPC,
    DEVICE_TYPE_NVR,
    DEVICE_TYPE_PLATFORM
};

class Client {
public:
    Client(string ip, int port, string device) :
            mIp(ip), mPort(port),  mDevice(device) 
    {
        mRtpPort = 0;
        mIsReg = false;
        mType = DEVICE_TYPE_UNKNOWN;
    }

    ~Client() = default;
public:

    void setRtpPort(int rtpPort) {
        mRtpPort = rtpPort;
    }

    void setReg(bool isReg) {
        mIsReg = isReg;
    }
    string  getDevice() const{
        return mDevice;
    }
    string  getIp() const{
        return mIp;
    }
    int getPort() const{
        return mPort;
    }

    unsigned long getHeartBeat() {
        return mHeartBeatTime;
    }

    void updateHeartBeat(unsigned long ts) {
        mHeartBeatTime = ts;
        mHeartBeatCount++;
        if (mHeartBeatFirst <= 0){
            mHeartBeatFirst = ts;
        }
    }

    unsigned long getHeartBeatGap() {
        if (mHeartBeatCount >= 2)
        {
           return (mHeartBeatTime - mHeartBeatFirst)/mHeartBeatCount ;
        }
        return 0;
    }

    long getExpiry() {
        return mExipry;
    }

    void setExpiry(long expiry) {
        mExipry = expiry;
    }

    DeviceType getDeviceType() {
        return mType;
    }

    void setDeviceType(DeviceType type) {
        mType = type;
    }

private:
    string mIp; // client ip
    int mPort; // client port
    string mDevice;// 340200000013200000024
    bool mIsReg;
    int mRtpPort;
    unsigned long mHeartBeatTime{0};
    unsigned long mHeartBeatFirst{0};
    unsigned long mHeartBeatGap{1};
    unsigned long mHeartBeatCount{0};
    long mExipry{0};
    DeviceType mType;
};


class WebSocketServer;

class SipServer {
public:
    SipServer();
    ~SipServer();

    bool Init(ServerInfo* pInfo, WebSocketServer* pServer);

    /*
    GB28181流传输几种模式
        UDP:服务端监听UDP端口，通过INVITE信令告知设备端口，设备主动向服务端发起流传输
        TCP被动:服务端监听TCP端口，通过INVITE信令告知设备端口，设备向服务端发起流传输
        TCP主动:设备端告知服务端监听的TCP端口情况，服务端主动向设备拉流，此种场景较少，且设备所在网络可以被服务所在网络访问（如下级设备与上级GB28181服务在同一个局域网，或者都在公网上能相互访问）。
     */

    int RequestInvite_UDP(const char* dst_channel, const char* rtpIp, int rtpPort);

    int RequestInvite_TCP_p(const char* dst_channel, const char* rtpIp, int rtpPort);

    int ByeInvite(std::string channel_id, string ip, int rtpPort);

    void Close();

    void RemoveInviteTask(tuple<std::string, std::string, int>);

public:
    void event_loop();

private:
    int init_sip_server();
    int sip_event_handle(eXosip_event_t *evtp);

    void RequestCatalog(Client* client);

    void RequestDeviceInfo(Client* client);

    void cacheClient(osip_uri_t *url, int expiry);

    void response_message_answer(eXosip_event_t *evtp,int code);
    void response_register(eXosip_event_t *evtp);
    void response_register_noauth(eXosip_event_t *evtp);
    void response_register_401unauthorized(eXosip_event_t *evt);
    void response_message(eXosip_event_t *evtp);
    void response_invite_ack(eXosip_event_t *evtp);
    int request_bye(eXosip_event_t* evtp);// 通知相机停止推流
    int parse_xml(const char* data, const char* s_mark, bool with_s_make, const char* e_mark, bool with_e_make, char* dest);
    void dump_request(eXosip_event_t *evtp);
    void dump_response(eXosip_event_t *evtp);

    int clearClientMap();
    void deleteClientByDevice(string device);

    Client* get_parent_by_id(string id);
    bool check_device_status(string id);

    void cache_invite_callinfo(eXosip_event_t *evtp);

    int reInvite(int cid);

    int check_device_type(string sip_id);

    int invite_UDP_nolock(const char* dst_channel, const char* rtpIp, int rtpPort);

    int invite_TCP_p_nolock(const char* dst_channel, const char* rtpIp, int rtpPort);

private:
    bool mQuit{ false };
    eXosip_t *mSipCtx;
    ServerInfo mInfo;

    std::map<std::string, Client *> mClientMap;// <DeviceID,SipClient>
    mutex m_client_map_mtx;
    std::map<std::string, DeviceInfo> m_device_map;
    mutex m_device_map_mtx;

    thread* m_event_loop_thread{nullptr};

    mutex m_invite_callinfo_map_mtx;
    std::map< tuple<std::string, std::string, int>, CallInfo> m_invite_callinfo_map;
    mutex m_invite_cmd_map_mtx;
    std::map< tuple<std::string, std::string, int>, string> m_invite_cmd_map;

    WebSocketServer* m_pWsServer;
};


#endif //__SIPSERVER_H__