Permit the Content-Transfer-Encoding: header to be forwarded from an HTTP transaction...
[citadel] / 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         char *content_transfer_encoding = NULL;
140         int n;
141         long new_msgnum;
142         char new_euid[1024];
143         char response_string[1024];
144
145         if ((h->request_body == NULL) || (h->request_body_length < 1)) {
146                 do_404(h);                      // Refuse to post a null message
147                 return;
148         }
149
150         ctdl_printf(c, "ENT0 1|||4|||1|");      // This protocol syntax will give us metadata back after upload
151         ctdl_readline(c, buf, sizeof buf);
152         if (buf[0] != '8') {
153                 h->response_code = 502;
154                 h->response_string = strdup("bad gateway");
155                 add_response_header(h, strdup("Content-type"), strdup("text/plain"));
156                 h->response_body = strdup(buf);
157                 h->response_body_length = strlen(h->response_body);
158                 return;
159         }
160
161         content_type = header_val(h, "Content-type");
162         ctdl_printf(c, "Content-type: %s\r\n", (content_type ? content_type : "application/octet-stream"));
163
164         content_transfer_encoding = header_val(h, "Content-Transfer-Encoding");
165         if (!IsEmptyStr(content_transfer_encoding)) {
166                 ctdl_printf(c, "Content-Transfer-Encoding: %s\r\n", content_transfer_encoding);
167         }
168
169         ctdl_printf(c, "\r\n");
170         ctdl_write(c, h->request_body, h->request_body_length);
171         if (h->request_body[h->request_body_length] != '\n') {
172                 ctdl_printf(c, "\r\n");
173         }
174         ctdl_printf(c, "000");
175
176         // Now handle the response from the Citadel server.
177
178         n = 0;
179         new_msgnum = 0;
180         strcpy(new_euid, "");
181         strcpy(response_string, "");
182
183         while (ctdl_readline(c, buf, sizeof buf), strcmp(buf, "000"))
184                 switch (n++) {
185                 case 0:
186                         new_msgnum = atol(buf);
187                         break;
188                 case 1:
189                         safestrncpy(response_string, buf, sizeof response_string);
190                         syslog(LOG_DEBUG, "new_msgnum=%ld (%s)\n", new_msgnum, buf);
191                         break;
192                 case 2:
193                         safestrncpy(new_euid, buf, sizeof new_euid);
194                         break;
195                 default:
196                         break;
197                 }
198
199         // Tell the client what happened.
200
201         // Citadel failed in some way?
202         char *new_location = malloc(1024);
203         if ((new_msgnum < 0L) || (new_location == NULL)) {
204                 h->response_code = 502;
205                 h->response_string = strdup("bad gateway");
206                 add_response_header(h, strdup("Content-type"), strdup("text/plain"));
207                 h->response_body = strdup(response_string);
208                 h->response_body_length = strlen(h->response_body);
209                 return;
210         }
211
212         char *etag = malloc(20);
213         if (etag != NULL) {
214                 sprintf(etag, "%ld", new_msgnum);
215                 add_response_header(h, strdup("ETag"), etag);   // http_transaction now owns this memory
216         }
217
218         char esc_room[1024];
219         char esc_euid[1024];
220         urlesc(esc_room, sizeof esc_room, c->room);
221         urlesc(esc_euid, sizeof esc_euid, new_euid);
222         snprintf(new_location, 1024, "/ctdl/r/%s/%s", esc_room, esc_euid);
223         add_response_header(h, strdup("Location"), new_location);       // http_transaction now owns this memory
224
225         if (old_msgnum <= 0) {
226                 h->response_code = 201; // We created this item for the first time.
227                 h->response_string = strdup("created");
228         }
229         else {
230                 h->response_code = 204; // We modified an existing item.
231                 h->response_string = strdup("no content");
232
233                 // The item we replaced has probably already been deleted by
234                 // the Citadel server, but we'll do this anyway, just in case.
235                 ctdl_delete_msgs(c, &old_msgnum, 1);
236         }
237
238 }
239
240
241 // Download a single component of a MIME-encoded message
242 void download_mime_component(struct http_transaction *h, struct ctdlsession *c, long msgnum, char *partnum) {
243         char buf[1024];
244         char content_type[1024];
245
246         ctdl_printf(c, "DLAT %ld|%s", msgnum, partnum);
247         ctdl_readline(c, buf, sizeof buf);
248         if (buf[0] != '6') {
249                 do_404(h);      // too bad, so sad, go away
250         }
251         // Server response is going to be: 6XX length|-1|filename|content-type|charset
252         h->response_body_length = extract_int(&buf[4], 0);
253         extract_token(content_type, buf, 3, '|', sizeof content_type);
254
255         h->response_body = malloc(h->response_body_length + 1);
256         int bytes = 0;
257         int thisblock;
258         do {
259                 thisblock = read(c->sock, &h->response_body[bytes], (h->response_body_length - bytes));
260                 bytes += thisblock;
261                 syslog(LOG_DEBUG, "Bytes read: %d of %d", (int) bytes, (int) h->response_body_length);
262         } while ((bytes < h->response_body_length) && (thisblock >= 0));
263         h->response_body[h->response_body_length] = 0;  // null terminate it just for good measure
264         syslog(LOG_DEBUG, "content type: %s", content_type);
265
266         add_response_header(h, strdup("Content-type"), strdup(content_type));
267         h->response_code = 200;
268         h->response_string = strdup("OK");
269 }