searchip 协议，IPC局域网搜索设备并修改ip

这个需要协议去对接

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35424&ptid=12182]csuzhsh 发表于 2016-8-4 08:03[/url]
这个需要协议去对接[/quote]

知道这个协议吗？我看这么多工具有，协议应该标准化了

没有标准化

建议你通过抓包工具，搜索时，抓取发出的包，然后，再抓取得到的包，让咱们的arm设备也按照这个包交互即可。



///////////你把工具发上来，我看看。

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35453&ptid=12182]ngswfx 发表于 2016-8-4 12:01[/url]
建议你通过抓包工具，搜索时，抓取发出的包，然后，再抓取得到的包，让咱们的arm设备也按照这个包交互即可 ...[/quote]

ipc助手，

http://www.d9soft.com/soft/115393.htm

http://www.pc6.com/softview/SoftView_215549.html  很多这样的软件。

1.批量修改网内

IPC 的 IP 地址，批量修改IP时 IPC  的用户名和密码必须输入正确，否则修改不成功。批量修改时，IPC 和 和 PC  可以不在同一网段。

2.开启/关闭报警输出

3.校时及其他功能

更多功能请参考pdf使用说明

本帖最后由 ngswfx 于 2016-8-4 17:27 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35512&ptid=12182]hik.leo 发表于 2016-8-4 17:10[/url]
ipc助手，

[url]http://www.d9soft.com/soft/115393.htm[/url]
[/quote]

按照我对这个东西的理解，如果不是通用协议，自己配合别人软件写linux服务端，难度会比2边都自己写要难一些。而且限制不少。


/////////这个程序完全就是私有协议，HK XM HB ZW TST ，我这里好多厂家的IPC，哪个它也搜索不到。看来完全私有的，配合它没有意义。


这类私有化的工具软件我自己的设备也有.

//你从网上搜一个类似广播方式收发的代码，自己写2个程序即可，一个arm服务端，一个是PC广播命令发送端，发送完命令后，在建立的socket上，接收过来的数据包即可。

