udp客戶端c代碼

A. 有沒有windows下c語言實現udp協議的代碼

Windows下C語言的Socket編程例子（TCP和UDP）
一。<TCP>
server端：
復制代碼
1#include"stdafx.h"
2#include<stdio.h>
3#include<winsock2.h>
4
5#pragmacomment(lib,"ws2_32.lib")
6
7intmain(intargc,char*argv[])
8{
9//初始化WSA
10WORDsockVersion=MAKEWORD(2,2);
11WSADATAwsaData;
12if(WSAStartup(sockVersion,&wsaData)!=0)
13{
14return0;
15}
16
17//創建套接字
18SOCKETslisten=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
19if(slisten==INVALID_SOCKET)
20{
21printf("socketerror!");
22return0;
23}
24
25//綁定IP和埠
26sockaddr_insin;
27sin.sin_family=AF_INET;
28sin.sin_port=htons(8888);
29sin.sin_addr.S_un.S_addr=INADDR_ANY;
30if(bind(slisten,(LPSOCKADDR)&sin,sizeof(sin))==SOCKET_ERROR)
31{
32printf("binderror!");
33}
34
35//開始監聽
36if(listen(slisten,5)==SOCKET_ERROR)
37{
38printf("listenerror!");
39return0;
40}
41
42//循環接收數據
43SOCKETsClient;
44sockaddr_inremoteAddr;
45intnAddrlen=sizeof(remoteAddr);
46charrevData[255];
47while(true)
48{
49printf("等待連接...
");
50sClient=accept(slisten,(SOCKADDR*)&remoteAddr,&nAddrlen);
51if(sClient==INVALID_SOCKET)
52{
53printf("accepterror!");
54continue;
55}
56printf("接受到一個連接：%s
",inet_ntoa(remoteAddr.sin_addr));
57
58//接收數據
59intret=recv(sClient,revData,255,0);
60if(ret>0)
61{
62revData[ret]=0x00;
63printf(revData);
64}
65
66//發送數據
67char*sendData="你好，TCP客戶端！
";
68send(sClient,sendData,strlen(sendData),0);
69closesocket(sClient);
70}
71
72closesocket(slisten);
73WSACleanup();
74return0;
75}
復制代碼
client端：
復制代碼
1#include"stdafx.h"
2#include<WINSOCK2.H>
3#include<STDIO.H>
4
5#pragmacomment(lib,"ws2_32.lib")
6
7
8intmain(intargc,char*argv[])
9{
10WORDsockVersion=MAKEWORD(2,2);
11WSADATAdata;
12if(WSAStartup(sockVersion,&data)!=0)
13{
14return0;
15}
16
17SOCKETsclient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
18if(sclient==INVALID_SOCKET)
19{
20printf("invalidsocket!");
21return0;
22}
23
24sockaddr_inserAddr;
25serAddr.sin_family=AF_INET;
26serAddr.sin_port=htons(8888);
27serAddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
28if(connect(sclient,(sockaddr*)&serAddr,sizeof(serAddr))==SOCKET_ERROR)
29{
30printf("connecterror!");
31closesocket(sclient);
32return0;
33}
34char*sendData="你好，TCP服務端，我是客戶端!
";
35send(sclient,sendData,strlen(sendData),0);
36
37charrecData[255];
38intret=recv(sclient,recData,255,0);
39if(ret>0)
40{
41recData[ret]=0x00;
42printf(recData);
43}
44closesocket(sclient);
45WSACleanup();
46return0;
47}
復制代碼

二.<UDP>
SERVER端
復制代碼
1#include"stdafx.h"
2#include<stdio.h>
3#include<winsock2.h>
4
5#pragmacomment(lib,"ws2_32.lib")
6
7intmain(intargc,char*argv[])
8{
9WSADATAwsaData;
10WORDsockVersion=MAKEWORD(2,2);
11if(WSAStartup(sockVersion,&wsaData)!=0)
12{
13return0;
14}
15
16SOCKETserSocket=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
17if(serSocket==INVALID_SOCKET)
18{
19printf("socketerror!");
20return0;
21}
22
23sockaddr_inserAddr;
24serAddr.sin_family=AF_INET;
25serAddr.sin_port=htons(8888);
26serAddr.sin_addr.S_un.S_addr=INADDR_ANY;
27if(bind(serSocket,(sockaddr*)&serAddr,sizeof(serAddr))==SOCKET_ERROR)
28{
29printf("binderror!");
30closesocket(serSocket);
31return0;
32}
33
34sockaddr_inremoteAddr;
35intnAddrLen=sizeof(remoteAddr);
36while(true)
37{
38charrecvData[255];
39intret=recvfrom(serSocket,recvData,255,0,(sockaddr*)&remoteAddr,&nAddrLen);
40if(ret>0)
41{
42recvData[ret]=0x00;
43printf("接受到一個連接：%s
",inet_ntoa(remoteAddr.sin_addr));
44printf(recvData);
45}
46
47char*sendData="一個來自服務端的UDP數據包
";
48sendto(serSocket,sendData,strlen(sendData),0,(sockaddr*)&remoteAddr,nAddrLen);
49
50}
51closesocket(serSocket);
52WSACleanup();
53return0;
54}
復制代碼
CLIENT端
復制代碼
1#include"stdafx.h"
2#include<stdio.h>
3#include<winsock2.h>
4
5#pragmacomment(lib,"ws2_32.lib")
6
7intmain(intargc,char*argv[])
8{
9WORDsocketVersion=MAKEWORD(2,2);
10WSADATAwsaData;
11if(WSAStartup(socketVersion,&wsaData)!=0)
12{
13return0;
14}
15SOCKETsclient=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
16
17sockaddr_insin;
18sin.sin_family=AF_INET;
19sin.sin_port=htons(8888);
20sin.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
21intlen=sizeof(sin);
22
23char*sendData="來自客戶端的數據包.
";
24sendto(sclient,sendData,strlen(sendData),0,(sockaddr*)&sin,len);
25
26charrecvData[255];
27intret=recvfrom(sclient,recvData,255,0,(sockaddr*)&sin,&len);
28if(ret>0)
29{
30recvData[ret]=0x00;
31printf(recvData);
32}
33
34closesocket(sclient);
35WSACleanup();
36return0;
37}

B. 能否給我一個用純C編寫的UDP發送和接收的程序

UDP的，你看下

1.伺服器端實現

程序在收到客戶端發送來的消息後，給客戶端發送消息，提示客戶端收到了該消息

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
int sock, length, fromlen, n;
struct sockaddr_in server;
struct sockaddr_in from;
char buf[1024];

//要求執行是輸入埠信息
if (argc!= 2) {
printf( "Usage: %s port_num\n",argv[0]);
return 1;
}

//創建通信所需的套接字，並與地址和埠信息幫定
sock=socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0){
perror("cannot create communicating socket");
return 1;
}

length = sizeof(server);
bzero(&server,length);
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=htons(atoi(argv[1]));

if (bind(sock,(struct sockaddr *)&server,length)<0){
perror("cannot bind the socket");
close(sock);
return 1;
}

fromlen = sizeof(struct sockaddr_in);

//讀取客戶端發送來的信息，顯示後，發回相關信息給客戶端
while (1) {
n = recvfrom(sock,buf,sizeof(buf),0,(struct sockaddr *)&from,&fromlen);
if (n < 0) {
perror("cannot receive date from client");
break;
}
write(STDOUT_FILENO,"server: Received a datagram: ",29);
write(STDOUT_FILENO,buf,n);

n = sendto(sock,"send message to client\n",22,
0,(struct sockaddr *)&from,fromlen);
if (n < 0) {
perror("cannot send data to the client");
break;
}
}

close(sock);
return 0;
}

2.客戶端實現

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
int sock, length, n;
struct sockaddr_in server, from;
struct hostent *hp;
char buffer[256];

//判斷輸入參數是否符合要求
if (argc != 3) {
printf("Usage: %s server_ip port_num\n",argv[0]);
return 1;
}

//創建通信套接字
sock= socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
perror("cannot create communicating socket");
return 1;
}

