Begin basic login/logout

[blerg.git] / http / http_blerg.c

diff --git a/http/http_blerg.c b/http/http_blerg.c
index 1d272eb..f481671 100644 (file)
--- a/http/http_blerg.c
+++ b/http/http_blerg.c
@@ -12,7 +12,7 @@
 
 yajl_gen_config yajl_c = { 0, 0 };
 
-struct create_state {
+struct auth_state {
        struct MHD_PostProcessor *pp;
        char username[33];
        char password[33];
@@ -163,17 +163,17 @@ void GET_generate_taglist_free(void *cls) {
        free(ts);
 }
 
-int POST_create_iterator(void *cls, enum MHD_ValueKind kind, const char *key, const char *filename, const char *content_type, const char *transfer_encoding, const char *data, uint64_t off, size_t size) {
-       struct create_state *cs = cls;
+int POST_auth_iterator(void *cls, enum MHD_ValueKind kind, const char *key, const char *filename, const char *content_type, const char *transfer_encoding, const char *data, uint64_t off, size_t size) {
+       struct auth_state *as = cls;
 
        if (strncmp(key, "username", 9) == 0) {
                if (size > 32) size = 32;
-               memcpy(cs->username, data, size);
-               cs->username[size] = 0;
+               memcpy(as->username, data, size);
+               as->username[size] = 0;
        } else if (strncmp(key, "password", 9) == 0) {
                if (size > 32) size = 32;
-               memcpy(cs->password, data, size);
-               cs->password[size] = 0;
+               memcpy(as->password, data, size);
+               as->password[size] = 0;
        }
 
        return MHD_YES;
@@ -435,39 +435,105 @@ ahc_derp (void *cls, struct MHD_Connection *connection, const char *url, const c
 
                return ret;
        } else if (strncmp(url, "/create", 8) == 0) {
-               struct create_state *cs = (struct create_state *) *ptr;
+               struct auth_state *as = (struct auth_state *) *ptr;
 
-               if (cs == NULL) {
+               if (as == NULL) {
                        if (strcmp(method, MHD_HTTP_METHOD_POST) != 0)
                                return respond_405(connection);
 
-                       struct create_state *cs = malloc(sizeof(struct create_state));
-                       cs->username[0] = cs->password[0] = 0;
-                       cs->pp = MHD_create_post_processor(connection, 1024, &POST_create_iterator, cs);
-                       *ptr = cs;
+                       struct auth_state *as = malloc(sizeof(struct auth_state));
+                       as->username[0] = as->password[0] = 0;
+                       as->pp = MHD_create_post_processor(connection, 1024, &POST_auth_iterator, as);
+                       *ptr = as;
                        return MHD_YES;
                }
 
                if (*upload_data_size) {
-                       MHD_post_process(cs->pp, upload_data, *upload_data_size);
+                       MHD_post_process(as->pp, upload_data, *upload_data_size);
                        *upload_data_size = 0;
                        return MHD_YES;
                }
 
-               if (cs->username[0] == 0 || cs->password[0] == 0)
+               if (as->username[0] == 0 || as->password[0] == 0)
                        return respond_JSON_Failure(connection);
 
-               if (blerg_exists(cs->username))
+               if (blerg_exists(as->username))
                        return respond_JSON_Failure(connection);
 
-               struct blerg *b = blerg_open(cs->username);
+               struct blerg *b = blerg_open(as->username);
                blerg_close(b);
-               auth_set_password(cs->username, cs->password);
+               auth_set_password(as->username, as->password);
 
-               MHD_destroy_post_processor(cs->pp);
-               free(cs);
+               MHD_destroy_post_processor(as->pp);
+               free(as);
                *ptr = NULL;
 
+               return respond_JSON_Success(connection);
+       } else if (strncmp(url, "/login", 7) == 0) {
+               struct auth_state *as = (struct auth_state *) *ptr;
+
+               if (as == NULL) {
+                       if (strcmp(method, MHD_HTTP_METHOD_POST) != 0)
+                               return respond_405(connection);
+
+                       struct auth_state *as = malloc(sizeof(struct auth_state));
+                       as->username[0] = as->password[0] = 0;
+                       as->pp = MHD_create_post_processor(connection, 1024, &POST_auth_iterator, as);
+                       *ptr = as;
+                       return MHD_YES;
+               }
+
+               if (*upload_data_size) {
+                       MHD_post_process(as->pp, upload_data, *upload_data_size);
+                       *upload_data_size = 0;
+                       return MHD_YES;
+               }
+
+               if (as->username[0] == 0 || as->password[0] == 0)
+                       return respond_JSON_Failure(connection);
+
+               if (!auth_login(as->username, as->password))
+                       return respond_JSON_Failure(connection);
+
+               response = MHD_create_response_from_data(strlen(JSON_SUCCESS), JSON_SUCCESS, MHD_NO, MHD_NO);
+
+               char *token = auth_get_token(as->username);
+               data = malloc(512);
+               snprintf(data, 512, "auth=%s", token);
+               MHD_add_response_header(response, "Set-Cookie", data);
+               free(token);
+               free(data);
+
+               MHD_destroy_post_processor(as->pp);
+               free(as);
+               *ptr = NULL;
+
+               ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
+               MHD_destroy_response(response);
+
+               return ret;
+       } else if (strncmp(url, "/logout", 8) == 0) {
+               struct auth_state *as = (struct auth_state *) *ptr;
+
+               if (as == NULL) {
+                       if (strcmp(method, MHD_HTTP_METHOD_POST) != 0)
+                               return respond_405(connection);
+
+                       struct auth_state *as = malloc(sizeof(struct auth_state));
+                       as->username[0] = as->password[0] = 0;
+                       as->pp = MHD_create_post_processor(connection, 1024, &POST_auth_iterator, as);
+                       *ptr = as;
+                       return MHD_YES;
+               }
+
+               if (*upload_data_size) {
+                       MHD_post_process(as->pp, upload_data, *upload_data_size);
+                       *upload_data_size = 0;
+                       return MHD_YES;
+               }
+
+               auth_logout(as->username);
+
                return respond_JSON_Success(connection);
        } else {
                return respond_404(connection);