webcit-ng/messages.c

   1 //
   2 // Message base functions
   3 //
   4 // Copyright (c) 1996-2021 by the citadel.org team
   5 //
   6 // This program is open source software.  It runs great on the
   7 // Linux operating system (and probably elsewhere).  You can use,
   8 // copy, and run it under the terms of the GNU General Public
   9 // License version 3.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 #include "webcit.h"
  17
  18
  19 // Given an encoded UID, translate that to an unencoded Citadel EUID and
  20 // then search for it in the current room.  Return a message number or -1
  21 // if not found.
  22 long locate_message_by_uid(struct ctdlsession *c, char *uid) {
  23         char buf[1024];
  24
  25         ctdl_printf(c, "EUID %s", uid);
  26         ctdl_readline(c, buf, sizeof buf);
  27         if (buf[0] == '2') {
  28                 return (atol(&buf[4]));
  29
  30         }
  31
  32         // Ugly hack to handle Mozilla Thunderbird, try stripping ".ics" if present
  33         if (!strcasecmp(&uid[strlen(uid) - 4], ".ics")) {
  34                 safestrncpy(buf, uid, sizeof buf);
  35                 buf[strlen(buf) - 4] = 0;
  36                 ctdl_printf(c, "EUID %s", buf);
  37                 ctdl_readline(c, buf, sizeof buf);
  38                 if (buf[0] == '2') {
  39                         return (atol(&buf[4]));
  40
  41                 }
  42         }
  43
  44         return (-1);
  45 }
  46
  47
  48 // DAV delete an object in a room.
  49 void dav_delete_message(struct http_transaction *h, struct ctdlsession *c, long msgnum) {
  50         ctdl_delete_msgs(c, &msgnum, 1);
  51         h->response_code = 204;
  52         h->response_string = strdup("no content");
  53 }
  54
  55
  56 // GET method directly on a message in a room
  57 void dav_get_message(struct http_transaction *h, struct ctdlsession *c, long msgnum) {
  58         char buf[1024];
  59         int in_body = 0;
  60         int encoding = 0;
  61         StrBuf *Body = NULL;
  62
  63         ctdl_printf(c, "MSG2 %ld", msgnum);
  64         ctdl_readline(c, buf, sizeof buf);
  65         if (buf[0] != '1') {
  66                 do_404(h);
  67                 return;
  68         }
  69
  70         char *etag = malloc(20);
  71         if (etag != NULL) {
  72                 sprintf(etag, "%ld", msgnum);
  73                 add_response_header(h, strdup("ETag"), etag);   // http_transaction now owns this memory
  74         }
  75
  76         while (ctdl_readline(c, buf, sizeof buf), strcmp(buf, "000")) {
  77                 if (IsEmptyStr(buf) && (in_body == 0)) {
  78                         in_body = 1;
  79                         Body = NewStrBuf();
  80                 }
  81                 else if (in_body == 0) {
  82                         char *k = buf;
  83                         char *v = strchr(buf, ':');
  84                         if (v) {
  85                                 *v = 0;
  86                                 ++v;
  87                                 striplt(v);     // we now have a key (k) and a value (v)
  88                                 if ((!strcasecmp(k, "content-type"))    // fields which can be passed from RFC822 to HTTP as-is
  89                                     || (!strcasecmp(k, "date"))
  90                                 ) {
  91                                         add_response_header(h, strdup(k), strdup(v));
  92                                 }
  93                                 else if (!strcasecmp(k, "content-transfer-encoding")) {
  94                                         if (!strcasecmp(v, "base64")) {
  95                                                 encoding = 'b';
  96                                         }
  97                                         else if (!strcasecmp(v, "quoted-printable")) {
  98                                                 encoding = 'q';
  99                                         }
 100                                 }
 101                         }
 102                 }
 103                 else if ((in_body == 1) && (Body != NULL)) {
 104                         StrBufAppendPrintf(Body, "%s\n", buf);
 105                 }
 106         }
 107
 108         h->response_code = 200;
 109         h->response_string = strdup("OK");
 110
 111         if (Body != NULL) {
 112                 if (encoding == 'q') {
 113                         h->response_body = malloc(StrLength(Body));
 114                         if (h->response_body != NULL) {
 115                                 h->response_body_length =
 116                                     CtdlDecodeQuotedPrintable(h->response_body, (char *) ChrPtr(Body), StrLength(Body));
 117                         }
 118                         FreeStrBuf(&Body);
 119                 }
 120                 else if (encoding == 'b') {
 121                         h->response_body = malloc(StrLength(Body));
 122                         if (h->response_body != NULL) {
 123                                 h->response_body_length = CtdlDecodeBase64(h->response_body, ChrPtr(Body), StrLength(Body));
 124                         }
 125                         FreeStrBuf(&Body);
 126                 }
 127                 else {
 128                         h->response_body_length = StrLength(Body);
 129                         h->response_body = SmashStrBuf(&Body);
 130                 }
 131         }
 132 }
 133
 134
 135 // PUT a message into a room
 136 void dav_put_message(struct http_transaction *h, struct ctdlsession *c, char *euid, long old_msgnum) {
 137         char buf[1024];
 138         char *content_type = NULL;
 139         int n;
 140         long new_msgnum;
 141         char new_euid[1024];
 142         char response_string[1024];
 143
 144         if ((h->request_body == NULL) || (h->request_body_length < 1)) {
 145                 do_404(h);                      // Refuse to post a null message
 146                 return;
 147         }
 148
 149         ctdl_printf(c, "ENT0 1|||4|||1|");      // This protocol syntax will give us metadata back after upload
 150         ctdl_readline(c, buf, sizeof buf);
 151         if (buf[0] != '8') {
 152                 h->response_code = 502;
 153                 h->response_string = strdup("bad gateway");
 154                 add_response_header(h, strdup("Content-type"), strdup("text/plain"));
 155                 h->response_body = strdup(buf);
 156                 h->response_body_length = strlen(h->response_body);
 157                 return;
 158         }
 159
 160         // Remember, ctdl_printf() appends \n on its own, so when adding a CRLF newline, only use \r
 161         // Or for a blank line, use ctdl_write() with \r\n
 162
 163         content_type = header_val(h, "Content-type");
 164         ctdl_printf(c, "Content-type: %s\r", (content_type ? content_type : "application/octet-stream"));
 165         ctdl_write(c, HKEY("\r\n"));
 166         ctdl_write(c, h->request_body, h->request_body_length);
 167         if (h->request_body[h->request_body_length] != '\n') {
 168                 ctdl_write(c, HKEY("\r\n"));
 169         }
 170         ctdl_printf(c, "000");
 171
 172         // Now handle the response from the Citadel server.
 173
 174         n = 0;
 175         new_msgnum = 0;
 176         strcpy(new_euid, "");
 177         strcpy(response_string, "");
 178
 179         while (ctdl_readline(c, buf, sizeof buf), strcmp(buf, "000"))
 180                 switch (n++) {
 181                 case 0:
 182                         new_msgnum = atol(buf);
 183                         break;
 184                 case 1:
 185                         safestrncpy(response_string, buf, sizeof response_string);
 186                         syslog(LOG_DEBUG, "new_msgnum=%ld (%s)\n", new_msgnum, buf);
 187                         break;
 188                 case 2:
 189                         safestrncpy(new_euid, buf, sizeof new_euid);
 190                         break;
 191                 default:
 192                         break;
 193                 }
 194
 195         // Tell the client what happened.
 196
 197         // Citadel failed in some way?
 198         char *new_location = malloc(1024);
 199         if ((new_msgnum < 0L) || (new_location == NULL)) {
 200                 h->response_code = 502;
 201                 h->response_string = strdup("bad gateway");
 202                 add_response_header(h, strdup("Content-type"), strdup("text/plain"));
 203                 h->response_body = strdup(response_string);
 204                 h->response_body_length = strlen(h->response_body);
 205                 return;
 206         }
 207
 208         char *etag = malloc(20);
 209         if (etag != NULL) {
 210                 sprintf(etag, "%ld", new_msgnum);
 211                 add_response_header(h, strdup("ETag"), etag);   // http_transaction now owns this memory
 212         }
 213
 214         char esc_room[1024];
 215         char esc_euid[1024];
 216         urlesc(esc_room, sizeof esc_room, c->room);
 217         urlesc(esc_euid, sizeof esc_euid, new_euid);
 218         snprintf(new_location, 1024, "/ctdl/r/%s/%s", esc_room, esc_euid);
 219         add_response_header(h, strdup("Location"), new_location);       // http_transaction now owns this memory
 220
 221         if (old_msgnum <= 0) {
 222                 h->response_code = 201; // We created this item for the first time.
 223                 h->response_string = strdup("created");
 224         }
 225         else {
 226                 h->response_code = 204; // We modified an existing item.
 227                 h->response_string = strdup("no content");
 228
 229                 // The item we replaced has probably already been deleted by
 230                 // the Citadel server, but we'll do this anyway, just in case.
 231                 ctdl_delete_msgs(c, &old_msgnum, 1);
 232         }
 233
 234 }
 235
 236
 237 // Download a single component of a MIME-encoded message
 238 void download_mime_component(struct http_transaction *h, struct ctdlsession *c, long msgnum, char *partnum) {
 239         char buf[1024];
 240         char content_type[1024];
 241
 242         ctdl_printf(c, "DLAT %ld|%s", msgnum, partnum);
 243         ctdl_readline(c, buf, sizeof buf);
 244         if (buf[0] != '6') {
 245                 do_404(h);      // too bad, so sad, go away
 246         }
 247         // Server response is going to be: 6XX length|-1|filename|content-type|charset
 248         h->response_body_length = extract_int(&buf[4], 0);
 249         extract_token(content_type, buf, 3, '|', sizeof content_type);
 250
 251         h->response_body = malloc(h->response_body_length + 1);
 252         int bytes = 0;
 253         int thisblock;
 254         do {
 255                 thisblock = read(c->sock, &h->response_body[bytes], (h->response_body_length - bytes));
 256                 bytes += thisblock;
 257                 syslog(LOG_DEBUG, "Bytes read: %d of %d", (int) bytes, (int) h->response_body_length);
 258         } while ((bytes < h->response_body_length) && (thisblock >= 0));
 259         h->response_body[h->response_body_length] = 0;  // null terminate it just for good measure
 260         syslog(LOG_DEBUG, "content type: %s", content_type);
 261
 262         add_response_header(h, strdup("Content-type"), strdup(content_type));
 263         h->response_code = 200;
 264         h->response_string = strdup("OK");
 265 }