src/disk/bootblock_iso9660.c

/*
 *  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: bootblock_iso9660.c,v 1.2 2007/03/16 15:17:55 debug Exp $
 *
 *  ISO9660 CD-ROM "bootblock" handling.
 *
 *  There is really no bootblock; instead, the file which is to be booted
 *  is extracted into a temporary file, and started as if it was given
 *  as a normal file argument on the command line.
 *
 *  TODO: This is really ugly. It's a quick hack. All the magic constants
 *        need to be replaced with real code!
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#include "cpu.h"
#include "diskimage.h"
#include "machine.h"
#include "misc.h"

/*  #define ISO_DEBUG  */


static void debug_print_volume_id_and_filename(int iso_type,
        unsigned char *buf, char *filename)
{
        /*  Volume ID:  */
        char str[35];
        int i, ofs = iso_type == 3? 48 : 40;

        memcpy(str, buf + ofs, sizeof(str));
        str[32] = '\0';  i = 31;

        while (i >= 0 && str[i]==' ')
                str[i--] = '\0';
        if (str[0])
                debug("\"%s\"", str);
        else {
                /*  System ID:  */
                ofs = iso_type == 3? 16 : 8;
                memcpy(str, buf + ofs, sizeof(str));
                str[32] = '\0';  i = 31;
                while (i >= 0 && str[i]==' ')
                        str[i--] = '\0';
                if (str[0])
                        debug("\"%s\"", str);
                else
                        debug("(no ID)");
        }

        debug(":%s\n", filename);
}


/*
 *  iso_load_bootblock():
 *
 *  Try to load a kernel from an ISO 9660 disk image. iso_type is 1 for
 *  "CD001" (standard), 2 for "CDW01" (ECMA), and 3 for "CDROM" (Sierra).
 *
 *  TODO: This function uses too many magic offsets and so on; it should be
 *  cleaned up some day.
 *
 *  Returns 1 on success, 0 on failure.
 */