server.sin_family = AF_INET;
hp = gethostbyname(argv[1]);
if (hp==0) {
perror("cannot get the server ip address");
return 1;
}

b((char *)hp->h_addr,
(char *)&server.sin_addr,
hp->h_length);

server.sin_port = htons(atoi(argv[2]));
length=sizeof(struct sockaddr_in);

printf("(client) enter the message: ");
bzero(buffer,256);
fgets(buffer,255,stdin);

//發送數據給指定伺服器
n=sendto(sock,buffer,strlen(buffer),0,&server,length);
if (n < 0){
perror("cannot get message from the client");
return 1;
}

//從伺服器中接受數據
bzero(buffer,256);
n = recvfrom(sock,buffer,256,0,&from, &length);
if (n < 0) {
perror("cannot send message to the server");
return 1;
}

printf("client got message : %s\n",buffer);
close(sock);
return 0;
}

C. 請教C#WinForm下的UDP代碼

UDP和WINFORM沒有半毛錢關系，

UDP是一種網路通訊協議，常用於單片機通訊或者底層通訊，不需要握手，

至於代碼，不明白你到底要什麼代碼，一般來講UDP需要聲明服務端和客戶端 ，並接受和發送數據，

思路上就是服務端聲明自己的IP、 埠， 然後開啟監聽，

