int server_fd = socket(PF_INET, SOCK_STREAM, 0)

struct sockaddr_in serv_addr = { .sin_family = AF_INET ,
						 .sin_port = htons(4221),
						 .sin_addr = { htonl(INADDR_ANY) },
						};

bind(server_fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))

int connection_backlog = 5;
listen(server_fd, connection_backlog)

struct sockaddr_in client_addr;
client_addr_len = sizeof(client_addr);
int client_fd = accept(server_fd, (struct sockaddr *) &client_addr, &client_addr_len);

close(server_fd);

#define RECV_BUF_SIZE 1024

char recv_buf[RECV_BUF_SIZE];

recv(client_fd, recv_buf, RECV_BUF_SIZE, 0);

char *response = "HTTP/1.1 200 OK\r\n\r\n";
send(client_fd, response, strlen(response), 0);

char response[1024] = "HTTP/1.1 200 OK\r\n"; // ステータスライン

strcat(response, "Content-Type: text/plain\r\n"); // ここからレスポンスヘッダ
strcat(response, "Content-Length: 4\r\n");
strcat(response, "\r\n");
strcat(response, "hoge"); // ここからレスポンスボディ

send(client_fd, response, strlen(response), 0);

char response[1024] = "HTTP/1.1 404 Not Found\r\n";

size_t strlen(const char *string);

int strcmp(const char *string1, const char *string2);

int strncmp(const char *string1, const char *string2, size_t n);

char strcpy(char *string1, const char *string2)

char *strchr(const char *string, int c);

char *strstr(const char *string1, const char *string2);

char *strcat(char *string1, const char *string2);

char *strerror(int errnum);

printf("Socket creation failed: %s...\n", strerror(errno));

typedef char HTTPVersion[16];
typedef char RequestPath[1024];
typedef enum
{
  GET,
  PUT,
  POST,
  DELETE,
} HTTPMethod;

typedef struct 
{
  HTTPVersion version;
  RequestPath path;
  HTTPMethod method;
} HTTPHead;

const uint8_t = MAX_METHOD_SIZE = 7;

char *strcat(char *str1, const char *str2);

static int num = 1;

#include <stdio.h>

int my_func()
{
    static int count;

    count++;

    return count;
}

int main(void)
{
    int count = 0;
    
    count = my_func();
    printf("%d\n", count); // 1

    count = my_func();
    printf("%d\n", count); // 2

    return 0;
}

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

#define BUF_SIZE 1024
#define CLRF "\r\n"
#define HTTP_VERSION "HTTP/1.1"
#define HTTP_OK HTTP_VERSION " 200 OK"
#define HTTP_NOT_FOUND HTTP_VERSION " 404 Not Found"
#define CONTENT_TYPE_KEY "Content-Type:"
#define CONTENT_TYPE_TEXT CONTENT_TYPE_KEY " text/plain"
#define CONTENT_LENGTH_KEY "Content-Length:"

typedef char RequestPath[1024];
typedef char HTTPVersion[16];
typedef char HTTPHost[256];
typedef char UserAgent[256];
typedef char Accept[1024];
typedef char HTTPBody[1024];

typedef enum
{
	GET,
	POST,
	END_OF_HTTP_METHOD,
} HTTPMethod;

const static struct
{
	HTTPMethod method;
	const char *str;
} conversion[] = {
		{GET, "GET"},
		{POST, "POST"}};

typedef struct
{
	HTTPMethod method;
	RequestPath path;
	HTTPVersion version;
	HTTPHost host;
	UserAgent user_agent;
	Accept accept;
} HTTPHead;

typedef struct
{
	HTTPHead head;
	HTTPBody body;
} HTTPRequest;

HTTPMethod conv_str_http_method_to_enum(const char *str)
{
	for (int i = 0; i < END_OF_HTTP_METHOD - 1; i++)
		if (strcmp(conversion[i].str, str) == 0)
		{
			return conversion[i].method;
		}

	return -1;
}

uint8_t recv_request(const int client_fd, char *request_buffer, int bufsize)
{
	request_buffer[bufsize - 1] = '\0';
	if (recv(client_fd, request_buffer, bufsize - 1, 0) < 0)
	{
		return -1;
	}
	return 0;
}

uint8_t read_status_line(const char *request, HTTPRequest *parsed_request)
{
	const uint8_t MAX_METHOD_SIZE = 7;
	char method[MAX_METHOD_SIZE];

	sscanf(request, "%s %s %s", method, parsed_request->head.path, parsed_request->head.version);
	parsed_request->head.method = conv_str_http_method_to_enum(method);

	return 0;
}

char *read_http_header(char *request_headers, HTTPRequest *parsed_request)
{
	static char key[32];
	static char value[1024];

	sscanf(request_headers, "%s %s", key, value);

	if (strcmp(key, "Host:") == 0)
	{
		strcpy(parsed_request->head.host, value);
	}
	else if (strcmp(key, "User-Agent:") == 0)
	{
		strcpy(parsed_request->head.user_agent, value);
	}
	else if (strcmp(key, "Accept:") == 0)
	{
		strcpy(parsed_request->head.accept, value);
	}

	return strchr(request_headers, '\n') + 1;
}

