设备发现协议SSDP实现

已于 2022-04-07 14:21:07 修改
阅读量2.9k 收藏 8
点赞数 1
分类专栏： Linux 文章标签： linux
于 2022-04-06 12:05:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhouyongku/article/details/123986586
版权
本文探讨了使用UDP进行SSDP（Simple Service Discovery Protocol）时，服务端如何正确设置socket加入239.255.255.250:1900组播，并修复了发送组播消息到239.255.255.250的问题。客户端和服务器端的代码示例及常见错误分析提供了深入理解。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原理：

1.将socket加入239.255.255.250，端口 1900

2.客户端：通过设置setsockopt +IPPROTO_IP,IP_ADD_MEMBERSHIP属性，可向ssdp组进行组播。

3.服务端：通过设置绑定239.255.255.250:1900进行数据接收，通过setsockopt +IPPROTO_IP,IP_ADD_MEMBERSHIP属性 加入组播。

容易错误的地方：

服务端打印sendto成功，但是通过wireshark抓包发现没有组播发送到239.255.255.250

这是因为：sendto的时候，用的sockaddr_in是通过recvfrom得到的：recvfrom得到的是具体的某个从组播拷贝的数据的源ip,这是单播。如果要组播发送，则要发送到这个地址：
    m_cddr.sin_family = AF_INET;
    m_cddr.sin_addr.s_addr = inet_addr("239.255.255.250");
    m_cddr.sin_port = htons(1900);

客户端代码：

/*
Author:zhuoyong
Date:2022-04-07
Mark:人脸识别客户端代码
*/

#ifndef CSSDPCLIENT_H
#define CSSDPCLIENT_H
#include<string>
#include<string.h>
#include<queue>
#include<stdio.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<thread>
#include<chrono>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<net/if.h>
#include<pthread.h>
#include<fcntl.h>
#define ERR printf
#define RTM printf
#define MAXSSDPSIZE 1024

using namespace std;

class CSSDPClient
{
public:
    static  void    Discover();
    //最终加密后的pssword=：md5(<uuid>:<uid>:<pwd>)
    static  void    ModifyNet(string &strUuid,string&strUid,string&strPwd,string &strMask,string&strGateway,string &strDns);
    //strCryptPwd=base64(AES(pwd))
    static  void    ModifyUser(string &strUuid,string&strUid,string&strPwd);
protected:
    CSSDPClient();
    ~CSSDPClient();
    void    SendMsg(const string&str);
    void    RecvMsg();
    void    NotifyOne(const string&str);
    string  MakeSSDHeader();
    string  MakeSearchMsg();
    string  MakeModifyNetMsg();
    string  MakeModifyUserMsg();
    static  CSSDPClient *Ins();
    void    InerDiscover(const string&str);
    void    InitSocket();
private:
    static CSSDPClient *    g_in;
    sockaddr_in             m_sddr ;
    int                     m_ssdps;
    queue<string>           m_que;
    pthread_cond_t          m_cd;
    pthread_mutex_t         m_mt;
};

#endif // CSSDPCLIENT_H

/*
 * ===========================================================================
 *
 *       Filename:  SSDPClient.cpp
 *    Description:  客户端设备发现 xml协议
 *        Version:  1.0
 *        Created:  20220406-12:07
 *       Revision:  none
 *       Compiler:  g++
 *         Author:   (zhouyongku),
 *        Company:  
 *
 * ===========================================================================
 */

#include"SSDPClient.h"



CSSDPClient *CSSDPClient::g_in=NULL;
//全局变量


//解析IP地址
CSSDPClient::CSSDPClient()
{
    m_mt=PTHREAD_MUTEX_INITIALIZER;
    m_cd=PTHREAD_COND_INITIALIZER;

    std::thread t([&]
    {
        InitSocket();
        while(true)
        {

            pthread_mutex_lock(&m_mt); // 拿到互斥锁，进入临界区
            if( m_que.size()<=0 )pthread_cond_wait(&m_cd,&m_mt); // 令线程等待在条件变量上
            pthread_mutex_unlock(&m_mt); // 释放互斥锁

            InerDiscover(m_que.front());

            m_que.pop();

        }


    });
    t.detach();
}

