simple-discuss/src/main.c

#include "printf.h"
#include "string_buffer.h"
#include "utils.h"
#include "comment.h"
#include "cgic.h"
#include "driver.h"
#include "drivers/unix_fs/unix_fs_driver.h"

#include <stdlib.h>
#include <time.h>

#define COMMENTS_PER_PAGE 20
#define MAX_NAME 1024
#define MAX_COMMENT_SIZE 4096

#define QMENTS_PATH "qments-storage"
#define DRIVER_DATA { QMENTS_PATH }
#define DRIVER unix_fs_driver

int
page_by_id(int id)
{
    return id / COMMENTS_PER_PAGE + 1;
}

void
fct_callback(char character, void *arg)
{
    sb_add_char((StringBuffer*) arg, character);
}

char *
render_comment(const Comment *comment)
{
    StringBuffer _buffer, *buffer;
    char *retval;
    int rid;
    
    buffer = &_buffer;
    sb_init_empty(buffer);

    fctprintf(fct_callback, buffer, "<div class=\"comment\" id=\"comment_%d\">\n", comment->id);
    
    /* begin header */
    fctprintf(fct_callback, buffer, "<div class=\"comment-header\">\n");
    fctprintf(fct_callback, buffer, "Posted by: %s\n", comment->header->user_displayname);

    rid = comment->header->reply_id;
    if (rid > 0) {
        fctprintf(fct_callback, buffer, "<a href=\"?page=%d#comment_%d\"> in reply to </a>", page_by_id(rid), rid);
    }

    fctprintf(fct_callback, buffer, "</div>\n");
    /* end header */

    fctprintf(fct_callback, buffer, "%s", comment->text);

    fctprintf(fct_callback, buffer, "</div>\n");

    SB_MOVE(buffer, retval);

    return retval;
}

void
allocate_header(CommentHeader *header)
{
    header->user_sid = malloc(MAX_NAME);
    header->user_displayname = malloc(MAX_NAME);
}

void
free_header(CommentHeader *header)
{
    free(header->user_sid);
    free(header->user_displayname);
}

void
allocate_comment(Comment *comment)
{
    comment->header = malloc(sizeof(CommentHeader));
    allocate_header(comment->header);
}

void
free_comment(Comment *comment)
{
    free_header(comment->header);
    free(comment->header);
    free(comment->text);
}

int
fetch_comment(int id, Driver *driver, void *driver_data, Comment *comment)
{
    int retval;
    comment->id = id;

    allocate_comment(comment);

    retval = driver->get_header(driver_data, comment->header, id);
    if (retval < 0) {
        goto defer;
    }
    comment->text = malloc(comment->header->text_length + 1);

    retval = driver->get_text(driver_data, comment->text, id);
defer:
    if (retval < 0) {
        free_comment(comment);
    }
    return retval;
}

void
print_submit_form()
{
    fputs("<form action=\"\">\n"
        "<label>Your name:</label>\n"
        "<input type=\"text\" name=\"displayname\"><br>\n"
        "<label>Leave comment: </label><br>\n"
        "<input type=\"text\" name=\"text\"><br>\n"
        "<input type=\"submit\" name=\"submit\" value=\"Submit\">\n"
    "</form>\n", cgiOut);
}

/* each page stores comments with ids in [P * (page - 1), P * page)
 * if page is not specified, then we'll just print last P comments (for now)
 * TODO: print errors in div
 * FIXME: NOW PAGING IS FAULTY, FIX IT
 */
void
print_page()
{
    int page, max_id;
    int id_begin, id_end, i;
    Comment comment;
    UnixFsDriverData driver_data = DRIVER_DATA;
    Driver driver = DRIVER;

    cgiFormInteger("page", &page, 0);
    if ((max_id = unix_fs_driver_get_max_id(&driver_data)) < 0) {
        fprintf(cgiOut, "Error fetching comments\n");
        return;
    }

    if (page <= 0) {
        id_end = max_id;
        id_begin = (max_id > COMMENTS_PER_PAGE ? max_id - COMMENTS_PER_PAGE : 1);
    } else {
        /* max_id >= COMMENTS_PER_PAGE * page
         * perform this check without overflow
         */
        if (max_id / page < COMMENTS_PER_PAGE) {
            fprintf(cgiOut, "There is no such page\n");
            return;
        }
        id_begin = COMMENTS_PER_PAGE * (page - 1);
        id_end = id_begin + COMMENTS_PER_PAGE;
        if (id_end > max_id) {
            id_end = max_id;
        }
    }

    for (i = id_begin; i != id_end; ++i) {
        if (fetch_comment(i, &driver, &driver_data, &comment) < 0) {
            fprintf(cgiOut, "Failed to fetch comment %d\n", i);
        } else {
            char *rendered_comment = render_comment(&comment);
            fputs(rendered_comment, cgiOut);
            free(rendered_comment);
            free_comment(&comment);
        }
    }
}

/* TODO: restore fields for user no to lose data */
int
handle_submitted_comment()
{
    char displayname[MAX_NAME], text[MAX_COMMENT_SIZE], *sanitized_text;
    int rid, retval;
    cgiFormResultType err;
    Driver driver = DRIVER;
    UnixFsDriverData driver_data = DRIVER_DATA;

    err = cgiFormString("text", text, MAX_COMMENT_SIZE);
    if (err == cgiFormTruncated) {
        fprintf(cgiOut, "Comment too long (max %d bytes)\n", MAX_COMMENT_SIZE);
        goto defer;
    }
    if (err == cgiFormNotFound) {
        fprintf(cgiOut, "Comment text not provided\n");
        goto defer;
    }

   err = cgiFormString("displayname", displayname, MAX_NAME);
   if (err == cgiFormTruncated) {
       fprintf(cgiOut, "Name too long (max %d bytes)\n", MAX_NAME);
       goto defer;
   }
   if (err == cgiFormNotFound) {
       fprintf(cgiOut, "Name not provided\n");
       goto defer;
   }

   if (contain_special(displayname)) {
       err = cgiFormTruncated;
       fprintf(cgiOut, "Name must not contain HTML special characters\n");
       goto defer;
   }

   cgiFormInteger("reply-to", &rid, 0);

   sanitized_text = mk_specialchars(text);

   CommentHeader header;
   time(&header.creation_time);
   header.reply_id = rid;
   header.text_length = strlen(sanitized_text);
   header.user_sid = "anonymous";
   header.user_displayname = displayname;

   if (driver.leave_comment(&driver_data, &header, sanitized_text) < 0) {
       fprintf(cgiOut, "Failed to leave your comment\n");
   } else {
       fprintf(cgiOut, "Comment successfully left\n");
   }

   free(sanitized_text);

defer:
   return (err == cgiFormSuccess ? 0 : -1);
}

int
cgiMain()
{
    cgiHeaderContentType("text/html");

    fprintf(cgiOut, "<html>\n");

    fprintf(cgiOut, "<head>\n");
    fprintf(cgiOut, "<title> Simple discuss powered by qments </title>\n");
    fprintf(cgiOut, "</head>\n");

    fprintf(cgiOut, "<body>\n");

    if (cgiFormSubmitClicked("submit") == cgiFormSuccess) {
        handle_submitted_comment();
    }
    
    print_submit_form();
    
    fprintf(cgiOut, "<div class=\"comment-section\">\n");
    print_page();
    fprintf(cgiOut, "</div>\n");

    fprintf(cgiOut, "</body>\n");

    fprintf(cgiOut, "</html>\n");

    return 0;
}