strip more, simplify code, assembly hack, 5328 bytes

Author: tleydxdy

build.sh

@@ -1,19 +1,19 @@
 #!/bin/sh
 
 gcc \
-  -std=c89 -pedantic \
+  -pedantic \
   -Wall -Werror \
   -s -Os -no-pie \
   -nostdlib \
   -ffreestanding \
   -fno-stack-protector \
   -fdata-sections \
+  -ffunction-sections \
   -fno-unwind-tables \
   -fno-asynchronous-unwind-tables \
-  -ffunction-sections \
   -Wl,-n \
   -Wl,--gc-sections \
   -Wl,--build-id=none \
   start.S httpd.c \
   -o httpd &&
-strip -R .comment httpd
+strip -R .comment -R .bss httpd

httpd.c

@@ -7,141 +7,105 @@
 #define O_RDONLY 0
 
 typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned int size_t;
+typedef unsigned int socklen_t;
+typedef int ssize_t;
 
 /* must be padded to at least 16 bytes */
 typedef struct {
   uint16_t sin_family; /* 2 */
   uint16_t sin_port;   /* 4 -> this is in big endian */
-  int sin_addr;        /* 8 */
+  uint32_t sin_addr;   /* 8 */
   char sin_zero[8];    /* 16 */
 } sockaddr_in_t;
 
-int write(int fd, void* buf, int buf_len);
-int read(int fd, void* buf, int buf_len);
+ssize_t read(int fd, void *buf, size_t nbyte);
+ssize_t write(int fd, const void *buf, size_t nbyte);
+int open(const char *path, int flags);
+int close(int fd);
 int socket(int domain, int type, int protocol);
-int bind(int socket, void* address, int address_len);
+int accept(int socket, sockaddr_in_t *restrict address,
+           socklen_t *restrict address_len);
+int shutdown(int socket, int how);
+int bind(int socket, const sockaddr_in_t *address, socklen_t address_len);
 int listen(int socket, int backlog);
-int accept(int socket, void* address, int address_len);
-int close(int fd);
+int setsockopt(int socket, int level, int option_name, const void *option_value,
+               socklen_t option_len);
 int fork();
-int setsockopt(int socket, int level, int option_name,
-  void* val, int val_len);
-void exit(int code);
-int shutdown(int socket, int how);
-int open(char* path, int flags);
+void exit(int status);
 
 /* this is fine because forked processes are copy on write */
 /* so there shouldn't be any data races */
-char http_buf[8192];
+static char http_buf[8192];
 
