NeoMutt  2022-04-29-247-gc6aae8
Teaching an old dog new tricks
DOXYGEN
mbox_open()

Open a Mailbox. More...

+ Collaboration diagram for mbox_open():

Functions

static enum MxOpenReturns comp_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns imap_mbox_open (struct Mailbox *m)
 Open a mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns maildir_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns mh_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns mbox_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns nntp_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns nm_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 
static enum MxOpenReturns pop_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -. More...
 

Detailed Description

Open a Mailbox.

Parameters
mMailbox to open
Return values
enumMxOpenReturns

Contract

Function Documentation

◆ comp_mbox_open()

static enum MxOpenReturns comp_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Set up a compressed mailbox to be read. Decompress the mailbox and set up the paths and hooks needed. Then determine the type of the mailbox so we can delegate the handling of messages.

Definition at line 443 of file compress.c.

444{
445 struct CompressInfo *ci = set_compress_info(m);
446 if (!ci)
447 return MX_OPEN_ERROR;
448
449 /* If there's no close-hook, or the file isn't writable */
450 if (!ci->cmd_close || (access(mailbox_path(m), W_OK) != 0))
451 m->readonly = true;
452
453 if (setup_paths(m) != 0)
454 goto cmo_fail;
455 store_size(m);
456
457 if (!lock_realpath(m, false))
458 {
459 mutt_error(_("Unable to lock mailbox"));
460 goto cmo_fail;
461 }
462
463 int rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
464 if (rc == 0)
465 goto cmo_fail;
466
468
470 if (m->type == MUTT_UNKNOWN)
471 {
472 mutt_error(_("Can't identify the contents of the compressed file"));
473 goto cmo_fail;
474 }
475
476 ci->child_ops = mx_get_ops(m->type);
477 if (!ci->child_ops)
478 {
479 mutt_error(_("Can't find mailbox ops for mailbox type %d"), m->type);
480 goto cmo_fail;
481 }
482
483 m->account->type = m->type;
484 return ci->child_ops->mbox_open(m);
485
486cmo_fail:
487 /* remove the partial uncompressed file */
488 (void) remove(mailbox_path(m));
490 return MX_OPEN_ERROR;
491}
static struct CompressInfo * set_compress_info(struct Mailbox *m)
Find the compress hooks for a mailbox.
Definition: compress.c:197
static void compress_info_free(struct Mailbox *m)
Frees the compress info members and structure.
Definition: compress.c:227
static int setup_paths(struct Mailbox *m)
Set the mailbox paths.
Definition: compress.c:151
static int execute_command(struct Mailbox *m, const char *command, const char *progress)
Run a system command.
Definition: compress.c:322
static void store_size(const struct Mailbox *m)
Save the size of the compressed file.
Definition: compress.c:179
static bool lock_realpath(struct Mailbox *m, bool excl)
Try to lock the Mailbox.realpath.
Definition: compress.c:86
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:125
#define mutt_error(...)
Definition: logging.h:87
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:210
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
#define _(a)
Definition: message.h:28
const struct MxOps * mx_get_ops(enum MailboxType type)
Get mailbox operations.
Definition: mx.c:141
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1327
@ MX_OPEN_ERROR
Open failed with an error.
Definition: mxapi.h:99
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:38
Private data for compress.
Definition: lib.h:47
const char * cmd_open
open-hook command
Definition: lib.h:50
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:52
const char * cmd_close
close-hook command
Definition: lib.h:49
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct Account * account
Account that owns this Mailbox.
Definition: mailbox.h:127
bool readonly
Don't allow changes to the mailbox.
Definition: mailbox.h:115
enum MxOpenReturns(* mbox_open)(struct Mailbox *m)
Definition: mxapi.h:160
+ Here is the call graph for this function:

◆ imap_mbox_open()

static enum MxOpenReturns imap_mbox_open ( struct Mailbox m)
static

Open a mailbox - Implements MxOps::mbox_open() -.

Definition at line 1928 of file imap.c.