///////////部分服务器端代码
[code]void* TvWallBroadCastServerInfThread(void* id)
{
        char                   strIp[32];
        memset(strIp,0,sizeof strIp);
        if(!IVComInf_GetLocalIPAddress(strIp))
                sprintf(strIp,"%s",tvWallServer.strTVWallServerIP);
        DebugInfEx(DBG_LEVEL1,"TvWallBroadCastServerInfThread 1 strIp:%s\n",strIp);
        int                                                    nSize = sizeof(sockaddr_in) ;
        //自动搜索HB_DVR
        sockaddr_in                   localAddr;
        BOOL                                          fBroadcast = TRUE;
        int                                                  err = -1;
        sockaddr_in            remoteAddr;
        timeval                                tv = {2, 500*1000} ;        // wait for 1s
        fd_set                                         read ;
        ULONGLONG      nBroadCastTimer=0;        //alive
        DebugInfEx(DBG_LEVEL1,"TvWallBroadCastServerInfThread 6 port:%d\n",IVPT_BROADCAST_TVWALLSERVER_PORT);
        bStartTvWallBroadCastServerInfThread=true;
        while(bStartTvWallBroadCastServerInfThread){
                usleep(1000);
                if(nCurNetLinkState!=1){
                                printf("TvWallBroadCastServerInfThread ___***____NetLink Off,wait 1 S \n");
                                usleep(1000000);//网络不通，等待1秒
                                continue;
                }
                nTvWallBroadCastServerInfThreadTimer=GetTickCount();
                if(hSocklBroadCastRecv == INVALID_SOCKET){
                        hSocklBroadCastRecv = socket(AF_INET, SOCK_DGRAM, 0);
                                if (hSocklBroadCastRecv == INVALID_SOCKET){
                                        //        DebugInfEx(DBG_LEVEL2,"TvWallBroadCastServerInfThread 3\n");
                                        usleep(3000000); //等待3秒
                                        continue;
                                }
                                //DebugInfEx(DBG_LEVEL2,"TvWallBroadCastServerInfThread 2\n");
                                err = setsockopt(hSocklBroadCastRecv, SOL_SOCKET, SO_BROADCAST/*SO_REUSEADDR*/, (char *)&fBroadcast, sizeof(BOOL)) ;
                                if (err == SOCKET_ERROR)  {
                                        if(hSocklBroadCastRecv&&hSocklBroadCastRecv!=INVALID_SOCKET)
                                                close(hSocklBroadCastRecv);
                                        hSocklBroadCastRecv = INVALID_SOCKET ;
                                        continue;
                                }
                                int opt = 1;
                                setsockopt(hSocklBroadCastRecv,SOL_SOCKET,SO_REUSEADDR,(void*)&opt,sizeof(opt));
                                DebugInfEx(DBG_LEVEL1,"TvWallBroadCastServerInfThread 4\n");
                                localAddr.sin_family = AF_INET;
                                localAddr.sin_addr.s_addr =INADDR_ANY;
                                localAddr.sin_port = htons(IVPT_BROADCAST_TVWALLSERVER_PORT);
                                err = bind(hSocklBroadCastRecv, (sockaddr *)&localAddr, sizeof(sockaddr_in)) ;
                                if (err == SOCKET_ERROR)  {
                                        if(hSocklBroadCastRecv&&hSocklBroadCastRecv!=INVALID_SOCKET)
                                                close(hSocklBroadCastRecv);
                                        hSocklBroadCastRecv = INVALID_SOCKET ;
                                        //DebugInfEx(DBG_LEVEL2,"TvWallBroadCastServerInfThread 5\n");
                                        continue;
                                }
                }
                if((GetTickCount()-nBroadCastTimer)>1800000)//半个小时纪录一次
                {
                        DebugInfEx(DBG_LEVEL2,"TvWallBroadCastS ok! HANDLE:%d\n",hSocklBroadCastRecv);
                        nBroadCastTimer=GetTickCount();
                }
                //DebugInfEx(DBG_LEVEL2,"TvWallBroadCastServerInfThread x\n");
                nTvWallBroadCastServerInfThreadTimer=GetTickCount();
                FD_ZERO(&read);
                FD_SET(hSocklBroadCastRecv, &read);
                err = ::select(hSocklBroadCastRecv+1, &read, NULL, NULL, &tv) ;
                //返回值0 // printf("time out!\n");
                if (err == (-1))  { // -1 printf("select error!\n");
                        if(hSocklBroadCastRecv&&hSocklBroadCastRecv!=INVALID_SOCKET)
                                close(hSocklBroadCastRecv);
                        hSocklBroadCastRecv = INVALID_SOCKET ;
                        continue;
                }
                if (err > 0)  {//其他值允许接收
                        int            Buf[512];
                //        DebugInfEx(DBG_LEVEL2,"TvWallBroadCastServerInfThread 7\n");
                        memset(Buf,0,sizeof(Buf));
                        err = recvfrom(hSocklBroadCastRecv, (char *)Buf, sizeof(Buf), 0, (sockaddr*)&remoteAddr, (socklen_t*)&nSize) ;
                        if(err==-1){
                                if(hSocklBroadCastRecv&&hSocklBroadCastRecv!=INVALID_SOCKET)
                                        close(hSocklBroadCastRecv);
                                hSocklBroadCastRecv = INVALID_SOCKET ;
                                //DebugInfEx(DBG_LEVEL2,"TvWallBroadCastServerInfThread 5\n");
                                continue;
                        }
                        if((err==sizeof(Buf))&&(Buf[24] == IVPT_BROADCAST_REQUEST_ID)){
                                memset(Buf,0,sizeof(Buf));
                                memcpy(Buf, nfhead_TvWallServer, IVPT_BROADCAST_CHAR_LEN);
                                Buf[19] =        IVPT_BROADCAST_SENDBACK_ID;
                                Buf[20]        =        tvWallServer.nTvSetNum;
                                Buf[21]        =        nMax_Wnd_DevideNum;
                                Buf[22]        =        tvWallServer.dwSrvPort;
                                memcpy(Buf+42,strSN,16);
                        //        DebugInfEx(DBG_LEVEL1,"TvWallBroadCastServerInfThread 8 strIp:%s,strSN:%s socket:%d\n",strIp,strSN,hSocklBroadCastRecv);
                                memcpy(Buf+25,strIp,sizeof(strIp));//255.255.255.255
                                for(int m=0;m<3;m++){
                                        err = sendto(hSocklBroadCastRecv, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in)) ;
                                        Sleep(30);
                                }
                        }
                }
        }
        if(hSocklBroadCastRecv&&hSocklBroadCastRecv!=INVALID_SOCKET)
                close(hSocklBroadCastRecv) ;
        hSocklBroadCastRecv = INVALID_SOCKET ;
        pthread_exit(NULL);
        return NULL;
}[/code]

