NeoMutt  2025-09-05-7-geaa2bd
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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() -.
 
static enum MxOpenReturns imap_mbox_open (struct Mailbox *m)
 Open a mailbox - Implements MxOps::mbox_open() -.
 
enum MxOpenReturns maildir_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 
static enum MxOpenReturns mbox_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 
static enum MxOpenReturns mh_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 
static enum MxOpenReturns nntp_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 
static enum MxOpenReturns nm_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 
static enum MxOpenReturns pop_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 

Detailed Description

Open a Mailbox.

Parameters
mMailbox to open
Return values
enumMxOpenReturns
Precondition
m is not NULL

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 413 of file compress.c.

414{
415 struct CompressInfo *ci = set_compress_info(m);
416 if (!ci)
417 return MX_OPEN_ERROR;
418
419 /* If there's no close-hook, or the file isn't writable */
420 if (!ci->cmd_close || (access(mailbox_path(m), W_OK) != 0))
421 m->readonly = true;
422
423 if (setup_paths(m) != 0)
424 goto cmo_fail;
425 store_size(m);
426
427 if (!lock_realpath(m, false))
428 {
429 mutt_error(_("Unable to lock mailbox"));
430 goto cmo_fail;
431 }
432
433 if (!execute_command(m, ci->cmd_open, _("Decompressing %s")))
434 goto cmo_fail;
435
437
439 if (m->type == MUTT_UNKNOWN)
440 {
441 mutt_error(_("Can't identify the contents of the compressed file"));
442 goto cmo_fail;
443 }
444
445 ci->child_ops = mx_get_ops(m->type);
446 if (!ci->child_ops)
447 {
448 mutt_error(_("Can't find mailbox ops for mailbox type %d"), m->type);
449 goto cmo_fail;
450 }
451
452 m->account->type = m->type;
453 return ci->child_ops->mbox_open(m);
454
455cmo_fail:
456 /* remove the partial uncompressed file */
457 (void) remove(mailbox_path(m));
459 return MX_OPEN_ERROR;
460}
static struct CompressInfo * set_compress_info(struct Mailbox *m)
Find the compress hooks for a mailbox.
Definition: compress.c:233
static void compress_info_free(struct Mailbox *m)
Frees the compress info members and structure.
Definition: compress.c:263
static int setup_paths(struct Mailbox *m)
Set the mailbox paths.
Definition: compress.c:173
static void store_size(const struct Mailbox *m)
Save the size of the compressed file.
Definition: compress.c:196
static bool lock_realpath(struct Mailbox *m, bool excl)
Try to lock the Mailbox.realpath.
Definition: compress.c:106
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:147
static bool execute_command(struct Mailbox *m, const struct Expando *exp, const char *progress)
Run a system command.
Definition: compress.c:289
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
#define mutt_error(...)
Definition: logging2.h:93
#define _(a)
Definition: message.h:28
const struct MxOps * mx_get_ops(enum MailboxType type)
Get mailbox operations.
Definition: mx.c:127
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1326
@ MX_OPEN_ERROR
Open failed with an error.
Definition: mxapi.h:75
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:37
Private data for compress.
Definition: lib.h:60
struct Expando * cmd_open
open-hook command
Definition: lib.h:63
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:65
struct Expando * cmd_close
close-hook command
Definition: lib.h:62
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:116
enum MxOpenReturns(* mbox_open)(struct Mailbox *m)
Definition: mxapi.h:133
+ 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 1871 of file imap.c.

