基于多台linux主机通过1台服务器进行socket通讯小程序编写

前言：

最近写个代码要应用到socket通信，之前一直都在搞linux底层驱动，好久没接触到应用层了，复习一下。

一、socket通信简介

socket是一个网络传输的基本接口，类似于io中open，socket实际打开一个网络设备，返回一个fd。而socke可分类为SOCK_STREAM：流式套接字，传输数据的时候是一字节流传输（通过面向连接，tcp）、SOCK_DGRAM ：数据包套接字，传输的时候以数据报(长度不定）(通过面向非连接，udp)、SOCK_RAW ：原始套接字,主要是去操作底层的协议(ping的实现， icmp协议)。其实就是“open—write/read—close”模式的一种实现，那么socket就提供了这些操作对应的函数接口。下面以TCP为例，介绍几个基本的socket接口函数。

二、重要函数

1.创建套接字

int socket(int domain, int type, int protocol);
参数：　通信域－－本机／跨机器通信
AF_UNIX/AF_LOCAL：　本机通信
AF_INET　：跨机器通信--用的协议族ipv4
参数2：传输什么类型是数据
SOCK_STREAM: 传输是字节流---tcp
SOCK_DGRAM ：传输的是数据报-- udp
SOCK_RAW ： 传输的是内部协议--icmp


参数3：具体是哪个协议--0

用法：
tcp编程：
socket(AF_INET, SOCK_STREAM, 0);


udp编程:
socket(AF_INET, SOCK_DGRAM, 0);

2, bind将进程和端口号和ip地址(当前主机)进行绑定，就可以被别人连接
 int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
参数1：当前的创建的ｓｏｃｋｅｔ
参数２：地址和端口的信息
参数3：地址和信息的长度


地址和端口的信息：struct sockaddr *addr　（通用地址）
实际用：　struct sockaddr_in
struct sockaddr_in
 {           
  u_short sin_family;      // 地址族, AF_INET，2 bytes
  u_short sin_port;      // 端口，2 bytes, 自己选择，转换成网络端字节序( 大端)htons();
  struct in_addr sin_addr;  // IPV4地址，4 bytes
  char sin_zero[8];        // 8 bytes unused，作为填充
 }; 


struct in_addr
{
in_addr_t  s_addr;            // u32 network address 
};


初始化struct sockaddr_in
struct sockaddr_in  self_addr;
self_addr.sin_family = AF_INET;
self_addr.sin_port = htons(9999);
self_addr.sin_addr.s_addr = inet_addr("192.168.7.5");


使用： grep -rHn 'struct sockaddr_in'  /usr/include/
#include <linux/in.h>
int bind(fd, （const struct sockaddr * ）&self_addr,   sizeof(self_addr));

3, listen();表示监听，设置在同一时间点，可以同时连接的最大的客户端的个数
int listen(int sockfd, int backlog);
参数2：最大的客户端的个数，　５－１０

４，accept()等待客户端的连接，阻塞
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
参数1： 服务端的创建的socket对应的fd
参数2,3表示客户端的信息，当然也可以不关心对方是谁，就可以填NULL， NULL
返回值：返回一个新的文件描述符，和客户端进行数据通信的
最简单的用法：
int  new_fd = accept(fd, NULL, NULL);

5.int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
参数2：表示连接到哪个服务器，需要给出信息

三、A for B to C 小程序编写

#ifndef __NET_H__
#define __NET_H__
#include <stdio.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <poll.h>
#include "list.h"

struct node_list{
    int fd;
    char mark;
    /*client node*/
    struct list_head node;
};

client：

#include "net.h"
#define SRV_PORT 9999

int main(int argc, char *argv[])
{
if(argc < 2)
{
printf("usage :  ./client  serverip\n");
exit(1);
}

int ret;
char keybuf[128];
char rbuf[128];
int len = 0;
int fd = socket(AF_INET, SOCK_STREAM, 0);
if(fd < 0)
{
perror("socket");
exit(1);
}
// connect
struct sockaddr_in peer;
peer.sin_family = AF_INET;
peer.sin_port = htons(SRV_PORT);
//inet_aton(SRV_IP, &peer.sin_addr);    
inet_aton(argv[1], &peer.sin_addr);    

ret = connect(fd, (struct sockaddr *)&peer, sizeof(peer));
if(ret < 0)
{
perror("connect");
exit(1);
}    
// 监控多个文件
struct pollfd pfd[2];
pfd[0].fd = 0;
pfd[0].events |= POLLIN;
pfd[1].fd = fd;
pfd[1].events |= POLLIN;
while(1)
{
ret = poll(pfd, 2, -1);
if(ret > 0)
{
if(pfd[0].revents & POLLIN) //键盘有输入
{
printf("请输入信息：");
len = read(0, keybuf, 128);
write(fd, keybuf, len);  //发送到服务端
bzero(keybuf,sizeof(keybuf));
printf("\n");
}
if(pfd[1].revents & POLLIN)
{
ret = read(fd, rbuf, 128);  
if(ret == 0)
{
printf("服务器失连！！\n");
exit(1);
}
rbuf[ret] = '\0';
printf("接收到");
printf("%s\n", rbuf);
}
}
}
close(fd);
return 0;
}

server：

#include "net.h"
#include "list.h"
#define SRV_PORT 9999

int main(int argc, char *argv[])
{
if(argc < 1)
{
printf("Usage: ./server port");
exit(1);
}
int srv_fd = -1;
int new_fd = -1;
int ret = -1;
char buf[128];
char ch = 'A';
LIST_HEAD(client_list);//创建链表client_list
//创建sockt接口
srv_fd = socket(AF_INET, SOCK_STREAM, 0);
if(srv_fd < 0)
{
perror("socket");
exit(1);
}
//配置socket接口
int on = 1;
ret = setsockopt(srv_fd,  SOL_SOCKET, SO_REUSEADDR,  &on, sizeof(on));
if(ret < 0)
{
perror("setsockopt");
exit(1);
}
//端口绑定
struct sockaddr_in self;
self.sin_family = AF_INET;
self.sin_port = htons(SRV_PORT);
//self.sin_addr.s_addr = inet_addr("192.168.7.5");
self.sin_addr.s_addr = htonl(INADDR_ANY); //本机ip
ret = bind(srv_fd, (const struct sockaddr *)&self, sizeof(self));
if(ret < 0)
{
perror("bind");
exit(1);
}
//监听
listen(srv_fd, 6);
printf("|-_-| :等待client连接~~~~~\n");
// 初始化select
int maxfd = srv_fd;    
fd_set rd_set;
FD_ZERO(&rd_set);


while(1)
{ 
//FD_SET(0, &rd_set);//监控键盘
FD_SET(srv_fd, &rd_set);

struct node_list *pnode;
if(!list_empty(&client_list))//查看链表内部是否为空
{//遍历链表，并设置每个fd监听
list_for_each_entry(pnode,&client_list,node)
{
FD_SET(pnode->fd, &rd_set);
}
}
ret = select(maxfd+1, &rd_set, NULL, NULL, NULL);
if(ret > 0) //表示有响铃--有数据
{
/*if(FD_ISSET(0, &rd_set))//表示有键盘输入
 {
fgets(buf, 128, stdin); //此时不需要等了，一定可以拿到数据
if(new_fd > 0)
{
write(new_fd, buf, 128); 
}
else
{
printf("keybuf = %s\n", buf);
}
 }*/
if(FD_ISSET(srv_fd, &rd_set))//表示有client连接
{
struct sockaddr_in client_addr;
socklen_t len = sizeof(client_addr);
new_fd = accept(srv_fd, (struct sockaddr *)&client_addr, &len);
if(new_fd < 0)
{
perror("accept");
exit(1);
}
//加入到链表中统一管理
struct node_list *new_node = malloc(sizeof(struct node_list));
new_node->fd = new_fd;
new_node->mark = ch;
ch = (char)(ch + 1);
list_add_tail(&new_node->node, &client_list);//将已连接的客户fd以及标志存入链表client_list中
printf("%c客户端(%s)已连接---\n",new_node->mark,inet_ntoa(client_addr.sin_addr)); 

//设定最大值
struct node_list *pnode;
list_for_each_entry(pnode,&client_list, node)
{
if(maxfd < pnode->fd)
maxfd = pnode->fd;
}
maxfd+=1;
}    

struct node_list *pnode,*tnode,*pnode_tag;
list_for_each_entry(pnode,&client_list, node)
{
if(FD_ISSET(pnode->fd, &rd_set)) //表示客户端有数据
{
//读取客户端发来的数据
ret = read(pnode->fd, buf, 128);
buf[ret] = '\0';
printf("%c--->%s \n",pnode->mark,buf);
if(ret < 0)
{
perror("read");
exit(1);
}
if(ret == 0)
{
printf("%c客户端已断开连接---\n",pnode->mark); 
FD_CLR(pnode->fd,&rd_set);//从取消该fd监控
list_del_init(&pnode->node);// 从链表中移除
close(pnode->fd);//关闭连接
free(pnode);
ch=(char)(ch-1);//移除客户端编号
break;
}
list_for_each_entry(pnode_tag,&client_list,node)
{
if(pnode_tag->mark == buf[0])
{
//write(pnode_tag->fd,buf,128);
tnode=pnode_tag;
}
}
//发送数据到目标客户端
buf[0]=pnode->mark;
int ret=write(tnode->fd,buf,128);
if(ret < 0)
{
perror("write");
exit(1);
}
}
}
}
}
close(srv_fd);
return 0;
}