客戶端向指定的IP埠發送數據，

當然服務端也可以發送，客戶端也可以監聽，

最需要處理的一般是非同步接收後的操作，

下面是個簡單的UDP通訊的代碼，服務端功能基本如下，客戶端可以比葫蘆畫瓢，

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Net.Sockets;
usingSystem.Net;
usingSystem.Threading;
usingSystem.IO;
namespaceUdpChatExample
{
///<summary>
///UDP伺服器對象
///</summary>
publicclassUDPServerClass
{
(stringMessage);//定義委託事件
;
publicUDPServerClass()
{
//獲取本機可用IP地址
IPAddress[]ips=Dns.GetHostAddresses(Dns.GetHostName());
foreach(IPAddressipainips)
{
if(ipa.AddressFamily==AddressFamily.InterNetwork)
{
MyIPAddress=ipa;//獲取本地IP地址
break;
}
}
Note_StringBuilder=newStringBuilder();
PortName=8080;

}

;

///<summary>
///偵聽埠名稱
///</summary>
publicintPortName;

///<summary>
///本地地址
///</summary>
;

///<summary>
///日誌記錄
///</summary>
publicStringBuilderNote_StringBuilder;
///<summary>
///本地IP地址
///</summary>
publicIPAddressMyIPAddress;

publicvoidThread_Listen()
{
//創建一個線程接收遠程主機發來的信息
ThreadmyThread=newThread(ReceiveData);
myThread.IsBackground=true;
myThread.Start();
}
///<summary>
///接收數據
///</summary>
privatevoidReceiveData()
{
IPEndPointlocal=newIPEndPoint(MyIPAddress,PortName);
ReceiveUdpClient=newUdpClient(local);
IPEndPointremote=newIPEndPoint(IPAddress.Any,0);
while(true)
{
try
{
//關閉udpClient時此句會產生異常
byte[]receiveBytes=ReceiveUdpClient.Receive(refremote);
stringreceiveMessage=Encoding.Default.GetString(receiveBytes,0,receiveBytes.Length);
//receiveMessage=ASCIIEncoding.ASCII.GetString(receiveBytes,0,receiveBytes.Length);
MessageArrived(string.Format("{0}來自{1}:{2}",DateTime.Now.ToString(),remote,receiveMessage));
//try
//{
//Byte[]sendBytes=Encoding.ASCII.GetBytes("Isanybodythere?");
//ReceiveUdpClient.Send(sendBytes,sendBytes.Length,local);
//}
//catch(Exceptione)
//{
//}
//break;

}
catch
{
break;
}
}
}

///<summary>
///添加日誌信息到Note_StringBuilder
///</summary>
publicvoidAddMessage_Note_StringBuilder()
{

}
}
}

D. C語言 UDP socket 簡單客戶端 編程，急

提一下，你那個地址不好用，換成了127.0.0.1，埠可以用，完全按照要求寫的，編譯沒錯誤，調試通過：
gcc server.c -o server
gcc client.c -o client
打開2個控制台：一個運行 ./server 另一個運行 ./client
server.c:
========================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>

#define BUFFERSIZE 1024
typedef struct sockaddr SA;

int main(void)
{
char buf[BUFFERSIZE];
struct sockaddr_in addr_s;
struct sockaddr_in addr_c;
int sockfd;
socklen_t length;
int i;

if((sockfd = socket(AF_INET,SOCK_DGRAM,0)) == -1)
{
perror("socket fail");
return -1;
}

memset(&addr_s,0,sizeof(addr_s));
addr_s.sin_family = AF_INET;
addr_s.sin_addr.s_addr = inet_addr("127.0.0.1");
addr_s.sin_port = htons(31180);

if(bind(sockfd,(SA *)&addr_s,sizeof(addr_s)) == -1)
{
perror("bind fail");
return -1;
}

length = sizeof(addr_c);

memset(buf,'\0',sizeof(buf));
if(recvfrom(sockfd,buf,sizeof(buf),0
,(SA *)&addr_c,&length) == -1)
{
perror("recvfrom fail");
}
printf("recvfrom client:%s\n",buf);
sendto(sockfd,buf,sizeof(buf),0,(SA *)&addr_c,sizeof(addr_c));

close(sockfd);
}

====================================
client.c:
====================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>

#define BUFFERSIZE 1024
typedef struct sockaddr SA;

