日期: 2017 年 4 月 9 日

一、创建Socket并对端口进行监听

socket函数

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

其中domain用于设置网络通信的域，最常用的为AF_INET，表示IPv4 Internet协议。
type为socket类型，本文中使用SOCK_STREAM，表示TCP；另外，SOCK_DGRAM，表示UDP；还有其他一些可用值，不在本文讨论范围内。
protocol为协议，TCP对应是IPPROTO_TCP，当protocol为0时，会根据type自动选择默认的协议。
返回值：如果调用成功返回套接字的描述符，失败在linux下返回-1。

   int server_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (INVALID_SOCKET == server_sockfd) {
     return INVALID_SOCKET;
   }

bind函数

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

socketfd：一个套接字描述符，即前面用socket初始化的server_sockfd值
addr：包含了端口号、IP等信息的一个结构体，对于不同的协议，这个结构体内容不同
addrlen：addr的长度
在本文的前提条件下（基于IPv4的TCP服务），addr结构体如下：

struct sockaddr_in {
    sa_family_t    sin_family; // 本文AF_INET
    in_port_t      sin_port;   // 端口号网络字节序，本文18080
    struct in_addr sin_addr;   // IP地址
};

struct in_addr {
	uint32_t       s_addr;     // IP地址网络字节序，本文用INADDR_ANY，表示绑定本机任意IP（0.0.0.0）
};

struct sockaddr_in server_sockaddr;
server_sockaddr.sin_family = AF_INET;
server_sockaddr.sin_port = htons(PORT); // PORT常量被定义为18080
server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(server_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr)) == -1) {
    // 绑定失败会返回-1，如端口被占用
    printf("Socket Bind Error\n");
    return ERR_SOCKET_INIT;
  }

listen函数

    int listen(int socketfd, int backlog);

backlog为连接队列最大长度
调用listen后，对应的端口进入监听状态，等待接收请求

  if(listen(server_sockfd, BACKLOG) == -1) {
    printf("Socket Listen Error\n");
    return ERR_SOCKET_INIT;
  }

二、连接的建立与数据的通信

accept函数

    int accept(int socketfd, struct sockaddr *addr, socklen_t *addrlen);

socketfd为服务器监听的套接字，即上面的socket函数的返回值
addr为客户端socket的信息，如地址、端口等，如果不关心这些，可以设为NULL
addrlen为addr的长度，也可以设为NULL
返回值为当前连接的套接字，通过这个套接字，可以跟当前的客户端进行通信，如果出错，返回-1。

      if ((connect_fd = accept(server_sockfd, (struct sockaddr*)&client_sockaddr, &socklen)) == -1) {
      continue;
    }

recv函数

int recv(int socketfd, char FAR* buf, int len, int flags);

socketfd为accept返回的连接套接字
buf为数据的缓冲区，缓冲区大小一般是程序预先指定，在HTTP协议下，用于接收请求头，当请求头内容超过缓冲区大小，可以直接返回413状态码。对于POST请求，可以根据请求头中的Content-Length字段判断请求大小，然后动态申请堆内存接收请求体部分。
len为缓冲区大小，每次会读取len个字节到缓冲区，然后由程序决定如何处理
flags一般设为0
当正确读取数据时，函数返回读取的字节数，如果连接终止，返回0，如果遇到错误则返回-1
读数据时，使用一个循环调用recv函数，循环退出的条件之一是recv返回值<=0，本文希望实现一个简易的HTTP服务，故根据HTTP协议，在缓冲区最后4个字节为“\r\n\r\n”时，表示请求结束。

  int recvLen;
  int pBuffer = 0;
  int errCode = 200;
  while ((recvLen = recv(req->connect_fd, &buffer[pBuffer], 512, 0)) > 0) {
    pBuffer += recvLen;
    if (pBuffer > BUFFER_LEN) {
      errCode = 413;
      break;
    }
    if (pBuffer >= 4 && strncmp("\r\n\r\n", &buffer[pBuffer - 4], 4) == 0) {
      break;
    }
  }

send函数

    int send(int socketfd, const char FAR* buf, int len, int flags);

socketfd为连接套接字
buf为要发送数据的缓冲区
len为缓冲区长度
flags一般设为0

close函数

    int close(int fd);

关闭socket连接，fd为要关闭的连接套接字

三、示例

说明：本文编写的服务器并不是一个完整的HTTP服务器，只能起到监听请求，但并不会处理请求，只是返回一个Hello World页面，且对请求的异常并未做过多的判断，这里认为请求均为正常的GET方法。
本系列文章最终要实现一个WebSocket服务器，故后面对服务器代码的完善也不会考虑HTTP的其他方法，只会返回一个错误码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define DEBUG 1
#define PORT 18080
#define BACKLOG 512
#define BUFFER_LEN 4096

#define INVALID_SOCKET   -1
#define ERR_SOCKET_INIT   1

// 请求结构体，包含请求的连接套接字、客户端地址信息及其长度
struct req_parameter {
  int connect_fd;
  struct sockaddr_in client_sockaddr;
  socklen_t socklen;
};

