]> granicus.if.org Git - neomutt/commitdiff
rename nntp structs
authorRichard Russon <rich@flatcap.org>
Wed, 17 Oct 2018 12:40:25 +0000 (13:40 +0100)
committerRichard Russon <rich@flatcap.org>
Wed, 17 Oct 2018 12:40:25 +0000 (13:40 +0100)
browser.c
complete.c
curs_main.c
mx.c
nntp/newsrc.c
nntp/nntp.c
nntp/nntp.h
nntp/nntp_private.h

index e6b7a0c7a5dc556c7aedbf438e2f21c3892d31b7..dc1f1d5534337815dbd6608c865ceb8e09d3e5a9 100644 (file)
--- a/browser.c
+++ b/browser.c
@@ -813,23 +813,23 @@ static int examine_directory(struct Menu *menu, struct BrowserState *state,
 #ifdef USE_NNTP
   if (OptNews)
   {
-    struct NntpServer *nserv = CurrentNewsSrv;
+    struct NntpAccountData *adata = CurrentNewsSrv;
 
     init_state(state, menu);
 
-    for (unsigned int i = 0; i < nserv->groups_num; i++)
+    for (unsigned int i = 0; i < adata->groups_num; i++)
     {
-      struct NntpMboxData *nntp_data = nserv->groups_list[i];
-      if (!nntp_data)
+      struct NntpMboxData *mdata = adata->groups_list[i];
+      if (!mdata)
         continue;
-      if (prefix && *prefix && (strncmp(prefix, nntp_data->group, strlen(prefix)) != 0))
+      if (prefix && *prefix && (strncmp(prefix, mdata->group, strlen(prefix)) != 0))
         continue;
       if (Mask && Mask->regex &&
-          !((regexec(Mask->regex, nntp_data->group, 0, NULL, 0) == 0) ^ Mask->not))
+          !((regexec(Mask->regex, mdata->group, 0, NULL, 0) == 0) ^ Mask->not))
       {
         continue;
       }
-      add_folder(menu, state, nntp_data->group, NULL, NULL, NULL, nntp_data);
+      add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
     }
   }
   else
@@ -968,17 +968,17 @@ static int examine_mailboxes(struct Menu *menu, struct BrowserState *state)
 #ifdef USE_NNTP
   if (OptNews)
   {
-    struct NntpServer *nserv = CurrentNewsSrv;
+    struct NntpAccountData *adata = CurrentNewsSrv;
 
     init_state(state, menu);
 
-    for (unsigned int i = 0; i < nserv->groups_num; i++)
+    for (unsigned int i = 0; i < adata->groups_num; i++)
     {
-      struct NntpMboxData *nntp_data = nserv->groups_list[i];
-      if (nntp_data && (nntp_data->new || (nntp_data->subscribed &&
-                                           (nntp_data->unread || !ShowOnlyUnread))))
+      struct NntpMboxData *mdata = adata->groups_list[i];
+      if (mdata && (mdata->new || (mdata->subscribed &&
+                                           (mdata->unread || !ShowOnlyUnread))))
       {
-        add_folder(menu, state, nntp_data->group, NULL, NULL, NULL, nntp_data);
+        add_folder(menu, state, mdata->group, NULL, NULL, NULL, mdata);
       }
     }
   }
