Mercurial > urweb

annotate src/c/urweb.c @ 1726:4df4521fbd3b

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