cgi/cgi_blerg.c

   1 /* Blerg is (C) 2011 The Dominion of Awesome, and is distributed under a
   2  * BSD-style license.  Please see the COPYING file for details.
   3  */
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <cgi-util.h>
   8 #include <yajl/yajl_gen.h>
   9 #include "database.h"
  10 #include "tags.h"
  11 #include "auth.h"
  12 #include "subscription.h"
  13 #include "json.h"
  14 #include "canned_responses.h"
  15 #include "app.h"
  16 #include "config.h"
  17
  18 yajl_gen_config yajl_c = { 0, 0 };
  19
  20 int check_auth(struct auth_cookie *ac) {
  21         const char *given_cookie = cgi_getcookie("auth");
  22
  23         if (parse_auth_cookie(given_cookie, ac) != 1) {
  24                 respond_403();
  25                 return 0;
  26         }
  27
  28         if (!auth_check_token(ac->name, ac->token)) {
  29                 respond_403();
  30                 return 0;
  31         }
  32         return 1;
  33 }
  34
  35 void respond_yajl(yajl_gen g) {
  36         const unsigned char *ybuf;
  37         unsigned int content_len;
  38
  39         yajl_gen_get_buf(g, &ybuf, &content_len);
  40
  41         printf("Content-type: application/json\r\n");
  42         printf("Content-length: %d\r\n\r\n", content_len);
  43         fwrite(ybuf, content_len, 1, stdout);
  44 }
  45
  46 void respond_for_range(struct blerg *b, uint64_t from, uint64_t to) {
  47         const unsigned char *ybuf;
  48         unsigned int len;
  49         uint64_t i;
  50         yajl_gen g;
  51         uint64_t record_count = blerg_get_record_count(b);
  52
  53         printf("Content-type: application/json\r\n\r\n");
  54
  55         if (from > to || from >= record_count || to >= record_count || to - from > 99) {
  56                 respond_JSON_Failure();
  57                 return;
  58         }
  59
  60         g = yajl_gen_alloc(&yajl_c, NULL);
  61         yajl_gen_array_open(g);
  62
  63         for (i = to; i != from - 1; i--) {
  64                 json_generate_one_record(g, NULL, b, i, 0);
  65                 yajl_gen_get_buf(g, &ybuf, &len);
  66                 fwrite(ybuf, len, 1, stdout);
  67                 yajl_gen_clear(g);
  68         }
  69
  70         yajl_gen_array_close(g);
  71         yajl_gen_get_buf(g, &ybuf, &len);
  72         fwrite(ybuf, len, 1, stdout);
  73         yajl_gen_free(g);
  74 }
  75
  76 void respond_blergref_list(struct blergref * results, int i) {
  77         const unsigned char *ybuf;
  78         unsigned int len;
  79         struct blerg *b;
  80         yajl_gen g;
  81
  82         i--;
  83
  84         printf("Content-type: application/json\r\n\r\n");
  85         g = yajl_gen_alloc(&yajl_c, NULL);
  86
  87         yajl_gen_array_open(g);
  88
  89         while (i >= 0) {
  90                 b = blerg_open(results[i].author);
  91                 if (b != NULL) {
  92                         json_generate_one_record(g, results[i].author, b, results[i].record, 0);
  93                         blerg_close(b);
  94                 }
  95                 yajl_gen_get_buf(g, &ybuf, &len);
  96                 fwrite(ybuf, len, 1, stdout);
  97                 yajl_gen_clear(g);
  98
  99                 i--;
 100         }
 101
 102         yajl_gen_array_close(g);
 103         yajl_gen_get_buf(g, &ybuf, &len);
 104         fwrite(ybuf, len, 1, stdout);
 105         yajl_gen_free(g);
 106 }
 107
 108 int main(int argc, char *argv[]) {
 109         char *path;
 110         char *request_method;
 111         int ret, len;
 112         struct url_info info;
 113         struct auth_cookie ac;
 114         char *data;
 115
 116         if (!blerg_init())
 117                 exit(1);
 118
 119         if (cgi_init() != CGIERR_NONE)
 120                 exit(0);
 121
 122         path = getenv("PATH_INFO");
 123         if (path == NULL) {
 124                 respond_404();
 125                 exit(0);
 126         }
 127         request_method = getenv("REQUEST_METHOD");
 128         if (request_method == NULL) {
 129                 fprintf(stderr, "Request method is null!?\n");
 130                 exit(0);
 131         }
 132
 133         if (strncmp(path, "/get", 4) == 0 && strlen(path) > 4) {
 134                 if (strncmp(request_method, "GET", 4) != 0) {
 135                         respond_405();
 136                         exit(0);
 137                 }
 138
 139                 if (path[4] != '/') {
 140                         respond_404();
 141                         exit(0);
 142                 }
 143
 144                 ret = parse_url_info(path + 5, &info);
 145                 if ((ret & URL_INFO_NAME) == 0) {
 146                         respond_404();
 147                         exit(0);
 148                 }
 149
 150                 if (!blerg_exists(info.name)) {
 151                         respond_404();
 152                         exit(0);
 153                 }
 154
 155                 struct blerg *b = blerg_open(info.name);
 156
 157                 if ((ret & URL_INFO_RECORD) && (ret & URL_INFO_RECORD_TO)) {
 158                         respond_for_range(b, info.record, info.record_to);
 159                 } else if (ret & URL_INFO_RECORD) {
 160                         ret = blerg_fetch(b, info.record, &data, &len);
 161
 162                         if (ret == 0) {
 163                                 respond_404();
 164                                 exit(0);
 165                         }
 166                         respond_simple_data(data, len);
 167                 } else {
 168                         uint64_t record_count, from, to;
 169                         record_count = blerg_get_record_count(b);
 170                         if (record_count == 0) {
 171                                 respond_simple_data("[]", 2);
 172                         } else {
 173                                 to = record_count - 1;
 174                                 from = (record_count > 50 ? to - 49 : 0);
 175                                 respond_for_range(b, from, to);
 176                         }
 177                 }
 178
 179                 blerg_close(b);
 180         } else if (strncmp(path, "/tag", 4) == 0 && strlen(path) > 4) {
 181                 if (strcmp(request_method, "GET") != 0) {
 182                         respond_405();
 183                         exit(0);
 184                 }
 185
 186                 if (path[4] != '/') {
 187                         respond_404();
 188                         exit(0);
 189                 }
 190
 191                 ret = parse_url_info(path + 5, &info);
 192                 if ((ret & URL_INFO_NAME) == 0) {
 193                         respond_404();
 194                         exit(0);
 195                 }
 196
 197                 if (info.name[0] == 'H')
 198                         info.name[0] = '#';
 199                 if (!tag_exists(info.name)) {
 200                         respond_404();
 201                         exit(0);
 202                 }
 203
 204                 int recs = 50;
 205                 struct blergref *taglist = tag_list(info.name, 0, &recs, -1);
 206
 207                 if (recs == 0) {
 208                         respond_simple_data("[]", 2);
 209                 } else {
 210                         respond_blergref_list(taglist, recs);
 211                 }
 212         } else if (strncmp(path, "/put", 4) == 0) {
 213                 if (strcmp(request_method, "POST") != 0) {
 214                         respond_405();
 215                         exit(0);
 216                 }
 217
 218                 if (!check_auth(&ac))
 219                         exit(0);
 220
 221                 if (path[4] == '/') {
 222                         respond_404();
 223                         exit(0);
 224                 }
 225
 226                 const char *data = cgi_getentrystr("data");
 227                 if (data == NULL || data[0] == 0) {
 228                         respond_JSON_Failure();
 229                         exit(0);
 230                 }
 231
 232                 struct blerg *b = blerg_open(ac.name);
 233                 if (b == NULL) {
 234                         respond_JSON_Failure();
 235                         exit(0);
 236                 }
 237                 ret = blerg_store(b, data, strlen(data));
 238                 blerg_close(b);
 239                 if (ret == -1) {
 240                         respond_JSON_Failure();
 241                         exit(0);
 242                 }
 243
 244                 respond_JSON_Success();
 245         } else if (strncmp(path, "/info", 5) == 0) {
 246                 if (strcmp(request_method, "GET") != 0) {
 247                         respond_405();
 248                         exit(0);
 249                 }
 250
 251                 if (path[5] != '/') {
 252                         respond_404();
 253                         exit(0);
 254                 }
 255
 256                 ret = parse_url_info(path + 6, &info);
 257                 if ((ret & URL_INFO_NAME) == 0) {
 258                         respond_404();
 259                         exit(0);
 260                 }
 261
 262                 if (!blerg_exists(info.name)) {
 263                         respond_404();
 264                         exit(0);
 265                 }
 266
 267                 struct blerg *b = blerg_open(info.name);
 268                 uint64_t record_count = blerg_get_record_count(b);
 269                 blerg_close(b);
 270
 271                 char number[21];
 272                 yajl_gen g = yajl_gen_alloc(&yajl_c, NULL);
 273                 yajl_gen_map_open(g);
 274                 yajl_gen_string(g, (unsigned char *)"record_count", 12);
 275                 snprintf(number, 21, "%llu", record_count);
 276                 yajl_gen_string(g, (unsigned char *)number, strlen(number));
 277                 yajl_gen_map_close(g);
 278
 279                 respond_yajl(g);
 280
 281                 yajl_gen_free(g);
 282         } else if (strncmp(path, "/create", 8) == 0) {
 283                 if (strcmp(request_method, "POST") != 0) {
 284                         respond_405();
 285                         exit(0);
 286                 }
 287
 288                 const char *username = cgi_getentrystr("username");
 289                 const char *password = cgi_getentrystr("password");
 290                 if (username == NULL || username[0] == 0 ||
 291                     password == NULL || password[0] == 0) {
 292                         respond_JSON_Failure();
 293                         exit(0);
 294                 }
 295
 296                 if (blerg_exists(username)) {
 297                         respond_JSON_Failure();
 298                         exit(0);
 299                 }
 300
 301                 struct blerg *b = blerg_open(username);
 302                 if (b != NULL) {
 303                         blerg_close(b);
 304                         auth_set_password(username, password);
 305
 306                         respond_JSON_Success();
 307                 } else {
 308                         respond_JSON_Failure();
 309                 }
 310         } else if (strncmp(path, "/login", 7) == 0) {
 311                 if (strcmp(request_method, "POST") != 0) {
 312                         respond_405();
 313                         exit(0);
 314                 }
 315
 316                 const char *username = cgi_getentrystr("username");
 317                 const char *password = cgi_getentrystr("password");
 318                 if (username == NULL || username[0] == 0 ||
 319                     password == NULL || password[0] == 0) {
 320                         respond_JSON_Failure();
 321                         exit(0);
 322                 }
 323
 324                 char *token = auth_login(username, password);
 325                 if (token == NULL) {
 326                         respond_JSON_Failure();
 327                         exit(0);
 328                 }
 329
 330                 printf("Set-Cookie: auth=%s/%s\r\n", username, token);
 331                 free(token);
 332
 333                 respond_JSON_Success();
 334         } else if (strncmp(path, "/logout", 8) == 0) {
 335                 if (strcmp(request_method, "POST") != 0) {
 336                         respond_405();
 337                         exit(0);
 338                 }
 339
 340                 if (!check_auth(&ac))
 341                         exit(0);
 342
 343                 auth_logout(ac.name, ac.token);
 344                 printf("Set-Cookie: auth=X; Expires=Thu, 01 Jan 1970 00:00:00 GMT\r\n");
 345                 respond_JSON_Success();
 346         } else if (strncmp(path, "/subscribe", 10) == 0) {
 347                 if (!check_auth(&ac))
 348                         exit(0);
 349
 350                 if (path[10] != '/') {
 351                         respond_404();
 352                         exit(0);
 353                 }
 354
 355                 ret = parse_url_info(path + 11, &info);
 356                 if ((ret & URL_INFO_NAME) == 0) {
 357                         respond_404();
 358                         exit(0);
 359                 }
 360
 361                 const char *subscribed = cgi_getentrystr("subscribed");
 362
 363                 if (strncmp(subscribed, "true", 4) == 0) {
 364                         subscription_add(ac.name, info.name);
 365                 } else if (strncmp(subscribed, "false", 5) == 0) {
 366                         subscription_remove(ac.name, info.name);
 367                 } else {
 368                         respond_JSON_Failure();
 369                         exit(0);
 370                 }
 371                 respond_JSON_Success();
 372         } else if (strncmp(path, "/feed", 6) == 0) {
 373                 if (!check_auth(&ac))
 374                         exit(0);
 375
 376                 int recs = 50;
 377                 struct blergref *feedlist = subscription_list(ac.name, 0, &recs, -1);
 378
 379                 if (recs == 0) {
 380                         respond_simple_data("[]", 2);
 381                 } else {
 382                         respond_blergref_list(feedlist, recs);
 383                 }
 384         } else if (strncmp(path, "/status", 7) == 0) {
 385                 if (!check_auth(&ac))
 386                         exit(0);
 387
 388                 if (strncmp(request_method, "POST", 4) == 0) {
 389                         const char *clear = cgi_getentrystr("clear");
 390
 391                         if (clear != NULL) {
 392                                 struct blerg *b = blerg_open(ac.name);
 393                                 if (strncmp(clear, "feed", 4) == 0) {
 394                                         blerg_set_subscription_mark(b);
 395                                 } else if (strncmp(clear, "mentioned", 9) == 0) {
 396                                         blerg_set_status(b, BLERGSTATUS_MENTIONED, 0);
 397                                 }
 398                                 blerg_close(b);
 399                                 respond_JSON_Success();
 400                         }
 401                 } else if (strncmp(request_method, "GET", 3) == 0) {
 402                         yajl_gen g;
 403
 404                         if (path[7] == 0) {  /* No username */
 405                                 g = yajl_gen_alloc(&yajl_c, NULL);
 406                                 yajl_gen_map_open(g);
 407
 408                                 struct blerg *b = blerg_open(ac.name);
 409                                 uint64_t subscription_mark = blerg_get_subscription_mark(b);
 410                                 int mentioned = blerg_get_status(b, BLERGSTATUS_MENTIONED);
 411                                 blerg_close(b);
 412
 413                                 yajl_gen_string(g, (unsigned char *)"feed_new", 8);
 414                                 yajl_gen_integer(g, subscription_count_items(ac.name) - subscription_mark);
 415
 416                                 yajl_gen_string(g, (unsigned char *)"mentioned", 9);
 417                                 yajl_gen_bool(g, mentioned);
 418
 419                                 yajl_gen_map_close(g);
 420                                 respond_yajl(g);
 421                                 yajl_gen_free(g);
 422                         } else {  /* with username */
 423                                 g = yajl_gen_alloc(&yajl_c, NULL);
 424                                 yajl_gen_map_open(g);
 425
 426                                 yajl_gen_string(g, (unsigned char *)"subscribed", 10);
 427                                 ret = parse_url_info(path + 8, &info);
 428                                 if ((ret & URL_INFO_NAME) == 1) {
 429                                         yajl_gen_bool(g, is_subscribed(ac.name, info.name));
 430                                 } else {
 431                                         yajl_gen_bool(g, 0);
 432                                 }
 433
 434                                 yajl_gen_map_close(g);
 435                                 respond_yajl(g);
 436                                 yajl_gen_free(g);
 437                         }
 438                 } else {
 439                         respond_405();
 440                         exit(0);
 441                 }
 442         } else if (strncmp(path, "/passwd", 7) == 0) {
 443                 if (!check_auth(&ac))
 444                         exit(0);
 445
 446                 const char *password = cgi_getentrystr("password");
 447                 const char *new_password = cgi_getentrystr("new_password");
 448                 if (password == NULL || new_password == NULL) {
 449                         respond_JSON_Failure();
 450                 } else {
 451                         if (auth_check_password(ac.name, password)) {
 452                                 auth_set_password(ac.name, new_password);
 453                                 respond_JSON_Success();
 454                         } else {
 455                                 respond_JSON_Failure();
 456                         }
 457                 }
 458         } else {
 459                 respond_404();
 460                 exit(0);
 461         }
 462
 463         cgi_quit();
 464
 465         return 0;
 466 }