csocketudp编程

⑴ C语言 socket编程 TFTP服务器与客户端的实现

想要快速入门socket编程，先找嵌入式linux方面的书籍来看，看关于文件操作部分，然后看基于tcp udp的socket编程实例，拿别人代码跑一跑，就能理解了，往后想了解更多，可以往tcpip协议方面看也能往Linux网络编程方面看，对于tftp协议，基于udp来设计，只需要看看别人怎么实现协议的代码，然后用结构体等数据结构将协议的各个段封装进去就行

⑵ 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);
}

⑶ 在windows下用C语言如何实现socket网络编程，需要用到哪些头文件或者库

需要用到的头文件包含：

#include <winsock2.h>

#include <windows.h>

与Linux环境下socket编程相比，windows环境多了一个步骤：启动或者初始化winsock库

Winsock，一种标准API，一种网络编程接口，用于两个或多个应用程序（或进程）之间通过网络进行数据通信。具有两个版本：

Winsock 1:

Windows CE平台支持。

头文件：WinSock.h

库：wsock32.lib

Winsock 2:

部分平台如Windows CE貌似不支持。通过前缀WSA可以区别于Winsock 1版本。个别函数如WSAStartup、WSACleanup、WSARecvEx、WSAGetLastError都属于Winsock 1.1规范的函数；

头文件：WinSock2.h

库：ws2_32.lib

mswsock.h用于编程扩展，使用时必须链接mswsock.dll

(3)csocketudp编程扩展阅读

winsock库的加载与卸载：

加载：int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

加载成功，返回值为0。

WORD wVersionRequested：加载的winsock版本，使用宏MAKEWORD(x, y)，x表示高字节,y表示低字节。然而使用时MAKEWORD(2, 2)。高字节与低字节相同~~

LPWSADATA lpWSAData：WSADATA结构的指针，传入参数后，系统帮助我们填充版本信息。有兴趣的可以看看结构体内容，不过基本用不着。

卸载：int WSACleanup(void);比起加载，卸载的函数真是轻松愉快。

⑷ Linux下的c语言UDP编程

read是直接读取文件，scanf系列函数本身也得用read读取文件。

bind是把socket和地址关联，INADDR_ANY的意思是任何地址。比如你的设备有很多ip，客户端向其中任何一个发送数据你的socket都能接收到。相应地如果你bind一个确定的ip的话，向其他ip发送数据你的socket是接收不到的。

⑸ TCP 和 UDP 在socket编程中的区别

区别:
1.基于连接与无连接
2.对系统资源的要求（TCP较多，UDP少）
3.UDP程序结构较简单
4.流模式与数据报模式
TCP保证数据正确性，UDP可能丢包
TCP保证数据顺序，UDP不保证
具体编程时的区别
socket()的参数不同
UDP Server不需要调用listen和accept
UDP收发数据用sendto/recvfrom函数
TCP：地址信息在connect/accept时确定UDP：在sendto/recvfrom函数中每次均 需指定地址信息

⑹ CSocket之UDP编程

#include <stdio.h>
#include <Winsock2.h>
#pragma comment(lib,"ws2_32.lib")

void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;

wVersionRequested = MAKEWORD( 1, 1);

err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
{
return;
}

if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 )
{
WSACleanup( );
return;
}

SOCKET sersocket=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN seraddr;
seraddr.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
seraddr.sin_family=AF_INET;
seraddr.sin_port=htons(5000);

bind(sersocket,(SOCKADDR*)&seraddr,sizeof(SOCKADDR));

SOCKADDR clientaddr;
int len=sizeof(SOCKADDR);

char revbuf[100];
char sendbuf[100];

recvfrom(sersocket,revbuf,100,0,(SOCKADDR*)&clientaddr,&len);
printf("%s\n",revbuf);
scanf("%s",&sendbuf);
sendto(sersocket,sendbuf,strlen(sendbuf)+1,0,(SOCKADDR*)&clientaddr,len);

closesocket(sersocket);
WSACleanup();
}

#include <stdio.h>
#include <Winsock2.h>
#pragma comment(lib,"ws2_32.lib")

void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;

wVersionRequested = MAKEWORD( 1, 1);

err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
{
return;
}

if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 )
{
WSACleanup( );
return;
}

SOCKET sockclient=socket(AF_INET,SOCK_DGRAM,0);

SOCKADDR_IN clientaddr;
clientaddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
clientaddr.sin_family=AF_INET;
clientaddr.sin_port=htons(5000);

int len=sizeof(SOCKADDR);

char revbuf[100];
char sendbuf[100];
printf("请输入内容：\n");
while(1)
{

scanf("%s",&sendbuf);
sendto(sockclient,sendbuf,strlen(sendbuf)+1,0,(SOCKADDR*)&clientaddr,len);
recvfrom(sockclient,revbuf,100,0,(SOCKADDR*)&clientaddr,&len);
printf("%s\n",revbuf);

}
closesocket(sockclient);
WSACleanup();
}

