[网络协议]进程间通信

进程间通信的方式

1. Pipe fifo   实现最简单
2. mmap 	非血缘关系进程间
3. 信号		开销小
4. domain	套接字，稳定性最好

使用本地套接字，实现一个本地服务器和多个客户端之间通信
类似

server 作为服务器，接收客户端的数据，保存每个客户端的fd，实现和客户端的双向通信。

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>


#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

#include "wrap.h"

#define MAXLINE 8192
#define SERV_PORT 8000

#define SERV_ADDR  "serv.socket"

//数据的类型
enum TYPE
{
   START,
   KEY, 
   USB
};


//struct buffer{
	char from[2];
	char to[2];
	int type;
	char str[3];
//};

struct s_info {                     //定义一个结构体, 将地址结构跟cfd捆绑
    struct sockaddr_un  cliaddr;
    int connfd;
};


/*
为了适应多进程之间的通信，定义的传递的格式
	form+to+type+内容
	
	form: 1个字节 那个客户端发来的数据
	to: 1个字节   发给谁，可以给服务器，也可以给别的客户端
	type：1个字节  数据类型
//	size: 内容的长度 //因为内容比较少，所以不要大小
	内容：	
*/

//保存客户端的名称+fd
struct s_id{
	char name[4];
	int fd;
};

//客户端名称+fd
struct s_id id[4] = {
	{"A", -1},
	{"B", -1},
	{"C", -1},
	{"D", -1},	
};

void *do_work(void *arg)
{
#if 1
    int n,i;
    struct s_info *ts = (struct s_info*)arg;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];      //#define INET_ADDRSTRLEN 16  可用"[+d"查看

    while (1) {
#if 1
        n = Read(ts->connfd, buf, MAXLINE);                     //读客户端
        if (n == 0) {
            printf("the client %d closed...\n", ts->connfd);
            break;                                              //跳出循环,关闭cfd
        }
	     printf(" n = %d, client bind filename %s\n", n, ts->cliaddr.sun_path);
       
#if 1

        from[0] = buf[0];
        from[1] = '\0';
                
        to[0] = buf[1];
        to[1] = '\0';
        type = buf[2]-'0';

        printf("from  = %s \n", from);
        printf("to = %s \n", to);
        printf("type = %d\n",  type);
	
	if(strcmp(to, "s") == 0){ //发数据给server的
	if(type == START){//开始登陆信号
             printf("start type = %d\n",  type);
	     
	     for(i=0;i<4;i++){
	    	if (strcmp(from,id[i].name) == 0 ){
			id[i].fd = ts->connfd;
			printf("i = %d, fd = %d \n", i, ts->connfd);
		    }
		}
	}
	else if(type == KEY){
		int key = buf[3] - '0';
		printf("key = %d \n", key);
	
	}
	else if(type == USB ){

	}
	}

#endif
 
	for (i = 0; i < n; i++) 
        { 
	   buf[i] = toupper(buf[i]);                           //小写-->大写
	}
        Write(STDOUT_FILENO, buf, n);                           //写出至屏幕
        Write(ts->connfd, buf, n);                              //回写给客户端
#else

  	    n = Read(ts->connfd, buf, MAXLINE);                     //读客户端
        if (n == 0) {
            printf("the client %d closed...\n", ts->connfd);
            break;                                              //跳出循环,关闭cfd
        }
#endif

  }
    Close(ts->connfd);
#endif 
    return (void *)0;
}

int main(void)
{

    int lfd, cfd, len, size, i;
    struct sockaddr_un servaddr, cliaddr;
    char buf[4096];
    struct s_info ts[10];
    pthread_t tid;


    lfd = Socket(AF_UNIX, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sun_family = AF_UNIX;
    strcpy(servaddr.sun_path,SERV_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);     /* servaddr total len */

    unlink(SERV_ADDR);                              /* 确保bind之前serv.sock文件不存在,bind会创建该文件 */
    Bind(lfd, (struct sockaddr *)&servaddr, len);           /* 参3不能是sizeof(servaddr) */

    Listen(lfd, 20);

    printf("Accept ...\n");


    while (1) {
        
        len = sizeof(cliaddr);
        cfd = Accept(lfd, (struct sockaddr *)&cliaddr, (socklen_t *)&len);

        len -= offsetof(struct sockaddr_un, sun_path);      /* 得到文件名的长度 */
        cliaddr.sun_path[len] = '\0';                       /* 确保打印时,没有乱码出现 */

	ts[i].cliaddr = cliaddr;
        ts[i].connfd = cfd;

        /* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */
        pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
        pthread_detach(tid);                                                    //子线程分离,防止僵线程产生.
        i++;
    }

    return 0;
}

client

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>

#include "wrap.h"

#define SERV_ADDR "serv.socket"
#define CLIE_ADDR "clie.socket"

int main(void)
{
    int  cfd, len;
    struct sockaddr_un servaddr, cliaddr;
    char buf[4096];

    cfd = Socket(AF_UNIX, SOCK_STREAM, 0);

    bzero(&cliaddr, sizeof(cliaddr));
    cliaddr.sun_family = AF_UNIX;
    strcpy(cliaddr.sun_path,CLIE_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(cliaddr.sun_path);     /* 计算客户端地址结构有效长度 */

    unlink(CLIE_ADDR);
    Bind(cfd, (struct sockaddr *)&cliaddr, len);                                 /* 客户端也需要bind, 不能依赖自动绑定*/

    
    bzero(&servaddr, sizeof(servaddr));                                          /* 构造server 地址 */
    servaddr.sun_family = AF_UNIX;
    strcpy(servaddr.sun_path,SERV_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);   /* 计算服务器端地址结构有效长度 */

    Connect(cfd, (struct sockaddr *)&servaddr, len);

    while (fgets(buf, sizeof(buf), stdin) != NULL) {
        write(cfd, buf, strlen(buf));
        len = read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, len);
    }

    close(cfd);

    return 0;
}