1063{
1067
1068 struct Buffer *tempfile = NULL;
1069 char buf[32] = { 0 };
1070 int j;
1071 bool unlink_tempfile = false;
1072 bool need_sort = false;
1073 int first = -1;
1074 LOFF_T offset;
1075 struct stat st = { 0 };
1076 struct MUpdate *new_offset = NULL;
1077 struct MUpdate *old_offset = NULL;
1078 FILE *fp = NULL;
1079 struct Progress *progress = NULL;
1081
1082
1085 {
1087 need_sort = true;
1088 }
1089
1090
1091
1094 {
1096 mutt_error(
_(
"Fatal error! Could not reopen mailbox!"));
1097 goto fatal;
1098 }
1099
1101
1103 {
1106 goto bail;
1107 }
1108
1109
1112 {
1113
1114 rc = check;
1115 goto bail;
1116 }
1117 else if (check < 0)
1118 {
1119 goto fatal;
1120 }
1121
1122
1125 int fd = open(
buf_string(tempfile), O_WRONLY | O_EXCL | O_CREAT, 0600);
1126 if ((fd == -1) || !(fp = fdopen(fd, "w")))
1127 {
1128 if (fd != -1)
1129 {
1130 close(fd);
1131 unlink_tempfile = true;
1132 }
1134 goto bail;
1135 }
1136 unlink_tempfile = true;
1137
1138
1139
1140 int i = 0;
1143 i++)
1144 {
1145 }
1147 {
1148
1149
1150
1151 mutt_error(
_(
"sync: mbox modified, but no modified messages (report this bug)"));
1153 goto bail;
1154 }
1155
1156
1157 first = i;
1158
1160
1161
1162
1165
1166
1169
1171 {
1174 }
1175
1176 for (i = first, j = 0; i < m->
msg_count; i++)
1177 {
1179
1180
1181
1182 old_offset[i - first].
valid =
true;
1187
1189 {
1190 j++;
1191
1193 {
1195 {
1197 goto bail;
1198 }
1199 }
1200
1201
1202
1203
1204 new_offset[i - first].
hdr = ftello(fp) + offset;
1205
1210 if (rc2 != 0)
1211 {
1213 goto bail;
1214 }
1215
1216
1217
1218
1219
1220
1223
1225 {
1227 {
1229 goto bail;
1230 }
1231 }
1232 else
1233 {
1234 if (fputs(
"\n",
fp) == EOF)
1235 {
1237 goto bail;
1238 }
1239 }
1240 }
1241 }
1242
1244 {
1247 goto bail;
1248 }
1249
1250
1252 {
1254 goto bail;
1255 }
1256
1257 unlink_tempfile = false;
1258
1261 {
1268 goto fatal;
1269 }
1270
1272
1273 !fgets(buf,
sizeof(buf), adata->
fp) ||
1276 {
1279 i = -1;
1280 }
1281 else
1282 {
1284 {
1285 i = -1;
1286 }
1287 else
1288 {
1289
1290
1294
1295 if (ferror(adata->
fp))
1296 i = -1;
1297 }
1298 if (i >= 0)
1299 {
1300 m->
size = ftello(adata->
fp);
1301 if ((m->
size < 0) || (ftruncate(fileno(adata->
fp), m->
size) != 0))
1302 {
1303 i = -1;
1305 }
1306 }
1307 }
1308
1311
1313 {
1314
1315
1317
1329 goto fatal;
1330 }
1331
1332
1334
1335
1338 {
1340 }
1342 {
1346 mutt_error(
_(
"Fatal error! Could not reopen mailbox!"));
1349 goto fatal;
1350 }
1351
1352
1353 for (i = first, j = first; i < m->
msg_count; i++)
1354 {
1356 {
1361 }
1362 }
1368
1370 if (c_check_mbox_size)
1371 {
1375 }
1376
1378 return 0;
1379
1380bail:
1381
1383
1384 if (tempfile && unlink_tempfile)
1386
1387
1388 if ((first >= 0) && old_offset)
1389 {
1390 for (i = first; (i < m->
msg_count) && old_offset[i - first].valid; i++)
1391 {
1397 }
1398 }
1399
1400
1402
1406
1409 {
1412 goto fatal;
1413 }
1414
1416 if (need_sort)
1417 {
1418
1419
1421 }
1422
1423fatal:
1426 return rc;
1427}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
int mutt_copy_message(FILE *fp_out, struct Email *e, struct Message *msg, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
#define MUTT_CM_UPDATE
Update structs on sync.
#define CH_UPDATE
Update the status and x-status fields?
#define CH_FROM
Retain the "From " message separator?
#define CH_UPDATE_LEN
Update Lines: and Content-Length:
void mailbox_update(struct Mailbox *m)
Get the mailbox's current size.
void mailbox_changed(struct Mailbox *m, enum NotifyMailbox action)
Notify observers of a change to a Mailbox.
struct Mailbox * mailbox_find(const char *path)
Find the mailbox with a given path.
@ NT_MAILBOX_RESORT
Email list needs resorting.
@ NT_MAILBOX_UPDATE
Update internal tables.
@ MUTT_MMDF
'mmdf' Mailbox type
@ MUTT_MBOX
'mbox' Mailbox type
void mutt_body_free(struct Body **ptr)
Free a Body.
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
#define mutt_file_fclose(FP)
#define mutt_file_fopen(PATH, MODE)
char * ShortHostname
Short version of the hostname.
char * Username
User's login name.
#define mutt_message(...)
#define mutt_debug(LEVEL,...)
static enum MxStatus mbox_mbox_check(struct Mailbox *m)
Check for new mail - Implements MxOps::mbox_check() -.
@ LL_DEBUG1
Log at debug level 1.
static int mbox_lock_mailbox(struct Mailbox *m, bool excl, bool retry)
Lock a mailbox.
static struct MboxAccountData * mbox_adata_get(struct Mailbox *m)
Get the private data associated with a Mailbox.
static FILE * mbox_open_readwrite(struct Mailbox *m)
Open an mbox read-write.
static FILE * mbox_open_readonly(struct Mailbox *m)
Open an mbox read-only.
static void mbox_unlock_mailbox(struct Mailbox *m)
Unlock a mailbox.
void mbox_reset_atime(struct Mailbox *m, struct stat *st)
Reset the access time on the mailbox file.
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
void mx_fastclose_mailbox(struct Mailbox *m, bool keep_account)
Free up memory associated with the Mailbox.
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
@ MX_STATUS_REOPENED
Mailbox was reopened.
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
void mutt_sig_block(void)
Block signals during critical operations.
void mutt_sig_unblock(void)
Restore previously blocked signals.
SortType
Methods for sorting.
@ SORT_ORDER
Sort by the order the messages appear in the mailbox.
void mutt_sort_order(struct Mailbox *m)
Sort emails by their disk order.
void * adata
Private data (for Mailbox backends)
struct Body * parts
parts of a multipart or message/rfc822
LOFF_T offset
offset where the actual data begins
LOFF_T length
length (in bytes) of attachment
long hdr_offset
Offset in stream where the headers begin.
String manipulation buffer.
int lines
How many lines in the body of this message?
struct Body * body
List of MIME parts.
bool changed
Email has been edited.
LOFF_T offset
Where in the stream does this message begin?
bool attach_del
Has an attachment marked for deletion.
Store of new offsets, used by mutt_sync_mailbox()
bool has_new
Mailbox has new mail.
enum MailboxType type
Mailbox type.
off_t size
Size of the Mailbox.
Mbox-specific Account data -.
A local copy of an email.
FILE * fp
pointer to the message data