udp传输系统.docx

udp传输系统.docx

《udp传输系统.docx》由会员分享，可在线阅读，更多相关《udp传输系统.docx（15页珍藏版）》请在冰豆网上搜索。

udp传输系统

//加载库文件

#pragmacomment（lib,"ws2_32"）

//加载头文件

#include

#include

#include

#include

//定义多播常量

#defineMCASTADDR"224.3.5.8"

#defineMCASTPORT25000

#defineBUFSIZE1024

#defineMCOUNT10

//定义广播常量

#defineBCASTPORT5050

#defineBCOUNT10

//定义广播全局变量

SOCKETsocketBro;

SOCKETsocketRec;

structsockaddr_inaddrBro;

structsockaddr_inaddrRec;

BOOLbroadSendFlag;

BOOLbroadFlag;

DWORDbCount;

DWORDbcastAddr;

shortbPort;

//定义多播全局变量

SOCKETsocketMul;

SOCKETsockJoin;

structsockaddr_inaddrLocal;

structsockaddr_inaddrMul;

BOOLmultiSendFlag;

BOOLbLoopBack;

BOOLmultiFlag;

DWORDdwInterface;

DWORDdwMulticastGroup;

DWORDmCount;

shortmPort;

//自定义函数

voidinitial（）;

voidGetArgments（intargc,char**argv）;

voiduserHelpAll（）;

voiduserHelpBro（）;

voiduserHelpMul（）;

voidbroadcastSend（）;

voidbroadcastRec（）;

voidmulControl（）;

voidmulticastSend（）;

voidmulticastRec（）;

voidinitial（）

{

//初始化广播全局变量

bPort=BCASTPORT;

bCount=BCOUNT;

bcastAddr=INADDR_BROADCAST;

broadSendFlag=FALSE;

broadFlag=FALSE;

multiFlag=FALSE;

//初始化多播全局变量

dwInterface=INADDR_ANY;

dwMulticastGroup=inet_addr（MCASTADDR）;

mPort=MCASTPORT;

mCount=MCOUNT;

multiSendFlag=FALSE;

bLoopBack=FALSE;

}

voidGetArgments（intargc,char**argv）

{

inti;

//如果参数小于2

if（argc<=1）

{

userHelpAll（）;

return;

}

//获取广播选项

if（argv[1][0]=='-'&&argv[1][1]=='b'）

{

broadFlag=TRUE;

for（i=2;i

{

if（argv[i][0]=='-'）

{

switch（tolower（argv[i][1]））

{

//发送者

case's':

broadSendFlag=TRUE;

break;

//广播地址

case'h':

if（strlen（argv[i]）>3）

bcastAddr=inet_addr（&argv[i][3]）;

break;

//广播端口号

case'p':

if（strlen（argv[i]）>3）

bPort=atoi（&argv[i][3]）;

break;

//广播数量

case'n':

bCount=atoi（&argv[i][3]）;

break;

//其他情况转向用户帮助

default:

userHelpBro（）;

ExitProcess（-1）;

break;

}

}

}

return;

}

//获取多播选项

if（argv[1][0]=='-'&&argv[1][1]=='m'）

{

multiFlag=TRUE;

for（i=2;i

{

if（argv[i][0]=='-'）

{

switch（tolower（argv[i][1]））

{

//发送者

case's':

multiSendFlag=TRUE;

break;

//多播地址

case'h':

if（strlen（argv[i]）>3）

dwMulticastGroup=inet_addr（&argv[i][3]）;

break;

//本地接口地址

case'i':

if（strlen（argv[i]）>3）

dwInterface=inet_addr（&argv[i][3]）;

break;

//多播端口号

case'p':

if（strlen（argv[i]）>3）

mPort=atoi（&argv[i][3]）;

break;

//环回标志设置为真

case'l':

bLoopBack=TRUE;

break;

//发送数量

case'n':

mCount=atoi（&argv[i][3]）;

break;

//显示用户帮助

default:

userHelpMul（）;

break;

}

}

}

}

return;

}

//全局用户帮助函数

voiduserHelpAll（）

{

printf（"Pleasechoosebroadcast[-b]ormulticast[-m]!

\n"）;

printf（"userHelpAll:

-b[-s][p][-h][-n]|-m[-s][-h][-p][-i][-l][-n]\n"）;

userHelpBro（）;

userHelpMul（）;

}

//广播用户帮助函数

voiduserHelpBro（）