1872{
1873 if (!m->account || !m->mdata)
1874 return MX_OPEN_ERROR;
1875
1876 char buf[PATH_MAX] = { 0 };
1877 int count = 0;
1878 int rc;
1879
1881 struct ImapMboxData *mdata = imap_mdata_get(m);
1882
1883 mutt_debug(LL_DEBUG3, "opening %s, saving %s\n", m->pathbuf.data,
1884 (adata->mailbox ? adata->mailbox->pathbuf.data : "(none)"));
1885 adata->prev_mailbox = adata->mailbox;
1886 adata->mailbox = m;
1887
1888 /* clear mailbox status */
1889 adata->status = 0;
1890 m->rights = 0;
1891 mdata->new_mail_count = 0;
1892
1893 if (m->verbose)
1894 mutt_message(_("Selecting %s..."), mdata->name);
1895
1896 /* pipeline ACL test */
1897 if (adata->capabilities & IMAP_CAP_ACL)
1898 {
1899 snprintf(buf, sizeof(buf), "MYRIGHTS %s", mdata->munge_name);
1900 imap_exec(adata, buf, IMAP_CMD_QUEUE);
1901 }
1902 else
1903 {
1904 /* assume we have all rights if ACL is unavailable */
1907 }
1908
1909 /* pipeline the postponed count if possible */
1910 const char *const c_postponed = cs_subset_string(NeoMutt->sub, "postponed");
1911 struct Mailbox *m_postponed = mx_mbox_find2(c_postponed);
1912 struct ImapAccountData *postponed_adata = imap_adata_get(m_postponed);
1913 if (postponed_adata &&
1914 imap_account_match(&postponed_adata->conn->account, &adata->conn->account))
1915 {
1916 imap_mailbox_status(m_postponed, true);
1917 }
1918
1919 const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
1920 if (c_imap_check_subscribed)
1921 imap_exec(adata, "LSUB \"\" \"*\"", IMAP_CMD_QUEUE);
1922
1924
1925 do
1926 {
1927 char *pc = NULL;
1928
1929 rc = imap_cmd_step(adata);
1930 if (rc != IMAP_RES_CONTINUE)
1931 break;
1932
1933 if (!mutt_strn_equal(adata->buf, "* ", 2))
1934 continue;
1935 pc = imap_next_word(adata->buf);
1936
1937 /* Obtain list of available flags here, may be overridden by a
1938 * PERMANENTFLAGS tag in the OK response */
1939 if (mutt_istr_startswith(pc, "FLAGS"))
1940 {
1941 /* don't override PERMANENTFLAGS */
1942 if (STAILQ_EMPTY(&mdata->flags))
1943 {
1944 mutt_debug(LL_DEBUG3, "Getting mailbox FLAGS\n");
1945 pc = get_flags(&mdata->flags, pc);
1946 if (!pc)
1947 goto fail;
1948 }
1949 }
1950 else if (mutt_istr_startswith(pc, "OK [PERMANENTFLAGS"))
1951 {
1952 /* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
1953 mutt_debug(LL_DEBUG3, "Getting mailbox PERMANENTFLAGS\n");
1954 /* safe to call on NULL */
1955 mutt_list_free(&mdata->flags);
1956 /* skip "OK [PERMANENT" so syntax is the same as FLAGS */
1957 pc += 13;
1958 pc = get_flags(&(mdata->flags), pc);
1959 if (!pc)
1960 goto fail;
1961 }
1962 else if (mutt_istr_startswith(pc, "OK [UIDVALIDITY"))
1963 {
1964 /* save UIDVALIDITY for the header cache */
1965 mutt_debug(LL_DEBUG3, "Getting mailbox UIDVALIDITY\n");
1966 pc += 3;
1967 pc = imap_next_word(pc);
1968 if (!mutt_str_atoui(pc, &mdata->uidvalidity))
1969 goto fail;
1970 }
1971 else if (mutt_istr_startswith(pc, "OK [UIDNEXT"))
1972 {
1973 mutt_debug(LL_DEBUG3, "Getting mailbox UIDNEXT\n");
1974 pc += 3;
1975 pc = imap_next_word(pc);
1976 if (!mutt_str_atoui(pc, &mdata->uid_next))
1977 goto fail;
1978 }
1979 else if (mutt_istr_startswith(pc, "OK [HIGHESTMODSEQ"))
1980 {
1981 mutt_debug(LL_DEBUG3, "Getting mailbox HIGHESTMODSEQ\n");
1982 pc += 3;
1983 pc = imap_next_word(pc);
1984 if (!mutt_str_atoull(pc, &mdata->modseq))
1985 goto fail;
1986 }
1987 else if (mutt_istr_startswith(pc, "OK [NOMODSEQ"))
1988 {
1989 mutt_debug(LL_DEBUG3, "Mailbox has NOMODSEQ set\n");
1990 mdata->modseq = 0;
1991 }
1992 else
1993 {
1994 pc = imap_next_word(pc);
1995 if (mutt_istr_startswith(pc, "EXISTS"))
1996 {
1997 count = mdata->new_mail_count;
1998 mdata->new_mail_count = 0;
1999 }
2000 }
2001 } while (rc == IMAP_RES_CONTINUE);
2002
2003 if (rc == IMAP_RES_NO)
2004 {
2005 char *s = imap_next_word(adata->buf); /* skip seq */
2006 s = imap_next_word(s); /* Skip response */
2007 mutt_error("%s", s);
2008 goto fail;
2009 }
2010
2011 if (rc != IMAP_RES_OK)
2012 goto fail;
2013
2014 /* check for READ-ONLY notification */
2015 if (mutt_istr_startswith(imap_get_qualifier(adata->buf), "[READ-ONLY]") &&
2016 !(adata->capabilities & IMAP_CAP_ACL))
2017 {
2018 mutt_debug(LL_DEBUG2, "Mailbox is read-only\n");
2019 m->readonly = true;
2020 }
2021
2022 /* dump the mailbox flags we've found */
2023 const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
2024 if (c_debug_level > LL_DEBUG2)
2025 {
2026 if (STAILQ_EMPTY(&mdata->flags))
2027 {
2028 mutt_debug(LL_DEBUG3, "No folder flags found\n");
2029 }
2030 else
2031 {
2032 struct ListNode *np = NULL;
2033 struct Buffer *flag_buffer = buf_pool_get();
2034 buf_printf(flag_buffer, "Mailbox flags: ");
2035 STAILQ_FOREACH(np, &mdata->flags, entries)
2036 {
2037 buf_add_printf(flag_buffer, "[%s] ", np->data);
2038 }
2039 mutt_debug(LL_DEBUG3, "%s\n", buf_string(flag_buffer));
2040 buf_pool_release(&flag_buffer);
2041 }
2042 }
2043
2044 if (!((m->rights & MUTT_ACL_DELETE) || (m->rights & MUTT_ACL_SEEN) ||
2045 (m->rights & MUTT_ACL_WRITE) || (m->rights & MUTT_ACL_INSERT)))
2046 {
2047 m->readonly = true;
2048 }
2049
2050 mx_alloc_memory(m, count);
2051
2052 m->msg_count = 0;
2053 m->msg_unread = 0;
2054 m->msg_flagged = 0;
2055 m->msg_new = 0;
2056 m->msg_deleted = 0;
2057 m->size = 0;
2058 m->vcount = 0;
2059
2060 if ((count > 0) && (imap_read_headers(m, 1, count, true) < 0))
2061 {
2062 mutt_error(_("Error opening mailbox"));
2063 goto fail;
2064 }
2065
2066 mutt_debug(LL_DEBUG2, "msg_count is %d\n", m->msg_count);
2067 return MX_OPEN_OK;
2068
2069fail:
2070 if (adata->state == IMAP_SELECTED)
2071 adata->state = IMAP_AUTHENTICATED;
2072 return MX_OPEN_ERROR;
2073}
const char * mutt_str_atoull(const char *str, unsigned long long *dst)
Convert ASCII string to an unsigned long long.
Definition: atoi.c:296
const char * mutt_str_atoui(const char *str, unsigned int *dst)
Convert ASCII string to an unsigned integer.
Definition: atoi.c:218
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:204
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:143
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
#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 mutt_message(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:90
struct ImapAccountData * imap_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:123
int imap_cmd_step(struct ImapAccountData *adata)
Reads server responses from an IMAP command.
Definition: command.c:1127
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:1302
struct ImapMboxData * imap_mdata_get(struct Mailbox *m)
Get the Mailbox data for this mailbox.
Definition: mdata.c:61
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:1339
@ IMAP_AUTHENTICATED
Connection is authenticated.
Definition: private.h:107
@ IMAP_SELECTED
Mailbox is selected.
Definition: private.h:108
#define IMAP_RES_OK
<tag> OK ...
Definition: private.h:55
#define IMAP_CAP_ACL
RFC2086: IMAP4 ACL extension.
Definition: private.h:124
#define IMAP_RES_NO
<tag> NO ...
Definition: private.h:53
bool imap_account_match(const struct ConnAccount *a1, const struct ConnAccount *a2)
Compare two Accounts.
Definition: util.c:1092
#define IMAP_RES_CONTINUE
* ...
Definition: private.h:56
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition: util.c:823
#define IMAP_CMD_QUEUE
Queue a command, do not execute.
Definition: private.h:73
char * imap_get_qualifier(char *buf)
Get the qualifier from a tagged response.
Definition: util.c:806
int imap_mailbox_status(struct Mailbox *m, bool queue)
Refresh the number of total and new messages.
Definition: imap.c:1209
static char * get_flags(struct ListHead *hflags, char *s)
Make a simple list out of a FLAGS response.
Definition: imap.c:132
static void imap_mbox_select(struct Mailbox *m)
Select a Mailbox.
Definition: imap.c:1748
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:46
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:45
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition: string.c:426
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:243
#define PATH_MAX
Definition: mutt.h:42
void mx_alloc_memory(struct Mailbox *m, int req_size)
Create storage for the emails.
Definition: mx.c:1211
struct Mailbox * mx_mbox_find2(const char *path)
Find a Mailbox on an Account.
Definition: mx.c:1610
@ MX_OPEN_OK
Open succeeded.
Definition: mxapi.h:74
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:82
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:390
#define STAILQ_EMPTY(head)
Definition: queue.h:382
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
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:40
unsigned int uid_next
Definition: mdata.h:52
struct ListHead flags
Definition: mdata.h:50
unsigned int new_mail_count
Set when EXISTS notifies of new mail.
Definition: mdata.h:47
unsigned long long modseq
Definition: mdata.h:53
uint32_t uidvalidity
Definition: mdata.h:51
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
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:119
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:117
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
Container for Accounts, Notifications.
Definition: neomutt.h:43
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:47
+ Here is the call graph for this function:

◆ maildir_mbox_open()

enum MxOpenReturns maildir_mbox_open ( struct Mailbox m)

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

Definition at line 740 of file mailbox.c.

741{
742 if ((maildir_read_dir(m, "new") == -1) || (maildir_read_dir(m, "cur") == -1))
743 return MX_OPEN_ERROR;
744
745 return MX_OPEN_OK;
746}
static int maildir_read_dir(struct Mailbox *m, const char *subdir)
Read a Maildir style mailbox.
Definition: mailbox.c:485
+ 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 828 of file mbox.c.

829{
830 if (init_mailbox(m) != 0)
831 return MX_OPEN_ERROR;
832
834 if (!adata)
835 return MX_OPEN_ERROR;
836
837 adata->fp = m->readonly ? NULL : mbox_open_readwrite(m);
838 if (!adata->fp)
839 {
840 adata->fp = mbox_open_readonly(m);
841 }
842 if (!adata->fp)
843 {
844 mutt_perror("%s", mailbox_path(m));
845 return MX_OPEN_ERROR;
846 }
847
849 if (mbox_lock_mailbox(m, false, true) == -1)
850 {
852 return MX_OPEN_ERROR;
853 }
854
855 m->has_new = true;
857 if (m->type == MUTT_MBOX)
858 rc = mbox_parse_mailbox(m);
859 else if (m->type == MUTT_MMDF)
860 rc = mmdf_parse_mailbox(m);
861 else
862 rc = MX_OPEN_ERROR;
863
864 if (!mbox_has_new(m))
865 m->has_new = false;
866 clearerr(adata->fp); // Clear the EOF flag
867 mutt_file_touch_atime(fileno(adata->fp));
868
871 return rc;
872}
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
void mutt_file_touch_atime(int fd)
Set the access time to current time.
Definition: file.c:968
#define mutt_perror(...)
Definition: logging2.h:94
static enum MxOpenReturns mbox_parse_mailbox(struct Mailbox *m)
Read a mailbox from disk.
Definition: mbox.c:351
static bool mbox_has_new(struct Mailbox *m)
Does the mailbox have new mail.
Definition: mbox.c:726
static int mbox_lock_mailbox(struct Mailbox *m, bool excl, bool retry)
Lock a mailbox.
Definition: mbox.c:139
static struct MboxAccountData * mbox_adata_get(struct Mailbox *m)
Get the private data associated with a Mailbox.
Definition: mbox.c:124
static int init_mailbox(struct Mailbox *m)
Add Mbox data to the Mailbox.
Definition: mbox.c:105
static FILE * mbox_open_readwrite(struct Mailbox *m)
Open an mbox read-write.
Definition: mbox.c:802
static FILE * mbox_open_readonly(struct Mailbox *m)
Open an mbox read-only.
Definition: mbox.c:817
static void mbox_unlock_mailbox(struct Mailbox *m)
Unlock a mailbox.
Definition: mbox.c:163
static enum MxOpenReturns mmdf_parse_mailbox(struct Mailbox *m)
Read a mailbox in MMDF format.
Definition: mbox.c:183
MxOpenReturns
Return values for mbox_open()
Definition: mxapi.h:73
void mutt_sig_block(void)
Block signals during critical operations.
Definition: signal.c:228
void mutt_sig_unblock(void)
Restore previously blocked signals.
Definition: signal.c:246
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:

◆ mh_mbox_open()

static enum MxOpenReturns mh_mbox_open ( struct Mailbox m)
static

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

Definition at line 815 of file mh.c.

816{
818}
static bool mh_read_dir(struct Mailbox *m)
Read an MH mailbox.
Definition: mh.c:661
+ Here is the call 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 2382 of file nntp.c.

2383{
2384 if (!m->account)
2385 return MX_OPEN_ERROR;
2386
2387 char buf[8192] = { 0 };
2388 char server[1024] = { 0 };
2389 char *group = NULL;
2390 int rc;
2391 struct HeaderCache *hc = NULL;
2392 anum_t first = 0, last = 0, count = 0;
2393
2394 struct Url *url = url_parse(mailbox_path(m));
2395 if (!url || !url->host || !url->path ||
2396 !((url->scheme == U_NNTP) || (url->scheme == U_NNTPS)))
2397 {
2398 url_free(&url);
2399 mutt_error(_("%s is an invalid newsgroup specification"), mailbox_path(m));
2400 return MX_OPEN_ERROR;
2401 }
2402
2403 group = url->path;
2404 if (group[0] == '/') /* Skip a leading '/' */
2405 group++;
2406
2407 url->path = strchr(url->path, '\0');
2408 url_tostring(url, server, sizeof(server), U_NO_FLAGS);
2409
2411 struct NntpAccountData *adata = m->account->adata;
2412 if (!adata)
2414 if (!adata)
2415 {
2416 adata = nntp_select_server(m, server, true);
2417 m->account->adata = adata;
2419 }
2420
2421 if (!adata)
2422 {
2423 url_free(&url);
2424 return MX_OPEN_ERROR;
2425 }
2427
2428 m->msg_count = 0;
2429 m->msg_unread = 0;
2430 m->vcount = 0;
2431
2432 if (group[0] == '/')
2433 group++;
2434
2435 /* find news group data structure */
2437 if (!mdata)
2438 {
2440 mutt_error(_("Newsgroup %s not found on the server"), group);
2441 url_free(&url);
2442 return MX_OPEN_ERROR;
2443 }
2444
2445 m->rights &= ~MUTT_ACL_INSERT; // Clear the flag
2446 const bool c_save_unsubscribed = cs_subset_bool(NeoMutt->sub, "save_unsubscribed");
2447 if (!mdata->newsrc_ent && !mdata->subscribed && !c_save_unsubscribed)
2448 m->readonly = true;
2449
2450 /* select newsgroup */
2451 mutt_message(_("Selecting %s..."), group);
2452 url_free(&url);
2453 buf[0] = '\0';
2454 if (nntp_query(mdata, buf, sizeof(buf)) < 0)
2455 {
2457 return MX_OPEN_ERROR;
2458 }
2459
2460 /* newsgroup not found, remove it */
2461 if (mutt_str_startswith(buf, "411"))
2462 {
2463 mutt_error(_("Newsgroup %s has been removed from the server"), mdata->group);
2464 if (!mdata->deleted)
2465 {
2466 mdata->deleted = true;
2468 }
2469 if (mdata->newsrc_ent && !mdata->subscribed && !c_save_unsubscribed)
2470 {
2471 FREE(&mdata->newsrc_ent);
2472 mdata->newsrc_len = 0;
2475 }
2476 }
2477 else
2478 {
2479 /* parse newsgroup info */
2480 if (sscanf(buf, "211 " ANUM_FMT " " ANUM_FMT " " ANUM_FMT, &count, &first, &last) != 3)
2481 {
2483 mutt_error("GROUP: %s", buf);
2484 return MX_OPEN_ERROR;
2485 }
2486 mdata->first_message = first;
2487 mdata->last_message = last;
2488 mdata->deleted = false;
2489
2490 /* get description if empty */
2491 const bool c_nntp_load_description = cs_subset_bool(NeoMutt->sub, "nntp_load_description");
2492 if (c_nntp_load_description && !mdata->desc)
2493 {
2494 if (get_description(mdata, NULL, NULL) < 0)
2495 {
2497 return MX_OPEN_ERROR;
2498 }
2499 if (mdata->desc)
2501 }
2502 }
2503
2505 m->mdata = mdata;
2506 // Every known newsgroup has an mdata which is stored in adata->groups_list.
2507 // Currently we don't let the Mailbox free the mdata.
2508 // m->mdata_free = nntp_mdata_free;
2509 if (!mdata->bcache && (mdata->newsrc_ent || mdata->subscribed || c_save_unsubscribed))
2510 mdata->bcache = mutt_bcache_open(&adata->conn->account, mdata->group);
2511
2512 /* strip off extra articles if adding context is greater than $nntp_context */
2513 first = mdata->first_message;
2514 const long c_nntp_context = cs_subset_long(NeoMutt->sub, "nntp_context");
2515 if (c_nntp_context && ((mdata->last_message - first + 1) > c_nntp_context))
2516 first = mdata->last_message - c_nntp_context + 1;
2517 mdata->last_loaded = first ? first - 1 : 0;
2518 count = mdata->first_message;
2519 mdata->first_message = first;
2521 mdata->first_message = count;
2522#ifdef USE_HCACHE
2523 hc = nntp_hcache_open(mdata);
2525#endif
2526 if (!hc)
2527 m->rights &= ~(MUTT_ACL_WRITE | MUTT_ACL_DELETE); // Clear the flags
2528
2530 rc = nntp_fetch_headers(m, hc, first, mdata->last_message, false);
2531#ifdef USE_HCACHE
2532 hcache_close(&hc);
2533#endif
2534 if (rc < 0)
2535 return MX_OPEN_ERROR;
2536 mdata->last_loaded = mdata->last_message;
2537 adata->newsrc_modified = false;
2538 return MX_OPEN_OK;
2539}
struct BodyCache * mutt_bcache_open(struct ConnAccount *account, const char *mailbox)
Open an Email-Body Cache.
Definition: bcache.c:146
long cs_subset_long(const struct ConfigSubset *sub, const char *name)
Get a long config item by name.
Definition: helpers.c:95
void nntp_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free() -.
Definition: adata.c:43
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 hcache_close(struct HeaderCache **ptr)
Multiplexor for StoreOps::close.
Definition: hcache.c:542
void mutt_account_hook(const char *url)
Perform an account hook.
Definition: hook.c:888
#define FREE(x)
Definition: memory.h:62
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:456
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:231
struct HeaderCache * nntp_hcache_open(struct NntpMboxData *mdata)
Open newsgroup hcache.
Definition: newsrc.c:707
void nntp_delete_group_cache(struct NntpMboxData *mdata)
Remove hcache and bcache of newsgroup.
Definition: newsrc.c:808
void nntp_hcache_update(struct NntpMboxData *mdata, struct HeaderCache *hc)
Remove stale cached headers.
Definition: newsrc.c:731
int nntp_active_save_cache(struct NntpAccountData *adata)
Save list of all newsgroups to cache.
Definition: newsrc.c:647
void nntp_bcache_update(struct NntpMboxData *mdata)
Remove stale cached messages.
Definition: newsrc.c:799
void nntp_newsrc_close(struct NntpAccountData *adata)
Unlock and close .newsrc file.
Definition: newsrc.c:120
int nntp_newsrc_update(struct NntpAccountData *adata)
Update .newsrc file.
Definition: newsrc.c:443
#define ANUM_FMT
Definition: lib.h:62
struct NntpAccountData * nntp_select_server(struct Mailbox *m, const char *server, bool leave_lock)
Open a connection to an NNTP server.
Definition: newsrc.c:945
#define anum_t
Definition: lib.h:61
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:729
static int get_description(struct NntpMboxData *mdata, const char *wildmat, const char *msg)
Fetch newsgroups descriptions.
Definition: nntp.c:935
struct NntpAccountData * CurrentNewsSrv
Current news server.
Definition: nntp.c:76
static int nntp_fetch_headers(struct Mailbox *m, void *hc, anum_t first, anum_t last, bool restore)
Fetch headers.
Definition: nntp.c:1203
void(* adata_free)(void **ptr)
Definition: account.h:53
Header Cache.
Definition: lib.h:86
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
NNTP-specific Account data -.
Definition: adata.h:36
bool newsrc_modified
Definition: adata.h:49
struct HashTable * groups_hash
Hash Table: "newsgroup" -> NntpMboxData.
Definition: adata.h:61
struct Connection * conn
Connection to NNTP Server.
Definition: adata.h:62
time_t check_time
Definition: adata.h:57
NNTP-specific Mailbox data -.
Definition: mdata.h:34
char * group
Name of newsgroup.
Definition: mdata.h:35
struct NntpAccountData * adata
Definition: mdata.h:48
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:238
void url_free(struct Url **ptr)
Free the contents of a URL.
Definition: url.c:123
int url_tostring(const struct Url *url, char *dest, size_t len, uint8_t flags)
Output the URL string for a given Url object.
Definition: url.c:422
#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 2068 of file notmuch.c.

