Bug 693380: raise file path/name size limit to 4k

And move as many cases of paths allocated on the stack to heap memory as is
reasonable.

No cluster differences.

10 files changed, 567 insertions, 267 deletions

diff --git a/gs/base/gdevdevn.c b/gs/base/gdevdevn.c
index 7a07980ef..de93faae8 100644
--- a/gs/base/gdevdevn.c
+++ b/gs/base/gdevdevn.c
@@ -276,8 +276,8 @@ devn_get_color_comp_index(gx_device * dev, gs_devn_params * pdevn_params,
         gs_separations * separations = &pdevn_params->separations;
         int sep_num = separations->num_separations++;
         /* We have a new spot colorant - put in stable memory to avoid "restore" */
-        sep_name = gs_alloc_bytes(dev->memory->stable_memory,
-                        name_size, "devn_get_color_comp_index");
+        sep_name = gs_alloc_bytes(dev->memory->stable_memory, name_size, "devn_get_color_comp_index");
+
         memcpy(sep_name, pname, name_size);
         separations->names[sep_num].size = name_size;
         separations->names[sep_num].data = sep_name;
@@ -2140,10 +2140,10 @@ spotcmyk_print_page(gx_device_printer * pdev, FILE * prn_stream)
     int pcmlinelength = 0; /* Initialize against indeterminizm in case of pdev->height == 0. */
     int linelength[GX_DEVICE_COLOR_MAX_COMPONENTS];
     byte *data;
-    char spotname[gp_file_name_sizeof];
+    char *spotname = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "spotcmyk_print_page(spotname)");
 
-    if (in == NULL || buf == NULL) {
-        code = gs_error_VMerror;
+    if (in == NULL || buf == NULL || spotname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
         goto prn_done;
     }
     /*
@@ -2164,7 +2164,7 @@ spotcmyk_print_page(gx_device_printer * pdev, FILE * prn_stream)
         gs_sprintf(spotname, "%ss%d", pdevn->fname, i);
         spot_file[i] = gp_fopen(spotname, "wb");
         if (spot_file[i] == NULL) {
-            code = gs_error_VMerror;
+            code = gs_note_error(gs_error_VMerror);
             goto prn_done;
         }
     }
@@ -2197,13 +2197,13 @@ spotcmyk_print_page(gx_device_printer * pdev, FILE * prn_stream)
         code = devn_write_pcx_file(pdev, (char *) &pdevn->fname,
                                 npcmcolors, bpc, pcmlinelength);
         if (code < 0)
-            return code;
+            goto prn_done;
     }
     for(i = 0; i < nspot; i++) {
         gs_sprintf(spotname, "%ss%d", pdevn->fname, i);
         code = devn_write_pcx_file(pdev, spotname, 1, bpc, linelength[i]);
         if (code < 0)
-            return code;
+            goto prn_done;
     }
 
     /* Clean up and exit */
@@ -2216,6 +2216,8 @@ spotcmyk_print_page(gx_device_printer * pdev, FILE * prn_stream)
         gs_free_object(pdev->memory, in, "spotcmyk_print_page(in)");
     if (buf != NULL)
         gs_free_object(pdev->memory, buf, "spotcmyk_print_page(buf)");
+    if (spotname != NULL)
+        gs_free_object(pdev->memory, spotname, "spotcmyk_print_page(spotname)");
     return code;
 }
 
@@ -2526,19 +2528,26 @@ devn_write_pcx_file(gx_device_printer * pdev, char * filename, int ncomp,
     pcx_header header;
     int code;
     bool planar;
-    char outname[gp_file_name_sizeof];
-    FILE * in;
-    FILE * out;
+    char *outname = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "devn_write_pcx_file(outname)");
+    FILE * in = NULL;
+    FILE * out = NULL;
     int depth = bpc_to_depth(ncomp, bpc);
 
+    if (outname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+    }
+
     in = gp_fopen(filename, "rb");
-    if (!in)
-        return_error(gs_error_invalidfileaccess);
+    if (!in) {
+        code = gs_note_error(gs_error_invalidfileaccess);
+	goto done;
+    }
     gs_sprintf(outname, "%s.pcx", filename);
     out = gp_fopen(outname, "wb");
     if (!out) {
-        fclose(in);
-        return_error(gs_error_invalidfileaccess);
+        code = gs_note_error(gs_error_invalidfileaccess);
+	goto done;
     }
 
     planar = devn_setup_pcx_header(pdev, &header, ncomp, bpc);
@@ -2546,8 +2555,15 @@ devn_write_pcx_file(gx_device_printer * pdev, char * filename, int ncomp,
     if (code >= 0)
         code = devn_finish_pcx_file(pdev, out, &header, ncomp, bpc);
 
-    fclose(in);
-    fclose(out);
+done:
+    if (in)
+      fclose(in);
+    if (out)
+      fclose(out);
+      
+    if (outname)
+      gs_free_object(pdev->memory, outname, "spotcmyk_print_page(outname)");
+
     return code;
 }
 
diff --git a/gs/base/gp.h b/gs/base/gp.h
index d1b8fa663..829a782fd 100644
--- a/gs/base/gp.h
+++ b/gs/base/gp.h
@@ -177,8 +177,13 @@ const char *gp_getenv_display(void);
  * parameter, but it would break too many clients to make this change now.)
  * Note that this is the size of the buffer, not the maximum number of
  * characters: the latter is one less, because of the terminating \0.
+ *
+ * This used to be 260, the same as the MAX_PATH value on Windows,
+ * but although MAX_PATH still exists on Windows, it is no longer
+ * the maximum length of a path - doh??
+ * We now use 4k as a reasonable limit for most environments.
  */
-#define gp_file_name_sizeof 260 /* == MAX_PATH on Windows */
+#define gp_file_name_sizeof 4096
 
 /* Define the character used for separating file names in a list. */
 extern const char gp_file_name_list_separator;
