[rigol] / rigold.c

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <signal.h>
#include <stdarg.h>

#include "scope.h"
#include "commands.h"

#define TIMEOUT 4

static int send_binary(int s, char *buf, int len)
{
	int ret;

	while(len > 0) {
		ret = write(s, buf, len);
		if (ret == -1) {
			perror("write");
			return ret;
		}
		buf += ret;
		len -= ret;
	}

	return 0;
}

static int send_text(int s, char *fmt, ...)
{
	va_list argp;
	char buf[4096];
	int cnt;

	va_start(argp, fmt);
	cnt = vsnprintf(buf, sizeof(buf), fmt, argp);
	va_end(argp);

	if (cnt < 0)
		return cnt;

	return send_binary(s, buf, cnt);
}

static int send_command_output(int s, struct scope *sc, char *cmd)
{
	unsigned char buf[1024*1024];
	int res;

	res = sendscpi(sc, cmd, buf, sizeof(buf));
	send_binary(s, (char*)buf, res);

	return res;
}

static void serve_index(int s, struct scope *sc, char *param)
{
	int i;
	struct channel_s *ch;

	send_text(s, "HTTP/1.0 200 OK\n");
	send_text(s, "Content-type: text/html\n\n");
	send_text(s, "<html><head><title>%s</title></head><body bgcolor=\"#ffffff\" text=\"#000000\">\n", scope_idn(sc));
	send_text(s, "<img src=\"/cgi-bin/lcd\" height=\"234\" width=\"320\">\n");
	send_text(s, "<br>\n");

	claimscope(sc);
	update_scope_status(sc);
	releasescope(sc);

	send_text(s, "System: Language: %s, Counter: %d, Beep: %d<br><br>\n",
		sc->status.system.lang,
		sc->status.system.counter_enabled,
		sc->status.system.beep_enabled);
	
	send_text(s, "Keyboard: Key Lock: %d<br><br>\n",
		sc->status.keyboard.key_lock);
	
	send_text(s, "Measure: Source: %s, Total: %d<br>\n",
		sc->status.measure.source,
		sc->status.measure.total);

	send_text(s, "Measure CH1:<br>\n");
	send_text(s, "VPP: %lg, VMAX: %lg, VMIN: %lg, VAMPLITUDE: %lg, VTOP: %lg, VBASE: %lg, VAVERAGE: %lg, VRMS: %lg<br>\n",
		sc->status.measure.ch1.vpp,
		sc->status.measure.ch1.vmax,
		sc->status.measure.ch1.vmin,
		sc->status.measure.ch1.vamplitude,
		sc->status.measure.ch1.vtop,
		sc->status.measure.ch1.vbase,
		sc->status.measure.ch1.vaverage,
		sc->status.measure.ch1.vrms);
	
	send_text(s, "Overshoot: %lg, Preshoot: %lg<br>\n",
		sc->status.measure.ch1.overshoot,
		sc->status.measure.ch1.preshoot);

	send_text(s, "Frequency: %lg, Risetime: %lg, Falltime: %lg<br>\n",
		sc->status.measure.ch1.frequency,
		sc->status.measure.ch1.risetime,
		sc->status.measure.ch1.falltime);

	send_text(s, "Period: %lg, Pwidth: %lg, Nwidth: %lg, Pdutycycle: %lg, Ndutycycle: %lg<br>\n",
		sc->status.measure.ch1.period,
		sc->status.measure.ch1.pwidth,
		sc->status.measure.ch1.nwidth,
		sc->status.measure.ch1.pdutycycle,
		sc->status.measure.ch1.ndutycycle);

	send_text(s, "Pdelay: %lg, Ndelay: %lg<br>\n",
		sc->status.measure.ch1.pdelay,
		sc->status.measure.ch1.ndelay);

	send_text(s, "Measure CH2:<br>\n");
	send_text(s, "VPP: %lg, VMAX: %lg, VMIN: %lg, VAMPLITUDE: %lg, VTOP: %lg, VBASE: %lg, VAVERAGE: %lg, VRMS: %lg<br>\n",
		sc->status.measure.ch2.vpp,
		sc->status.measure.ch2.vmax,
		sc->status.measure.ch2.vmin,
		sc->status.measure.ch2.vamplitude,
		sc->status.measure.ch2.vtop,
		sc->status.measure.ch2.vbase,
		sc->status.measure.ch2.vaverage,
		sc->status.measure.ch2.vrms);
	
	send_text(s, "Overshoot: %lg, Preshoot: %lg<br>\n",
		sc->status.measure.ch2.overshoot,
		sc->status.measure.ch2.preshoot);

	send_text(s, "Frequency: %lg, Risetime: %lg, Falltime: %lg<br>\n",
		sc->status.measure.ch2.frequency,
		sc->status.measure.ch2.risetime,
		sc->status.measure.ch2.falltime);

	send_text(s, "Period: %lg, Pwidth: %lg, Nwidth: %lg, Pdutycycle: %lg, Ndutycycle: %lg<br>\n",
		sc->status.measure.ch2.period,
		sc->status.measure.ch2.pwidth,
		sc->status.measure.ch2.nwidth,
		sc->status.measure.ch2.pdutycycle,
		sc->status.measure.ch2.ndutycycle);

	send_text(s, "Pdelay: %lg, Ndelay: %lg<br>\n",
		sc->status.measure.ch2.pdelay,
		sc->status.measure.ch2.ndelay);

	send_text(s, "<br>Acquire: Type: %s, Mode: %s, Averages: %d, CH1: %.10lg samples/s, CH2: %.10lg samples/s<br>\n",
		sc->status.acquire.type,
		sc->status.acquire.mode,
		sc->status.acquire.averages,
		sc->status.acquire.srate_ch1,
		sc->status.acquire.srate_ch2);

	send_text(s, "<br>Display: Type: %s, Grid: %s, Persist: %d, MNUDisplay: %s, MNUStatus: %d, Screen: %s, Brightness: %d, Intensity: %d<br><br>\n",
		sc->status.display.type,
		sc->status.display.grid,
		sc->status.display.persist,
		sc->status.display.mnudisplay,
		sc->status.display.mnustatus,
		sc->status.display.screen,
		sc->status.display.brightness,
		sc->status.display.intensity);
	
	for (i = 1; i <= 2; i++) {
		if (i == 1) {
			ch = &(sc->status.channel.ch1);
		} else {
			ch = &(sc->status.channel.ch2);
		}
		send_text(s, "Channel %d: ", i);

		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",
			ch->bwlimit_enabled,
			ch->coupling,
			ch->displayed,
			ch->inverted,
			ch->offset,
			ch->probe,
			ch->scale,
			ch->filter_enabled,
			ch->memory_depth,
			ch->vernier);
	}

	send_text(s, "<br>Horizontal: Mode: %s, Offset: %lg, Delayed Offset: %lg, Scale: %lg, Format: %s<br>\n",
		sc->status.timebase.mode,
		sc->status.timebase.offset,
		sc->status.timebase.delayed_offset,
		sc->status.timebase.scale,
		sc->status.timebase.format);


	send_text(s, "<br>\n");
	send_text(s, "<form method=\"get\" action=\"\">\n");
	send_text(s, "<input type=\"text\" name=\"cmd\" value=\"");
	if (param) {
		if (strncmp(param, "cmd=", 4) == 0)
			param += 4;

		send_text(s, param);
	}
	send_text(s, "\">\n");
	send_text(s, "<input type=\"submit\">\n");
	send_text(s, "</form>\n");
	send_text(s, "<a href=\"?cmd=:RUN\">RUN</a> ");
	send_text(s, "<a href=\"?cmd=:STOP\">STOP</a> ");
	send_text(s, "<a href=\"?cmd=:FORC\">FORCE</a> ");
	if (param) {
		claimscope(sc);
		if (strchr (param, '?')) {
			send_text(s, "<pre>< ");
			send_text(s, param);
			send_text(s, "\n> ");
			send_command_output(s, sc, param);
			send_text(s, "</pre>\n");
		} else {
			sendscpi(sc, param, NULL, 0);
		}
		releasescope(sc);
	}
	send_text(s, "</body></html>\n");
}

