服务端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>
#include "windows.h"
#include "winsock2.h"

#define PORT 3000
#define BACKLOG 10

#define BUFSIZE 1024

int main()
{
    WORD sockVersion = MAKEWORD(2,2);
    WSADATA wsaData;
    if(WSAStartup(sockVersion, &wsaData)!=0)
    {
        return 0;
    }

    int sockfd;
    int client_fd;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    int struct_len;
    char buf[BUFSIZ];
    char str[4096];

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bzero(&(server_addr.sin_zero),8);
    struct_len = sizeof(struct sockaddr_in);

    /* 创建一个socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    /* 绑定套接字到端口 */
    if (bind(sockfd, (struct sockaddr *)&server_addr, struct_len) == SOCKET_ERROR) {
        perror("Bind error\n");
    }

    /* 启动socket监听请求，开始等待客户端发来的请求 */
    if (listen(sockfd, BACKLOG) == SOCKET_ERROR) {
        perror("Listen error\n");
        return -1;
    }
    printf("http server running on port %d\n", PORT);
    
    while (1) {
        /* 调用了accept函数，阻塞了程序，直到接收到客户端的请求 */
        client_fd = accept(sockfd, &client_addr, &struct_len);
        if (client_fd == INVALID_SOCKET) {
            printf("accept error\n");
            continue;
        }

        /* 调用recv函数接收客户端发来的请求信息 */
        int ret = recv(client_fd, buf, BUFSIZ, 0);
        if (ret >0) {
            buf[ret] = '\0';
            printf("recv data: \n%s\n", buf);

            char content[1024] = "hello world";
            char content_len[1024];

            memset(str, 0, 4096);
            strcat(str, "HTTP/1.0 200 OK\r\n");
            strcat(str, "Content-Type: text/html;charset=utf-8\r\n");
            strcat(str, "Content-Length: ");
            sprintf(content_len, "%lu\r\n", strlen(content));
            strcat(str, content_len);
            strcat(str, "\r\n");
            strcat(str, content);
            printf("send data: \n%s\n", str);
            
            /* 发送响应给客户端 */
            int s_ret = send(client_fd, str, strlen(str), 0);
            if ( s_ret < 0) {
                perror("send error\n");
            }            
        }
        close(client_fd);
    }

    close(sockfd);
    WSACleanup();
    return 0;
}

编译：

gcc server.c -o server.exe

运行:

./server.exe

图片.png

浏览器访问http://127.0.0.1:3000

图片.png

启动server的流程
图片.png

创建一个套接字，通过各参数指定套接字的类型。

int socket(int af,int type,int protocol);

  • family：协议族。AF_INET：IPV4协议；AF_INET6：IPv6协议；AF_LOCAL：Unix域协议；AF_ROUTE：路由套接字；AF_KEY：密钥套接字

  • type：套接字类型。SOCK_STREAM ： 字节流套接字；SOCK_DGRAM：数据包套接字；SOCK_SEGPACKET：有序分组套接字；SOCK_RAW：原始套接字

  • protocol：某个协议类型常量。TCP：0，UDP ：1， SCTP ：2


套接字地址结构

在socket编程中，大部分函数都用到一个指向套接字地址结构的指针作为参数。针对不同的协议类型，会有不同的结构体定义格式，对于ipv4，结构如下所示：    

struct sockaddr_in {
    short    sin_family;           /* IP协议族，IPV4是AF_INET */
    u_short    sin_port;           /* 一个16比特的TCP/UDP端口地址 */
    struct in_addr    sin_addr;    /* 32比特的IPV4地址，网络字节序 */
    char    sin_zero[8];           /* 未使用字段 */
};

注：sockaddr_in是**Internet socket address structure**的缩写。

ip地址结构    

struct in_addr {
  union {
    struct { u_char  s_b1, s_b2, s_b3, s_b4; } S_un_b;
    struct { u_short s_w1, s_w2; } S_un_w;
    u_long S_addr;
  } S_un;
} IN_ADDR, *PIN_ADDR, *LPIN_ADDR;

套接字地址结构的作用是为了将ip地址和端口号传递到socket函数，写成结构体的方式是为了抽象。当作为一个参数传递进任何套接字函数时，套接字地址结构总是以引用方式传递。然而，协议族有很多，因此以这样的指针作为参数之一的任何套接字函数必须处理来自所有支持的任何协议族的套接字地址结构。使用void *作为通用的指针类型，因此，套接字函数被定义为以指向某个通用套接字结构的一个指针作为其参数之一，正如下面的bind函数原型一样。
    

