2010-01-03 07:59:24 +00:00
|
|
|
/* -*- mode: c++; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
|
|
|
|
* vim: ts=4 sw=4 noet ai cindent syntax=cpp
|
2009-07-28 21:44:22 +00:00
|
|
|
*
|
|
|
|
* Conky, a system monitor, based on torsmo
|
2005-08-05 01:06:17 +00:00
|
|
|
*
|
2007-08-10 19:53:44 +00:00
|
|
|
* Any original torsmo code is licensed under the BSD license
|
|
|
|
*
|
|
|
|
* All code written since the fork of torsmo is licensed under the GPL
|
|
|
|
*
|
|
|
|
* Please see COPYING for details
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
|
2010-01-01 23:46:17 +00:00
|
|
|
* Copyright (c) 2005-2010 Brenden Matthews, Philip Kovacs, et. al.
|
2008-02-20 20:30:45 +00:00
|
|
|
* (see AUTHORS)
|
2007-08-10 19:53:44 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2008-02-20 20:30:45 +00:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2005-08-05 01:06:17 +00:00
|
|
|
*
|
2008-12-09 23:35:49 +00:00
|
|
|
*/
|
2005-08-05 01:06:17 +00:00
|
|
|
|
2008-12-15 21:40:24 +00:00
|
|
|
#include "config.h"
|
2008-12-14 02:53:05 +00:00
|
|
|
#include "conky.h"
|
2008-12-15 21:40:24 +00:00
|
|
|
#include "common.h"
|
|
|
|
#include "logging.h"
|
2009-10-24 23:17:30 +00:00
|
|
|
#include "text_object.h"
|
2010-01-13 18:52:35 +00:00
|
|
|
#include "timed-thread.h"
|
2008-12-14 02:53:05 +00:00
|
|
|
|
2008-12-15 21:40:24 +00:00
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
2008-12-23 03:59:42 +00:00
|
|
|
#include <limits.h>
|
2010-01-03 07:59:24 +00:00
|
|
|
#include <mutex>
|
2009-03-28 17:53:35 +00:00
|
|
|
#include <netinet/in.h>
|
2008-12-15 21:40:24 +00:00
|
|
|
#include <netdb.h>
|
|
|
|
#include <sys/socket.h>
|
2005-07-20 00:30:40 +00:00
|
|
|
#include <sys/stat.h>
|
2006-03-16 18:07:31 +00:00
|
|
|
#include <sys/time.h>
|
2008-12-23 03:59:42 +00:00
|
|
|
#include <sys/param.h>
|
2006-03-16 18:07:31 +00:00
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
#include <dirent.h>
|
2006-03-16 18:07:31 +00:00
|
|
|
#include <errno.h>
|
2008-12-14 02:53:05 +00:00
|
|
|
#include <termios.h>
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2008-12-15 21:40:24 +00:00
|
|
|
/* MAX() is defined by a header included from conky.h
|
|
|
|
* maybe once this is not true anymore, so have an alternative
|
|
|
|
* waiting to drop in.
|
|
|
|
*
|
|
|
|
* #define MAX(a, b) ((a > b) ? a : b)
|
|
|
|
*/
|
|
|
|
|
2009-10-24 23:59:07 +00:00
|
|
|
#define POP3_TYPE 1
|
|
|
|
#define IMAP_TYPE 2
|
|
|
|
|
2010-06-02 16:00:38 +00:00
|
|
|
#define MAXFOLDERSIZE 128
|
|
|
|
|
2009-10-24 23:59:07 +00:00
|
|
|
struct mail_s { // for imap and pop3
|
|
|
|
unsigned long unseen;
|
|
|
|
unsigned long messages;
|
|
|
|
unsigned long used;
|
|
|
|
unsigned long quota;
|
|
|
|
unsigned long port;
|
|
|
|
unsigned int retries;
|
|
|
|
float interval;
|
|
|
|
double last_update;
|
|
|
|
char host[128];
|
|
|
|
char user[128];
|
|
|
|
char pass[128];
|
|
|
|
char command[1024];
|
2010-01-03 07:59:24 +00:00
|
|
|
timed_thread_ptr p_timed_thread;
|
2009-10-24 23:59:07 +00:00
|
|
|
char secure;
|
2010-06-02 16:00:38 +00:00
|
|
|
char folder[MAXFOLDERSIZE];
|
2010-01-03 07:59:24 +00:00
|
|
|
mail_s() : unseen(0), messages(0), used(0), quota(0), port(0), retries(0),
|
|
|
|
interval(0), last_update(0), secure(0) {
|
|
|
|
host[0] = 0;
|
|
|
|
user[0] = 0;
|
|
|
|
pass[0] = 0;
|
|
|
|
command[0] = 0;
|
2010-06-02 16:00:38 +00:00
|
|
|
memset(folder, 0, MAXFOLDERSIZE); /* to satisfy valgrind */
|
2010-01-03 07:59:24 +00:00
|
|
|
}
|
2009-10-24 23:59:07 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct local_mail_s {
|
|
|
|
char *mbox;
|
|
|
|
int mail_count;
|
|
|
|
int new_mail_count;
|
|
|
|
int seen_mail_count;
|
|
|
|
int unseen_mail_count;
|
|
|
|
int flagged_mail_count;
|
|
|
|
int unflagged_mail_count;
|
|
|
|
int forwarded_mail_count;
|
|
|
|
int unforwarded_mail_count;
|
|
|
|
int replied_mail_count;
|
|
|
|
int unreplied_mail_count;
|
|
|
|
int draft_mail_count;
|
|
|
|
int trashed_mail_count;
|
|
|
|
float interval;
|
|
|
|
time_t last_mtime;
|
|
|
|
double last_update;
|
|
|
|
};
|
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
char *current_mail_spool;
|
|
|
|
|
2009-10-24 23:43:08 +00:00
|
|
|
static struct mail_s *global_mail;
|
|
|
|
static int global_mail_use = 0;
|
|
|
|
|
2009-10-24 23:59:07 +00:00
|
|
|
static void update_mail_count(struct local_mail_s *mail)
|
2005-07-20 00:30:40 +00:00
|
|
|
{
|
2008-03-29 09:58:09 +00:00
|
|
|
struct stat st;
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2008-02-20 20:30:45 +00:00
|
|
|
if (mail == NULL) {
|
2005-07-20 00:30:40 +00:00
|
|
|
return;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
|
|
|
/* TODO: use that fine file modification notify on Linux 2.4 */
|
|
|
|
|
|
|
|
/* don't check mail so often (9.5s is minimum interval) */
|
2008-02-20 20:30:45 +00:00
|
|
|
if (current_update_time - mail->last_update < 9.5) {
|
2005-07-20 00:30:40 +00:00
|
|
|
return;
|
2008-02-20 20:30:45 +00:00
|
|
|
} else {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->last_update = current_update_time;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2009-08-01 18:45:43 +00:00
|
|
|
if (stat(mail->mbox, &st)) {
|
2009-06-08 16:35:41 +00:00
|
|
|
static int rep = 0;
|
2008-02-20 20:30:45 +00:00
|
|
|
|
2005-07-20 00:30:40 +00:00
|
|
|
if (!rep) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("can't stat %s: %s", mail->mbox, strerror(errno));
|
2005-07-20 00:30:40 +00:00
|
|
|
rep = 1;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#if HAVE_DIRENT_H
|
|
|
|
/* maildir format */
|
2008-03-29 09:58:09 +00:00
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2005-07-20 00:30:40 +00:00
|
|
|
DIR *dir;
|
|
|
|
char *dirname;
|
|
|
|
struct dirent *dirent;
|
2009-02-18 05:26:15 +00:00
|
|
|
char *mailflags;
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->mail_count = mail->new_mail_count = 0;
|
2009-02-18 05:26:15 +00:00
|
|
|
mail->seen_mail_count = mail->unseen_mail_count = 0;
|
|
|
|
mail->flagged_mail_count = mail->unflagged_mail_count = 0;
|
|
|
|
mail->forwarded_mail_count = mail->unforwarded_mail_count = 0;
|
|
|
|
mail->replied_mail_count = mail->unreplied_mail_count = 0;
|
|
|
|
mail->draft_mail_count = mail->trashed_mail_count = 0;
|
2009-08-01 18:45:43 +00:00
|
|
|
dirname = (char *) malloc(sizeof(char) * (strlen(mail->mbox) + 5));
|
2005-07-20 00:30:40 +00:00
|
|
|
if (!dirname) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("malloc");
|
2005-07-20 00:30:40 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-08-01 18:45:43 +00:00
|
|
|
strcpy(dirname, mail->mbox);
|
2005-07-20 00:30:40 +00:00
|
|
|
strcat(dirname, "/");
|
|
|
|
/* checking the cur subdirectory */
|
|
|
|
strcat(dirname, "cur");
|
|
|
|
|
|
|
|
dir = opendir(dirname);
|
|
|
|
if (!dir) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("cannot open directory");
|
2005-07-20 00:30:40 +00:00
|
|
|
free(dirname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
dirent = readdir(dir);
|
|
|
|
while (dirent) {
|
|
|
|
/* . and .. are skipped */
|
|
|
|
if (dirent->d_name[0] != '.') {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->mail_count++;
|
2009-02-18 05:26:15 +00:00
|
|
|
mailflags = (char *) malloc(sizeof(char) * strlen(strrchr(dirent->d_name, ',')));
|
|
|
|
if (!mailflags) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("malloc");
|
2009-02-18 05:26:15 +00:00
|
|
|
free(dirname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
strcpy(mailflags, strrchr(dirent->d_name, ','));
|
|
|
|
if (!strchr(mailflags, 'T')) { /* The message is not in the trash */
|
|
|
|
if (strchr(mailflags, 'S')) { /*The message has been seen */
|
|
|
|
mail->seen_mail_count++;
|
|
|
|
} else {
|
|
|
|
mail->unseen_mail_count++;
|
|
|
|
}
|
|
|
|
if (strchr(mailflags, 'F')) { /*The message was flagged */
|
|
|
|
mail->flagged_mail_count++;
|
|
|
|
} else {
|
|
|
|
mail->unflagged_mail_count++;
|
|
|
|
}
|
|
|
|
if (strchr(mailflags, 'P')) { /*The message was forwarded */
|
|
|
|
mail->forwarded_mail_count++;
|
|
|
|
} else {
|
|
|
|
mail->unforwarded_mail_count++;
|
|
|
|
}
|
|
|
|
if (strchr(mailflags, 'R')) { /*The message was replied */
|
|
|
|
mail->replied_mail_count++;
|
|
|
|
} else {
|
|
|
|
mail->unreplied_mail_count++;
|
|
|
|
}
|
|
|
|
if (strchr(mailflags, 'D')) { /*The message is a draft */
|
|
|
|
mail->draft_mail_count++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mail->trashed_mail_count++;
|
|
|
|
}
|
|
|
|
free(mailflags);
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
dirent = readdir(dir);
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
dirname[strlen(dirname) - 3] = '\0';
|
|
|
|
strcat(dirname, "new");
|
|
|
|
|
|
|
|
dir = opendir(dirname);
|
|
|
|
if (!dir) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("cannot open directory");
|
2005-07-20 00:30:40 +00:00
|
|
|
free(dirname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
dirent = readdir(dir);
|
|
|
|
while (dirent) {
|
|
|
|
/* . and .. are skipped */
|
|
|
|
if (dirent->d_name[0] != '.') {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->new_mail_count++;
|
|
|
|
mail->mail_count++;
|
2009-02-18 05:26:15 +00:00
|
|
|
mail->unseen_mail_count++; /* new messages cannot have been seen */
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
dirent = readdir(dir);
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
free(dirname);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* mbox format */
|
2008-03-29 09:58:09 +00:00
|
|
|
if (st.st_mtime != mail->last_mtime) {
|
2005-07-20 00:30:40 +00:00
|
|
|
/* yippee, modification time has changed, let's read mail count! */
|
|
|
|
static int rep;
|
|
|
|
FILE *fp;
|
|
|
|
int reading_status = 0;
|
|
|
|
|
|
|
|
/* could lock here but I don't think it's really worth it because
|
|
|
|
* this isn't going to write mail spool */
|
|
|
|
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->new_mail_count = mail->mail_count = 0;
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2009-02-18 05:26:15 +00:00
|
|
|
/* these flags are not supported for mbox */
|
|
|
|
mail->seen_mail_count = mail->unseen_mail_count = -1;
|
|
|
|
mail->flagged_mail_count = mail->unflagged_mail_count = -1;
|
|
|
|
mail->forwarded_mail_count = mail->unforwarded_mail_count = -1;
|
|
|
|
mail->replied_mail_count = mail->unreplied_mail_count = -1;
|
|
|
|
mail->draft_mail_count = mail->trashed_mail_count = -1;
|
|
|
|
|
2009-08-01 18:45:43 +00:00
|
|
|
fp = open_file(mail->mbox, &rep);
|
2008-02-20 20:30:45 +00:00
|
|
|
if (!fp) {
|
2005-07-20 00:30:40 +00:00
|
|
|
return;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
|
|
|
/* NOTE: adds mail as new if there isn't Status-field at all */
|
|
|
|
|
|
|
|
while (!feof(fp)) {
|
|
|
|
char buf[128];
|
2009-06-08 16:35:41 +00:00
|
|
|
int was_new = 0;
|
2008-02-20 20:30:45 +00:00
|
|
|
|
|
|
|
if (fgets(buf, 128, fp) == NULL) {
|
2005-07-20 00:30:40 +00:00
|
|
|
break;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
|
|
|
if (strncmp(buf, "From ", 5) == 0) {
|
|
|
|
/* ignore MAILER-DAEMON */
|
2008-02-20 20:30:45 +00:00
|
|
|
if (strncmp(buf + 5, "MAILER-DAEMON ", 14) != 0) {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->mail_count++;
|
2009-06-08 16:35:41 +00:00
|
|
|
was_new = 0;
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2009-06-08 16:35:41 +00:00
|
|
|
if (reading_status == 1) {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->new_mail_count++;
|
2008-02-20 20:30:45 +00:00
|
|
|
} else {
|
2005-07-20 00:30:40 +00:00
|
|
|
reading_status = 1;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
} else {
|
2009-06-08 16:35:41 +00:00
|
|
|
if (reading_status == 1
|
2008-02-20 20:30:45 +00:00
|
|
|
&& strncmp(buf, "X-Mozilla-Status:", 17) == 0) {
|
2009-06-08 16:35:41 +00:00
|
|
|
int xms = strtol(buf + 17, NULL, 16);
|
|
|
|
/* check that mail isn't marked for deletion */
|
|
|
|
if (xms & 0x0008) {
|
|
|
|
mail->trashed_mail_count++;
|
|
|
|
reading_status = 0;
|
|
|
|
/* Don't check whether the trashed email is unread */
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
/* check that mail isn't already read */
|
2009-06-08 16:35:41 +00:00
|
|
|
if (!(xms & 0x0001)) {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->new_mail_count++;
|
2009-06-08 16:35:41 +00:00
|
|
|
was_new = 1;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2009-06-08 16:35:41 +00:00
|
|
|
/* check for an additional X-Status header */
|
|
|
|
reading_status = 2;
|
2005-07-20 00:30:40 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-06-08 16:35:41 +00:00
|
|
|
if (reading_status == 1 && strncmp(buf, "Status:", 7) == 0) {
|
2005-07-20 00:30:40 +00:00
|
|
|
/* check that mail isn't already read */
|
2008-02-20 20:30:45 +00:00
|
|
|
if (strchr(buf + 7, 'R') == NULL) {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->new_mail_count++;
|
2009-06-08 16:35:41 +00:00
|
|
|
was_new = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
reading_status = 2;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (reading_status >= 1 && strncmp(buf, "X-Status:", 9) == 0) {
|
|
|
|
/* check that mail isn't marked for deletion */
|
|
|
|
if (strchr(buf + 9, 'D') != NULL) {
|
|
|
|
mail->trashed_mail_count++;
|
|
|
|
/* If the mail was previously detected as new,
|
|
|
|
subtract it from the new mail count */
|
|
|
|
if (was_new)
|
|
|
|
mail->new_mail_count--;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
|
|
|
reading_status = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip until \n */
|
2008-02-20 20:30:45 +00:00
|
|
|
while (strchr(buf, '\n') == NULL && !feof(fp)) {
|
2009-12-20 01:49:47 +00:00
|
|
|
if (!fgets(buf, 128, fp))
|
|
|
|
break;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
|
2008-02-20 20:30:45 +00:00
|
|
|
if (reading_status) {
|
2007-10-02 23:57:41 +00:00
|
|
|
mail->new_mail_count++;
|
2008-02-20 20:30:45 +00:00
|
|
|
}
|
2005-07-20 00:30:40 +00:00
|
|
|
|
2008-03-29 09:58:09 +00:00
|
|
|
mail->last_mtime = st.st_mtime;
|
2005-07-20 00:30:40 +00:00
|
|
|
}
|
|
|
|
}
|
2008-12-14 02:53:05 +00:00
|
|
|
|
2009-10-24 23:13:50 +00:00
|
|
|
void parse_local_mail_args(struct text_object *obj, const char *arg)
|
|
|
|
{
|
|
|
|
float n1;
|
|
|
|
char mbox[256], dst[256];
|
2009-10-24 23:59:07 +00:00
|
|
|
struct local_mail_s *locmail;
|
2009-10-24 23:13:50 +00:00
|
|
|
|
|
|
|
if (!arg) {
|
|
|
|
n1 = 9.5;
|
|
|
|
/* Kapil: Changed from MAIL_FILE to
|
|
|
|
current_mail_spool since the latter
|
|
|
|
is a copy of the former if undefined
|
|
|
|
but the latter should take precedence
|
|
|
|
if defined */
|
|
|
|
strncpy(mbox, current_mail_spool, sizeof(mbox));
|
|
|
|
} else {
|
|
|
|
if (sscanf(arg, "%s %f", mbox, &n1) != 2) {
|
|
|
|
n1 = 9.5;
|
|
|
|
strncpy(mbox, arg, sizeof(mbox));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
variable_substitute(mbox, dst, sizeof(dst));
|
2009-10-24 23:59:07 +00:00
|
|
|
|
2010-01-03 07:59:24 +00:00
|
|
|
locmail = (struct local_mail_s*)malloc(sizeof(struct local_mail_s));
|
2009-10-24 23:59:07 +00:00
|
|
|
memset(locmail, 0, sizeof(struct local_mail_s));
|
|
|
|
locmail->mbox = strndup(dst, text_buffer_size);
|
|
|
|
locmail->interval = n1;
|
|
|
|
obj->data.opaque = locmail;
|
2009-10-24 23:13:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define PRINT_MAILS_GENERATOR(x) \
|
|
|
|
void print_##x##mails(struct text_object *obj, char *p, int p_max_size) \
|
|
|
|
{ \
|
2010-01-03 07:59:24 +00:00
|
|
|
struct local_mail_s *locmail = (struct local_mail_s *)obj->data.opaque; \
|
2009-10-24 23:59:07 +00:00
|
|
|
if (!locmail) \
|
|
|
|
return; \
|
|
|
|
update_mail_count(locmail); \
|
|
|
|
snprintf(p, p_max_size, "%d", locmail->x##mail_count); \
|
2009-10-24 23:13:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PRINT_MAILS_GENERATOR()
|
|
|
|
PRINT_MAILS_GENERATOR(new_)
|
|
|
|
PRINT_MAILS_GENERATOR(seen_)
|
|
|
|
PRINT_MAILS_GENERATOR(unseen_)
|
|
|
|
PRINT_MAILS_GENERATOR(flagged_)
|
|
|
|
PRINT_MAILS_GENERATOR(unflagged_)
|
|
|
|
PRINT_MAILS_GENERATOR(forwarded_)
|
|
|
|
PRINT_MAILS_GENERATOR(unforwarded_)
|
|
|
|
PRINT_MAILS_GENERATOR(replied_)
|
|
|
|
PRINT_MAILS_GENERATOR(unreplied_)
|
|
|
|
PRINT_MAILS_GENERATOR(draft_)
|
|
|
|
PRINT_MAILS_GENERATOR(trashed_)
|
|
|
|
|
2009-10-24 23:59:07 +00:00
|
|
|
void free_local_mails(struct text_object *obj)
|
|
|
|
{
|
2010-01-03 07:59:24 +00:00
|
|
|
struct local_mail_s *locmail = (struct local_mail_s *)obj->data.opaque;
|
2009-10-24 23:59:07 +00:00
|
|
|
|
|
|
|
if (!locmail)
|
|
|
|
return;
|
|
|
|
|
2010-02-24 01:14:20 +00:00
|
|
|
free_and_zero(locmail->mbox);
|
|
|
|
free_and_zero(obj->data.opaque);
|
2009-10-24 23:59:07 +00:00
|
|
|
}
|
|
|
|
|
2008-12-14 02:53:05 +00:00
|
|
|
#define MAXDATASIZE 1000
|
|
|
|
|
|
|
|
struct mail_s *parse_mail_args(char type, const char *arg)
|
|
|
|
{
|
|
|
|
struct mail_s *mail;
|
|
|
|
char *tmp;
|
|
|
|
|
2010-01-03 07:59:24 +00:00
|
|
|
mail = new mail_s;
|
2008-12-14 02:53:05 +00:00
|
|
|
|
|
|
|
if (sscanf(arg, "%128s %128s %128s", mail->host, mail->user, mail->pass)
|
|
|
|
!= 3) {
|
|
|
|
if (type == POP3_TYPE) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("Scanning POP3 args failed");
|
2009-05-10 01:20:05 +00:00
|
|
|
} else if (type == IMAP_TYPE) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("Scanning IMAP args failed");
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
2010-01-24 21:15:52 +00:00
|
|
|
delete mail;
|
2009-04-28 16:19:28 +00:00
|
|
|
return 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
// see if password needs prompting
|
|
|
|
if (mail->pass[0] == '*' && mail->pass[1] == '\0') {
|
|
|
|
int fp = fileno(stdin);
|
|
|
|
struct termios term;
|
|
|
|
|
|
|
|
tcgetattr(fp, &term);
|
|
|
|
term.c_lflag &= ~ECHO;
|
|
|
|
tcsetattr(fp, TCSANOW, &term);
|
|
|
|
printf("Enter mailbox password (%s@%s): ", mail->user, mail->host);
|
2009-12-20 01:49:47 +00:00
|
|
|
if (scanf("%128s", mail->pass))
|
|
|
|
mail->pass[0] = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
printf("\n");
|
|
|
|
term.c_lflag |= ECHO;
|
|
|
|
tcsetattr(fp, TCSANOW, &term);
|
|
|
|
}
|
|
|
|
// now we check for optional args
|
2010-01-03 07:59:24 +00:00
|
|
|
tmp = (char*)strstr(arg, "-r ");
|
2008-12-14 02:53:05 +00:00
|
|
|
if (tmp) {
|
|
|
|
tmp += 3;
|
|
|
|
sscanf(tmp, "%u", &mail->retries);
|
|
|
|
} else {
|
|
|
|
mail->retries = 5; // 5 retries after failure
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
tmp = (char*)strstr(arg, "-i ");
|
2008-12-14 02:53:05 +00:00
|
|
|
if (tmp) {
|
|
|
|
tmp += 3;
|
|
|
|
sscanf(tmp, "%f", &mail->interval);
|
|
|
|
} else {
|
|
|
|
mail->interval = 300; // 5 minutes
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
tmp = (char*)strstr(arg, "-p ");
|
2008-12-14 02:53:05 +00:00
|
|
|
if (tmp) {
|
|
|
|
tmp += 3;
|
|
|
|
sscanf(tmp, "%lu", &mail->port);
|
|
|
|
} else {
|
|
|
|
if (type == POP3_TYPE) {
|
|
|
|
mail->port = 110; // default pop3 port
|
|
|
|
} else if (type == IMAP_TYPE) {
|
|
|
|
mail->port = 143; // default imap port
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (type == IMAP_TYPE) {
|
2010-01-03 07:59:24 +00:00
|
|
|
tmp = (char*)strstr(arg, "-f ");
|
2008-12-14 02:53:05 +00:00
|
|
|
if (tmp) {
|
2010-06-02 16:00:38 +00:00
|
|
|
int len = MAXFOLDERSIZE-1;
|
2008-12-14 02:53:05 +00:00
|
|
|
tmp += 3;
|
2009-09-27 17:40:06 +00:00
|
|
|
if (tmp[0] == '\'') {
|
2010-01-03 07:59:24 +00:00
|
|
|
len = (char*)strstr(tmp + 1, "'") - tmp - 1;
|
2010-06-02 16:00:38 +00:00
|
|
|
if (len > MAXFOLDERSIZE-1) {
|
|
|
|
len = MAXFOLDERSIZE-1;
|
2009-09-27 17:40:06 +00:00
|
|
|
}
|
2010-06-02 17:28:40 +00:00
|
|
|
tmp++;
|
2009-09-27 17:40:06 +00:00
|
|
|
}
|
2010-06-02 16:00:38 +00:00
|
|
|
strncpy(mail->folder, tmp, len);
|
2008-12-14 02:53:05 +00:00
|
|
|
} else {
|
2010-06-02 17:28:40 +00:00
|
|
|
strncpy(mail->folder, "INBOX", MAXFOLDERSIZE-1); // default imap inbox
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
tmp = (char*)strstr(arg, "-e ");
|
2008-12-14 02:53:05 +00:00
|
|
|
if (tmp) {
|
2010-06-02 17:28:40 +00:00
|
|
|
int len = 1024;
|
2008-12-14 02:53:05 +00:00
|
|
|
tmp += 3;
|
|
|
|
|
|
|
|
if (tmp[0] == '\'') {
|
2010-01-03 07:59:24 +00:00
|
|
|
len = (char*)strstr(tmp + 1, "'") - tmp - 1;
|
2010-06-02 17:28:40 +00:00
|
|
|
if (len > 1024) {
|
|
|
|
len = 1024;
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
strncpy(mail->command, tmp + 1, len);
|
|
|
|
} else {
|
|
|
|
mail->command[0] = '\0';
|
|
|
|
}
|
|
|
|
return mail;
|
|
|
|
}
|
|
|
|
|
2009-10-24 23:17:30 +00:00
|
|
|
void parse_imap_mail_args(struct text_object *obj, const char *arg)
|
|
|
|
{
|
2009-10-24 23:43:08 +00:00
|
|
|
static int rep = 0;
|
|
|
|
|
2009-10-24 23:17:30 +00:00
|
|
|
if (!arg) {
|
2009-10-24 23:43:08 +00:00
|
|
|
if (!global_mail && !rep) {
|
|
|
|
// something is wrong, warn once then stop
|
|
|
|
NORM_ERR("There's a problem with your mail settings. "
|
|
|
|
"Check that the global mail settings are properly defined"
|
|
|
|
" (line %li).", obj->line);
|
|
|
|
rep = 1;
|
|
|
|
return;
|
|
|
|
}
|
2009-10-24 23:49:58 +00:00
|
|
|
obj->data.opaque = global_mail;
|
2009-10-24 23:43:08 +00:00
|
|
|
global_mail_use++;
|
2009-10-24 23:17:30 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
// proccss
|
2009-10-24 23:49:58 +00:00
|
|
|
obj->data.opaque = parse_mail_args(IMAP_TYPE, arg);
|
2009-10-24 23:17:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void parse_pop3_mail_args(struct text_object *obj, const char *arg)
|
|
|
|
{
|
2009-10-24 23:43:08 +00:00
|
|
|
static int rep = 0;
|
|
|
|
|
2009-10-24 23:17:30 +00:00
|
|
|
if (!arg) {
|
2009-10-24 23:43:08 +00:00
|
|
|
if (!global_mail && !rep) {
|
|
|
|
// something is wrong, warn once then stop
|
|
|
|
NORM_ERR("There's a problem with your mail settings. "
|
|
|
|
"Check that the global mail settings are properly defined"
|
|
|
|
" (line %li).", obj->line);
|
|
|
|
rep = 1;
|
|
|
|
return;
|
|
|
|
}
|
2009-10-24 23:49:58 +00:00
|
|
|
obj->data.opaque = global_mail;
|
2009-10-24 23:43:08 +00:00
|
|
|
global_mail_use++;
|
2009-10-24 23:17:30 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
// proccss
|
2009-10-24 23:49:58 +00:00
|
|
|
obj->data.opaque = parse_mail_args(POP3_TYPE, arg);
|
2009-10-24 23:43:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void parse_global_imap_mail_args(const char *value)
|
|
|
|
{
|
|
|
|
global_mail = parse_mail_args(IMAP_TYPE, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void parse_global_pop3_mail_args(const char *value)
|
|
|
|
{
|
|
|
|
global_mail = parse_mail_args(POP3_TYPE, value);
|
2009-10-24 23:17:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void free_mail_obj(struct text_object *obj)
|
|
|
|
{
|
2009-10-24 23:49:58 +00:00
|
|
|
if (!obj->data.opaque)
|
2009-10-24 23:43:08 +00:00
|
|
|
return;
|
|
|
|
|
2009-10-24 23:49:58 +00:00
|
|
|
if (obj->data.opaque == global_mail) {
|
2009-10-24 23:43:08 +00:00
|
|
|
if (--global_mail_use == 0) {
|
2010-01-03 07:59:24 +00:00
|
|
|
delete global_mail;
|
2009-10-24 23:43:08 +00:00
|
|
|
global_mail = 0;
|
|
|
|
}
|
|
|
|
} else {
|
2010-01-03 07:59:24 +00:00
|
|
|
struct mail_s *mail = (struct mail_s*)obj->data.opaque;
|
|
|
|
delete mail;
|
2009-10-24 23:49:58 +00:00
|
|
|
obj->data.opaque = 0;
|
2009-10-24 23:17:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-14 02:53:05 +00:00
|
|
|
int imap_command(int sockfd, const char *command, char *response, const char *verify)
|
|
|
|
{
|
2009-08-08 01:20:47 +00:00
|
|
|
struct timeval fetchtimeout;
|
2008-12-14 02:53:05 +00:00
|
|
|
fd_set fdset;
|
|
|
|
int res, numbytes = 0;
|
|
|
|
if (send(sockfd, command, strlen(command), 0) == -1) {
|
|
|
|
perror("send");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-08-08 01:20:47 +00:00
|
|
|
fetchtimeout.tv_sec = 60; // 60 second timeout i guess
|
|
|
|
fetchtimeout.tv_usec = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
FD_ZERO(&fdset);
|
|
|
|
FD_SET(sockfd, &fdset);
|
2009-08-08 01:20:47 +00:00
|
|
|
res = select(sockfd + 1, &fdset, NULL, NULL, &fetchtimeout);
|
2008-12-14 02:53:05 +00:00
|
|
|
if (res > 0) {
|
|
|
|
if ((numbytes = recv(sockfd, response, MAXDATASIZE - 1, 0)) == -1) {
|
|
|
|
perror("recv");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2008-12-16 04:55:48 +00:00
|
|
|
DBGP2("imap_command() command: %s", command);
|
2008-12-14 02:53:05 +00:00
|
|
|
DBGP2("imap_command() received: %s", response);
|
|
|
|
response[numbytes] = '\0';
|
|
|
|
if (strstr(response, verify) == NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-03 07:59:24 +00:00
|
|
|
int imap_check_status(char *recvbuf, struct mail_s *mail, thread_handle &handle)
|
2008-12-14 02:53:05 +00:00
|
|
|
{
|
|
|
|
char *reply;
|
2010-01-03 07:59:24 +00:00
|
|
|
reply = (char*)strstr(recvbuf, " (MESSAGES ");
|
2008-12-14 02:53:05 +00:00
|
|
|
if (!reply || strlen(reply) < 2) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
reply += 2;
|
|
|
|
*strchr(reply, ')') = '\0';
|
|
|
|
if (reply == NULL) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("Error parsing IMAP response: %s", recvbuf);
|
2008-12-14 02:53:05 +00:00
|
|
|
return -1;
|
|
|
|
} else {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(handle.mutex());
|
2008-12-14 02:53:05 +00:00
|
|
|
sscanf(reply, "MESSAGES %lu UNSEEN %lu", &mail->messages,
|
|
|
|
&mail->unseen);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void imap_unseen_command(struct mail_s *mail, unsigned long old_unseen, unsigned long old_messages)
|
|
|
|
{
|
|
|
|
if (strlen(mail->command) > 1 && (mail->unseen > old_unseen
|
|
|
|
|| (mail->messages > old_messages && mail->unseen > 0))) {
|
|
|
|
// new mail goodie
|
|
|
|
if (system(mail->command) == -1) {
|
|
|
|
perror("system()");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-24 23:49:58 +00:00
|
|
|
static void ensure_mail_thread(struct mail_s *mail,
|
2010-02-24 19:10:26 +00:00
|
|
|
const std::function<void(thread_handle &, struct mail_s *mail)> &func, const char *text)
|
2009-10-24 23:17:30 +00:00
|
|
|
{
|
2009-10-24 23:49:58 +00:00
|
|
|
if (mail->p_timed_thread)
|
2009-10-24 23:43:08 +00:00
|
|
|
return;
|
|
|
|
|
2010-06-10 17:13:15 +00:00
|
|
|
mail->p_timed_thread = timed_thread::create(std::bind(func, std::placeholders::_1, mail),
|
|
|
|
std::chrono::microseconds(long(mail->interval * 1000000)));
|
2009-10-24 23:49:58 +00:00
|
|
|
if (!mail->p_timed_thread) {
|
2009-10-24 23:43:08 +00:00
|
|
|
NORM_ERR("Error creating %s timed thread", text);
|
|
|
|
}
|
2009-10-24 23:17:30 +00:00
|
|
|
}
|
|
|
|
|
2010-01-03 07:59:24 +00:00
|
|
|
static void imap_thread(thread_handle &handle, struct mail_s *mail)
|
2008-12-14 02:53:05 +00:00
|
|
|
{
|
|
|
|
int sockfd, numbytes;
|
|
|
|
char recvbuf[MAXDATASIZE];
|
|
|
|
char sendbuf[MAXDATASIZE];
|
|
|
|
unsigned int fail = 0;
|
|
|
|
unsigned long old_unseen = ULONG_MAX;
|
|
|
|
unsigned long old_messages = ULONG_MAX;
|
|
|
|
struct stat stat_buf;
|
|
|
|
int has_idle = 0;
|
2010-01-03 07:59:24 +00:00
|
|
|
int threadfd = handle.readfd();
|
2009-10-01 01:06:18 +00:00
|
|
|
char resolved_host = 0;
|
2010-08-15 12:56:46 +00:00
|
|
|
struct addrinfo hints;
|
2010-08-26 17:34:34 +00:00
|
|
|
struct addrinfo *ai = 0, *rp;
|
2010-08-15 12:56:46 +00:00
|
|
|
char portbuf[8];
|
2008-12-14 02:53:05 +00:00
|
|
|
|
|
|
|
while (fail < mail->retries) {
|
2009-08-08 01:20:47 +00:00
|
|
|
struct timeval fetchtimeout;
|
2008-12-14 02:53:05 +00:00
|
|
|
int res;
|
|
|
|
fd_set fdset;
|
|
|
|
|
2009-10-01 01:06:18 +00:00
|
|
|
if (!resolved_host) {
|
2010-08-15 12:56:46 +00:00
|
|
|
memset(&hints, 0, sizeof(struct addrinfo));
|
|
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_flags = 0;
|
|
|
|
hints.ai_protocol = 0;
|
|
|
|
snprintf(portbuf, 8, "%lu", mail->port);
|
|
|
|
|
|
|
|
res = getaddrinfo(mail->host, portbuf, &hints, &ai);
|
|
|
|
if (res != 0) {
|
|
|
|
NORM_ERR("IMAP getaddrinfo: %s", gai_strerror(res));
|
2009-10-01 01:06:18 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
resolved_host = 1;
|
|
|
|
}
|
2008-12-14 02:53:05 +00:00
|
|
|
if (fail > 0) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("Trying IMAP connection again for %s@%s (try %u/%u)",
|
2008-12-14 02:53:05 +00:00
|
|
|
mail->user, mail->host, fail + 1, mail->retries);
|
|
|
|
}
|
|
|
|
do {
|
2010-08-15 12:56:46 +00:00
|
|
|
for (rp = ai; rp != NULL; rp = rp->ai_next) {
|
|
|
|
sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
|
|
|
|
if (sockfd == -1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (connect(sockfd, rp->ai_addr, rp->ai_addrlen) != -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
close(sockfd);
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
2010-08-15 12:56:46 +00:00
|
|
|
freeaddrinfo(ai);
|
2010-08-26 17:34:34 +00:00
|
|
|
ai = 0;
|
2010-08-15 12:56:46 +00:00
|
|
|
if (rp == NULL) {
|
2008-12-14 02:53:05 +00:00
|
|
|
perror("connect");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-08-08 01:20:47 +00:00
|
|
|
fetchtimeout.tv_sec = 60; // 60 second timeout i guess
|
|
|
|
fetchtimeout.tv_usec = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
FD_ZERO(&fdset);
|
|
|
|
FD_SET(sockfd, &fdset);
|
2009-08-08 01:20:47 +00:00
|
|
|
res = select(sockfd + 1, &fdset, NULL, NULL, &fetchtimeout);
|
2008-12-14 02:53:05 +00:00
|
|
|
if (res > 0) {
|
|
|
|
if ((numbytes = recv(sockfd, recvbuf, MAXDATASIZE - 1, 0)) == -1) {
|
|
|
|
perror("recv");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("IMAP connection failed: timeout");
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
recvbuf[numbytes] = '\0';
|
|
|
|
DBGP2("imap_thread() received: %s", recvbuf);
|
|
|
|
if (strstr(recvbuf, "* OK") != recvbuf) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("IMAP connection failed, probably not an IMAP server");
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
2009-09-27 01:38:07 +00:00
|
|
|
strncpy(sendbuf, "abc CAPABILITY\r\n", MAXDATASIZE);
|
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "abc OK")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (strstr(recvbuf, " IDLE ") != NULL) {
|
|
|
|
has_idle = 1;
|
|
|
|
}
|
|
|
|
|
2008-12-14 02:53:05 +00:00
|
|
|
strncpy(sendbuf, "a1 login ", MAXDATASIZE);
|
|
|
|
strncat(sendbuf, mail->user, MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
strncat(sendbuf, " ", MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
strncat(sendbuf, mail->pass, MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
strncat(sendbuf, "\r\n", MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "a1 OK")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-09-27 17:40:06 +00:00
|
|
|
strncpy(sendbuf, "a2 STATUS \"", MAXDATASIZE);
|
2008-12-14 02:53:05 +00:00
|
|
|
strncat(sendbuf, mail->folder, MAXDATASIZE - strlen(sendbuf) - 1);
|
2009-09-27 17:40:06 +00:00
|
|
|
strncat(sendbuf, "\" (MESSAGES UNSEEN)\r\n",
|
2008-12-14 02:53:05 +00:00
|
|
|
MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "a2 OK")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-01-03 07:59:24 +00:00
|
|
|
if (imap_check_status(recvbuf, mail, handle)) {
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
imap_unseen_command(mail, old_unseen, old_messages);
|
|
|
|
fail = 0;
|
|
|
|
old_unseen = mail->unseen;
|
|
|
|
old_messages = mail->messages;
|
|
|
|
|
|
|
|
if (has_idle) {
|
2009-09-27 17:40:06 +00:00
|
|
|
strncpy(sendbuf, "a4 SELECT \"", MAXDATASIZE);
|
2008-12-14 02:53:05 +00:00
|
|
|
strncat(sendbuf, mail->folder, MAXDATASIZE - strlen(sendbuf) - 1);
|
2009-09-27 17:40:06 +00:00
|
|
|
strncat(sendbuf, "\"\r\n", MAXDATASIZE - strlen(sendbuf) - 1);
|
2008-12-14 02:53:05 +00:00
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "a4 OK")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
strncpy(sendbuf, "a5 IDLE\r\n", MAXDATASIZE);
|
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "+ idling")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
recvbuf[0] = '\0';
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
/*
|
|
|
|
* RFC 2177 says we have to re-idle every 29 minutes.
|
|
|
|
* We'll do it every 20 minutes to be safe.
|
|
|
|
*/
|
2009-08-08 01:20:47 +00:00
|
|
|
fetchtimeout.tv_sec = 1200;
|
|
|
|
fetchtimeout.tv_usec = 0;
|
2008-12-16 04:55:48 +00:00
|
|
|
DBGP2("idling...");
|
2008-12-14 02:53:05 +00:00
|
|
|
FD_ZERO(&fdset);
|
|
|
|
FD_SET(sockfd, &fdset);
|
|
|
|
FD_SET(threadfd, &fdset);
|
2009-10-01 01:06:18 +00:00
|
|
|
res = select(MAX(sockfd + 1, threadfd + 1), &fdset, NULL, NULL, &fetchtimeout);
|
2010-01-03 07:59:24 +00:00
|
|
|
if (handle.test(1) || (res == -1 && errno == EINTR) || FD_ISSET(threadfd, &fdset)) {
|
2008-12-14 02:53:05 +00:00
|
|
|
if ((fstat(sockfd, &stat_buf) == 0) && S_ISSOCK(stat_buf.st_mode)) {
|
|
|
|
/* if a valid socket, close it */
|
|
|
|
close(sockfd);
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
return;
|
2008-12-14 02:53:05 +00:00
|
|
|
} else if (res > 0) {
|
|
|
|
if ((numbytes = recv(sockfd, recvbuf, MAXDATASIZE - 1, 0)) == -1) {
|
|
|
|
perror("recv idling");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2009-05-30 05:31:03 +00:00
|
|
|
fail++;
|
2008-12-14 02:53:05 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
recvbuf[numbytes] = '\0';
|
|
|
|
DBGP2("imap_thread() received: %s", recvbuf);
|
|
|
|
if (strlen(recvbuf) > 2) {
|
2010-01-02 22:22:46 +00:00
|
|
|
unsigned long messages, recent = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
char *buf = recvbuf;
|
2008-12-16 04:55:48 +00:00
|
|
|
char force_check = 0;
|
2010-01-03 07:59:24 +00:00
|
|
|
buf = (char*)strstr(buf, "EXISTS");
|
2008-12-14 02:53:05 +00:00
|
|
|
while (buf && strlen(buf) > 1 && strstr(buf + 1, "EXISTS")) {
|
2010-01-03 07:59:24 +00:00
|
|
|
buf = (char*)strstr(buf + 1, "EXISTS");
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
if (buf) {
|
|
|
|
// back up until we reach '*'
|
|
|
|
while (buf >= recvbuf && buf[0] != '*') {
|
|
|
|
buf--;
|
|
|
|
}
|
|
|
|
if (sscanf(buf, "* %lu EXISTS\r\n", &messages) == 1) {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(handle.mutex());
|
2008-12-16 04:55:48 +00:00
|
|
|
if (mail->messages != messages) {
|
|
|
|
force_check = 1;
|
|
|
|
mail->messages = messages;
|
|
|
|
}
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
buf = recvbuf;
|
2010-01-03 07:59:24 +00:00
|
|
|
buf = (char*)strstr(buf, "RECENT");
|
2008-12-14 02:53:05 +00:00
|
|
|
while (buf && strlen(buf) > 1 && strstr(buf + 1, "RECENT")) {
|
2010-01-03 07:59:24 +00:00
|
|
|
buf = (char*)strstr(buf + 1, "RECENT");
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
if (buf) {
|
|
|
|
// back up until we reach '*'
|
|
|
|
while (buf >= recvbuf && buf[0] != '*') {
|
|
|
|
buf--;
|
|
|
|
}
|
|
|
|
if (sscanf(buf, "* %lu RECENT\r\n", &recent) != 1) {
|
|
|
|
recent = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* check if we got a FETCH from server, recent was
|
|
|
|
* something other than 0, or we had a timeout
|
|
|
|
*/
|
|
|
|
buf = recvbuf;
|
2009-08-08 01:20:47 +00:00
|
|
|
if (recent > 0 || (buf && strstr(buf, " FETCH ")) || fetchtimeout.tv_sec == 0 || force_check) {
|
2008-12-14 02:53:05 +00:00
|
|
|
// re-check messages and unseen
|
|
|
|
if (imap_command(sockfd, "DONE\r\n", recvbuf, "a5 OK")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
2009-09-27 17:40:06 +00:00
|
|
|
strncpy(sendbuf, "a2 STATUS \"", MAXDATASIZE);
|
2008-12-14 02:53:05 +00:00
|
|
|
strncat(sendbuf, mail->folder, MAXDATASIZE - strlen(sendbuf) - 1);
|
2009-09-27 17:40:06 +00:00
|
|
|
strncat(sendbuf, "\" (MESSAGES UNSEEN)\r\n",
|
2008-12-14 02:53:05 +00:00
|
|
|
MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "a2 OK")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
if (imap_check_status(recvbuf, mail, handle)) {
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
strncpy(sendbuf, "a5 IDLE\r\n", MAXDATASIZE);
|
|
|
|
if (imap_command(sockfd, sendbuf, recvbuf, "+ idling")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* check if we got a BYE from server
|
|
|
|
*/
|
|
|
|
buf = recvbuf;
|
|
|
|
if (buf && strstr(buf, "* BYE")) {
|
|
|
|
// need to re-connect
|
|
|
|
break;
|
|
|
|
}
|
2009-05-30 05:31:03 +00:00
|
|
|
} else {
|
|
|
|
fail++;
|
|
|
|
break;
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
imap_unseen_command(mail, old_unseen, old_messages);
|
|
|
|
fail = 0;
|
|
|
|
old_unseen = mail->unseen;
|
|
|
|
old_messages = mail->messages;
|
|
|
|
}
|
2009-05-30 05:31:03 +00:00
|
|
|
if (fail) break;
|
2008-12-14 02:53:05 +00:00
|
|
|
} else {
|
|
|
|
strncpy(sendbuf, "a3 logout\r\n", MAXDATASIZE);
|
|
|
|
if (send(sockfd, sendbuf, strlen(sendbuf), 0) == -1) {
|
|
|
|
perror("send a3");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
2009-08-08 01:20:47 +00:00
|
|
|
fetchtimeout.tv_sec = 60; // 60 second timeout i guess
|
|
|
|
fetchtimeout.tv_usec = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
FD_ZERO(&fdset);
|
|
|
|
FD_SET(sockfd, &fdset);
|
2009-08-08 01:20:47 +00:00
|
|
|
res = select(sockfd + 1, &fdset, NULL, NULL, &fetchtimeout);
|
2008-12-14 02:53:05 +00:00
|
|
|
if (res > 0) {
|
|
|
|
if ((numbytes = recv(sockfd, recvbuf, MAXDATASIZE - 1, 0)) == -1) {
|
|
|
|
perror("recv a3");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
recvbuf[numbytes] = '\0';
|
|
|
|
DBGP2("imap_thread() received: %s", recvbuf);
|
|
|
|
if (strstr(recvbuf, "a3 OK") == NULL) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("IMAP logout failed: %s", recvbuf);
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (0);
|
|
|
|
if ((fstat(sockfd, &stat_buf) == 0) && S_ISSOCK(stat_buf.st_mode)) {
|
|
|
|
/* if a valid socket, close it */
|
|
|
|
close(sockfd);
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
if (handle.test(0)) {
|
|
|
|
return;
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mail->unseen = 0;
|
|
|
|
mail->messages = 0;
|
|
|
|
}
|
|
|
|
|
2009-10-24 23:17:30 +00:00
|
|
|
void print_imap_unseen(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
2010-01-03 07:59:24 +00:00
|
|
|
struct mail_s *mail = (struct mail_s*)obj->data.opaque;
|
2009-10-24 23:49:58 +00:00
|
|
|
|
|
|
|
if (!mail)
|
|
|
|
return;
|
|
|
|
|
2010-02-24 19:10:26 +00:00
|
|
|
ensure_mail_thread(mail, std::bind(imap_thread, std::placeholders::_1, std::placeholders::_2), "imap");
|
2009-10-24 23:17:30 +00:00
|
|
|
|
|
|
|
if (mail && mail->p_timed_thread) {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
|
2009-10-24 23:17:30 +00:00
|
|
|
snprintf(p, p_max_size, "%lu", mail->unseen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_imap_messages(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
2010-01-03 07:59:24 +00:00
|
|
|
struct mail_s *mail = (struct mail_s*)obj->data.opaque;
|
2009-10-24 23:49:58 +00:00
|
|
|
|
|
|
|
if (!mail)
|
|
|
|
return;
|
|
|
|
|
2010-02-24 19:10:26 +00:00
|
|
|
ensure_mail_thread(mail, std::bind(imap_thread, std::placeholders::_1, std::placeholders::_2), "imap");
|
2009-10-24 23:17:30 +00:00
|
|
|
|
|
|
|
if (mail && mail->p_timed_thread) {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
|
2009-10-24 23:17:30 +00:00
|
|
|
snprintf(p, p_max_size, "%lu", mail->messages);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-14 02:53:05 +00:00
|
|
|
int pop3_command(int sockfd, const char *command, char *response, const char *verify)
|
|
|
|
{
|
2009-08-08 01:20:47 +00:00
|
|
|
struct timeval fetchtimeout;
|
2008-12-14 02:53:05 +00:00
|
|
|
fd_set fdset;
|
|
|
|
int res, numbytes = 0;
|
|
|
|
if (send(sockfd, command, strlen(command), 0) == -1) {
|
|
|
|
perror("send");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-08-08 01:20:47 +00:00
|
|
|
fetchtimeout.tv_sec = 60; // 60 second timeout i guess
|
|
|
|
fetchtimeout.tv_usec = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
FD_ZERO(&fdset);
|
|
|
|
FD_SET(sockfd, &fdset);
|
2009-08-08 01:20:47 +00:00
|
|
|
res = select(sockfd + 1, &fdset, NULL, NULL, &fetchtimeout);
|
2008-12-14 02:53:05 +00:00
|
|
|
if (res > 0) {
|
|
|
|
if ((numbytes = recv(sockfd, response, MAXDATASIZE - 1, 0)) == -1) {
|
|
|
|
perror("recv");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DBGP2("pop3_command() received: %s", response);
|
|
|
|
response[numbytes] = '\0';
|
|
|
|
if (strstr(response, verify) == NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-03 07:59:24 +00:00
|
|
|
static void pop3_thread(thread_handle &handle, struct mail_s *mail)
|
2008-12-14 02:53:05 +00:00
|
|
|
{
|
|
|
|
int sockfd, numbytes;
|
|
|
|
char recvbuf[MAXDATASIZE];
|
|
|
|
char sendbuf[MAXDATASIZE];
|
|
|
|
char *reply;
|
|
|
|
unsigned int fail = 0;
|
|
|
|
unsigned long old_unseen = ULONG_MAX;
|
|
|
|
struct stat stat_buf;
|
2009-10-01 01:06:18 +00:00
|
|
|
char resolved_host = 0;
|
2010-08-15 12:56:46 +00:00
|
|
|
struct addrinfo hints;
|
2010-08-26 17:34:34 +00:00
|
|
|
struct addrinfo *ai = 0, *rp;
|
2010-08-15 12:56:46 +00:00
|
|
|
char portbuf[8];
|
2008-12-14 02:53:05 +00:00
|
|
|
|
|
|
|
while (fail < mail->retries) {
|
2009-08-08 01:20:47 +00:00
|
|
|
struct timeval fetchtimeout;
|
2008-12-14 02:53:05 +00:00
|
|
|
int res;
|
|
|
|
fd_set fdset;
|
2009-10-01 01:06:18 +00:00
|
|
|
if (!resolved_host) {
|
2010-08-15 12:56:46 +00:00
|
|
|
memset(&hints, 0, sizeof(struct addrinfo));
|
|
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_flags = 0;
|
|
|
|
hints.ai_protocol = 0;
|
|
|
|
snprintf(portbuf, 8, "%lu", mail->port);
|
|
|
|
|
|
|
|
res = getaddrinfo(mail->host, portbuf, &hints, &ai);
|
|
|
|
if (res != 0) {
|
|
|
|
NORM_ERR("POP3 getaddrinfo: %s", gai_strerror(res));
|
2009-10-01 01:06:18 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
resolved_host = 1;
|
|
|
|
}
|
2008-12-14 02:53:05 +00:00
|
|
|
if (fail > 0) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("Trying POP3 connection again for %s@%s (try %u/%u)",
|
2008-12-14 02:53:05 +00:00
|
|
|
mail->user, mail->host, fail + 1, mail->retries);
|
|
|
|
}
|
|
|
|
do {
|
2010-08-15 12:56:46 +00:00
|
|
|
for (rp = ai; rp != NULL; rp = rp->ai_next) {
|
|
|
|
sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
|
|
|
|
if (sockfd == -1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (connect(sockfd, rp->ai_addr, rp->ai_addrlen) != -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
close(sockfd);
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
2010-08-15 12:56:46 +00:00
|
|
|
freeaddrinfo(ai);
|
2010-08-26 17:34:34 +00:00
|
|
|
ai = 0;
|
2010-08-15 12:56:46 +00:00
|
|
|
if (rp == NULL) {
|
2008-12-14 02:53:05 +00:00
|
|
|
perror("connect");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-08-08 01:20:47 +00:00
|
|
|
fetchtimeout.tv_sec = 60; // 60 second timeout i guess
|
|
|
|
fetchtimeout.tv_usec = 0;
|
2008-12-14 02:53:05 +00:00
|
|
|
FD_ZERO(&fdset);
|
|
|
|
FD_SET(sockfd, &fdset);
|
2009-08-08 01:20:47 +00:00
|
|
|
res = select(sockfd + 1, &fdset, NULL, NULL, &fetchtimeout);
|
2008-12-14 02:53:05 +00:00
|
|
|
if (res > 0) {
|
|
|
|
if ((numbytes = recv(sockfd, recvbuf, MAXDATASIZE - 1, 0)) == -1) {
|
|
|
|
perror("recv");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("POP3 connection failed: timeout\n");
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
DBGP2("pop3_thread received: %s", recvbuf);
|
|
|
|
recvbuf[numbytes] = '\0';
|
|
|
|
if (strstr(recvbuf, "+OK ") != recvbuf) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("POP3 connection failed, probably not a POP3 server");
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
strncpy(sendbuf, "USER ", MAXDATASIZE);
|
|
|
|
strncat(sendbuf, mail->user, MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
strncat(sendbuf, "\r\n", MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
if (pop3_command(sockfd, sendbuf, recvbuf, "+OK ")) {
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
strncpy(sendbuf, "PASS ", MAXDATASIZE);
|
|
|
|
strncat(sendbuf, mail->pass, MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
strncat(sendbuf, "\r\n", MAXDATASIZE - strlen(sendbuf) - 1);
|
|
|
|
if (pop3_command(sockfd, sendbuf, recvbuf, "+OK ")) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("POP3 server login failed: %s", recvbuf);
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
strncpy(sendbuf, "STAT\r\n", MAXDATASIZE);
|
|
|
|
if (pop3_command(sockfd, sendbuf, recvbuf, "+OK ")) {
|
|
|
|
perror("send STAT");
|
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// now we get the data
|
|
|
|
reply = recvbuf + 4;
|
|
|
|
if (reply == NULL) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("Error parsing POP3 response: %s", recvbuf);
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
} else {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(handle.mutex());
|
2008-12-14 02:53:05 +00:00
|
|
|
sscanf(reply, "%lu %lu", &mail->unseen, &mail->used);
|
|
|
|
}
|
2009-10-24 23:49:58 +00:00
|
|
|
|
2008-12-14 02:53:05 +00:00
|
|
|
strncpy(sendbuf, "QUIT\r\n", MAXDATASIZE);
|
|
|
|
if (pop3_command(sockfd, sendbuf, recvbuf, "+OK")) {
|
2009-08-01 18:45:43 +00:00
|
|
|
NORM_ERR("POP3 logout failed: %s", recvbuf);
|
2008-12-14 02:53:05 +00:00
|
|
|
fail++;
|
|
|
|
break;
|
|
|
|
}
|
2009-10-24 23:49:58 +00:00
|
|
|
|
2008-12-14 02:53:05 +00:00
|
|
|
if (strlen(mail->command) > 1 && mail->unseen > old_unseen) {
|
|
|
|
// new mail goodie
|
|
|
|
if (system(mail->command) == -1) {
|
|
|
|
perror("system()");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fail = 0;
|
|
|
|
old_unseen = mail->unseen;
|
|
|
|
} while (0);
|
|
|
|
if ((fstat(sockfd, &stat_buf) == 0) && S_ISSOCK(stat_buf.st_mode)) {
|
|
|
|
/* if a valid socket, close it */
|
|
|
|
close(sockfd);
|
|
|
|
}
|
2010-01-03 07:59:24 +00:00
|
|
|
if (handle.test(0)) {
|
|
|
|
return;
|
2008-12-14 02:53:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mail->unseen = 0;
|
|
|
|
mail->used = 0;
|
|
|
|
}
|
|
|
|
|
2009-10-24 23:17:30 +00:00
|
|
|
void print_pop3_unseen(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
2010-01-03 07:59:24 +00:00
|
|
|
struct mail_s *mail = (struct mail_s *)obj->data.opaque;
|
2009-10-24 23:49:58 +00:00
|
|
|
|
|
|
|
if (!mail)
|
|
|
|
return;
|
|
|
|
|
2010-02-24 19:10:26 +00:00
|
|
|
ensure_mail_thread(mail, std::bind(pop3_thread, std::placeholders::_1, std::placeholders::_2), "pop3");
|
2009-10-24 23:17:30 +00:00
|
|
|
|
|
|
|
if (mail && mail->p_timed_thread) {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
|
2009-10-24 23:17:30 +00:00
|
|
|
snprintf(p, p_max_size, "%lu", mail->unseen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_pop3_used(struct text_object *obj, char *p, int p_max_size)
|
|
|
|
{
|
2010-01-03 07:59:24 +00:00
|
|
|
struct mail_s *mail = (struct mail_s *)obj->data.opaque;
|
2009-10-24 23:49:58 +00:00
|
|
|
|
|
|
|
if (!mail)
|
|
|
|
return;
|
|
|
|
|
2010-02-24 19:10:26 +00:00
|
|
|
ensure_mail_thread(mail, std::bind(pop3_thread, std::placeholders::_1, std::placeholders::_2), "pop3");
|
2009-10-24 23:17:30 +00:00
|
|
|
|
|
|
|
if (mail && mail->p_timed_thread) {
|
2010-02-24 19:10:26 +00:00
|
|
|
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
|
2009-10-24 23:17:30 +00:00
|
|
|
snprintf(p, p_max_size, "%.1f",
|
|
|
|
mail->used / 1024.0 / 1024.0);
|
|
|
|
}
|
|
|
|
}
|