path: root/api/api.c

/*
 * threaded.c -- A simple multi-threaded FastCGI application.
 */

#ifndef lint
// static const char rcsid[] = "$Id: threaded.c,v 1.9 2001/11/20 03:23:21 robs Exp $"; // just popps up warnings
#endif /* not lint */

#include "fcgi_config.h"

#include <pthread.h>
#include <sys/types.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include "fcgiapp.h"

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "urlcode.c"
#include <limits.h>
#include <stdio.h>
#define MALLOC_RETURNED_NULL fprintf(stderr, "%s()@" __FILE__ ":%d: malloc() returned NULL\n", __func__, __LINE__);


#define THREAD_COUNT 20

static int counts[THREAD_COUNT];

struct assoc_s {
	char * key;
	char * value;
}; // value je lahko NULL

void free_assoc_s(struct assoc_s * s) {
	if (s->key != NULL) {
		free(s->key);
		s->key = NULL;
	}
	if (s->value != NULL) {
		free(s->value);
		s->value = NULL;
	}
	free(s);
	s = NULL;
	return;
}

struct request_uri_s {
	char * path;
	struct assoc_s ** params; // to je "array". zadnji naj bo NULL.
};

void free_request_uri_s(struct request_uri_s * s) {
	int unsigned i = 0;
	while (s->params[i] != NULL) {
		free_assoc_s(s->params[i]);
		s->params[i++] = NULL;
	}
	free(s->path);
	s->path = NULL;
	free(s->params);
	s->params = NULL;
	free(s);
	s = NULL;
	return;
}

struct assoc_s ** parse_html_keyvalue(const char * t) {
	struct assoc_s ** params = malloc(sizeof(void *));
	if (params == NULL) {
		MALLOC_RETURNED_NULL
		return NULL;
	}
	unsigned int o = 0; // številka parametra od 0 vključno z 0
	unsigned int n = 0; // 0 če smo v key, 1 če smo v value, 3 če je konec urija
	unsigned int a = 0; // nakazuje pozicijo naslednjega znaka, ki ga bomo napisa.
	params[0] = malloc(sizeof(struct assoc_s));
	if (params[0] == NULL) {
		MALLOC_RETURNED_NULL
		return NULL;
	}
	for (unsigned int e = 0; n != 3 && e <= UINT_MAX; e++) {
		switch (t[e]) {
			case '\0':
				params = realloc(params, sizeof(struct assoc_s)*(o+1));
				if (params == NULL) {
					MALLOC_RETURNED_NULL
					return NULL;
				} // zadnji mora biti null
				params[o+1] = NULL;
				n = 3;
				break;
			case '=':
				if (n == 0) { // ni treba mallocat, realloca se pred vsakim writom bajta
					n = 1;
					a = 0;
				} else { // this is some undocumented behaviour, adding = to param value
					params[o]->value = realloc(params[o]->value, a+1);
					if (params[o]->value == NULL) {
						MALLOC_RETURNED_NULL
						return NULL;
					}
					params[o]->value[a++] = '=';
				}
				break;
			case '&': // tu je treba mallocat, ker assoc_s še ne obstaja za naslednji
				n = 0;
				a = 0;
				o++;
				params = realloc(params, sizeof(struct assoc_s)*(o+1));
				if (params == NULL) {
					MALLOC_RETURNED_NULL
					return NULL;
				}
				params[o] = malloc(sizeof(struct assoc_s)); // value kasneje
				if (params[o] == NULL) {
					MALLOC_RETURNED_NULL
					return NULL;
				}
				break;
			default:
				if (n == 0) {
					params[o]->key = realloc(params[o]->key, a+1);
					if (params[o]->key == NULL) {
						MALLOC_RETURNED_NULL
						return NULL;
					}
					params[o]->key[a++] = t[e];
				} else {
					params[o]->value = realloc(params[o]->value, a+1);
					if (params[o]->value == NULL) {
						MALLOC_RETURNED_NULL
						return NULL;
					}
					params[o]->value[a++] = t[e];
				}
				break;
		}
	}
	return params;
}

