437b3ba8 |
1 | #include <stdio.h> |
2 | #include <unistd.h> |
3 | #include <stdlib.h> |
4 | #include <fcntl.h> |
5 | #include <stdarg.h> |
6 | #include <sys/select.h> |
7 | #include "hw_types.h" |
8 | #include "hw_helpers.h" |
9 | #define XON 0x11 |
10 | #define XOFF 0x13 |
11 | #define CHAR_START 0x81 |
12 | // 0x93 |
13 | #define CHAR_END1 0223 |
14 | #define CHAR_END2 0223 |
15 | #define CHAR_END3 0223 |
16 | #define MAX_BLOCK_SIZE 500 |
17 | |
18 | //#define DEBUG |
19 | //#define DEBUG_CHECKSUM |
20 | //#define DEBUG_STRUCTURE |
21 | //#define IGNORE_CHECKSUM |
22 | #define HARDCORE_DEBUG |
23 | /********************************************************/ |
24 | void output (char *string, int length); |
25 | datablock *get_block (); |
26 | |
27 | /********************************************************/ |
28 | char ends[3] = { CHAR_END1, CHAR_END2, CHAR_END3 }; |
29 | int errflag = 0; // Global error flag |
30 | int tapemode = 0; |
31 | int inputfd; |
32 | int ignore = 0; |
33 | int dosplit = 0; |
34 | int splitnum = 0; |
77ce3d6a |
35 | int silent = 0; |
0413f345 |
36 | int read_pos = -5; |
37 | int block_pos= -5; |
437b3ba8 |
38 | /********************************************************/ |
39 | |
40 | |
41 | /********************************************************/ |
42 | void dump_data (void *data, int count) |
43 | { |
44 | int fd = open ("dump", O_RDWR | O_CREAT | O_APPEND, 0666); |
45 | write (fd, "***", 3); |
46 | write (fd, data, count); |
47 | close (fd); |
48 | } |
49 | |
50 | /********************************************************/ |
51 | void endwarn (int ret) |
52 | { |
53 | if (ret < 1) { |
54 | err ("Unexpected problem in input"); |
55 | exit (3); |
56 | } |
57 | } |
58 | |
59 | /********************************************************/ |
60 | /* Small output things */ |
61 | void err (char *string) |
62 | { |
63 | printf ("Error: --> %s\n", string); |
64 | errflag++; |
65 | } |
66 | |
67 | void msg (char *string) |
68 | { |
69 | #ifdef DEBUG |
70 | printf ("** %s\n", string); |
71 | #endif |
72 | } |
73 | |
74 | void msgf (char *format, ...) |
75 | { |
76 | va_list ag; |
77 | va_start (ag, format); |
78 | char ms[100]; |
79 | vsprintf (ms, format, ag); |
80 | msg (ms); |
81 | va_end (ag); |
82 | } |
83 | |
84 | void errf (char *format, ...) |
85 | { |
86 | va_list ag; |
87 | va_start (ag, format); |
88 | char ms[100]; |
89 | vsprintf (ms, format, ag); |
90 | err (ms); |
91 | va_end (ag); |
92 | } |
93 | |
94 | void say (char *string) |
95 | { |
77ce3d6a |
96 | if (!silent) printf ("%s\n", string); |
437b3ba8 |
97 | } |
98 | |
99 | void sayf (char *format, ...) |
100 | { |
101 | va_list ag; |
102 | va_start (ag, format); |
103 | char ms[100]; |
104 | vsprintf (ms, format, ag); |
105 | say (ms); |
106 | va_end (ag); |
107 | } |
108 | |
109 | |
110 | /********************************************************/ |
111 | /********************************************************/ |
112 | |
113 | /********************************************************/ |
114 | /*Block input routines*/ |
115 | |
116 | unsigned char decode (unsigned char in) |
117 | { |
118 | if (in & 64) |
119 | switch (in) { |
120 | case 0174: |
121 | return 05; |
122 | break; |
123 | case 0374: |
124 | return 045; |
125 | break; |
126 | case 0175: |
127 | return 012; |
128 | break; |
129 | case 0375: |
130 | return 052; |
131 | break; |
132 | case 0176: |
133 | return 021; |
134 | break; |
135 | case 0376: |
136 | return 061; |
137 | break; |
138 | case 0177: |
139 | return 023; |
140 | break; |
141 | case 0377: |
142 | return 063; |
143 | break; |
144 | default: |
145 | err ("decode(): Impossible case!!!\n"); |
146 | return 0; |
147 | break; |
148 | } else { |
149 | if (in & 128) |
150 | in |= 32; |
151 | return in; |
152 | } |
153 | |
154 | return 0; |
155 | } |
156 | |
157 | /********************************************************/ |
158 | /********************************************************/ |
159 | |
160 | void combine466 (unsigned char *raw, unsigned char *data) |
161 | { |
162 | hw16 *result = (hw16 *) data; |
163 | |
164 | // result->tape.low = 077; |
165 | unsigned char r1, r2, r3; |
166 | |
167 | r1 = decode ((raw)[0]) & 017; |
168 | r2 = decode ((raw)[1]) & 077; |
169 | r3 = decode ((raw)[2]) & 077; |
170 | |
171 | result->tape.high = r1; |
172 | result->tape.mid = r2; |
173 | result->tape.low = r3; |
174 | |
175 | #ifdef DEBUG_COMBINE |
176 | msgf ("combine466 (data) : %s%s%s", bin2str (r1, 4), bin2str (r2, 6), |
177 | bin2str (r3, 6)); |
178 | msgf ("combine466 (rawmem) : %s%s", bin2str (data[1], 8), |
179 | bin2str (data[0], 8)); |
180 | msgf ("combine466 (structure): %s", bin2str (result->value, 16)); |
181 | #endif |
182 | } |
183 | |
184 | /*********************************************************************/ |
185 | /*********************************************************************/ |
186 | int checksum_error (hw16 * data, int size) |
187 | { |
188 | unsigned short int checksumme = 0; |
189 | int c; |
190 | for (c = 0; c < (size - 1); c++) { |
191 | checksumme ^= data[c].value; |
192 | #ifdef DEBUG_CHECKSUM |
193 | msgf ("checksum_error(): Gelesen:%04x Berechnet:%04x", |
194 | data[c + 1].value, checksumme); |
195 | if (data[c + 1].value == checksumme) |
196 | msg ("checksum_error (): Treffer."); |
197 | #endif |
198 | } |
199 | #ifdef DEBUG_CHECKSUM |
200 | msgf ("checksum_error(): Gelesen:%04x Berechnet:%04x", |
201 | data[size - 1].value, checksumme); |
202 | #endif |
203 | if (data[size - 1].value != checksumme) |
204 | return 1; |
205 | return 0; |
206 | } |
207 | |
208 | /********************************************************/ |
209 | datablock *get_block() |
210 | { |
211 | int blk_size, round, ret, found, complete; |
212 | unsigned char buffer[3]; |
213 | hw16 *blk_data; |
214 | unsigned char *raw_data; |
215 | |
216 | if (tapemode) |
217 | tapestart (); |
218 | do { |
0413f345 |
219 | read_pos+=ret=read (inputfd, buffer, 1); |
220 | |
437b3ba8 |
221 | #ifdef HARDCORE_DEBUG |
222 | msgf ("READ : (hex)%02x (bin)%s (dec)%3i (oct)%3o", |
223 | buffer[0], bin2str (buffer[0], 8), buffer[0], buffer[0]); |
224 | #endif |
225 | if (ret < 1) { |
226 | msg ("get_block(): Nichts mehr zu lesen"); |
227 | return NULL; |
228 | } |
229 | |
230 | if (buffer[0]==0x83){ |
231 | datablock *result = (datablock *) malloc (sizeof (datablock)); |
232 | result->type = BT_STOP; |
233 | result->data = NULL; |
234 | result->raw_data = NULL; |
235 | result->size = 0; |
236 | return result; |
237 | } |
238 | |
239 | } while (*buffer != (unsigned char) CHAR_START); |
0413f345 |
240 | |
241 | block_pos=read_pos; |
437b3ba8 |
242 | msg ("get_block(): Blockstart erkannt"); |
243 | |
244 | // blk_data = (hw16 *) malloc (MAX_BLOCK_SIZE * sizeof (hw16)); |
245 | blk_data=NULL; |
246 | raw_data=NULL; |
247 | round = 0; |
248 | blk_size = 0; |
249 | |
250 | do { |
251 | complete = 0; |
252 | ret = read (inputfd, buffer + round, 1); |
0413f345 |
253 | read_pos+=ret; |
437b3ba8 |
254 | #ifdef HARDCORE_DEBUG |
255 | static int lochzahl = 0; |
256 | char *bin = bin2str (buffer[round], 8); |
257 | int a; |
258 | for (a = 0; a < 8; a++) |
259 | if (bin[a] == '1') |
260 | lochzahl++; |
261 | msgf ("READ (round %i): (hex)%02x (bin)%s (dec)%3i " |
262 | " (oct)%3o Lochzahl:%4i", |
263 | round, buffer[round], bin, buffer[round], buffer[round], lochzahl); |
264 | |
265 | // msgf ("READ(round %i) (hex)%02x", round, buffer[round]); |
266 | #endif |
267 | endwarn (ret); |
268 | round++; |
269 | found = 0; |
270 | if (buffer[round - 1] == CHAR_END1) |
271 | found++; |
272 | if (buffer[round - 1] == CHAR_END2) |
273 | found++; |
274 | |
275 | if (found) { |
276 | complete++; |
277 | } else { |
278 | if (round == 3) { |
279 | //if (blk_size == MAX_BLOCK_SIZE) { |
280 |