![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rommgr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to rommgr.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * ROM file management
5: *
6: * (c) 1995 Bernd Schmidt
7: */
8:
9: #include "sysconfig.h"
10: #include "sysdeps.h"
11:
12: #include "options.h"
13: #include "uae.h"
14: #include "memory.h"
15: #include "romlist.h"
16: #include "zfile.h"
17: #include "gui.h"
18: #include "crc32.h"
19:
20: static int is_encrypted_rom (uae_u8 *data, int size)
21: {
22: return size > 11 && !memcmp (data, "AMIROMTYPE1", 11);
23: }
24:
25: static struct romlist *list_of_roms;
26: static int romlist_cnt;
27:
28: void romlist_add (char *path, struct romdata *rd, int loc)
29: {
30: struct romlist *rl2;
31:
32: romlist_cnt++;
33: list_of_roms = realloc (list_of_roms, sizeof (struct romlist) * romlist_cnt);
34: rl2 = list_of_roms + romlist_cnt - 1;
35: rl2->path = my_strdup (path);
36: rl2->rd = rd;
37: rl2->loc = loc;
38: }
39:
40: char *romlist_get (struct romdata *rd)
41: {
42: int i;
43:
44: if (!rd)
45: return 0;
46: for (i = 0; i < romlist_cnt; i++) {
47: if (list_of_roms[i].rd == rd)
48: return list_of_roms[i].path;
49: }
50: return 0;
51: }
52:
53: struct romlist *romlist_from_idx (int idx, int type, int need_crc32)
54: {
55: int i;
56: for (i = 0; i < romlist_cnt; i++) {
57: if (!list_of_roms[i].rd)
58: continue;
59:
60: if (list_of_roms[i].rd->type != type || (!list_of_roms[i].rd->crc32 && need_crc32))
61: continue;
62:
63: if (idx == 0)
64: return list_of_roms + i;
65: idx--;
66: }
67: return 0;
68: }
69:
70: static void sort_romlist (void)
71: {
72: int i, j;
73: for (i = 0; i < romlist_cnt; i++) {
74: int k = i;
75:
76: if (list_of_roms[i].rd == 0)
77: continue;
78:
79: for (j = i + 1; j < romlist_cnt; j++) {
80: if (list_of_roms[j].rd == 0)
81: continue;
82: if (list_of_roms[j].rd == list_of_roms[k].rd
83: && list_of_roms[j].loc == ROMLOC_USER)
84: k = j;
85: else if (strcmp (list_of_roms[j].rd->name, list_of_roms[k].rd->name) < 0)
86: k = j;
87: }
88: if (k != i) {
89: struct romlist t;
90: t = list_of_roms[k];
91: list_of_roms[k] = list_of_roms[i];
92: list_of_roms[i] = t;
93: }
94: }
95: /* Delete duplicates from the user directory. */
96: for (i = j = 0; i < romlist_cnt; i++) {
97: if (!list_of_roms[i].rd
98: || i + 1 > romlist_cnt
99: || list_of_roms[i].rd != list_of_roms[i + 1].rd
100: || list_of_roms[i].loc == ROMLOC_SYSTEM)
101: {
102: if (i != j)
103: list_of_roms[j] = list_of_roms[i];
104: j++;
105: }
106: }
107: romlist_cnt = j;
108: }
109:
110: void romlist_clear (int mask)
111: {
112: int i, j;
113: for (i = j = 0; i < romlist_cnt; i++) {
114: if ((list_of_roms[i].loc & mask) == 0) {
115: if (i != j)
116: list_of_roms[j] = list_of_roms[i];
117: j++;
118: }
119: }
120: romlist_cnt = j;
121: list_of_roms = realloc (list_of_roms, sizeof (struct romlist) * j);
122: }
123:
124: struct romdata *getromdatabypath(char *path)
125: {
126: int i;
127: for (i = 0; i < romlist_cnt; i++) {
128: struct romdata *rd = list_of_roms[i].rd;
129: if (rd->configname && path[0] == ':') {
130: if (!strcmp(path + 1, rd->configname))
131: return rd;
132: }
133: if (!strcmp(list_of_roms[i].path, path))
134: return list_of_roms[i].rd;
135: }
136: return NULL;
137: }
138:
139: #define NEXT_ROM_ID 68
140:
141: static struct romheader romheaders[] = {
142: { "Freezer Cartridges", 1 },
143: { "Arcadia Games", 2 },
144: { NULL, 0 }
145: };
146:
147: static struct romdata roms[] = {
148: { "Cloanto Amiga Forever ROM key", 0, 0, 0, 0, 0, 2069, 0, 0, 1, ROMTYPE_KEY, 0,
149: 0x869ae1b1, 0x801bbab3,0x2e3d3738,0x6dd1636d,0x4f1d6fa7,0xe21d5874, NULL },
150: { "Cloanto Amiga Forever 2006 ROM key", 0, 0, 0, 0, 0, 750, 48, 0, 1, ROMTYPE_KEY, 0,
151: 0xb01c4b56, 0xbba8e5cd,0x118b8d92,0xafed5693,0x5eeb9770,0x2a662d8f, NULL },
152:
153: { "KS ROM v1.0 (A1000)(NTSC)", 1, 0, 1, 0, "A1000\0", 262144, 1, 0, 0, ROMTYPE_KICK, 0,
154: 0x299790ff, 0x00C15406,0xBEB4B8AB,0x1A16AA66,0xC05860E1,0xA7C1AD79, NULL },
155: { "KS ROM v1.1 (A1000)(NTSC)", 1, 1, 31, 34, "A1000\0", 262144, 2, 0, 0, ROMTYPE_KICK, 0,
156: 0xd060572a, 0x4192C505,0xD130F446,0xB2ADA6BD,0xC91DAE73,0x0ACAFB4C, NULL },
157: { "KS ROM v1.1 (A1000)(PAL)", 1, 1, 31, 34, "A1000\0", 262144, 3, 0, 0, ROMTYPE_KICK, 0,
158: 0xec86dae2, 0x16DF8B5F,0xD524C5A1,0xC7584B24,0x57AC15AF,0xF9E3AD6D, NULL },
159: { "KS ROM v1.2 (A1000)", 1, 2, 33, 166, "A1000\0", 262144, 4, 0, 0, ROMTYPE_KICK, 0,
160: 0x9ed783d0, 0x6A7BFB5D,0xBD6B8F17,0x9F03DA84,0xD8D95282,0x67B6273B, NULL },
161: { "KS ROM v1.2 (A500,A1000,A2000)", 1, 2, 33, 180, "A500\0A1000\0A2000\0", 262144, 5, 0, 0, ROMTYPE_KICK, 0,
162: 0xa6ce1636, 0x11F9E62C,0xF299F721,0x84835B7B,0x2A70A163,0x33FC0D88, NULL },
163: { "KS ROM v1.3 (A500,A1000,A2000)", 1, 3, 34, 5, "A500\0A1000\0A2000\0", 262144, 6, 0, 0, ROMTYPE_KICK, 0,
164: 0xc4f0f55f, 0x891E9A54,0x7772FE0C,0x6C19B610,0xBAF8BC4E,0xA7FCB785, NULL },
165: { "KS ROM v1.3 (A3000)(SK)", 1, 3, 34, 5, "A3000\0", 262144, 32, 0, 0, ROMTYPE_KICK, 0,
166: 0xe0f37258, 0xC39BD909,0x4D4E5F4E,0x28C1411F,0x30869504,0x06062E87, NULL },
167: { "KS ROM v1.4 (A3000)", 1, 4, 36, 16, "A3000\0", 524288, 59, ROMREQ_68030, 0, ROMTYPE_KICK, 0,
168: 0xbc0ec13f, 0xF76316BF,0x36DFF14B,0x20FA349E,0xD02E4B11,0xDD932B07, NULL },
169:
170: { "KS ROM v2.04 (A500+)", 2, 4, 37, 175, "A500+\0", 524288, 7, 0, 0, ROMTYPE_KICK, 0,
171: 0xc3bdb240, 0xC5839F5C,0xB98A7A89,0x47065C3E,0xD2F14F5F,0x42E334A1, NULL },
172: { "KS ROM v2.05 (A600)", 2, 5, 37, 299, "A600\0", 524288, 8, 0, 0, ROMTYPE_KICK, 0,
173: 0x83028fb5, 0x87508DE8,0x34DC7EB4,0x7359CEDE,0x72D2E3C8,0xA2E5D8DB, NULL },
174: { "KS ROM v2.05 (A600HD)", 2, 5, 37, 300, "A600HD\0A600\0", 524288, 9, 0, 0, ROMTYPE_KICK, 0,
175: 0x64466c2a, 0xF72D8914,0x8DAC39C6,0x96E30B10,0x859EBC85,0x9226637B, NULL },
176: { "KS ROM v2.05 (A600HD)", 2, 5, 37, 350, "A600HD\0A600\0", 524288, 10, 0, 0, ROMTYPE_KICK, 0,
177: 0x43b0df7b, 0x02843C42,0x53BBD29A,0xBA535B0A,0xA3BD9A85,0x034ECDE4, NULL },
178:
179: { "KS ROM v3.0 (A1200)", 3, 0, 39, 106, "A1200\0", 524288, 11, 0, 0, ROMTYPE_KICK, 0,
180: 0x6c9b07d2, 0x70033828,0x182FFFC7,0xED106E53,0x73A8B89D,0xDA76FAA5, NULL },
181: { "KS ROM v3.0 (A4000)", 3, 0, 39, 106, "A4000\0", 524288, 12, ROMREQ_A4000, 0, ROMTYPE_KICK, 0,
182: 0x9e6ac152, 0xF0B4E9E2,0x9E12218C,0x2D5BD702,0x0E4E7852,0x97D91FD7, NULL },
183: { "KS ROM v3.1 (A4000)", 3, 1, 40, 70, "A4000\0", 524288, 13, ROMREQ_A4000, 0, ROMTYPE_KICK, 0,
184: 0x2b4566f1, 0x81c631dd,0x096bbb31,0xd2af9029,0x9c76b774,0xdb74076c, NULL },
185: { "KS ROM v3.1 (A500,A600,A2000)", 3, 1, 40, 63, "A500\0A600\0A2000\0", 524288, 14, 0, 0, ROMTYPE_KICK, 0,
186: 0xfc24ae0d, 0x3B7F1493,0xB27E2128,0x30F989F2,0x6CA76C02,0x049F09CA, NULL },
187: { "KS ROM v3.1 (A1200)", 3, 1, 40, 68, "A1200\0", 524288, 15, ROMREQ_68EC020, 0, ROMTYPE_KICK, 0,
188: 0x1483a091, 0xE2154572,0x3FE8374E,0x91342617,0x604F1B3D,0x703094F1, NULL },
189: { "KS ROM v3.1 (A3000)", 3, 1, 40, 68, "A3000\0", 524288, 61, ROMREQ_68020, 0, ROMTYPE_KICK, 0,
190: 0xefb239cc, 0xF8E210D7,0x2B4C4853,0xE0C9B85D,0x223BA20E,0x3D1B36EE, NULL },
191: { "KS ROM v3.1 (A4000)(Cloanto)", 3, 1, 40, 68, "A4000\0", 524288, 31, ROMREQ_A4000, 1, ROMTYPE_KICK, 0,
192: 0x43b6dd22, 0xC3C48116,0x0866E60D,0x085E436A,0x24DB3617,0xFF60B5F9, NULL },
193: { "KS ROM v3.1 (A4000)", 3, 1, 40, 68, "A4000\0", 524288, 16, ROMREQ_A4000, 0, ROMTYPE_KICK, 0,
194: 0xd6bae334, 0x5FE04842,0xD04A4897,0x20F0F4BB,0x0E469481,0x99406F49, NULL },
195: { "KS ROM v3.1 (A4000T)", 3, 1, 40, 70, "A4000T\0", 524288, 17, ROMREQ_A4000, 0, ROMTYPE_KICK, 0,
196: 0x75932c3a, 0xB0EC8B84,0xD6768321,0xE01209F1,0x1E6248F2,0xF5281A21, NULL },
197: { "KS ROM v3.X (A4000)(Cloanto)", 3, 10, 45, 57, "A4000\0", 524288, 46, ROMREQ_A4000, 0, ROMTYPE_KICK, 0,
198: 0x08b69382, 0x81D3AEA3,0x0DB7FBBB,0x4AFEE41C,0x21C5ED66,0x2B70CA53, NULL },
199:
200: { "CD32 KS ROM v3.1", 3, 1, 40, 60, "CD32\0", 524288, 18, ROMREQ_68EC020, 0, ROMTYPE_KICKCD32, 0,
201: 0x1e62d4a5, 0x3525BE88,0x87F79B59,0x29E017B4,0x2380A79E,0xDFEE542D, NULL },
202: { "CD32 extended ROM", 3, 1, 40, 60, "CD32\0", 524288, 19, ROMREQ_68EC020, 0, ROMTYPE_EXTCD32, 0,
203: 0x87746be2, 0x5BEF3D62,0x8CE59CC0,0x2A66E6E4,0xAE0DA48F,0x60E78F7F, NULL },
204: { "CD32 ROM (KS + extended)", 3, 1, 40, 60, "CD32\0", 2 * 524288, 64, ROMREQ_68EC020, 0, ROMTYPE_KICKCD32, 0,
205: 0xd3837ae4, 0x06807db3,0x18163745,0x5f4d4658,0x2d9972af,0xec8956d9, NULL },
206:
207: { "CDTV extended ROM v1.00", 1, 0, 1, 0, "CDTV\0", 262144, 20, 0, 0, ROMTYPE_EXTCDTV, 0,
208: 0x42baa124, 0x7BA40FFA,0x17E500ED,0x9FED041F,0x3424BD81,0xD9C907BE, NULL },
209: { "CDTV extended ROM v2.07", 2, 7, 2, 7, "CDTV\0", 262144, 22, 0, 0, ROMTYPE_EXTCDTV, 0,
210: 0xceae68d2, 0x5BC114BB,0xA29F60A6,0x14A31174,0x5B3E2464,0xBFA06846, NULL },
211: { "CDTV extended ROM v2.30", 2, 30, 2, 30, "CDTV\0", 262144, 21, 0, 0, ROMTYPE_EXTCDTV, 0,
212: 0x30b54232, 0xED7E461D,0x1FFF3CDA,0x321631AE,0x42B80E3C,0xD4FA5EBB, NULL },
213:
214: { "A1000 bootstrap ROM", 0, 0, 0, 0, "A1000\0", 8192, 23, ROMREQ_A1000, 0, ROMTYPE_KICK, 0,
215: 0x62f11c04, 0xC87F9FAD,0xA4EE4E69,0xF3CCA0C3,0x6193BE82,0x2B9F5FE6, NULL },
216: { "A1000 bootstrap ROM", 0, 0, 0, 0, "A1000\0", 65536, 24, ROMREQ_A1000, 0, ROMTYPE_KICK, 0,
217: 0x0b1ad2d0, 0xBA93B8B8,0x5CA0D83A,0x68225CC3,0x3B95050D,0x72D2FDD7, NULL },
218:
219: { "Freezer: Action Replay Mk I v1.00", 1, 0, 1, 0, "AR\0", 65536, 52, 0, 0, ROMTYPE_AR, 1,
220: 0x2d921771, 0x1EAD9DDA,0x2DAD2914,0x6441F5EF,0x72183750,0x22E01248, NULL },
221: { "Freezer: Action Replay Mk I v1.50", 1, 50, 1, 50, "AR\0", 65536, 25, 0, 0, ROMTYPE_AR, 1,
222: 0xd4ce0675, 0x843B433B,0x2C56640E,0x045D5FDC,0x854DC6B1,0xA4964E7C, NULL },
223: { "Freezer: Action Replay Mk II v2.05", 2, 5, 2, 5, "AR\0", 131072, 26, 0, 0, ROMTYPE_AR, 1,
224: 0x1287301f, 0xF6601DE8,0x888F0050,0x72BF562B,0x9F533BBC,0xAF1B0074, NULL },
225: { "Freezer: Action Replay Mk II v2.12", 2, 12, 2, 12, "AR\0", 131072, 27, 0, 0, ROMTYPE_AR, 1,
226: 0x804d0361, 0x3194A07A,0x0A82D8B5,0xF2B6AEFA,0x3CA581D6,0x8BA8762B, NULL },
227: { "Freezer: Action Replay Mk II v2.14", 2, 14, 2, 14, "AR\0", 131072, 28, 0, 0, ROMTYPE_AR, 1,
228: 0x49650e4f, 0x255D6DF6,0x3A4EAB0A,0x838EB1A1,0x6A267B09,0x59DFF634, NULL },
229: { "Freezer: Action Replay Mk III v3.09", 3, 9, 3, 9, "AR\0", 262144, 29, 0, 0, ROMTYPE_AR, 1,
230: 0x0ed9b5aa, 0x0FF3170A,0xBBF0CA64,0xC9DD93D6,0xEC0C7A01,0xB5436824, NULL },
231: { "Freezer: Action Replay Mk III v3.17", 3, 17, 3, 17, "AR\0", 262144, 30, 0, 0, ROMTYPE_AR, 1,
232: 0xc8a16406, 0x5D4987C2,0xE3FFEA8B,0x1B02E314,0x30EF190F,0x2DB76542, NULL },
233: { "Freezer: Action Replay 1200", 0, 0, 0, 0, "AR\0", 262144, 47, 0, 0, ROMTYPE_AR, 1,
234: 0x8d760101, 0x0F6AB834,0x2810094A,0xC0642F62,0xBA42F78B,0xC0B07E6A, NULL },
235:
236: { "Freezer: Action Cartridge Super IV Professional", 0, 0, 0, 0, "SUPERIV\0", 0, 62, 0, 0, ROMTYPE_SUPERIV, 1,
237: 0xffffffff, 0, 0, 0, 0, 0, "SuperIV" },
238: { "Freezer: Action Cart. Super IV Pro (+ROM v4.3)", 4, 3, 4, 3, "SUPERIV\0", 170368, 60, 0, 0, ROMTYPE_SUPERIV, 1,
239: 0xe668a0be, 0x633A6E65,0xA93580B8,0xDDB0BE9C,0x9A64D4A1,0x7D4B4801, NULL },
240: { "Freezer: X-Power Professional 500 v1.2", 1, 2, 1, 2, "XPOWER\0", 131072, 65, 0, 0, ROMTYPE_SUPERIV, 1,
241: 0x9e70c231, 0xa2977a1c,0x41a8ca7d,0x4af4a168,0x726da542,0x179d5963, NULL },
242: /* v1.0 is bad dump */
243: { "Freezer: Nordic Power v1.0", 0, 0, 0, 0, "NPOWER\0", 65536, 66, 0, 0, ROMTYPE_SUPERIV, 1, },
244: //0xdd16cdec, 0xfd882967,0x87e2da5f,0x4ef6be32,0x5f7c9324,0xb5bd8e64 },
245: { "Freezer: Nordic Power v2.0", 2, 0, 2, 0, "NPOWER\0", 65536, 67, 0, 0, ROMTYPE_SUPERIV, 1,
246: 0xa4db2906, 0x0aec68f7,0x25470c89,0x6b699ff4,0x6623dec5,0xc777466e },
247:
248: { "Freezer: HRTMon v2.30 (built-in)", 0, 0, 0, 0, "HRTMON\0", 0, 63, 0, 0, ROMTYPE_HRTMON, 1,
249: 0xffffffff, 0, 0, 0, 0, 0, "HRTMon" },
250:
251: { "A590/A2091 SCSI boot ROM", 0, 0, 6, 0, "A590\0A2091\0", 16384, 53, 0, 0, ROMTYPE_A2091BOOT, 0,
252: 0x8396cf4e, 0x5E03BC61,0x8C862ABE,0x7BF79723,0xB4EEF4D2,0x1859A0F2, NULL },
253: { "A590/A2091 SCSI boot ROM", 0, 0, 6, 6, "A590\0A2091\0", 16384, 54, 0, 0, ROMTYPE_A2091BOOT, 0,
254: 0x33e00a7a, 0x739BB828,0xE874F064,0x9360F59D,0x26B5ED3F,0xBC99BB66, NULL },
255: { "A590/A2091 SCSI boot ROM", 0, 0, 7, 0, "A590\0A2091\0", 16384, 55, 0, 0, ROMTYPE_A2091BOOT, 0,
256: 0x714a97a2, 0xE50F01BA,0xF2899892,0x85547863,0x72A82C33,0x3C91276E, NULL },
257: { "A590/A2091 SCSI Guru boot ROM", 0, 0, 6, 14, "A590\0A2091\0", 32768, 56, 0, 0, ROMTYPE_A2091BOOT, 0,
258: 0x04e52f93, 0x6DA21B6F,0x5E8F8837,0xD64507CD,0x8A4D5CDC,0xAC4F426B, NULL },
259: { "A4091 SCSI boot ROM", 0, 0, 40, 9, "A4091\0", 32768, 57, 0, 0, ROMTYPE_A4091BOOT, 0,
260: 0x00000000, 0, 0, 0, 0, 0, NULL },
261: { "A4091 SCSI boot ROM", 0, 0, 40, 13, "A4091\0", 32768, 58, 0, 0, ROMTYPE_A4091BOOT, 0,
262: 0x54cb9e85, 0x3CE66919,0xF6FD6797,0x4923A12D,0x91B730F1,0xFFB4A7BA, NULL },
263:
264: { "Arcadia OnePlay 2.11", 0, 0, 0, 0, "ARCADIA\0", 0, 49, 0, 0, ROMTYPE_ARCADIABIOS, 0 },
265: { "Arcadia TenPlay 2.11", 0, 0, 0, 0, "ARCADIA\0", 0, 50, 0, 0, ROMTYPE_ARCADIABIOS, 0 },
266: { "Arcadia OnePlay 3.00", 0, 0, 0, 0, "ARCADIA\0", 0, 51, 0, 0, ROMTYPE_ARCADIABIOS, 0 },
267:
268: { "Arcadia SportTime Table Hockey", 0, 0, 0, 0, "ARCADIA\0", 0, 33, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
269: { "Arcadia SportTime Bowling", 0, 0, 0, 0, "ARCADIA\0", 0, 34, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
270: { "Arcadia World Darts", 0, 0, 0, 0, "ARCADIA\0", 0, 35, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
271: { "Arcadia Magic Johnson's Fast Break", 0, 0, 0, 0, "ARCADIA\0", 0, 36, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
272: { "Arcadia Leader Board Golf", 0, 0, 0, 0, "ARCADIA\0", 0, 37, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
273: { "Arcadia Leader Board Golf (alt)", 0, 0, 0, 0, "ARCADIA\0", 0, 38, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
274: { "Arcadia Ninja Mission", 0, 0, 0, 0, "ARCADIA\0", 0, 39, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
275: { "Arcadia Road Wars", 0, 0, 0, 0, "ARCADIA\0", 0, 40, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
276: { "Arcadia Sidewinder", 0, 0, 0, 0, "ARCADIA\0", 0, 41, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
277: { "Arcadia Spot", 0, 0, 0, 0, "ARCADIA\0", 0, 42, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
278: { "Arcadia Space Ranger", 0, 0, 0, 0, "ARCADIA\0", 0, 43, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
279: { "Arcadia Xenon", 0, 0, 0, 0, "ARCADIA\0", 0, 44, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
280: { "Arcadia World Trophy Soccer", 0, 0, 0, 0, "ARCADIA\0", 0, 45, 0, 0, ROMTYPE_ARCADIAGAME, 2 },
281:
282: { NULL }
283:
284: };
285:
286: struct romdata *getarcadiarombyname (char *name)
287: {
288: int i;
289: for (i = 0; roms[i].name; i++) {
290: if (roms[i].type == ROMTYPE_ARCADIAGAME || roms[i].type == ROMTYPE_ARCADIAGAME) {
291: char *p = roms[i].name;
292: p = p + strlen (p) + 1;
293: if (strlen (name) >= strlen (p) + 4) {
294: char *p2 = name + strlen (name) - strlen (p) - 4;
295: if (!memcmp (p, p2, strlen (p)) && !memcmp (p2 + strlen (p2) - 4, ".zip", 4))
296: return &roms[i];
297: }
298: }
299: }
300: return NULL;
301: }
302:
303: struct romlist **getarcadiaroms(void)
304: {
305: int i, out, max;
306: void *buf;
307: struct romlist **rdout, *rltmp;
308:
309: max = 0;
310: for (i = 0; roms[i].name; i++) {
311: if (roms[i].type == ROMTYPE_ARCADIABIOS || roms[i].type == ROMTYPE_ARCADIAGAME)
312: max++;
313: }
314: buf = xmalloc((sizeof (struct romlist*) + sizeof (struct romlist)) * (max + 1));
315: rdout = (struct romlist**)buf;
316: rltmp = (struct romlist*)((uae_u8*)buf + (max + 1) * sizeof (struct romlist*));
317: out = 0;
318: for (i = 0; roms[i].name; i++) {
319: if (roms[i].type == ROMTYPE_ARCADIABIOS || roms[i].type == ROMTYPE_ARCADIAGAME) {
320: rdout[out++] = rltmp;
321: rltmp->path = NULL;
322: rltmp->rd = &roms[i];
323: rltmp++;
324: }
325: }
326: rdout[out] = NULL;
327: return rdout;
328: }
329:
330: static int kickstart_checksum_do (uae_u8 *mem, int size)
331: {
332: uae_u32 cksum = 0, prevck = 0;
333: int i;
334: for (i = 0; i < size; i+=4) {
335: uae_u32 data = mem[i]*65536*256 + mem[i+1]*65536 + mem[i+2]*256 + mem[i+3];
336: cksum += data;
337: if (cksum < prevck)
338: cksum++;
339: prevck = cksum;
340: }
341: return cksum == 0xffffffff;
342: }
343:
344: #define ROM_KEY_NUM 3
345: struct rom_key {
346: uae_u8 *key;
347: int size;
348: };
349:
350: static struct rom_key keyring[ROM_KEY_NUM];
351: int nr_keys;
352:
353: static int addkey (uae_u8 *key, int size, const char *name)
354: {
355: int i;
356:
357: if (nr_keys == ROM_KEY_NUM)
358: return 0;
359:
360: for (i = 0; i < nr_keys; i++) {
361: if (keyring[i].size == size && !memcmp (keyring[i].key, key, size))
362: return 0;
363: }
364: keyring[nr_keys].key = malloc (size);
365: if (!keyring[nr_keys].key)
366: return 0;
367: memcpy (keyring[nr_keys].key, key, size);
368: keyring[nr_keys].size = size;
369: write_log ("ROM KEY '%s' %d bytes loaded\n", name, size);
370: nr_keys++;
371: return 1;
372: }
373:
374: static void decode_cloanto_rom_do (uae_u8 *mem, int size, int real_size, uae_u8 *key, int keysize)
375: {
376: int cnt, t;
377: for (t = cnt = 0; cnt < size; cnt++, t = (t + 1) % keysize) {
378: mem[cnt] ^= key[t];
379: if (real_size == cnt + 1)
380: t = keysize - 1;
381: }
382: }
383:
384: int decode_cloanto_rom (uae_u8 *mem, int size, int real_size, int quiet)
385: {
386: struct zfile *keyf;
387: uae_u8 *p;
388: int keysize;
389: int i;
390:
391: /* Try keyring entries first. */
392: for (i = ROM_KEY_NUM - 1; i >= 0; i--) {
393: uae_u8 *key = keyring[i].key;
394: keysize = keyring[i].size;
395: if (!key)
396: continue;
397: decode_cloanto_rom_do (mem, size, real_size, key, keysize);
398:
399: if ((mem[2] == 0x4e && mem[3] == 0xf9)
400: || (mem[0] == 0x11 && (mem[1] == 0x11 || mem[1] == 0x14)))
401: return 1;
402: /* Undo the decode. */
403: decode_cloanto_rom_do (mem, size, real_size, key, keysize);
404: }
405:
406: if (strlen (currprefs.keyfile) == 0) {
407: if (!quiet)
408: gui_message ("No filename given for ROM key file and ROM image is an encrypted \"Amiga Forever\" ROM file.\n");
409: return 0;
410: }
411: keyf = zfile_open (currprefs.keyfile, "rb");
412: if (keyf == 0) {
413: if (!quiet)
414: gui_message ("Could not find specified ROM key-file.\n");
415: return 0;
416: }
417:
418: p = (uae_u8 *) xmalloc (524288);
419: keysize = zfile_fread (p, 1, 524288, keyf);
420: decode_cloanto_rom_do (mem, size, real_size, p, keysize);
421: zfile_fclose (keyf);
422: free (p);
423: return 1;
424: }
425:
426: #if 0
427: struct romdata *getromdatabyname (char *name)
428: {
429: char tmp[MAX_PATH];
430: int i = 0;
431: while (roms[i].name) {
432: getromname (&roms[i], tmp);
433: if (!strcmp (tmp, name) || !strcmp (roms[i].name, name))
434: return &roms[i];
435: i++;
436: }
437: return 0;
438: }
439: #endif
440:
441: struct romdata *getromdatabyid (int id)
442: {
443: int i = 0;
444: while (roms[i].name) {
445: if (id == roms[i].id)
446: return &roms[i];
447: i++;
448: }
449: return 0;
450: }
451:
452: STATIC_INLINE int notcrc32(uae_u32 crc32)
453: {
454: if (crc32 == 0xffffffff || crc32 == 0x00000000)
455: return 1;
456: return 0;
457: }
458:
459: struct romdata *getromdatabycrc (uae_u32 crc32)
460: {
461: int i = 0;
462: while (roms[i].name) {
463: if (crc32 == roms[i].crc32 && !notcrc32(crc32))
464: return &roms[i];
465: i++;
466: }
467: return 0;
468: }
469:
470: static int cmpsha1(uae_u8 *s1, struct romdata *rd)
471: {
472: int i;
473:
474: for (i = 0; i < SHA1_SIZE / 4; i++) {
475: uae_u32 v1 = (s1[0] << 24) | (s1[1] << 16) | (s1[2] << 8) | (s1[3] << 0);
476: uae_u32 v2 = rd->sha1[i];
477: if (v1 != v2)
478: return -1;
479: s1 += 4;
480: }
481: return 0;
482: }
483:
484: static struct romdata *checkromdata (uae_u8 *sha1, int size, uae_u32 mask)
485: {
486: int i = 0;
487: while (roms[i].name) {
488: if (!notcrc32 (roms[i].crc32) && roms[i].size >= size) {
489: if (roms[i].type & mask) {
490: if (!cmpsha1 (sha1, &roms[i]))
491: return &roms[i];
492: }
493: }
494: i++;
495: }
496: return NULL;
497: }
498:
499: struct romdata *getromdatabydata (uae_u8 *rom, int size)
500: {
501: uae_u8 sha1[SHA1_SIZE];
502: uae_u8 tmp[4];
503: uae_u8 *tmpbuf = NULL;
504: struct romdata *ret = NULL;
505:
506: if (is_encrypted_rom (rom, size)) {
507: uae_u8 *tmpbuf = (uae_u8*)xmalloc (size);
508: int tmpsize = size - 11;
509: memcpy (tmpbuf, rom + 11, tmpsize);
510: if (!decode_cloanto_rom (tmpbuf, tmpsize, tmpsize, 1))
511: return 0;
512: rom = tmpbuf;
513: size = tmpsize;
514: }
515: get_sha1 (rom, size, sha1);
516: ret = checkromdata(sha1, size, -1);
517: if (!ret) {
518: get_sha1 (rom, size / 2, sha1);
519: ret = checkromdata (sha1, size / 2, -1);
520: if (!ret) {
521: /* ignore AR IO-port range until we have full dump */
522: memcpy (tmp, rom, 4);
523: memset (rom, 0, 4);
524: get_sha1 (rom, size, sha1);
525: ret = checkromdata (sha1, size, ROMTYPE_AR);
526: memcpy (rom, tmp, 4);
527: }
528: }
529: free (tmpbuf);
530: return ret;
531: }
532:
533: static struct romdata *getromdatabyzfile (struct zfile *f)
534: {
535: int pos, size;
536: uae_u8 *p;
537: struct romdata *rd;
538:
539: pos = zfile_ftell (f);
540: zfile_fseek (f, 0, SEEK_END);
541: size = zfile_ftell (f);
542:
543: /* Weed out too-large files to save time. */
544: if (size > 1024 * 1024)
545: return 0;
546:
547: p = (uae_u8*)xmalloc (size);
548: if (!p)
549: return 0;
550: memset (p, 0, size);
551: zfile_fseek (f, 0, SEEK_SET);
552: zfile_fread (p, 1, size, f);
553: zfile_fseek (f, pos, SEEK_SET);
554: rd = getromdatabydata (p, size);
555: free (p);
556: return rd;
557: }
558:
559: void getromname (struct romdata *rd, char *name)
560: {
561: name[0] = 0;
562: if (!rd)
563: return;
564: strcat (name, rd->name);
565: if ((rd->subrev || rd->subver) && rd->subver != rd->ver)
566: sprintf (name + strlen (name), " rev %d.%d", rd->subver, rd->subrev);
567: if (rd->size > 0)
568: sprintf (name + strlen (name), " (%dk)", (rd->size + 1023) / 1024);
569: }
570:
571: struct romlist *getromlistbyids(int *ids)
572: {
573: struct romdata *rd;
574: int i, j;
575:
576: i = 0;
577: while (ids[i] >= 0) {
578: rd = getromdatabyid (ids[i]);
579: if (rd) {
580: for (j = 0; j < romlist_cnt; j++) {
581: if (list_of_roms[j].rd == rd)
582: return list_of_roms + j;
583: }
584: }
585: i++;
586: }
587: return NULL;
588: }
589:
590: static struct romlist *getromlistbyromdata(struct romdata *rd)
591: {
592: int ids[2];
593:
594: ids[0] = rd->id;
595: ids[1] = 0;
596: return getromlistbyids(ids);
597: }
598:
599: #if 0
600: void romwarning(int *ids)
601: {
602: int i, exp;
603: char tmp1[MAX_DPATH], tmp2[MAX_DPATH];
604: char tmp3[MAX_DPATH];
605:
606: exp = 0;
607: tmp2[0] = 0;
608: i = 0;
609: while (ids[i] >= 0) {
610: struct romdata *rd = getromdatabyid (ids[i]);
611: getromname (rd, tmp1);
612: strcat (tmp2, "- ");
613: strcat (tmp2, tmp1);
614: strcat (tmp2, "\n");
615: if (rd->type & (ROMTYPE_A2091BOOT | ROMTYPE_A4091BOOT))
616: exp++;
617: i++;
618: }
619: translate_message (exp ? NUMSG_EXPROMNEED : NUMSG_ROMNEED, tmp3);
620: gui_message (tmp3, tmp2);
621: }
622: #endif
623:
624: void scan_roms (const char *path, int loc)
625: {
626: DIR *dir;
627: int pathlen = strlen (path);
628: int bufsz = pathlen + 256;
629: char *buffer;
630: uae_u8 *data;
631: int keys_added = 0;
632:
633: dir = opendir (path);
634: if (!dir)
635: return;
636:
637: buffer = malloc (bufsz);
638: if (!buffer)
639: goto out;
640: data = malloc (1024 * 1024);
641: if (!data)
642: goto out1;
643: romlist_clear (loc);
644:
645: strcpy (buffer, path);
646: buffer[pathlen++] = '/';
647: buffer[pathlen] = '\0';
648: for (;;) {
649: struct zfile *f;
650: struct dirent *ent = readdir (dir);
651: int len;
652: struct romdata *rd;
653: long size;
654:
655: if (!ent)
656: break;
657:
658: len = strlen (ent->d_name);
659: if (len + pathlen + 1 >= bufsz) {
660: bufsz = len + pathlen + 200;
661: buffer = realloc (buffer, bufsz);
662: if (!buffer) {
663: goto out;
664: }
665: }
666: strcpy (buffer + pathlen, ent->d_name);
667: f = zfile_open (buffer, "rb");
668: if (!f)
669: continue;
670:
671: zfile_fseek (f, 0, SEEK_END);
672: size = zfile_ftell (f);
673:
674: /* Weed out too-large files to save time. */
675: if (size > 1024 * 1024) {
676: zfile_fclose (f);
677: continue;
678: }
679: zfile_fseek (f, 0, SEEK_SET);
680: zfile_fread (data, 1, size, f);
681:
682: rd = getromdatabydata (data, size);
683: zfile_fclose (f);
684:
685: /* Add encrypted ROMs even if we don't have the key yet. */
686: if (!rd && !is_encrypted_rom (data, size))
687: continue;
688:
689: if (rd && rd->type == ROMTYPE_KEY) {
690: if (addkey (data, size, ent->d_name))
691: keys_added = 1;
692: } else
693: romlist_add (buffer, rd, loc);
694: }
695: /* Now, if we added any keys, reexamine all encrypted ROMs. */
696: if (keys_added) {
697: int i;
698: for (i = 0; i < romlist_cnt; i++) {
699: struct romlist *rl = list_of_roms + i;
700: if (rl->rd)
701: continue;
702: struct zfile *f = zfile_open (rl->path, "rb");
703: if (!f)
704: continue;
705: rl->rd = getromdatabyzfile (f);
706: zfile_fclose (f);
707: }
708: }
709: sort_romlist ();
710: gui_romlist_changed ();
711:
712: free (data);
713: out1:
714: free (buffer);
715: out:
716: closedir (dir);
717: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.