本帖最后由 ngswfx 于 2016-8-4 17:36 编辑

//arm搜索命令代码，PC端类似

[code]
void *ReceiveBroadcastMsg3(LPVOID dwUser)
{
        bSearching=true;
        if (hSocketCast3 == INVALID_SOCKET)
        {
                bSearching=false;
                return 0;
        }
        printf("ReceiveBroadcastMsg3 in \n");
        int            err=0;
        int                         nSize = sizeof(sockaddr_in) ;
        char                   strIp[32];
        char                   _strSN[48];
        int                           nPort=0;
        int                   Buf[1024];
        char                   str[MAX_PATH];
        char                   Header[IVPT_BROADCAST_CHAR_LEN];
        int                           _nTvSetNum=0;
        int                           i=0;
        bool                   bfound=false;
        sockaddr_in    localAddr;
        BOOL           fBroadcast = TRUE;
        sockaddr_in    remoteAddr;
        memset(strIp,0,sizeof strIp);
        memset(Buf,0,sizeof Buf);
        memset(str,0,sizeof str);
        memset(_strSN,0,sizeof _strSN);
        //500ms都找不到的DVR，找到也没用 500ms
        timeval        tv = {1, 500000} ;        // wait for 1s
        fd_set         read;
        printf("ReceiveBroadcastMsg3 start run \n");
        while(1) {
                Sleep(1);
                if((GetTickCount()-nBeginScanTimer3)>nScanTimer3)
                        break;
                FD_ZERO(&read);
                FD_SET(hSocketCast3, &read);
                err = ::select(hSocketCast3+1, &read, NULL, NULL, &tv);
                if (err > 0){
                        err = recvfrom(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr*)&remoteAddr,(socklen_t*)&nSize);
                        //状态
                        snprintf(str,sizeof str,"Get brocast msg：%d ID:%d(%d)\n",err,IVPT_BROADCAST_SENDBACK_ID,Buf[19]);
                        //printf(str);
                        if(SearchPtDeviceEx)
                                SearchPtDeviceEx(-1,str,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
                        if(_searchPTDeviceOutEx)
                                _searchPTDeviceOutEx(NULL,NULL,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
                        //发回的信息
                        if (err > 0 && Buf[19]==IVPT_BROADCAST_SENDBACK_ID){
                                memset(strIp,0,sizeof strIp);
                                memcpy(strIp,Buf+25,sizeof(strIp));//IP地址
                                memcpy(_strSN,Buf+42,16);
                                nPort=Buf[22];//端口
                                //printf("nSearchPercent:%d strIp:%s _strSN:%s\n",nSearchPercent,strIp,_strSN);
                                memcpy(Header,Buf,IVPT_BROADCAST_CHAR_LEN);
                                if(strncmp((char *)Buf, nfhead_TvWallServer,IVPT_BROADCAST_CHAR_LEN) == 0){//电视墙服务器
                                        int nTotalTVSet=Buf[20];//显示设备个数
                                        int nMaxDevideNum=Buf[21];//最大分割数
                                        IVPT_TV_WALL_SERVER serverPara;
                                        memset(&serverPara,0,sizeof (IVPT_TV_WALL_SERVER));
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        snprintf(serverPara.strSN,16,"%s",_strSN);
                                        serverPara.nServerType=NET_DEVICE_TV_WALL_SERVER;
                                        serverPara.nPort=nPort;
                                        serverPara.nTvSetNum=nTotalTVSet;
                                        serverPara.nMaxDevideNum=nMaxDevideNum;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_TV_WALL_SERVER,strIp,nPort,(char *)&serverPara,sizeof (IVPT_TV_WALL_SERVER),nSearchPercent,lpUserPTDeviceHandle);
                                        if(_searchPTDeviceOutEx)_searchPTDeviceOutEx(NET_DEVICE_TV_WALL_SERVER,strIp,nPort,(char *)&serverPara,sizeof (IVPT_TV_WALL_SERVER),nSearchPercent,lpUserPTDeviceHandle);
                                }else if(strncmp((char *)Buf, nfhead_RecordServer,IVPT_BROADCAST_CHAR_LEN) == 0){//存储服务器
#if 0
                                        IVPT_RECORD_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_RECORD_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_RECORD_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_RECORD_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_RECORD_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }else if(strncmp((char *)Buf, nfhead_UserServer,IVPT_BROADCAST_CHAR_LEN) == 0){//用户验证服务器
#if 0
                                        IVPT_USER_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_USER_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_USER_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_USER_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_USER_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }else if(strncmp((char *)Buf, nfhead_StreamServer,IVPT_BROADCAST_CHAR_LEN) == 0){//流媒体服务器
#if 0
                                        IVPT_STREAM_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_STREAM_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_STREAM_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_STREAM_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_STREAM_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }else if(strncmp((char *)Buf, nfhead_StateServer,IVPT_BROADCAST_CHAR_LEN) == 0){//状态获取服务器
#if 0
                                        IVPT_STATE_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_STATE_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_STATE_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_STATE_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_STATE_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }else if(strncmp((char *)Buf, nfhead_NtpServer,IVPT_BROADCAST_CHAR_LEN) == 0){//时间服务器
#if 0
                                        IVPT_NTP_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_NTP_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_NTP_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_NTP_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_NTP_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }else if(strncmp((char *)Buf, nfhead_AlarmServer,IVPT_BROADCAST_CHAR_LEN) == 0){//报警服务器
#if 0
                                        IVPT_ALARM_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_ALARM_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_ALARM_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_ALARM_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_ALARM_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }else if(strncmp((char *)Buf, nfhead_SmartServer,IVPT_BROADCAST_CHAR_LEN) == 0){//智能分析服务器
#if 0
                                        IVPT_SMART_SERVER serverPara;
                                        memset(&serverPara,0,sizeof IVPT_SMART_SERVER);
                                        snprintf(serverPara.strServerIP,sizeof serverPara.strServerIP,"%s",strIp);
                                        serverPara.nServerType=NET_DEVICE_SMART_SERVER;
                                        serverPara.nPort=nPort;
                                        if(SearchPtDeviceEx)SearchPtDeviceEx(NET_DEVICE_SMART_SERVER,strIp,nPort,(char *)&serverPara,sizeof IVPT_SMART_SERVER,nSearchPercent,lpUserPTDeviceHandle);
#endif
                                }
                        }
                }
        }
        nSearchPercent=100;
        if(SearchPtDeviceEx)SearchPtDeviceEx(NULL,NULL,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
        if(_searchPTDeviceOutEx)
                _searchPTDeviceOutEx(NULL,NULL,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
        _searchPTDeviceOutEx=NULL;
        close(hSocketCast3);
        hSocketCast3=INVALID_SOCKET;
        printf("ReceiveBroadcastMsg3 finished___________\n");
        bSearching=false;
        return 0;
}
int     _SearchPtDeviceEx(searchPTDevice _searchPTDevice,long lpUser)
{
        if(_searchPTDevice){
                _searchPTDeviceOutEx=_searchPTDevice;
                if(lpUser)
                        lpUserPTDeviceHandle=lpUser;
                if(!bSearching)
                        _SearchPtDevice();
        }else _searchPTDeviceOutEx=NULL;
        return true;
}
void _SearchPtDevice()
{
        if(bSearching){
                if(_searchPTDeviceOutEx)
                        _searchPTDeviceOutEx(NULL,NULL,0,NULL,0,100,lpUserPTDeviceHandle);
                _searchPTDeviceOutEx=NULL;
                return;
        }
        nSearchPercent=0;
        if(_searchPTDeviceOutEx)_searchPTDeviceOutEx(NULL,NULL,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
        //关闭自动搜索
        if(hSendThreadCast){
                pthread_cancel(hSendThreadCast);
                hSendThreadCast=NULL;
        }
        if(hThreadCast3){
                pthread_cancel(hThreadCast3);
                hThreadCast3=NULL;
        }
        if(hSocketCast3!=INVALID_SOCKET){
                close(hSocketCast3);
                hSocketCast3=INVALID_SOCKET;
        }
        BOOL          fBroadcast = TRUE ;
        int           err = -1 ;
        if(hSocketCast3==INVALID_SOCKET){//如果么有就新建一个
                hSocketCast3 = socket(AF_INET, SOCK_DGRAM, 0) ;
                if (hSocketCast3 == INVALID_SOCKET){
                        if(_searchPTDeviceOutEx)_searchPTDeviceOutEx(NULL,NULL,0,NULL,0,100,lpUserPTDeviceHandle);
                        _searchPTDeviceOutEx=NULL;
                        return;
                }
                err = setsockopt(hSocketCast3, SOL_SOCKET, SO_BROADCAST, (char *)&fBroadcast, sizeof(BOOL)) ;
                if (err == SOCKET_ERROR)  {
                        close(hSocketCast3) ;
                        hSocketCast3=INVALID_SOCKET;
                        if(_searchPTDeviceOutEx)_searchPTDeviceOutEx(NULL,NULL,0,NULL,0,100,lpUserPTDeviceHandle);
                        _searchPTDeviceOutEx=NULL;
                        return;
                }
        }
        printf("_SearchPtDevice hSocketCast3:%d \n",hSocketCast3);
        nBeginScanTimer3=GetTickCount();
        int ret =0;
        pthread_attr_t attr;
        ret = pthread_attr_init(&attr);
        pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
        ret = pthread_attr_setstacksize(&attr, 1024*1024);//thread 堆栈设置为20K，stacksize以字节为单位
        if(!hThreadCast3)
                pthread_create(&hThreadCast3,&attr,ReceiveBroadcastMsg3,NULL);
        ret = pthread_attr_setstacksize(&attr, 1024*1024);//thread 堆栈设置为20K，stacksize以字节为单位
        if(!hSendThreadCast)
                pthread_create(&hSendThreadCast,&attr,SendBroadcastMsg,NULL);
        pthread_attr_destroy(&attr);
        if(_searchPTDeviceOutEx)_searchPTDeviceOutEx(NULL,NULL,0,NULL,0,5,lpUserPTDeviceHandle);
}
extern bool AddDecUnitListToLinkClass();
void* SendBroadcastMsg(LPVOID dwUser)
{
        if(hSocketCast3==INVALID_SOCKET)
                return 0;
        int           err = -1 ;
        //发出侦测所有
        int         Buf[1024] ;
        memset(Buf,0,sizeof(Buf));
        sockaddr_in   remoteAddr;
        //数据辨识标志
        Buf[24] = IVPT_BROADCAST_REQUEST_ID ;
        remoteAddr.sin_family = AF_INET ;
        remoteAddr.sin_addr.s_addr = INADDR_BROADCAST;

        int nMaxTryTimers=100;
        int nLeep=10;
        int nTryTimers=nMaxTryTimers;
        while(nTryTimers>0)
        {
                nSearchPercent=((nMaxTryTimers-nTryTimers)*50/nMaxTryTimers)+(GetTickCount()-nBeginScanTimer3)*50/nScanTimer3;
                if(SearchPtDeviceEx)SearchPtDeviceEx(-1,NULL,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
                if(_searchPTDeviceOutEx)_searchPTDeviceOutEx(NULL,NULL,0,NULL,0,nSearchPercent,lpUserPTDeviceHandle);
                //向电视墙端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_TVWALLSERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
                //向流媒体端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_STREAMSERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
#if 0
                //向存储服务器端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_RECORDSERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
                //向报警端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_ALARMSERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
                //向用户验证端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_USERSERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
                //向状态服务器端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_STATESERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
                //向智能分析服务器端口发送信息
                remoteAddr.sin_port =htons (IVPT_BROADCAST_SMARTSERVER_PORT);
                err = sendto(hSocketCast3, (char *)Buf, sizeof(Buf), 0, (sockaddr *)(&remoteAddr), sizeof(sockaddr_in));
                Sleep(nLeep);
#endif
                nTryTimers--;
                if((GetTickCount()-nBeginScanTimer3)>nScanTimer3)break;
        }
        //等待2秒，再去实际连接
        Sleep(2000);
        IVHI_TVWALL_CTRL_SDK_SortDecUnitListByIP();
        AddDecUnitListToLinkClass();
        printf("SendBroadcastMsg finished hSocketCast3:%d \n",hSocketCast3);
        return 0;
}

[/code]

注意代码不可能运行起来，因为关联的函数以及参数很多，但流程时对的。

///////arm服务端开启一个端口广播服务。如果受到符合命令的搜索指令，将自己的基本信息，广播出去。

//////arm客户端或者PC搜索端，向这个广播端口发出搜索指令的同时，还是利用这个已经建立的socket侦测接收返回的数据，然后对数据进行解析即可。

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35520&ptid=12182]ngswfx 发表于 2016-8-4 17:39[/url]
注意代码不可能运行起来，因为关联的函数以及参数很多，但流程时对的。

///////arm服务端开启一个端口广 ...[/quote]

端口用 255.255.255.255吧

本帖最后由 ngswfx 于 2016-8-4 18:00 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35523&ptid=12182]hik.leo 发表于 2016-8-4 17:56[/url]
端口用 255.255.255.255吧[/quote]

你的理解有误。那是全部IP段，可不是端口。#define        INADDR_BROADCAST        ((in_addr_t) 0xffffffff)


#define IVPT_BROADCAST_CHAR_LEN                                        18
#define        IVPT_BROADCAST_REQUEST_ID                                0xa8
#define        IVPT_BROADCAST_SENDBACK_ID                                0xd1
#define        FIRST_REC_DISK                                                        'E'
#define        IVPT_BROADCAST_HBDVR_PORT                                27150
#define        IVPT_BROADCAST_HDVRSERVER_PORT                        27156
#define        IVPT_BROADCAST_TVWALLSERVER_PORT                27160
#define        IVPT_BROADCAST_RECORDSERVER_PORT                27161
#define        IVPT_BROADCAST_ALARMSERVER_PORT                        27162
#define        IVPT_BROADCAST_USERSERVER_PORT                        27163
#define        IVPT_BROADCAST_STREAMSERVER_PORT                27164
#define        IVPT_BROADCAST_STATESERVER_PORT                        27165
#define        IVPT_BROADCAST_SMARTSERVER_PORT                        27166
#define        IVPT_BROADCAST_CLIENT_CENTER_PORT                27167   //管理中心
#define PING_MAX_PACKET_SIZE                                1024

static char                                                                                nfhead_RecordServer[IVPT_BROADCAST_CHAR_LEN]        = "IV_RECORDSRV_INF@";
static char                                                                                nfhead_AlarmServer[IVPT_BROADCAST_CHAR_LEN]                = "IV_ALARMSRVR_INF@";
static char                                                                                nfhead_TvWallServer[IVPT_BROADCAST_CHAR_LEN]        = "TV_TVWALLSRV_INF@";
static char                                                                                nfhead_UserServer[IVPT_BROADCAST_CHAR_LEN]                = "IV_USERSERVR_INF@";
static char                                                                                nfhead_StreamServer[IVPT_BROADCAST_CHAR_LEN]        = "IV_STREAMSRV_INF@";
static char                                                                                nfhead_StateServer[IVPT_BROADCAST_CHAR_LEN]                = "IV_STATESERV_INF@";
static char                                                                                nfhead_SmartServer[IVPT_BROADCAST_CHAR_LEN]                = "IV_STMARTSRV_INF@";
static char                                                                                nfhead_NtpServer[IVPT_BROADCAST_CHAR_LEN]                = "IV_NTPSRV_INF@";

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35524&ptid=12182]ngswfx 发表于 2016-8-4 17:58[/url]
你的理解有误。那是全部IP段，可不是端口。#define        INADDR_BROADCAST        ((in_addr_t) 0xffffffff)


[/quote]

是有协议我们以前做个一个，带加密的，防止别人抓包来控制我们的设备

[quote][url=forum.php?mod=redirect&goto=findpost&pid=35524&ptid=12182]ngswfx 发表于 2016-8-4 17:58[/url]
你的理解有误。那是全部IP段，可不是端口。#define        INADDR_BROADCAST        ((in_addr_t) 0xffffffff)


[/quote]

兄弟，问个问题，这种全网段ip修改工具的原理是什么？udp广播吗？udp广播没有全网段广播的啊

本帖最后由 ngswfx 于 2016-8-13 03:25 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=36037&ptid=12182]qq1003442507 发表于 2016-8-12 21:11[/url]
兄弟，问个问题，这种全网段ip修改工具的原理是什么？udp广播吗？udp广播没有全网段广播的啊[/quote]