大同小异，CSocket只是进行了封装而已，原理是一样的，编程要思路灵活才行。

⑺ 简述基于TCP和UDP的Socket编程的异同

Socket有两种主要的操作方式：面向连接的和无连接的。无连接的操作使用UDP数据报协议，这个操作不需要连接一个目的的socket，它只是简单地投出数据报，快速高效，但缺少数据安全性。面向连接的操作使用TCP协议，一个这个模式的socket必须在发送数据之前与目的地的socket取得一个连接，一旦连接建立了，socket就可以使用一个流接口：打开-读-写-关闭，所有的发送的信息都会在另一端以同样的顺序被接收，面向连接的操作比无连接的操作效率要低，但数据的安全性更高。基于TCP的socket编程是采用的流式套接字(SOCK_STREAM)。基于UDP采用的数据报套接字(SOCK_DGRAM).
流式套接字的设计是针对面向连接的网络应用，在数据传输之前需要预先建立连接，在数据传输过程中需要维持连接，在数据传输结束后需要释放连接。由于采用校验和、确认与超时等差错控制手段，因此流式套接字可以保证数据传输的正确性。
数据报套接字（SOCK_DGRAM）提供无连接的、不可靠的数据传输服务，实际上它是基于TCP/IP协议族中的UDP协议实现的。数据报套接字提供无序、有差错与有重复的数据流服务。数据报套接字的设计是针对无连接的网络应用，在数据传输之前不需要预先建立连接。由于只采用很有限的差错控制手段，因此数据报套接字无法保证数据传输的正确性。

⑻ UDP和Socket通信步骤

这是在网上找到的，希望对你有所帮助。
sockets（套接字）编程有三种，流式套接字（SOCK_STREAM），数据报套接字（SOCK_DGRAM），原始套接字（SOCK_RAW）；

WINDOWS环境下TCP/UDP编程步骤：

1. 基于TCP的socket编程是采用的流式套接字。

在这个程序中，将两个工程添加到一个工作区。要链接一个ws2_32.lib的库文件。

服务器端编程的步骤：

1：加载套接字库，创建套接字(WSAStartup()/socket())；

2：绑定套接字到一个IP地址和一个端口上(bind())；

3：将套接字设置为监听模式等待连接请求(listen())；

4：请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept())；

5：用返回的套接字和客户端进行通信(send()/recv())；

6：返回，等待另一连接请求；

7：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。

服务器端代码如下：

#include <stdio.h>

#include <Winsock2.h>

void main()

{

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 1, 1 );

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 ) {

return;

}

if ( LOBYTE( wsaData.wVersion ) != 1 ||

HIBYTE( wsaData.wVersion ) != 1 ) {

WSACleanup( );

return;

}

SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);

SOCKADDR_IN addrSrv;

addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);

addrSrv.sin_family=AF_INET;

addrSrv.sin_port=htons(6000);

bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

listen(sockSrv,5);

SOCKADDR_IN addrClient;

int len=sizeof(SOCKADDR);

while(1)

{

SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);

char sendBuf[50];

sprintf(sendBuf,"Welcome %s to here!",inet_ntoa(addrClient.sin_addr));

send(sockConn,sendBuf,strlen(sendBuf)+1,0);

char recvBuf[50];

recv(sockConn,recvBuf,50,0);

printf("%s\n",recvBuf);

closesocket(sockConn);

}

}

客户端编程的步骤：

1：加载套接字库，创建套接字(WSAStartup()/socket())；

2：向服务器发出连接请求(connect())；

3：和服务器端进行通信(send()/recv())；

4：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。

客户端的代码如下：

#include <stdio.h>

#include <Winsock2.h>

void main()

{

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 1, 1 );

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 ) {

return;

}

if ( LOBYTE( wsaData.wVersion ) != 1 ||

HIBYTE( wsaData.wVersion ) != 1 ) {

WSACleanup( );

return;

}

SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);

SOCKADDR_IN addrSrv;

addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");

addrSrv.sin_family=AF_INET;

addrSrv.sin_port=htons(6000);

connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

char recvBuf[50];

recv(sockClient,recvBuf,50,0);

printf("%s\n",recvBuf);

send(sockClient,"hello",strlen("hello")+1,0);

closesocket(sockClient);

WSACleanup();

}

2.基于UDP的socket编程是采用的数据报套接字。

在这个程序中，将两个工程添加到一个工作区。同时还要链接一个ws2_32.lib的库文件。

服务器端编程的步骤：

1：加载套接字库，创建套接字(WSAStartup()/socket())；

2：绑定套接字到一个IP地址和一个端口上(bind())；

