]> code.citadel.org Git - citadel.git/blob - webcit/tools.c
* Save an incoming meeting request into the user's calendar.
[citadel.git] / webcit / tools.c
1 /*
2  * tools.c -- Miscellaneous routines 
3  */
4
5
6
7 #include <ctype.h>
8 #include <stdlib.h>
9 #include <unistd.h>
10 #include <stdio.h>
11 #include <fcntl.h>
12 #include <signal.h>
13 #include <sys/types.h>
14 #include <sys/wait.h>
15 #include <sys/socket.h>
16 #include <sys/time.h>
17 #include <limits.h>
18 #include <netinet/in.h>
19 #include <netdb.h>
20 #include <string.h>
21 #include <pwd.h>
22 #include <errno.h>
23 #include <stdarg.h>
24 #include <pthread.h>
25 #include <signal.h>
26 #include <sys/time.h>
27 #include "webcit.h"
28 #include "webserver.h"
29
30
31 char *ascmonths[] = {
32         "Jan", "Feb", "Mar", "Apr", "May", "Jun",
33         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
34 };
35
36 char *ascdays[] = {
37         "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
38 };
39
40
41 char *safestrncpy(char *dest, const char *src, size_t n)
42 {
43         if (dest == NULL || src == NULL) {
44                 lprintf(1, "safestrncpy: NULL argument\n");
45                 abort();
46         }
47         strncpy(dest, src, n);
48         dest[n - 1] = 0;
49         return dest;
50 }
51
52
53
54 /*
55  * num_tokens()  -  discover number of parameters/tokens in a string
56  */
57 int num_tokens(char *source, char tok) {
58         int a;
59         int count = 1;
60
61         if (source == NULL) return(0);
62         for (a=0; a<strlen(source); ++a) {
63                 if (source[a]==tok) ++count;
64         }
65         return(count);
66 }
67
68 /*
69  * extract_token()  -  a smarter string tokenizer
70  */
71 void extract_token(char *dest, char *source, int parmnum, char separator) 
72 {
73         int i;
74         int len;
75         int curr_parm;
76
77         strcpy(dest,"");
78         len = 0;
79         curr_parm = 0;
80
81         if (strlen(source)==0) {
82                 return;
83         }
84
85         for (i=0; i<strlen(source); ++i) {
86                 if (source[i]==separator) {
87                         ++curr_parm;
88                 }
89                 else if (curr_parm == parmnum) {
90                         dest[len+1] = 0;
91                         dest[len++] = source[i];
92                 }
93         }
94 }
95
96
97
98 /*
99  * remove_token()  -  a tokenizer that kills, maims, and destroys
100  */
101 void remove_token(char *source, int parmnum, char separator)
102 {
103         int i;
104         int len;
105         int curr_parm;
106         int start, end;
107
108         len = 0;
109         curr_parm = 0;
110         start = (-1);
111         end = (-1);
112
113         if (strlen(source)==0) {
114                 return;
115                 }
116
117         for (i=0; i<strlen(source); ++i) {
118                 if ( (start < 0) && (curr_parm == parmnum) ) {
119                         start = i;
120                 }
121
122                 if ( (end < 0) && (curr_parm == (parmnum+1)) ) {
123                         end = i;
124                 }
125
126                 if (source[i]==separator) {
127                         ++curr_parm;
128                 }
129         }
130
131         if (end < 0) end = strlen(source);
132
133         strcpy(&source[start], &source[end]);
134 }
135
136
137
138
139 /*
140  * extract_int()  -  extract an int parm w/o supplying a buffer
141  */
142 int extract_int(char *source, int parmnum)
143 {
144         char buf[SIZ];
145         
146         extract_token(buf, source, parmnum, '|');
147         return(atoi(buf));
148 }
149
150 /*
151  * extract_long()  -  extract an long parm w/o supplying a buffer
152  */
153 long extract_long(char *source, long int parmnum)
154 {
155         char buf[SIZ];
156         
157         extract_token(buf, source, parmnum, '|');
158         return(atol(buf));
159 }
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175 /*
176  * check for the presence of a character within a string (returns count)
177  */
178 int haschar(st, ch)
179 char st[];
180 char ch;
181 {
182         int a, b;
183         b = 0;
184         for (a = 0; a < strlen(st); ++a)
185                 if (st[a] == ch)
186                         ++b;
187         return (b);
188 }
189
190
191 /*
192  * Format a date/time stamp for output 
193  */
194 void fmt_date(char *buf, time_t thetime) {
195         struct tm *tm;
196         int hour;
197
198         strcpy(buf, "");
199         tm = localtime(&thetime);
200         hour = tm->tm_hour;
201         if (hour == 0) hour = 12;
202         else if (hour > 12) hour = hour - 12;
203
204         sprintf(buf, "%s %d %d %2d:%02d%s",
205                 ascmonths[tm->tm_mon],
206                 tm->tm_mday,
207                 tm->tm_year + 1900,
208                 hour,
209                 tm->tm_min,
210                 ( (tm->tm_hour > 12) ? "pm" : "am" )
211         );
212 }
213
214
215
216
217 /*
218  * Format a date/time stamp to the format used in HTTP headers
219  */
220 void httpdate(char *buf, time_t thetime) {
221         struct tm *tm;
222
223         strcpy(buf, "");
224         tm = localtime(&thetime);
225
226         sprintf(buf, "%s, %02d %s %4d %02d:%02d:%02d",
227                 ascdays[tm->tm_wday],
228                 tm->tm_mday,
229                 ascmonths[tm->tm_mon],
230                 tm->tm_year + 1900,
231                 tm->tm_hour,
232                 tm->tm_min,
233                 tm->tm_sec
234         );
235 }
236
237
238
239
240
241 /*
242  * Utility function to "readline" from memory
243  * (returns new pointer)
244  */
245 char *memreadline(char *start, char *buf, int maxlen)
246 {
247         char ch;
248         char *ptr;
249         int len = 0;    /* tally our own length to avoid strlen() delays */
250
251         ptr = start;
252         memset(buf, 0, maxlen);
253
254         while (1) {
255                 ch = *ptr++;
256                 if ( (len < (maxlen - 1)) && (ch != 13) && (ch != 10) ) {
257                         buf[strlen(buf) + 1] = 0;
258                         buf[strlen(buf)] = ch;
259                         ++len;
260                 }
261                 if ((ch == 10) || (ch == 0)) {
262                         return ptr;
263                 }
264         }
265 }
266
267
268
269 /*
270  * pattern2()  -  searches for patn within search string, returns pos
271  */
272 int pattern2(char *search, char *patn)
273 {
274         int a;
275         for (a=0; a<strlen(search); ++a) {
276                 if (!strncasecmp(&search[a],patn,strlen(patn))) return(a);
277                 }
278         return(-1);
279         }
280
281
282 /*
283  * Strip leading and trailing spaces from a string
284  */
285 void striplt(char *buf)
286 {
287         while ((strlen(buf) > 0) && (isspace(buf[0])))
288                 strcpy(buf, &buf[1]);
289         while (isspace(buf[strlen(buf) - 1]))
290                 buf[strlen(buf) - 1] = 0;
291 }
292
293
294 /*
295  * Determine whether the specified message number is contained within the
296  * specified set.
297  */
298 int is_msg_in_mset(char *mset, long msgnum) {
299         int num_sets;
300         int s;
301         char setstr[SIZ], lostr[SIZ], histr[SIZ];       /* was 1024 */
302         long lo, hi;
303
304         /*
305          * Now set it for all specified messages.
306          */
307         num_sets = num_tokens(mset, ',');
308         for (s=0; s<num_sets; ++s) {
309                 extract_token(setstr, mset, s, ',');
310
311                 extract_token(lostr, setstr, 0, ':');
312                 if (num_tokens(setstr, ':') >= 2) {
313                         extract_token(histr, setstr, 1, ':');
314                         if (!strcmp(histr, "*")) {
315                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
316                         }
317                 } 
318                 else {
319                         strcpy(histr, lostr);
320                 }
321                 lo = atol(lostr);
322                 hi = atol(histr);
323
324                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
325         }
326
327         return(0);
328 }
329
330
331
332 /*
333  * Read binary data from server into memory
334  */
335 void read_server_binary(char *buffer, size_t total_len) {
336         char buf[SIZ];
337         size_t bytes = 0;
338         size_t thisblock = 0;
339
340         while (bytes < total_len) {
341                 thisblock = 4095;
342                 if ((total_len - bytes) < thisblock) {
343                         thisblock = total_len - bytes;
344                 }
345                 serv_printf("READ %d|%d", (int)bytes, (int)thisblock);
346                 serv_gets(buf);
347                 if (buf[0] == '6') {
348                         thisblock = (size_t)atoi(&buf[4]);
349                         serv_read(&buffer[bytes], thisblock);
350                         bytes += thisblock;
351                 }
352                 else {
353                         wprintf("Error: %s<BR>\n", &buf[4]);
354                 }
355         }
356 }