static void serve_lcd(int s, struct scope *sc)
{
	char buf[256];
	int imglen;
	unsigned char *png;

	claimscope(sc);
	png = get_lcd(sc, &imglen, 0);
	releasescope(sc);

	if (png == NULL)
		return;


	send_text(s, "HTTP/1.0 200 OK\n");
	send_text(s, "Content-type: image/png\n");
	snprintf(buf, sizeof(buf), "Content-length: %u\n\n", imglen);
	send_text(s, buf);
	send_binary(s, (char*)png, imglen);
	free(png);
}

static void serve_404(int s)
{
	send_text(s, "HTTP/1.0 404 Not found\n");
	send_text(s, "Content-type: text/html\n\n");
	send_text(s, "<html><head><title>404</title></head>");
	send_text(s, "<body bgcolor=\"#ffffff\" text=\"#000000\">\n");
	send_text(s, "<h1>404</h1>");
	send_text(s, "</body></html>\n");
}

int is_eor(char *buf)
{
	int eor = 0;

	/* This does not completely work, when the request is split
	   in multiple packets... */
	if (strstr(buf, "\x0d\x0a\x0d\x0a")) {
		eor = 1;
	} else if (strstr(buf, "\x0a\x0a")) {
		eor = 1;
	} else if (strcmp(buf, "\x0d\x0a") == 0) {
		eor = 1;
	} else if (strcmp(buf, "\x0a") == 0) {
		eor = 1;
	}

	return eor;
}