{

printf（"Broadcast:

-b-s:

str-p:

int-h:

str-n:

int\n"）;

printf（"-bStartthebroadcastprogram.\n"）;

printf（"-sActasserver（senddata）;otherwise\n"）;

printf（"receivedata.Defaultisreceiver.\n"）;

printf（"-p:

intPortnumbertouse\n"）;

printf（"Thedefaultportis5050.\n"）;

printf（"-h:

strThedecimalbroadcastIPaddress.\n"）;

printf（"-n:

intTheNumberofmessagestosend/receive.\n"）;

printf（"Thedefaultnumberis10.\n"）;

}

//多播用户帮助

voiduserHelpMul（）

{

printf（"Multicast:

-m-s-h:

str-p:

int-i:

str-l-n:

int\n"）;

printf（"-mStartthemulticastprogram.\n"）;

printf（"-sActasserver（senddata）;otherwise\n"）;

printf（"receivedata.Defaultisreceiver.\n"）;

printf（"-h:

strThedecimalmulticastIPaddresstojoin\n"）;

printf（"Thedefaultgroupis:

%s\n",MCASTADDR）;

printf（"-p:

intPortnumbertouse\n"）;

printf（"Thedefaultgroupis:

%s\n",MCASTADDR）;

printf（"-i:

strLocalinterfacetobindto;bydefault\n"）;

printf（"useINADDRY_ANY\n"）;

printf（"-lDisableloopback\n"）;

printf（"-n:

intNumberofmessagestosend/receive\n"）;

ExitProcess（-1）;

}

//广播消息发送函数

voidbroadcastSend（）

{

//设置广播消息

char*smsg="Themessagereceivedisfromsender!

";

BOOLopt=TRUE;

intnlen=sizeof（addrBro）;

intret;

DWORDi=0;

//创建UDP套接字

socketBro=WSASocket（AF_INET,SOCK_DGRAM,0,NULL,0,WSA_FLAG_OVERLAPPED）;

//创建失败

if（socketBro==INVALID_SOCKET）

{

printf（"Createsocketfailed:

%d\n",WSAGetLastError（））;

WSACleanup（）;

return;

}

//设置广播地址各个选项

addrBro.sin_family=AF_INET;

addrBro.sin_port=htons（bPort）;

addrBro.sin_addr.S_un.S_addr=bcastAddr;

//设置该套接字为广播类型

if（setsockopt（socketBro,SOL_SOCKET,SO_BROADCAST,（charFAR*）&opt,

sizeof（opt））==SOCKET_ERROR）//设置失败

{

printf（"setsockoptfailed:

%d",WSAGetLastError（））;

closesocket（socketBro）;

WSACleanup（）;

return;

}

//循环发送消息

while（i

{

Sleep（1000）;

//从广播发送消息

ret=sendto（socketBro,smsg,256,0,（structsockaddr*）&addrBro,nlen）;

if（ret=SOCKET_ERROR）

printf（"Sendfailed:

%d!

\n",i）;

else

printf（"Sendmessage%d!

\n",i）;

i++;

}

closesocket（socketBro）;

WSACleanup（）;

}

//广播消息的接收模块

voidbroadcastRec（）

{

BOOLoptval=TRUE;

intaddrBroLen;

charbuf[256];

DWORDi=0;

//该地址用来绑定套接字

addrRec.sin_family=AF_INET;

addrRec.sin_addr.S_un.S_addr=0;

addrRec.sin_port=htons（bPort）;

addrBro.sin_port=htons（bPort）;

addrBroLen=sizeof（addrBro）;

//创建UDP套接字

socketRec=socket（AF_INET,SOCK_DGRAM,0）;

if（socketRec==INVALID_SOCKET）

{

printf（"Createsocketerror:

%d",WSAGetLastError（））;

WSACleanup（）;

return;

}

//设置该套接字为可重用类型

if（setsockopt（socketRec,SOL_SOCKET,SO_REUSEADDR,（charFAR*）&optval,

sizeof（optval））==SOCKET_ERROR）

{

printf（"setsockoptfailed:

%d",WSAGetLastError（））;

closesocket（socketRec）;

WSACleanup（）;

return;

}

//绑定套接字和地址

if（bind（socketRec,（structsockaddr*）&addrRec,

sizeof（structsockaddr_in））==SOCKET_ERROR）

{

printf（"bindfailedwith:

%d\n",WSAGetLastError（））;

closesocket（socketRec）;

WSACleanup（）;

return;

}

//从广播地址接收消息

while（i

{

recvfrom（socketRec,buf,256,0,（structsockaddrFAR*）&addrBro,（intFAR*）&addrBroLen）;

Sleep（2000）;

printf（"%s\n",buf）;

ZeroMemory（buf,256）;

i++;

}

closesocket（socketRec）;

WSACleanup（）;

}

//多播控制函数

voidmulControl（）

{

intoptval;

//创建多播UDP套接字

if（（socketMul=WSASocket（AF_INET,SOCK_DGRAM,0,NULL,0,

WSA_FLAG_MULTIPOINT_C_LEAF

|WSA_FLAG_MULTIPOINT_D_LEAF

|WSA_FLAG_OVERLAPPED））==INVALID_SOCKET）

{

printf（"socketfailedwith:

%d\n",WSAGetLastError（））;

WSACleanup（）;

return;

}

//设置本地接口地址

addrLocal.sin_family=AF_INET;

addrLocal.sin_port=htons（mPort）;

addrRec.sin_addr.S_un.S_addr=dwMulticastGroup;

//重新设置TTL值

optval=8;

if（setsockopt（socketMul,IPPROTO_IP,IP_MULTICAST_TTL,

（char*）&optval,sizeof（int））==SOCKET_ERROR）

{

printf（"setsockopt（IP_MULTICAST_TTL）failed:

%d\n",WSAGetLastError（））;

closesocket（socketMul）;

WSACleanup（）;

return;

}

//如果指定了返还选项

if（bLoopBack）

{

optval=0;

if（setsockopt（socketMul,IPPROTO_IP,IP_MULTICAST_LOOP,

（char*）&optval,sizeof（optval））==SOCKET_ERROR）

{

printf（"setsockopt（IP_MULTICAST_LOOP）failed:

%d\n",WSAGetLastError（））;

closesocket（socketMul）;

WSACleanup（）;

return;

}

}

if（（sockJoin=WSAJoinLeaf（socketMul,（SOCKADDR*）&addrMul,

sizeof（addrMul）,NULL,NULL,NULL,NULL,

JL_BOTH）==INVALID_SOCKET））

{

printf（"WSAJoinLeaf（）failed:

%d\n",WSAGetLastError（））;

closesocket（socketMul）;

return;

}

}

//多播消息发送模块

voidmulticastSend（）

{

TCHARsendbuf[BUFSIZE];

DWORDi;

intret;

mulControl（）;

//发送mCount条消息

for（i=0;i

{

sprintf（sendbuf,"sever1:

Thisisatest:

%d",i）;

ret=sendto（socketMul,（char*）sendbuf,strlen（sendbuf）,0,

（structsockaddr*）&addrMul,sizeof（addrMul））;

if（ret==SOCKET_ERROR）

{

printf（"sedntofailedwith:

%d\n",WSAGetLastError（））;

closesocket（sockJoin）;

closesocket（socketMul）;

WSACleanup（）;

return;

}

else

printf（"Sendmessage%d\n",i）;

Sleep（500）;

}

closesocket（socketMul）;

WSACleanup（）;

}

//多播消息接收函数

voidmulticastRec（）

{

DWORDi;

structsockaddr_infrom;

TCHARrecvbuf[BUFSIZE];

intret;

intlen=sizeof（structsockaddr_in）;

mulControl（）;

for（i=0;i

{

if（（ret=recvfrom（socketMul,recvbuf,BUFSIZE,0,

（structsockaddr*）&from,&len））==SOCKET_ERROR）

{

printf（"recvfromfailedwith:

%d\n",WSAGetLastError（））;

closesocket（sockJoin）;

closesocket（socketMul）;

WSACleanup（）;

return;

}

recvbuf[ret]=0;

printf（"RECV:

'%s'from<%s>\n",recvbuf,inet_ntoa（from.sin_addr））;

}

closesocket（socketMul）;

WSACleanup（）;

}

intmain（intargc,char**argv）

{

WSADATAwsd;

initial（）;

GetArgments（argc,argv）;

if（WSAStartup（MAKEWORD（2,2）,&wsd）!

=0）

{

printf（"WSAStartup（）failed\n"）;

return-1;

}

//如果是执行广播程序

if（broadFlag）

{

if（broadSendFlag）

{

broadcastSend（）;

return0;

}

else

{

broadcastRec（）;

return0;

}

}

//多播

if（multiFlag）

{

if（multiSendFlag）

{

multicastSend（）;

return0;

}

else

{

multicastRec（）;

return0;

}

}

return0;

}