3：等待和接收数据(sendto()/recvfrom())；

4：关闭套接字，关闭加载的套接字库(closesocket()/WSACleanup())。

服务器端代码如下：

#include <winsock2.h>

#include <stdio.h>

void main()

{

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 1, 1 );

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 )

{

return;

}

if ( LOBYTE( wsaData.wVersion ) != 1 ||

HIBYTE( wsaData.wVersion ) != 1 )

{

WSACleanup( );

return;

}

SOCKET sockSrv=socket(AF_INET,SOCK_DGRAM,0);

SOCKADDR_IN addrSrv;

addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);

addrSrv.sin_family=AF_INET;

addrSrv.sin_port=htons(7003);

bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

char recvBuf[50];

SOCKADDR addrClient;

int len=sizeof(SOCKADDR);

recvfrom(sockSrv,recvBuf,50,0,(SOCKADDR*)&addrClient,&len);

printf("%s\n",recvBuf);

closesocket(sockSrv);

WSACleanup();

}

对于基于UDP的socket客户端来说，要进行如下步骤：

1：创建一个套接字(socket)；

2：向服务器发送数据(sendto);

3：关闭套接字；

代码如下：

#include <winsock2.h>

#include <stdio.h>

void main()

{

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 2, 2 );

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 ) {

return;

}

if ( LOBYTE( wsaData.wVersion ) != 2 ||

HIBYTE( wsaData.wVersion ) != 2 ) {

WSACleanup( );

return;

}

SOCKET sockClient=socket(AF_INET,SOCK_DGRAM,0);

SOCKADDR_IN addrClient;

addrClient.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");

addrClient.sin_family=AF_INET;

addrClient.sin_port=htons(8889);

SOCKADDR_IN addrSrv;

sendto(sockClient,"hi",3,0,(SOCKADDR*)&addrClient,sizeof(SOCKADDR));

}

LINUX环境下TCP/UDP编程步骤：

TCP编程步骤：

一. 服务端：

1.socket(int domain,int type,int protocol):建立套接字；

2 .bind(int sockid,struct sockaddr *addrp,socklen_t addrlen):把本机地址和端口跟上一步建立的socket绑定在一起；

3.listen(int sockid,int qsize):监听某套接字;

4.fd=accept(int sockid,struct sockaddr *callerid,socklen_t *addrlenp):等待某套接字接收信息；

5.recv(int fd,void *buf,size_t nbytes,int flags):从套接字接收数据;

6.close(fd) 和close(sockid)

二.客户端：

1. socket():建立套接字；

2.connect(int sockid,struct sockaddr *serv_addrp,socklen_t addrlen):连接到服务器；

3. send(int sockfd,const void *buf,size_t nbytes,int flags):发送数据到服务器.

4. close(sockid);

UDP编程步骤：

一，服务端：

1. socket():同上；

2. bind():同上；

3. recvfrom(int sockfd,void*buff,size_t nbytes,int flags,struct sockaddr*from,socklen_t*addrlen):在套接字口接收数据，并且记录下接收到的数据来源;一定要注意这里的参数addrlen，它不仅是函数的输出，也是函数的输入！所以要在调用该函数之前对addrlen赋值sizeof(struct sockaddr)。否则返回的地址from将会出错！

4. close(sockfd);

二. 客户端：

1. socket();同上；

2. sendto(int sockfd,const void*buff,size_t nbytes,int flags,const struct sockaddr*to,socklen_t addrlen):往指定的地址发送数据；

3. close(sockfd);

⑼ 怎么写一个socket编程,不管是udp的还是tcp的,可以不在同一个局域网中通信

网络通讯很简单的道理 通许必须有一方是公网地址 这个所谓的公网地址简单理解就是互联网上公开的地址,能够背直接访问的IP地址
那么你如果想实现中国到美国的通讯(下面简称2方通讯)方法有一下几种
方法1:
中国这边或者美国那边至少一方是具有公网IP地址的 具有公网地址的作为服务端 另外一方作为客户端连接(具体实现就是公网一方监听自己的公网地址上的某个端口 客户端直接连接对方的公网地址跟端口即可)( A<=====>B(公网地址) )
方法2:
2方都具有公网地址 那就更简单 互相连接对方的公网地址跟端口即可(A(公网)<======>B(公网))
方法3:
2方都没有公网地址(但是其中一方或者双方都能在路由器上做端口映射 这个问题就转化成了方法2 或者方法1)(A(端口映射)<===========B)
方法4:
2方都没有公网地址也无法做端口映射 这个时候就要假设一个中转的服务器 2方都去连接那个中转服务器 通过服务来转发消息(A(内网)<===============(消息中转服务器)============>B(内网))
目前QQ就是用的这样的消息传送方式

⑽ 有没有windows下c语言实现udp协议的代码

php">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}