git.zerfleddert.de Git - rigol/blob - rigold.c

   1 #include <sys/types.h>
   2 #include <sys/socket.h>
   3 #include <arpa/inet.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <strings.h>
   8 #include <unistd.h>
   9 #include <signal.h>
  10 #include <stdarg.h>
  11
  12 #include "scope.h"
  13 #include "commands.h"
  14
  15 #define TIMEOUT 4
  16
  17 static int send_binary(int s, char *buf, int len)
  18 {
  19         int ret;
  20
  21         while(len > 0) {
  22                 ret = write(s, buf, len);
  23                 if (ret == -1) {
  24                         perror("write");
  25                         return ret;
  26                 }
  27                 buf += ret;
  28                 len -= ret;
  29         }
  30
  31         return 0;
  32 }
  33
  34 static int send_text(int s, char *fmt, ...)
  35 {
  36         va_list argp;
  37         char buf[4096];
  38         int cnt;
  39
  40         va_start(argp, fmt);
  41         cnt = vsnprintf(buf, sizeof(buf), fmt, argp);
  42         va_end(argp);
  43
  44         if (cnt < 0)
  45                 return cnt;
  46
  47         return send_binary(s, buf, cnt);
  48 }
  49
  50 static int send_command_output(int s, struct scope *sc, char *cmd)
  51 {
  52         unsigned char buf[1024*1024];
  53         int res;
  54
  55         res = sendscpi(sc, cmd, buf, sizeof(buf));
  56         send_binary(s, (char*)buf, res);
  57
  58         return res;
  59 }
  60
  61 static void serve_index(int s, struct scope *sc, char *param)
  62 {
  63         int i;
  64         struct channel_s *ch;
  65
  66         send_text(s, "HTTP/1.0 200 OK\n");
  67         send_text(s, "Content-type: text/html\n\n");
  68         send_text(s, "<html><head><title>%s</title></head><body bgcolor=\"#ffffff\" text=\"#000000\">\n", scope_idn(sc));
  69         send_text(s, "<img src=\"/cgi-bin/lcd\" height=\"234\" width=\"320\">\n");
  70         send_text(s, "<br>\n");
  71
  72         claimscope(sc);
  73         update_scope_status(sc);
  74         releasescope(sc);
  75
  76         send_text(s, "System: Language: %s, Counter: %d, Beep: %d<br><br>\n",
  77                 sc->status.system.lang,
  78                 sc->status.system.counter_enabled,
  79                 sc->status.system.beep_enabled);
  80
  81         send_text(s, "Keyboard: Key Lock: %d<br><br>\n",
  82                 sc->status.keyboard.key_lock);
  83
  84         send_text(s, "Measure: Source: %s, Total: %d<br>\n",
  85                 sc->status.measure.source,
  86                 sc->status.measure.total);
  87
  88         send_text(s, "Measure CH1:<br>\n");
  89         send_text(s, "VPP: %lg, VMAX: %lg, VMIN: %lg, VAMPLITUDE: %lg, VTOP: %lg, VBASE: %lg, VAVERAGE: %lg, VRMS: %lg<br>\n",
  90                 sc->status.measure.ch1.vpp,
  91                 sc->status.measure.ch1.vmax,
  92                 sc->status.measure.ch1.vmin,
  93                 sc->status.measure.ch1.vamplitude,
  94                 sc->status.measure.ch1.vtop,
  95                 sc->status.measure.ch1.vbase,
  96                 sc->status.measure.ch1.vaverage,
  97                 sc->status.measure.ch1.vrms);
  98
  99         send_text(s, "Overshoot: %lg, Preshoot: %lg<br>\n",
 100                 sc->status.measure.ch1.overshoot,
 101                 sc->status.measure.ch1.preshoot);
 102
 103         send_text(s, "Frequency: %lg, Risetime: %lg, Falltime: %lg<br>\n",
 104                 sc->status.measure.ch1.frequency,
 105                 sc->status.measure.ch1.risetime,
 106                 sc->status.measure.ch1.falltime);
 107
 108         send_text(s, "Period: %lg, Pwidth: %lg, Nwidth: %lg, Pdutycycle: %lg, Ndutycycle: %lg<br>\n",
 109                 sc->status.measure.ch1.period,
 110                 sc->status.measure.ch1.pwidth,
 111                 sc->status.measure.ch1.nwidth,
 112                 sc->status.measure.ch1.pdutycycle,
 113                 sc->status.measure.ch1.ndutycycle);
 114
 115         send_text(s, "Pdelay: %lg, Ndelay: %lg<br>\n",
 116                 sc->status.measure.ch1.pdelay,
 117                 sc->status.measure.ch1.ndelay);
 118
 119         send_text(s, "Measure CH2:<br>\n");
 120         send_text(s, "VPP: %lg, VMAX: %lg, VMIN: %lg, VAMPLITUDE: %lg, VTOP: %lg, VBASE: %lg, VAVERAGE: %lg, VRMS: %lg<br>\n",
 121                 sc->status.measure.ch2.vpp,
 122                 sc->status.measure.ch2.vmax,
 123                 sc->status.measure.ch2.vmin,
 124                 sc->status.measure.ch2.vamplitude,
 125                 sc->status.measure.ch2.vtop,
 126                 sc->status.measure.ch2.vbase,
 127                 sc->status.measure.ch2.vaverage,
 128                 sc->status.measure.ch2.vrms);
 129
 130         send_text(s, "Overshoot: %lg, Preshoot: %lg<br>\n",
 131                 sc->status.measure.ch2.overshoot,
 132                 sc->status.measure.ch2.preshoot);
 133
 134         send_text(s, "Frequency: %lg, Risetime: %lg, Falltime: %lg<br>\n",
 135                 sc->status.measure.ch2.frequency,
 136                 sc->status.measure.ch2.risetime,
 137                 sc->status.measure.ch2.falltime);
 138
 139         send_text(s, "Period: %lg, Pwidth: %lg, Nwidth: %lg, Pdutycycle: %lg, Ndutycycle: %lg<br>\n",
 140                 sc->status.measure.ch2.period,
 141                 sc->status.measure.ch2.pwidth,
 142                 sc->status.measure.ch2.nwidth,
 143                 sc->status.measure.ch2.pdutycycle,
 144                 sc->status.measure.ch2.ndutycycle);
 145
 146         send_text(s, "Pdelay: %lg, Ndelay: %lg<br>\n",
 147                 sc->status.measure.ch2.pdelay,
 148                 sc->status.measure.ch2.ndelay);
 149
 150         send_text(s, "<br>Acquire: Type: %s, Mode: %s, Averages: %d, CH1: %.10lg samples/s, CH2: %.10lg samples/s<br>\n",
 151                 sc->status.acquire.type,
 152                 sc->status.acquire.mode,
 153                 sc->status.acquire.averages,
 154                 sc->status.acquire.srate_ch1,
 155                 sc->status.acquire.srate_ch2);
 156
 157         send_text(s, "<br>Display: Type: %s, Grid: %s, Persist: %d, MNUDisplay: %s, MNUStatus: %d, Screen: %s, Brightness: %d, Intensity: %d<br><br>\n",
 158                 sc->status.display.type,
 159                 sc->status.display.grid,
 160                 sc->status.display.persist,
 161                 sc->status.display.mnudisplay,
 162                 sc->status.display.mnustatus,
 163                 sc->status.display.screen,
 164                 sc->status.display.brightness,
 165                 sc->status.display.intensity);
 166
 167         for (i = 1; i <= 2; i++) {
 168                 if (i == 1) {
 169                         ch = &(sc->status.channel.ch1);
 170                 } else {
 171                         ch = &(sc->status.channel.ch2);
 172                 }
 173                 send_text(s, "Channel %d: ", i);
 174
 175                 send_text(s, "BWLimit: %d, Coupling: %s, Displayed: %d, Inverted: %d, Offset: %lg, Probe: %lgX, Scale: %lg, Filter: %d, Memory Depth: %d, Vernier: %s<br>\n",
 176                         ch->bwlimit_enabled,
 177                         ch->coupling,
 178                         ch->displayed,
 179                         ch->inverted,
 180                         ch->offset,
 181                         ch->probe,
 182                         ch->scale,
 183                         ch->filter_enabled,
 184                         ch->memory_depth,
 185                         ch->vernier);
 186         }
 187
 188         send_text(s, "<br>Horizontal: Mode: %s, Offset: %lg, Delayed Offset: %lg, Scale: %lg, Format: %s<br>\n",
 189                 sc->status.timebase.mode,
 190                 sc->status.timebase.offset,
 191                 sc->status.timebase.delayed_offset,
 192                 sc->status.timebase.scale,
 193                 sc->status.timebase.format);
 194
 195
 196         send_text(s, "<br>\n");
 197         send_text(s, "<form method=\"get\" action=\"\">\n");
 198         send_text(s, "<input type=\"text\" name=\"cmd\" value=\"");
 199         if (param) {
 200                 if (strncmp(param, "cmd=", 4) == 0)
 201                         param += 4;
 202
 203                 send_text(s, param);
 204         }
 205         send_text(s, "\">\n");
 206         send_text(s, "<input type=\"submit\">\n");
 207         send_text(s, "</form>\n");
 208         send_text(s, "<a href=\"?cmd=:RUN\">RUN</a> ");
 209         send_text(s, "<a href=\"?cmd=:STOP\">STOP</a> ");
 210         send_text(s, "<a href=\"?cmd=:FORC\">FORCE</a> ");
 211         if (param) {
 212                 claimscope(sc);
 213                 if (strchr (param, '?')) {
 214                         send_text(s, "<pre>< ");
 215                         send_text(s, param);
 216                         send_text(s, "\n> ");
 217                         send_command_output(s, sc, param);
 218                         send_text(s, "</pre>\n");
 219                 } else {
 220                         sendscpi(sc, param, NULL, 0);
 221                 }
 222                 releasescope(sc);
 223         }
 224         send_text(s, "</body></html>\n");
 225 }
 226
 227 static void serve_lcd(int s, struct scope *sc)
 228 {
 229         char buf[256];
 230         int imglen;
 231         unsigned char *png;
 232
 233         claimscope(sc);
 234         png = get_lcd(sc, &imglen, 0);
 235         releasescope(sc);
 236
 237         if (png == NULL)
 238                 return;
 239
 240
 241         send_text(s, "HTTP/1.0 200 OK\n");
 242         send_text(s, "Content-type: image/png\n");
 243         snprintf(buf, sizeof(buf), "Content-length: %u\n\n", imglen);
 244         send_text(s, buf);
 245         send_binary(s, (char*)png, imglen);
 246         free(png);
 247 }
 248
 249 static void serve_404(int s)
 250 {
 251         send_text(s, "HTTP/1.0 404 Not found\n");
 252         send_text(s, "Content-type: text/html\n\n");
 253         send_text(s, "<html><head><title>404</title></head>");
 254         send_text(s, "<body bgcolor=\"#ffffff\" text=\"#000000\">\n");
 255         send_text(s, "<h1>404</h1>");
 256         send_text(s, "</body></html>\n");
 257 }
 258
 259 int is_eor(char *buf)
 260 {
 261         int eor = 0;
 262
 263         /* This does not completely work, when the request is split
 264            in multiple packets... */
 265         if (strstr(buf, "\x0d\x0a\x0d\x0a")) {
 266                 eor = 1;
 267         } else if (strstr(buf, "\x0a\x0a")) {
 268                 eor = 1;
 269         } else if (strcmp(buf, "\x0d\x0a") == 0) {
 270                 eor = 1;
 271         } else if (strcmp(buf, "\x0a") == 0) {
 272                 eor = 1;
 273         }
 274
 275         return eor;
 276 }
 277
 278
 279 static void parse_request(int s, struct scope *sc)
 280 {
 281         int ret;
 282         int eor;
 283         char buf[4096];
 284         char file[4096];
 285         const char delim[] = " \t\x0d\x0a";
 286         char *saveptr;
 287         char *token;
 288         char *param = NULL;
 289
 290         alarm(TIMEOUT);
 291         ret=read(s, buf, sizeof(buf)-1);
 292         if (ret == -1) {
 293                 perror("read");
 294                 return;
 295         }
 296         buf[ret] = 0;
 297
 298         eor = is_eor(buf);
 299
 300         token = strtok_r(buf, delim, &saveptr);
 301         if (token == NULL)
 302                 return;
 303         /* TODO: Only GET... */
 304         token = strtok_r(NULL, delim, &saveptr);
 305         if (token == NULL)
 306                 return;
 307         bzero(&file, sizeof(file));
 308         strncpy(file, token, sizeof(file)-1);
 309
 310         while (!eor) {
 311                 alarm(TIMEOUT);
 312                 ret=read(s, buf, sizeof(buf)-1);
 313                 if (ret == -1) {
 314                         perror("read");
 315                         return;
 316                 }
 317                 buf[ret] = 0;
 318                 eor = is_eor(buf);
 319         }
 320         alarm(0);
 321
 322         param = strchr(file, '?');
 323         if (param) {
 324                 *param = 0;
 325                 param++;
 326
 327                 while ((token = strchr(param, '%')) != NULL) {
 328                         char buf[3];
 329
 330                         if (strlen(token+1) < 2)
 331                                 break;
 332
 333                         strncpy(buf, token+1, 3);
 334                         buf[2] = 0;
 335
 336                         *token = (char)strtoul(buf, NULL, 16);
 337                         memmove(token+1, token+3, strlen(token)-2);
 338
 339                 }
 340                 while ((token = strchr(param, '+')) != NULL) {
 341                         *token = ' ';
 342                 }
 343         }
 344
 345         if (strcmp("/", file) == 0) {
 346                 serve_index(s, sc, param);
 347         } else if (strcmp("/cgi-bin/lcd", file) == 0) {
 348                 serve_lcd(s, sc);
 349         } else {
 350                 serve_404(s);
 351         }
 352 }
 353
 354 void sighandler(int sig)
 355 {
 356         switch(sig) {
 357                 case SIGPIPE:
 358                         break;
 359                 case SIGALRM:
 360                 default:
 361                         printf("Signal %d received\n", sig);
 362                         break;
 363         }
 364 }
 365
 366 int main(int argc, char **argv)
 367 {
 368         struct sigaction act;
 369         int sock, csock;
 370         int opt;
 371         socklen_t slen;
 372         struct scope *sc;
 373         struct sockaddr_in sin, clientsin;
 374         unsigned short port = 8088;
 375
 376         sc = initscope();
 377         if (sc == NULL) {
 378                 printf("Scope not found!\n");
 379                 exit(EXIT_FAILURE);
 380         }
 381
 382         bzero(&act, sizeof(act));
 383         act.sa_handler = sighandler;
 384         act.sa_flags = SA_RESTART;
 385         if (sigaction(SIGPIPE, &act, NULL) == -1) {
 386                 perror("sigaction");
 387                 exit(EXIT_FAILURE);
 388         }
 389
 390         bzero(&act, sizeof(act));
 391         act.sa_handler = sighandler;
 392         if (sigaction(SIGALRM, &act, NULL) == -1) {
 393                 perror("sigaction");
 394                 exit(EXIT_FAILURE);
 395         }
 396
 397         if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
 398                 perror("socket");
 399                 exit(EXIT_FAILURE);
 400         }
 401
 402         if (argc == 2) {
 403                 port=atoi(argv[1]);
 404         }
 405
 406         bzero(&sin, sizeof(sin));
 407         sin.sin_addr.s_addr=htonl(INADDR_ANY);
 408         sin.sin_family=AF_INET;
 409         sin.sin_port=htons(port);
 410
 411         opt = 1;
 412         setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt,sizeof(opt));
 413
 414         if (bind(sock, (struct sockaddr*)&sin, sizeof(sin)) == -1) {
 415                 perror("bind");
 416                 exit(EXIT_FAILURE);
 417         }
 418
 419         listen(sock, 32);
 420         printf("Listening on Port %u\n", port);
 421
 422         while(1) {
 423                 bzero(&clientsin, sizeof(clientsin));
 424                 slen = sizeof(clientsin);
 425                 if ((csock = accept(sock, (struct sockaddr*)&clientsin, &slen)) == -1) {
 426                         perror("accept");
 427                 }
 428
 429                 parse_request(csock, sc);
 430
 431                 close(csock);
 432         }
 433
 434         closescope(sc);
 435         return 0;
 436 }