Ur/Web: src/c/urweb.c annotate

annotate src/c/urweb.c @ 1942:a671e5258a2c

Raise exception when recv()ing from someone else's channel; improve setting of client ID in RPCs

author	Adam Chlipala <adam@chlipala.net>
date	Fri, 27 Dec 2013 12:10:03 -0500
parents	9f3597979e98
children	3ecd0b6360eb

rev	line source
adamc@1268	1 #include "config.h"
adamc@1268	2
adamc@117	3 #include <stdlib.h>
adamc@102	4 #include <stdio.h>
adamc@117	5 #include <string.h>
adamc@457	6 #include <strings.h>
adamc@106	7 #include <ctype.h>
adamc@167	8 #include <setjmp.h>
adamc@167	9 #include <stdarg.h>
adamc@682	10 #include <assert.h>
adamc@741	11 #include <ctype.h>
adamc@1114	12 #include <limits.h>
adamc@1113	13 #include <stdint.h>
adamc@1094	14 #include <sys/types.h>
adamc@1094	15 #include <sys/socket.h>
adam@1397	16 #include <openssl/des.h>
adam@1486	17 #include <openssl/rand.h>
adam@1374	18 #include <time.h>
adam@1571	19 #include <math.h>
adamc@102	20
adamc@667	21 #include <pthread.h>
adamc@667	22
adamc@102	23 #include "types.h"
adamc@102	24
adam@1431	25 uw_unit uw_unit_v = 0;
adamc@102	26
adamc@667	27
adamc@667	28 // Socket extras
adamc@667	29
adamc@863	30 int uw_really_send(int sock, const void *buf, ssize_t len) {
adamc@667	31 while (len > 0) {
adamc@856	32 ssize_t n = send(sock, buf, len, 0);
adamc@856	33
adamc@856	34 if (n < 0)
adamc@856	35 return n;
adamc@856	36
adamc@856	37 buf += n;
adamc@856	38 len -= n;
adamc@856	39 }
adamc@856	40
adamc@856	41 return 0;
adamc@856	42 }
adamc@856	43
adamc@856	44 int uw_really_write(int fd, const void *buf, size_t len) {
adamc@856	45 while (len > 0) {
adamc@856	46 ssize_t n = write(fd, buf, len);
adamc@667	47
adamc@667	48 if (n < 0)
adamc@667	49 return n;
adamc@667	50
adamc@667	51 buf += n;
adamc@667	52 len -= n;
adamc@667	53 }
adamc@667	54
adamc@667	55 return 0;
adamc@667	56 }
adamc@667	57
adamc@667	58
adamc@667	59 // Buffers
adamc@667	60
adam@1369	61 void uw_buffer_init(size_t max, uw_buffer *b, size_t s) {
adamc@1113	62 b->max = max;
adamc@667	63 b->front = b->start = malloc(s);
adamc@667	64 b->back = b->front + s;
adamc@667	65 }
adamc@667	66
adam@1369	67 void uw_buffer_free(uw_buffer *b) {
adamc@667	68 free(b->start);
adamc@667	69 }
adamc@667	70
adam@1369	71 void uw_buffer_reset(uw_buffer *b) {
adamc@667	72 b->front = b->start;
adamc@667	73 }
adamc@667	74
adam@1369	75 int uw_buffer_check(uw_buffer *b, size_t extra) {
adamc@667	76 if (b->back - b->front < extra) {
adamc@667	77 size_t desired = b->front - b->start + extra, next;
adamc@667	78 char *new_heap;
adamc@667	79
adamc@667	80 next = b->back - b->start;
adamc@667	81 if (next == 0)
adamc@667	82 next = 1;
adamc@667	83 for (; next < desired; next *= 2);
adamc@667	84
adamc@1134	85 if (next > b->max) {
adamc@1113	86 if (desired <= b->max)
adamc@1113	87 next = desired;
adamc@1113	88 else
adamc@1113	89 return 1;
adamc@1134	90 }
adamc@1113	91
adamc@667	92 new_heap = realloc(b->start, next);
adamc@667	93 b->front = new_heap + (b->front - b->start);
adamc@667	94 b->back = new_heap + next;
adamc@667	95 b->start = new_heap;
adamc@667	96 }
adamc@1113	97
adamc@1113	98 return 0;
adamc@1113	99 }
adamc@1113	100
adamc@1113	101 __attribute__((noreturn)) void uw_error(uw_context, failure_kind, const char *, ...);
adamc@1113	102
adam@1369	103 static void ctx_uw_buffer_check(uw_context ctx, const char kind, uw_buffer b, size_t extra) {
adam@1369	104 if (uw_buffer_check(b, extra))
adamc@1113	105 uw_error(ctx, FATAL, "Memory limit exceeded (%s)", kind);
adamc@667	106 }
adamc@667	107
adam@1369	108 size_t uw_buffer_used(uw_buffer *b) {
adamc@667	109 return b->front - b->start;
adamc@667	110 }
adamc@667	111
adam@1369	112 size_t uw_buffer_avail(uw_buffer *b) {
adamc@667	113 return b->back - b->start;
adamc@667	114 }
adamc@667	115
adam@1369	116 int uw_buffer_append(uw_buffer b, const char s, size_t len) {
adam@1369	117 if (uw_buffer_check(b, len+1))
adamc@1113	118 return 1;
adamc@1113	119
adamc@1113	120 memcpy(b->front, s, len);
adamc@1113	121 b->front += len;
adamc@1113	122 *b->front = 0;
adamc@1113	123
adamc@1113	124 return 0;
adamc@1113	125 }
adamc@1113	126
adam@1369	127 static void ctx_uw_buffer_append(uw_context ctx, const char kind, uw_buffer b, const char *s, size_t len) {
adam@1369	128 ctx_uw_buffer_check(ctx, kind, b, len+1);
adamc@1113	129
adamc@668	130 memcpy(b->front, s, len);
adamc@668	131 b->front += len;
adamc@672	132 *b->front = 0;
adamc@668	133 }
adamc@667	134
adamc@668	135
adamc@672	136 // Persistent state types
adamc@667	137
adamc@667	138 typedef enum { UNUSED, USED } usage;
adamc@667	139
adamc@667	140 typedef struct client {
adamc@682	141 unsigned id;
adamc@667	142 usage mode;
adamc@682	143 int pass;
adamc@682	144 struct client *next;
adamc@689	145 pthread_mutex_t lock, pull_lock;
adam@1369	146 uw_buffer msgs;
adamc@682	147 int sock;
adamc@863	148 int (send)(int sockfd, const void buf, ssize_t len);
adamc@863	149 int (*close)(int fd);
adamc@682	150 time_t last_contact;
adamc@682	151 unsigned n_channels;
adamc@685	152 unsigned refcount;
adamc@1121	153 void *data;
adamc@667	154 } client;
adamc@667	155
adamc@672	156
adamc@672	157 // Persistent client state
adamc@672	158
adamc@682	159 static client *clients, clients_free, *clients_used;
adamc@682	160 static unsigned n_clients;
adamc@667	161
adam@1707	162 static pthread_mutex_t clients_mutex = PTHREAD_MUTEX_INITIALIZER;
adamc@1113	163 size_t uw_messages_max = SIZE_MAX;
adamc@1113	164 size_t uw_clients_max = SIZE_MAX;
adamc@1113	165
adamc@1121	166 void *uw_init_client_data();
adamc@1121	167 void uw_free_client_data(void *);
adamc@1121	168 void uw_copy_client_data(void dst, void src);
adamc@1121	169
adamc@682	170 static client *new_client() {
adamc@667	171 client *c;
adamc@667	172
adamc@667	173 pthread_mutex_lock(&clients_mutex);
adamc@667	174
adamc@667	175 if (clients_free) {
adamc@667	176 c = clients_free;
adamc@682	177 clients_free = clients_free->next;
adamc@667	178 }
adam@1672	179 else if (n_clients >= uw_clients_max) {
adam@1672	180 pthread_mutex_unlock(&clients_mutex);
adamc@1113	181 return NULL;
adam@1672	182 } else {
adamc@667	183 ++n_clients;
adamc@667	184 clients = realloc(clients, sizeof(client) * n_clients);
adamc@667	185 c = malloc(sizeof(client));
adamc@667	186 c->id = n_clients-1;
adamc@682	187 pthread_mutex_init(&c->lock, NULL);
adamc@689	188 pthread_mutex_init(&c->pull_lock, NULL);
adam@1369	189 uw_buffer_init(uw_messages_max, &c->msgs, 0);
adamc@667	190 clients[n_clients-1] = c;
adamc@667	191 }
adamc@667	192
adamc@682	193 pthread_mutex_lock(&c->lock);
adamc@667	194 c->mode = USED;
adamc@682	195 c->pass = rand();
adamc@682	196 c->sock = -1;
adamc@682	197 c->last_contact = time(NULL);
adam@1369	198 uw_buffer_reset(&c->msgs);
adamc@682	199 c->n_channels = 0;
adamc@685	200 c->refcount = 0;
adamc@1121	201 c->data = uw_init_client_data();
adamc@682	202 pthread_mutex_unlock(&c->lock);
adamc@682	203
adamc@682	204 c->next = clients_used;
adamc@682	205 clients_used = c;
adamc@667	206
adamc@667	207 pthread_mutex_unlock(&clients_mutex);
adamc@667	208
adamc@667	209 return c;
adamc@667	210 }
adamc@667	211
adamc@685	212 static void use_client(client *c) {
adamc@685	213 pthread_mutex_lock(&c->lock);
adamc@685	214 ++c->refcount;
adamc@685	215 pthread_mutex_unlock(&c->lock);
adamc@689	216 pthread_mutex_lock(&c->pull_lock);
adamc@685	217 }
adamc@685	218
adamc@685	219 static void release_client(client *c) {
adamc@689	220 pthread_mutex_unlock(&c->pull_lock);
adamc@685	221 pthread_mutex_lock(&c->lock);
adamc@685	222 --c->refcount;
adamc@685	223 pthread_mutex_unlock(&c->lock);
adamc@685	224 }
adamc@685	225
adamc@856	226 static const char begin_msgs[] = "Content-type: text/plain\r\n\r\n";
adam@1707	227 static pthread_t pruning_thread;
adam@1707	228 static int pruning_thread_initialized = 0;
adamc@667	229
adamc@682	230 static client *find_client(unsigned id) {
adamc@667	231 client *c;
adam@1708	232 int i_am_pruner = pruning_thread_initialized && pthread_equal(pruning_thread, pthread_self());
adam@1708	233
adam@1708	234 if (!i_am_pruner) pthread_mutex_lock(&clients_mutex);
adamc@667	235
adamc@667	236 if (id >= n_clients) {
adam@1708	237 if (!i_am_pruner) pthread_mutex_unlock(&clients_mutex);
adamc@668	238 return NULL;
adamc@667	239 }
adamc@667	240
adamc@667	241 c = clients[id];
adamc@667	242
adam@1708	243 if (!i_am_pruner) pthread_mutex_unlock(&clients_mutex);
adamc@668	244 return c;
adamc@668	245 }
adamc@668	246
adamc@856	247 static char *on_success = "HTTP/1.1 200 OK\r\n";
adam@1409	248 static char *on_redirect = "HTTP/1.1 303 See Other\r\n";
adamc@856	249
adamc@856	250 void uw_set_on_success(char *s) {
adamc@856	251 on_success = s;
adamc@856	252 }
adamc@856	253
adam@1552	254 static void chastise(int (send)(int sockfd, const void buf, ssize_t len), int sock) {
adam@1552	255 send(sock, on_success, strlen(on_success));
adam@1552	256 send(sock, begin_msgs, sizeof(begin_msgs) - 1);
adam@1552	257 send(sock, "R", 1);
adam@1552	258 close(sock);
adam@1552	259 }
adam@1552	260
adamc@863	261 void uw_client_connect(unsigned id, int pass, int sock,
adamc@863	262 int (send)(int sockfd, const void buf, ssize_t len),
adamc@864	263 int (*close)(int fd),
adamc@864	264 void *logger_data, uw_logger log_error) {
adamc@682	265 client *c = find_client(id);
adamc@668	266
adamc@668	267 if (c == NULL) {
adam@1552	268 chastise(send, sock);
adamc@864	269 log_error(logger_data, "Out-of-bounds client request (%u)\n", id);
adamc@667	270 return;
adamc@667	271 }
adamc@667	272
adamc@682	273 pthread_mutex_lock(&c->lock);
adamc@671	274
adamc@682	275 if (c->mode != USED) {
adamc@682	276 pthread_mutex_unlock(&c->lock);
adam@1552	277 chastise(send, sock);
adamc@864	278 log_error(logger_data, "Client request for unused slot (%u)\n", id);
adamc@667	279 return;
adamc@667	280 }
adamc@667	281
adamc@682	282 if (pass != c->pass) {
adamc@682	283 pthread_mutex_unlock(&c->lock);
adam@1552	284 chastise(send, sock);
adamc@864	285 log_error(logger_data, "Wrong client password (%u, %d)\n", id, pass);
adamc@682	286 return;
adamc@667	287 }
adamc@667	288
adamc@682	289 if (c->sock != -1) {
adamc@863	290 c->close(c->sock);
adamc@682	291 c->sock = -1;
adamc@682	292 }
adamc@667	293
adamc@682	294 c->last_contact = time(NULL);
adamc@682	295
adam@1369	296 if (uw_buffer_used(&c->msgs) > 0) {
adamc@863	297 send(sock, on_success, strlen(on_success));
adamc@863	298 send(sock, begin_msgs, sizeof(begin_msgs) - 1);
adam@1369	299 send(sock, c->msgs.start, uw_buffer_used(&c->msgs));
adam@1369	300 uw_buffer_reset(&c->msgs);
adamc@667	301 close(sock);
adamc@667	302 }
adamc@863	303 else {
adamc@682	304 c->sock = sock;
adamc@863	305 c->send = send;
adamc@863	306 c->close = close;
adamc@863	307 }
adamc@667	308
adamc@682	309 pthread_mutex_unlock(&c->lock);
adamc@667	310 }
adamc@667	311
adamc@682	312 static void free_client(client *c) {
adamc@682	313 c->mode = UNUSED;
adamc@682	314 c->pass = -1;
adamc@667	315
adamc@682	316 c->next = clients_free;
adamc@682	317 clients_free = c;
adamc@667	318 }
adamc@667	319
adamc@682	320 static uw_Basis_channel new_channel(client *c) {
adamc@682	321 uw_Basis_channel ch = {c->id, c->n_channels++};
adamc@668	322 return ch;
adamc@668	323 }
adamc@668	324
adam@1447	325 static void client_send(client c, uw_buffer msg, const char *script, int script_len) {
adamc@685	326 pthread_mutex_lock(&c->lock);
adamc@671	327
adamc@682	328 if (c->sock != -1) {
adamc@863	329 c->send(c->sock, on_success, strlen(on_success));
adamc@863	330 c->send(c->sock, begin_msgs, sizeof(begin_msgs) - 1);
adam@1447	331 if (script_len > 0) {
adam@1447	332 c->send(c->sock, "E\n", 2);
adam@1447	333 c->send(c->sock, script, script_len);
adam@1447	334 c->send(c->sock, "\n", 1);
adam@1447	335 }
adam@1369	336 c->send(c->sock, msg->start, uw_buffer_used(msg));
adamc@863	337 c->close(c->sock);
adamc@682	338 c->sock = -1;
adam@1665	339 } else if (uw_buffer_append(&c->msgs, msg->start, uw_buffer_used(msg)))
adamc@1113	340 fprintf(stderr, "Client message buffer size exceeded");
adamc@671	341
adamc@685	342 pthread_mutex_unlock(&c->lock);
adamc@668	343 }
adamc@668	344
adamc@668	345
adamc@668	346 // Global entry points
adamc@668	347
adamc@1164	348 extern void uw_global_custom();
adamc@1104	349 extern void uw_init_crypto();
adamc@1104	350
adamc@668	351 void uw_global_init() {
adamc@668	352 srand(time(NULL) ^ getpid());
adamc@668	353
adamc@668	354 clients = malloc(0);
adamc@1104	355
adamc@1164	356 uw_global_custom();
adamc@1104	357 uw_init_crypto();
adamc@1094	358 }
adamc@1094	359
adamc@1094	360 void uw_app_init(uw_app *app) {
adamc@1094	361 app->client_init();
adamc@668	362 }
adamc@668	363
adam@1332	364 int uw_time = 0, uw_time_max = 0, uw_min_heap = 0;
adamc@1114	365
adamc@668	366
adamc@667	367 // Single-request state
adamc@667	368
adamc@323	369 typedef struct regions {
adamc@323	370 struct regions *next;
adamc@323	371 } regions;
adamc@323	372
adamc@425	373 typedef struct {
adamc@425	374 void (func)(void);
adamc@425	375 void *arg;
adamc@425	376 } cleanup;
adamc@425	377
adamc@671	378 typedef struct {
adamc@682	379 unsigned client;
adam@1369	380 uw_buffer msgs;
adamc@682	381 } delta;
adamc@671	382
adamc@737	383 typedef enum {
adamc@759	384 UNSET, NORMAL, FIL, SUBFORM, SUBFORMS, ENTRY
adamc@737	385 } input_kind;
adamc@737	386
adamc@756	387 typedef struct input {
adamc@737	388 input_kind kind;
adamc@737	389 union {
adamc@737	390 char *normal;
adamc@739	391 uw_Basis_file file;
adamc@756	392 struct {
adamc@759	393 struct input fields, parent;
adamc@756	394 } subform;
adamc@759	395 struct {
adamc@759	396 struct input entries, parent;
adamc@759	397 } subforms;
adamc@759	398 struct {
adamc@759	399 struct input fields, next, *parent;
adamc@759	400 } entry;
adamc@737	401 } data;
adamc@737	402 } input;
adamc@737	403
adamc@771	404 typedef struct {
adamc@771	405 void *data;
adam@1327	406 uw_callback commit, rollback;
adam@1327	407 uw_callback_with_retry free;
adamc@771	408 } transactional;
adamc@771	409
adamc@1061	410 typedef struct {
adamc@1061	411 char *name;
adamc@1061	412 void *data;
adamc@1061	413 void (free)(void);
adamc@1061	414 } global;
adamc@1061	415
adamc@311	416 struct uw_context {
adamc@1094	417 uw_app *app;
adam@1446	418 int id;
adamc@1094	419
adamc@854	420 char (get_header)(void , const char );
adamc@854	421 void *get_header_data;
adamc@457	422
adam@1799	423 char (get_env)(void , const char );
adam@1799	424 void *get_env_data;
adam@1799	425
adam@1369	426 uw_buffer outHeaders, page, heap, script;
adam@1451	427 int allowed_to_return_indirectly, returning_indirectly;
adamc@759	428 input inputs, subinputs, *cur_container;
adamc@1094	429 size_t sz_inputs, n_subinputs, used_subinputs;
adamc@167	430
adam@1446	431 unsigned long long source_count;
adamc@562	432
adamc@272	433 void *db;
adam@1931	434 int transaction_started;
adamc@272	435
adamc@167	436 jmp_buf jmp_buf;
adamc@167	437
adamc@323	438 regions *regions;
adamc@323	439
adamc@425	440 cleanup cleanup, cleanup_front, *cleanup_back;
adamc@425	441
adamc@1094	442 const char *script_header;
adamc@643	443
adam@1936	444 int needs_push, needs_sig, could_write_db;
adamc@693	445
adamc@682	446 size_t n_deltas, used_deltas;
adamc@682	447 delta *deltas;
adamc@671	448
adamc@682	449 client *client;
adamc@682	450
adamc@771	451 transactional *transactionals;
adamc@771	452 size_t n_transactionals, used_transactionals;
adamc@771	453
adamc@1061	454 global *globals;
adamc@1061	455 size_t n_globals;
adamc@1061	456
adamc@1066	457 char *current_url;
adamc@1066	458
adamc@1114	459 int deadline;
adamc@1114	460
adamc@1121	461 void *client_data;
adamc@1121	462
adam@1334	463 void *logger_data;
adam@1334	464 uw_logger log_debug;
adam@1334	465
adam@1386	466 int isPost, hasPostBody;
adam@1347	467 uw_Basis_postBody postBody;
adam@1370	468 uw_Basis_string queryString;
adam@1347	469
adam@1556	470 unsigned nextId;
adam@1556	471
adam@1782	472 int amInitializing;
adam@1782	473
adamc@167	474 char error_message[ERROR_BUF_LEN];
adam@1877	475
adam@1877	476 int usedSig, needsResig;
adamc@117	477 };
adamc@117	478
adamc@1113	479 size_t uw_headers_max = SIZE_MAX;
adamc@1113	480 size_t uw_page_max = SIZE_MAX;
adamc@1113	481 size_t uw_heap_max = SIZE_MAX;
adamc@1113	482 size_t uw_script_max = SIZE_MAX;
adamc@1113	483
adam@1446	484 uw_context uw_init(int id, void *logger_data, uw_logger log_debug) {
adamc@311	485 uw_context ctx = malloc(sizeof(struct uw_context));
adamc@136	486
adamc@1094	487 ctx->app = NULL;
adam@1446	488 ctx->id = id;
adamc@1094	489
adamc@854	490 ctx->get_header = NULL;
adamc@854	491 ctx->get_header_data = NULL;
adamc@457	492
adam@1799	493 ctx->get_env = NULL;
adam@1799	494 ctx->get_env_data = NULL;
adam@1799	495
adam@1413	496 uw_buffer_init(uw_headers_max, &ctx->outHeaders, 1);
adam@1413	497 ctx->outHeaders.start[0] = 0;
adam@1413	498 uw_buffer_init(uw_page_max, &ctx->page, 1);
adam@1413	499 ctx->page.start[0] = 0;
adam@1451	500 ctx->allowed_to_return_indirectly = ctx->returning_indirectly = 0;
adam@1369	501 uw_buffer_init(uw_heap_max, &ctx->heap, uw_min_heap);
adam@1369	502 uw_buffer_init(uw_script_max, &ctx->script, 1);
adamc@667	503 ctx->script.start[0] = 0;
adamc@136	504
adamc@1094	505 ctx->inputs = malloc(0);
adamc@759	506 ctx->cur_container = NULL;
adamc@756	507 ctx->subinputs = malloc(0);
adamc@1094	508 ctx->sz_inputs = ctx->n_subinputs = ctx->used_subinputs = 0;
adamc@144	509
adamc@272	510 ctx->db = NULL;
adam@1931	511 ctx->transaction_started = 0;
adamc@272	512
adamc@323	513 ctx->regions = NULL;
adamc@323	514
adamc@425	515 ctx->cleanup_front = ctx->cleanup_back = ctx->cleanup = malloc(0);
adamc@425	516
adamc@643	517 ctx->script_header = "";
adamc@693	518 ctx->needs_push = 0;
adamc@736	519 ctx->needs_sig = 0;
adam@1936	520 ctx->could_write_db = 1;
adamc@1104	521
adamc@565	522 ctx->source_count = 0;
adamc@562	523
adamc@682	524 ctx->n_deltas = ctx->used_deltas = 0;
adamc@671	525 ctx->deltas = malloc(0);
adamc@671	526
adamc@700	527 ctx->client = NULL;
adamc@700	528
adamc@700	529 ctx->error_message[0] = 0;
adamc@700	530
adamc@771	531 ctx->transactionals = malloc(0);
adamc@771	532 ctx->n_transactionals = ctx->used_transactionals = 0;
adamc@771	533
adamc@1061	534 ctx->globals = malloc(0);
adamc@1061	535 ctx->n_globals = 0;
adamc@1061	536
adamc@1066	537 ctx->current_url = "";
adamc@1066	538
adamc@1114	539 ctx->deadline = INT_MAX;
adamc@1114	540
adamc@1121	541 ctx->client_data = uw_init_client_data();
adamc@1121	542
adam@1334	543 ctx->logger_data = logger_data;
adam@1334	544 ctx->log_debug = log_debug;
adam@1334	545
adam@1386	546 ctx->isPost = ctx->hasPostBody = 0;
adam@1347	547
adam@1370	548 ctx->queryString = NULL;
adam@1370	549
adam@1556	550 ctx->nextId = 0;
adam@1556	551
adam@1782	552 ctx->amInitializing = 0;
adam@1782	553
adam@1877	554 ctx->usedSig = 0;
adam@1877	555 ctx->needsResig = 0;
adam@1877	556
adamc@117	557 return ctx;
adamc@106	558 }
adamc@106	559
adamc@1113	560 size_t uw_inputs_max = SIZE_MAX;
adamc@1113	561
adamc@1121	562 uw_app *uw_get_app(uw_context ctx) {
adamc@1121	563 return ctx->app;
adamc@1121	564 }
adamc@1121	565
adamc@1113	566 int uw_set_app(uw_context ctx, uw_app *app) {
adamc@1094	567 ctx->app = app;
adamc@1094	568
adamc@1105	569 if (app && app->inputs_len > ctx->sz_inputs) {
adamc@1113	570 if (app->inputs_len > uw_inputs_max)
adamc@1113	571 return 1;
adamc@1113	572
adamc@1094	573 ctx->sz_inputs = app->inputs_len;
adamc@1094	574 ctx->inputs = realloc(ctx->inputs, ctx->sz_inputs * sizeof(input));
adamc@1094	575 memset(ctx->inputs, 0, ctx->sz_inputs * sizeof(input));
adamc@1094	576 }
adamc@1134	577
adamc@1134	578 return 0;
adamc@1094	579 }
adamc@1094	580
adamc@1121	581 void uw_set_client_data(uw_context ctx, void *data) {
adamc@1121	582 uw_copy_client_data(ctx->client_data, data);
adamc@1121	583 }
adamc@1121	584
adamc@311	585 void uw_set_db(uw_context ctx, void *db) {
adamc@272	586 ctx->db = db;
adamc@272	587 }
adamc@272	588
adamc@311	589 void *uw_get_db(uw_context ctx) {
adamc@272	590 return ctx->db;
adamc@272	591 }
adamc@272	592
adamc@311	593 void uw_free(uw_context ctx) {
adamc@671	594 size_t i;
adamc@671	595
adam@1369	596 uw_buffer_free(&ctx->outHeaders);
adam@1369	597 uw_buffer_free(&ctx->script);
adam@1369	598 uw_buffer_free(&ctx->page);
adam@1369	599 uw_buffer_free(&ctx->heap);
adamc@144	600 free(ctx->inputs);
adamc@756	601 free(ctx->subinputs);
adamc@425	602 free(ctx->cleanup);
adamc@771	603 free(ctx->transactionals);
adamc@1121	604 uw_free_client_data(ctx->client_data);
adamc@671	605
adamc@682	606 for (i = 0; i < ctx->n_deltas; ++i)
adam@1369	607 uw_buffer_free(&ctx->deltas[i].msgs);
marco-oweber@1330	608 free(ctx->deltas);
adamc@671	609
adamc@1061	610 for (i = 0; i < ctx->n_globals; ++i)
adamc@1089	611 if (ctx->globals[i].free)
adamc@1089	612 ctx->globals[i].free(ctx->globals[i].data);
marco-oweber@1330	613 free(ctx->globals);
adamc@1061	614
adamc@136	615 free(ctx);
adamc@136	616 }
adamc@136	617
adamc@562	618 void uw_reset_keep_error_message(uw_context ctx) {
adam@1369	619 uw_buffer_reset(&ctx->outHeaders);
adam@1369	620 uw_buffer_reset(&ctx->script);
adamc@667	621 ctx->script.start[0] = 0;
adam@1369	622 uw_buffer_reset(&ctx->page);
adam@1451	623 ctx->allowed_to_return_indirectly = ctx->returning_indirectly = 0;
adam@1369	624 uw_buffer_reset(&ctx->heap);
adamc@323	625 ctx->regions = NULL;
adamc@425	626 ctx->cleanup_front = ctx->cleanup;
adamc@682	627 ctx->used_deltas = 0;
adamc@682	628 ctx->client = NULL;
adamc@759	629 ctx->cur_container = NULL;
adamc@771	630 ctx->used_transactionals = 0;
adamc@1117	631 ctx->script_header = "";
adam@1370	632 ctx->queryString = NULL;
adam@1556	633 ctx->nextId = 0;
adam@1782	634 ctx->amInitializing = 0;
adam@1877	635 ctx->usedSig = 0;
adam@1877	636 ctx->needsResig = 0;
adam@1931	637 ctx->transaction_started = 0;
adamc@167	638 }
adamc@167	639
adamc@562	640 void uw_reset_keep_request(uw_context ctx) {
adamc@562	641 uw_reset_keep_error_message(ctx);
adamc@562	642 ctx->error_message[0] = 0;
adamc@167	643 }
adamc@167	644
adamc@311	645 void uw_reset(uw_context ctx) {
adamc@311	646 uw_reset_keep_request(ctx);
adamc@1105	647 if (ctx->app)
adamc@1105	648 memset(ctx->inputs, 0, ctx->app->inputs_len * sizeof(input));
adamc@756	649 memset(ctx->subinputs, 0, ctx->n_subinputs * sizeof(input));
adam@1461	650 ctx->used_subinputs = ctx->hasPostBody = ctx->isPost = 0;
adamc@144	651 }
adamc@144	652
adamc@311	653 failure_kind uw_begin_init(uw_context ctx) {
adamc@272	654 int r = setjmp(ctx->jmp_buf);
adamc@272	655
adamc@1105	656 if (r == 0 && ctx->app)
adamc@1094	657 ctx->app->db_init(ctx);
adamc@272	658
adamc@272	659 return r;
adamc@272	660 }
adamc@272	661
adamc@1118	662 void uw_close(uw_context ctx) {
adamc@1118	663 ctx->app->db_close(ctx);
adamc@1118	664 }
adamc@1118	665
adam@1446	666 uw_Basis_string uw_Basis_requestHeader(uw_context ctx, uw_Basis_string h) {
adam@1446	667 return ctx->get_header(ctx->get_header_data, h);
adam@1446	668 }
adam@1446	669
adamc@854	670 void uw_set_headers(uw_context ctx, char (get_header)(void , const char ), void *get_header_data) {
adamc@854	671 ctx->get_header = get_header;
adamc@854	672 ctx->get_header_data = get_header_data;
adamc@742	673 }
adamc@742	674
adam@1799	675 void uw_set_env(uw_context ctx, char (get_env)(void , const char ), void *get_env_data) {
adam@1799	676 ctx->get_env = get_env;
adam@1799	677 ctx->get_env_data = get_env_data;
adam@1799	678 }
adam@1799	679
adamc@801	680 static void uw_set_error(uw_context ctx, const char *fmt, ...) {
adamc@801	681 va_list ap;
adamc@801	682 va_start(ap, fmt);
adamc@801	683
adamc@801	684 vsnprintf(ctx->error_message, ERROR_BUF_LEN, fmt, ap);
adamc@801	685 }
adamc@801	686
adamc@1131	687 int uw_has_error(uw_context ctx) {
adamc@1131	688 return ctx->error_message[0] != 0;
adamc@1131	689 }
adamc@1131	690
adamc@311	691 __attribute__((noreturn)) void uw_error(uw_context ctx, failure_kind fk, const char *fmt, ...) {
adamc@425	692 cleanup *cl;
adamc@425	693
adamc@167	694 va_list ap;
adamc@167	695 va_start(ap, fmt);
adamc@167	696
adamc@167	697 vsnprintf(ctx->error_message, ERROR_BUF_LEN, fmt, ap);
adamc@167	698
adamc@425	699 for (cl = ctx->cleanup; cl < ctx->cleanup_front; ++cl)
adamc@425	700 cl->func(cl->arg);
adamc@425	701
adamc@425	702 ctx->cleanup_front = ctx->cleanup;
adamc@425	703
adamc@190	704 longjmp(ctx->jmp_buf, fk);
adamc@167	705 }
adamc@167	706
adamc@1113	707 size_t uw_cleanup_max = SIZE_MAX;
adamc@1113	708
adamc@425	709 void uw_push_cleanup(uw_context ctx, void (func)(void ), void *arg) {
adamc@425	710 if (ctx->cleanup_front >= ctx->cleanup_back) {
adamc@425	711 int len = ctx->cleanup_back - ctx->cleanup, newLen;
adamc@425	712 if (len == 0)
adamc@425	713 newLen = 1;
adamc@425	714 else
adamc@428	715 newLen = len * 2;
adamc@1113	716
adamc@1134	717 if (newLen > uw_cleanup_max) {
adamc@1113	718 if (len+1 <= uw_cleanup_max)
adamc@1113	719 newLen = uw_cleanup_max;
adamc@1113	720 else
adamc@1113	721 uw_error(ctx, FATAL, "Exceeded limit on number of cleanup handlers");
adamc@1134	722 }
adamc@1113	723
adamc@470	724 ctx->cleanup = realloc(ctx->cleanup, newLen * sizeof(cleanup));
adamc@425	725 ctx->cleanup_front = ctx->cleanup + len;
adamc@425	726 ctx->cleanup_back = ctx->cleanup + newLen;
adamc@425	727 }
adamc@425	728
adamc@425	729 ctx->cleanup_front->func = func;
adamc@425	730 ctx->cleanup_front->arg = arg;
adamc@425	731 ++ctx->cleanup_front;
adamc@425	732 }
adamc@425	733
adam@1444	734 char uw_Basis_htmlifyString(uw_context, const char );
adam@1444	735
adamc@682	736 void uw_login(uw_context ctx) {
adam@1942	737 char id_s, pass_s;
adam@1942	738
adam@1942	739 if ((id_s = uw_Basis_requestHeader(ctx, "UrWeb-Client"))
adam@1942	740 && (pass_s = uw_Basis_requestHeader(ctx, "UrWeb-Pass"))) {
adam@1942	741 unsigned id = atoi(id_s);
adam@1942	742 int pass = atoi(pass_s);
adam@1942	743 client *c = find_client(id);
adam@1942	744
adam@1942	745 if (c == NULL)
adam@1942	746 uw_error(ctx, FATAL, "Unknown client ID in HTTP headers (%s, %s)", uw_Basis_htmlifyString(ctx, id_s), uw_Basis_htmlifyString(ctx, pass_s));
adam@1942	747 else {
adamc@685	748 use_client(c);
adamc@682	749 ctx->client = c;
adam@1942	750
adam@1942	751 if (c->mode != USED)
adam@1942	752 uw_error(ctx, FATAL, "Stale client ID (%u) in subscription request", id);
adam@1942	753 if (c->pass != pass)
adam@1942	754 uw_error(ctx, FATAL, "Wrong client password (%u, %d) in subscription request", id, pass);
adamc@864	755 }
adam@1942	756 } else if (ctx->needs_push) {
adam@1942	757 client *c = new_client();
adam@1942	758
adam@1942	759 if (c == NULL)
adam@1942	760 uw_error(ctx, FATAL, "Limit exceeded on number of message-passing clients");
adam@1942	761
adam@1942	762 use_client(c);
adam@1942	763 uw_copy_client_data(c->data, ctx->client_data);
adam@1942	764 ctx->client = c;
adamc@682	765 }
adamc@682	766 }
adamc@682	767
adamc@671	768 failure_kind uw_begin(uw_context ctx, char *path) {
adamc@671	769 int r = setjmp(ctx->jmp_buf);
adamc@671	770
adam@1931	771 if (r == 0)
adam@1931	772 ctx->app->handle(ctx, path);
adam@1931	773
adam@1931	774 return r;
adam@1931	775 }
adam@1931	776
adam@1931	777 void uw_ensure_transaction(uw_context ctx) {
adam@1931	778 if (!ctx->transaction_started) {
adam@1936	779 if (ctx->app->db_begin(ctx, ctx->could_write_db))
adamc@671	780 uw_error(ctx, BOUNDED_RETRY, "Error running SQL BEGIN");
adam@1931	781 ctx->transaction_started = 1;
adamc@671	782 }
adamc@671	783 }
adamc@671	784
adamc@772	785 uw_Basis_client uw_Basis_self(uw_context ctx) {
adamc@682	786 if (ctx->client == NULL)
adamc@682	787 uw_error(ctx, FATAL, "Call to Basis.self() from page that has only server-side code");
adamc@682	788
adamc@682	789 return ctx->client->id;
adamc@682	790 }
adamc@682	791
adamc@425	792 void uw_pop_cleanup(uw_context ctx) {
adamc@425	793 if (ctx->cleanup_front == ctx->cleanup)
adamc@425	794 uw_error(ctx, FATAL, "Attempt to pop from empty cleanup action stack");
adamc@425	795
adamc@425	796 --ctx->cleanup_front;
adamc@425	797 ctx->cleanup_front->func(ctx->cleanup_front->arg);
adamc@425	798 }
adamc@425	799
adamc@311	800 char *uw_error_message(uw_context ctx) {
adamc@167	801 return ctx->error_message;
adamc@167	802 }
adamc@167	803
adamc@1115	804 void uw_set_error_message(uw_context ctx, const char *msg) {
adamc@1115	805 strncpy(ctx->error_message, msg, sizeof(ctx->error_message));
adamc@1115	806 ctx->error_message[sizeof(ctx->error_message)-1] = 0;
adamc@1115	807 }
adamc@1115	808
adamc@759	809 static input *INP(uw_context ctx) {
adamc@759	810 if (ctx->cur_container == NULL)
adamc@759	811 return ctx->inputs;
adamc@759	812 else if (ctx->cur_container->kind == SUBFORM)
adamc@759	813 return ctx->cur_container->data.subform.fields;
adamc@759	814 else if (ctx->cur_container->kind == ENTRY)
adamc@759	815 return ctx->cur_container->data.entry.fields;
adamc@759	816 else
adamc@760	817 uw_error(ctx, FATAL, "INP: Wrong kind (%d, %p)", ctx->cur_container->kind, ctx->cur_container);
adamc@759	818 }
adamc@759	819
adamc@760	820 static void adjust_pointer(input *ptr, input old_start, input *new_start, size_t len) {
adamc@760	821 if (ptr != NULL && ptr >= old_start && *ptr < old_start + len)
adamc@760	822 *ptr += new_start - old_start;
adamc@760	823 }
adamc@760	824
adamc@760	825 static void adjust_input(input x, input old_start, input *new_start, size_t len) {
adamc@759	826 switch (x->kind) {
adamc@759	827 case SUBFORM:
adamc@760	828 adjust_pointer(&x->data.subform.fields, old_start, new_start, len);
adamc@760	829 adjust_pointer(&x->data.subform.parent, old_start, new_start, len);
adamc@759	830 break;
adamc@759	831 case SUBFORMS:
adamc@760	832 adjust_pointer(&x->data.subforms.entries, old_start, new_start, len);
adamc@760	833 adjust_pointer(&x->data.subforms.parent, old_start, new_start, len);
adamc@759	834 break;
adamc@759	835 case ENTRY:
adamc@760	836 adjust_pointer(&x->data.entry.fields, old_start, new_start, len);
adamc@760	837 adjust_pointer(&x->data.entry.next, old_start, new_start, len);
adamc@760	838 adjust_pointer(&x->data.entry.parent, old_start, new_start, len);
adamc@1134	839 break;
adamc@1134	840 default:
adamc@1134	841 break;
adamc@759	842 }
adamc@759	843 }
adamc@759	844
adamc@1113	845 size_t uw_subinputs_max = SIZE_MAX;
adamc@1113	846
adamc@759	847 static input *check_input_space(uw_context ctx, size_t len) {
adamc@759	848 size_t i;
adamc@759	849 input *r;
adamc@759	850
adamc@759	851 if (ctx->used_subinputs + len >= ctx->n_subinputs) {
adamc@1113	852 if (ctx->used_subinputs + len > uw_subinputs_max)
adamc@1113	853 uw_error(ctx, FATAL, "Exceeded limit on number of subinputs");
adamc@1113	854
adamc@759	855 input new_subinputs = realloc(ctx->subinputs, sizeof(input) (ctx->used_subinputs + len));
adamc@759	856
adamc@760	857 if (ctx->subinputs != new_subinputs) {
adamc@760	858 for (i = 0; i < ctx->used_subinputs; ++i)
adamc@760	859 adjust_input(&new_subinputs[i], ctx->subinputs, new_subinputs, ctx->used_subinputs);
adamc@1094	860 for (i = 0; i < ctx->app->inputs_len; ++i)
adamc@760	861 adjust_input(&ctx->inputs[i], ctx->subinputs, new_subinputs, ctx->used_subinputs);
adamc@760	862
adamc@760	863 adjust_pointer(&ctx->cur_container, ctx->subinputs, new_subinputs, ctx->used_subinputs);
adamc@760	864
adamc@760	865 ctx->n_subinputs = ctx->used_subinputs + len;
adamc@760	866 ctx->subinputs = new_subinputs;
adamc@760	867 }
adamc@759	868 }
adamc@759	869
adamc@759	870 r = &ctx->subinputs[ctx->used_subinputs];
adamc@759	871
adamc@759	872 for (i = 0; i < len; ++i)
adam@1474	873 ctx->subinputs[ctx->used_subinputs++].kind = UNSET;
adamc@759	874
adamc@759	875 return r;
adamc@759	876 }
adamc@756	877
adamc@801	878 int uw_set_input(uw_context ctx, const char name, char value) {
adamc@1050	879 //printf("Input name %s\n", name);
adamc@1038	880
adamc@756	881 if (!strcasecmp(name, ".b")) {
adamc@1094	882 int n = ctx->app->input_num(value);
adamc@756	883 input *inps;
adamc@756	884
adamc@801	885 if (n < 0) {
adam@1444	886 uw_set_error(ctx, "Bad subform name %s", uw_Basis_htmlifyString(ctx, value));
adamc@801	887 return -1;
adamc@801	888 }
adamc@801	889
adamc@1094	890 if (n >= ctx->app->inputs_len) {
adam@1444	891 uw_set_error(ctx, "For subform name %s, index %d is out of range", uw_Basis_htmlifyString(ctx, value), n);
adamc@801	892 return -1;
adamc@801	893 }
adamc@756	894
adamc@1094	895 inps = check_input_space(ctx, ctx->app->inputs_len);
adamc@759	896
adamc@759	897 INP(ctx)[n].kind = SUBFORM;
adamc@759	898 INP(ctx)[n].data.subform.parent = ctx->cur_container;
adamc@759	899 INP(ctx)[n].data.subform.fields = inps;
adamc@759	900 ctx->cur_container = &INP(ctx)[n];
adamc@756	901 } else if (!strcasecmp(name, ".e")) {
adamc@756	902 input *tmp;
adamc@756	903
adamc@801	904 if (ctx->cur_container == NULL) {
adamc@801	905 uw_set_error(ctx, "Unmatched subform closer");
adamc@801	906 return -1;
adamc@801	907 }
adamc@756	908
adamc@759	909 tmp = ctx->cur_container;
adamc@759	910 switch (tmp->kind) {
adamc@759	911 case SUBFORM:
adamc@759	912 ctx->cur_container = tmp->data.subform.parent;
adamc@759	913 tmp->data.subform.parent = NULL;
adamc@759	914 break;
adamc@759	915 case SUBFORMS:
adamc@759	916 ctx->cur_container = tmp->data.subforms.parent;
adamc@759	917 tmp->data.subforms.parent = NULL;
adamc@759	918 break;
adamc@759	919 case ENTRY:
adamc@759	920 ctx->cur_container = tmp->data.entry.parent;
adamc@759	921 break;
adamc@759	922 default:
adamc@801	923 uw_set_error(ctx, "uw_set_input: Wrong kind");
adamc@801	924 return -1;
adamc@759	925 }
adamc@759	926 } else if (!strcasecmp(name, ".s")) {
adamc@1094	927 int n = ctx->app->input_num(value);
adamc@759	928
adamc@801	929 if (n < 0) {
adam@1444	930 uw_set_error(ctx, "Bad subforms name %s", uw_Basis_htmlifyString(ctx, value));
adamc@801	931 return -1;
adamc@801	932 }
adamc@801	933
adamc@1094	934 if (n >= ctx->app->inputs_len) {
adam@1444	935 uw_set_error(ctx, "For subforms name %s, index %d is out of range", uw_Basis_htmlifyString(ctx, value), n);
adamc@801	936 return -1;
adamc@801	937 }
adamc@759	938
adamc@759	939 INP(ctx)[n].kind = SUBFORMS;
adamc@759	940 INP(ctx)[n].data.subforms.parent = ctx->cur_container;
adamc@759	941 INP(ctx)[n].data.subforms.entries = NULL;
adamc@759	942 ctx->cur_container = &INP(ctx)[n];
adamc@759	943 } else if (!strcasecmp(name, ".i")) {
adamc@759	944 input *inps;
adamc@759	945
adamc@801	946 if (!ctx->cur_container) {
adamc@801	947 uw_set_error(ctx, "New entry without container");
adamc@801	948 return -1;
adamc@801	949 }
adamc@801	950
adamc@801	951 if (ctx->cur_container->kind != SUBFORMS) {
adamc@801	952 uw_set_error(ctx, "Bad kind for entry parent");
adamc@801	953 return -1;
adamc@801	954 }
adamc@759	955
adamc@1094	956 inps = check_input_space(ctx, ctx->app->inputs_len + 1);
adamc@759	957
adamc@759	958 inps->kind = ENTRY;
adamc@759	959 inps->data.entry.parent = ctx->cur_container;
adamc@759	960 inps->data.entry.next = ctx->cur_container->data.subforms.entries;
adamc@759	961 ctx->cur_container->data.subforms.entries = inps;
adamc@759	962
adamc@759	963 inps->data.entry.fields = inps+1;
adamc@759	964 ctx->cur_container = inps;
adamc@756	965 } else {
adamc@1094	966 int n = ctx->app->input_num(name);
adamc@756	967
adam@1384	968 if (n < 0)
adam@1384	969 return 0;
adamc@801	970
adamc@1094	971 if (n >= ctx->app->inputs_len) {
adam@1444	972 uw_set_error(ctx, "For input name %s, index %d is out of range", uw_Basis_htmlifyString(ctx, name), n);
adamc@801	973 return -1;
adamc@801	974 }
adamc@756	975
adamc@756	976 INP(ctx)[n].kind = NORMAL;
adamc@756	977 INP(ctx)[n].data.normal = value;
adamc@756	978 }
adamc@801	979
adamc@801	980 return 0;
adamc@144	981 }
adamc@144	982
adamc@311	983 char *uw_get_input(uw_context ctx, int n) {
adamc@169	984 if (n < 0)
adamc@311	985 uw_error(ctx, FATAL, "Negative input index %d", n);
adamc@1094	986 if (n >= ctx->app->inputs_len)
adamc@311	987 uw_error(ctx, FATAL, "Out-of-bounds input index %d", n);
adamc@737	988
adamc@756	989 switch (INP(ctx)[n].kind) {
adamc@737	990 case UNSET:
adamc@737	991 return NULL;
adamc@739	992 case FIL:
adamc@739	993 uw_error(ctx, FATAL, "Tried to read a file form input as normal");
adamc@756	994 case SUBFORM:
adamc@756	995 uw_error(ctx, FATAL, "Tried to read a subform form input as normal");
adamc@759	996 case SUBFORMS:
adamc@759	997 uw_error(ctx, FATAL, "Tried to read a subforms form input as normal");
adamc@759	998 case ENTRY:
adamc@759	999 uw_error(ctx, FATAL, "Tried to read an entry form input as normal");
adamc@737	1000 case NORMAL:
adamc@756	1001 return INP(ctx)[n].data.normal;
adamc@737	1002 default:
adamc@737	1003 uw_error(ctx, FATAL, "Impossible input kind");
adamc@737	1004 }
adamc@138	1005 }
adamc@138	1006
adamc@311	1007 char *uw_get_optional_input(uw_context ctx, int n) {
adamc@190	1008 if (n < 0)
adamc@311	1009 uw_error(ctx, FATAL, "Negative input index %d", n);
adamc@1094	1010 if (n >= ctx->app->inputs_len)
adamc@311	1011 uw_error(ctx, FATAL, "Out-of-bounds input index %d", n);
adamc@737	1012
adamc@756	1013 switch (INP(ctx)[n].kind) {
adamc@737	1014 case UNSET:
adamc@737	1015 return "";
adamc@739	1016 case FIL:
adamc@739	1017 uw_error(ctx, FATAL, "Tried to read a file form input as normal");
adamc@756	1018 case SUBFORM:
adamc@756	1019 uw_error(ctx, FATAL, "Tried to read a subform form input as normal");
adamc@759	1020 case SUBFORMS:
adamc@759	1021 uw_error(ctx, FATAL, "Tried to read a subforms form input as normal");
adamc@759	1022 case ENTRY:
adamc@759	1023 uw_error(ctx, FATAL, "Tried to read an entry form input as normal");
adamc@737	1024 case NORMAL:
adamc@756	1025 return INP(ctx)[n].data.normal;
adamc@737	1026 default:
adamc@737	1027 uw_error(ctx, FATAL, "Impossible input kind");
adamc@737	1028 }
adamc@737	1029 }
adamc@737	1030
adamc@801	1031 int uw_set_file_input(uw_context ctx, const char *name, uw_Basis_file f) {
adamc@1094	1032 int n = ctx->app->input_num(name);
adamc@737	1033
adamc@801	1034 if (n < 0) {
adam@1444	1035 uw_set_error(ctx, "Bad file input name %s", uw_Basis_htmlifyString(ctx, name));
adamc@801	1036 return -1;
adamc@801	1037 }
adamc@801	1038
adamc@1094	1039 if (n >= ctx->app->inputs_len) {
adam@1444	1040 uw_set_error(ctx, "For file input name %s, index %d is out of range", uw_Basis_htmlifyString(ctx, name), n);
adamc@801	1041 return -1;
adamc@801	1042 }
adamc@737	1043
adamc@739	1044 ctx->inputs[n].kind = FIL;
adamc@739	1045 ctx->inputs[n].data.file = f;
adamc@801	1046
adamc@801	1047 return 0;
adamc@737	1048 }
adamc@737	1049
adamc@739	1050 void *uw_malloc(uw_context ctx, size_t len);
adamc@739	1051
adamc@739	1052 uw_Basis_file uw_get_file_input(uw_context ctx, int n) {
adamc@737	1053 if (n < 0)
adamc@737	1054 uw_error(ctx, FATAL, "Negative file input index %d", n);
adamc@1094	1055 if (n >= ctx->app->inputs_len)
adamc@737	1056 uw_error(ctx, FATAL, "Out-of-bounds file input index %d", n);
adamc@737	1057
adamc@756	1058 switch (INP(ctx)[n].kind) {
adamc@737	1059 case UNSET:
adamc@737	1060 {
adamc@739	1061 char *data = uw_malloc(ctx, 0);
adamc@740	1062 uw_Basis_file f = {NULL, "", {0, data}};
adamc@739	1063 return f;
adamc@737	1064 }
adamc@739	1065 case FIL:
adamc@756	1066 return INP(ctx)[n].data.file;
adamc@737	1067 case NORMAL:
adamc@737	1068 uw_error(ctx, FATAL, "Tried to read a normal form input as files");
adamc@756	1069 case SUBFORM:
adamc@756	1070 uw_error(ctx, FATAL, "Tried to read a subform form input as files");
adamc@759	1071 case SUBFORMS:
adamc@759	1072 uw_error(ctx, FATAL, "Tried to read a subforms form input as files");
adamc@759	1073 case ENTRY:
adamc@759	1074 uw_error(ctx, FATAL, "Tried to read an entry form input as files");
adamc@737	1075 default:
adamc@737	1076 uw_error(ctx, FATAL, "Impossible input kind");
adamc@737	1077 }
adamc@190	1078 }
adamc@190	1079
adamc@756	1080 void uw_enter_subform(uw_context ctx, int n) {
adamc@756	1081 if (n < 0)
adamc@756	1082 uw_error(ctx, FATAL, "Negative subform index %d", n);
adamc@1094	1083 if (n >= ctx->app->inputs_len)
adamc@756	1084 uw_error(ctx, FATAL, "Out-of-bounds subform index %d", n);
adamc@756	1085
adamc@756	1086 switch (INP(ctx)[n].kind) {
adamc@756	1087 case UNSET:
adamc@756	1088 uw_error(ctx, FATAL, "Missing subform");
adamc@756	1089 case FIL:
adamc@756	1090 uw_error(ctx, FATAL, "Tried to read a file form input as subform");
adamc@756	1091 case NORMAL:
adamc@756	1092 uw_error(ctx, FATAL, "Tried to read a normal form input as subform");
adamc@759	1093 case SUBFORMS:
adamc@759	1094 uw_error(ctx, FATAL, "Tried to read a subforms form input as subform");
adamc@759	1095 case ENTRY:
adamc@759	1096 uw_error(ctx, FATAL, "Tried to read an entry form input as subform");
adamc@756	1097 case SUBFORM:
adamc@759	1098 INP(ctx)[n].data.subform.parent = ctx->cur_container;
adamc@760	1099 ctx->cur_container = &INP(ctx)[n];
adamc@756	1100 return;
adamc@756	1101 default:
adamc@756	1102 uw_error(ctx, FATAL, "Impossible input kind");
adamc@756	1103 }
adamc@756	1104 }
adamc@756	1105
adamc@756	1106 void uw_leave_subform(uw_context ctx) {
adamc@756	1107 input *tmp;
adamc@756	1108
adamc@759	1109 if (ctx->cur_container == NULL)
adamc@756	1110 uw_error(ctx, FATAL, "Unmatched uw_leave_subform");
adamc@756	1111
adamc@759	1112 tmp = ctx->cur_container;
adamc@759	1113 ctx->cur_container = tmp->data.subform.parent;
adamc@759	1114 tmp->data.subform.parent = NULL;
adamc@759	1115 }
adamc@759	1116
adamc@759	1117 int uw_enter_subforms(uw_context ctx, int n) {
adamc@759	1118 input *inps;
adamc@759	1119
adamc@759	1120 if (n < 0)
adamc@759	1121 uw_error(ctx, FATAL, "Negative subforms index %d", n);
adamc@1094	1122 if (n >= ctx->app->inputs_len)
adamc@759	1123 uw_error(ctx, FATAL, "Out-of-bounds subforms index %d", n);
adamc@759	1124
adamc@759	1125 switch (INP(ctx)[n].kind) {
adamc@759	1126 case UNSET:
adamc@759	1127 uw_error(ctx, FATAL, "Missing subforms");
adamc@759	1128 case FIL:
adamc@759	1129 uw_error(ctx, FATAL, "Tried to read a file form input as subforms");
adamc@759	1130 case NORMAL:
adamc@759	1131 uw_error(ctx, FATAL, "Tried to read a normal form input %p as subforms", &INP(ctx)[n]);
adamc@759	1132 case SUBFORM:
adamc@759	1133 uw_error(ctx, FATAL, "Tried to read a subform form input as subforms");
adamc@759	1134 case ENTRY:
adamc@759	1135 uw_error(ctx, FATAL, "Tried to read an entry form input as subforms");
adamc@759	1136 case SUBFORMS:
adamc@759	1137 inps = INP(ctx)[n].data.subforms.entries;
adamc@759	1138 if (inps) {
adamc@759	1139 INP(ctx)[n].data.subforms.parent = ctx->cur_container;
adamc@759	1140 ctx->cur_container = INP(ctx)[n].data.subforms.entries;
adamc@759	1141 return 1;
adamc@759	1142 } else
adamc@759	1143 return 0;
adamc@759	1144 default:
adamc@759	1145 uw_error(ctx, FATAL, "Impossible input kind");
adamc@759	1146 }
adamc@759	1147 }
adamc@759	1148
adamc@759	1149 int uw_next_entry(uw_context ctx) {
adamc@759	1150 if (ctx->cur_container == NULL)
adamc@759	1151 uw_error(ctx, FATAL, "uw_next_entry(NULL)");
adamc@759	1152
adamc@759	1153 switch (ctx->cur_container->kind) {
adamc@759	1154 case UNSET:
adamc@759	1155 uw_error(ctx, FATAL, "Missing entry");
adamc@759	1156 case FIL:
adamc@759	1157 uw_error(ctx, FATAL, "Tried to read a file form input as entry");
adamc@759	1158 case NORMAL:
adamc@759	1159 uw_error(ctx, FATAL, "Tried to read a normal form input as entry");
adamc@759	1160 case SUBFORM:
adamc@759	1161 uw_error(ctx, FATAL, "Tried to read a subform form input as entry");
adamc@759	1162 case SUBFORMS:
adamc@759	1163 uw_error(ctx, FATAL, "Tried to read a subforms form input as entry");
adamc@759	1164 case ENTRY:
adamc@759	1165 if (ctx->cur_container->data.entry.next) {
adamc@759	1166 ctx->cur_container = ctx->cur_container->data.entry.next;
adamc@759	1167 return 1;
adamc@759	1168 } else {
adamc@759	1169 ctx->cur_container = ctx->cur_container->data.entry.parent->data.subforms.parent;
adamc@759	1170 return 0;
adamc@759	1171 }
adamc@759	1172 default:
adamc@759	1173 uw_error(ctx, FATAL, "Impossible input kind");
adamc@759	1174 }
adamc@756	1175 }
adamc@756	1176
adamc@643	1177 void uw_set_script_header(uw_context ctx, const char *s) {
adamc@643	1178 ctx->script_header = s;
adamc@643	1179 }
adamc@643	1180
adamc@1094	1181 const char *uw_get_url_prefix(uw_context ctx) {
adamc@1094	1182 return ctx->app->url_prefix;
adamc@667	1183 }
adamc@667	1184
adamc@693	1185 void uw_set_needs_push(uw_context ctx, int n) {
adamc@693	1186 ctx->needs_push = n;
adamc@693	1187 }
adamc@693	1188
adamc@736	1189 void uw_set_needs_sig(uw_context ctx, int n) {
adamc@736	1190 ctx->needs_sig = n;
adamc@736	1191 }
adamc@736	1192
adam@1936	1193 void uw_set_could_write_db(uw_context ctx, int n) {
adam@1936	1194 ctx->could_write_db = n;
adam@1936	1195 }
adam@1936	1196
adamc@667	1197
adam@1369	1198 static void uw_buffer_check_ctx(uw_context ctx, const char kind, uw_buffer b, size_t extra, const char *desc) {
adamc@666	1199 if (b->back - b->front < extra) {
adamc@666	1200 size_t desired = b->front - b->start + extra, next;
adamc@136	1201 char *new_heap;
adamc@136	1202
adamc@666	1203 next = b->back - b->start;
adamc@317	1204 if (next == 0)
adamc@317	1205 next = 1;
adamc@317	1206 for (; next < desired; next *= 2);
adamc@136	1207
adamc@1134	1208 if (next > b->max) {
adamc@1113	1209 if (desired <= b->max)
adamc@1113	1210 next = desired;
adamc@1113	1211 else
adamc@1113	1212 uw_error(ctx, FATAL, "Memory limit exceeded (%s)", kind);
adamc@1134	1213 }
adamc@1113	1214
adamc@666	1215 new_heap = realloc(b->start, next);
adamc@666	1216 b->front = new_heap + (b->front - b->start);
adamc@666	1217 b->back = new_heap + next;
adamc@136	1218
adamc@667	1219 if (new_heap != b->start) {
adamc@666	1220 b->start = new_heap;
adam@1389	1221 uw_error(ctx, UNLIMITED_RETRY, "Couldn't allocate new %s contiguously; increasing size to %llu", desc, (unsigned long long)next);
adamc@136	1222 }
adamc@136	1223
adamc@666	1224 b->start = new_heap;
adamc@136	1225 }
adamc@136	1226 }
adamc@136	1227
adamc@832	1228 void uw_check_heap(uw_context ctx, size_t extra) {
adam@1369	1229 uw_buffer_check_ctx(ctx, "heap", &ctx->heap, extra, "heap chunk");
adamc@666	1230 }
adamc@666	1231
adamc@832	1232 char *uw_heap_front(uw_context ctx) {
adamc@832	1233 return ctx->heap.front;
adamc@832	1234 }
adamc@832	1235
adamc@832	1236 void uw_set_heap_front(uw_context ctx, char *fr) {
adamc@832	1237 ctx->heap.front = fr;
adamc@832	1238 }
adamc@832	1239
adam@1782	1240 void uw_begin_initializing(uw_context ctx) {
adam@1782	1241 ctx->amInitializing = 1;
adam@1782	1242 }
adam@1782	1243
adam@1782	1244 void uw_end_initializing(uw_context ctx) {
adam@1782	1245 ctx->amInitializing = 0;
adam@1782	1246 }
adam@1782	1247
adamc@311	1248 void *uw_malloc(uw_context ctx, size_t len) {
adamc@136	1249 void *result;
adamc@136	1250
adam@1782	1251 if (ctx->amInitializing) {
adam@1782	1252 result = malloc(len);
adam@1782	1253
adam@1782	1254 if (result)
adam@1782	1255 return result;
adam@1782	1256 else
adam@1782	1257 uw_error(ctx, FATAL, "uw_malloc: malloc() returns 0");
adam@1782	1258 } else {
adam@1782	1259 uw_check_heap(ctx, len);
adam@1782	1260
adam@1782	1261 result = ctx->heap.front;
adam@1782	1262 ctx->heap.front += len;
adam@1782	1263 return result;
adam@1782	1264 }
adamc@117	1265 }
adamc@117	1266
adamc@323	1267 void uw_begin_region(uw_context ctx) {
adamc@666	1268 regions r = (regions ) ctx->heap.front;
adamc@323	1269
adamc@323	1270 uw_check_heap(ctx, sizeof(regions));
adamc@323	1271
adamc@666	1272 ctx->heap.front += sizeof(regions);
adamc@323	1273
adamc@323	1274 r->next = ctx->regions;
adamc@323	1275 ctx->regions = r;
adamc@323	1276 }
adamc@323	1277
adamc@323	1278 void uw_end_region(uw_context ctx) {
adamc@323	1279 regions *r = ctx->regions;
adamc@323	1280
adamc@323	1281 if (r == NULL)
adamc@323	1282 uw_error(ctx, FATAL, "Region stack underflow");
adamc@323	1283
adamc@666	1284 ctx->heap.front = (char *) r;
adamc@323	1285 ctx->regions = r->next;
adamc@323	1286 }
adamc@323	1287
adamc@324	1288 void uw_memstats(uw_context ctx) {
adam@1369	1289 printf("Headers: %lu/%lu\n", (unsigned long)uw_buffer_used(&ctx->outHeaders), (unsigned long)uw_buffer_avail(&ctx->outHeaders));
adam@1369	1290 printf("Script: %lu/%lu\n", (unsigned long)uw_buffer_used(&ctx->script), (unsigned long)uw_buffer_avail(&ctx->script));
adam@1369	1291 printf("Page: %lu/%lu\n", (unsigned long)uw_buffer_used(&ctx->page), (unsigned long)uw_buffer_avail(&ctx->page));
adam@1369	1292 printf("Heap: %lu/%lu\n", (unsigned long)uw_buffer_used(&ctx->heap), (unsigned long)uw_buffer_avail(&ctx->heap));
adamc@324	1293 }
adamc@324	1294
adam@1915	1295 int uw_pagelen(uw_context ctx) {
adam@1915	1296 return ctx->page.front - ctx->page.start;
adam@1915	1297 }
adam@1915	1298
adamc@311	1299 int uw_send(uw_context ctx, int sock) {
adamc@666	1300 int n = uw_really_send(sock, ctx->outHeaders.start, ctx->outHeaders.front - ctx->outHeaders.start);
adamc@462	1301
adamc@462	1302 if (n < 0)
adamc@462	1303 return n;
adamc@462	1304
adamc@462	1305 n = uw_really_send(sock, "\r\n", 2);
adamc@462	1306
adamc@462	1307 if (n < 0)
adamc@462	1308 return n;
adamc@462	1309
adamc@666	1310 return uw_really_send(sock, ctx->page.start, ctx->page.front - ctx->page.start);
adamc@462	1311 }
adamc@462	1312
adamc@856	1313 int uw_print(uw_context ctx, int fd) {
adamc@856	1314 int n = uw_really_write(fd, ctx->outHeaders.start, ctx->outHeaders.front - ctx->outHeaders.start);
adamc@856	1315
adamc@856	1316 if (n < 0)
adamc@856	1317 return n;
adamc@856	1318
adamc@856	1319 n = uw_really_write(fd, "\r\n", 2);
adamc@856	1320
adamc@856	1321 if (n < 0)
adamc@856	1322 return n;
adamc@856	1323
adamc@856	1324 return uw_really_write(fd, ctx->page.start, ctx->page.front - ctx->page.start);
adamc@856	1325 }
adamc@856	1326
adamc@860	1327 int uw_output(uw_context ctx, int (output)(void data, char buf, size_t len), void data) {
adamc@860	1328 int n = output(data, ctx->outHeaders.start, ctx->outHeaders.front - ctx->outHeaders.start);
adamc@860	1329
adamc@860	1330 if (n < 0)
adamc@860	1331 return n;
adamc@860	1332
adamc@860	1333 n = output(data, "\r\n", 2);
adamc@860	1334
adamc@860	1335 if (n < 0)
adamc@860	1336 return n;
adamc@860	1337
adamc@860	1338 return output(data, ctx->page.start, ctx->page.front - ctx->page.start);
adamc@860	1339 }
adamc@860	1340
adamc@462	1341 static void uw_check_headers(uw_context ctx, size_t extra) {
adam@1369	1342 ctx_uw_buffer_check(ctx, "headers", &ctx->outHeaders, extra);
adamc@462	1343 }
adamc@462	1344
adamc@462	1345 void uw_write_header(uw_context ctx, uw_Basis_string s) {
adamc@462	1346 int len = strlen(s);
adamc@462	1347
adamc@462	1348 uw_check_headers(ctx, len + 1);
adamc@666	1349 strcpy(ctx->outHeaders.front, s);
adamc@666	1350 ctx->outHeaders.front += len;
adamc@562	1351 }
adamc@562	1352
adam@1934	1353 int uw_has_contentLength(uw_context ctx) {
adam@1934	1354 return strstr(ctx->outHeaders.start, "Content-length: ") != NULL;
adam@1934	1355 }
adam@1934	1356
adamc@1110	1357 void uw_clear_headers(uw_context ctx) {
adam@1369	1358 uw_buffer_reset(&ctx->outHeaders);
adamc@1110	1359 }
adamc@1110	1360
adam@1932	1361 void uw_Basis_clear_page(uw_context ctx) {
adam@1932	1362 uw_buffer_reset(&ctx->page);
adam@1932	1363 }
adam@1932	1364
adamc@562	1365 static void uw_check_script(uw_context ctx, size_t extra) {
adam@1369	1366 ctx_uw_buffer_check(ctx, "script", &ctx->script, extra);
adamc@562	1367 }
adamc@562	1368
adamc@562	1369 void uw_write_script(uw_context ctx, uw_Basis_string s) {
adamc@562	1370 int len = strlen(s);
adamc@562	1371
adamc@562	1372 uw_check_script(ctx, len + 1);
adamc@666	1373 strcpy(ctx->script.front, s);
adamc@666	1374 ctx->script.front += len;
adamc@562	1375 }
adamc@562	1376
adam@1446	1377 const char *uw_get_real_script(uw_context ctx) {
adam@1671	1378 if (strstr(ctx->outHeaders.start, "Set-Cookie: ")) {
adam@1671	1379 uw_write_script(ctx, "sig=\"");
adam@1671	1380 uw_write_script(ctx, ctx->app->cookie_sig(ctx));
adam@1671	1381 uw_write_script(ctx, "\";");
adam@1671	1382 }
adam@1671	1383
adam@1446	1384 return ctx->script.start;
adam@1446	1385 }
adam@1446	1386
adamc@695	1387 uw_Basis_string uw_Basis_maybe_onload(uw_context ctx, uw_Basis_string s) {
adamc@695	1388 if (s[0] == 0)
adamc@695	1389 return "";
adamc@695	1390 else {
adamc@695	1391 char *r = uw_malloc(ctx, 11 + strlen(s));
adamc@695	1392 sprintf(r, " onload='%s'", s);
adamc@695	1393 return r;
adamc@695	1394 }
adamc@695	1395 }
adamc@695	1396
adamc@1042	1397 uw_Basis_string uw_Basis_maybe_onunload(uw_context ctx, uw_Basis_string s) {
adamc@1042	1398 if (ctx->script_header[0] == 0)
adamc@1042	1399 return "";
adamc@1042	1400 else {
vshabanoff@1763	1401 char *r = uw_malloc(ctx, 37 + strlen(s));
vshabanoff@1763	1402 sprintf(r, " onunload='unloading=true;%s;unload()'", s);
adamc@1042	1403 return r;
adamc@1042	1404 }
adamc@1042	1405 }
adamc@1042	1406
adamc@694	1407 const char *uw_Basis_get_settings(uw_context ctx, uw_unit u) {
adamc@736	1408 if (ctx->client == NULL) {
adamc@736	1409 if (ctx->needs_sig) {
adamc@1094	1410 char *sig = ctx->app->cookie_sig(ctx);
adamc@736	1411 char *r = uw_malloc(ctx, strlen(sig) + 8);
adamc@736	1412 sprintf(r, "sig=\"%s\";", sig);
adamc@736	1413 return r;
adamc@736	1414 }
adamc@736	1415 else
adamc@736	1416 return "";
adamc@736	1417 } else {
adamc@1094	1418 char *sig = ctx->needs_sig ? ctx->app->cookie_sig(ctx) : "";
adamc@1094	1419 char r = uw_malloc(ctx, 59 + 3 INTS_MAX + strlen(ctx->app->url_prefix)
adamc@736	1420 + (ctx->needs_sig ? strlen(sig) + 7 : 0));
adam@1552	1421 sprintf(r, "isPost=%s;client_id=%u;client_pass=%d;url_prefix=\"%s\";timeout=%d;%s%s%slistener();",
adam@1552	1422 (ctx->isPost ? "true" : "false"),
adamc@682	1423 ctx->client->id,
adamc@682	1424 ctx->client->pass,
adamc@1094	1425 ctx->app->url_prefix,
adamc@1094	1426 ctx->app->timeout,
adamc@736	1427 ctx->needs_sig ? "sig=\"" : "",
adamc@736	1428 sig,
adamc@736	1429 ctx->needs_sig ? "\";" : "");
adamc@679	1430 return r;
adamc@668	1431 }
adamc@667	1432 }
adamc@667	1433
adamc@574	1434 uw_Basis_string uw_Basis_jsifyString(uw_context ctx, uw_Basis_string s) {
adamc@574	1435 char r, s2;
adamc@574	1436
adam@1446	1437 uw_check_heap(ctx, strlen(s) * 4 + 3);
adamc@574	1438
adamc@666	1439 r = s2 = ctx->heap.front;
adamc@574	1440 *s2++ = '"';
adamc@574	1441
adamc@574	1442 for (; *s; s++) {
adam@1286	1443 unsigned char c = *s;
adamc@574	1444
adamc@574	1445 switch (c) {
adamc@574	1446 case '"':
adamc@574	1447 strcpy(s2, "\\\"");
adamc@574	1448 s2 += 2;
adamc@574	1449 break;
adamc@1027	1450 case '\'':
adamc@1027	1451 strcpy(s2, "\\047");
adamc@1027	1452 s2 += 4;
adamc@1027	1453 break;
adamc@574	1454 case '\\':
adamc@574	1455 strcpy(s2, "\\\\");
adamc@574	1456 s2 += 2;
adamc@574	1457 break;
adam@1457	1458 case '<':
adam@1457	1459 strcpy(s2, "\\074");
adam@1457	1460 s2 += 4;
adam@1457	1461 break;
adamc@574	1462 default:
adam@1286	1463 if (isprint((int)c) \|\| c >= 128)
adamc@574	1464 *s2++ = c;
adamc@574	1465 else {
adam@1429	1466 sprintf(s2, "\\%03o", c);
adamc@574	1467 s2 += 4;
adamc@574	1468 }
adamc@574	1469 }
adamc@574	1470 }
adamc@574	1471
adamc@574	1472 strcpy(s2, "\"");
adamc@910	1473 ctx->heap.front = s2 + 2;
adamc@574	1474 return r;
adamc@574	1475 }
adamc@574	1476
adam@1286	1477 uw_Basis_string uw_Basis_jsifyChar(uw_context ctx, uw_Basis_char c1) {
adam@1286	1478 unsigned char c = c1;
adamc@1025	1479 char r, s2;
adamc@1025	1480
adam@1446	1481 uw_check_heap(ctx, 7);
adamc@1025	1482
adamc@1025	1483 r = s2 = ctx->heap.front;
adamc@1025	1484 *s2++ = '"';
adamc@1025	1485
adamc@1025	1486 switch (c) {
adamc@1025	1487 case '"':
adamc@1025	1488 strcpy(s2, "\\\"");
adamc@1025	1489 s2 += 2;
adamc@1025	1490 break;
adamc@1027	1491 case '\'':
adamc@1027	1492 strcpy(s2, "\\047");
adamc@1027	1493 s2 += 4;
adamc@1027	1494 break;
adamc@1025	1495 case '\\':
adamc@1025	1496 strcpy(s2, "\\\\");
adamc@1025	1497 s2 += 2;
adamc@1025	1498 break;
adam@1457	1499 case '<':
adam@1457	1500 strcpy(s2, "\\074");
adam@1457	1501 s2 += 4;
adam@1457	1502 break;
adamc@1025	1503 default:
adam@1286	1504 if (isprint((int)c) \|\| c >= 128)
adamc@1025	1505 *s2++ = c;
adamc@1025	1506 else {
adam@1429	1507 sprintf(s2, "\\%03o", (unsigned char)c);
adamc@1025	1508 s2 += 4;
adamc@1025	1509 }
adamc@1025	1510 }
adamc@1025	1511
adamc@1025	1512 strcpy(s2, "\"");
adamc@1025	1513 ctx->heap.front = s2 + 2;
adamc@1025	1514 return r;
adamc@1025	1515 }
adamc@1025	1516
adamc@574	1517 uw_Basis_string uw_Basis_jsifyString_ws(uw_context ctx, uw_Basis_string s) {
adamc@574	1518 char r, s2;
adamc@574	1519
adam@1446	1520 uw_check_script(ctx, strlen(s) * 4 + 3);
adamc@574	1521
adamc@666	1522 r = s2 = ctx->script.front;
adamc@574	1523 *s2++ = '"';
adamc@574	1524
adamc@574	1525 for (; *s; s++) {
adam@1286	1526 unsigned char c = *s;
adamc@574	1527
adamc@574	1528 switch (c) {
adamc@577	1529 case '\'':
adamc@1027	1530 strcpy(s2, "\\");
adamc@574	1531 s2 += 2;
adamc@574	1532 break;
adamc@574	1533 case '\\':
adamc@574	1534 strcpy(s2, "\\\\");
adamc@574	1535 s2 += 2;
adamc@574	1536 break;
adam@1457	1537 case '<':
adam@1457	1538 strcpy(s2, "\\074");
adam@1457	1539 s2 += 4;
adam@1457	1540 break;
adamc@574	1541 default:
adam@1286	1542 if (isprint((int)c) \|\| c >= 128)
adamc@574	1543 *s2++ = c;
adamc@574	1544 else {
adam@1429	1545 sprintf(s2, "\\%03o", c);
adamc@574	1546 s2 += 4;
adamc@574	1547 }
adamc@574	1548 }
adamc@574	1549 }
adamc@574	1550
adamc@574	1551 strcpy(s2, "\"");
adamc@666	1552 ctx->script.front = s2 + 1;
adamc@574	1553 return r;
adamc@574	1554 }
adamc@574	1555
adamc@682	1556 char *uw_Basis_jsifyChannel(uw_context ctx, uw_Basis_channel chn) {
adamc@682	1557 if (ctx->client == NULL \|\| chn.cli != ctx->client->id)
adamc@682	1558 return "null";
adamc@682	1559 else {
adamc@682	1560 int len;
adamc@682	1561 char *r;
adamc@682	1562
adamc@682	1563 uw_check_heap(ctx, INTS_MAX + 1);
adamc@682	1564 r = ctx->heap.front;
adamc@682	1565 sprintf(r, "%u%n", chn.chn, &len);
adamc@682	1566 ctx->heap.front += len+1;
adamc@682	1567 return r;
adamc@682	1568 }
adamc@682	1569 }
adamc@682	1570
adam@1446	1571 uw_Basis_source uw_Basis_new_client_source(uw_context ctx, uw_Basis_string s) {
adamc@577	1572 int len;
adamc@577	1573 size_t s_len = strlen(s);
adamc@562	1574
adam@1446	1575 uw_check_script(ctx, 15 + 2 * INTS_MAX + s_len);
adam@1446	1576 sprintf(ctx->script.front, "s%d_%llu=sc(exec(%n", ctx->id, ctx->source_count, &len);
adamc@666	1577 ctx->script.front += len;
adamc@666	1578 strcpy(ctx->script.front, s);
adamc@666	1579 ctx->script.front += s_len;
adamc@970	1580 strcpy(ctx->script.front, "));");
adamc@972	1581 ctx->script.front += 3;
adamc@562	1582
adam@1446	1583 uw_Basis_source r = {ctx->id, ctx->source_count++};
adam@1446	1584 return r;
adam@1446	1585 }
adam@1446	1586
adam@1446	1587 uw_unit uw_Basis_set_client_source(uw_context ctx, uw_Basis_source src, uw_Basis_string s) {
adamc@577	1588 int len;
adamc@577	1589 size_t s_len = strlen(s);
adamc@577	1590
adam@1446	1591 uw_check_script(ctx, 15 + 2 * INTS_MAX + s_len);
adam@1446	1592 sprintf(ctx->script.front, "sv(s%d_%llu,exec(%n", src.context, src.source, &len);
adamc@666	1593 ctx->script.front += len;
adamc@666	1594 strcpy(ctx->script.front, s);
adamc@666	1595 ctx->script.front += s_len;
adamc@970	1596 strcpy(ctx->script.front, "));");
adamc@972	1597 ctx->script.front += 3;
adamc@577	1598
adamc@577	1599 return uw_unit_v;
adamc@577	1600 }
adamc@577	1601
adamc@311	1602 static void uw_check(uw_context ctx, size_t extra) {
adam@1369	1603 ctx_uw_buffer_check(ctx, "page", &ctx->page, extra);
adamc@117	1604 }
adamc@117	1605
adamc@311	1606 static void uw_writec_unsafe(uw_context ctx, char c) {
adamc@666	1607 *(ctx->page.front)++ = c;
adam@1413	1608 *ctx->page.front = 0;
adamc@117	1609 }
adamc@117	1610
adamc@311	1611 void uw_writec(uw_context ctx, char c) {
adam@1413	1612 uw_check(ctx, 2);
adamc@311	1613 uw_writec_unsafe(ctx, c);
adamc@117	1614 }
adamc@117	1615
adamc@311	1616 static void uw_write_unsafe(uw_context ctx, const char* s) {
adamc@117	1617 int len = strlen(s);
adamc@666	1618 memcpy(ctx->page.front, s, len);
adamc@666	1619 ctx->page.front += len;
adamc@117	1620 }
adamc@117	1621
adamc@311	1622 void uw_write(uw_context ctx, const char* s) {
adamc@311	1623 uw_check(ctx, strlen(s) + 1);
adamc@311	1624 uw_write_unsafe(ctx, s);
adamc@666	1625 *ctx->page.front = 0;
adamc@102	1626 }
adamc@106	1627
adamc@311	1628 char *uw_Basis_attrifyInt(uw_context ctx, uw_Basis_int n) {
adamc@136	1629 char *result;
adamc@136	1630 int len;
adamc@311	1631 uw_check_heap(ctx, INTS_MAX);
adamc@666	1632 result = ctx->heap.front;
adamc@276	1633 sprintf(result, "%lld%n", n, &len);
adamc@666	1634 ctx->heap.front += len+1;
adamc@136	1635 return result;
adamc@106	1636 }
adamc@106	1637
adamc@311	1638 char *uw_Basis_attrifyFloat(uw_context ctx, uw_Basis_float n) {
adamc@136	1639 char *result;
adamc@136	1640 int len;
adamc@311	1641 uw_check_heap(ctx, FLOATS_MAX);
adamc@666	1642 result = ctx->heap.front;
adam@1920	1643 sprintf(result, "%.16g%n", n, &len);
adamc@666	1644 ctx->heap.front += len+1;
adamc@136	1645 return result;
adamc@106	1646 }
adamc@106	1647
adamc@311	1648 char *uw_Basis_attrifyString(uw_context ctx, uw_Basis_string s) {
adamc@136	1649 int len = strlen(s);
adamc@136	1650 char result, p;
adamc@311	1651 uw_check_heap(ctx, len * 6 + 1);
adamc@136	1652
adamc@666	1653 result = p = ctx->heap.front;
adamc@136	1654
adamc@136	1655 for (; *s; s++) {
adamc@1054	1656 unsigned char c = *s;
adamc@136	1657
adamc@136	1658 if (c == '"') {
adamc@136	1659 strcpy(p, """);
adamc@136	1660 p += 6;
adamc@136	1661 } else if (c == '&') {
adamc@136	1662 strcpy(p, "&");
adamc@136	1663 p += 5;
adamc@136	1664 }
adamc@1059	1665 else
adamc@136	1666 *p++ = c;
adamc@136	1667 }
adamc@136	1668
adamc@137	1669 *p++ = 0;
adamc@666	1670 ctx->heap.front = p;
adamc@136	1671 return result;
adamc@106	1672 }
adamc@106	1673
adamc@1011	1674 char *uw_Basis_attrifyChar(uw_context ctx, uw_Basis_char c) {
adamc@1011	1675 char result, p;
adamc@1011	1676 uw_check_heap(ctx, 7);
adamc@1011	1677
adamc@1011	1678 result = p = ctx->heap.front;
adamc@1011	1679
adamc@1011	1680 if (c == '"') {
adamc@1011	1681 strcpy(p, """);
adamc@1011	1682 p += 6;
adamc@1011	1683 } else if (c == '&') {
adamc@1011	1684 strcpy(p, "&");
adamc@1011	1685 p += 5;
adamc@1011	1686 }
adamc@1059	1687 else
adamc@1011	1688 *p++ = c;
adamc@1011	1689
adamc@1011	1690 *p++ = 0;
adamc@1011	1691 ctx->heap.front = p;
adamc@1011	1692 return result;
adamc@1011	1693 }
adamc@1011	1694
adamc@721	1695 char *uw_Basis_attrifyCss_class(uw_context ctx, uw_Basis_css_class s) {
adamc@721	1696 return s;
adamc@721	1697 }
adamc@721	1698
adamc@311	1699 static void uw_Basis_attrifyInt_w_unsafe(uw_context ctx, uw_Basis_int n) {
adamc@117	1700 int len;
adamc@117	1701
adamc@666	1702 sprintf(ctx->page.front, "%lld%n", n, &len);
adamc@666	1703 ctx->page.front += len;
adamc@106	1704 }
adamc@106	1705
adamc@428	1706 uw_unit uw_Basis_attrifyInt_w(uw_context ctx, uw_Basis_int n) {
adamc@311	1707 uw_check(ctx, INTS_MAX);
adamc@311	1708 uw_Basis_attrifyInt_w_unsafe(ctx, n);
adamc@428	1709
adamc@428	1710 return uw_unit_v;
adamc@106	1711 }
adamc@106	1712
adamc@428	1713 uw_unit uw_Basis_attrifyFloat_w(uw_context ctx, uw_Basis_float n) {
adamc@117	1714 int len;
adamc@117	1715
adamc@311	1716 uw_check(ctx, FLOATS_MAX);
adamc@666	1717 sprintf(ctx->page.front, "%g%n", n, &len);
adamc@666	1718 ctx->page.front += len;
adamc@428	1719
adamc@428	1720 return uw_unit_v;
adamc@117	1721 }
adamc@117	1722
adamc@428	1723 uw_unit uw_Basis_attrifyString_w(uw_context ctx, uw_Basis_string s) {
adamc@311	1724 uw_check(ctx, strlen(s) * 6);
adamc@117	1725
adamc@106	1726 for (; *s; s++) {
adamc@1054	1727 unsigned char c = *s;
adamc@106	1728
adamc@106	1729 if (c == '"')
adamc@311	1730 uw_write_unsafe(ctx, """);
adamc@136	1731 else if (c == '&')
adamc@311	1732 uw_write_unsafe(ctx, "&");
adamc@1059	1733 else
adamc@311	1734 uw_writec_unsafe(ctx, c);
adamc@106	1735 }
adamc@428	1736
adamc@428	1737 return uw_unit_v;
adamc@106	1738 }
adamc@120	1739
adamc@1011	1740 uw_unit uw_Basis_attrifyChar_w(uw_context ctx, uw_Basis_char c) {
adamc@1011	1741 uw_check(ctx, 6);
adamc@1011	1742
adamc@1011	1743 if (c == '"')
adamc@1011	1744 uw_write_unsafe(ctx, """);
adamc@1011	1745 else if (c == '&')
adamc@1011	1746 uw_write_unsafe(ctx, "&");
adamc@1059	1747 else
adamc@1011	1748 uw_writec_unsafe(ctx, c);
adamc@1011	1749
adamc@1011	1750 return uw_unit_v;
adamc@1011	1751 }
adamc@1011	1752
adamc@120	1753
adamc@311	1754 char *uw_Basis_urlifyInt(uw_context ctx, uw_Basis_int n) {
adamc@137	1755 int len;
adamc@137	1756 char *r;
adamc@137	1757
adamc@311	1758 uw_check_heap(ctx, INTS_MAX);
adamc@666	1759 r = ctx->heap.front;
adamc@276	1760 sprintf(r, "%lld%n", n, &len);
adamc@666	1761 ctx->heap.front += len+1;
adamc@137	1762 return r;
adamc@120	1763 }
adamc@120	1764
adamc@682	1765 char *uw_Basis_urlifyChannel(uw_context ctx, uw_Basis_channel chn) {
adamc@682	1766 if (ctx->client == NULL \|\| chn.cli != ctx->client->id)
adamc@682	1767 return "";
adamc@682	1768 else {
adamc@682	1769 int len;
adamc@682	1770 char *r;
adamc@679	1771
adamc@682	1772 uw_check_heap(ctx, INTS_MAX + 1);
adamc@682	1773 r = ctx->heap.front;
adamc@682	1774 sprintf(r, "%u%n", chn.chn, &len);
adamc@682	1775 ctx->heap.front += len+1;
adamc@682	1776 return r;
adamc@682	1777 }
adamc@679	1778 }
adamc@679	1779
adamc@311	1780 char *uw_Basis_urlifyFloat(uw_context ctx, uw_Basis_float n) {
adamc@137	1781 int len;
adamc@137	1782 char *r;
adamc@137	1783
adamc@311	1784 uw_check_heap(ctx, FLOATS_MAX);
adamc@666	1785 r = ctx->heap.front;
adamc@137	1786 sprintf(r, "%g%n", n, &len);
adamc@666	1787 ctx->heap.front += len+1;
adamc@137	1788 return r;
adamc@120	1789 }
adamc@120	1790
adamc@311	1791 char *uw_Basis_urlifyString(uw_context ctx, uw_Basis_string s) {
adamc@137	1792 char r, p;
adamc@137	1793
adamc@925	1794 if (s[0] == '\0')
adamc@925	1795 return "_";
adamc@925	1796
adamc@925	1797 uw_check_heap(ctx, strlen(s) * 3 + 1 + !!(s[0] == '_'));
adamc@925	1798
adamc@925	1799 r = p = ctx->heap.front;
adamc@925	1800 if (s[0] == '_')
adamc@925	1801 *p++ = '_';
adamc@925	1802
adamc@925	1803 for (; *s; s++) {
adamc@1087	1804 unsigned char c = *s;
adamc@137	1805
adamc@137	1806 if (c == ' ')
adamc@137	1807 *p++ = '+';
adamc@137	1808 else if (isalnum(c))
adamc@137	1809 *p++ = c;
adamc@137	1810 else {
adamc@1259	1811 sprintf(p, ".%02X", c);
adamc@137	1812 p += 3;
adamc@137	1813 }
adamc@137	1814 }
adamc@137	1815
adamc@137	1816 *p++ = 0;
adamc@666	1817 ctx->heap.front = p;
adamc@137	1818 return r;
adamc@120	1819 }
adamc@120	1820
adamc@311	1821 char *uw_Basis_urlifyBool(uw_context ctx, uw_Basis_bool b) {
adamc@311	1822 if (b == uw_Basis_False)
adamc@186	1823 return "0";
adamc@186	1824 else
adamc@186	1825 return "1";
adamc@186	1826 }
adamc@186	1827
adam@1620	1828 char *uw_Basis_urlifySource(uw_context ctx, uw_Basis_source src) {
adam@1620	1829 char *r;
adam@1620	1830 int len;
adam@1620	1831 uw_check_heap(ctx, 2 * INTS_MAX + 2);
adam@1620	1832 r = ctx->heap.front;
adam@1620	1833 sprintf(r, "%d/%llu%n", src.context, src.source, &len);
adam@1620	1834 ctx->heap.front += len+1;
adam@1620	1835 return r;
adam@1620	1836 }
adam@1620	1837
adamc@311	1838 static void uw_Basis_urlifyInt_w_unsafe(uw_context ctx, uw_Basis_int n) {
adamc@120	1839 int len;
adamc@120	1840
adamc@666	1841 sprintf(ctx->page.front, "%lld%n", n, &len);
adamc@666	1842 ctx->page.front += len;
adamc@120	1843 }
adamc@120	1844
adamc@428	1845 uw_unit uw_Basis_urlifyInt_w(uw_context ctx, uw_Basis_int n) {
adamc@311	1846 uw_check(ctx, INTS_MAX);
adamc@311	1847 uw_Basis_urlifyInt_w_unsafe(ctx, n);
adamc@428	1848
adamc@428	1849 return uw_unit_v;
adamc@120	1850 }
adamc@120	1851
adamc@682	1852 uw_unit uw_Basis_urlifyChannel_w(uw_context ctx, uw_Basis_channel chn) {
adamc@682	1853 if (ctx->client != NULL && chn.cli == ctx->client->id) {
adamc@682	1854 int len;
adamc@682	1855
adamc@682	1856 uw_check(ctx, INTS_MAX + 1);
adamc@682	1857 sprintf(ctx->page.front, "%u%n", chn.chn, &len);
adamc@682	1858 ctx->page.front += len;
adamc@682	1859 }
adamc@682	1860
adamc@679	1861 return uw_unit_v;
adamc@679	1862 }
adamc@679	1863
adamc@428	1864 uw_unit uw_Basis_urlifyFloat_w(uw_context ctx, uw_Basis_float n) {
adamc@120	1865 int len;
adamc@120	1866
adamc@311	1867 uw_check(ctx, FLOATS_MAX);
adamc@666	1868 sprintf(ctx->page.front, "%g%n", n, &len);
adamc@666	1869 ctx->page.front += len;
adamc@428	1870
adamc@428	1871 return uw_unit_v;
adamc@120	1872 }
adamc@120	1873
adamc@488	1874 uw_Basis_string uw_Basis_urlifyTime(uw_context ctx, uw_Basis_time t) {
adamc@1376	1875 return uw_Basis_urlifyInt(ctx, (uw_Basis_int)t.seconds * 1000000 + t.microseconds);
adamc@488	1876 }
adamc@488	1877
adam@1404	1878 uw_unit uw_Basis_urlifyTime_w(uw_context ctx, uw_Basis_time t) {
adam@1404	1879 return uw_Basis_urlifyInt_w(ctx, (uw_Basis_int)t.seconds * 1000000 + t.microseconds);
adam@1404	1880 }
adam@1404	1881
adamc@428	1882 uw_unit uw_Basis_urlifyString_w(uw_context ctx, uw_Basis_string s) {
adamc@925	1883 if (s[0] == '\0') {
adamc@925	1884 uw_check(ctx, 1);
adamc@925	1885 uw_writec_unsafe(ctx, '_');
adamc@925	1886 return uw_unit_v;
adamc@925	1887 }
adamc@925	1888
adamc@925	1889 uw_check(ctx, strlen(s) * 3 + !!(s[0] == '_'));
adamc@925	1890
adamc@925	1891 if (s[0] == '_')
adamc@925	1892 uw_writec_unsafe(ctx, '_');
adamc@120	1893
adamc@120	1894 for (; *s; s++) {
adamc@1087	1895 unsigned char c = *s;
adamc@120	1896
adamc@120	1897 if (c == ' ')
adamc@311	1898 uw_writec_unsafe(ctx, '+');
adamc@120	1899 else if (isalnum(c))
adamc@311	1900 uw_writec_unsafe(ctx, c);
adamc@120	1901 else {
adamc@1259	1902 sprintf(ctx->page.front, ".%02X", c);
adamc@666	1903 ctx->page.front += 3;
adamc@120	1904 }
adamc@120	1905 }
adamc@428	1906
adamc@428	1907 return uw_unit_v;
adamc@120	1908 }
adamc@120	1909
adamc@428	1910 uw_unit uw_Basis_urlifyBool_w(uw_context ctx, uw_Basis_bool b) {
adamc@311	1911 if (b == uw_Basis_False)
adamc@311	1912 uw_writec(ctx, '0');
adamc@186	1913 else
adamc@311	1914 uw_writec(ctx, '1');
adamc@428	1915
adamc@428	1916 return uw_unit_v;
adamc@186	1917 }
adamc@186	1918
adam@1620	1919 uw_unit uw_Basis_urlifySource_w(uw_context ctx, uw_Basis_source src) {
adam@1620	1920 int len;
adam@1620	1921
adam@1620	1922 uw_check(ctx, 2 * INTS_MAX + 2);
adam@1620	1923 sprintf(ctx->page.front, "%d/%llu%n", src.context, src.source, &len);
adam@1620	1924 ctx->page.front += len;
adam@1620	1925
adam@1620	1926 return uw_unit_v;
adam@1620	1927 }
adam@1620	1928
adamc@120	1929
adamc@311	1930 static char uw_unurlify_advance(char s) {
adamc@144	1931 char *new_s = strchr(s, '/');
adamc@120	1932
adamc@120	1933 if (new_s)
adamc@120	1934 *new_s++ = 0;
adamc@120	1935 else
adamc@144	1936 new_s = strchr(s, 0);
adamc@144	1937
adamc@144	1938 return new_s;
adamc@144	1939 }
adamc@144	1940
adamc@311	1941 uw_Basis_int uw_Basis_unurlifyInt(uw_context ctx, char **s) {
adamc@311	1942 char new_s = uw_unurlify_advance(s);
adamc@311	1943 uw_Basis_int r;
adamc@120	1944
adamc@276	1945 r = atoll(*s);
adamc@120	1946 *s = new_s;
adamc@120	1947 return r;
adamc@120	1948 }
adamc@120	1949
adamc@311	1950 uw_Basis_float uw_Basis_unurlifyFloat(uw_context ctx, char **s) {
adamc@311	1951 char new_s = uw_unurlify_advance(s);
adamc@311	1952 uw_Basis_float r;
adamc@120	1953
adamc@120	1954 r = atof(*s);
adamc@120	1955 *s = new_s;
adamc@120	1956 return r;
adamc@120	1957 }
adamc@120	1958
adamc@488	1959 uw_Basis_time uw_Basis_unurlifyTime(uw_context ctx, char **s) {
adam@1365	1960 uw_Basis_int n = uw_Basis_unurlifyInt(ctx, s);
adam@1365	1961 uw_Basis_time r = {n / 1000000, n % 1000000};
adam@1365	1962 return r;
adamc@488	1963 }
adamc@488	1964
adamc@1023	1965 static uw_Basis_string uw_unurlifyString_to(int fromClient, uw_context ctx, char r, char s) {
adamc@927	1966 char s1, s2 = s;
adamc@144	1967 int n;
adamc@136	1968
adamc@1023	1969 if (!fromClient) {
adamc@1023	1970 if (*s2 == '_')
adamc@1023	1971 ++s2;
adamc@1259	1972 else if ((s2[0] == '%' \|\| s2[0] == '.') && s2[1] == '5' && (s2[2] == 'f' \|\| s2[2] == 'F'))
adamc@1023	1973 s2 += 3;
adamc@1023	1974 }
adamc@925	1975
adamc@927	1976 for (s1 = r; *s2; ++s1, ++s2) {
adamc@1087	1977 unsigned char c = *s2;
adamc@136	1978
adamc@136	1979 switch (c) {
adamc@136	1980 case '+':
adamc@136	1981 *s1 = ' ';
adamc@136	1982 break;
adamc@136	1983 case '%':
adamc@169	1984 if (s2[1] == 0)
adamc@311	1985 uw_error(ctx, FATAL, "Missing first character of escaped URL byte");
adamc@169	1986 if (s2[2] == 0)
adamc@311	1987 uw_error(ctx, FATAL, "Missing second character of escaped URL byte");
adamc@169	1988 if (sscanf(s2+1, "%02X", &n) != 1)
adam@1444	1989 uw_error(ctx, FATAL, "Invalid escaped URL byte starting at: %s", uw_Basis_htmlifyString(ctx, s2));
adamc@136	1990 *s1 = n;
adamc@136	1991 s2 += 2;
adamc@136	1992 break;
adamc@1259	1993 case '.':
adamc@1259	1994 if (!fromClient) {
adamc@1259	1995 if (s2[1] == 0)
adamc@1259	1996 uw_error(ctx, FATAL, "Missing first character of escaped URL byte");
adamc@1259	1997 if (s2[2] == 0)
adamc@1259	1998 uw_error(ctx, FATAL, "Missing second character of escaped URL byte");
adamc@1259	1999 if (sscanf(s2+1, "%02X", &n) != 1)
adam@1444	2000 uw_error(ctx, FATAL, "Invalid escaped URL byte starting at: %s", uw_Basis_htmlifyString(ctx, s2));
adamc@1259	2001 *s1 = n;
adamc@1259	2002 s2 += 2;
adamc@1259	2003 break;
adamc@1259	2004 }
adamc@136	2005 default:
adamc@136	2006 *s1 = c;
adamc@136	2007 }
adamc@136	2008 }
adamc@136	2009 *s1++ = 0;
adamc@144	2010 return s1;
adamc@144	2011 }
adamc@144	2012
adamc@311	2013 uw_Basis_bool uw_Basis_unurlifyBool(uw_context ctx, char **s) {
adamc@311	2014 char new_s = uw_unurlify_advance(s);
adamc@311	2015 uw_Basis_bool r;
adamc@186	2016
adamc@186	2017 if (s[0] == 0 \|\| !strcmp(s, "0") \|\| !strcmp(*s, "off"))
adamc@311	2018 r = uw_Basis_False;
adamc@186	2019 else
adamc@311	2020 r = uw_Basis_True;
adamc@186	2021
adamc@186	2022 *s = new_s;
adamc@186	2023 return r;
adamc@186	2024 }
adamc@186	2025
adamc@311	2026 uw_Basis_string uw_Basis_unurlifyString(uw_context ctx, char **s) {
adamc@311	2027 char new_s = uw_unurlify_advance(s);
adamc@1134	2028 char *r;
adamc@1134	2029 int len;
adamc@144	2030
adamc@200	2031 len = strlen(*s);
adamc@311	2032 uw_check_heap(ctx, len + 1);
adamc@144	2033
adamc@666	2034 r = ctx->heap.front;
adamc@1023	2035 ctx->heap.front = uw_unurlifyString_to(0, ctx, ctx->heap.front, *s);
adamc@1023	2036 *s = new_s;
adamc@1023	2037 return r;
adamc@1023	2038 }
adamc@1023	2039
adamc@1109	2040 uw_Basis_unit uw_Basis_unurlifyUnit(uw_context ctx, char **s) {
adamc@1109	2041 s = uw_unurlify_advance(s);
adamc@1109	2042 return uw_unit_v;
adamc@1109	2043 }
adamc@1109	2044
adamc@1023	2045 uw_Basis_string uw_Basis_unurlifyString_fromClient(uw_context ctx, char **s) {
adamc@1023	2046 char new_s = uw_unurlify_advance(s);
adamc@1134	2047 char *r;
adamc@1134	2048 int len;
adamc@1023	2049
adamc@1023	2050 len = strlen(*s);
adamc@1023	2051 uw_check_heap(ctx, len + 1);
adamc@1023	2052
adamc@1023	2053 r = ctx->heap.front;
adamc@1023	2054 ctx->heap.front = uw_unurlifyString_to(1, ctx, ctx->heap.front, *s);
adamc@136	2055 *s = new_s;
adamc@136	2056 return r;
adamc@120	2057 }
adamc@135	2058
adamc@135	2059
adamc@311	2060 char *uw_Basis_htmlifyInt(uw_context ctx, uw_Basis_int n) {
adamc@286	2061 int len;
adamc@286	2062 char *r;
adamc@286	2063
adamc@311	2064 uw_check_heap(ctx, INTS_MAX);
adamc@666	2065 r = ctx->heap.front;
adamc@286	2066 sprintf(r, "%lld%n", n, &len);
adamc@666	2067 ctx->heap.front += len+1;
adamc@286	2068 return r;
adamc@286	2069 }
adamc@286	2070
adamc@428	2071 uw_unit uw_Basis_htmlifyInt_w(uw_context ctx, uw_Basis_int n) {
adamc@286	2072 int len;
adamc@286	2073
adamc@311	2074 uw_check(ctx, INTS_MAX);
adamc@666	2075 sprintf(ctx->page.front, "%lld%n", n, &len);
adamc@666	2076 ctx->page.front += len;
adamc@428	2077
adamc@428	2078 return uw_unit_v;
adamc@286	2079 }
adamc@286	2080
adam@1358	2081 char *uw_Basis_htmlifySpecialChar(uw_context ctx, unsigned char ch) {
adam@1358	2082 unsigned int n = ch;
adam@1358	2083 int len;
adam@1358	2084 char *r;
adam@1358	2085
adam@1358	2086 uw_check_heap(ctx, INTS_MAX+3);
adam@1358	2087 r = ctx->heap.front;
adam@1358	2088 sprintf(r, "&#%u;%n", n, &len);
adam@1358	2089 ctx->heap.front += len+1;
adam@1358	2090 return r;
adam@1358	2091 }
adam@1358	2092
adam@1358	2093 uw_unit uw_Basis_htmlifySpecialChar_w(uw_context ctx, unsigned char ch) {
adam@1358	2094 unsigned int n = ch;
adam@1358	2095 int len;
adam@1358	2096
adam@1358	2097 uw_check(ctx, INTS_MAX+3);
adam@1358	2098 sprintf(ctx->page.front, "&#%u;%n", n, &len);
adam@1358	2099 ctx->page.front += len;
adam@1358	2100 return uw_unit_v;
adam@1358	2101 }
adam@1358	2102
adamc@311	2103 char *uw_Basis_htmlifyFloat(uw_context ctx, uw_Basis_float n) {
adamc@286	2104 int len;
adamc@286	2105 char *r;
adamc@286	2106
adamc@311	2107 uw_check_heap(ctx, FLOATS_MAX);
adamc@666	2108 r = ctx->heap.front;
adamc@286	2109 sprintf(r, "%g%n", n, &len);
adamc@666	2110 ctx->heap.front += len+1;
adamc@286	2111 return r;
adamc@286	2112 }
adamc@286	2113
adamc@428	2114 uw_unit uw_Basis_htmlifyFloat_w(uw_context ctx, uw_Basis_float n) {
adamc@286	2115 int len;
adamc@286	2116
adamc@311	2117 uw_check(ctx, FLOATS_MAX);
adamc@666	2118 sprintf(ctx->page.front, "%g%n", n, &len);
adamc@666	2119 ctx->page.front += len;
adamc@428	2120
adamc@428	2121 return uw_unit_v;
adamc@286	2122 }
adamc@286	2123
adam@1365	2124 char *uw_Basis_jsifyTime(uw_context ctx, uw_Basis_time t) {
adam@1360	2125 int len;
adam@1360	2126 char *r;
adam@1360	2127
adam@1360	2128 uw_check_heap(ctx, INTS_MAX);
adam@1360	2129 r = ctx->heap.front;
adamc@1377	2130 sprintf(r, "%lld%n", (uw_Basis_int)t.seconds * 1000000 + t.microseconds, &len);
adam@1360	2131 ctx->heap.front += len+1;
adam@1360	2132 return r;
adam@1360	2133 }
adam@1360	2134
adam@1365	2135 uw_unit uw_Basis_jsifyInt_w(uw_context ctx, uw_Basis_int n) {
adam@1360	2136 int len;
adam@1360	2137
adam@1360	2138 uw_check(ctx, INTS_MAX);
adam@1360	2139 sprintf(ctx->page.front, "%lld%n", (uw_Basis_int)n, &len);
adam@1360	2140 ctx->page.front += len;
adam@1360	2141
adam@1360	2142 return uw_unit_v;
adam@1360	2143 }
adam@1360	2144
adam@1444	2145 char uw_Basis_htmlifyString(uw_context ctx, const char s) {
adamc@137	2146 char r, s2;
adamc@137	2147
adamc@311	2148 uw_check_heap(ctx, strlen(s) * 5 + 1);
adamc@137	2149
adamc@666	2150 for (r = s2 = ctx->heap.front; *s; s++) {
adamc@1054	2151 unsigned char c = *s;
adamc@137	2152
adamc@137	2153 switch (c) {
adamc@137	2154 case '<':
adamc@137	2155 strcpy(s2, "<");
adamc@137	2156 s2 += 4;
adamc@137	2157 break;
adamc@137	2158 case '&':
adamc@137	2159 strcpy(s2, "&");
adamc@137	2160 s2 += 5;
adamc@137	2161 break;
adamc@137	2162 default:
adamc@1059	2163 *s2++ = c;
adamc@137	2164 }
adamc@137	2165 }
adamc@137	2166
adamc@137	2167 *s2++ = 0;
adamc@666	2168 ctx->heap.front = s2;
adamc@137	2169 return r;
adamc@135	2170 }
adamc@135	2171
adamc@428	2172 uw_unit uw_Basis_htmlifyString_w(uw_context ctx, uw_Basis_string s) {
adamc@321	2173 uw_check(ctx, strlen(s) * 6);
adamc@135	2174
adamc@135	2175 for (; *s; s++) {
adamc@1054	2176 unsigned char c = *s;
adamc@135	2177
adamc@135	2178 switch (c) {
adamc@135	2179 case '<':
adamc@311	2180 uw_write_unsafe(ctx, "<");
adamc@135	2181 break;
adamc@135	2182 case '&':
adamc@311	2183 uw_write_unsafe(ctx, "&");
adamc@135	2184 break;
adamc@135	2185 default:
adamc@1059	2186 uw_writec_unsafe(ctx, c);
adamc@135	2187 }
adamc@135	2188 }
adamc@428	2189
adamc@428	2190 return uw_unit_v;
adamc@135	2191 }
adamc@180	2192
adamc@311	2193 uw_Basis_string uw_Basis_htmlifyBool(uw_context ctx, uw_Basis_bool b) {
adamc@311	2194 if (b == uw_Basis_False)
adamc@286	2195 return "False";
adamc@286	2196 else
adamc@286	2197 return "True";
adamc@286	2198 }
adamc@286	2199
adamc@428	2200 uw_unit uw_Basis_htmlifyBool_w(uw_context ctx, uw_Basis_bool b) {
adamc@311	2201 if (b == uw_Basis_False) {
adamc@311	2202 uw_check(ctx, 6);
adamc@666	2203 strcpy(ctx->page.front, "False");
adamc@666	2204 ctx->page.front += 5;
adamc@286	2205 } else {
adamc@311	2206 uw_check(ctx, 5);
adamc@666	2207 strcpy(ctx->page.front, "True");
adamc@666	2208 ctx->page.front += 4;
adamc@286	2209 }
adamc@428	2210
adamc@428	2211 return uw_unit_v;
adamc@286	2212 }
adamc@286	2213
adamc@436	2214 #define TIME_FMT "%x %X"
adamc@438	2215 #define TIME_FMT_PG "%Y-%m-%d %T"
adam@1632	2216 #define TIME_FMT_JS "%Y/%m/%d %T"
adamc@436	2217
adam@1629	2218 uw_Basis_string uw_Basis_timeToString(uw_context, uw_Basis_time);
adam@1629	2219
adamc@436	2220 uw_Basis_string uw_Basis_htmlifyTime(uw_context ctx, uw_Basis_time t) {
adam@1629	2221 return uw_Basis_htmlifyString(ctx, uw_Basis_timeToString(ctx, t));
adamc@436	2222 }
adamc@436	2223
adamc@436	2224 uw_unit uw_Basis_htmlifyTime_w(uw_context ctx, uw_Basis_time t) {
adam@1629	2225 return uw_Basis_htmlifyString_w(ctx, uw_Basis_timeToString(ctx, t));
adamc@436	2226 }
adamc@436	2227
adam@1446	2228 char *uw_Basis_htmlifySource(uw_context ctx, uw_Basis_source src) {
adam@1446	2229 int len;
adam@1446	2230 char *r;
adam@1446	2231
adam@1446	2232 uw_check_heap(ctx, 2 * INTS_MAX + 2);
adam@1446	2233 r = ctx->heap.front;
adam@1446	2234 sprintf(r, "s%d_%llu%n", src.context, src.source, &len);
adam@1446	2235 ctx->heap.front += len+1;
adam@1446	2236 return r;
adam@1446	2237 }
adam@1446	2238
adam@1446	2239 uw_unit uw_Basis_htmlifySource_w(uw_context ctx, uw_Basis_source src) {
adam@1446	2240 int len;
adam@1446	2241
adam@1446	2242 uw_check(ctx, 2 * INTS_MAX + 1);
adam@1446	2243 sprintf(ctx->page.front, "s%d_%llu%n", src.context, src.source, &len);
adam@1446	2244 ctx->page.front += len;
adam@1446	2245
adam@1446	2246 return uw_unit_v;
adam@1446	2247 }
adam@1446	2248
adamc@821	2249 uw_Basis_char uw_Basis_strsub(uw_context ctx, uw_Basis_string s, uw_Basis_int n) {
adam@1388	2250 while (n >= 0) {
adam@1388	2251 if (*s == 0)
adam@1388	2252 uw_error(ctx, FATAL, "Out-of-bounds strsub");
adam@1388	2253
adam@1388	2254 if (n == 0)
adam@1388	2255 return *s;
adam@1388	2256
adam@1388	2257 --n;
adam@1388	2258 ++s;
adam@1388	2259 }
adam@1388	2260
adam@1388	2261 uw_error(ctx, FATAL, "Negative strsub bound");
adamc@821	2262 }
adamc@821	2263
adamc@821	2264 uw_Basis_string uw_Basis_strsuffix(uw_context ctx, uw_Basis_string s, uw_Basis_int n) {
adam@1388	2265 while (n >= 0) {
adam@1388	2266 if (*s == 0 \|\| n == 0)
adam@1388	2267 return s;
adam@1388	2268
adam@1388	2269 --n;
adam@1388	2270 ++s;
adam@1388	2271 }
adam@1388	2272
adam@1388	2273 uw_error(ctx, FATAL, "Negative strsuffix bound");
adamc@821	2274 }
adamc@821	2275
adamc@828	2276 uw_Basis_int uw_Basis_strlen(uw_context ctx, uw_Basis_string s) {
adamc@828	2277 return strlen(s);
adamc@828	2278 }
adamc@828	2279
adam@1388	2280 uw_Basis_bool uw_Basis_strlenGe(uw_context ctx, uw_Basis_string s, uw_Basis_int n) {
adam@1388	2281 while (n > 0) {
adam@1388	2282 if (*s == 0)
adam@1388	2283 return uw_Basis_False;
adam@1388	2284
adam@1388	2285 --n;
adam@1388	2286 ++s;
adam@1388	2287 }
adam@1388	2288
adam@1388	2289 return uw_Basis_True;
adam@1388	2290 }
adam@1388	2291
adamc@829	2292 uw_Basis_string uw_Basis_strchr(uw_context ctx, uw_Basis_string s, uw_Basis_char ch) {
adamc@829	2293 return strchr(s, ch);
adamc@829	2294 }
adamc@829	2295
adamc@831	2296 uw_Basis_int uw_Basis_strcspn(uw_context ctx, uw_Basis_string s, uw_Basis_string chs) {
adamc@831	2297 return strcspn(s, chs);
adamc@831	2298 }
adamc@831	2299
adamc@829	2300 uw_Basis_int *uw_Basis_strindex(uw_context ctx, uw_Basis_string s, uw_Basis_char ch) {
adamc@829	2301 uw_Basis_string r = strchr(s, ch);
adamc@829	2302 if (r == NULL)
adamc@829	2303 return NULL;
adamc@829	2304 else {
adamc@829	2305 uw_Basis_int *nr = uw_malloc(ctx, sizeof(uw_Basis_int));
adamc@829	2306 *nr = r - s;
adamc@829	2307 return nr;
adamc@829	2308 }
adamc@829	2309 }
adamc@829	2310
adam@1390	2311 uw_Basis_int uw_Basis_strsindex(uw_context ctx, const char haystack, const char *needle) {
adam@1390	2312 uw_Basis_string r = strstr(haystack, needle);
adam@1390	2313 if (r == NULL)
adam@1390	2314 return NULL;
adam@1390	2315 else {
adam@1390	2316 uw_Basis_int *nr = uw_malloc(ctx, sizeof(uw_Basis_int));
adam@1390	2317 *nr = r - haystack;
adam@1390	2318 return nr;
adam@1390	2319 }
adam@1390	2320 }
adam@1390	2321
adamc@311	2322 uw_Basis_string uw_Basis_strcat(uw_context ctx, uw_Basis_string s1, uw_Basis_string s2) {
adamc@828	2323 int len = uw_Basis_strlen(ctx, s1) + uw_Basis_strlen(ctx, s2) + 1;
adamc@180	2324 char *s;
adamc@180	2325
adamc@311	2326 uw_check_heap(ctx, len);
adamc@180	2327
adamc@666	2328 s = ctx->heap.front;
adamc@180	2329
adamc@180	2330 strcpy(s, s1);
adamc@180	2331 strcat(s, s2);
adamc@666	2332 ctx->heap.front += len;
adamc@180	2333
adamc@180	2334 return s;
adamc@180	2335 }
adamc@278	2336
adamc@829	2337 uw_Basis_string uw_Basis_substring(uw_context ctx, uw_Basis_string s, uw_Basis_int start, uw_Basis_int len) {
adamc@829	2338 size_t full_len = uw_Basis_strlen(ctx, s);
adamc@829	2339
adamc@829	2340 if (start < 0)
adamc@829	2341 uw_error(ctx, FATAL, "substring: Negative start index");
adamc@829	2342 if (len < 0)
adamc@829	2343 uw_error(ctx, FATAL, "substring: Negative length");
adamc@829	2344 if (start + len > full_len)
adamc@829	2345 uw_error(ctx, FATAL, "substring: Start index plus length is too large");
adamc@829	2346
adamc@829	2347 if (start + len == full_len)
adamc@829	2348 return &s[start];
adamc@829	2349 else {
adamc@829	2350 uw_Basis_string r = uw_malloc(ctx, len+1);
adamc@959	2351 memcpy(r, s+start, len);
adamc@829	2352 r[len] = 0;
adamc@829	2353 return r;
adamc@829	2354 }
adamc@829	2355
adamc@829	2356 }
adamc@829	2357
adamc@1023	2358 uw_Basis_string uw_Basis_str1(uw_context ctx, uw_Basis_char ch) {
adamc@1023	2359 char *r;
adamc@1023	2360
adamc@1023	2361 uw_check_heap(ctx, 2);
adamc@1023	2362 r = ctx->heap.front;
adamc@1023	2363 r[0] = ch;
adamc@1023	2364 r[1] = 0;
adamc@1023	2365
adamc@1023	2366 ctx->heap.front += 2;
adamc@1023	2367
adamc@1023	2368 return r;
adamc@1023	2369 }
adamc@1023	2370
adamc@737	2371 uw_Basis_string uw_strdup(uw_context ctx, uw_Basis_string s1) {
adamc@828	2372 int len = uw_Basis_strlen(ctx, s1) + 1;
adamc@278	2373 char *s;
adamc@278	2374
adamc@311	2375 uw_check_heap(ctx, len);
adamc@278	2376
adamc@666	2377 s = ctx->heap.front;
adamc@278	2378
adamc@278	2379 strcpy(s, s1);
adamc@666	2380 ctx->heap.front += len;
adamc@278	2381
adamc@278	2382 return s;
adamc@278	2383 }
adamc@280	2384
adam@1295	2385 uw_Basis_string uw_dup_and_clear_error_message(uw_context ctx) {
adam@1295	2386 if (ctx->error_message[0]) {
adam@1295	2387 char *s = uw_strdup(ctx, ctx->error_message);
adam@1295	2388 ctx->error_message[0] = 0;
adam@1295	2389 return s;
adam@1295	2390 } else
adam@1295	2391 return NULL;
adam@1295	2392 }
adam@1295	2393
adamc@737	2394 uw_Basis_string uw_maybe_strdup(uw_context ctx, uw_Basis_string s1) {
adamc@493	2395 if (s1)
adamc@737	2396 return uw_strdup(ctx, s1);
adamc@493	2397 else
adamc@493	2398 return NULL;
adamc@493	2399 }
adamc@493	2400
adamc@742	2401 char uw_memdup(uw_context ctx, const char p, size_t len) {
adamc@742	2402 char *r = uw_malloc(ctx, len);
adamc@742	2403 memcpy(r, p, len);
adamc@742	2404 return r;
adamc@742	2405 }
adamc@280	2406
adamc@879	2407 char *uw_sqlfmtInt = "%lld::int8%n";
adamc@879	2408
adamc@311	2409 char *uw_Basis_sqlifyInt(uw_context ctx, uw_Basis_int n) {
adamc@281	2410 int len;
adamc@281	2411 char *r;
adamc@281	2412
adamc@311	2413 uw_check_heap(ctx, INTS_MAX + 6);
adamc@666	2414 r = ctx->heap.front;
adamc@879	2415 sprintf(r, uw_sqlfmtInt, n, &len);
adamc@666	2416 ctx->heap.front += len+1;
adamc@281	2417 return r;
adamc@281	2418 }
adamc@281	2419
adamc@467	2420 char uw_Basis_sqlifyIntN(uw_context ctx, uw_Basis_int n) {
adamc@467	2421 if (n == NULL)
adamc@467	2422 return "NULL";
adamc@467	2423 else
adamc@467	2424 return uw_Basis_sqlifyInt(ctx, *n);
adamc@467	2425 }
adamc@467	2426
adam@1920	2427 char *uw_sqlfmtFloat = "%.16g::float8%n";
adamc@879	2428
adamc@311	2429 char *uw_Basis_sqlifyFloat(uw_context ctx, uw_Basis_float n) {
adamc@281	2430 int len;
adamc@281	2431 char *r;
adamc@281	2432
adamc@311	2433 uw_check_heap(ctx, FLOATS_MAX + 8);
adamc@666	2434 r = ctx->heap.front;
adamc@879	2435 sprintf(r, uw_sqlfmtFloat, n, &len);
adamc@666	2436 ctx->heap.front += len+1;
adamc@281	2437 return r;
adamc@281	2438 }
adamc@281	2439
adamc@467	2440 char uw_Basis_sqlifyFloatN(uw_context ctx, uw_Basis_float n) {
adamc@467	2441 if (n == NULL)
adamc@467	2442 return "NULL";
adamc@467	2443 else
adamc@467	2444 return uw_Basis_sqlifyFloat(ctx, *n);
adamc@467	2445 }
adamc@467	2446
adam@1834	2447 int uw_Estrings = 1, uw_sql_type_annotations = 1;
adamc@879	2448 char *uw_sqlsuffixString = "::text";
adamc@1011	2449 char *uw_sqlsuffixChar = "::char";
adamc@281	2450
adamc@311	2451 uw_Basis_string uw_Basis_sqlifyString(uw_context ctx, uw_Basis_string s) {
adamc@280	2452 char r, s2;
adamc@280	2453
adamc@879	2454 uw_check_heap(ctx, strlen(s) * 2 + 3 + uw_Estrings + strlen(uw_sqlsuffixString));
adamc@280	2455
adamc@666	2456 r = s2 = ctx->heap.front;
adamc@879	2457 if (uw_Estrings)
adamc@879	2458 *s2++ = 'E';
adamc@280	2459 *s2++ = '\'';
adamc@280	2460
adamc@280	2461 for (; *s; s++) {
adamc@280	2462 char c = *s;
adamc@280	2463
adamc@280	2464 switch (c) {
adamc@280	2465 case '\'':
adamc@885	2466 if (uw_Estrings)
adamc@885	2467 strcpy(s2, "\\'");
adamc@885	2468 else
adamc@885	2469 strcpy(s2, "''");
adamc@280	2470 s2 += 2;
adamc@280	2471 break;
adamc@280	2472 case '\\':
adamc@885	2473 if (uw_Estrings) {
adamc@885	2474 strcpy(s2, "\\\\");
adamc@885	2475 s2 += 2;
adamc@885	2476 } else
adamc@885	2477 *s2++ = '\\';
adamc@280	2478 break;
adamc@280	2479 default:
adamc@1150	2480 if (isprint((int)c))
adamc@280	2481 *s2++ = c;
adamc@879	2482 else if (uw_Estrings) {
adam@1857	2483 sprintf(s2, "\\%03o", (unsigned char)c);
adamc@280	2484 s2 += 4;
adamc@280	2485 }
adamc@879	2486 else
adam@1689	2487 *s2++ = c; // I hope this is safe to do... don't know how to support UTF-8 outside Postgres otherwise!
adamc@280	2488 }
adamc@280	2489 }
adamc@280	2490
adamc@879	2491 *s2++ = '\'';
adamc@879	2492 strcpy(s2, uw_sqlsuffixString);
adamc@879	2493 ctx->heap.front = s2 + 1 + strlen(uw_sqlsuffixString);
adamc@280	2494 return r;
adamc@280	2495 }
adamc@281	2496
adamc@1011	2497 uw_Basis_string uw_Basis_sqlifyChar(uw_context ctx, uw_Basis_char c) {
adamc@1011	2498 char r, s2;
adamc@1011	2499
adamc@1011	2500 uw_check_heap(ctx, 5 + uw_Estrings + strlen(uw_sqlsuffixChar));
adamc@1011	2501
adamc@1011	2502 r = s2 = ctx->heap.front;
adamc@1011	2503 if (uw_Estrings)
adamc@1011	2504 *s2++ = 'E';
adamc@1011	2505 *s2++ = '\'';
adamc@1011	2506
adamc@1011	2507 switch (c) {
adamc@1011	2508 case '\'':
adamc@1011	2509 if (uw_Estrings)
adamc@1011	2510 strcpy(s2, "\\'");
adamc@1011	2511 else
adamc@1011	2512 strcpy(s2, "''");
adamc@1011	2513 s2 += 2;
adamc@1011	2514 break;
adamc@1011	2515 case '\\':
adamc@1011	2516 if (uw_Estrings) {
adamc@1011	2517 strcpy(s2, "\\\\");
adamc@1011	2518 s2 += 2;
adamc@1011	2519 } else
adamc@1011	2520 *s2++ = '\\';
adamc@1011	2521 break;
adamc@1011	2522 default:
adamc@1150	2523 if (isprint((int)c))
adamc@1011	2524 *s2++ = c;
adamc@1011	2525 else if (uw_Estrings) {
adam@1857	2526 sprintf(s2, "\\%03o", (unsigned char)c);
adamc@1011	2527 s2 += 4;
adamc@1011	2528 }
adamc@1011	2529 else
adamc@1011	2530 uw_error(ctx, FATAL, "Non-printable character %u in char to SQLify", c);
adamc@1011	2531 }
adamc@1011	2532
adamc@1011	2533 *s2++ = '\'';
adamc@1011	2534 strcpy(s2, uw_sqlsuffixChar);
adamc@1011	2535 ctx->heap.front = s2 + 1 + strlen(uw_sqlsuffixChar);
adamc@1011	2536 return r;
adamc@1011	2537 }
adamc@1011	2538
adamc@879	2539 char *uw_sqlsuffixBlob = "::bytea";
adamc@879	2540
adam@1867	2541 uw_Basis_string uw_Basis_sqlifyBlob(uw_context ctx, uw_Basis_blob b) {
adamc@737	2542 char r, s2;
adamc@737	2543 size_t i;
adamc@737	2544
adam@1867	2545 uw_check_heap(ctx, b.size * 5 + 4 + strlen(uw_sqlsuffixBlob));
adamc@737	2546
adamc@737	2547 r = s2 = ctx->heap.front;
adamc@879	2548 if (uw_Estrings)
adamc@879	2549 *s2++ = 'E';
adam@1867	2550 else
adam@1867	2551 *s2++ = 'X';
adamc@737	2552 *s2++ = '\'';
adamc@737	2553
adamc@737	2554 for (i = 0; i < b.size; ++i) {
adam@1867	2555 unsigned char c = b.data[i];
adam@1867	2556
adam@1867	2557 if (uw_Estrings) {
adam@1867	2558 switch (c) {
adam@1867	2559 case '\'':
adamc@885	2560 strcpy(s2, "\\'");
adam@1867	2561 s2 += 2;
adam@1867	2562 break;
adam@1867	2563 case '\\':
adamc@885	2564 strcpy(s2, "\\\\\\\\");
adamc@885	2565 s2 += 4;
adam@1867	2566 break;
adam@1867	2567 default:
adam@1867	2568 if (isprint((int)c))
adam@1867	2569 *s2++ = c;
adam@1867	2570 else {
adam@1867	2571 sprintf(s2, "\\\\%03o", c);
adam@1867	2572 s2 += 5;
adam@1867	2573 }
adamc@737	2574 }
adam@1867	2575 } else {
adam@1867	2576 sprintf(s2, "%02X", c);
adam@1867	2577 s2 += 2;
adamc@737	2578 }
adam@1867	2579 }
adamc@737	2580
adamc@879	2581 *s2++ = '\'';
adamc@879	2582 strcpy(s2, uw_sqlsuffixBlob);
adamc@879	2583 ctx->heap.front = s2 + 1 + strlen(uw_sqlsuffixBlob);
adamc@737	2584 return r;
adamc@737	2585 }
adamc@737	2586
adamc@682	2587 char *uw_Basis_sqlifyChannel(uw_context ctx, uw_Basis_channel chn) {
adamc@682	2588 int len;
adamc@682	2589 char *r;
adamc@682	2590 unsigned long long combo = ((unsigned long long)chn.cli << 32) \| chn.chn;
adamc@682	2591
adamc@682	2592 uw_check_heap(ctx, INTS_MAX + 7);
adamc@682	2593 r = ctx->heap.front;
adamc@879	2594 sprintf(r, uw_sqlfmtInt, combo, &len);
adamc@682	2595 ctx->heap.front += len+1;
adamc@682	2596 return r;
adamc@682	2597 }
adamc@682	2598
adamc@682	2599 char *uw_Basis_attrifyChannel(uw_context ctx, uw_Basis_channel chn) {
adamc@682	2600 int len;
adamc@682	2601 char *r;
adamc@682	2602 unsigned long long combo = ((unsigned long long)chn.cli << 32) \| chn.chn;
adamc@682	2603
adamc@682	2604 uw_check_heap(ctx, INTS_MAX + 1);
adamc@682	2605 r = ctx->heap.front;
adamc@682	2606 sprintf(r, "%lld%n", combo, &len);
adamc@682	2607 ctx->heap.front += len+1;
adamc@682	2608 return r;
adamc@682	2609 }
adamc@682	2610
adamc@879	2611 char *uw_sqlfmtUint4 = "%u::int4%n";
adamc@879	2612
adamc@682	2613 char *uw_Basis_sqlifyClient(uw_context ctx, uw_Basis_client cli) {
adamc@682	2614 int len;
adamc@682	2615 char *r;
adamc@682	2616
adamc@682	2617 uw_check_heap(ctx, INTS_MAX + 7);
adamc@682	2618 r = ctx->heap.front;
adamc@879	2619 sprintf(r, uw_sqlfmtUint4, cli, &len);
adamc@682	2620 ctx->heap.front += len+1;
adamc@682	2621 return r;
adamc@682	2622 }
adamc@682	2623
adamc@682	2624 char *uw_Basis_attrifyClient(uw_context ctx, uw_Basis_client cli) {
adamc@682	2625 int len;
adamc@682	2626 char *r;
adamc@682	2627
adamc@682	2628 uw_check_heap(ctx, INTS_MAX + 1);
adamc@682	2629 r = ctx->heap.front;
adamc@682	2630 sprintf(r, "%u%n", cli, &len);
adamc@682	2631 ctx->heap.front += len+1;
adamc@682	2632 return r;
adamc@682	2633 }
adamc@682	2634
adamc@467	2635 uw_Basis_string uw_Basis_sqlifyStringN(uw_context ctx, uw_Basis_string s) {
adamc@467	2636 if (s == NULL)
adamc@467	2637 return "NULL";
adamc@467	2638 else
adamc@467	2639 return uw_Basis_sqlifyString(ctx, s);
adamc@467	2640 }
adamc@467	2641
adamc@311	2642 char *uw_Basis_sqlifyBool(uw_context ctx, uw_Basis_bool b) {
adamc@311	2643 if (b == uw_Basis_False)
adamc@281	2644 return "FALSE";
adamc@281	2645 else
adamc@281	2646 return "TRUE";
adamc@281	2647 }
adamc@282	2648
adamc@467	2649 char uw_Basis_sqlifyBoolN(uw_context ctx, uw_Basis_bool b) {
adamc@467	2650 if (b == NULL)
adamc@467	2651 return "NULL";
adamc@467	2652 else
adamc@467	2653 return uw_Basis_sqlifyBool(ctx, *b);
adamc@467	2654 }
adamc@467	2655
adamc@439	2656 char *uw_Basis_sqlifyTime(uw_context ctx, uw_Basis_time t) {
adamc@439	2657 size_t len;
adamc@682	2658 char r, s;
adam@1392	2659 struct tm stm = {};
adam@1392	2660 stm.tm_isdst = -1;
adamc@682	2661
adam@1365	2662 if (localtime_r(&t.seconds, &stm)) {
adamc@682	2663 s = uw_malloc(ctx, TIMES_MAX);
adam@1364	2664 len = strftime(s, TIMES_MAX, TIME_FMT_PG, &stm);
adam@1834	2665 if (uw_sql_type_annotations) {
adam@1834	2666 if (t.microseconds) {
adam@1834	2667 r = uw_malloc(ctx, len + 21);
adam@1834	2668 sprintf(r, "'%s.%06u'::timestamp", s, t.microseconds);
adam@1834	2669 } else {
adam@1834	2670 r = uw_malloc(ctx, len + 14);
adam@1834	2671 sprintf(r, "'%s'::timestamp", s);
adam@1834	2672 }
adam@1367	2673 } else {
adam@1834	2674 r = uw_malloc(ctx, len + 3);
adam@1834	2675 sprintf(r, "'%s'", s);
adam@1367	2676 }
adamc@682	2677 return r;
adamc@682	2678 } else
adamc@682	2679 return "<Invalid time>";
adamc@682	2680 }
adamc@682	2681
adamc@682	2682 char *uw_Basis_attrifyTime(uw_context ctx, uw_Basis_time t) {
adamc@682	2683 size_t len;
adamc@439	2684 char *r;
adam@1392	2685 struct tm stm = {};
adam@1392	2686 stm.tm_isdst = -1;
adamc@439	2687
adam@1365	2688 if (localtime_r(&t.seconds, &stm)) {
adamc@439	2689 uw_check_heap(ctx, TIMES_MAX);
adamc@666	2690 r = ctx->heap.front;
adamc@439	2691 len = strftime(r, TIMES_MAX, TIME_FMT, &stm);
adamc@666	2692 ctx->heap.front += len+1;
adamc@439	2693 return r;
adamc@439	2694 } else
adamc@439	2695 return "<Invalid time>";
adamc@439	2696 }
adamc@439	2697
adam@1364	2698 char *uw_Basis_ensqlTime(uw_context ctx, uw_Basis_time t) {
adam@1364	2699 size_t len;
adam@1364	2700 char *r;
adam@1392	2701 struct tm stm = {};
adam@1392	2702 stm.tm_isdst = -1;
adam@1364	2703
adam@1365	2704 if (localtime_r(&t.seconds, &stm)) {
adam@1364	2705 uw_check_heap(ctx, TIMES_MAX);
adam@1364	2706 r = ctx->heap.front;
adam@1365	2707 len = strftime(r, TIMES_MAX-7, TIME_FMT_PG, &stm);
adam@1365	2708 ctx->heap.front += len;
adam@1365	2709 sprintf(ctx->heap.front, ".%06u", t.microseconds);
adam@1365	2710 ctx->heap.front += 8;
adam@1364	2711 return r;
adam@1364	2712 } else
adam@1364	2713 return "<Invalid time>";
adam@1364	2714 }
adam@1364	2715
adamc@467	2716 char uw_Basis_sqlifyTimeN(uw_context ctx, uw_Basis_time t) {
adamc@467	2717 if (t == NULL)
adamc@467	2718 return "NULL";
adamc@467	2719 else
adamc@467	2720 return uw_Basis_sqlifyTime(ctx, *t);
adamc@467	2721 }
adamc@467	2722
adamc@311	2723 char *uw_Basis_ensqlBool(uw_Basis_bool b) {
adamc@311	2724 static uw_Basis_int true = 1;
adamc@311	2725 static uw_Basis_int false = 0;
adamc@282	2726
adamc@311	2727 if (b == uw_Basis_False)
adamc@282	2728 return (char *)&false;
adamc@282	2729 else
adamc@282	2730 return (char *)&true;
adamc@282	2731 }
adamc@284	2732
adamc@311	2733 uw_Basis_string uw_Basis_intToString(uw_context ctx, uw_Basis_int n) {
adamc@284	2734 int len;
adamc@284	2735 char *r;
adamc@284	2736
adamc@311	2737 uw_check_heap(ctx, INTS_MAX);
adamc@666	2738 r = ctx->heap.front;
adamc@284	2739 sprintf(r, "%lld%n", n, &len);
adamc@666	2740 ctx->heap.front += len+1;
adamc@284	2741 return r;
adamc@284	2742 }
adamc@285	2743
adamc@311	2744 uw_Basis_string uw_Basis_floatToString(uw_context ctx, uw_Basis_float n) {
adamc@285	2745 int len;
adamc@285	2746 char *r;
adamc@285	2747
adamc@311	2748 uw_check_heap(ctx, FLOATS_MAX);
adamc@666	2749 r = ctx->heap.front;
adamc@285	2750 sprintf(r, "%g%n", n, &len);
adamc@666	2751 ctx->heap.front += len+1;
adamc@285	2752 return r;
adamc@285	2753 }
adamc@285	2754
adamc@821	2755 uw_Basis_string uw_Basis_charToString(uw_context ctx, uw_Basis_char ch) {
adamc@821	2756 char *r = uw_malloc(ctx, 2);
adamc@821	2757 r[0] = ch;
adamc@821	2758 r[1] = 0;
adamc@821	2759 return r;
adamc@821	2760 }
adamc@821	2761
adamc@311	2762 uw_Basis_string uw_Basis_boolToString(uw_context ctx, uw_Basis_bool b) {
adamc@311	2763 if (b == uw_Basis_False)
adamc@285	2764 return "False";
adamc@285	2765 else
adamc@285	2766 return "True";
adamc@285	2767 }
adamc@288	2768
adam@1359	2769 uw_Basis_string uw_Basis_timef(uw_context ctx, const char *fmt, uw_Basis_time t) {
adam@1352	2770 size_t len;
adam@1352	2771 char *r;
adam@1392	2772 struct tm stm = {};
adam@1392	2773 stm.tm_isdst = -1;
adam@1352	2774
adam@1365	2775 if (localtime_r(&t.seconds, &stm)) {
adam@1352	2776 uw_check_heap(ctx, TIMES_MAX);
adam@1352	2777 r = ctx->heap.front;
adam@1352	2778 len = strftime(r, TIMES_MAX, fmt, &stm);
adam@1352	2779 ctx->heap.front += len+1;
adam@1352	2780 return r;
adam@1352	2781 } else
adam@1352	2782 return "<Invalid time>";
adam@1352	2783 }
adam@1352	2784
adam@1629	2785 uw_Basis_string uw_Basis_timeToString(uw_context ctx, uw_Basis_time t) {
adam@1629	2786 return uw_Basis_timef(ctx, ctx->app->time_format, t);
adam@1629	2787 }
adam@1629	2788
adamc@311	2789 uw_Basis_int *uw_Basis_stringToInt(uw_context ctx, uw_Basis_string s) {
adamc@288	2790 char *endptr;
adamc@311	2791 uw_Basis_int n = strtoll(s, &endptr, 10);
adamc@288	2792
adamc@288	2793 if (s != '\0' && endptr == '\0') {
adamc@311	2794 uw_Basis_int *r = uw_malloc(ctx, sizeof(uw_Basis_int));
adamc@288	2795 *r = n;
adamc@288	2796 return r;
adamc@288	2797 } else
adamc@288	2798 return NULL;
adamc@288	2799 }
adamc@289	2800
adamc@311	2801 uw_Basis_float *uw_Basis_stringToFloat(uw_context ctx, uw_Basis_string s) {
adamc@289	2802 char *endptr;
adamc@311	2803 uw_Basis_float n = strtod(s, &endptr);
adamc@289	2804
adamc@289	2805 if (s != '\0' && endptr == '\0') {
adamc@311	2806 uw_Basis_float *r = uw_malloc(ctx, sizeof(uw_Basis_float));
adamc@289	2807 *r = n;
adamc@289	2808 return r;
adamc@289	2809 } else
adamc@289	2810 return NULL;
adamc@289	2811 }
adamc@289	2812
adamc@821	2813 uw_Basis_char *uw_Basis_stringToChar(uw_context ctx, uw_Basis_string s) {
adamc@821	2814 if (s[0] == 0) {
adamc@821	2815 uw_Basis_char *r = uw_malloc(ctx, 1);
adamc@821	2816 r[0] = 0;
adamc@821	2817 return r;
adamc@821	2818 } else if (s[1] != 0)
adamc@821	2819 return NULL;
adamc@821	2820 else {
adamc@821	2821 uw_Basis_char *r = uw_malloc(ctx, 1);
adamc@821	2822 r[0] = s[0];
adamc@821	2823 return r;
adamc@821	2824 }
adamc@821	2825 }
adamc@821	2826
adamc@311	2827 uw_Basis_bool *uw_Basis_stringToBool(uw_context ctx, uw_Basis_string s) {
adamc@311	2828 static uw_Basis_bool true = uw_Basis_True;
adamc@311	2829 static uw_Basis_bool false = uw_Basis_False;
adamc@289	2830
adamc@289	2831 if (!strcasecmp (s, "True"))
adamc@289	2832 return &true;
adamc@289	2833 else if (!strcasecmp (s, "False"))
adamc@289	2834 return &false;
adamc@289	2835 else
adamc@289	2836 return NULL;
adamc@289	2837 }
adamc@292	2838
adamc@436	2839 uw_Basis_time *uw_Basis_stringToTime(uw_context ctx, uw_Basis_string s) {
adamc@438	2840 char dot = strchr(s, '.'), end = strchr(s, 0);
adam@1374	2841 struct tm stm = {};
adam@1392	2842 stm.tm_isdst = -1;
adamc@436	2843
adamc@439	2844 if (dot) {
adamc@439	2845 *dot = 0;
adamc@439	2846 if (strptime(s, TIME_FMT_PG, &stm) == end) {
adamc@439	2847 *dot = '.';
adamc@439	2848 uw_Basis_time *r = uw_malloc(ctx, sizeof(uw_Basis_time));
adam@1365	2849 r->seconds = mktime(&stm);
adam@1365	2850 r->microseconds = 0;
adamc@439	2851 return r;
adamc@439	2852 }
adamc@439	2853 else {
adamc@439	2854 *dot = '.';
adamc@439	2855 return NULL;
adamc@439	2856 }
adamc@436	2857 }
adamc@439	2858 else {
adamc@439	2859 if (strptime(s, TIME_FMT_PG, &stm) == end) {
adamc@439	2860 uw_Basis_time *r = uw_malloc(ctx, sizeof(uw_Basis_time));
adam@1365	2861 r->seconds = mktime(&stm);
adam@1365	2862 r->microseconds = 0;
adamc@439	2863 return r;
adamc@439	2864 }
adamc@439	2865 else if (strptime(s, TIME_FMT, &stm) == end) {
adamc@439	2866 uw_Basis_time *r = uw_malloc(ctx, sizeof(uw_Basis_time));
adam@1365	2867 r->seconds = mktime(&stm);
adam@1365	2868 r->microseconds = 0;
adamc@439	2869 return r;
adam@1632	2870 } else if (strptime(s, TIME_FMT_JS, &stm) == end) {
adam@1632	2871 uw_Basis_time *r = uw_malloc(ctx, sizeof(uw_Basis_time));
adam@1632	2872 r->seconds = mktime(&stm);
adam@1632	2873 r->microseconds = 0;
adam@1632	2874 return r;
adamc@439	2875 }
adamc@439	2876 else
adamc@439	2877 return NULL;
adamc@439	2878 }
adamc@436	2879 }
adamc@436	2880
adam@1352	2881 uw_Basis_time uw_Basis_stringToTimef(uw_context ctx, const char fmt, uw_Basis_string s) {
adam@1352	2882 char *end = strchr(s, 0);
adam@1374	2883 struct tm stm = {};
adam@1392	2884 stm.tm_isdst = -1;
adam@1352	2885
adam@1352	2886 if (strptime(s, fmt, &stm) == end) {
adam@1352	2887 uw_Basis_time *r = uw_malloc(ctx, sizeof(uw_Basis_time));
adam@1365	2888 r->seconds = mktime(&stm);
adam@1365	2889 r->microseconds = 0;
adam@1352	2890 return r;
adam@1352	2891 }
adam@1352	2892 else
adam@1352	2893 return NULL;
adam@1352	2894 }
adam@1352	2895
adamc@311	2896 uw_Basis_int uw_Basis_stringToInt_error(uw_context ctx, uw_Basis_string s) {
adamc@292	2897 char *endptr;
adamc@311	2898 uw_Basis_int n = strtoll(s, &endptr, 10);
adamc@292	2899
adamc@292	2900 if (s != '\0' && endptr == '\0')
adamc@292	2901 return n;
adamc@292	2902 else
adam@1444	2903 uw_error(ctx, FATAL, "Can't parse int: %s", uw_Basis_htmlifyString(ctx, s));
adamc@292	2904 }
adamc@293	2905
adamc@682	2906 #include <errno.h>
adamc@682	2907
adamc@678	2908 uw_Basis_channel uw_Basis_stringToChannel_error(uw_context ctx, uw_Basis_string s) {
adamc@682	2909 unsigned long long n;
adamc@682	2910
adamc@682	2911 if (sscanf(s, "%llu", &n) < 1)
adam@1444	2912 uw_error(ctx, FATAL, "Can't parse channel: %s", uw_Basis_htmlifyString(ctx, s));
adamc@682	2913 else {
adamc@682	2914 uw_Basis_channel ch = {n >> 32, n & ((1ull << 32) - 1)};
adamc@682	2915 return ch;
adamc@682	2916 }
adamc@682	2917 }
adamc@682	2918
adamc@682	2919 uw_Basis_client uw_Basis_stringToClient_error(uw_context ctx, uw_Basis_string s) {
adamc@678	2920 char *endptr;
adamc@682	2921 unsigned long n = strtoul(s, &endptr, 10);
adamc@678	2922
adamc@678	2923 if (s != '\0' && endptr == '\0')
adamc@678	2924 return n;
adamc@678	2925 else
adam@1444	2926 uw_error(ctx, FATAL, "Can't parse client: %s", uw_Basis_htmlifyString(ctx, s));
adamc@678	2927 }
adamc@678	2928
adamc@311	2929 uw_Basis_float uw_Basis_stringToFloat_error(uw_context ctx, uw_Basis_string s) {
adamc@293	2930 char *endptr;
adamc@311	2931 uw_Basis_float n = strtod(s, &endptr);
adamc@293	2932
adamc@293	2933 if (s != '\0' && endptr == '\0')
adamc@293	2934 return n;
adamc@293	2935 else
adam@1444	2936 uw_error(ctx, FATAL, "Can't parse float: %s", uw_Basis_htmlifyString(ctx, s));
adamc@293	2937 }
adamc@293	2938
adamc@821	2939 uw_Basis_char uw_Basis_stringToChar_error(uw_context ctx, uw_Basis_string s) {
adamc@821	2940 if (s[0] == 0)
adamc@821	2941 return 0;
adamc@821	2942 else if (s[1] != 0)
adam@1444	2943 uw_error(ctx, FATAL, "Can't parse char: %s", uw_Basis_htmlifyString(ctx, s));
adamc@821	2944 else
adamc@821	2945 return s[0];
adamc@821	2946 }
adamc@821	2947
adamc@311	2948 uw_Basis_bool uw_Basis_stringToBool_error(uw_context ctx, uw_Basis_string s) {
adamc@296	2949 if (!strcasecmp(s, "T") \|\| !strcasecmp (s, "True"))
adamc@311	2950 return uw_Basis_True;
adamc@296	2951 else if (!strcasecmp(s, "F") \|\| !strcasecmp (s, "False"))
adamc@311	2952 return uw_Basis_False;
adamc@293	2953 else
adam@1444	2954 uw_error(ctx, FATAL, "Can't parse bool: %s", uw_Basis_htmlifyString(ctx, s));
adamc@293	2955 }
adamc@436	2956
adam@1352	2957 uw_Basis_time uw_Basis_unsqlTime(uw_context ctx, uw_Basis_string s) {
adam@1352	2958 char dot = strchr(s, '.'), end = strchr(s, 0);
adam@1352	2959 struct tm stm = {};
adam@1392	2960 stm.tm_isdst = -1;
adam@1352	2961
adam@1352	2962 if (dot) {
adam@1352	2963 *dot = 0;
adam@1352	2964 if (strptime(s, TIME_FMT_PG, &stm)) {
adam@1352	2965 *dot = '.';
adam@1410	2966 char usec[] = "000000";
adam@1410	2967 int len = strlen(dot+1);
adam@1410	2968 memcpy(usec, dot+1, len < 6 ? len : 6);
adam@1410	2969 uw_Basis_time r = { mktime(&stm), atoi(usec) };
adam@1365	2970 return r;
adam@1352	2971 }
adam@1352	2972 else {
adam@1352	2973 *dot = '.';
adam@1444	2974 uw_error(ctx, FATAL, "Can't parse time: %s", uw_Basis_htmlifyString(ctx, s));
adam@1352	2975 }
adam@1352	2976 }
adam@1352	2977 else {
adam@1352	2978 if (strptime(s, TIME_FMT_PG, &stm) == end) {
adam@1365	2979 uw_Basis_time r = { mktime(&stm) };
adam@1365	2980 return r;
adam@1352	2981 } else if (strptime(s, TIME_FMT, &stm) == end) {
adam@1365	2982 uw_Basis_time r = { mktime(&stm) };
adam@1365	2983 return r;
adam@1352	2984 } else
adam@1444	2985 uw_error(ctx, FATAL, "Can't parse time: %s", uw_Basis_htmlifyString(ctx, s));
adam@1352	2986 }
adam@1352	2987 }
adam@1352	2988
adamc@436	2989 uw_Basis_time uw_Basis_stringToTime_error(uw_context ctx, uw_Basis_string s) {
adamc@438	2990 char dot = strchr(s, '.'), end = strchr(s, 0);
adamc@436	2991 struct tm stm = {};
adam@1392	2992 stm.tm_isdst = -1;
adamc@436	2993
adamc@438	2994 if (dot) {
adamc@438	2995 *dot = 0;
adamc@438	2996 if (strptime(s, TIME_FMT_PG, &stm)) {
adamc@438	2997 *dot = '.';
adam@1365	2998 {
adam@1365	2999 uw_Basis_time r = { mktime(&stm) };
adam@1365	3000 return r;
adam@1365	3001 }
adamc@438	3002 }
adamc@438	3003 else {
adamc@438	3004 *dot = '.';
adam@1444	3005 uw_error(ctx, FATAL, "Can't parse time: %s", uw_Basis_htmlifyString(ctx, s));
adamc@438	3006 }
adamc@438	3007 }
adamc@438	3008 else {
adam@1365	3009 if (strptime(s, TIME_FMT_PG, &stm) == end) {
adam@1365	3010 uw_Basis_time r = { mktime(&stm) };
adam@1365	3011 return r;
adam@1365	3012 } else if (strptime(s, TIME_FMT, &stm) == end) {
adam@1365	3013 uw_Basis_time r = { mktime(&stm) };
adam@1365	3014 return r;
adam@1632	3015 } else if (strptime(s, TIME_FMT_JS, &stm) == end) {
adam@1632	3016 uw_Basis_time r = { mktime(&stm) };
adam@1632	3017 return r;
adam@1365	3018 } else
adam@1444	3019 uw_error(ctx, FATAL, "Can't parse time: %s", uw_Basis_htmlifyString(ctx, s));
adamc@438	3020 }
adamc@436	3021 }
adamc@457	3022
adam@1352	3023 uw_Basis_time uw_Basis_stringToTimef_error(uw_context ctx, const char *fmt, uw_Basis_string s) {
adam@1352	3024 char *end = strchr(s, 0);
adamc@939	3025 struct tm stm = {};
adam@1392	3026 stm.tm_isdst = -1;
adamc@939	3027
adam@1365	3028 if (strptime(s, fmt, &stm) == end) {
adam@1365	3029 uw_Basis_time r = { mktime(&stm) };
adam@1365	3030 return r;
adam@1365	3031 } else
adam@1444	3032 uw_error(ctx, FATAL, "Can't parse time: %s", uw_Basis_htmlifyString(ctx, s));
adamc@939	3033 }
adamc@939	3034
adamc@742	3035 uw_Basis_blob uw_Basis_stringToBlob_error(uw_context ctx, uw_Basis_string s, size_t len) {
adamc@742	3036 char *r = ctx->heap.front;
adamc@742	3037 uw_Basis_blob b = {len, r};
adamc@742	3038
adamc@742	3039 uw_check_heap(ctx, len);
adamc@742	3040
adamc@742	3041 while (*s) {
adamc@742	3042 if (s[0] == '\\') {
adamc@742	3043 if (s[1] == '\\') {
adamc@742	3044 *r++ = '\\';
adamc@742	3045 s += 2;
adamc@1153	3046 } else if (isdigit((int)s[1]) && isdigit((int)s[2]) && isdigit((int)s[3])) {
adamc@742	3047 r++ = (s[1] - '0') 8 * 8 + ((s[2] - '0') * 8) + (s[3] - '0');
adamc@742	3048 s += 4;
adamc@742	3049 }
adamc@742	3050 else {
adamc@742	3051 *r++ = '\\';
adamc@742	3052 ++s;
adamc@742	3053 }
adamc@742	3054 } else {
adamc@742	3055 *r++ = s[0];
adamc@742	3056 ++s;
adamc@742	3057 }
adamc@742	3058 }
adamc@742	3059
adamc@742	3060 b.size = r - ctx->heap.front;
adamc@742	3061 ctx->heap.front = r;
adamc@742	3062 return b;
adamc@742	3063 }
adamc@742	3064
adam@1402	3065 #define THE_PAST "expires=Sat, 01-Jan-2011 00:00:00 GMT"
adamc@1052	3066
adamc@463	3067 uw_Basis_string uw_Basis_get_cookie(uw_context ctx, uw_Basis_string c) {
adamc@463	3068 int len = strlen(c);
adamc@854	3069 char *p = ctx->outHeaders.start;
adamc@474	3070
adamc@1134	3071 while ((p = strstr(p, "\nSet-Cookie: "))) {
adamc@474	3072 char *p2;
adamc@474	3073 p += 13;
adamc@474	3074 p2 = strchr(p, '=');
adamc@474	3075
adamc@474	3076 if (p2) {
adamc@474	3077 size_t sz = strcspn(p2+1, ";\r\n");
adamc@474	3078
adamc@474	3079 if (!strncasecmp(p, c, p2 - p)) {
adamc@1052	3080 if (sz == 0 && strstr(p2+2, THE_PAST))
adamc@1052	3081 return NULL;
adamc@1052	3082 else {
adamc@1052	3083 char *ret = uw_malloc(ctx, sz + 1);
adamc@1052	3084 memcpy(ret, p2+1, sz);
adamc@1052	3085 ret[sz] = 0;
adamc@1052	3086 return ret;
adamc@1052	3087 }
adamc@474	3088 }
adamc@474	3089 }
adamc@474	3090 }
adamc@463	3091
adamc@1134	3092 if ((p = uw_Basis_requestHeader(ctx, "Cookie"))) {
adamc@1051	3093 char *p2;
adamc@1051	3094
adamc@854	3095 while (1) {
adamc@1051	3096 if (!strncmp(p, c, len) && p[len] == '=') {
adamc@1134	3097 if ((p2 = strchr(p, ';'))) {
adamc@1051	3098 size_t n = p2 - (p + len);
adamc@1051	3099 char *r = uw_malloc(ctx, n);
adamc@1051	3100 memcpy(r, p + 1 + len, n-1);
adamc@1051	3101 r[n-1] = 0;
adamc@1051	3102 return r;
adamc@1051	3103 } else
adamc@1051	3104 return p + 1 + len;
adamc@1134	3105 } else if ((p = strchr(p, ';')))
adamc@854	3106 p += 2;
adamc@463	3107 else
adamc@463	3108 return NULL;
adamc@463	3109 }
adamc@463	3110 }
adamc@792	3111
adamc@792	3112 return NULL;
adamc@457	3113 }
adamc@462	3114
adam@1877	3115 static void set_cookie(uw_context ctx) {
adam@1877	3116 if (ctx->usedSig)
adam@1877	3117 ctx->needsResig = 1;
adam@1877	3118 }
adam@1877	3119
adamc@1050	3120 uw_unit uw_Basis_set_cookie(uw_context ctx, uw_Basis_string prefix, uw_Basis_string c, uw_Basis_string v, uw_Basis_time *expires, uw_Basis_bool secure) {
adamc@462	3121 uw_write_header(ctx, "Set-Cookie: ");
adamc@462	3122 uw_write_header(ctx, c);
adamc@462	3123 uw_write_header(ctx, "=");
adamc@462	3124 uw_write_header(ctx, v);
adamc@466	3125 uw_write_header(ctx, "; path=");
adamc@466	3126 uw_write_header(ctx, prefix);
adamc@1050	3127 if (expires) {
adamc@1050	3128 char formatted[30];
adam@1392	3129 struct tm tm = {};
adam@1392	3130 tm.tm_isdst = -1;
adamc@1050	3131
adam@1365	3132 gmtime_r(&expires->seconds, &tm);
adamc@1050	3133
adamc@1050	3134 strftime(formatted, sizeof formatted, "%a, %d-%b-%Y %T GMT", &tm);
adamc@1050	3135
adamc@1050	3136 uw_write_header(ctx, "; expires=");
adamc@1050	3137 uw_write_header(ctx, formatted);
adamc@1050	3138 }
adamc@1050	3139 if (secure)
adamc@1050	3140 uw_write_header(ctx, "; secure");
adamc@462	3141 uw_write_header(ctx, "\r\n");
adam@1877	3142 set_cookie(ctx);
adamc@462	3143
adamc@462	3144 return uw_unit_v;
adamc@462	3145 }
adamc@667	3146
adamc@1050	3147 uw_unit uw_Basis_clear_cookie(uw_context ctx, uw_Basis_string prefix, uw_Basis_string c) {
adamc@1050	3148 uw_write_header(ctx, "Set-Cookie: ");
adamc@1050	3149 uw_write_header(ctx, c);
adamc@1050	3150 uw_write_header(ctx, "=; path=");
adamc@1050	3151 uw_write_header(ctx, prefix);
adamc@1052	3152 uw_write_header(ctx, "; " THE_PAST "\r\n");
adam@1877	3153 set_cookie(ctx);
adamc@1050	3154
adamc@1050	3155 return uw_unit_v;
adamc@1050	3156 }
adamc@1050	3157
adamc@1113	3158 size_t uw_deltas_max = SIZE_MAX;
adamc@1113	3159
adamc@682	3160 static delta *allocate_delta(uw_context ctx, unsigned client) {
adamc@682	3161 unsigned i;
adamc@682	3162 delta *d;
adamc@671	3163
adamc@682	3164 for (i = 0; i < ctx->used_deltas; ++i)
adamc@682	3165 if (ctx->deltas[i].client == client)
adamc@682	3166 return &ctx->deltas[i];
adamc@671	3167
adamc@682	3168 if (ctx->used_deltas >= ctx->n_deltas) {
adamc@1113	3169 if (ctx->n_deltas + 1 > uw_deltas_max)
adamc@1113	3170 uw_error(ctx, FATAL, "Exceeded limit on number of deltas");
adamc@1113	3171
adamc@682	3172 ctx->deltas = realloc(ctx->deltas, sizeof(delta) * ++ctx->n_deltas);
adam@1369	3173 uw_buffer_init(uw_messages_max, &ctx->deltas[ctx->n_deltas-1].msgs, 0);
adamc@682	3174 }
adamc@671	3175
adamc@682	3176 d = &ctx->deltas[ctx->used_deltas++];
adamc@682	3177 d->client = client;
adam@1369	3178 uw_buffer_reset(&d->msgs);
adamc@682	3179 return d;
adamc@671	3180 }
adamc@671	3181
adamc@668	3182 uw_Basis_channel uw_Basis_new_channel(uw_context ctx, uw_unit u) {
adamc@682	3183 if (ctx->client == NULL)
adamc@682	3184 uw_error(ctx, FATAL, "Attempt to create channel on request not associated with a persistent connection");
adamc@671	3185
adamc@682	3186 return new_channel(ctx->client);
adamc@668	3187 }
adamc@668	3188
adamc@668	3189 uw_unit uw_Basis_send(uw_context ctx, uw_Basis_channel chn, uw_Basis_string msg) {
adamc@682	3190 delta *d = allocate_delta(ctx, chn.cli);
adamc@682	3191 size_t len;
adamc@682	3192 int preLen;
adamc@682	3193 char pre[INTS_MAX + 2];
adamc@668	3194
adamc@682	3195 len = strlen(msg);
adamc@682	3196
adamc@682	3197 sprintf(pre, "%u\n%n", chn.chn, &preLen);
adamc@682	3198
adam@1369	3199 ctx_uw_buffer_append(ctx, "messages", &d->msgs, pre, preLen);
adam@1369	3200 ctx_uw_buffer_append(ctx, "messages", &d->msgs, msg, len);
adam@1369	3201 ctx_uw_buffer_append(ctx, "messages", &d->msgs, "\n", 1);
adamc@671	3202
adamc@671	3203 return uw_unit_v;
adamc@668	3204 }
adamc@671	3205
adam@1327	3206 int uw_rollback(uw_context ctx, int will_retry) {
adamc@1131	3207 int i;
adamc@1131	3208 cleanup *cl;
adamc@1131	3209
adamc@1131	3210 if (ctx->client)
adamc@1131	3211 release_client(ctx->client);
adamc@1131	3212
adamc@1131	3213 for (cl = ctx->cleanup; cl < ctx->cleanup_front; ++cl)
adamc@1131	3214 cl->func(cl->arg);
adamc@1131	3215
adamc@1131	3216 ctx->cleanup_front = ctx->cleanup;
adamc@1131	3217
adamc@1131	3218 for (i = ctx->used_transactionals-1; i >= 0; --i)
adamc@1131	3219 if (ctx->transactionals[i].rollback != NULL)
adamc@1131	3220 ctx->transactionals[i].rollback(ctx->transactionals[i].data);
adamc@1131	3221
adamc@1131	3222 for (i = ctx->used_transactionals-1; i >= 0; --i)
adamc@1131	3223 if (ctx->transactionals[i].free)
adam@1327	3224 ctx->transactionals[i].free(ctx->transactionals[i].data, will_retry);
adamc@1131	3225
adam@1941	3226 if (ctx->app && ctx->transaction_started) {
adam@1941	3227 ctx->transaction_started = 0;
adam@1941	3228 return ctx->app->db_rollback(ctx);
adam@1941	3229 } else
adam@1941	3230 return 0;
adamc@1131	3231 }
adamc@1131	3232
adam@1728	3233 static const char begin_xhtml[] = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">";
adam@1728	3234
adam@1877	3235 extern int uw_hash_blocksize;
adam@1877	3236
adam@1877	3237 static const char sig_intro[] = "<input type=\"hidden\" name=\"Sig\" value=\"";
adam@1877	3238
adam@1877	3239 static char find_sig(char haystack) {
adam@1877	3240 int i;
adam@1877	3241 char *s = strstr(haystack, sig_intro);
adam@1877	3242
adam@1877	3243 if (!s \|\| strlen(haystack) - (s - haystack) - (sizeof sig_intro - 1) < uw_hash_blocksize*2+1)
adam@1877	3244 return NULL;
adam@1877	3245
adam@1877	3246 s += sizeof sig_intro - 1;
adam@1877	3247
adam@1877	3248 for (i = 0; i < uw_hash_blocksize*2; ++i)
adam@1877	3249 if (!isxdigit((int)s[i]))
adam@1877	3250 return NULL;
adam@1877	3251
adam@1877	3252 if (s[i] != '"')
adam@1877	3253 return NULL;
adam@1877	3254
adam@1877	3255 return s;
adam@1877	3256 }
adam@1877	3257
adam@1938	3258 int uw_commit(uw_context ctx) {
adamc@1104	3259 int i;
adam@1877	3260 char *sig;
adamc@1104	3261
adamc@1131	3262 if (uw_has_error(ctx)) {
adam@1327	3263 uw_rollback(ctx, 0);
adam@1938	3264 return 0;
adamc@1131	3265 }
adamc@1131	3266
adamc@1104	3267 for (i = ctx->used_transactionals-1; i >= 0; --i)
adamc@771	3268 if (ctx->transactionals[i].rollback != NULL)
adamc@1131	3269 if (ctx->transactionals[i].commit) {
adamc@1083	3270 ctx->transactionals[i].commit(ctx->transactionals[i].data);
adamc@1131	3271 if (uw_has_error(ctx)) {
adam@1327	3272 uw_rollback(ctx, 0);
adam@1938	3273 return 0;
adamc@1131	3274 }
adamc@1131	3275 }
adamc@771	3276
adamc@1104	3277 for (i = ctx->used_transactionals-1; i >= 0; --i)
adamc@771	3278 if (ctx->transactionals[i].rollback == NULL)
adamc@1131	3279 if (ctx->transactionals[i].commit) {
adamc@1083	3280 ctx->transactionals[i].commit(ctx->transactionals[i].data);
adamc@1131	3281 if (uw_has_error(ctx)) {
adam@1327	3282 uw_rollback(ctx, 0);
adam@1938	3283 return 0;
adamc@1131	3284 }
adamc@1131	3285 }
adamc@1131	3286
adam@1938	3287 if (ctx->transaction_started) {
adam@1939	3288 int code = ctx->app->db_commit(ctx);
adam@1938	3289
adam@1938	3290 if (code) {
adam@1939	3291 if (code == -1)
adam@1938	3292 return 1;
adam@1938	3293
adam@1938	3294 for (i = ctx->used_transactionals-1; i >= 0; --i)
adam@1938	3295 if (ctx->transactionals[i].free)
adam@1938	3296 ctx->transactionals[i].free(ctx->transactionals[i].data, 0);
adam@1938	3297
adam@1938	3298 uw_set_error_message(ctx, "Error running SQL COMMIT");
adam@1938	3299 return 0;
adam@1938	3300 }
adamc@1131	3301 }
adamc@682	3302
adamc@682	3303 for (i = 0; i < ctx->used_deltas; ++i) {
adamc@682	3304 delta *d = &ctx->deltas[i];
adamc@682	3305 client *c = find_client(d->client);
adamc@682	3306
adam@1551	3307 assert (c != NULL);
adam@1551	3308 assert(c->mode == USED);
adamc@682	3309
adam@1447	3310 client_send(c, &d->msgs, ctx->script.start, uw_buffer_used(&ctx->script));
adamc@682	3311 }
adamc@682	3312
adamc@682	3313 if (ctx->client)
adamc@685	3314 release_client(ctx->client);
adamc@771	3315
adamc@1104	3316 for (i = ctx->used_transactionals-1; i >= 0; --i)
adamc@1083	3317 if (ctx->transactionals[i].free)
adam@1327	3318 ctx->transactionals[i].free(ctx->transactionals[i].data, 0);
adamc@916	3319
vshabanoff@1726	3320 uw_check(ctx, 1);
vshabanoff@1726	3321 *ctx->page.front = 0;
adam@1413	3322
adam@1728	3323 if (!ctx->returning_indirectly && !strncmp(ctx->page.start, begin_xhtml, sizeof begin_xhtml - 1)) {
adam@1728	3324 char *s;
adam@1728	3325
adam@1728	3326 // Splice script data into appropriate part of page, also adding <head> if needed.
adam@1728	3327 s = ctx->page.start + sizeof begin_xhtml - 1;
adam@1728	3328 s = strchr(s, '<');
adam@1728	3329 if (s == NULL) {
adam@1728	3330 // Weird. Document has no tags!
adam@1728	3331
adam@1728	3332 uw_write(ctx, "<head></head><body></body>");
adam@1728	3333 uw_check(ctx, 1);
adam@1728	3334 *ctx->page.front = 0;
adam@1728	3335 } else if (!strncmp(s, "<head>", 6)) {
adam@1728	3336 // <head> is present. Let's add the <script> tags immediately after it.
adam@1728	3337
adam@1729	3338 // Any freeform JavaScript to include?
adam@1729	3339 if (uw_buffer_used(&ctx->script) > 0) {
adam@1729	3340 size_t lenH = strlen(ctx->script_header), len = uw_buffer_used(&ctx->script);
adam@1729	3341 size_t lenP = lenH + 40 + len;
adam@1729	3342 char start = s + 6, oldPage = ctx->page.start;
adam@1729	3343
adam@1729	3344 ctx_uw_buffer_check(ctx, "page", &ctx->page, uw_buffer_used(&ctx->page) + lenP);
adam@1729	3345 start += ctx->page.start - oldPage;
adam@1729	3346 memmove(start + lenP, start, uw_buffer_used(&ctx->page) - (start - ctx->page.start) + 1);
adam@1729	3347 ctx->page.front += lenP;
adam@1729	3348 memcpy(start, ctx->script_header, lenH);
adam@1729	3349 memcpy(start + lenH, "<script type=\"text/javascript\">", 31);
adam@1729	3350 memcpy(start + lenH + 31, ctx->script.start, len);
adam@1729	3351 memcpy(start + lenH + 31 + len, "</script>", 9);
adam@1729	3352 } else {
adam@1729	3353 size_t lenH = strlen(ctx->script_header);
adam@1729	3354 char start = s + 6, oldPage = ctx->page.start;
adam@1729	3355
adam@1729	3356 ctx_uw_buffer_check(ctx, "page", &ctx->page, uw_buffer_used(&ctx->page) + lenH);
adam@1729	3357 start += ctx->page.start - oldPage;
adam@1729	3358 memmove(start + lenH, start, uw_buffer_used(&ctx->page) - (start - ctx->page.start) + 1);
adam@1729	3359 ctx->page.front += lenH;
adam@1729	3360 memcpy(start, ctx->script_header, lenH);
adam@1729	3361 }
adam@1728	3362 } else {
adam@1728	3363 // No <head>. At this point, add it, with <script> tags inside.
adam@1728	3364
adam@1729	3365 if (uw_buffer_used(&ctx->script) > 0) {
adam@1729	3366 size_t lenH = strlen(ctx->script_header), len = uw_buffer_used(&ctx->script);
adam@1729	3367 size_t lenP = lenH + 53 + len;
adam@1729	3368 char start = s, oldPage = ctx->page.start;
adam@1729	3369
adam@1729	3370 ctx_uw_buffer_check(ctx, "page", &ctx->page, uw_buffer_used(&ctx->page) + lenP);
adam@1729	3371 start += ctx->page.start - oldPage;
adam@1729	3372 memmove(start + lenP, start, uw_buffer_used(&ctx->page) - (start - ctx->page.start) + 1);
adam@1729	3373 ctx->page.front += lenP;
adam@1729	3374 memcpy(start, "<head>", 6);
adam@1729	3375 memcpy(start + 6, ctx->script_header, lenH);
adam@1729	3376 memcpy(start + 6 + lenH, "<script type=\"text/javascript\">", 31);
adam@1729	3377 memcpy(start + 6 + lenH + 31, ctx->script.start, len);
adam@1729	3378 memcpy(start + 6 + lenH + 31 + len, "</script></head>", 16);
adam@1729	3379 } else {
adam@1729	3380 size_t lenH = strlen(ctx->script_header);
adam@1729	3381 size_t lenP = lenH + 13;
adam@1729	3382 char start = s, oldPage = ctx->page.start;
adam@1729	3383
adam@1729	3384 ctx_uw_buffer_check(ctx, "page", &ctx->page, uw_buffer_used(&ctx->page) + lenP);
adam@1729	3385 start += ctx->page.start - oldPage;
adam@1729	3386 memmove(start + lenP, start, uw_buffer_used(&ctx->page) - (start - ctx->page.start) + 1);
adam@1729	3387 ctx->page.front += lenP;
adam@1729	3388 memcpy(start, "<head>", 6);
adam@1729	3389 memcpy(start + 6, ctx->script_header, lenH);
adam@1729	3390 memcpy(start + 6 + lenH, "</head>", 7);
adam@1729	3391 }
adamc@916	3392 }
adamc@916	3393 }
adam@1877	3394
adam@1877	3395 if (ctx->needsResig) {
adam@1877	3396 sig = find_sig(ctx->page.start);
adam@1877	3397 if (sig) {
adam@1877	3398 char *realsig = ctx->app->cookie_sig(ctx);
adam@1877	3399
adam@1877	3400 do {
adam@1877	3401 memcpy(sig, realsig, 2*uw_hash_blocksize);
adam@1877	3402 sig = find_sig(sig);
adam@1877	3403 } while (sig);
adam@1877	3404 }
adam@1877	3405 }
adam@1938	3406
adam@1938	3407 return 0;
adamc@671	3408 }
adamc@671	3409
adamc@683	3410
adamc@1113	3411 size_t uw_transactionals_max = SIZE_MAX;
adamc@1113	3412
adamc@771	3413 void uw_register_transactional(uw_context ctx, void *data, uw_callback commit, uw_callback rollback,
adam@1327	3414 uw_callback_with_retry free) {
adamc@771	3415 if (ctx->used_transactionals >= ctx->n_transactionals) {
adamc@1113	3416 if (ctx->used_transactionals+1 > uw_transactionals_max)
adamc@1113	3417 uw_error(ctx, FATAL, "Exceeded limit on number of transactionals");
adamc@1084	3418 ctx->transactionals = realloc(ctx->transactionals, sizeof(transactional) * (ctx->used_transactionals+1));
adamc@771	3419 ++ctx->n_transactionals;
adamc@771	3420 }
adamc@771	3421
adamc@771	3422 ctx->transactionals[ctx->used_transactionals].data = data;
adamc@771	3423 ctx->transactionals[ctx->used_transactionals].commit = commit;
adamc@771	3424 ctx->transactionals[ctx->used_transactionals].rollback = rollback;
adamc@771	3425 ctx->transactionals[ctx->used_transactionals++].free = free;
adamc@771	3426 }
adamc@771	3427
adamc@683	3428
adamc@683	3429 // "Garbage collection"
adamc@683	3430
adamc@1121	3431 void uw_do_expunge(uw_context ctx, uw_Basis_client cli, void *data);
adamc@1121	3432 void uw_post_expunge(uw_context ctx, void *data);
adamc@1121	3433
adamc@1121	3434 static failure_kind uw_expunge(uw_context ctx, uw_Basis_client cli, void *data) {
adamc@683	3435 int r = setjmp(ctx->jmp_buf);
adamc@683	3436
adamc@1121	3437 if (r == 0)
adamc@1121	3438 uw_do_expunge(ctx, cli, data);
adamc@1121	3439 else
adamc@1121	3440 ctx->app->db_rollback(ctx);
adamc@1121	3441
adamc@1121	3442 uw_post_expunge(ctx, data);
adamc@683	3443
adamc@683	3444 return r;
adamc@683	3445 }
adamc@683	3446
adamc@683	3447 void uw_prune_clients(uw_context ctx) {
adamc@683	3448 client c, next, *prev = NULL;
adamc@683	3449 time_t cutoff;
adamc@683	3450
adamc@1094	3451 cutoff = time(NULL) - ctx->app->timeout;
adamc@683	3452
adamc@683	3453 pthread_mutex_lock(&clients_mutex);
adam@1707	3454 pruning_thread = pthread_self();
adam@1707	3455 pruning_thread_initialized = 1;
adamc@683	3456
adamc@683	3457 for (c = clients_used; c; c = next) {
adamc@683	3458 next = c->next;
adamc@683	3459 pthread_mutex_lock(&c->lock);
adamc@685	3460 if (c->last_contact < cutoff && c->refcount == 0) {
adamc@683	3461 failure_kind fk = UNLIMITED_RETRY;
adamc@683	3462 if (prev)
adamc@683	3463 prev->next = next;
adamc@683	3464 else
adamc@683	3465 clients_used = next;
adamc@683	3466 while (fk == UNLIMITED_RETRY) {
adam@1941	3467 uw_reset(ctx);
adamc@1121	3468 fk = uw_expunge(ctx, c->id, c->data);
adamc@1121	3469 if (fk == UNLIMITED_RETRY)
adamc@684	3470 printf("Unlimited retry during expunge: %s\n", uw_error_message(ctx));
adamc@683	3471 }
adamc@684	3472 if (fk == SUCCESS)
adamc@684	3473 free_client(c);
adamc@1121	3474 else
adamc@856	3475 fprintf(stderr, "Expunge blocked by error: %s\n", uw_error_message(ctx));
adamc@683	3476 }
adamc@683	3477 else
adamc@683	3478 prev = c;
adamc@683	3479 pthread_mutex_unlock(&c->lock);
adamc@683	3480 }
adamc@683	3481
adamc@683	3482 pthread_mutex_unlock(&clients_mutex);
adamc@683	3483 }
adamc@687	3484
adamc@687	3485 failure_kind uw_initialize(uw_context ctx) {
adamc@687	3486 int r = setjmp(ctx->jmp_buf);
adamc@687	3487
adamc@687	3488 if (r == 0) {
adam@1936	3489 uw_ensure_transaction(ctx);
adamc@1094	3490 ctx->app->initializer(ctx);
adamc@1094	3491 if (ctx->app->db_commit(ctx))
adamc@687	3492 uw_error(ctx, FATAL, "Error running SQL COMMIT");
adamc@687	3493 }
adamc@687	3494
adamc@687	3495 return r;
adamc@687	3496 }
adamc@717	3497
adamc@1065	3498 static int url_bad(uw_Basis_string s) {
adamc@1065	3499 for (; *s; ++s)
adamc@1153	3500 if (!isgraph((int)*s))
adamc@1065	3501 return 1;
adamc@1065	3502
adamc@1065	3503 return 0;
adamc@1065	3504 }
adamc@1065	3505
adamc@717	3506 uw_Basis_string uw_Basis_bless(uw_context ctx, uw_Basis_string s) {
adamc@1065	3507 if (url_bad(s))
adamc@1065	3508 uw_error(ctx, FATAL, "Invalid URL %s", uw_Basis_htmlifyString(ctx, s));
adamc@1094	3509 if (ctx->app->check_url(s))
adamc@770	3510 return s;
adamc@770	3511 else
adamc@770	3512 uw_error(ctx, FATAL, "Disallowed URL %s", uw_Basis_htmlifyString(ctx, s));
adamc@717	3513 }
adamc@734	3514
adamc@770	3515 uw_Basis_string uw_Basis_checkUrl(uw_context ctx, uw_Basis_string s) {
adamc@1065	3516 if (url_bad(s))
adamc@1065	3517 return NULL;
adamc@1094	3518 if (ctx->app->check_url(s))
adamc@770	3519 return s;
adamc@770	3520 else
adamc@770	3521 return NULL;
adamc@770	3522 }
adamc@770	3523
adam@1465	3524 static int mime_format(const char *s) {
adamc@770	3525 for (; *s; ++s)
adamc@1153	3526 if (!isalnum((int)s) && s != '/' && s != '-' && s != '.')
adamc@770	3527 return 0;
adamc@770	3528
adamc@770	3529 return 1;
adamc@770	3530 }
adamc@770	3531
adamc@741	3532 uw_Basis_string uw_Basis_blessMime(uw_context ctx, uw_Basis_string s) {
adamc@770	3533 if (!mime_format(s))
adamc@770	3534 uw_error(ctx, FATAL, "MIME type \"%s\" contains invalid character", uw_Basis_htmlifyString(ctx, s));
adamc@770	3535
adamc@1094	3536 if (ctx->app->check_mime(s))
adamc@770	3537 return s;
adamc@770	3538 else
adamc@770	3539 uw_error(ctx, FATAL, "Disallowed MIME type %s", uw_Basis_htmlifyString(ctx, s));
adamc@770	3540 }
adamc@770	3541
adamc@770	3542 uw_Basis_string uw_Basis_checkMime(uw_context ctx, uw_Basis_string s) {
adamc@770	3543 if (!mime_format(s))
adamc@770	3544 return NULL;
adamc@770	3545
adamc@1094	3546 if (ctx->app->check_mime(s))
adamc@770	3547 return s;
adamc@770	3548 else
adamc@770	3549 return NULL;
adamc@741	3550 }
adamc@741	3551
adam@1465	3552 uw_Basis_string uw_Basis_blessRequestHeader(uw_context ctx, uw_Basis_string s) {
adam@1465	3553 if (!mime_format(s))
adam@1465	3554 uw_error(ctx, FATAL, "Request header \"%s\" contains invalid character", uw_Basis_htmlifyString(ctx, s));
adam@1465	3555
adam@1465	3556 if (ctx->app->check_requestHeader(s))
adam@1465	3557 return s;
adam@1465	3558 else
adam@1465	3559 uw_error(ctx, FATAL, "Disallowed request header %s", uw_Basis_htmlifyString(ctx, s));
adam@1465	3560 }
adam@1465	3561
adam@1465	3562 uw_Basis_string uw_Basis_checkRequestHeader(uw_context ctx, uw_Basis_string s) {
adam@1465	3563 if (!mime_format(s))
adam@1465	3564 return NULL;
adam@1465	3565
adam@1465	3566 if (ctx->app->check_requestHeader(s))
adam@1465	3567 return s;
adam@1465	3568 else
adam@1465	3569 return NULL;
adam@1465	3570 }
adam@1465	3571
adam@1465	3572 uw_Basis_string uw_Basis_blessResponseHeader(uw_context ctx, uw_Basis_string s) {
adam@1465	3573 if (!mime_format(s))
adam@1465	3574 uw_error(ctx, FATAL, "Response header \"%s\" contains invalid character", uw_Basis_htmlifyString(ctx, s));
adam@1465	3575
adam@1465	3576 if (ctx->app->check_responseHeader(s))
adam@1465	3577 return s;
adam@1465	3578 else
adam@1465	3579 uw_error(ctx, FATAL, "Disallowed response header %s", uw_Basis_htmlifyString(ctx, s));
adam@1465	3580 }
adam@1465	3581
adam@1799	3582 static int envVar_format(const char *s) {
adam@1799	3583 for (; *s; ++s)
adam@1799	3584 if (!isalnum((int)s) && s != '_' && *s != '.')
adam@1799	3585 return 0;
adam@1799	3586
adam@1799	3587 return 1;
adam@1799	3588 }
adam@1799	3589
adam@1465	3590 uw_Basis_string uw_Basis_checkResponseHeader(uw_context ctx, uw_Basis_string s) {
adam@1799	3591 if (!envVar_format(s))
adam@1465	3592 return NULL;
adam@1465	3593
adam@1465	3594 if (ctx->app->check_responseHeader(s))
adam@1465	3595 return s;
adam@1465	3596 else
adam@1465	3597 return NULL;
adam@1465	3598 }
adam@1465	3599
adam@1799	3600 uw_Basis_string uw_Basis_blessEnvVar(uw_context ctx, uw_Basis_string s) {
adam@1799	3601 if (!envVar_format(s))
adam@1799	3602 uw_error(ctx, FATAL, "Environment variable \"%s\" contains invalid character", uw_Basis_htmlifyString(ctx, s));
adam@1799	3603
adam@1799	3604 if (ctx->app->check_envVar(s))
adam@1799	3605 return s;
adam@1799	3606 else
adam@1799	3607 uw_error(ctx, FATAL, "Disallowed environment variable %s", uw_Basis_htmlifyString(ctx, s));
adam@1799	3608 }
adam@1799	3609
adam@1799	3610 uw_Basis_string uw_Basis_checkEnvVar(uw_context ctx, uw_Basis_string s) {
adam@1799	3611 if (!mime_format(s))
adam@1799	3612 return NULL;
adam@1799	3613
adam@1799	3614 if (ctx->app->check_envVar(s))
adam@1799	3615 return s;
adam@1799	3616 else
adam@1799	3617 return NULL;
adam@1799	3618 }
adam@1799	3619
adam@1465	3620 uw_Basis_string uw_Basis_getHeader(uw_context ctx, uw_Basis_string name) {
adam@1465	3621 return uw_Basis_requestHeader(ctx, name);
adam@1465	3622 }
adam@1465	3623
adam@1465	3624 static int mime_value_format(const char *s) {
adam@1465	3625 for (; *s; ++s)
adam@1465	3626 if (s == '\r' \|\| s == '\n')
adam@1465	3627 return 0;
adam@1465	3628
adam@1465	3629 return 1;
adam@1465	3630 }
adam@1465	3631
adam@1465	3632 uw_unit uw_Basis_setHeader(uw_context ctx, uw_Basis_string name, uw_Basis_string value) {
adam@1465	3633 if (!mime_value_format(value))
adam@1465	3634 uw_error(ctx, FATAL, "Invalid value for HTTP response header");
adam@1465	3635
adam@1465	3636 uw_write_header(ctx, name);
adam@1465	3637 uw_write_header(ctx, ": ");
adam@1465	3638 uw_write_header(ctx, value);
adam@1465	3639 uw_write_header(ctx, "\r\n");
adam@1465	3640
adam@1465	3641 return uw_unit_v;
adam@1465	3642 }
adam@1465	3643
adam@1799	3644 uw_Basis_string uw_Basis_getenv(uw_context ctx, uw_Basis_string name) {
adam@1799	3645 return ctx->get_env(ctx->get_env_data, name);
adam@1799	3646 }
adam@1799	3647
adamc@734	3648 uw_Basis_string uw_unnull(uw_Basis_string s) {
adamc@734	3649 return s ? s : "";
adamc@734	3650 }
adamc@734	3651
adamc@734	3652 uw_Basis_string uw_Basis_makeSigString(uw_context ctx, uw_Basis_string sig) {
adamc@734	3653 uw_Basis_string r = uw_malloc(ctx, 2 * uw_hash_blocksize + 1);
adamc@734	3654 int i;
adamc@734	3655
adamc@734	3656 for (i = 0; i < uw_hash_blocksize; ++i)
adamc@734	3657 sprintf(&r[2i], "%.02X", ((unsigned char )sig)[i]);
adamc@734	3658
adamc@734	3659 return r;
adamc@734	3660 }
adamc@734	3661
adam@1512	3662 /* This bit of crafty code is intended to prevent GCC from performing
adam@1512	3663 * optimizations that would enable timing attacks. See:
adam@1512	3664 * http://www.impredicative.com/pipermail/ur/2011-July/000659.html
adam@1512	3665 */
adam@1512	3666 int uw_streq(uw_Basis_string s1, uw_Basis_string s2) {
adam@1512	3667 int i, x = 0, len1 = strlen(s1);
adam@1512	3668
adam@1512	3669 if (len1 != strlen(s2)) return 0;
adam@1512	3670
adam@1512	3671 for (i = 0; i < len1; ++i) {
adam@1512	3672 __asm__ __volatile__ ("");
adam@1512	3673 x \|= s1[i] ^ s2[i];
adam@1512	3674 }
adam@1512	3675
adam@1512	3676 return x == 0;
adam@1512	3677 }
adam@1512	3678
adamc@734	3679 uw_Basis_string uw_Basis_sigString(uw_context ctx, uw_unit u) {
adam@1877	3680 ctx->usedSig = 1;
adamc@1094	3681 return ctx->app->cookie_sig(ctx);
adamc@734	3682 }
adamc@737	3683
adamc@737	3684 uw_Basis_string uw_Basis_fileName(uw_context ctx, uw_Basis_file f) {
adamc@737	3685 return f.name;
adamc@737	3686 }
adamc@737	3687
adamc@740	3688 uw_Basis_string uw_Basis_fileMimeType(uw_context ctx, uw_Basis_file f) {
adamc@740	3689 return f.type;
adamc@740	3690 }
adamc@740	3691
adamc@745	3692 uw_Basis_int uw_Basis_blobSize(uw_context ctx, uw_Basis_blob b) {
adamc@745	3693 return b.size;
adamc@745	3694 }
adamc@745	3695
adamc@1119	3696 uw_Basis_blob uw_Basis_textBlob(uw_context ctx, uw_Basis_string s) {
adamc@1119	3697 uw_Basis_blob b = {strlen(s), s};
adamc@1119	3698
adamc@1119	3699 return b;
adamc@1119	3700 }
adamc@1119	3701
adamc@737	3702 uw_Basis_blob uw_Basis_fileData(uw_context ctx, uw_Basis_file f) {
adamc@737	3703 return f.data;
adamc@737	3704 }
adamc@741	3705
adam@1347	3706 uw_Basis_string uw_Basis_postType(uw_context ctx, uw_Basis_postBody pb) {
adam@1347	3707 return pb.type;
adam@1347	3708 }
adam@1347	3709
adam@1347	3710 uw_Basis_string uw_Basis_postData(uw_context ctx, uw_Basis_postBody pb) {
adam@1347	3711 return pb.data;
adam@1347	3712 }
adam@1347	3713
adam@1471	3714 static char *old_headers(uw_context ctx) {
adam@1471	3715 if (uw_buffer_used(&ctx->outHeaders) == 0)
adam@1471	3716 return NULL;
adam@1471	3717 else {
adam@1471	3718 char *s = strchr(ctx->outHeaders.start, '\n');
adam@1471	3719
adam@1471	3720 if (s == NULL \|\| strncasecmp(s+1, "Content-type: ", 14))
adam@1471	3721 return NULL;
adam@1471	3722 else {
adam@1471	3723 s = strchr(s+15, '\n');
adam@1471	3724 if (s == NULL)
adam@1471	3725 return NULL;
adam@1471	3726 else
adam@1471	3727 return uw_strdup(ctx, s+1);
adam@1471	3728 }
adam@1471	3729 }
adam@1471	3730 }
adam@1471	3731
adamc@741	3732 __attribute__((noreturn)) void uw_return_blob(uw_context ctx, uw_Basis_blob b, uw_Basis_string mimeType) {
adamc@741	3733 cleanup *cl;
adamc@741	3734 int len;
adam@1471	3735 char *oldh;
adamc@741	3736
adam@1451	3737 if (!ctx->allowed_to_return_indirectly)
adam@1451	3738 uw_error(ctx, FATAL, "Tried to return a blob from an RPC");
adam@1451	3739
adamc@1065	3740 ctx->returning_indirectly = 1;
adam@1471	3741 oldh = old_headers(ctx);
adam@1369	3742 uw_buffer_reset(&ctx->outHeaders);
adam@1369	3743 uw_buffer_reset(&ctx->page);
adamc@741	3744
adamc@856	3745 uw_write_header(ctx, on_success);
adamc@856	3746 uw_write_header(ctx, "Content-Type: ");
adamc@741	3747 uw_write_header(ctx, mimeType);
adam@1934	3748 uw_write_header(ctx, "\r\nContent-length: ");
adam@1369	3749 ctx_uw_buffer_check(ctx, "headers", &ctx->outHeaders, INTS_MAX);
adamc@1134	3750 sprintf(ctx->outHeaders.front, "%lu%n", (unsigned long)b.size, &len);
adamc@741	3751 ctx->outHeaders.front += len;
adamc@1066	3752 uw_write_header(ctx, "\r\n");
adam@1471	3753 if (oldh) uw_write_header(ctx, oldh);
adamc@741	3754
adam@1369	3755 ctx_uw_buffer_append(ctx, "page", &ctx->page, b.data, b.size);
adamc@741	3756
adamc@741	3757 for (cl = ctx->cleanup; cl < ctx->cleanup_front; ++cl)
adamc@741	3758 cl->func(cl->arg);
adamc@741	3759
adamc@741	3760 ctx->cleanup_front = ctx->cleanup;
adamc@741	3761
adamc@1065	3762 longjmp(ctx->jmp_buf, RETURN_INDIRECTLY);
adamc@1065	3763 }
adamc@1065	3764
adam@1932	3765 __attribute__((noreturn)) void uw_return_blob_from_page(uw_context ctx, uw_Basis_string mimeType) {
adam@1932	3766 cleanup *cl;
adam@1932	3767 int len;
adam@1932	3768 char *oldh;
adam@1932	3769
adam@1932	3770 if (!ctx->allowed_to_return_indirectly)
adam@1932	3771 uw_error(ctx, FATAL, "Tried to return a blob from an RPC");
adam@1932	3772
adam@1932	3773 ctx->returning_indirectly = 1;
adam@1932	3774 oldh = old_headers(ctx);
adam@1932	3775 uw_buffer_reset(&ctx->outHeaders);
adam@1932	3776
adam@1932	3777 uw_write_header(ctx, on_success);
adam@1932	3778 uw_write_header(ctx, "Content-Type: ");
adam@1932	3779 uw_write_header(ctx, mimeType);
adam@1934	3780 uw_write_header(ctx, "\r\nContent-length: ");
adam@1932	3781 ctx_uw_buffer_check(ctx, "headers", &ctx->outHeaders, INTS_MAX);
adam@1932	3782 sprintf(ctx->outHeaders.front, "%lu%n", (unsigned long)uw_buffer_used(&ctx->page), &len);
adam@1932	3783 ctx->outHeaders.front += len;
adam@1932	3784 uw_write_header(ctx, "\r\n");
adam@1932	3785 if (oldh) uw_write_header(ctx, oldh);
adam@1932	3786
adam@1932	3787 for (cl = ctx->cleanup; cl < ctx->cleanup_front; ++cl)
adam@1932	3788 cl->func(cl->arg);
adam@1932	3789
adam@1932	3790 ctx->cleanup_front = ctx->cleanup;
adam@1932	3791
adam@1932	3792 longjmp(ctx->jmp_buf, RETURN_INDIRECTLY);
adam@1932	3793 }
adam@1932	3794
adamc@1065	3795 __attribute__((noreturn)) void uw_redirect(uw_context ctx, uw_Basis_string url) {
adamc@1065	3796 cleanup *cl;
adamc@1066	3797 char *s;
adam@1471	3798 char *oldh;
adamc@1065	3799
adam@1451	3800 if (!ctx->allowed_to_return_indirectly)
adam@1451	3801 uw_error(ctx, FATAL, "Tried to redirect from an RPC");
adam@1451	3802
adamc@1065	3803 ctx->returning_indirectly = 1;
adam@1471	3804 oldh = old_headers(ctx);
adam@1369	3805 uw_buffer_reset(&ctx->page);
adam@1369	3806 ctx_uw_buffer_check(ctx, "page", &ctx->page, uw_buffer_used(&ctx->outHeaders)+1);
adam@1369	3807 memcpy(ctx->page.start, ctx->outHeaders.start, uw_buffer_used(&ctx->outHeaders));
adam@1369	3808 ctx->page.start[uw_buffer_used(&ctx->outHeaders)] = 0;
adam@1369	3809 uw_buffer_reset(&ctx->outHeaders);
adamc@1065	3810
adam@1409	3811 if (on_success[0])
adam@1409	3812 uw_write_header(ctx, on_redirect);
adam@1409	3813 else
adam@1409	3814 uw_write_header(ctx, "Status: 303 See Other\r\n");
adam@1409	3815 s = on_success[0] ? strchr(ctx->page.start, '\n') : ctx->page.start;
adamc@1066	3816 if (s) {
adamc@1066	3817 char *s2;
adam@1409	3818 if (s[0] == '\n') ++s;
adam@1409	3819 for (; (s2 = strchr(s, '\n')); s = s2+1) {
adamc@1066	3820 *s2 = 0;
adamc@1066	3821 if (!strncmp(s, "Set-Cookie: ", 12)) {
adamc@1066	3822 uw_write_header(ctx, s);
adamc@1066	3823 uw_write_header(ctx, "\n");
adamc@1066	3824 }
adamc@1066	3825 }
adamc@1066	3826 }
adamc@1066	3827
adamc@1065	3828 uw_write_header(ctx, "Location: ");
adamc@1065	3829 uw_write_header(ctx, url);
adamc@1065	3830 uw_write_header(ctx, "\r\n\r\n");
adam@1471	3831 if (oldh) uw_write_header(ctx, oldh);
adamc@1065	3832
adamc@1065	3833 for (cl = ctx->cleanup; cl < ctx->cleanup_front; ++cl)
adamc@1065	3834 cl->func(cl->arg);
adamc@1065	3835
adamc@1065	3836 ctx->cleanup_front = ctx->cleanup;
adamc@1065	3837
adamc@1065	3838 longjmp(ctx->jmp_buf, RETURN_INDIRECTLY);
adamc@741	3839 }
adamc@874	3840
adamc@874	3841 uw_Basis_string uw_Basis_unAs(uw_context ctx, uw_Basis_string s) {
adam@1467	3842 uw_Basis_string ret = uw_malloc(ctx, strlen(s) + 1), r = ret;
adamc@874	3843
adamc@874	3844 for (; *s; ++s) {
adamc@874	3845 if (s[0] == '\'') {
adamc@874	3846 *r++ = '\'';
adamc@874	3847 for (++s; *s; ++s) {
adamc@874	3848 if (s[0] == '\'') {
adamc@874	3849 *r++ = '\'';
adamc@874	3850 break;
adamc@874	3851 } else if (s[0] == '\\') {
adam@1467	3852 *r++ = '\\';
adam@1467	3853 *r++ = s[1];
adam@1467	3854 ++s;
adamc@874	3855 } else
adamc@874	3856 *r++ = s[0];
adamc@874	3857 }
adamc@874	3858 if (*s == 0) break;
adam@1467	3859 } else if (s[0] == 'T' && s[1] == '_' && s[2] == 'T' && s[3] == '.')
adam@1467	3860 s += 3;
adamc@874	3861 else
adamc@874	3862 *r++ = s[0];
adamc@874	3863 }
adamc@874	3864
adam@1467	3865 *r = 0;
adam@1467	3866 return ret;
adamc@874	3867 }
adamc@874	3868
adamc@922	3869 uw_Basis_string uw_Basis_mstrcat(uw_context ctx, ...) {
adamc@922	3870 va_list ap;
adamc@922	3871 size_t len = 1;
adamc@922	3872 char s, r, *s2;
adamc@922	3873
adamc@922	3874 va_start(ap, ctx);
adamc@922	3875 for (s = va_arg(ap, char); s; s = va_arg(ap, char))
adamc@922	3876 len += strlen(s);
adamc@922	3877 va_end(ap);
adamc@922	3878
adamc@922	3879 r = uw_malloc(ctx, len);
adamc@922	3880 va_start(ap, ctx);
adamc@922	3881 for (s2 = r, s = va_arg(ap, char); s; s = va_arg(ap, char))
adamc@922	3882 while (*s)
adamc@922	3883 s2++ = s++;
adamc@922	3884 va_end(ap);
adamc@922	3885 *s2 = 0;
adamc@922	3886
adamc@922	3887 return r;
adamc@922	3888 }
adamc@1006	3889
adam@1365	3890 const uw_Basis_time uw_Basis_minTime = {};
adamc@1050	3891
adamc@1006	3892 uw_Basis_time uw_Basis_now(uw_context ctx) {
adam@1365	3893 uw_Basis_time r = { time(NULL) };
adam@1365	3894 return r;
adamc@1006	3895 }
adamc@1061	3896
adam@1369	3897 uw_Basis_time uw_Basis_addSeconds(uw_context ctx, uw_Basis_time tm, uw_Basis_int n) {
adam@1369	3898 tm.seconds += n;
adam@1365	3899 return tm;
adamc@1138	3900 }
adamc@1138	3901
adam@1514	3902 uw_Basis_int uw_Basis_diffInSeconds(uw_context ctx, uw_Basis_time tm1, uw_Basis_time tm2) {
adam@1514	3903 return difftime(tm2.seconds, tm1.seconds);
adam@1514	3904 }
adam@1514	3905
adam@1685	3906 uw_Basis_int uw_Basis_toMilliseconds(uw_context ctx, uw_Basis_time tm) {
adam@1685	3907 return tm.seconds * 1000 + tm.microseconds / 1000;
adam@1685	3908 }
adam@1685	3909
adam@1685	3910 uw_Basis_int uw_Basis_diffInMilliseconds(uw_context ctx, uw_Basis_time tm1, uw_Basis_time tm2) {
adam@1685	3911 return uw_Basis_toMilliseconds(ctx, tm2) - uw_Basis_toMilliseconds(ctx, tm1);
adam@1685	3912 }
adam@1685	3913
adam@1514	3914 uw_Basis_int uw_Basis_toSeconds(uw_context ctx, uw_Basis_time tm) {
adam@1514	3915 return tm.seconds;
adam@1514	3916 }
adam@1514	3917
adamc@1061	3918 void uw_get_global(uw_context ctx, char name) {
adamc@1061	3919 int i;
adamc@1061	3920
adamc@1061	3921 for (i = 0; i < ctx->n_globals; ++i)
adamc@1061	3922 if (!strcmp(name, ctx->globals[i].name))
adamc@1061	3923 return ctx->globals[i].data;
adamc@1061	3924
adamc@1061	3925 return NULL;
adamc@1061	3926 }
adamc@1061	3927
adamc@1113	3928 size_t uw_globals_max = SIZE_MAX;
adamc@1113	3929
adamc@1061	3930 void uw_set_global(uw_context ctx, char name, void data, void (free)(void)) {
adamc@1061	3931 int i;
adamc@1061	3932
adamc@1061	3933 for (i = 0; i < ctx->n_globals; ++i)
adamc@1061	3934 if (!strcmp(name, ctx->globals[i].name)) {
adamc@1089	3935 if (ctx->globals[i].free)
adamc@1061	3936 ctx->globals[i].free(ctx->globals[i].data);
adamc@1061	3937 ctx->globals[i].data = data;
adamc@1061	3938 ctx->globals[i].free = free;
adamc@1061	3939 return;
adamc@1061	3940 }
adamc@1089	3941
adamc@1113	3942 if (ctx->n_globals+1 > uw_globals_max)
adamc@1113	3943 uw_error(ctx, FATAL, "Exceeded limit on number of globals");
adamc@1113	3944
adamc@1061	3945 ++ctx->n_globals;
adamc@1061	3946 ctx->globals = realloc(ctx->globals, ctx->n_globals * sizeof(global));
adamc@1061	3947 ctx->globals[ctx->n_globals-1].name = name;
adamc@1061	3948 ctx->globals[ctx->n_globals-1].data = data;
adamc@1061	3949 ctx->globals[ctx->n_globals-1].free = free;
adamc@1061	3950 }
adamc@1061	3951
adamc@1061	3952 uw_Basis_bool uw_Basis_isalnum(uw_context ctx, uw_Basis_char c) {
adamc@1153	3953 return !!isalnum((int)c);
adamc@1061	3954 }
adamc@1061	3955
adamc@1061	3956 uw_Basis_bool uw_Basis_isalpha(uw_context ctx, uw_Basis_char c) {
adamc@1153	3957 return !!isalpha((int)c);
adamc@1061	3958 }
adamc@1061	3959
adamc@1061	3960 uw_Basis_bool uw_Basis_isblank(uw_context ctx, uw_Basis_char c) {
adamc@1153	3961 return !!isblank((int)c);
adamc@1061	3962 }
adamc@1061	3963
adamc@1061	3964 uw_Basis_bool uw_Basis_iscntrl(uw_context ctx, uw_Basis_char c) {
adamc@1153	3965 return !!iscntrl((int)c);
adamc@1061	3966 }
adamc@1061	3967
adamc@1061	3968 uw_Basis_bool uw_Basis_isdigit(uw_context ctx, uw_Basis_char c) {
adamc@1153	3969 return !!isdigit((int)c);
adamc@1061	3970 }
adamc@1061	3971
adamc@1061	3972 uw_Basis_bool uw_Basis_isgraph(uw_context ctx, uw_Basis_char c) {
adamc@1153	3973 return !!isgraph((int)c);
adamc@1061	3974 }
adamc@1061	3975
adamc@1061	3976 uw_Basis_bool uw_Basis_islower(uw_context ctx, uw_Basis_char c) {
adamc@1153	3977 return !!islower((int)c);
adamc@1061	3978 }
adamc@1061	3979
adamc@1061	3980 uw_Basis_bool uw_Basis_isprint(uw_context ctx, uw_Basis_char c) {
adamc@1153	3981 return !!isprint((int)c);
adamc@1061	3982 }
adamc@1061	3983
adamc@1061	3984 uw_Basis_bool uw_Basis_ispunct(uw_context ctx, uw_Basis_char c) {
adamc@1153	3985 return !!ispunct((int)c);
adamc@1061	3986 }
adamc@1061	3987
adamc@1061	3988 uw_Basis_bool uw_Basis_isspace(uw_context ctx, uw_Basis_char c) {
adamc@1153	3989 return !!isspace((int)c);
adamc@1061	3990 }
adamc@1063	3991
adamc@1061	3992 uw_Basis_bool uw_Basis_isupper(uw_context ctx, uw_Basis_char c) {
adamc@1153	3993 return !!isupper((int)c);
adamc@1061	3994 }
adamc@1061	3995
adamc@1061	3996 uw_Basis_bool uw_Basis_isxdigit(uw_context ctx, uw_Basis_char c) {
adamc@1153	3997 return !!isxdigit((int)c);
adamc@1061	3998 }
adamc@1061	3999
adamc@1061	4000 uw_Basis_char uw_Basis_tolower(uw_context ctx, uw_Basis_char c) {
adamc@1153	4001 return tolower((int)c);
adamc@1061	4002 }
adamc@1061	4003
adamc@1061	4004 uw_Basis_char uw_Basis_toupper(uw_context ctx, uw_Basis_char c) {
adamc@1153	4005 return toupper((int)c);
adamc@1061	4006 }
adamc@1066	4007
adamc@1128	4008 uw_Basis_int uw_Basis_ord(uw_context ctx, uw_Basis_char c) {
adamc@1128	4009 return (unsigned char)c;
adamc@1128	4010 }
adamc@1128	4011
adamc@1128	4012 uw_Basis_char uw_Basis_chr(uw_context ctx, uw_Basis_int n) {
adamc@1128	4013 return n;
adamc@1128	4014 }
adamc@1128	4015
adamc@1066	4016 uw_Basis_string uw_Basis_currentUrl(uw_context ctx) {
adamc@1066	4017 return ctx->current_url;
adamc@1066	4018 }
adamc@1066	4019
adamc@1066	4020 void uw_set_currentUrl(uw_context ctx, char *s) {
adamc@1066	4021 ctx->current_url = s;
adamc@1066	4022 }
adamc@1114	4023
adamc@1114	4024 void uw_set_deadline(uw_context ctx, int n) {
adamc@1114	4025 ctx->deadline = n;
adamc@1114	4026 }
adamc@1114	4027
adamc@1114	4028 void uw_check_deadline(uw_context ctx) {
adamc@1114	4029 if (uw_time > ctx->deadline)
adamc@1114	4030 uw_error(ctx, FATAL, "Maximum running time exceeded");
adamc@1114	4031 }
adamc@1115	4032
adamc@1115	4033 size_t uw_database_max = SIZE_MAX;
adamc@1120	4034
adam@1389	4035 uw_Basis_int uw_Basis_naughtyDebug(uw_context ctx, uw_Basis_string s) {
adam@1389	4036 fprintf(stderr, "%s\n", s);
adam@1389	4037 return 0;
adam@1389	4038 }
adam@1389	4039
adamc@1120	4040 uw_Basis_unit uw_Basis_debug(uw_context ctx, uw_Basis_string s) {
adam@1334	4041 if (ctx->log_debug)
adam@1334	4042 ctx->log_debug(ctx->logger_data, "%s\n", s);
adam@1334	4043 else
adam@1334	4044 fprintf(stderr, "%s\n", s);
adamc@1120	4045 return uw_unit_v;
adamc@1120	4046 }
adamc@1250	4047
adam@1933	4048 static pthread_mutex_t rand_mutex = PTHREAD_MUTEX_INITIALIZER;
adam@1933	4049
adamc@1250	4050 uw_Basis_int uw_Basis_rand(uw_context ctx) {
adam@1486	4051 uw_Basis_int ret;
adam@1933	4052 pthread_mutex_lock(&rand_mutex);
adam@1486	4053 int r = RAND_bytes((unsigned char *)&ret, sizeof ret);
adam@1933	4054 pthread_mutex_unlock(&rand_mutex);
adam@1486	4055
adam@1486	4056 if (r)
adam@1486	4057 return abs(ret);
adam@1486	4058 else
adam@1486	4059 uw_error(ctx, FATAL, "Random number generation failed");
adamc@1250	4060 }
adam@1347	4061
adam@1347	4062 void uw_noPostBody(uw_context ctx) {
adam@1347	4063 ctx->hasPostBody = 0;
adam@1347	4064 }
adam@1347	4065
adam@1347	4066 void uw_postBody(uw_context ctx, uw_Basis_postBody pb) {
adam@1347	4067 ctx->hasPostBody = 1;
adam@1347	4068 ctx->postBody = pb;
adam@1347	4069 }
adam@1347	4070
adam@1347	4071 int uw_hasPostBody(uw_context ctx) {
adam@1347	4072 return ctx->hasPostBody;
adam@1347	4073 }
adam@1347	4074
adam@1386	4075 void uw_isPost(uw_context ctx) {
adam@1386	4076 ctx->isPost = 1;
adam@1386	4077 }
adam@1386	4078
adam@1386	4079 uw_Basis_bool uw_Basis_currentUrlHasPost(uw_context ctx) {
adam@1386	4080 return ctx->isPost;
adam@1386	4081 }
adam@1386	4082
adam@1485	4083 uw_Basis_bool uw_Basis_currentUrlHasQueryString(uw_context ctx) {
adam@1485	4084 return ctx->queryString != NULL && ctx->queryString[0] != 0;
adam@1485	4085 }
adam@1485	4086
adam@1370	4087 void uw_setQueryString(uw_context ctx, uw_Basis_string s) {
adam@1370	4088 ctx->queryString = s;
adam@1370	4089 }
adam@1370	4090
adam@1370	4091 uw_Basis_string uw_queryString(uw_context ctx) {
adam@1370	4092 return ctx->queryString;
adam@1370	4093 }
adam@1370	4094
adam@1347	4095 uw_Basis_postBody uw_getPostBody(uw_context ctx) {
adam@1347	4096 if (ctx->hasPostBody)
adam@1347	4097 return ctx->postBody;
adam@1347	4098 else
adam@1347	4099 uw_error(ctx, FATAL, "Asked for POST body when none exists");
adam@1347	4100 }
adam@1349	4101
adam@1349	4102 failure_kind uw_runCallback(uw_context ctx, void (*callback)(uw_context)) {
adam@1349	4103 int r = setjmp(ctx->jmp_buf);
adam@1349	4104
adam@1349	4105 if (r == 0) {
adam@1936	4106 uw_ensure_transaction(ctx);
adam@1418	4107
adam@1349	4108 callback(ctx);
adam@1349	4109 }
adam@1349	4110
adam@1349	4111 return r;
adam@1349	4112 }
adam@1360	4113
adam@1360	4114 uw_Basis_string uw_Basis_crypt(uw_context ctx, uw_Basis_string key, uw_Basis_string salt) {
adam@1397	4115 char buf[14];
adam@1397	4116 return uw_strdup(ctx, DES_fcrypt(key, salt, buf));
adam@1360	4117 }
adam@1365	4118
adam@1365	4119 uw_Basis_bool uw_Basis_eq_time(uw_context ctx, uw_Basis_time t1, uw_Basis_time t2) {
adam@1365	4120 return !!(t1.seconds == t2.seconds && t1.microseconds == t2.microseconds);
adam@1365	4121 }
adam@1365	4122
adam@1365	4123 uw_Basis_bool uw_Basis_lt_time(uw_context ctx, uw_Basis_time t1, uw_Basis_time t2) {
adam@1365	4124 return !!(t1.seconds < t2.seconds \|\| t1.microseconds < t2.microseconds);
adam@1365	4125 }
adam@1365	4126
adam@1365	4127 uw_Basis_bool uw_Basis_le_time(uw_context ctx, uw_Basis_time t1, uw_Basis_time t2) {
adam@1365	4128 return !!(uw_Basis_eq_time(ctx, t1, t2) \|\| uw_Basis_lt_time(ctx, t1, t2));
adam@1365	4129 }
adam@1365	4130
adam@1372	4131 uw_Basis_time *uw_Basis_readUtc(uw_context ctx, uw_Basis_string s) {
adam@1374	4132 struct tm stm = {};
adam@1375	4133 char *end = strchr(s, 0);
adam@1449	4134 stm.tm_isdst = -1;
adam@1375	4135
adam@1632	4136 if (strptime(s, TIME_FMT_PG, &stm) == end \|\| strptime(s, TIME_FMT, &stm) == end \|\| strptime(s, TIME_FMT_JS, &stm) == end) {
adam@1373	4137 uw_Basis_time *r = uw_malloc(ctx, sizeof(uw_Basis_time));
adam@1375	4138
kkallio@1448	4139 r->seconds = timegm(&stm);
adam@1373	4140 r->microseconds = 0;
adam@1373	4141
adam@1373	4142 return r;
adam@1374	4143 }
adam@1374	4144 else
adam@1373	4145 return NULL;
adam@1372	4146 }
adam@1407	4147
adam@1407	4148 failure_kind uw_begin_onError(uw_context ctx, char *msg) {
adam@1407	4149 int r = setjmp(ctx->jmp_buf);
adam@1407	4150
adam@1407	4151 if (ctx->app->on_error) {
adam@1407	4152 if (r == 0) {
adam@1936	4153 uw_ensure_transaction(ctx);
adam@1407	4154
adam@1409	4155 uw_buffer_reset(&ctx->outHeaders);
adam@1409	4156 if (on_success[0])
adam@1409	4157 uw_write_header(ctx, "HTTP/1.1 ");
adam@1409	4158 else
adam@1409	4159 uw_write_header(ctx, "Status: ");
adam@1409	4160 uw_write_header(ctx, "500 Internal Server Error\r\n");
adam@1919	4161 uw_write_header(ctx, "Content-type: text/html\r\n");
adam@1407	4162 uw_write(ctx, begin_xhtml);
adam@1407	4163 ctx->app->on_error(ctx, msg);
adam@1407	4164 uw_write(ctx, "</html>");
adam@1407	4165 }
adam@1407	4166
adam@1407	4167 return r;
adam@1407	4168 } else
adam@1407	4169 uw_error(ctx, FATAL, "Tried to run nonexistent onError handler");
adam@1407	4170 }
adam@1451	4171
adam@1451	4172 void uw_mayReturnIndirectly(uw_context ctx) {
adam@1451	4173 ctx->allowed_to_return_indirectly = 1;
adam@1451	4174 }
adam@1483	4175
adam@1556	4176 uw_Basis_string uw_Basis_fresh(uw_context ctx) {
adam@1703	4177 int len;
adam@1703	4178 char *r;
adam@1703	4179
adam@1703	4180 uw_check_heap(ctx, 2+INTS_MAX);
adam@1703	4181 r = ctx->heap.front;
adam@1703	4182 sprintf(r, "uw%u%n", ctx->nextId++, &len);
adam@1703	4183 ctx->heap.front += len+1;
adam@1703	4184 return r;
adam@1556	4185 }
adam@1571	4186
adam@1571	4187 uw_Basis_float uw_Basis_floatFromInt(uw_context ctx, uw_Basis_int n) {
adam@1571	4188 return n;
adam@1571	4189 }
adam@1571	4190
adam@1571	4191 uw_Basis_int uw_Basis_ceil(uw_context ctx, uw_Basis_float n) {
adam@1571	4192 return ceil(n);
adam@1571	4193 }
adam@1571	4194
adam@1571	4195 uw_Basis_int uw_Basis_trunc(uw_context ctx, uw_Basis_float n) {
adam@1571	4196 return trunc(n);
adam@1571	4197 }
adam@1571	4198
adam@1571	4199 uw_Basis_int uw_Basis_round(uw_context ctx, uw_Basis_float n) {
adam@1571	4200 return round(n);
adam@1571	4201 }
adam@1755	4202
adam@1755	4203 uw_Basis_string uw_Basis_atom(uw_context ctx, uw_Basis_string s) {
adam@1755	4204 char *p;
adam@1755	4205
adam@1755	4206 for (p = s; *p; ++p) {
adam@1755	4207 char c = *p;
adam@1801	4208 if (!isalnum((int)c) && c != '+' && c != '-' && c != '.' && c != '%' && c != '#')
adam@1755	4209 uw_error(ctx, FATAL, "Disallowed character in CSS atom");
adam@1755	4210 }
adam@1755	4211
adam@1755	4212 return s;
adam@1755	4213 }
adam@1755	4214
adam@1755	4215 uw_Basis_string uw_Basis_css_url(uw_context ctx, uw_Basis_string s) {
adam@1755	4216 char *p;
adam@1755	4217
adam@1755	4218 for (p = s; *p; ++p) {
adam@1755	4219 char c = *p;
adam@1801	4220 if (!isalnum((int)c) && c != ':' && c != '/' && c != '.' && c != '_' && c != '+'
adam@1755	4221 && c != '-' && c != '%' && c != '?' && c != '&' && c != '=' && c != '#')
adam@1755	4222 uw_error(ctx, FATAL, "Disallowed character in CSS URL");
adam@1755	4223 }
adam@1755	4224
adam@1755	4225 return s;
adam@1755	4226 }
adam@1755	4227
adam@1755	4228 uw_Basis_string uw_Basis_property(uw_context ctx, uw_Basis_string s) {
adam@1755	4229 char *p;
adam@1755	4230
adam@1755	4231 if (!*s)
adam@1755	4232 uw_error(ctx, FATAL, "Empty CSS property");
adam@1755	4233
adam@1801	4234 if (!islower((int)s[0]) && s[0] != '_')
adam@1755	4235 uw_error(ctx, FATAL, "Bad initial character in CSS property");
adam@1755	4236
adam@1755	4237 for (p = s; *p; ++p) {
adam@1755	4238 char c = *p;
adam@1801	4239 if (!islower((int)c) && !isdigit((int)c) && c != '_' && c != '-')
adam@1755	4240 uw_error(ctx, FATAL, "Disallowed character in CSS property");
adam@1755	4241 }
adam@1755	4242
adam@1755	4243 return s;
adam@1755	4244 }
adam@1787	4245
adam@1787	4246 uw_Basis_string uw_Basis_fieldName(uw_context ctx, uw_Basis_postField f) {
adam@1787	4247 return f.name;
adam@1787	4248 }
adam@1787	4249
adam@1787	4250 uw_Basis_string uw_Basis_fieldValue(uw_context ctx, uw_Basis_postField f) {
adam@1787	4251 return f.value;
adam@1787	4252 }
adam@1787	4253
adam@1787	4254 uw_Basis_string uw_Basis_remainingFields(uw_context ctx, uw_Basis_postField f) {
adam@1787	4255 return f.remaining;
adam@1787	4256 }
adam@1787	4257
adam@1787	4258 uw_Basis_postField *uw_Basis_firstFormField(uw_context ctx, uw_Basis_string s) {
adam@1788	4259 char *unurl;
adam@1787	4260 uw_Basis_postField *f;
adam@1787	4261
adam@1788	4262 if (!ctx->hasPostBody)
adam@1788	4263 uw_error(ctx, FATAL, "firstFormField called when there is no POST body");
adam@1788	4264
adam@1788	4265 if (s < ctx->postBody.data \|\| s >= ctx->postBody.data + ctx->postBody.len)
adam@1787	4266 return NULL;
adam@1787	4267
adam@1787	4268 f = uw_malloc(ctx, sizeof(uw_Basis_postField));
adam@1788	4269 unurl = s;
adam@1787	4270 f->name = uw_Basis_unurlifyString(ctx, &unurl);
adam@1788	4271 s = strchr(s, 0);
adam@1788	4272 if (!s)
adam@1788	4273 uw_error(ctx, FATAL, "firstFormField: Missing null terminator");
adam@1788	4274 ++s;
adam@1788	4275 unurl = s;
adam@1788	4276 f->value = uw_Basis_unurlifyString(ctx, &unurl);
adam@1788	4277 s = strchr(s, 0);
adam@1788	4278 if (!s)
adam@1788	4279 uw_error(ctx, FATAL, "firstFormField: Missing null terminator");
adam@1788	4280 f->remaining = s+1;
adam@1787	4281
adam@1787	4282 return f;
adam@1787	4283 }

Mercurial > urweb

annotate src/c/urweb.c @ 1942:a671e5258a2c