socket套接字编程

利用socket套接字编写的C/S网络模型

单进程版本：

server只能有一个client连接，这是基于tcp可靠连接的网络服务模型。编写流程是先创建socket套接字，再绑定端口，再将server设置为监听状态，此时基于tcp的套接字就创建完成了。剩下的工作就像是进程间通信中的管道一样，只不过这里的管道是套接字。 
//tcp_server.c

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

void usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_prot]\n", proc);
}
int startup(const char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0){
        perror("socket");
        exit(2);
    }
    printf("sock: %d\n", sock);
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);//主机转网络
    local.sin_addr.s_addr = inet_addr(ip);//先将点分十进制转换成四字节，再将四字节转网络地址
    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){//绑定
        perror("bind");
        exit(3);
    }
    if(listen(sock, 10) < 0){// 设置套接字为监听状态
        perror("listen");
        exit(4);
    }
    return sock;
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        usage(argv[0]);
        return 1;
    }
    int listen_sock = startup(argv[1], atoi(argv[2]));
    struct sockaddr_in client;
    while(1){
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if(new_sock < 0){
            perror("accept");
            continue;
        }
        printf("get new client[%s:%d]\n", inet_ntoa(client.sin_addr),ntohs(client.sin_port));

        while(1){
            char buf[1024];
            ssize_t s = read(new_sock, buf, sizeof(buf)-1);
            if(s > 0){
                buf[s] = 0;
                printf("client# %s\n", buf);
                write(new_sock, buf, strlen(buf));
            }else if(s == 0){
                printf("client close!!!\n");
                break;
            }else{
                perror("read");
                break;
            }
        }
    }
    return 0;
}

//tcp_client.c 
client套接字的创建流程和server是一样的，只是client作为客户端只有连别人，没有人连它，所以不需要设置为监听状态。

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<string.h>

void usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_port]\n", proc);
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0){
        perror("socket");
        return 2;
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    if(connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0){
        perror("connect");
        return 3;
    }
    char buf[1024];
    while(1){
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf)-1);
        if(s > 0){
            buf[s-1] = 0;
            write(sock, buf, strlen(buf));
            ssize_t _s = read(sock, buf, sizeof(buf)-1);
            if(_s > 0){
                buf[_s] = 0;
                printf("server echo# %s\n", buf);
            }
        }
    }
    close(sock);
    return 0;
}

测试结果：

多进程版的server：

#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>

void usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_port]\n", proc);
}
int startup(char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0){
        perror("socket");
        return 2;
    }
    printf("sock: %d\n", sock);
    struct sockaddr_in peer;
    peer.sin_family = AF_INET;
    peer.sin_port = htons(port);
    peer.sin_addr.s_addr = inet_addr(ip);
    if(bind(sock, (struct sockaddr*)&peer, sizeof(peer)) < 0){
        perror("bind");
        return 3;
    }
    if(listen(sock, 10) < 0){
        perror("listen");
        return 4;
    }
    return sock;
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        usage(argv[0]);
        return 1;
    }
    int listen_sock=startup(argv[1], atoi(argv[2]));
    struct sockaddr_in client;
    while(1){
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if(new_sock < 0){
            perror("accept");
            continue;
        }
        printf("get new client[%s:%d]\n",inet_ntoa(client.sin_addr), ntohs(client.sin_port));
        char buf[1024];
        pid_t id = fork();
        if(id < 0){
            perror("fork");
            close(new_sock);
        }else if(id == 0){//child
            close(listen_sock);
            if(fork() > 0){
                exit(1);
            }
            while(1){
                ssize_t s = read(new_sock, buf, sizeof(buf)-1);
                if(s > 0){
                    buf[s] = 0;
                    printf("client# %s\n", buf);
                    write(new_sock, buf, strlen(buf));
                }else if(s == 0){
                    printf("client is quit!!!\n");
                    break;
                }else{
                    perror("read");
                    break;
                }
            }
            close(new_sock);
        }else{//father
            close(new_sock);
            waitpid(id, NULL, 0);
        }
    }
    return 0;
}

测试结果：

一个server能创建多少个进程由你的系统说了算。所以server的处理能力和硬件支持有关

多线程版的server：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<string.h>
#include<pthread.h>

void usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_prot]\n", proc);
}
int startup(const char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0){
        perror("socket");
        exit(2);
    }
    printf("sock: %d\n", sock);
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);//主机转网络
    local.sin_addr.s_addr = inet_addr(ip);//先将点分十进制转换成四字节，再将四字节转网络地址
    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){//绑定
        perror("bind");
        exit(3);
    }
    if(listen(sock, 10) < 0){// 设置套接字为监听状态
        perror("listen");
        exit(4);
    }
    return sock;
}
void *request(void *arg)
{
//  close(listen_sock);
    int new_sock = (int)arg;
    while(1){
        char buf[1024];
        ssize_t s = read(new_sock, buf, sizeof(buf));
        if(s > 0){
            buf[s] = 0;
            printf("client# %s\n", buf);
            write(new_sock, buf, strlen(buf));
        }else if(s == 0){
            printf("client close!!!\n");
            break;
        }else{
            perror("read");
            break;
        }
    }
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        usage(argv[0]);
        return 1;
    }
    int listen_sock = startup(argv[1], atoi(argv[2]));
    struct sockaddr_in client;
    while(1){
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if(new_sock < 0){
            perror("accept");
            continue;
        }
        printf("get new client[%s:%d]\n", inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        pthread_t id;
        pthread_create(&id, NULL, request, (void*)new_sock);
        pthread_detach(id);
    }
    return 0;
}

测试结果：

一个server能连接多少个client由硬件说了算。

基于UDP版本的C/S网络模型

UDP是无连接的，不可靠的传输协议，它是按照数据块大小传输的。所以编写服务器模型时不需要监听和accept，谁相连就连想断就断，不需要握手也不用挥手的协议。

//udp_server.c

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

void usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_prot]\n", proc);
}
int startup(const char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if(sock < 0){
        perror("socket");
        exit(2);
    }
    printf("sock: %d\n", sock);
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);//主机转网络
    local.sin_addr.s_addr = inet_addr(ip);//先将点分十进制转换成四字节，再将四字节转网络地址

    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){//绑定
        perror("bind");
        exit(3);
    }
    return sock;
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        usage(argv[0]);
        return 1;
    }
    int sock = startup(argv[1], atoi(argv[2]));
    struct sockaddr_in client;
    char buf[1024];
    while(1){
        socklen_t len = sizeof(client);
        ssize_t s = recvfrom(sock, buf, sizeof(buf)-1, 0, (struct sockaddr*)&client, &len);
        if(s > 0){
            buf[s-1] = 0;
            printf("[%s:%d]: %s\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port), buf);
            sendto(sock, buf, strlen(buf), 0, (struct sockaddr*)&client, sizeof(client));
        }
    }
    return 0;
}

//udp_cilent.c

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<string.h>

void usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_port]\n", proc);
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if(sock < 0){
        perror("socket");
        return 2;
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    char buf[1024];
    struct sockaddr_in peer;
    while(1){
        socklen_t len = sizeof(peer);
        printf("Please Enter# ");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf)-1);
        if(s > 0){
            buf[s] = 0;
            sendto(sock, buf, strlen(buf), 0, (struct sockaddr*)&server, sizeof(server));
            ssize_t _s = recvfrom(sock, buf, strlen(buf), 0, (struct sockaddr*)&peer, &len);
            if(_s > 0){
                buf[_s] = 0;
                printf("server echo# %s\n", buf);
            }
        }
    }
    close(sock);
    return 0;
}测试结果：