chiark / gitweb /
Better message for 503 from peer on idle conn. Conventional macro protection for...
[inn-innduct.git] / storage / overdata.c
1 /*  $Id: overdata.c 7477 2005-12-24 21:34:38Z eagle $
2 **
3 **  Overview data processing.
4 **
5 **  Here be routines for creating and checking the overview data, the
6 **  tab-separated list of overview fields.
7 */
8
9 #include "config.h"
10 #include "clibrary.h"
11 #include <ctype.h>
12
13 #include "inn/buffer.h"
14 #include "inn/innconf.h"
15 #include "inn/messages.h"
16 #include "inn/qio.h"
17 #include "inn/wire.h"
18 #include "inn/vector.h"
19 #include "libinn.h"
20 #include "ovinterface.h"
21 #include "paths.h"
22
23
24 /* The standard overview fields. */
25 static const char * const fields[] = {
26     "Subject", "From", "Date", "Message-ID", "References", "Bytes", "Lines"
27 };
28
29
30 /*
31 **  Return a vector of the standard overview fields. Note there is no
32 **  way to free up the resulting data structure.
33 */
34 const struct cvector *
35 overview_fields(void)
36 {
37     static struct cvector *list = NULL;
38
39     if (list == NULL) {
40         unsigned int field;
41
42         list = cvector_new();
43         cvector_resize(list, ARRAY_SIZE(fields));
44
45         for (field = 0; field < ARRAY_SIZE(fields); ++field) {
46             cvector_add(list, fields[field]);
47         }
48     }
49     return list;
50 }
51
52 /*
53 **  Parse the overview schema and return a vector of the additional fields
54 **  over the standard ones.  Caller is responsible for freeing the vector.
55 */
56 struct vector *
57 overview_extra_fields(void)
58 {
59     struct vector *list = NULL;
60     struct vector *result = NULL;
61     char *schema = NULL;
62     char *line, *p;
63     QIOSTATE *qp = NULL;
64     unsigned int field;
65     bool full = false;
66
67     schema = concatpath(innconf->pathetc, _PATH_SCHEMA);
68     qp = QIOopen(schema);
69     if (qp == NULL) {
70         syswarn("cannot open %s", schema);
71         goto done;
72     }
73     list = vector_new();
74     for (field = 0, line = QIOread(qp); line != NULL; line = QIOread(qp)) {
75         while (ISWHITE(*line))
76             line++;
77         p = strchr(line, '#');
78         if (p != NULL)
79             *p = '\0';
80         p = strchr(line, '\n');
81         if (p != NULL)
82             *p = '\0';
83         if (*line == '\0')
84             continue;
85         p = strchr(line, ':');
86         if (p != NULL) {
87             *p++ = '\0';
88             full = (strcmp(p, "full") == 0);
89         }
90         if (field >= ARRAY_SIZE(fields)) {
91             if (!full)
92                 warn("additional field %s not marked with :full", line);
93             vector_add(list, line);
94         } else {
95             if (strcasecmp(line, fields[field]) != 0)
96                 warn("field %d is %s, should be %s", field, line,
97                      fields[field]);
98         }
99         field++;
100     }
101     if (QIOerror(qp)) {
102         if (QIOtoolong(qp)) {
103             warn("line too long in %s", schema);
104         } else {
105             syswarn("error while reading %s", schema);
106         }
107     }
108     result = list;
109
110 done:
111     if (schema != NULL)
112         free(schema);
113     if (qp != NULL)
114         QIOclose(qp);
115     if (result == NULL && list != NULL)
116         vector_free(list);
117     return result;
118 }
119
120
121 /*
122 **  Given an article, its length, the name of a header, and a buffer to append
123 **  the data to, append header data for that header to the overview data
124 **  that's being constructed.  Doesn't append any data if the header isn't
125 **  found.
126 */
127 static void
128 build_header(const char *article, size_t length, const char *header,
129              struct buffer *overview)
130 {
131     ptrdiff_t size;
132     size_t offset;
133     const char *data, *end, *p;
134
135     data = wire_findheader(article, length, header);
136     if (data == NULL)
137         return;
138     end = wire_endheader(data, article + length - 1);
139     if (end == NULL)
140         return;
141
142     /* Someone managed to break their server so that they were appending
143        multiple Xref headers, and INN had a bug where it wouldn't notice this
144        and reject the article.  Just in case, see if there are multiple Xref
145        headers and use the last one. */
146     if (strcasecmp(header, "xref") == 0) {
147         const char *next = end + 1;
148
149         while (next != NULL) {
150             next = wire_findheader(next, length - (next - article), header);
151             if (next != NULL) {
152                 data = next;
153                 end = wire_endheader(data, article + length - 1);
154                 if (end == NULL)
155                     return;
156             }
157         }
158     }
159
160     size = end - data + 1;
161     offset = overview->used + overview->left;
162     buffer_resize(overview, offset + size);
163
164     for (p = data; p <= end; p++) {
165         if (*p == '\r' && p[1] == '\n') {
166             p++;
167             continue;
168         }
169         if (*p == '\0' || *p == '\t' || *p == '\n' || *p == '\r')
170             overview->data[offset++] = ' ';
171         else
172             overview->data[offset++] = *p;
173         overview->left++;
174     }
175 }
176
177
178 /*
179 **  Given an article number, an article, and a vector of additional headers,
180 **  generate overview data into the provided buffer.  If the buffer parameter
181 **  is NULL, a new buffer is allocated.  The article should be in wire format.
182 **  Returns the buffer containing the overview data.
183 */
184 struct buffer *
185 overview_build(ARTNUM number, const char *article, size_t length,
186                const struct vector *extra, struct buffer *overview)
187 {
188     unsigned int field;
189     char buffer[32];
190
191     snprintf(buffer, sizeof(buffer), "%lu", number);
192     if (overview == NULL)
193         overview = buffer_new();
194     buffer_set(overview, buffer, strlen(buffer));
195     for (field = 0; field < ARRAY_SIZE(fields); field++) {
196         buffer_append(overview, "\t", 1);
197         if (field == 5) {
198             snprintf(buffer, sizeof(buffer), "%lu", (unsigned long) length);
199             buffer_append(overview, buffer, strlen(buffer));
200         } else
201             build_header(article, length, fields[field], overview);
202     }
203     for (field = 0; field < extra->count; field++) {
204         buffer_append(overview, "\t", 1);
205         buffer_append(overview, extra->strings[field],
206                       strlen(extra->strings[field]));
207         buffer_append(overview, ": ", 2);
208         build_header(article, length, extra->strings[field], overview);
209     }
210     buffer_append(overview, "\r\n", 2);
211     return overview;
212 }
213
214
215 /*
216 **  Check whether a given string is a valid number.
217 */
218 static bool
219 valid_number(const char *string)
220 {
221     const char *p;
222
223     for (p = string; *p != '\0'; p++)
224         if (!CTYPE(isdigit, *p))
225             return false;
226     return true;
227 }
228
229
230 /*
231 **  Check whether a given string is a valid overview string (doesn't contain
232 **  CR or LF, and if the second argument is true must be preceeded by a header
233 **  name, colon, and space).  Allow CRLF at the end of the data, but don't
234 **  require it.
235 */
236 static bool
237 valid_overview_string(const char *string, bool full)
238 {
239     const unsigned char *p;
240
241     /* RFC 2822 says that header fields must consist of printable ASCII
242        characters (characters between 33 and 126, inclusive) excluding colon.
243        We also allow high-bit characters, just in case, but not DEL. */
244     p = (const unsigned char *) string;
245     if (full) {
246         for (; *p != '\0' && *p != ':'; p++)
247             if (*p < 33 || *p == 127)
248                 return false;
249         if (*p != ':')
250             return false;
251         p++;
252         if (*p != ' ')
253             return false;
254     }
255     for (p++; *p != '\0'; p++) {
256         if (*p == '\015' && p[1] == '\012' && p[2] == '\0')
257             break;
258         if (*p == '\015' || *p == '\012')
259             return false;
260     }
261     return true;
262 }
263
264
265 /*
266 **  Check the given overview data and make sure it's well-formed.  Extension
267 **  headers are not checked against overview.fmt (having a different set of
268 **  extension headers doesn't make the data invalid), but the presence of the
269 **  standard fields is checked.  Also checked is whether the article number in
270 **  the data matches the passed article number.  Returns true if the data is
271 **  okay, false otherwise.
272 */
273 bool
274 overview_check(const char *data, size_t length, ARTNUM article)
275 {
276     char *copy;
277     struct cvector *overview;
278     ARTNUM overnum;
279     size_t i;
280
281     copy = xstrndup(data, length);
282     overview = cvector_split(copy, '\t', NULL);
283
284     /* The actual checks.  We don't verify all of the data, since that data
285        may be malformed in the article, but we do check to be sure that the
286        fields that should be numbers are numbers.  That should catch most
287        positional errors.  We can't check Lines yet since right now INN is
288        still accepting the value from the post verbatim. */
289     if (overview->count < 8)
290         goto fail;
291     if (!valid_number(overview->strings[0]))
292         goto fail;
293     overnum = strtoul(overview->strings[0], NULL, 10);
294     if (overnum != article)
295         goto fail;
296     if (!valid_number(overview->strings[6]))
297         goto fail;
298     for (i = 1; i < 6; i++)
299         if (!valid_overview_string(overview->strings[i], false))
300             goto fail;
301     for (i = 8; i < overview->count; i++)
302         if (!valid_overview_string(overview->strings[i], true))
303             goto fail;
304     cvector_free(overview);
305     free(copy);
306     return true;
307
308  fail:
309     cvector_free(overview);
310     free(copy);
311     return false;
312 }
313
314
315 /*
316 **  Given an overview header, return the offset of the field within
317 **  the overview data, or -1 if the field is not present in the
318 **  overview schema for this installation.
319 */
320 int
321 overview_index(const char *field, const struct vector *extra)
322 {
323     int i;
324
325     for (i = 0; i < (sizeof fields / sizeof fields[0]); ++i) {
326         if (strcasecmp(field, fields[i]) == 0)
327             return i;
328     }
329     for (i = 0; i < extra->count; i++) {
330         if (strcasecmp(field, extra->strings[i]) == 0)
331             return i + (sizeof fields / sizeof fields[0]);
332     }
333     return -1;
334 }
335
336
337 /*
338 **  Given an overview header line, split out a vector pointing at each
339 **  of the components (within line), returning a pointer to the
340 **  vector. If the vector initially passed in is NULL a new vector is
341 **  created, else the existing one is filled in.
342 **
343 **  A member `n' of the vector is of length (vector->strings[n+1] -
344 **  vector->strings[n] - 1). Note that the last member of the vector
345 **  will always point beyond (line + length).
346 */
347 struct cvector *
348 overview_split(const char *line, size_t length, ARTNUM *number,
349                struct cvector *vector)
350 {
351     const char *p = NULL;
352
353     if (vector == NULL) {
354         vector = cvector_new();
355     } else {
356         cvector_clear(vector);
357     }
358     while (line != NULL) {
359         /* the first field is the article number */
360         if (p == NULL) {
361             if (number != NULL) {
362                 *number = atoi(line);
363             }
364         } else {
365             cvector_add(vector, line);
366         }
367         p = memchr(line, '\t', length);
368         if (p != NULL) {
369             /* skip over the tab */
370             ++p;
371             /* and calculate the remaining length */
372             length -= (p - line);
373         } else {
374             /* add in a pointer to beyond the end of the final
375              * component, so you can always calculate the length.
376              * overview lines are always terminated with \r\n, so the
377              * -1 ends up chopping those off */
378             cvector_add(vector, line + length - 1);
379         }
380         line = p;
381     }
382     return vector;
383 }
384
385 /*
386 **  Given an overview vector (from overview_split), return a copy of
387 **  the member which the caller is interested in (and must free).
388 */
389 char *
390 overview_getheader(const struct cvector *vector, int element,
391                    const struct vector *extra)
392 {
393     char *field = NULL;
394     size_t len;
395     const char *p;
396
397     if ((element + 1) >= vector->count ||
398         (element >= ARRAY_SIZE(fields) &&
399          (element - ARRAY_SIZE(fields)) >= extra->count)) {
400         warn("request for invalid overview field %d", element);
401         return NULL;
402     }
403     /* Note... this routine does not synthesise Newsgroups: on behalf
404      * of the caller... */
405     if (element >= ARRAY_SIZE(fields)) {
406         /* +2 for `: ' */
407         p = vector->strings[element] +
408             strlen(extra->strings[element - ARRAY_SIZE(fields)]) + 2;
409         len = vector->strings[element + 1] - p - 1;
410     } else {
411         p = vector->strings[element];
412         len = vector->strings[element + 1] - vector->strings[element] - 1;
413     }
414     field = xstrndup(p, len);
415     return field;
416 }