// sockaddr中将IP转为字符串
void sockaddrtoipstr(struct sockaddr_in addr, char* ipStr) {
  int ipRaw = addr.sin_addr.s_addr;
  int i = 4;
  int j = 0;
  while (i--) {
    int len;
    len = sprintf(&ipStr[j], "%d%c",
      (ipRaw & (0xFF << 8 * (3 - i))) >> 8 * (3 - i),
      '.'
    );
    j += len;
  }
  ipStr[j - 1] = 0;
}

// 关闭连接的通用方法，主要还是close，这里添加了一个调试用的关闭信息提示
void closeSocket(const struct req_parameter* req) {
  #if (DEBUG)
  char ipStr[16] = {0};
  sockaddrtoipstr(req->client_sockaddr, ipStr);
  printf("Close Connection %s:%d\n", ipStr, ntohs(req->client_sockaddr.sin_port));
  #endif
  close(req->connect_fd);
}

// 处理请求过长的错误，实际就是缓冲区溢出了，返回客户端的响应
void handle413(const struct req_parameter* req) {
  const char resp[] = "\
HTTP/1.1 413 Request Entity Too Large\r\n\
Connection: Close\r\n\r\n\
Request Entity Too Large\
";
  #if (DEBUG)
  printf(">%s\n", resp);
  #endif
  send(req->connect_fd, resp, sizeof(resp) - 1, 0);
  closeSocket(req);
}

// 处理正常的请求，不论请求什么，都返回一个Hello World，这里实际没有对请求进行实质性处理，后面的文章会继续完善
void handle200(const struct req_parameter* req) {
  const char resp[] = "\
HTTP/1.1 200 OK\r\n\
Connection: Close\r\n\r\n\
<h1>Hello World</h1>\
";
  #if (DEBUG)
  printf(">%s\n", resp);
  #endif
  send(req->connect_fd, resp, sizeof(resp) - 1, 0);
  closeSocket(req);
}

void handleRequest(const struct req_parameter* req) {
  char buffer[BUFFER_LEN + 512] = {0};
  #if (DEBUG)
  char ipStr[16] = {0};
  sockaddrtoipstr(req->client_sockaddr, ipStr);
  printf("Accept socket from %s:%d\n", ipStr, ntohs(req->client_sockaddr.sin_port));
  #endif
  int recvLen;
  int pBuffer = 0; // 指向缓冲区当前位置的索引
  int errCode = 200;
  // 循环读取数据，直到连接中断或出现错误
  while ((recvLen = recv(req->connect_fd, &buffer[pBuffer], 512, 0)) > 0) {
    pBuffer += recvLen;
    if (pBuffer > BUFFER_LEN) {
      errCode = 413;
      break;
    }
    // 根据协议，认为请求头已经结束，退出循环，请求体部分即使有，这里也会忽略掉
    if (pBuffer >= 4 && strncmp("\r\n\r\n", &buffer[pBuffer - 4], 4) == 0) {
      break;
    }
  }
  #if (DEBUG)
  printf("Receive %d byte(s): \n%.*s\n", pBuffer, pBuffer, buffer);
  #endif
  switch (errCode) {
    case 200:
      handle200(req);
      break;
    case 413:
      handle413(req);
      break;
  }
  free((void *)req);
}

int main() {
  // 创建socket
  int server_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (INVALID_SOCKET == server_sockfd) {
    return INVALID_SOCKET;
  }
  struct sockaddr_in server_sockaddr;
  server_sockaddr.sin_family = AF_INET;
  server_sockaddr.sin_port = htons(PORT);
  server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  // 设置socket参数
  if (setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int)) == -1) {
    printf("setsockopt(SO_REUSEADDR) failed\n");
    return ERR_SOCKET_INIT;
  }
  // 绑定IP和端口
  if(bind(server_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr)) == -1) {
    printf("Socket Bind Error\n");
    return ERR_SOCKET_INIT;
  }
  // 监听
  if(listen(server_sockfd, BACKLOG) == -1) {
    printf("Socket Listen Error\n");
    return ERR_SOCKET_INIT;
  }

  #if (DEBUG)
  printf("Listening on port:%d\n", PORT);
  #endif
  while (1) {
    int connect_fd;
    struct sockaddr_in client_sockaddr;
    socklen_t socklen;
    extern int errno;
    // 循环直到接收到一个连接请求，才会继续
    if ((connect_fd = accept(server_sockfd, (struct sockaddr*)&client_sockaddr, &socklen)) == -1) {
      #if (DEBUG)
      printf("Accept socket error: %s(errno: %d)\n", strerror(errno), errno);
      #endif
      continue;
    }
    // 构造请求参数结构体
    struct req_parameter *req = (struct req_parameter*) malloc(sizeof (struct req_parameter));
    req->connect_fd = connect_fd;
    req->client_sockaddr = client_sockaddr;
    req->socklen = socklen;
    pthread_t thread;
    // 创建一个线程处理请求，此处线程暂不需要被外界影响，后续会增加线程通信，以便断开不活跃的连接，会在后面文章中进行改造
    pthread_create(&thread, NULL, (void *)&handleRequest, req);
  }
  close(server_sockfd);
  return 0;
}