CSSDPClient::~CSSDPClient()
{

}

CSSDPClient *CSSDPClient::Ins()
{
    if( CSSDPClient::g_in == nullptr )
    {
        CSSDPClient::g_in = new CSSDPClient();
    }

    return CSSDPClient::g_in;
}

void CSSDPClient::InerDiscover(const string&str)
{
    SendMsg( str );
    RecvMsg( );
}

void CSSDPClient::InitSocket()
{
    struct timeval TimeOut;
    TimeOut.tv_sec = 1;
    TimeOut.tv_usec = 0;


    m_ssdps=socket(AF_INET,SOCK_DGRAM,0);
    if( m_ssdps < 0)
    {
        ERR("CSSDPClient::InitSocket failed of create socket 239.255.255.250:1900");
        return;
    }

    bzero(&m_sddr, sizeof(m_sddr));
    m_sddr.sin_family = AF_INET;
    m_sddr.sin_addr.s_addr = inet_addr("239.255.255.250");
    m_sddr.sin_port = htons(1900);
    setsockopt(m_ssdps, SOL_SOCKET, SO_RCVTIMEO, (char *)&TimeOut, sizeof(TimeOut));
    ip_mreq mreq;
    bzero(&mreq,sizeof(mreq));
    mreq.imr_multiaddr.s_addr =inet_addr("239.255.255.250");
    mreq.imr_interface.s_addr =htonl(INADDR_ANY);
    if( setsockopt(m_ssdps, IPPROTO_IP,IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) <0 )
    {
        ERR("CSSDPServer::InitSocket failed of setsockopt IP_ADD_MEMBERSHIP");
        return;
    }

//    if( bind(m_ssdps, (struct sockaddr *)&m_sddr, sizeof(m_sddr)) < 0 )
//    {
//        ERR("CSSDPClient::InitSocket failed of bind socket %s:%d",SSDP_MCAST_ADDR,SSDP_PORT);
//    }
}

void CSSDPClient::Discover()
{
    string str=CSSDPClient::Ins()->MakeSearchMsg();
    CSSDPClient::Ins()->NotifyOne(str);

}

void CSSDPClient::ModifyNet(string &strUuid, string &strUid, string &strPwd, string &strMask, string &strGateway, string &strDns)
{
    string str=CSSDPClient::Ins()->MakeModifyNetMsg();
    CSSDPClient::Ins()->NotifyOne(str);
}

void CSSDPClient::ModifyUser(string &strUuid, string &strUid, string &strPwd)
{
    string str=CSSDPClient::Ins()->MakeModifyUserMsg();
    CSSDPClient::Ins()->NotifyOne(str);
}

void CSSDPClient::NotifyOne(const string&str)
{
    RTM("CSSDPClient::NotifyOne quesize=%d",m_que.size());
    pthread_mutex_lock(&m_mt); // 拿到互斥锁，进入临界区
    m_que.push( str );
    pthread_cond_signal(&m_cd); // 通知等待在条件变量上的消费者
    pthread_mutex_unlock(&m_mt); // 释放互斥锁
}

string CSSDPClient::MakeSSDHeader()
{
    string strMsg="M-SEARCH * HTTP/1.1\n";
    strMsg +="HOST: 239.255.255.250:1900\n";
    strMsg +="MAN: \"ssdp:discover\"\n";
    strMsg +="MX: 1\n";
    strMsg +="ST: urn:dial-multiscreen-org:service:dial:1\n";
    strMsg +="USER-AGENT:arm\n";
    return strMsg;
}

string CSSDPClient::MakeSearchMsg()
{

    string strMsg=MakeSSDHeader();
    strMsg +="<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
    strMsg +="<Probe>\n";
        strMsg +="  <Uuid>";
        strMsg += "uuid-test";
        strMsg +="</Uuid>\n";
        strMsg +="  <Types>inquiry</Types>\n";
        strMsg +="  <DeviceType>";
        strMsg += "wodepingban";
        strMsg +="</DeviceType>\n";
    strMsg +="</Probe>";
    return strMsg;
}