diff --git a/gs/base/gsdevice.c b/gs/base/gsdevice.c
index f5ea88966..e57560f1c 100644
--- a/gs/base/gsdevice.c
+++ b/gs/base/gsdevice.c
@@ -1042,14 +1042,22 @@ int gx_device_delete_output_file(const gx_device * dev, const char *fname)
 {
     gs_parsed_file_name_t parsed;
     const char *fmt;
-    char pfname[gp_file_name_sizeof];
-    int code = gx_parse_output_file_name(&parsed, &fmt, fname, strlen(fname),
+    char *pfname = (char *)gs_alloc_bytes(dev->memory, gp_file_name_sizeof, "gx_device_delete_output_file(pfname)");
+    int code;
+
+    if (pfname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+    }
+    
+    code = gx_parse_output_file_name(&parsed, &fmt, fname, strlen(fname),
                                          dev->memory);
+    if (code < 0) {
+        goto done;
+    }
 
-    if (code < 0)
-        return code;
     if (parsed.iodev && !strcmp(parsed.iodev->dname, "%stdout%"))
-        return 0;
+        goto done;
 
     if (fmt) {						/* filename includes "%nnd" */
         long count1 = dev->PageCount + 1;
@@ -1069,8 +1077,15 @@ int gx_device_delete_output_file(const gx_device * dev, const char *fname)
         parsed.len = strlen(parsed.fname);
     }
     if (parsed.iodev)
-        return (parsed.iodev->procs.delete_file((gx_io_device *)(&parsed.iodev), (const char *)parsed.fname));
-    return_error(gs_error_invalidfileaccess);
+        code = parsed.iodev->procs.delete_file((gx_io_device *)(&parsed.iodev), (const char *)parsed.fname);
+    else
+        code = gs_note_error(gs_error_invalidfileaccess);
+
+done:
+    if (pfname != NULL)
+        gs_free_object(dev->memory, pfname, "gx_device_delete_output_file(pfname)");
+
+    return(code);
 }
 
 /* Open the output file for a device. */
@@ -1080,18 +1095,28 @@ gx_device_open_output_file(const gx_device * dev, char *fname,
 {
     gs_parsed_file_name_t parsed;
     const char *fmt;
-    char pfname[gp_file_name_sizeof];
-    int code = gx_parse_output_file_name(&parsed, &fmt, fname, strlen(fname),
-                                         dev->memory);
+    char *pfname = (char *)gs_alloc_bytes(dev->memory, gp_file_name_sizeof, "gx_device_open_output_file(pfname)");
+    int code;
+    
+    if (pfname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+     }
+
+    code = gx_parse_output_file_name(&parsed, &fmt, fname, strlen(fname), dev->memory);
+    if (code < 0) {
+        goto done;
+    }
 
-    if (code < 0)
-        return code;
     if (parsed.iodev && !strcmp(parsed.iodev->dname, "%stdout%")) {
-        if (parsed.fname)
-            return_error(gs_error_undefinedfilename);
+        if (parsed.fname) {
+            code = gs_note_error(gs_error_undefinedfilename);
+	    goto done;
+	}
         *pfile = dev->memory->gs_lib_ctx->fstdout;
         /* Force stdout to binary. */
-        return gp_setmode_binary(*pfile, true);
+        code = gp_setmode_binary(*pfile, true);
+	goto done;
     } else if (parsed.iodev && !strcmp(parsed.iodev->dname, "%pipe%")) {
         positionable = false;
     }
@@ -1115,8 +1140,10 @@ gx_device_open_output_file(const gx_device * dev, char *fname,
     if (positionable || (parsed.iodev && parsed.iodev != iodev_default(dev->memory))) {
         char fmode[4];
 
-        if (!parsed.fname)
-            return_error(gs_error_undefinedfilename);
+        if (!parsed.fname) {
+            code = gs_note_error(gs_error_undefinedfilename);
+	    goto done;
+	}
         strcpy(fmode, gp_fmode_wb);
         if (positionable)
             strcat(fmode, "+");
@@ -1126,15 +1153,21 @@ gx_device_open_output_file(const gx_device * dev, char *fname,
             emprintf1(dev->memory,
                       "**** Could not open the file %s .\n",
                       parsed.fname);
-        return code;
     }
-    *pfile = gp_open_printer(dev->memory, (pfname[0] ? pfname : fname), binary);
-    if (*pfile)
-        return 0;
-    emprintf1(dev->memory,
-              "**** Could not open the file %s .\n",
-              (pfname[0] ? pfname : fname));
-    return_error(gs_error_invalidfileaccess);
+    else {
+        *pfile = gp_open_printer(dev->memory, (pfname[0] ? pfname : fname), binary);
+        if (!(*pfile)) {
+            emprintf1(dev->memory, "**** Could not open the file %s .\n", (pfname[0] ? pfname : fname));
+
+            code = gs_note_error(gs_error_invalidfileaccess);
+        }
+    }
+
+done:
+    if (pfname != NULL)
+        gs_free_object(dev->memory, pfname, "gx_device_open_output_file(pfname)");
+
+    return(code);
 }
 
 /* Close the output file for a device. */
diff --git a/gs/base/gsiodisk.c b/gs/base/gsiodisk.c
index ed6266262..243651fad 100644
--- a/gs/base/gsiodisk.c
+++ b/gs/base/gsiodisk.c
@@ -110,7 +110,7 @@
 
 /* Function prototypes */
 static iodev_proc_init(iodev_diskn_init);
-static iodev_proc_gp_fopen(iodev_diskn_gp_fopen);
+static iodev_proc_fopen(iodev_diskn_fopen);
 static iodev_proc_delete_file(diskn_delete);
 static iodev_proc_rename_file(diskn_rename);
 static iodev_proc_file_status(diskn_status);
@@ -127,7 +127,7 @@ const gx_io_device varname = \
 { \
     diskname, "FileSystem", \
     {iodev_diskn_init, iodev_no_open_device, \
-     NULL /* no longer used */ , iodev_diskn_gp_fopen, iodev_os_fclose, \
+     NULL /* no longer used */ , iodev_diskn_fopen, iodev_os_fclose, \
      diskn_delete, diskn_rename, diskn_status, \
      iodev_no_enumerate_files, /* Only until we have a root location */ \
      diskn_enumerate_next, diskn_enumerate_close, \
@@ -163,7 +163,6 @@ gs_private_st_ptrs1(st_diskn_state, struct diskn_state_s, "diskn_state",
 #define TEMP_FILE_NAME "Tmp.txt"
 #define MAP_FILE_VERSION 1
 #define InitialNumber 0
-#define BUFFER_LENGTH gp_file_name_sizeof
 
 typedef struct map_file_enum_s {
     FILE *  stream;         /* stream to map file */
@@ -175,13 +174,13 @@ typedef struct map_file_enum_s {
 gs_private_st_ptrs2(st_map_file_enum, struct map_file_enum_s, "map_file_enum",
     map_file_enum_enum_ptrs, map_file_enum_reloc_ptrs, pattern, root);
 
-static void * map_file_enum_init(gs_memory_t *, const char *, const char *);
+static void * map_file_enum_init(gs_memory_t *, const char *, const char *, uint);
 static bool map_file_enum_next(void *, char *);
 static void map_file_enum_close(void *);
-static bool map_file_name_get(const char *, const char *, char *);
-static void map_file_name_add(const char *, const char *);
-static void map_file_name_ren(const char*, const char *, const char *);
-static void map_file_name_del(const char *, const char *);
+static bool map_file_name_get(gs_memory_t *, const char *, const char *, char *);
+static void map_file_name_add(gs_memory_t *, const char *, const char *);
+static void map_file_name_ren(gs_memory_t *, const char*, const char *, const char *);
+static void map_file_name_del(gs_memory_t *, const char *, const char *);
 
 static int
 iodev_diskn_init(gx_io_device * iodev, gs_memory_t * mem)
@@ -198,101 +197,159 @@ iodev_diskn_init(gx_io_device * iodev, gs_memory_t * mem)
 }
 
 static int
-iodev_diskn_gp_fopen(gx_io_device * iodev, const char *fname, const char *access,
+iodev_diskn_fopen(gx_io_device * iodev, const char *fname, const char *access,
                FILE ** pfile, char *rfname, uint rnamelen)
 {
-    char realname[gp_file_name_sizeof];
     diskn_state * pstate = (diskn_state *)iodev->state;
+    char *realname = (char *)gs_alloc_bytes(pstate->memory, gp_file_name_sizeof, "iodev_diskn_fopen(realname)");
+    int code = 0;
+
+    if (realname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+    }
 
     /* Exit if we do not have a root location */
-    if (!pstate->root)
-        return_error(gs_error_undefinedfilename);
+    if (!pstate->root) {
+        code = gs_note_error(gs_error_undefinedfilename);
+	goto done;
+    }
 
     /* Remap filename (if it exists). */
-    if (!map_file_name_get((char *)pstate->root, fname, realname)) {
+    if (!map_file_name_get(pstate->memory, (char *)pstate->root, fname, realname)) {
         if (strchr(access, 'w')) {
-            map_file_name_add(pstate->root, fname);
-            map_file_name_get(pstate->root, fname, realname);
+            map_file_name_add(pstate->memory, pstate->root, fname);
+            map_file_name_get(pstate->memory, pstate->root, fname, realname);
         }
-        else
-            return_error(gs_error_undefinedfilename);
+        else {
+            code = gs_note_error(gs_error_undefinedfilename);
+	    goto done;
+	}
     }
 
-    return iodev_os_gp_fopen(iodev_default(pstate->memory), realname, access, pfile, rfname, rnamelen);
+    code = iodev_os_gp_fopen(iodev_default(pstate->memory), realname, access, pfile, rfname, rnamelen);
+    
+done:
+    if (realname != NULL)
+        gs_free_object(pstate->memory, realname, "iodev_diskn_fopen(realname)");
+
+    return(code);
 }
 
 static int
 diskn_delete(gx_io_device * iodev, const char *fname)
 {
-    char realname[gp_file_name_sizeof];
     diskn_state * pstate = (diskn_state *)iodev->state;
+    char *realname = (char *)gs_alloc_bytes(pstate->memory, gp_file_name_sizeof, "diskn_delete(realname)");
+    int code = 0;
+
+    if (realname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+    }
 
     /* Exit if we do not have a root location */
-    if (!pstate->root)
-        return_error(gs_error_undefinedfilename);
+    if (!pstate->root) {
+        code = gs_note_error(gs_error_undefinedfilename);
+        goto done;
+    }
 
     /* Map filename (if it exists). */
-    if (!map_file_name_get((char *)pstate->root, fname, realname))
-        return_error(gs_error_undefinedfilename);
+    if (!map_file_name_get(pstate->memory, (char *)pstate->root, fname, realname)) {
+        code = gs_note_error(gs_error_undefinedfilename);
+        goto done;
+    }
+
+    map_file_name_del(pstate->memory, (char *)pstate->root, fname);
+    code = (unlink(realname) == 0 ? 0 : gs_note_error(gs_error_ioerror));
+
+done:
+    if (realname != NULL)
+        gs_free_object(pstate->memory, realname, "diskn_delete(realname)");
 
-    map_file_name_del((char *)pstate->root, fname);
-    return (unlink(realname) == 0 ? 0 : gs_error_ioerror);
+    return(code);
 }
 
 static int
 diskn_rename(gx_io_device * iodev, const char *from, const char *to)
 {
-    char toreal[gp_file_name_sizeof];
-    int code = 0;
     diskn_state * pstate = (diskn_state *)iodev->state;
+    char *toreal = (char *)gs_alloc_bytes(pstate->memory, gp_file_name_sizeof, "diskn_rename(toreal)");
+    int code = 0;
+
+    if (toreal == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+    }
 
     /* Exit if we do not have a root location */
-    if (!pstate->root)
-        return_error(gs_error_undefinedfilename);
+    if (!pstate->root) {
+        code = gs_note_error(gs_error_undefinedfilename);
+        goto done;
+    }
 
     /* if filenames are the same them we are done. */
-    if (strcmp(to, from) == 0)
-        return 0;
+    if (strcmp(to, from) == 0) {
+        code = 0;
+        goto done;
+    }
 
     /*
      * If the destination file already exists, then we want to delete it.
      */
-    if (map_file_name_get((char *)pstate->root, to, toreal)) {
-        map_file_name_del((char *)pstate->root, to);
-        code = unlink(toreal) == 0 ? 0 : gs_error_ioerror;
+    if (map_file_name_get(pstate->memory, (char *)pstate->root, to, toreal)) {
+        map_file_name_del(pstate->memory, (char *)pstate->root, to);
+        code = unlink(toreal) == 0 ? 0 : gs_note_error(gs_error_ioerror);
     }
 
-    map_file_name_ren((char *)pstate->root, from, to);
-    return code;
+    map_file_name_ren(pstate->memory, (char *)pstate->root, from, to);
+
+done:
+    if (toreal != NULL)
+        gs_free_object(pstate->memory, toreal, "diskn_rename(toreal)");
+
+    return(code);
 }
 
 static int
 diskn_status(gx_io_device * iodev, const char *fname, struct stat *pstat)
 {
-    char realname[gp_file_name_sizeof];
     diskn_state * pstate = (diskn_state *)iodev->state;
+    char *realname = (char *)gs_alloc_bytes(pstate->memory, gp_file_name_sizeof, "diskn_status(realname)");
+    int code = 0;
+
+    if (realname == NULL) {
+        code = gs_note_error(gs_error_VMerror);
+	goto done;
+    }
 
     /* Exit if we do not have a root location */
-    if (!pstate->root)
-        return_error(gs_error_undefinedfilename);
+    if (!pstate->root) {
+        code = gs_note_error(gs_error_undefinedfilename);
+        goto done;
+    }
 
     /* Map filename (if it exists). */
-    if (!map_file_name_get((char *)pstate->root, fname, realname))
-        return_error(gs_error_undefinedfilename);
+    if (!map_file_name_get(pstate->memory, (char *)pstate->root, fname, realname)) {
+        code = gs_note_error(gs_error_undefinedfilename);
+    }
+
+    code = stat((char *)realname, pstat) < 0 ? gs_note_error(gs_error_undefinedfilename) : 0;
 
-    return (stat((char *)realname, pstat) < 0 ? gs_error_undefinedfilename : 0);
+done:
+    if (realname != NULL)
+        gs_free_object(pstate->memory, realname, "diskn_status(realname)");
+
+    return(code);
 }
 
 static file_enum *
-diskn_enumerate_files_init(gx_io_device * iodev, const char *pat, uint patlen,
+diskn_enumerate_files(gx_io_device * iodev, const char *pat, uint patlen,
              gs_memory_t * mem)
 {
-    char patstr[gp_file_name_sizeof];
     diskn_state * pstate = (diskn_state *)iodev->state;
-
-    memcpy(patstr, pat, patlen);	/* Copy string to buffer */
-    patstr[patlen]=0;			/* Terminate string */
-    return (file_enum *)map_file_enum_init(mem, (char *)pstate->root, patstr);
+    
+    return (file_enum *)map_file_enum_init(mem, (char *)pstate->root, pat, patlen);
 }
 
 static void
@@ -391,7 +448,7 @@ diskn_put_params(gx_io_device *iodev, gs_param_list *plist)
                 return gs_error_VMerror;
             pstate->root_size = rootstr.size + 1;
             /* Now allow enumeration of files on the disk */
-            iodev->procs.enumerate_files = diskn_enumerate_files_init;
+            iodev->procs.enumerate_files = diskn_enumerate_files;
         }
 
         memcpy(pstate->root, rootstr.data, rootstr.size);
@@ -409,14 +466,25 @@ diskn_put_params(gx_io_device *iodev, gs_param_list *plist)
  * Returns - NULL if error, file structure pointer if no error
  */
 static FILE *
-MapFileOpen(const char * rootpath, const char * filename, const char * attributes)
+MapFileOpen(gs_memory_t *mem, const char * rootpath, const char * filename, const char * attributes)
 {
-    char fullname[BUFFER_LENGTH];
+    char *fullname = NULL;
+    FILE *f = NULL;
+    int totlen = strlen(rootpath) + strlen(filename) + 1;
 
-    if (strlen(rootpath) + strlen(filename) >= BUFFER_LENGTH)
+    if (totlen >= gp_file_name_sizeof)
         return NULL;
-    gs_sprintf(fullname, "%s%s", rootpath, filename);
-    return gp_fopen(fullname, attributes);
+
+    fullname = (char *)gs_alloc_bytes(mem, totlen, "MapFileOpen(fullname)");
+    if (fullname) {
+
+        gs_sprintf(fullname, "%s%s", rootpath, filename);
+        f = gp_fopen(fullname, attributes);
+
+        gs_free_object(mem, fullname , "MapFileOpen(fullname)");
+    }
+
+    return(f);
 }
 
 /*
@@ -479,7 +547,7 @@ MapFileRead(FILE * mapfile, char * namebuf, int * value)
     /* Get the file name */
     do {
         namebuf[count++] = c = fgetc(mapfile);
-    } while (count < BUFFER_LENGTH && c != EOF && c != '\n' && c != '\r');
+    } while (count < gp_file_name_sizeof && c != EOF && c != '\n' && c != '\r');
     namebuf[--count] = 0;    /* Terminate file name */
 
     /* Clean up any trailing linefeeds or carriage returns */
@@ -510,14 +578,21 @@ MapFileWrite(FILE * mapfile, const char * namebuf, int value)
  * filename - File name string
  */
 static void
-MapFileUnlink(const char * rootpath, const char * filename)
+MapFileUnlink(gs_memory_t *mem, const char * rootpath, const char * filename)
 {
-    char fullname[BUFFER_LENGTH];
+    char *fullname = NULL;
+    int totlen = strlen(rootpath) + strlen(filename) + 1;
 
-    if (strlen(rootpath) + strlen(filename) >= BUFFER_LENGTH)
+    if (totlen >= gp_file_name_sizeof)
         return;
-    gs_sprintf(fullname, "%s%s", rootpath, filename);
-    unlink(fullname);
+    fullname = (char *)gs_alloc_bytes(mem, totlen, "MapFileUnlink(fullname)");
+    if (fullname) {
+        gs_sprintf(fullname, "%s%s", rootpath, filename);
+
+        unlink(fullname);
+
+        gs_free_object(mem, fullname , "MapFileUnlink(fullname)");
+    }
 }
 
 /*
@@ -528,18 +603,28 @@ MapFileUnlink(const char * rootpath, const char * filename)
  * newfilename - New file name string
  */
 static void
-MapFileRename(const char * rootpath, const char * newfilename, const char * oldfilename)
+MapFileRename(gs_memory_t *mem, const char * rootpath, const char * newfilename, const char * oldfilename)
 {
-    char oldfullname[BUFFER_LENGTH];
-    char newfullname[BUFFER_LENGTH];
+    char *oldfullname = NULL;
+    char *newfullname = NULL;
+    int ototlen = strlen(rootpath) + strlen(oldfilename) + 1;
+    int ntotlen = strlen(rootpath) + strlen(newfilename) + 1;
 
-    if (strlen(rootpath) + strlen(oldfilename) >= BUFFER_LENGTH)
+    if (ototlen >= gp_file_name_sizeof)
         return;
-    if (strlen(rootpath) + strlen(newfilename) >= BUFFER_LENGTH)
+    if (ntotlen >= gp_file_name_sizeof)
         return;
-    gs_sprintf(oldfullname, "%s%s", rootpath, oldfilename);
-    gs_sprintf(newfullname, "%s%s", rootpath, newfilename);
-    rename(oldfullname, newfullname);
+    oldfullname = (char *)gs_alloc_bytes(mem, ototlen, "MapFileRename(oldfullname)");
+    newfullname = (char *)gs_alloc_bytes(mem, ntotlen, "MapFileRename(newfullname)");
+
+    if (oldfullname && newfullname) {    
+        gs_sprintf(oldfullname, "%s%s", rootpath, oldfilename);
+        gs_sprintf(newfullname, "%s%s", rootpath, newfilename);
+        rename(oldfullname, newfullname);
+    }
+
+    gs_free_object(mem, oldfullname , "MapFileRename(oldfullname)");
+    gs_free_object(mem, newfullname , "MapFileRename(newfullname)");
 }
 
 /*
@@ -552,14 +637,14 @@ MapFileRename(const char * rootpath, const char * newfilename, const char * oldf
  * returns	    -1 if file not found, file number if found.
  */
 static int
-MapToFile(const char* rootpath, const char* name)
+MapToFile(gs_memory_t *mem, const char* rootpath, const char* name)
 {
     FILE * mapfile;
     int d = -1;
-    char filename[BUFFER_LENGTH];
+    char *filename = NULL;
     int file_version;
 
-    mapfile = MapFileOpen(rootpath, MAP_FILE_NAME, "r");
+    mapfile = MapFileOpen(mem, rootpath, MAP_FILE_NAME, "r");
     if (mapfile == NULL)
         return -1;
 
@@ -568,13 +653,15 @@ MapToFile(const char* rootpath, const char* name)
     if (MapFileReadVersion(mapfile, &file_version)
         && file_version == MAP_FILE_VERSION) {
 
+        filename = (char *)gs_alloc_bytes(mem, gp_file_name_sizeof, "MapToFile(filename)");
         /* Scan the file looking for the given name */
 
-        while (MapFileRead(mapfile, filename, &d)) {
+        while (filename && MapFileRead(mapfile, filename, &d)) {
             if (strcmp(filename, name) == 0)
                 break;
             d = -1;
         }
+        gs_free_object(mem, filename, "MapToFile(filename)");
     }
     fclose(mapfile);
     return d;
@@ -591,7 +678,7 @@ MapToFile(const char* rootpath, const char* name)
  * Returns:		    NULL if error, else pointer to enumeration structure.
  */
 static void *
-map_file_enum_init(gs_memory_t * mem, const char * root_name, const char * search_pattern)
+map_file_enum_init(gs_memory_t *mem, const char * root_name, const char * search_pattern, uint search_pattern_len)
 {
     int file_version;
     map_file_enum * mapfileenum = gs_alloc_struct(mem, map_file_enum, &st_map_file_enum,
@@ -603,13 +690,15 @@ map_file_enum_init(gs_memory_t * mem, const char * root_name, const char * searc
     mapfileenum->memory = mem;
 
     if (search_pattern) {
-        mapfileenum->pattern = (char *)gs_alloc_bytes(mem, strlen(search_pattern) + 1,
+        mapfileenum->pattern = (char *)gs_alloc_bytes(mem, search_pattern_len + 1,
                                                         "diskn:enum_init(pattern)");
         if (mapfileenum->pattern == NULL) {
             map_file_enum_close((file_enum *) mapfileenum);
             return NULL;
         }
-        strcpy(mapfileenum->pattern, search_pattern);
+        memcpy(mapfileenum->pattern, search_pattern, search_pattern_len);
+        /* Terminate string */
+        mapfileenum->pattern[search_pattern_len] = '\0';
     }
 
     mapfileenum->root = (char *)gs_alloc_bytes(mem, strlen(root_name) + 1,
@@ -619,10 +708,10 @@ map_file_enum_init(gs_memory_t * mem, const char * root_name, const char * searc
         return NULL;
     }
 
-    if (strlen(root_name) >= BUFFER_LENGTH)
+    if (strlen(root_name) >= gp_file_name_sizeof)
         return NULL;
     strcpy(mapfileenum->root, root_name);
-    mapfileenum->stream = MapFileOpen(root_name, MAP_FILE_NAME, "r");
+    mapfileenum->stream = MapFileOpen(mem, root_name, MAP_FILE_NAME, "r");
 
     /* Check the mapping file version number */
     if (mapfileenum->stream != NULL
@@ -704,13 +793,13 @@ map_file_enum_close(void * enum_mem)
  * osname          char*   resulting os specific path to the file
  */
 static bool
-map_file_name_get(const char * root_name, const char * Fname, char * osname)
+map_file_name_get(gs_memory_t *mem, const char * root_name, const char * Fname, char * osname)
 {
-    int d = MapToFile(root_name, Fname);
+    int d = MapToFile(mem, root_name, Fname);
 
     if (d != -1) {
         /* 20 characters are enough for even a 64 bit integer */
-        if ((strlen(root_name) + 20) < BUFFER_LENGTH) {
+        if ((strlen(root_name) + 20) < gp_file_name_sizeof) {
             gs_sprintf(osname, "%s%d", root_name, d);
             return true;
         }
@@ -729,32 +818,37 @@ map_file_name_get(const char * root_name, const char * Fname, char * osname)
  * Fname           char*   name of the entry to add to the map
  */
 static void
-map_file_name_del(const char * root_name, const char * Fname)
+map_file_name_del(gs_memory_t *mem, const char * root_name, const char * Fname)
 {
     /*  search for target entry */
-    int d = MapToFile(root_name, Fname);
+    int d = MapToFile(mem, root_name, Fname);
     int file_version;
+    char *name = NULL;
 
-    if (d != -1) {			 /* if the file exists ... */
-        char    name[BUFFER_LENGTH];
+    name = (char *)gs_alloc_bytes(mem, gp_file_name_sizeof, "map_file_name_del(name)");
+
+    if (name && d != -1) {			 /* if the file exists ... */
         FILE*   newMap;
         FILE*   oldMap;
 
         /* Open current map file and a working file */
 
-        MapFileUnlink(root_name, TEMP_FILE_NAME );
-        newMap = MapFileOpen(root_name, TEMP_FILE_NAME, "w");
-        if (newMap == NULL)
+        MapFileUnlink(mem, root_name, TEMP_FILE_NAME );
+        newMap = MapFileOpen(mem, root_name, TEMP_FILE_NAME, "w");
+        if (newMap == NULL) {
+            gs_free_object(mem, name , "map_file_name_del(name)");
             return;
-        oldMap = MapFileOpen(root_name, MAP_FILE_NAME, "r");
+        }
+        oldMap = MapFileOpen(mem, root_name, MAP_FILE_NAME, "r");
         if (oldMap != NULL && (!MapFileReadVersion(oldMap, &file_version)
             || file_version != MAP_FILE_VERSION)) {
             fclose(oldMap);
             oldMap= NULL;
         }
         if (oldMap == NULL) {
+            gs_free_object(mem, name , "map_file_name_del(name)");
             fclose(newMap);
-            MapFileUnlink(root_name, TEMP_FILE_NAME);
+            MapFileUnlink(mem, root_name, TEMP_FILE_NAME);
             return;
         }
 
@@ -766,9 +860,10 @@ map_file_name_del(const char * root_name, const char * Fname)
                 MapFileWrite(newMap, name, d);
         fclose(newMap);
         fclose(oldMap);
-        MapFileUnlink(root_name, MAP_FILE_NAME);
-        MapFileRename(root_name, MAP_FILE_NAME, TEMP_FILE_NAME);
+        MapFileUnlink(mem, root_name, MAP_FILE_NAME);
+        MapFileRename(mem, root_name, MAP_FILE_NAME, TEMP_FILE_NAME);
     }
+    gs_free_object(mem, name, "map_file_name_del(name)");
 }
 
 /*
@@ -780,51 +875,55 @@ map_file_name_del(const char * root_name, const char * Fname)
  * Fname           char*   name of the entry to add to the map
  */
 static void
-map_file_name_add(const char * root_name, const char * Fname)
+map_file_name_add(gs_memory_t *mem, const char * root_name, const char * Fname)
 {
     /*
      * add entry to map file
      * entry number is one greater than biggest number
      */
-    char    name[BUFFER_LENGTH];
+    char *name = NULL;
     int d;
     int dmax = -1;
     int file_version;
     FILE*   newMap;
     FILE*   oldMap;
 
-    oldMap = MapFileOpen(root_name, MAP_FILE_NAME, "r");
-    if (oldMap != NULL && (!MapFileReadVersion(oldMap, &file_version)
-        || file_version != MAP_FILE_VERSION)) {
-        fclose(oldMap);
-        oldMap = NULL;
-    }
-    if (oldMap == NULL) {
-        oldMap = MapFileOpen(root_name, MAP_FILE_NAME, "w");
-        if (!oldMap)
-            return;
-        MapFileWriteVersion(oldMap, MAP_FILE_VERSION);
-        MapFileWrite(oldMap, Fname, InitialNumber);
-        fclose(oldMap);
-    }
-    else {
-        MapFileUnlink(root_name, TEMP_FILE_NAME);
-        newMap = MapFileOpen(root_name, TEMP_FILE_NAME, "w");
-        if (newMap != NULL) {
-            MapFileWriteVersion(newMap, MAP_FILE_VERSION);
-            while (MapFileRead(oldMap, name, &d)) {
-                MapFileWrite(newMap, name, d);
-                if (dmax < d)
-                    dmax = d;
-            }
-
-            dmax += 1;
-            MapFileWrite(newMap, Fname, dmax);
-            fclose(newMap);
+    name = (char *)gs_alloc_bytes(mem, gp_file_name_sizeof, "map_file_name_add(name)");
+    if (name) {
+        oldMap = MapFileOpen(mem, root_name, MAP_FILE_NAME, "r");
+        if (oldMap != NULL && (!MapFileReadVersion(oldMap, &file_version)
+            || file_version != MAP_FILE_VERSION)) {
             fclose(oldMap);
-            MapFileUnlink(root_name, MAP_FILE_NAME);
-            MapFileRename(root_name, MAP_FILE_NAME, TEMP_FILE_NAME);
+            oldMap = NULL;
+        }
+        if (oldMap == NULL) {
+            oldMap = MapFileOpen(mem, root_name, MAP_FILE_NAME, "w");
+            if (!oldMap)
+                return;
+            MapFileWriteVersion(oldMap, MAP_FILE_VERSION);
+            MapFileWrite(oldMap, Fname, InitialNumber);
+            fclose(oldMap);
+        }
+        else {
+            MapFileUnlink(mem, root_name, TEMP_FILE_NAME);
+            newMap = MapFileOpen(mem, root_name, TEMP_FILE_NAME, "w");
+            if (newMap != NULL) {
+                MapFileWriteVersion(newMap, MAP_FILE_VERSION);
+                while (MapFileRead(oldMap, name, &d)) {
+                    MapFileWrite(newMap, name, d);
+                    if (dmax < d)
+                        dmax = d;
+                }
+
+                dmax += 1;
+                MapFileWrite(newMap, Fname, dmax);
+                fclose(newMap);
+                fclose(oldMap);
+                MapFileUnlink(mem, root_name, MAP_FILE_NAME);
+                MapFileRename(mem, root_name, MAP_FILE_NAME, TEMP_FILE_NAME);
+            }
         }
+        gs_free_object(mem, name , "map_file_name_add(name)");
     }
 }
 
@@ -838,25 +937,25 @@ map_file_name_add(const char * root_name, const char * Fname)
  * newname         char*   name to change the entry indicated by oldname into
  */
 static void
-map_file_name_ren(const char* root_name, const char * oldname, const char * newname)
+map_file_name_ren(gs_memory_t *mem, const char* root_name, const char * oldname, const char * newname)
 {
     /*  search for target entry */
 
-    int d = MapToFile(root_name, oldname);
+    int d = MapToFile(mem, root_name, oldname);
     int file_version;
+    char *name = (char *)gs_alloc_bytes(mem, gp_file_name_sizeof, "map_file_name_ren(name)");
 
-    if (d != -1) { 		/* if target exists ... */
-        char    name[BUFFER_LENGTH];
+    if (name && d != -1) { 		/* if target exists ... */
         FILE*   newMap;
         FILE*   oldMap;
 
         /* Open current map file and a working file */
 
-        MapFileUnlink(root_name, TEMP_FILE_NAME );
-        newMap = MapFileOpen(root_name, TEMP_FILE_NAME, "w");
+        MapFileUnlink(mem, root_name, TEMP_FILE_NAME );
+        newMap = MapFileOpen(mem, root_name, TEMP_FILE_NAME, "w");
         if (newMap == NULL)
             return;
-        oldMap = MapFileOpen(root_name, MAP_FILE_NAME, "r");
+        oldMap = MapFileOpen(mem, root_name, MAP_FILE_NAME, "r");
         if (oldMap != NULL && (!MapFileReadVersion(oldMap, &file_version)
             || file_version != MAP_FILE_VERSION)) {
             fclose(oldMap);
@@ -864,7 +963,7 @@ map_file_name_ren(const char* root_name, const char * oldname, const char * newn
         }
         if (oldMap == NULL) {
             fclose(newMap);
-            MapFileUnlink(root_name, TEMP_FILE_NAME);
+            MapFileUnlink(mem, root_name, TEMP_FILE_NAME);
             return;
         }
 
@@ -878,7 +977,8 @@ map_file_name_ren(const char* root_name, const char * oldname, const char * newn
                 MapFileWrite(newMap, newname, d);
         fclose(newMap);
         fclose(oldMap);
-        MapFileUnlink(root_name, MAP_FILE_NAME);
-        MapFileRename(root_name, MAP_FILE_NAME, TEMP_FILE_NAME);
+        MapFileUnlink(mem, root_name, MAP_FILE_NAME);
+        MapFileRename(mem, root_name, MAP_FILE_NAME, TEMP_FILE_NAME);
     }
+    gs_free_object(mem, name ,"map_file_name_ren(name)");
 }
diff --git a/gs/base/gsiomacres.c b/gs/base/gsiomacres.c
index 3b59231f0..064d5d7ad 100644
--- a/gs/base/gsiomacres.c
+++ b/gs/base/gsiomacres.c
@@ -369,16 +369,21 @@ static int
 iodev_macresource_open_file(gx_io_device *iodev, const char *fname, uint namelen,
     const char *access, stream **ps, gs_memory_t *mem)
 {
-    char filename[gp_file_name_sizeof];
+    char filename = gs_alloc_bytes(dev->memory, gp_file_name_sizeof, "iodev_macresource_open_file(filename)");
     char *res_type_string, *res_id_string;
     uint type;
     ushort id;
     bool datafork = 0;
-    int size;
+    int size, code;
     byte *buf;
 
     /* return NULL if there's an error */
     *ps = NULL;
+    
+    if (filename == NULL) {
+      code = gs_note_error(gs_error_VMerror);
+      goto done;
+    }
 
     strncpy(filename, fname, min(namelen, gp_file_name_sizeof));
     if (namelen < gp_file_name_sizeof) filename[namelen] = '\0';
@@ -387,13 +392,15 @@ iodev_macresource_open_file(gx_io_device *iodev, const char *fname, uint namelen
     res_type_string = strrchr(filename, '#');
     if (res_type_string == NULL) {
         if_debug0('s', "[s] couldn't find resource type separator\n");
-        return_error(e_invalidfileaccess);
+        code = gs_note_error(e_invalidfileaccess);
+	goto done;
     }
     *res_type_string++ = '\0';
     res_id_string = strrchr(res_type_string, '+');
     if (res_id_string == NULL) {
         if_debug0('s', "couldn't find resource id separator\n");
-        return_error(e_invalidfileaccess);
+        code = gs_note_error(e_invalidfileaccess);
+	goto done;
     }
     *res_id_string++ = '\0';
     type = res_string2type(res_type_string);
@@ -411,7 +418,8 @@ iodev_macresource_open_file(gx_io_device *iodev, const char *fname, uint namelen
             datafork = true;
         } else {
             if_debug0('s', "could not get resource size\n");
-            return_error(e_invalidfileaccess);
+            code = gs_note_error(e_invalidfileaccess);
+	    goto done;
         }
     }
     if_debug1('s', "[s] got resource size %d bytes\n", size);
@@ -419,7 +427,8 @@ iodev_macresource_open_file(gx_io_device *iodev, const char *fname, uint namelen
     buf = gs_alloc_string(mem, size, "macresource buffer");
     if (buf == NULL) {
         if_debug0('s', "macresource: could not allocate buffer for resource data\n");
-        return_error(e_VMerror);
+        code = gs_note_error(e_VMerror);
+	goto done;
     }
     /* call again to get the resource data */
     if (!datafork) {
@@ -432,6 +441,9 @@ iodev_macresource_open_file(gx_io_device *iodev, const char *fname, uint namelen
     *ps = s_alloc(mem, "macresource");
     sread_string(*ps, buf, size);
 
-    /* return success */
-    return 0;
+done:
+    if (pfname != NULL)
+        gs_free_object(dev->memory, filename, "iodev_macresource_open_file(filename)");
+
+    return (code);
 }
diff --git a/gs/base/gsparam2.c b/gs/base/gsparam2.c
index 5aa1f47a4..bd54a0998 100644
--- a/gs/base/gsparam2.c
+++ b/gs/base/gsparam2.c
@@ -24,7 +24,7 @@
 #include "gserrors.h"
 #include "gsparams.h"
 
-#define MAX_PARAM_KEY 255
+#define MAX_PARAM_KEY gp_file_name_sizeof
 
 /* ---------------- Serializer ---------------- */
 
@@ -42,6 +42,11 @@ gs_param_list_puts(stream *dest, gs_param_list *list)
     int code = 0;
     gs_param_enumerator_t key_enum;
     gs_param_key_t key;
+    char *string_key = gs_alloc_bytes(dest->memory, MAX_PARAM_KEY + 1, "gs_param_list_puts(string_key)");
+    
+    if (!string_key) {
+        return_error(gs_error_VMerror);
+    }
 
     param_init_enumerator(&key_enum);
 
@@ -72,7 +77,6 @@ gs_param_list_puts(stream *dest, gs_param_list *list)
 
         /* Get next datum & put its type & key to stream */
         gs_param_typed_value value;
-        char string_key[MAX_PARAM_KEY + 1];
 
         if (sizeof(string_key) < key.size + 1) {
             code = gs_note_error(gs_error_rangecheck);
@@ -155,6 +159,8 @@ string_array:	sput_word(dest, size);
             break;
     }
 
+    gs_free_object(dest->memory, string_key, "gs_param_list_puts(string_key)");
+
     /* Write end marker, which is an (illegal) 0 key length */
     return (code < 0 ? code : sput_word(dest, 0));
 }
@@ -200,6 +206,11 @@ int
 gs_param_list_gets(stream *src, gs_param_list *list, gs_memory_t *mem)
 {
     int code = 0;
+    char *string_key = gs_alloc_bytes(dest->memory, MAX_PARAM_KEY + 1, "gs_param_list_gets(string_key)");
+    
+    if (!string_key) {
+        return_error(gs_error_VMerror);
+    }
 
     do {
         gs_param_typed_value typed;
@@ -210,7 +221,6 @@ gs_param_list_gets(stream *src, gs_param_list *list, gs_memory_t *mem)
         void *data;
         uint size;
         gs_param_type type;
-        char string_key[MAX_PARAM_KEY + 1];
 
         /* key length 0 indicates end of data */
         if ((code = sget_word(src, &key_sizeof)) < 0 ||
@@ -340,6 +350,8 @@ put:	if (code < 0)
     }
     while (code >= 0);
 
+    gs_free_object(dest->memory, string_key, "gs_param_list_gets(string_key)");
+
     return code;
 }
 
diff --git a/gs/devices/gdevtsep.c b/gs/devices/gdevtsep.c
index 400413c3a..76160fafe 100644
--- a/gs/devices/gdevtsep.c
+++ b/gs/devices/gdevtsep.c
@@ -502,7 +502,6 @@ tiffcmyk_print_page(gx_device_printer * pdev, FILE * file)
 /* ----------  The tiffsep device ------------ */
 
 #define NUM_CMYK_COMPONENTS 4
-#define MAX_FILE_NAME_SIZE gp_file_name_sizeof
 #define MAX_COLOR_VALUE 255             /* We are using 8 bits per colorant */
 
 /* The device descriptor */
@@ -1226,7 +1225,7 @@ tiffsep1_prn_close(gx_device * pdev)
     int num_std_colorants = tfdev->devn_params.num_std_colorant_names;
     int num_order = tfdev->devn_params.num_separation_order_names;
     int num_spot = tfdev->devn_params.separations.num_separations;
-    char name[MAX_FILE_NAME_SIZE];
+    char *name= NULL;
     int code = gdev_prn_close(pdev);
     short map_comp_to_sep[GX_DEVICE_COLOR_MAX_COMPONENTS];
     int comp_num;
@@ -1237,15 +1236,26 @@ tiffsep1_prn_close(gx_device * pdev)
 
     if (code < 0)
         return code;
+
+    name = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "tiffsep1_prn_close(name)");
+    if (!name)
+        return_error(gs_error_VMerror);
+
     code = gx_parse_output_file_name(&parsed, &fmt, tfdev->fname,
                                      strlen(tfdev->fname), pdev->memory);
-    if (code < 0)
-        return code;
+    if (code < 0) {
+        goto done;
+    }
 
     /* If we are doing separate pages, delete the old default file */
     if (parsed.iodev == iodev_default(pdev->memory)) {          /* filename includes "%nnd" */
+        char *compname = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "tiffsep1_prn_close(compname)");
+        if (!compname) {
+            code = gs_note_error(gs_error_VMerror);
+            goto done;
+        }
+
         if (fmt) {
-            char compname[MAX_FILE_NAME_SIZE];
             long count1 = pdev->PageCount;
 
             while (*fmt != 'l' && *fmt != '%')
@@ -1258,7 +1268,7 @@ tiffsep1_prn_close(gx_device * pdev)
         } else {
             parsed.iodev->procs.delete_file(parsed.iodev, tfdev->fname);
         }
-
+        gs_free_object(pdev->memory, compname, "tiffsep1_prn_close(compname)");
     }
 
     if (tfdev->close_files) {
@@ -1269,12 +1279,14 @@ tiffsep1_prn_close(gx_device * pdev)
                 int sep_num = map_comp_to_sep[comp_num];
 
                 code = create_separation_file_name((tiffsep_device *)tfdev, name,
-                                                    MAX_FILE_NAME_SIZE, sep_num, true);
-                if (code < 0)
-                    return code;
+                                                    gp_file_name_sizeof, sep_num, true);
+                if (code < 0) {
+                    goto done;
+                }
                 code = gx_device_close_output_file(pdev, name, tfdev->sep_file[comp_num]);
-                if (code < 0)
-                    return code;
+                if (code < 0) {
+                    goto done;
+                }
                 tfdev->sep_file[comp_num] = NULL;
             }
             if (tfdev->tiff[comp_num]) {
@@ -1287,7 +1299,12 @@ tiffsep1_prn_close(gx_device * pdev)
     if( tfdev->thresholds[0].dstart != NULL) {
         sep1_free_thresholds(tfdev);
     }
-    return 0;
+
+done:
+
+    if (name)
+        gs_free_object(pdev->memory, name, "tiffsep1_prn_close(name)");
+    return code;
 }
 
 
@@ -1664,19 +1681,24 @@ tiffsep_prn_close(gx_device * pdev)
     int num_std_colorants = pdevn->devn_params.num_std_colorant_names;
     int num_order = pdevn->devn_params.num_separation_order_names;
     int num_spot = pdevn->devn_params.separations.num_separations;
-    char name[MAX_FILE_NAME_SIZE];
+    char *name = NULL;
     int code;
     int comp_num;
     int num_comp = number_output_separations(num_dev_comp, num_std_colorants,
                                         num_order, num_spot);
 
+    name = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "tiffsep_prn_close(name)");
+    if (!name)
+        return_error(gs_error_VMerror);
+
     if (pdevn->tiff_comp && pdevn->close_files) {
         TIFFCleanup(pdevn->tiff_comp);
         pdevn->tiff_comp = NULL;
     }
     code = gdev_prn_close(pdev);
-    if (code < 0)
-        return code;
+    if (code < 0) {
+        goto done;
+    }
 
     if (pdevn->close_files) {
         /* Close the separation files */
@@ -1685,17 +1707,23 @@ tiffsep_prn_close(gx_device * pdev)
                 int sep_num = pdevn->devn_params.separation_order_map[comp_num];
 
                 code = create_separation_file_name(pdevn, name,
-                        MAX_FILE_NAME_SIZE, sep_num, true);
-                if (code < 0)
-                    return code;
+                        gp_file_name_sizeof, sep_num, true);
+                if (code < 0) {
+                    goto done;
+                }
                 code = tiffsep_close_sep_file(pdevn, name, comp_num);
-                if (code < 0)
-                    return code;
+                if (code < 0) {
+                    goto done;
+                }
             }
         }
     }
 
-    return 0;
+done:
+
+    if (name)
+        gs_free_object(pdev->memory, name, "tiffsep_prn_close(name)");
+    return code;
 }
 
 /*
@@ -2101,7 +2129,7 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
     int num_spot = tfdev->devn_params.separations.num_separations;
     int num_comp, comp_num, sep_num, code = 0, code1 = 0;
     cmyk_composite_map cmyk_map[GX_DEVICE_COLOR_MAX_COMPONENTS];
-    char name[MAX_FILE_NAME_SIZE];
+    char *name = NULL;
     int base_filename_length = length_base_file_name(tfdev);
     int save_depth = pdev->color_info.depth;
     int save_numcomps = pdev->color_info.num_components;
@@ -2115,12 +2143,15 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
     int width = gx_downscaler_scale(tfdev->width, factor);
     int height = gx_downscaler_scale(tfdev->height, factor);
 
+    name = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "tiffsep_print_page(name)");
+    if (!name)
+        return_error(gs_error_VMerror);
 
     /* Print the names of the spot colors */
     if (num_order == 0) {
         for (sep_num = 0; sep_num < num_spot; sep_num++) {
             copy_separation_name(tfdev, name,
-                MAX_FILE_NAME_SIZE - base_filename_length - SUFFIX_SIZE, sep_num);
+                gp_file_name_sizeof - base_filename_length - SUFFIX_SIZE, sep_num);
             dmlprintf1(pdev->memory, "%%%%SeparationName: %s\n", name);
         }
     }
@@ -2142,12 +2173,15 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
         }
 
         code = gx_device_open_output_file((gx_device *)pdev, pdev->fname, true, true, &(tfdev->comp_file));
-        if (code < 0)
-            return code;
+        if (code < 0) {
+            goto done;
+        }
 
         tfdev->tiff_comp = tiff_from_filep(pdev, pdev->dname, tfdev->comp_file, tfdev->BigEndian, tfdev->UseBigTIFF);
-        if (!tfdev->tiff_comp)
-            return_error(gs_error_invalidfileaccess);
+        if (!tfdev->tiff_comp) {
+            code = gs_note_error(gs_error_invalidfileaccess);
+            goto done;
+        }
 
     }
     code = tiff_set_fields_for_printer(pdev, tfdev->tiff_comp, factor, 0);
@@ -2161,8 +2195,9 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
     }
 
     pdev->color_info.depth = save_depth;
-    if (code < 0)
-        return code;
+    if (code < 0) {
+        goto done;
+    }
 
     /* Set up the separation output files */
     num_comp = number_output_separations( tfdev->color_info.num_components,
@@ -2175,36 +2210,45 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
     for (comp_num = 0; comp_num < num_comp; comp_num++ ) {
         int sep_num = tfdev->devn_params.separation_order_map[comp_num];
 
-        code = create_separation_file_name(tfdev, name, MAX_FILE_NAME_SIZE,
+        code = create_separation_file_name(tfdev, name, gp_file_name_sizeof,
                                             sep_num, true);
-        if (code < 0)
-            return code;
+        if (code < 0) {
+            goto done;
+        }
 
         /* Open the separation file, if not already open */
         if (tfdev->sep_file[comp_num] == NULL) {
             code = gx_device_open_output_file((gx_device *)pdev, name,
                     true, true, &(tfdev->sep_file[comp_num]));
-            if (code < 0)
-                return code;
+            if (code < 0) {
+                goto done;
+            }
             tfdev->tiff[comp_num] = tiff_from_filep(pdev, name,
                                                     tfdev->sep_file[comp_num],
                                                     tfdev->BigEndian, tfdev->UseBigTIFF);
-            if (!tfdev->tiff[comp_num])
-                return_error(gs_error_ioerror);
+            if (!tfdev->tiff[comp_num]) {
+                code = gs_note_error(gs_error_ioerror);
+                goto done;
+            }
         }
 
         pdev->color_info.depth = dst_bpc;     /* Create files for 8 bit gray */
         pdev->color_info.num_components = 1;
         if (tfdev->Compression==COMPRESSION_NONE &&
             height*8/dst_bpc > ((unsigned long) 0xFFFFFFFF - (file ? ftell(file): 0))/width) /* note width is never 0 in print_page */
-            return_error(gs_error_rangecheck);  /* this will overflow 32 bits */
+        {
+            code = gs_note_error(gs_error_rangecheck);  /* this will overflow 32 bits */
+            goto done;
+        }
 
+        
         code = tiff_set_fields_for_printer(pdev, tfdev->tiff[comp_num], factor, 0);
         tiff_set_gray_fields(pdev, tfdev->tiff[comp_num], dst_bpc, tfdev->Compression, tfdev->MaxStripSize);
         pdev->color_info.depth = save_depth;
         pdev->color_info.num_components = save_numcomps;
-        if (code < 0)
-            return code;
+        if (code < 0) {
+            goto done;
+        }
     }
 
     build_cmyk_map(tfdev, num_comp, cmyk_map);
@@ -2220,6 +2264,10 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
 
         sep_line =
             gs_alloc_bytes(pdev->memory, cmyk_raster, "tiffsep_print_page");
+        if (!sep_line) {
+            code = gs_note_error(gs_error_VMerror);
+            goto done;
+        }
 
         for (comp_num = 0; comp_num < num_comp; comp_num++ )
             TIFFCheckpointDirectory(tfdev->tiff[comp_num]);
@@ -2249,7 +2297,7 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
                                                       "tiffsep_print_page");
                     params.data[comp_num] = planes[comp_num];
                     if (params.data[comp_num] == NULL) {
-                        code = gs_error_VMerror;
+                        code = gs_note_error(gs_error_VMerror);
                         goto cleanup;
                     }
                 }
@@ -2270,7 +2318,7 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
                         /* Assign the new plane to the appropriate position */
                         params.data[plane_index] = planes[plane_count];
                         if (params.data[plane_index] == NULL) {
-                            code = gs_error_VMerror;
+                            code = gs_note_error(gs_error_VMerror);
                             goto cleanup;
                         }
                         plane_count += 1;
@@ -2289,7 +2337,7 @@ tiffsep_print_page(gx_device_printer * pdev, FILE * file)
                                                     "tiffsep_print_page");
                     params.data[comp_num] = planes[comp_num];
                     if (params.data[comp_num] == NULL) {
-                        code = gs_error_VMerror;
+                        code = gs_note_error(gs_error_VMerror);
                         goto cleanup;
                     }
                 }
@@ -2369,7 +2417,7 @@ cleanup:
             if (fmt) {
                 int sep_num = tfdev->devn_params.separation_order_map[comp_num];
 
-                code = create_separation_file_name(tfdev, name, MAX_FILE_NAME_SIZE, sep_num, false);
+                code = create_separation_file_name(tfdev, name, gp_file_name_sizeof, sep_num, false);
                 if (code < 0) {
                     code1 = code;
                     continue;
@@ -2389,6 +2437,10 @@ cleanup:
             code = code1;
         }
     }
+
+done:
+    if (name)
+        gs_free_object(pdev->memory, name, "tiffsep_print_page(name)");
     return code;
 }
 
@@ -2408,7 +2460,7 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
     int num_spot = tfdev->devn_params.separations.num_separations;
     int num_comp, comp_num, code = 0, code1 = 0;
     short map_comp_to_sep[GX_DEVICE_COLOR_MAX_COMPONENTS];
-    char name[MAX_FILE_NAME_SIZE];
+    char *name = NULL;
     int save_depth = pdev->color_info.depth;
     int save_numcomps = pdev->color_info.num_components;
     const char *fmt;
@@ -2418,6 +2470,10 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
     if (tfdev->thresholds[0].dstart == NULL)
         return_error(gs_error_rangecheck);
 
+    name = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "tiffsep1_print_page(name)");
+    if (!name)
+        return_error(gs_error_VMerror);
+
     build_comp_to_sep_map((tiffsep_device *)tfdev, map_comp_to_sep);
 
     /*
@@ -2430,8 +2486,12 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
     /* If the output file is on disk and the name contains a page #, */
     /* then delete the previous file. */
     if (pdev->file != NULL && parsed.iodev == iodev_default(pdev->memory) && fmt) {
-        char compname[MAX_FILE_NAME_SIZE];
         long count1 = pdev->PageCount;
+        char *compname = (char *)gs_alloc_bytes(pdev->memory, gp_file_name_sizeof, "tiffsep1_print_page(compname)");
+        if (!compname) {
+            code = gs_note_error(gs_error_VMerror);
+            goto done;
+        }
 
         gx_device_close_output_file((gx_device *)pdev, pdev->fname, pdev->file);
         pdev->file = NULL;
@@ -2444,8 +2504,12 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
             gs_sprintf(compname, parsed.fname, (int)count1);
         parsed.iodev->procs.delete_file(parsed.iodev, compname);
         /* we always need an open printer (it will get deleted in tiffsep1_prn_close */
-        if ((code = gdev_prn_open_printer((gx_device *)pdev, 1)) < 0)
-            return code;
+        code = gdev_prn_open_printer((gx_device *)pdev, 1);
+
+        gs_free_object(pdev->memory, compname, "tiffsep_print_page(compname)");
+        if (code < 0) {
+            goto done;
+        }
     }
 
     /* Set up the separation output files */
@@ -2455,21 +2519,25 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
         int sep_num = map_comp_to_sep[comp_num];
 
         code = create_separation_file_name((tiffsep_device *)tfdev, name,
-                                        MAX_FILE_NAME_SIZE, sep_num, true);
-        if (code < 0)
-            return code;
+                                        gp_file_name_sizeof, sep_num, true);
+        if (code < 0) {
+            goto done;
+        }
 
         /* Open the separation file, if not already open */
         if (tfdev->sep_file[comp_num] == NULL) {
             code = gx_device_open_output_file((gx_device *)pdev, name,
                     true, true, &(tfdev->sep_file[comp_num]));
-            if (code < 0)
-                return code;
+            if (code < 0) {
+                goto done;
+            }
             tfdev->tiff[comp_num] = tiff_from_filep(pdev, name,
                                                     tfdev->sep_file[comp_num],
                                                     tfdev->BigEndian, tfdev->UseBigTIFF);
-            if (!tfdev->tiff[comp_num])
-                return_error(gs_error_ioerror);
+            if (!tfdev->tiff[comp_num]) {
+                code = gs_note_error(gs_error_ioerror);
+                goto done;
+            }
         }
 
         pdev->color_info.depth = 8;     /* Create files for 8 bit gray */
@@ -2478,8 +2546,9 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
         tiff_set_gray_fields(pdev, tfdev->tiff[comp_num], 1, tfdev->Compression, tfdev->MaxStripSize);
         pdev->color_info.depth = save_depth;
         pdev->color_info.num_components = save_numcomps;
-        if (code < 0)
-            return code;
+        if (code < 0) {
+            goto done;
+        }
 
     }   /* end initialization of separation files */
 
@@ -2612,7 +2681,7 @@ tiffsep1_print_page(gx_device_printer * pdev, FILE * file)
             if (fmt) {
                 int sep_num = map_comp_to_sep[comp_num];
 
-                code = create_separation_file_name((tiffsep_device *)tfdev, name, MAX_FILE_NAME_SIZE, sep_num, false);
+                code = create_separation_file_name((tiffsep_device *)tfdev, name, gp_file_name_sizeof, sep_num, false);
                 if (code < 0) {
                     code1 = code;
                     continue;
@@ -2637,8 +2706,11 @@ cleanup:
      */
     if (non_encodable_count) {
         dmlprintf1(pdev->memory, "WARNING:  Non encodable pixels = %d\n", non_encodable_count);
-        return_error(gs_error_rangecheck);
+        code = gs_note_error(gs_error_rangecheck);
     }
 
+done:
+    if (name)
+        gs_free_object(pdev->memory, name, "tiffsep1_print_page(name)");
     return code;
 }
diff --git a/gs/devices/vector/gdevxps.c b/gs/devices/vector/gdevxps.c
index 37b651147..b61a0fc58 100644
--- a/gs/devices/vector/gdevxps.c
+++ b/gs/devices/vector/gdevxps.c
@@ -376,12 +376,23 @@ zip_append_data(gs_memory_t *mem, gx_device_xps_zinfo_t *info, byte *data, uint
     /* if there is no data then this is the first call for this
        archive file, open a temporary file to store the data. */
     if (info->data.count == 0) {
-        char filename[gp_file_name_sizeof];
-        FILE *fp = gp_open_scratch_file(mem, "xpsdata-",
+        char *filename =
+          (char *)gs_alloc_bytes(mem, gp_file_name_sizeof, "zip_append_data(filename)");
+        FILE *fp;
+        
+        if (!filename) {
+            return(gs_throw_code(gs_error_VMerror));
+        }
+        
+        fp = gp_open_scratch_file(mem, "xpsdata-",
                                         filename, "wb+");
-        if (fp == NULL)
+
+        if (fp == NULL) {
+            gs_free_object(mem, filename, "zip_append_data(filename)");
             return gs_throw_code(gs_error_Fatal);
+        }
         unlink(filename);
+        gs_free_object(mem, filename, "zip_append_data(filename)");
         info->data.fp = fp;
     }
 
diff --git a/gs/psi/zfile.c b/gs/psi/zfile.c
index 6061d3189..e092bed9c 100644
--- a/gs/psi/zfile.c
+++ b/gs/psi/zfile.c
@@ -665,8 +665,8 @@ ztempfile(i_ctx_t *i_ctx_p)
     const char *pstr;
     char fmode[4];
     int code = parse_file_access_string(op, fmode);
-    char prefix[gp_file_name_sizeof];
-    char fname[gp_file_name_sizeof];
+    char *prefix = NULL;
+    char *fname= NULL;
     uint fnlen;
     FILE *sfile;
     stream *s;
@@ -674,6 +674,13 @@ ztempfile(i_ctx_t *i_ctx_p)
 
     if (code < 0)
         return code;
+    prefix = (char *)gs_alloc_bytes(imemory, gp_file_name_sizeof, "ztempfile(prefix)");
+    fname = (char *)gs_alloc_bytes(imemory, gp_file_name_sizeof, "ztempfile(fname)");
+    if (!prefix || !fname) {
+        code = gs_note_error(gs_error_VMerror);
+        goto done;
+    }
+
     strcat(fmode, gp_fmode_binary_suffix);
     if (r_has_type(op - 1, t_null))
         pstr = gp_scratch_file_name_prefix;
@@ -682,8 +689,10 @@ ztempfile(i_ctx_t *i_ctx_p)
 
         check_read_type(op[-1], t_string);
         psize = r_size(op - 1);
-        if (psize >= gp_file_name_sizeof)
-            return_error(e_rangecheck);
+        if (psize >= gp_file_name_sizeof) {
+            code = gs_note_error(e_rangecheck);
+            goto done;
+        }
         memcpy(prefix, op[-1].value.const_bytes, psize);
         prefix[psize] = 0;
         pstr = prefix;
@@ -692,29 +701,37 @@ ztempfile(i_ctx_t *i_ctx_p)
     if (gp_file_name_is_absolute(pstr, strlen(pstr))) {
         if (check_file_permissions(i_ctx_p, pstr, strlen(pstr),
                                    "PermitFileWriting") < 0) {
-            return_error(e_invalidfileaccess);
+            code = gs_note_error(e_invalidfileaccess);
+            goto done;
         }
     } else if (!prefix_is_simple(pstr)) {
-        return_error(e_invalidfileaccess);
+        code = gs_note_error(e_invalidfileaccess);
+        goto done;
     }
 
     s = file_alloc_stream(imemory, "ztempfile(stream)");
-    if (s == 0)
-        return_error(e_VMerror);
+    if (s == 0) {
+        code = gs_note_error(e_VMerror);
+        goto done;
+    }
     buf = gs_alloc_bytes(imemory, file_default_buffer_size,
                          "ztempfile(buffer)");
-    if (buf == 0)
-        return_error(e_VMerror);
+    if (buf == 0) {
+        code = gs_note_error(e_VMerror);
+        goto done;
+    }
     sfile = gp_open_scratch_file(imemory, pstr, fname, fmode);
     if (sfile == 0) {
         gs_free_object(imemory, buf, "ztempfile(buffer)");
-        return_error(e_invalidfileaccess);
+        code = gs_note_error(e_invalidfileaccess);
+        goto done;
     }
     fnlen = strlen(fname);
     sbody = ialloc_string(fnlen, ".tempfile(fname)");
     if (sbody == 0) {
         gs_free_object(imemory, buf, "ztempfile(buffer)");
-        return_error(e_VMerror);
+        code = gs_note_error(e_VMerror);
+        goto done;
     }
     memcpy(sbody, fname, fnlen);
     file_init_stream(s, sfile, fmode, buf, file_default_buffer_size);
@@ -724,10 +741,17 @@ ztempfile(i_ctx_t *i_ctx_p)
         sclose(s);
         iodev_dflt->procs.delete_file(iodev_dflt, fname);
         ifree_string(sbody, fnlen, ".tempfile(fname)");
-        return_error(e_VMerror);
+        code = gs_note_error(e_VMerror);
+        goto done;
     }
     make_string(op - 1, a_readonly | icurrent_space, fnlen, sbody);
     make_stream_file(op, s, fmode);
+
+done:
+    if (prefix)
+        gs_free_object(imemory, prefix, "ztempfile(prefix)");
+    if (fname)
+        gs_free_object(imemory, fname, "ztempfile(fname)");
     return code;
 }
 
diff --git a/xps/xpsjxr.c b/xps/xpsjxr.c
index b5bb6c8c4..90c5d3d08 100644
--- a/xps/xpsjxr.c
+++ b/xps/xpsjxr.c
@@ -168,27 +168,37 @@ int
 xps_decode_jpegxr(xps_context_t *ctx, byte *buf, int len, xps_image_t *output)
 {
     FILE *file;
-    char name[gp_file_name_sizeof];
+    char *name = xps_alloc(ctx, gp_file_name_sizeof);
     struct state state;
     jxr_container_t container;
     jxr_image_t image;
     int offset, alpha_offset;
     int rc;
+    
+    if (!name) {
+        return gs_throw(gs_error_VMerror, "cannot allocate scratch file name buffer");
+    }
 
     memset(output, 0, sizeof(*output));
 
     file = gp_open_scratch_file(ctx->memory, "jpegxr-scratch-", name, "wb+");
-    if (!file)
+    if (!file) {
+        xps_free(ctx, name);
         return gs_throw(gs_error_invalidfileaccess, "cannot open scratch file");
+    }
     rc = fwrite(buf, 1, len, file);
-    if (rc != len)
+    if (rc != len) {
+        xps_free(ctx, name);
         return gs_throw(gs_error_invalidfileaccess, "cannot write to scratch file");
+    }
     fseek(file, 0, SEEK_SET);
 
     container = jxr_create_container();
     rc = jxr_read_image_container(container, file);
-    if (rc < 0)
+    if (rc < 0) {
+        xps_free(ctx, name);
         return gs_throw1(-1, "jxr_read_image_container: %s", jxr_error_string(rc));
+    }
 
     offset = jxrc_image_offset(container, 0);
     alpha_offset = jxrc_alpha_offset(container, 0);
@@ -215,8 +225,10 @@ xps_decode_jpegxr(xps_context_t *ctx, byte *buf, int len, xps_image_t *output)
 
     fseek(file, offset, SEEK_SET);
     rc = jxr_read_image_bitstream(image, file);
-    if (rc < 0)
+    if (rc < 0) {
+        xps_free(ctx, name);
         return gs_throw1(-1, "jxr_read_image_bitstream: %s", jxr_error_string(rc));
+    }
 
     jxr_destroy(image);
 
@@ -241,8 +253,10 @@ xps_decode_jpegxr(xps_context_t *ctx, byte *buf, int len, xps_image_t *output)
 
         fseek(file, alpha_offset, SEEK_SET);
         rc = jxr_read_image_bitstream(image, file);
-        if (rc < 0)
+        if (rc < 0) {
+            xps_free(ctx, name);
             return gs_throw1(-1, "jxr_read_image_bitstream: %s", jxr_error_string(rc));
+        }
 
         jxr_destroy(image);
     }
@@ -251,6 +265,7 @@ xps_decode_jpegxr(xps_context_t *ctx, byte *buf, int len, xps_image_t *output)
 
     fclose(file);
     unlink(name);
+    xps_free(ctx, name);
 
     return gs_okay;
 }