int main(void)
{
int sockfd;
char buf[BUFFERSIZE];
struct sockaddr_in addr_s;

if((sockfd = socket(AF_INET,SOCK_DGRAM,0)) == -1)
{
perror("socket fail");
return -1;
}

memset(&addr_s,0,sizeof(addr_s));
addr_s.sin_family = AF_INET;
addr_s.sin_addr.s_addr = inet_addr("127.0.0.1");
addr_s.sin_port = htons(31180);

memset(buf,'\0',sizeof(buf));
sprintf(buf,"abcde");
if(sendto(sockfd,buf,sizeof(buf)
,0,(SA *)&addr_s,sizeof(addr_s)) < 0)
{
perror("sendto fail");
}
memset(buf,'\0',sizeof(buf));
recvfrom(sockfd,buf,sizeof(buf),0,NULL,NULL);
printf("recvfrom server:%s\n",buf);

close(sockfd);
}

E. 基於UDP的PING程序的C語言（或c++）代碼誰有！跪求！

#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<unistd.h>
#include<netinet/ip_icmp.h>
#include<netdb.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/time.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<pthread.h>

structsockaddr_indst_addr;
structsockaddr_inrecv_addr;
structtimevaltvrecv;
charicmp_pkt[1024]={0};
charrecv_pkt[1024]={0};
intsockfd=0,bytes=56,nsend_pkt=0,nrecv_pkt=0;
pid_tpid;

voidstatistics();
intin_chksum(unsignedshort*buf,intsize);
intpack(intsend_pkt);
void*send_ping();
intunpack(char*recv_pkt,intsize);
void*recv_ping();
voidtv_sub(structtimeval*out,structtimeval*in);