static void parse_request(int s, struct scope *sc)
{
	int ret;
	int eor;
	char buf[4096];
	char file[4096];
	const char delim[] = " \t\x0d\x0a";
	char *saveptr;
	char *token;
	char *param = NULL;

	alarm(TIMEOUT);
	ret=read(s, buf, sizeof(buf)-1);
	if (ret == -1) {
		perror("read");
		return;
	}
	buf[ret] = 0;

	eor = is_eor(buf);

	token = strtok_r(buf, delim, &saveptr);
	if (token == NULL)
		return;
	/* TODO: Only GET... */
	token = strtok_r(NULL, delim, &saveptr);
	if (token == NULL)
		return;
	bzero(&file, sizeof(file));
	strncpy(file, token, sizeof(file)-1);

	while (!eor) {
		alarm(TIMEOUT);
		ret=read(s, buf, sizeof(buf)-1);
		if (ret == -1) {
			perror("read");
			return;
		}
		buf[ret] = 0;
		eor = is_eor(buf);
	}
	alarm(0);

	param = strchr(file, '?');
	if (param) {
		*param = 0;
		param++;

		while ((token = strchr(param, '%')) != NULL) {
			char buf[3];

			if (strlen(token+1) < 2)
				break;

			strncpy(buf, token+1, 3);
			buf[2] = 0;

			*token = (char)strtoul(buf, NULL, 16);
			memmove(token+1, token+3, strlen(token)-2);

		}
		while ((token = strchr(param, '+')) != NULL) {
			*token = ' ';
		}
	}

	if (strcmp("/", file) == 0) {
		serve_index(s, sc, param);
	} else if (strcmp("/cgi-bin/lcd", file) == 0) {
		serve_lcd(s, sc);
	} else {
		serve_404(s);
	}
}

void sighandler(int sig)
{
	switch(sig) {
		case SIGPIPE:
			break;
		case SIGALRM:
		default:
			printf("Signal %d received\n", sig);
			break;
	}
}

