linux网络编程
实现一个简单的Client/Server通信的程序：
服务器端和客户端的通信过程：
1. 服务器端：
1) 服务器端创建套接字(socket() )
2) 服务器端将套接字绑定到本机端口( bind() )
3) 服务器端的套接字转化为监听套接字( listen() )
4) 服务器端阻塞等待客户端发送信息到服务器( accept() )
5) 服务器端读取客户端的数据( read() )
6) 服务器端向客户端发送数据( write() )
7) 关闭连接(close() )
2.客户端：
1) 创建客户端套接字(socket() )
2) 向服务器端请求连接 (connect() )
3) 向服务器端写数据 (writ())
4) 接收服务器端的数据 (read ())
5) 关闭连接 (close())
编程常用数据结构和API：
1)定义套接字地址结构
# include<linux/socket.h>
struct sockaddr{ // 通用的套接字地址
unsigned short sa_family ; // 地址类型 AF_XXX
char sa_data[14]; // 协议地址
}
struct sockaddr_in{ //TCP/IP族的套接字地址
unsigned short sin_family; //地址类型
unsigned short int sin_port ; //端口号
struct in_addr sin_addr; //IP地址
unsigned char sin_zero[8]; //填充字节
struct in_addr{ // IP地址
unsigned long s_addr;
}
设置服务器地址的一个示例代码如下：
struct sockaddr_in sock;
memset(&sock,0,sizeof(sockaddr_in));
sock.sin_family=AF_INET;
sock.sin_port=80;
inet_aton("127.0.0.1",&sock.sin_addr)
其中，inet_aton 和 memset函数的定义如下：
#include<netinet/in.h>
#include<arpa/inet.h>
int inet_aton(const char *cp,struct in_addr *inp) //将cp所指向的字符串转化为二进制的网络字节顺序的IP地址
memset(void *s,int c,size_t n) //将s所指向的前n个字节赋成参数c所指定的值
2)创建套接字
#include<sys/types.h>
#include<sys/socket.h>
int socket(int domain,int type,int protocol)
// domain: AF_INET。。。
// type: 套接字类型 (SOCK_STREAM: TCP流套接字 | SOCK_DGRAM: UDP流套接字 )
// protocol =0
3) 绑定套接字(将创建套接字和服务器地址绑定)
#include <sys/types.h>
#include <sys/socket.h>
int bind (int sockfd, struct sockaddr * my_addr, socklen_t addlen)
4) 建立监听（将套接字转换为监听套接字）
#include<sys/socket.h>
int listen(int s, int backlog)
//s: 套接字
//backlog : 定义连接请求队列的长度
5) 服务器端阻塞等待客户端连接请求
#include <sys/types>
#include <sys/socket>
int accept(int s, struct sockaddr_in * addr, socket_t addrlen);
6) 客户端请求连接
#inlcude <sys/types.h>
#inlcude <sys/socket.h>
int connect (int sockfd,const struct sockaddr *serv_addr,socklen_t addrlen);
//sockfd:套接字
//serv_addr :服务器地址结构体
//addrlen : 地址结构体的长度
7) 接收数据
#inlcude <sys/types.h>
#inlcude <sys/socket.h>
size_t recv(int s, void * buf, size_t len, int flags);
//返回发送数据的长度
8) 发送数据
#inlcude <sys/types.h>
#inlcude <sys/socket.h>
size_t send(int s, const void* msg, size_t len, int flags);
//返回发送数据的长度
下面来看三个实例~
1） 基于TCP 协议的服务器端和客户端通信程序：
///服务器端 my_server.c
#include <sys/type.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <errno.h>
#include "my_recv.h" //自定义头文件
#define SERV_PORT 4507 // 服务器端口
#define LISTENQ 12 // 连接请求队列的最大长度
//发送数据
void send_data(int conn_fd,const char* string)
{
if( send(conn_fd,srtring,strlen(string),0)<0) {
// my_err("send",__LINE__); // my_err 函数在my_recv.h 中声明
printf("send error\n");
exit(1);
}
}
int main() {
int sock_fd,conn_fd;
int optval;
int ret;
int name_num;
pit_t pid;
socklen_t cli_len;
struct sockaddr_in cli_addr,serv_addr;
char recv_buf[128];
//创建TCP套接字
sock_fd = socket(AF_INET,SOCK_STREAM,0);
if(sock_fd<0){
my_err("socket",__LINE__);
}
//设置该套接字使之可以重新绑定端口
optval=1;
if(setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,(void *)optval,sizeof(int)<0){
// my_err("setsockopt",__LINE__);
printf("setsockopt error\n");
exit(1);
}
//初始化服务器端地址结构
memset(&serv_addr,0,sizeof(struct sockaddr_in));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port = htons(SERV_PORT);
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
//将套接字绑定到本地端口
if (bind(sock_fd,(struct sockaddr *)&serv_addr, sizeof(struct sockaddr_in))<0){
//my_err("bind",__LINE__);
printf("bind error\n");
exit(1);
}
//将套接字转化为监听套接字
if (listen(sock_fd,LISTENQ)<0){
//my_err("listen",__LINE__);
printf("listen error\n");
exit(1);
}
cli_len=sizeof(struct sockaddr_in);
while(1){
//主进程通过accept阻塞等待客户端的连接请求，并返回连接套接字用于收发数据
conn_fd= accept(sock_fd,(struct sockaddr*)&cli_addr,&cli_len);
if(conn_fd<0){
//my_err("accept",__LINE__);
printf("accept error\n");
exit(1);
}
//创建子进程处理接收到的连接请求
if ((pid=fork())==0){ //子进程
while(1){
if((ret=recv(conn_fd,recv_buf,sizeof(recv_buf),0))<0)<0){
perror("recv");
exit(1);
}
printf("the received data is:%s \n",recv_buf);
send_data(conn_fd,"I've just received data: %s\n",recv_buf);
}
close(sock_fd);
close(conn_fd);
exit(0); //结束子进程
}
return 0;
}
///客户端 myclient.c
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<errno.h>
#include<arpa/inet.h>
int main(int argc,char **argv){
int i;
int ret;
int conn_fd;
int serv_port=4507;
char *strIP="127.0.0.1";
struct sockaddr_in serv_addr;
char input_buf[BUFSIZE]="Hello Joan!";
char recv_buf[BUFSIZE];
//初始化服务器端地址结构
memset(&serv_addr,0,sizeof(struct sockaddr_in));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(serv_port);
inet_aton(strIP,&serv_addr.sin_addr);
//创建一个TCP套接字
conn_fd=socket(AF_INET,SOCK_STREAM,0);
if(conn_fd<0){
printf("client socket error\n");
exit(1);
}
//向服务器发送连接请求
if(connect(conn_fd,(struct sock_addr *)&serv_addr,sizeof(sock_addr))<0){
printf("client connect error\n");
exit(1);
}
//向服务器发送数据
if(send(conn_fd,input_buf,strlen(input_buf),0)<0){
printf("client send error\n");
exit(1);
}
// 读取服务器发送的数据
if((ret=recv(conn_fd,recv_buf,sizeof(recv_buf),0)<0){
printf("data too long\n");
exit(1);
}
printf("the received data from server is: %s\n",recv_buf);
close(conn_fd);
return 0;
}
2) 实现将一个文件分割为N份发送到服务器端，在服务器端再重组文件的程序：
3) 实现一个简单的端口扫描程序:
// 基于UDP 协议的服务器端和客户端通信程序：