Linux下C语言Hello-Hi 网络聊天室

1.socket原理

　　socket通信就是通过IP和端口号将两台主机建立连接，提供通信。主机A的应用程序要能和服务器B进行通信，必须通过Socket建立连接，而建立Socket连接本质上就是依靠TCP/IP协议来建立TCP连接。TCP协议是传输层协议，建立TCP连接还需要用到底层的各种协议的服务，其中最主要的是依靠IP协议来寻找网络中的主机。处于网络层的IP协议可以通过地址找到所要寻找的目标主机，但是一台主机可能运行着多个应用程序，我们必须指定TCP或UDP的地址（端口号）的确定端口号，因此一个Socket实例唯一代表一个主机上的应用程序的通信链路。

2.socket通信流程

服务端：初始化 socket套接字(socket)----->绑定socket(bind)---->对端口进行监听（listen）----->阻塞（accept）----->接受数据（处理数据），根据需要返回结果

客户端：初始化 socket套接字（socket）------>发送连接请求（connect），如果连接成功，客户端发送数据请求，等待服务器端返回数据

3.socket编程函数

int  socket(int protofamily, int type, int protocol);//返回sockf

sockfd是描述符。socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

protofamily：即协议域，又称为协议族（family）。常用的协议族有，AF_INET(IPV4)、AF_INET6(IPV6)、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。

type：指定socket类型。常用的socket类型有，SOCK_STREAM（TCP）、SOCK_DGRAM（UDP）、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等

protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议，当protocol为0时，会自动选择type类型对应的默认协议。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。

addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是： 

struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};

addrlen：对应的是地址的长度。

int listen(int sockfd, int backlog);

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); //返回连接connect_fd

server.c

#include<stdio.h>
#include<unistd.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<ctype.h>
#include<arpa/inet.h>
#include<strings.h>
#include "wrap.h"
#include<string.h>

#define SERV_PORT 6666
#define SERV_IP "127.0.0.1"

int main(){
    int lfd, cfd, err;
    struct  sockaddr_in serv_addr, clie_addr;   //define in <netinet/in.h>
    socklen_t  clie_addr_len;
    char buf[BUFSIZ], clie_IP[BUFSIZ];   
    int n;  


    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);   
    lfd = Socket(AF_INET, SOCK_STREAM, 0);

    Bind(lfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr));
    Listen(lfd, 128);   
    clie_addr_len = sizeof(clie_addr);
    cfd =  Accept(lfd, (struct sockaddr *)&clie_addr,  &clie_addr_len); 

    printf("client IP: %s, client port: %d
", inet_ntop(AF_INET, 
&clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)), 
ntohs(clie_addr.sin_port));

    while (1)
    {
        n = read(cfd, buf, sizeof(buf));  
            buf[i] = toupper(buf[i]);
         }
    write(cfd, buf, n);
    */
        char s[] = "Hi, there!";
        strcpy(buf, s);
        write(cfd,buf, strlen(buf));
    } 

    close(lfd);
    close(cfd);

    return 0;

    

}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include "wrap.h"

#define SERV_PORT 6666
#define SERV_IP  "127.0.0.1" 
int main(){
    int cfd;
    struct sockaddr_in serv_addr;
    char buf[BUFSIZ];
    ssize_t n;

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET, SERV_IP,  &serv_addr.sin_addr.s_addr);

    cfd = Socket(AF_INET, SOCK_STREAM, 0);

    Connect(cfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    while (1)
    {
        fgets(buf, sizeof(buf), stdin);  
        write(cfd, buf, strlen(buf));    
        n = Read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, n);  
    }

    close(cfd);
    return 0;
}

wrap.c

　

#include<error.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<errno.h>
void perr_exit(const char *s){
    perror(s);
    exit(1);
}

int Socket(int domain, int type, int protocol){  
    int n = socket(domain, type, protocol);
    if (n == -1)
        perr_exit("socket error");
    return n;
}

void Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen){
    if(bind(sockfd, addr, addrlen) == -1)
        perr_exit("bind error");
    return;
}

void Listen(int sockfd, int backlog){
    if( listen(sockfd, backlog) == -1)
        perr_exit("listen error");
    return;
}

int Accept(int sockfd, struct sockaddr *addr , socklen_t *addrlen){   //慢速系统调用: accept()  /   read()
    again:{
        int n = accept(sockfd, addr, addrlen);
        if(n == -1){
           if(errno == EINTR || errno == ECONNABORTED){
               goto again;
           }else
           {
               perr_exit("accept error");
           }
        }
    return n;}
}

void Connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen){
    if(connect(sockfd, addr, addrlen) == -1)
        perr_exit("connect error");
    return;
}

ssize_t Read(int fd, void *buf, size_t count){   //慢速系统调用
    ssize_t n;
    again:
        n = read(fd, buf, count);
        if(n == -1){
            if(errno == EINTR || errno == EAGAIN){
                goto again;
            }else
            {
                perr_exit("read error");
            }
        }
return n;
}

编译运行：

gcc server.c wrap.c -o server

gcc client.c wrap.c -o client

./server

./client

截图：