1 |
cebix |
1.1 |
/* |
2 |
cebix |
1.6 |
* 1541t64.cpp - 1541 emulation in archive-type files (.t64/LYNX/.p00) |
3 |
cebix |
1.1 |
* |
4 |
cebix |
1.6 |
* Frodo (C) Copyright 1994-2001 Christian Bauer |
5 |
cebix |
1.1 |
* |
6 |
|
|
* This program is free software; you can redistribute it and/or modify |
7 |
|
|
* it under the terms of the GNU General Public License as published by |
8 |
|
|
* the Free Software Foundation; either version 2 of the License, or |
9 |
|
|
* (at your option) any later version. |
10 |
|
|
* |
11 |
|
|
* This program is distributed in the hope that it will be useful, |
12 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 |
|
|
* GNU General Public License for more details. |
15 |
|
|
* |
16 |
|
|
* You should have received a copy of the GNU General Public License |
17 |
|
|
* along with this program; if not, write to the Free Software |
18 |
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
19 |
|
|
*/ |
20 |
|
|
|
21 |
|
|
/* |
22 |
cebix |
1.6 |
* NOTES: |
23 |
|
|
* - This module handles access to files inside (uncompressed) archives |
24 |
|
|
* and makes the archive look like a disk. It supports C64S tape images |
25 |
|
|
* (.t64), C64 LYNX archives and .p00 files. |
26 |
|
|
* - If any file is opened, the contents of the file in the archive file are |
27 |
|
|
* copied into a temporary file which is used for reading. This is done |
28 |
|
|
* to insert the load address. |
29 |
cebix |
1.1 |
* |
30 |
cebix |
1.6 |
* Incompatibilities: |
31 |
|
|
* - Only read accesses possible |
32 |
|
|
* - No "raw" directory reading |
33 |
|
|
* - No relative/sequential/user files |
34 |
|
|
* - Unimplemented commands: B-P, M-R, M-W, C, S, P, N |
35 |
|
|
* - Impossible to implement: B-R, B-W, B-E, B-A, B-F, M-E |
36 |
cebix |
1.1 |
*/ |
37 |
|
|
|
38 |
|
|
#include "sysdeps.h" |
39 |
|
|
|
40 |
|
|
#include "1541t64.h" |
41 |
|
|
#include "IEC.h" |
42 |
|
|
#include "Prefs.h" |
43 |
|
|
|
44 |
cebix |
1.6 |
#define DEBUG 0 |
45 |
|
|
#include "debug.h" |
46 |
|
|
|
47 |
|
|
|
48 |
|
|
// Prototypes |
49 |
|
|
static bool is_t64_header(const uint8 *header); |
50 |
|
|
static bool is_lynx_header(const uint8 *header); |
51 |
|
|
static bool is_p00_header(const uint8 *header); |
52 |
|
|
static bool parse_t64_file(FILE *f, vector<c64_dir_entry> &vec, char *dir_title); |
53 |
|
|
static bool parse_lynx_file(FILE *f, vector<c64_dir_entry> &vec, char *dir_title); |
54 |
|
|
static bool parse_p00_file(FILE *f, vector<c64_dir_entry> &vec, char *dir_title); |
55 |
|
|
|
56 |
cebix |
1.1 |
|
57 |
|
|
/* |
58 |
|
|
* Constructor: Prepare emulation |
59 |
|
|
*/ |
60 |
|
|
|
61 |
cebix |
1.6 |
ArchDrive::ArchDrive(IEC *iec, const char *filepath) : Drive(iec), the_file(NULL) |
62 |
cebix |
1.1 |
{ |
63 |
|
|
for (int i=0; i<16; i++) |
64 |
|
|
file[i] = NULL; |
65 |
cebix |
1.6 |
Reset(); |
66 |
cebix |
1.1 |
|
67 |
cebix |
1.6 |
// Open archive file |
68 |
|
|
if (change_arch(filepath)) |
69 |
cebix |
1.1 |
Ready = true; |
70 |
|
|
} |
71 |
|
|
|
72 |
|
|
|
73 |
|
|
/* |
74 |
|
|
* Destructor |
75 |
|
|
*/ |
76 |
|
|
|
77 |
cebix |
1.6 |
ArchDrive::~ArchDrive() |
78 |
cebix |
1.1 |
{ |
79 |
cebix |
1.6 |
// Close archive file |
80 |
|
|
if (the_file) { |
81 |
|
|
close_all_channels(); |
82 |
|
|
fclose(the_file); |
83 |
|
|
} |
84 |
cebix |
1.1 |
Ready = false; |
85 |
|
|
} |
86 |
|
|
|
87 |
|
|
|
88 |
|
|
/* |
89 |
cebix |
1.6 |
* Open the archive file |
90 |
cebix |
1.1 |
*/ |
91 |
|
|
|
92 |
cebix |
1.6 |
bool ArchDrive::change_arch(const char *path) |
93 |
cebix |
1.1 |
{ |
94 |
cebix |
1.6 |
FILE *new_file; |
95 |
cebix |
1.1 |
|
96 |
cebix |
1.6 |
// Open new archive file |
97 |
|
|
if ((new_file = fopen(path, "rb")) != NULL) { |
98 |
|
|
|
99 |
|
|
file_info.clear(); |
100 |
|
|
|
101 |
|
|
// Read header, determine archive type and parse archive contents |
102 |
|
|
uint8 header[64]; |
103 |
|
|
fread(header, 1, 64, new_file); |
104 |
|
|
bool parsed_ok = false; |
105 |
|
|
if (is_t64_header(header)) { |
106 |
|
|
archive_type = TYPE_T64; |
107 |
|
|
parsed_ok = parse_t64_file(new_file, file_info, dir_title); |
108 |
|
|
} else if (is_lynx_header(header)) { |
109 |
|
|
archive_type = TYPE_LYNX; |
110 |
|
|
parsed_ok = parse_lynx_file(new_file, file_info, dir_title); |
111 |
|
|
} else if (is_p00_header(header)) { |
112 |
|
|
archive_type = TYPE_P00; |
113 |
|
|
parsed_ok = parse_p00_file(new_file, file_info, dir_title); |
114 |
|
|
} |
115 |
cebix |
1.1 |
|
116 |
cebix |
1.6 |
if (!parsed_ok) { |
117 |
|
|
fclose(new_file); |
118 |
|
|
if (the_file) { |
119 |
|
|
close_all_channels(); |
120 |
cebix |
1.1 |
fclose(the_file); |
121 |
|
|
the_file = NULL; |
122 |
|
|
} |
123 |
cebix |
1.6 |
return false; |
124 |
cebix |
1.1 |
} |
125 |
|
|
|
126 |
cebix |
1.6 |
// Close old archive if open, and set new file |
127 |
|
|
if (the_file) { |
128 |
|
|
close_all_channels(); |
129 |
|
|
fclose(the_file); |
130 |
|
|
the_file = NULL; |
131 |
cebix |
1.1 |
} |
132 |
cebix |
1.6 |
the_file = new_file; |
133 |
|
|
return true; |
134 |
cebix |
1.1 |
} |
135 |
cebix |
1.6 |
return false; |
136 |
cebix |
1.1 |
} |
137 |
|
|
|
138 |
|
|
|
139 |
|
|
/* |
140 |
|
|
* Open channel |
141 |
|
|
*/ |
142 |
|
|
|
143 |
cebix |
1.6 |
uint8 ArchDrive::Open(int channel, const uint8 *name, int name_len) |
144 |
cebix |
1.1 |
{ |
145 |
cebix |
1.6 |
D(bug("ArchDrive::Open channel %d, file %s\n", channel, name)); |
146 |
|
|
|
147 |
cebix |
1.1 |
set_error(ERR_OK); |
148 |
|
|
|
149 |
|
|
// Channel 15: Execute file name as command |
150 |
|
|
if (channel == 15) { |
151 |
cebix |
1.3 |
execute_cmd(name, name_len); |
152 |
cebix |
1.1 |
return ST_OK; |
153 |
|
|
} |
154 |
|
|
|
155 |
|
|
// Close previous file if still open |
156 |
|
|
if (file[channel]) { |
157 |
|
|
fclose(file[channel]); |
158 |
|
|
file[channel] = NULL; |
159 |
|
|
} |
160 |
|
|
|
161 |
cebix |
1.3 |
if (name[0] == '#') { |
162 |
cebix |
1.1 |
set_error(ERR_NOCHANNEL); |
163 |
|
|
return ST_OK; |
164 |
|
|
} |
165 |
|
|
|
166 |
|
|
if (the_file == NULL) { |
167 |
|
|
set_error(ERR_NOTREADY); |
168 |
|
|
return ST_OK; |
169 |
|
|
} |
170 |
|
|
|
171 |
cebix |
1.3 |
if (name[0] == '$') |
172 |
|
|
return open_directory(channel, name + 1, name_len - 1); |
173 |
cebix |
1.1 |
|
174 |
cebix |
1.3 |
return open_file(channel, name, name_len); |
175 |
cebix |
1.1 |
} |
176 |
|
|
|
177 |
|
|
|
178 |
|
|
/* |
179 |
|
|
* Open file |
180 |
|
|
*/ |
181 |
|
|
|
182 |
cebix |
1.6 |
uint8 ArchDrive::open_file(int channel, const uint8 *name, int name_len) |
183 |
cebix |
1.1 |
{ |
184 |
cebix |
1.3 |
uint8 plain_name[NAMEBUF_LENGTH]; |
185 |
|
|
int plain_name_len; |
186 |
|
|
int mode = FMODE_READ; |
187 |
cebix |
1.6 |
int type = FTYPE_DEL; |
188 |
|
|
int rec_len = 0; |
189 |
cebix |
1.3 |
parse_file_name(name, name_len, plain_name, plain_name_len, mode, type, rec_len); |
190 |
|
|
|
191 |
|
|
// Channel 0 is READ, channel 1 is WRITE |
192 |
|
|
if (channel == 0 || channel == 1) { |
193 |
|
|
mode = channel ? FMODE_WRITE : FMODE_READ; |
194 |
|
|
if (type == FTYPE_DEL) |
195 |
|
|
type = FTYPE_PRG; |
196 |
|
|
} |
197 |
|
|
|
198 |
|
|
bool writing = (mode == FMODE_WRITE || mode == FMODE_APPEND); |
199 |
|
|
|
200 |
|
|
// Wildcards are only allowed on reading |
201 |
|
|
if (writing && (strchr((const char *)plain_name, '*') || strchr((const char *)plain_name, '?'))) { |
202 |
|
|
set_error(ERR_SYNTAX33); |
203 |
|
|
return ST_OK; |
204 |
cebix |
1.1 |
} |
205 |
|
|
|
206 |
|
|
// Allow only read accesses |
207 |
cebix |
1.3 |
if (writing) { |
208 |
cebix |
1.1 |
set_error(ERR_WRITEPROTECT); |
209 |
|
|
return ST_OK; |
210 |
|
|
} |
211 |
|
|
|
212 |
cebix |
1.3 |
// Relative files are not supported |
213 |
|
|
if (type == FTYPE_REL) { |
214 |
|
|
set_error(ERR_UNIMPLEMENTED); |
215 |
|
|
return ST_OK; |
216 |
|
|
} |
217 |
|
|
|
218 |
cebix |
1.1 |
// Find file |
219 |
cebix |
1.3 |
int num; |
220 |
|
|
if (find_first_file(plain_name, plain_name_len, num)) { |
221 |
cebix |
1.1 |
|
222 |
|
|
// Open temporary file |
223 |
|
|
if ((file[channel] = tmpfile()) != NULL) { |
224 |
|
|
|
225 |
|
|
// Write load address (.t64 only) |
226 |
cebix |
1.6 |
if (archive_type == TYPE_T64) { |
227 |
cebix |
1.1 |
fwrite(&file_info[num].sa_lo, 1, 1, file[channel]); |
228 |
|
|
fwrite(&file_info[num].sa_hi, 1, 1, file[channel]); |
229 |
|
|
} |
230 |
|
|
|
231 |
cebix |
1.6 |
// Copy file contents from archive file to temp file |
232 |
|
|
uint8 *buf = new uint8[file_info[num].size]; |
233 |
cebix |
1.1 |
fseek(the_file, file_info[num].offset, SEEK_SET); |
234 |
cebix |
1.6 |
fread(buf, file_info[num].size, 1, the_file); |
235 |
|
|
fwrite(buf, file_info[num].size, 1, file[channel]); |
236 |
cebix |
1.1 |
rewind(file[channel]); |
237 |
|
|
delete[] buf; |
238 |
|
|
|
239 |
cebix |
1.3 |
if (mode == FMODE_READ) // Read and buffer first byte |
240 |
cebix |
1.6 |
read_char[channel] = getc(file[channel]); |
241 |
cebix |
1.1 |
} |
242 |
|
|
} else |
243 |
|
|
set_error(ERR_FILENOTFOUND); |
244 |
|
|
|
245 |
|
|
return ST_OK; |
246 |
|
|
} |
247 |
|
|
|
248 |
|
|
|
249 |
|
|
/* |
250 |
|
|
* Find first file matching wildcard pattern |
251 |
|
|
*/ |
252 |
|
|
|
253 |
|
|
// Return true if name 'n' matches pattern 'p' |
254 |
cebix |
1.3 |
static bool match(const uint8 *p, int p_len, const uint8 *n) |
255 |
cebix |
1.1 |
{ |
256 |
cebix |
1.3 |
while (p_len-- > 0) { |
257 |
cebix |
1.1 |
if (*p == '*') // Wildcard '*' matches all following characters |
258 |
|
|
return true; |
259 |
|
|
if ((*p != *n) && (*p != '?')) // Wildcard '?' matches single character |
260 |
|
|
return false; |
261 |
|
|
p++; n++; |
262 |
cebix |
1.3 |
} |
263 |
cebix |
1.1 |
|
264 |
cebix |
1.3 |
return *n == 0; |
265 |
cebix |
1.1 |
} |
266 |
|
|
|
267 |
cebix |
1.6 |
bool ArchDrive::find_first_file(const uint8 *pattern, int pattern_len, int &num) |
268 |
cebix |
1.1 |
{ |
269 |
cebix |
1.6 |
vector<c64_dir_entry>::const_iterator i, end = file_info.end(); |
270 |
|
|
for (i = file_info.begin(), num = 0; i != end; i++, num++) { |
271 |
|
|
if (match(pattern, pattern_len, (uint8 *)i->name)) |
272 |
cebix |
1.1 |
return true; |
273 |
cebix |
1.3 |
} |
274 |
cebix |
1.1 |
return false; |
275 |
|
|
} |
276 |
|
|
|
277 |
|
|
|
278 |
|
|
/* |
279 |
|
|
* Open directory, create temporary file |
280 |
|
|
*/ |
281 |
|
|
|
282 |
cebix |
1.6 |
uint8 ArchDrive::open_directory(int channel, const uint8 *pattern, int pattern_len) |
283 |
cebix |
1.1 |
{ |
284 |
|
|
// Special treatment for "$0" |
285 |
cebix |
1.3 |
if (pattern[0] == '0' && pattern_len == 1) { |
286 |
|
|
pattern++; |
287 |
|
|
pattern_len--; |
288 |
|
|
} |
289 |
cebix |
1.1 |
|
290 |
cebix |
1.3 |
// Skip everything before the ':' in the pattern |
291 |
|
|
uint8 *t = (uint8 *)memchr(pattern, ':', pattern_len); |
292 |
|
|
if (t) { |
293 |
|
|
t++; |
294 |
|
|
pattern_len -= t - pattern; |
295 |
|
|
pattern = t; |
296 |
|
|
} |
297 |
cebix |
1.1 |
|
298 |
|
|
// Create temporary file |
299 |
|
|
if ((file[channel] = tmpfile()) == NULL) |
300 |
|
|
return ST_OK; |
301 |
|
|
|
302 |
|
|
// Create directory title |
303 |
cebix |
1.3 |
uint8 buf[] = "\001\004\001\001\0\0\022\042 \042 00 2A"; |
304 |
|
|
for (int i=0; i<16 && dir_title[i]; i++) |
305 |
|
|
buf[i + 8] = dir_title[i]; |
306 |
cebix |
1.1 |
fwrite(buf, 1, 32, file[channel]); |
307 |
|
|
|
308 |
|
|
// Create and write one line for every directory entry |
309 |
cebix |
1.6 |
vector<c64_dir_entry>::const_iterator i, end = file_info.end(); |
310 |
|
|
for (i = file_info.begin(); i != end; i++) { |
311 |
cebix |
1.1 |
|
312 |
|
|
// Include only files matching the pattern |
313 |
cebix |
1.6 |
if (pattern_len == 0 || match(pattern, pattern_len, (uint8 *)i->name)) { |
314 |
cebix |
1.1 |
|
315 |
|
|
// Clear line with spaces and terminate with null byte |
316 |
|
|
memset(buf, ' ', 31); |
317 |
|
|
buf[31] = 0; |
318 |
|
|
|
319 |
cebix |
1.6 |
uint8 *p = (uint8 *)buf; |
320 |
cebix |
1.1 |
*p++ = 0x01; // Dummy line link |
321 |
|
|
*p++ = 0x01; |
322 |
|
|
|
323 |
|
|
// Calculate size in blocks (254 bytes each) |
324 |
cebix |
1.6 |
int n = (i->size + 254) / 254; |
325 |
cebix |
1.3 |
*p++ = n & 0xff; |
326 |
|
|
*p++ = (n >> 8) & 0xff; |
327 |
cebix |
1.1 |
|
328 |
|
|
p++; |
329 |
cebix |
1.3 |
if (n < 10) p++; // Less than 10: add one space |
330 |
|
|
if (n < 100) p++; // Less than 100: add another space |
331 |
cebix |
1.1 |
|
332 |
|
|
// Convert and insert file name |
333 |
|
|
*p++ = '\"'; |
334 |
cebix |
1.3 |
uint8 *q = p; |
335 |
cebix |
1.6 |
for (int j=0; j<16 && i->name[j]; j++) |
336 |
|
|
*q++ = i->name[j]; |
337 |
cebix |
1.1 |
*q++ = '\"'; |
338 |
|
|
p += 18; |
339 |
|
|
|
340 |
|
|
// File type |
341 |
cebix |
1.6 |
switch (i->type) { |
342 |
|
|
case FTYPE_DEL: |
343 |
|
|
*p++ = 'D'; |
344 |
|
|
*p++ = 'E'; |
345 |
|
|
*p++ = 'L'; |
346 |
cebix |
1.1 |
break; |
347 |
|
|
case FTYPE_SEQ: |
348 |
|
|
*p++ = 'S'; |
349 |
|
|
*p++ = 'E'; |
350 |
|
|
*p++ = 'Q'; |
351 |
|
|
break; |
352 |
cebix |
1.6 |
case FTYPE_PRG: |
353 |
|
|
*p++ = 'P'; |
354 |
|
|
*p++ = 'R'; |
355 |
|
|
*p++ = 'G'; |
356 |
|
|
break; |
357 |
cebix |
1.1 |
case FTYPE_USR: |
358 |
|
|
*p++ = 'U'; |
359 |
|
|
*p++ = 'S'; |
360 |
|
|
*p++ = 'R'; |
361 |
|
|
break; |
362 |
|
|
case FTYPE_REL: |
363 |
|
|
*p++ = 'R'; |
364 |
|
|
*p++ = 'E'; |
365 |
|
|
*p++ = 'L'; |
366 |
|
|
break; |
367 |
|
|
default: |
368 |
|
|
*p++ = '?'; |
369 |
|
|
*p++ = '?'; |
370 |
|
|
*p++ = '?'; |
371 |
|
|
break; |
372 |
|
|
} |
373 |
|
|
|
374 |
|
|
// Write line |
375 |
|
|
fwrite(buf, 1, 32, file[channel]); |
376 |
|
|
} |
377 |
|
|
} |
378 |
|
|
|
379 |
|
|
// Final line |
380 |
|
|
fwrite("\001\001\0\0BLOCKS FREE. \0\0", 1, 32, file[channel]); |
381 |
|
|
|
382 |
|
|
// Rewind file for reading and read first byte |
383 |
|
|
rewind(file[channel]); |
384 |
cebix |
1.6 |
read_char[channel] = getc(file[channel]); |
385 |
cebix |
1.1 |
|
386 |
|
|
return ST_OK; |
387 |
|
|
} |
388 |
|
|
|
389 |
|
|
|
390 |
|
|
/* |
391 |
|
|
* Close channel |
392 |
|
|
*/ |
393 |
|
|
|
394 |
cebix |
1.6 |
uint8 ArchDrive::Close(int channel) |
395 |
cebix |
1.1 |
{ |
396 |
cebix |
1.6 |
D(bug("ArchDrive::Close channel %d\n", channel)); |
397 |
|
|
|
398 |
cebix |
1.1 |
if (channel == 15) { |
399 |
|
|
close_all_channels(); |
400 |
|
|
return ST_OK; |
401 |
|
|
} |
402 |
|
|
|
403 |
|
|
if (file[channel]) { |
404 |
|
|
fclose(file[channel]); |
405 |
|
|
file[channel] = NULL; |
406 |
|
|
} |
407 |
|
|
|
408 |
|
|
return ST_OK; |
409 |
|
|
} |
410 |
|
|
|
411 |
|
|
|
412 |
|
|
/* |
413 |
|
|
* Close all channels |
414 |
|
|
*/ |
415 |
|
|
|
416 |
cebix |
1.6 |
void ArchDrive::close_all_channels(void) |
417 |
cebix |
1.1 |
{ |
418 |
|
|
for (int i=0; i<15; i++) |
419 |
|
|
Close(i); |
420 |
|
|
|
421 |
|
|
cmd_len = 0; |
422 |
|
|
} |
423 |
|
|
|
424 |
|
|
|
425 |
|
|
/* |
426 |
|
|
* Read from channel |
427 |
|
|
*/ |
428 |
|
|
|
429 |
cebix |
1.6 |
uint8 ArchDrive::Read(int channel, uint8 &byte) |
430 |
cebix |
1.1 |
{ |
431 |
cebix |
1.6 |
D(bug("ArchDrive::Read channel %d\n", channel)); |
432 |
cebix |
1.1 |
|
433 |
|
|
// Channel 15: Error channel |
434 |
|
|
if (channel == 15) { |
435 |
cebix |
1.4 |
byte = *error_ptr++; |
436 |
cebix |
1.1 |
|
437 |
cebix |
1.6 |
if (byte != '\x0d') |
438 |
cebix |
1.1 |
return ST_OK; |
439 |
|
|
else { // End of message |
440 |
|
|
set_error(ERR_OK); |
441 |
|
|
return ST_EOF; |
442 |
|
|
} |
443 |
|
|
} |
444 |
|
|
|
445 |
|
|
if (!file[channel]) return ST_READ_TIMEOUT; |
446 |
|
|
|
447 |
|
|
// Get char from buffer and read next |
448 |
cebix |
1.4 |
byte = read_char[channel]; |
449 |
cebix |
1.6 |
int c = getc(file[channel]); |
450 |
cebix |
1.1 |
if (c == EOF) |
451 |
|
|
return ST_EOF; |
452 |
|
|
else { |
453 |
|
|
read_char[channel] = c; |
454 |
|
|
return ST_OK; |
455 |
|
|
} |
456 |
|
|
} |
457 |
|
|
|
458 |
|
|
|
459 |
|
|
/* |
460 |
|
|
* Write to channel |
461 |
|
|
*/ |
462 |
|
|
|
463 |
cebix |
1.6 |
uint8 ArchDrive::Write(int channel, uint8 byte, bool eoi) |
464 |
cebix |
1.1 |
{ |
465 |
cebix |
1.6 |
D(bug("ArchDrive::Write channel %d, byte %02x, eoi %d\n", channel, byte, eoi)); |
466 |
|
|
|
467 |
cebix |
1.1 |
// Channel 15: Collect chars and execute command on EOI |
468 |
|
|
if (channel == 15) { |
469 |
cebix |
1.6 |
if (cmd_len > 58) { |
470 |
|
|
set_error(ERR_SYNTAX32); |
471 |
cebix |
1.1 |
return ST_TIMEOUT; |
472 |
cebix |
1.6 |
} |
473 |
cebix |
1.1 |
|
474 |
cebix |
1.3 |
cmd_buf[cmd_len++] = byte; |
475 |
cebix |
1.1 |
|
476 |
|
|
if (eoi) { |
477 |
cebix |
1.3 |
execute_cmd(cmd_buf, cmd_len); |
478 |
cebix |
1.1 |
cmd_len = 0; |
479 |
|
|
} |
480 |
|
|
return ST_OK; |
481 |
|
|
} |
482 |
|
|
|
483 |
|
|
if (!file[channel]) |
484 |
|
|
set_error(ERR_FILENOTOPEN); |
485 |
|
|
else |
486 |
|
|
set_error(ERR_WRITEPROTECT); |
487 |
|
|
|
488 |
|
|
return ST_TIMEOUT; |
489 |
|
|
} |
490 |
|
|
|
491 |
|
|
|
492 |
|
|
/* |
493 |
cebix |
1.3 |
* Execute drive commands |
494 |
cebix |
1.1 |
*/ |
495 |
|
|
|
496 |
cebix |
1.3 |
// RENAME:new=old |
497 |
|
|
// ^ ^ |
498 |
|
|
// new_file old_file |
499 |
cebix |
1.6 |
void ArchDrive::rename_cmd(const uint8 *new_file, int new_file_len, const uint8 *old_file, int old_file_len) |
500 |
cebix |
1.1 |
{ |
501 |
cebix |
1.3 |
// Check if destination file is already present |
502 |
|
|
int num; |
503 |
|
|
if (find_first_file(new_file, new_file_len, num)) { |
504 |
|
|
set_error(ERR_FILEEXISTS); |
505 |
|
|
return; |
506 |
|
|
} |
507 |
cebix |
1.1 |
|
508 |
cebix |
1.3 |
// Check if source file is present |
509 |
|
|
if (!find_first_file(old_file, old_file_len, num)) { |
510 |
|
|
set_error(ERR_FILENOTFOUND); |
511 |
|
|
return; |
512 |
|
|
} |
513 |
cebix |
1.1 |
|
514 |
cebix |
1.3 |
set_error(ERR_WRITEPROTECT); |
515 |
cebix |
1.1 |
} |
516 |
|
|
|
517 |
cebix |
1.3 |
// INITIALIZE |
518 |
cebix |
1.6 |
void ArchDrive::initialize_cmd(void) |
519 |
cebix |
1.1 |
{ |
520 |
|
|
close_all_channels(); |
521 |
cebix |
1.3 |
} |
522 |
cebix |
1.1 |
|
523 |
cebix |
1.3 |
// VALIDATE |
524 |
cebix |
1.6 |
void ArchDrive::validate_cmd(void) |
525 |
cebix |
1.3 |
{ |
526 |
cebix |
1.1 |
} |
527 |
|
|
|
528 |
|
|
|
529 |
|
|
/* |
530 |
|
|
* Reset drive |
531 |
|
|
*/ |
532 |
|
|
|
533 |
cebix |
1.6 |
void ArchDrive::Reset(void) |
534 |
cebix |
1.1 |
{ |
535 |
|
|
close_all_channels(); |
536 |
|
|
cmd_len = 0; |
537 |
|
|
set_error(ERR_STARTUP); |
538 |
cebix |
1.6 |
} |
539 |
|
|
|
540 |
|
|
|
541 |
|
|
/* |
542 |
|
|
* Check whether file with given header (64 bytes) and size looks like one |
543 |
|
|
* of the file types supported by this module |
544 |
|
|
*/ |
545 |
|
|
|
546 |
|
|
static bool is_t64_header(const uint8 *header) |
547 |
|
|
{ |
548 |
|
|
return memcmp(header, "C64S tape file", 14) == 0; |
549 |
|
|
} |
550 |
|
|
|
551 |
|
|
static bool is_lynx_header(const uint8 *header) |
552 |
|
|
{ |
553 |
|
|
return memcmp(header + 0x38, "USE LYNX", 8) == 0; |
554 |
|
|
} |
555 |
|
|
|
556 |
|
|
static bool is_p00_header(const uint8 *header) |
557 |
|
|
{ |
558 |
|
|
return memcmp(header, "C64File", 7) == 0; |
559 |
|
|
} |
560 |
|
|
|
561 |
|
|
bool IsArchFile(const char *path, const uint8 *header, long size) |
562 |
|
|
{ |
563 |
|
|
return is_t64_header(header) || is_lynx_header(header) || is_p00_header(header); |
564 |
|
|
} |
565 |
|
|
|
566 |
|
|
|
567 |
|
|
/* |
568 |
|
|
* Read directory of archive file into (empty) c64_dir_entry vector, |
569 |
|
|
* returns false on error |
570 |
|
|
*/ |
571 |
|
|
|
572 |
|
|
static bool parse_t64_file(FILE *f, vector<c64_dir_entry> &vec, char *dir_title) |
573 |
|
|
{ |
574 |
|
|
// Read header and get maximum number of files contained |
575 |
|
|
fseek(f, 32, SEEK_SET); |
576 |
|
|
uint8 buf[32]; |
577 |
|
|
fread(&buf, 32, 1, f); |
578 |
|
|
int max = (buf[3] << 8) | buf[2]; |
579 |
|
|
if (max == 0) |
580 |
|
|
max = 1; |
581 |
|
|
|
582 |
|
|
memcpy(dir_title, buf+8, 16); |
583 |
|
|
|
584 |
|
|
// Allocate buffer for file records and read them |
585 |
|
|
uint8 *buf2 = new uint8[max * 32]; |
586 |
|
|
fread(buf2, 32, max, f); |
587 |
|
|
|
588 |
|
|
// Determine number of files contained |
589 |
|
|
int num_files = 0; |
590 |
|
|
for (int i=0; i<max; i++) |
591 |
|
|
if (buf2[i*32] == 1) |
592 |
|
|
num_files++; |
593 |
|
|
|
594 |
|
|
if (!num_files) { |
595 |
|
|
delete[] buf2; |
596 |
|
|
return false; |
597 |
|
|
} |
598 |
|
|
|
599 |
|
|
// Construct file information array |
600 |
|
|
vec.reserve(num_files); |
601 |
|
|
uint8 *b = buf2; |
602 |
|
|
for (int i=0; i<max; i++, b+=32) { |
603 |
|
|
if (b[0] == 1) { |
604 |
|
|
|
605 |
|
|
// Convert file name (strip trailing spaces) |
606 |
|
|
uint8 name_buf[17]; |
607 |
|
|
memcpy(name_buf, b + 16, 16); |
608 |
|
|
name_buf[16] = 0x20; |
609 |
|
|
uint8 *p = name_buf + 16; |
610 |
|
|
while (*p-- == 0x20) ; |
611 |
|
|
p[2] = 0; |
612 |
|
|
|
613 |
|
|
// Find file size and offset |
614 |
|
|
size_t size = ((b[5] << 8) | b[4]) - ((b[3] << 8) | b[2]); |
615 |
|
|
off_t offset = (b[11] << 24) | (b[10] << 16) | (b[9] << 8) | b[8]; |
616 |
|
|
|
617 |
|
|
// Add entry |
618 |
|
|
vec.push_back(c64_dir_entry(name_buf, FTYPE_PRG, false, false, size, offset, b[2], b[3])); |
619 |
|
|
} |
620 |
|
|
} |
621 |
|
|
|
622 |
|
|
delete[] buf2; |
623 |
|
|
return true; |
624 |
|
|
} |
625 |
|
|
|
626 |
|
|
static bool parse_lynx_file(FILE *f, vector<c64_dir_entry> &vec, char *dir_title) |
627 |
|
|
{ |
628 |
|
|
// Dummy directory title |
629 |
|
|
strcpy(dir_title, "LYNX ARCHIVE "); |
630 |
|
|
|
631 |
|
|
// Read header and get number of directory blocks and files contained |
632 |
|
|
fseek(f, 0x60, SEEK_SET); |
633 |
|
|
int dir_blocks; |
634 |
|
|
fscanf(f, "%d", &dir_blocks); |
635 |
|
|
while (getc(f) != 0x0d) |
636 |
|
|
if (feof(f)) |
637 |
|
|
return false; |
638 |
|
|
int num_files; |
639 |
|
|
fscanf(f, "%d\x0d", &num_files); |
640 |
|
|
|
641 |
|
|
// Construct file information array |
642 |
|
|
vec.reserve(num_files); |
643 |
|
|
int cur_offset = dir_blocks * 254; |
644 |
|
|
for (int i=0; i<num_files; i++) { |
645 |
|
|
|
646 |
|
|
// Read and convert file name (strip trailing shift-spaces) |
647 |
|
|
uint8 name_buf[17]; |
648 |
|
|
fread(name_buf, 16, 1, f); |
649 |
|
|
name_buf[16] = 0xa0; |
650 |
|
|
uint8 *p = name_buf + 16; |
651 |
|
|
while (*p-- == 0xa0) ; |
652 |
|
|
p[2] = 0; |
653 |
|
|
|
654 |
|
|
// Read file length and type |
655 |
|
|
int num_blocks, last_block; |
656 |
|
|
char type_char; |
657 |
|
|
fscanf(f, "\x0d%d\x0d%c\x0d%d\x0d", &num_blocks, &type_char, &last_block); |
658 |
|
|
size_t size = (num_blocks - 1) * 254 + last_block - 1; |
659 |
|
|
|
660 |
|
|
int type; |
661 |
|
|
switch (type_char) { |
662 |
|
|
case 'S': |
663 |
|
|
type = FTYPE_SEQ; |
664 |
|
|
break; |
665 |
|
|
case 'U': |
666 |
|
|
type = FTYPE_USR; |
667 |
|
|
break; |
668 |
|
|
case 'R': |
669 |
|
|
type = FTYPE_REL; |
670 |
|
|
break; |
671 |
|
|
default: |
672 |
|
|
type = FTYPE_PRG; |
673 |
|
|
break; |
674 |
|
|
} |
675 |
|
|
|
676 |
|
|
// Read start address |
677 |
|
|
long here = ftell(f); |
678 |
|
|
uint8 sa_lo, sa_hi; |
679 |
|
|
fseek(f, cur_offset, SEEK_SET); |
680 |
|
|
fread(&sa_lo, 1, 1, f); |
681 |
|
|
fread(&sa_hi, 1, 1, f); |
682 |
|
|
fseek(f, here, SEEK_SET); |
683 |
|
|
|
684 |
|
|
// Add entry |
685 |
|
|
vec.push_back(c64_dir_entry(name_buf, type, false, false, size, cur_offset, sa_lo, sa_hi)); |
686 |
|
|
|
687 |
|
|
cur_offset += num_blocks * 254; |
688 |
|
|
} |
689 |
|
|
|
690 |
|
|
return true; |
691 |
|
|
} |
692 |
|
|
|
693 |
|
|
static bool parse_p00_file(FILE *f, vector<c64_dir_entry> &vec, char *dir_title) |
694 |
|
|
{ |
695 |
|
|
// Dummy directory title |
696 |
|
|
strcpy(dir_title, ".P00 FILE "); |
697 |
|
|
|
698 |
|
|
// Contains only one file |
699 |
|
|
vec.reserve(1); |
700 |
|
|
|
701 |
|
|
// Read file name and start address |
702 |
|
|
uint8 name_buf[17]; |
703 |
|
|
fseek(f, 8, SEEK_SET); |
704 |
|
|
fread(name_buf, 17, 1, f); |
705 |
|
|
name_buf[16] = 0; |
706 |
|
|
uint8 sa_lo, sa_hi; |
707 |
|
|
fseek(f, 26, SEEK_SET); |
708 |
|
|
fread(&sa_lo, 1, 1, f); |
709 |
|
|
fread(&sa_hi, 1, 1, f); |
710 |
|
|
|
711 |
|
|
// Get file size |
712 |
|
|
fseek(f, 0, SEEK_END); |
713 |
|
|
size_t size = ftell(f) - 26; |
714 |
|
|
|
715 |
|
|
// Add entry |
716 |
|
|
vec.push_back(c64_dir_entry(name_buf, FTYPE_PRG, false, false, size, 26, sa_lo, sa_hi)); |
717 |
|
|
return true; |
718 |
|
|
} |
719 |
|
|
|
720 |
|
|
bool ReadArchDirectory(const char *path, vector<c64_dir_entry> &vec) |
721 |
|
|
{ |
722 |
|
|
// Open file |
723 |
|
|
FILE *f = fopen(path, "rb"); |
724 |
|
|
if (f) { |
725 |
|
|
|
726 |
|
|
// Read header |
727 |
|
|
uint8 header[64]; |
728 |
|
|
fread(header, 1, sizeof(header), f); |
729 |
|
|
|
730 |
|
|
// Determine archive type and parse archive |
731 |
|
|
bool result = false; |
732 |
|
|
char dir_title[16]; |
733 |
|
|
if (is_t64_header(header)) |
734 |
|
|
result = parse_t64_file(f, vec, dir_title); |
735 |
|
|
else if (is_lynx_header(header)) |
736 |
|
|
result = parse_lynx_file(f, vec, dir_title); |
737 |
|
|
else if (is_p00_header(header)) |
738 |
|
|
result = parse_p00_file(f, vec, dir_title); |
739 |
|
|
|
740 |
|
|
fclose(f); |
741 |
|
|
return result; |
742 |
|
|
} else |
743 |
|
|
return false; |
744 |
cebix |
1.1 |
} |