1929{
1930 if (!m->account || !m->mdata)
1931 return MX_OPEN_ERROR;
1932
1933 char buf[PATH_MAX] = { 0 };
1934 int count = 0;
1935 int rc;
1936
1938 struct ImapMboxData *mdata = imap_mdata_get(m);
1939
1940 mutt_debug(LL_DEBUG3, "opening %s, saving %s\n", m->pathbuf.data,
1941 (adata->mailbox ? adata->mailbox->pathbuf.data : "(none)"));
1942 adata->prev_mailbox = adata->mailbox;
1943 adata->mailbox = m;
1944
1945 /* clear mailbox status */
1946 adata->status = 0;
1947 m->rights = 0;
1948 mdata->new_mail_count = 0;
1949
1950 if (m->verbose)
1951 mutt_message(_("Selecting %s..."), mdata->name);
1952
1953 /* pipeline ACL test */
1954 if (adata->capabilities & IMAP_CAP_ACL)
1955 {
1956 snprintf(buf, sizeof(buf), "MYRIGHTS %s", mdata->munge_name);
1957 imap_exec(adata, buf, IMAP_CMD_QUEUE);
1958 }
1959 /* assume we have all rights if ACL is unavailable */
1960 else
1961 {
1964 }
1965
1966 /* pipeline the postponed count if possible */
1967 const char *const c_postponed = cs_subset_string(NeoMutt->sub, "postponed");
1968 struct Mailbox *m_postponed = mx_mbox_find2(c_postponed);
1969 struct ImapAccountData *postponed_adata = imap_adata_get(m_postponed);
1970 if (postponed_adata &&
1971 imap_account_match(&postponed_adata->conn->account, &adata->conn->account))
1972 {
1973 imap_mailbox_status(m_postponed, true);
1974 }
1975
1976 const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
1977 if (c_imap_check_subscribed)
1978 imap_exec(adata, "LSUB \"\" \"*\"", IMAP_CMD_QUEUE);
1979
1981
1982 do
1983 {
1984 char *pc = NULL;
1985
1986 rc = imap_cmd_step(adata);
1987 if (rc != IMAP_RES_CONTINUE)
1988 break;
1989
1990 pc = adata->buf + 2;
1991
1992 /* Obtain list of available flags here, may be overridden by a
1993 * PERMANENTFLAGS tag in the OK response */
1994 if (mutt_istr_startswith(pc, "FLAGS"))
1995 {
1996 /* don't override PERMANENTFLAGS */
1997 if (STAILQ_EMPTY(&mdata->flags))
1998 {
1999 mutt_debug(LL_DEBUG3, "Getting mailbox FLAGS\n");
2000 pc = get_flags(&mdata->flags, pc);
2001 if (!pc)
2002 goto fail;
2003 }
2004 }
2005 /* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
2006 else if (mutt_istr_startswith(pc, "OK [PERMANENTFLAGS"))
2007 {
2008 mutt_debug(LL_DEBUG3, "Getting mailbox PERMANENTFLAGS\n");
2009 /* safe to call on NULL */
2010 mutt_list_free(&mdata->flags);
2011 /* skip "OK [PERMANENT" so syntax is the same as FLAGS */
2012 pc += 13;
2013 pc = get_flags(&(mdata->flags), pc);
2014 if (!pc)
2015 goto fail;
2016 }
2017 /* save UIDVALIDITY for the header cache */
2018 else if (mutt_istr_startswith(pc, "OK [UIDVALIDITY"))
2019 {
2020 mutt_debug(LL_DEBUG3, "Getting mailbox UIDVALIDITY\n");
2021 pc += 3;
2022 pc = imap_next_word(pc);
2023 if (!mutt_str_atoui(pc, &mdata->uidvalidity))
2024 goto fail;
2025 }
2026 else if (mutt_istr_startswith(pc, "OK [UIDNEXT"))
2027 {
2028 mutt_debug(LL_DEBUG3, "Getting mailbox UIDNEXT\n");
2029 pc += 3;
2030 pc = imap_next_word(pc);
2031 if (!mutt_str_atoui(pc, &mdata->uid_next))
2032 goto fail;
2033 }
2034 else if (mutt_istr_startswith(pc, "OK [HIGHESTMODSEQ"))
2035 {
2036 mutt_debug(LL_DEBUG3, "Getting mailbox HIGHESTMODSEQ\n");
2037 pc += 3;
2038 pc = imap_next_word(pc);
2039 if (!mutt_str_atoull(pc, &mdata->modseq))
2040 goto fail;
2041 }
2042 else if (mutt_istr_startswith(pc, "OK [NOMODSEQ"))
2043 {
2044 mutt_debug(LL_DEBUG3, "Mailbox has NOMODSEQ set\n");
2045 mdata->modseq = 0;
2046 }
2047 else
2048 {
2049 pc = imap_next_word(pc);
2050 if (mutt_istr_startswith(pc, "EXISTS"))
2051 {
2052 count = mdata->new_mail_count;
2053 mdata->new_mail_count = 0;
2054 }
2055 }
2056 } while (rc == IMAP_RES_CONTINUE);
2057
2058 if (rc == IMAP_RES_NO)
2059 {
2060 char *s = imap_next_word(adata->buf); /* skip seq */
2061 s = imap_next_word(s); /* Skip response */
2062 mutt_error("%s", s);
2063 goto fail;
2064 }
2065
2066 if (rc != IMAP_RES_OK)
2067 goto fail;
2068
2069 /* check for READ-ONLY notification */
2070 if (mutt_istr_startswith(imap_get_qualifier(adata->buf), "[READ-ONLY]") &&
2071 !(adata->capabilities & IMAP_CAP_ACL))
2072 {
2073 mutt_debug(LL_DEBUG2, "Mailbox is read-only\n");
2074 m->readonly = true;
2075 }
2076
2077 /* dump the mailbox flags we've found */
2078 const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
2079 if (c_debug_level > LL_DEBUG2)
2080 {
2081 if (STAILQ_EMPTY(&mdata->flags))
2082 mutt_debug(LL_DEBUG3, "No folder flags found\n");
2083 else
2084 {
2085 struct ListNode *np = NULL;
2086 struct Buffer flag_buffer;
2087 mutt_buffer_init(&flag_buffer);
2088 mutt_buffer_printf(&flag_buffer, "Mailbox flags: ");
2089 STAILQ_FOREACH(np, &mdata->flags, entries)
2090 {
2091 mutt_buffer_add_printf(&flag_buffer, "[%s] ", np->data);
2092 }
2093 mutt_debug(LL_DEBUG3, "%s\n", flag_buffer.data);
2094 FREE(&flag_buffer.data);
2095 }
2096 }
2097
2098 if (!((m->rights & MUTT_ACL_DELETE) || (m->rights & MUTT_ACL_SEEN) ||
2099 (m->rights & MUTT_ACL_WRITE) || (m->rights & MUTT_ACL_INSERT)))
2100 {
2101 m->readonly = true;
2102 }
2103
2104 while (m->email_max < count)
2105 mx_alloc_memory(m);
2106
2107 m->msg_count = 0;
2108 m->msg_unread = 0;
2109 m->msg_flagged = 0;
2110 m->msg_new = 0;
2111 m->msg_deleted = 0;
2112 m->size = 0;
2113 m->vcount = 0;
2114
2115 if (count && (imap_read_headers(m, 1, count, true) < 0))
2116 {
2117 mutt_error(_("Error opening mailbox"));
2118 goto fail;
2119 }
2120
2121 mutt_debug(LL_DEBUG2, "msg_count is %d\n", m->msg_count);
2122 return MX_OPEN_OK;
2123
2124fail:
2125 if (adata->state == IMAP_SELECTED)
2126 adata->state = IMAP_AUTHENTICATED;
2127 return MX_OPEN_ERROR;
2128}
const char * mutt_str_atoull(const char *str, unsigned long long *dst)
Convert ASCII string to an unsigned long long.
Definition: atoi.c:274
const char * mutt_str_atoui(const char *str, unsigned int *dst)
Convert ASCII string to an unsigned integer.
Definition: atoi.c:202
struct Buffer * mutt_buffer_init(struct Buffer *buf)
Initialise a new Buffer.
Definition: buffer.c:52
int mutt_buffer_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:211
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:168
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
#define mutt_message(...)
Definition: logging.h:86
#define mutt_debug(LEVEL,...)
Definition: logging.h:84
struct ImapAccountData * imap_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:89
int imap_cmd_step(struct ImapAccountData *adata)
Reads server responses from an IMAP command.
Definition: command.c:1076
int imap_exec(struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
Execute a command and wait for the response from the server.
Definition: command.c:1247
struct ImapMboxData * imap_mdata_get(struct Mailbox *m)
Get the Mailbox data for this mailbox.
Definition: mdata.c:60
int imap_read_headers(struct Mailbox *m, unsigned int msn_begin, unsigned int msn_end, bool initial_download)
Read headers from the server.
Definition: message.c:1327
@ IMAP_AUTHENTICATED
Connection is authenticated.
Definition: private.h:109
@ IMAP_SELECTED
Mailbox is selected.
Definition: private.h:110
#define IMAP_RES_OK
<tag> OK ...
Definition: private.h:56
#define IMAP_CAP_ACL
RFC2086: IMAP4 ACL extension.
Definition: private.h:126
#define IMAP_RES_NO
<tag> NO ...
Definition: private.h:54
bool imap_account_match(const struct ConnAccount *a1, const struct ConnAccount *a2)
Compare two Accounts.
Definition: util.c:1044
#define IMAP_RES_CONTINUE
* ...
Definition: private.h:57
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition: util.c:789
#define IMAP_CMD_QUEUE
Queue a command, do not execute.
Definition: private.h:75
char * imap_get_qualifier(char *buf)
Get the qualifier from a tagged response.
Definition: util.c:772
int imap_mailbox_status(struct Mailbox *m, bool queue)
Refresh the number of total and new messages.
Definition: imap.c:1273
static char * get_flags(struct ListHead *hflags, char *s)
Make a simple list out of a FLAGS response.
Definition: imap.c:121
static void imap_mbox_select(struct Mailbox *m)
Select a Mailbox.
Definition: imap.c:1815
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:122
@ LL_DEBUG3
Log at debug level 3.
Definition: logging.h:42
@ LL_DEBUG2
Log at debug level 2.
Definition: logging.h:41
#define MUTT_ACL_CREATE
Create a mailbox.
Definition: mailbox.h:62
#define MUTT_ACL_POST
Post (submit messages to the server)
Definition: mailbox.h:68
#define MUTT_ACL_LOOKUP
Lookup mailbox (visible to 'list')
Definition: mailbox.h:67
#define MUTT_ACL_INSERT
Add/copy into the mailbox (used when editing a message)
Definition: mailbox.h:66
#define MUTT_ACL_DELETE
Delete a message.
Definition: mailbox.h:63
#define MUTT_ACL_WRITE
Write to a message (for flagging or linking threads)
Definition: mailbox.h:71
#define MUTT_ACL_SEEN
Change the 'seen' status of a message.
Definition: mailbox.h:70
#define MUTT_ACL_READ
Read the mailbox.
Definition: mailbox.h:69
#define FREE(x)
Definition: memory.h:43
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:239
#define PATH_MAX
Definition: mutt.h:40
struct Mailbox * mx_mbox_find2(const char *path)
Find a Mailbox on an Account.
Definition: mx.c:1649
void mx_alloc_memory(struct Mailbox *m)
Create storage for the emails.
Definition: mx.c:1219
@ MX_OPEN_OK
Open succeeded.
Definition: mxapi.h:98
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_EMPTY(head)
Definition: queue.h:348
void * adata
Private data (for Mailbox backends)
Definition: account.h:43
String manipulation buffer.
Definition: buffer.h:34
char * data
Pointer to data.
Definition: buffer.h:35
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:50
IMAP-specific Account data -.
Definition: adata.h:40
struct Mailbox * prev_mailbox
Previously selected mailbox.
Definition: adata.h:77
ImapCapFlags capabilities
Capability flags.
Definition: adata.h:55
unsigned char state
ImapState, e.g. IMAP_AUTHENTICATED.
Definition: adata.h:44
struct Mailbox * mailbox
Current selected mailbox.
Definition: adata.h:76
unsigned char status
ImapFlags, e.g. IMAP_FATAL.
Definition: adata.h:45
struct Connection * conn
Connection to IMAP server.
Definition: adata.h:41
IMAP-specific Mailbox data -.
Definition: mdata.h:39
unsigned int uid_next
Definition: mdata.h:51
struct ListHead flags
Definition: mdata.h:49
unsigned int new_mail_count
Set when EXISTS notifies of new mail.
Definition: mdata.h:46
unsigned long long modseq
Definition: mdata.h:52
uint32_t uidvalidity
Definition: mdata.h:50
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
A mailbox.
Definition: mailbox.h:79
int vcount
The number of virtual messages.
Definition: mailbox.h:99
int msg_new
Number of new messages.
Definition: mailbox.h:92
int msg_count
Total number of messages.
Definition: mailbox.h:88
AclFlags rights
ACL bits, see AclFlags.
Definition: mailbox.h:117
int email_max
Number of pointers in emails.
Definition: mailbox.h:97
void * mdata
Driver specific data.
Definition: mailbox.h:132
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
off_t size
Size of the Mailbox.
Definition: mailbox.h:84
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
bool verbose
Display status messages?
Definition: mailbox.h:114
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:

◆ maildir_mbox_open()

static enum MxOpenReturns maildir_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 1093 of file maildir.c.

1094{
1095 /* maildir looks sort of like MH, except that there are two subdirectories
1096 * of the main folder path from which to read messages */
1097 if ((maildir_read_dir(m, "new") == -1) || (maildir_read_dir(m, "cur") == -1))
1098 return MX_OPEN_ERROR;
1099
1100 return MX_OPEN_OK;
1101}
int maildir_read_dir(struct Mailbox *m, const char *subdir)
Read a Maildir style mailbox.
Definition: maildir.c:670
+ Here is the call graph for this function:

◆ mh_mbox_open()

static enum MxOpenReturns mh_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 849 of file mh.c.

850{
852}
static bool mh_read_dir(struct Mailbox *m)
Read an MH mailbox.
Definition: mh.c:692
+ Here is the call graph for this function:

◆ mbox_mbox_open()

static enum MxOpenReturns mbox_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 925 of file mbox.c.

926{
927 if (init_mailbox(m) != 0)
928 return MX_OPEN_ERROR;
929
931 if (!adata)
932 return MX_OPEN_ERROR;
933
934 adata->fp = m->readonly ? NULL : mbox_open_readwrite(m);
935 if (!adata->fp)
936 {
937 adata->fp = mbox_open_readonly(m);
938 }
939 if (!adata->fp)
940 {
942 return MX_OPEN_ERROR;
943 }
944
946 if (mbox_lock_mailbox(m, false, true) == -1)
947 {
949 return MX_OPEN_ERROR;
950 }
951
952 m->has_new = true;
954 if (m->type == MUTT_MBOX)
955 rc = mbox_parse_mailbox(m);
956 else if (m->type == MUTT_MMDF)
957 rc = mmdf_parse_mailbox(m);
958 else
959 rc = MX_OPEN_ERROR;
960
961 if (!mbox_has_new(m))
962 m->has_new = false;
963 clearerr(adata->fp); // Clear the EOF flag
964 mutt_file_touch_atime(fileno(adata->fp));
965
968 return rc;
969}
void mutt_file_touch_atime(int fd)
Set the access time to current time.
Definition: file.c:1082
#define mutt_perror(...)
Definition: logging.h:88
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
static enum MxOpenReturns mbox_parse_mailbox(struct Mailbox *m)
Read a mailbox from disk.
Definition: mbox.c:343
static bool mbox_has_new(struct Mailbox *m)
Does the mailbox have new mail.
Definition: mbox.c:709
static int mbox_lock_mailbox(struct Mailbox *m, bool excl, bool retry)
Lock a mailbox.
Definition: mbox.c:134
static struct MboxAccountData * mbox_adata_get(struct Mailbox *m)
Get the private data associated with a Mailbox.
Definition: mbox.c:119
static int init_mailbox(struct Mailbox *m)
Add Mbox data to the Mailbox.
Definition: mbox.c:100
static FILE * mbox_open_readwrite(struct Mailbox *m)
Open an mbox read-write.
Definition: mbox.c:899
static FILE * mbox_open_readonly(struct Mailbox *m)
Open an mbox read-only.
Definition: mbox.c:914
static void mbox_unlock_mailbox(struct Mailbox *m)
Unlock a mailbox.
Definition: mbox.c:156
static enum MxOpenReturns mmdf_parse_mailbox(struct Mailbox *m)
Read a mailbox in MMDF format.
Definition: mbox.c:176
MxOpenReturns
Return values for mbox_open()
Definition: mxapi.h:97
void mutt_sig_block(void)
Block signals during critical operations.
Definition: signal.c:150
void mutt_sig_unblock(void)
Restore previously blocked signals.
Definition: signal.c:168
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
Mbox-specific Account data -.
Definition: lib.h:49
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ nntp_mbox_open()

static enum MxOpenReturns nntp_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 2298 of file nntp.c.

2299{
2300 if (!m->account)
2301 return MX_OPEN_ERROR;
2302
2303 char buf[8192] = { 0 };
2304 char server[1024] = { 0 };
2305 char *group = NULL;
2306 int rc;
2307 void *hc = NULL;
2308 anum_t first, last, count = 0;
2309
2310 struct Url *url = url_parse(mailbox_path(m));
2311 if (!url || !url->host || !url->path ||
2312 !((url->scheme == U_NNTP) || (url->scheme == U_NNTPS)))
2313 {
2314 url_free(&url);
2315 mutt_error(_("%s is an invalid newsgroup specification"), mailbox_path(m));
2316 return MX_OPEN_ERROR;
2317 }
2318
2319 group = url->path;
2320 if (group[0] == '/') /* Skip a leading '/' */
2321 group++;
2322
2323 url->path = strchr(url->path, '\0');
2324 url_tostring(url, server, sizeof(server), U_NO_FLAGS);
2325
2327 struct NntpAccountData *adata = m->account->adata;
2328 if (!adata)
2329 {
2330 adata = nntp_select_server(m, server, true);
2331 m->account->adata = adata;
2333 }
2334
2335 if (!adata)
2336 {
2337 url_free(&url);
2338 return MX_OPEN_ERROR;
2339 }
2341
2342 m->msg_count = 0;
2343 m->msg_unread = 0;
2344 m->vcount = 0;
2345
2346 if (group[0] == '/')
2347 group++;
2348
2349 /* find news group data structure */
2351 if (!mdata)
2352 {
2354 mutt_error(_("Newsgroup %s not found on the server"), group);
2355 url_free(&url);
2356 return MX_OPEN_ERROR;
2357 }
2358
2359 m->rights &= ~MUTT_ACL_INSERT; // Clear the flag
2360 const bool c_save_unsubscribed = cs_subset_bool(NeoMutt->sub, "save_unsubscribed");
2361 if (!mdata->newsrc_ent && !mdata->subscribed && !c_save_unsubscribed)
2362 m->readonly = true;
2363
2364 /* select newsgroup */
2365 mutt_message(_("Selecting %s..."), group);
2366 url_free(&url);
2367 buf[0] = '\0';
2368 if (nntp_query(mdata, buf, sizeof(buf)) < 0)
2369 {
2371 return MX_OPEN_ERROR;
2372 }
2373
2374 /* newsgroup not found, remove it */
2375 if (mutt_str_startswith(buf, "411"))
2376 {
2377 mutt_error(_("Newsgroup %s has been removed from the server"), mdata->group);
2378 if (!mdata->deleted)
2379 {
2380 mdata->deleted = true;
2382 }
2383 if (mdata->newsrc_ent && !mdata->subscribed && !c_save_unsubscribed)
2384 {
2385 FREE(&mdata->newsrc_ent);
2386 mdata->newsrc_len = 0;
2389 }
2390 }
2391
2392 /* parse newsgroup info */
2393 else
2394 {
2395 if (sscanf(buf, "211 " ANUM " " ANUM " " ANUM, &count, &first, &last) != 3)
2396 {
2398 mutt_error("GROUP: %s", buf);
2399 return MX_OPEN_ERROR;
2400 }
2401 mdata->first_message = first;
2402 mdata->last_message = last;
2403 mdata->deleted = false;
2404
2405 /* get description if empty */
2406 const bool c_nntp_load_description = cs_subset_bool(NeoMutt->sub, "nntp_load_description");
2407 if (c_nntp_load_description && !mdata->desc)
2408 {
2409 if (get_description(mdata, NULL, NULL) < 0)
2410 {
2412 return MX_OPEN_ERROR;
2413 }
2414 if (mdata->desc)
2416 }
2417 }
2418
2420 m->mdata = mdata;
2421 // Every known newsgroup has an mdata which is stored in adata->groups_list.
2422 // Currently we don't let the Mailbox free the mdata.
2423 // m->mdata_free = nntp_mdata_free;
2424 if (!mdata->bcache && (mdata->newsrc_ent || mdata->subscribed || c_save_unsubscribed))
2425 mdata->bcache = mutt_bcache_open(&adata->conn->account, mdata->group);
2426
2427 /* strip off extra articles if adding context is greater than $nntp_context */
2428 first = mdata->first_message;
2429 const long c_nntp_context = cs_subset_long(NeoMutt->sub, "nntp_context");
2430 if (c_nntp_context && (mdata->last_message - first + 1 > c_nntp_context))
2431 first = mdata->last_message - c_nntp_context + 1;
2432 mdata->last_loaded = first ? first - 1 : 0;
2433 count = mdata->first_message;
2434 mdata->first_message = first;
2436 mdata->first_message = count;
2437#ifdef USE_HCACHE
2438 hc = nntp_hcache_open(mdata);
2440#endif
2441 if (!hc)
2442 m->rights &= ~(MUTT_ACL_WRITE | MUTT_ACL_DELETE); // Clear the flags
2443
2445 rc = nntp_fetch_headers(m, hc, first, mdata->last_message, false);
2446#ifdef USE_HCACHE
2448#endif
2449 if (rc < 0)
2450 return MX_OPEN_ERROR;
2451 mdata->last_loaded = mdata->last_message;
2452 adata->newsrc_modified = false;
2453 return MX_OPEN_OK;
2454}
struct BodyCache * mutt_bcache_open(struct ConnAccount *account, const char *mailbox)
Open an Email-Body Cache.
Definition: bcache.c:144
long cs_subset_long(const struct ConfigSubset *sub, const char *name)
Get a long config item by name.
Definition: helpers.c:121
time_t mutt_date_epoch(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:428
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:362
void mutt_hcache_close(struct HeaderCache *hc)
Multiplexor for StoreOps::close.
Definition: hcache.c:432
void mutt_account_hook(const char *url)
Perform an account hook.
Definition: hook.c:843
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:227
struct HeaderCache * nntp_hcache_open(struct NntpMboxData *mdata)
Open newsgroup hcache.
Definition: newsrc.c:711
void nntp_delete_group_cache(struct NntpMboxData *mdata)
Remove hcache and bcache of newsgroup.
Definition: newsrc.c:813
void nntp_hcache_update(struct NntpMboxData *mdata, struct HeaderCache *hc)
Remove stale cached headers.
Definition: newsrc.c:735
int nntp_active_save_cache(struct NntpAccountData *adata)
Save list of all newsgroups to cache.
Definition: newsrc.c:652
void nntp_bcache_update(struct NntpMboxData *mdata)
Remove stale cached messages.
Definition: newsrc.c:804
void nntp_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free()
Definition: adata.c:43
void nntp_newsrc_close(struct NntpAccountData *adata)
Unlock and close .newsrc file.
Definition: newsrc.c:118
int nntp_newsrc_update(struct NntpAccountData *adata)
Update .newsrc file.
Definition: newsrc.c:442
struct NntpAccountData * nntp_select_server(struct Mailbox *m, const char *server, bool leave_lock)
Open a connection to an NNTP server.
Definition: newsrc.c:1019
#define ANUM
Definition: lib.h:61
#define anum_t
Definition: lib.h:60
static int nntp_query(struct NntpMboxData *mdata, char *line, size_t linelen)
Send data from buffer and receive answer to same buffer.
Definition: nntp.c:686
static int get_description(struct NntpMboxData *mdata, const char *wildmat, const char *msg)
Fetch newsgroups descriptions.
Definition: nntp.c:879
struct NntpAccountData * CurrentNewsSrv
Current NNTP news server.
Definition: nntp.c:77
static int nntp_fetch_headers(struct Mailbox *m, void *hc, anum_t first, anum_t last, bool restore)
Fetch headers.
Definition: nntp.c:1149
void(* adata_free)(void **ptr)
Free the private data attached to the Account.
Definition: account.h:53
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
NNTP-specific Account data -.
Definition: adata.h:37
bool newsrc_modified
Definition: adata.h:50
struct HashTable * groups_hash
Definition: adata.h:62
struct Connection * conn
Connection to NNTP Server.
Definition: adata.h:63
time_t check_time
Definition: adata.h:58
NNTP-specific Mailbox data -.
Definition: mdata.h:33
char * group
Name of newsgroup.
Definition: mdata.h:34
struct NntpAccountData * adata
Definition: mdata.h:47
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * host
Host.
Definition: url.h:73
char * path
Path.
Definition: url.h:75
enum UrlScheme scheme
Scheme, e.g. U_SMTPS.
Definition: url.h:70
struct Url * url_parse(const char *src)
Fill in Url.
Definition: url.c:234
int url_tostring(struct Url *url, char *dest, size_t len, uint8_t flags)
Output the URL string for a given Url object.
Definition: url.c:418
void url_free(struct Url **ptr)
Free the contents of a URL.
Definition: url.c:123
#define U_NO_FLAGS
Definition: url.h:49
@ U_NNTPS
Url is nntps://.
Definition: url.h:42
@ U_NNTP
Url is nntp://.
Definition: url.h:41
+ Here is the call graph for this function:

◆ nm_mbox_open()

static enum MxOpenReturns nm_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Definition at line 2018 of file notmuch.c.

2019{
2020 if (init_mailbox(m) != 0)
2021 return MX_OPEN_ERROR;
2022
2023 struct NmMboxData *mdata = nm_mdata_get(m);
2024 if (!mdata)
2025 return MX_OPEN_ERROR;
2026
2027 mutt_debug(LL_DEBUG1, "nm: reading messages...[current count=%d]\n", m->msg_count);
2028
2029 progress_setup(m);
2030 enum MxOpenReturns rc = MX_OPEN_ERROR;
2031
2032 notmuch_query_t *q = get_query(m, false);
2033 if (q)
2034 {
2035 rc = MX_OPEN_OK;
2036 switch (mdata->query_type)
2037 {
2038 case NM_QUERY_TYPE_UNKNOWN: // UNKNOWN should never occur, but MESGS is default
2040 if (!read_mesgs_query(m, q, false))
2041 rc = MX_OPEN_ABORT;
2042 break;
2044 if (!read_threads_query(m, q, false, get_limit(mdata)))
2045 rc = MX_OPEN_ABORT;
2046 break;
2047 }
2048 notmuch_query_destroy(q);
2049 }
2050
2051 nm_db_release(m);
2052
2054 m->mtime.tv_nsec = 0;
2055
2056 mdata->oldmsgcount = 0;
2057
2058 mutt_debug(LL_DEBUG1, "nm: reading messages... done [rc=%d, count=%d]\n", rc, m->msg_count);
2059 progress_free(&mdata->progress);
2060 return rc;
2061}
@ LL_DEBUG1
Log at debug level 1.
Definition: logging.h:40
@ MX_OPEN_ABORT
Open was aborted.
Definition: mxapi.h:100
int nm_db_release(struct Mailbox *m)
Close the Notmuch database.
Definition: db.c:222
struct NmMboxData * nm_mdata_get(struct Mailbox *m)
Get the Notmuch Mailbox data.
Definition: mdata.c:97
static int init_mailbox(struct Mailbox *m)
Add Notmuch data to the Mailbox.
Definition: notmuch.c:186
static int get_limit(struct NmMboxData *mdata)
Get the database limit.
Definition: notmuch.c:396
static bool read_threads_query(struct Mailbox *m, notmuch_query_t *q, bool dedup, int limit)
Perform a query with threads.
Definition: notmuch.c:995
static notmuch_query_t * get_query(struct Mailbox *m, bool writable)
Create a new query.
Definition: notmuch.c:431
static bool read_mesgs_query(struct Mailbox *m, notmuch_query_t *q, bool dedup)
Search for matching messages.
Definition: notmuch.c:925
static void progress_setup(struct Mailbox *m)
Set up the Progress Bar.
Definition: notmuch.c:663
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:86
@ NM_QUERY_TYPE_UNKNOWN
Unknown query type. Error in notmuch query.
Definition: query.h:38
@ NM_QUERY_TYPE_THREADS
Whole threads.
Definition: query.h:37
@ NM_QUERY_TYPE_MESGS
Default: Messages only.
Definition: query.h:36
struct timespec mtime
Time Mailbox was last changed.
Definition: mailbox.h:104
Notmuch-specific Mailbox data -.
Definition: mdata.h:34
long tv_nsec
Number of nanosecond, on top.
Definition: file.h:51
time_t tv_sec
Number of seconds since the epoch.
Definition: file.h:50
+ Here is the call graph for this function:

◆ pop_mbox_open()

static enum MxOpenReturns pop_mbox_open ( struct Mailbox m)
static

Open a Mailbox - Implements MxOps::mbox_open() -.

Fetch only headers

Definition at line 742 of file pop.c.

743{
744 if (!m->account)
745 return MX_OPEN_ERROR;
746
747 char buf[PATH_MAX] = { 0 };
748 struct ConnAccount cac = { { 0 } };
749 struct Url url = { 0 };
750
751 if (pop_parse_path(mailbox_path(m), &cac))
752 {
753 mutt_error(_("%s is an invalid POP path"), mailbox_path(m));
754 return MX_OPEN_ERROR;
755 }
756
757 mutt_account_tourl(&cac, &url);
758 url.path = NULL;
759 url_tostring(&url, buf, sizeof(buf), U_NO_FLAGS);
760
761 mutt_buffer_strcpy(&m->pathbuf, buf);
763
764 struct PopAccountData *adata = m->account->adata;
765 if (!adata)
766 {
768 m->account->adata = adata;
770 }
771
772 struct Connection *conn = adata->conn;
773 if (!conn)
774 {
775 adata->conn = mutt_conn_new(&cac);
776 conn = adata->conn;
777 if (!conn)
778 return MX_OPEN_ERROR;
779 }
780
781 if (conn->fd < 0)
783
784 if (pop_open_connection(adata) < 0)
785 return MX_OPEN_ERROR;
786
787 adata->bcache = mutt_bcache_open(&cac, NULL);
788
789 /* init (hard-coded) ACL rights */
791#ifdef USE_HCACHE
792 /* flags are managed using header cache, so it only makes sense to
793 * enable them in that case */
795#endif
796
797 while (true)
798 {
799 if (pop_reconnect(m) < 0)
800 return MX_OPEN_ERROR;
801
802 m->size = adata->size;
803
804 mutt_message(_("Fetching list of messages..."));
805
806 const int rc = pop_fetch_headers(m);
807
808 if (rc >= 0)
809 return MX_OPEN_OK;
810
811 if (rc < -1)
812 return MX_OPEN_ERROR;
813 }
814}
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:327
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:326
void mutt_account_tourl(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition: mutt_account.c:79
struct Connection * mutt_conn_new(const struct ConnAccount *cac)
Create a new Connection.
Definition: mutt_socket.c:48
struct PopAccountData * pop_adata_new(void)
Create a new PopAccountData object.
Definition: adata.c:54
void pop_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free()
Definition: adata.c:40
int pop_open_connection(struct PopAccountData *adata)
Open connection and authenticate.
Definition: lib.c:308
int pop_parse_path(const char *path, struct ConnAccount *cac)
Parse a POP mailbox name.
Definition: lib.c:82
int pop_reconnect(struct Mailbox *m)
Reconnect and verify indexes if connection was lost.
Definition: lib.c:599
static int pop_fetch_headers(struct Mailbox *m)
Read headers.
Definition: pop.c:321
Login details for a remote server.
Definition: connaccount.h:53
int fd
Socket file descriptor.
Definition: connection.h:54
POP-specific Account data -.
Definition: adata.h:37
size_t size
Definition: adata.h:50
struct Connection * conn
Connection to POP server.
Definition: adata.h:38
struct BodyCache * bcache
body cache
Definition: adata.h:55
+ Here is the call graph for this function: