lib.h File Reference

Usenet network mailbox type; talk to an NNTP server. More...

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "core/lib.h"
#include "format_flags.h"

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	NntpAcache
	NNTP article cache. More...
struct	NewsrcEntry
	An entry in a .newsrc (subscribed newsgroups) More...

Macros
#define	anum_t   long
#define	ANUM   "%ld"
#define	NNTP_ACACHE_LEN   10

Functions
struct NntpAccountData *	nntp_select_server (struct Mailbox *m, const char *server, bool leave_lock)
	Open a connection to an NNTP server.
struct NntpMboxData *	mutt_newsgroup_subscribe (struct NntpAccountData *adata, char *group)
	Subscribe newsgroup.
struct NntpMboxData *	mutt_newsgroup_unsubscribe (struct NntpAccountData *adata, char *group)
	Unsubscribe newsgroup.
struct NntpMboxData *	mutt_newsgroup_catchup (struct Mailbox *m, struct NntpAccountData *adata, char *group)
	Catchup newsgroup.
struct NntpMboxData *	mutt_newsgroup_uncatchup (struct Mailbox *m, struct NntpAccountData *adata, char *group)
	Uncatchup newsgroup.
int	nntp_active_fetch (struct NntpAccountData *adata, bool mark_new)
	Fetch list of all newsgroups from server.
int	nntp_newsrc_update (struct NntpAccountData *adata)
	Update .newsrc file.
int	nntp_post (struct Mailbox *m, const char *msg)
	Post article.
int	nntp_check_msgid (struct Mailbox *m, const char *msgid)
	Fetch article by Message-ID.
int	nntp_check_children (struct Mailbox *m, const char *msgid)
	Fetch children of article with the Message-ID.
int	nntp_newsrc_parse (struct NntpAccountData *adata)
	Parse .newsrc file.
void	nntp_newsrc_close (struct NntpAccountData *adata)
	Unlock and close .newsrc file.
void	nntp_mailbox (struct Mailbox *m, char *buf, size_t buflen)
	Get first newsgroup with new messages.
void	nntp_expand_path (char *buf, size_t buflen, struct ConnAccount *acct)
	Make fully qualified url from newsgroup name.
void	nntp_clear_cache (struct NntpAccountData *adata)
	Clear the NNTP cache.
const char *	nntp_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Expand the newsrc filename - Implements format_t -.
int	nntp_compare_order (const struct Email *a, const struct Email *b, bool reverse)
	Sort to mailbox order - Implements sort_mail_t -.
enum MailboxType	nntp_path_probe (const char *path, const struct stat *st)
	Is this an NNTP Mailbox? - Implements MxOps::path_probe() -.
const char *	group_index_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the newsgroup menu - Implements format_t -.
int	nntp_complete (struct Buffer *buf)
	Auto-complete NNTP newsgroups.

Variables
struct NntpAccountData *	CurrentNewsSrv
	Current NNTP news server.
const struct MxOps	MxNntpOps
	NNTP Mailbox - Implements MxOps -.

Detailed Description

Usenet network mailbox type; talk to an NNTP server.

Authors

• Brandon Long
• Andrej Gritsenko
• Vsevolod Volkov

Copyright

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 2 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 along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file lib.h.

Macro Definition Documentation

anum_t

#define anum_t   long

Definition at line 61 of file lib.h.

ANUM

#define ANUM   "%ld"

Definition at line 62 of file lib.h.

NNTP_ACACHE_LEN

#define NNTP_ACACHE_LEN   10

Definition at line 83 of file lib.h.

Function Documentation

nntp_select_server()

struct NntpAccountData * nntp_select_server	(	struct Mailbox *	m,
		const char *	server,
		bool	leave_lock
	)

Open a connection to an NNTP server.

Parameters

m	Mailbox
server	Server URL
leave_lock	Leave the server locked?

Return values

ptr	NNTP server
NULL	Error

Automatically loads a newsrc into memory, if necessary. Checks the size/mtime of a newsrc file, if it doesn't match, load again. Hmm, if a system has broken mtimes, this might mean the file is reloaded every time, which we'd have to fix.

See also

$newsrc, nntp_format_str()

Definition at line 1021 of file newsrc.c.

{
  char file[PATH_MAX] = { 0 };
  int rc;
  struct ConnAccount cac = { { 0 } };
  struct NntpAccountData *adata = NULL;
  struct Connection *conn = NULL;
 
  if (!server || (*server == '\0'))
  {
    mutt_error(_("No news server defined"));
    return NULL;
  }
 
  /* create account from news server url */
  cac.flags = 0;
  cac.port = NNTP_PORT;
  cac.type = MUTT_ACCT_TYPE_NNTP;
  cac.service = "nntp";
  cac.get_field = nntp_get_field;
 
  snprintf(file, sizeof(file), "%s%s", strstr(server, "://") ? "" : "news://", server);
  struct Url *url = url_parse(file);
  if (!url || (url->path && *url->path) ||
      !((url->scheme == U_NNTP) || (url->scheme == U_NNTPS)) || !url->host ||
      (mutt_account_fromurl(&cac, url) < 0))
  {
    url_free(&url);
    mutt_error(_("%s is an invalid news server specification"), server);
    return NULL;
  }
  if (url->scheme == U_NNTPS)
  {
    cac.flags |= MUTT_ACCT_SSL;
    cac.port = NNTP_SSL_PORT;
  }
  url_free(&url);
 
  // If nntp_user and nntp_pass are specified in the config, use them to find the connection
  const char *user = NULL;
  const char *pass = NULL;
  if ((user = cac.get_field(MUTT_CA_USER, NULL)))
  {
    mutt_str_copy(cac.user, user, sizeof(cac.user));
    cac.flags |= MUTT_ACCT_USER;
  }
  if ((pass = cac.get_field(MUTT_CA_PASS, NULL)))
  {
    mutt_str_copy(cac.pass, pass, sizeof(cac.pass));
    cac.flags |= MUTT_ACCT_PASS;
  }
 
  /* find connection by account */
  conn = mutt_conn_find(&cac);
  if (!conn)
    return NULL;
  if (!(conn->account.flags & MUTT_ACCT_USER) && cac.flags & MUTT_ACCT_USER)
  {
    conn->account.flags |= MUTT_ACCT_USER;
    conn->account.user[0] = '\0';
  }
 
  /* new news server */
  adata = nntp_adata_new(conn);
 
  rc = nntp_open_connection(adata);
 
  /* try to create cache directory and enable caching */
  adata->cacheable = false;
  const char *const c_news_cache_dir = cs_subset_path(NeoMutt->sub, "news_cache_dir");
  if ((rc >= 0) && c_news_cache_dir)
  {
    cache_expand(file, sizeof(file), &conn->account, NULL);
    if (mutt_file_mkdir(file, S_IRWXU) < 0)
    {
      mutt_error(_("Can't create %s: %s"), file, strerror(errno));
    }
    adata->cacheable = true;
  }
 
  /* load .newsrc */
  if (rc >= 0)
  {
    const char *const c_newsrc = cs_subset_path(NeoMutt->sub, "newsrc");
    mutt_expando_format(file, sizeof(file), 0, sizeof(file), NONULL(c_newsrc),
                        nntp_format_str, (intptr_t) adata, MUTT_FORMAT_NO_FLAGS);
    mutt_expand_path(file, sizeof(file));
    adata->newsrc_file = mutt_str_dup(file);
    rc = nntp_newsrc_parse(adata);
  }
  if (rc >= 0)
  {
    /* try to load list of newsgroups from cache */
    if (adata->cacheable && (active_get_cache(adata) == 0))
    {
      rc = nntp_check_new_groups(m, adata);
    }
    else
    {
      /* load list of newsgroups from server */
      rc = nntp_active_fetch(adata, false);
    }
  }
 
  if (rc >= 0)
    nntp_clear_cache(adata);
 
#ifdef USE_HCACHE
  /* check cache files */
  if ((rc >= 0) && adata->cacheable)
  {
    struct dirent *de = NULL;
    DIR *dir = mutt_file_opendir(file, MUTT_OPENDIR_NONE);
 
    if (dir)
    {
      while ((de = readdir(dir)))
      {
        struct HeaderCache *hc = NULL;
        char *group = de->d_name;
 
        char *p = group + strlen(group) - 7;
        if ((strlen(group) < 8) || !mutt_str_equal(p, ".hcache"))
          continue;
        *p = '\0';
        struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
        if (!mdata)
          continue;
 
        hc = nntp_hcache_open(mdata);
        if (!hc)
          continue;
 
        /* fetch previous values of first and last */
        char *hdata = hcache_fetch_str(hc, "index", 5);
        if (hdata)
        {
          anum_t first, last;
 
          if (sscanf(hdata, ANUM " " ANUM, &first, &last) == 2)
          {
            if (mdata->deleted)
            {
              mdata->first_message = first;
              mdata->last_message = last;
            }
            if ((last >= mdata->first_message) && (last <= mdata->last_message))
            {
              mdata->last_cached = last;
              mutt_debug(LL_DEBUG2, "%s last_cached=" ANUM "\n", mdata->group, last);
            }
          }
          FREE(&hdata);
        }
        hcache_close(&hc);
      }
      closedir(dir);
    }
  }
#endif
 
  if ((rc < 0) || !leave_lock)
    nntp_newsrc_close(adata);
 
  if (rc < 0)
  {
    mutt_hash_free(&adata->groups_hash);
    FREE(&adata->groups_list);
    FREE(&adata->newsrc_file);
    FREE(&adata->authenticators);
    FREE(&adata);
    mutt_socket_close(conn);
    FREE(&conn);
    return NULL;
  }
 
  return adata;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_newsgroup_subscribe()

struct NntpMboxData * mutt_newsgroup_subscribe	(	struct NntpAccountData *	adata,
		char *	group
	)

Subscribe newsgroup.

Parameters

adata	NNTP server
group	Newsgroup

Return values

ptr	NNTP data
NULL	Error

Definition at line 1249 of file newsrc.c.

{
  if (!adata || !adata->groups_hash || !group || (*group == '\0'))
    return NULL;
 
  struct NntpMboxData *mdata = mdata_find(adata, group);
  mdata->subscribed = true;
  if (!mdata->newsrc_ent)
  {
    mdata->newsrc_ent = mutt_mem_calloc(1, sizeof(struct NewsrcEntry));
    mdata->newsrc_len = 1;
    mdata->newsrc_ent[0].first = 1;
    mdata->newsrc_ent[0].last = 0;
  }
  return mdata;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_newsgroup_unsubscribe()

struct NntpMboxData * mutt_newsgroup_unsubscribe	(	struct NntpAccountData *	adata,
		char *	group
	)

Unsubscribe newsgroup.

Parameters

adata	NNTP server
group	Newsgroup

Return values

ptr	NNTP data
NULL	Error

Definition at line 1273 of file newsrc.c.

{
  if (!adata || !adata->groups_hash || !group || (*group == '\0'))
    return NULL;
 
  struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
  if (!mdata)
    return NULL;
 
  mdata->subscribed = false;
  const bool c_save_unsubscribed = cs_subset_bool(NeoMutt->sub, "save_unsubscribed");
  if (!c_save_unsubscribed)
  {
    mdata->newsrc_len = 0;
    FREE(&mdata->newsrc_ent);
  }
  return mdata;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_newsgroup_catchup()

struct NntpMboxData * mutt_newsgroup_catchup	(	struct Mailbox *	m,
		struct NntpAccountData *	adata,
		char *	group
	)

Catchup newsgroup.

Parameters

m	Mailbox
adata	NNTP server
group	Newsgroup

Return values

ptr	NNTP data
NULL	Error

Definition at line 1300 of file newsrc.c.

{
  if (!adata || !adata->groups_hash || !group || (*group == '\0'))
    return NULL;
 
  struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
  if (!mdata)
    return NULL;
 
  if (mdata->newsrc_ent)
  {
    mutt_mem_realloc(&mdata->newsrc_ent, sizeof(struct NewsrcEntry));
    mdata->newsrc_len = 1;
    mdata->newsrc_ent[0].first = 1;
    mdata->newsrc_ent[0].last = mdata->last_message;
  }
  mdata->unread = 0;
  if (m && (m->mdata == mdata))
  {
    for (unsigned int i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      mutt_set_flag(m, e, MUTT_READ, true, true);
    }
  }
  return mdata;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_newsgroup_uncatchup()

struct NntpMboxData * mutt_newsgroup_uncatchup	(	struct Mailbox *	m,
		struct NntpAccountData *	adata,
		char *	group
	)

Uncatchup newsgroup.

Parameters

m	Mailbox
adata	NNTP server
group	Newsgroup

Return values

ptr	NNTP data
NULL	Error

Definition at line 1339 of file newsrc.c.

{
  if (!adata || !adata->groups_hash || !group || (*group == '\0'))
    return NULL;
 
  struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
  if (!mdata)
    return NULL;
 
  if (mdata->newsrc_ent)
  {
    mutt_mem_realloc(&mdata->newsrc_ent, sizeof(struct NewsrcEntry));
    mdata->newsrc_len = 1;
    mdata->newsrc_ent[0].first = 1;
    mdata->newsrc_ent[0].last = mdata->first_message - 1;
  }
  if (m && (m->mdata == mdata))
  {
    mdata->unread = m->msg_count;
    for (unsigned int i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      mutt_set_flag(m, e, MUTT_READ, false, true);
    }
  }
  else
  {
    mdata->unread = mdata->last_message;
    if (mdata->newsrc_ent)
      mdata->unread -= mdata->newsrc_ent[0].last;
  }
  return mdata;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_active_fetch()

int nntp_active_fetch	(	struct NntpAccountData *	adata,
		bool	mark_new
	)

Fetch list of all newsgroups from server.

Parameters

adata	NNTP server
mark_new	Mark the groups as new

Return values

0	Success
-1	Failure

Definition at line 1986 of file nntp.c.

{
  struct NntpMboxData tmp_mdata = { 0 };
  char msg[256] = { 0 };
  char buf[1024] = { 0 };
  unsigned int i;
  int rc;
 
  snprintf(msg, sizeof(msg), _("Loading list of groups from server %s..."),
           adata->conn->account.host);
  mutt_message("%s", msg);
  if (nntp_date(adata, &adata->newgroups_time) < 0)
    return -1;
 
  tmp_mdata.adata = adata;
  tmp_mdata.group = NULL;
  i = adata->groups_num;
  mutt_str_copy(buf, "LIST\r\n", sizeof(buf));
  rc = nntp_fetch_lines(&tmp_mdata, buf, sizeof(buf), msg, nntp_add_group, adata);
  if (rc)
  {
    if (rc > 0)
    {
      mutt_error("LIST: %s", buf);
    }
    return -1;
  }
 
  if (mark_new)
  {
    for (; i < adata->groups_num; i++)
    {
      struct NntpMboxData *mdata = adata->groups_list[i];
      mdata->has_new_mail = true;
    }
  }
 
  for (i = 0; i < adata->groups_num; i++)
  {
    struct NntpMboxData *mdata = adata->groups_list[i];
 
    if (mdata && mdata->deleted && !mdata->newsrc_ent)
    {
      nntp_delete_group_cache(mdata);
      mutt_hash_delete(adata->groups_hash, mdata->group, NULL);
      adata->groups_list[i] = NULL;
    }
  }
 
  const bool c_nntp_load_description = cs_subset_bool(NeoMutt->sub, "nntp_load_description");
  if (c_nntp_load_description)
    rc = get_description(&tmp_mdata, "*", _("Loading descriptions..."));
 
  nntp_active_save_cache(adata);
  if (rc < 0)
    return -1;
  mutt_clear_error();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_newsrc_update()

int nntp_newsrc_update

(

struct NntpAccountData *

adata

)

Update .newsrc file.

Parameters

adata

NNTP server

Return values

0	Success
-1	Failure

Definition at line 441 of file newsrc.c.

{
  if (!adata)
    return -1;
 
  int rc = -1;
 
  size_t buflen = 10240;
  char *buf = mutt_mem_calloc(1, buflen);
  size_t off = 0;
 
  /* we will generate full newsrc here */
  for (unsigned int i = 0; i < adata->groups_num; i++)
  {
    struct NntpMboxData *mdata = adata->groups_list[i];
 
    if (!mdata || !mdata->newsrc_ent)
      continue;
 
    /* write newsgroup name */
    if ((off + strlen(mdata->group) + 3) > buflen)
    {
      buflen *= 2;
      mutt_mem_realloc(&buf, buflen);
    }
    snprintf(buf + off, buflen - off, "%s%c ", mdata->group, mdata->subscribed ? ':' : '!');
    off += strlen(buf + off);
 
    /* write entries */
    for (unsigned int j = 0; j < mdata->newsrc_len; j++)
    {
      if ((off + 1024) > buflen)
      {
        buflen *= 2;
        mutt_mem_realloc(&buf, buflen);
      }
      if (j)
        buf[off++] = ',';
      if (mdata->newsrc_ent[j].first == mdata->newsrc_ent[j].last)
      {
        snprintf(buf + off, buflen - off, ANUM, mdata->newsrc_ent[j].first);
      }
      else if (mdata->newsrc_ent[j].first < mdata->newsrc_ent[j].last)
      {
        snprintf(buf + off, buflen - off, ANUM "-" ANUM,
                 mdata->newsrc_ent[j].first, mdata->newsrc_ent[j].last);
      }
      off += strlen(buf + off);
    }
    buf[off++] = '\n';
  }
  buf[off] = '\0';
 
  /* newrc being fully rewritten */
  mutt_debug(LL_DEBUG1, "Updating %s\n", adata->newsrc_file);
  if (adata->newsrc_file && (update_file(adata->newsrc_file, buf) == 0))
  {
    struct stat st = { 0 };
 
    rc = stat(adata->newsrc_file, &st);
    if (rc == 0)
    {
      adata->size = st.st_size;
      adata->mtime = st.st_mtime;
    }
    else
    {
      mutt_perror("%s", adata->newsrc_file);
    }
  }
  FREE(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_post()

int nntp_post	(	struct Mailbox *	m,
		const char *	msg
	)

Post article.

Parameters

m	Mailbox
msg	Message to post

Return values

0	Success
-1	Failure

Definition at line 1901 of file nntp.c.

{
  struct NntpMboxData *mdata = NULL;
  struct NntpMboxData tmp_mdata = { 0 };
  char buf[1024] = { 0 };
 
  if (m && (m->type == MUTT_NNTP))
  {
    mdata = m->mdata;
  }
  else
  {
    const char *const c_news_server = cs_subset_string(NeoMutt->sub, "news_server");
    CurrentNewsSrv = nntp_select_server(m, c_news_server, false);
    if (!CurrentNewsSrv)
      return -1;
 
    mdata = &tmp_mdata;
    mdata->adata = CurrentNewsSrv;
    mdata->group = NULL;
  }
 
  FILE *fp = mutt_file_fopen(msg, "r");
  if (!fp)
  {
    mutt_perror("%s", msg);
    return -1;
  }
 
  mutt_str_copy(buf, "POST\r\n", sizeof(buf));
  if (nntp_query(mdata, buf, sizeof(buf)) < 0)
  {
    mutt_file_fclose(&fp);
    return -1;
  }
  if (buf[0] != '3')
  {
    mutt_error(_("Can't post article: %s"), buf);
    mutt_file_fclose(&fp);
    return -1;
  }
 
  buf[0] = '.';
  buf[1] = '\0';
  while (fgets(buf + 1, sizeof(buf) - 2, fp))
  {
    size_t len = strlen(buf);
    if (buf[len - 1] == '\n')
    {
      buf[len - 1] = '\r';
      buf[len] = '\n';
      len++;
      buf[len] = '\0';
    }
    if (mutt_socket_send_d(mdata->adata->conn, (buf[1] == '.') ? buf : buf + 1,
                           MUTT_SOCK_LOG_FULL) < 0)
    {
      mutt_file_fclose(&fp);
      return nntp_connect_error(mdata->adata);
    }
  }
  mutt_file_fclose(&fp);
 
  if (((buf[strlen(buf) - 1] != '\n') &&
       (mutt_socket_send_d(mdata->adata->conn, "\r\n", MUTT_SOCK_LOG_FULL) < 0)) ||
      (mutt_socket_send_d(mdata->adata->conn, ".\r\n", MUTT_SOCK_LOG_FULL) < 0) ||
      (mutt_socket_readln(buf, sizeof(buf), mdata->adata->conn) < 0))
  {
    return nntp_connect_error(mdata->adata);
  }
  if (buf[0] != '2')
  {
    mutt_error(_("Can't post article: %s"), buf);
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_check_msgid()

int nntp_check_msgid	(	struct Mailbox *	m,
		const char *	msgid
	)

Fetch article by Message-ID.

Parameters

m	Mailbox
msgid	Message ID

Return values

0	Success
1	No such article
-1	Error

Definition at line 2164 of file nntp.c.

{
  if (!m)
    return -1;
 
  struct NntpMboxData *mdata = m->mdata;
  char buf[1024] = { 0 };
 
  FILE *fp = mutt_file_mkstemp();
  if (!fp)
  {
    mutt_perror(_("Can't create temporary file"));
    return -1;
  }
 
  snprintf(buf, sizeof(buf), "HEAD %s\r\n", msgid);
  int rc = nntp_fetch_lines(mdata, buf, sizeof(buf), NULL, fetch_tempfile, fp);
  if (rc)
  {
    mutt_file_fclose(&fp);
    if (rc < 0)
      return -1;
    if (mutt_str_startswith(buf, "430"))
      return 1;
    mutt_error("HEAD: %s", buf);
    return -1;
  }
 
  /* parse header */
  mx_alloc_memory(m, m->msg_count);
  m->emails[m->msg_count] = email_new();
  struct Email *e = m->emails[m->msg_count];
  e->edata = nntp_edata_new();
  e->edata_free = nntp_edata_free;
  e->env = mutt_rfc822_read_header(fp, e, false, false);
  mutt_file_fclose(&fp);
 
  /* get article number */
  if (e->env->xref)
  {
    nntp_parse_xref(m, e);
  }
  else
  {
    snprintf(buf, sizeof(buf), "STAT %s\r\n", msgid);
    if (nntp_query(mdata, buf, sizeof(buf)) < 0)
    {
      email_free(&e);
      return -1;
    }
    sscanf(buf + 4, ANUM, &nntp_edata_get(e)->article_num);
  }
 
  /* reset flags */
  e->read = false;
  e->old = false;
  e->deleted = false;
  e->changed = true;
  e->received = e->date_sent;
  e->index = m->msg_count++;
  mailbox_changed(m, NT_MAILBOX_INVALID);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_check_children()

int nntp_check_children	(	struct Mailbox *	m,
		const char *	msgid
	)

Fetch children of article with the Message-ID.

Parameters

m	Mailbox
msgid	Message ID to find

Return values

0	Success
-1	Failure

Definition at line 2235 of file nntp.c.

{
  if (!m)
    return -1;
 
  struct NntpMboxData *mdata = m->mdata;
  char buf[256] = { 0 };
  int rc;
  struct HeaderCache *hc = NULL;
 
  if (!mdata || !mdata->adata)
    return -1;
  if (mdata->first_message > mdata->last_loaded)
    return 0;
 
  /* init context */
  struct ChildCtx cc = { 0 };
  cc.mailbox = m;
  cc.num = 0;
  cc.max = 10;
  cc.child = mutt_mem_malloc(sizeof(anum_t) * cc.max);
 
  /* fetch numbers of child messages */
  snprintf(buf, sizeof(buf), "XPAT References " ANUM "-" ANUM " *%s*\r\n",
           mdata->first_message, mdata->last_loaded, msgid);
  rc = nntp_fetch_lines(mdata, buf, sizeof(buf), NULL, fetch_children, &cc);
  if (rc)
  {
    FREE(&cc.child);
    if (rc > 0)
    {
      if (!mutt_str_startswith(buf, "500"))
      {
        mutt_error("XPAT: %s", buf);
      }
      else
      {
        mutt_error(_("Unable to find child articles because server does not support XPAT command"));
      }
    }
    return -1;
  }
 
  /* fetch all found messages */
  bool verbose = m->verbose;
  m->verbose = false;
#ifdef USE_HCACHE
  hc = nntp_hcache_open(mdata);
#endif
  int old_msg_count = m->msg_count;
  for (int i = 0; i < cc.num; i++)
  {
    rc = nntp_fetch_headers(m, hc, cc.child[i], cc.child[i], true);
    if (rc < 0)
      break;
  }
  if (m->msg_count > old_msg_count)
    mailbox_changed(m, NT_MAILBOX_INVALID);
 
#ifdef USE_HCACHE
  hcache_close(&hc);
#endif
  m->verbose = verbose;
  FREE(&cc.child);
  return (rc < 0) ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_newsrc_parse()

int nntp_newsrc_parse

(

struct NntpAccountData *

adata

)

Parse .newsrc file.

Parameters

adata

NNTP server

Return values

0	Not changed
1	Parsed
-1	Error

Definition at line 162 of file newsrc.c.

{
  if (!adata)
    return -1;
 
  char *line = NULL;
  struct stat st = { 0 };
 
  if (adata->fp_newsrc)
  {
    /* if we already have a handle, close it and reopen */
    mutt_file_fclose(&adata->fp_newsrc);
  }
  else
  {
    /* if file doesn't exist, create it */
    adata->fp_newsrc = mutt_file_fopen(adata->newsrc_file, "a");
    mutt_file_fclose(&adata->fp_newsrc);
  }
 
  /* open .newsrc */
  adata->fp_newsrc = mutt_file_fopen(adata->newsrc_file, "r");
  if (!adata->fp_newsrc)
  {
    mutt_perror("%s", adata->newsrc_file);
    return -1;
  }
 
  /* lock it */
  mutt_debug(LL_DEBUG1, "Locking %s\n", adata->newsrc_file);
  if (mutt_file_lock(fileno(adata->fp_newsrc), false, true))
  {
    mutt_file_fclose(&adata->fp_newsrc);
    return -1;
  }
 
  if (stat(adata->newsrc_file, &st) != 0)
  {
    mutt_perror("%s", adata->newsrc_file);
    nntp_newsrc_close(adata);
    return -1;
  }
 
  if ((adata->size == st.st_size) && (adata->mtime == st.st_mtime))
    return 0;
 
  adata->size = st.st_size;
  adata->mtime = st.st_mtime;
  adata->newsrc_modified = true;
  mutt_debug(LL_DEBUG1, "Parsing %s\n", adata->newsrc_file);
 
  /* .newsrc has been externally modified or hasn't been loaded yet */
  for (unsigned int i = 0; i < adata->groups_num; i++)
  {
    struct NntpMboxData *mdata = adata->groups_list[i];
    if (!mdata)
      continue;
 
    mdata->subscribed = false;
    mdata->newsrc_len = 0;
    FREE(&mdata->newsrc_ent);
  }
 
  line = mutt_mem_malloc(st.st_size + 1);
  while (st.st_size && fgets(line, st.st_size + 1, adata->fp_newsrc))
  {
    char *b = NULL, *h = NULL;
    unsigned int j = 1;
    bool subs = false;
 
    /* find end of newsgroup name */
    char *p = strpbrk(line, ":!");
    if (!p)
      continue;
 
    /* ":" - subscribed, "!" - unsubscribed */
    if (*p == ':')
      subs = true;
    *p++ = '\0';
 
    /* get newsgroup data */
    struct NntpMboxData *mdata = mdata_find(adata, line);
    FREE(&mdata->newsrc_ent);
 
    /* count number of entries */
    b = p;
    while (*b)
      if (*b++ == ',')
        j++;
    mdata->newsrc_ent = mutt_mem_calloc(j, sizeof(struct NewsrcEntry));
    mdata->subscribed = subs;
 
    /* parse entries */
    j = 0;
    while (p)
    {
      b = p;
 
      /* find end of entry */
      p = strchr(p, ',');
      if (p)
        *p++ = '\0';
 
      /* first-last or single number */
      h = strchr(b, '-');
      if (h)
        *h++ = '\0';
      else
        h = b;
 
      if ((sscanf(b, ANUM, &mdata->newsrc_ent[j].first) == 1) &&
          (sscanf(h, ANUM, &mdata->newsrc_ent[j].last) == 1))
      {
        j++;
      }
    }
    if (j == 0)
    {
      mdata->newsrc_ent[j].first = 1;
      mdata->newsrc_ent[j].last = 0;
      j++;
    }
    if (mdata->last_message == 0)
      mdata->last_message = mdata->newsrc_ent[j - 1].last;
    mdata->newsrc_len = j;
    mutt_mem_realloc(&mdata->newsrc_ent, j * sizeof(struct NewsrcEntry));
    nntp_group_unread_stat(mdata);
    mutt_debug(LL_DEBUG2, "%s\n", mdata->group);
  }
  FREE(&line);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_newsrc_close()

void nntp_newsrc_close

(

struct NntpAccountData *

adata

)

Unlock and close .newsrc file.

Parameters

adata

NNTP server

Definition at line 118 of file newsrc.c.

{
  if (!adata->fp_newsrc)
    return;
 
  mutt_debug(LL_DEBUG1, "Unlocking %s\n", adata->newsrc_file);
  mutt_file_unlock(fileno(adata->fp_newsrc));
  mutt_file_fclose(&adata->fp_newsrc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_mailbox()

void nntp_mailbox	(	struct Mailbox *	m,
		char *	buf,
		size_t	buflen
	)

Get first newsgroup with new messages.

Parameters

m	Mailbox
buf	Buffer for result
buflen	Length of buffer

Definition at line 1382 of file newsrc.c.

{
  if (!m)
    return;
 
  for (unsigned int i = 0; i < CurrentNewsSrv->groups_num; i++)
  {
    struct NntpMboxData *mdata = CurrentNewsSrv->groups_list[i];
 
    if (!mdata || !mdata->subscribed || !mdata->unread)
      continue;
 
    if ((m->type == MUTT_NNTP) &&
        mutt_str_equal(mdata->group, ((struct NntpMboxData *) m->mdata)->group))
    {
      unsigned int unread = 0;
 
      for (unsigned int j = 0; j < m->msg_count; j++)
      {
        struct Email *e = m->emails[j];
        if (!e)
          break;
        if (!e->read && !e->deleted)
          unread++;
      }
      if (unread == 0)
        continue;
    }
    mutt_str_copy(buf, mdata->group, buflen);
    break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_expand_path()

void nntp_expand_path	(	char *	buf,
		size_t	buflen,
		struct ConnAccount *	cac
	)

Make fully qualified url from newsgroup name.

Parameters

buf	Buffer for the result
buflen	Length of buffer
cac	Account to serialise

Definition at line 564 of file newsrc.c.

{
  struct Url url = { 0 };
 
  mutt_account_tourl(cac, &url);
  url.path = mutt_str_dup(buf);
  url_tostring(&url, buf, buflen, U_NO_FLAGS);
  FREE(&url.path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_clear_cache()

void nntp_clear_cache

(

struct NntpAccountData *

adata

)

Clear the NNTP cache.

Parameters

adata

NNTP server

Remove hcache and bcache of all unexistent and unsubscribed newsgroups

Definition at line 847 of file newsrc.c.

{
  char file[PATH_MAX] = { 0 };
  char *fp = NULL;
  struct dirent *de = NULL;
  DIR *dir = NULL;
 
  if (!adata || !adata->cacheable)
    return;
 
  cache_expand(file, sizeof(file), &adata->conn->account, NULL);
  dir = mutt_file_opendir(file, MUTT_OPENDIR_NONE);
  if (dir)
  {
    mutt_strn_cat(file, sizeof(file), "/", 1);
    fp = file + strlen(file);
    while ((de = readdir(dir)))
    {
      char *group = de->d_name;
      struct stat st = { 0 };
      struct NntpMboxData *mdata = NULL;
      struct NntpMboxData tmp_mdata = { 0 };
 
      if (mutt_str_equal(group, ".") || mutt_str_equal(group, ".."))
        continue;
      *fp = '\0';
      mutt_strn_cat(file, sizeof(file), group, strlen(group));
      if (stat(file, &st) != 0)
        continue;
 
#ifdef USE_HCACHE
      if (S_ISREG(st.st_mode))
      {
        char *ext = group + strlen(group) - 7;
        if ((strlen(group) < 8) || !mutt_str_equal(ext, ".hcache"))
          continue;
        *ext = '\0';
      }
      else
#endif
          if (!S_ISDIR(st.st_mode))
        continue;
 
      const bool c_save_unsubscribed = cs_subset_bool(NeoMutt->sub, "save_unsubscribed");
      mdata = mutt_hash_find(adata->groups_hash, group);
      if (!mdata)
      {
        mdata = &tmp_mdata;
        mdata->adata = adata;
        mdata->group = group;
        mdata->bcache = NULL;
      }
      else if (mdata->newsrc_ent || mdata->subscribed || c_save_unsubscribed)
      {
        continue;
      }
 
      nntp_delete_group_cache(mdata);
      if (S_ISDIR(st.st_mode))
      {
        rmdir(file);
        mutt_debug(LL_DEBUG2, "%s\n", file);
      }
    }
    closedir(dir);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_complete()

int nntp_complete

(

struct Buffer *

buf

)

Auto-complete NNTP newsgroups.

Parameters

buf	Buffer containing pathname

Return values

0	Match found
-1	No matches

XXX rules

Definition at line 45 of file complete.c.

{
  struct NntpAccountData *adata = CurrentNewsSrv;
  size_t n = 0;
  struct Buffer *filepart = buf_new(buf_string(buf));
  bool init = false;
 
  /* special case to handle when there is no filepart yet
   * find the first subscribed newsgroup */
  int len = buf_len(filepart);
  if (len == 0)
  {
    for (; n < adata->groups_num; n++)
    {
      struct NntpMboxData *mdata = adata->groups_list[n];
 
      if (mdata && mdata->subscribed)
      {
        buf_strcpy(filepart, mdata->group);
        init = true;
        n++;
        break;
      }
    }
  }
 
  for (; n < adata->groups_num; n++)
  {
    struct NntpMboxData *mdata = adata->groups_list[n];
 
    if (mdata && mdata->subscribed &&
        mutt_strn_equal(mdata->group, buf_string(filepart), len))
    {
      if (init)
      {
        char *str = filepart->data;
        size_t i;
        for (i = 0; (str[i] != '\0') && mdata->group[i]; i++)
        {
          if (str[i] != mdata->group[i])
            break;
        }
        str[i] = '\0';
        buf_fix_dptr(filepart);
      }
      else
      {
        buf_strcpy(filepart, mdata->group);
        init = true;
      }
    }
  }
 
  buf_copy(buf, filepart);
  buf_free(&filepart);
  return init ? 0 : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CurrentNewsSrv

struct NntpAccountData* CurrentNewsSrv

extern

Current NNTP news server.

Current NNTP news server.

Definition at line 77 of file nntp.c.