int main(int argc, char **argv) 
{
	struct sigaction act;
	int sock, csock;
	int opt;
	socklen_t slen;
	struct scope *sc;
	struct sockaddr_in sin, clientsin;
	unsigned short port = 8088;

	sc = initscope();
	if (sc == NULL) {
		printf("Scope not found!\n");
		exit(EXIT_FAILURE);
	}

	bzero(&act, sizeof(act));
	act.sa_handler = sighandler;
	act.sa_flags = SA_RESTART;
	if (sigaction(SIGPIPE, &act, NULL) == -1) {
		perror("sigaction");
		exit(EXIT_FAILURE);
	}

	bzero(&act, sizeof(act));
	act.sa_handler = sighandler;
	if (sigaction(SIGALRM, &act, NULL) == -1) {
		perror("sigaction");
		exit(EXIT_FAILURE);
	}

	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		perror("socket");
		exit(EXIT_FAILURE);
	}

	if (argc == 2) {
		port=atoi(argv[1]);
	}

	bzero(&sin, sizeof(sin));
	sin.sin_addr.s_addr=htonl(INADDR_ANY);
	sin.sin_family=AF_INET;
	sin.sin_port=htons(port);

	opt = 1;
	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt,sizeof(opt));

	if (bind(sock, (struct sockaddr*)&sin, sizeof(sin)) == -1) {
		perror("bind");
		exit(EXIT_FAILURE);
	}

	listen(sock, 32);
	printf("Listening on Port %u\n", port);

	while(1) {
		bzero(&clientsin, sizeof(clientsin));
		slen = sizeof(clientsin);
		if ((csock = accept(sock, (struct sockaddr*)&clientsin, &slen)) == -1) {
			perror("accept");
		}

		parse_request(csock, sc);

		close(csock);
	}

	closescope(sc);
	return 0;
}
Commit	Line	Data
ad9fbc05 MG	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>
713be7a4	8	#include <unistd.h>
7a226bb8	9	#include <signal.h>
78fb0984	10	#include <stdarg.h>
659f6954	11
713be7a4	12	#include "scope.h"
ad9fbc05 MG	13	#include "commands.h"
ad9fbc05 MG	14
33b7545a MG	15	#define TIMEOUT 4
33b7545a MG	16
ad9fbc05 MG	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
78fb0984	34	static int send_text(int s, char *fmt, ...)
ad9fbc05	35	{
78fb0984 MG	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;
ad9fbc05 MG	59	}
ad9fbc05 MG	60
04d383a4	61	static void serve_index(int s, struct scope sc, char param)
ad9fbc05	62	{
15747296 MG	63	int i;
	64	struct channel_s *ch;
	65
33b7545a	66	send_text(s, "HTTP/1.0 200 OK\n");
ad9fbc05	67	send_text(s, "Content-type: text/html\n\n");
78fb0984	68	send_text(s, "<html><head><title>%s</title></head><body bgcolor=\"#ffffff\" text=\"#000000\">\n", scope_idn(sc));
04d383a4	69	send_text(s, "<img src=\"/cgi-bin/lcd\" height=\"234\" width=\"320\">\n");
78fb0984 MG	70	send_text(s, "<br>\n");
	71
	72	claimscope(sc);
	73	update_scope_status(sc);
15747296	74	releasescope(sc);
78fb0984	75
adb5a679	76	send_text(s, "System: Language: %s, Counter: %d, Beep: %d<br><br>\n",
78fb0984 MG	77	sc->status.system.lang,
	78	sc->status.system.counter_enabled,
	79	sc->status.system.beep_enabled);
	80
adb5a679	81	send_text(s, "Keyboard: Key Lock: %d<br><br>\n",
78fb0984	82	sc->status.keyboard.key_lock);
adb5a679 MG	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);
78fb0984	118
adb5a679 MG	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
15747296	150	send_text(s, "<br>Acquire: Type: %s, Mode: %s, Averages: %d, CH1: %.10lg samples/s, CH2: %.10lg samples/s<br>\n",
adb5a679 MG	151	sc->status.acquire.type,
adb5a679 MG	152	sc->status.acquire.mode,
15747296 MG	153	sc->status.acquire.averages,
	154	sc->status.acquire.srate_ch1,
	155	sc->status.acquire.srate_ch2);
adb5a679	156
15747296	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",
adb5a679 MG	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);
15747296 MG	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	}
78fb0984	187
15747296 MG	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);
78fb0984	194
78fb0984	195
04d383a4 MG	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");
78fb0984 MG	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> ");
04d383a4	211	if (param) {
04d383a4 MG	212	claimscope(sc);
04d383a4 MG	213	if (strchr (param, '?')) {
04d383a4 MG	214	send_text(s, "<pre>< ");
	215	send_text(s, param);
	216	send_text(s, "\n> ");
78fb0984	217	send_command_output(s, sc, param);
04d383a4 MG	218	send_text(s, "</pre>\n");
	219	} else {
	220	sendscpi(sc, param, NULL, 0);
	221	}
	222	releasescope(sc);
	223	}
