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