miniroon

miniroon-read.c (5115B)

---

 #include <errno.h>
 #include <unistd.h>
 #include <sys/select.h>
 #include <stdlib.h>
 #include <assert.h>
 
 #include <skalibs/types.h>
 #include <skalibs/strerr.h>
 #include <skalibs/djbunix.h>
 #include <skalibs/exec.h>
 #include <skalibs/netstring.h>
 #include <skalibs/stralloc.h>
 #include <skalibs/env.h>
 
 #include "netstring.h"
 #include "miniroon-header.h"
 
 #define USAGE "miniroon-read directory"
 #define PROG "miniroon-read"
 
 #define input_fd 0
 #define payload_size_max 1024*1024
 #define MAX_CAVEATS 256
 #define MAX_ENV_ALLOW 256
 
 
 void fd_block(int fd) {
     int flags = fcntl(fd, F_GETFL);
     if(flags == -1) {
         strerr_dief1sys(111, "fcntl() getfd");
     }
     if(fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) < 0) {
         strerr_dief1sys(111, "fcntl() setfd");
     }
 }
 
 size_t read_payload_size(int fd) {
   char read_char;
   size_t payload_size = 0;
 
   fd_block(fd);
 
   while(payload_size < payload_size_max) {
     switch(read(fd, &read_char, 1)) {
       case 0:
         strerr_dief1x(111, "EOF before netstring size was read");
         break;
       case 1:
         if(read_char == ':') {
           return payload_size;
         } else if(read_char >= '0' && read_char <= '9') {
           payload_size *= 10;
           payload_size += read_char - '0';
         } else {
           strerr_dief1x(111, "Malformed netstring on input");
         }
         break;
       case -1:
         if(errno != EINTR) {
           strerr_dief1sys(111, "read() length");
         }
         break;
       default:
         strerr_dief1x(110, "Unexpected return value from read()");
         break;
     }
   }
 
   strerr_dief1x(111, "Input netstring too big");
 }
 
 void read_payload(const bytebuffer bb) {
   char *read_next = bb.data;
   ssize_t read_size;
   while(read_next - bb.data < bb.len) {
     read_size = read(input_fd, read_next, bb.len - (read_next - bb.data));
     if(read_size == 0) {
       strerr_dief1x(111, "EOF before full netstring payload was read");
     }
     if(read_size == -1) {
       if(errno != EINTR) {
         strerr_dief1sys(111, "read() payload");
       }
       continue;
     }
     read_next += read_size;
   }
   if(bb.data[bb.len - 1] != ',') {
       strerr_dief1x(111, "Invalid netstring terminator");
   }
 }
 
 void process_header(miniroon_header *header, const bytebuffer source) {
   parse_header(header, source);
 
   char id[header->id.len + 1];
   for(size_t i=0; i<header->id.len; i++) {
     id[i] = header->id.data[i];
     if(id[i] == '-') { continue; }
     if(id[i] >= '0' && id[i] <= '9') { continue; }
     if(id[i] >= 'a' && id[i] <= 'z') { continue; }
     strerr_dief1x(111, "Invalid character in miniroon ID");
   }
   id[header->id.len] = 0;
 
   if (chdir(id) != 0) {
     strerr_dief1sys(111, "chdir(id)");
   }
 }
 
 void exec_verify_and_write_payload (const bytebuffer payload);
 void process_payload(const bytebuffer payload) {
   miniroon_header header;
   netstring_chunk c;
   netstring_chunk_init(&c, payload);
 
   if(!netstring_chunk_next(&c)) {
     strerr_dief1x(111, "Mising miniroon header");
   }
   process_header(&header, c.inner);
   exec_verify_and_write_payload(payload);
 }
 
 void exec_verify_and_write_payload (const bytebuffer payload) {
   pid_t pid1=0, pid2=0;
   int wstat ;
   int p[2] ;
 
   if(pipe(p) == -1) {
     strerr_diefu1sys(111, "create pipe");
   }
 
   pid1 = fork();
   switch(pid1) {
     case -1:
       strerr_diefu1sys(111, "first fork()");
       break;
     case 0:  /* child */
       fd_close(p[0]);
       pid2 = fork();
       switch(pid2) {
         case -1:
           strerr_diefu1sys(111, "second fork()");
           break;
         case 0:  /* child */
           ssize_t payload_write = fd_write(p[1], payload.data, payload.len);
           if(payload_write < 0 ) {
             strerr_dief1sys(111, "write(payload)");
           }
           if(payload_write != payload.len) {
             strerr_dief1x(111, "could not write whole payload");
           }
           exit(0);
           break;
         default:  /* parent */
           exit(0);
           break;
       }
       break;
     default:  /* parent */
       waitpid_nointr(pid1, &wstat, 0);
       if(!WIFEXITED(wstat) || WEXITSTATUS(wstat) != 0) {
         strerr_dief1x(111, "child terminated abnormally");
       }
 
       char cmd[] = "./verify";
       char fmt_fd[UINT64_FMT], fmt_len[UINT64_FMT];
       fmt_fd[uint64_fmt(fmt_fd, (uint64_t)p[0])] = 0;
       fmt_len[uint64_fmt(fmt_len, (uint64_t)payload.len)] = 0;
       const char *cmd_argv[4] = {cmd, fmt_fd, fmt_len, 0};
 
       fd_close(p[1]);
       xexec(cmd_argv);
       break;
   }
 }
 
 int main (int argc, char const *const *argv)
 {
 
   if (argc != 2) {
     strerr_dieusage(100, USAGE);
   }
 
   if (chdir(argv[1]) != 0) {
     strerr_dief1sys(111, "chdir()");
   }
   size_t payload_size = read_payload_size(input_fd);
   char payload_data[payload_size + 1];
   bytebuffer payload = {payload_data, payload_size + 1};
   read_payload(payload);
   payload.len -= 1; /* strip final netstring terminator */
   dbg_print_bb1("Got payload", payload);
   process_payload(payload);
   assert(0);
   strerr_dief1x(110, "Internal logic error, should not get here");
   return 110;
 }
 
 /*  vim: sts=2 sw=2 et
 */