int iso_load_bootblock(struct machine *m, struct cpu *cpu,
        int disk_id, int disk_type, int iso_type, unsigned char *buf,
        int *n_loadp, char ***load_namesp)
{
        int filenr, dirlen, res = 0, res2, iadd = DEBUG_INDENTATION;
        int found_dir;
        uint64_t dirofs;
        uint64_t fileofs, filelen;
        unsigned char *dirbuf = NULL, *dp;
        unsigned char *match_entry = NULL;
        char *p, *filename_orig;
        char *filename = strdup(cpu->machine->boot_kernel_filename);
        unsigned char *filebuf = NULL;
        char *tmpfname = NULL;
        char **new_array;
        int tmpfile_handle;

        if (filename == NULL) {
                fatal("out of memory\n");
                exit(1);
        }
        filename_orig = filename;

        debug("ISO9660 boot:\n");
        debug_indentation(iadd);

        debug_print_volume_id_and_filename(iso_type, buf, filename);


        /*
         *  Traverse the directory structure to find the kernel.
         */

        dirlen = buf[0x84] + 256*buf[0x85] + 65536*buf[0x86];
        if (dirlen != buf[0x8b] + 256*buf[0x8a] + 65536*buf[0x89])
                fatal("WARNING: Root directory length mismatch?\n");

        dirofs = (int64_t)(buf[0x8c] + (buf[0x8d] << 8) + (buf[0x8e] << 16) +
            ((uint64_t)buf[0x8f] << 24)) * 2048;

#ifdef ISO_DEBUG
        debug("root = %i bytes at 0x%llx\n", dirlen, (long long)dirofs);
#endif

        dirbuf = malloc(dirlen);
        if (dirbuf == NULL) {
                fatal("out of memory in iso_load_bootblock()\n");
                exit(1);
        }

        res2 = diskimage_access(m, disk_id, disk_type, 0, dirofs, dirbuf,
            dirlen);
        if (!res2) {
                fatal("Couldn't read the disk image. Aborting.\n");
                goto ret;
        }

        found_dir = 1;  /*  Assume root dir  */
        dp = dirbuf; filenr = 1;
        p = NULL;
        while (dp < dirbuf + dirlen) {
                size_t i, nlen = dp[0];
                int x = dp[2] + (dp[3] << 8) + (dp[4] << 16) +
                    ((uint64_t)dp[5] << 24);
                int y = dp[6] + (dp[7] << 8);
                char direntry[65];

                dp += 8;

                /*
                 *  As long as there is an \ or / in the filename, then we
                 *  have not yet found the directory.
                 */
                p = strchr(filename, '/');
                if (p == NULL)
                        p = strchr(filename, '\\');

#ifdef ISO_DEBUG
                debug("%i%s: %i, %i, \"", filenr, filenr == found_dir?
                    " [CURRENT]" : "", x, y);
#endif
                for (i=0; i<nlen && i<sizeof(direntry)-1; i++)
                        if (dp[i]) {
                                direntry[i] = dp[i];
#ifdef ISO_DEBUG
                                debug("%c", dp[i]);
#endif
                        } else
                                break;
#ifdef ISO_DEBUG
                debug("\"\n");
#endif
                direntry[i] = '\0';

                /*  A directory name match?  */
                if ((p != NULL && strncasecmp(filename, direntry, nlen) == 0
                    && nlen == (size_t)p - (size_t)filename && found_dir == y)
                    || (p == NULL && direntry[0] == '\0') ) {
                        found_dir = filenr;
                        if (p != NULL)
                                filename = p+1;
                        dirofs = 2048 * (int64_t)x;
                }

                dp += nlen;

                /*  16-bit aligned lenght:  */
                if (nlen & 1)
                        dp ++;

                filenr ++;
        }

        p = strchr(filename, '/');
        if (p == NULL)
                p = strchr(filename, '\\');

        if (p != NULL) {
                char *blah = filename_orig;

                fatal("could not find '%s' in /", filename);

                /*  Print the first part of the filename:  */
                while (blah != filename)
                        fatal("%c", *blah++);
                
                fatal("\n");
                goto ret;
        }

        /*  debug("dirofs = 0x%llx\n", (long long)dirofs);  */

        /*  Free the old dirbuf, and allocate a new one:  */
        free(dirbuf);
        dirbuf = malloc(512);
        if (dirbuf == NULL) {
                fatal("out of memory in iso_load_bootblock()\n");
                exit(1);
        }

        for (;;) {
                size_t len, i;

                /*  Too close to another sector? Then realign.  */
                if ((dirofs & 2047) + 70 > 2047) {
                        dirofs = (dirofs | 2047) + 1;
                        /*  debug("realign dirofs = 0x%llx\n", dirofs);  */
                }

                res2 = diskimage_access(m, disk_id, disk_type, 0, dirofs,
                    dirbuf, 256);
                if (!res2) {
                        fatal("Couldn't read the disk image. Aborting.\n");
                        goto ret;
                }

                dp = dirbuf;
                len = dp[0];
                if (len < 2)
                        break;

                /*
                 *  TODO: Actually parse the directory entry!
                 *
                 *  Haha, this must be rewritten.
                 */

#if 0
/*  hahahaha  */
printf("filename = '%s'\n", filename);
{
int j;
for (j=32; j<len; j++)
        printf("%c", dp[j] >= ' ' && dp[j] < 128? dp[j] : '.');
printf("\n");
}
#endif

                for (i=32; i<len; i++) {
                        if (i < len - strlen(filename))
                                if (strncmp(filename, (char *)dp + i,
                                    strlen(filename)) == 0) {
                                        /*  The filename was found somewhere
                                            in the directory entry.  */
                                        if (match_entry != NULL) {
                                                fatal("TODO: I'm too lazy to"
                                                    " implement a correct "
                                                    "directory parser right "
                                                    "now... (BUG)\n");
                                                exit(1);
                                        }
                                        match_entry = malloc(512);
                                        if (match_entry == NULL) {
                                                fatal("out of memory\n");
                                                exit(1);
                                        }
                                        memcpy(match_entry, dp, 512);
                                        break;
                                }
                }

                if (match_entry != NULL)
                        break;

                dirofs += len;
        }

        if (match_entry == NULL) {
                char *blah = filename_orig;

                fatal("could not find '%s' in /", filename);

                /*  Print the first part of the filename:  */
                while (blah != filename)
                        fatal("%c", *blah++);
                
                fatal("\n");
                goto ret;
        }

        fileofs = match_entry[2] + (match_entry[3] << 8) +
            (match_entry[4] << 16) + ((uint64_t)match_entry[5] << 24);
        filelen = match_entry[10] + (match_entry[11] << 8) +
            (match_entry[12] << 16) + ((uint64_t)match_entry[13] << 24);
        fileofs *= 2048;

        /*  debug("filelen=%llx fileofs=%llx\n", (long long)filelen,
            (long long)fileofs);  */

        filebuf = malloc(filelen);
        if (filebuf == NULL) {
                fatal("could not allocate %lli bytes to read the file"
                    " from the disk image!\n", (long long)filelen);
                goto ret;
        }

        tmpfname = strdup("/tmp/gxemul.XXXXXXXXXXXX");

        res2 = diskimage_access(m, disk_id, disk_type, 0, fileofs, filebuf,
            filelen);
        if (!res2) {
                fatal("could not read the file from the disk image!\n");
                goto ret;
        }

        tmpfile_handle = mkstemp(tmpfname);
        if (tmpfile_handle < 0) {
                fatal("could not create %s\n", tmpfname);
                exit(1);
        }
        write(tmpfile_handle, filebuf, filelen);
        close(tmpfile_handle);

        debug("extracted %lli bytes into %s\n", (long long)filelen, tmpfname);

        /*  Add the temporary filename to the load_namesp array:  */
        (*n_loadp)++;
        new_array = malloc(sizeof(char *) * (*n_loadp));
        if (new_array == NULL) {
                fatal("out of memory\n");
                exit(1);
        }
        memcpy(new_array, *load_namesp, sizeof(char *) * (*n_loadp));
        *load_namesp = new_array;

        /*  This adds a Backspace char in front of the filename; this
            is a special hack which causes the file to be removed once
            it has been loaded.  */
        tmpfname = realloc(tmpfname, strlen(tmpfname) + 2);
        memmove(tmpfname + 1, tmpfname, strlen(tmpfname) + 1);
        tmpfname[0] = 8;

        (*load_namesp)[*n_loadp - 1] = tmpfname;

        res = 1;

ret:
        if (dirbuf != NULL)
                free(dirbuf);

        if (filebuf != NULL)
                free(filebuf);

        if (match_entry != NULL)
                free(match_entry);

        free(filename_orig);

        debug_indentation(-iadd);
        return res;
}