-int strlen(char* s) {
-  char* p;
-  for (p = s; *p; ++p);
+static size_t strlen(const char *s) {
+  const char *p = s;
+  while (*p)
+    ++p;
   return p - s;
 }
 
-uint16_t swap_uint16(uint16_t x) {
-  return (
-    ((x << 8) & 0xFF00) |
-    ((x >> 8) & 0x00FF)
-  );
+static uint16_t swap_uint16(uint16_t x) {
+  return (((x << 8) & 0xFF00) | ((x >> 8) & 0x00FF));
 }
 
-#define fprint(fd, s) \
-  write(fd, s, strlen(s))
+#define fprint(fd, s) write(fd, s, strlen(s))
+
+#define fprintn(fd, s, n) write(fd, s, n)
+
+#define fprintl(fd, s) fprintn(fd, s, sizeof(s) - 1)
+
+#define fprintln(fd, s) fprintl(fd, s "\n")
+
+#define print(s) fprint(1, s)
 
-#define fprintln(fd, s) \
-  fprint(fd, s "\n")
+#define printn(s, n) fprintn(1, s, n)
 
-#define print(s) \
-  fprint(1, s)
+#define printl(s) fprintl(1, s)
 
-#define println(s) \
-  fprintln(1, s)
+#define println(s) fprintln(1, s)
 
 #ifdef DEBUG
-#define die(s) \
-  println("FATAL: " s); \
+#define die(s)                                                                 \
+  println("FATAL: " s);                                                        \
   exit(1)
 
-#define perror(s) \
-  println("ERROR: " s)
+#define perror(s) println("ERROR: " s)
 #else
 #define die(s) exit(1)
+
 #define perror(s)
 #endif
 
-int tcp_listen(int port) {
+static int tcp_listen(int port) {
   static int yes = 1;
-  static sockaddr_in_t addr;
-  int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  if (sock < 0) {
-    die("socket");
-  }
-  setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
-  /* address is zero = any address */
-  addr.sin_family = AF_INET;
+  static sockaddr_in_t addr = {AF_INET};
   addr.sin_port = swap_uint16(port);
-  if (bind(sock, &addr, sizeof(addr)) < 0) {
-    die("bind");
-  }
-  if (listen(sock, 10) < 0) {
+  int sock;
+  if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0 ||
+      setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) ||
+      bind(sock, &addr, sizeof(addr)) || listen(sock, 10)) {
     die("listen");
   }
   return sock;
 }
 
-/*
- * must read the entire request otherwise some clients misbehave
- * http request ends with an empty line
- * line separator is \r\n but might as well handle \n aswell
- */
-
-int isspace(char c) {
-  switch (c) {
-    case '\r':
-    case ' ':
-    case '\t':
-      return 1;
-  }
-  return 0;
-}
-
-void http_consume(int clientfd) {
+static void http_consume(int clientfd) {
   int n;
-  int total = 0;
-  char* p;
-  char* buf = http_buf;
-  char* last_line = buf;
-  while (1) {
-    n = read(clientfd, buf, sizeof(http_buf) - (buf - http_buf) - 1);
-    if (n > 0) {
-      buf[n] = 0;
-      buf += n;
-      total += n;
-    } else {
-      if (n < 0) {
-        perror("read");
-      }
-      break;
-    }
-    /* iterate lines, look for empty line */
-    for (p = last_line; p < http_buf + total; ++p) {
-      for (; *p && isspace(*p); ++p);
-      if (*p == '\n') {
-        /* all whitespace line */
-        write(1, http_buf, total);
-        return;
-      }
-      /* skip rest of the line */
-      for (; *p && *p != '\n'; ++p);
-      /* micro optimization: save last line start */
-      last_line = p;
+  while ((n = read(clientfd, http_buf, sizeof(http_buf))) > 0) {
+    printn(http_buf, n);
+    const char *p = http_buf + (n - 3);
+    if (n < 3 || (*p == '\n' && *(p + 1) == '\r' && *(p + 2) == '\n')) {
+      return;
     }
   }
+  if (n < 0) {
+    perror("read");
+  }
 }
 
-void http_drop(int clientfd) {
+static void http_drop(int clientfd) {
   shutdown(clientfd, SHUT_RDWR);
   close(clientfd);
 }
@@ -159,40 +123,32 @@ void http_drop(int clientfd) {
  * binaries it also makes sense to keep the mem usage low
  */
 
-#define http_code(fd, x) \
-  fprint(fd, "HTTP/1.1 " x "\r\n\r\n" x);
+#define http_code(fd, x) fprintl(fd, "HTTP/1.1 " x "\r\n\r\n" x);
 
-int http_serve(int clientfd, char* file_path) {
-  int f;
-  char* buf = http_buf;
+static int http_serve(int clientfd, const char *file_path) {
+  int f, n;
   http_consume(clientfd);
-  fprint(clientfd, "HTTP/1.1 200 OK\r\n\r\n");
-  f = open(file_path, O_RDONLY);
-  if (f < 0) {
+  if ((f = open(file_path, O_RDONLY)) < 0) {
     perror("open");
     http_code(clientfd, "404 Not Found");
     return 1;
   }
-  while (1) {
-    int n = read(f, buf, sizeof(http_buf));
-    if (n > 0) {
-      if (write(clientfd, buf, n) < 0) {
-        perror("write");
-        return 1;
-      }
-    } else {
-      if (n < 0) {
-        perror("read");
-      }
-      break;
+  fprintl(clientfd, "HTTP/1.1 200 OK\r\n\r\n");
+  while ((n = read(f, http_buf, sizeof(http_buf))) > 0) {
+    if (write(clientfd, http_buf, n) < 0) {
+      perror("write");
+      return 1;
     }
   }
+  if (n < 0) {
+    perror("read");
+  }
   http_drop(clientfd);
   return 0;
 }
 
-int atoi(char* s) {
-  int res = 0;
+static uint16_t string2port(const char *s) {
+  uint16_t res = 0;
   for (; *s; ++s) {
     if (*s > '9' || *s < '0') {
       return 0;
@@ -202,38 +158,28 @@ int atoi(char* s) {
   return res;
 }
 
-void usage(char* self) {
-  print("usage: ");
+static void usage(const char *self) {
+  printl("usage: ");
   print(self);
   println(" port file");
   exit(1);
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
   int sock;
-  int port;
-  if (argc != 3) {
-    usage(argv[0]);
-  }
-  port = atoi(argv[1]);
-  if (!port) {
+  uint16_t port;
+  if (argc != 3 || (port = string2port(argv[1])) == 0) {
     usage(argv[0]);
   }
   sock = tcp_listen(port);
   while (1) {
-    int pid;
-    int clientfd = accept(sock, 0, 0);
-    if (clientfd < 0) {
+    int pid, clientfd;
+    if ((clientfd = accept(sock, 0, 0)) < 0) {
       perror("accept");
-      continue;
-    }
-    pid = fork();
-    if (!pid) {
-      return http_serve(clientfd, argv[2]);
-    }
-    if (pid < 0) {
+    } else if ((pid = fork()) < 0) {
       perror("fork");
-      continue;
+    } else if (pid == 0) {
+      return http_serve(clientfd, argv[2]);
     }
   }
   return 0;

start.S

@@ -5,34 +5,37 @@
 /*                           ^^^         */
 /* stack grows from a high address to a low address */
 
+#define c(x, n) \
+.global x; \
+x:; \
+  add r9,n
+
+c(exit, 3)       /* 60 */
+c(fork, 3)       /* 57 */
+c(setsockopt, 4) /* 54 */
+c(listen, 1)     /* 50 */
+c(bind, 1)       /* 49 */
+c(shutdown, 5)   /* 48 */
+c(accept, 2)     /* 43 */
+c(socket, 38)    /* 41 */
+c(close, 1)      /* 03 */
+c(open, 1)       /* 02 */
+c(write, 1)      /* 01 */
+.global read     /* 00 */
+read:
+
 .global _syscall
 _syscall:
   mov r10,rcx
+  mov rax,r9
+  xor r9,r9
   syscall
   ret
 
-#define c(x, n) \
-.global x; \
-x:; \
-  mov eax,n; \
-  jmp _syscall
-
-c(read, 0)
-c(write, 1)
-c(open, 2)
-c(close, 3)
-c(socket, 41)
-c(accept, 43)
-c(shutdown, 48)
-c(bind, 49)
-c(listen, 50)
-c(setsockopt, 54)
-c(fork, 57)
-c(exit, 60)
-
 .global _start
 _start:
   xor rbp,rbp
+  xor r9,r9
   pop rdi     /* argc */
   mov rsi,rsp /* argv */
   call main