uint8_t read_http_headers(const char *request, HTTPRequest *parsed_request)
{
	char request_copy[strlen(request) + 1];
	strcpy(request_copy, request);

	char *beginning_of_headers = strchr(request_copy, '\n');
	beginning_of_headers++;

	while (beginning_of_headers[0] != '\r' && beginning_of_headers[1] != '\n')
		beginning_of_headers = read_http_header(beginning_of_headers, parsed_request);

	return 0;
}

uint8_t read_request_body(const char *request, HTTPRequest *parsed_request)
{
	char *beginning_of_body = strstr(request, CLRF CLRF);
	strcpy(parsed_request->body, beginning_of_body);
	return 0;
}

uint8_t parse_http_request(const char *request, HTTPRequest *parsed_request)
{
	read_status_line(request, parsed_request);
	read_http_headers(request, parsed_request);
	read_request_body(request, parsed_request);
	return 0;
}

uint8_t respond_200(const int client_fd, const HTTPRequest *request, char *response)
{
	sprintf(response, HTTP_OK CLRF CLRF);

	if (send(client_fd, response, strlen(response), 0) < 0)
	{
		printf("Send failed.\n");
		return 1;
	}

	return 0;
}

uint8_t respond_request_path(const int client_fd, const HTTPRequest *request, char *response)
{
	const char *content = request->head.path + strlen("/echo/");

	char content_length[8];
	sprintf(content_length, "%lu", strlen(content));
	sprintf(response, "%s" CLRF "%s" CLRF CONTENT_LENGTH_KEY "%s" CLRF CLRF "%s", HTTP_OK, CONTENT_TYPE_TEXT, content_length, content);

	if (send(client_fd, response, strlen(response), 0) < 0)
	{
		printf("Send failed.\n");
		return 1;
	}

	return 0;
}

uint8_t respond_ua(const int client_fd, const HTTPRequest *request, char *response)
{
	char content_length[8];
	sprintf(content_length, "%lu", strlen(request->head.user_agent));

	sprintf(response, "%s" CLRF "%s" CLRF CONTENT_LENGTH_KEY "%s" CLRF CLRF "%s", HTTP_OK, CONTENT_TYPE_TEXT, content_length, request->head.user_agent);

	if (send(client_fd, response, strlen(response), 0) < 0)
	{
		printf("Send failed.\n");
		return 1;
	}

	return 0;
}

uint8_t respond_not_found(const int client_fd, const HTTPRequest *request, char *response)
{
	sprintf(response, HTTP_NOT_FOUND CLRF CLRF);

	if (send(client_fd, response, strlen(response), 0) < 0)
	{
		printf("Send failed.\n");
		return 1;
	}

	return 0;
}

uint8_t handle_request(const int client_fd, const char *request, char *response)
{
	HTTPHead head = {
			.method = 0,
			.path = "",
			.version = "",
			.host = "",
			.user_agent = "",
			.accept = "",
	};

	HTTPRequest req = {
			.head = head,
			.body = "",
	};

	parse_http_request(request, &req);

	if (strcmp(req.head.path, "/") == 0)
	{
		return respond_200(client_fd, &req, response);
	}
	else if (strncmp(req.head.path, "/echo/", strlen("/echo/")) == 0)
	{
		return respond_request_path(client_fd, &req, response);
	}
	else if (strcmp(req.head.path, "/user-agent") == 0)
	{
		return respond_ua(client_fd, &req, response);
	}

	return respond_not_found(client_fd, &req, response);
}

int main()
{
	// Disable output buffering
	setbuf(stdout, NULL);

	int server_fd;

	server_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (server_fd == -1)
	{
		printf("Socket creation failed: %s...\n", strerror(errno));
		return 1;
	}

	int reuse = 1;
	if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse)) < 0)
	{
		printf("SO_REUSEPORT failed: %s \n", strerror(errno));
		return 1;
	}

	struct sockaddr_in serv_addr = {
			.sin_family = AF_INET,
			.sin_port = htons(4221),
			.sin_addr = {htonl(INADDR_ANY)},
	};

	if (bind(server_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != 0)
	{
		printf("Bind failed: %s \n", strerror(errno));
		return 1;
	}

	int connection_backlog = 5;
	if (listen(server_fd, connection_backlog) != 0)
	{
		printf("Listen failed: %s \n", strerror(errno));
		return 1;
	}

	while (1)
	{
		printf("Waiting for a client to connect...\n");

		struct sockaddr_in client_addr;
		socklen_t client_addr_len = sizeof(client_addr);

		int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);

		if (client_fd == -1)
		{
			printf("Failed to accept connection.\n");
			return 1;
		}

		printf("Client connected\n");

		if (!fork())
		{
			close(server_fd);

			char request_buffer[BUF_SIZE];

			if (recv_request(client_fd, request_buffer, BUF_SIZE) != 0)
			{
				printf("Failed to receive request.\n");
				return 1;
			}

			char response_buffer[BUF_SIZE];

			handle_request(client_fd, request_buffer, response_buffer);

			close(client_fd);

			exit(0);
		}

		close(client_fd);
	}

	close(server_fd);

	return 0;
}