1	dpavlin	36	/*
2			* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28			* $Id: bootblock_iso9660.c,v 1.2 2007/03/16 15:17:55 debug Exp $
29			*
30			* ISO9660 CD-ROM "bootblock" handling.
31			*
32			* There is really no bootblock; instead, the file which is to be booted
33			* is extracted into a temporary file, and started as if it was given
34			* as a normal file argument on the command line.
35			*
36			* TODO: This is really ugly. It's a quick hack. All the magic constants
37			* need to be replaced with real code!
38			*/
39
40			#include <stdio.h>
41			#include <stdlib.h>
42			#include <string.h>
43			#include <sys/types.h>
44			#include <unistd.h>
45
46			#include "cpu.h"
47			#include "diskimage.h"
48			#include "machine.h"
49			#include "misc.h"
50
51			/* #define ISO_DEBUG */
52
53
54			static void debug_print_volume_id_and_filename(int iso_type,
55			unsigned char buf, char filename)
56			{
57			/* Volume ID: */
58			char str[35];
59			int i, ofs = iso_type == 3? 48 : 40;
60
61			memcpy(str, buf + ofs, sizeof(str));
62			str[32] = '\0'; i = 31;
63
64			while (i >= 0 && str[i]==' ')
65			str[i--] = '\0';
66			if (str[0])
67			debug("\"%s\"", str);
68			else {
69			/* System ID: */
70			ofs = iso_type == 3? 16 : 8;
71			memcpy(str, buf + ofs, sizeof(str));
72			str[32] = '\0'; i = 31;
73			while (i >= 0 && str[i]==' ')
74			str[i--] = '\0';
75			if (str[0])
76			debug("\"%s\"", str);
77			else
78			debug("(no ID)");
79			}
80
81			debug(":%s\n", filename);
82			}
83
84
85			/*
86			* iso_load_bootblock():
87			*
88			* Try to load a kernel from an ISO 9660 disk image. iso_type is 1 for
89			* "CD001" (standard), 2 for "CDW01" (ECMA), and 3 for "CDROM" (Sierra).
90			*
91			* TODO: This function uses too many magic offsets and so on; it should be
92			* cleaned up some day.
93			*
94			* Returns 1 on success, 0 on failure.
95			*/
96			int iso_load_bootblock(struct machine m, struct cpu cpu,
97			int disk_id, int disk_type, int iso_type, unsigned char *buf,
98			int n_loadp, char **load_namesp)
99			{
100			int filenr, dirlen, res = 0, res2, iadd = DEBUG_INDENTATION;
101			int found_dir;
102			uint64_t dirofs;
103			uint64_t fileofs, filelen;
104			unsigned char dirbuf = NULL, dp;
105			unsigned char *match_entry = NULL;
106			char p, filename_orig;
107			char *filename = strdup(cpu->machine->boot_kernel_filename);
108			unsigned char *filebuf = NULL;
109			char *tmpfname = NULL;
110			char **new_array;
111			int tmpfile_handle;
112
113			if (filename == NULL) {
114			fatal("out of memory\n");
115			exit(1);
116			}
117			filename_orig = filename;
118
119			debug("ISO9660 boot:\n");
120			debug_indentation(iadd);
121
122			debug_print_volume_id_and_filename(iso_type, buf, filename);
123
124
125			/*
126			* Traverse the directory structure to find the kernel.
127			*/
128
129			dirlen = buf[0x84] + 256buf[0x85] + 65536buf[0x86];
130			if (dirlen != buf[0x8b] + 256buf[0x8a] + 65536buf[0x89])
131			fatal("WARNING: Root directory length mismatch?\n");
132
133			dirofs = (int64_t)(buf[0x8c] + (buf[0x8d] << 8) + (buf[0x8e] << 16) +
134			((uint64_t)buf[0x8f] << 24)) * 2048;
135
136			#ifdef ISO_DEBUG
137			debug("root = %i bytes at 0x%llx\n", dirlen, (long long)dirofs);
138			#endif
139
140			dirbuf = malloc(dirlen);
141			if (dirbuf == NULL) {
142			fatal("out of memory in iso_load_bootblock()\n");
143			exit(1);
144			}
145
146			res2 = diskimage_access(m, disk_id, disk_type, 0, dirofs, dirbuf,
147			dirlen);
148			if (!res2) {
149			fatal("Couldn't read the disk image. Aborting.\n");
150			goto ret;
151			}
152
153			found_dir = 1; /* Assume root dir */
154			dp = dirbuf; filenr = 1;
155			p = NULL;
156			while (dp < dirbuf + dirlen) {
157			size_t i, nlen = dp[0];
158			int x = dp[2] + (dp[3] << 8) + (dp[4] << 16) +
159			((uint64_t)dp[5] << 24);
160			int y = dp[6] + (dp[7] << 8);
161			char direntry[65];
162
163			dp += 8;
164
165			/*
166			* As long as there is an \ or / in the filename, then we
167			* have not yet found the directory.
168			*/
169			p = strchr(filename, '/');
170			if (p == NULL)
171			p = strchr(filename, '\\');
172
173			#ifdef ISO_DEBUG
174			debug("%i%s: %i, %i, \"", filenr, filenr == found_dir?
175			" [CURRENT]" : "", x, y);
176			#endif
177			for (i=0; i<nlen && i<sizeof(direntry)-1; i++)
178			if (dp[i]) {
179			direntry[i] = dp[i];
180			#ifdef ISO_DEBUG
181			debug("%c", dp[i]);
182			#endif
183			} else
184			break;
185			#ifdef ISO_DEBUG
186			debug("\"\n");
187			#endif
188			direntry[i] = '\0';
189
190			/* A directory name match? */
191			if ((p != NULL && strncasecmp(filename, direntry, nlen) == 0
192			&& nlen == (size_t)p - (size_t)filename && found_dir == y)
193			\|\| (p == NULL && direntry[0] == '\0') ) {
194			found_dir = filenr;
195			if (p != NULL)
196			filename = p+1;
197			dirofs = 2048 * (int64_t)x;
198			}
199
200			dp += nlen;
201
202			/* 16-bit aligned lenght: */
203			if (nlen & 1)
204			dp ++;
205
206			filenr ++;
207			}
208
209			p = strchr(filename, '/');
210			if (p == NULL)
211			p = strchr(filename, '\\');
212
213			if (p != NULL) {
214			char *blah = filename_orig;
215
216			fatal("could not find '%s' in /", filename);
217
218			/* Print the first part of the filename: */
219			while (blah != filename)
220			fatal("%c", *blah++);
221
222			fatal("\n");
223			goto ret;
224			}
225
226			/* debug("dirofs = 0x%llx\n", (long long)dirofs); */
227
228			/* Free the old dirbuf, and allocate a new one: */
229			free(dirbuf);
230			dirbuf = malloc(512);
231			if (dirbuf == NULL) {
232			fatal("out of memory in iso_load_bootblock()\n");
233			exit(1);
234			}
235
236			for (;;) {
237			size_t len, i;
238
239			/* Too close to another sector? Then realign. */
240			if ((dirofs & 2047) + 70 > 2047) {
241			dirofs = (dirofs \| 2047) + 1;
242			/* debug("realign dirofs = 0x%llx\n", dirofs); */
243			}
244
245			res2 = diskimage_access(m, disk_id, disk_type, 0, dirofs,
246			dirbuf, 256);
247			if (!res2) {
248			fatal("Couldn't read the disk image. Aborting.\n");
249			goto ret;
250			}
251
252			dp = dirbuf;
253			len = dp[0];
254			if (len < 2)
255			break;
256
257			/*
258			* TODO: Actually parse the directory entry!
259			*
260			* Haha, this must be rewritten.
261			*/
262
263			#if 0
264			/* hahahaha */
265			printf("filename = '%s'\n", filename);
266			{
267			int j;
268			for (j=32; j<len; j++)
269			printf("%c", dp[j] >= ' ' && dp[j] < 128? dp[j] : '.');
270			printf("\n");
271			}
272			#endif
273
274			for (i=32; i<len; i++) {
275			if (i < len - strlen(filename))
276			if (strncmp(filename, (char *)dp + i,
277			strlen(filename)) == 0) {
278			/* The filename was found somewhere
279			in the directory entry. */
280			if (match_entry != NULL) {
281			fatal("TODO: I'm too lazy to"
282			" implement a correct "
283			"directory parser right "
284			"now... (BUG)\n");
285			exit(1);
286			}
287			match_entry = malloc(512);
288			if (match_entry == NULL) {
289			fatal("out of memory\n");
290			exit(1);
291			}
292			memcpy(match_entry, dp, 512);
293			break;
294			}
295			}
296
297			if (match_entry != NULL)
298			break;
299
300			dirofs += len;
301			}
302
303			if (match_entry == NULL) {
304			char *blah = filename_orig;
305
306			fatal("could not find '%s' in /", filename);
307
308			/* Print the first part of the filename: */
309			while (blah != filename)
310			fatal("%c", *blah++);
311
312			fatal("\n");
313			goto ret;
314			}
315
316			fileofs = match_entry[2] + (match_entry[3] << 8) +
317			(match_entry[4] << 16) + ((uint64_t)match_entry[5] << 24);
318			filelen = match_entry[10] + (match_entry[11] << 8) +
319			(match_entry[12] << 16) + ((uint64_t)match_entry[13] << 24);
320			fileofs *= 2048;
321
322			/* debug("filelen=%llx fileofs=%llx\n", (long long)filelen,
323			(long long)fileofs); */
324
325			filebuf = malloc(filelen);
326			if (filebuf == NULL) {
327			fatal("could not allocate %lli bytes to read the file"
328			" from the disk image!\n", (long long)filelen);
329			goto ret;
330			}
331
332			tmpfname = strdup("/tmp/gxemul.XXXXXXXXXXXX");
333
334			res2 = diskimage_access(m, disk_id, disk_type, 0, fileofs, filebuf,
335			filelen);
336			if (!res2) {
337			fatal("could not read the file from the disk image!\n");
338			goto ret;
339			}
340
341			tmpfile_handle = mkstemp(tmpfname);
342			if (tmpfile_handle < 0) {
343			fatal("could not create %s\n", tmpfname);
344			exit(1);
345			}
346			write(tmpfile_handle, filebuf, filelen);
347			close(tmpfile_handle);
348
349			debug("extracted %lli bytes into %s\n", (long long)filelen, tmpfname);
350
351			/* Add the temporary filename to the load_namesp array: */
352			(*n_loadp)++;
353			new_array = malloc(sizeof(char ) (*n_loadp));
354			if (new_array == NULL) {
355			fatal("out of memory\n");
356			exit(1);
357			}
358			memcpy(new_array, load_namesp, sizeof(char ) * (*n_loadp));
359			*load_namesp = new_array;
360
361			/* This adds a Backspace char in front of the filename; this
362			is a special hack which causes the file to be removed once
363			it has been loaded. */
364			tmpfname = realloc(tmpfname, strlen(tmpfname) + 2);
365			memmove(tmpfname + 1, tmpfname, strlen(tmpfname) + 1);
366			tmpfname[0] = 8;
367
368			(load_namesp)[n_loadp - 1] = tmpfname;
369
370			res = 1;
371
372			ret:
373			if (dirbuf != NULL)
374			free(dirbuf);
375
376			if (filebuf != NULL)
377			free(filebuf);
378
379			if (match_entry != NULL)
380			free(match_entry);
381
382			free(filename_orig);
383
384			debug_indentation(-iadd);
385			return res;
386			}
387