string CSSDPClient::MakeModifyNetMsg()
{
    string strMsg=MakeSSDHeader();
    char szMsg[MAXSSDPSIZE]={0};
    sprintf( szMsg,
    "%s\n"
    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
    "<Probe>\n"
    "<Uuid>testuuid</Uuid>\n"
    "<Types>update</Types>\n"
    "<DeviceSN>123456sdflsdfjl1023-1asdfgh</DeviceSN>\n"
    "<method>modifyipdns</method>\n"
    "<MAC>ab-cd-ef-gh-kh</MAC>\n"
    "<IPv4Address>192.168.66.24</IPv4Address>\n"
    "<IPv4SubnetMask>255.255.255.0</IPv4SubnetMask>\n"
    "<IPv4Gateway>192.168.66.254</IPv4Gateway>\n"
    "<IPv6Address>::</IPv6Address>\n"
    "<IPv6Gateway>::</IPv6Gateway>\n"
    "<IPv6MaskLen>64</IPv6MaskLen>\n"
    "<DHCP>false</DHCP>\n"
    "<Password>kFnsMaQrzmGi89g+6txepC1RNnZMSi/fA16x+UdjFOmqBmoVCc/zeZ8X6oZmLBdWaXnvwTxjLIQBsLsDP0xjHw==</Password>\n"
    "</Probe>\n",
    strMsg.c_str());
    return string(szMsg);

}

string CSSDPClient::MakeModifyUserMsg()
{
    string strMsg=MakeSSDHeader();


    char szMsg[MAXSSDPSIZE]={0};
    sprintf( szMsg,
    "%s\n"
     "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
     "<Probe>\n"
     "<Uuid>your uuid>\n"
     "<Types>update</Types>\n"
     "<DeviceSN>your device sn</DeviceSN>\n"
     "<method>modifypassword</method>\n"
     "<newpassword>your new md5 password</newpassword>\n"
     "<Password>your md5 password</Password>\n"
     "</Probe>\n");
    return string(szMsg);
}


//发送ssdp:discover消息
void CSSDPClient::SendMsg(const string&str)
{
    RTM("CSSDPClient::SendMsg msg=%s",str.c_str());

    socklen_t len = sizeof(m_sddr);
    int nRet=sendto(m_ssdps,str.c_str(),str.length(),0,(sockaddr*)&m_sddr,len);
    if( nRet >0 )
    {
        RTM("CSSDPClient::SendMsg leng=%d",nRet);

    }

    char szMsg[MAXSSDPSIZE]={0};
    nRet = recvfrom( m_ssdps,szMsg,MAXSSDPSIZE,0,(sockaddr*)&m_sddr,&len);
    if( nRet >0 )
    {
        RTM("CSSDPClient::SendMsg RECV MSG=%s",szMsg);
    }
}

void CSSDPClient::RecvMsg()
{
    socklen_t len = sizeof(m_sddr);
    char szMsg[MAXSSDPSIZE]={0};
    int num = recvfrom(m_ssdps,szMsg,MAXSSDPSIZE,0,(sockaddr*)&m_sddr,&len);
    if( num >0 )
    {
        string str;
        //ParseMsg(buf);
    }
}

服务端：

#ifndef CSSDPSERVER_H
#define CSSDPSERVER_H
/*
Author:zhuoyong
Date:2022-04-07
Mark:设备发现服务端代码
*/
#include<string>
#include<string.h>
#include<queue>
#include<stdio.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<thread>
#include<chrono>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<net/if.h>
#include<pthread.h>
#include<fcntl.h>
#include<mutex>
#define ERR printf
#define RTM printf
#define MAXSSDPSIZE 1024

using namespace std;


