Linux C Socket编程(一)Socket简易服务器

本文介绍一个简单的TCP Socket服务器的开发,只拥有最基本的Socket监听功能,以及简单的非完整的处理HTTP响应功能。

一、创建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;
}

linux文件目录权限探究

本文探究linux中目录和文件设置不同权限位的作用

一、实验环境与前提
账号1:root
账号2:git(普通用户,非root组)
root账号可以无视文件目录权限,故此处只用于更改权限,git账号为普通账号,可以验证被root更改文件权限时的表现。文中所有创建的目录、文件均由root账号操作,故文件主为root、文件组为root。git账号属于其他用户,故只考虑权限位的后三位,文件主及其所属用户组的权限设为0,对其他用户的权限进行修改实验。

公共目录:/share,目录权限:drwxrwxrwx 2 root root
实验以/share目录为根目录,所有实验均在/share目录下进行,实验按顺序进行,每个实验是在上一个实验的基础上进行操作。

提示符$为普通用户(即git)、#为root账户,下面不再说明使用哪个账户进行操作,请根据提示符区分。

各操作使用的命令:
1.列目录(ll test, ll=ls -l –color=auto)
2.进目录(cd test)
3.删目录(rm -rf test)
4.创建文件(touch test/file)
5.删除文件(rm -rf test/006)
6.修改文件(echo test > test/006)
7.查看文件(cat test/006)
test目录下的文件及权限如下:

--------w- 1 root root 0 1月  1 00:00 002
-------r-- 1 root root 0 1月  1 00:00 004
-------rw- 1 root root 0 1月  1 00:00 006
drwxr-xr-x 2 root root 4096 1月  1 00:00 dir

二、实验一 目录的r权限(目录权限004)
1. 更改目录权限为r,并查看目录权限

/share# chmod 004 test && ll -d test
d------r-- 2 root root 4096 1月  1 00:00 test

2. 测试能否进入目录
/share$ cd test
结果无法进入,提示权限不足
3. 测试能否显示目录内容
/share$ ll test
结果如下:

ls: 无法访问test/002: 权限不够
ls: 无法访问test/004: 权限不够
ls: 无法访问test/006: 权限不够
ls: 无法访问test/dir: 权限不够
总用量 0
-????????? ? ? ? ?            ? 002
-????????? ? ? ? ?            ? 004
-????????? ? ? ? ?            ? 006
d????????? ? ? ? ?            ? dir

4. 测试普通用户是否能在test目录下创建文件
/share$ touch test/file
提示权限不足
5. 测试普通用户是否可以对目录下的文件内容进行操作
/share$ cat test/006
/share$ echo test > test/006
以上均无权限
6. 删除目录
/share$ rm -rf test
结果分两种情况:如果test目录是空的,可以删除,如果test目录不为空,不能删除。因为删除命令必须保证命令不为空,rm -rf会删除掉test目录下的文件,而test目录只有r权限,不能删除里面的文件,所以无法删除目录

结论:
目录的r权限表示用户可以读取目录的内容,但不能获取详细的信息,只能知道目录下有哪些文件,也不能进入目录,以及修改目录中的文件

三、实验二 目录的w权限(目录权限002)
1. 修改目录权限为002

/share# chmod 002 test && ll -d test
d-------w- 2 root root 4096 1月  00 00:00 test

2. 测试列目录权限
/share$ ll test
提示无权限
3. 测试进目录权限
/share$ cd test
提示无权限
4. 测试创建删除文件
/share$ touch test/file
提示无权限(删除test目录下的文件也无权限,命令略)
5. 删除目录
/share$ rm -rf test
同r权限结果
6. 查看文件
/share$ cat test/file
提示无权限

结论:
仅有w权限的目录无法进行任何操作,即使目录里面的文件为可读写也不能对该目录下的文件进行操作

四、实验三 目录的x权限(目录权限001)
1. 修改目录权限为001
2. 权限:
列目录:NO
进目录:YES
创建文件:NO
删除文件:NO
读写文件:依赖文件本身权限,文件有读权限即可
删除目录本身:同r和w权限

结论:
仅拥有目录x权限,只能进入目录,不能在目录中创建、删除文件,可以读取、修改其中的文件(取决于文件的权限)

五、目录权限及组合测试表

权限位\操作 列目录 进目录 删目录 创建文件 删除文件 修改文件 查看文件
N N 空可删 N N N N
r 无法显示详细信息 N 空可删 N N N N
w N N 空可删 N N N N
x N Y 空可删 N N Y Y
rw 无法显示详细信息 N 空可删 N N N N
rx Y Y 空可删 N N Y Y
wx N Y 空可删 Y Y Y Y
rwx Y Y Y Y Y Y Y

注:无法显示详细信息指,可以知道目录下有哪些文件,但不知道文件大小、权限、修改时间等信息

结论:
1. r权限用于查看目录下都有哪些文件和目录
2. x权限用于查看目录下各目录和文件的详情(权限码、修改时间等),且可以进入目录
3. 只要有x权限就可以进入目录,但查看目录下的详细信息,需要有r和x权限,可理解为:要想知道目录的详情,得先通过r权限知道目录下有哪些文件,之后才能用x权限查这些文件的信息
4. 有目录的x权限是对目录下的文件进行增删改查操作的必要条件,可理解为:如果连文件的最基本的信息都不知道,就没法判断是否可以对目录下的文件有读写权限,所以不能读写文件,而创建文件需要更改目录下文件详情的信息,没有目录x权限也不行,删除文件同样的道理,也需要修改目录下文件的详情。
5. 想要在目录中创建、删除文件,必须要有目录的wx权限,可理解为:创建、删除都需要改变目录索引中的文件详情信息,所以需要w和x权限。rwx三个权限中x为是否有能力接触目录索引中的详情,r和w表示对目录索引的详情有怎样的能力,rx可读,wx可写
6. 目录本身的删除权限,与目录的权限关系不大,主要看上级目录的权限。实验中对于非空目录,只有rwx权限可删,对于空目录,由于上级目录/share是777权限所以可以删。非空目录删除时需要递归删除目录下的文件,根据第5点结论只少要有wx权限,而删除目录下的所有文件,首先得知道都有哪些文件,这就需要r权限,所以rwx权限缺一不可。
实际上,本实验中,如果test目录有wx权限,是有办法不修改权限删除test目录,即先使用rm命令将test目录下的文件一一删除,然后再删test目录,这里我们知道test目录中都有哪些文件,所以可以这么操作,但一般情况下,如果没有r权限,无法得知目录下的文件情况。

六、不同权限的适用场景
r: 只需要看目录下有哪些内容
w: 无法使用
x: 做中间目录使用,有如下目录结构:/documents/<username>/file,documents权限为x,每个用户拥有一个以用户名命名的目录,下面存放各种私人文档,此时可以设置<username>目录为700,属主为用户名的账户,这样每个用户都可以cd到自己的用户名目录下进行各种操作,并且他们看不到documents下有哪些目录,即不知道服务器上为哪些账号开放了此服务(虽然这么做没有什么实质意义)。
rx: 最常用的权限组合,可以进目录看到里面的内容详情,但不能对里面的文件进行新增、删除操作,如/home目录,home目录结构跟上面例子中documents目录极为相似,区别就是我们可以在home目录中通过ls -l查看有哪些子目录,进而推断出服务器上有哪些账号(不考虑无home的用户以及设置非同名用户目录的情况)
wx: 很少用到,对于某些程序,只负责读写指定文件,文件路径已知。但由于w权限通常高于r权限(业务意义上,都可以增加文件,还不允许读取当前目录有哪些文件,这种场景很少),一般很少使用。
rwx: 对目录拥有绝对的权限,可以删除目录下任意文件(无论文件权限如何,即使没有读写文件的权限),一般只对属主的权限设置成rwx,这样比较安全,所以一般默认目录的权限为rwxr-xr-x,目录的属主完全控制,其他人不能删除、新增文件(至于修改文件操作属于文件本身的权限,不在目录权限里考虑)