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