2069{
2070 if (init_mailbox(m) != 0)
2071 return MX_OPEN_ERROR;
2072
2073 struct NmMboxData *mdata = nm_mdata_get(m);
2074 if (!mdata)
2075 return MX_OPEN_ERROR;
2076
2077 mutt_debug(LL_DEBUG1, "nm: reading messages...[current count=%d]\n", m->msg_count);
2078
2079 progress_setup(m);
2080 enum MxOpenReturns rc = MX_OPEN_ERROR;
2081
2082 notmuch_query_t *q = get_query(m, false);
2083 if (q)
2084 {
2085 rc = MX_OPEN_OK;
2086 switch (mdata->query_type)
2087 {
2088 case NM_QUERY_TYPE_UNKNOWN: // UNKNOWN should never occur, but MESGS is default
2090 if (!read_mesgs_query(m, q, false))
2091 rc = MX_OPEN_ABORT;
2092 break;
2094 if (!read_threads_query(m, q, false, get_limit(mdata)))
2095 rc = MX_OPEN_ABORT;
2096 break;
2097 }
2098 notmuch_query_destroy(q);
2099 }
2100
2101 nm_db_release(m);
2102
2103 mdata->mtime.tv_sec = mutt_date_now();
2104 mdata->mtime.tv_nsec = 0;
2105
2106 mdata->oldmsgcount = 0;
2107
2108 mutt_debug(LL_DEBUG1, "nm: reading messages... done [rc=%d, count=%d]\n", rc, m->msg_count);
2109 progress_free(&mdata->progress);
2110 return rc;
2111}
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:44
@ MX_OPEN_ABORT
Open was aborted.
Definition: mxapi.h:76
int nm_db_release(struct Mailbox *m)
Close the Notmuch database.
Definition: db.c:233
struct NmMboxData * nm_mdata_get(struct Mailbox *m)
Get the Notmuch Mailbox data.
Definition: mdata.c:96
static int init_mailbox(struct Mailbox *m)
Add Notmuch data to the Mailbox.
Definition: notmuch.c:200
static int get_limit(struct NmMboxData *mdata)
Get the database limit.
Definition: notmuch.c:415
static bool read_threads_query(struct Mailbox *m, notmuch_query_t *q, bool dedup, int limit)
Perform a query with threads.
Definition: notmuch.c:1032
static notmuch_query_t * get_query(struct Mailbox *m, bool writable)
Create a new query.
Definition: notmuch.c:450
static bool read_mesgs_query(struct Mailbox *m, notmuch_query_t *q, bool dedup)
Search for matching messages.
Definition: notmuch.c:962
static void progress_setup(struct Mailbox *m)
Set up the Progress Bar.
Definition: notmuch.c:700
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:110
@ 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
Notmuch-specific Mailbox data -.
Definition: mdata.h:35
+ 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 740 of file pop.c.