int bind(SOCKET s,const struct sockaddr *name,int namelen);


这就要求，对这些函数的任何调用都必须要将指向特定于协议的套接字地址结构的指针进行强制类型转换，变成某个通用套接字地址结构的指针。例如：
    

struct sockaddr_in addr;
bind(sockfd, (struct sockaddr *)&addr , sizeof(addr));


对于所有socket函数而言，sockaddr的唯一用途就是对指向特定协议的套接字地址结构的指针执行强制类型转换，指向要绑定给sockfd的协议地址。


bind函数

将套接字地址结构绑定到套接字    

int bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));

  • sockfd：socket描述符，唯一标识一个socket。bind函数就是将这个描述字绑定一个名字。

  • addr：一个sockaddr指针，指向要绑定给sockfd的协议地址。一个socket由ip和端口号唯一确定，而sockaddr就包含了ip和端口的信息 地址的长度

绑定了socket之后，就可以使用该socket开始监听请求了。

listen函数

将sockfd从未连接的套接字转换成一个被动套接字，指示内核应接受指向该套接字的连接请求。    

int listen(SOCKET s,int backlog);

listen函数会将套接字从CLOSED状态转换到LISTEN状态，第二个参数规定内核应该为相应套接字排队的最大连接个数。

关于backlog参数，内核为任何一个给定的监听套接字维护两个队列：

1、未完成连接队列，在队列里面的套接字处于SYN_RCVD状态

2、已完成队列，处于ESTABLISHED状态

两个队列之和不超过backlog的大小。

listen完成之后，socket就处于LISTEN状态，此时的socket调用accept函数就可以接受客户端发来的请求了。


accept函数

int accept(SOCKET s,struct sockaddr *addr,int *addrlen);

用于从已完成连接队列头返回下一个已完成连接，如果已完成连接队列为空，那么进程就会被阻塞。因此调用了accept函数之后，进程就会被阻塞，直到有新的请求到来。

第一个参数sockfd是客户端的套接字描述符，第二个是客户端的套接字地址结构，第三个是套接字地址结构的长度。

如果accept成功，那么返回值是由内核自动生成的全新描述符，代表所返回的客户端的TCP连接。

对于accept函数，第一个参数称为监听套接字描述符，返回值称为已连接套接字。服务器仅创建监听套接字，它一直存在。已连接套接字由服务器进程接受的客户连接创建，当服务器完成某个连接的响应后，相应的已连接套接字就被关闭了。

accept函数返回时，会返回套接字描述符或出错指示的整数，以及引用参数中的套接字地址和该地址的大小。如果对返回值不感兴趣，可以把两个引用参数设为空。

accept之后，一个TCP连接就建立起来了，接着，服务器就接受客户端的请求信息，然后做出响应。


recv和send函数

int recv(SOCKET s,char *buf,int len,int flags);
int send(SOCKET s,const char *buf,int len,int flags);


分别用于从客户端读取信息和发送信息到客户端。在此不做过多的解释。


套接字地址结构大小和值-结果参数

可以看到，在bind函数和accept函数里面，都有一个套接字地址结构长度的参数，区别在于一个是值形式，另一个是引用形式。套接字地址结构的传递方式取决于该结构的传递方向：是从进程到内核，还是从内核到进程。

1、从进程到内核：bind、connect、sendto。 函数将指针和指针所指内容的大小都传给了内核，于是内核知道到底需要从进程复制多少数据进来。
2、从内核到进程： accept、recvfrom、getsockname、getperrname。 这四个函数的结构大小是以只引用的方式传递。 因为当函数被调用时，结构大小是一个值，它告诉内核该结构的大小，这样内核在写该结构时不至于越界；当函数返回时，结构大小又是一个结果，它告诉内核在该结构中究竟存储了多少信息。


HTTP响应报文

发送响应给客户端时，发送的报文要遵循HTTP协议，HTTP的响应报文格式如下：    

<status-line>
<headers>
<blank line>
[<response-body>]


第一行status-line，状态栏，格式：HTTP版本 状态码 状态码代表文字

第二行headers是返回报文的类型，长度等信息

第三行是一个空行，

第四行是响应报文的实体。

一个HTTP响应报文例子：

HTTP/1.1 200 OK
Content-Type: text/html;charset=utf-8
Content-Length: 122

hello world


最后close函数关闭套接字