X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fwiki%2Fserv_wiki.c;h=f18bb4a4a30c84ad45b8b52085960b59105d3813;hb=e26a8dee20d1726b4995821f717f867f50fc5659;hp=cf14f9df9aa7132d66bdaaf06c948b7c8edc10f6;hpb=7168e390493f766c54c1de7e5d1ad6a2e51c3d13;p=citadel.git diff --git a/citadel/modules/wiki/serv_wiki.c b/citadel/modules/wiki/serv_wiki.c index cf14f9df9..f18bb4a4a 100644 --- a/citadel/modules/wiki/serv_wiki.c +++ b/citadel/modules/wiki/serv_wiki.c @@ -1,23 +1,21 @@ /* - * $Id$ - * - * Server-side module for Wiki rooms. This will handle things like version control. + * Server-side module for Wiki rooms. This handles things like version control. * - * Copyright (c) 2009 by the citadel.org team + * Copyright (c) 2009-2011 by the citadel.org team * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. + * This program is open source software. You can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 3 of the + * License, or (at your option) any later version. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "sysdep.h" @@ -53,12 +51,26 @@ #include "config.h" #include "control.h" #include "user_ops.h" -#include "policy.h" #include "database.h" #include "msgbase.h" #include "euidindex.h" #include "ctdl_module.h" +/* + * Data passed back and forth between wiki_rev() and its MIME parser callback + */ +struct HistoryEraserCallBackData { + char *tempfilename; /* name of temp file being patched */ + char *stop_when; /* stop when we hit this uuid */ + int done; /* set to nonzero when we're done patching */ +}; + +/* + * Name of the temporary room we create to store old revisions when someone requests them. + * We put it in an invalid namespace so the DAP cleans up after us later. + */ +char *wwm = "9999999999.WikiWaybackMachine"; + /* * Before allowing a wiki page save to execute, we have to perform version control. * This involves fetching the old version of the page if it exists. @@ -71,6 +83,7 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { struct CtdlMessage *history_msg = NULL; char diff_old_filename[PATH_MAX]; char diff_new_filename[PATH_MAX]; + char diff_out_filename[PATH_MAX]; char diff_cmd[PATH_MAX]; FILE *fp; int rv; @@ -78,7 +91,6 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { char boundary[256]; char prefixed_boundary[258]; char buf[1024]; - int nbytes = 0; char *diffbuf = NULL; size_t diffbuf_len = 0; char *ptr = NULL; @@ -93,8 +105,9 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { /* If this isn't a MIME message, don't bother. */ if (msg->cm_format_type != 4) return(0); - /* If there's no EUID we can't do this. */ - if (msg->cm_fields['E'] == NULL) return(0); + /* If there's no EUID we can't do this. Reject the post. */ + if (msg->cm_fields['E'] == NULL) return(1); + snprintf(history_page, sizeof history_page, "%s_HISTORY_", msg->cm_fields['E']); /* Make sure we're saving a real wiki page rather than a wiki history page. @@ -103,15 +116,21 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { if ( (strlen(msg->cm_fields['E']) >= 9) && (!strcasecmp(&msg->cm_fields['E'][strlen(msg->cm_fields['E'])-9], "_HISTORY_")) ) { - CtdlLogPrintf(CTDL_DEBUG, "History page not being historied\n"); + syslog(LOG_DEBUG, "History page not being historied\n"); return(0); } /* If there's no message text, obviously this is all b0rken and shouldn't happen at all */ if (msg->cm_fields['M'] == NULL) return(0); + /* Set the message subject identical to the page name */ + if (msg->cm_fields['U'] != NULL) { + free(msg->cm_fields['U']); + } + msg->cm_fields['U'] = strdup(msg->cm_fields['E']); + /* See if we can retrieve the previous version. */ - old_msgnum = locate_message_by_euid(msg->cm_fields['E'], &CCC->room); + old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CCC->room); if (old_msgnum > 0L) { old_msg = CtdlFetchMessage(old_msgnum, 1); } @@ -135,6 +154,7 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { */ CtdlMakeTempFileName(diff_old_filename, sizeof diff_old_filename); CtdlMakeTempFileName(diff_new_filename, sizeof diff_new_filename); + CtdlMakeTempFileName(diff_out_filename, sizeof diff_out_filename); if (old_msg != NULL) { fp = fopen(diff_old_filename, "w"); @@ -147,27 +167,37 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { rv = fwrite(msg->cm_fields['M'], strlen(msg->cm_fields['M']), 1, fp); fclose(fp); - diffbuf_len = 0; - diffbuf = NULL; snprintf(diff_cmd, sizeof diff_cmd, - "diff -u %s %s", + "diff -u %s %s >%s", diff_new_filename, - ((old_msg != NULL) ? diff_old_filename : "/dev/null") + ((old_msg != NULL) ? diff_old_filename : "/dev/null"), + diff_out_filename ); - fp = popen(diff_cmd, "r"); + syslog(LOG_DEBUG, "diff cmd: %s", diff_cmd); + rv = system(diff_cmd); + syslog(LOG_DEBUG, "diff cmd returned %d", rv); + + diffbuf_len = 0; + diffbuf = NULL; + fp = fopen(diff_out_filename, "r"); + if (fp == NULL) { + fp = fopen("/dev/null", "r"); + } if (fp != NULL) { - do { - diffbuf = realloc(diffbuf, diffbuf_len + 1025); - nbytes = fread(&diffbuf[diffbuf_len], 1, 1024, fp); - diffbuf_len += nbytes; - } while (nbytes == 1024); + fseek(fp, 0L, SEEK_END); + diffbuf_len = ftell(fp); + fseek(fp, 0L, SEEK_SET); + diffbuf = malloc(diffbuf_len + 1); + fread(diffbuf, diffbuf_len, 1, fp); diffbuf[diffbuf_len] = 0; - pclose(fp); + fclose(fp); } - CtdlLogPrintf(CTDL_DEBUG, "diff length is %d bytes\n", diffbuf_len); + + syslog(LOG_DEBUG, "diff length is "SIZE_T_FMT" bytes", diffbuf_len); unlink(diff_old_filename); unlink(diff_new_filename); + unlink(diff_out_filename); /* Determine whether this was a bogus (empty) edit */ if ((diffbuf_len = 0) && (diffbuf != NULL)) { @@ -180,7 +210,7 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { /* Now look for the existing edit history */ - history_msgnum = locate_message_by_euid(history_page, &CCC->room); + history_msgnum = CtdlLocateMessageByEuid(history_page, &CCC->room); history_msg = NULL; if (history_msgnum > 0L) { history_msg = CtdlFetchMessage(history_msgnum, 1); @@ -197,6 +227,7 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { history_msg->cm_fields['R'] = strdup(CCC->room.QRname); history_msg->cm_fields['E'] = strdup(history_page); history_msg->cm_fields['U'] = strdup(history_page); + history_msg->cm_fields['1'] = strdup("1"); /* suppress full text indexing */ snprintf(boundary, sizeof boundary, "Citadel--Multipart--%04x--%08lx", getpid(), time(NULL)); history_msg->cm_fields['M'] = malloc(1024); snprintf(history_msg->cm_fields['M'], 1024, @@ -212,7 +243,15 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { /* Update the history message (regardless of whether it's new or existing) */ - /* First, figure out the boundary string. We do this even when we generated the + /* Remove the Message-ID from the old version of the history message. This will cause a brand + * new one to be generated, avoiding an uninitentional hit of the loop zapper when we replicate. + */ + if (history_msg->cm_fields['I'] != NULL) { + free(history_msg->cm_fields['I']); + history_msg->cm_fields['I'] = NULL; + } + + /* Figure out the boundary string. We do this even when we generated the * boundary string in the above code, just to be safe and consistent. */ strcpy(boundary, ""); @@ -242,7 +281,8 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { } } while ( (IsEmptyStr(boundary)) && (*ptr != 0) ); - /* Now look for the first boundary. That is where we need to insert our fun. + /* + * Now look for the first boundary. That is where we need to insert our fun. */ if (!IsEmptyStr(boundary)) { snprintf(prefixed_boundary, sizeof prefixed_boundary, "--%s", boundary); @@ -252,16 +292,15 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { ptr = bmstrcasestr(history_msg->cm_fields['M'], prefixed_boundary); if (ptr != NULL) { char *the_rest_of_it = strdup(ptr); - char uuid[32]; + char uuid[64]; char memo[512]; - char encoded_memo[768]; + char encoded_memo[1024]; generate_uuid(uuid); snprintf(memo, sizeof memo, "%s|%ld|%s|%s", uuid, time(NULL), CCC->user.fullname, config.c_nodename - /* no longer logging CCC->cs_inet_email */ ); CtdlEncodeBase64(encoded_memo, memo, strlen(memo), 0); sprintf(ptr, "--%s\n" @@ -281,12 +320,14 @@ int wiki_upload_beforesave(struct CtdlMessage *msg) { } history_msg->cm_fields['T'] = realloc(history_msg->cm_fields['T'], 32); - snprintf(history_msg->cm_fields['T'], 32, "%ld", time(NULL)); + if (history_msg->cm_fields['T'] != NULL) { + snprintf(history_msg->cm_fields['T'], 32, "%ld", time(NULL)); + } CtdlSubmitMsg(history_msg, NULL, "", 0); } else { - CtdlLogPrintf(CTDL_ALERT, "Empty boundary string in history message. No history!\n"); + syslog(LOG_ALERT, "Empty boundary string in history message. No history!\n"); } free(diffbuf); @@ -334,7 +375,7 @@ void wiki_history(char *pagename) { } snprintf(history_page_name, sizeof history_page_name, "%s_HISTORY_", pagename); - msgnum = locate_message_by_euid(history_page_name, &CC->room); + msgnum = CtdlLocateMessageByEuid(history_page_name, &CC->room); if (msgnum > 0L) { msg = CtdlFetchMessage(msgnum, 1); } @@ -361,17 +402,88 @@ void wiki_history(char *pagename) { return; } +/* + * MIME Parser callback for wiki_rev() + * + * The "filename" field will contain a memo field, which includes (among other things) + * the uuid of this revision. After we hit the desired revision, we stop processing. + * + * The "content" filed will contain "diff" output suitable for applying via "patch" + * to our temporary file. + */ +void wiki_rev_callback(char *name, char *filename, char *partnum, char *disp, + void *content, char *cbtype, char *cbcharset, size_t length, + char *encoding, char *cbid, void *cbuserdata) +{ + struct HistoryEraserCallBackData *hecbd = (struct HistoryEraserCallBackData *)cbuserdata; + char memo[1024]; + char this_rev[256]; + FILE *fp; + char *ptr = NULL; + char buf[1024]; + + /* Did a previous callback already indicate that we've reached our target uuid? + * If so, don't process anything else. + */ + if (hecbd->done) { + return; + } + + CtdlDecodeBase64(memo, filename, strlen(filename)); + extract_token(this_rev, memo, 0, '|', sizeof this_rev); + syslog(LOG_DEBUG, "callback found rev: %s\n", this_rev); + + /* Perform the patch */ + fp = popen("patch -f -s -p0 -r /dev/null >/dev/null 2>/dev/null", "w"); + if (fp) { + /* Replace the filenames in the patch with the tempfilename we're actually tweaking */ + fprintf(fp, "--- %s\n", hecbd->tempfilename); + fprintf(fp, "+++ %s\n", hecbd->tempfilename); + + ptr = (char *)content; + int linenum = 0; + do { + ++linenum; + ptr = memreadline(ptr, buf, sizeof buf); + if (*ptr != 0) { + if (linenum <= 2) { + /* skip the first two lines; they contain bogus filenames */ + } + else { + fprintf(fp, "%s\n", buf); + } + } + } while ((*ptr != 0) && (ptr < ((char*)content + length))); + if (pclose(fp) != 0) { + syslog(LOG_ERR, "pclose() returned an error - patch failed\n"); + } + } + + if (!strcasecmp(this_rev, hecbd->stop_when)) { + /* Found our target rev. Tell any subsequent callbacks to suppress processing. */ + syslog(LOG_DEBUG, "Target revision has been reached -- stop patching.\n"); + hecbd->done = 1; + } +} /* - * Fetch a specific revision of a wiki page + * Fetch a specific revision of a wiki page. The "operation" string may be set to "fetch" in order + * to simply fetch the desired revision and store it in a temporary location for viewing, or "revert" + * to revert the currently active page to that revision. */ -void wiki_rev(char *pagename, char *rev) +void wiki_rev(char *pagename, char *rev, char *operation) { int r; char history_page_name[270]; long msgnum; + char temp[PATH_MAX]; + char timestamp[64]; struct CtdlMessage *msg; + FILE *fp; + struct HistoryEraserCallBackData hecbd; + long len = 0L; + int rv; r = CtdlDoIHavePermissionToReadMessagesInThisRoom(); if (r != om_ok) { @@ -384,8 +496,52 @@ void wiki_rev(char *pagename, char *rev) return; } + if (!strcasecmp(operation, "revert")) { + r = CtdlDoIHavePermissionToPostInThisRoom(temp, sizeof temp, NULL, POST_LOGGED_IN, 0); + if (r != 0) { + cprintf("%d %s\n", r, temp); + return; + } + } + + /* Begin by fetching the current version of the page. We're going to patch + * backwards through the diffs until we get the one we want. + */ + msgnum = CtdlLocateMessageByEuid(pagename, &CC->room); + if (msgnum > 0L) { + msg = CtdlFetchMessage(msgnum, 1); + } + else { + msg = NULL; + } + + if ((msg != NULL) && (msg->cm_fields['M'] == NULL)) { + CtdlFreeMessage(msg); + msg = NULL; + } + + if (msg == NULL) { + cprintf("%d Page '%s' was not found.\n", ERROR+MESSAGE_NOT_FOUND, pagename); + return; + } + + /* Output it to a temporary file */ + + CtdlMakeTempFileName(temp, sizeof temp); + fp = fopen(temp, "w"); + if (fp != NULL) { + r = fwrite(msg->cm_fields['M'], strlen(msg->cm_fields['M']), 1, fp); + fclose(fp); + } + else { + syslog(LOG_ALERT, "Cannot open %s: %s\n", temp, strerror(errno)); + } + CtdlFreeMessage(msg); + + /* Get the revision history */ + snprintf(history_page_name, sizeof history_page_name, "%s_HISTORY_", pagename); - msgnum = locate_message_by_euid(history_page_name, &CC->room); + msgnum = CtdlLocateMessageByEuid(history_page_name, &CC->room); if (msgnum > 0L) { msg = CtdlFetchMessage(msgnum, 1); } @@ -403,14 +559,98 @@ void wiki_rev(char *pagename, char *rev) return; } - -/* - FIXME do something here - mime_parser(msg->cm_fields['M'], NULL, *wiki_history_callback, NULL, NULL, NULL, 0); - */ + /* Start patching backwards (newest to oldest) through the revision history until we + * hit the revision uuid requested by the user. (The callback will perform each one.) + */ + memset(&hecbd, 0, sizeof(struct HistoryEraserCallBackData)); + hecbd.tempfilename = temp; + hecbd.stop_when = rev; + + mime_parser(msg->cm_fields['M'], NULL, *wiki_rev_callback, NULL, NULL, (void *)&hecbd, 0); CtdlFreeMessage(msg); - cprintf("%d FIXME not finished yet, check the log to find out wtf\n", ERROR); + + /* Were we successful? */ + if (hecbd.done == 0) { + cprintf("%d Revision '%s' of page '%s' was not found.\n", + ERROR + MESSAGE_NOT_FOUND, rev, pagename + ); + } + + /* We have the desired revision on disk. Now do something with it. */ + + else if ( (!strcasecmp(operation, "fetch")) || (!strcasecmp(operation, "revert")) ) { + msg = malloc(sizeof(struct CtdlMessage)); + memset(msg, 0, sizeof(struct CtdlMessage)); + msg->cm_magic = CTDLMESSAGE_MAGIC; + msg->cm_anon_type = MES_NORMAL; + msg->cm_format_type = FMT_RFC822; + fp = fopen(temp, "r"); + if (fp) { + fseek(fp, 0L, SEEK_END); + len = ftell(fp); + fseek(fp, 0L, SEEK_SET); + msg->cm_fields['M'] = malloc(len + 1); + rv = fread(msg->cm_fields['M'], len, 1, fp); + syslog(LOG_DEBUG, "did %d blocks of %ld bytes\n", rv, len); + msg->cm_fields['M'][len] = 0; + fclose(fp); + } + if (len <= 0) { + msgnum = (-1L); + } + else if (!strcasecmp(operation, "fetch")) { + msg->cm_fields['A'] = strdup("Citadel"); + CtdlCreateRoom(wwm, 5, "", 0, 1, 1, VIEW_BBS); /* Not an error if already exists */ + msgnum = CtdlSubmitMsg(msg, NULL, wwm, 0); /* Store the revision here */ + + /* + * WARNING: VILE SLEAZY HACK + * This will avoid the 'message xxx is not in this room' security error, + * but only if the client fetches the message we just generated immediately + * without first trying to perform other fetch operations. + */ + if (CC->cached_msglist != NULL) { + free(CC->cached_msglist); + CC->cached_msglist = NULL; + CC->cached_num_msgs = 0; + } + CC->cached_msglist = malloc(sizeof(long)); + if (CC->cached_msglist != NULL) { + CC->cached_num_msgs = 1; + CC->cached_msglist[0] = msgnum; + } + + } + else if (!strcasecmp(operation, "revert")) { + snprintf(timestamp, sizeof timestamp, "%ld", time(NULL)); + msg->cm_fields['T'] = strdup(timestamp); + msg->cm_fields['A'] = strdup(CC->user.fullname); + msg->cm_fields['F'] = strdup(CC->cs_inet_email); + msg->cm_fields['O'] = strdup(CC->room.QRname); + msg->cm_fields['N'] = strdup(NODENAME); + msg->cm_fields['E'] = strdup(pagename); + msgnum = CtdlSubmitMsg(msg, NULL, "", 0); /* Replace the current revision */ + } + else { + /* Theoretically it is impossible to get here, but throw an error anyway */ + msgnum = (-1L); + } + CtdlFreeMessage(msg); + if (msgnum >= 0L) { + cprintf("%d %ld\n", CIT_OK, msgnum); /* Give the client a msgnum */ + } + else { + cprintf("%d Error %ld has occurred.\n", ERROR+INTERNAL_ERROR, msgnum); + } + } + + /* We did all this work for nothing. Express anguish to the caller. */ + else { + cprintf("%d An unknown operation was requested.\n", ERROR+CMD_NOT_SUPPORTED); + } + + unlink(temp); return; } @@ -423,6 +663,7 @@ void cmd_wiki(char *argbuf) { char subcmd[32]; char pagename[256]; char rev[128]; + char operation[16]; extract_token(subcmd, argbuf, 0, '|', sizeof subcmd); @@ -435,7 +676,8 @@ void cmd_wiki(char *argbuf) { if (!strcasecmp(subcmd, "rev")) { extract_token(pagename, argbuf, 1, '|', sizeof pagename); extract_token(rev, argbuf, 2, '|', sizeof rev); - wiki_rev(pagename, rev); + extract_token(operation, argbuf, 3, '|', sizeof operation); + wiki_rev(pagename, rev, operation); return; } @@ -452,9 +694,9 @@ CTDL_MODULE_INIT(wiki) if (!threading) { CtdlRegisterMessageHook(wiki_upload_beforesave, EVT_BEFORESAVE); - CtdlRegisterProtoHook(cmd_wiki, "WIKI", "Commands related to Wiki management"); + CtdlRegisterProtoHook(cmd_wiki, "WIKI", "Commands related to Wiki management"); } - /* return our Subversion id for the Log */ - return "$Id$"; + /* return our module name for the log */ + return "wiki"; }