intmain(intargc,char**argv)
{
	intsize=50*1024;
	interrno=-1;
	intttl=64;
	void*tret;
	pthread_tsend_id,recv_id;
	structin_addripv4_addr;
	structhostent*ipv4_host;
	structprotoent*protocol=NULL;

	if(argc<2)
	{
		printf("usage:./ping<host>
");
		return-1;
	}
	if((protocol=getprotobyname("icmp"))==NULL)
	{
		printf("unkownprotocol
");
		return-1;
	}

	if((sockfd=socket(AF_INET,SOCK_RAW,protocol->p_proto))<0)
	{
		printf("socketfail
");
		return-1;
	}
	setsockopt(sockfd,SOL_SOCKET,SO_RCVBUF,&size,sizeof(size));
	setsockopt(sockfd,IPPROTO_IP,IP_MULTICAST_TTL,&ttl,sizeof(ttl));
	setsockopt(sockfd,IPPROTO_IP,IP_TTL,&ttl,sizeof(ttl));

	memset(&dst_addr,0,sizeof(dst_addr));
	dst_addr.sin_family=AF_INET;
	errno=inet_aton(argv[1],&ipv4_addr);
	if(errno==0)
	{
		ipv4_host=gethostbyname(argv[1]);
		if(NULL==ipv4_host)
		{
			printf("connect:Invalidargument
");
			return-1;
		}
		memcpy(&(dst_addr.sin_addr),ipv4_host->h_addr,sizeof(structin_addr));
	}
	else
	{
		memcpy(&(dst_addr.sin_addr),&(ipv4_addr.s_addr),sizeof(structin_addr));
	}

	pid=getpid();
	printf("PING%s(%s)%dbytesofdata.
",argv[1],inet_ntoa(dst_addr.sin_addr),bytes);
	signal(SIGINT,statistics);
	
	errno=pthread_create(&send_id,NULL,send_ping,NULL);
	if(errno!=0)
	{
		printf("send_pingthreadfail
");
		return-1;
	}
	errno=pthread_create(&recv_id,NULL,recv_ping,NULL);
	if(errno!=0)
	{
		printf("recv_pingthreadfail
");
		return-1;
	}
	pthread_join(send_id,&tret);
	pthread_join(recv_id,&tret);

	return0;
}

voidstatistics()
{
	printf("
---%spingstatistics---
",inet_ntoa(dst_addr.sin_addr));
	printf("%dpacketstransmitted,%dreceived,%.3f%cpacketloss
",
		nsend_pkt,nrecv_pkt,(float)100*(nsend_pkt-nrecv_pkt)/nsend_pkt,'%');
	close(sockfd);

	exit(0);
}

intin_chksum(unsignedshort*buf,intsize)
{
	intnleft=size;
	intsum=0;
	unsignedshort*w=buf;
	unsignedshortans=0;

	while(nleft>1)
	{
		sum+=*w++;
		nleft-=2;
	}
	if(nleft==1)
	{
		*(unsignedchar*)(&ans)=*(unsignedchar*)w;
		sum+=ans;
	}
	sum=(sum>>16)+(sum&0xFFFF);
	sum+=(sum>>16);
	ans=~sum;
	returnans;
}

intpack(intsend_pkt)
{
	structicmp*pkt=(structicmp*)icmp_pkt;
	structtimeval*time=NULL;

	pkt->icmp_type=ICMP_ECHO;
	pkt->icmp_cksum=0;
	pkt->icmp_seq=htons(nsend_pkt);
	pkt->icmp_id=pid;
	time=(structtimeval*)pkt->icmp_data;
	gettimeofday(time,NULL);
	pkt->icmp_cksum=in_chksum((unsignedshort*)pkt,bytes+8);

	returnbytes+8;
}

void*send_ping()
{
	intsend_bytes=0;
	intret=-1;

	while(1)
	{
		nsend_pkt++;
		send_bytes=pack(nsend_pkt);

		ret=sendto(sockfd,icmp_pkt,send_bytes,0,(structsockaddr*)&dst_addr,sizeof(dst_addr));
		if(ret==-1)
		{
			printf("sendfail
");
			sleep(1);
			continue;
		}
		sleep(1);
	}
}

voidtv_sub(structtimeval*out,structtimeval*in)
{
	if((out->tv_usec-=in->tv_usec)<0)
	{
		--out->tv_sec;
		out->tv_usec+=1000000;
	}

	out->tv_sec-=in->tv_sec;
}

intunpack(char*recv_pkt,intsize)
{
	structiphdr*ip=NULL;
	intiphdrlen;
	structicmp*icmp;
	structtimeval*tvsend;
	doublertt;

	ip=(structiphdr*)recv_pkt;
	iphdrlen=ip->ihl<<2;
	icmp=(structicmp*)(recv_pkt+iphdrlen);

	size-=iphdrlen;
	if(size<8)
	{
		printf("ICMPsizeislessthan8
");
		return-1;
	}

	if((icmp->icmp_type==ICMP_ECHOREPLY)&&(icmp->icmp_id==pid))
	{
		tvsend=(structtimeval*)icmp->icmp_data;
		tv_sub(&tvrecv,tvsend);
		rtt=tvrecv.tv_sec*1000+(double)tvrecv.tv_usec/(double)1000;
		printf("%dbytefrom%s:icmp_seq=%dttl=%drtt=%.3fms
",
			size,inet_ntoa(recv_addr.sin_addr),ntohs(icmp->icmp_seq),ip->ttl,rtt);
	}
	else
	{
		return-1;
	}
	return0;
}

void*recv_ping()
{
	fd_setrd_set;
	structtimevaltime;
	time.tv_sec=5;
	time.tv_usec=0;
	intret=0,nread=0,recv_len=0;
	
	recv_len=sizeof(recv_addr);
	while(1)
	{
		FD_ZERO(&rd_set);
		FD_SET(sockfd,&rd_set);
		ret=select(sockfd+1,&rd_set,NULL,NULL,&time);
		if(ret<=0)
		{
			continue;
		}
		elseif(FD_ISSET(sockfd,&rd_set))
		{
			nread=recvfrom(sockfd,recv_pkt,sizeof(recv_pkt),0,(structsockaddr*)&recv_addr,(socklen_t*)&recv_len);
			if(nread<0)
			{
				continue;
			}
			gettimeofday(&tvrecv,NULL);

			if(unpack(recv_pkt,nread)==-1)
			{
				continue;
			}
			nrecv_pkt++;
		}
	}
}

F. VC實現最簡單的UDP通信

http://hi..com/ypxmaomao/blog/item/1bd9ba95e3aa224cd0135ebf.html
[文章信息] 作者:張曉明 楊建華 錢名海時間:2003-06-28出處:PCVC責任編輯:方舟 [文章導讀] 在Windows 95環境下，基於TCP/IP協議，用Winsock完成了話音的一端—端傳輸

摘要：在Windows 95環境下，基於TCP/IP協議，用Winsock完成了話音的端到端傳輸。採用雙套接字技術，闡述了主要函數的使用要點，以及基於非同步選擇機制的應用方法。同時，給出了相應的實常式序。

一、引言

Windows 95作為微機的操作系統，已經完全融入了網路與通信功能，不僅可以建立純Windows 95環境下的「對等網路」，而且支持多種協議，如TCP/IP、IPX/SPX、NETBUI等。在TCP/IP協議組中，TPC是一種面向連接的協義，為用戶提供可靠的、全雙工的位元組流服務，具有確認、流控制、多路復用和同步等功能，適於數據傳輸。UDP協議則是無連接的，每個分組都攜帶完整的目的地址，各分組在系統中獨立傳送。它不能保證分組的先後順序，不進行分組出錯的恢復與重傳，因此不保證傳輸的可靠性，但是，它提供高傳輸效率的數據報服務，適於實時的語音、圖像傳輸、廣播消息等網路傳輸。

Winsock介面為進程間通信提供了一種新的手段，它不但能用於同一機器中的進程之間通信，而且支持網路通信功能。隨著Windows 95的推出。Winsock已經被正式集成到了Windows系統中，同時包括了16位和32位的編程介面。而Winsock的開發工具也可以在Borland C++4.0、Visual C++2.0這些C編譯器中找到，主要由一個名為winsock.h的頭文件和動態連接庫winsock.dll或wsodk32.dll組成，這兩種動態連接庫分別用於Win16和Win32的應用程序。

本文針對話音的全雙工傳輸要求，採用UDP協議實現了實時網路通信。使用VisualC++2.0編譯環境，其動態連接庫名為wsock32.dll。

二、主要函數的使用要點

通過建立雙套接字，可以很方便地實現全雙工網路通信。

1.套接字建立函數：

SOCKET socket(int family,int type,int protocol)
對於UDP協議，寫為：

SOCKRET s;
s=socket(AF_INET,SOCK_DGRAM,0);
或s=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)
為了建立兩個套接字，必須實現地址的重復綁定，即，當一個套接字已經綁定到某本地地址後，為了讓另一個套接字重復使用該地址，必須為調用bind()函數綁定第二個套接字之前，通過函數setsockopt()為該套接字設置SO_REUSEADDR套接字選項。通過函數getsockopt()可獲得套接字選項設置狀態。需要注意的是，兩個套接字所對應的埠號不能相同。 此外，還涉及到套接字緩沖區的設置問題，按規定，每個區的設置范圍是：不小於512個位元組，大大於8k位元組，根據需要，文中選用了4k位元組。

2.套接字綁定函數

int bind(SOCKET s,struct sockaddr_in*name,int namelen)
s是剛才創建好的套接字，name指向描述通訊對象的結構體的指針，namelen是該結構體的長度。該結構體中的分量包括：IP地址(對應name.sin_addr.s_addr)、埠號(name.sin_port)、地址類型(name.sin_family，一般都賦成AF_INET，表示是internet地址)。

(1)IP地址的填寫方法：在全雙工通信中，要把用戶名對應的點分表示法地址轉換成32位長整數格式的IP地址，使用inet_addr()函數。

(2)埠號是用於表示同一台計算機不同的進程(應用程序)，其分配方法有兩種：1)進程可以讓系統為套接字自動分配一埠號，只要在調用bind前將埠號指定為0即可。由系統自動分配的埠號位於1024~5000之間，而1~1023之間的任一TCP或UDP埠都是保留的，系統不允許任一進程使用保留埠，除非其有效用戶ID是零(超級用戶)。

2)進程可為套接字指定一特定埠。這對於需要給套接字分配一眾所埠的伺服器是很有用的。指定范圍為1024和65536之間。可任意指定。

在本程序中，對兩個套接字的埠號規定為2000和2001，前者對應發送套接字，後者對應接收套接字。

埠號要從一個16位無符號數(u_short類型數)從主機位元組順序轉換成網路位元組順序，使用htons()函數。

根據以上兩個函數，可以給出雙套接字建立與綁定的程序片斷。

//設置有關的全局變數
SOCKET sr,ss;
HPSTR sockBufferS,sockBufferR;
HANDLE hSendData,hReceiveData;
DWROD dwDataSize=1024*4;
struct sockaddr_in therel.there2;
#DEFINE LOCAL_HOST_ADDR 200.200.200.201
#DEFINE REMOTE_HOST-ADDR 200.200.200.202
#DEFINE LOCAL_HOST_PORT 2000
#DEFINE LOCAL_HOST_PORT 2001
//套接字建立函數
BOOL make_skt(HWND hwnd)
{
struct sockaddr_in here,here1;
ss=socket(AF_INET,SOCK_DGRAM,0);
sr=socket(AF_INET,SOCK_DGRAM,0);
if((ss==INVALID_SOCKET)||(sr==INVALID_SOCKET))
{
MessageBox(hwnd,「套接字建立失敗!」，「」,MB_OK);
return(FALSE);
}
here.sin_family=AF_INET;
here.sin_addr.s_addr=inet_addr(LOCAL_HOST_ADDR);
here.sin_port=htons(LICAL_HOST_PORT);
//another socket
herel.sin_family=AF_INET;
herel.sin_addr.s_addr(LOCAL_HOST_ADDR);
herel.sin_port=htons(LOCAL_HOST_PORT1);
SocketBuffer();//套接字緩沖區的鎖定設置
setsockopt(ss,SOL_SOCKET,SO_SNDBUF,(char FAR*)sockBufferS,dwDataSize);
if(bind(ss,(LPSOCKADDR)&here,sizeof(here)))
{
MessageBox(hwnd,「發送套接字綁定失敗!」，「」，MB_OK);
return(FALSE);
}
setsockopt(sr SQL_SOCKET,SO_RCVBUF|SO_REUSEADDR,(char FAR*)
sockBufferR,dwDataSize);
if(bind(sr,(LPSOCKADDR)&here1,sizeof(here1)))
{
MessageBox(hwnd,「接收套接字綁定失敗!」，「」，MB_OK);
return(FALSE);
}
return(TRUE);
}
//套接字緩沖區設置
void sockBuffer(void)
{
hSendData=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE,dwDataSize);
if(!hSendData)
{
MessageBox(hwnd,「發送套接字緩沖區定位失敗!」，NULL,
MB_OK|MB_ICONEXCLAMATION);
return;
}
if((sockBufferS=GlobalLock(hSendData)==NULL)
{
MessageBox(hwnd,「發送套接字緩沖區鎖定失敗!」，NULL,
MB_OK|MB_ICONEXCLAMATION);
GlobalFree(hRecordData[0];
return;
}
hReceiveData=globalAlloc(GMEM_MOVEABLE|GMEM_SHARE,dwDataSize);
if(!hReceiveData)
{
MessageBox(hwnd,"「接收套接字緩沖區定位敗!」，NULL
MB_OK|MB_ICONEXCLAMATION);
return;
}
if((sockBufferT=Globallock(hReceiveData))=NULL)
MessageBox(hwnd,"發送套接字緩沖區鎖定失敗!」，NULL,
MB_OK|MB_ICONEXCLAMATION);
GlobalFree(hRecordData[0]);
return;
}
{
3.數據發送與接收函數；

int sendto(SOCKET s.char*buf,int len,int flags,struct sockaddr_in to,int
tolen);
int recvfrom(SOCKET s.char*buf,int len,int flags,struct sockaddr_in
fron,int*fromlen)
其中，參數flags一般取0。

recvfrom()函數實際上是讀取sendto()函數發過來的一個數據包，當讀到的數據位元組少於規定接收的數目時，就把數據全部接收，並返回實際接收到的位元組數；當讀到的數據多於規定值時，在數據報文方式下，多餘的數據將被丟棄。而在流方式下，剩餘的數據由下recvfrom()讀出。為了發送和接收數據，必須建立數據發送緩沖區和數據接收緩沖區。規定：IP層的一個數據報最大不超過64K(含數據報頭)。當緩沖區設置得過多、過大時，常因內存不夠而導致套接字建立失敗。在減小緩沖區後，該錯誤消失。經過實驗，文中選用了4K位元組。

此外，還應注意這兩個函數中最後參數的寫法，給sendto()的最後參數是一個整數值，而recvfrom()的則是指向一整數值的指針。

4.套接字關閉函數：closesocket(SOCKET s)

通訊結束時，應關閉指定的套接字，以釋與之相關的資源。

在關閉套接字時，應先對鎖定的各種緩沖區加以釋放。其程序片斷為：

void CloseSocket(void)
{
GlobalUnlock(hSendData);
GlobalFree(hSenddata);
GlobalUnlock(hReceiveData);
GlobalFree(hReceiveDava);
if(WSAAysncSelect(ss,hwnd,0,0)=SOCKET_ERROR)
{
MessageBos(hwnd,「發送套接字關閉失敗!」，「」，MB_OK);
return;
}
if(WSAAysncSelect(sr,hwnd,0,0)==SOCKET_ERROR)
{
MessageBox(hwnd,「接收套接字關閉失敗!」，「」，MB_OK);
return;
}
WSACleanup();
closesockent(ss);
closesockent(sr);
return;
}
三、Winsock的編程特點與非同步選擇機制

1 阻塞及其處理方式

在網路通訊中，由於網路擁擠或一次發送的數據量過大等原因，經常會發生交換的數據在短時間內不能傳送完，收發數據的函數因此不能返回，這種現象叫做阻塞。Winsock對有可能阻塞的函數提供了兩種處理方式：阻塞和非阻塞方式。在阻塞方式下，收發數據的函數在被調用後一直要到傳送完畢或者出錯才能返回。在阻塞期間，被阻的函數不會斷調用系統函數GetMessage()來保持消息循環的正常進行。對於非阻塞方式，函數被調用後立即返回，當傳送完成後由Winsock給程序發一個事先約定好的消息。

在編程時，應盡量使用非阻塞方式。因為在阻塞方式下，用戶可能會長時間的等待過程中試圖關閉程序，因為消息循環還在起作用，所以程序的窗口可能被關閉，這樣當函數從Winsock的動態連接庫中返回時，主程序已經從內存中刪除，這顯然是極其危險的。

2 非同步選擇函數WSAAsyncSelect()的使用

Winsock通過WSAAsyncSelect()自動地設置套接字處於非阻塞方式。使用WindowsSockets實現Windows網路程序設計的關鍵就是它提供了對網路事件基於消息的非同步存取，用於注冊應用程序感興趣的網路事件。它請求Windows Sockets DLL在檢測到套接字上發生的網路事件時，向窗口發送一個消息。對UDP協議，這些網路事件主要為：

FD_READ 期望在套接字收到數據(即讀准備好)時接收通知；

FD_WRITE 期望在套接字可發送數(即寫准備好)時接收通知；

FD_CLOSE 期望在套接字關閉時接電通知

消息變數wParam指示發生網路事件的套接字，變數1Param的低位元組描述發生的網路事件，高字包含錯誤碼。如在窗口函數的消息循環中均加一個分支：

int ok=sizeof(SOCKADDR);
case wMsg;
switch(1Param)
{
case FD_READ:
//套接字上讀數據
if(recvfrom(sr.lpPlayData[j],dwDataSize,0,(struct sockaddr FAR*)&there1,

(int FAR*)&ok)==SOCKET_ERROR0
{
MessageBox)hwnd,「數據接收失敗!」，「」，MB_OK);
return(FALSE);
}
case FD_WRITE:
//套接字上寫數據
}
break；
在程序的編制中，應根據需要靈活地將WSAAsyncSelect()函靈敏放在相應的消息循環之中，其它說明可參見文獻[1]。此外，應該指出的是，以上程序片斷中的消息框主要是為程序調試方便而設置的，而在正式產品中不再出現。同時，按照程序容錯誤設計，應建立一個專門的容錯處理函數。程序中可能出現的各種錯誤都將由該函數進行處理，依據錯誤的危害程度不同，建立幾種不同的處理措施。這樣，才能保證雙方通話的順利和可靠。

四、結論

本文是多媒體網路傳輸項目的重要內容之一，目前，結合硬體全雙工語音卡等設備，已經成功地實現了話音的全雙工的通信。有關整個多媒體傳輸系統設計的內容，將有另文敘述。

G. 求用udp發廣播消息的C代碼。

//發送端程序

#include <stdio.h>
#include <winsock.h>

int main(int argc, char* argv[])
{
WSADATA wsaData; //指向WinSocket信息結構的指針
SOCKET sockListener;
SOCKADDR_IN sin,saUdpServ;
BOOL fBroadcast = TRUE;
char sendBuff[1024];
int nSize;
int ncount=0;
if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//進行WinSocket的初始化
{
printf("Can't initiates windows socket!Program stop.\n");//初始化失敗返回-1
return -1;
}
sockListener=socket(PF_INET,SOCK_DGRAM,0);
setsockopt ( sockListener,SOL_SOCKET,SO_BROADCAST,

(CHAR *)&fBroadcast,sizeof ( BOOL ));
sin.sin_family = AF_INET;
sin.sin_port = htons(0);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind( sockListener, (SOCKADDR *)&sin, sizeof(sin))!=0)
{
printf("Can't bind socket to local port!Program stop.\n");//初始化失敗返回-1
return -1;
}
saUdpServ.sin_family = AF_INET;
saUdpServ.sin_addr.s_addr = htonl ( INADDR_BROADCAST );
saUdpServ.sin_port = htons (7001);//發送用的埠，可以根據需要更改
nSize = sizeof ( SOCKADDR_IN );
while(1)
{
sprintf(sendBuff,"Message %d",ncount++);
sendto ( sockListener,sendBuff,
lstrlen (sendBuff),
0,
(SOCKADDR *) &saUdpServ,
sizeof ( SOCKADDR_IN ));
printf("%s\n",sendBuff);
}
return 0;
}

/////////////////////

//接收

#include <stdio.h>
#include <winsock.h>
#include <conio.h>

int main(int argc, char* argv[])
{
WSADATA wsaData; //指向WinSocket信息結構的指針
SOCKET sockListener;
SOCKADDR_IN sin,saClient;
char cRecvBuff[1024];
int nSize,nbSize;
int iAddrLen=sizeof(saClient);
if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//進行WinSocket的初始化
{
printf("Can't initiates windows socket!Program stop.\n");//初始化失敗返回-1
return -1;
}
sockListener=socket(AF_INET, SOCK_DGRAM,0);
sin.sin_family = AF_INET;
sin.sin_port = htons(7001);//發送端使用的發送埠，可以根據需要更改
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind( sockListener, (SOCKADDR FAR *)&sin, sizeof(sin))!=0)
{
printf("Can't bind socket to local port!Program stop.\n");//初始化失敗返回-1
return -1;
}
while(1)
{
nSize = sizeof ( SOCKADDR_IN );
if((nbSize=recvfrom (sockListener,cRecvBuff,1024,0,

(SOCKADDR FAR *) &saClient,&nSize))==SOCKET_ERROR)
{
printf("Recive Error");
break;
}
cRecvBuff[nbSize] = '\0';
printf("%s\n",cRecvBuff);

}
return 0;
}