ad9fbc05 MG	224	send_text(s, "</body></html>\n");
	225	}
	226
713be7a4	227	static void serve_lcd(int s, struct scope *sc)
ad9fbc05 MG	228	{
	229	char buf[256];
	230	int imglen;
	231	unsigned char *png;
	232
713be7a4	233	claimscope(sc);
ad9fbc05	234	png = get_lcd(sc, &imglen, 0);
713be7a4	235	releasescope(sc);
ad9fbc05 MG	236
	237	if (png == NULL)
	238	return;
	239
	240
33b7545a	241	send_text(s, "HTTP/1.0 200 OK\n");
ad9fbc05 MG	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
04d383a4 MG	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
33b7545a MG	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
713be7a4	279	static void parse_request(int s, struct scope *sc)
ad9fbc05 MG	280	{
ad9fbc05 MG	281	int ret;
33b7545a MG	282	int eor;
	283	char buf[4096];
	284	char file[4096];
ad9fbc05	285	const char delim[] = " \t\x0d\x0a";
ad9fbc05 MG	286	char *saveptr;
ad9fbc05 MG	287	char *token;
04d383a4	288	char *param = NULL;
ad9fbc05	289
33b7545a	290	alarm(TIMEOUT);
ad9fbc05 MG	291	ret=read(s, buf, sizeof(buf)-1);
	292	if (ret == -1) {
	293	perror("read");
	294	return;
	295	}
	296	buf[ret] = 0;
	297
33b7545a MG	298	eor = is_eor(buf);
33b7545a MG	299
ad9fbc05	300	token = strtok_r(buf, delim, &saveptr);
77385d56 MG	301	if (token == NULL)
77385d56 MG	302	return;
ad9fbc05 MG	303	/* TODO: Only GET... */
ad9fbc05 MG	304	token = strtok_r(NULL, delim, &saveptr);
77385d56 MG	305	if (token == NULL)
77385d56 MG	306	return;
ad9fbc05 MG	307	bzero(&file, sizeof(file));
	308	strncpy(file, token, sizeof(file)-1);
	309
33b7545a MG	310	while (!eor) {
	311	alarm(TIMEOUT);
	312	ret=read(s, buf, sizeof(buf)-1);
	313	if (ret == -1) {
	314	perror("read");
	315	return;
ad9fbc05	316	}
33b7545a MG	317	buf[ret] = 0;
	318	eor = is_eor(buf);
	319	}
	320	alarm(0);
ad9fbc05	321
04d383a4 MG	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	}
78fb0984 MG	340	while ((token = strchr(param, '+')) != NULL) {
	341	*token = ' ';
	342	}
04d383a4 MG	343	}
04d383a4 MG	344
ad9fbc05	345	if (strcmp("/", file) == 0) {
04d383a4 MG	346	serve_index(s, sc, param);
04d383a4 MG	347	} else if (strcmp("/cgi-bin/lcd", file) == 0) {
ad9fbc05	348	serve_lcd(s, sc);
04d383a4 MG	349	} else {
04d383a4 MG	350	serve_404(s);
ad9fbc05 MG	351	}
ad9fbc05 MG	352	}
659f6954	353
7a226bb8 MG	354	void sighandler(int sig)
7a226bb8 MG	355	{
33b7545a MG	356	switch(sig) {
	357	case SIGPIPE:
	358	break;
	359	case SIGALRM:
	360	default:
	361	printf("Signal %d received\n", sig);
	362	break;
	363	}
7a226bb8 MG	364	}
7a226bb8 MG	365
659f6954 MG	366	int main(int argc, char **argv)
659f6954 MG	367	{
7a226bb8	368	struct sigaction act;
ad9fbc05 MG	369	int sock, csock;
	370	int opt;
	371	socklen_t slen;
713be7a4	372	struct scope *sc;
ad9fbc05	373	struct sockaddr_in sin, clientsin;
77385d56	374	unsigned short port = 8088;
659f6954	375
713be7a4	376	sc = initscope();
7a226bb8 MG	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	}
ad9fbc05	389
33b7545a MG	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
ad9fbc05 MG	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
713be7a4	434	closescope(sc);
659f6954 MG	435	return 0;
659f6954 MG	436	}