太底层、太理论方面的我不明白。

////应该是c网段的。192.168.1.0---------192.168.1.255,这个肯定没问题。

////如果时B网段的。192.168.0.0----------192.168.255.255.这个我就不知道行不行了。

///////当然，估计还和子网掩码有关，我们通常设置是255.255.255.0，如果要弄B网段的广播，估计要把自己的子网掩码搞成255.255.0.0               (我猜的，哈哈:lol )


/////////////////////////由于理论东西我也不懂，所以搜索了一下：

广播域的计算
如何知道一台主机是属于哪一个广播域呢？其实计算很简单，只要用主机的IP地址与子网掩码进行与运算即可知道该主机属于哪一个广播域。例如：一台主机的IP地址为192.168.23.150，子网掩码为255.255.255.0，那么它所属的广播域就是192.168.23.150&255.255.255.0=192.168.23.0。那么其它的在广播域192.168.23.0内的所有主机就可以到该设备发送的广播包。如果把子网掩码改为255.255.0.0，那么它所属的广播域就是192.168.23.150&255.255.0.0=192.168.0.0。那么其它的在广播域192.168.0.0内的所有主机都可以收到该设备发送的广播包。
广播地址的计算
要想相同广播域内的其它主机能收到的广播帧，还需要在发送广播包的时候指定当前所属广播域内的广播地址。广播地址的计算方法为子网掩码取反再与广播域进行或运算。
例如：如果主机当前所属广播域为192.168.0.0，子网掩码为255.255.0.0，那么广播地址则为192.168.255.255。
使用UDP进行跨网段广播
要使主机A发送的广播包能够被另一网段的主机B收到，那么只需要更改主机A的子网掩码使得与主机B在同一个广播域内，再使用新的广播域的广播地址发送广播包即可。

例如：要使用192.168.23.150发送广播包让192.168.27.135收到，只需要设置192.168.23.150的子网掩码为255.255.0.0，然后再使用广播地址192.168.255.255即可。

特别要指出的是：255.255.255.255是受限广播地址，不能使用该地址发送广播包。


/////////////还有这个帖子：[url]http://bbs.csdn.net/topics/390896452[/url]

//综合来看，如果自己的机器是192.168.2.26，想找到192.0.0.0-192.255.255.255这个范围内的设备，应该都可以实现，把子网掩码搞成255.0.0.0。如果希望192.168.2.26能搜索到10.X.X.X，我没有弄成功。