![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inffile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to inffile.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari - inffile.c
3:
4: This file is distributed under the GNU General Public License, version 2
5: or at your option any later version. Read the file gpl.txt for details.
6:
7: TOS *.INF file overloading for autostarting & TOS resolution overriding.
8: */
9: const char INFFILE_fileid[] = "Hatari inffile.c : " __DATE__ " " __TIME__;
10:
11: #include <SDL_endian.h>
12: #include <assert.h>
13: #include <errno.h>
14:
15: #include "main.h"
16: #include "configuration.h"
17: #include "inffile.h"
18: #include "options.h"
19: #include "gemdos.h"
20: #include "file.h"
21: #include "log.h"
22: #include "str.h"
23: #include "tos.h"
24: #include "vdi.h"
25:
26: /* debug output + leaves virtual INF file behind */
27: #define INF_DEBUG 0
28:
29: /* TOS resolution numbers used in Atari TOS INF files.
30: *
31: * Note: EmuTOS uses different numbers, so these are re-mapped.
32: */
33: typedef enum {
34: RES_UNSET, /* 0 */
35: RES_ST_LOW, /* 1 */
36: RES_ST_MED, /* 2 */
37: RES_ST_HIGH, /* 3 */
38: RES_TT_MED, /* 4, also Falcon 80 cols mode */
39: RES_TT_HIGH, /* 5 */
40: RES_TT_LOW, /* 6, also Falcon 40 cols mode */
41: RES_COUNT
42: } res_value_t;
43:
44:
45: static struct {
46: FILE *file; /* file pointer to contents of INF file */
47: char *prgname; /* TOS name of the program to auto start */
48: const char *infname; /* name of the INF file TOS will try to match */
49: res_value_t reso; /* resolution setting value request for #E line */
50: /* for validation */
51: int reso_id;
52: const char *reso_str;
53: int prgname_id;
54: } TosOverride;
55:
56:
57: /* autostarted program name will be added before the first
58: * '@' character in the INF files #Z line
59: * (first value is 00: TOS, 01: GEM).
60: *
61: * Resolution is specified in the 2nd hex value in #E line
62: * in normal TOS and EmuTOS <= 0.9.6, and in 4th hex value
63: * in EmuTOS >= 0.9.7. Hatari supports only latter EmuTOS
64: * versions.
65: *
66: * TOS versions expect both of these to be within certain
67: * number of bytes from the beginning of the file, and there
68: * are also TOS version specific limits on the INF file sizes.
69: *
70: * More documentation on the DESKTOP.INF file content:
71: * http://st-news.com/issues/st-news-volume-2-issue-6/education/the-desktopinf-file/
72: */
73:
74: /* EmuDesk INF file format and values differ from normal TOS */
75: static const char emudesk_inf[] =
76: "#R 01\r\n"
77: "#E 1A 61 FF 00 00\r\n"
78: "#W 00 00 02 08 26 0C 00 @\r\n"
79: "#W 00 00 02 0A 26 0C 00 @\r\n"
80: "#W 00 00 02 0D 26 0C 00 @\r\n"
81: "#W 00 00 00 00 14 0B 00 @\r\n"
82: "#W 00 00 00 00 14 0B 00 @\r\n"
83: "#W 00 00 00 00 14 0B 00 @\r\n"
84: "#M 00 00 01 FF A DISK A@ @\r\n"
85: "#M 01 00 01 FF B DISK B@ @\r\n"
86: "#M 02 00 00 FF C DISK C@ @\r\n"
87: "#F FF 07 @ *.*@ 000 @\r\n"
88: "#N FF 07 @ *.*@ 000 @\r\n"
89: "#D FF 02 @ *.*@\r\n"
90: "#Y 06 FF *.GTP@ @ 000 @\r\n"
91: "#G 06 FF *.APP@ @ 000 @\r\n"
92: "#G 06 FF *.PRG@ @ 000 @\r\n"
93: "#P 06 FF *.TTP@ @ 000 @\r\n"
94: "#F 06 FF *.TOS@ @ 000 @\r\n"
95: "#T 00 03 03 FF TRASH@ @\r\n";
96:
97: /* TOS v1.04 works only with DESKTOP.INF from that version
98: * (it crashes with newer INF after autobooted program exits),
99: * later v1.x TOS versions work also with this.
100: *
101: * Trailing spaces are significant for TOS parsing.
102: */
103: static const char desktop_inf[] =
104: "#a000000\r\n"
105: "#b000000\r\n"
106: "#c7770007000600070055200505552220770557075055507703111103\r\n"
107: "#d \r\n"
108: "#E 18 11 \r\n"
109: "#W 00 00 02 0B 26 09 00 @\r\n"
110: "#W 00 00 0A 0F 1A 09 00 @\r\n"
111: "#W 00 00 0E 01 1A 09 00 @\r\n"
112: "#M 01 00 00 FF C HARD DISK@ @ \r\n"
113: "#M 00 00 00 FF A FLOPPY DISK@ @ \r\n"
114: "#M 00 01 00 FF B FLOPPY DISK@ @ \r\n"
115: "#T 00 03 02 FF TRASH@ @ \r\n"
116: "#F FF 04 @ *.*@ \r\n"
117: "#D FF 01 @ *.*@ \r\n"
118: "#G 03 FF *.APP@ @ \r\n"
119: "#G 03 FF *.PRG@ @ \r\n"
120: "#P 03 FF *.TTP@ @ \r\n"
121: "#F 03 04 *.TOS@ @ \r\n"
122: "\032";
123:
124: /* TOS v2.x and newer have also different format, using
125: * TOS v1.04 INF file would result in bogus resolution with TOS v4
126: */
127: static const char newdesk_inf[] =
128: "#a000000\r\n"
129: "#b000000\r\n"
130: "#c7770007000600070055200505552220770557075055507703111103\r\n"
131: "#d \r\n"
132: "#K 4F 53 4C 00 46 42 43 57 45 58 00 00 00 00 00 00 00 00 00 00 00 00 00 52 00 00 4D 56 50 00 @\r\n"
133: "#E 18 01 00 06 \r\n"
134: "#Q 41 40 43 40 43 40 \r\n"
135: "#W 00 00 02 0B 26 09 00 @\r\n"
136: "#W 00 00 0A 0F 1A 09 00 @\r\n"
137: "#W 00 00 0E 01 1A 09 00 @\r\n"
138: "#W 00 00 04 07 26 0C 00 @\r\n"
139: "#W 00 00 0C 0B 26 09 00 @\r\n"
140: "#W 00 00 08 0F 1A 09 00 @\r\n"
141: "#W 00 00 06 01 1A 09 00 @\r\n"
142: "#N FF 04 000 @ *.*@ @ \r\n"
143: "#D FF 01 000 @ *.*@ @ \r\n"
144: "#G 03 FF 000 *.APP@ @ @ \r\n"
145: "#G 03 FF 000 *.PRG@ @ @ \r\n"
146: "#Y 03 FF 000 *.GTP@ @ @ \r\n"
147: "#P 03 FF 000 *.TTP@ @ @ \r\n"
148: "#F 03 04 000 *.TOS@ @ @ \r\n"
149: "#M 00 01 00 FF C HARD DISK@ @ \r\n"
150: "#M 00 00 00 FF A FLOPPY DISK@ @ \r\n"
151: "#M 01 00 00 FF B FLOPPY DISK@ @ \r\n"
152: "#T 00 03 02 FF TRASH@ @ \r\n";
153:
154:
155: /*-----------------------------------------------------------------------*/
156: /**
157: * Set name of program that will be auto started after TOS boots.
158: * Supported only from TOS 1.04 forward.
159: *
160: * If program lacks a path, "C:\" will be added.
161: *
162: * Returns true if OK, false for obviously invalid path specification.
163: */
164: bool INF_SetAutoStart(const char *name, int opt_id)
165: {
166: char *prgname;
167: int len = strlen(name);
168: char drive = toupper(name[0]);
169:
170: if (drive >= 'A' && drive <= 'Z' && name[1] == ':')
171: {
172: /* full path */
173: const char *ptr;
174: int offset;
175: prgname = malloc(len+2);
176: ptr = strrchr(name, '\\');
177: if (ptr)
178: offset = ptr - name + 1;
179: else
180: offset = 2;
181: /* copy/upcase path part */
182: memcpy(prgname, name, offset);
183: prgname[offset] = '\0';
184: Str_ToUpper(prgname);
185:
186: if (name[2] != '\\')
187: {
188: /* NOT OK: A:DIR\NAME.PRG */
189: if (ptr)
190: {
191: free(prgname);
192: return false;
193: }
194: /* A:NAME.PRG -> A:\NAME.PRG */
195: prgname[offset] = '\\';
196: /* copy/upcase file part */
197: Str_Filename2TOSname(name+offset, prgname+offset+1);
198: } else {
199: /* copy/upcase file part */
200: Str_Filename2TOSname(name+offset, prgname+offset);
201: }
202: }
203: else if (strchr(name, '\\'))
204: {
205: /* partial path not accepted */
206: return false;
207: }
208: else
209: {
210: /* just program -> add path */
211: prgname = malloc(3 + len + 1);
212: strcpy(prgname, "C:\\");
213: Str_Filename2TOSname(name, prgname+3);
214: }
215: if (TosOverride.prgname)
216: free(TosOverride.prgname);
217: TosOverride.prgname = prgname;
218: TosOverride.prgname_id = opt_id;
219: return true;
220: }
221:
222:
223: /*-----------------------------------------------------------------------*/
224: /**
225: * Set specified TOS resolution override.
226: *
227: * Return true for success, false otherwise.
228: */
229: bool INF_SetResolution(const char *str, int opt_id)
230: {
231: int reso;
232:
233: /* map to values used by real TOS INF files */
234: if (strcmp(str, "low") == 0)
235: reso = RES_ST_LOW;
236: else if (strcmp(str, "med") == 0)
237: reso = RES_ST_MED;
238: else if (strcmp(str, "high") == 0)
239: reso = RES_ST_HIGH;
240: else if (strcmp(str, "ttmed") == 0)
241: reso = RES_TT_MED;
242: else if (strcmp(str, "ttlow") == 0)
243: reso = RES_TT_LOW;
244: else
245: {
246: reso = atoi(str);
247: if (reso <= RES_UNSET || reso >= RES_COUNT)
248: return false;
249: }
250: TosOverride.reso = reso;
251: TosOverride.reso_id = opt_id;
252: TosOverride.reso_str = str;
253: return true;
254: }
255:
256:
257: /*-----------------------------------------------------------------------*/
258: /**
259: * Validate autostart options against Hatari settings:
260: * - program drive
261: *
262: * If there's a problem, return problematic option ID
263: * and set val & err strings, otherwise just return zero.
264: */
265: int INF_ValidateAutoStart(const char **val, const char **err)
266: {
267: const char *path = TosOverride.prgname;
268: char drive;
269:
270: if (!path)
271: return 0;
272:
273: /* validate autostart program drive */
274: drive = path[0];
275:
276: if (drive == 'A')
277: {
278: if (ConfigureParams.DiskImage.EnableDriveA && ConfigureParams.DiskImage.szDiskFileName[0][0])
279: return 0;
280: }
281: else if (drive == 'B')
282: {
283: if (ConfigureParams.DiskImage.EnableDriveB && ConfigureParams.DiskImage.szDiskFileName[1][0])
284: return 0;
285: }
286: /* exact drive checking for hard drives would require:
287: *
288: * For images:
289: * - finding out what partitions each of the IDE master &
290: * Slave, 8 ACSI, and 8 SCSI images do have, *and*
291: * - finding out which of those partitions the native Atari
292: * harddisk driver happens to support...
293: * -> not feasible
294: *
295: * For GEMDOS HD:
296: * - If multiple partitions are specified, which ones
297: * - If not, what is the single partition drive letter
298: *
299: * So, just check that some harddisk is enabled for C: ->
300: */
301:
302: /* GEMDOS HD */
303: else if (ConfigureParams.HardDisk.bUseHardDiskDirectories && ConfigureParams.HardDisk.szHardDiskDirectories[0][0])
304: {
305: return 0;
306: }
307: /* IDE */
308: else if (ConfigureParams.HardDisk.bUseIdeMasterHardDiskImage && ConfigureParams.HardDisk.szIdeMasterHardDiskImage[0])
309: {
310: return 0;
311: }
312: else if (ConfigureParams.HardDisk.bUseIdeMasterHardDiskImage && ConfigureParams.HardDisk.szIdeMasterHardDiskImage[0])
313: {
314: return 0;
315: }
316: else
317: {
318: /* ACSI / SCSI */
319: int i;
320: for (i = 0; i < MAX_ACSI_DEVS; i++)
321: {
322: if (ConfigureParams.Acsi[i].bUseDevice && ConfigureParams.Acsi[i].sDeviceFile[0])
323: return 0;
324: if (ConfigureParams.Scsi[i].bUseDevice && ConfigureParams.Scsi[i].sDeviceFile[0])
325: return 0;
326: }
327: }
328: /* error */
329: *val = TosOverride.prgname;
330: *err = "Required autostart drive isn't enabled";
331: return TosOverride.prgname_id;
332: }
333:
334:
335: /**
336: * Map / set VDI to INF file resolution
337: */
338: static res_value_t vdi2inf(res_value_t mode)
339: {
340: res_value_t res = TosOverride.reso;
341: res_value_t newres = mode + 1;
342: if (res != newres)
343: {
344: if (res)
345: Log_Printf(LOG_WARN, "Overriding TOS resolution %d with VDI resolution %d.\n",
346: res, newres);
347: res = newres;
348: }
349: return res;
350: }
351:
352: /**
353: * Map / set VDI to INF file resolution
354: */
355: extern void INF_SetVdiMode(int vdi_res)
356: {
357: TosOverride.reso = vdi2inf(vdi_res);
358: }
359:
360:
361: /**
362: * Resolution needs to be validated later, here, because we don't
363: * know the final machine type when options are parsed, as it can
364: * change later when TOS is loaded.
365: *
366: * Resolution settings are:
367: * 0: no override
368: * 1-3: ST/STE resolutions:
369: * - ST low, med, high
370: * 4-6: TT/Falcon resolutions:
371: * - TT med, high, low
372: * - Falcon 80 cols, N/A, 40 cols
373: *
374: * If there's a problem, return problematic option ID
375: * and set val & err strings, otherwise just return zero.
376: */
377: static int INF_ValidateResolution(int *set_res, const char **val, const char **err)
378: {
379: res_value_t res = TosOverride.reso;
380: *set_res = 0;
381:
382: /* VDI resolution overrides TOS resolution setting */
383: if (bUseVDIRes)
384: {
385: res = vdi2inf(VDIRes);
386: }
387: else
388: {
389: int monitor = ConfigureParams.Screen.nMonitorType;
390:
391: /* validate given TOS resolution */
392: if (!res)
393: return 0;
394:
395: *val = TosOverride.reso_str;
396:
397: switch(ConfigureParams.System.nMachineType)
398: {
399: case MACHINE_STE:
400: case MACHINE_MEGA_STE:
401: case MACHINE_ST:
402: case MACHINE_MEGA_ST:
403: if (monitor == MONITOR_TYPE_MONO && res != RES_ST_HIGH)
404: {
405: res = RES_ST_HIGH;
406: Log_Printf(LOG_WARN, "With mono monitor, TOS can use only mono resolution, correcting.\n");
407: }
408: else if (res >= RES_ST_HIGH)
409: {
410: *err = "invalid ST/STE color TOS resolution";
411: return TosOverride.reso_id;
412: }
413: break;
414:
415: case MACHINE_TT:
416: if (monitor == MONITOR_TYPE_MONO && res != RES_TT_HIGH)
417: {
418: res = RES_TT_HIGH;
419: Log_Printf(LOG_WARN, "With mono monitor, TOS can use only mono resolution, correcting.\n");
420: }
421: else if (res == RES_TT_HIGH)
422: {
423: *err = "invalid TT color TOS resolution";
424: return TosOverride.reso_id;
425: }
426: break;
427:
428: case MACHINE_FALCON:
429: if (monitor == MONITOR_TYPE_MONO && res != RES_ST_HIGH)
430: {
431: res = RES_ST_HIGH;
432: Log_Printf(LOG_WARN, "With mono monitor, TOS can use only mono resolution, correcting.\n");
433: }
434: else if (res == RES_TT_HIGH)
435: {
436: *err = "TT-mono is invalid Falcon TOS resolution";
437: return TosOverride.reso_id;
438: }
439: else
440: {
441: Log_Printf(LOG_WARN, "TOS resolution setting doesn't work with Falcon (yet)\n");
442: }
443: /* TODO:
444: * Falcon resolution setting doesn't have effect,
445: * seems that #E Falcon settings in columns 6 & 7
446: * are also needed:
447: * - line doubling / interlace
448: * - ST compat, RGB/VGA, columns & #colors
449: */
450: break;
451: }
452: }
453:
454: if (bIsEmuTOS)
455: {
456: /* map values 0-6: N/A, ST low, med, high, TT med, high, low */
457: unsigned char map[] = { 0, 0, 1, 2, 4, 6, 7 };
458: res = map[res];
459: Log_Printf(LOG_INFO, "Remapped TOS resolution for EmuTOS.\n");
460: }
461: else if (TosVersion >= 0x0160)
462: {
463: switch(ConfigureParams.System.nMachineType)
464: {
465: case MACHINE_STE:
466: case MACHINE_MEGA_STE:
467: case MACHINE_FALCON:
468: /* enable blitter */
469: res |= 0x10;
470: break;
471: default:
472: break;
473: }
474: }
475:
476: Log_Printf(LOG_INFO, "Resulting INF file TOS resolution: 0x%02x -> 0x%02x.\n", TosOverride.reso, res);
477: *set_res = res;
478: return 0;
479: }
480:
481:
482: /*-----------------------------------------------------------------------*/
483: /**
484: * Get builtin INF file contents which open window for the boot drive,
485: * if any.
486: *
487: * NOTE: this won't work for EmuTOS because it opens INF file second
488: * time to read window info, at which point the temporary virtual INF
489: * file has already disappeared. Real TOS versions read INF file
490: * only once and work fine.
491: */
492: static char *get_builtin_inf(const char *contents)
493: {
494: /* line to open window (for boot drive) */
495: static const char drivewin[] = "#W 00 00 02 06 26 0C 00 X:\\*.*@\r\n";
496: int winlen, inflen, winoffset1, winoffset2, driveoffset;
497: const char *winline;
498: char *inf;
499:
500: assert(contents);
501:
502: inflen = strlen(contents);
503: winlen = strlen(drivewin);
504: inf = malloc(inflen + winlen + 1);
505: assert(inf);
506:
507: /* drive letter offset on drive window line */
508: driveoffset = strchr(drivewin, 'X') - drivewin;
509:
510: /* first copy everything until first window line */
511: winline = strstr(contents, "#W");
512: assert(winline);
513: winoffset2 = winoffset1 = winline - contents;
514: memcpy(inf, contents, winoffset1);
515:
516: /* then comes boot drive window line, if any */
517: if (ConfigureParams.HardDisk.bBootFromHardDisk)
518: {
519: /* C:, ignore IDE/ACSI for now */
520: if (GemDOS_IsDriveEmulated(2))
521: {
522: strcpy(inf + winoffset1, drivewin);
523: inf[winoffset1 + driveoffset] = 'C';
524: winoffset2 += winlen;
525: }
526: }
527: else if (ConfigureParams.DiskImage.EnableDriveA && ConfigureParams.DiskImage.szDiskFileName[0][0])
528: {
529: /* A: */
530: strcpy(inf + winoffset1, drivewin);
531: inf[winoffset1 + driveoffset] = 'A';
532: winoffset2 += winlen;
533: }
534: /* finally copy rest */
535: strcpy(inf + winoffset2, contents + winoffset1);
536:
537: return inf;
538: }
539:
540: /**
541: * Get suitable Atari desktop configuration file for current TOS version,
542: * either by loading existing file, or creating default one if there isn't
543: * a pre-existing one.
544: *
545: * Return INF file contents and set its name & size to args.
546: */
547: static char *get_inf_file(const char **set_infname, int *set_size, int *res_col)
548: {
549: char *hostname;
550: const char *contents, *infname;
551: Uint8 *host_content;
552: long host_size;
553: int size;
554:
555: /* default position of the 2 digit hex code for resolution on #E line */
556: *res_col = 6;
557:
558: /* infname needs to be exactly the same string that given
559: * TOS version gives for GEMDOS to find.
560: */
561: if (bIsEmuTOS)
562: {
563: if (ConfigureParams.HardDisk.bBootFromHardDisk)
564: infname = "C:\\EMUDESK.INF";
565: else
566: infname = "A:\\EMUDESK.INF";
567: size = sizeof(emudesk_inf);
568: contents = emudesk_inf;
569: *res_col = 12;
570: }
571: /* need to match file TOS searches first */
572: else if (TosVersion >= 0x0200)
573: {
574: infname = "NEWDESK.INF";
575: size = sizeof(newdesk_inf);
576: contents = newdesk_inf;
577: }
578: else
579: {
580: infname = "DESKTOP.INF";
581: size = sizeof(desktop_inf);
582: contents = desktop_inf;
583: }
584: *set_infname = infname;
585: *set_size = size;
586:
587: /* Existing INF can be modified only through GEMDOS hard disk,
588: * i.e. boot needs to be from C:, which needs to be GEMDOS HD
589: */
590: if (!(ConfigureParams.HardDisk.bBootFromHardDisk && GemDOS_IsDriveEmulated(2)))
591: {
592: #if INF_DEBUG
593: fprintf(stderr, "No GEMDOS HD boot drive, using builtin INF autostart file.\n");
594: #endif
595: return get_builtin_inf(contents);
596: }
597:
598: hostname = malloc(FILENAME_MAX);
599: assert(hostname);
600:
601: /* convert to host file name, and read that */
602: GemDOS_CreateHardDriveFileName(2, infname, hostname, FILENAME_MAX);
603: #if INF_DEBUG
604: GemDOS_Info(stderr, 0);
605: fprintf(stderr, "\nChecking for existing INF file '%s' -> '%s'...\n", infname, hostname);
606: #endif
607: host_content = File_Read(hostname, &host_size, NULL);
608:
609: if (host_content)
610: {
611: Log_Printf(LOG_INFO, "Going to modify '%s'.\n", hostname);
612: free(hostname);
613: *set_size = host_size;
614: return (char *)host_content;
615: }
616: Log_Printf(LOG_INFO, "Using builtin '%s'.\n", infname);
617: free(hostname);
618: return get_builtin_inf(contents);
619: }
620:
621:
622: /*-----------------------------------------------------------------------*/
623: /**
624: * Skip rest of INF file line.
625: * Return index after its end, or zero for error.
626: */
627: static int skip_line(const char *contents, int offset, int size)
628: {
629: int orig = offset;
630: char chr;
631:
632: for (; offset < size; offset++)
633: {
634: chr = contents[offset];
635: if (chr == '\r' || chr == '\n')
636: {
637: chr = contents[++offset];
638: if (chr == '\r' || chr == '\n')
639: offset++;
640: return offset;
641: }
642: }
643: Log_Printf(LOG_WARN, "Malformed INF file '%s', no line end at offsets %d-%d!\n",
644: TosOverride.prgname, orig, offset);
645: return 0;
646: }
647:
648: /**
649: * Return INF file autostart line format suitable for given
650: * program type, based on program name extension.
651: */
652: static const char *prg_format(const char *prgname)
653: {
654: const char *ext;
655: int size;
656:
657: size = strlen(prgname);
658: if (size > 4)
659: ext = prgname + size - 4;
660: else
661: ext = prgname;
662:
663: if (strcmp(ext, ".TTP") == 0 ||strcmp(ext, ".TOS") == 0)
664: return "#Z 00 %s@ \r\n"; /* TOS program */
665: else
666: return "#Z 01 %s@ \r\n"; /* GEM program */
667: }
668:
669: /**
670: * Create modified, temporary INF file that contains the required
671: * autostart and resolution information.
672: *
673: * Return FILE* pointer to it.
674: */
675: static FILE* write_inf_file(const char *contents, int size, int res, int res_col)
676: {
677: const char *infname, *prgname, *format = NULL;
678: int offset, off_prg, off_rez, endcheck;
679: FILE *fp;
680:
681: #if defined(WIN32) /* unfortunately tmpfile() needs administrative privileges on windows, so this needs special care */
682: char *ptr = WinTmpFile();
683: if (ptr != NULL)
684: fp = fopen(ptr,"w+b");
685: else
686: fp = NULL;
687: #else
688: # if INF_DEBUG
689: {
690: const char *debugfile = "/tmp/hatari-desktop-inf.txt";
691: fprintf(stderr, "Virtual INF file: '%s'\n", debugfile);
692: fp = fopen(debugfile, "w+b");
693: }
694: # else
695: fp = tmpfile();
696: # endif
697: #endif
698: prgname = TosOverride.prgname;
699: infname = TosOverride.infname;
700:
701: if (!fp)
702: {
703: Log_Printf(LOG_ERROR, "Failed to create virtual INF file '%s': %s!\n",
704: infname, strerror(errno));
705: return NULL;
706: }
707:
708: if (prgname)
709: format = prg_format(prgname);
710:
711: /* need to fit at least 2 res digits + \r\n */
712: endcheck = size-res_col-2-2;
713: /* positions after prog info & resolution info */
714: off_prg = off_rez = 0;
715: /* find where to insert the program name and resolution */
716: for (offset = 0; offset < endcheck; offset++)
717: {
718: if (contents[offset] != '#')
719: continue;
720:
721: /* replace autostart line only when requested */
722: if (prgname && contents[offset+1] == 'Z')
723: {
724: fwrite(contents+off_prg, offset-off_prg, 1, fp);
725: /* write only first #Z line, skip rest */
726: if (!off_prg)
727: fprintf(fp, format, prgname);
728: offset = skip_line(contents, offset, size-1);
729: if (!offset)
730: break;
731: off_prg = offset;
732: }
733: /* resolution line always written */
734: if (contents[offset+1] == 'E')
735: {
736: fwrite(contents+off_prg, offset-off_prg, 1, fp);
737: /* INF file with autostart line missing?
738: *
739: * It's assumed that #Z is always before #E,
740: * if it exits. So write one when requested,
741: * if it hasn't been written yet.
742: */
743: if (prgname && !off_prg)
744: {
745: off_prg = offset;
746: fprintf(fp, format, prgname);
747: }
748: /* write #E line start */
749: fwrite(contents+offset, res_col, 1, fp);
750: /* write requested resolution, or default?
751: *
752: * (TosOverride.reso tells if there's request,
753: * 'res' tells the actual value to use)
754: */
755: if (TosOverride.reso)
756: fprintf(fp, "%02x", res);
757: else
758: fwrite(contents+offset+res_col, 2, 1, fp);
759: /* set point to rest of #E */
760: offset += res_col + 2;
761: off_rez = offset;
762: break;
763: }
764: }
765: if (!off_rez)
766: {
767: fclose(fp);
768: Log_Printf(LOG_ERROR, "'%s' not a valid INF file, #E resolution line missing -> autostarting / resolution overriding not possible!\n", infname);
769: return NULL;
770: }
771: /* write rest of INF file & seek back to start */
772: if (!(fwrite(contents+offset, size-offset-1, 1, fp) && fseek(fp, 0, SEEK_SET) == 0))
773: {
774: fclose(fp);
775: Log_Printf(LOG_ERROR, "Virtual '%s' file writing failed!\n", infname);
776: return NULL;
777: }
778: if (prgname)
779: Log_Printf(LOG_WARN, "Virtual '%s' autostart file created for '%s'.\n", infname, prgname);
780: else
781: Log_Printf(LOG_WARN, "Virtual '%s' TOS resolution override file created.\n", infname);
782: return fp;
783: }
784:
785:
786: /*-----------------------------------------------------------------------*/
787: /**
788: * Create a temporary TOS INF file for autostarting and resolution overriding.
789: *
790: * File has TOS version specific differences, so it needs to be re-created
791: * on each boot in case user changed TOS version.
792: *
793: * Called at end of TOS ROM loading.
794: */
795: void INF_CreateOverride(void)
796: {
797: char *contents;
798: const char *err, *val;
799: int size, res, res_col, opt_id;
800:
801: if ((opt_id = INF_ValidateResolution(&res, &val, &err)))
802: {
803: Opt_ShowError(opt_id, val, err);
804: bQuitProgram = true;
805: return;
806: }
807:
808: /* in case TOS didn't for some reason close it on previous boot */
809: INF_CloseOverride(TosOverride.file);
810:
811: /* INF overriding needed? */
812: if (!(TosOverride.prgname || TosOverride.reso))
813: return;
814:
815: /* GEMDOS HD / INF overriding not supported? */
816: if (TosVersion < 0x0104)
817: {
818: Log_Printf(LOG_WARN, "Only TOS versions >= 1.04 support autostarting & resolution overriding!\n");
819: return;
820: }
821:
822: contents = get_inf_file(&TosOverride.infname, &size, &res_col);
823: if (contents)
824: {
825: TosOverride.file = write_inf_file(contents, size, res, res_col);
826: free(contents);
827: }
828: }
829:
830:
831: /*-----------------------------------------------------------------------*/
832: /**
833: * Whether INF file overriding needs GEMDOS
834: * interception or Fopen() check enabling
835: */
836: bool INF_Overriding(autostart_t t)
837: {
838: if (t == AUTOSTART_FOPEN)
839: return (bool)TosOverride.file;
840: return (((bool)TosOverride.prgname) || ((bool)TosOverride.reso));
841: }
842:
843: /*-----------------------------------------------------------------------*/
844: /**
845: * If given name matches virtual INF file name, return its handle, NULL otherwise
846: */
847: FILE *INF_OpenOverride(const char *filename)
848: {
849: if (TosOverride.file && strcmp(filename, TosOverride.infname) == 0)
850: {
851: /* whether to "autostart" also exception debugging? */
852: if (ConfigureParams.Debugger.nExceptionDebugMask & EXCEPT_AUTOSTART)
853: {
854: ExceptionDebugMask = ConfigureParams.Debugger.nExceptionDebugMask & ~EXCEPT_AUTOSTART;
855: fprintf(stderr, "Exception debugging enabled (0x%x).\n", ExceptionDebugMask);
856: }
857: Log_Printf(LOG_WARN, "Virtual INF file '%s' matched.\n", filename);
858: return TosOverride.file;
859: }
860: return NULL;
861: }
862:
863: /*-----------------------------------------------------------------------*/
864: /**
865: * If given handle matches virtual INF file, close it and return true,
866: * false otherwise.
867: */
868: bool INF_CloseOverride(FILE *fp)
869: {
870: if (fp && fp == TosOverride.file)
871: {
872: /* Remove virtual INF file after TOS has
873: * read it enough times to do autostarting etc.
874: * Otherwise user may try change desktop settings
875: * and save them, but they would be lost.
876: */
877: fclose(TosOverride.file);
878: TosOverride.file = NULL;
879: Log_Printf(LOG_WARN, "Virtual INF file removed.\n");
880: return true;
881: }
882: return false;
883: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.