class CSSDPServer
{
public:
    static  void    Init(  );

protected:
    CSSDPServer(  );
    ~CSSDPServer();
    void    SendMsg(const string&str);
    void    RecvMsg();
    string  MakeSSDHeader();
    string  MakeResponseSearchMsg( );
    static  CSSDPServer *Ins();
    void    InitSendSocket();
    void    InitRecvSocket();
    void    ProcesMsg( const char *strMsg );
private:
    static CSSDPServer *    g_in;
    sockaddr_in             m_sddr ;
    sockaddr_in             m_cddr ;
    int                     m_ssdps;
    int                     m_ssdpc;
    queue<string>           m_que;
    pthread_cond_t          m_cd;
    pthread_mutex_t         m_mt;
};

#endif // CSSDPSERVER_H

/*
 * ===========================================================================
 *
 *       Filename:  SSDPServer.cpp
 *    Description:  服务端设备发现 xml协议
 *        Version:  1.0
 *        Created:  20220406-12:07
 *       Revision:  none
 *       Compiler:  g++
 *         Author:   (zhouyongku),
 *        Company:  
 *
 * ===========================================================================
 */


#include"SSDPServer.h"

CSSDPServer *CSSDPServer::g_in=NULL;
//全局变量


//解析IP地址
CSSDPServer::CSSDPServer(  )
{
    m_mt=PTHREAD_MUTEX_INITIALIZER;
    m_cd=PTHREAD_COND_INITIALIZER;
    RTM("CSSDPServer::CSSDPServer");
    std::thread t([&]
    {
        RTM("CSSDPServer::CSSDPServer create thread");
        InitSendSocket();
        InitRecvSocket();
        char szMsg[MAXSSDPSIZE]={0};
        socklen_t len = sizeof(m_sddr);
        while( true )
        {
            if((recvfrom(m_ssdps, szMsg, MAXSSDPSIZE, 0, (sockaddr*)&m_sddr, &len)) >= 0)
            {
                //printf("recvfrom success ip=%s,msg=%s",inet_ntoa(m_sddr.sin_addr),szMsg);

                ProcesMsg( szMsg );
                memset(szMsg,0,sizeof(szMsg));
            }
            std::this_thread::sleep_for(std::chrono::seconds(10));
        }
    });
    t.detach();
}
void CSSDPServer::ProcesMsg( const char *strMsg )
{
    //and your code here




    SendMsg( MakeResponseSearchMsg( ) );


}


CSSDPServer::~CSSDPServer()
{

}

CSSDPServer *CSSDPServer::Ins(  )
{
    if( CSSDPServer::g_in == nullptr )
    {
        CSSDPServer::g_in = new CSSDPServer(  );
    }

    return CSSDPServer::g_in;
}


void CSSDPServer::InitSendSocket()
{
    struct timeval TimeOut;
    TimeOut.tv_sec = 1;
    TimeOut.tv_usec = 0;


    m_ssdpc=socket(AF_INET,SOCK_DGRAM,0);
    if( m_ssdpc < 0)
    {
        ERR("CSSDPClient::InitSocket failed of create socket 239.255.255.250:1900");
        return;
    }

    bzero(&m_cddr, sizeof(m_cddr));
    m_cddr.sin_family = AF_INET;
    m_cddr.sin_addr.s_addr = inet_addr("239.255.255.250");
    m_cddr.sin_port = htons(1900);
    setsockopt(m_ssdpc, SOL_SOCKET, SO_RCVTIMEO, (char *)&TimeOut, sizeof(TimeOut));
    ip_mreq mreq;
    bzero(&mreq,sizeof(mreq));
    mreq.imr_multiaddr.s_addr =inet_addr("239.255.255.250");
    mreq.imr_interface.s_addr =htonl(INADDR_ANY);
    if( setsockopt(m_ssdpc, IPPROTO_IP,IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) <0 )
    {
        ERR("CSSDPServer::InitSocket failed of setsockopt IP_ADD_MEMBERSHIP");
        return;
    }
}