struct request_uri_s * parse_request_uri(char * uri) { // returns NULL on fail!
	struct request_uri_s * parsed = malloc(sizeof(struct request_uri_s));
	if (parsed == NULL) { // and returns pointer to ONE request_uri_s on success^
		MALLOC_RETURNED_NULL
		return NULL;
	}
	char * t = strchr(uri, '?'); // remember to free /\ !
	if (t != NULL)
		t[0] = '\0'; // uri vedno vseeno pride ven nespremenjen/popravljen
	parsed->path = malloc(sizeof(char)*strlen(uri)+1); //znak po path je itak NULL
	if (parsed->path == NULL) { // malloc returna NULL, fucking panic!
		if (t != NULL) // popravimo še \0 nazaj na ?
			t[0] = '?';
		MALLOC_RETURNED_NULL
		return NULL;
	}
	strncpy(parsed->path, uri, strlen(uri)+1); // torej zadnji znak patha bo NULL
	parsed->params = NULL; // če slučajno ni query_stringa in kmalu returnamo
	if (t == NULL) // ni query stringa zato je path parse dovoljšen
		return parsed; // parsed.params je NULL, to pred uporabo PREVERIMO!
	t[0] = '?'; // ker smo prej zaradi strlen in strncpy dali na NULL, sedaj spre.
	t++; // da ne začnemo z vprašajem ampak z prvim znakom
	parsed->params = parse_html_keyvalue(t);
	return parsed;
}

static void *doit(void *a) {
	intptr_t rc, i, thread_id = (intptr_t)a;
	pid_t pid = getpid();
	FCGX_Request request;
	char *server_name;
	char * uri_to_parse;
	struct request_uri_s * parseduri;

	FCGX_InitRequest(&request, 0, 0);

	for (;;) {
		static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
		static pthread_mutex_t counts_mutex = PTHREAD_MUTEX_INITIALIZER;

		/* Some platforms require accept() serialization, some don't.. */
		pthread_mutex_lock(&accept_mutex);
		rc = FCGX_Accept_r(&request);
		pthread_mutex_unlock(&accept_mutex);

		if (rc < 0)
			break;	

		server_name = FCGX_GetParam("SERVER_NAME", request.envp);
		uri_to_parse = FCGX_GetParam("REQUEST_URI", request.envp);
		parseduri = parse_request_uri(uri_to_parse);
		if (strchr(parseduri->path, 'S') != NULL) {
			exit(0);
		}
		if (parseduri == NULL) {
			FCGX_FPrintF(request.out, "Status: 500 Zaledna napaka\r\n"
				"Content-Type: text/plain; charset=utf-8\r\n\r\n"
				"zgodila se je napaka na strežniku med procesiranjem URIja.\r\n");
			free_request_uri_s(parseduri);
			goto doit_finish;
		}
		FCGX_FPrintF(request.out,
				"Status: 200 V redu\r\n"
				"Content-type: text/html; charset=utf-8\r\n"
				"\r\n"
				"<title>FastCGI Pozdravljen svet! (večnitenje v C, knjižnica fcgiapp)</title>"
				"<h1>FastCGI Pozdravljen svet! (večnitenje v C, knjižnica fcgiapp)</h1>"
				"Nit %d, Proces %ld<p>"
				"Števci zahtev za %d niti na strežniku <i>%s</i><p><code>",
				thread_id, pid,
				THREAD_COUNT, server_name ? server_name : "?");
		free_request_uri_s(parseduri);
		pthread_mutex_lock(&counts_mutex);
		++counts[thread_id];
		for (i = 0; i < THREAD_COUNT; i++)
			FCGX_FPrintF(request.out, "%5d " , counts[i]);
		pthread_mutex_unlock(&counts_mutex);

doit_finish:
		FCGX_Finish_r(&request);
	}

	return NULL;
}

int main(void) {
	intptr_t i;
	pthread_t id[THREAD_COUNT];

	FCGX_Init();

	for (i = 1; i < THREAD_COUNT; i++)
		pthread_create(&id[i], NULL, doit, (void*)i);

	doit(0); // trenutno nit uporabimo tudi kot handler, zakaj pa ne (:

	return 0;
}