Enlarge buffers from _POSIX_PATH_MAX to PATH_MAX

Every buffer that has a filesystem path copied into it

diff --git a/attach.c b/attach.c
index 78e09b61228c448c9d455f2a28c32b0a885e8d82..33fe1becb325291e3b48d92c4911f392c476a9e2 100644 (file)
--- a/attach.c
+++ b/attach.c
@@ -51,7 +51,7 @@
 int mutt_get_tmp_attachment(struct Body *a)
 {
   char type[STRING];
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   FILE *fpin = NULL, *fpout = NULL;
   struct stat st;
 
@@ -97,7 +97,7 @@ int mutt_compose_attachment(struct Body *a)
 {
   char type[STRING];
   char command[HUGE_STRING];
-  char newfile[_POSIX_PATH_MAX] = "";
+  char newfile[PATH_MAX] = "";
   struct Rfc1524MailcapEntry *entry = rfc1524_new_entry();
   bool unlink_newfile = false;
   int rc = 0;
@@ -142,7 +142,7 @@ int mutt_compose_attachment(struct Body *a)
         if (r != -1 && entry->composetypecommand)
         {
           struct Body *b = NULL;
-          char tempfile[_POSIX_PATH_MAX];
+          char tempfile[PATH_MAX];
 
           FILE *fp = mutt_file_fopen(a->filename, "r");
           if (!fp)
@@ -234,7 +234,7 @@ int mutt_edit_attachment(struct Body *a)
 {
   char type[STRING];
   char command[HUGE_STRING];
-  char newfile[_POSIX_PATH_MAX] = "";
+  char newfile[PATH_MAX] = "";
   struct Rfc1524MailcapEntry *entry = rfc1524_new_entry();
   bool unlink_newfile = false;
   int rc = 0;
@@ -367,8 +367,8 @@ void mutt_check_lookup_list(struct Body *b, char *type, size_t len)
 int mutt_view_attachment(FILE *fp, struct Body *a, int flag, struct Header *hdr,
                          struct AttachCtx *actx)
 {
-  char tempfile[_POSIX_PATH_MAX] = "";
-  char pagerfile[_POSIX_PATH_MAX] = "";
+  char tempfile[PATH_MAX] = "";
+  char pagerfile[PATH_MAX] = "";
   bool use_mailcap = false;
   bool use_pipe = false;
   bool use_pager = true;
@@ -981,7 +981,7 @@ int mutt_decode_save_attachment(FILE *fp, struct Body *m, char *path, int displa
  */
 int mutt_print_attachment(FILE *fp, struct Body *a)
 {
-  char newfile[_POSIX_PATH_MAX] = "";
+  char newfile[PATH_MAX] = "";
   char type[STRING];
   pid_t thepid;
   FILE *ifp = NULL, *fpout = NULL;

diff --git a/bcache.c b/bcache.c
index 0346c52f7bf812994f421b8320d3f643bbbcb326..fde35e36377be1ad584dd5d032500e0861066cdb 100644 (file)
--- a/bcache.c
+++ b/bcache.c
@@ -42,7 +42,7 @@
  */
 struct BodyCache
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   size_t pathlen;
 };
 
@@ -87,8 +87,8 @@ static int bcache_path(struct Account *account, const char *mailbox, char *dst,
 
 static int mutt_bcache_move(struct BodyCache *bcache, const char *id, const char *newid)
 {
-  char path[_POSIX_PATH_MAX];
-  char newpath[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
+  char newpath[PATH_MAX];
 
   if (!bcache || !id || !*id || !newid || !*newid)
     return -1;
@@ -130,7 +130,7 @@ void mutt_bcache_close(struct BodyCache **bcache)
 
 FILE *mutt_bcache_get(struct BodyCache *bcache, const char *id)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   FILE *fp = NULL;
 
   if (!id || !*id || !bcache)
@@ -185,7 +185,7 @@ FILE *mutt_bcache_put(struct BodyCache *bcache, const char *id)
 
 int mutt_bcache_commit(struct BodyCache *bcache, const char *id)
 {
-  char tmpid[_POSIX_PATH_MAX];
+  char tmpid[PATH_MAX];
 
   snprintf(tmpid, sizeof(tmpid), "%s.tmp", id);
 
@@ -194,7 +194,7 @@ int mutt_bcache_commit(struct BodyCache *bcache, const char *id)
 
 int mutt_bcache_del(struct BodyCache *bcache, const char *id)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   if (!id || !*id || !bcache)
     return -1;
@@ -210,7 +210,7 @@ int mutt_bcache_del(struct BodyCache *bcache, const char *id)
 
 int mutt_bcache_exists(struct BodyCache *bcache, const char *id)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   struct stat st;
   int rc = 0;
 

diff --git a/body.c b/body.c
index 7fc70e66712136b47582cf6abf682401bed69994..6d09e48278dafd0041a681888fc2c80c7a0f46fe 100644 (file)
--- a/body.c
+++ b/body.c
@@ -62,7 +62,7 @@ int mutt_body_copy(FILE *fp, struct Body **tgt, struct Body *src)
   if (!tgt || !src)
     return -1;
 
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
   struct Body *b = NULL;
 
   bool use_disp;

diff --git a/browser.c b/browser.c
index 630a9eec9859c9e7f7e6862db5c1872d25529589..261e4b378b2addfaebc337fb2946184de2c7ba23 100644 (file)
--- a/browser.c
+++ b/browser.c
@@ -98,8 +98,8 @@ struct Folder
   int num;
 };
 
-static char OldLastDir[_POSIX_PATH_MAX] = "";
-static char LastDir[_POSIX_PATH_MAX] = "";
+static char OldLastDir[PATH_MAX] = "";
+static char LastDir[PATH_MAX] = "";
 
 /**
  * destroy_state - Free the BrowserState
@@ -257,7 +257,7 @@ static void browser_sort(struct BrowserState *state)
 static int link_is_dir(const char *folder, const char *path)
 {
   struct stat st;
-  char fullpath[_POSIX_PATH_MAX];
+  char fullpath[PATH_MAX];
 
   mutt_file_concat_path(fullpath, folder, path, sizeof(fullpath));
 
@@ -748,7 +748,7 @@ static int examine_directory(struct Menu *menu, struct BrowserState *state,
     struct stat s;
     DIR *dp = NULL;
     struct dirent *de = NULL;
-    char buffer[_POSIX_PATH_MAX + SHORT_STRING];
+    char buffer[PATH_MAX + SHORT_STRING];
     struct Buffy *tmp = NULL;
 
     while (stat(d, &s) == -1)
@@ -1075,7 +1075,7 @@ static void init_menu(struct BrowserState *state, struct Menu *menu,
     }
     else
     {
-      char path[_POSIX_PATH_MAX];
+      char path[PATH_MAX];
       menu->is_mailbox_list = 0;
       mutt_str_strfcpy(path, LastDir, sizeof(path));
       mutt_pretty_mailbox(path, sizeof(path));
@@ -1092,7 +1092,7 @@ static void init_menu(struct BrowserState *state, struct Menu *menu,
   int ldlen = mutt_str_strlen(LastDir);
   if ((ldlen > 0) && (mutt_str_strncmp(LastDir, OldLastDir, ldlen) == 0))
   {
-    char TargetDir[_POSIX_PATH_MAX] = "";
+    char TargetDir[PATH_MAX] = "";
 
 #ifdef USE_IMAP
     /* Use mx_is_imap to check what kind of dir is OldLastDir.
@@ -1163,8 +1163,8 @@ void mutt_browser_select_dir(char *f)
 
 void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfiles)
 {
-  char buf[_POSIX_PATH_MAX];
-  char prefix[_POSIX_PATH_MAX] = "";
+  char buf[PATH_MAX];
+  char prefix[PATH_MAX] = "";
   char helpstr[LONG_STRING];
   char title[STRING];
   struct BrowserState state;
@@ -1178,7 +1178,7 @@ void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfi
   /* Keeps in memory the directory we were in when hitting '='
    * to go directly to $folder (Folder)
    */
-  char GotoSwapper[_POSIX_PATH_MAX] = "";
+  char GotoSwapper[PATH_MAX] = "";
 
   buffy = buffy && folder;
 
@@ -1503,7 +1503,7 @@ void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfi
 #endif
             else
             {
-              char tmp[_POSIX_PATH_MAX];
+              char tmp[PATH_MAX];
               mutt_file_concat_path(tmp, LastDir,
                                     state.entry[menu->current].name, sizeof(tmp));
               mutt_str_strfcpy(LastDir, tmp, sizeof(LastDir));
@@ -1583,7 +1583,7 @@ void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfi
               struct FolderFile ff = state.entry[j];
               if (ff.tagged)
               {
-                char full[_POSIX_PATH_MAX];
+                char full[PATH_MAX];
                 mutt_file_concat_path(full, LastDir, ff.name, sizeof(full));
                 mutt_expand_path(full, sizeof(full));
                 tfiles[k++] = mutt_str_strdup(full);
@@ -1767,7 +1767,7 @@ void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfi
             {
               /* in case dir is relative, make it relative to LastDir,
                * not current working dir */
-              char tmp[_POSIX_PATH_MAX];
+              char tmp[PATH_MAX];
               mutt_file_concat_path(tmp, LastDir, buf, sizeof(tmp));
               mutt_str_strfcpy(buf, tmp, sizeof(buf));
             }
@@ -2031,7 +2031,7 @@ void mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfi
         }
         else
         {
-          char buf2[_POSIX_PATH_MAX];
+          char buf2[PATH_MAX];
 
           mutt_file_concat_path(buf2, LastDir, state.entry[menu->current].name,
                                 sizeof(buf2));

diff --git a/buffy.c b/buffy.c
index 1297ef22b7cf5f3993ec3accdb91cecbc717d94e..5bc65d65fa6eb243e579125de255625e28662178 100644 (file)
--- a/buffy.c
+++ b/buffy.c
@@ -597,7 +597,7 @@ int mutt_parse_mailboxes(struct Buffer *path, struct Buffer *s,
                          unsigned long data, struct Buffer *err)
 {
   struct Buffy **b = NULL;
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   struct stat sb;
   char f1[PATH_MAX];
   char *p = NULL;
@@ -698,7 +698,7 @@ int mutt_parse_mailboxes(struct Buffer *path, struct Buffer *s,
 int mutt_parse_unmailboxes(struct Buffer *path, struct Buffer *s,
                            unsigned long data, struct Buffer *err)
 {
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   bool clear_all = false;
 
   while (!clear_all && MoreArgs(s))
@@ -817,7 +817,7 @@ int mutt_buffy_check(bool force)
 bool mutt_buffy_list(void)
 {
   struct Buffy *b = NULL;
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   char buffylist[2 * STRING];
   size_t pos = 0;
   int first = 1;

diff --git a/buffy.h b/buffy.h
index 9d37372aa33f93fb93bcc01f7d60eb4cc8cd641a..abaff004cb5e190cc6ee2d058afd8c36a26d0884 100644 (file)
--- a/buffy.h
+++ b/buffy.h
@@ -40,9 +40,9 @@ struct stat;
  */
 struct Buffy
 {
-  char path[_POSIX_PATH_MAX];
-  char realpath[_POSIX_PATH_MAX]; /**< used for duplicate detection, context
-                                   * comparison, and the sidebar */
+  char path[PATH_MAX];
+  char realpath[PATH_MAX]; /**< used for duplicate detection, context
+                            * comparison, and the sidebar */
   char *desc;
   off_t size;
   struct Buffy *next;

diff --git a/commands.c b/commands.c
index b89ab86be10f923a8aa9cda7ac7f2ed84829d563..ca52386cf8db1ec19e6a7cdba61f04359f14ca13 100644 (file)
--- a/commands.c
+++ b/commands.c
@@ -63,11 +63,11 @@
 static const char *ExtPagerProgress = "all";
 
 /** The folder the user last saved to.  Used by ci_save_message() */
-static char LastSaveFolder[_POSIX_PATH_MAX] = "";
+static char LastSaveFolder[PATH_MAX] = "";
 
 int mutt_display_message(struct Header *cur)
 {
-  char tempfile[_POSIX_PATH_MAX], buf[LONG_STRING];
+  char tempfile[PATH_MAX], buf[LONG_STRING];
   int rc = 0;
   bool builtin = false;
   int cmflags = MUTT_CM_DECODE | MUTT_CM_DISPLAY | MUTT_CM_CHARCONV;
@@ -784,7 +784,7 @@ int mutt_save_message_ctx(struct Header *h, int delete, int decode, int decrypt,
 int mutt_save_message(struct Header *h, int delete, int decode, int decrypt)
 {
   int need_passphrase = 0, app = 0;
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   const char *prompt = NULL;
   struct Context ctx;
   struct stat st;

diff --git a/complete.c b/complete.c
index f084fd78e77cfed7cbd81041a0e34a0d4220e8b6..e6d64854c34d179c8271196f3cae9bbe139ea9bf 100644 (file)
--- a/complete.c
+++ b/complete.c
@@ -62,8 +62,8 @@ int mutt_complete(char *buf, size_t buflen)
   struct dirent *de = NULL;
   int i, init = 0;
   size_t len;
-  char dirpart[_POSIX_PATH_MAX], exp_dirpart[_POSIX_PATH_MAX];
-  char filepart[_POSIX_PATH_MAX];
+  char dirpart[PATH_MAX], exp_dirpart[PATH_MAX];
+  char filepart[PATH_MAX];
 #ifdef USE_IMAP
   char imap_path[LONG_STRING];
 #endif
@@ -158,7 +158,7 @@ int mutt_complete(char *buf, size_t buflen)
     p = strrchr(buf, '/');
     if (p)
     {
-      char tmp[_POSIX_PATH_MAX];
+      char tmp[PATH_MAX];
       if (mutt_file_concatn_path(tmp, sizeof(tmp), exp_dirpart, strlen(exp_dirpart),
                                  buf + 1, (size_t)(p - buf - 1)) == NULL)
       {
@@ -246,7 +246,7 @@ int mutt_complete(char *buf, size_t buflen)
       }
       else
       {
-        char tmp[_POSIX_PATH_MAX];
+        char tmp[PATH_MAX];
         struct stat st;
 
         mutt_str_strfcpy(filepart, de->d_name, sizeof(filepart));

diff --git a/compose.c b/compose.c
index ee138b95aa9b0f058d8257d1e83d9ec191087913..5a2c2be33568b4bf1e0fac6ada48ca7d70bd9a20 100644 (file)
--- a/compose.c
+++ b/compose.c
@@ -363,7 +363,7 @@ static int check_attachments(struct AttachCtx *actx)
 {
   int r;
   struct stat st;
-  char pretty[_POSIX_PATH_MAX], msg[_POSIX_PATH_MAX + SHORT_STRING];
+  char pretty[PATH_MAX], msg[PATH_MAX + SHORT_STRING];
 
   for (int i = 0; i < actx->idxlen; i++)
   {
@@ -814,7 +814,7 @@ int mutt_compose_menu(struct Header *msg, char *fcc, size_t fcclen,
 {
   char helpstr[LONG_STRING];
   char buf[LONG_STRING];
-  char fname[_POSIX_PATH_MAX];
+  char fname[PATH_MAX];
   struct AttachPtr *new = NULL;
   int i, close = 0;
   int r = -1; /* return value */

diff --git a/compress.c b/compress.c
index 0af613a02a3a77c5fc71811fa0e952031e0bf91b..d237d195a02add43d933b0a69148beed5a8b00a3 100644 (file)
--- a/compress.c
+++ b/compress.c
@@ -154,7 +154,7 @@ static int setup_paths(struct Context *ctx)
   if (!ctx)
     return -1;
 
-  char tmppath[_POSIX_PATH_MAX];
+  char tmppath[PATH_MAX];
 
   /* Setup the right paths */
   FREE(&ctx->realpath);

diff --git a/conn/ssl.c b/conn/ssl.c
index f24bd6d06ea791acadf348cb2571d947cfd3f0af..d90e1e4c9d69b192681fe55dd109b6e2f72030f8 100644 (file)
--- a/conn/ssl.c
+++ b/conn/ssl.c
@@ -595,7 +595,7 @@ static int ssl_init(void)
   if (!HAVE_ENTROPY())
   {
     /* load entropy from files */
-    char path[_POSIX_PATH_MAX];
+    char path[PATH_MAX];
     add_entropy(EntropyFile);
     add_entropy(RAND_file_name(path, sizeof(path)));
 

diff --git a/editmsg.c b/editmsg.c
index dd40e0c67e23938b9eb8bb4e14a6aed6abb8e628..f169fc07d706d1835b45da0fa999091a135cffc9 100644 (file)
--- a/editmsg.c
+++ b/editmsg.c
@@ -58,7 +58,7 @@
  */
 static int edit_or_view_one_message(bool edit, struct Context *ctx, struct Header *cur)
 {
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
   char buf[STRING];
   int omagic;
   int oerrno;

diff --git a/handler.c b/handler.c
index d719ed06d1e01b3147c5f7b18186a36121b659e8..d579074908d6ed18251f9843be7a7f81b930ad03 100644 (file)
--- a/handler.c
+++ b/handler.c
@@ -511,7 +511,7 @@ static int autoview_handler(struct Body *a, struct State *s)
   char buffer[LONG_STRING];
   char type[STRING];
   char command[HUGE_STRING];
-  char tempfile[_POSIX_PATH_MAX] = "";
+  char tempfile[PATH_MAX] = "";
   char *fname = NULL;
   FILE *fpin = NULL;
   FILE *fpout = NULL;
@@ -1296,7 +1296,7 @@ static int run_decode_and_handler(struct Body *b, struct State *s,
   {
     const int orig_type = b->type;
 #ifndef USE_FMEMOPEN
-    char tempfile[_POSIX_PATH_MAX];
+    char tempfile[PATH_MAX];
 #endif
     if (!plaintext)
     {

diff --git a/hcache/bdb.c b/hcache/bdb.c
index ed785f61d0ff40bc8e7ff66b5731aeb5325bae78..c8bcdb15271d225c594421f603006c68bf192cae 100644 (file)
--- a/hcache/bdb.c
+++ b/hcache/bdb.c
@@ -51,7 +51,7 @@ struct HcacheDbCtx
   DB_ENV *env;
   DB *db;
   int fd;
-  char lockfile[_POSIX_PATH_MAX];
+  char lockfile[PATH_MAX];
 };
 
 /**

diff --git a/hcache/hcache.c b/hcache/hcache.c
index 69a9664b80af7635b5c692c4c59d18094940ac86..3b1287830abba5e910309a5c655c8fe4c7d78c0f 100644 (file)
--- a/hcache/hcache.c
+++ b/hcache/hcache.c
@@ -693,7 +693,7 @@ static bool create_hcache_dir(const char *path)
   if (!path)
     return false;
 
-  static char dir[_POSIX_PATH_MAX];
+  static char dir[PATH_MAX];
   mutt_str_strfcpy(dir, path, sizeof(dir));
 
   char *p = strrchr(dir, '/');
@@ -734,7 +734,7 @@ static bool create_hcache_dir(const char *path)
  */
 static const char *hcache_per_folder(const char *path, const char *folder, hcache_namer_t namer)
 {
-  static char hcpath[_POSIX_PATH_MAX];
+  static char hcpath[PATH_MAX];
   char suffix[32] = "";
   struct stat sb;
 
@@ -764,7 +764,7 @@ static const char *hcache_per_folder(const char *path, const char *folder, hcach
   else
   {
     unsigned char m[16]; /* binary md5sum */
-    char name[_POSIX_PATH_MAX];
+    char name[PATH_MAX];
     snprintf(name, sizeof(name), "%s|%s", hcache_get_ops()->name, folder);
     mutt_md5(name, m);
     mutt_md5_toascii(m, name);
@@ -1016,7 +1016,7 @@ void *mutt_hcache_fetch(header_cache_t *h, const char *key, size_t keylen)
  */
 void *mutt_hcache_fetch_raw(header_cache_t *h, const char *key, size_t keylen)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   const struct HcacheOps *ops = hcache_get_ops();
 
   if (!h || !ops)
@@ -1074,7 +1074,7 @@ int mutt_hcache_store(header_cache_t *h, const char *key, size_t keylen,
 int mutt_hcache_store_raw(header_cache_t *h, const char *key, size_t keylen,
                           void *data, size_t dlen)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   const struct HcacheOps *ops = hcache_get_ops();
 
   if (!h || !ops)
@@ -1090,7 +1090,7 @@ int mutt_hcache_store_raw(header_cache_t *h, const char *key, size_t keylen,
  */
 int mutt_hcache_delete(header_cache_t *h, const char *key, size_t keylen)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   const struct HcacheOps *ops = hcache_get_ops();
 
   if (!h)

diff --git a/hcache/kc.c b/hcache/kc.c
index cbae92552a6f6191a2f1d6b02592c45121404c76..a78724803df2e0b65452046a3959254903daf714 100644 (file)
--- a/hcache/kc.c
+++ b/hcache/kc.c
@@ -42,7 +42,7 @@
  */
 static void *hcache_kyotocabinet_open(const char *path)
 {
-  char kcdbpath[_POSIX_PATH_MAX];
+  char kcdbpath[PATH_MAX];
   int printfresult;
 
   printfresult = snprintf(kcdbpath, sizeof(kcdbpath), "%s#type=kct#opts=%s#rcomp=lex",

diff --git a/header.c b/header.c
index 4ff9c45fa85f5f74cf709f09e6278701122bdbec..6fd5b89768b7c0932e57961bbe72628e3835e47f 100644 (file)
--- a/header.c
+++ b/header.c
@@ -42,7 +42,7 @@
 void mutt_edit_headers(const char *editor, const char *body, struct Header *msg,
                        char *fcc, size_t fcclen)
 {
-  char path[_POSIX_PATH_MAX]; /* tempfile used to edit headers + body */
+  char path[PATH_MAX]; /* tempfile used to edit headers + body */
   char buffer[LONG_STRING];
   const char *p = NULL;
   int i;

diff --git a/help.c b/help.c
index 3a98062a3fc45f45e173fbc2efff5830e80f1e82..50999495431f0bc59998bc3b0e23af372dcd8369 100644 (file)
--- a/help.c
+++ b/help.c
@@ -345,7 +345,7 @@ static void dump_unbound(FILE *f, const struct Binding *funcs,
 
 void mutt_help(int menu)
 {
-  char t[_POSIX_PATH_MAX];
+  char t[PATH_MAX];
   char buf[SHORT_STRING];
   FILE *f = NULL;
 

diff --git a/history.c b/history.c
index 306d9890b140ad4a9d13f88ba4703efb761367e7..ef1a139fd4c3f71dfec32896061ba616a3a6589f 100644 (file)
--- a/history.c
+++ b/history.c
@@ -214,7 +214,7 @@ static int dup_hash_inc(struct Hash *dup_hash, char *str)
  */
 static void shrink_histfile(void)
 {
-  char tmpfname[_POSIX_PATH_MAX];
+  char tmpfname[PATH_MAX];
   FILE *tmp = NULL;
   int n[HC_LAST] = { 0 };
   int line, hclass, read;

diff --git a/hook.c b/hook.c
index 1d904078cfc8b0687414f105dfc2d9838e87694e..18aea1fe29da2f495df5d0950c6e1ccca544357a 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -84,7 +84,7 @@ int mutt_parse_hook(struct Buffer *buf, struct Buffer *s, unsigned long data,
   bool not = false;
   regex_t *rx = NULL;
   struct Pattern *pat = NULL;
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   mutt_buffer_init(&pattern);
   mutt_buffer_init(&command);
@@ -547,7 +547,7 @@ void mutt_default_save(char *path, size_t pathlen, struct Header *hdr)
     addr = NULL;
   if (addr)
   {
-    char tmp[_POSIX_PATH_MAX];
+    char tmp[PATH_MAX];
     mutt_safe_path(tmp, sizeof(tmp), addr);
     snprintf(path, pathlen, "=%s", tmp);
   }
@@ -567,7 +567,7 @@ void mutt_select_fcc(char *path, size_t pathlen, struct Header *hdr)
     if ((SaveName || ForceName) && (env->to || env->cc || env->bcc))
     {
       struct Address *addr = env->to ? env->to : (env->cc ? env->cc : env->bcc);
-      char buf[_POSIX_PATH_MAX];
+      char buf[PATH_MAX];
       mutt_safe_path(buf, sizeof(buf), addr);
       mutt_file_concat_path(path, NONULL(Folder), buf, pathlen);
       if (!ForceName && mx_access(path, W_OK) != 0)

diff --git a/imap/imap.c b/imap/imap.c
index 88aca466049dffbe2d45e068723a4f0d558865dc..5c735fd3a1650bb6929eea13101cfa57e1d25332 100644 (file)
--- a/imap/imap.c
+++ b/imap/imap.c
@@ -2315,7 +2315,7 @@ static int imap_mbox_close(struct Context *ctx)
  */
 static int imap_msg_open_new(struct Context *ctx, struct Message *msg, struct Header *hdr)
 {
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
 
   mutt_mktemp(tmp, sizeof(tmp));
   msg->fp = mutt_file_fopen(tmp, "w");

diff --git a/imap/message.c b/imap/message.c
index cb3429ec7fab2ba0ed1f99a0821f610bc95b5cca..9944040d341bbec0985e147e8e9916fb4c5ba0c5 100644 (file)
--- a/imap/message.c
+++ b/imap/message.c
@@ -100,7 +100,7 @@ static void update_context(struct ImapData *idata, int oldmsgcount)
  */
 static struct BodyCache *msg_cache_open(struct ImapData *idata)
 {
-  char mailbox[_POSIX_PATH_MAX];
+  char mailbox[PATH_MAX];
 
   if (idata->bcache)
     return idata->bcache;
@@ -606,7 +606,7 @@ int imap_read_headers(struct ImapData *idata, unsigned int msn_begin, unsigned i
 {
   char *hdrreq = NULL;
   FILE *fp = NULL;
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   int msgno, idx;
   struct ImapHeader h;
   struct ImapStatus *status = NULL;
@@ -976,7 +976,7 @@ int imap_msg_open(struct Context *ctx, struct Message *msg, int msgno)
 {
   struct Envelope *newenv = NULL;
   char buf[LONG_STRING];
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   char *pc = NULL;
   unsigned int bytes;
   struct Progress progressbar;

diff --git a/init.c b/init.c
index 7538fe67d616ffeb36e792bb9016cea1644fdf15..06747812f7f9a33d7d4400a2ed9693d04e5a1f41 100644 (file)
--- a/init.c
+++ b/init.c
@@ -1088,7 +1088,7 @@ static void restore_default(struct Option *p)
         FREE((char **) p->var);
         if (init)
         {
-          char path[_POSIX_PATH_MAX];
+          char path[PATH_MAX];
           mutt_str_strfcpy(path, init, sizeof(path));
           mutt_expand_path(path, sizeof(path));
           *((char **) p->var) = mutt_str_strdup(path);
@@ -1909,7 +1909,7 @@ static int parse_my_hdr(struct Buffer *buf, struct Buffer *s,
 static int parse_path_list(struct Buffer *buf, struct Buffer *s,
                            unsigned long data, struct Buffer *err)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   do
   {
@@ -1935,7 +1935,7 @@ static int parse_path_list(struct Buffer *buf, struct Buffer *s,
 static int parse_path_unlist(struct Buffer *buf, struct Buffer *s,
                              unsigned long data, struct Buffer *err)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   do
   {
@@ -2181,7 +2181,7 @@ static int parse_set(struct Buffer *buf, struct Buffer *s, unsigned long data,
         }
         else if ((idx >= 0) && (DTYPE(MuttVars[idx].type) == DT_PATH))
         {
-          char scratch[_POSIX_PATH_MAX];
+          char scratch[PATH_MAX];
           mutt_str_strfcpy(scratch, buf->data, sizeof(scratch));
           mutt_expand_path(scratch, sizeof(scratch));
           if (mutt_str_strcmp(MuttVars[idx].name, "debug_file") == 0)
@@ -2652,7 +2652,7 @@ static int parse_setenv(struct Buffer *buf, struct Buffer *s,
 static int parse_source(struct Buffer *buf, struct Buffer *s,
                         unsigned long data, struct Buffer *err)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   do
   {

diff --git a/main.c b/main.c
index 9a0154b1f9e730719935bfba0a92e4afb4807078..1334791dfd9052c1be02622635275fc1654d743a 100644 (file)
--- a/main.c
+++ b/main.c
@@ -289,7 +289,7 @@ static int get_user_info(void)
  */
 int main(int argc, char *argv[], char *envp[])
 {
-  char folder[_POSIX_PATH_MAX] = "";
+  char folder[PATH_MAX] = "";
   char *subject = NULL;
   char *include_file = NULL;
   char *draft_file = NULL;
@@ -669,7 +669,7 @@ int main(int argc, char *argv[], char *envp[])
   if (!OptNoCurses && Folder)
   {
     struct stat sb;
-    char fpath[_POSIX_PATH_MAX];
+    char fpath[PATH_MAX];
 
     mutt_str_strfcpy(fpath, Folder, sizeof(fpath));
     mutt_expand_path(fpath, sizeof(fpath));
@@ -718,7 +718,7 @@ int main(int argc, char *argv[], char *envp[])
     char *tempfile = NULL, *infile = NULL;
     char *bodytext = NULL, *bodyfile = NULL;
     int rv = 0;
-    char expanded_infile[_POSIX_PATH_MAX];
+    char expanded_infile[PATH_MAX];
 
     if (!OptNoCurses)
       mutt_flushinp();

diff --git a/mbox.c b/mbox.c
index 238a42be56d710265cb31e332ffc27e00a771082..a97c8c51cfbdab160fce80f401292baba8852c6e 100644 (file)
--- a/mbox.c
+++ b/mbox.c
@@ -972,7 +972,7 @@ void mbox_reset_atime(struct Context *ctx, struct stat *st)
  */
 static int mbox_mbox_sync(struct Context *ctx, int *index_hint)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   char buf[32];
   int i, j, save_sort = SORT_ORDER;
   int rc = -1;
@@ -1241,7 +1241,7 @@ static int mbox_mbox_sync(struct Context *ctx, int *index_hint)
      * around
      */
 
-    char savefile[_POSIX_PATH_MAX];
+    char savefile[PATH_MAX];
 
     snprintf(savefile, sizeof(savefile), "%s/neomutt.%s-%s-%u", NONULL(Tmpdir),
              NONULL(Username), NONULL(ShortHostname), (unsigned int) getpid());

diff --git a/mh.c b/mh.c
index df3b80a0ec45b9bd0199ba16880440fa8e8d9fb6..f3c414e107b3d1c1788053e44f0b5776e8ed4a9e 100644 (file)
--- a/mh.c
+++ b/mh.c
@@ -167,7 +167,7 @@ static int mh_read_sequences(struct MhSequences *mhs, const char *path)
   short f;
   int first, last, rc = 0;
 
-  char pathname[_POSIX_PATH_MAX];
+  char pathname[PATH_MAX];
   snprintf(pathname, sizeof(pathname), "%s/.mh_sequences", path);
 
   FILE *fp = fopen(pathname, "r");
@@ -236,7 +236,7 @@ static inline mode_t mh_umask(struct Context *ctx)
  */
 static int mh_sequences_changed(struct Buffy *b)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   struct stat sb;
 
   if ((snprintf(path, sizeof(path), "%s/.mh_sequences", b->path) < sizeof(path)) &&
@@ -257,7 +257,7 @@ static int mh_sequences_changed(struct Buffy *b)
  */
 static int mh_already_notified(struct Buffy *b, int msgno)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   struct stat sb;
 
   if ((snprintf(path, sizeof(path), "%s/%d", b->path, msgno) < sizeof(path)) &&
@@ -374,7 +374,7 @@ bool mh_buffy(struct Buffy *mailbox, bool check_stats)
 static int mh_mkstemp(struct Context *dest, FILE **fp, char **tgt)
 {
   int fd;
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   mode_t omask;
 
   omask = umask(mh_umask(dest));
@@ -462,7 +462,7 @@ static void mh_update_sequences(struct Context *ctx)
 {
   FILE *ofp = NULL, *nfp = NULL;
 
-  char sequences[_POSIX_PATH_MAX];
+  char sequences[PATH_MAX];
   char *tmpfname = NULL;
   char *buf = NULL;
   char *p = NULL;
@@ -576,7 +576,7 @@ static void mh_sequences_add_one(struct Context *ctx, int n, short unseen,
   FILE *ofp = NULL, *nfp = NULL;
 
   char *tmpfname = NULL;
-  char sequences[_POSIX_PATH_MAX];
+  char sequences[PATH_MAX];
 
   char seq_unseen[STRING];
   char seq_replied[STRING];
@@ -746,7 +746,7 @@ void maildir_parse_flags(struct Header *h, const char *path)
 
 static void maildir_update_mtime(struct Context *ctx)
 {
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   struct stat st;
   struct MhData *data = mh_data(ctx);
 
@@ -831,7 +831,7 @@ static int maildir_parse_dir(struct Context *ctx, struct Maildir ***last,
 {
   DIR *dirp = NULL;
   struct dirent *de = NULL;
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   int is_old = 0;
   struct Maildir *entry = NULL;
   struct Header *h = NULL;
@@ -1121,7 +1121,7 @@ static void maildir_delayed_parsing(struct Context *ctx, struct Maildir **md,
                                     struct Progress *progress)
 {
   struct Maildir *p, *last = NULL;
-  char fn[_POSIX_PATH_MAX];
+  char fn[PATH_MAX];
   int count;
   int sort = 0;
 #ifdef USE_HCACHE
@@ -1342,7 +1342,7 @@ static int maildir_mbox_open_append(struct Context *ctx, int flags)
     return -1;
   }
 
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
   snprintf(tmp, sizeof(tmp), "%s/cur", ctx->path);
   if (mkdir(tmp, S_IRWXU))
   {
@@ -1400,7 +1400,7 @@ static int mh_mbox_open_append(struct Context *ctx, int flags)
     return -1;
   }
 
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
   snprintf(tmp, sizeof(tmp), "%s/.mh_sequences", ctx->path);
   const int i = creat(tmp, S_IRWXU);
   if (i == -1)
@@ -1458,7 +1458,7 @@ static int maildir_mh_open_message(struct Context *ctx, struct Message *msg,
                                    int msgno, int is_maildir)
 {
   struct Header *cur = ctx->hdrs[msgno];
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   snprintf(path, sizeof(path), "%s/%s", ctx->path, cur->path);
 
@@ -1514,7 +1514,7 @@ static int maildir_msg_open_new(struct Context *ctx, struct Message *msg,
                                     struct Header *hdr)
 {
   int fd;
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   char suffix[16];
   char subdir[16];
   mode_t omask;
@@ -1598,8 +1598,8 @@ static int md_commit_message(struct Context *ctx, struct Message *msg, struct He
 {
   char subdir[4];
   char suffix[16];
-  char path[_POSIX_PATH_MAX];
-  char full[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
+  char full[PATH_MAX];
   char *s = NULL;
 
   if (mutt_file_fsync_close(&msg->fp))
@@ -1690,7 +1690,7 @@ static int mh_commit_msg(struct Context *ctx, struct Message *msg,
   struct dirent *de = NULL;
   char *cp = NULL, *dep = NULL;
   unsigned int n, hi = 0;
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   char tmp[16];
 
   if (mutt_file_fsync_close(&msg->fp))
@@ -1791,8 +1791,8 @@ static int mh_rewrite_message(struct Context *ctx, int msgno)
   int rc = mutt_copy_message_ctx(dest->fp, ctx, h, MUTT_CM_UPDATE, CH_UPDATE | CH_UPDATE_LEN);
   if (rc == 0)
   {
-    char oldpath[_POSIX_PATH_MAX];
-    char partpath[_POSIX_PATH_MAX];
+    char oldpath[PATH_MAX];
+    char partpath[PATH_MAX];
     snprintf(oldpath, sizeof(oldpath), "%s/%s", ctx->path, h->path);
     mutt_str_strfcpy(partpath, h->path, sizeof(partpath));
 
@@ -1826,7 +1826,7 @@ static int mh_rewrite_message(struct Context *ctx, int msgno)
 
     if (ctx->magic == MUTT_MH && rc == 0)
     {
-      char newpath[_POSIX_PATH_MAX];
+      char newpath[PATH_MAX];
       snprintf(newpath, sizeof(newpath), "%s/%s", ctx->path, h->path);
       rc = mutt_file_safe_rename(newpath, oldpath);
       if (rc == 0)
@@ -1876,10 +1876,10 @@ static int maildir_sync_message(struct Context *ctx, int msgno)
   {
     /* we just have to rename the file. */
 
-    char newpath[_POSIX_PATH_MAX];
-    char partpath[_POSIX_PATH_MAX];
-    char fullpath[_POSIX_PATH_MAX];
-    char oldpath[_POSIX_PATH_MAX];
+    char newpath[PATH_MAX];
+    char partpath[PATH_MAX];
+    char fullpath[PATH_MAX];
+    char oldpath[PATH_MAX];
     char suffix[16];
 
     char *p = strrchr(h->path, '/');
@@ -1932,7 +1932,7 @@ int mh_sync_mailbox_message(struct Context *ctx, int msgno)
 
   if (h->deleted && (ctx->magic != MUTT_MAILDIR || !MaildirTrash))
   {
-    char path[_POSIX_PATH_MAX];
+    char path[PATH_MAX];
     snprintf(path, sizeof(path), "%s/%s", ctx->path, h->path);
     if (ctx->magic == MUTT_MAILDIR || (MhPurge && ctx->magic == MUTT_MH))
     {
@@ -1961,7 +1961,7 @@ int mh_sync_mailbox_message(struct Context *ctx, int msgno)
       /* MH just moves files out of the way when you delete them */
       if (*h->path != ',')
       {
-        char tmp[_POSIX_PATH_MAX];
+        char tmp[PATH_MAX];
         snprintf(tmp, sizeof(tmp), "%s/,%s", ctx->path, h->path);
         unlink(tmp);
         rename(path, tmp);
@@ -2058,7 +2058,7 @@ static int maildir_mbox_check(struct Context *ctx, int *index_hint)
 {
   struct stat st_new; /* status of the "new" subdirectory */
   struct stat st_cur; /* status of the "cur" subdirectory */
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   int changed = 0;            /* bitmask representing which subdirectories
                                  have changed.  0x1 = new, 0x2 = cur */
   bool occult = false;        /* messages were removed from the mailbox */
@@ -2215,7 +2215,7 @@ static int maildir_mbox_check(struct Context *ctx, int *index_hint)
  */
 static int mh_mbox_check(struct Context *ctx, int *index_hint)
 {
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   struct stat st, st_cur;
   bool modified = false, have_new = false, occult = false, flags_changed = false;
   struct Maildir *md = NULL, *p = NULL;
@@ -2452,8 +2452,8 @@ bool maildir_update_flags(struct Context *ctx, struct Header *o, struct Header *
 static FILE *md_open_find_message(const char *folder, const char *unique,
                                   const char *subfolder, char **newname)
 {
-  char dir[_POSIX_PATH_MAX];
-  char tunique[_POSIX_PATH_MAX];
+  char dir[PATH_MAX];
+  char tunique[PATH_MAX];
   char fname[LONG_STRING];
 
   struct dirent *de = NULL;
@@ -2494,7 +2494,7 @@ static FILE *md_open_find_message(const char *folder, const char *unique,
 
 FILE *maildir_open_find_message(const char *folder, const char *msg, char **newname)
 {
-  char unique[_POSIX_PATH_MAX];
+  char unique[PATH_MAX];
 
   static unsigned int new_hits = 0, cur_hits = 0; /* simple dynamic optimization */
 
@@ -2538,7 +2538,7 @@ int maildir_check_empty(const char *path)
   DIR *dp = NULL;
   struct dirent *de = NULL;
   int r = 1; /* assume empty until we find a message */
-  char realpath[_POSIX_PATH_MAX];
+  char realpath[PATH_MAX];
   int iter = 0;
 
   /* Strategy here is to look for any file not beginning with a period */
@@ -2597,7 +2597,7 @@ int mh_check_empty(const char *path)
 
 bool mx_is_maildir(const char *path)
 {
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
   struct stat st;
 
   snprintf(tmp, sizeof(tmp), "%s/cur", path);
@@ -2608,7 +2608,7 @@ bool mx_is_maildir(const char *path)
 
 bool mx_is_mh(const char *path)
 {
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
 
   snprintf(tmp, sizeof(tmp), "%s/.mh_sequences", path);
   if (access(tmp, F_OK) == 0)

diff --git a/mutt.h b/mutt.h
index d8b379b478fa1ae2f659fd45289366db16b2e333..4474497470cb092795fec29ca02f7e852109a7ee 100644 (file)
--- a/mutt.h
+++ b/mutt.h
@@ -42,8 +42,8 @@ struct Mapping;
 #endif
 
 /* PATH_MAX is undefined on the hurd */
-#if !defined(PATH_MAX) && defined(_POSIX_PATH_MAX)
-#define PATH_MAX _POSIX_PATH_MAX
+#ifndef PATH_MAX
+#define PATH_MAX 4096
 #endif
 
 #ifdef HAVE_FGETS_UNLOCKED

diff --git a/mutt/file.c b/mutt/file.c
index 2b07138eaa5c3d878af9de6d59ae187042c95e6d..608a3d422cc9ab786425685f0d1d89510d3410a0 100644 (file)
--- a/mutt/file.c
+++ b/mutt/file.c
@@ -90,7 +90,7 @@ static bool compare_stat(struct stat *osb, struct stat *nsb)
 static int mkwrapdir(const char *path, char *newfile, size_t nflen, char *newdir, size_t ndlen)
 {
   const char *basename = NULL;
-  char parent[_POSIX_PATH_MAX];
+  char parent[PATH_MAX];
   char *p = NULL;
 
   mutt_str_strfcpy(parent, NONULL(path), sizeof(parent));
@@ -303,7 +303,7 @@ int mutt_file_symlink(const char *oldpath, const char *newpath)
   }
   else
   {
-    char abs_oldpath[_POSIX_PATH_MAX];
+    char abs_oldpath[PATH_MAX];
 
     if ((getcwd(abs_oldpath, sizeof(abs_oldpath)) == NULL) ||
         ((strlen(abs_oldpath) + 1 + strlen(oldpath) + 1) > sizeof(abs_oldpath)))
@@ -473,8 +473,8 @@ int mutt_file_open(const char *path, int flags)
 
   if (flags & O_EXCL)
   {
-    char safe_file[_POSIX_PATH_MAX];
-    char safe_dir[_POSIX_PATH_MAX];
+    char safe_file[PATH_MAX];
+    char safe_dir[PATH_MAX];
 
     if (mkwrapdir(path, safe_file, sizeof(safe_file), safe_dir, sizeof(safe_dir)) == -1)
       return -1;

diff --git a/mutt_lua.c b/mutt_lua.c
index e69f4b68816ac215646e78df953880dc303c2722..71f5f12e3c57173720c5114f42b16a2fadef06c2 100644 (file)
--- a/mutt_lua.c
+++ b/mutt_lua.c
@@ -432,7 +432,7 @@ int mutt_lua_source_file(struct Buffer *tmp, struct Buffer *s,
 
   lua_init(&Lua);
 
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
 
   if (mutt_extract_token(tmp, s, 0) != 0)
   {

diff --git a/mutt_notmuch.c b/mutt_notmuch.c
index d71e7cfe3cbb5dbee8adfea39fe24c1e8a3f91fc..4337b01844b43824d94df13a60590df5b3e6bf5c 100644 (file)
--- a/mutt_notmuch.c
+++ b/mutt_notmuch.c
@@ -702,7 +702,7 @@ static bool is_longrun(struct NmCtxData *data)
  */
 static int get_database_mtime(struct NmCtxData *data, time_t *mtime)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   struct stat st;
 
   if (!data)
@@ -1512,9 +1512,9 @@ static int update_header_flags(struct Context *ctx, struct Header *hdr, const ch
 static int rename_maildir_filename(const char *old, char *newpath, size_t newsz,
                                    struct Header *h)
 {
-  char filename[_POSIX_PATH_MAX];
-  char suffix[_POSIX_PATH_MAX];
-  char folder[_POSIX_PATH_MAX];
+  char filename[PATH_MAX];
+  char suffix[PATH_MAX];
+  char folder[PATH_MAX];
 
   mutt_str_strfcpy(folder, old, sizeof(folder));
   char *p = strrchr(folder, '/');
@@ -1673,7 +1673,7 @@ static int rename_filename(struct NmCtxData *data, const char *old,
            msg && ls && notmuch_filenames_valid(ls); notmuch_filenames_move_to_next(ls))
       {
         const char *path = notmuch_filenames_get(ls);
-        char newpath[_POSIX_PATH_MAX];
+        char newpath[PATH_MAX];
 
         if (strcmp(new, path) == 0)
           continue;
@@ -1877,7 +1877,7 @@ char *nm_uri_from_query(struct Context *ctx, char *buf, size_t buflen)
 {
   mutt_debug(2, "(%s)\n", buf);
   struct NmCtxData *data = get_ctxdata(ctx);
-  char uri[_POSIX_PATH_MAX + LONG_STRING + 32]; /* path to DB + query + URI "decoration" */
+  char uri[PATH_MAX + LONG_STRING + 32]; /* path to DB + query + URI "decoration" */
   int added;
 
   if (data)
@@ -2538,7 +2538,7 @@ static int nm_mbox_check(struct Context *ctx, int *index_hint)
   for (int i = 0; notmuch_messages_valid(msgs) && ((limit == 0) || (i < limit));
        notmuch_messages_move_to_next(msgs), i++)
   {
-    char old[_POSIX_PATH_MAX];
+    char old[PATH_MAX];
     const char *new = NULL;
 
     notmuch_message_t *m = notmuch_messages_get(msgs);
@@ -2636,7 +2636,7 @@ static int nm_mbox_sync(struct Context *ctx, int *index_hint)
 
   for (int i = 0; i < ctx->msgcount; i++)
   {
-    char old[_POSIX_PATH_MAX], new[_POSIX_PATH_MAX];
+    char old[PATH_MAX], new[PATH_MAX];
     struct Header *h = ctx->hdrs[i];
     struct NmHdrData *hd = h->data;
 
@@ -2701,7 +2701,7 @@ static int nm_msg_open(struct Context *ctx, struct Message *msg, int msgno)
   if (!ctx || !msg)
     return 1;
   struct Header *cur = ctx->hdrs[msgno];
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   char *folder = nm_header_get_folder(cur);
 
   snprintf(path, sizeof(path), "%s/%s", folder, cur->path);

diff --git a/muttlib.c b/muttlib.c
index eb0ffce8883a2f16aee2815793d520382dd022a3..6aa492af25d5554a5af8ca1ddec47a2cf2ae3eea 100644 (file)
--- a/muttlib.c
+++ b/muttlib.c
@@ -90,7 +90,7 @@ void mutt_adv_mktemp(char *s, size_t l)
   }
   else
   {
-    char prefix[_POSIX_PATH_MAX];
+    char prefix[PATH_MAX];
     mutt_str_strfcpy(prefix, s, sizeof(prefix));
     mutt_file_sanitize_filename(prefix, true);
     snprintf(s, l, "%s/%s", NONULL(Tmpdir), prefix);
@@ -125,9 +125,9 @@ char *mutt_expand_path(char *s, size_t slen)
 
 char *mutt_expand_path_regex(char *s, size_t slen, bool regex)
 {
-  char p[_POSIX_PATH_MAX] = "";
-  char q[_POSIX_PATH_MAX] = "";
-  char tmp[_POSIX_PATH_MAX];
+  char p[PATH_MAX] = "";
+  char q[PATH_MAX] = "";
+  char tmp[PATH_MAX];
   char *t = NULL;
 
   char *tail = "";
@@ -676,7 +676,7 @@ int mutt_check_overwrite(const char *attname, const char *path, char *fname,
     else if ((rc = mutt_yesorno(_("File is a directory, save under it?"), MUTT_YES)) != MUTT_YES)
       return (rc == MUTT_NO) ? 1 : -1;
 
-    char tmp[_POSIX_PATH_MAX];
+    char tmp[PATH_MAX];
     mutt_str_strfcpy(tmp, mutt_file_basename(NONULL(attname)), sizeof(tmp));
     if (mutt_get_field(_("File under directory: "), tmp, sizeof(tmp),
                        MUTT_FILE | MUTT_CLEAR) != 0 ||
@@ -1304,7 +1304,7 @@ FILE *mutt_open_read(const char *path, pid_t *thepid)
  */
 int mutt_save_confirm(const char *s, struct stat *st)
 {
-  char tmp[_POSIX_PATH_MAX];
+  char tmp[PATH_MAX];
   int ret = 0;
   int rc;
   int magic = 0;

diff --git a/mx.c b/mx.c
index e66e68d7912dc07d0209693d41cb937ca94bacdd..f9ba6051a9560ecc38347e6898128e471997f539 100644 (file)
--- a/mx.c
+++ b/mx.c
@@ -690,7 +690,7 @@ int mx_mbox_close(struct Context *ctx, int *index_hint)
 {
   int i, move_messages = 0, purge = 1, read_msgs = 0;
   struct Context f;
-  char mbox[_POSIX_PATH_MAX];
+  char mbox[PATH_MAX];
   char buf[SHORT_STRING];
 
   if (!ctx)

diff --git a/ncrypt/crypt.c b/ncrypt/crypt.c
index 55f5a6377363fbb663eeb78f84db1d52941dd08c..07fbb7b0718ce45cb02c55128e9d2f82d678f30a 100644 (file)
--- a/ncrypt/crypt.c
+++ b/ncrypt/crypt.c
@@ -726,7 +726,7 @@ void crypt_convert_to_7bit(struct Body *a)
 
 void crypt_extract_keys_from_messages(struct Header *h)
 {
-  char tempfname[_POSIX_PATH_MAX], *mbox = NULL;
+  char tempfname[PATH_MAX], *mbox = NULL;
   struct Address *tmp = NULL;
   FILE *fpout = NULL;
 
@@ -1045,7 +1045,7 @@ int mutt_signed_handler(struct Body *a, struct State *s)
 
     if (sigcnt)
     {
-      char tempfile[_POSIX_PATH_MAX];
+      char tempfile[PATH_MAX];
       mutt_mktemp(tempfile, sizeof(tempfile));
       bool goodsig = true;
       if (crypt_write_signed(a, s, tempfile) == 0)

diff --git a/ncrypt/crypt_gpgme.c b/ncrypt/crypt_gpgme.c
index d9c1a67c906a111c00025e67a862c59e8f4f6040..341df7cdbbf0cf416eb1aad8260ecd68061ec0c8 100644 (file)
--- a/ncrypt/crypt_gpgme.c
+++ b/ncrypt/crypt_gpgme.c
@@ -517,7 +517,7 @@ static gpgme_data_t create_gpgme_data(void)
  */
 static gpgme_data_t body_to_data_object(struct Body *a, int convert)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   int err = 0;
   gpgme_data_t data;
 
@@ -648,7 +648,7 @@ static int data_object_to_stream(gpgme_data_t data, FILE *fp)
 static char *data_object_to_tempfile(gpgme_data_t data, char *tempf, FILE **ret_fp)
 {
   int err;
-  char tempfb[_POSIX_PATH_MAX];
+  char tempfb[PATH_MAX];
   FILE *fp = NULL;
   ssize_t nread = 0;
 
@@ -1928,7 +1928,7 @@ restart:
  */
 int pgp_gpgme_decrypt_mime(FILE *fpin, FILE **fpout, struct Body *b, struct Body **cur)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   struct State s;
   struct Body *first_part = b;
   int is_signed = 0;
@@ -2021,7 +2021,7 @@ bail:
  */
 int smime_gpgme_decrypt_mime(FILE *fpin, FILE **fpout, struct Body *b, struct Body **cur)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   struct State s;
   FILE *tmpfp = NULL;
   int is_signed;
@@ -2148,8 +2148,8 @@ static int pgp_gpgme_extract_keys(gpgme_data_t keydata, FILE **fp, int dryrun)
 {
   /* there's no side-effect free way to view key data in GPGME,
    * so we import the key into a temporary keyring */
-  char tmpdir[_POSIX_PATH_MAX];
-  char tmpfile[_POSIX_PATH_MAX];
+  char tmpdir[PATH_MAX];
+  char tmpfile[PATH_MAX];
   gpgme_ctx_t tmpctx;
   gpgme_error_t err;
   gpgme_engine_info_t engineinfo;
@@ -2300,7 +2300,7 @@ static int line_compare(const char *a, size_t n, const char *b)
  */
 static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   char buf[HUGE_STRING];
   FILE *tfp = NULL;
 
@@ -2725,7 +2725,7 @@ int pgp_gpgme_application_handler(struct Body *m, struct State *s)
  */
 int pgp_gpgme_encrypted_handler(struct Body *a, struct State *s)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   int is_signed;
   int rc = 0;
 
@@ -2802,7 +2802,7 @@ int pgp_gpgme_encrypted_handler(struct Body *a, struct State *s)
  */
 int smime_gpgme_application_handler(struct Body *a, struct State *s)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   int is_signed;
   int rc = 0;
 
@@ -3858,7 +3858,7 @@ static void print_key_info(gpgme_key_t key, FILE *fp)
  */
 static void verify_key(struct CryptKeyInfo *key)
 {
-  char cmd[LONG_STRING], tempfile[_POSIX_PATH_MAX];
+  char cmd[LONG_STRING], tempfile[PATH_MAX];
   const char *s = NULL;
   gpgme_ctx_t listctx = NULL;
   gpgme_error_t err;

diff --git a/ncrypt/pgp.c b/ncrypt/pgp.c
index 5974e705ce885b94347bda422dcc85496b781614..95c8a6149d8798dcbf848ac4555f9af887888d87 100644 (file)
--- a/ncrypt/pgp.c
+++ b/ncrypt/pgp.c
@@ -328,8 +328,8 @@ int pgp_application_pgp_handler(struct Body *m, struct State *s)
   long bytes;
   LOFF_T last_pos, offset;
   char buf[HUGE_STRING];
-  char outfile[_POSIX_PATH_MAX];
-  char tmpfname[_POSIX_PATH_MAX];
+  char outfile[PATH_MAX];
+  char tmpfname[PATH_MAX];
   FILE *pgpout = NULL, *pgpin = NULL, *pgperr = NULL;
   FILE *tmpfp = NULL;
   pid_t thepid;
@@ -617,7 +617,7 @@ out:
 
 static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   char buf[HUGE_STRING];
   FILE *tfp = NULL;
 
@@ -699,7 +699,7 @@ int pgp_check_traditional(FILE *fp, struct Body *b, int just_one)
 
 int pgp_verify_one(struct Body *sigbdy, struct State *s, const char *tempfile)
 {
-  char sigfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
+  char sigfile[PATH_MAX], pgperrfile[PATH_MAX];
   FILE *pgpout = NULL, *pgperr = NULL;
   pid_t thepid;
   int badsig = -1;
@@ -766,7 +766,7 @@ int pgp_verify_one(struct Body *sigbdy, struct State *s, const char *tempfile)
 static void pgp_extract_keys_from_attachment(FILE *fp, struct Body *top)
 {
   struct State s;
-  char tempfname[_POSIX_PATH_MAX];
+  char tempfname[PATH_MAX];
 
   mutt_mktemp(tempfname, sizeof(tempfname));
   FILE *tempfp = mutt_file_fopen(tempfname, "w");
@@ -824,8 +824,8 @@ static struct Body *pgp_decrypt_part(struct Body *a, struct State *s,
   FILE *pgpin = NULL, *pgpout = NULL, *pgptmp = NULL;
   struct stat info;
   struct Body *tattach = NULL;
-  char pgperrfile[_POSIX_PATH_MAX];
-  char pgptmpfile[_POSIX_PATH_MAX];
+  char pgperrfile[PATH_MAX];
+  char pgptmpfile[PATH_MAX];
   pid_t thepid;
   int rv;
 
@@ -946,7 +946,7 @@ static struct Body *pgp_decrypt_part(struct Body *a, struct State *s,
 
 int pgp_decrypt_mime(FILE *fpin, FILE **fpout, struct Body *b, struct Body **cur)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   struct State s;
   struct Body *p = b;
   bool need_decode = false;
@@ -1032,7 +1032,7 @@ bail:
  */
 int pgp_encrypted_handler(struct Body *a, struct State *s)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   FILE *fpin = NULL;
   struct Body *tattach = NULL;
   int rc = 0;
@@ -1105,7 +1105,7 @@ struct Body *pgp_sign_message(struct Body *a)
 {
   struct Body *t = NULL;
   char buffer[LONG_STRING];
-  char sigfile[_POSIX_PATH_MAX], signedfile[_POSIX_PATH_MAX];
+  char sigfile[PATH_MAX], signedfile[PATH_MAX];
   FILE *pgpin = NULL, *pgpout = NULL, *pgperr = NULL, *sfp = NULL;
   bool err = false;
   bool empty = true;
@@ -1360,8 +1360,8 @@ char *pgp_find_keys(struct Address *addrlist, int oppenc_mode)
 struct Body *pgp_encrypt_message(struct Body *a, char *keylist, int sign)
 {
   char buf[LONG_STRING];
-  char tempfile[_POSIX_PATH_MAX], pgperrfile[_POSIX_PATH_MAX];
-  char pgpinfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX], pgperrfile[PATH_MAX];
+  char pgpinfile[PATH_MAX];
   FILE *pgpin = NULL, *pgperr = NULL, *fptmp = NULL;
   struct Body *t = NULL;
   int err = 0;
@@ -1489,9 +1489,9 @@ struct Body *pgp_traditional_encryptsign(struct Body *a, int flags, char *keylis
 {
   struct Body *b = NULL;
 
-  char pgpoutfile[_POSIX_PATH_MAX];
-  char pgperrfile[_POSIX_PATH_MAX];
-  char pgpinfile[_POSIX_PATH_MAX];
+  char pgpoutfile[PATH_MAX];
+  char pgperrfile[PATH_MAX];
+  char pgpinfile[PATH_MAX];
 
   char body_charset[STRING];
   char *from_charset = NULL;

diff --git a/ncrypt/pgpinvoke.c b/ncrypt/pgpinvoke.c
index 01c98940709cec64c0d1021024cb54b7510c75a2..e2f7ba1aaf2fe63ae0826176a96d351570e463d3 100644 (file)
--- a/ncrypt/pgpinvoke.c
+++ b/ncrypt/pgpinvoke.c
@@ -247,7 +247,7 @@ pid_t pgp_invoke_traditional(FILE **pgpin, FILE **pgpout, FILE **pgperr,
 
 void pgp_invoke_import(const char *fname)
 {
-  char tmp_fname[_POSIX_PATH_MAX + SHORT_STRING];
+  char tmp_fname[PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
   struct PgpCommandContext cctx;
 

diff --git a/ncrypt/pgpkey.c b/ncrypt/pgpkey.c
index 6c87e0d9a3b5285d6bc256f8a8b2cdc28bb17dc4..579f0f48643fbc4d5e98a44ec37c4c0a2d77f9e9 100644 (file)
--- a/ncrypt/pgpkey.c
+++ b/ncrypt/pgpkey.c
@@ -478,7 +478,7 @@ static struct PgpKeyInfo *pgp_select_key(struct PgpKeyInfo *keys,
   int i;
   bool done = false;
   char helpstr[LONG_STRING], buf[LONG_STRING], tmpbuf[STRING];
-  char cmd[LONG_STRING], tempfile[_POSIX_PATH_MAX];
+  char cmd[LONG_STRING], tempfile[PATH_MAX];
   FILE *fp = NULL, *devnull = NULL;
   pid_t thepid;
   struct PgpKeyInfo *kp = NULL;
@@ -746,7 +746,7 @@ struct Body *pgp_make_key_attachment(char *tempf)
 {
   struct Body *att = NULL;
   char buf[LONG_STRING];
-  char tempfb[_POSIX_PATH_MAX], tmp[STRING];
+  char tempfb[PATH_MAX], tmp[STRING];
   FILE *tempfp = NULL;
   FILE *devnull = NULL;
   struct stat sb;

diff --git a/ncrypt/pgpmicalg.c b/ncrypt/pgpmicalg.c
index 875c9f9e110c1a087fd881368ac24484afc931ce..f304aa8bfe161eea6b2ff158c0155a9142cb0a84 100644 (file)
--- a/ncrypt/pgpmicalg.c
+++ b/ncrypt/pgpmicalg.c
@@ -161,7 +161,7 @@ static short pgp_mic_from_packet(unsigned char *p, size_t len)
 
 static short pgp_find_hash(const char *fname)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   size_t l;
   short rc = -1;
 

diff --git a/ncrypt/smime.c b/ncrypt/smime.c
index d9af6715cbe725f342021cea157ea2f4ea750585..67a704fadd364bc7a0ddaf0562a025de5501dcce 100644 (file)
--- a/ncrypt/smime.c
+++ b/ncrypt/smime.c
@@ -76,9 +76,9 @@ struct SmimeCommandContext
 char SmimePass[STRING];
 time_t SmimeExptime = 0; /* when does the cached passphrase expire? */
 
-static char SmimeKeyToUse[_POSIX_PATH_MAX] = { 0 };
-static char SmimeCertToUse[_POSIX_PATH_MAX];
-static char SmimeIntermediateToUse[_POSIX_PATH_MAX];
+static char SmimeKeyToUse[PATH_MAX] = { 0 };
+static char SmimeCertToUse[PATH_MAX];
+static char SmimeIntermediateToUse[PATH_MAX];
 
 static void smime_free_key(struct SmimeKey **keylist)
 {
@@ -177,7 +177,7 @@ static const char *fmt_smime_command(char *buf, size_t buflen, size_t col, int c
     {
       if (!optional)
       {
-        char path[_POSIX_PATH_MAX];
+        char path[PATH_MAX];
         char buf1[LONG_STRING], buf2[LONG_STRING];
         struct stat sb;
 
@@ -621,7 +621,7 @@ static struct SmimeKey *smime_parse_key(char *buf)
 
 static struct SmimeKey *smime_get_candidates(char *search, short public)
 {
-  char index_file[_POSIX_PATH_MAX];
+  char index_file[PATH_MAX];
   char buf[LONG_STRING];
   struct SmimeKey *key = NULL, *results = NULL;
   struct SmimeKey **results_end = &results;
@@ -961,7 +961,7 @@ char *smime_find_keys(struct Address *addrlist, int oppenc_mode)
 static int smime_handle_cert_email(char *certificate, char *mailbox, int copy,
                                    char ***buffer, int *num)
 {
-  char tmpfname[_POSIX_PATH_MAX];
+  char tmpfname[PATH_MAX];
   char email[STRING];
   int rc = -1, count = 0;
   pid_t thepid;
@@ -1055,8 +1055,8 @@ static int smime_handle_cert_email(char *certificate, char *mailbox, int copy,
 
 static char *smime_extract_certificate(char *infile)
 {
-  char pk7out[_POSIX_PATH_MAX], certfile[_POSIX_PATH_MAX];
-  char tmpfname[_POSIX_PATH_MAX];
+  char pk7out[PATH_MAX], certfile[PATH_MAX];
+  char tmpfname[PATH_MAX];
   pid_t thepid;
   int empty;
 
@@ -1160,8 +1160,8 @@ static char *smime_extract_certificate(char *infile)
 
 static char *smime_extract_signer_certificate(char *infile)
 {
-  char certfile[_POSIX_PATH_MAX];
-  char tmpfname[_POSIX_PATH_MAX];
+  char certfile[PATH_MAX];
+  char tmpfname[PATH_MAX];
   pid_t thepid;
   int empty;
 
@@ -1225,7 +1225,7 @@ static char *smime_extract_signer_certificate(char *infile)
  */
 void smime_invoke_import(char *infile, char *mailbox)
 {
-  char tmpfname[_POSIX_PATH_MAX], *certfile = NULL, buf[STRING];
+  char tmpfname[PATH_MAX], *certfile = NULL, buf[STRING];
   FILE *smimein = NULL;
 
   mutt_mktemp(tmpfname, sizeof(tmpfname));
@@ -1297,7 +1297,7 @@ void smime_invoke_import(char *infile, char *mailbox)
 
 int smime_verify_sender(struct Header *h)
 {
-  char *mbox = NULL, *certfile = NULL, tempfname[_POSIX_PATH_MAX];
+  char *mbox = NULL, *certfile = NULL, tempfname[PATH_MAX];
   int retval = 1;
 
   mutt_mktemp(tempfname, sizeof(tempfname));
@@ -1380,8 +1380,8 @@ static pid_t smime_invoke_sign(FILE **smimein, FILE **smimeout, FILE **smimeerr,
 struct Body *smime_build_smime_entity(struct Body *a, char *certlist)
 {
   char buf[LONG_STRING], certfile[LONG_STRING];
-  char tempfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];
-  char smimeinfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX], smimeerrfile[PATH_MAX];
+  char smimeinfile[PATH_MAX];
   char *cert_start, *cert_end;
   FILE *smimein = NULL;
   int err = 0, empty, off;
@@ -1530,7 +1530,7 @@ static char *openssl_md_to_smime_micalg(char *md)
 struct Body *smime_sign_message(struct Body *a)
 {
   char buffer[LONG_STRING];
-  char signedfile[_POSIX_PATH_MAX], filetosign[_POSIX_PATH_MAX];
+  char signedfile[PATH_MAX], filetosign[PATH_MAX];
   FILE *smimein = NULL, *smimeout = NULL, *smimeerr = NULL, *sfp = NULL;
   int err = 0;
   int empty = 0;
@@ -1684,7 +1684,7 @@ static pid_t smime_invoke_decrypt(FILE **smimein, FILE **smimeout,
 
 int smime_verify_one(struct Body *sigbdy, struct State *s, const char *tempfile)
 {
-  char signedfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];
+  char signedfile[PATH_MAX], smimeerrfile[PATH_MAX];
   FILE *smimeout = NULL;
   pid_t thepid;
   int badsig = -1;
@@ -1795,8 +1795,8 @@ int smime_verify_one(struct Body *sigbdy, struct State *s, const char *tempfile)
  */
 static struct Body *smime_handle_entity(struct Body *m, struct State *s, FILE *out_file)
 {
-  char outfile[_POSIX_PATH_MAX], errfile[_POSIX_PATH_MAX];
-  char tmpfname[_POSIX_PATH_MAX];
+  char outfile[PATH_MAX], errfile[PATH_MAX];
+  char tmpfname[PATH_MAX];
   FILE *smimeout = NULL, *smimein = NULL, *smimeerr = NULL;
   FILE *tmpfp = NULL, *tmpfp_buffer = NULL, *fpout = NULL;
   struct stat info;
@@ -1914,7 +1914,7 @@ static struct Body *smime_handle_entity(struct Body *m, struct State *s, FILE *o
     fflush(smimeout);
     rewind(smimeout);
 
-    char tmptmpfname[_POSIX_PATH_MAX];
+    char tmptmpfname[PATH_MAX];
     if (out_file)
       fpout = out_file;
     else
@@ -2004,7 +2004,7 @@ static struct Body *smime_handle_entity(struct Body *m, struct State *s, FILE *o
 
 int smime_decrypt_mime(FILE *fpin, FILE **fpout, struct Body *b, struct Body **cur)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   struct State s;
   LOFF_T tmpoffset = b->offset;
   size_t tmplength = b->length;

diff --git a/newsrc.c b/newsrc.c
index 86fa52fa8b470b6fe6a8336c0bb3be11c29f767b..aae7144ecaab710c494ae8c1c77631b7867770a8 100644 (file)
--- a/newsrc.c
+++ b/newsrc.c
@@ -410,7 +410,7 @@ void nntp_newsrc_gen_entries(struct Context *ctx)
 static int update_file(char *filename, char *buf)
 {
   FILE *fp = NULL;
-  char tmpfile[_POSIX_PATH_MAX];
+  char tmpfile[PATH_MAX];
   int rc = -1;
 
   while (true)
@@ -542,7 +542,7 @@ int nntp_newsrc_update(struct NntpServer *nserv)
 static void cache_expand(char *dst, size_t dstlen, struct Account *acct, char *src)
 {
   char *c = NULL;
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
 
   /* server subdirectory */
   if (acct)
@@ -627,7 +627,7 @@ int nntp_add_group(char *line, void *data)
 static int active_get_cache(struct NntpServer *nserv)
 {
   char buf[HUGE_STRING];
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
   time_t t;
 
   cache_expand(file, sizeof(file), &nserv->conn->account, ".active");
@@ -660,7 +660,7 @@ static int active_get_cache(struct NntpServer *nserv)
  */
 int nntp_active_save_cache(struct NntpServer *nserv)
 {
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
   char *buf = NULL;
   size_t buflen, off;
   int rc;
@@ -723,7 +723,7 @@ static int nntp_hcache_namer(const char *path, char *dest, size_t destlen)
 header_cache_t *nntp_hcache_open(struct NntpData *nntp_data)
 {
   struct Url url;
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
 
   if (!nntp_data->nserv || !nntp_data->nserv->cacheable ||
       !nntp_data->nserv->conn || !nntp_data->group ||
@@ -829,7 +829,7 @@ void nntp_delete_group_cache(struct NntpData *nntp_data)
     return;
 
 #ifdef USE_HCACHE
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
   nntp_hcache_namer(nntp_data->group, file, sizeof(file));
   cache_expand(file, sizeof(file), &nntp_data->nserv->conn->account, file);
   unlink(file);
@@ -858,7 +858,7 @@ void nntp_delete_group_cache(struct NntpData *nntp_data)
  */
 void nntp_clear_cache(struct NntpServer *nserv)
 {
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
   char *fp = NULL;
   struct dirent *entry = NULL;
   DIR *dp = NULL;
@@ -1016,7 +1016,7 @@ const char *nntp_format_str(char *buf, size_t buflen, size_t col, int cols, char
  */
 struct NntpServer *nntp_select_server(char *server, bool leave_lock)
 {
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
 #ifdef USE_HCACHE
   char *p = NULL;
 #endif

diff --git a/nntp.c b/nntp.c
index 2fffb785db0b51b53eb2b68eb19a23df3d3f906e..d582cebbeee15d4203b597d1476758f85c0058f5 100644 (file)
--- a/nntp.c
+++ b/nntp.c
@@ -1656,7 +1656,7 @@ static int nntp_msg_open(struct Context *ctx, struct Message *msg, int msgno)
   }
   else
   {
-    char buf[_POSIX_PATH_MAX];
+    char buf[PATH_MAX];
     /* don't try to fetch article from removed newsgroup */
     if (nntp_data->deleted)
       return -1;

diff --git a/pop.c b/pop.c
index 1cc1243568ebd5e5793a40080a9d0dbac433f971..5e5eedbe3596f89f80a9d87d312279590cd9907d 100644 (file)
--- a/pop.c
+++ b/pop.c
@@ -589,7 +589,7 @@ static int pop_fetch_message(struct Context *ctx, struct Message *msg, int msgno
 {
   void *uidl = NULL;
   char buf[LONG_STRING];
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   struct Progress progressbar;
   struct PopData *pop_data = (struct PopData *) ctx->data;
   struct PopCache *cache = NULL;

diff --git a/postpone.c b/postpone.c
index 93f442e18cdaa7826f1ea385309106f140b8aa9a..f41a0933a285c4eb778072344472114cd8c5f1fb 100644 (file)
--- a/postpone.c
+++ b/postpone.c
@@ -135,7 +135,7 @@ int mutt_num_postponed(int force)
   {
     /* if we have a maildir mailbox, we need to stat the "new" dir */
 
-    char buf[_POSIX_PATH_MAX];
+    char buf[PATH_MAX];
 
     snprintf(buf, sizeof(buf), "%s/new", Postponed);
     if (access(buf, F_OK) == 0 && stat(buf, &st) == -1)
@@ -558,7 +558,7 @@ int mutt_prepare_template(FILE *fp, struct Context *ctx, struct Header *newhdr,
                           struct Header *hdr, short resend)
 {
   struct Message *msg = NULL;
-  char file[_POSIX_PATH_MAX];
+  char file[PATH_MAX];
   struct Body *b = NULL;
   FILE *bfp = NULL;
   int rc = -1;

diff --git a/recvattach.c b/recvattach.c
index fb44ebc3be00a44545e08aa8d830d32c495b7391..0243cf353af730a199e8c1b347e31dd6b73c30e3 100644 (file)
--- a/recvattach.c
+++ b/recvattach.c
@@ -268,7 +268,7 @@ const char *attach_format_str(char *buf, size_t buflen, size_t col, int cols,
       {
         if (aptr->content->filename && *aptr->content->filename == '/')
         {
-          char path[_POSIX_PATH_MAX];
+          char path[PATH_MAX];
 
           mutt_str_strfcpy(path, aptr->content->filename, sizeof(path));
           mutt_pretty_mailbox(path, sizeof(path));
@@ -457,7 +457,7 @@ static int query_save_attachment(FILE *fp, struct Body *body,
                                  struct Header *hdr, char **directory)
 {
   char *prompt = NULL;
-  char buf[_POSIX_PATH_MAX], tfile[_POSIX_PATH_MAX];
+  char buf[PATH_MAX], tfile[PATH_MAX];
   int append = 0;
   int rc;
 
@@ -543,7 +543,7 @@ static int query_save_attachment(FILE *fp, struct Body *body,
 void mutt_save_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag,
                                struct Body *top, struct Header *hdr, struct Menu *menu)
 {
-  char buf[_POSIX_PATH_MAX], tfile[_POSIX_PATH_MAX];
+  char buf[PATH_MAX], tfile[PATH_MAX];
   char *directory = NULL;
   int rc = 1;
   int last = menu ? menu->current : -1;
@@ -629,11 +629,11 @@ void mutt_save_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag,
 
 static void query_pipe_attachment(char *command, FILE *fp, struct Body *body, bool filter)
 {
-  char tfile[_POSIX_PATH_MAX];
+  char tfile[PATH_MAX];
 
   if (filter)
   {
-    char warning[STRING + _POSIX_PATH_MAX];
+    char warning[STRING + PATH_MAX];
     snprintf(warning, sizeof(warning),
              _("WARNING!  You are about to overwrite %s, continue?"), body->filename);
     if (mutt_yesorno(warning, MUTT_NO) != MUTT_YES)
@@ -808,7 +808,7 @@ static void print_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag,
         {
           /* decode and print */
 
-          char newfile[_POSIX_PATH_MAX] = "";
+          char newfile[PATH_MAX] = "";
           FILE *ifp = NULL;
 
           mutt_mktemp(newfile, sizeof(newfile));

diff --git a/recvcmd.c b/recvcmd.c
index 8918023b9f9a3fd0dffd2884300dd9d167afafda..204f9e99d49a6f8ffe42c3bea8e5c725175fc041 100644 (file)
--- a/recvcmd.c
+++ b/recvcmd.c
@@ -385,7 +385,7 @@ static void attach_forward_bodies(FILE *fp, struct Header *hdr, struct AttachCtx
   bool mime_fwd_any = true;
   struct Header *parent_hdr = NULL;
   FILE *parent_fp = NULL;
-  char tmpbody[_POSIX_PATH_MAX];
+  char tmpbody[PATH_MAX];
   char prefix[STRING];
   int rc = 0;
   struct State st;
@@ -560,7 +560,7 @@ static void attach_forward_msgs(FILE *fp, struct AttachCtx *actx, struct Body *c
   int rc;
 
   struct Body **last = NULL;
-  char tmpbody[_POSIX_PATH_MAX];
+  char tmpbody[PATH_MAX];
   FILE *tmpfp = NULL;
 
   int chflags = CH_XMIT;
@@ -807,7 +807,7 @@ void mutt_attach_reply(FILE *fp, struct Header *hdr, struct AttachCtx *actx,
   struct Header *tmphdr = NULL;
 
   struct State st;
-  char tmpbody[_POSIX_PATH_MAX];
+  char tmpbody[PATH_MAX];
   FILE *tmpfp = NULL;
 
   char prefix[SHORT_STRING];

diff --git a/rfc1524.c b/rfc1524.c
index 2f4b1251d213f28297211289653eb8fd273a10f0..0f146eb722b7de66187b0dc5b8edbffacee55729 100644 (file)
--- a/rfc1524.c
+++ b/rfc1524.c
@@ -425,7 +425,7 @@ void rfc1524_free_entry(struct Rfc1524MailcapEntry **entry)
 int rfc1524_mailcap_lookup(struct Body *a, char *type,
                            struct Rfc1524MailcapEntry *entry, int opt)
 {
-  char path[_POSIX_PATH_MAX];
+  char path[PATH_MAX];
   int found = false;
   char *curr = MailcapPath;
 
@@ -495,8 +495,8 @@ int rfc1524_expand_filename(char *nametemplate, char *oldfile, char *newfile, si
   int i, j, k, ps;
   char *s = NULL;
   bool lmatch = false, rmatch = false;
-  char left[_POSIX_PATH_MAX];
-  char right[_POSIX_PATH_MAX];
+  char left[PATH_MAX];
+  char right[PATH_MAX];
 
   newfile[0] = 0;
 

diff --git a/rfc3676.c b/rfc3676.c
index 6ede8d5b32f7611a2f04968870a7d4b92d9b6705..8db8f414ab436aaf24952d67a7d0c94fa799066b 100644 (file)
--- a/rfc3676.c
+++ b/rfc3676.c
@@ -356,7 +356,7 @@ void rfc3676_space_stuff(struct Header *hdr)
   unsigned char c = '\0';
   FILE *in = NULL, *out = NULL;
   char buf[LONG_STRING];
-  char tmpfile[_POSIX_PATH_MAX];
+  char tmpfile[PATH_MAX];
 
   if (!hdr || !hdr->content || !hdr->content->filename)
     return;

diff --git a/send.c b/send.c
index b1a759e9f80b1200b727d59bda76f544e37aac60..38647ff2d264819fa673c3570ef40a2b7b36de66 100644 (file)
--- a/send.c
+++ b/send.c
@@ -1069,7 +1069,7 @@ struct Address *mutt_default_from(void)
 
 static int send_message(struct Header *msg)
 {
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   int i;
 #ifdef USE_SMTP
   short old_write_bcc;
@@ -1286,7 +1286,7 @@ int ci_send_message(int flags, struct Header *msg, char *tempfile,
                     struct Context *ctx, struct Header *cur)
 {
   char buffer[LONG_STRING];
-  char fcc[_POSIX_PATH_MAX] = ""; /* where to copy this message */
+  char fcc[PATH_MAX] = ""; /* where to copy this message */
   FILE *tempfp = NULL;
   struct Body *pbody = NULL;
   int i;

diff --git a/sendlib.c b/sendlib.c
index 17bc47b9c8b6b00198de33c2f7894c2cabf136c9..154613f8eed1deb675b3261a4201eede625bdd74 100644 (file)
--- a/sendlib.c
+++ b/sendlib.c
@@ -1110,7 +1110,7 @@ bye:
 
 static void transform_to_7bit(struct Body *a, FILE *fpin)
 {
-  char buf[_POSIX_PATH_MAX];
+  char buf[PATH_MAX];
   struct State s;
   struct stat sb;
 
@@ -1165,7 +1165,7 @@ static void transform_to_7bit(struct Body *a, FILE *fpin)
 
 void mutt_message_to_7bit(struct Body *a, FILE *fp)
 {
-  char temp[_POSIX_PATH_MAX];
+  char temp[PATH_MAX];
   char *line = NULL;
   FILE *fpin = NULL;
   FILE *fpout = NULL;
@@ -2293,7 +2293,7 @@ static int send_msg(const char *path, char **args, const char *msg, char **tempf
 
   if (SendmailWait >= 0 && tempfile)
   {
-    char tmp[_POSIX_PATH_MAX];
+    char tmp[PATH_MAX];
 
     mutt_mktemp(tmp, sizeof(tmp));
     *tempfile = mutt_str_strdup(tmp);
@@ -2714,7 +2714,7 @@ static int bounce_message(FILE *fp, struct Header *h, struct Address *to,
 {
   int rc = 0;
   FILE *f = NULL;
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   struct Message *msg = NULL;
 
   if (!h)
@@ -2895,8 +2895,8 @@ static void set_noconv_flags(struct Body *b, short flag)
 int mutt_write_multiple_fcc(const char *path, struct Header *hdr, const char *msgid,
                             int post, char *fcc, char **finalpath)
 {
-  char fcc_tok[_POSIX_PATH_MAX];
-  char fcc_expanded[_POSIX_PATH_MAX];
+  char fcc_tok[PATH_MAX];
+  char fcc_expanded[PATH_MAX];
 
   mutt_str_strfcpy(fcc_tok, path, sizeof(fcc_tok));
 
@@ -2933,7 +2933,7 @@ int mutt_write_fcc(const char *path, struct Header *hdr, const char *msgid,
 {
   struct Context f;
   struct Message *msg = NULL;
-  char tempfile[_POSIX_PATH_MAX];
+  char tempfile[PATH_MAX];
   FILE *tempfp = NULL;
   int rc = -1;
   bool need_buffy_cleanup = false;