void CSSDPServer::InitRecvSocket()
{
    RTM("CSSDPServer::InitRecvSocket");
    struct timeval TimeOut;
    TimeOut.tv_sec = 1;
    TimeOut.tv_usec = 0;

    m_ssdps=socket(AF_INET,SOCK_DGRAM,0);
    if( m_ssdps < 0)
    {
        ERR("CSSDPServer::InitSocket failed of create socket 239.255.255.250:1900");
        return;
    }

    bzero(&m_sddr, sizeof(m_sddr));
    m_sddr.sin_family = AF_INET;
    m_sddr.sin_addr.s_addr = INADDR_ANY;
    m_sddr.sin_port = htons(1900);

    if( bind(m_ssdps, (struct sockaddr *)&m_sddr, sizeof(m_sddr)) < 0 )
    {
        ERR("CSSDPServer::InitSocket failed of bind socket 0.0.0.0:1900");
        return ;
    }
    ip_mreq mreq;
    bzero(&mreq,sizeof(mreq));
    mreq.imr_multiaddr.s_addr =inet_addr("239.255.255.250");
    mreq.imr_interface.s_addr =htonl(INADDR_ANY);
    if( setsockopt(m_ssdps, IPPROTO_IP,IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) <0 )
    {
        ERR("CSSDPServer::InitSocket failed of setsockopt IP_ADD_MEMBERSHIP");
        return;
    }
    RTM("CSSDPServer::InitRecvSocket success");

}

void CSSDPServer::Init( )
{
    CSSDPServer::Ins(  );
}


string CSSDPServer::MakeSSDHeader()
{
    string strMsg="NOTIFY * HTTP/1.1\n"
            "HOST: 239.255.255.250:1900\n"
            "CACHE-CONTROL: max-age=66\n"
            "LOCATION:xml\n"
            "OPT:ns=01\n"
            "01-NLS:0\n"
            "NT: urn:schemas-upnp-org:service:AVTransport:1\n"
            "NTS: ssdp:alive\n"
            "SERVER: Ubuntu/16.04\n"
            "X-User-Agent: redsonic\n"
            "USN:1\n";
    return strMsg;
}


string CSSDPServer::MakeResponseSearchMsg()
{

    string strMsg=MakeSSDHeader();

    char szMsg[MAXSSDPSIZE]={0};

        snprintf( szMsg,MAXSSDPSIZE,
                  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                  "<ProbeMatch>\n"
                  "<mount>your msg</mount>\n"
                  "<enable>your msg</enable>\n"
                  "<platformip>%s</platformip>\n"
                  "<Uuid>your msg</Uuid>\n"
                  "<Types>inquiry</Types>\n"
                  "<DeviceType>CDZSFACEBOX</DeviceType>\n"
                  "<DeviceSN>your msg</DeviceSN>\n"
                  "<DeviceName>your msg</DeviceName>\n"
                  "<MAC>your msg</MAC>\n"
                  "<IPv4Address>your msg</IPv4Address>\n"
                  "<IPv4SubnetMask>your msg</IPv4SubnetMask>\n"
                  "<IPv4Gateway>your msg</IPv4Gateway>\n"
                  "<IPv6Address>::</IPv6Address>\n"
                  "<IPv6Gateway>::</IPv6Gateway>\n"
                  "<IPv6MaskLen>64</IPv6MaskLen>\n"
                  "<DHCP>::</DHCP>\n"
                  "<SoftwareVersion>your msg</SoftwareVersion>\n"
                  "<BootTime>your msg</BootTime>\n"
                  "<Diskrate>your msg</Diskrate >\n"
                  "<Cpurate>your msg</Cpurate >\n"
                  "<Memoryrate>%s</Memoryrate >\n"
                  "</ProbeMatch>");


    strMsg += szMsg;
    return strMsg;
}


//发送ssdp:discover消息
void CSSDPServer::SendMsg(const string&str)
{
    RTM("CSSDPServer::SendMsg msg=%s",str.c_str());

    socklen_t len = sizeof(m_cddr);
    int nLen = sendto(m_ssdps,str.c_str(),str.length(),0,(sockaddr*)&m_cddr,len);
    if( nLen >0 )
    {
        RTM("CSSDPServer::SendMsg success to send to %s msg len=%d",inet_ntoa(m_cddr.sin_addr),nLen);
    }
    else
    {
        RTM("CSSDPServer::SendMsg failed to send msg");
    }
}

void CSSDPServer::RecvMsg()
{
    socklen_t len = sizeof(m_sddr);
    char szMsg[MAXSSDPSIZE]={0};
    int num = recvfrom(m_ssdps,szMsg,MAXSSDPSIZE,0,(sockaddr*)&m_sddr,&len);
    if( num >0 )
    {
        string str;
        //ParseMsg(buf);
    }
}

测试代码：

#include<SSDPClient.h>

int main(int argc, char *argv[])
{
    while( true )
    {
        CSSDPClient::Discover();
        std::this_thread::sleep_for( std::chrono::seconds(10) );
    }

    return 0;
}


#include"SSDPServer.h"
int main(int argc, char *argv[])
{

    CSSDPServer::Init( );


    std::this_thread::sleep_for( std::chrono::seconds(100000) );

    return 0;
}

抓包：

发送方：ssdpclient 192.168.66.44 发送 search命令

接收方 ssdpserv (我在同一个电脑上测试 ip都是192.168.66.44)

SSDP协议
zhanshenggaoyang的专栏
09-24 1997
SSDP是一个“简单服务发现协议” ，即英文“Simple Service Discovery Protocol的缩写” , 该协议定义了如何在网络上发现网络服务的方法。SSDP也规定了存放在XML文件中的信息格式。SSDP信息的传送是依靠HTTPU和HTTPMU进行的。不论是控
SSDP 简单服务发现协议
热门推荐
lilypp的专栏
07-26 4万+
【参考】http://www.cnblogs.com/debin/archive/2009/12/01/1614543.html
node-ssdp:NodeJS的简单服务发现协议的异步实现
05-23
节点SSDP 一个异步/ AWAIT执行在S imple小号ervice d iscovery P代表的NodeJS rotocol的。 动机 创建最小，干净和异步的实现。 那里的大多数类似项目都是未维护的，并且基于回调。 请参阅 ，以获取更完整和维护的解决方案。 安装 使用npm i --save homelify/node-ssdp直接从Github安装npm i --save homelify/node-ssdp 用法 搜索 执行m-search并从解析为javascript对象的设备返回消息。 （请参阅 ） const SSDP = require('@homelify/node-ssdp'); const message = await SSDP.mSearch({ serviceType });
基于ONVIF协议的（IPC）客户端程序开发-7：设备搜索
Jayson 博客
02-06 3957
1 前言 要访问一个IPC摄像头，或者说要调用IPC摄像头提供的WEB服务接口，就要先知道其IP地址，这就是「设备发现」的过程，或者叫「设备搜索」的过程。ONVIF规范并没有自己定义服务发现框架，而是复用了已经很成熟的WS-Discovery标准，WS-Discovery 协议使得服务能够被客户端发现。我们先了解下什么是WS-Discovery。 2 WS-Discovery原理
swift-基于DLNA实现iOS投屏SSDP发现设备及SOAP控制设备
08-15
基于DLNA实现iOS投屏，SSDP发现设备及SOAP控制设备
嵌入式开发 之设备发现SSDP(lssdp实现)
chinastand的专栏
05-22 1403
1.提出需求   嵌入式设备开发过程中往往需要使用telnet或者ssh进行登陆调试，设备发布之后也需要再局域网内进行设备管理。此时就需要再局域网下搜索设备。 2.解决问题 2.1 串口   串口时最简单有效的方式，ifconfig查看IP地址即可，但千里马常有，串口不常有。 2.2 组播广播   设备绑定一个广播端口，等待广播包，缺点是协议不统一，需要自己制定协议编写代码。稳定性得不到保障 2.3 使用通用协议   SSDP协议是现有协议中比较简单并且大范围使用的协议，uPnP和DLNA协议族都使用了SS
C语言典型代码---SSDP设备发现
小人物的编程
09-15 2666
搜罗了网上好多代码，要不是不完整，要不是功能复杂，要么就是有bug，so参考各个代码，修改出这个版本。
SSDP，简单服务发现技术
weixin_30508241的博客
12-01 1888
SSDP:Simple Sever Discovery Protocol,简单服务发现协议，此协议为网络客户提供一种无需任何配置、管理和维护网络设备服务的机制。此协议采用基于通知和发现路由的多播发现方式实现。协议客户端在保留的多播地址：239.255.255.250：1900（IPV4）发现服务，（IPv6 是：FF0x::C）同时每个设备服务也在此地址上上监听服务发现请求。如果服务监听到的发现请...
SSDP设备发现的大致流程
uuxia的专栏
11-28 1万+
前言：之前有专文介绍了minidlna中的UPNP功能，内中介绍其中包含的SSDP（简单发现协议），SOAP（简单对象访问协议）等几个协议（http://blog.csdn.net/sakaue/article/details/19070735）。本文将根据minidlna的程序流程，概述SSDP的流程，为下一部分ACE实现做铺垫。设备发现的大致流程：首先，根据UPNP的规范： 在设备加入网络，
SSDP-Search:简单服务发现协议的Java实现
05-12
轻量级的Java存储库，它允许使用概述的简单服务发现协议（SSDP）在局域网上发现硬件设备。 特征： 创建格式化的SSDP搜索请求 将SSDP搜索请求发送到网络上的设备 解析任何收到的响应 安装 用法 执照 该软件已获得MIT...
ssdp协议c语言实现
04-21
ssdp协议c语言实现。多线程异步实现接收/发送notify消息，设备缓存过期尚未实现。
c实现ssdp协议
08-29
C语言实现SSDP协议
ssdp协议搜索GB28181设备
qianbo042311的博客
08-02 1608
ssdp协议近似于http协议，事实上，和http协议相似得地方就是他得协议内容，当然，我们要去除他得端口和d类地址。为什么我在给其他员工或者面试得时候要他人深入一些，理解一下http协议，是因为理解了http协议，掌握ssdp也就不远了，很多人可能会问http协议有啥内容，无非就是get，post，put，delete么，还能怎么样，我经常问他们一点http协议怎么知道他结束了？虽然ssdp是udp协议，但是他依然需要\r\n来代表行结束，\r\n\r\n代表协议内容部分结束。......
SSDP协议内容解析
zhu530548851的专栏
06-05 1万+
SSDP协议内容解析
SSDP 协议
junco007的专栏
10-28 6745
1.组播地址 2.SSDP，简单服务发现技术 组播地址 为了让组播源和组播组成员进行通信，需要提供网络层组播地址，即IP组播地址。同时必须存在一种技术将IP组播地址映射为链路层的组播MAC地址。 1. IP组播地址 (1)        IPv4组播地址 IANA（Internet Assigned Numbers Authority，互联网编号分配委员会）将D类地址空间分配给IP
使用WiFi热点抓包产生的SSDP流量分析
weixin_30505485的博客
03-11 725
抓包时经常会看到SSDP流量，这个流量应该是因为使用WiFi热点抓包产生的。而不是APP所产生的流量。同样一个app使用WiFi热点与不使用WiFi热点抓取的流量情况。 按照SSDP协议的规定，当一个控制点（客户端）接入网络的时候，它可以向一个特定的多播地址的SSDP端口使用M-SEARCH方法发送“ssdp:discover”消息。当设备监听到这个保留的多播地址上...
海康威视设备发现sdp原理
zhouyongku的专栏
08-02 4761
首先，sdp是向239.255.255.250:1900发送udp消息以达到局域网广播目的，海康的sdp并没有像标准的ssdp那样包含:M-SEARCH,NOTIFY等关键字，而是采用自定义的xml字符串作为其私有协议。 我用wireshark抓包得出： 通过海康sdp客户端工具，点击刷新： 客户端发送广播 <?xml version="1.0" encoding="utf-8"?> <Probe><Uuid>A3DD39B4-DA2E-4547-9C6C-484
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值