741{
742 if (!m->account)
743 return MX_OPEN_ERROR;
744
745 char buf[PATH_MAX] = { 0 };
746 struct ConnAccount cac = { { 0 } };
747 struct Url url = { 0 };
748
749 if (pop_parse_path(mailbox_path(m), &cac))
750 {
751 mutt_error(_("%s is an invalid POP path"), mailbox_path(m));
752 return MX_OPEN_ERROR;
753 }
754
755 account_to_url(&cac, &url);
756 url.path = NULL;
757 url_tostring(&url, buf, sizeof(buf), U_NO_FLAGS);
758
759 buf_strcpy(&m->pathbuf, buf);
761
762 struct PopAccountData *adata = m->account->adata;
763 if (!adata)
764 {
766 m->account->adata = adata;
768 }
769
770 struct Connection *conn = adata->conn;
771 if (!conn)
772 {
773 adata->conn = mutt_conn_new(&cac);
774 conn = adata->conn;
775 if (!conn)
776 return MX_OPEN_ERROR;
777 }
778
779 if (conn->fd < 0)
781
782 if (pop_open_connection(adata) < 0)
783 return MX_OPEN_ERROR;
784
785 adata->bcache = mutt_bcache_open(&cac, NULL);
786
787 /* init (hard-coded) ACL rights */
789#ifdef USE_HCACHE
790 /* flags are managed using header cache, so it only makes sense to
791 * enable them in that case */
793#endif
794
795 while (true)
796 {
797 if (pop_reconnect(m) < 0)
798 return MX_OPEN_ERROR;
799
800 m->size = adata->size;
801
802 mutt_message(_("Fetching list of messages..."));
803
804 const int rc = pop_fetch_headers(m);
805
806 if (rc >= 0)
807 return MX_OPEN_OK;
808
809 if (rc < -1)
810 return MX_OPEN_ERROR;
811 }
812}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
void pop_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free() -.
Definition: adata.c:41
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:281
void account_to_url(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition: mutt_account.c:80
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:63
int pop_open_connection(struct PopAccountData *adata)
Open connection and authenticate.
Definition: lib.c:316
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:608
static int pop_fetch_headers(struct Mailbox *m)
Read headers.
Definition: pop.c:323
Login details for a remote server.
Definition: connaccount.h:53
int fd
Socket file descriptor.
Definition: connection.h:53
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: