1 实现最简单的udp socket 模型，实现发送一个字符串。
2 实现一个简单的打开文件，读取文件的例子，如用fgets(),类似的函数有很多，然后再把读取的文件内容忘另一个文件里写(相关函数fopen(),write(),read())。
3 把上面两个函数结合到一起，在客户端实现打开要传送的文件，按一定的大小读取，读取后调用sendto（）发送到服务器端。在服务器端创建一个文件，然后调用recvfrom（）接受客户端发送过来的数据，向来是创建的那个文件中写。
下面是改好的udp发送文件的例子。
服务器端程序的编译
gcc -o file_server file_server
客户端程序的编译
gcc -o file_client file_client.c
服务器程序和客户端程应当分别运行在2台计算机上.
服务器端程序的运行,在一个计算机的终端执行
./file_server
客户端程序的运行,在另一个计算机的终端中执行
./file_client 运行服务器程序的计算机的IP地址
根据提示输入要传输的服务器上的文件，该文件在服务器的运行目录上
在实际编程和测试中,可以用2个终端代替2个计算机,这样就可以在一台计算机上测试网络程序,
服务器端程序的运行,在一个终端执行
./file_server
客户端程序的运行,在另一个终端中执行
./file_client 127.0.0.1
说明: 任何计算机都可以通过127.0.0.1访问自己. 也可以用计算机的实际IP地址代替127.0.0.1
//////////////////////////////////////////////////////////////////////////////////////
// file_server.c 文件传输顺序服务器示例
//////////////////////////////////////////////////////////////////////////////////////
//本文件是服务器的代码
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
/*
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
*/
#define HELLO_WORLD_SERVER_PORT 6666
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512
int main(int argc, char **argv)
{
//设置一个socket地址结构server_addr,代表服务器internet地址, 端口
struct sockaddr_in server_addr， pcliaddr
bzero(&server_addr,sizeof(server_addr))//把一段内存区的内容全部设置为0
server_addr.sin_family = AF_INET
server_addr.sin_addr.s_addr = htons(INADDR_ANY)
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT)
//创建用于internet的据报套接字（UDPt,用server_socket代表服务器socket
// 创建数据报套接字（UDP）
int server_socket = socket(PF_INET,SOCK_DGRAM,0)
if( server_socket <0)
{
printf("Create Socket Failed!")
exit(1)
}
//把socket和socket地址结构联系起来
if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
{
printf("Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT)
exit(1)
}
while (1) //服务器端要一直运行
{
//定义客户端的socket地址结构client_addr
struct sockaddr_in client_addr
socklen_t n = sizeof(client_addr)
int length
char buffer[BUFFER_SIZE]
bzero(buffer, BUFFER_SIZE)
length = recvfrom(new_server_socket,buffer,BUFFER_SIZE,0,&pcliaddr,&n)
if (length <0)
{
printf("Server Recieve Data Failed!\n")
break
}
char file_name[FILE_NAME_MAX_SIZE+1]
bzero(file_name, FILE_NAME_MAX_SIZE+1)
strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer))
// int fp = open(file_name, O_RDONLY)
// if( fp <0 )
FILE * fp = fopen(file_name,"r")
if(NULL == fp )
{
printf("File:\t%s Not Found\n", file_name)
}
else
{
bzero(buffer, BUFFER_SIZE)
int file_block_length = 0
// while( (file_block_length = read(fp,buffer,BUFFER_SIZE))>0)
while( (file_block_length = fread(buffer,sizeof(char),BUFFER_SIZE,fp))>0)
{
printf("file_block_length = %d\n",file_block_length)
//发送buffer中的字符串到new_server_socket,实际是给客户端
if(send(new_server_socket,buffer,file_block_length,0)<0)
{
printf("Send File:\t%s Failed\n", file_name)
break
}
bzero(buffer, BUFFER_SIZE)
}
// close(fp)
fclose(fp)
printf("File:\t%s Transfer Finished\n",file_name)
}
}
}
//////////////////////////////////////////////////////////////////////////////////////
// file_client.c 文件传输客户端程序示例
//////////////////////////////////////////////////////////////////////////////////////
//本文件是客户机的代码
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
/*
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
*/
#define HELLO_WORLD_SERVER_PORT 6666
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512
int main(int argc, char **argv)
{
if (argc != 2)
{
printf("Usage: ./%s ServerIPAddress\n",argv[0])
exit(1)
}
//设置一个socket地址结构client_addr,代表客户机internet地址, 端口
struct sockaddr_in client_addr
bzero(&client_addr,sizeof(client_addr))//把一段内存区的内容全部设置为0
client_addr.sin_family = AF_INET //internet协议族
client_addr.sin_addr.s_addr = htons(INADDR_ANY)//INADDR_ANY表示自动获取本机地址
client_addr.sin_port = htons(0) //0表示让系统自动分配一个空闲端口
//创建用于internet的流协议(TCP)socket,用client_socket代表客户机socket
int client_socket = socket(AF_INET,SOCK_DGRAM,0)
if( client_socket <0)
{
printf("Create Socket Failed!\n")
exit(1)
}
//设置一个socket地址结构server_addr,代表服务器的internet地址, 端口
struct sockaddr_in server_addr
bzero(&server_addr,sizeof(server_addr))
server_addr.sin_family = AF_INET
if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //服务器的IP地址来自程序的参数
{
printf("Server IP Address Error!\n")
exit(1)
}
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT)
socklen_t server_addr_length = sizeof(server_addr)
char file_name[FILE_NAME_MAX_SIZE+1]
bzero(file_name, FILE_NAME_MAX_SIZE+1)
printf("Please Input File Name On Server:\t")
scanf("%s", file_name)
char buffer[BUFFER_SIZE]
bzero(buffer,BUFFER_SIZE)
strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name))
//向服务器发送buffer中的数据
socklen_t n = sizeof(server_addr)
sendto(client_socket,buffer,BUFFER_SIZE,0,(struct sockaddr*)&server_addr,n)
// int fp = open(file_name, O_WRONLY|O_CREAT)
// if( fp <0 )
FILE * fp = fopen(file_name,"w")
if(NULL == fp )
{
printf("File:\t%s Can Not Open To Write\n", file_name)
exit(1)
}
//从服务器接收数据到buffer中
bzero(buffer,BUFFER_SIZE)
int length = 0
while( length = recv(client_socket,buffer,BUFFER_SIZE,0))
{
if(length <0)
{
printf("Recieve Data From Server %s Failed!\n", argv[1])
break
}
// int write_length = write(fp, buffer,length)
int write_length = fwrite(buffer,sizeof(char),length,fp)
if (write_length<length)
{
printf("File:\t%s Write Failed\n", file_name)
break
}
bzero(buffer,BUFFER_SIZE)
}
printf("Recieve File:\t %s From Server[%s] Finished\n",file_name, argv[1])
return 0
}
用ACE，它提供了很完善的一套构架。#include "ace/SOCK_Dgram_Mcast.h"
#include "ace/INET_Addr.h"
#include "ace/OS.h"
#include "ace/ACE.h"
#include "ace/Log_Msg.h"
int ACE_TMAIN (int argc, char* argv[])
{
ACE_Time_Value ti = ACE_Time_Value (0, 20000)
ACE_INET_Addr local_addr ((u_short) 9000)
ACE_INET_Addr recv_addr
ACE_SOCK_Dgram recv_dgram
//打开端口
if (recv_dgram.open (local_addr) == -1) {
ACE_DEBUG ((LM_ERROR, "%p\n", "Recieving data gram open"))
ACE_OS::exit (-1)
}
ACE_Time_Value t = ACE_Time_Value::zero
while (1) {
//recieve data gram
char buf[2048]
//接收UDP数据，
ssize_t recv = recv_dgram.recv (buf, 2048, recv_addr)
//显示接收了多少数据，以及数据的来源
ACE_DEBUG ((LM_DEBUG, "%M [%t %N:%l] %s:%d recieved %d\n", recv_addr.get_host_addr (), recv_addr.get_port_number (), recv))
if (recv <= 0) {
ACE_DEBUG ((LM_DEBUG, "%M [%t %N:%l] Can't recieve any data gram from the port (%s:%d)\n", recv_addr.get_host_addr (),recv_addr.get_port_number ()))
ACE_OS::sleep (ti)
continue
}
}
return 0
}
一. Linux下UDP编程框架使用UDP进行程序设计可以分为客户端和服务器端两部分。
1.服务器端程序包括：
? 建立套接字
? 将套接字地址结构进行绑定
? 读写数据
? 关闭套接字
2.客户端程序包括：
? 建立套接字
? 读写数据
? 关闭套接字
3.服务器端和客户端程序之间的差别
服务器端和客户端两个流程之间的主要差别在于对地址的绑定函数（bind()函数），而客户端可以不用进行地址和端口的绑定 *** 作。
二.Linux中UDP套接字函数
从图可知，UDP协议的服务端程序设计的流程分为套接字建立，套接字与地址结构进行绑定，收发数据，关闭套接字客户端程序流程为套接字建立，收发数据，关闭套接字等过程。它们分别对应socket(),bind(),sendto(),recvfrom(),和close()函数。
网络程序通过调用socket（）函数，会返回一个用于通信的套接字描述符。Linux应用程序在执行任何形式的I/O *** 作的时候，程序是在读或者写一个文件描述符。因此，可以把创建的套接字描述符看成普通的描述符来 *** 作，并通过读写套接字描述符来实现网络之间的数据交流。
1. socket
1>函数原型:
int socket(int domain,int type,int protocol)
2>函数功能：
函数socket()用于创建一个套接字描述符。
3>形参：
? domain:用于指定创建套接字所使用的协议族，在头文件
中定义。
常见的协议族如下：
AF_UNIX:创建只在本机内进行通信的套接字。
AF_INET:使用IPv4 TCP/IP协议
AF_INET6:使用IPv6 TCP/IP协议
说明：
AF_UNIX只能用于单一的UNIX系统进程间通信，而AF_INET是针对Interne的，因而可以允许在远程主机之间通信。一般把它赋为AF_INET。
? type:指明套接的类型，对应的参数如下
SOCK_STREAM:创建TCP流套接字
SOCK_DGRAM:创建UDP数据报套接字
SOCK_RAW:创建原始套接字
? protocol:
参数protocol通常设置为0，表示通过参数domain指定的协议族和参数type指定的套接字类型来确定使用的协议。当为原始套接字时，系统无法唯一的确定协议，此时就需要使用使用该参数指定所使用的协议。
4>返回值：执行成功后返回一个新创建的套接字；若有错误发生则返回一个-1，错误代码存入errno中。
5>举例：调用socket函数创建一个UDP套接字
int sock_fd
sock_fd = socket(AF_INET,SOCK_DGRAM,0)
if(sock_fd <0){
perror(“socket”)
exit(1)
}
2. bind
1>函数原型：
int bind(int sockfd,struct sockaddr *my_addr,socklen_taddrlen)
2>函数功能
函数bind()的作用是将一个套接字文件描述符与一个本地地址绑定在一起。
3>形参：
? sockfd:sockfd是调用socket函数返回的文件描述符；
? addrlen是sockaddr结构的长度。
? my_addr: 是一个指向sockaddr结构的指针，它保存着本地套接字的地址（即端口和IP地址）信息。不过由于系统兼容性的问题，一般不使用这个结构，而使用另外一个结构(struct sockaddr_in)来代替
4>套接字地址结构：
(1)structsockaddr:
结构struct sockaddr定义了一种通用的套接字地址，它在
Linux/socket.h 中定义。
struct sockaddr{
unsigned short sa_family/*地址类型，AF_XXX*/
char sa_data[14]/*14字节的协议地址*/
}
a. sin_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF_INET.
b. sa_data：存储具体的协议地址。
(2)sockaddr_in
每种协议族都有自己的协议地址格式，TCP/IP协议组的地址格式为结构体struct sockaddr_in,它在netinet/in.h头文件中定义。
struct sockaddr_in{
unsigned short sin_family/*地址类型*/
unsigned short sin_port/*端口号*/
struct in_addr sin_addr/*IP地址*/
unsigned char sin_zero[8]/*填充字节，一般赋值为0*/
}
a. sin_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF_INET.
b. sin_port:是端口号
c. sin_addr:用来存储32位的IP地址。
d. 数组sin_zero为填充字段，一般赋值为0.
e. structin_addr的定义如下：
struct in_addr{
unsignedlong s_addr
}
结构体sockaddr的长度为16字节，结构体sockaddr_in的长度为16字节。可以将参数my_addr的sin_addr设置为INADDR_ANY而不是某个确定的IP地址就可以绑定到任何网络接口。对于只有一IP地址的计算机，INADDR_ANY对应的就是它的IP地址；对于多宿主主机(拥有多个网卡)，INADDR_ANY表示本服务器程序将处理来自所有网络接口上相应端口的连接请求
5>返回值：
函数成功后返回0，当有错误发生时则返回-1，错误代码存入errno中。
6>举例：调用socket函数创建一个UDP套接字
struct sockaddr_in addr_serv,addr_client/*本地的地址信息*/
memset(&serv_addr,0,sizeof(struct sockaddr_in))
addr_serv.sin_family = AF_INET/*协议族*/
addr_serv.sin_port = htons(SERV_PORT)/*本地端口号*/
addr_serv.sin_addr.s_addr = htonl(INADDR_ANY)/*任意本地地址*/
/*套接字绑定*/
if(bind(sock_fd,(struct sockaddr *)&addr_serv),sizeof(structsockaddr_in)) <0)
{
perror(“bind”)
exit(1)
}
3.close
1>函数原型：
int close(intfd)
2>函数功能：
函数close用来关闭一个套接字描述符。
3>函数形参：
? 参数fd为一个套接字描述符。
4>返回值：
执行成功返回0，出错则返回-1.错误代码存入errno中。
说明：
以上三个函数中，前两个要包含头文件
#include
#include
后一个包含：
#include
4.sendto
1>函数原型：
#include
#include
ssize_t sendo(ints,const void *msg,size_t len,int flags,const struct sockaddr *to,socklen_ttolen)
2>函数功能：
向目标主机发送消息
3>函数形参：
? s:套接字描述符。
? *msg:发送缓冲区
? len:待发送数据的长度
? flags:控制选项，一般设置为0或取下面的值
(1)MSG_OOB:在指定的套接字上发送带外数据(out-of-band data),该类型的套接字必须支持带外数据（eg:SOCK_STREAM）.
(2)MSG_DONTROUTE:通过最直接的路径发送数据，而忽略下层协议的路由设置。
? to:用于指定目的地址
? tolen:目的地址的长度。
4>函数返回值：
执行成功后返回实际发送数据的字节数，出错返回-1，错误代码存入errno中。
5>函数举例：
char send_buf[BUFFERSIZE]
struct sockaddr_in addr_client
memset(&addr_client,0,sizeof(struct sockaddr_in))
addr_client.sin_family = AF_INET
addr_client.sin_port = htons(DEST_PORT)
if(inet_aton(“172.17.242.131”,&addr_client.sin_addr)<0){
perror(“inet_aton”)
exit(1)
}
if(sendto(sock_fd,send_buf,len,0,(strut sockaddr*)&addr_client,sizeof(struct sockaddr_in)) <0){
perror(“sendto”)
exit(1)
}
5.recvfrom
1>函数原型：
#include
#include
ssize_t recvfrom(int s,void *buf,size_t len,intflags,struct sockaddr *from,socklen_t *fromlen)
2>函数功能：接收数据
3>函数形参：
? int s:套接字描述符
? buf:指向接收缓冲区，接收到的数据将放在这个指针所指向的内存空间。
? len:指定了缓冲区的大小。
? flags:控制选项,一般设置为0或取以下值
(1)MSG_OOB:请求接收带外数据
(2)MSG_PEEK:只查看数据而不读出
(3)MSG_WAITALL:只在接收缓冲区时才返回。
? *from:保存了接收数据报的源地址。
? *fromlen:参数fromlen在调用recvfrom前为参数from的长度，调用recvfrom后将保存from的实际大小。
4>函数返回值：
执行成功后返回实际接收到数据的字节数，出错时则返回-1，错误代码存入errno中。
5>函数实例：
char recv_buf[BUFFERSIZE]
struct sockaddr_in addr_client
int src_len
src_len = sizeof(struct sockaddr_in)
int src_len
src_len = sizeof(struct sockaddr_in)
if(recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(structsockaddr *)&src_addr,&src_len)<0){
perror(“again_recvfrom”)
exit(1)
}
三.UDP编程实例
客户端向服务器发送字符串Hello tiger,服务器接收到数据后将接收到字符串发送回客户端。
1.服务器端程序
1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8 #include
9
10 #define SERV_PORT 3000
11
12 int main()
13 {
14 int sock_fd//套接子描述符号
15 int recv_num
16 int send_num
17 int client_len
18 char recv_buf[20]
19 struct sockaddr_in addr_serv
20 struct sockaddr_in addr_client//服务器和客户端地址
21 sock_fd = socket(AF_INET,SOCK_DGRAM,0)
22 if(sock_fd <0){
23 perror("socket")
24 exit(1)
25 } else{
26
27 printf("sock sucessful\n")
28 }
29 //初始化服务器断地址
30 memset(&addr_serv,0,sizeof(struct sockaddr_in))
31 addr_serv.sin_family = AF_INET//协议族
32 addr_serv.sin_port = htons(SERV_PORT)
33 addr_serv.sin_addr.s_addr = htonl(INADDR_ANY)//任意本地址
34
35 client_len = sizeof(struct sockaddr_in)
36 /*绑定套接子*/
37 if(bind(sock_fd,(struct sockaddr *)&addr_serv,sizeof(struct sockaddr_in))<0 ){
38 perror("bind")
39 exit(1)
40 } else{
41
42 printf("bind sucess\n")
43 }
44 while(1){
45 printf("begin recv:\n")
46 recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_client,&client_len)
47 if(recv_num <0){
48 printf("bad\n")
49 perror("again recvfrom")
50 exit(1)
51 } else{
52 recv_buf[recv_num]='\0'
53 printf("recv sucess:%s\n",recv_buf)
54 }
55 printf("begin send:\n")
56 send_num = sendto(sock_fd,recv_buf,recv_num,0,(struct sockaddr *)&addr_client,client_len)
57 if(send_num <0){
58 perror("sendto")
59 exit(1)
60 } else{
61 printf("send sucessful\n")
62 }
63 }
64 close(sock_fd)
65 return 0
66 }
2.客户端程序
1 #include
2 #include
3 #include
4 #include
5 #include
6
7 #include
8 #include
9 #include
10
11 #define DEST_PORT 3000
12 #define DSET_IP_ADDRESS "192.168.1.103"
13
14 int main()
15 {
16 int sock_fd/*套接字文件描述符*/
17 int send_num
18 int recv_num
19 int dest_len
20 char send_buf[20]={"hello tiger"}
21 char recv_buf[20]
22 struct sockaddr_in addr_serv/*服务端地址，客户端地址*/
23
24 sock_fd = socket(AF_INET,SOCK_DGRAM,0)//创建套接子
25 //初始化服务器端地址
26 memset(&addr_serv,0,sizeof(addr_serv))
27 addr_serv.sin_family = AF_INET
28 addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS)
29 addr_serv.sin_port = htons(DEST_PORT)
30
31 dest_len = sizeof(struct sockaddr_in)
32 printf("begin send:\n")
33 send_num = sendto(sock_fd,send_buf,sizeof(send_buf),0,(struct sockaddr *)&addr_serv,dest_len)
34 if(send_num <0){
35 perror("sendto")
36 exit(1)
37 } else{
38
39 printf("send sucessful:%s\n",send_buf)
40 }
41 recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_serv,&dest_len)
42 if(recv_num <0 ){
43
44 perror("recv_from")
45 exit(1)
46 } else{
47 printf("recv sucessful\n")
48 }
49 recv_buf[recv_num]='\0'
50 printf("the receive:%s\n",recv_buf)
51 close(sock_fd)
52 return 0
53 }
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）