nsz Git - libfirm/blob - support/lpp_server/lpp_server.h

   1 /*
   2  * This file is part of libFirm.
   3  * Copyright (C) 2012 Universitaet Karlsruhe
   4  */
   5
   6 #ifndef LPP_SERVER_H
   7 #define LPP_SERVER_H
   8
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11 #include <stdint.h>
  12 #include <unistd.h>
  13 #include <errno.h>
  14 #include <netinet/in.h>
  15
  16 enum {
  17 #define LPP_CMD(x) x,
  18 #include "lpp_cmd.def"
  19 #undef LPP_CMD
  20   LPP_CMD_LAST
  21 };
  22
  23 #define BASIC_ERR_CHECK(expr,cond,fmt,last) \
  24   if((expr) cond) { \
  25     fprintf(stderr, "%s(%d): %s %s: ", __FILE__, __LINE__, #expr, #cond); \
  26     print_err fmt; \
  27     fprintf(stderr, "\n"); \
  28     last; \
  29   }
  30
  31 #define BASIC_ERRNO_CHECK(expr,cond,last) \
  32   if((expr) cond) { \
  33     fprintf(stderr, "%s(%d): %s %s: %s\n", \
  34         __FILE__, __LINE__, #expr, #cond, strerror(errno)); \
  35     last; \
  36   }
  37
  38 #define ERR_CHECK_RETURN(expr, cond, fmt, retval) \
  39   BASIC_ERR_CHECK(expr, cond, fmt, return retval)
  40
  41 #define ERRNO_CHECK_RETURN(expr, cond, retval) \
  42   BASIC_ERRNO_CHECK(expr, cond, return retval)
  43
  44 #define ERR_CHECK_RETURN_VOID(expr, cond, fmt) \
  45   BASIC_ERR_CHECK(expr, cond, fmt, return)
  46
  47 #define ERRNO_CHECK_RETURN_VOID(expr, cond) \
  48   BASIC_ERRNO_CHECK(expr, cond, return)
  49
  50 #define ERR_CHECK(expr, cond, fmt) \
  51   BASIC_ERR_CHECK(expr, cond, fmt, (void) 0)
  52
  53 #define ERRNO_CHECK(expr, cond) \
  54   BASIC_ERRNO_CHECK(expr, cond, (void) 0)
  55
  56 static void print_err(const char *fmt, ...)
  57 {
  58         va_list args;
  59
  60         va_start(args, fmt);
  61         vfprintf(stderr, fmt, args);
  62         va_end(args);
  63 }
  64
  65 static  void writel(int fd, uint32_t x)
  66 {
  67         x = htonl(x);
  68         ERRNO_CHECK(write(fd, &x, sizeof(x)), == -1);
  69 }
  70
  71 static  void writed(int fd, double dbl)
  72 {
  73         ERRNO_CHECK(write(fd, &dbl, sizeof(dbl)), == -1);
  74 }
  75
  76 static  void writes(int fd, const char *str)
  77 {
  78         size_t n = strlen(str);
  79         writel(fd, n);
  80         ERRNO_CHECK(write(fd, str, n), == -1);
  81 }
  82
  83 static  uint32_t readl(int fd)
  84 {
  85         uint32_t res;
  86
  87         ERRNO_CHECK(read(fd, &res, sizeof(res)), == -1);
  88         return ntohl(res);
  89 }
  90
  91 static  double readd(int fd)
  92 {
  93         double res;
  94         ERRNO_CHECK(read(fd, &res, sizeof(res)), == -1);
  95         return res;
  96 }
  97
  98 static  char *reads(int fd)
  99 {
 100         size_t len = readl(fd);
 101         char *res = malloc(sizeof(char) * (len + 1));
 102
 103         ERRNO_CHECK(read(fd, res, len), == -1);
 104         res[len] = '\0';
 105         return res;
 106 }
 107
 108 static char *readbuf(int fd, size_t buflen, char *buf)
 109 {
 110         char dummy[1024];
 111         size_t i;
 112         size_t n         = buflen - 1;
 113         size_t len       = readl(fd);
 114         size_t max_read  = n < len ? n : len;
 115         size_t rest      = len - max_read;
 116
 117         if(buflen > 0 && buf != NULL) {
 118                 ERRNO_CHECK(read(fd, buf, max_read), == -1);
 119                 buf[max_read] = '\0';
 120         }
 121
 122         /* eat up data that didnt fit into the string */
 123         for(i = 0, n = rest / sizeof(dummy); i < n; ++i)
 124                 read(fd, dummy, sizeof(dummy));
 125
 126         if(rest % sizeof(dummy) > 0)
 127                 read(fd, dummy, rest % sizeof(dummy));
 128
 129         return buf;
 130 }
 131
 132 static int ack(int fd, size_t buflen, char *buf)
 133 {
 134         int res = 0;
 135         int cmd = readl(fd);
 136
 137         switch(cmd) {
 138                 case LPP_CMD_OK:
 139                         res = 1;
 140                         break;
 141                 case LPP_CMD_BAD:
 142                         readbuf(fd, buflen, buf);
 143                 default:
 144                         res = 0;
 145         }
 146
 147         return res;
 148 }
 149
 150 static void send_res(int fd, int ok, const char *fmt, ...)
 151 {
 152         if(!ok) {
 153                 char buf[1024];
 154                 va_list args;
 155
 156                 va_start(args, fmt);
 157                 vsnprintf(buf, sizeof(buf), fmt, args);
 158                 va_end(args);
 159
 160                 writel(fd, LPP_CMD_BAD);
 161                 writes(fd, buf);
 162         }
 163
 164         else
 165                 writel(fd, LPP_CMD_OK);
 166 }
 167
 168 static void send_ack(int fd)
 169 {
 170         send_res(fd, 1, "");
 171 }
 172
 173 #endif