@@ -1313,14 +1313,14 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
       mutt_str_strfcpy(prefix, file, sizeof(prefix));
     else
     {
-      struct NntpServer *nserv = CurrentNewsSrv;
+      struct NntpAccountData *adata = CurrentNewsSrv;
 
       /* default state for news reader mode is browse subscribed newsgroups */
       mailbox = false;
-      for (unsigned int j = 0; j < nserv->groups_num; j++)
+      for (unsigned int j = 0; j < adata->groups_num; j++)
       {
-        struct NntpMboxData *nntp_data = nserv->groups_list[j];
-        if (nntp_data && nntp_data->subscribed)
+        struct NntpMboxData *mdata = adata->groups_list[j];
+        if (mdata && mdata->subscribed)
         {
           mailbox = true;
           break;
@@ -2151,18 +2151,18 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
         if (OptNews)
         {
           struct FolderFile *ff = &state.entry[menu->current];
-          struct NntpMboxData *nntp_data = NULL;
+          struct NntpMboxData *mdata = NULL;
 
           int rc = nntp_newsrc_parse(CurrentNewsSrv);
           if (rc < 0)
             break;
 
           if (i == OP_CATCHUP)
-            nntp_data = mutt_newsgroup_catchup(Context, CurrentNewsSrv, ff->name);
+            mdata = mutt_newsgroup_catchup(Context, CurrentNewsSrv, ff->name);
           else
-            nntp_data = mutt_newsgroup_uncatchup(Context, CurrentNewsSrv, ff->name);
+            mdata = mutt_newsgroup_uncatchup(Context, CurrentNewsSrv, ff->name);
 
-          if (nntp_data)
+          if (mdata)
           {
             nntp_newsrc_update(CurrentNewsSrv);
             if (menu->current + 1 < menu->max)
@@ -2178,20 +2178,20 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
       case OP_LOAD_ACTIVE:
         if (OptNews)
         {
-          struct NntpServer *nserv = CurrentNewsSrv;
+          struct NntpAccountData *adata = CurrentNewsSrv;
 
-          if (nntp_newsrc_parse(nserv) < 0)
+          if (nntp_newsrc_parse(adata) < 0)
             break;
 
-          for (unsigned int j = 0; j < nserv->groups_num; j++)
+          for (unsigned int j = 0; j < adata->groups_num; j++)
           {
-            struct NntpMboxData *nntp_data = nserv->groups_list[j];
-            if (nntp_data)
-              nntp_data->deleted = true;
+            struct NntpMboxData *mdata = adata->groups_list[j];
+            if (mdata)
+              mdata->deleted = true;
           }
-          nntp_active_fetch(nserv, true);
-          nntp_newsrc_update(nserv);
-          nntp_newsrc_close(nserv);
+          nntp_active_fetch(adata, true);
+          nntp_newsrc_update(adata);
+          nntp_newsrc_close(adata);
 
           destroy_state(&state);
           if (mailbox)
@@ -2215,7 +2215,7 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
       case OP_UNSUBSCRIBE_PATTERN:
         if (OptNews)
         {
-          struct NntpServer *nserv = CurrentNewsSrv;
+          struct NntpAccountData *adata = CurrentNewsSrv;
           regex_t rx;
           memset(&rx, 0, sizeof(rx));
           char *s = buf;
@@ -2253,7 +2253,7 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
             break;
           }
 
-          int rc = nntp_newsrc_parse(nserv);
+          int rc = nntp_newsrc_parse(adata);
           if (rc < 0)
             break;
 
@@ -2265,9 +2265,9 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
                 regexec(&rx, ff->name, 0, NULL, 0) == 0)
             {
               if (i == OP_BROWSER_SUBSCRIBE || i == OP_SUBSCRIBE_PATTERN)
-                mutt_newsgroup_subscribe(nserv, ff->name);
+                mutt_newsgroup_subscribe(adata, ff->name);
               else
-                mutt_newsgroup_unsubscribe(nserv, ff->name);
+                mutt_newsgroup_unsubscribe(adata, ff->name);
             }
             if (i == OP_BROWSER_SUBSCRIBE || i == OP_BROWSER_UNSUBSCRIBE)
             {
@@ -2279,15 +2279,15 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
           }
           if (i == OP_SUBSCRIBE_PATTERN)
           {
-            for (unsigned int k = 0; nserv && (k < nserv->groups_num); k++)
+            for (unsigned int k = 0; adata && (k < adata->groups_num); k++)
             {
-              struct NntpMboxData *nntp_data = nserv->groups_list[k];
-              if (nntp_data && nntp_data->group && !nntp_data->subscribed)
+              struct NntpMboxData *mdata = adata->groups_list[k];
+              if (mdata && mdata->group && !mdata->subscribed)
               {
-                if (regexec(&rx, nntp_data->group, 0, NULL, 0) == 0)
+                if (regexec(&rx, mdata->group, 0, NULL, 0) == 0)
                 {
-                  mutt_newsgroup_subscribe(nserv, nntp_data->group);
-                  add_folder(menu, &state, nntp_data->group, NULL, NULL, NULL, nntp_data);
+                  mutt_newsgroup_subscribe(adata, mdata->group);
+                  add_folder(menu, &state, mdata->group, NULL, NULL, NULL, mdata);
                 }
               }
             }
@@ -2295,9 +2295,9 @@ void mutt_select_file(char *file, size_t filelen, int flags, char ***files, int
           }
           if (rc > 0)
             menu->redraw = REDRAW_FULL;
-          nntp_newsrc_update(nserv);
-          nntp_clear_cache(nserv);
-          nntp_newsrc_close(nserv);
+          nntp_newsrc_update(adata);
+          nntp_clear_cache(adata);
+          nntp_newsrc_close(adata);
           if (i != OP_BROWSER_SUBSCRIBE && i != OP_BROWSER_UNSUBSCRIBE)
             regfree(&rx);
         }
index e047a9e59cd09eb165e661dceb1b6c8e6fb5eb58..80635f294f1859e49cc5f506aa6ebcd4a5cf6a20 100644 (file)
@@ -72,7 +72,7 @@ int mutt_complete(char *buf, size_t buflen)
 #ifdef USE_NNTP
   if (OptNews)
   {
-    struct NntpServer *nserv = CurrentNewsSrv;
+    struct NntpAccountData *adata = CurrentNewsSrv;
     unsigned int n = 0;
 
     mutt_str_strfcpy(filepart, buf, sizeof(filepart));
@@ -82,13 +82,13 @@ int mutt_complete(char *buf, size_t buflen)
     len = mutt_str_strlen(filepart);
     if (len == 0)
     {
-      for (; n < nserv->groups_num; n++)
+      for (; n < adata->groups_num; n++)
       {
-        struct NntpMboxData *nntp_data = nserv->groups_list[n];
+        struct NntpMboxData *mdata = adata->groups_list[n];
 
-        if (nntp_data && nntp_data->subscribed)
+        if (mdata && mdata->subscribed)
         {
-          mutt_str_strfcpy(filepart, nntp_data->group, sizeof(filepart));
+          mutt_str_strfcpy(filepart, mdata->group, sizeof(filepart));
           init = 1;
           n++;
           break;
@@ -96,18 +96,18 @@ int mutt_complete(char *buf, size_t buflen)
       }
     }
 
-    for (; n < nserv->groups_num; n++)
+    for (; n < adata->groups_num; n++)
     {
-      struct NntpMboxData *nntp_data = nserv->groups_list[n];
+      struct NntpMboxData *mdata = adata->groups_list[n];
 
-      if (nntp_data && nntp_data->subscribed &&
-          (mutt_str_strncmp(nntp_data->group, filepart, len) == 0))
+      if (mdata && mdata->subscribed &&
+          (mutt_str_strncmp(mdata->group, filepart, len) == 0))
       {
         if (init)
         {
-          for (i = 0; filepart[i] && nntp_data->group[i]; i++)
+          for (i = 0; filepart[i] && mdata->group[i]; i++)
           {
-            if (filepart[i] != nntp_data->group[i])
+            if (filepart[i] != mdata->group[i])
             {
               filepart[i] = '\0';
               break;
@@ -117,7 +117,7 @@ int mutt_complete(char *buf, size_t buflen)
         }
         else
         {
-          mutt_str_strfcpy(filepart, nntp_data->group, sizeof(filepart));
+          mutt_str_strfcpy(filepart, mdata->group, sizeof(filepart));
           init = 1;
         }
       }
index 03c74682096bc4192fbceb6beb9d8ab9818bc345..082efe0bb7a43c52ae4741e91e957838566304cf 100644 (file)
@@ -3004,8 +3004,8 @@ int mutt_index_menu(void)
         CHECK_ATTACH
         if (Context && Context->mailbox->magic == MUTT_NNTP)
         {
-          struct NntpMboxData *nntp_data = Context->mailbox->data;
-          if (mutt_newsgroup_catchup(Context, nntp_data->nserv, nntp_data->group))
+          struct NntpMboxData *mdata = Context->mailbox->data;
+          if (mutt_newsgroup_catchup(Context, mdata->adata, mdata->group))
             menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
         }
         break;
diff --git a/mx.c b/mx.c
index 9cd1274cf3eb7851e09b77b200263ea4fb7aa1ef..67ddbef5a49b5d6685f7d4bbea4f6c74b6149e1a 100644 (file)
--- a/mx.c
+++ b/mx.c
@@ -514,9 +514,9 @@ int mx_mbox_close(struct Context **pctx, int *index_hint)
 #ifdef USE_NNTP
   if (ctx->mailbox->msg_unread && ctx->mailbox->magic == MUTT_NNTP)
   {
-    struct NntpMboxData *nntp_data = ctx->mailbox->data;
+    struct NntpMboxData *mdata = ctx->mailbox->data;
 
-    if (nntp_data && nntp_data->nserv && nntp_data->group)
+    if (mdata && mdata->adata && mdata->group)
     {
       int rc = query_quadoption(CatchupNewsgroup, _("Mark all articles read?"));
       if (rc == MUTT_ABORT)
@@ -525,7 +525,7 @@ int mx_mbox_close(struct Context **pctx, int *index_hint)
         return -1;
       }
       else if (rc == MUTT_YES)
-        mutt_newsgroup_catchup(Context, nntp_data->nserv, nntp_data->group);
+        mutt_newsgroup_catchup(Context, mdata->adata, mdata->group);
     }
   }
 #endif
index de772469089bafa2ae47d980e86fa8ea29933ddf..847fde72e61e245c77574bb82307c1172d30cf2e 100644 (file)
@@ -69,14 +69,14 @@ struct BodyCache;
 
 /**
  * mdata_find - Find NntpMboxData for given newsgroup or add it
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param group Newsgroup
  * @retval ptr  NNTP data
  * @retval NULL Error
  */
-static struct NntpMboxData *mdata_find(struct NntpServer *nserv, const char *group)
+static struct NntpMboxData *mdata_find(struct NntpAccountData *adata, const char *group)
 {
-  struct NntpMboxData *mdata = mutt_hash_find(nserv->groups_hash, group);
+  struct NntpMboxData *mdata = mutt_hash_find(adata->groups_hash, group);
   if (mdata)
     return mdata;
 
@@ -85,17 +85,17 @@ static struct NntpMboxData *mdata_find(struct NntpServer *nserv, const char *gro
   mdata = mutt_mem_calloc(1, sizeof(struct NntpMboxData) + len);
   mdata->group = (char *) mdata + sizeof(struct NntpMboxData);
   mutt_str_strfcpy(mdata->group, group, len);
-  mdata->nserv = nserv;
+  mdata->adata = adata;
   mdata->deleted = true;
-  mutt_hash_insert(nserv->groups_hash, mdata->group, mdata);
+  mutt_hash_insert(adata->groups_hash, mdata->group, mdata);
 
   /* add NntpMboxData to list */
-  if (nserv->groups_num >= nserv->groups_max)
+  if (adata->groups_num >= adata->groups_max)
   {
-    nserv->groups_max *= 2;
-    mutt_mem_realloc(&nserv->groups_list, nserv->groups_max * sizeof(mdata));
+    adata->groups_max *= 2;
+    mutt_mem_realloc(&adata->groups_list, adata->groups_max * sizeof(mdata));
   }
-  nserv->groups_list[nserv->groups_num++] = mdata;
+  adata->groups_list[adata->groups_num++] = mdata;
 
   return mdata;
 }
@@ -143,16 +143,16 @@ void nntp_hash_destructor_t(int type, void *obj, intptr_t data)
 
 /**
  * nntp_newsrc_close - Unlock and close .newsrc file
- * @param nserv NNTP server
+ * @param adata NNTP server
  */
-void nntp_newsrc_close(struct NntpServer *nserv)
+void nntp_newsrc_close(struct NntpAccountData *adata)
 {
-  if (!nserv->newsrc_fp)
+  if (!adata->newsrc_fp)
     return;
 
-  mutt_debug(1, "Unlocking %s\n", nserv->newsrc_file);
-  mutt_file_unlock(fileno(nserv->newsrc_fp));
-  mutt_file_fclose(&nserv->newsrc_fp);
+  mutt_debug(1, "Unlocking %s\n", adata->newsrc_file);
+  mutt_file_unlock(fileno(adata->newsrc_fp));
+  mutt_file_fclose(&adata->newsrc_fp);
 }
 
 /**
@@ -181,63 +181,63 @@ void nntp_group_unread_stat(struct NntpMboxData *mdata)
 
 /**
  * nntp_newsrc_parse - Parse .newsrc file
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Not changed
  * @retval  1 Parsed
  * @retval -1 Error
  */
-int nntp_newsrc_parse(struct NntpServer *nserv)
+int nntp_newsrc_parse(struct NntpAccountData *adata)
 {
   char *line = NULL;
   struct stat sb;
 
-  if (nserv->newsrc_fp)
+  if (adata->newsrc_fp)
   {
     /* if we already have a handle, close it and reopen */
-    mutt_file_fclose(&nserv->newsrc_fp);
+    mutt_file_fclose(&adata->newsrc_fp);
   }
   else
   {
     /* if file doesn't exist, create it */
-    nserv->newsrc_fp = mutt_file_fopen(nserv->newsrc_file, "a");
-    mutt_file_fclose(&nserv->newsrc_fp);
+    adata->newsrc_fp = mutt_file_fopen(adata->newsrc_file, "a");
+    mutt_file_fclose(&adata->newsrc_fp);
   }
 
   /* open .newsrc */
-  nserv->newsrc_fp = mutt_file_fopen(nserv->newsrc_file, "r");
-  if (!nserv->newsrc_fp)
+  adata->newsrc_fp = mutt_file_fopen(adata->newsrc_file, "r");
+  if (!adata->newsrc_fp)
   {
-    mutt_perror(nserv->newsrc_file);
+    mutt_perror(adata->newsrc_file);
     return -1;
   }
 
   /* lock it */
-  mutt_debug(1, "Locking %s\n", nserv->newsrc_file);
-  if (mutt_file_lock(fileno(nserv->newsrc_fp), false, true))
+  mutt_debug(1, "Locking %s\n", adata->newsrc_file);
+  if (mutt_file_lock(fileno(adata->newsrc_fp), false, true))
   {
-    mutt_file_fclose(&nserv->newsrc_fp);
+    mutt_file_fclose(&adata->newsrc_fp);
     return -1;
   }
 
-  if (stat(nserv->newsrc_file, &sb))
+  if (stat(adata->newsrc_file, &sb))
   {
-    mutt_perror(nserv->newsrc_file);
-    nntp_newsrc_close(nserv);
+    mutt_perror(adata->newsrc_file);
+    nntp_newsrc_close(adata);
     return -1;
   }
 
-  if (nserv->size == sb.st_size && nserv->mtime == sb.st_mtime)
+  if (adata->size == sb.st_size && adata->mtime == sb.st_mtime)
     return 0;
 
-  nserv->size = sb.st_size;
-  nserv->mtime = sb.st_mtime;
-  nserv->newsrc_modified = true;
-  mutt_debug(1, "Parsing %s\n", nserv->newsrc_file);
+  adata->size = sb.st_size;
+  adata->mtime = sb.st_mtime;
+  adata->newsrc_modified = true;
+  mutt_debug(1, "Parsing %s\n", adata->newsrc_file);
 
   /* .newsrc has been externally modified or hasn't been loaded yet */
-  for (unsigned int i = 0; i < nserv->groups_num; i++)
+  for (unsigned int i = 0; i < adata->groups_num; i++)
   {
-    struct NntpMboxData *mdata = nserv->groups_list[i];
+    struct NntpMboxData *mdata = adata->groups_list[i];
 
     if (!mdata)
       continue;
@@ -248,7 +248,7 @@ int nntp_newsrc_parse(struct NntpServer *nserv)
   }
 
   line = mutt_mem_malloc(sb.st_size + 1);
-  while (sb.st_size && fgets(line, sb.st_size + 1, nserv->newsrc_fp))
+  while (sb.st_size && fgets(line, sb.st_size + 1, adata->newsrc_fp))
   {
     char *b = NULL, *h = NULL;
     unsigned int j = 1;
@@ -265,7 +265,7 @@ int nntp_newsrc_parse(struct NntpServer *nserv)
     *p++ = '\0';
 
     /* get newsgroup data */
-    struct NntpMboxData *mdata = mdata_find(nserv, line);
+    struct NntpMboxData *mdata = mdata_find(adata, line);
     FREE(&mdata->newsrc_ent);
 
     /* count number of entries */
@@ -455,17 +455,17 @@ static int update_file(char *filename, char *buf)
 
 /**
  * nntp_newsrc_update - Update .newsrc file
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Success
  * @retval -1 Failure
  */
-int nntp_newsrc_update(struct NntpServer *nserv)
+int nntp_newsrc_update(struct NntpAccountData *adata)
 {
   char *buf = NULL;
   size_t buflen, off;
   int rc = -1;
 
-  if (!nserv)
+  if (!adata)
     return -1;
 
   buflen = 10 * LONG_STRING;
@@ -473,9 +473,9 @@ int nntp_newsrc_update(struct NntpServer *nserv)
   off = 0;
 
   /* we will generate full newsrc here */
-  for (unsigned int i = 0; i < nserv->groups_num; i++)
+  for (unsigned int i = 0; i < adata->groups_num; i++)
   {
-    struct NntpMboxData *mdata = nserv->groups_list[i];
+    struct NntpMboxData *mdata = adata->groups_list[i];
 
     if (!mdata || !mdata->newsrc_ent)
       continue;
@@ -513,20 +513,20 @@ int nntp_newsrc_update(struct NntpServer *nserv)
   buf[off] = '\0';
 
   /* newrc being fully rewritten */
-  mutt_debug(1, "Updating %s\n", nserv->newsrc_file);
-  if (nserv->newsrc_file && update_file(nserv->newsrc_file, buf) == 0)
+  mutt_debug(1, "Updating %s\n", adata->newsrc_file);
+  if (adata->newsrc_file && update_file(adata->newsrc_file, buf) == 0)
   {
     struct stat sb;
 
-    rc = stat(nserv->newsrc_file, &sb);
+    rc = stat(adata->newsrc_file, &sb);
     if (rc == 0)
     {
-      nserv->size = sb.st_size;
-      nserv->mtime = sb.st_mtime;
+      adata->size = sb.st_size;
+      adata->mtime = sb.st_mtime;
     }
     else
     {
-      mutt_perror(nserv->newsrc_file);
+      mutt_perror(adata->newsrc_file);
     }
   }
   FREE(&buf);
@@ -591,14 +591,14 @@ void nntp_expand_path(char *buf, size_t buflen, struct ConnAccount *acct)
  */
 int nntp_add_group(char *line, void *data)
 {
-  struct NntpServer *nserv = data;
+  struct NntpAccountData *adata = data;
   struct NntpMboxData *mdata = NULL;
   char group[LONG_STRING] = "";
   char desc[HUGE_STRING] = "";
   char mod;
   anum_t first, last;
 
-  if (!nserv || !line)
+  if (!adata || !line)
     return 0;
 
   /* These sscanf limits must match the sizes of the group and desc arrays */
@@ -609,7 +609,7 @@ int nntp_add_group(char *line, void *data)
     return 0;
   }
 
-  mdata = mdata_find(nserv, group);
+  mdata = mdata_find(adata, group);
   mdata->deleted = false;
   mdata->first_message = first;
   mdata->last_message = last;
@@ -626,17 +626,17 @@ int nntp_add_group(char *line, void *data)
 
 /**
  * active_get_cache - Load list of all newsgroups from cache
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Success
  * @retval -1 Failure
  */
-static int active_get_cache(struct NntpServer *nserv)
+static int active_get_cache(struct NntpAccountData *adata)
 {
   char buf[HUGE_STRING];
   char file[PATH_MAX];
   time_t t;
 
-  cache_expand(file, sizeof(file), &nserv->conn->account, ".active");
+  cache_expand(file, sizeof(file), &adata->conn->account, ".active");
   mutt_debug(1, "Parsing %s\n", file);
   FILE *fp = mutt_file_fopen(file, "r");
   if (!fp)
@@ -647,11 +647,11 @@ static int active_get_cache(struct NntpServer *nserv)
     mutt_file_fclose(&fp);
     return -1;
   }
-  nserv->newgroups_time = t;
+  adata->newgroups_time = t;
 
   mutt_message(_("Loading list of groups from cache..."));
   while (fgets(buf, sizeof(buf), fp))
-    nntp_add_group(buf, nserv);
+    nntp_add_group(buf, adata);
   nntp_add_group(NULL, NULL);
   mutt_file_fclose(&fp);
   mutt_clear_error();
@@ -660,28 +660,28 @@ static int active_get_cache(struct NntpServer *nserv)
 
 /**
  * nntp_active_save_cache - Save list of all newsgroups to cache
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Success
  * @retval -1 Failure
  */
-int nntp_active_save_cache(struct NntpServer *nserv)
+int nntp_active_save_cache(struct NntpAccountData *adata)
 {
   char file[PATH_MAX];
   char *buf = NULL;
   size_t buflen, off;
   int rc;
 
-  if (!nserv->cacheable)
+  if (!adata->cacheable)
     return 0;
 
   buflen = 10 * LONG_STRING;
   buf = mutt_mem_calloc(1, buflen);
-  snprintf(buf, buflen, "%lu\n", (unsigned long) nserv->newgroups_time);
+  snprintf(buf, buflen, "%lu\n", (unsigned long) adata->newgroups_time);
   off = strlen(buf);
 
-  for (unsigned int i = 0; i < nserv->groups_num; i++)
+  for (unsigned int i = 0; i < adata->groups_num; i++)
   {
-    struct NntpMboxData *mdata = nserv->groups_list[i];
+    struct NntpMboxData *mdata = adata->groups_list[i];
 
     if (!mdata || mdata->deleted)
       continue;
@@ -697,7 +697,7 @@ int nntp_active_save_cache(struct NntpServer *nserv)
     off += strlen(buf + off);
   }
 
-  cache_expand(file, sizeof(file), &nserv->conn->account, ".active");
+  cache_expand(file, sizeof(file), &adata->conn->account, ".active");
   mutt_debug(1, "Updating %s\n", file);
   rc = update_file(file, buf);
   FREE(&buf);
@@ -735,13 +735,13 @@ header_cache_t *nntp_hcache_open(struct NntpMboxData *mdata)
   struct Url url;
   char file[PATH_MAX];
 
-  if (!mdata->nserv || !mdata->nserv->cacheable || !mdata->nserv->conn ||
+  if (!mdata->adata || !mdata->adata->cacheable || !mdata->adata->conn ||
       !mdata->group || !(mdata->newsrc_ent || mdata->subscribed || SaveUnsubscribed))
   {
     return NULL;
   }
 
-  mutt_account_tourl(&mdata->nserv->conn->account, &url);
+  mutt_account_tourl(&mdata->adata->conn->account, &url);
   url.path = mdata->group;
   url_tostring(&url, file, sizeof(file), U_PATH);
   return mutt_hcache_open(NewsCacheDir, file, nntp_hcache_namer);
@@ -831,13 +831,13 @@ void nntp_bcache_update(struct NntpMboxData *mdata)
  */
 void nntp_delete_group_cache(struct NntpMboxData *mdata)
 {
-  if (!mdata || !mdata->nserv || !mdata->nserv->cacheable)
+  if (!mdata || !mdata->adata || !mdata->adata->cacheable)
     return;
 
 #ifdef USE_HCACHE
   char file[PATH_MAX];
   nntp_hcache_namer(mdata->group, file, sizeof(file));
-  cache_expand(file, sizeof(file), &mdata->nserv->conn->account, file);
+  cache_expand(file, sizeof(file), &mdata->adata->conn->account, file);
   unlink(file);
   mdata->last_cached = 0;
   mutt_debug(2, "%s\n", file);
@@ -845,7 +845,7 @@ void nntp_delete_group_cache(struct NntpMboxData *mdata)
 
   if (!mdata->bcache)
   {
-    mdata->bcache = mutt_bcache_open(&mdata->nserv->conn->account, mdata->group);
+    mdata->bcache = mutt_bcache_open(&mdata->adata->conn->account, mdata->group);
   }
   if (mdata->bcache)
   {
@@ -857,21 +857,21 @@ void nntp_delete_group_cache(struct NntpMboxData *mdata)
 
 /**
  * nntp_clear_cache - Clear the NNTP cache
- * @param nserv NNTP server
+ * @param adata NNTP server
  *
  * Remove hcache and bcache of all unexistent and unsubscribed newsgroups
  */
-void nntp_clear_cache(struct NntpServer *nserv)
+void nntp_clear_cache(struct NntpAccountData *adata)
 {
   char file[PATH_MAX];
   char *fp = NULL;
   struct dirent *entry = NULL;
   DIR *dp = NULL;
 
-  if (!nserv || !nserv->cacheable)
+  if (!adata || !adata->cacheable)
     return;
 
-  cache_expand(file, sizeof(file), &nserv->conn->account, NULL);
+  cache_expand(file, sizeof(file), &adata->conn->account, NULL);
   dp = opendir(file);
   if (dp)
   {
@@ -882,7 +882,7 @@ void nntp_clear_cache(struct NntpServer *nserv)
       char *group = entry->d_name;
       struct stat sb;
       struct NntpMboxData *mdata = NULL;
-      struct NntpMboxData nntp_tmp;
+      struct NntpMboxData tmp_mdata;
 
       if ((mutt_str_strcmp(group, ".") == 0) || (mutt_str_strcmp(group, "..") == 0))
         continue;
@@ -904,11 +904,11 @@ void nntp_clear_cache(struct NntpServer *nserv)
           if (!S_ISDIR(sb.st_mode))
         continue;
 
-      mdata = mutt_hash_find(nserv->groups_hash, group);
+      mdata = mutt_hash_find(adata->groups_hash, group);
       if (!mdata)
       {
-        mdata = &nntp_tmp;
-        mdata->nserv = nserv;
+        mdata = &tmp_mdata;
+        mdata->adata = adata;
         mdata->group = group;
         mdata->bcache = NULL;
       }
@@ -942,8 +942,8 @@ const char *nntp_format_str(char *buf, size_t buflen, size_t col, int cols, char
                             const char *src, const char *prec, const char *if_str,
                             const char *else_str, unsigned long data, enum FormatFlag flags)
 {
-  struct NntpServer *nserv = (struct NntpServer *) data;
-  struct ConnAccount *acct = &nserv->conn->account;
+  struct NntpAccountData *adata = (struct NntpAccountData *) data;
+  struct ConnAccount *acct = &adata->conn->account;
   struct Url url;
   char fn[SHORT_STRING], fmt[SHORT_STRING], *p = NULL;
 
@@ -1006,7 +1006,7 @@ const char *nntp_format_str(char *buf, size_t buflen, size_t col, int cols, char
  * system has broken mtimes, this might mean the file is reloaded every time,
  * which we'd have to fix.
  */
-struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, bool leave_lock)
+struct NntpAccountData *nntp_select_server(struct Mailbox *mailbox, char *server, bool leave_lock)
 {
   char file[PATH_MAX];
 #ifdef USE_HCACHE
@@ -1014,7 +1014,7 @@ struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, boo
 #endif
   int rc;
   struct ConnAccount acct;
-  struct NntpServer *nserv = NULL;
+  struct NntpAccountData *adata = NULL;
   struct NntpMboxData *mdata = NULL;
   struct Connection *conn = NULL;
   struct Url url;
@@ -1056,42 +1056,42 @@ struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, boo
   }
 
   /* news server already exists */
-  nserv = conn->data;
-  if (nserv)
+  adata = conn->data;
+  if (adata)
   {
-    if (nserv->status == NNTP_BYE)
-      nserv->status = NNTP_NONE;
-    if (nntp_open_connection(nserv) < 0)
+    if (adata->status == NNTP_BYE)
+      adata->status = NNTP_NONE;
+    if (nntp_open_connection(adata) < 0)
       return NULL;
 
-    rc = nntp_newsrc_parse(nserv);
+    rc = nntp_newsrc_parse(adata);
     if (rc < 0)
       return NULL;
 
     /* check for new newsgroups */
-    if (!leave_lock && nntp_check_new_groups(mailbox, nserv) < 0)
+    if (!leave_lock && nntp_check_new_groups(mailbox, adata) < 0)
       rc = -1;
 
     /* .newsrc has been externally modified */
     if (rc > 0)
-      nntp_clear_cache(nserv);
+      nntp_clear_cache(adata);
     if (rc < 0 || !leave_lock)
-      nntp_newsrc_close(nserv);
-    return (rc < 0) ? NULL : nserv;
+      nntp_newsrc_close(adata);
+    return (rc < 0) ? NULL : adata;
   }
 
   /* new news server */
-  nserv = mutt_mem_calloc(1, sizeof(struct NntpServer));
-  nserv->conn = conn;
-  nserv->groups_hash = mutt_hash_create(1009, 0);
-  mutt_hash_set_destructor(nserv->groups_hash, nntp_hash_destructor_t, 0);
-  nserv->groups_max = 16;
-  nserv->groups_list = mutt_mem_malloc(nserv->groups_max * sizeof(mdata));
+  adata = mutt_mem_calloc(1, sizeof(struct NntpAccountData));
+  adata->conn = conn;
+  adata->groups_hash = mutt_hash_create(1009, 0);
+  mutt_hash_set_destructor(adata->groups_hash, nntp_hash_destructor_t, 0);
+  adata->groups_max = 16;
+  adata->groups_list = mutt_mem_malloc(adata->groups_max * sizeof(mdata));
 
-  rc = nntp_open_connection(nserv);
+  rc = nntp_open_connection(adata);
 
   /* try to create cache directory and enable caching */
-  nserv->cacheable = false;
+  adata->cacheable = false;
   if (rc >= 0 && NewsCacheDir && *NewsCacheDir)
   {
     cache_expand(file, sizeof(file), &conn->account, NULL);
@@ -1099,35 +1099,35 @@ struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, boo
     {
       mutt_error(_("Can't create %s: %s"), file, strerror(errno));
     }
-    nserv->cacheable = true;
+    adata->cacheable = true;
   }
 
   /* load .newsrc */
   if (rc >= 0)
   {
     mutt_expando_format(file, sizeof(file), 0, MuttIndexWindow->cols,
-                        NONULL(Newsrc), nntp_format_str, (unsigned long) nserv, 0);
+                        NONULL(Newsrc), nntp_format_str, (unsigned long) adata, 0);
     mutt_expand_path(file, sizeof(file));
-    nserv->newsrc_file = mutt_str_strdup(file);
-    rc = nntp_newsrc_parse(nserv);
+    adata->newsrc_file = mutt_str_strdup(file);
+    rc = nntp_newsrc_parse(adata);
   }
   if (rc >= 0)
   {
     /* try to load list of newsgroups from cache */
-    if (nserv->cacheable && active_get_cache(nserv) == 0)
-      rc = nntp_check_new_groups(mailbox, nserv);
+    if (adata->cacheable && active_get_cache(adata) == 0)
+      rc = nntp_check_new_groups(mailbox, adata);
 
     /* load list of newsgroups from server */
     else
-      rc = nntp_active_fetch(nserv, false);
+      rc = nntp_active_fetch(adata, false);
   }
 
   if (rc >= 0)
-    nntp_clear_cache(nserv);
+    nntp_clear_cache(adata);
 
 #ifdef USE_HCACHE
   /* check cache files */
-  if (rc >= 0 && nserv->cacheable)
+  if (rc >= 0 && adata->cacheable)
   {
     struct dirent *entry = NULL;
     DIR *dp = opendir(file);
@@ -1144,7 +1144,7 @@ struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, boo
         if (strlen(group) < 8 || (strcmp(p, ".hcache") != 0))
           continue;
         *p = '\0';
-        mdata = mutt_hash_find(nserv->groups_hash, group);
+        mdata = mutt_hash_find(adata->groups_hash, group);
         if (!mdata)
           continue;
 
@@ -1181,22 +1181,22 @@ struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, boo
 #endif
 
   if (rc < 0 || !leave_lock)
-    nntp_newsrc_close(nserv);
+    nntp_newsrc_close(adata);
 
   if (rc < 0)
   {
-    mutt_hash_destroy(&nserv->groups_hash);
-    FREE(&nserv->groups_list);
-    FREE(&nserv->newsrc_file);
-    FREE(&nserv->authenticators);
-    FREE(&nserv);
+    mutt_hash_destroy(&adata->groups_hash);
+    FREE(&adata->groups_list);
+    FREE(&adata->newsrc_file);
+    FREE(&adata->authenticators);
+    FREE(&adata);
     mutt_socket_close(conn);
     mutt_socket_free(conn);
     return NULL;
   }
 
-  conn->data = nserv;
-  return nserv;
+  conn->data = adata;
+  return adata;
 }
 
 /**
@@ -1216,7 +1216,7 @@ void nntp_article_status(struct Mailbox *mailbox, struct Email *e, char *group,
   struct NntpMboxData *mdata = mailbox->data;
 
   if (group)
-    mdata = mutt_hash_find(mdata->nserv->groups_hash, group);
+    mdata = mutt_hash_find(mdata->adata->groups_hash, group);
 
   if (!mdata)
     return;
@@ -1243,19 +1243,19 @@ void nntp_article_status(struct Mailbox *mailbox, struct Email *e, char *group,
 
 /**
  * mutt_newsgroup_subscribe - Subscribe newsgroup
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param group Newsgroup
  * @retval ptr  NNTP data
  * @retval NULL Error
  */
-struct NntpMboxData *mutt_newsgroup_subscribe(struct NntpServer *nserv, char *group)
+struct NntpMboxData *mutt_newsgroup_subscribe(struct NntpAccountData *adata, char *group)
 {
   struct NntpMboxData *mdata = NULL;
 
-  if (!nserv || !nserv->groups_hash || !group || !*group)
+  if (!adata || !adata->groups_hash || !group || !*group)
     return NULL;
 
-  mdata = mdata_find(nserv, group);
+  mdata = mdata_find(adata, group);
   mdata->subscribed = true;
   if (!mdata->newsrc_ent)
   {
@@ -1269,19 +1269,19 @@ struct NntpMboxData *mutt_newsgroup_subscribe(struct NntpServer *nserv, char *gr
 
 /**
  * mutt_newsgroup_unsubscribe - Unsubscribe newsgroup
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param group Newsgroup
  * @retval ptr  NNTP data
  * @retval NULL Error
  */
-struct NntpMboxData *mutt_newsgroup_unsubscribe(struct NntpServer *nserv, char *group)
+struct NntpMboxData *mutt_newsgroup_unsubscribe(struct NntpAccountData *adata, char *group)
 {
   struct NntpMboxData *mdata = NULL;
 
-  if (!nserv || !nserv->groups_hash || !group || !*group)
+  if (!adata || !adata->groups_hash || !group || !*group)
     return NULL;
 
-  mdata = mutt_hash_find(nserv->groups_hash, group);
+  mdata = mutt_hash_find(adata->groups_hash, group);
   if (!mdata)
     return NULL;
 
@@ -1297,20 +1297,20 @@ struct NntpMboxData *mutt_newsgroup_unsubscribe(struct NntpServer *nserv, char *
 /**
  * mutt_newsgroup_catchup - Catchup newsgroup
  * @param ctx   Mailbox
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param group Newsgroup
  * @retval ptr  NNTP data
  * @retval NULL Error
  */
 struct NntpMboxData *mutt_newsgroup_catchup(struct Context *ctx,
-                                            struct NntpServer *nserv, char *group)
+                                            struct NntpAccountData *adata, char *group)
 {
   struct NntpMboxData *mdata = NULL;
 
-  if (!nserv || !nserv->groups_hash || !group || !*group)
+  if (!adata || !adata->groups_hash || !group || !*group)
     return NULL;
 
-  mdata = mutt_hash_find(nserv->groups_hash, group);
+  mdata = mutt_hash_find(adata->groups_hash, group);
   if (!mdata)
     return NULL;
 
@@ -1333,20 +1333,20 @@ struct NntpMboxData *mutt_newsgroup_catchup(struct Context *ctx,
 /**
  * mutt_newsgroup_uncatchup - Uncatchup newsgroup
  * @param ctx   Mailbox
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param group Newsgroup
  * @retval ptr  NNTP data
  * @retval NULL Error
  */
 struct NntpMboxData *mutt_newsgroup_uncatchup(struct Context *ctx,
-                                              struct NntpServer *nserv, char *group)
+                                              struct NntpAccountData *adata, char *group)
 {
   struct NntpMboxData *mdata = NULL;
 
-  if (!nserv || !nserv->groups_hash || !group || !*group)
+  if (!adata || !adata->groups_hash || !group || !*group)
     return NULL;
 
-  mdata = mutt_hash_find(nserv->groups_hash, group);
+  mdata = mutt_hash_find(adata->groups_hash, group);
   if (!mdata)
     return NULL;
 
index 275f0867664d992c17484fa28b8fca2322766db3..a2ba456078e25ad1e77f7eeba8b5a18918d39377 100644 (file)
@@ -73,7 +73,7 @@ bool NntpLoadDescription; ///< Config: (nntp) Load descriptions for newsgroups w
 short NntpPoll; ///< Config: (nntp) Interval between checks for new posts
 bool ShowNewNews; ///< Config: (nntp) Check for new newsgroups when entering the browser
 
-struct NntpServer *CurrentNewsSrv;
+struct NntpAccountData *CurrentNewsSrv;
 
 const char *OverviewFmt = "Subject:\0"
                           "From:\0"
@@ -131,64 +131,64 @@ static struct NntpEmailData *new_emaildata(void)
 
 /**
  * nntp_connect_error - Signal a failed connection
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval -1 Always
  */
-static int nntp_connect_error(struct NntpServer *nserv)
+static int nntp_connect_error(struct NntpAccountData *adata)
 {
-  nserv->status = NNTP_NONE;
+  adata->status = NNTP_NONE;
   mutt_error(_("Server closed connection"));
   return -1;
 }
 
 /**
  * nntp_capabilities - Get capabilities
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval -1 Error, connection is closed
  * @retval  0 Mode is reader, capabilities set up
  * @retval  1 Need to switch to reader mode
  */
-static int nntp_capabilities(struct NntpServer *nserv)
+static int nntp_capabilities(struct NntpAccountData *adata)
 {
-  struct Connection *conn = nserv->conn;
+  struct Connection *conn = adata->conn;
   bool mode_reader = false;
   char buf[LONG_STRING];
   char authinfo[LONG_STRING] = "";
 
-  nserv->hasCAPABILITIES = false;
-  nserv->hasSTARTTLS = false;
-  nserv->hasDATE = false;
-  nserv->hasLIST_NEWSGROUPS = false;
-  nserv->hasLISTGROUP = false;
-  nserv->hasLISTGROUPrange = false;
-  nserv->hasOVER = false;
-  FREE(&nserv->authenticators);
+  adata->hasCAPABILITIES = false;
+  adata->hasSTARTTLS = false;
+  adata->hasDATE = false;
+  adata->hasLIST_NEWSGROUPS = false;
+  adata->hasLISTGROUP = false;
+  adata->hasLISTGROUPrange = false;
+  adata->hasOVER = false;
+  FREE(&adata->authenticators);
 
   if (mutt_socket_send(conn, "CAPABILITIES\r\n") < 0 ||
       mutt_socket_readln(buf, sizeof(buf), conn) < 0)
   {
-    return nntp_connect_error(nserv);
+    return nntp_connect_error(adata);
   }
 
   /* no capabilities */
   if (mutt_str_strncmp("101", buf, 3) != 0)
     return 1;
-  nserv->hasCAPABILITIES = true;
+  adata->hasCAPABILITIES = true;
 
   /* parse capabilities */
   do
   {
     if (mutt_socket_readln(buf, sizeof(buf), conn) < 0)
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     if (mutt_str_strcmp("STARTTLS", buf) == 0)
-      nserv->hasSTARTTLS = true;
+      adata->hasSTARTTLS = true;
     else if (mutt_str_strcmp("MODE-READER", buf) == 0)
       mode_reader = true;
     else if (mutt_str_strcmp("READER", buf) == 0)
     {
-      nserv->hasDATE = true;
-      nserv->hasLISTGROUP = true;
-      nserv->hasLISTGROUPrange = true;
+      adata->hasDATE = true;
+      adata->hasLISTGROUP = true;
+      adata->hasLISTGROUPrange = true;
     }
     else if (mutt_str_strncmp("AUTHINFO ", buf, 9) == 0)
     {
@@ -201,11 +201,11 @@ static int nntp_capabilities(struct NntpServer *nserv)
       char *p = buf + 5;
       while (*p == ' ')
         p++;
-      nserv->authenticators = mutt_str_strdup(p);
+      adata->authenticators = mutt_str_strdup(p);
     }
 #endif
     else if (mutt_str_strcmp("OVER", buf) == 0)
-      nserv->hasOVER = true;
+      adata->hasOVER = true;
     else if (mutt_str_strncmp("LIST ", buf, 5) == 0)
     {
       char *p = strstr(buf, " NEWSGROUPS");
@@ -213,14 +213,14 @@ static int nntp_capabilities(struct NntpServer *nserv)
       {
         p += 11;
         if (*p == '\0' || *p == ' ')
-          nserv->hasLIST_NEWSGROUPS = true;
+          adata->hasLIST_NEWSGROUPS = true;
       }
     }
   } while (mutt_str_strcmp(".", buf) != 0);
   *buf = '\0';
 #ifdef USE_SASL
-  if (nserv->authenticators && strcasestr(authinfo, " SASL "))
-    mutt_str_strfcpy(buf, nserv->authenticators, sizeof(buf));
+  if (adata->authenticators && strcasestr(authinfo, " SASL "))
+    mutt_str_strfcpy(buf, adata->authenticators, sizeof(buf));
 #endif
   if (strcasestr(authinfo, " USER "))
   {
@@ -228,10 +228,10 @@ static int nntp_capabilities(struct NntpServer *nserv)
       mutt_str_strcat(buf, sizeof(buf), " ");
     mutt_str_strcat(buf, sizeof(buf), "USER");
   }
-  mutt_str_replace(&nserv->authenticators, buf);
+  mutt_str_replace(&adata->authenticators, buf);
 
   /* current mode is reader */
-  if (nserv->hasDATE)
+  if (adata->hasDATE)
     return 0;
 
   /* server is mode-switching, need to switch to reader mode */
@@ -239,148 +239,148 @@ static int nntp_capabilities(struct NntpServer *nserv)
     return 1;
 
   mutt_socket_close(conn);
-  nserv->status = NNTP_BYE;
+  adata->status = NNTP_BYE;
   mutt_error(_("Server doesn't support reader mode"));
   return -1;
 }
 
 /**
  * nntp_attempt_features - Detect supported commands
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Success
  * @retval -1 Failure
  */
-static int nntp_attempt_features(struct NntpServer *nserv)
+static int nntp_attempt_features(struct NntpAccountData *adata)
 {
-  struct Connection *conn = nserv->conn;
+  struct Connection *conn = adata->conn;
   char buf[LONG_STRING];
 
   /* no CAPABILITIES, trying DATE, LISTGROUP, LIST NEWSGROUPS */
-  if (!nserv->hasCAPABILITIES)
+  if (!adata->hasCAPABILITIES)
   {
     if (mutt_socket_send(conn, "DATE\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("500", buf, 3) != 0)
-      nserv->hasDATE = true;
+      adata->hasDATE = true;
 
     if (mutt_socket_send(conn, "LISTGROUP\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("500", buf, 3) != 0)
-      nserv->hasLISTGROUP = true;
+      adata->hasLISTGROUP = true;
 
     if (mutt_socket_send(conn, "LIST NEWSGROUPS +\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("500", buf, 3) != 0)
-      nserv->hasLIST_NEWSGROUPS = true;
+      adata->hasLIST_NEWSGROUPS = true;
     if (mutt_str_strncmp("215", buf, 3) == 0)
     {
       do
       {
         if (mutt_socket_readln(buf, sizeof(buf), conn) < 0)
-          return nntp_connect_error(nserv);
+          return nntp_connect_error(adata);
       } while (mutt_str_strcmp(".", buf) != 0);
     }
   }
 
   /* no LIST NEWSGROUPS, trying XGTITLE */
-  if (!nserv->hasLIST_NEWSGROUPS)
+  if (!adata->hasLIST_NEWSGROUPS)
   {
     if (mutt_socket_send(conn, "XGTITLE\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("500", buf, 3) != 0)
-      nserv->hasXGTITLE = true;
+      adata->hasXGTITLE = true;
   }
 
   /* no OVER, trying XOVER */
-  if (!nserv->hasOVER)
+  if (!adata->hasOVER)
   {
     if (mutt_socket_send(conn, "XOVER\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("500", buf, 3) != 0)
-      nserv->hasXOVER = true;
+      adata->hasXOVER = true;
   }
 
   /* trying LIST OVERVIEW.FMT */
-  if (nserv->hasOVER || nserv->hasXOVER)
+  if (adata->hasOVER || adata->hasXOVER)
   {
     if (mutt_socket_send(conn, "LIST OVERVIEW.FMT\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("215", buf, 3) != 0)
-      nserv->overview_fmt = mutt_str_strdup(OverviewFmt);
+      adata->overview_fmt = mutt_str_strdup(OverviewFmt);
     else
     {
       int cont = 0;
       size_t buflen = 2 * LONG_STRING, off = 0, b = 0;
 
-      if (nserv->overview_fmt)
-        FREE(&nserv->overview_fmt);
-      nserv->overview_fmt = mutt_mem_malloc(buflen);
+      if (adata->overview_fmt)
+        FREE(&adata->overview_fmt);
+      adata->overview_fmt = mutt_mem_malloc(buflen);
 
       while (true)
       {
         if (buflen - off < LONG_STRING)
         {
           buflen *= 2;
-          mutt_mem_realloc(&nserv->overview_fmt, buflen);
+          mutt_mem_realloc(&adata->overview_fmt, buflen);
         }
 
         const int chunk =
-            mutt_socket_readln(nserv->overview_fmt + off, buflen - off, conn);
+            mutt_socket_readln(adata->overview_fmt + off, buflen - off, conn);
         if (chunk < 0)
         {
-          FREE(&nserv->overview_fmt);
-          return nntp_connect_error(nserv);
+          FREE(&adata->overview_fmt);
+          return nntp_connect_error(adata);
         }
 
-        if (!cont && (mutt_str_strcmp(".", nserv->overview_fmt + off) == 0))
+        if (!cont && (mutt_str_strcmp(".", adata->overview_fmt + off) == 0))
           break;
 
         cont = chunk >= buflen - off ? 1 : 0;
-        off += strlen(nserv->overview_fmt + off);
+        off += strlen(adata->overview_fmt + off);
         if (!cont)
         {
           char *colon = NULL;
 
-          if (nserv->overview_fmt[b] == ':')
+          if (adata->overview_fmt[b] == ':')
           {
-            memmove(nserv->overview_fmt + b, nserv->overview_fmt + b + 1, off - b - 1);
-            nserv->overview_fmt[off - 1] = ':';
+            memmove(adata->overview_fmt + b, adata->overview_fmt + b + 1, off - b - 1);
+            adata->overview_fmt[off - 1] = ':';
           }
-          colon = strchr(nserv->overview_fmt + b, ':');
+          colon = strchr(adata->overview_fmt + b, ':');
           if (!colon)
-            nserv->overview_fmt[off++] = ':';
+            adata->overview_fmt[off++] = ':';
           else if (strcmp(colon + 1, "full") != 0)
-            off = colon + 1 - nserv->overview_fmt;
-          if (strcasecmp(nserv->overview_fmt + b, "Bytes:") == 0)
+            off = colon + 1 - adata->overview_fmt;
+          if (strcasecmp(adata->overview_fmt + b, "Bytes:") == 0)
           {
-            size_t len = strlen(nserv->overview_fmt + b);
-            mutt_str_strfcpy(nserv->overview_fmt + b, "Content-Length:", len + 1);
+            size_t len = strlen(adata->overview_fmt + b);
+            mutt_str_strfcpy(adata->overview_fmt + b, "Content-Length:", len + 1);
             off = b + len;
           }
-          nserv->overview_fmt[off++] = '\0';
+          adata->overview_fmt[off++] = '\0';
           b = off;
         }
       }
-      nserv->overview_fmt[off++] = '\0';
-      mutt_mem_realloc(&nserv->overview_fmt, off);
+      adata->overview_fmt[off++] = '\0';
+      mutt_mem_realloc(&adata->overview_fmt, off);
     }
   }
   return 0;
@@ -388,13 +388,13 @@ static int nntp_attempt_features(struct NntpServer *nserv)
 
 /**
  * nntp_auth - Get login, password and authenticate
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Success
  * @retval -1 Failure
  */
-static int nntp_auth(struct NntpServer *nserv)
+static int nntp_auth(struct NntpAccountData *adata)
 {
-  struct Connection *conn = nserv->conn;
+  struct Connection *conn = adata->conn;
   char buf[LONG_STRING];
   char authenticators[LONG_STRING] = "USER";
   char *method = NULL, *a = NULL, *p = NULL;
@@ -412,9 +412,9 @@ static int nntp_auth(struct NntpServer *nserv)
     /* get list of authenticators */
     if (NntpAuthenticators && *NntpAuthenticators)
       mutt_str_strfcpy(authenticators, NntpAuthenticators, sizeof(authenticators));
-    else if (nserv->hasCAPABILITIES)
+    else if (adata->hasCAPABILITIES)
     {
-      mutt_str_strfcpy(authenticators, nserv->authenticators, sizeof(authenticators));
+      mutt_str_strfcpy(authenticators, adata->authenticators, sizeof(authenticators));
       p = authenticators;
       while (*p)
       {
@@ -430,7 +430,7 @@ static int nntp_auth(struct NntpServer *nserv)
       p++;
     }
 
-    mutt_debug(1, "available methods: %s\n", nserv->authenticators);
+    mutt_debug(1, "available methods: %s\n", adata->authenticators);
     a = authenticators;
     while (true)
     {
@@ -446,16 +446,16 @@ static int nntp_auth(struct NntpServer *nserv)
         *a++ = '\0';
 
       /* check authenticator */
-      if (nserv->hasCAPABILITIES)
+      if (adata->hasCAPABILITIES)
       {
         char *m = NULL;
 
-        if (!nserv->authenticators)
+        if (!adata->authenticators)
           continue;
-        m = strcasestr(nserv->authenticators, method);
+        m = strcasestr(adata->authenticators, method);
         if (!m)
           continue;
-        if (m > nserv->authenticators && *(m - 1) != ' ')
+        if (m > adata->authenticators && *(m - 1) != ' ')
           continue;
         m += strlen(method);
         if (*m != '\0' && *m != ' ')
@@ -663,7 +663,7 @@ static int nntp_auth(struct NntpServer *nserv)
   }
 
   /* error */
-  nserv->status = NNTP_BYE;
+  adata->status = NNTP_BYE;
   conn->account.flags = flags;
   if (conn->fd < 0)
   {
@@ -684,27 +684,27 @@ static int nntp_auth(struct NntpServer *nserv)
  */
 static int nntp_query(struct NntpMboxData *mdata, char *line, size_t linelen)
 {
-  struct NntpServer *nserv = mdata->nserv;
+  struct NntpAccountData *adata = mdata->adata;
   char buf[LONG_STRING] = { 0 };
 
-  if (nserv->status == NNTP_BYE)
+  if (adata->status == NNTP_BYE)
     return -1;
 
   while (true)
   {
-    if (nserv->status == NNTP_OK)
+    if (adata->status == NNTP_OK)
     {
       int rc = 0;
 
       if (*line)
-        rc = mutt_socket_send(nserv->conn, line);
+        rc = mutt_socket_send(adata->conn, line);
       else if (mdata->group)
       {
         snprintf(buf, sizeof(buf), "GROUP %s\r\n", mdata->group);
-        rc = mutt_socket_send(nserv->conn, buf);
+        rc = mutt_socket_send(adata->conn, buf);
       }
       if (rc >= 0)
-        rc = mutt_socket_readln(buf, sizeof(buf), nserv->conn);
+        rc = mutt_socket_readln(buf, sizeof(buf), adata->conn);
       if (rc >= 0)
         break;
     }
@@ -712,15 +712,15 @@ static int nntp_query(struct NntpMboxData *mdata, char *line, size_t linelen)
     /* reconnect */
     while (true)
     {
-      nserv->status = NNTP_NONE;
-      if (nntp_open_connection(nserv) == 0)
+      adata->status = NNTP_NONE;
+      if (nntp_open_connection(adata) == 0)
         break;
 
       snprintf(buf, sizeof(buf), _("Connection to %s lost. Reconnect?"),
-               nserv->conn->account.host);
+               adata->conn->account.host);
       if (mutt_yesorno(buf, MUTT_YES) != MUTT_YES)
       {
-        nserv->status = NNTP_BYE;
+        adata->status = NNTP_BYE;
         return -1;
       }
     }
@@ -729,10 +729,10 @@ static int nntp_query(struct NntpMboxData *mdata, char *line, size_t linelen)
     if (mdata->group)
     {
       snprintf(buf, sizeof(buf), "GROUP %s\r\n", mdata->group);
-      if (mutt_socket_send(nserv->conn, buf) < 0 ||
-          mutt_socket_readln(buf, sizeof(buf), nserv->conn) < 0)
+      if (mutt_socket_send(adata->conn, buf) < 0 ||
+          mutt_socket_readln(buf, sizeof(buf), adata->conn) < 0)
       {
-        return nntp_connect_error(nserv);
+        return nntp_connect_error(adata);
       }
     }
     if (!*line)
@@ -791,10 +791,10 @@ static int nntp_fetch_lines(struct NntpMboxData *mdata, char *query, size_t qlen
     while (true)
     {
       char *p = NULL;
-      int chunk = mutt_socket_readln_d(buf, sizeof(buf), mdata->nserv->conn, MUTT_SOCK_LOG_HDR);
+      int chunk = mutt_socket_readln_d(buf, sizeof(buf), mdata->adata->conn, MUTT_SOCK_LOG_HDR);
       if (chunk < 0)
       {
-        mdata->nserv->status = NNTP_NONE;
+        mdata->adata->status = NNTP_NONE;
         break;
       }
 
@@ -840,7 +840,7 @@ static int nntp_fetch_lines(struct NntpMboxData *mdata, char *query, size_t qlen
  */
 static int fetch_description(char *line, void *data)
 {
-  struct NntpServer *nserv = data;
+  struct NntpAccountData *adata = data;
   struct NntpMboxData *mdata = NULL;
   char *desc = NULL;
 
@@ -856,7 +856,7 @@ static int fetch_description(char *line, void *data)
   else
     desc = strchr(line, '\0');
 
-  mdata = mutt_hash_find(nserv->groups_hash, line);
+  mdata = mutt_hash_find(adata->groups_hash, line);
   if (mdata && (mutt_str_strcmp(desc, mdata->desc) != 0))
   {
     mutt_str_replace(&mdata->desc, desc);
@@ -881,18 +881,18 @@ static int get_description(struct NntpMboxData *mdata, const char *wildmat, cons
   const char *cmd = NULL;
 
   /* get newsgroup description, if possible */
-  struct NntpServer *nserv = mdata->nserv;
+  struct NntpAccountData *adata = mdata->adata;
   if (!wildmat)
     wildmat = mdata->group;
-  if (nserv->hasLIST_NEWSGROUPS)
+  if (adata->hasLIST_NEWSGROUPS)
     cmd = "LIST NEWSGROUPS";
-  else if (nserv->hasXGTITLE)
+  else if (adata->hasXGTITLE)
     cmd = "XGTITLE";
   else
     return 0;
 
   snprintf(buf, sizeof(buf), "%s %s\r\n", cmd, wildmat);
-  int rc = nntp_fetch_lines(mdata, buf, sizeof(buf), msg, fetch_description, nserv);
+  int rc = nntp_fetch_lines(mdata, buf, sizeof(buf), msg, fetch_description, adata);
   if (rc > 0)
   {
     mutt_error("%s: %s", cmd, buf);
@@ -1026,7 +1026,7 @@ static int parse_overview_line(char *line, void *data)
   if (!fp)
     return -1;
 
-  header = mdata->nserv->overview_fmt;
+  header = mdata->adata->overview_fmt;
   while (field)
   {
     char *b = field;
@@ -1175,11 +1175,11 @@ static int nntp_fetch_headers(struct Context *ctx, void *hc, anum_t first,
 #endif
 
   /* fetch list of articles */
-  if (NntpListgroup && mdata->nserv->hasLISTGROUP && !mdata->deleted)
+  if (NntpListgroup && mdata->adata->hasLISTGROUP && !mdata->deleted)
   {
     if (!ctx->mailbox->quiet)
       mutt_message(_("Fetching list of articles..."));
-    if (mdata->nserv->hasLISTGROUPrange)
+    if (mdata->adata->hasLISTGROUPrange)
       snprintf(buf, sizeof(buf), "LISTGROUP %s %u-%u\r\n", mdata->group, first, last);
     else
       snprintf(buf, sizeof(buf), "LISTGROUP %s\r\n", mdata->group);
@@ -1275,9 +1275,9 @@ static int nntp_fetch_headers(struct Context *ctx, void *hc, anum_t first,
       continue;
 
     /* fallback to fetch overview */
-    else if (mdata->nserv->hasOVER || mdata->nserv->hasXOVER)
+    else if (mdata->adata->hasOVER || mdata->adata->hasXOVER)
     {
-      if (NntpListgroup && mdata->nserv->hasLISTGROUP)
+      if (NntpListgroup && mdata->adata->hasLISTGROUP)
         break;
       else
         continue;
@@ -1349,13 +1349,13 @@ static int nntp_fetch_headers(struct Context *ctx, void *hc, anum_t first,
     first_over = current + 1;
   }
 
-  if (!NntpListgroup || !mdata->nserv->hasLISTGROUP)
+  if (!NntpListgroup || !mdata->adata->hasLISTGROUP)
     current = first_over;
 
   /* fetch overview information */
   if (current <= last && rc == 0 && !mdata->deleted)
   {
-    char *cmd = mdata->nserv->hasOVER ? "OVER" : "XOVER";
+    char *cmd = mdata->adata->hasOVER ? "OVER" : "XOVER";
     snprintf(buf, sizeof(buf), "%s %u-%u\r\n", cmd, current, last);
     rc = nntp_fetch_lines(mdata, buf, sizeof(buf), NULL, parse_overview_line, &fc);
     if (rc > 0)
@@ -1433,27 +1433,27 @@ static int nntp_group_poll(struct NntpMboxData *mdata, int update_stat)
 static int check_mailbox(struct Context *ctx)
 {
   struct NntpMboxData *mdata = ctx->mailbox->data;
-  struct NntpServer *nserv = mdata->nserv;
+  struct NntpAccountData *adata = mdata->adata;
   time_t now = time(NULL);
   int rc, ret = 0;
   void *hc = NULL;
 
-  if (nserv->check_time + NntpPoll > now)
+  if (adata->check_time + NntpPoll > now)
     return 0;
 
   mutt_message(_("Checking for new messages..."));
-  if (nntp_newsrc_parse(nserv) < 0)
+  if (nntp_newsrc_parse(adata) < 0)
     return -1;
 
-  nserv->check_time = now;
+  adata->check_time = now;
   rc = nntp_group_poll(mdata, 0);
   if (rc < 0)
   {
-    nntp_newsrc_close(nserv);
+    nntp_newsrc_close(adata);
     return -1;
   }
   if (rc)
-    nntp_active_save_cache(nserv);
+    nntp_active_save_cache(adata);
 
   /* articles have been renumbered, remove all headers */
   if (mdata->last_message < mdata->last_loaded)
@@ -1473,7 +1473,7 @@ static int check_mailbox(struct Context *ctx)
   }
 
   /* .newsrc has been externally modified */
-  if (nserv->newsrc_modified)
+  if (adata->newsrc_modified)
   {
 #ifdef USE_HCACHE
     unsigned char *messages = NULL;
@@ -1587,7 +1587,7 @@ static int check_mailbox(struct Context *ctx)
     FREE(&messages);
 #endif
 
-    nserv->newsrc_modified = false;
+    adata->newsrc_modified = false;
     ret = MUTT_REOPENED;
   }
 
@@ -1636,28 +1636,28 @@ static int check_mailbox(struct Context *ctx)
   mutt_hcache_close(hc);
 #endif
   if (ret)
-    nntp_newsrc_close(nserv);
+    nntp_newsrc_close(adata);
   mutt_clear_error();
   return ret;
 }
 
 /**
  * nntp_date - Get date and time from server
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param now   Server time
  * @retval  0 Success
  * @retval -1 Failure
  */
-static int nntp_date(struct NntpServer *nserv, time_t *now)
+static int nntp_date(struct NntpAccountData *adata, time_t *now)
 {
-  if (nserv->hasDATE)
+  if (adata->hasDATE)
   {
     struct NntpMboxData mdata;
     char buf[LONG_STRING];
     struct tm tm;
     memset(&tm, 0, sizeof(tm));
 
-    mdata.nserv = nserv;
+    mdata.adata = adata;
     mdata.group = NULL;
     mutt_str_strfcpy(buf, "DATE\r\n", sizeof(buf));
     if (nntp_query(&mdata, buf, sizeof(buf)) < 0)
@@ -1707,28 +1707,28 @@ static int fetch_children(char *line, void *data)
 
 /**
  * nntp_open_connection - Connect to server, authenticate and get capabilities
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @retval  0 Success
  * @retval -1 Failure
  */
-int nntp_open_connection(struct NntpServer *nserv)
+int nntp_open_connection(struct NntpAccountData *adata)
 {
-  struct Connection *conn = nserv->conn;
+  struct Connection *conn = adata->conn;
   char buf[STRING];
   int cap;
   bool posting = false, auth = true;
 
-  if (nserv->status == NNTP_OK)
+  if (adata->status == NNTP_OK)
     return 0;
-  if (nserv->status == NNTP_BYE)
+  if (adata->status == NNTP_BYE)
     return -1;
-  nserv->status = NNTP_NONE;
+  adata->status = NNTP_NONE;
 
   if (mutt_socket_open(conn) < 0)
     return -1;
 
   if (mutt_socket_readln(buf, sizeof(buf), conn) < 0)
-    return nntp_connect_error(nserv);
+    return nntp_connect_error(adata);
 
   if (mutt_str_strncmp("200", buf, 3) == 0)
     posting = true;
@@ -1741,7 +1741,7 @@ int nntp_open_connection(struct NntpServer *nserv)
   }
 
   /* get initial capabilities */
-  cap = nntp_capabilities(nserv);
+  cap = nntp_capabilities(adata);
   if (cap < 0)
     return -1;
 
@@ -1751,7 +1751,7 @@ int nntp_open_connection(struct NntpServer *nserv)
     if (mutt_socket_send(conn, "MODE READER\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
 
     if (mutt_str_strncmp("200", buf, 3) == 0)
@@ -1759,7 +1759,7 @@ int nntp_open_connection(struct NntpServer *nserv)
     else if (mutt_str_strncmp("201", buf, 3) == 0)
       posting = false;
     /* error if has capabilities, ignore result if no capabilities */
-    else if (nserv->hasCAPABILITIES)
+    else if (adata->hasCAPABILITIES)
     {
       mutt_socket_close(conn);
       mutt_error(_("Could not switch to reader mode"));
@@ -1767,9 +1767,9 @@ int nntp_open_connection(struct NntpServer *nserv)
     }
 
     /* recheck capabilities after MODE READER */
-    if (nserv->hasCAPABILITIES)
+    if (adata->hasCAPABILITIES)
     {
-      cap = nntp_capabilities(nserv);
+      cap = nntp_capabilities(adata);
       if (cap < 0)
         return -1;
     }
@@ -1781,40 +1781,40 @@ int nntp_open_connection(struct NntpServer *nserv)
 
 #ifdef USE_SSL
   /* Attempt STARTTLS if available and desired. */
-  if (nserv->use_tls != 1 && (nserv->hasSTARTTLS || SslForceTls))
+  if (adata->use_tls != 1 && (adata->hasSTARTTLS || SslForceTls))
   {
-    if (nserv->use_tls == 0)
+    if (adata->use_tls == 0)
     {
-      nserv->use_tls =
+      adata->use_tls =
           SslForceTls || query_quadoption(SslStarttls,
                                           _("Secure connection with TLS?")) == MUTT_YES ?
               2 :
               1;
     }
-    if (nserv->use_tls == 2)
+    if (adata->use_tls == 2)
     {
       if (mutt_socket_send(conn, "STARTTLS\r\n") < 0 ||
           mutt_socket_readln(buf, sizeof(buf), conn) < 0)
       {
-        return nntp_connect_error(nserv);
+        return nntp_connect_error(adata);
       }
       if (mutt_str_strncmp("382", buf, 3) != 0)
       {
-        nserv->use_tls = 0;
+        adata->use_tls = 0;
         mutt_error("STARTTLS: %s", buf);
       }
       else if (mutt_ssl_starttls(conn))
       {
-        nserv->use_tls = 0;
-        nserv->status = NNTP_NONE;
-        mutt_socket_close(nserv->conn);
+        adata->use_tls = 0;
+        adata->status = NNTP_NONE;
+        mutt_socket_close(adata->conn);
         mutt_error(_("Could not negotiate TLS connection"));
         return -1;
       }
       else
       {
         /* recheck capabilities after STARTTLS */
-        cap = nntp_capabilities(nserv);
+        cap = nntp_capabilities(adata);
         if (cap < 0)
           return -1;
       }
@@ -1833,20 +1833,20 @@ int nntp_open_connection(struct NntpServer *nserv)
     if (mutt_socket_send(conn, "STAT\r\n") < 0 ||
         mutt_socket_readln(buf, sizeof(buf), conn) < 0)
     {
-      return nntp_connect_error(nserv);
+      return nntp_connect_error(adata);
     }
     if (mutt_str_strncmp("480", buf, 3) != 0)
       auth = false;
   }
 
   /* authenticate */
-  if (auth && nntp_auth(nserv) < 0)
+  if (auth && nntp_auth(adata) < 0)
     return -1;
 
   /* get final capabilities after authentication */
-  if (nserv->hasCAPABILITIES && (auth || cap > 0))
+  if (adata->hasCAPABILITIES && (auth || cap > 0))
   {
-    cap = nntp_capabilities(nserv);
+    cap = nntp_capabilities(adata);
     if (cap < 0)
       return -1;
     if (cap > 0)
@@ -1858,10 +1858,10 @@ int nntp_open_connection(struct NntpServer *nserv)
   }
 
   /* attempt features */
-  if (nntp_attempt_features(nserv) < 0)
+  if (nntp_attempt_features(adata) < 0)
     return -1;
 
-  nserv->status = NNTP_OK;
+  adata->status = NNTP_OK;
   return 0;
 }
 
@@ -1875,7 +1875,7 @@ int nntp_open_connection(struct NntpServer *nserv)
 int nntp_post(struct Mailbox *mailbox, const char *msg)
 {
   struct NntpMboxData *mdata = NULL;
-  struct NntpMboxData nntp_tmp = { 0 };
+  struct NntpMboxData tmp_mdata = { 0 };
   char buf[LONG_STRING];
 
   if (mailbox && (mailbox->magic == MUTT_NNTP))
@@ -1886,8 +1886,8 @@ int nntp_post(struct Mailbox *mailbox, const char *msg)
     if (!CurrentNewsSrv)
       return -1;
 
-    mdata = &nntp_tmp;
-    mdata->nserv = CurrentNewsSrv;
+    mdata = &tmp_mdata;
+    mdata->adata = CurrentNewsSrv;
     mdata->group = NULL;
   }
 
@@ -1923,21 +1923,21 @@ int nntp_post(struct Mailbox *mailbox, const char *msg)
       len++;
       buf[len] = '\0';
     }
-    if (mutt_socket_send_d(mdata->nserv->conn, buf[1] == '.' ? buf : buf + 1,
+    if (mutt_socket_send_d(mdata->adata->conn, buf[1] == '.' ? buf : buf + 1,
                            MUTT_SOCK_LOG_HDR) < 0)
     {
       mutt_file_fclose(&fp);
-      return nntp_connect_error(mdata->nserv);
+      return nntp_connect_error(mdata->adata);
     }
   }
   mutt_file_fclose(&fp);
 
   if ((buf[strlen(buf) - 1] != '\n' &&
-       mutt_socket_send_d(mdata->nserv->conn, "\r\n", MUTT_SOCK_LOG_HDR) < 0) ||
-      mutt_socket_send_d(mdata->nserv->conn, ".\r\n", MUTT_SOCK_LOG_HDR) < 0 ||
-      mutt_socket_readln(buf, sizeof(buf), mdata->nserv->conn) < 0)
+       mutt_socket_send_d(mdata->adata->conn, "\r\n", MUTT_SOCK_LOG_HDR) < 0) ||
+      mutt_socket_send_d(mdata->adata->conn, ".\r\n", MUTT_SOCK_LOG_HDR) < 0 ||
+      mutt_socket_readln(buf, sizeof(buf), mdata->adata->conn) < 0)
   {
-    return nntp_connect_error(mdata->nserv);
+    return nntp_connect_error(mdata->adata);
   }
   if (buf[0] != '2')
   {
@@ -1949,30 +1949,30 @@ int nntp_post(struct Mailbox *mailbox, const char *msg)
 
 /**
  * nntp_active_fetch - Fetch list of all newsgroups from server
- * @param nserv NNTP server
+ * @param adata NNTP server
  * @param new   Mark the groups as new
  * @retval  0 Success
  * @retval -1 Failure
  */
-int nntp_active_fetch(struct NntpServer *nserv, bool new)
+int nntp_active_fetch(struct NntpAccountData *adata, bool new)
 {
-  struct NntpMboxData mdata;
+  struct NntpMboxData tmp_mdata;
   char msg[STRING];
   char buf[LONG_STRING];
   unsigned int i;
   int rc;
 
   snprintf(msg, sizeof(msg), _("Loading list of groups from server %s..."),
-           nserv->conn->account.host);
+           adata->conn->account.host);
   mutt_message(msg);
-  if (nntp_date(nserv, &nserv->newgroups_time) < 0)
+  if (nntp_date(adata, &adata->newgroups_time) < 0)
     return -1;
 
-  mdata.nserv = nserv;
-  mdata.group = NULL;
-  i = nserv->groups_num;
+  tmp_mdata.adata = adata;
+  tmp_mdata.group = NULL;
+  i = adata->groups_num;
   mutt_str_strfcpy(buf, "LIST\r\n", sizeof(buf));
-  rc = nntp_fetch_lines(&mdata, buf, sizeof(buf), msg, nntp_add_group, nserv);
+  rc = nntp_fetch_lines(&tmp_mdata, buf, sizeof(buf), msg, nntp_add_group, adata);
   if (rc)
   {
     if (rc > 0)
@@ -1984,29 +1984,29 @@ int nntp_active_fetch(struct NntpServer *nserv, bool new)
 
   if (new)
   {
-    for (; i < nserv->groups_num; i++)
+    for (; i < adata->groups_num; i++)
     {
-      struct NntpMboxData *data = nserv->groups_list[i];
-      data->new = true;
+      struct NntpMboxData *mdata = adata->groups_list[i];
+      mdata->new = true;
     }
   }
 
-  for (i = 0; i < nserv->groups_num; i++)
+  for (i = 0; i < adata->groups_num; i++)
   {
-    struct NntpMboxData *data = nserv->groups_list[i];
+    struct NntpMboxData *mdata = adata->groups_list[i];
 
-    if (data && data->deleted && !data->newsrc_ent)
+    if (mdata && mdata->deleted && !mdata->newsrc_ent)
     {
-      nntp_delete_group_cache(data);
-      mutt_hash_delete(nserv->groups_hash, data->group, NULL);
-      nserv->groups_list[i] = NULL;
+      nntp_delete_group_cache(mdata);
+      mutt_hash_delete(adata->groups_hash, mdata->group, NULL);
+      adata->groups_list[i] = NULL;
     }
   }
 
   if (NntpLoadDescription)
-    rc = get_description(&mdata, "*", _("Loading descriptions..."));
+    rc = get_description(&tmp_mdata, "*", _("Loading descriptions..."));
 
-  nntp_active_save_cache(nserv);
+  nntp_active_save_cache(adata);
   if (rc < 0)
     return -1;
   mutt_clear_error();
@@ -2016,14 +2016,14 @@ int nntp_active_fetch(struct NntpServer *nserv, bool new)
 /**
  * nntp_check_new_groups - Check for new groups/articles in subscribed groups
  * @param mailbox Mailbox
- * @param nserv   NNTP server
+ * @param adata   NNTP server
  * @retval  1 New groups found
  * @retval  0 No new groups
  * @retval -1 Error
  */
-int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv)
+int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpAccountData *adata)
 {
-  struct NntpMboxData mdata;
+  struct NntpMboxData tmp_mdata;
   time_t now;
   struct tm *tm = NULL;
   char buf[LONG_STRING];
@@ -2031,20 +2031,20 @@ int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv)
   unsigned int i;
   int rc, update_active = false;
 
-  if (!nserv || !nserv->newgroups_time)
+  if (!adata || !adata->newgroups_time)
     return -1;
 
   /* check subscribed newsgroups for new articles */
   if (ShowNewNews)
   {
     mutt_message(_("Checking for new messages..."));
-    for (i = 0; i < nserv->groups_num; i++)
+    for (i = 0; i < adata->groups_num; i++)
     {
-      struct NntpMboxData *data = nserv->groups_list[i];
+      struct NntpMboxData *mdata = adata->groups_list[i];
 
-      if (data && data->subscribed)
+      if (mdata && mdata->subscribed)
       {
-        rc = nntp_group_poll(data, 1);
+        rc = nntp_group_poll(mdata, 1);
         if (rc < 0)
           return -1;
         if (rc > 0)
@@ -2052,31 +2052,31 @@ int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv)
       }
     }
     /* select current newsgroup */
-    if (mailbox && (mailbox->magic == MUTT_NNTP))
+    if (Context && (Context->mailbox->magic == MUTT_NNTP))
     {
       buf[0] = '\0';
-      if (nntp_query(mailbox->data, buf, sizeof(buf)) < 0)
+      if (nntp_query(Context->mailbox->data, buf, sizeof(buf)) < 0)
         return -1;
     }
   }
-  else if (nserv->newgroups_time)
+  else if (adata->newgroups_time)
     return 0;
 
   /* get list of new groups */
   mutt_message(msg);
-  if (nntp_date(nserv, &now) < 0)
+  if (nntp_date(adata, &now) < 0)
     return -1;
-  mdata.nserv = nserv;
-  if (mailbox && (mailbox->magic == MUTT_NNTP))
-    mdata.group = ((struct NntpMboxData *) mailbox->data)->group;
+  tmp_mdata.adata = adata;
+  if (Context && (Context->mailbox->magic == MUTT_NNTP))
+    tmp_mdata.group = ((struct NntpMboxData *) Context->mailbox->data)->group;
   else
-    mdata.group = NULL;
-  i = nserv->groups_num;
-  tm = gmtime(&nserv->newgroups_time);
+    tmp_mdata.group = NULL;
+  i = adata->groups_num;
+  tm = gmtime(&adata->newgroups_time);
   snprintf(buf, sizeof(buf), "NEWGROUPS %02d%02d%02d %02d%02d%02d GMT\r\n",
            tm->tm_year % 100, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
            tm->tm_min, tm->tm_sec);
-  rc = nntp_fetch_lines(&mdata, buf, sizeof(buf), msg, nntp_add_group, nserv);
+  rc = nntp_fetch_lines(&tmp_mdata, buf, sizeof(buf), msg, nntp_add_group, adata);
   if (rc)
   {
     if (rc > 0)
@@ -2088,15 +2088,15 @@ int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv)
 
   /* new groups found */
   rc = 0;
-  if (nserv->groups_num != i)
+  if (adata->groups_num != i)
   {
     int groups_num = i;
 
-    nserv->newgroups_time = now;
-    for (; i < nserv->groups_num; i++)
+    adata->newgroups_time = now;
+    for (; i < adata->groups_num; i++)
     {
-      struct NntpMboxData *data = nserv->groups_list[i];
-      data->new = true;
+      struct NntpMboxData *mdata = adata->groups_list[i];
+      mdata->new = true;
     }
 
     /* loading descriptions */
@@ -2106,12 +2106,12 @@ int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv)
       struct Progress progress;
 
       mutt_progress_init(&progress, _("Loading descriptions..."),
-                         MUTT_PROGRESS_MSG, ReadInc, nserv->groups_num - i);
-      for (i = groups_num; i < nserv->groups_num; i++)
+                         MUTT_PROGRESS_MSG, ReadInc, adata->groups_num - i);
+      for (i = groups_num; i < adata->groups_num; i++)
       {
-        struct NntpMboxData *data = nserv->groups_list[i];
+        struct NntpMboxData *mdata = adata->groups_list[i];
 
-        if (get_description(data, NULL, NULL) < 0)
+        if (get_description(mdata, NULL, NULL) < 0)
           return -1;
         mutt_progress_update(&progress, ++count, -1);
       }
@@ -2120,7 +2120,7 @@ int nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv)
     rc = 1;
   }
   if (update_active)
-    nntp_active_save_cache(nserv);
+    nntp_active_save_cache(adata);
   mutt_clear_error();
   return rc;
 }
@@ -2209,7 +2209,7 @@ int nntp_check_children(struct Context *ctx, const char *msgid)
   bool quiet;
   void *hc = NULL;
 
-  if (!mdata || !mdata->nserv)
+  if (!mdata || !mdata->adata)
     return -1;
   if (mdata->first_message > mdata->last_loaded)
     return 0;
@@ -2280,7 +2280,7 @@ int nntp_compare_order(const void *a, const void *b)
  */
 static int nntp_mbox_open(struct Context *ctx)
 {
-  struct NntpServer *nserv = NULL;
+  struct NntpAccountData *adata = NULL;
   struct NntpMboxData *mdata = NULL;
   char buf[HUGE_STRING];
   char server[LONG_STRING];
@@ -2300,19 +2300,22 @@ static int nntp_mbox_open(struct Context *ctx)
   }
 
   group = url.path;
+  if (group[0] == '/')  /* Skip a leading '/' */
+    group++;
+
   url.path = strchr(url.path, '\0');
   url_tostring(&url, server, sizeof(server), 0);
-  nserv = nntp_select_server(ctx->mailbox, server, true);
+  adata = nntp_select_server(ctx->mailbox, server, true);
   url_free(&url);
-  if (!nserv)
+  if (!adata)
     return -1;
-  CurrentNewsSrv = nserv;
+  CurrentNewsSrv = adata;
 
   /* find news group data structure */
-  mdata = mutt_hash_find(nserv->groups_hash, group);
+  mdata = mutt_hash_find(adata->groups_hash, group);
   if (!mdata)
   {
-    nntp_newsrc_close(nserv);
+    nntp_newsrc_close(adata);
     mutt_error(_("Newsgroup %s not found on the server"), group);
     return -1;
   }
@@ -2326,7 +2329,7 @@ static int nntp_mbox_open(struct Context *ctx)
   buf[0] = '\0';
   if (nntp_query(mdata, buf, sizeof(buf)) < 0)
   {
-    nntp_newsrc_close(nserv);
+    nntp_newsrc_close(adata);
     return -1;
   }
 
@@ -2337,14 +2340,14 @@ static int nntp_mbox_open(struct Context *ctx)
     if (!mdata->deleted)
     {
       mdata->deleted = true;
-      nntp_active_save_cache(nserv);
+      nntp_active_save_cache(adata);
     }
     if (mdata->newsrc_ent && !mdata->subscribed && !SaveUnsubscribed)
     {
       FREE(&mdata->newsrc_ent);
       mdata->newsrc_len = 0;
       nntp_delete_group_cache(mdata);
-      nntp_newsrc_update(nserv);
+      nntp_newsrc_update(adata);
     }
   }
 
@@ -2353,7 +2356,7 @@ static int nntp_mbox_open(struct Context *ctx)
   {
     if (sscanf(buf, "211 " ANUM " " ANUM " " ANUM, &count, &first, &last) != 3)
     {
-      nntp_newsrc_close(nserv);
+      nntp_newsrc_close(adata);
       mutt_error("GROUP: %s", buf);
       return -1;
     }
@@ -2366,18 +2369,18 @@ static int nntp_mbox_open(struct Context *ctx)
     {
       if (get_description(mdata, NULL, NULL) < 0)
       {
-        nntp_newsrc_close(nserv);
+        nntp_newsrc_close(adata);
         return -1;
       }
       if (mdata->desc)
-        nntp_active_save_cache(nserv);
+        nntp_active_save_cache(adata);
     }
   }
 
-  time(&nserv->check_time);
+  time(&adata->check_time);
   ctx->mailbox->data = mdata;
   if (!mdata->bcache && (mdata->newsrc_ent || mdata->subscribed || SaveUnsubscribed))
-    mdata->bcache = mutt_bcache_open(&nserv->conn->account, mdata->group);
+    mdata->bcache = mutt_bcache_open(&adata->conn->account, mdata->group);
 
   /* strip off extra articles if adding context is greater than $nntp_context */
   first = mdata->first_message;
@@ -2397,7 +2400,7 @@ static int nntp_mbox_open(struct Context *ctx)
     mutt_bit_unset(ctx->mailbox->rights, MUTT_ACL_WRITE);
     mutt_bit_unset(ctx->mailbox->rights, MUTT_ACL_DELETE);
   }
-  nntp_newsrc_close(nserv);
+  nntp_newsrc_close(adata);
   rc = nntp_fetch_headers(ctx, hc, first, mdata->last_message, 0);
 #ifdef USE_HCACHE
   mutt_hcache_close(hc);
@@ -2405,7 +2408,7 @@ static int nntp_mbox_open(struct Context *ctx)
   if (rc < 0)
     return -1;
   mdata->last_loaded = mdata->last_message;
-  nserv->newsrc_modified = false;
+  adata->newsrc_modified = false;
   return 0;
 }
 
@@ -2424,8 +2427,8 @@ static int nntp_mbox_check(struct Context *ctx, int *index_hint)
   if (ret == 0)
   {
     struct NntpMboxData *mdata = ctx->mailbox->data;
-    struct NntpServer *nserv = mdata->nserv;
-    nntp_newsrc_close(nserv);
+    struct NntpAccountData *adata = mdata->adata;
+    nntp_newsrc_close(adata);
   }
   return ret;
 }
@@ -2444,7 +2447,7 @@ static int nntp_mbox_sync(struct Context *ctx, int *index_hint)
 #endif
 
   /* check for new articles */
-  mdata->nserv->check_time = 0;
+  mdata->adata->check_time = 0;
   rc = check_mailbox(ctx);
   if (rc)
     return rc;
@@ -2487,8 +2490,8 @@ static int nntp_mbox_sync(struct Context *ctx, int *index_hint)
 
   /* save .newsrc entries */
   nntp_newsrc_gen_entries(ctx);
-  nntp_newsrc_update(mdata->nserv);
-  nntp_newsrc_close(mdata->nserv);
+  nntp_newsrc_update(mdata->adata);
+  nntp_newsrc_close(mdata->adata);
   return 0;
 }
 
@@ -2498,18 +2501,18 @@ static int nntp_mbox_sync(struct Context *ctx, int *index_hint)
  */
 static int nntp_mbox_close(struct Context *ctx)
 {
-  struct NntpMboxData *mdata = ctx->mailbox->data, *nntp_tmp = NULL;
+  struct NntpMboxData *mdata = ctx->mailbox->data, *tmp_mdata = NULL;
   if (!mdata)
     return 0;
 
   mdata->unread = ctx->mailbox->msg_unread;
 
   nntp_acache_free(mdata);
-  if (!mdata->nserv || !mdata->nserv->groups_hash || !mdata->group)
+  if (!mdata->adata || !mdata->adata->groups_hash || !mdata->group)
     return 0;
 
-  nntp_tmp = mutt_hash_find(mdata->nserv->groups_hash, mdata->group);
-  if (!nntp_tmp || nntp_tmp != mdata)
+  tmp_mdata = mutt_hash_find(mdata->adata->groups_hash, mdata->group);
+  if (!tmp_mdata || tmp_mdata != mdata)
     nntp_data_free(mdata);
   return 0;
 }
index 4bb658b4daac7a72f17381ac86c1af95fdddf4e0..6e6d8b22f48dd3f356221540676d398ce7164f29 100644 (file)
@@ -65,9 +65,9 @@ extern char *Newsrc;
 #define ANUM "%u"
 
 /**
- * struct NntpServer - NNTP-specific server data
+ * struct NntpAccountData - NNTP-specific server data
  */
-struct NntpServer
+struct NntpAccountData
 {
   bool hasCAPABILITIES    : 1;
   bool hasSTARTTLS        : 1;
@@ -145,33 +145,33 @@ struct NntpMboxData
   bool deleted    : 1;
   unsigned int newsrc_len;
   struct NewsrcEntry *newsrc_ent;
-  struct NntpServer *nserv;
+  struct NntpAccountData *adata;
   struct NntpAcache acache[NNTP_ACACHE_LEN];
   struct BodyCache *bcache;
 };
 
-struct NntpServer *nntp_select_server(struct Mailbox *mailbox, char *server, bool leave_lock);
-struct NntpMboxData *mutt_newsgroup_subscribe(struct NntpServer *nserv, char *group);
-struct NntpMboxData *mutt_newsgroup_unsubscribe(struct NntpServer *nserv, char *group);
-struct NntpMboxData *mutt_newsgroup_catchup(struct Context *ctx, struct NntpServer *nserv, char *group);
-struct NntpMboxData *mutt_newsgroup_uncatchup(struct Context *ctx, struct NntpServer *nserv, char *group);
-int nntp_active_fetch(struct NntpServer *nserv, bool new);
-int nntp_newsrc_update(struct NntpServer *nserv);
+struct NntpAccountData *nntp_select_server(struct Mailbox *mailbox, char *server, bool leave_lock);
+struct NntpMboxData *mutt_newsgroup_subscribe(struct NntpAccountData *adata, char *group);
+struct NntpMboxData *mutt_newsgroup_unsubscribe(struct NntpAccountData *adata, char *group);
+struct NntpMboxData *mutt_newsgroup_catchup(struct Context *ctx, struct NntpAccountData *adata, char *group);
+struct NntpMboxData *mutt_newsgroup_uncatchup(struct Context *ctx, struct NntpAccountData *adata, char *group);
+int nntp_active_fetch(struct NntpAccountData *adata, bool new);
+int nntp_newsrc_update(struct NntpAccountData *adata);
 int nntp_post(struct Mailbox *mailbox, const char *msg);
 int nntp_check_msgid(struct Context *ctx, const char *msgid);
 int nntp_check_children(struct Context *ctx, const char *msgid);
-int nntp_newsrc_parse(struct NntpServer *nserv);
-void nntp_newsrc_close(struct NntpServer *nserv);
+int nntp_newsrc_parse(struct NntpAccountData *adata);
+void nntp_newsrc_close(struct NntpAccountData *adata);
 void nntp_mailbox(struct Mailbox *mailbox, char *buf, size_t buflen);
 void nntp_expand_path(char *buf, size_t buflen, struct ConnAccount *acct);
-void nntp_clear_cache(struct NntpServer *nserv);
+void nntp_clear_cache(struct NntpAccountData *adata);
 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, unsigned long data, enum FormatFlag flags);
 
 void nntp_article_status(struct Mailbox *mailbox, struct Email *e, char *group, anum_t anum);
 
-extern struct NntpServer *CurrentNewsSrv;
+extern struct NntpAccountData *CurrentNewsSrv;
 
 int nntp_compare_order(const void *a, const void *b);
 int nntp_path_probe(const char *path, const struct stat *st);
index b429115f78493d54067882b5454400fc71387441..cd52bfd94b7ea32148e48132611566ab5dcfa5d2 100644 (file)
@@ -30,7 +30,7 @@
 struct Context;
 struct Mailbox;
 struct NntpMboxData;
-struct NntpServer;
+struct NntpAccountData;
 
 #define NNTP_PORT 119
 #define NNTP_SSL_PORT 563
@@ -47,20 +47,20 @@ enum NntpStatus
 
 #define NNTP_EDATA(email) ((struct NntpEmailData *) ((email)->data))
 
-void nntp_acache_free(struct NntpMboxData *nntp_data);
-int  nntp_active_save_cache(struct NntpServer *nserv);
+void nntp_acache_free(struct NntpMboxData *mdata);
+int  nntp_active_save_cache(struct NntpAccountData *adata);
 int  nntp_add_group(char *line, void *data);
-void nntp_bcache_update(struct NntpMboxData *nntp_data);
-int  nntp_check_new_groups(struct Mailbox *mailbox, struct NntpServer *nserv);
+void nntp_bcache_update(struct NntpMboxData *mdata);
+int  nntp_check_new_groups(struct Mailbox *mailbox, struct NntpAccountData *adata);
 void nntp_data_free(void *data);
-void nntp_delete_group_cache(struct NntpMboxData *nntp_data);
-void nntp_group_unread_stat(struct NntpMboxData *nntp_data);
+void nntp_delete_group_cache(struct NntpMboxData *mdata);
+void nntp_group_unread_stat(struct NntpMboxData *mdata);
 void nntp_newsrc_gen_entries(struct Context *ctx);
-int  nntp_open_connection(struct NntpServer *nserv);
+int  nntp_open_connection(struct NntpAccountData *adata);
 
 #ifdef USE_HCACHE
-header_cache_t *nntp_hcache_open(struct NntpMboxData *nntp_data);
-void nntp_hcache_update(struct NntpMboxData *nntp_data, header_cache_t *hc);
+header_cache_t *nntp_hcache_open(struct NntpMboxData *mdata);
+void nntp_hcache_update(struct NntpMboxData *mdata, header_cache_t *hc);
 #endif
 
 #endif /* MUTT_NNTP_NNTP_PRIVATE_H */