rev |
line source |
yuuji@0
|
1 /* ========================================================================
|
yuuji@0
|
2 * Copyright 1988-2008 University of Washington
|
yuuji@0
|
3 *
|
yuuji@0
|
4 * Licensed under the Apache License, Version 2.0 (the "License");
|
yuuji@0
|
5 * you may not use this file except in compliance with the License.
|
yuuji@0
|
6 * You may obtain a copy of the License at
|
yuuji@0
|
7 *
|
yuuji@0
|
8 * http://www.apache.org/licenses/LICENSE-2.0
|
yuuji@0
|
9 *
|
yuuji@0
|
10 *
|
yuuji@0
|
11 * ========================================================================
|
yuuji@0
|
12 */
|
yuuji@0
|
13
|
yuuji@0
|
14 /*
|
yuuji@0
|
15 * Program: UNIX mail routines
|
yuuji@0
|
16 *
|
yuuji@0
|
17 * Author: Mark Crispin
|
yuuji@0
|
18 * UW Technology
|
yuuji@0
|
19 * University of Washington
|
yuuji@0
|
20 * Seattle, WA 98195
|
yuuji@0
|
21 * Internet: MRC@Washington.EDU
|
yuuji@0
|
22 *
|
yuuji@0
|
23 * Date: 20 December 1989
|
yuuji@0
|
24 * Last Edited: 27 March 2008
|
yuuji@0
|
25 */
|
yuuji@0
|
26
|
yuuji@0
|
27
|
yuuji@0
|
28 /* DEDICATION
|
yuuji@0
|
29 *
|
yuuji@0
|
30 * This file is dedicated to my dog, Unix, also known as Yun-chan and
|
yuuji@0
|
31 * Unix J. Terwilliker Jehosophat Aloysius Monstrosity Animal Beast. Unix
|
yuuji@0
|
32 * passed away at the age of 11 1/2 on September 14, 1996, 12:18 PM PDT, after
|
yuuji@0
|
33 * a two-month bout with cirrhosis of the liver.
|
yuuji@0
|
34 *
|
yuuji@0
|
35 * He was a dear friend, and I miss him terribly.
|
yuuji@0
|
36 *
|
yuuji@0
|
37 * Lift a leg, Yunie. Luv ya forever!!!!
|
yuuji@0
|
38 */
|
yuuji@0
|
39
|
yuuji@0
|
40 #include <stdio.h>
|
yuuji@0
|
41 #include <ctype.h>
|
yuuji@0
|
42 #include <errno.h>
|
yuuji@0
|
43 extern int errno; /* just in case */
|
yuuji@0
|
44 #include <signal.h>
|
yuuji@0
|
45 #include "mail.h"
|
yuuji@0
|
46 #include "osdep.h"
|
yuuji@0
|
47 #include <time.h>
|
yuuji@0
|
48 #include <sys/stat.h>
|
yuuji@0
|
49 #include "unix.h"
|
yuuji@0
|
50 #include "pseudo.h"
|
yuuji@0
|
51 #include "fdstring.h"
|
yuuji@0
|
52 #include "misc.h"
|
yuuji@0
|
53 #include "dummy.h"
|
yuuji@0
|
54
|
yuuji@0
|
55 /* UNIX I/O stream local data */
|
yuuji@0
|
56
|
yuuji@0
|
57 typedef struct unix_local {
|
yuuji@0
|
58 unsigned int dirty : 1; /* disk copy needs updating */
|
yuuji@0
|
59 unsigned int ddirty : 1; /* double-dirty, ping becomes checkpoint */
|
yuuji@0
|
60 unsigned int pseudo : 1; /* uses a pseudo message */
|
yuuji@0
|
61 unsigned int appending : 1; /* don't mark new messages as old */
|
yuuji@0
|
62 int fd; /* mailbox file descriptor */
|
yuuji@0
|
63 int ld; /* lock file descriptor */
|
yuuji@0
|
64 char *lname; /* lock file name */
|
yuuji@0
|
65 off_t filesize; /* file size parsed */
|
yuuji@0
|
66 time_t filetime; /* last file time */
|
yuuji@0
|
67 time_t lastsnarf; /* last snarf time (for mbox driver) */
|
yuuji@0
|
68 unsigned char *buf; /* temporary buffer */
|
yuuji@0
|
69 unsigned long buflen; /* current size of temporary buffer */
|
yuuji@0
|
70 unsigned long uid; /* current text uid */
|
yuuji@0
|
71 SIZEDTEXT text; /* current text */
|
yuuji@0
|
72 unsigned long textlen; /* current text length */
|
yuuji@0
|
73 char *line; /* returned line */
|
yuuji@0
|
74 char *linebuf; /* line readin buffer */
|
yuuji@0
|
75 unsigned long linebuflen; /* current line readin buffer length */
|
yuuji@0
|
76 } UNIXLOCAL;
|
yuuji@0
|
77
|
yuuji@0
|
78
|
yuuji@0
|
79 /* Convenient access to local data */
|
yuuji@0
|
80
|
yuuji@0
|
81 #define LOCAL ((UNIXLOCAL *) stream->local)
|
yuuji@0
|
82
|
yuuji@0
|
83
|
yuuji@0
|
84 /* UNIX protected file structure */
|
yuuji@0
|
85
|
yuuji@0
|
86 typedef struct unix_file {
|
yuuji@0
|
87 MAILSTREAM *stream; /* current stream */
|
yuuji@0
|
88 off_t curpos; /* current file position */
|
yuuji@0
|
89 off_t protect; /* protected position */
|
yuuji@0
|
90 off_t filepos; /* current last written file position */
|
yuuji@0
|
91 char *buf; /* overflow buffer */
|
yuuji@0
|
92 size_t buflen; /* current overflow buffer length */
|
yuuji@0
|
93 char *bufpos; /* current buffer position */
|
yuuji@0
|
94 } UNIXFILE;
|
yuuji@0
|
95
|
yuuji@0
|
96 /* Function prototypes */
|
yuuji@0
|
97
|
yuuji@0
|
98 DRIVER *unix_valid (char *name);
|
yuuji@0
|
99 long unix_isvalid_fd (int fd);
|
yuuji@0
|
100 void *unix_parameters (long function,void *value);
|
yuuji@0
|
101 void unix_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents);
|
yuuji@0
|
102 void unix_list (MAILSTREAM *stream,char *ref,char *pat);
|
yuuji@0
|
103 void unix_lsub (MAILSTREAM *stream,char *ref,char *pat);
|
yuuji@0
|
104 long unix_create (MAILSTREAM *stream,char *mailbox);
|
yuuji@0
|
105 long unix_delete (MAILSTREAM *stream,char *mailbox);
|
yuuji@0
|
106 long unix_rename (MAILSTREAM *stream,char *old,char *newname);
|
yuuji@0
|
107 MAILSTREAM *unix_open (MAILSTREAM *stream);
|
yuuji@0
|
108 void unix_close (MAILSTREAM *stream,long options);
|
yuuji@0
|
109 char *unix_header (MAILSTREAM *stream,unsigned long msgno,
|
yuuji@0
|
110 unsigned long *length,long flags);
|
yuuji@0
|
111 long unix_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags);
|
yuuji@0
|
112 char *unix_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
|
yuuji@0
|
113 unsigned long *length,long flags);
|
yuuji@0
|
114 void unix_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt);
|
yuuji@0
|
115 long unix_ping (MAILSTREAM *stream);
|
yuuji@0
|
116 void unix_check (MAILSTREAM *stream);
|
yuuji@0
|
117 long unix_expunge (MAILSTREAM *stream,char *sequence,long options);
|
yuuji@0
|
118 long unix_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options);
|
yuuji@0
|
119 long unix_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
|
yuuji@0
|
120 int unix_collect_msg (MAILSTREAM *stream,FILE *sf,char *flags,char *date,
|
yuuji@0
|
121 STRING *msg);
|
yuuji@0
|
122 int unix_append_msgs (MAILSTREAM *stream,FILE *sf,FILE *df,SEARCHSET *set);
|
yuuji@0
|
123
|
yuuji@0
|
124 void unix_abort (MAILSTREAM *stream);
|
yuuji@0
|
125 char *unix_file (char *dst,char *name);
|
yuuji@0
|
126 int unix_lock (char *file,int flags,int mode,DOTLOCK *lock,int op);
|
yuuji@0
|
127 void unix_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock);
|
yuuji@0
|
128 int unix_parse (MAILSTREAM *stream,DOTLOCK *lock,int op);
|
yuuji@0
|
129 char *unix_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size);
|
yuuji@0
|
130 unsigned long unix_pseudo (MAILSTREAM *stream,char *hdr);
|
yuuji@0
|
131 unsigned long unix_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
|
yuuji@0
|
132 unsigned long uid,long flag);
|
yuuji@0
|
133 long unix_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock,
|
yuuji@0
|
134 long flags);
|
yuuji@0
|
135 long unix_extend (MAILSTREAM *stream,unsigned long size);
|
yuuji@0
|
136 void unix_write (UNIXFILE *f,char *s,unsigned long i);
|
yuuji@0
|
137 void unix_phys_write (UNIXFILE *f,char *buf,size_t size);
|
yuuji@0
|
138
|
yuuji@0
|
139 /* mbox mail routines */
|
yuuji@0
|
140
|
yuuji@0
|
141 /* Function prototypes */
|
yuuji@0
|
142
|
yuuji@0
|
143 DRIVER *mbox_valid (char *name);
|
yuuji@0
|
144 long mbox_create (MAILSTREAM *stream,char *mailbox);
|
yuuji@0
|
145 long mbox_delete (MAILSTREAM *stream,char *mailbox);
|
yuuji@0
|
146 long mbox_rename (MAILSTREAM *stream,char *old,char *newname);
|
yuuji@0
|
147 long mbox_status (MAILSTREAM *stream,char *mbx,long flags);
|
yuuji@0
|
148 MAILSTREAM *mbox_open (MAILSTREAM *stream);
|
yuuji@0
|
149 long mbox_ping (MAILSTREAM *stream);
|
yuuji@0
|
150 void mbox_check (MAILSTREAM *stream);
|
yuuji@0
|
151 long mbox_expunge (MAILSTREAM *stream,char *sequence,long options);
|
yuuji@0
|
152 long mbox_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data);
|
yuuji@0
|
153
|
yuuji@0
|
154
|
yuuji@0
|
155 /* UNIX mail routines */
|
yuuji@0
|
156
|
yuuji@0
|
157
|
yuuji@0
|
158 /* Driver dispatch used by MAIL */
|
yuuji@0
|
159
|
yuuji@0
|
160 DRIVER unixdriver = {
|
yuuji@0
|
161 "unix", /* driver name */
|
yuuji@0
|
162 /* driver flags */
|
yuuji@0
|
163 DR_LOCAL|DR_MAIL|DR_LOCKING|DR_NONEWMAILRONLY|DR_XPOINT,
|
yuuji@0
|
164 (DRIVER *) NIL, /* next driver */
|
yuuji@0
|
165 unix_valid, /* mailbox is valid for us */
|
yuuji@0
|
166 unix_parameters, /* manipulate parameters */
|
yuuji@0
|
167 unix_scan, /* scan mailboxes */
|
yuuji@0
|
168 unix_list, /* list mailboxes */
|
yuuji@0
|
169 unix_lsub, /* list subscribed mailboxes */
|
yuuji@0
|
170 NIL, /* subscribe to mailbox */
|
yuuji@0
|
171 NIL, /* unsubscribe from mailbox */
|
yuuji@0
|
172 unix_create, /* create mailbox */
|
yuuji@0
|
173 unix_delete, /* delete mailbox */
|
yuuji@0
|
174 unix_rename, /* rename mailbox */
|
yuuji@0
|
175 mail_status_default, /* status of mailbox */
|
yuuji@0
|
176 unix_open, /* open mailbox */
|
yuuji@0
|
177 unix_close, /* close mailbox */
|
yuuji@0
|
178 NIL, /* fetch message "fast" attributes */
|
yuuji@0
|
179 NIL, /* fetch message flags */
|
yuuji@0
|
180 NIL, /* fetch overview */
|
yuuji@0
|
181 NIL, /* fetch message envelopes */
|
yuuji@0
|
182 unix_header, /* fetch message header */
|
yuuji@0
|
183 unix_text, /* fetch message text */
|
yuuji@0
|
184 NIL, /* fetch partial message text */
|
yuuji@0
|
185 NIL, /* unique identifier */
|
yuuji@0
|
186 NIL, /* message number */
|
yuuji@0
|
187 NIL, /* modify flags */
|
yuuji@0
|
188 unix_flagmsg, /* per-message modify flags */
|
yuuji@0
|
189 NIL, /* search for message based on criteria */
|
yuuji@0
|
190 NIL, /* sort messages */
|
yuuji@0
|
191 NIL, /* thread messages */
|
yuuji@0
|
192 unix_ping, /* ping mailbox to see if still alive */
|
yuuji@0
|
193 unix_check, /* check for new messages */
|
yuuji@0
|
194 unix_expunge, /* expunge deleted messages */
|
yuuji@0
|
195 unix_copy, /* copy messages to another mailbox */
|
yuuji@0
|
196 unix_append, /* append string message to mailbox */
|
yuuji@0
|
197 NIL /* garbage collect stream */
|
yuuji@0
|
198 };
|
yuuji@0
|
199
|
yuuji@0
|
200 /* prototype stream */
|
yuuji@0
|
201 MAILSTREAM unixproto = {&unixdriver};
|
yuuji@0
|
202
|
yuuji@0
|
203 /* driver parameters */
|
yuuji@0
|
204 static long unix_fromwidget = T;
|
yuuji@1
|
205 char *myMailSuffix =NIL; /* home directory name */
|
yuuji@0
|
206
|
yuuji@0
|
207 /* UNIX mail validate mailbox
|
yuuji@0
|
208 * Accepts: mailbox name
|
yuuji@0
|
209 * Returns: our driver if name is valid, NIL otherwise
|
yuuji@0
|
210 */
|
yuuji@0
|
211
|
yuuji@0
|
212 DRIVER *unix_valid (char *name)
|
yuuji@0
|
213 {
|
yuuji@0
|
214 int fd;
|
yuuji@0
|
215 DRIVER *ret = NIL;
|
yuuji@0
|
216 char *t,file[MAILTMPLEN];
|
yuuji@0
|
217 struct stat sbuf;
|
yuuji@0
|
218 time_t tp[2];
|
yuuji@0
|
219 errno = EINVAL; /* assume invalid argument */
|
yuuji@0
|
220 /* must be non-empty file */
|
yuuji@0
|
221 if ((t = dummy_file (file,name)) && !stat (t,&sbuf)) {
|
yuuji@0
|
222 if (!sbuf.st_size)errno = 0;/* empty file */
|
yuuji@0
|
223 else if ((fd = open (file,O_RDONLY,NIL)) >= 0) {
|
yuuji@0
|
224 /* OK if mailbox format good */
|
yuuji@0
|
225 if (unix_isvalid_fd (fd)) ret = &unixdriver;
|
yuuji@0
|
226 else errno = -1; /* invalid format */
|
yuuji@0
|
227 close (fd); /* close the file */
|
yuuji@0
|
228 /* \Marked status? */
|
yuuji@0
|
229 if ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) {
|
yuuji@0
|
230 tp[0] = sbuf.st_atime; /* yes, preserve atime and mtime */
|
yuuji@0
|
231 tp[1] = sbuf.st_mtime;
|
yuuji@0
|
232 utime (file,tp); /* set the times */
|
yuuji@0
|
233 }
|
yuuji@0
|
234 }
|
yuuji@0
|
235 }
|
yuuji@0
|
236 return ret; /* return what we should */
|
yuuji@0
|
237 }
|
yuuji@0
|
238
|
yuuji@0
|
239 /* UNIX mail test for valid mailbox
|
yuuji@0
|
240 * Accepts: file descriptor
|
yuuji@0
|
241 * scratch buffer
|
yuuji@0
|
242 * Returns: T if valid, NIL otherwise
|
yuuji@0
|
243 */
|
yuuji@0
|
244
|
yuuji@0
|
245 long unix_isvalid_fd (int fd)
|
yuuji@0
|
246 {
|
yuuji@0
|
247 int zn;
|
yuuji@0
|
248 int ret = NIL;
|
yuuji@0
|
249 char tmp[MAILTMPLEN],*s,*t,c = '\n';
|
yuuji@0
|
250 memset (tmp,'\0',MAILTMPLEN);
|
yuuji@0
|
251 if (read (fd,tmp,MAILTMPLEN-1) >= 0) {
|
yuuji@0
|
252 for (s = tmp; (*s == '\r') || (*s == '\n') || (*s == ' ') || (*s == '\t');)
|
yuuji@0
|
253 c = *s++;
|
yuuji@0
|
254 if (c == '\n') VALID (s,t,ret,zn);
|
yuuji@0
|
255 }
|
yuuji@0
|
256 return ret; /* return what we should */
|
yuuji@0
|
257 }
|
yuuji@0
|
258
|
yuuji@0
|
259
|
yuuji@0
|
260 /* UNIX manipulate driver parameters
|
yuuji@0
|
261 * Accepts: function code
|
yuuji@0
|
262 * function-dependent value
|
yuuji@0
|
263 * Returns: function-dependent return value
|
yuuji@0
|
264 */
|
yuuji@0
|
265
|
yuuji@0
|
266 void *unix_parameters (long function,void *value)
|
yuuji@0
|
267 {
|
yuuji@0
|
268 void *ret = NIL;
|
yuuji@0
|
269 switch ((int) function) {
|
yuuji@0
|
270 case GET_INBOXPATH:
|
yuuji@0
|
271 if (value) ret = dummy_file ((char *) value,"INBOX");
|
yuuji@0
|
272 break;
|
yuuji@0
|
273 case SET_FROMWIDGET:
|
yuuji@0
|
274 unix_fromwidget = (long) value;
|
yuuji@0
|
275 case GET_FROMWIDGET:
|
yuuji@0
|
276 ret = (void *) unix_fromwidget;
|
yuuji@0
|
277 break;
|
yuuji@0
|
278 }
|
yuuji@0
|
279 return ret;
|
yuuji@0
|
280 }
|
yuuji@0
|
281
|
yuuji@0
|
282 /* UNIX mail scan mailboxes
|
yuuji@0
|
283 * Accepts: mail stream
|
yuuji@0
|
284 * reference
|
yuuji@0
|
285 * pattern to search
|
yuuji@0
|
286 * string to scan
|
yuuji@0
|
287 */
|
yuuji@0
|
288
|
yuuji@0
|
289 void unix_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
|
yuuji@0
|
290 {
|
yuuji@0
|
291 if (stream) dummy_scan (NIL,ref,pat,contents);
|
yuuji@0
|
292 }
|
yuuji@0
|
293
|
yuuji@0
|
294
|
yuuji@0
|
295 /* UNIX mail list mailboxes
|
yuuji@0
|
296 * Accepts: mail stream
|
yuuji@0
|
297 * reference
|
yuuji@0
|
298 * pattern to search
|
yuuji@0
|
299 */
|
yuuji@0
|
300
|
yuuji@0
|
301 void unix_list (MAILSTREAM *stream,char *ref,char *pat)
|
yuuji@0
|
302 {
|
yuuji@0
|
303 if (stream) dummy_list (NIL,ref,pat);
|
yuuji@0
|
304 }
|
yuuji@0
|
305
|
yuuji@0
|
306
|
yuuji@0
|
307 /* UNIX mail list subscribed mailboxes
|
yuuji@0
|
308 * Accepts: mail stream
|
yuuji@0
|
309 * reference
|
yuuji@0
|
310 * pattern to search
|
yuuji@0
|
311 */
|
yuuji@0
|
312
|
yuuji@0
|
313 void unix_lsub (MAILSTREAM *stream,char *ref,char *pat)
|
yuuji@0
|
314 {
|
yuuji@0
|
315 if (stream) dummy_lsub (NIL,ref,pat);
|
yuuji@0
|
316 }
|
yuuji@0
|
317
|
yuuji@0
|
318 /* UNIX mail create mailbox
|
yuuji@0
|
319 * Accepts: MAIL stream
|
yuuji@0
|
320 * mailbox name to create
|
yuuji@0
|
321 * Returns: T on success, NIL on failure
|
yuuji@0
|
322 */
|
yuuji@0
|
323
|
yuuji@0
|
324 long unix_create (MAILSTREAM *stream,char *mailbox)
|
yuuji@0
|
325 {
|
yuuji@0
|
326 char *s,mbx[MAILTMPLEN],tmp[MAILTMPLEN];
|
yuuji@0
|
327 long ret = NIL;
|
yuuji@0
|
328 int i,fd;
|
yuuji@0
|
329 time_t ti = time (0);
|
yuuji@0
|
330 if (!(s = dummy_file (mbx,mailbox))) {
|
yuuji@0
|
331 sprintf (tmp,"Can't create %.80s: invalid name",mailbox);
|
yuuji@0
|
332 MM_LOG (tmp,ERROR);
|
yuuji@0
|
333 }
|
yuuji@0
|
334 /* create underlying file */
|
yuuji@0
|
335 else if (dummy_create_path (stream,s,get_dir_protection (mailbox))) {
|
yuuji@0
|
336 /* done if dir-only or whiner */
|
yuuji@0
|
337 if (((s = strrchr (s,'/')) && !s[1]) ||
|
yuuji@0
|
338 mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) ret = T;
|
yuuji@0
|
339 else if ((fd = open (mbx,O_WRONLY,
|
yuuji@0
|
340 (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL))) < 0) {
|
yuuji@0
|
341 sprintf (tmp,"Can't reopen mailbox node %.80s: %s",mbx,strerror (errno));
|
yuuji@0
|
342 MM_LOG (tmp,ERROR);
|
yuuji@0
|
343 unlink (mbx); /* delete the file */
|
yuuji@0
|
344 }
|
yuuji@0
|
345 else { /* initialize header */
|
yuuji@0
|
346 memset (tmp,'\0',MAILTMPLEN);
|
yuuji@0
|
347 sprintf (tmp,"From %s %sDate: ",pseudo_from,ctime (&ti));
|
yuuji@0
|
348 rfc822_fixed_date (s = tmp + strlen (tmp));
|
yuuji@0
|
349 /* write the pseudo-header */
|
yuuji@0
|
350 sprintf (s += strlen (s),
|
yuuji@0
|
351 "\nFrom: %s <%s@%s>\nSubject: %s\nX-IMAP: %010lu 0000000000",
|
yuuji@0
|
352 pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
|
yuuji@0
|
353 (unsigned long) ti);
|
yuuji@0
|
354 for (i = 0; i < NUSERFLAGS; ++i) if (default_user_flag (i))
|
yuuji@0
|
355 sprintf (s += strlen (s)," %s",default_user_flag (i));
|
yuuji@0
|
356 sprintf (s += strlen (s),"\nStatus: RO\n\n%s\n\n",pseudo_msg);
|
yuuji@0
|
357 if (write (fd,tmp,strlen (tmp)) > 0) ret = T;
|
yuuji@0
|
358 else {
|
yuuji@0
|
359 sprintf (tmp,"Can't initialize mailbox node %.80s: %s",mbx,
|
yuuji@0
|
360 strerror (errno));
|
yuuji@0
|
361 MM_LOG (tmp,ERROR);
|
yuuji@0
|
362 unlink (mbx); /* delete the file */
|
yuuji@0
|
363 }
|
yuuji@0
|
364 close (fd); /* close file */
|
yuuji@0
|
365 }
|
yuuji@0
|
366 }
|
yuuji@0
|
367 /* set proper protections */
|
yuuji@0
|
368 return ret ? set_mbx_protections (mailbox,mbx) : NIL;
|
yuuji@0
|
369 }
|
yuuji@0
|
370
|
yuuji@0
|
371 /* UNIX mail delete mailbox
|
yuuji@0
|
372 * Accepts: MAIL stream
|
yuuji@0
|
373 * mailbox name to delete
|
yuuji@0
|
374 * Returns: T on success, NIL on failure
|
yuuji@0
|
375 */
|
yuuji@0
|
376
|
yuuji@0
|
377 long unix_delete (MAILSTREAM *stream,char *mailbox)
|
yuuji@0
|
378 {
|
yuuji@0
|
379 return unix_rename (stream,mailbox,NIL);
|
yuuji@0
|
380 }
|
yuuji@0
|
381
|
yuuji@0
|
382
|
yuuji@0
|
383 /* UNIX mail rename mailbox
|
yuuji@0
|
384 * Accepts: MAIL stream
|
yuuji@0
|
385 * old mailbox name
|
yuuji@0
|
386 * new mailbox name (or NIL for delete)
|
yuuji@0
|
387 * Returns: T on success, NIL on failure
|
yuuji@0
|
388 */
|
yuuji@0
|
389
|
yuuji@0
|
390 long unix_rename (MAILSTREAM *stream,char *old,char *newname)
|
yuuji@0
|
391 {
|
yuuji@0
|
392 long ret = NIL;
|
yuuji@0
|
393 char c,*s = NIL;
|
yuuji@0
|
394 char tmp[MAILTMPLEN],file[MAILTMPLEN],lock[MAILTMPLEN];
|
yuuji@0
|
395 DOTLOCK lockx;
|
yuuji@0
|
396 int fd,ld;
|
yuuji@0
|
397 long i;
|
yuuji@0
|
398 struct stat sbuf;
|
yuuji@0
|
399 MM_CRITICAL (stream); /* get the c-client lock */
|
yuuji@0
|
400 if (!dummy_file (file,old) ||
|
yuuji@0
|
401 (newname && (!((s = mailboxfile (tmp,newname)) && *s) ||
|
yuuji@0
|
402 ((s = strrchr (tmp,'/')) && !s[1]))))
|
yuuji@0
|
403 sprintf (tmp,newname ?
|
yuuji@0
|
404 "Can't rename mailbox %.80s to %.80s: invalid name" :
|
yuuji@0
|
405 "Can't delete mailbox %.80s: invalid name",
|
yuuji@0
|
406 old,newname);
|
yuuji@0
|
407 /* lock out other c-clients */
|
yuuji@0
|
408 else if ((ld = lockname (lock,file,LOCK_EX|LOCK_NB,&i)) < 0)
|
yuuji@0
|
409 sprintf (tmp,"Mailbox %.80s is in use by another process",old);
|
yuuji@0
|
410
|
yuuji@0
|
411 else {
|
yuuji@0
|
412 if ((fd = unix_lock (file,O_RDWR,
|
yuuji@0
|
413 (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
|
yuuji@0
|
414 &lockx,LOCK_EX)) < 0)
|
yuuji@0
|
415 sprintf (tmp,"Can't lock mailbox %.80s: %s",old,strerror (errno));
|
yuuji@0
|
416 else {
|
yuuji@0
|
417 if (newname) { /* want rename? */
|
yuuji@0
|
418 /* found superior to destination name? */
|
yuuji@0
|
419 if (s = strrchr (s,'/')) {
|
yuuji@0
|
420 c = *++s; /* remember first character of inferior */
|
yuuji@0
|
421 *s = '\0'; /* tie off to get just superior */
|
yuuji@0
|
422 /* name doesn't exist, create it */
|
yuuji@0
|
423 if ((stat (tmp,&sbuf) || ((sbuf.st_mode & S_IFMT) != S_IFDIR)) &&
|
yuuji@0
|
424 !dummy_create_path (stream,tmp,get_dir_protection (newname))) {
|
yuuji@0
|
425 unix_unlock (fd,NIL,&lockx);
|
yuuji@0
|
426 unix_unlock (ld,NIL,NIL);
|
yuuji@0
|
427 unlink (lock);
|
yuuji@0
|
428 MM_NOCRITICAL (stream);
|
yuuji@0
|
429 return ret; /* return success or failure */
|
yuuji@0
|
430 }
|
yuuji@0
|
431 *s = c; /* restore full name */
|
yuuji@0
|
432 }
|
yuuji@0
|
433 if (rename (file,tmp))
|
yuuji@0
|
434 sprintf (tmp,"Can't rename mailbox %.80s to %.80s: %s",old,newname,
|
yuuji@0
|
435 strerror (errno));
|
yuuji@0
|
436 else ret = T; /* set success */
|
yuuji@0
|
437 }
|
yuuji@0
|
438 else if (unlink (file))
|
yuuji@0
|
439 sprintf (tmp,"Can't delete mailbox %.80s: %s",old,strerror (errno));
|
yuuji@0
|
440 else ret = T; /* set success */
|
yuuji@0
|
441 unix_unlock (fd,NIL,&lockx);
|
yuuji@0
|
442 }
|
yuuji@0
|
443 unix_unlock (ld,NIL,NIL); /* flush the lock */
|
yuuji@0
|
444 unlink (lock);
|
yuuji@0
|
445 }
|
yuuji@0
|
446 MM_NOCRITICAL (stream); /* no longer critical */
|
yuuji@0
|
447 if (!ret) MM_LOG (tmp,ERROR); /* log error */
|
yuuji@0
|
448 return ret; /* return success or failure */
|
yuuji@0
|
449 }
|
yuuji@0
|
450
|
yuuji@0
|
451 /* UNIX mail open
|
yuuji@0
|
452 * Accepts: Stream to open
|
yuuji@0
|
453 * Returns: Stream on success, NIL on failure
|
yuuji@0
|
454 */
|
yuuji@0
|
455
|
yuuji@0
|
456 MAILSTREAM *unix_open (MAILSTREAM *stream)
|
yuuji@0
|
457 {
|
yuuji@0
|
458 long i;
|
yuuji@0
|
459 int fd;
|
yuuji@0
|
460 char tmp[MAILTMPLEN];
|
yuuji@0
|
461 DOTLOCK lock;
|
yuuji@0
|
462 long retry;
|
yuuji@0
|
463 /* return prototype for OP_PROTOTYPE call */
|
yuuji@0
|
464 if (!stream) return user_flags (&unixproto);
|
yuuji@0
|
465 retry = stream->silent ? 1 : KODRETRY;
|
yuuji@0
|
466 if (stream->local) fatal ("unix recycle stream");
|
yuuji@0
|
467 stream->local = memset (fs_get (sizeof (UNIXLOCAL)),0,sizeof (UNIXLOCAL));
|
yuuji@0
|
468 /* note if an INBOX or not */
|
yuuji@0
|
469 stream->inbox = !compare_cstring (stream->mailbox,"INBOX");
|
yuuji@0
|
470 /* canonicalize the stream mailbox name */
|
yuuji@0
|
471 if (!dummy_file (tmp,stream->mailbox)) {
|
yuuji@0
|
472 sprintf (tmp,"Can't open - invalid name: %.80s",stream->mailbox);
|
yuuji@0
|
473 MM_LOG (tmp,ERROR);
|
yuuji@0
|
474 return NIL;
|
yuuji@0
|
475 }
|
yuuji@0
|
476 /* flush old name */
|
yuuji@0
|
477 fs_give ((void **) &stream->mailbox);
|
yuuji@0
|
478 /* save canonical name */
|
yuuji@0
|
479 stream->mailbox = cpystr (tmp);
|
yuuji@0
|
480 LOCAL->fd = LOCAL->ld = -1; /* no file or state locking yet */
|
yuuji@0
|
481 LOCAL->buf = (char *) fs_get (CHUNKSIZE);
|
yuuji@0
|
482 LOCAL->buflen = CHUNKSIZE - 1;
|
yuuji@0
|
483 LOCAL->text.data = (unsigned char *) fs_get (CHUNKSIZE);
|
yuuji@0
|
484 LOCAL->text.size = CHUNKSIZE - 1;
|
yuuji@0
|
485 LOCAL->linebuf = (char *) fs_get (CHUNKSIZE);
|
yuuji@0
|
486 LOCAL->linebuflen = CHUNKSIZE - 1;
|
yuuji@0
|
487 stream->sequence++; /* bump sequence number */
|
yuuji@0
|
488
|
yuuji@0
|
489 /* make lock for read/write access */
|
yuuji@0
|
490 if (!stream->rdonly) while (retry) {
|
yuuji@0
|
491 /* try to lock file */
|
yuuji@0
|
492 if ((fd = lockname (tmp,stream->mailbox,LOCK_EX|LOCK_NB,&i)) < 0) {
|
yuuji@0
|
493 /* suppressing kiss-of-death? */
|
yuuji@0
|
494 if (stream->nokod) retry = 0;
|
yuuji@0
|
495 /* no, first time through? */
|
yuuji@0
|
496 else if (retry-- == KODRETRY) {
|
yuuji@0
|
497 /* learned other guy's PID and can signal? */
|
yuuji@0
|
498 if (i && !kill ((int) i,SIGUSR2)) {
|
yuuji@0
|
499 sprintf (tmp,"Trying to get mailbox lock from process %ld",i);
|
yuuji@0
|
500 MM_LOG (tmp,WARN);
|
yuuji@0
|
501 }
|
yuuji@0
|
502 else retry = 0; /* give up */
|
yuuji@0
|
503 }
|
yuuji@0
|
504 if (!stream->silent) { /* nothing if silent stream */
|
yuuji@0
|
505 if (retry) sleep (1); /* wait a second before trying again */
|
yuuji@0
|
506 else MM_LOG ("Mailbox is open by another process, access is readonly",
|
yuuji@0
|
507 WARN);
|
yuuji@0
|
508 }
|
yuuji@0
|
509 }
|
yuuji@0
|
510 else { /* got the lock, nobody else can alter state */
|
yuuji@0
|
511 LOCAL->ld = fd; /* note lock's fd and name */
|
yuuji@0
|
512 LOCAL->lname = cpystr (tmp);
|
yuuji@0
|
513 /* make sure mode OK (don't use fchmod()) */
|
yuuji@0
|
514 chmod (LOCAL->lname,(long) mail_parameters (NIL,GET_LOCKPROTECTION,NIL));
|
yuuji@0
|
515 if (stream->silent) i = 0;/* silent streams won't accept KOD */
|
yuuji@0
|
516 else { /* note our PID in the lock */
|
yuuji@0
|
517 sprintf (tmp,"%d",getpid ());
|
yuuji@0
|
518 write (fd,tmp,(i = strlen (tmp))+1);
|
yuuji@0
|
519 }
|
yuuji@0
|
520 ftruncate (fd,i); /* make sure tied off */
|
yuuji@0
|
521 fsync (fd); /* make sure it's available */
|
yuuji@0
|
522 retry = 0; /* no more need to try */
|
yuuji@0
|
523 }
|
yuuji@0
|
524 }
|
yuuji@0
|
525
|
yuuji@0
|
526 /* parse mailbox */
|
yuuji@0
|
527 stream->nmsgs = stream->recent = 0;
|
yuuji@0
|
528 /* will we be able to get write access? */
|
yuuji@0
|
529 if ((LOCAL->ld >= 0) && access (stream->mailbox,W_OK) && (errno == EACCES)) {
|
yuuji@0
|
530 MM_LOG ("Can't get write access to mailbox, access is readonly",WARN);
|
yuuji@0
|
531 flock (LOCAL->ld,LOCK_UN); /* release the lock */
|
yuuji@0
|
532 close (LOCAL->ld); /* close the lock file */
|
yuuji@0
|
533 LOCAL->ld = -1; /* no more lock fd */
|
yuuji@0
|
534 unlink (LOCAL->lname); /* delete it */
|
yuuji@0
|
535 }
|
yuuji@0
|
536 /* reset UID validity */
|
yuuji@0
|
537 stream->uid_validity = stream->uid_last = 0;
|
yuuji@0
|
538 if (stream->silent && !stream->rdonly && (LOCAL->ld < 0))
|
yuuji@0
|
539 unix_abort (stream); /* abort if can't get RW silent stream */
|
yuuji@0
|
540 /* parse mailbox */
|
yuuji@0
|
541 else if (unix_parse (stream,&lock,LOCK_SH)) {
|
yuuji@0
|
542 unix_unlock (LOCAL->fd,stream,&lock);
|
yuuji@0
|
543 mail_unlock (stream);
|
yuuji@0
|
544 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
545 }
|
yuuji@0
|
546 if (!LOCAL) return NIL; /* failure if stream died */
|
yuuji@0
|
547 /* make sure upper level knows readonly */
|
yuuji@0
|
548 stream->rdonly = (LOCAL->ld < 0);
|
yuuji@0
|
549 /* notify about empty mailbox */
|
yuuji@0
|
550 if (!(stream->nmsgs || stream->silent)) MM_LOG ("Mailbox is empty",NIL);
|
yuuji@0
|
551 if (!stream->rdonly) { /* flags stick if readwrite */
|
yuuji@0
|
552 stream->perm_seen = stream->perm_deleted =
|
yuuji@0
|
553 stream->perm_flagged = stream->perm_answered = stream->perm_draft = T;
|
yuuji@0
|
554 if (!stream->uid_nosticky) {/* users with lives get permanent keywords */
|
yuuji@0
|
555 stream->perm_user_flags = 0xffffffff;
|
yuuji@0
|
556 /* and maybe can create them too! */
|
yuuji@0
|
557 stream->kwd_create = stream->user_flags[NUSERFLAGS-1] ? NIL : T;
|
yuuji@0
|
558 }
|
yuuji@0
|
559 }
|
yuuji@0
|
560 return stream; /* return stream alive to caller */
|
yuuji@0
|
561 }
|
yuuji@0
|
562
|
yuuji@0
|
563
|
yuuji@0
|
564 /* UNIX mail close
|
yuuji@0
|
565 * Accepts: MAIL stream
|
yuuji@0
|
566 * close options
|
yuuji@0
|
567 */
|
yuuji@0
|
568
|
yuuji@0
|
569 void unix_close (MAILSTREAM *stream,long options)
|
yuuji@0
|
570 {
|
yuuji@0
|
571 int silent = stream->silent;
|
yuuji@0
|
572 stream->silent = T; /* go silent */
|
yuuji@0
|
573 /* expunge if requested */
|
yuuji@0
|
574 if (options & CL_EXPUNGE) unix_expunge (stream,NIL,NIL);
|
yuuji@0
|
575 /* else dump final checkpoint */
|
yuuji@0
|
576 else if (LOCAL->dirty) unix_check (stream);
|
yuuji@0
|
577 stream->silent = silent; /* restore old silence state */
|
yuuji@0
|
578 unix_abort (stream); /* now punt the file and local data */
|
yuuji@0
|
579 }
|
yuuji@0
|
580
|
yuuji@0
|
581 /* UNIX mail fetch message header
|
yuuji@0
|
582 * Accepts: MAIL stream
|
yuuji@0
|
583 * message # to fetch
|
yuuji@0
|
584 * pointer to returned header text length
|
yuuji@0
|
585 * option flags
|
yuuji@0
|
586 * Returns: message header in RFC822 format
|
yuuji@0
|
587 */
|
yuuji@0
|
588
|
yuuji@0
|
589 /* lines to filter from header */
|
yuuji@0
|
590 static STRINGLIST *unix_hlines = NIL;
|
yuuji@0
|
591
|
yuuji@0
|
592 char *unix_header (MAILSTREAM *stream,unsigned long msgno,
|
yuuji@0
|
593 unsigned long *length,long flags)
|
yuuji@0
|
594 {
|
yuuji@0
|
595 MESSAGECACHE *elt;
|
yuuji@0
|
596 unsigned char *s,*t,*tl;
|
yuuji@0
|
597 *length = 0; /* default to empty */
|
yuuji@0
|
598 if (flags & FT_UID) return "";/* UID call "impossible" */
|
yuuji@0
|
599 elt = mail_elt (stream,msgno);/* get cache */
|
yuuji@0
|
600 if (!unix_hlines) { /* once only code */
|
yuuji@0
|
601 STRINGLIST *lines = unix_hlines = mail_newstringlist ();
|
yuuji@0
|
602 lines->text.size = strlen ((char *) (lines->text.data =
|
yuuji@0
|
603 (unsigned char *) "Status"));
|
yuuji@0
|
604 lines = lines->next = mail_newstringlist ();
|
yuuji@0
|
605 lines->text.size = strlen ((char *) (lines->text.data =
|
yuuji@0
|
606 (unsigned char *) "X-Status"));
|
yuuji@0
|
607 lines = lines->next = mail_newstringlist ();
|
yuuji@0
|
608 lines->text.size = strlen ((char *) (lines->text.data =
|
yuuji@0
|
609 (unsigned char *) "X-Keywords"));
|
yuuji@0
|
610 lines = lines->next = mail_newstringlist ();
|
yuuji@0
|
611 lines->text.size = strlen ((char *) (lines->text.data =
|
yuuji@0
|
612 (unsigned char *) "X-UID"));
|
yuuji@0
|
613 lines = lines->next = mail_newstringlist ();
|
yuuji@0
|
614 lines->text.size = strlen ((char *) (lines->text.data =
|
yuuji@0
|
615 (unsigned char *) "X-IMAP"));
|
yuuji@0
|
616 lines = lines->next = mail_newstringlist ();
|
yuuji@0
|
617 lines->text.size = strlen ((char *) (lines->text.data =
|
yuuji@0
|
618 (unsigned char *) "X-IMAPbase"));
|
yuuji@0
|
619 }
|
yuuji@0
|
620 /* go to header position */
|
yuuji@0
|
621 lseek (LOCAL->fd,elt->private.special.offset +
|
yuuji@0
|
622 elt->private.msg.header.offset,L_SET);
|
yuuji@0
|
623
|
yuuji@0
|
624 if (flags & FT_INTERNAL) { /* initial data OK? */
|
yuuji@0
|
625 if (elt->private.msg.header.text.size > LOCAL->buflen) {
|
yuuji@0
|
626 fs_give ((void **) &LOCAL->buf);
|
yuuji@0
|
627 LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
|
yuuji@0
|
628 elt->private.msg.header.text.size) + 1);
|
yuuji@0
|
629 }
|
yuuji@0
|
630 /* read message */
|
yuuji@0
|
631 read (LOCAL->fd,LOCAL->buf,elt->private.msg.header.text.size);
|
yuuji@0
|
632 /* got text, tie off string */
|
yuuji@0
|
633 LOCAL->buf[*length = elt->private.msg.header.text.size] = '\0';
|
yuuji@0
|
634 /* squeeze out CRs (in case from PC) */
|
yuuji@0
|
635 for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
|
yuuji@0
|
636 if (*t != '\r') *s++ = *t;
|
yuuji@0
|
637 *s = '\0';
|
yuuji@0
|
638 *length = s - LOCAL->buf; /* adjust length */
|
yuuji@0
|
639 }
|
yuuji@0
|
640 else { /* need to make a CRLF version */
|
yuuji@0
|
641 read (LOCAL->fd,s = (char *) fs_get (elt->private.msg.header.text.size+1),
|
yuuji@0
|
642 elt->private.msg.header.text.size);
|
yuuji@0
|
643 /* tie off string, and convert to CRLF */
|
yuuji@0
|
644 s[elt->private.msg.header.text.size] = '\0';
|
yuuji@0
|
645 *length = strcrlfcpy (&LOCAL->buf,&LOCAL->buflen,s,
|
yuuji@0
|
646 elt->private.msg.header.text.size);
|
yuuji@0
|
647 fs_give ((void **) &s); /* free readin buffer */
|
yuuji@0
|
648 /* squeeze out spurious CRs */
|
yuuji@0
|
649 for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
|
yuuji@0
|
650 if ((*t != '\r') || (t[1] == '\n')) *s++ = *t;
|
yuuji@0
|
651 *s = '\0';
|
yuuji@0
|
652 *length = s - LOCAL->buf; /* adjust length */
|
yuuji@0
|
653 }
|
yuuji@0
|
654 *length = mail_filter (LOCAL->buf,*length,unix_hlines,FT_NOT);
|
yuuji@0
|
655 return (char *) LOCAL->buf; /* return processed copy */
|
yuuji@0
|
656 }
|
yuuji@0
|
657
|
yuuji@0
|
658 /* UNIX mail fetch message text
|
yuuji@0
|
659 * Accepts: MAIL stream
|
yuuji@0
|
660 * message # to fetch
|
yuuji@0
|
661 * pointer to returned stringstruct
|
yuuji@0
|
662 * option flags
|
yuuji@0
|
663 * Returns: T on success, NIL if failure
|
yuuji@0
|
664 */
|
yuuji@0
|
665
|
yuuji@0
|
666 long unix_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
|
yuuji@0
|
667 {
|
yuuji@0
|
668 char *s;
|
yuuji@0
|
669 unsigned long i;
|
yuuji@0
|
670 MESSAGECACHE *elt;
|
yuuji@0
|
671 /* UID call "impossible" */
|
yuuji@0
|
672 if (flags & FT_UID) return NIL;
|
yuuji@0
|
673 elt = mail_elt (stream,msgno);/* get cache element */
|
yuuji@0
|
674 /* if message not seen */
|
yuuji@0
|
675 if (!(flags & FT_PEEK) && !elt->seen) {
|
yuuji@0
|
676 /* mark message seen and dirty */
|
yuuji@0
|
677 elt->seen = elt->private.dirty = LOCAL->dirty = T;
|
yuuji@0
|
678 MM_FLAGS (stream,msgno);
|
yuuji@0
|
679 }
|
yuuji@0
|
680 s = unix_text_work (stream,elt,&i,flags);
|
yuuji@0
|
681 INIT (bs,mail_string,s,i); /* set up stringstruct */
|
yuuji@0
|
682 return T; /* success */
|
yuuji@0
|
683 }
|
yuuji@0
|
684
|
yuuji@0
|
685 /* UNIX mail fetch message text worker routine
|
yuuji@0
|
686 * Accepts: MAIL stream
|
yuuji@0
|
687 * message cache element
|
yuuji@0
|
688 * pointer to returned header text length
|
yuuji@0
|
689 * option flags
|
yuuji@0
|
690 */
|
yuuji@0
|
691
|
yuuji@0
|
692 char *unix_text_work (MAILSTREAM *stream,MESSAGECACHE *elt,
|
yuuji@0
|
693 unsigned long *length,long flags)
|
yuuji@0
|
694 {
|
yuuji@0
|
695 FDDATA d;
|
yuuji@0
|
696 STRING bs;
|
yuuji@0
|
697 unsigned char c,*s,*t,*tl,tmp[CHUNKSIZE];
|
yuuji@0
|
698 /* go to text position */
|
yuuji@0
|
699 lseek (LOCAL->fd,elt->private.special.offset +
|
yuuji@0
|
700 elt->private.msg.text.offset,L_SET);
|
yuuji@0
|
701 if (flags & FT_INTERNAL) { /* initial data OK? */
|
yuuji@0
|
702 if (elt->private.msg.text.text.size > LOCAL->buflen) {
|
yuuji@0
|
703 fs_give ((void **) &LOCAL->buf);
|
yuuji@0
|
704 LOCAL->buf = (char *) fs_get ((LOCAL->buflen =
|
yuuji@0
|
705 elt->private.msg.text.text.size) + 1);
|
yuuji@0
|
706 }
|
yuuji@0
|
707 /* read message */
|
yuuji@0
|
708 read (LOCAL->fd,LOCAL->buf,elt->private.msg.text.text.size);
|
yuuji@0
|
709 /* got text, tie off string */
|
yuuji@0
|
710 LOCAL->buf[*length = elt->private.msg.text.text.size] = '\0';
|
yuuji@0
|
711 /* squeeze out CRs (in case from PC) */
|
yuuji@0
|
712 for (s = t = LOCAL->buf,tl = LOCAL->buf + *length; t < tl; t++)
|
yuuji@0
|
713 if (*t != '\r') *s++ = *t;
|
yuuji@0
|
714 *s = '\0';
|
yuuji@0
|
715 *length = s - LOCAL->buf; /* adjust length */
|
yuuji@0
|
716 return (char *) LOCAL->buf;
|
yuuji@0
|
717 }
|
yuuji@0
|
718
|
yuuji@0
|
719 /* have it cached already? */
|
yuuji@0
|
720 if (elt->private.uid != LOCAL->uid) {
|
yuuji@0
|
721 /* not cached, cache it now */
|
yuuji@0
|
722 LOCAL->uid = elt->private.uid;
|
yuuji@0
|
723 /* is buffer big enough? */
|
yuuji@0
|
724 if (elt->rfc822_size > LOCAL->text.size) {
|
yuuji@0
|
725 /* excessively conservative, but the right thing is too hard to do */
|
yuuji@0
|
726 fs_give ((void **) &LOCAL->text.data);
|
yuuji@0
|
727 LOCAL->text.data = (unsigned char *)
|
yuuji@0
|
728 fs_get ((LOCAL->text.size = elt->rfc822_size) + 1);
|
yuuji@0
|
729 }
|
yuuji@0
|
730 d.fd = LOCAL->fd; /* yes, set up file descriptor */
|
yuuji@0
|
731 d.pos = elt->private.special.offset + elt->private.msg.text.offset;
|
yuuji@0
|
732 d.chunk = tmp; /* initial buffer chunk */
|
yuuji@0
|
733 d.chunksize = CHUNKSIZE; /* file chunk size */
|
yuuji@0
|
734 INIT (&bs,fd_string,&d,elt->private.msg.text.text.size);
|
yuuji@0
|
735 for (s = (char *) LOCAL->text.data; SIZE (&bs);) switch (c = SNX (&bs)) {
|
yuuji@0
|
736 case '\r': /* carriage return seen */
|
yuuji@0
|
737 break;
|
yuuji@0
|
738 case '\n':
|
yuuji@0
|
739 *s++ = '\r'; /* insert a CR */
|
yuuji@0
|
740 default:
|
yuuji@0
|
741 *s++ = c; /* copy characters */
|
yuuji@0
|
742 }
|
yuuji@0
|
743 *s = '\0'; /* tie off buffer */
|
yuuji@0
|
744 /* calculate length of cached data */
|
yuuji@0
|
745 LOCAL->textlen = s - LOCAL->text.data;
|
yuuji@0
|
746 }
|
yuuji@0
|
747 *length = LOCAL->textlen; /* return from cache */
|
yuuji@0
|
748 return (char *) LOCAL->text.data;
|
yuuji@0
|
749 }
|
yuuji@0
|
750
|
yuuji@0
|
751 /* UNIX per-message modify flag
|
yuuji@0
|
752 * Accepts: MAIL stream
|
yuuji@0
|
753 * message cache element
|
yuuji@0
|
754 */
|
yuuji@0
|
755
|
yuuji@0
|
756 void unix_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
|
yuuji@0
|
757 {
|
yuuji@0
|
758 /* only after finishing */
|
yuuji@0
|
759 if (elt->valid) elt->private.dirty = LOCAL->dirty = T;
|
yuuji@0
|
760 }
|
yuuji@0
|
761
|
yuuji@0
|
762
|
yuuji@0
|
763 /* UNIX mail ping mailbox
|
yuuji@0
|
764 * Accepts: MAIL stream
|
yuuji@0
|
765 * Returns: T if stream alive, else NIL
|
yuuji@0
|
766 */
|
yuuji@0
|
767
|
yuuji@0
|
768 long unix_ping (MAILSTREAM *stream)
|
yuuji@0
|
769 {
|
yuuji@0
|
770 DOTLOCK lock;
|
yuuji@0
|
771 struct stat sbuf;
|
yuuji@0
|
772 long reparse;
|
yuuji@0
|
773 /* big no-op if not readwrite */
|
yuuji@0
|
774 if (LOCAL && (LOCAL->ld >= 0) && !stream->lock) {
|
yuuji@0
|
775 if (stream->rdonly) { /* does he want to give up readwrite? */
|
yuuji@0
|
776 /* checkpoint if we changed something */
|
yuuji@0
|
777 if (LOCAL->dirty) unix_check (stream);
|
yuuji@0
|
778 flock (LOCAL->ld,LOCK_UN);/* release readwrite lock */
|
yuuji@0
|
779 close (LOCAL->ld); /* close the readwrite lock file */
|
yuuji@0
|
780 LOCAL->ld = -1; /* no more readwrite lock fd */
|
yuuji@0
|
781 unlink (LOCAL->lname); /* delete the readwrite lock file */
|
yuuji@0
|
782 }
|
yuuji@0
|
783 else { /* see if need to reparse */
|
yuuji@0
|
784 if (!(reparse = (long) mail_parameters (NIL,GET_NETFSSTATBUG,NIL))) {
|
yuuji@0
|
785 /* get current mailbox size */
|
yuuji@0
|
786 if (LOCAL->fd >= 0) fstat (LOCAL->fd,&sbuf);
|
yuuji@0
|
787 else if (stat (stream->mailbox,&sbuf)) {
|
yuuji@0
|
788 sprintf (LOCAL->buf,"Mailbox stat failed, aborted: %s",
|
yuuji@0
|
789 strerror (errno));
|
yuuji@0
|
790 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
791 unix_abort (stream);
|
yuuji@0
|
792 return NIL;
|
yuuji@0
|
793 }
|
yuuji@0
|
794 reparse = (sbuf.st_size != LOCAL->filesize);
|
yuuji@0
|
795 }
|
yuuji@0
|
796 /* parse if mailbox changed */
|
yuuji@0
|
797 if ((LOCAL->ddirty || reparse) && unix_parse (stream,&lock,LOCK_EX)) {
|
yuuji@0
|
798 /* force checkpoint if double-dirty */
|
yuuji@0
|
799 if (LOCAL->ddirty) unix_rewrite (stream,NIL,&lock,NIL);
|
yuuji@0
|
800 /* unlock mailbox */
|
yuuji@0
|
801 else unix_unlock (LOCAL->fd,stream,&lock);
|
yuuji@0
|
802 mail_unlock (stream); /* and stream */
|
yuuji@0
|
803 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
804 }
|
yuuji@0
|
805 }
|
yuuji@0
|
806 }
|
yuuji@0
|
807 return LOCAL ? LONGT : NIL; /* return if still alive */
|
yuuji@0
|
808 }
|
yuuji@0
|
809
|
yuuji@0
|
810 /* UNIX mail check mailbox
|
yuuji@0
|
811 * Accepts: MAIL stream
|
yuuji@0
|
812 */
|
yuuji@0
|
813
|
yuuji@0
|
814 void unix_check (MAILSTREAM *stream)
|
yuuji@0
|
815 {
|
yuuji@0
|
816 DOTLOCK lock;
|
yuuji@0
|
817 /* parse and lock mailbox */
|
yuuji@0
|
818 if (LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
|
yuuji@0
|
819 unix_parse (stream,&lock,LOCK_EX)) {
|
yuuji@0
|
820 /* any unsaved changes? */
|
yuuji@0
|
821 if (LOCAL->dirty && unix_rewrite (stream,NIL,&lock,NIL)) {
|
yuuji@0
|
822 if (!stream->silent) MM_LOG ("Checkpoint completed",NIL);
|
yuuji@0
|
823 }
|
yuuji@0
|
824 /* no checkpoint needed, just unlock */
|
yuuji@0
|
825 else unix_unlock (LOCAL->fd,stream,&lock);
|
yuuji@0
|
826 mail_unlock (stream); /* unlock the stream */
|
yuuji@0
|
827 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
828 }
|
yuuji@0
|
829 }
|
yuuji@0
|
830
|
yuuji@0
|
831
|
yuuji@0
|
832 /* UNIX mail expunge mailbox
|
yuuji@0
|
833 * Accepts: MAIL stream
|
yuuji@0
|
834 * sequence to expunge if non-NIL
|
yuuji@0
|
835 * expunge options
|
yuuji@0
|
836 * Returns: T, always
|
yuuji@0
|
837 */
|
yuuji@0
|
838
|
yuuji@0
|
839 long unix_expunge (MAILSTREAM *stream,char *sequence,long options)
|
yuuji@0
|
840 {
|
yuuji@0
|
841 long ret;
|
yuuji@0
|
842 unsigned long i;
|
yuuji@0
|
843 DOTLOCK lock;
|
yuuji@0
|
844 char *msg = NIL;
|
yuuji@0
|
845 /* parse and lock mailbox */
|
yuuji@0
|
846 if (ret = (sequence ? ((options & EX_UID) ?
|
yuuji@0
|
847 mail_uid_sequence (stream,sequence) :
|
yuuji@0
|
848 mail_sequence (stream,sequence)) : LONGT) &&
|
yuuji@0
|
849 LOCAL && (LOCAL->ld >= 0) && !stream->lock &&
|
yuuji@0
|
850 unix_parse (stream,&lock,LOCK_EX)) {
|
yuuji@0
|
851 /* check expunged messages if not dirty */
|
yuuji@0
|
852 for (i = 1; !LOCAL->dirty && (i <= stream->nmsgs); i++) {
|
yuuji@0
|
853 MESSAGECACHE *elt = mail_elt (stream,i);
|
yuuji@0
|
854 if (mail_elt (stream,i)->deleted) LOCAL->dirty = T;
|
yuuji@0
|
855 }
|
yuuji@0
|
856 if (!LOCAL->dirty) { /* not dirty and no expunged messages */
|
yuuji@0
|
857 unix_unlock (LOCAL->fd,stream,&lock);
|
yuuji@0
|
858 msg = "No messages deleted, so no update needed";
|
yuuji@0
|
859 }
|
yuuji@0
|
860 else if (unix_rewrite (stream,&i,&lock,sequence ? LONGT : NIL)) {
|
yuuji@0
|
861 if (i) sprintf (msg = LOCAL->buf,"Expunged %lu messages",i);
|
yuuji@0
|
862 else msg = "Mailbox checkpointed, but no messages expunged";
|
yuuji@0
|
863 }
|
yuuji@0
|
864 /* rewrite failed */
|
yuuji@0
|
865 else unix_unlock (LOCAL->fd,stream,&lock);
|
yuuji@0
|
866 mail_unlock (stream); /* unlock the stream */
|
yuuji@0
|
867 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
868 if (msg && !stream->silent) MM_LOG (msg,NIL);
|
yuuji@0
|
869 }
|
yuuji@0
|
870 else if (!stream->silent) MM_LOG("Expunge ignored on readonly mailbox",WARN);
|
yuuji@0
|
871 return ret;
|
yuuji@0
|
872 }
|
yuuji@0
|
873
|
yuuji@0
|
874 /* UNIX mail copy message(s)
|
yuuji@0
|
875 * Accepts: MAIL stream
|
yuuji@0
|
876 * sequence
|
yuuji@0
|
877 * destination mailbox
|
yuuji@0
|
878 * copy options
|
yuuji@0
|
879 * Returns: T if copy successful, else NIL
|
yuuji@0
|
880 */
|
yuuji@0
|
881
|
yuuji@0
|
882 long unix_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
|
yuuji@0
|
883 {
|
yuuji@0
|
884 struct stat sbuf;
|
yuuji@0
|
885 int fd;
|
yuuji@0
|
886 char *s,file[MAILTMPLEN];
|
yuuji@0
|
887 DOTLOCK lock;
|
yuuji@0
|
888 time_t tp[2];
|
yuuji@0
|
889 unsigned long i,j;
|
yuuji@0
|
890 MESSAGECACHE *elt;
|
yuuji@0
|
891 long ret = T;
|
yuuji@0
|
892 mailproxycopy_t pc =
|
yuuji@0
|
893 (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
|
yuuji@0
|
894 copyuid_t cu = (copyuid_t) (mail_parameters (NIL,GET_USERHASNOLIFE,NIL) ?
|
yuuji@0
|
895 NIL : mail_parameters (NIL,GET_COPYUID,NIL));
|
yuuji@0
|
896 SEARCHSET *source = cu ? mail_newsearchset () : NIL;
|
yuuji@0
|
897 SEARCHSET *dest = cu ? mail_newsearchset () : NIL;
|
yuuji@0
|
898 MAILSTREAM *tstream = NIL;
|
yuuji@0
|
899 DRIVER *d;
|
yuuji@0
|
900 for (d = (DRIVER *) mail_parameters (NIL,GET_DRIVERS,NIL);
|
yuuji@0
|
901 (d && strcmp (d->name,"mbox") && !(d->flags & DR_DISABLE));
|
yuuji@0
|
902 d = d->next); /* see if mbox driver active */
|
yuuji@0
|
903 if (!((options & CP_UID) ? mail_uid_sequence (stream,sequence) :
|
yuuji@0
|
904 mail_sequence (stream,sequence))) return NIL;
|
yuuji@0
|
905 /* make sure destination is valid */
|
yuuji@0
|
906 if (!((d && mbox_valid (mailbox) && (mailbox = "mbox")) ||
|
yuuji@0
|
907 unix_valid (mailbox) || !errno))
|
yuuji@0
|
908 switch (errno) {
|
yuuji@0
|
909 case ENOENT: /* no such file? */
|
yuuji@0
|
910 if (compare_cstring (mailbox,"INBOX")) {
|
yuuji@0
|
911 MM_NOTIFY (stream,"[TRYCREATE] Must create mailbox before copy",NIL);
|
yuuji@0
|
912 return NIL;
|
yuuji@0
|
913 }
|
yuuji@0
|
914 if (pc) return (*pc) (stream,sequence,mailbox,options);
|
yuuji@0
|
915 unix_create (NIL,"INBOX");/* create empty INBOX */
|
yuuji@0
|
916 case EACCES: /* file protected */
|
yuuji@0
|
917 sprintf (LOCAL->buf,"Can't access destination: %.80s",mailbox);
|
yuuji@0
|
918 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
919 return NIL;
|
yuuji@0
|
920 case EINVAL:
|
yuuji@0
|
921 if (pc) return (*pc) (stream,sequence,mailbox,options);
|
yuuji@0
|
922 sprintf (LOCAL->buf,"Invalid UNIX-format mailbox name: %.80s",mailbox);
|
yuuji@0
|
923 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
924 return NIL;
|
yuuji@0
|
925 default:
|
yuuji@0
|
926 if (pc) return (*pc) (stream,sequence,mailbox,options);
|
yuuji@0
|
927 sprintf (LOCAL->buf,"Not a UNIX-format mailbox: %.80s",mailbox);
|
yuuji@0
|
928 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
929 return NIL;
|
yuuji@0
|
930 }
|
yuuji@0
|
931
|
yuuji@0
|
932 /* try to open rewrite for UIDPLUS */
|
yuuji@0
|
933 if ((tstream = mail_open_work (&unixdriver,NIL,mailbox,
|
yuuji@0
|
934 OP_SILENT|OP_NOKOD)) && tstream->rdonly)
|
yuuji@0
|
935 tstream = mail_close (tstream);
|
yuuji@0
|
936 if (cu && !tstream) { /* wanted a COPYUID? */
|
yuuji@0
|
937 sprintf (LOCAL->buf,"Unable to write-open mailbox for COPYUID: %.80s",
|
yuuji@0
|
938 mailbox);
|
yuuji@0
|
939 MM_LOG (LOCAL->buf,WARN);
|
yuuji@0
|
940 cu = NIL; /* don't try to do COPYUID */
|
yuuji@0
|
941 }
|
yuuji@0
|
942 LOCAL->buf[0] = '\0';
|
yuuji@0
|
943 MM_CRITICAL (stream); /* go critical */
|
yuuji@0
|
944 if ((fd = unix_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND,
|
yuuji@0
|
945 (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
|
yuuji@0
|
946 &lock,LOCK_EX)) < 0) {
|
yuuji@0
|
947 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
948 sprintf (LOCAL->buf,"Can't open destination mailbox: %s",strerror (errno));
|
yuuji@0
|
949 MM_LOG (LOCAL->buf,ERROR);/* log the error */
|
yuuji@0
|
950 return NIL; /* failed */
|
yuuji@0
|
951 }
|
yuuji@0
|
952 fstat (fd,&sbuf); /* get current file size */
|
yuuji@0
|
953 /* write all requested messages to mailbox */
|
yuuji@0
|
954 for (i = 1; ret && (i <= stream->nmsgs); i++)
|
yuuji@0
|
955 if ((elt = mail_elt (stream,i))->sequence) {
|
yuuji@0
|
956 lseek (LOCAL->fd,elt->private.special.offset,L_SET);
|
yuuji@0
|
957 read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
|
yuuji@0
|
958 if (write (fd,LOCAL->buf,elt->private.special.text.size) < 0) ret = NIL;
|
yuuji@0
|
959 else { /* internal header succeeded */
|
yuuji@0
|
960 s = unix_header (stream,i,&j,FT_INTERNAL);
|
yuuji@0
|
961 /* header size, sans trailing newline */
|
yuuji@0
|
962 if (j && (s[j - 2] == '\n')) j--;
|
yuuji@0
|
963 if (write (fd,s,j) < 0) ret = NIL;
|
yuuji@0
|
964 else { /* message header succeeded */
|
yuuji@0
|
965 j = tstream ? /* write UIDPLUS data if have readwrite */
|
yuuji@0
|
966 unix_xstatus (stream,LOCAL->buf,elt,++(tstream->uid_last),LONGT) :
|
yuuji@0
|
967 unix_xstatus (stream,LOCAL->buf,elt,NIL,NIL);
|
yuuji@0
|
968 if (write (fd,LOCAL->buf,j) < 0) ret = NIL;
|
yuuji@0
|
969 else { /* message status succeeded */
|
yuuji@0
|
970 s = unix_text_work (stream,elt,&j,FT_INTERNAL);
|
yuuji@0
|
971 if ((write (fd,s,j) < 0) || (write (fd,"\n",1) < 0)) ret = NIL;
|
yuuji@0
|
972 else if (cu) { /* need to pass back new UID? */
|
yuuji@0
|
973 mail_append_set (source,mail_uid (stream,i));
|
yuuji@0
|
974 mail_append_set (dest,tstream->uid_last);
|
yuuji@0
|
975 }
|
yuuji@0
|
976 }
|
yuuji@0
|
977 }
|
yuuji@0
|
978 }
|
yuuji@0
|
979 }
|
yuuji@0
|
980
|
yuuji@0
|
981 if (!ret || fsync (fd)) { /* force out the update */
|
yuuji@0
|
982 sprintf (LOCAL->buf,"Message copy failed: %s",strerror (errno));
|
yuuji@0
|
983 ftruncate (fd,sbuf.st_size);
|
yuuji@0
|
984 ret = NIL;
|
yuuji@0
|
985 }
|
yuuji@0
|
986 /* force UIDVALIDITY assignment now */
|
yuuji@0
|
987 if (tstream && !tstream->uid_validity) tstream->uid_validity = time (0);
|
yuuji@0
|
988 /* return sets if doing COPYUID */
|
yuuji@0
|
989 if (cu && ret) (*cu) (stream,mailbox,tstream->uid_validity,source,dest);
|
yuuji@0
|
990 else { /* flush any sets we may have built */
|
yuuji@0
|
991 mail_free_searchset (&source);
|
yuuji@0
|
992 mail_free_searchset (&dest);
|
yuuji@0
|
993 }
|
yuuji@0
|
994 tp[1] = time (0); /* set mtime to now */
|
yuuji@0
|
995 if (ret) tp[0] = tp[1] - 1; /* set atime to now-1 if successful copy */
|
yuuji@0
|
996 else tp[0] = /* else preserve \Marked status */
|
yuuji@0
|
997 ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) ?
|
yuuji@0
|
998 sbuf.st_atime : tp[1];
|
yuuji@0
|
999 utime (file,tp); /* set the times */
|
yuuji@0
|
1000 unix_unlock (fd,NIL,&lock); /* unlock and close mailbox */
|
yuuji@0
|
1001 if (tstream) { /* update last UID if we can */
|
yuuji@0
|
1002 UNIXLOCAL *local = (UNIXLOCAL *) tstream->local;
|
yuuji@0
|
1003 local->dirty = T; /* do a rewrite */
|
yuuji@0
|
1004 local->appending = T; /* but not at the cost of marking as old */
|
yuuji@0
|
1005 tstream = mail_close (tstream);
|
yuuji@0
|
1006 }
|
yuuji@0
|
1007 /* log the error */
|
yuuji@0
|
1008 if (!ret) MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
1009 /* delete if requested message */
|
yuuji@0
|
1010 else if (options & CP_MOVE) for (i = 1; i <= stream->nmsgs; i++)
|
yuuji@0
|
1011 if ((elt = mail_elt (stream,i))->sequence)
|
yuuji@0
|
1012 elt->deleted = elt->private.dirty = LOCAL->dirty = T;
|
yuuji@0
|
1013 MM_NOCRITICAL (stream); /* release critical */
|
yuuji@0
|
1014 return ret;
|
yuuji@0
|
1015 }
|
yuuji@0
|
1016
|
yuuji@0
|
1017 /* UNIX mail append message from stringstruct
|
yuuji@0
|
1018 * Accepts: MAIL stream
|
yuuji@0
|
1019 * destination mailbox
|
yuuji@0
|
1020 * append callback
|
yuuji@0
|
1021 * data for callback
|
yuuji@0
|
1022 * Returns: T if append successful, else NIL
|
yuuji@0
|
1023 */
|
yuuji@0
|
1024
|
yuuji@0
|
1025 #define BUFLEN 8*MAILTMPLEN
|
yuuji@0
|
1026
|
yuuji@0
|
1027 long unix_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data)
|
yuuji@0
|
1028 {
|
yuuji@0
|
1029 struct stat sbuf;
|
yuuji@0
|
1030 int fd;
|
yuuji@0
|
1031 unsigned long i;
|
yuuji@0
|
1032 char *flags,*date,buf[BUFLEN],tmp[MAILTMPLEN],file[MAILTMPLEN];
|
yuuji@0
|
1033 time_t tp[2];
|
yuuji@0
|
1034 FILE *sf,*df;
|
yuuji@0
|
1035 MESSAGECACHE elt;
|
yuuji@0
|
1036 DOTLOCK lock;
|
yuuji@0
|
1037 STRING *message;
|
yuuji@0
|
1038 unsigned long uidlocation = 0;
|
yuuji@0
|
1039 appenduid_t au = (appenduid_t)
|
yuuji@0
|
1040 (mail_parameters (NIL,GET_USERHASNOLIFE,NIL) ? NIL :
|
yuuji@0
|
1041 mail_parameters (NIL,GET_APPENDUID,NIL));
|
yuuji@0
|
1042 SEARCHSET *dst = au ? mail_newsearchset () : NIL;
|
yuuji@0
|
1043 long ret = LONGT;
|
yuuji@0
|
1044 MAILSTREAM *tstream = NIL;
|
yuuji@0
|
1045 if (!stream) { /* stream specified? */
|
yuuji@0
|
1046 stream = &unixproto; /* no, default stream to prototype */
|
yuuji@0
|
1047 for (i = 0; i < NUSERFLAGS && stream->user_flags[i]; ++i)
|
yuuji@0
|
1048 fs_give ((void **) &stream->user_flags[i]);
|
yuuji@0
|
1049 }
|
yuuji@0
|
1050 if (!unix_valid (mailbox)) switch (errno) {
|
yuuji@0
|
1051 case ENOENT: /* no such file? */
|
yuuji@0
|
1052 if (compare_cstring (mailbox,"INBOX")) {
|
yuuji@0
|
1053 MM_NOTIFY (stream,"[TRYCREATE] Must create mailbox before append",NIL);
|
yuuji@0
|
1054 return NIL;
|
yuuji@0
|
1055 }
|
yuuji@0
|
1056 unix_create (NIL,"INBOX"); /* create empty INBOX */
|
yuuji@0
|
1057 case 0: /* merely empty file? */
|
yuuji@0
|
1058 tstream = stream;
|
yuuji@0
|
1059 break;
|
yuuji@0
|
1060 case EACCES: /* file protected */
|
yuuji@0
|
1061 sprintf (tmp,"Can't access destination: %.80s",mailbox);
|
yuuji@0
|
1062 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1063 return NIL;
|
yuuji@0
|
1064 case EINVAL:
|
yuuji@0
|
1065 sprintf (tmp,"Invalid UNIX-format mailbox name: %.80s",mailbox);
|
yuuji@0
|
1066 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1067 return NIL;
|
yuuji@0
|
1068 default:
|
yuuji@0
|
1069 sprintf (tmp,"Not a UNIX-format mailbox: %.80s",mailbox);
|
yuuji@0
|
1070 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1071 return NIL;
|
yuuji@0
|
1072 }
|
yuuji@0
|
1073 /* get sniffing stream for keywords */
|
yuuji@0
|
1074 else if (!(tstream = mail_open (NIL,mailbox,
|
yuuji@0
|
1075 OP_READONLY|OP_SILENT|OP_NOKOD|OP_SNIFF))) {
|
yuuji@0
|
1076 sprintf (tmp,"Unable to examine mailbox for APPEND: %.80s",mailbox);
|
yuuji@0
|
1077 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1078 return NIL;
|
yuuji@0
|
1079 }
|
yuuji@0
|
1080
|
yuuji@0
|
1081 /* get first message */
|
yuuji@0
|
1082 if (!MM_APPEND (af) (tstream,data,&flags,&date,&message)) return NIL;
|
yuuji@0
|
1083 if (!(sf = tmpfile ())) { /* must have scratch file */
|
yuuji@0
|
1084 sprintf (tmp,".%lx.%lx",(unsigned long) time (0),(unsigned long)getpid ());
|
yuuji@0
|
1085 if (!stat (tmp,&sbuf) || !(sf = fopen (tmp,"wb+"))) {
|
yuuji@0
|
1086 sprintf (tmp,"Unable to create scratch file: %.80s",strerror (errno));
|
yuuji@0
|
1087 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1088 return NIL;
|
yuuji@0
|
1089 }
|
yuuji@0
|
1090 unlink (tmp);
|
yuuji@0
|
1091 }
|
yuuji@0
|
1092 do { /* parse date */
|
yuuji@0
|
1093 if (!date) rfc822_date (date = tmp);
|
yuuji@0
|
1094 if (!mail_parse_date (&elt,date)) {
|
yuuji@0
|
1095 sprintf (tmp,"Bad date in append: %.80s",date);
|
yuuji@0
|
1096 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1097 }
|
yuuji@0
|
1098 else { /* user wants to suppress time zones? */
|
yuuji@0
|
1099 if (mail_parameters (NIL,GET_NOTIMEZONES,NIL)) {
|
yuuji@0
|
1100 time_t when = mail_longdate (&elt);
|
yuuji@0
|
1101 date = ctime (&when); /* use traditional date */
|
yuuji@0
|
1102 }
|
yuuji@0
|
1103 /* use POSIX-style date */
|
yuuji@0
|
1104 else date = mail_cdate (tmp,&elt);
|
yuuji@0
|
1105 if (!SIZE (message)) MM_LOG ("Append of zero-length message",ERROR);
|
yuuji@0
|
1106 else if (!unix_collect_msg (tstream,sf,flags,date,message)) {
|
yuuji@0
|
1107 sprintf (tmp,"Error writing scratch file: %.80s",strerror (errno));
|
yuuji@0
|
1108 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1109 }
|
yuuji@0
|
1110 /* get next message */
|
yuuji@0
|
1111 else if (MM_APPEND (af) (tstream,data,&flags,&date,&message)) continue;
|
yuuji@0
|
1112 }
|
yuuji@0
|
1113 fclose (sf); /* punt scratch file */
|
yuuji@0
|
1114 return NIL; /* give up */
|
yuuji@0
|
1115 } while (message); /* until no more messages */
|
yuuji@0
|
1116 if (fflush (sf)) {
|
yuuji@0
|
1117 sprintf (tmp,"Error finishing scratch file: %.80s",strerror (errno));
|
yuuji@0
|
1118 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1119 fclose (sf); /* punt scratch file */
|
yuuji@0
|
1120 return NIL; /* give up */
|
yuuji@0
|
1121 }
|
yuuji@0
|
1122 i = ftell (sf); /* size of scratch file */
|
yuuji@0
|
1123 /* close sniffing stream */
|
yuuji@0
|
1124 if (tstream != stream) tstream = mail_close (tstream);
|
yuuji@0
|
1125
|
yuuji@0
|
1126 MM_CRITICAL (stream); /* go critical */
|
yuuji@0
|
1127 /* try to open readwrite for UIDPLUS */
|
yuuji@0
|
1128 if ((tstream = mail_open_work (&unixdriver,NIL,mailbox,
|
yuuji@0
|
1129 OP_SILENT|OP_NOKOD)) && tstream->rdonly)
|
yuuji@0
|
1130 tstream = mail_close (tstream);
|
yuuji@0
|
1131 if (au && !tstream) { /* wanted an APPENDUID? */
|
yuuji@0
|
1132 sprintf (tmp,"Unable to re-open mailbox for APPENDUID: %.80s",mailbox);
|
yuuji@0
|
1133 MM_LOG (tmp,WARN);
|
yuuji@0
|
1134 au = NIL;
|
yuuji@0
|
1135 }
|
yuuji@0
|
1136 if (((fd = unix_lock (dummy_file (file,mailbox),O_WRONLY|O_APPEND,
|
yuuji@0
|
1137 (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
|
yuuji@0
|
1138 &lock,LOCK_EX)) < 0) ||
|
yuuji@0
|
1139 !(df = fdopen (fd,"ab"))) {
|
yuuji@0
|
1140 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
1141 sprintf (tmp,"Can't open append mailbox: %s",strerror (errno));
|
yuuji@0
|
1142 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1143 return NIL;
|
yuuji@0
|
1144 }
|
yuuji@0
|
1145 fstat (fd,&sbuf); /* get current file size */
|
yuuji@0
|
1146 rewind (sf);
|
yuuji@0
|
1147 tp[1] = time (0); /* set mtime to now */
|
yuuji@0
|
1148 /* write all messages */
|
yuuji@0
|
1149 if (!unix_append_msgs (tstream,sf,df,au ? dst : NIL) ||
|
yuuji@0
|
1150 (fflush (df) == EOF) || fsync (fd)) {
|
yuuji@0
|
1151 sprintf (buf,"Message append failed: %s",strerror (errno));
|
yuuji@0
|
1152 MM_LOG (buf,ERROR);
|
yuuji@0
|
1153 ftruncate (fd,sbuf.st_size);
|
yuuji@0
|
1154 tp[0] = /* preserve \Marked status */
|
yuuji@0
|
1155 ((sbuf.st_ctime > sbuf.st_atime) || (sbuf.st_mtime > sbuf.st_atime)) ?
|
yuuji@0
|
1156 sbuf.st_atime : tp[1];
|
yuuji@0
|
1157 ret = NIL; /* return error */
|
yuuji@0
|
1158 }
|
yuuji@0
|
1159 else tp[0] = tp[1] - 1; /* set atime to now-1 if successful copy */
|
yuuji@0
|
1160 utime (file,tp); /* set the times */
|
yuuji@0
|
1161 fclose (sf); /* done with scratch file */
|
yuuji@0
|
1162 /* force UIDVALIDITY assignment now */
|
yuuji@0
|
1163 if (tstream && !tstream->uid_validity) tstream->uid_validity = time (0);
|
yuuji@0
|
1164 /* return sets if doing APPENDUID */
|
yuuji@0
|
1165 if (au && ret) (*au) (mailbox,tstream->uid_validity,dst);
|
yuuji@0
|
1166 else mail_free_searchset (&dst);
|
yuuji@0
|
1167 unix_unlock (fd,NIL,&lock); /* unlock and close mailbox */
|
yuuji@0
|
1168 fclose (df); /* note that unix_unlock() released the fd */
|
yuuji@0
|
1169 if (tstream) { /* update last UID if we can */
|
yuuji@0
|
1170 UNIXLOCAL *local = (UNIXLOCAL *) tstream->local;
|
yuuji@0
|
1171 local->dirty = T; /* do a rewrite */
|
yuuji@0
|
1172 local->appending = T; /* but not at the cost of marking as old */
|
yuuji@0
|
1173 tstream = mail_close (tstream);
|
yuuji@0
|
1174 }
|
yuuji@0
|
1175 MM_NOCRITICAL (stream); /* release critical */
|
yuuji@0
|
1176 return ret;
|
yuuji@0
|
1177 }
|
yuuji@0
|
1178
|
yuuji@0
|
1179 /* Collect and write single message to append scratch file
|
yuuji@0
|
1180 * Accepts: MAIL stream
|
yuuji@0
|
1181 * scratch file
|
yuuji@0
|
1182 * flags
|
yuuji@0
|
1183 * date
|
yuuji@0
|
1184 * message stringstruct
|
yuuji@0
|
1185 * Returns: NIL if write error, else T
|
yuuji@0
|
1186 */
|
yuuji@0
|
1187
|
yuuji@0
|
1188 int unix_collect_msg (MAILSTREAM *stream,FILE *sf,char *flags,char *date,
|
yuuji@0
|
1189 STRING *msg)
|
yuuji@0
|
1190 {
|
yuuji@0
|
1191 unsigned char *s,*t;
|
yuuji@0
|
1192 unsigned long uf;
|
yuuji@0
|
1193 long f = mail_parse_flags (stream,flags,&uf);
|
yuuji@0
|
1194 /* write metadata, note date ends with NL */
|
yuuji@0
|
1195 if (fprintf (sf,"%ld %lu %s",f,SIZE (msg) + 1,date) < 0) return NIL;
|
yuuji@0
|
1196 while (uf) /* write user flags */
|
yuuji@0
|
1197 if ((s = stream->user_flags[find_rightmost_bit (&uf)]) &&
|
yuuji@0
|
1198 (fprintf (sf," %s",s) < 0)) return NIL;
|
yuuji@0
|
1199 if (putc ('\n',sf) == EOF) return NIL;
|
yuuji@0
|
1200 while (SIZE (msg)) { /* copy text to scratch file */
|
yuuji@0
|
1201 for (s = (unsigned char *) msg->curpos, t = s + msg->cursize; s < t; ++s)
|
yuuji@0
|
1202 if (!*s) *s = 0x80; /* disallow NUL */
|
yuuji@0
|
1203 /* write buffered text */
|
yuuji@0
|
1204 if (fwrite (msg->curpos,1,msg->cursize,sf) == msg->cursize)
|
yuuji@0
|
1205 SETPOS (msg,GETPOS (msg) + msg->cursize);
|
yuuji@0
|
1206 else return NIL; /* failed */
|
yuuji@0
|
1207 }
|
yuuji@0
|
1208 /* write trailing newline and return */
|
yuuji@0
|
1209 return (putc ('\n',sf) == EOF) ? NIL : T;
|
yuuji@0
|
1210 }
|
yuuji@0
|
1211
|
yuuji@0
|
1212 /* Append messages from scratch file to mailbox
|
yuuji@0
|
1213 * Accepts: MAIL stream
|
yuuji@0
|
1214 * source file
|
yuuji@0
|
1215 * destination file
|
yuuji@0
|
1216 * uidset to update if non-NIL
|
yuuji@0
|
1217 * Returns: T if success, NIL if failure
|
yuuji@0
|
1218 */
|
yuuji@0
|
1219
|
yuuji@0
|
1220 int unix_append_msgs (MAILSTREAM *stream,FILE *sf,FILE *df,SEARCHSET *set)
|
yuuji@0
|
1221 {
|
yuuji@0
|
1222 int ti,zn,c;
|
yuuji@0
|
1223 long f;
|
yuuji@0
|
1224 unsigned long i,j;
|
yuuji@0
|
1225 char *x,tmp[MAILTMPLEN];
|
yuuji@0
|
1226 int hdrp = T;
|
yuuji@0
|
1227 /* get message metadata line */
|
yuuji@0
|
1228 while (fgets (tmp,MAILTMPLEN,sf)) {
|
yuuji@0
|
1229 if (!(isdigit (tmp[0]) && strchr (tmp,'\n'))) return NIL;
|
yuuji@0
|
1230 f = strtol (tmp,&x,10); /* get flags */
|
yuuji@0
|
1231 if (!((*x++ == ' ') && isdigit (*x))) return NIL;
|
yuuji@0
|
1232 i = strtoul (x,&x,10); /* get message size */
|
yuuji@0
|
1233 if ((*x++ != ' ') || /* build initial header */
|
yuuji@0
|
1234 (fprintf (df,"From %s@%s %sStatus: ",myusername(),mylocalhost(),x)<0)||
|
yuuji@0
|
1235 (f&fSEEN && (putc ('R',df) == EOF)) ||
|
yuuji@0
|
1236 (fputs ("\nX-Status: ",df) == EOF) ||
|
yuuji@0
|
1237 (f&fDELETED && (putc ('D',df) == EOF)) ||
|
yuuji@0
|
1238 (f&fFLAGGED && (putc ('F',df) == EOF)) ||
|
yuuji@0
|
1239 (f&fANSWERED && (putc ('A',df) == EOF)) ||
|
yuuji@0
|
1240 (f&fDRAFT && (putc ('T',df) == EOF)) ||
|
yuuji@0
|
1241 (fputs ("\nX-Keywords:",df) == EOF)) return NIL;
|
yuuji@0
|
1242 /* copy keywords */
|
yuuji@0
|
1243 while ((c = getc (sf)) != '\n') switch (c) {
|
yuuji@0
|
1244 case EOF:
|
yuuji@0
|
1245 return NIL;
|
yuuji@0
|
1246 default:
|
yuuji@0
|
1247 if (putc (c,df) == EOF) return NIL;
|
yuuji@0
|
1248 }
|
yuuji@0
|
1249 if ((putc ('\n',df) == EOF) ||
|
yuuji@0
|
1250 (set && (fprintf (df,"X-UID: %lu\n",++(stream->uid_last)) < 0)))
|
yuuji@0
|
1251 return NIL;
|
yuuji@0
|
1252
|
yuuji@0
|
1253 for (c = '\n'; i && fgets (tmp,MAILTMPLEN,sf); c = tmp[j-1]) {
|
yuuji@0
|
1254 /* get read line length */
|
yuuji@0
|
1255 if (i < (j = strlen (tmp))) fatal ("unix_append_msgs overrun");
|
yuuji@0
|
1256 i -= j; /* number of bytes left */
|
yuuji@0
|
1257 /* squish out CRs (note also copies NUL) */
|
yuuji@0
|
1258 for (x = tmp; x = strchr (x,'\r'); --j) memmove (x,x+1,j-(x-tmp));
|
yuuji@0
|
1259 if (!j) continue; /* do nothing if line emptied */
|
yuuji@0
|
1260 /* start of line? */
|
yuuji@0
|
1261 if ((c == '\n')) switch (tmp[0]) {
|
yuuji@0
|
1262 case 'F': /* possible "From " (case counts here) */
|
yuuji@0
|
1263 if ((j > 4) && (tmp[0] == 'F') && (tmp[1] == 'r') && (tmp[2] == 'o') &&
|
yuuji@0
|
1264 (tmp[3] == 'm') && (tmp[4] == ' ')) {
|
yuuji@0
|
1265 if (!unix_fromwidget) {
|
yuuji@0
|
1266 VALID (tmp,x,ti,zn);/* conditional, only write widget if */
|
yuuji@0
|
1267 if (!ti) break; /* it looks like a valid header */
|
yuuji@0
|
1268 } /* write the widget */
|
yuuji@0
|
1269 if (putc ('>',df) == EOF) return NIL;
|
yuuji@0
|
1270 }
|
yuuji@0
|
1271 break;
|
yuuji@0
|
1272 case 'S': case 's': /* possible "Status:" */
|
yuuji@0
|
1273 if (hdrp && (j > 6) && ((tmp[1] == 't') || (tmp[1] == 'T')) &&
|
yuuji@0
|
1274 ((tmp[2] == 'a') || (tmp[2] == 'A')) &&
|
yuuji@0
|
1275 ((tmp[3] == 't') || (tmp[3] == 'T')) &&
|
yuuji@0
|
1276 ((tmp[4] == 'u') || (tmp[4] == 'U')) &&
|
yuuji@0
|
1277 ((tmp[5] == 's') || (tmp[5] == 'S')) && (tmp[6] == ':') &&
|
yuuji@0
|
1278 (fputs ("X-Original-",df) == EOF)) return NIL;
|
yuuji@0
|
1279 break;
|
yuuji@0
|
1280 case 'X': case 'x': /* possible X-??? header */
|
yuuji@0
|
1281 if (hdrp && (tmp[1] == '-') &&
|
yuuji@0
|
1282 /* possible X-UID: */
|
yuuji@0
|
1283 (((j > 5) && ((tmp[2] == 'U') || (tmp[2] == 'u')) &&
|
yuuji@0
|
1284 ((tmp[3] == 'I') || (tmp[3] == 'i')) &&
|
yuuji@0
|
1285 ((tmp[4] == 'D') || (tmp[4] == 'd')) && (tmp[5] == ':')) ||
|
yuuji@0
|
1286 /* possible X-IMAP: */
|
yuuji@0
|
1287 ((j > 6) && ((tmp[2] == 'I') || (tmp[2] == 'i')) &&
|
yuuji@0
|
1288 ((tmp[3] == 'M') || (tmp[3] == 'm')) &&
|
yuuji@0
|
1289 ((tmp[4] == 'A') || (tmp[4] == 'a')) &&
|
yuuji@0
|
1290 ((tmp[5] == 'P') || (tmp[5] == 'p')) &&
|
yuuji@0
|
1291 ((tmp[6] == ':') ||
|
yuuji@0
|
1292 /* or X-IMAPbase: */
|
yuuji@0
|
1293 ((j > 10) && ((tmp[6] == 'b') || (tmp[6] == 'B')) &&
|
yuuji@0
|
1294 ((tmp[7] == 'a') || (tmp[7] == 'A')) &&
|
yuuji@0
|
1295 ((tmp[8] == 's') || (tmp[8] == 'S')) &&
|
yuuji@0
|
1296 ((tmp[9] == 'e') || (tmp[9] == 'E')) && (tmp[10] == ':')))) ||
|
yuuji@0
|
1297 /* possible X-Status: */
|
yuuji@0
|
1298 ((j > 8) && ((tmp[2] == 'S') || (tmp[2] == 's')) &&
|
yuuji@0
|
1299 ((tmp[3] == 't') || (tmp[3] == 'T')) &&
|
yuuji@0
|
1300 ((tmp[4] == 'a') || (tmp[4] == 'A')) &&
|
yuuji@0
|
1301 ((tmp[5] == 't') || (tmp[5] == 'T')) &&
|
yuuji@0
|
1302 ((tmp[6] == 'u') || (tmp[6] == 'U')) &&
|
yuuji@0
|
1303 ((tmp[7] == 's') || (tmp[7] == 'S')) && (tmp[8] == ':')) ||
|
yuuji@0
|
1304 /* possible X-Keywords: */
|
yuuji@0
|
1305 ((j > 10) && ((tmp[2] == 'K') || (tmp[2] == 'k')) &&
|
yuuji@0
|
1306 ((tmp[3] == 'e') || (tmp[3] == 'E')) &&
|
yuuji@0
|
1307 ((tmp[4] == 'y') || (tmp[4] == 'Y')) &&
|
yuuji@0
|
1308 ((tmp[5] == 'w') || (tmp[5] == 'W')) &&
|
yuuji@0
|
1309 ((tmp[6] == 'o') || (tmp[6] == 'O')) &&
|
yuuji@0
|
1310 ((tmp[7] == 'r') || (tmp[7] == 'R')) &&
|
yuuji@0
|
1311 ((tmp[8] == 'd') || (tmp[8] == 'D')) &&
|
yuuji@0
|
1312 ((tmp[9] == 's') || (tmp[9] == 'S')) && (tmp[10] == ':'))) &&
|
yuuji@0
|
1313 (fputs ("X-Original-",df) == EOF)) return NIL;
|
yuuji@0
|
1314 case '\n': /* blank line */
|
yuuji@0
|
1315 hdrp = NIL;
|
yuuji@0
|
1316 break;
|
yuuji@0
|
1317 default: /* nothing to do */
|
yuuji@0
|
1318 break;
|
yuuji@0
|
1319 }
|
yuuji@0
|
1320 /* just write the line */
|
yuuji@0
|
1321 if (fwrite (tmp,1,j,df) != j) return NIL;
|
yuuji@0
|
1322 }
|
yuuji@0
|
1323 if (i) return NIL; /* didn't read entire message */
|
yuuji@0
|
1324 /* update set */
|
yuuji@0
|
1325 if (stream) mail_append_set (set,stream->uid_last);
|
yuuji@0
|
1326 }
|
yuuji@0
|
1327 return T;
|
yuuji@0
|
1328 }
|
yuuji@0
|
1329
|
yuuji@0
|
1330 /* Internal routines */
|
yuuji@0
|
1331
|
yuuji@0
|
1332
|
yuuji@0
|
1333 /* UNIX mail abort stream
|
yuuji@0
|
1334 * Accepts: MAIL stream
|
yuuji@0
|
1335 */
|
yuuji@0
|
1336
|
yuuji@0
|
1337 void unix_abort (MAILSTREAM *stream)
|
yuuji@0
|
1338 {
|
yuuji@0
|
1339 if (LOCAL) { /* only if a file is open */
|
yuuji@0
|
1340 if (LOCAL->fd >= 0) close (LOCAL->fd);
|
yuuji@0
|
1341 if (LOCAL->ld >= 0) { /* have a mailbox lock? */
|
yuuji@0
|
1342 flock (LOCAL->ld,LOCK_UN);/* yes, release the lock */
|
yuuji@0
|
1343 close (LOCAL->ld); /* close the lock file */
|
yuuji@0
|
1344 unlink (LOCAL->lname); /* and delete it */
|
yuuji@0
|
1345 }
|
yuuji@0
|
1346 if (LOCAL->lname) fs_give ((void **) &LOCAL->lname);
|
yuuji@0
|
1347 /* free local text buffers */
|
yuuji@0
|
1348 if (LOCAL->buf) fs_give ((void **) &LOCAL->buf);
|
yuuji@0
|
1349 if (LOCAL->text.data) fs_give ((void **) &LOCAL->text.data);
|
yuuji@0
|
1350 if (LOCAL->linebuf) fs_give ((void **) &LOCAL->linebuf);
|
yuuji@0
|
1351 if (LOCAL->line) fs_give ((void **) &LOCAL->line);
|
yuuji@0
|
1352 /* nuke the local data */
|
yuuji@0
|
1353 fs_give ((void **) &stream->local);
|
yuuji@0
|
1354 stream->dtb = NIL; /* log out the DTB */
|
yuuji@0
|
1355 }
|
yuuji@0
|
1356 }
|
yuuji@0
|
1357
|
yuuji@0
|
1358 /* UNIX open and lock mailbox
|
yuuji@0
|
1359 * Accepts: file name to open/lock
|
yuuji@0
|
1360 * file open mode
|
yuuji@0
|
1361 * destination buffer for lock file name
|
yuuji@0
|
1362 * type of locking operation (LOCK_SH or LOCK_EX)
|
yuuji@0
|
1363 */
|
yuuji@0
|
1364
|
yuuji@0
|
1365 int unix_lock (char *file,int flags,int mode,DOTLOCK *lock,int op)
|
yuuji@0
|
1366 {
|
yuuji@0
|
1367 int fd;
|
yuuji@0
|
1368 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
|
yuuji@0
|
1369 (*bn) (BLOCK_FILELOCK,NIL);
|
yuuji@0
|
1370 /* try locking the easy way */
|
yuuji@0
|
1371 if (dotlock_lock (file,lock,-1)) {
|
yuuji@0
|
1372 /* got dotlock file, easy open */
|
yuuji@0
|
1373 if ((fd = open (file,flags,mode)) >= 0) flock (fd,op);
|
yuuji@0
|
1374 else dotlock_unlock (lock); /* open failed, free the dotlock */
|
yuuji@0
|
1375 }
|
yuuji@0
|
1376 /* no dot lock file, open file now */
|
yuuji@0
|
1377 else if ((fd = open (file,flags,mode)) >= 0) {
|
yuuji@0
|
1378 /* try paranoid way to make a dot lock file */
|
yuuji@0
|
1379 if (dotlock_lock (file,lock,fd)) {
|
yuuji@0
|
1380 close (fd); /* get fresh fd in case of timing race */
|
yuuji@0
|
1381 if ((fd = open (file,flags,mode)) >= 0) flock (fd,op);
|
yuuji@0
|
1382 /* open failed, free the dotlock */
|
yuuji@0
|
1383 else dotlock_unlock (lock);
|
yuuji@0
|
1384 }
|
yuuji@0
|
1385 else flock (fd,op); /* paranoid way failed, just flock() it */
|
yuuji@0
|
1386 }
|
yuuji@0
|
1387 (*bn) (BLOCK_NONE,NIL);
|
yuuji@0
|
1388 return fd;
|
yuuji@0
|
1389 }
|
yuuji@0
|
1390
|
yuuji@0
|
1391 /* UNIX unlock and close mailbox
|
yuuji@0
|
1392 * Accepts: file descriptor
|
yuuji@0
|
1393 * (optional) mailbox stream to check atime/mtime
|
yuuji@0
|
1394 * (optional) lock file name
|
yuuji@0
|
1395 */
|
yuuji@0
|
1396
|
yuuji@0
|
1397 void unix_unlock (int fd,MAILSTREAM *stream,DOTLOCK *lock)
|
yuuji@0
|
1398 {
|
yuuji@0
|
1399 if (stream) { /* need to muck with times? */
|
yuuji@0
|
1400 struct stat sbuf;
|
yuuji@0
|
1401 time_t tp[2];
|
yuuji@0
|
1402 time_t now = time (0);
|
yuuji@0
|
1403 fstat (fd,&sbuf); /* get file times */
|
yuuji@0
|
1404 if (LOCAL->ld >= 0) { /* yes, readwrite session? */
|
yuuji@0
|
1405 tp[0] = now; /* set atime to now */
|
yuuji@0
|
1406 /* set mtime to (now - 1) if necessary */
|
yuuji@0
|
1407 tp[1] = (now > sbuf.st_mtime) ? sbuf.st_mtime : now - 1;
|
yuuji@0
|
1408 }
|
yuuji@0
|
1409 else if (stream->recent) { /* readonly with recent messages */
|
yuuji@0
|
1410 if ((sbuf.st_atime >= sbuf.st_mtime) ||
|
yuuji@0
|
1411 (sbuf.st_atime >= sbuf.st_ctime))
|
yuuji@0
|
1412 /* keep past mtime, whack back atime */
|
yuuji@0
|
1413 tp[0] = (tp[1] = (sbuf.st_mtime < now) ? sbuf.st_mtime : now) - 1;
|
yuuji@0
|
1414 else now = 0; /* no time change needed */
|
yuuji@0
|
1415 }
|
yuuji@0
|
1416 /* readonly with no recent messages */
|
yuuji@0
|
1417 else if ((sbuf.st_atime < sbuf.st_mtime) ||
|
yuuji@0
|
1418 (sbuf.st_atime < sbuf.st_ctime)) {
|
yuuji@0
|
1419 tp[0] = now; /* set atime to now */
|
yuuji@0
|
1420 /* set mtime to (now - 1) if necessary */
|
yuuji@0
|
1421 tp[1] = (now > sbuf.st_mtime) ? sbuf.st_mtime : now - 1;
|
yuuji@0
|
1422 }
|
yuuji@0
|
1423 else now = 0; /* no time change needed */
|
yuuji@0
|
1424 /* set the times, note change */
|
yuuji@0
|
1425 if (now && !utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
|
yuuji@0
|
1426 }
|
yuuji@0
|
1427 flock (fd,LOCK_UN); /* release flock'ers */
|
yuuji@0
|
1428 if (!stream) close (fd); /* close the file if no stream */
|
yuuji@0
|
1429 dotlock_unlock (lock); /* flush the lock file if any */
|
yuuji@0
|
1430 }
|
yuuji@0
|
1431
|
yuuji@0
|
1432 /* UNIX mail parse and lock mailbox
|
yuuji@0
|
1433 * Accepts: MAIL stream
|
yuuji@0
|
1434 * space to write lock file name
|
yuuji@0
|
1435 * type of locking operation
|
yuuji@0
|
1436 * Returns: T if parse OK, critical & mailbox is locked shared; NIL if failure
|
yuuji@0
|
1437 */
|
yuuji@0
|
1438
|
yuuji@0
|
1439 int unix_parse (MAILSTREAM *stream,DOTLOCK *lock,int op)
|
yuuji@0
|
1440 {
|
yuuji@0
|
1441 int zn;
|
yuuji@0
|
1442 unsigned long i,j,k,m;
|
yuuji@0
|
1443 unsigned char c,*s,*t,*u,tmp[MAILTMPLEN],date[30];
|
yuuji@0
|
1444 int ti = 0,retain = T;
|
yuuji@0
|
1445 unsigned long nmsgs = stream->nmsgs;
|
yuuji@0
|
1446 unsigned long prevuid = nmsgs ? mail_elt (stream,nmsgs)->private.uid : 0;
|
yuuji@0
|
1447 unsigned long recent = stream->recent;
|
yuuji@0
|
1448 unsigned long oldnmsgs = stream->nmsgs;
|
yuuji@0
|
1449 short silent = stream->silent;
|
yuuji@0
|
1450 short pseudoseen = NIL;
|
yuuji@0
|
1451 struct stat sbuf;
|
yuuji@0
|
1452 STRING bs;
|
yuuji@0
|
1453 FDDATA d;
|
yuuji@0
|
1454 MESSAGECACHE *elt;
|
yuuji@0
|
1455 mail_lock (stream); /* guard against recursion or pingers */
|
yuuji@0
|
1456 /* toss out previous descriptor */
|
yuuji@0
|
1457 if (LOCAL->fd >= 0) close (LOCAL->fd);
|
yuuji@0
|
1458 MM_CRITICAL (stream); /* open and lock mailbox (shared OK) */
|
yuuji@0
|
1459 if ((LOCAL->fd = unix_lock (stream->mailbox,(LOCAL->ld >= 0) ?
|
yuuji@0
|
1460 O_RDWR : O_RDONLY,
|
yuuji@0
|
1461 (long)mail_parameters(NIL,GET_MBXPROTECTION,NIL),
|
yuuji@0
|
1462 lock,op)) < 0) {
|
yuuji@0
|
1463 sprintf (tmp,"Mailbox open failed, aborted: %s",strerror (errno));
|
yuuji@0
|
1464 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1465 unix_abort (stream);
|
yuuji@0
|
1466 mail_unlock (stream);
|
yuuji@0
|
1467 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
1468 return NIL;
|
yuuji@0
|
1469 }
|
yuuji@0
|
1470 fstat (LOCAL->fd,&sbuf); /* get status */
|
yuuji@0
|
1471 /* validate change in size */
|
yuuji@0
|
1472 if (sbuf.st_size < LOCAL->filesize) {
|
yuuji@0
|
1473 sprintf (tmp,"Mailbox shrank from %lu to %lu bytes, aborted",
|
yuuji@0
|
1474 (unsigned long) LOCAL->filesize,(unsigned long) sbuf.st_size);
|
yuuji@0
|
1475 MM_LOG (tmp,ERROR); /* this is pretty bad */
|
yuuji@0
|
1476 unix_unlock (LOCAL->fd,stream,lock);
|
yuuji@0
|
1477 unix_abort (stream);
|
yuuji@0
|
1478 mail_unlock (stream);
|
yuuji@0
|
1479 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
1480 return NIL;
|
yuuji@0
|
1481 }
|
yuuji@0
|
1482
|
yuuji@0
|
1483 /* new data? */
|
yuuji@0
|
1484 else if (i = sbuf.st_size - LOCAL->filesize) {
|
yuuji@0
|
1485 d.fd = LOCAL->fd; /* yes, set up file descriptor */
|
yuuji@0
|
1486 d.pos = LOCAL->filesize; /* get to that position in the file */
|
yuuji@0
|
1487 d.chunk = LOCAL->buf; /* initial buffer chunk */
|
yuuji@0
|
1488 d.chunksize = CHUNKSIZE; /* file chunk size */
|
yuuji@0
|
1489 INIT (&bs,fd_string,&d,i); /* initialize stringstruct */
|
yuuji@0
|
1490 /* skip leading whitespace for broken MTAs */
|
yuuji@0
|
1491 while (((c = CHR (&bs)) == '\n') || (c == '\r') ||
|
yuuji@0
|
1492 (c == ' ') || (c == '\t')) SNX (&bs);
|
yuuji@0
|
1493 if (SIZE (&bs)) { /* read new data */
|
yuuji@0
|
1494 /* remember internal header position */
|
yuuji@0
|
1495 j = LOCAL->filesize + GETPOS (&bs);
|
yuuji@0
|
1496 s = unix_mbxline (stream,&bs,&i);
|
yuuji@0
|
1497 t = NIL,zn = 0;
|
yuuji@0
|
1498 if (i) VALID (s,t,ti,zn); /* see if valid From line */
|
yuuji@0
|
1499 if (!ti) { /* someone pulled the rug from under us */
|
yuuji@0
|
1500 sprintf (tmp,"Unexpected changes to mailbox (try restarting): %.20s",
|
yuuji@0
|
1501 (char *) s);
|
yuuji@0
|
1502 MM_LOG (tmp,ERROR);
|
yuuji@0
|
1503 unix_unlock (LOCAL->fd,stream,lock);
|
yuuji@0
|
1504 unix_abort (stream);
|
yuuji@0
|
1505 mail_unlock (stream);
|
yuuji@0
|
1506 /* done with critical */
|
yuuji@0
|
1507 MM_NOCRITICAL (stream);
|
yuuji@0
|
1508 return NIL;
|
yuuji@0
|
1509 }
|
yuuji@0
|
1510 stream->silent = T; /* quell main program new message events */
|
yuuji@0
|
1511 do { /* found a message */
|
yuuji@0
|
1512 /* instantiate first new message */
|
yuuji@0
|
1513 mail_exists (stream,++nmsgs);
|
yuuji@0
|
1514 (elt = mail_elt (stream,nmsgs))->valid = T;
|
yuuji@0
|
1515 recent++; /* assume recent by default */
|
yuuji@0
|
1516 elt->recent = T;
|
yuuji@0
|
1517 /* note position/size of internal header */
|
yuuji@0
|
1518 elt->private.special.offset = j;
|
yuuji@0
|
1519 elt->private.msg.header.offset = elt->private.special.text.size = i;
|
yuuji@0
|
1520
|
yuuji@0
|
1521 /* generate plausible IMAPish date string */
|
yuuji@0
|
1522 date[2] = date[6] = date[20] = '-'; date[11] = ' ';
|
yuuji@0
|
1523 date[14] = date[17] = ':';
|
yuuji@0
|
1524 /* dd */
|
yuuji@0
|
1525 date[0] = t[ti - 2]; date[1] = t[ti - 1];
|
yuuji@0
|
1526 /* mmm */
|
yuuji@0
|
1527 date[3] = t[ti - 6]; date[4] = t[ti - 5]; date[5] = t[ti - 4];
|
yuuji@0
|
1528 /* hh */
|
yuuji@0
|
1529 date[12] = t[ti + 1]; date[13] = t[ti + 2];
|
yuuji@0
|
1530 /* mm */
|
yuuji@0
|
1531 date[15] = t[ti + 4]; date[16] = t[ti + 5];
|
yuuji@0
|
1532 if (t[ti += 6] == ':') {/* ss */
|
yuuji@0
|
1533 date[18] = t[++ti]; date[19] = t[++ti];
|
yuuji@0
|
1534 ti++; /* move to space */
|
yuuji@0
|
1535 }
|
yuuji@0
|
1536 else date[18] = date[19] = '0';
|
yuuji@0
|
1537 /* yy -- advance over timezone if necessary */
|
yuuji@0
|
1538 if (zn == ti) ti += (((t[zn+1] == '+') || (t[zn+1] == '-')) ? 6 : 4);
|
yuuji@0
|
1539 date[7] = t[ti + 1]; date[8] = t[ti + 2];
|
yuuji@0
|
1540 date[9] = t[ti + 3]; date[10] = t[ti + 4];
|
yuuji@0
|
1541 /* zzz */
|
yuuji@0
|
1542 t = zn ? (t + zn + 1) : (unsigned char *) "LCL";
|
yuuji@0
|
1543 date[21] = *t++; date[22] = *t++; date[23] = *t++;
|
yuuji@0
|
1544 if ((date[21] != '+') && (date[21] != '-')) date[24] = '\0';
|
yuuji@0
|
1545 else { /* numeric time zone */
|
yuuji@0
|
1546 date[24] = *t++; date[25] = *t++;
|
yuuji@0
|
1547 date[26] = '\0'; date[20] = ' ';
|
yuuji@0
|
1548 }
|
yuuji@0
|
1549 /* set internal date */
|
yuuji@0
|
1550 if (!mail_parse_date (elt,date)) {
|
yuuji@0
|
1551 sprintf (tmp,"Unable to parse internal date: %s",(char *) date);
|
yuuji@0
|
1552 MM_LOG (tmp,WARN);
|
yuuji@0
|
1553 }
|
yuuji@0
|
1554
|
yuuji@0
|
1555 do { /* look for message body */
|
yuuji@0
|
1556 s = t = unix_mbxline (stream,&bs,&i);
|
yuuji@0
|
1557 if (i) switch (*s) { /* check header lines */
|
yuuji@0
|
1558 case 'X': /* possible X-???: line */
|
yuuji@0
|
1559 if (s[1] == '-') { /* must be immediately followed by hyphen */
|
yuuji@0
|
1560 /* X-Status: becomes Status: in S case */
|
yuuji@0
|
1561 if (s[2] == 'S' && s[3] == 't' && s[4] == 'a' && s[5] == 't' &&
|
yuuji@0
|
1562 s[6] == 'u' && s[7] == 's' && s[8] == ':') s += 2;
|
yuuji@0
|
1563 /* possible X-Keywords */
|
yuuji@0
|
1564 else if (s[2] == 'K' && s[3] == 'e' && s[4] == 'y' &&
|
yuuji@0
|
1565 s[5] == 'w' && s[6] == 'o' && s[7] == 'r' &&
|
yuuji@0
|
1566 s[8] == 'd' && s[9] == 's' && s[10] == ':') {
|
yuuji@0
|
1567 SIZEDTEXT uf;
|
yuuji@0
|
1568 retain = NIL; /* don't retain continuation */
|
yuuji@0
|
1569 s += 11; /* flush leading whitespace */
|
yuuji@0
|
1570 while (*s && (*s != '\n') && ((*s != '\r') || (s[1] != '\n'))){
|
yuuji@0
|
1571 while (*s == ' ') s++;
|
yuuji@0
|
1572 /* find end of keyword */
|
yuuji@0
|
1573 if (!(u = strpbrk (s," \n\r"))) u = s + strlen (s);
|
yuuji@0
|
1574 /* got a keyword? */
|
yuuji@0
|
1575 if ((k = (u - s)) && (k <= MAXUSERFLAG)) {
|
yuuji@0
|
1576 uf.data = (unsigned char *) s;
|
yuuji@0
|
1577 uf.size = k;
|
yuuji@0
|
1578 for (j = 0; (j < NUSERFLAGS) && stream->user_flags[j]; ++j)
|
yuuji@0
|
1579 if (!compare_csizedtext (stream->user_flags[j],&uf)) {
|
yuuji@0
|
1580 elt->user_flags |= ((long) 1) << j;
|
yuuji@0
|
1581 break;
|
yuuji@0
|
1582 }
|
yuuji@0
|
1583 }
|
yuuji@0
|
1584 s = u; /* advance to next keyword */
|
yuuji@0
|
1585 }
|
yuuji@0
|
1586 break;
|
yuuji@0
|
1587 }
|
yuuji@0
|
1588
|
yuuji@0
|
1589 /* possible X-IMAP */
|
yuuji@0
|
1590 else if ((s[2] == 'I') && (s[3] == 'M') && (s[4] == 'A') &&
|
yuuji@0
|
1591 (s[5] == 'P') && ((m = (s[6] == ':')) ||
|
yuuji@0
|
1592 ((s[6] == 'b') && (s[7] == 'a') &&
|
yuuji@0
|
1593 (s[8] == 's') && (s[9] == 'e') &&
|
yuuji@0
|
1594 (s[10] == ':')))) {
|
yuuji@0
|
1595 retain = NIL; /* don't retain continuation */
|
yuuji@0
|
1596 if ((nmsgs == 1) && !stream->uid_validity) {
|
yuuji@0
|
1597 /* advance to data */
|
yuuji@0
|
1598 s += m ? 7 : 11;
|
yuuji@0
|
1599 /* flush whitespace */
|
yuuji@0
|
1600 while (*s == ' ') s++;
|
yuuji@0
|
1601 j = 0; /* slurp UID validity */
|
yuuji@0
|
1602 /* found a digit? */
|
yuuji@0
|
1603 while (isdigit (*s)) {
|
yuuji@0
|
1604 j *= 10; /* yes, add it in */
|
yuuji@0
|
1605 j += *s++ - '0';
|
yuuji@0
|
1606 }
|
yuuji@0
|
1607 /* flush whitespace */
|
yuuji@0
|
1608 while (*s == ' ') s++;
|
yuuji@0
|
1609 /* must have valid UID validity and UID last */
|
yuuji@0
|
1610 if (j && isdigit (*s)) {
|
yuuji@0
|
1611 /* pseudo-header seen if X-IMAP */
|
yuuji@0
|
1612 if (m) pseudoseen = LOCAL->pseudo = T;
|
yuuji@0
|
1613 /* save UID validity */
|
yuuji@0
|
1614 stream->uid_validity = j;
|
yuuji@0
|
1615 j = 0; /* slurp UID last */
|
yuuji@0
|
1616 while (isdigit (*s)) {
|
yuuji@0
|
1617 j *= 10; /* yes, add it in */
|
yuuji@0
|
1618 j += *s++ - '0';
|
yuuji@0
|
1619 }
|
yuuji@0
|
1620 /* save UID last */
|
yuuji@0
|
1621 stream->uid_last = j;
|
yuuji@0
|
1622 /* process keywords */
|
yuuji@0
|
1623 for (j = 0; (*s != '\n') && ((*s != '\r')||(s[1] != '\n'));
|
yuuji@0
|
1624 s = u,j++) {
|
yuuji@0
|
1625 /* flush leading whitespace */
|
yuuji@0
|
1626 while (*s == ' ') s++;
|
yuuji@0
|
1627 u = strpbrk (s," \n\r");
|
yuuji@0
|
1628 /* got a keyword? */
|
yuuji@0
|
1629 if ((j < NUSERFLAGS) && (k = (u - s)) &&
|
yuuji@0
|
1630 (k <= MAXUSERFLAG)) {
|
yuuji@0
|
1631 if (stream->user_flags[j])
|
yuuji@0
|
1632 fs_give ((void **) &stream->user_flags[j]);
|
yuuji@0
|
1633 stream->user_flags[j] = (char *) fs_get (k + 1);
|
yuuji@0
|
1634 strncpy (stream->user_flags[j],s,k);
|
yuuji@0
|
1635 stream->user_flags[j][k] = '\0';
|
yuuji@0
|
1636 }
|
yuuji@0
|
1637 }
|
yuuji@0
|
1638 }
|
yuuji@0
|
1639 }
|
yuuji@0
|
1640 break;
|
yuuji@0
|
1641 }
|
yuuji@0
|
1642
|
yuuji@0
|
1643 /* possible X-UID */
|
yuuji@0
|
1644 else if (s[2] == 'U' && s[3] == 'I' && s[4] == 'D' &&
|
yuuji@0
|
1645 s[5] == ':') {
|
yuuji@0
|
1646 retain = NIL; /* don't retain continuation */
|
yuuji@0
|
1647 /* only believe if have a UID validity */
|
yuuji@0
|
1648 if (stream->uid_validity && ((nmsgs > 1) || !pseudoseen)) {
|
yuuji@0
|
1649 s += 6; /* advance to UID value */
|
yuuji@0
|
1650 /* flush whitespace */
|
yuuji@0
|
1651 while (*s == ' ') s++;
|
yuuji@0
|
1652 j = 0;
|
yuuji@0
|
1653 /* found a digit? */
|
yuuji@0
|
1654 while (isdigit (*s)) {
|
yuuji@0
|
1655 j *= 10; /* yes, add it in */
|
yuuji@0
|
1656 j += *s++ - '0';
|
yuuji@0
|
1657 }
|
yuuji@0
|
1658 /* flush remainder of line */
|
yuuji@0
|
1659 while (*s != '\n') s++;
|
yuuji@0
|
1660 /* make sure not duplicated */
|
yuuji@0
|
1661 if (elt->private.uid)
|
yuuji@0
|
1662 sprintf (tmp,"Message %lu UID %lu already has UID %lu",
|
yuuji@0
|
1663 pseudoseen ? elt->msgno - 1 : elt->msgno,
|
yuuji@0
|
1664 j,elt->private.uid);
|
yuuji@0
|
1665 /* make sure UID doesn't go backwards */
|
yuuji@0
|
1666 else if (j <= prevuid)
|
yuuji@0
|
1667 sprintf (tmp,"Message %lu UID %lu less than %lu",
|
yuuji@0
|
1668 pseudoseen ? elt->msgno - 1 : elt->msgno,
|
yuuji@0
|
1669 j,prevuid + 1);
|
yuuji@0
|
1670 #if 0 /* this is currently broken by UIDPLUS */
|
yuuji@0
|
1671 /* or skip by mailbox's recorded last */
|
yuuji@0
|
1672 else if (j > stream->uid_last)
|
yuuji@0
|
1673 sprintf (tmp,"Message %lu UID %lu greater than last %lu",
|
yuuji@0
|
1674 pseudoseen ? elt->msgno - 1 : elt->msgno,
|
yuuji@0
|
1675 j,stream->uid_last);
|
yuuji@0
|
1676 #endif
|
yuuji@0
|
1677 else { /* normal UID case */
|
yuuji@0
|
1678 prevuid = elt->private.uid = j;
|
yuuji@0
|
1679 #if 1 /* temporary kludge for UIDPLUS */
|
yuuji@0
|
1680 if (prevuid > stream->uid_last) {
|
yuuji@0
|
1681 stream->uid_last = prevuid;
|
yuuji@0
|
1682 LOCAL->ddirty = LOCAL->dirty = T;
|
yuuji@0
|
1683 }
|
yuuji@0
|
1684 #endif
|
yuuji@0
|
1685 break; /* exit this cruft */
|
yuuji@0
|
1686 }
|
yuuji@0
|
1687 MM_LOG (tmp,WARN);
|
yuuji@0
|
1688 /* invalidate UID validity */
|
yuuji@0
|
1689 stream->uid_validity = 0;
|
yuuji@0
|
1690 elt->private.uid = 0;
|
yuuji@0
|
1691 }
|
yuuji@0
|
1692 break;
|
yuuji@0
|
1693 }
|
yuuji@0
|
1694 }
|
yuuji@0
|
1695 /* otherwise fall into S case */
|
yuuji@0
|
1696
|
yuuji@0
|
1697 case 'S': /* possible Status: line */
|
yuuji@0
|
1698 if (s[0] == 'S' && s[1] == 't' && s[2] == 'a' && s[3] == 't' &&
|
yuuji@0
|
1699 s[4] == 'u' && s[5] == 's' && s[6] == ':') {
|
yuuji@0
|
1700 retain = NIL; /* don't retain continuation */
|
yuuji@0
|
1701 s += 6; /* advance to status flags */
|
yuuji@0
|
1702 do switch (*s++) {/* parse flags */
|
yuuji@0
|
1703 case 'R': /* message read */
|
yuuji@0
|
1704 elt->seen = T;
|
yuuji@0
|
1705 break;
|
yuuji@0
|
1706 case 'O': /* message old */
|
yuuji@0
|
1707 if (elt->recent) {
|
yuuji@0
|
1708 elt->recent = NIL;
|
yuuji@0
|
1709 recent--; /* it really wasn't recent */
|
yuuji@0
|
1710 }
|
yuuji@0
|
1711 break;
|
yuuji@0
|
1712 case 'D': /* message deleted */
|
yuuji@0
|
1713 elt->deleted = T;
|
yuuji@0
|
1714 break;
|
yuuji@0
|
1715 case 'F': /* message flagged */
|
yuuji@0
|
1716 elt->flagged = T;
|
yuuji@0
|
1717 break;
|
yuuji@0
|
1718 case 'A': /* message answered */
|
yuuji@0
|
1719 elt->answered = T;
|
yuuji@0
|
1720 break;
|
yuuji@0
|
1721 case 'T': /* message is a draft */
|
yuuji@0
|
1722 elt->draft = T;
|
yuuji@0
|
1723 break;
|
yuuji@0
|
1724 default: /* some other crap */
|
yuuji@0
|
1725 break;
|
yuuji@0
|
1726 } while (*s && (*s != '\n') && ((*s != '\r') || (s[1] != '\n')));
|
yuuji@0
|
1727 break; /* all done */
|
yuuji@0
|
1728 }
|
yuuji@0
|
1729 /* otherwise fall into default case */
|
yuuji@0
|
1730
|
yuuji@0
|
1731 default: /* ordinary header line */
|
yuuji@0
|
1732 if ((*s == 'S') || (*s == 's') ||
|
yuuji@0
|
1733 (((*s == 'X') || (*s == 'x')) && (s[1] == '-'))) {
|
yuuji@0
|
1734 unsigned char *e,*v;
|
yuuji@0
|
1735 /* must match what mail_filter() does */
|
yuuji@0
|
1736 for (u = s,v = tmp,e = u + min (i,MAILTMPLEN - 1);
|
yuuji@0
|
1737 (u < e) && ((c = (*u ? *u : (*u = ' '))) != ':') &&
|
yuuji@0
|
1738 ((c > ' ') || ((c != ' ') && (c != '\t') &&
|
yuuji@0
|
1739 (c != '\r') && (c != '\n')));
|
yuuji@0
|
1740 *v++ = *u++);
|
yuuji@0
|
1741 *v = '\0'; /* tie off */
|
yuuji@0
|
1742 /* matches internal header? */
|
yuuji@0
|
1743 if (!compare_cstring (tmp,"STATUS") ||
|
yuuji@0
|
1744 !compare_cstring (tmp,"X-STATUS") ||
|
yuuji@0
|
1745 !compare_cstring (tmp,"X-KEYWORDS") ||
|
yuuji@0
|
1746 !compare_cstring (tmp,"X-UID") ||
|
yuuji@0
|
1747 !compare_cstring (tmp,"X-IMAP") ||
|
yuuji@0
|
1748 !compare_cstring (tmp,"X-IMAPBASE")) {
|
yuuji@0
|
1749 char err[MAILTMPLEN];
|
yuuji@0
|
1750 sprintf (err,"Discarding bogus %s header in message %lu",
|
yuuji@0
|
1751 (char *) tmp,elt->msgno);
|
yuuji@0
|
1752 MM_LOG (err,WARN);
|
yuuji@0
|
1753 retain = NIL; /* don't retain continuation */
|
yuuji@0
|
1754 break; /* different case or something */
|
yuuji@0
|
1755 }
|
yuuji@0
|
1756 }
|
yuuji@0
|
1757 /* retain or non-continuation? */
|
yuuji@0
|
1758 if (retain || ((*s != ' ') && (*s != '\t'))) {
|
yuuji@0
|
1759 retain = T; /* retaining continuation now */
|
yuuji@0
|
1760 /* line length in LF format newline */
|
yuuji@0
|
1761 for (j = k = 0; j < i; ++j) if (s[j] != '\r') ++k;
|
yuuji@0
|
1762 /* "internal" header size */
|
yuuji@0
|
1763 elt->private.spare.data += k;
|
yuuji@0
|
1764 /* message size */
|
yuuji@0
|
1765 elt->rfc822_size += k + 1;
|
yuuji@0
|
1766 }
|
yuuji@0
|
1767 else {
|
yuuji@0
|
1768 char err[MAILTMPLEN];
|
yuuji@0
|
1769 sprintf (err,"Discarding bogus continuation in msg %lu: %.80s",
|
yuuji@0
|
1770 elt->msgno,(char *) s);
|
yuuji@0
|
1771 if (u = strpbrk (err,"\r\n")) *u = '\0';
|
yuuji@0
|
1772 MM_LOG (err,WARN);
|
yuuji@0
|
1773 break; /* different case or something */
|
yuuji@0
|
1774 }
|
yuuji@0
|
1775 break;
|
yuuji@0
|
1776 }
|
yuuji@0
|
1777 } while (i && (*t != '\n') && ((*t != '\r') || (t[1] != '\n')));
|
yuuji@0
|
1778 /* "internal" header sans trailing newline */
|
yuuji@0
|
1779 if (i) elt->private.spare.data--;
|
yuuji@0
|
1780 /* assign a UID if none found */
|
yuuji@0
|
1781 if (((nmsgs > 1) || !pseudoseen) && !elt->private.uid) {
|
yuuji@0
|
1782 prevuid = elt->private.uid = ++stream->uid_last;
|
yuuji@0
|
1783 elt->private.dirty = T;
|
yuuji@0
|
1784 LOCAL->ddirty = T; /* force update */
|
yuuji@0
|
1785 }
|
yuuji@0
|
1786 else elt->private.dirty = elt->recent;
|
yuuji@0
|
1787
|
yuuji@0
|
1788 /* note size of header, location of text */
|
yuuji@0
|
1789 elt->private.msg.header.text.size =
|
yuuji@0
|
1790 (elt->private.msg.text.offset =
|
yuuji@0
|
1791 (LOCAL->filesize + GETPOS (&bs)) - elt->private.special.offset) -
|
yuuji@0
|
1792 elt->private.special.text.size;
|
yuuji@0
|
1793 k = m = 0; /* no previous line size yet */
|
yuuji@0
|
1794 /* note current position */
|
yuuji@0
|
1795 j = LOCAL->filesize + GETPOS (&bs);
|
yuuji@0
|
1796 if (i) do { /* look for next message */
|
yuuji@0
|
1797 s = unix_mbxline (stream,&bs,&i);
|
yuuji@0
|
1798 if (i) { /* got new data? */
|
yuuji@0
|
1799 VALID (s,t,ti,zn); /* yes, parse line */
|
yuuji@0
|
1800 if (!ti) { /* not a header line, add it to message */
|
yuuji@0
|
1801 elt->rfc822_size += i;
|
yuuji@0
|
1802 for (j = 0; j < i; ++j) switch (s[j]) {
|
yuuji@0
|
1803 case '\r': /* squeeze out CRs */
|
yuuji@0
|
1804 elt->rfc822_size -= 1;
|
yuuji@0
|
1805 break;
|
yuuji@0
|
1806 case '\n': /* LF becomes CRLF */
|
yuuji@0
|
1807 elt->rfc822_size += 1;
|
yuuji@0
|
1808 break;
|
yuuji@0
|
1809 default:
|
yuuji@0
|
1810 break;
|
yuuji@0
|
1811 }
|
yuuji@0
|
1812 if ((i == 1) && (*s == '\n')) {
|
yuuji@0
|
1813 k = 2;
|
yuuji@0
|
1814 m = 1;
|
yuuji@0
|
1815 }
|
yuuji@0
|
1816 else if ((i == 2) && (*s == '\r') && (s[1] == '\n'))
|
yuuji@0
|
1817 k = m = 2;
|
yuuji@0
|
1818 else k = m = 0; /* file does not end with newline! */
|
yuuji@0
|
1819 /* update current position */
|
yuuji@0
|
1820 j = LOCAL->filesize + GETPOS (&bs);
|
yuuji@0
|
1821 }
|
yuuji@0
|
1822 }
|
yuuji@0
|
1823 } while (i && !ti); /* until found a header */
|
yuuji@0
|
1824 elt->private.msg.text.text.size = j -
|
yuuji@0
|
1825 (elt->private.special.offset + elt->private.msg.text.offset);
|
yuuji@0
|
1826 /* flush ending blank line */
|
yuuji@0
|
1827 elt->private.msg.text.text.size -= m;
|
yuuji@0
|
1828 elt->rfc822_size -= k;
|
yuuji@0
|
1829 /* until end of buffer */
|
yuuji@0
|
1830 } while (!stream->sniff && i);
|
yuuji@0
|
1831 if (pseudoseen) { /* flush pseudo-message if present */
|
yuuji@0
|
1832 /* decrement recent count */
|
yuuji@0
|
1833 if (mail_elt (stream,1)->recent) recent--;
|
yuuji@0
|
1834 /* and the exists count */
|
yuuji@0
|
1835 mail_exists (stream,nmsgs--);
|
yuuji@0
|
1836 mail_expunged(stream,1);/* fake an expunge of that message */
|
yuuji@0
|
1837 }
|
yuuji@0
|
1838 /* need to start a new UID validity? */
|
yuuji@0
|
1839 if (!stream->uid_validity) {
|
yuuji@0
|
1840 stream->uid_validity = time (0);
|
yuuji@0
|
1841 /* in case a whiner with no life */
|
yuuji@0
|
1842 if (mail_parameters (NIL,GET_USERHASNOLIFE,NIL))
|
yuuji@0
|
1843 stream->uid_nosticky = T;
|
yuuji@0
|
1844 else if (nmsgs) { /* don't bother if empty file */
|
yuuji@0
|
1845 /* make dirty to restart UID epoch */
|
yuuji@0
|
1846 LOCAL->ddirty = LOCAL->dirty = T;
|
yuuji@0
|
1847 /* need to rewrite msg 1 if not pseudo */
|
yuuji@0
|
1848 if (!LOCAL->pseudo) mail_elt (stream,1)->private.dirty = T;
|
yuuji@0
|
1849 MM_LOG ("Assigning new unique identifiers to all messages",NIL);
|
yuuji@0
|
1850 }
|
yuuji@0
|
1851 }
|
yuuji@0
|
1852 stream->nmsgs = oldnmsgs; /* whack it back down */
|
yuuji@0
|
1853 stream->silent = silent; /* restore old silent setting */
|
yuuji@0
|
1854 /* notify upper level of new mailbox sizes */
|
yuuji@0
|
1855 mail_exists (stream,nmsgs);
|
yuuji@0
|
1856 mail_recent (stream,recent);
|
yuuji@0
|
1857 /* mark dirty so O flags are set */
|
yuuji@0
|
1858 if (recent) LOCAL->dirty = T;
|
yuuji@0
|
1859 }
|
yuuji@0
|
1860 }
|
yuuji@0
|
1861 /* no change, don't babble if never got time */
|
yuuji@0
|
1862 else if (LOCAL->filetime && LOCAL->filetime != sbuf.st_mtime)
|
yuuji@0
|
1863 MM_LOG ("New mailbox modification time but apparently no changes",WARN);
|
yuuji@0
|
1864 /* update parsed file size and time */
|
yuuji@0
|
1865 LOCAL->filesize = sbuf.st_size;
|
yuuji@0
|
1866 LOCAL->filetime = sbuf.st_mtime;
|
yuuji@0
|
1867 return T; /* return the winnage */
|
yuuji@0
|
1868 }
|
yuuji@0
|
1869
|
yuuji@0
|
1870 /* UNIX read line from mailbox
|
yuuji@0
|
1871 * Accepts: mail stream
|
yuuji@0
|
1872 * stringstruct
|
yuuji@0
|
1873 * pointer to line size
|
yuuji@0
|
1874 * Returns: pointer to input line
|
yuuji@0
|
1875 */
|
yuuji@0
|
1876
|
yuuji@0
|
1877 char *unix_mbxline (MAILSTREAM *stream,STRING *bs,unsigned long *size)
|
yuuji@0
|
1878 {
|
yuuji@0
|
1879 unsigned long i,j,k,m;
|
yuuji@0
|
1880 char *s,*t,*te;
|
yuuji@0
|
1881 char *ret = "";
|
yuuji@0
|
1882 /* flush old buffer */
|
yuuji@0
|
1883 if (LOCAL->line) fs_give ((void **) &LOCAL->line);
|
yuuji@0
|
1884 /* if buffer needs refreshing */
|
yuuji@0
|
1885 if (!bs->cursize) SETPOS (bs,GETPOS (bs));
|
yuuji@0
|
1886 if (SIZE (bs)) { /* find newline */
|
yuuji@0
|
1887 /* end of fast scan */
|
yuuji@0
|
1888 te = (t = (s = bs->curpos) + bs->cursize) - 12;
|
yuuji@0
|
1889 while (s < te) if ((*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
|
yuuji@0
|
1890 (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
|
yuuji@0
|
1891 (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
|
yuuji@0
|
1892 (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n')) {
|
yuuji@0
|
1893 --s; /* back up */
|
yuuji@0
|
1894 break; /* exit loop */
|
yuuji@0
|
1895 }
|
yuuji@0
|
1896 /* final character-at-a-time scan */
|
yuuji@0
|
1897 while ((s < t) && (*s != '\n')) ++s;
|
yuuji@0
|
1898 /* difficult case if line spans buffer */
|
yuuji@0
|
1899 if ((i = s - bs->curpos) == bs->cursize) {
|
yuuji@0
|
1900 /* have space in line buffer? */
|
yuuji@0
|
1901 if (i > LOCAL->linebuflen) {
|
yuuji@0
|
1902 fs_give ((void **) &LOCAL->linebuf);
|
yuuji@0
|
1903 LOCAL->linebuf = (char *) fs_get (LOCAL->linebuflen = i);
|
yuuji@0
|
1904 }
|
yuuji@0
|
1905 /* remember what we have so far */
|
yuuji@0
|
1906 memcpy (LOCAL->linebuf,bs->curpos,i);
|
yuuji@0
|
1907 /* load next buffer */
|
yuuji@0
|
1908 SETPOS (bs,k = GETPOS (bs) + i);
|
yuuji@0
|
1909 /* end of fast scan */
|
yuuji@0
|
1910 te = (t = (s = bs->curpos) + bs->cursize) - 12;
|
yuuji@0
|
1911 /* fast scan in overlap buffer */
|
yuuji@0
|
1912 while (s < te) if ((*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
|
yuuji@0
|
1913 (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
|
yuuji@0
|
1914 (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n') ||
|
yuuji@0
|
1915 (*s++ == '\n') || (*s++ == '\n') || (*s++ == '\n')) {
|
yuuji@0
|
1916 --s; /* back up */
|
yuuji@0
|
1917 break; /* exit loop */
|
yuuji@0
|
1918 }
|
yuuji@0
|
1919
|
yuuji@0
|
1920 /* final character-at-a-time scan */
|
yuuji@0
|
1921 while ((s < t) && (*s != '\n')) ++s;
|
yuuji@0
|
1922 /* huge line? */
|
yuuji@0
|
1923 if ((j = s - bs->curpos) == bs->cursize) {
|
yuuji@0
|
1924 SETPOS (bs,GETPOS (bs) + j);
|
yuuji@0
|
1925 /* look for end of line (s-l-o-w!!) */
|
yuuji@0
|
1926 for (m = SIZE (bs); m && (SNX (bs) != '\n'); --m,++j);
|
yuuji@0
|
1927 SETPOS (bs,k); /* go back to where it started */
|
yuuji@0
|
1928 }
|
yuuji@0
|
1929 /* got size of data, make buffer for return */
|
yuuji@0
|
1930 ret = LOCAL->line = (char *) fs_get (i + j + 2);
|
yuuji@0
|
1931 /* copy first chunk */
|
yuuji@0
|
1932 memcpy (ret,LOCAL->linebuf,i);
|
yuuji@0
|
1933 while (j) { /* copy remainder */
|
yuuji@0
|
1934 if (!bs->cursize) SETPOS (bs,GETPOS (bs));
|
yuuji@0
|
1935 memcpy (ret + i,bs->curpos,k = min (j,bs->cursize));
|
yuuji@0
|
1936 i += k; /* account for this much read in */
|
yuuji@0
|
1937 j -= k;
|
yuuji@0
|
1938 bs->curpos += k; /* increment new position */
|
yuuji@0
|
1939 bs->cursize -= k; /* eat that many bytes */
|
yuuji@0
|
1940 }
|
yuuji@0
|
1941 if (!bs->cursize) SETPOS (bs,GETPOS (bs));
|
yuuji@0
|
1942 /* read newline at end */
|
yuuji@0
|
1943 if (SIZE (bs)) ret[i++] = SNX (bs);
|
yuuji@0
|
1944 ret[i] = '\0'; /* makes debugging easier */
|
yuuji@0
|
1945 }
|
yuuji@0
|
1946 else { /* this is easy */
|
yuuji@0
|
1947 ret = bs->curpos; /* string it at this position */
|
yuuji@0
|
1948 bs->curpos += ++i; /* increment new position */
|
yuuji@0
|
1949 bs->cursize -= i; /* eat that many bytes */
|
yuuji@0
|
1950 }
|
yuuji@0
|
1951 *size = i; /* return that to user */
|
yuuji@0
|
1952 }
|
yuuji@0
|
1953 else *size = 0; /* end of data, return empty */
|
yuuji@0
|
1954 return ret;
|
yuuji@0
|
1955 }
|
yuuji@0
|
1956
|
yuuji@0
|
1957 /* UNIX make pseudo-header
|
yuuji@0
|
1958 * Accepts: MAIL stream
|
yuuji@0
|
1959 * buffer to write pseudo-header
|
yuuji@0
|
1960 * Returns: length of pseudo-header
|
yuuji@0
|
1961 */
|
yuuji@0
|
1962
|
yuuji@0
|
1963 unsigned long unix_pseudo (MAILSTREAM *stream,char *hdr)
|
yuuji@0
|
1964 {
|
yuuji@0
|
1965 int i;
|
yuuji@0
|
1966 char *s,tmp[MAILTMPLEN];
|
yuuji@0
|
1967 time_t now = time (0);
|
yuuji@0
|
1968 rfc822_fixed_date (tmp);
|
yuuji@0
|
1969 sprintf (hdr,"From %s %.24s\nDate: %s\nFrom: %s <%s@%.80s>\nSubject: %s\nMessage-ID: <%lu@%.80s>\nX-IMAP: %010lu %010lu",
|
yuuji@0
|
1970 pseudo_from,ctime (&now),
|
yuuji@0
|
1971 tmp,pseudo_name,pseudo_from,mylocalhost (),pseudo_subject,
|
yuuji@0
|
1972 (unsigned long) now,mylocalhost (),stream->uid_validity,
|
yuuji@0
|
1973 stream->uid_last);
|
yuuji@0
|
1974 for (s = hdr + strlen (hdr),i = 0; i < NUSERFLAGS; ++i)
|
yuuji@0
|
1975 if (stream->user_flags[i])
|
yuuji@0
|
1976 sprintf (s += strlen (s)," %s",stream->user_flags[i]);
|
yuuji@0
|
1977 sprintf (s += strlen (s),"\nStatus: RO\n\n%s\n\n",pseudo_msg);
|
yuuji@0
|
1978 return strlen (hdr); /* return header length */
|
yuuji@0
|
1979 }
|
yuuji@0
|
1980
|
yuuji@0
|
1981 /* UNIX make status string
|
yuuji@0
|
1982 * Accepts: MAIL stream
|
yuuji@0
|
1983 * destination string to write
|
yuuji@0
|
1984 * message cache entry
|
yuuji@0
|
1985 * UID to write if non-zero (else use elt->private.uid)
|
yuuji@0
|
1986 * non-zero flag to write UID (.LT. 0 to write UID base info too)
|
yuuji@0
|
1987 * Returns: length of string
|
yuuji@0
|
1988 */
|
yuuji@0
|
1989
|
yuuji@0
|
1990 unsigned long unix_xstatus (MAILSTREAM *stream,char *status,MESSAGECACHE *elt,
|
yuuji@0
|
1991 unsigned long uid,long flag)
|
yuuji@0
|
1992 {
|
yuuji@0
|
1993 char *t,stack[64];
|
yuuji@0
|
1994 char *s = status;
|
yuuji@0
|
1995 unsigned long n;
|
yuuji@0
|
1996 int pad = 50;
|
yuuji@0
|
1997 int sticky = uid ? T : !stream->uid_nosticky;
|
yuuji@0
|
1998 /* This used to use sprintf(), but thanks to certain cretinous C libraries
|
yuuji@0
|
1999 with horribly slow implementations of sprintf() I had to change it to this
|
yuuji@0
|
2000 mess. At least it should be fast. */
|
yuuji@0
|
2001 if ((flag < 0) && sticky) { /* need to write X-IMAPbase: header? */
|
yuuji@0
|
2002 *s++ = 'X'; *s++ = '-'; *s++ = 'I'; *s++ = 'M'; *s++ = 'A'; *s++ = 'P';
|
yuuji@0
|
2003 *s++ = 'b'; *s++ = 'a'; *s++ = 's'; *s++ = 'e'; *s++ = ':'; *s++ = ' ';
|
yuuji@0
|
2004 t = stack;
|
yuuji@0
|
2005 n = stream->uid_validity; /* push UID validity digits on the stack */
|
yuuji@0
|
2006 do *t++ = (char) (n % 10) + '0';
|
yuuji@0
|
2007 while (n /= 10);
|
yuuji@0
|
2008 /* pop UID validity digits from stack */
|
yuuji@0
|
2009 while (t > stack) *s++ = *--t;
|
yuuji@0
|
2010 *s++ = ' ';
|
yuuji@0
|
2011 n = stream->uid_last; /* push UID last digits on the stack */
|
yuuji@0
|
2012 do *t++ = (char) (n % 10) + '0';
|
yuuji@0
|
2013 while (n /= 10);
|
yuuji@0
|
2014 /* pop UID last digits from stack */
|
yuuji@0
|
2015 while (t > stack) *s++ = *--t;
|
yuuji@0
|
2016 for (n = 0; n < NUSERFLAGS; ++n) if (t = stream->user_flags[n])
|
yuuji@0
|
2017 for (*s++ = ' '; *t; *s++ = *t++);
|
yuuji@0
|
2018 *s++ = '\n';
|
yuuji@0
|
2019 pad += 30; /* increased padding if have IMAPbase */
|
yuuji@0
|
2020 }
|
yuuji@0
|
2021 *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't'; *s++ = 'u'; *s++ = 's';
|
yuuji@0
|
2022 *s++ = ':'; *s++ = ' ';
|
yuuji@0
|
2023 if (elt->seen) *s++ = 'R';
|
yuuji@0
|
2024 /* only write O if have a UID */
|
yuuji@0
|
2025 if (flag && (!elt->recent || !LOCAL->appending)) *s++ = 'O';
|
yuuji@0
|
2026 *s++ = '\n';
|
yuuji@0
|
2027 *s++ = 'X'; *s++ = '-'; *s++ = 'S'; *s++ = 't'; *s++ = 'a'; *s++ = 't';
|
yuuji@0
|
2028 *s++ = 'u'; *s++ = 's'; *s++ = ':'; *s++ = ' ';
|
yuuji@0
|
2029 if (elt->deleted) *s++ = 'D';
|
yuuji@0
|
2030 if (elt->flagged) *s++ = 'F';
|
yuuji@0
|
2031 if (elt->answered) *s++ = 'A';
|
yuuji@0
|
2032 if (elt->draft) *s++ = 'T';
|
yuuji@0
|
2033 *s++ = '\n';
|
yuuji@0
|
2034
|
yuuji@0
|
2035 if (sticky) { /* only do this if UIDs sticky */
|
yuuji@0
|
2036 *s++ = 'X'; *s++ = '-'; *s++ = 'K'; *s++ = 'e'; *s++ = 'y'; *s++ = 'w';
|
yuuji@0
|
2037 *s++ = 'o'; *s++ = 'r'; *s++ = 'd'; *s++ = 's'; *s++ = ':';
|
yuuji@0
|
2038 if (n = elt->user_flags) do {
|
yuuji@0
|
2039 *s++ = ' ';
|
yuuji@0
|
2040 for (t = stream->user_flags[find_rightmost_bit (&n)]; *t; *s++ = *t++);
|
yuuji@0
|
2041 } while (n);
|
yuuji@0
|
2042 n = s - status; /* get size of stuff so far */
|
yuuji@0
|
2043 /* pad X-Keywords to make size constant */
|
yuuji@0
|
2044 if (n < pad) for (n = pad - n; n > 0; --n) *s++ = ' ';
|
yuuji@0
|
2045 *s++ = '\n';
|
yuuji@0
|
2046 if (flag) { /* want to include UID? */
|
yuuji@0
|
2047 t = stack;
|
yuuji@0
|
2048 /* push UID digits on the stack */
|
yuuji@0
|
2049 n = uid ? uid : elt->private.uid;
|
yuuji@0
|
2050 do *t++ = (char) (n % 10) + '0';
|
yuuji@0
|
2051 while (n /= 10);
|
yuuji@0
|
2052 *s++ = 'X'; *s++ = '-'; *s++ = 'U'; *s++ = 'I'; *s++ = 'D'; *s++ = ':';
|
yuuji@0
|
2053 *s++ = ' ';
|
yuuji@0
|
2054 /* pop UID from stack */
|
yuuji@0
|
2055 while (t > stack) *s++ = *--t;
|
yuuji@0
|
2056 *s++ = '\n';
|
yuuji@0
|
2057 }
|
yuuji@0
|
2058 }
|
yuuji@0
|
2059 *s++ = '\n'; *s = '\0'; /* end of extended message status */
|
yuuji@0
|
2060 return s - status; /* return size of resulting string */
|
yuuji@0
|
2061 }
|
yuuji@0
|
2062
|
yuuji@0
|
2063 /* Rewrite mailbox file
|
yuuji@0
|
2064 * Accepts: MAIL stream, must be critical and locked
|
yuuji@0
|
2065 * return pointer to number of expunged messages if want expunge
|
yuuji@0
|
2066 * lock file name
|
yuuji@0
|
2067 * expunge sequence, not deleted flag
|
yuuji@0
|
2068 * Returns: T if success and mailbox unlocked, NIL if failure
|
yuuji@0
|
2069 */
|
yuuji@0
|
2070
|
yuuji@0
|
2071 #define OVERFLOWBUFLEN 8192 /* initial overflow buffer length */
|
yuuji@0
|
2072
|
yuuji@0
|
2073 long unix_rewrite (MAILSTREAM *stream,unsigned long *nexp,DOTLOCK *lock,
|
yuuji@0
|
2074 long flags)
|
yuuji@0
|
2075 {
|
yuuji@0
|
2076 MESSAGECACHE *elt;
|
yuuji@0
|
2077 UNIXFILE f;
|
yuuji@0
|
2078 char *s;
|
yuuji@0
|
2079 time_t tp[2];
|
yuuji@0
|
2080 long ret,flag;
|
yuuji@0
|
2081 unsigned long i,j;
|
yuuji@0
|
2082 unsigned long recent = stream->recent;
|
yuuji@0
|
2083 unsigned long size = LOCAL->pseudo ? unix_pseudo (stream,LOCAL->buf) : 0;
|
yuuji@0
|
2084 if (nexp) *nexp = 0; /* initially nothing expunged */
|
yuuji@0
|
2085 /* calculate size of mailbox after rewrite */
|
yuuji@0
|
2086 for (i = 1,flag = LOCAL->pseudo ? 1 : -1; i <= stream->nmsgs; i++) {
|
yuuji@0
|
2087 elt = mail_elt (stream,i); /* get cache */
|
yuuji@0
|
2088 if (!(nexp && elt->deleted && (flags ? elt->sequence : T))) {
|
yuuji@0
|
2089 /* add RFC822 size of this message */
|
yuuji@0
|
2090 size += elt->private.special.text.size + elt->private.spare.data +
|
yuuji@0
|
2091 unix_xstatus (stream,LOCAL->buf,elt,NIL,flag) +
|
yuuji@0
|
2092 elt->private.msg.text.text.size + 1;
|
yuuji@0
|
2093 flag = 1; /* only count X-IMAPbase once */
|
yuuji@0
|
2094 }
|
yuuji@0
|
2095 }
|
yuuji@0
|
2096 /* no messages, has a life, and no pseudo */
|
yuuji@0
|
2097 if (!size && !mail_parameters (NIL,GET_USERHASNOLIFE,NIL)) {
|
yuuji@0
|
2098 LOCAL->pseudo = T; /* so make a pseudo-message now */
|
yuuji@0
|
2099 size = unix_pseudo (stream,LOCAL->buf);
|
yuuji@0
|
2100 }
|
yuuji@0
|
2101 /* extend the file as necessary */
|
yuuji@0
|
2102 if (ret = unix_extend (stream,size)) {
|
yuuji@0
|
2103 /* Set up buffered I/O file structure
|
yuuji@0
|
2104 * curpos current position being written through buffering
|
yuuji@0
|
2105 * filepos current position being written physically to the disk
|
yuuji@0
|
2106 * bufpos current position being written in the buffer
|
yuuji@0
|
2107 * protect current maximum position that can be written to the disk
|
yuuji@0
|
2108 * before buffering is forced
|
yuuji@0
|
2109 * The code tries to buffer so that that disk is written in multiples of
|
yuuji@0
|
2110 * OVERBLOWBUFLEN bytes.
|
yuuji@0
|
2111 */
|
yuuji@0
|
2112 f.stream = stream; /* note mail stream */
|
yuuji@0
|
2113 f.curpos = f.filepos = 0; /* start of file */
|
yuuji@0
|
2114 f.protect = stream->nmsgs ? /* initial protection pointer */
|
yuuji@0
|
2115 mail_elt (stream,1)->private.special.offset : 8192;
|
yuuji@0
|
2116 f.bufpos = f.buf = (char *) fs_get (f.buflen = OVERFLOWBUFLEN);
|
yuuji@0
|
2117
|
yuuji@0
|
2118 if (LOCAL->pseudo) /* update pseudo-header */
|
yuuji@0
|
2119 unix_write (&f,LOCAL->buf,unix_pseudo (stream,LOCAL->buf));
|
yuuji@0
|
2120 /* loop through all messages */
|
yuuji@0
|
2121 for (i = 1,flag = LOCAL->pseudo ? 1 : -1; i <= stream->nmsgs;) {
|
yuuji@0
|
2122 elt = mail_elt (stream,i);/* get cache */
|
yuuji@0
|
2123 /* expunge this message? */
|
yuuji@0
|
2124 if (nexp && elt->deleted && (flags ? elt->sequence : T)) {
|
yuuji@0
|
2125 /* one less recent message */
|
yuuji@0
|
2126 if (elt->recent) --recent;
|
yuuji@0
|
2127 mail_expunged(stream,i);/* notify upper levels */
|
yuuji@0
|
2128 ++*nexp; /* count up one more expunged message */
|
yuuji@0
|
2129 }
|
yuuji@0
|
2130 else { /* preserve this message */
|
yuuji@0
|
2131 i++; /* advance to next message */
|
yuuji@0
|
2132 if ((flag < 0) || /* need to rewrite message? */
|
yuuji@0
|
2133 elt->private.dirty || (f.curpos != elt->private.special.offset) ||
|
yuuji@0
|
2134 (elt->private.msg.header.text.size !=
|
yuuji@0
|
2135 (elt->private.spare.data +
|
yuuji@0
|
2136 unix_xstatus (stream,LOCAL->buf,elt,NIL,flag)))) {
|
yuuji@0
|
2137 unsigned long newoffset = f.curpos;
|
yuuji@0
|
2138 /* yes, seek to internal header */
|
yuuji@0
|
2139 lseek (LOCAL->fd,elt->private.special.offset,L_SET);
|
yuuji@0
|
2140 read (LOCAL->fd,LOCAL->buf,elt->private.special.text.size);
|
yuuji@0
|
2141 /* see if need to squeeze out a CR */
|
yuuji@0
|
2142 if (LOCAL->buf[elt->private.special.text.size - 2] == '\r') {
|
yuuji@0
|
2143 LOCAL->buf[--elt->private.special.text.size - 1] = '\n';
|
yuuji@0
|
2144 --size; /* squeezed out a CR from PC */
|
yuuji@0
|
2145 }
|
yuuji@0
|
2146 /* protection pointer moves to RFC822 header */
|
yuuji@0
|
2147 f.protect = elt->private.special.offset +
|
yuuji@0
|
2148 elt->private.msg.header.offset;
|
yuuji@0
|
2149 /* write internal header */
|
yuuji@0
|
2150 unix_write (&f,LOCAL->buf,elt->private.special.text.size);
|
yuuji@0
|
2151 /* get RFC822 header */
|
yuuji@0
|
2152 s = unix_header (stream,elt->msgno,&j,FT_INTERNAL);
|
yuuji@0
|
2153 /* in case this got decremented */
|
yuuji@0
|
2154 elt->private.msg.header.offset = elt->private.special.text.size;
|
yuuji@0
|
2155 /* header size, sans trailing newline */
|
yuuji@0
|
2156 if ((j < 2) || (s[j - 2] == '\n')) j--;
|
yuuji@0
|
2157 /* this can happen if CRs were squeezed */
|
yuuji@0
|
2158 if (j < elt->private.spare.data) {
|
yuuji@0
|
2159 /* so fix up counts */
|
yuuji@0
|
2160 size -= elt->private.spare.data - j;
|
yuuji@0
|
2161 elt->private.spare.data = j;
|
yuuji@0
|
2162 }
|
yuuji@0
|
2163 else if (j != elt->private.spare.data)
|
yuuji@0
|
2164 fatal ("header size inconsistent");
|
yuuji@0
|
2165 /* protection pointer moves to RFC822 text */
|
yuuji@0
|
2166 f.protect = elt->private.special.offset +
|
yuuji@0
|
2167 elt->private.msg.text.offset;
|
yuuji@0
|
2168 unix_write (&f,s,j); /* write RFC822 header */
|
yuuji@0
|
2169 /* write status and UID */
|
yuuji@0
|
2170 unix_write (&f,LOCAL->buf,
|
yuuji@0
|
2171 j = unix_xstatus (stream,LOCAL->buf,elt,NIL,flag));
|
yuuji@0
|
2172 flag = 1; /* only write X-IMAPbase once */
|
yuuji@0
|
2173 /* new file header size */
|
yuuji@0
|
2174 elt->private.msg.header.text.size = elt->private.spare.data + j;
|
yuuji@0
|
2175
|
yuuji@0
|
2176 /* did text move? */
|
yuuji@0
|
2177 if (f.curpos != f.protect) {
|
yuuji@0
|
2178 /* get message text */
|
yuuji@0
|
2179 s = unix_text_work (stream,elt,&j,FT_INTERNAL);
|
yuuji@0
|
2180 /* this can happen if CRs were squeezed */
|
yuuji@0
|
2181 if (j < elt->private.msg.text.text.size) {
|
yuuji@0
|
2182 /* so fix up counts */
|
yuuji@0
|
2183 size -= elt->private.msg.text.text.size - j;
|
yuuji@0
|
2184 elt->private.msg.text.text.size = j;
|
yuuji@0
|
2185 }
|
yuuji@0
|
2186 /* can't happen it says here */
|
yuuji@0
|
2187 else if (j > elt->private.msg.text.text.size)
|
yuuji@0
|
2188 fatal ("text size inconsistent");
|
yuuji@0
|
2189 /* new text offset, status/UID may change it */
|
yuuji@0
|
2190 elt->private.msg.text.offset = f.curpos - newoffset;
|
yuuji@0
|
2191 /* protection pointer moves to next message */
|
yuuji@0
|
2192 f.protect = (i <= stream->nmsgs) ?
|
yuuji@0
|
2193 mail_elt (stream,i)->private.special.offset : (f.curpos + j + 1);
|
yuuji@0
|
2194 unix_write (&f,s,j);/* write text */
|
yuuji@0
|
2195 /* write trailing newline */
|
yuuji@0
|
2196 unix_write (&f,"\n",1);
|
yuuji@0
|
2197 }
|
yuuji@0
|
2198 else { /* tie off header and status */
|
yuuji@0
|
2199 unix_write (&f,NIL,NIL);
|
yuuji@0
|
2200 /* protection pointer moves to next message */
|
yuuji@0
|
2201 f.protect = (i <= stream->nmsgs) ?
|
yuuji@0
|
2202 mail_elt (stream,i)->private.special.offset : size;
|
yuuji@0
|
2203 /* locate end of message text */
|
yuuji@0
|
2204 j = f.filepos + elt->private.msg.text.text.size;
|
yuuji@0
|
2205 /* trailing newline already there? */
|
yuuji@0
|
2206 if (f.protect == (j + 1)) f.curpos = f.filepos = f.protect;
|
yuuji@0
|
2207 else { /* trailing newline missing, write it */
|
yuuji@0
|
2208 f.curpos = f.filepos = j;
|
yuuji@0
|
2209 unix_write (&f,"\n",1);
|
yuuji@0
|
2210 }
|
yuuji@0
|
2211 }
|
yuuji@0
|
2212 /* new internal header offset */
|
yuuji@0
|
2213 elt->private.special.offset = newoffset;
|
yuuji@0
|
2214 elt->private.dirty =NIL;/* message is now clean */
|
yuuji@0
|
2215 }
|
yuuji@0
|
2216 else { /* no need to rewrite this message */
|
yuuji@0
|
2217 /* tie off previous message if needed */
|
yuuji@0
|
2218 unix_write (&f,NIL,NIL);
|
yuuji@0
|
2219 /* protection pointer moves to next message */
|
yuuji@0
|
2220 f.protect = (i <= stream->nmsgs) ?
|
yuuji@0
|
2221 mail_elt (stream,i)->private.special.offset : size;
|
yuuji@0
|
2222 /* locate end of message text */
|
yuuji@0
|
2223 j = f.filepos + elt->private.special.text.size +
|
yuuji@0
|
2224 elt->private.msg.header.text.size +
|
yuuji@0
|
2225 elt->private.msg.text.text.size;
|
yuuji@0
|
2226 /* trailing newline already there? */
|
yuuji@0
|
2227 if (f.protect == (j + 1)) f.curpos = f.filepos = f.protect;
|
yuuji@0
|
2228 else { /* trailing newline missing, write it */
|
yuuji@0
|
2229 f.curpos = f.filepos = j;
|
yuuji@0
|
2230 unix_write (&f,"\n",1);
|
yuuji@0
|
2231 }
|
yuuji@0
|
2232 }
|
yuuji@0
|
2233 }
|
yuuji@0
|
2234 }
|
yuuji@0
|
2235
|
yuuji@0
|
2236 unix_write (&f,NIL,NIL); /* tie off final message */
|
yuuji@0
|
2237 if (size != f.filepos) fatal ("file size inconsistent");
|
yuuji@0
|
2238 fs_give ((void **) &f.buf); /* free buffer */
|
yuuji@0
|
2239 /* make sure tied off */
|
yuuji@0
|
2240 ftruncate (LOCAL->fd,LOCAL->filesize = size);
|
yuuji@0
|
2241 fsync (LOCAL->fd); /* make sure the updates take */
|
yuuji@0
|
2242 if (size && (flag < 0)) fatal ("lost UID base information");
|
yuuji@0
|
2243 /* no longer dirty */
|
yuuji@0
|
2244 LOCAL->ddirty = LOCAL->dirty = NIL;
|
yuuji@0
|
2245 /* notify upper level of new mailbox sizes */
|
yuuji@0
|
2246 mail_exists (stream,stream->nmsgs);
|
yuuji@0
|
2247 mail_recent (stream,recent);
|
yuuji@0
|
2248 /* set atime to now, mtime a second earlier */
|
yuuji@0
|
2249 tp[1] = (tp[0] = time (0)) - 1;
|
yuuji@0
|
2250 /* set the times, note change */
|
yuuji@0
|
2251 if (!utime (stream->mailbox,tp)) LOCAL->filetime = tp[1];
|
yuuji@0
|
2252 close (LOCAL->fd); /* close and reopen file */
|
yuuji@0
|
2253 if ((LOCAL->fd = open (stream->mailbox,O_RDWR,
|
yuuji@0
|
2254 (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL)))
|
yuuji@0
|
2255 < 0) {
|
yuuji@0
|
2256 sprintf (LOCAL->buf,"Mailbox open failed, aborted: %s",strerror (errno));
|
yuuji@0
|
2257 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
2258 unix_abort (stream);
|
yuuji@0
|
2259 }
|
yuuji@0
|
2260 dotlock_unlock (lock); /* flush the lock file */
|
yuuji@0
|
2261 }
|
yuuji@0
|
2262 return ret; /* return state from algorithm */
|
yuuji@0
|
2263 }
|
yuuji@0
|
2264
|
yuuji@0
|
2265 /* Extend UNIX mailbox file
|
yuuji@0
|
2266 * Accepts: MAIL stream
|
yuuji@0
|
2267 * new desired size
|
yuuji@0
|
2268 * Return: T if success, else NIL
|
yuuji@0
|
2269 */
|
yuuji@0
|
2270
|
yuuji@0
|
2271 long unix_extend (MAILSTREAM *stream,unsigned long size)
|
yuuji@0
|
2272 {
|
yuuji@0
|
2273 unsigned long i = (size > LOCAL->filesize) ? size - LOCAL->filesize : 0;
|
yuuji@0
|
2274 if (i) { /* does the mailbox need to grow? */
|
yuuji@0
|
2275 if (i > LOCAL->buflen) { /* make sure have enough space */
|
yuuji@0
|
2276 /* this user won the lottery all right */
|
yuuji@0
|
2277 fs_give ((void **) &LOCAL->buf);
|
yuuji@0
|
2278 LOCAL->buf = (char *) fs_get ((LOCAL->buflen = i) + 1);
|
yuuji@0
|
2279 }
|
yuuji@0
|
2280 memset (LOCAL->buf,'\0',i); /* get a block of nulls */
|
yuuji@0
|
2281 while (T) { /* until write successful or punt */
|
yuuji@0
|
2282 lseek (LOCAL->fd,LOCAL->filesize,L_SET);
|
yuuji@0
|
2283 if ((write (LOCAL->fd,LOCAL->buf,i) >= 0) && !fsync (LOCAL->fd)) break;
|
yuuji@0
|
2284 else {
|
yuuji@0
|
2285 long e = errno; /* note error before doing ftruncate */
|
yuuji@0
|
2286 ftruncate (LOCAL->fd,LOCAL->filesize);
|
yuuji@0
|
2287 if (MM_DISKERROR (stream,e,NIL)) {
|
yuuji@0
|
2288 fsync (LOCAL->fd); /* user chose to punt */
|
yuuji@0
|
2289 sprintf (LOCAL->buf,"Unable to extend mailbox: %s",strerror (e));
|
yuuji@0
|
2290 if (!stream->silent) MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
2291 return NIL;
|
yuuji@0
|
2292 }
|
yuuji@0
|
2293 }
|
yuuji@0
|
2294 }
|
yuuji@0
|
2295 }
|
yuuji@0
|
2296 return LONGT;
|
yuuji@0
|
2297 }
|
yuuji@0
|
2298
|
yuuji@0
|
2299 /* Write data to buffered file
|
yuuji@0
|
2300 * Accepts: buffered file pointer
|
yuuji@0
|
2301 * file data or NIL to indicate "flush buffer"
|
yuuji@0
|
2302 * date size (ignored for "flush buffer")
|
yuuji@0
|
2303 * Does not return until success
|
yuuji@0
|
2304 */
|
yuuji@0
|
2305
|
yuuji@0
|
2306 void unix_write (UNIXFILE *f,char *buf,unsigned long size)
|
yuuji@0
|
2307 {
|
yuuji@0
|
2308 unsigned long i,j,k;
|
yuuji@0
|
2309 if (buf) { /* doing buffered write? */
|
yuuji@0
|
2310 i = f->bufpos - f->buf; /* yes, get size of current buffer data */
|
yuuji@0
|
2311 /* yes, have space in current buffer chunk? */
|
yuuji@0
|
2312 if (j = i ? ((f->buflen - i) % OVERFLOWBUFLEN) : f->buflen) {
|
yuuji@0
|
2313 /* yes, fill up buffer as much as we can */
|
yuuji@0
|
2314 memcpy (f->bufpos,buf,k = min (j,size));
|
yuuji@0
|
2315 f->bufpos += k; /* new buffer position */
|
yuuji@0
|
2316 f->curpos += k; /* new current position */
|
yuuji@0
|
2317 if (j -= k) return; /* all done if still have buffer free space */
|
yuuji@0
|
2318 buf += k; /* full, get new unwritten data pointer */
|
yuuji@0
|
2319 size -= k; /* new data size */
|
yuuji@0
|
2320 i += k; /* new buffer data size */
|
yuuji@0
|
2321 }
|
yuuji@0
|
2322 /* This chunk of the buffer is full. See if can make some space by
|
yuuji@0
|
2323 * writing to the disk, if there's enough unprotected space to do so.
|
yuuji@0
|
2324 * Try to fill out any unaligned chunk, along with any subsequent full
|
yuuji@0
|
2325 * chunks that will fit in unprotected space.
|
yuuji@0
|
2326 */
|
yuuji@0
|
2327 /* any unprotected space we can write to? */
|
yuuji@0
|
2328 if (j = min (i,f->protect - f->filepos)) {
|
yuuji@0
|
2329 /* yes, filepos not at chunk boundary? */
|
yuuji@0
|
2330 if ((k = f->filepos % OVERFLOWBUFLEN) && ((k = OVERFLOWBUFLEN - k) < j))
|
yuuji@0
|
2331 j -= k; /* yes, and can write out partial chunk */
|
yuuji@0
|
2332 else k = 0; /* no partial chunk to write */
|
yuuji@0
|
2333 /* if at least a chunk free, write that too */
|
yuuji@0
|
2334 if (j > OVERFLOWBUFLEN) k += j - (j % OVERFLOWBUFLEN);
|
yuuji@0
|
2335 if (k) { /* write data if there is anything we can */
|
yuuji@0
|
2336 unix_phys_write (f,f->buf,k);
|
yuuji@0
|
2337 /* slide buffer */
|
yuuji@0
|
2338 if (i -= k) memmove (f->buf,f->buf + k,i);
|
yuuji@0
|
2339 f->bufpos = f->buf + i; /* new end of buffer */
|
yuuji@0
|
2340 }
|
yuuji@0
|
2341 }
|
yuuji@0
|
2342
|
yuuji@0
|
2343 /* Have flushed the buffer as best as possible. All done if no more
|
yuuji@0
|
2344 * data to write. Otherwise, if the buffer is empty AND if the unwritten
|
yuuji@0
|
2345 * data is larger than a chunk AND the unprotected space is also larger
|
yuuji@0
|
2346 * than a chunk, then write as many chunks as we can directly from the
|
yuuji@0
|
2347 * data. Buffer the rest, expanding the buffer as needed.
|
yuuji@0
|
2348 */
|
yuuji@0
|
2349 if (size) { /* have more data that we need to buffer? */
|
yuuji@0
|
2350 /* can write any of it to disk instead? */
|
yuuji@0
|
2351 if ((f->bufpos == f->buf) &&
|
yuuji@0
|
2352 ((j = min (f->protect - f->filepos,size)) > OVERFLOWBUFLEN)) {
|
yuuji@0
|
2353 /* write as much as we can right now */
|
yuuji@0
|
2354 unix_phys_write (f,buf,j -= (j % OVERFLOWBUFLEN));
|
yuuji@0
|
2355 buf += j; /* new data pointer */
|
yuuji@0
|
2356 size -= j; /* new data size */
|
yuuji@0
|
2357 f->curpos += j; /* advance current pointer */
|
yuuji@0
|
2358 }
|
yuuji@0
|
2359 if (size) { /* still have data that we need to buffer? */
|
yuuji@0
|
2360 /* yes, need to expand the buffer? */
|
yuuji@0
|
2361 if ((i = ((f->bufpos + size) - f->buf)) > f->buflen) {
|
yuuji@0
|
2362 /* note current position in buffer */
|
yuuji@0
|
2363 j = f->bufpos - f->buf;
|
yuuji@0
|
2364 i += OVERFLOWBUFLEN; /* yes, grow another chunk */
|
yuuji@0
|
2365 fs_resize ((void **) &f->buf,f->buflen = i - (i % OVERFLOWBUFLEN));
|
yuuji@0
|
2366 /* in case buffer relocated */
|
yuuji@0
|
2367 f->bufpos = f->buf + j;
|
yuuji@0
|
2368 }
|
yuuji@0
|
2369 /* buffer remaining data */
|
yuuji@0
|
2370 memcpy (f->bufpos,buf,size);
|
yuuji@0
|
2371 f->bufpos += size; /* new end of buffer */
|
yuuji@0
|
2372 f->curpos += size; /* advance current pointer */
|
yuuji@0
|
2373 }
|
yuuji@0
|
2374 }
|
yuuji@0
|
2375 }
|
yuuji@0
|
2376 else { /* flush buffer to disk */
|
yuuji@0
|
2377 unix_phys_write (f,f->buf,i = f->bufpos - f->buf);
|
yuuji@0
|
2378 f->bufpos = f->buf; /* reset buffer */
|
yuuji@0
|
2379 /* update positions */
|
yuuji@0
|
2380 f->curpos = f->protect = f->filepos;
|
yuuji@0
|
2381 }
|
yuuji@0
|
2382 }
|
yuuji@0
|
2383
|
yuuji@0
|
2384 /* Physical disk write
|
yuuji@0
|
2385 * Accepts: buffered file pointer
|
yuuji@0
|
2386 * buffer address
|
yuuji@0
|
2387 * buffer size
|
yuuji@0
|
2388 * Does not return until success
|
yuuji@0
|
2389 */
|
yuuji@0
|
2390
|
yuuji@0
|
2391 void unix_phys_write (UNIXFILE *f,char *buf,size_t size)
|
yuuji@0
|
2392 {
|
yuuji@0
|
2393 MAILSTREAM *stream = f->stream;
|
yuuji@0
|
2394 /* write data at desired position */
|
yuuji@0
|
2395 while (size && ((lseek (LOCAL->fd,f->filepos,L_SET) < 0) ||
|
yuuji@0
|
2396 (write (LOCAL->fd,buf,size) < 0))) {
|
yuuji@0
|
2397 int e;
|
yuuji@0
|
2398 char tmp[MAILTMPLEN];
|
yuuji@0
|
2399 sprintf (tmp,"Unable to write to mailbox: %s",strerror (e = errno));
|
yuuji@0
|
2400 MM_LOG (tmp,ERROR);
|
yuuji@0
|
2401 MM_DISKERROR (NIL,e,T); /* serious problem, must retry */
|
yuuji@0
|
2402 }
|
yuuji@0
|
2403 f->filepos += size; /* update file position */
|
yuuji@0
|
2404 }
|
yuuji@1
|
2405
|
yuuji@1
|
2406 /* Return my mail suffix(of qmail or Postfix)
|
yuuji@1
|
2407 * Returns: my mail address extensional suffix
|
yuuji@1
|
2408 */
|
yuuji@1
|
2409
|
yuuji@1
|
2410 char *mymailsuffix ()
|
yuuji@1
|
2411 {
|
yuuji@1
|
2412 return myMailSuffix ? myMailSuffix : "";
|
yuuji@1
|
2413 }
|
yuuji@0
|
2414
|
yuuji@0
|
2415 /* MBOX mail routines */
|
yuuji@0
|
2416
|
yuuji@0
|
2417
|
yuuji@0
|
2418 /* Driver dispatch used by MAIL */
|
yuuji@0
|
2419
|
yuuji@0
|
2420 DRIVER mboxdriver = {
|
yuuji@0
|
2421 "mbox", /* driver name */
|
yuuji@0
|
2422 /* driver flags */
|
yuuji@0
|
2423 DR_LOCAL|DR_MAIL|DR_LOCKING|DR_NONEWMAILRONLY,
|
yuuji@0
|
2424 (DRIVER *) NIL, /* next driver */
|
yuuji@0
|
2425 mbox_valid, /* mailbox is valid for us */
|
yuuji@0
|
2426 unix_parameters, /* manipulate parameters */
|
yuuji@0
|
2427 unix_scan, /* scan mailboxes */
|
yuuji@0
|
2428 unix_list, /* find mailboxes */
|
yuuji@0
|
2429 unix_lsub, /* find subscribed mailboxes */
|
yuuji@0
|
2430 NIL, /* subscribe to mailbox */
|
yuuji@0
|
2431 NIL, /* unsubscribe from mailbox */
|
yuuji@0
|
2432 mbox_create, /* create mailbox */
|
yuuji@0
|
2433 mbox_delete, /* delete mailbox */
|
yuuji@0
|
2434 mbox_rename, /* rename mailbox */
|
yuuji@0
|
2435 mbox_status, /* status of mailbox */
|
yuuji@0
|
2436 mbox_open, /* open mailbox */
|
yuuji@0
|
2437 unix_close, /* close mailbox */
|
yuuji@0
|
2438 NIL, /* fetch message "fast" attributes */
|
yuuji@0
|
2439 NIL, /* fetch message flags */
|
yuuji@0
|
2440 NIL, /* fetch overview */
|
yuuji@0
|
2441 NIL, /* fetch message structure */
|
yuuji@0
|
2442 unix_header, /* fetch message header */
|
yuuji@0
|
2443 unix_text, /* fetch message body */
|
yuuji@0
|
2444 NIL, /* fetch partial message text */
|
yuuji@0
|
2445 NIL, /* unique identifier */
|
yuuji@0
|
2446 NIL, /* message number */
|
yuuji@0
|
2447 NIL, /* modify flags */
|
yuuji@0
|
2448 unix_flagmsg, /* per-message modify flags */
|
yuuji@0
|
2449 NIL, /* search for message based on criteria */
|
yuuji@0
|
2450 NIL, /* sort messages */
|
yuuji@0
|
2451 NIL, /* thread messages */
|
yuuji@0
|
2452 mbox_ping, /* ping mailbox to see if still alive */
|
yuuji@0
|
2453 mbox_check, /* check for new messages */
|
yuuji@0
|
2454 mbox_expunge, /* expunge deleted messages */
|
yuuji@0
|
2455 unix_copy, /* copy messages to another mailbox */
|
yuuji@0
|
2456 mbox_append, /* append string message to mailbox */
|
yuuji@0
|
2457 NIL /* garbage collect stream */
|
yuuji@0
|
2458 };
|
yuuji@0
|
2459
|
yuuji@0
|
2460 /* prototype stream */
|
yuuji@0
|
2461 MAILSTREAM mboxproto = {&mboxdriver};
|
yuuji@0
|
2462
|
yuuji@0
|
2463 /* MBOX mail validate mailbox
|
yuuji@0
|
2464 * Accepts: mailbox name
|
yuuji@0
|
2465 * Returns: our driver if name is valid, NIL otherwise
|
yuuji@0
|
2466 */
|
yuuji@0
|
2467
|
yuuji@0
|
2468 DRIVER *mbox_valid (char *name)
|
yuuji@0
|
2469 {
|
yuuji@0
|
2470 /* only INBOX, mbox must exist */
|
yuuji@0
|
2471 if (!compare_cstring (name,"INBOX") && (unix_valid ("mbox") || !errno) &&
|
yuuji@0
|
2472 (unix_valid (sysinbox()) || !errno || (errno == ENOENT)))
|
yuuji@0
|
2473 return &mboxdriver;
|
yuuji@0
|
2474 return NIL; /* can't win (yet, anyway) */
|
yuuji@0
|
2475 }
|
yuuji@0
|
2476
|
yuuji@0
|
2477 /* MBOX mail create mailbox
|
yuuji@0
|
2478 * Accepts: MAIL stream
|
yuuji@0
|
2479 * mailbox name to create
|
yuuji@0
|
2480 * Returns: T on success, NIL on failure
|
yuuji@0
|
2481 */
|
yuuji@0
|
2482
|
yuuji@0
|
2483 long mbox_create (MAILSTREAM *stream,char *mailbox)
|
yuuji@0
|
2484 {
|
yuuji@0
|
2485 char tmp[MAILTMPLEN];
|
yuuji@0
|
2486 if (!compare_cstring (mailbox,"INBOX")) return unix_create (NIL,"mbox");
|
yuuji@0
|
2487 sprintf (tmp,"Can't create non-INBOX name as mbox: %.80s",mailbox);
|
yuuji@0
|
2488 MM_LOG (tmp,ERROR);
|
yuuji@0
|
2489 return NIL;
|
yuuji@0
|
2490 }
|
yuuji@0
|
2491
|
yuuji@0
|
2492
|
yuuji@0
|
2493 /* MBOX mail delete mailbox
|
yuuji@0
|
2494 * Accepts: MAIL stream
|
yuuji@0
|
2495 * mailbox name to delete
|
yuuji@0
|
2496 * Returns: T on success, NIL on failure
|
yuuji@0
|
2497 */
|
yuuji@0
|
2498
|
yuuji@0
|
2499 long mbox_delete (MAILSTREAM *stream,char *mailbox)
|
yuuji@0
|
2500 {
|
yuuji@0
|
2501 return mbox_rename (stream,mailbox,NIL);
|
yuuji@0
|
2502 }
|
yuuji@0
|
2503
|
yuuji@0
|
2504
|
yuuji@0
|
2505 /* MBOX mail rename mailbox
|
yuuji@0
|
2506 * Accepts: MAIL stream
|
yuuji@0
|
2507 * old mailbox name
|
yuuji@0
|
2508 * new mailbox name (or NIL for delete)
|
yuuji@0
|
2509 * Returns: T on success, NIL on failure
|
yuuji@0
|
2510 */
|
yuuji@0
|
2511
|
yuuji@0
|
2512 long mbox_rename (MAILSTREAM *stream,char *old,char *newname)
|
yuuji@0
|
2513 {
|
yuuji@0
|
2514 char tmp[MAILTMPLEN];
|
yuuji@0
|
2515 long ret = unix_rename (stream,"~/mbox",newname);
|
yuuji@0
|
2516 /* recreate file if renamed INBOX */
|
yuuji@0
|
2517 if (ret) unix_create (NIL,"mbox");
|
yuuji@0
|
2518 else MM_LOG (tmp,ERROR); /* log error */
|
yuuji@0
|
2519 return ret; /* return success */
|
yuuji@0
|
2520 }
|
yuuji@0
|
2521
|
yuuji@0
|
2522 /* MBOX Mail status
|
yuuji@0
|
2523 * Accepts: mail stream
|
yuuji@0
|
2524 * mailbox name
|
yuuji@0
|
2525 * status flags
|
yuuji@0
|
2526 * Returns: T on success, NIL on failure
|
yuuji@0
|
2527 */
|
yuuji@0
|
2528
|
yuuji@0
|
2529 long mbox_status (MAILSTREAM *stream,char *mbx,long flags)
|
yuuji@0
|
2530 {
|
yuuji@0
|
2531 MAILSTATUS status;
|
yuuji@0
|
2532 unsigned long i;
|
yuuji@0
|
2533 MAILSTREAM *tstream = NIL;
|
yuuji@0
|
2534 MAILSTREAM *systream = NIL;
|
yuuji@0
|
2535 /* make temporary stream (unless this mbx) */
|
yuuji@0
|
2536 if (!stream && !(stream = tstream =
|
yuuji@0
|
2537 mail_open (NIL,mbx,OP_READONLY|OP_SILENT))) return NIL;
|
yuuji@0
|
2538 status.flags = flags; /* return status values */
|
yuuji@0
|
2539 status.messages = stream->nmsgs;
|
yuuji@0
|
2540 status.recent = stream->recent;
|
yuuji@0
|
2541 if (flags & SA_UNSEEN) /* must search to get unseen messages */
|
yuuji@0
|
2542 for (i = 1,status.unseen = 0; i <= stream->nmsgs; i++)
|
yuuji@0
|
2543 if (!mail_elt (stream,i)->seen) status.unseen++;
|
yuuji@0
|
2544 status.uidnext = stream->uid_last + 1;
|
yuuji@0
|
2545 status.uidvalidity = stream->uid_validity;
|
yuuji@0
|
2546 if (!status.recent && /* calculate post-snarf results */
|
yuuji@0
|
2547 (systream = mail_open (NIL,sysinbox (),OP_READONLY|OP_SILENT))) {
|
yuuji@0
|
2548 status.messages += systream->nmsgs;
|
yuuji@0
|
2549 status.recent += systream->recent;
|
yuuji@0
|
2550 if (flags & SA_UNSEEN) /* must search to get unseen messages */
|
yuuji@0
|
2551 for (i = 1; i <= systream->nmsgs; i++)
|
yuuji@0
|
2552 if (!mail_elt (systream,i)->seen) status.unseen++;
|
yuuji@0
|
2553 /* kludge but probably good enough */
|
yuuji@0
|
2554 status.uidnext += systream->nmsgs;
|
yuuji@0
|
2555 }
|
yuuji@0
|
2556 MM_STATUS(stream,mbx,&status);/* pass status to main program */
|
yuuji@0
|
2557 if (tstream) mail_close (tstream);
|
yuuji@0
|
2558 if (systream) mail_close (systream);
|
yuuji@0
|
2559 return T; /* success */
|
yuuji@0
|
2560 }
|
yuuji@0
|
2561
|
yuuji@0
|
2562 /* MBOX mail open
|
yuuji@0
|
2563 * Accepts: stream to open
|
yuuji@0
|
2564 * Returns: stream on success, NIL on failure
|
yuuji@0
|
2565 */
|
yuuji@0
|
2566
|
yuuji@0
|
2567 MAILSTREAM *mbox_open (MAILSTREAM *stream)
|
yuuji@0
|
2568 {
|
yuuji@0
|
2569 unsigned long i = 1;
|
yuuji@0
|
2570 unsigned long recent = 0;
|
yuuji@0
|
2571 /* return prototype for OP_PROTOTYPE call */
|
yuuji@0
|
2572 if (!stream) return &mboxproto;
|
yuuji@0
|
2573 /* change mailbox file name */
|
yuuji@0
|
2574 fs_give ((void **) &stream->mailbox);
|
yuuji@0
|
2575 stream->mailbox = cpystr ("mbox");
|
yuuji@0
|
2576 /* open mailbox, snarf new mail */
|
yuuji@0
|
2577 if (!(unix_open (stream) && mbox_ping (stream))) return NIL;
|
yuuji@0
|
2578 stream->inbox = T; /* mark that this is an INBOX */
|
yuuji@0
|
2579 /* notify upper level of mailbox sizes */
|
yuuji@0
|
2580 mail_exists (stream,stream->nmsgs);
|
yuuji@0
|
2581 while (i <= stream->nmsgs) if (mail_elt (stream,i++)->recent) ++recent;
|
yuuji@0
|
2582 mail_recent (stream,recent); /* including recent messages */
|
yuuji@0
|
2583 return stream;
|
yuuji@0
|
2584 }
|
yuuji@0
|
2585
|
yuuji@0
|
2586 /* MBOX mail ping mailbox
|
yuuji@0
|
2587 * Accepts: MAIL stream
|
yuuji@0
|
2588 * Returns: T if stream alive, else NIL
|
yuuji@0
|
2589 * No-op for readonly files, since read/writer can expunge it from under us!
|
yuuji@0
|
2590 */
|
yuuji@0
|
2591
|
yuuji@0
|
2592 static int snarfed = 0; /* number of snarfs */
|
yuuji@0
|
2593
|
yuuji@0
|
2594 long mbox_ping (MAILSTREAM *stream)
|
yuuji@0
|
2595 {
|
yuuji@0
|
2596 int sfd;
|
yuuji@0
|
2597 unsigned long size;
|
yuuji@0
|
2598 struct stat sbuf;
|
yuuji@0
|
2599 char *s;
|
yuuji@0
|
2600 DOTLOCK lock,lockx;
|
yuuji@0
|
2601 /* time to try snarf and sysinbox non-empty? */
|
yuuji@0
|
2602 if (LOCAL && !stream->rdonly && !stream->lock &&
|
yuuji@0
|
2603 (time (0) >= (LOCAL->lastsnarf +
|
yuuji@0
|
2604 (long) mail_parameters (NIL,GET_SNARFINTERVAL,NIL))) &&
|
yuuji@0
|
2605 !stat (sysinbox (),&sbuf) && sbuf.st_size) {
|
yuuji@0
|
2606 MM_CRITICAL (stream); /* yes, go critical */
|
yuuji@0
|
2607 /* open and lock sysinbox */
|
yuuji@0
|
2608 if ((sfd = unix_lock (sysinbox (),O_RDWR,
|
yuuji@0
|
2609 (long) mail_parameters (NIL,GET_MBXPROTECTION,NIL),
|
yuuji@0
|
2610 &lockx,LOCK_EX)) >= 0) {
|
yuuji@0
|
2611 /* locked sysinbox in good format? */
|
yuuji@0
|
2612 if (fstat (sfd,&sbuf) || !(size = sbuf.st_size) ||
|
yuuji@0
|
2613 !unix_isvalid_fd (sfd)) {
|
yuuji@0
|
2614 sprintf (LOCAL->buf,"Mail drop %s is not in standard Unix format",
|
yuuji@0
|
2615 sysinbox ());
|
yuuji@0
|
2616 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
2617 }
|
yuuji@0
|
2618 /* sysinbox good, parse and excl-lock mbox */
|
yuuji@0
|
2619 else if (unix_parse (stream,&lock,LOCK_EX)) {
|
yuuji@0
|
2620 lseek (sfd,0,L_SET); /* read entire sysinbox into memory */
|
yuuji@0
|
2621 read (sfd,s = (char *) fs_get (size + 1),size);
|
yuuji@0
|
2622 s[size] = '\0'; /* tie it off */
|
yuuji@0
|
2623 /* append to end of mbox */
|
yuuji@0
|
2624 lseek (LOCAL->fd,LOCAL->filesize,L_SET);
|
yuuji@0
|
2625
|
yuuji@0
|
2626 /* copy to mbox */
|
yuuji@0
|
2627 if ((write (LOCAL->fd,s,size) < 0) || fsync (LOCAL->fd)) {
|
yuuji@0
|
2628 sprintf (LOCAL->buf,"New mail move failed: %s",strerror (errno));
|
yuuji@0
|
2629 MM_LOG (LOCAL->buf,WARN);
|
yuuji@0
|
2630 /* revert mbox to previous size */
|
yuuji@0
|
2631 ftruncate (LOCAL->fd,LOCAL->filesize);
|
yuuji@0
|
2632 }
|
yuuji@0
|
2633 /* sysinbox better not have changed */
|
yuuji@0
|
2634 else if (fstat (sfd,&sbuf) || (size != sbuf.st_size)) {
|
yuuji@0
|
2635 sprintf (LOCAL->buf,"Mail drop %s lock failure, old=%lu now=%lu",
|
yuuji@0
|
2636 sysinbox (),size,(unsigned long) sbuf.st_size);
|
yuuji@0
|
2637 MM_LOG (LOCAL->buf,ERROR);
|
yuuji@0
|
2638 /* revert mbox to previous size */
|
yuuji@0
|
2639 ftruncate (LOCAL->fd,LOCAL->filesize);
|
yuuji@0
|
2640 /* Believe it or not, a Singaporean government system actually had
|
yuuji@0
|
2641 * symlinks from /var/mail/user to ~user/mbox. To compound this
|
yuuji@0
|
2642 * error, they used an SVR4 system; BSD and OSF locks would have
|
yuuji@0
|
2643 * prevented it but not SVR4 locks.
|
yuuji@0
|
2644 */
|
yuuji@0
|
2645 if (!fstat (sfd,&sbuf) && (size == sbuf.st_size))
|
yuuji@0
|
2646 syslog (LOG_ALERT,"File %s and %s are the same file!",
|
yuuji@0
|
2647 sysinbox (),stream->mailbox);
|
yuuji@0
|
2648 }
|
yuuji@0
|
2649 else { /* data copied OK */
|
yuuji@0
|
2650 ftruncate (sfd,0); /* truncate sysinbox to zero bytes */
|
yuuji@0
|
2651 if (!snarfed++) { /* have we snarfed before? */
|
yuuji@0
|
2652 /* syslog if server, else user log */
|
yuuji@0
|
2653 sprintf (LOCAL->buf,"Moved %lu bytes of new mail to %s from %s",
|
yuuji@0
|
2654 size,stream->mailbox,sysinbox ());
|
yuuji@0
|
2655 if (strcmp ((char *) mail_parameters (NIL,GET_SERVICENAME,NIL),
|
yuuji@0
|
2656 "unknown"))
|
yuuji@0
|
2657 syslog (LOG_INFO,"%s host= %s",LOCAL->buf,tcp_clienthost ());
|
yuuji@0
|
2658 else MM_LOG (LOCAL->buf,WARN);
|
yuuji@0
|
2659 }
|
yuuji@0
|
2660 }
|
yuuji@0
|
2661 /* done with sysinbox text */
|
yuuji@0
|
2662 fs_give ((void **) &s);
|
yuuji@0
|
2663 /* all done with mbox */
|
yuuji@0
|
2664 unix_unlock (LOCAL->fd,stream,&lock);
|
yuuji@0
|
2665 mail_unlock (stream); /* unlock the stream */
|
yuuji@0
|
2666 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
2667 }
|
yuuji@0
|
2668 /* all done with sysinbox */
|
yuuji@0
|
2669 unix_unlock (sfd,NIL,&lockx);
|
yuuji@0
|
2670 }
|
yuuji@0
|
2671 MM_NOCRITICAL (stream); /* done with critical */
|
yuuji@0
|
2672 LOCAL->lastsnarf = time (0);/* note time of last snarf */
|
yuuji@0
|
2673 }
|
yuuji@0
|
2674 return unix_ping (stream); /* do the unix routine now */
|
yuuji@0
|
2675 }
|
yuuji@0
|
2676
|
yuuji@0
|
2677 /* MBOX mail check mailbox
|
yuuji@0
|
2678 * Accepts: MAIL stream
|
yuuji@0
|
2679 */
|
yuuji@0
|
2680
|
yuuji@0
|
2681 void mbox_check (MAILSTREAM *stream)
|
yuuji@0
|
2682 {
|
yuuji@0
|
2683 /* do local ping, then do unix routine */
|
yuuji@0
|
2684 if (mbox_ping (stream)) unix_check (stream);
|
yuuji@0
|
2685 }
|
yuuji@0
|
2686
|
yuuji@0
|
2687
|
yuuji@0
|
2688 /* MBOX mail expunge mailbox
|
yuuji@0
|
2689 * Accepts: MAIL stream
|
yuuji@0
|
2690 * sequence to expunge if non-NIL
|
yuuji@0
|
2691 * expunge options
|
yuuji@0
|
2692 * Returns: T, always
|
yuuji@0
|
2693 */
|
yuuji@0
|
2694
|
yuuji@0
|
2695 long mbox_expunge (MAILSTREAM *stream,char *sequence,long options)
|
yuuji@0
|
2696 {
|
yuuji@0
|
2697 long ret = unix_expunge (stream,sequence,options);
|
yuuji@0
|
2698 mbox_ping (stream); /* do local ping */
|
yuuji@0
|
2699 return ret;
|
yuuji@0
|
2700 }
|
yuuji@0
|
2701
|
yuuji@0
|
2702
|
yuuji@0
|
2703 /* MBOX mail append message from stringstruct
|
yuuji@0
|
2704 * Accepts: MAIL stream
|
yuuji@0
|
2705 * destination mailbox
|
yuuji@0
|
2706 * append callback
|
yuuji@0
|
2707 * data for callback
|
yuuji@0
|
2708 * Returns: T if append successful, else NIL
|
yuuji@0
|
2709 */
|
yuuji@0
|
2710
|
yuuji@0
|
2711 long mbox_append (MAILSTREAM *stream,char *mailbox,append_t af,void *data)
|
yuuji@0
|
2712 {
|
yuuji@0
|
2713 char tmp[MAILTMPLEN];
|
yuuji@0
|
2714 if (mbox_valid (mailbox)) return unix_append (stream,"mbox",af,data);
|
yuuji@0
|
2715 sprintf (tmp,"Can't append to that name: %.80s",mailbox);
|
yuuji@0
|
2716 MM_LOG (tmp,ERROR);
|
yuuji@0
|
2717 return NIL;
|
yuuji@0
|
2718 }
|