]>
Commit | Line | Data |
---|---|---|
583a1ce5 TT |
1 | /* |
2 | ||
3 | /usr/src/ext2ed/general_com.c | |
4 | ||
5 | A part of the extended file system 2 disk editor. | |
6 | ||
7 | --------------------- | |
8 | General user commands | |
9 | --------------------- | |
10 | ||
11 | First written on: April 9 1995 | |
12 | ||
13 | Copyright (C) 1995 Gadi Oxman | |
14 | ||
15 | */ | |
16 | ||
d1154eb4 | 17 | #include "config.h" |
583a1ce5 TT |
18 | #include <stdio.h> |
19 | #include <stdlib.h> | |
20 | #include <string.h> | |
21 | ||
22 | #include "ext2ed.h" | |
7c36779a | 23 | #include "../version.h" |
583a1ce5 TT |
24 | |
25 | void help (char *command_line) | |
26 | ||
27 | { | |
28 | int i,max_line=0; | |
29 | char argument [80],*ptr; | |
30 | ||
31 | werase (show_pad);wmove (show_pad,0,0); | |
32 | ||
33 | ptr=parse_word (command_line,argument); | |
34 | ||
35 | if (*ptr!=0) { | |
36 | ptr=parse_word (ptr,argument); | |
efc6f628 | 37 | if (*argument!=0) { |
583a1ce5 TT |
38 | detailed_help (argument); |
39 | return; | |
40 | } | |
41 | } | |
42 | ||
43 | if (current_type!=NULL) { | |
efc6f628 | 44 | |
583a1ce5 | 45 | wprintw (show_pad,"Type %s specific commands:\n",current_type->name);max_line++; |
efc6f628 | 46 | |
583a1ce5 TT |
47 | if (current_type->type_commands.last_command==-1) { |
48 | wprintw (show_pad,"\nnone\n");max_line+=2; | |
49 | } | |
50 | else | |
51 | for (i=0;i<=current_type->type_commands.last_command;i++) { | |
52 | if (i%5==0) { | |
53 | wprintw (show_pad,"\n");max_line++; | |
54 | } | |
55 | wprintw (show_pad,"%-13s",current_type->type_commands.names [i]); | |
56 | if (i%5!=4) | |
efc6f628 | 57 | wprintw (show_pad,"; "); |
583a1ce5 | 58 | } |
efc6f628 | 59 | |
583a1ce5 | 60 | wprintw (show_pad,"\n\n");max_line+=2; |
efc6f628 | 61 | } |
583a1ce5 TT |
62 | |
63 | if (ext2_commands.last_command != -1) { | |
64 | wprintw (show_pad,"ext2 filesystem general commands: \n");max_line++; | |
65 | for (i=0;i<=ext2_commands.last_command;i++) { | |
66 | if (i%5==0) { | |
67 | wprintw (show_pad,"\n");max_line++; | |
68 | } | |
69 | wprintw (show_pad,"%-13s",ext2_commands.names [i]); | |
70 | if (i%5!=4) | |
efc6f628 | 71 | wprintw (show_pad,"; "); |
583a1ce5 TT |
72 | |
73 | } | |
74 | wprintw (show_pad,"\n\n");max_line+=2; | |
75 | } | |
76 | ||
77 | wprintw (show_pad,"General commands: \n"); | |
efc6f628 | 78 | |
583a1ce5 TT |
79 | for (i=0;i<=general_commands.last_command;i++) { |
80 | if (i%5==0) { | |
81 | wprintw (show_pad,"\n");max_line++; | |
82 | } | |
83 | wprintw (show_pad,"%-13s",general_commands.names [i]); | |
84 | if (i%5!=4) | |
efc6f628 | 85 | wprintw (show_pad,"; "); |
583a1ce5 | 86 | } |
efc6f628 | 87 | |
583a1ce5 | 88 | wprintw (show_pad,"\n\n");max_line+=2; |
efc6f628 | 89 | |
7c36779a | 90 | wprintw (show_pad,"EXT2ED ver %s (%s)\n",E2FSPROGS_VERSION, E2FSPROGS_DATE); |
583a1ce5 | 91 | wprintw (show_pad,"Copyright (C) 1995 Gadi Oxman\n"); |
0f31c737 | 92 | wprintw (show_pad,"Reviewed 2001 Christian Bac\n"); |
ce20096f | 93 | wprintw (show_pad,"Modified and enhanced by Theodore Ts'o, 2002\n"); |
583a1ce5 TT |
94 | wprintw (show_pad,"EXT2ED is hereby placed under the terms of the GNU General Public License.\n\n"); |
95 | wprintw (show_pad,"EXT2ED was programmed as a student project in the software laboratory\n"); | |
96 | wprintw (show_pad,"of the faculty of electrical engineering in the\n"); | |
97 | wprintw (show_pad,"Technion - Israel Institute of Technology\n"); | |
98 | wprintw (show_pad,"with the guide of Avner Lottem and Dr. Ilana David.\n"); | |
99 | ||
5e941d29 | 100 | max_line+=10; |
efc6f628 | 101 | |
583a1ce5 TT |
102 | show_pad_info.line=0;show_pad_info.max_line=max_line; |
103 | ||
104 | werase (show_win);wmove (show_win,0,0); | |
105 | wprintw (show_win,"EXT2ED help"); | |
efc6f628 | 106 | |
583a1ce5 TT |
107 | refresh_show_win (); |
108 | refresh_show_pad (); | |
109 | } | |
110 | ||
111 | void detailed_help (char *text) | |
112 | ||
113 | { | |
114 | int i; | |
efc6f628 | 115 | |
583a1ce5 TT |
116 | if (current_type != NULL) |
117 | for (i=0;i<=current_type->type_commands.last_command;i++) { | |
118 | if (strcmp (current_type->type_commands.names [i],text)==0) { | |
119 | wprintw (show_pad,"%s - %s\n",text,current_type->type_commands.descriptions [i]); | |
120 | refresh_show_pad ();return; | |
121 | } | |
122 | } | |
123 | ||
124 | for (i=0;i<=ext2_commands.last_command;i++) { | |
125 | if (strcmp (ext2_commands.names [i],text)==0) { | |
126 | wprintw (show_pad,"%s - %s\n",text,ext2_commands.descriptions [i]); | |
127 | refresh_show_pad ();return; | |
128 | } | |
129 | } | |
130 | ||
131 | for (i=0;i<=general_commands.last_command;i++) { | |
132 | if (strcmp (general_commands.names [i],text)==0) { | |
133 | wprintw (show_pad,"%s - %s\n",text,general_commands.descriptions [i]); | |
134 | refresh_show_pad ();return; | |
135 | } | |
136 | } | |
137 | ||
138 | if (strcmp ("quit",text)==0) { | |
139 | wprintw (show_pad,"quit - Exists EXT2ED"); | |
140 | refresh_show_pad ();return; | |
141 | } | |
142 | ||
ce20096f | 143 | wprintw (show_pad,"Error - Command %s not available now\n",text); |
583a1ce5 TT |
144 | refresh_show_pad ();return; |
145 | } | |
146 | ||
147 | ||
148 | ||
149 | void set_device (char *command_line) | |
150 | ||
151 | { | |
152 | char *ptr,new_device [80]; | |
efc6f628 | 153 | |
583a1ce5 TT |
154 | ptr=parse_word (command_line,new_device); |
155 | if (*ptr==0) { | |
156 | wprintw (command_win,"Error - Device name not specified\n"); | |
157 | refresh_command_win ();return; | |
158 | } | |
efc6f628 | 159 | parse_word (ptr,new_device); |
583a1ce5 TT |
160 | check_mounted (new_device); |
161 | if (mounted && !AllowMountedRead) { | |
162 | wprintw (command_win,"Error - Filesystem is mounted, aborting\n"); | |
163 | wprintw (command_win,"You may wish to use the AllowMountedRead on configuration option\n"); | |
164 | refresh_command_win ();return; | |
165 | } | |
efc6f628 | 166 | |
583a1ce5 TT |
167 | if (mounted && AllowMountedRead) { |
168 | wprintw (command_win,"Warning - Filesystem is mounted. Displayed data may be unreliable.\n"); | |
169 | refresh_command_win (); | |
170 | } | |
171 | ||
172 | if (device_handle!=NULL) | |
173 | fclose (device_handle); | |
efc6f628 | 174 | |
583a1ce5 TT |
175 | if ( (device_handle=fopen (new_device,"rb"))==NULL) { |
176 | wprintw (command_win,"Error - Can not open device %s\n",new_device);refresh_command_win (); | |
177 | return; | |
178 | } | |
179 | else { | |
180 | strcpy (device_name,new_device); | |
181 | write_access=0; /* Write access disabled */ | |
182 | current_type=NULL; /* There is no type now */ | |
183 | remember_lifo.entries_count=0; /* Empty Object memory */ | |
184 | free_user_commands (&ext2_commands); /* Free filesystem specific objects */ | |
185 | free_struct_descriptors (); | |
186 | if (!set_file_system_info ()) { /* Error while getting info --> abort */ | |
187 | free_user_commands (&ext2_commands); | |
188 | free_struct_descriptors (); | |
189 | fclose (device_handle); | |
190 | device_handle=NULL; /* Notice that our device is still not set up */ | |
191 | device_offset=-1; | |
192 | return; | |
193 | } | |
194 | if (*AlternateDescriptors) /* Check if user defined objects exist */ | |
195 | set_struct_descriptors (AlternateDescriptors); | |
196 | dispatch ("setoffset 0"); | |
197 | dispatch ("help"); /* Show help screen */ | |
198 | wprintw (command_win,"Device changed to %s",device_name);refresh_command_win (); | |
199 | } | |
200 | } | |
201 | ||
202 | void set_offset (char *command_line) | |
203 | ||
204 | { | |
205 | long mult=1; | |
206 | long new_offset; | |
207 | char *ptr,new_offset_buffer [80]; | |
efc6f628 | 208 | |
583a1ce5 TT |
209 | if (device_handle==NULL) { |
210 | wprintw (command_win,"Error - No device opened\n");refresh_command_win (); | |
211 | return; | |
212 | } | |
efc6f628 | 213 | |
583a1ce5 | 214 | ptr=parse_word (command_line,new_offset_buffer); |
efc6f628 | 215 | |
583a1ce5 TT |
216 | if (*ptr==0) { |
217 | wprintw (command_win,"Error - No argument specified\n");refresh_command_win (); | |
218 | return; | |
219 | } | |
220 | ||
221 | ptr=parse_word (ptr,new_offset_buffer); | |
222 | ||
223 | if (strcmp (new_offset_buffer,"block")==0) { | |
224 | mult=file_system_info.block_size; | |
225 | ptr=parse_word (ptr,new_offset_buffer); | |
226 | } | |
227 | ||
228 | if (strcmp (new_offset_buffer,"type")==0) { | |
229 | if (current_type==NULL) { | |
230 | wprintw (command_win,"Error - No type set\n");refresh_command_win (); | |
231 | return; | |
232 | } | |
233 | ||
234 | mult=current_type->length; | |
235 | ptr=parse_word (ptr,new_offset_buffer); | |
236 | } | |
237 | ||
238 | if (*new_offset_buffer==0) { | |
239 | wprintw (command_win,"Error - No offset specified\n");refresh_command_win (); | |
240 | return; | |
241 | } | |
242 | ||
243 | if (new_offset_buffer [0]=='+') { | |
244 | if (device_offset==-1) { | |
245 | wprintw (command_win,"Error - Select a fixed offset first\n");refresh_command_win (); | |
246 | return; | |
247 | } | |
248 | new_offset=device_offset+atol (new_offset_buffer+1)*mult; | |
249 | } | |
efc6f628 | 250 | |
583a1ce5 TT |
251 | else if (new_offset_buffer [0]=='-') { |
252 | if (device_offset==-1) { | |
253 | wprintw (command_win,"Error - Select a fixed offset first\n");refresh_command_win (); | |
254 | return; | |
255 | } | |
256 | new_offset=device_offset-atol (new_offset_buffer+1)*mult; | |
257 | if (new_offset<0) new_offset=0; | |
258 | } | |
efc6f628 TT |
259 | |
260 | else | |
583a1ce5 | 261 | new_offset=atol (new_offset_buffer)*mult; |
efc6f628 | 262 | |
583a1ce5 TT |
263 | if ( (fseek (device_handle,new_offset,SEEK_SET))==-1) { |
264 | wprintw (command_win,"Error - Failed to seek to offset %ld in device %s\n",new_offset,device_name); | |
265 | refresh_command_win (); | |
266 | return; | |
267 | }; | |
268 | device_offset=new_offset; | |
269 | wprintw (command_win,"Device offset changed to %ld\n",device_offset);refresh_command_win (); | |
270 | load_type_data (); | |
271 | type_data.offset_in_block=0; | |
272 | } | |
273 | ||
7c36779a TT |
274 | void set_int(short len, void *ptr, char *name, char *value) |
275 | { | |
276 | char *char_ptr; | |
277 | short *short_ptr; | |
278 | long *long_ptr; | |
279 | long v; | |
280 | char *tmp; | |
281 | ||
282 | v = strtol(value, &tmp, 0); | |
283 | if (*tmp) { | |
284 | wprintw( command_win, "Bad value - %s\n", value); | |
285 | return; | |
286 | } | |
287 | switch (len) { | |
288 | case 1: | |
289 | char_ptr = (char *) ptr; | |
290 | *char_ptr = v; | |
291 | break; | |
292 | case 2: | |
293 | short_ptr = (short *) ptr; | |
294 | *short_ptr = v; | |
295 | break; | |
296 | case 4: | |
297 | long_ptr = (long *) ptr; | |
298 | *long_ptr = v; | |
299 | break; | |
300 | default: | |
301 | wprintw (command_win, | |
302 | "set_int: unsupported length: %d\n", len); | |
303 | return; | |
304 | } | |
305 | wprintw (command_win, "Variable %s set to %s\n", | |
306 | name, value); | |
307 | } | |
308 | ||
309 | void set_uint(short len, void *ptr, char *name, char *value) | |
310 | { | |
311 | unsigned char *char_ptr; | |
312 | unsigned short *short_ptr; | |
313 | unsigned long *long_ptr; | |
314 | unsigned long v; | |
315 | char *tmp; | |
316 | ||
317 | v = strtoul(value, &tmp, 0); | |
318 | if (*tmp) { | |
319 | wprintw( command_win, "Bad value - %s\n", value); | |
320 | return; | |
321 | } | |
322 | switch (len) { | |
323 | case 1: | |
324 | char_ptr = (unsigned char *) ptr; | |
325 | *char_ptr = v; | |
326 | break; | |
327 | case 2: | |
328 | short_ptr = (unsigned short *) ptr; | |
329 | *short_ptr = v; | |
330 | break; | |
331 | case 4: | |
332 | long_ptr = (unsigned long *) ptr; | |
333 | *long_ptr = v; | |
334 | break; | |
335 | default: | |
336 | wprintw (command_win, | |
337 | "set_uint: unsupported length: %d\n", len); | |
338 | return; | |
339 | } | |
340 | wprintw (command_win, "Variable %s set to %s\n", | |
341 | name, value); | |
342 | } | |
343 | ||
344 | void set_char(short len, void *ptr, char *name, char *value) | |
345 | { | |
346 | if (strlen(value)+1 > len) { | |
347 | wprintw( command_win, "Value %s too big for field\n", | |
348 | name, len); | |
349 | return; | |
350 | } | |
351 | memset(ptr, 0, len); | |
352 | strcpy((char *) ptr, value); | |
353 | wprintw (command_win, "Variable %s set to %s\n", | |
354 | name, value); | |
355 | } | |
356 | ||
357 | ||
583a1ce5 TT |
358 | void set (char *command_line) |
359 | ||
360 | { | |
361 | unsigned short *int_ptr; | |
362 | unsigned char *char_ptr; | |
363 | unsigned long *long_ptr,offset=0; | |
7c36779a | 364 | int i,len, found=0; |
583a1ce5 | 365 | char *ptr,buffer [80],variable [80],value [80]; |
efc6f628 | 366 | |
583a1ce5 TT |
367 | if (device_handle==NULL) { |
368 | wprintw (command_win,"Error - No device opened\n");refresh_command_win (); | |
369 | return; | |
370 | } | |
371 | ||
372 | if (current_type==NULL) { | |
373 | hex_set (command_line); | |
374 | return; | |
375 | } | |
376 | ||
377 | ptr=parse_word (command_line,buffer); | |
378 | if (ptr==NULL || *ptr==0) { | |
379 | wprintw (command_win,"Error - Missing arguments\n");refresh_command_win (); | |
380 | return; | |
381 | } | |
382 | parse_word (ptr,buffer); | |
383 | ptr=strchr (buffer,'='); | |
384 | if (ptr==NULL) { | |
385 | wprintw (command_win,"Error - Bad syntax\n");refresh_command_win ();return; | |
386 | } | |
387 | strncpy (variable,buffer,ptr-buffer);variable [ptr-buffer]=0; | |
388 | strcpy (value,++ptr); | |
389 | ||
390 | if (current_type==NULL) { | |
391 | wprintw (command_win,"Sorry, not yet supported\n");refresh_command_win ();return; | |
392 | } | |
efc6f628 | 393 | |
583a1ce5 TT |
394 | for (i=0;i<current_type->fields_num && !found;i++) { |
395 | if (strcmp (current_type->field_names [i],variable)==0) { | |
396 | found=1; | |
397 | ptr=type_data.u.buffer+offset; | |
7c36779a TT |
398 | len = current_type->field_lengths [i]; |
399 | switch (current_type->field_types [i]) { | |
400 | case FIELD_TYPE_INT: | |
401 | set_int(len, ptr, variable, value); | |
402 | break; | |
403 | case FIELD_TYPE_UINT: | |
404 | set_uint(len, ptr, variable, value); | |
405 | break; | |
406 | case FIELD_TYPE_CHAR: | |
407 | set_char(len, ptr, variable, value); | |
408 | break; | |
409 | default: | |
410 | wprintw (command_win, | |
411 | "set: unhandled type %d\n", | |
412 | current_type->field_types [i]); | |
413 | break; | |
583a1ce5 | 414 | } |
7c36779a | 415 | refresh_command_win (); |
583a1ce5 TT |
416 | } |
417 | offset+=current_type->field_lengths [i]; | |
418 | } | |
419 | if (found) | |
420 | dispatch ("show"); | |
421 | else { | |
422 | wprintw (command_win,"Error - Variable %s not found\n",variable); | |
423 | refresh_command_win (); | |
424 | } | |
425 | } | |
426 | ||
427 | void hex_set (char *command_line) | |
428 | ||
429 | { | |
430 | unsigned char tmp; | |
431 | char *ptr,buffer [80],*ch_ptr; | |
432 | int mode=HEX; | |
efc6f628 | 433 | |
583a1ce5 TT |
434 | ptr=parse_word (command_line,buffer); |
435 | if (*ptr==0) { | |
436 | wprintw (command_win,"Error - Argument not specified\n");refresh_command_win ();return; | |
437 | } | |
438 | ||
439 | ptr=parse_word (ptr,buffer); | |
440 | ||
441 | if (strcasecmp (buffer,"text")==0) { | |
442 | mode=TEXT; | |
443 | strcpy (buffer,ptr); | |
444 | } | |
445 | ||
446 | else if (strcasecmp (buffer,"hex")==0) { | |
447 | mode=HEX; | |
448 | ptr=parse_word (ptr,buffer); | |
449 | } | |
450 | ||
451 | if (*buffer==0) { | |
452 | wprintw (command_win,"Error - Data not specified\n");refresh_command_win ();return; | |
453 | } | |
454 | ||
455 | if (mode==HEX) { | |
456 | do { | |
457 | tmp=(unsigned char) strtol (buffer,NULL,16); | |
458 | type_data.u.buffer [type_data.offset_in_block]=tmp; | |
459 | type_data.offset_in_block++; | |
460 | ptr=parse_word (ptr,buffer); | |
461 | if (type_data.offset_in_block==file_system_info.block_size) { | |
462 | if (*ptr) { | |
463 | wprintw (command_win,"Error - Ending offset outside block, only partial string changed\n"); | |
464 | refresh_command_win (); | |
465 | } | |
466 | type_data.offset_in_block--; | |
467 | } | |
468 | } while (*buffer) ; | |
469 | } | |
470 | ||
471 | else { | |
472 | ch_ptr=buffer; | |
473 | while (*ch_ptr) { | |
474 | tmp=(unsigned char) *ch_ptr++; | |
475 | type_data.u.buffer [type_data.offset_in_block]=tmp; | |
476 | type_data.offset_in_block++; | |
477 | if (type_data.offset_in_block==file_system_info.block_size) { | |
478 | if (*ch_ptr) { | |
479 | wprintw (command_win,"Error - Ending offset outside block, only partial string changed\n"); | |
480 | refresh_command_win (); | |
481 | } | |
482 | type_data.offset_in_block--; | |
483 | } | |
484 | } | |
485 | } | |
efc6f628 | 486 | |
583a1ce5 TT |
487 | strcpy (buffer,"show");dispatch (buffer); |
488 | } | |
489 | ||
490 | ||
491 | ||
492 | void set_type (char *command_line) | |
493 | ||
494 | { | |
495 | struct struct_descriptor *descriptor_ptr; | |
496 | char *ptr,buffer [80],tmp_buffer [80]; | |
497 | short found=0; | |
498 | ||
499 | if (!load_type_data ()) | |
500 | return; | |
501 | ||
502 | ptr=parse_word (command_line,buffer); | |
503 | parse_word (ptr,buffer); | |
efc6f628 | 504 | |
583a1ce5 TT |
505 | if (strcmp (buffer,"none")==0 || strcmp (buffer,"hex")==0) { |
506 | wprintw (command_win,"Data will be shown as hex dump\n");refresh_command_win (); | |
507 | current_type=NULL; | |
508 | sprintf (tmp_buffer,"show");dispatch (tmp_buffer); | |
509 | return; | |
510 | } | |
efc6f628 | 511 | |
583a1ce5 TT |
512 | descriptor_ptr=first_type; |
513 | while (descriptor_ptr!=NULL && !found) { | |
514 | if (strcmp (descriptor_ptr->name,buffer)==0) | |
515 | found=1; | |
516 | else | |
517 | descriptor_ptr=descriptor_ptr->next; | |
518 | } | |
519 | if (found) { | |
520 | wprintw (command_win,"Structure type set to %s\n",buffer);refresh_command_win (); | |
521 | current_type=descriptor_ptr; | |
522 | sprintf (tmp_buffer,"show");dispatch (tmp_buffer); | |
523 | } | |
524 | else { | |
525 | wprintw (command_win,"Error - %s is not a valid type\n",buffer);refresh_command_win (); | |
526 | } | |
efc6f628 | 527 | } |
583a1ce5 | 528 | |
7c36779a TT |
529 | void show_int(short len, void *ptr) |
530 | { | |
531 | long temp; | |
532 | char *format; | |
533 | ||
534 | switch (len) { | |
535 | case 1: | |
536 | temp = *((char *) ptr); | |
537 | format = "%3d (0x%02x)\n"; | |
538 | break; | |
539 | case 2: | |
540 | temp = *((short *) ptr); | |
541 | format = "%d (0x%x)\n"; | |
542 | break; | |
543 | case 4: | |
544 | temp = *((long *) ptr); | |
545 | format = "%d\n"; | |
546 | break; | |
547 | default: | |
548 | wprintw (show_pad, "unimplemented\n"); | |
549 | return; | |
550 | } | |
551 | wprintw(show_pad, format, temp, temp); | |
552 | } | |
553 | ||
554 | void show_uint(short len, void *ptr) | |
555 | { | |
556 | unsigned long temp; | |
557 | char *format; | |
558 | ||
559 | switch (len) { | |
560 | case 1: | |
561 | temp = *((unsigned char *) ptr); | |
562 | temp = temp & 0xFF; | |
563 | format = "%3u (0x%02x)\n"; | |
564 | break; | |
565 | case 2: | |
566 | temp = *((unsigned short *) ptr); | |
567 | temp = temp & 0xFFFF; | |
568 | format = "%u (0x%x)\n"; | |
569 | break; | |
570 | case 4: | |
571 | temp = (unsigned long) *((unsigned long *) ptr); | |
572 | format = "%u\n"; | |
573 | break; | |
574 | default: | |
575 | wprintw (show_pad, "unimplemented\n"); | |
576 | return; | |
577 | } | |
578 | wprintw(show_pad, format, temp, temp); | |
579 | } | |
580 | ||
581 | void show_char(short len, void *ptr) | |
582 | { | |
583 | unsigned char *cp = (unsigned char *) ptr; | |
584 | unsigned char ch; | |
585 | int i,j; | |
586 | ||
587 | wprintw(show_pad, "\""); | |
efc6f628 | 588 | |
7c36779a TT |
589 | for (i=0; i < len; i++) { |
590 | ch = *cp++; | |
591 | if (ch == 0) { | |
592 | for (j=i+1; j < len; j++) | |
593 | if (cp[j-i]) | |
594 | break; | |
595 | if (j == len) | |
596 | break; | |
597 | } | |
598 | if (ch > 128) { | |
599 | wprintw(show_pad, "M-"); | |
600 | ch -= 128; | |
601 | } | |
602 | if ((ch < 32) || (ch == 0x7f)) { | |
603 | wprintw(show_pad, "^"); | |
604 | ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */ | |
605 | } | |
606 | wprintw(show_pad, "%c", ch); | |
607 | } | |
efc6f628 | 608 | |
7c36779a TT |
609 | wprintw(show_pad, "\"\n"); |
610 | } | |
611 | ||
583a1ce5 | 612 | |
efc6f628 | 613 | |
583a1ce5 TT |
614 | void show (char *command_line) |
615 | ||
616 | { | |
7c36779a | 617 | unsigned int i,l,len,temp_int; |
efc6f628 | 618 | unsigned long offset=0,temp_long; |
583a1ce5 TT |
619 | unsigned char temp_char,*ch_ptr; |
620 | void *ptr; | |
621 | ||
622 | if (device_handle==NULL) | |
623 | return; | |
624 | ||
625 | show_pad_info.line=0; | |
efc6f628 | 626 | |
583a1ce5 TT |
627 | if (current_type==NULL) { |
628 | wmove (show_pad,0,0); | |
629 | ch_ptr=type_data.u.buffer; | |
630 | for (l=0;l<file_system_info.block_size/16;l++) { | |
631 | wprintw (show_pad,"%08ld : ",offset); | |
632 | for (i=0;i<16;i++) { | |
633 | if (type_data.offset_in_block==offset+i) | |
634 | wattrset (show_pad,A_REVERSE); | |
efc6f628 | 635 | |
583a1ce5 TT |
636 | if (ch_ptr [i]>=' ' && ch_ptr [i]<='z') |
637 | wprintw (show_pad,"%c",ch_ptr [i]); | |
638 | else | |
639 | wprintw (show_pad,"."); | |
640 | if (type_data.offset_in_block==offset+i) | |
641 | wattrset (show_pad,A_NORMAL); | |
642 | } | |
643 | wprintw (show_pad," "); | |
644 | for (i=0;i<16;i++) { | |
645 | if (type_data.offset_in_block==offset+i) | |
646 | wattrset (show_pad,A_REVERSE); | |
efc6f628 | 647 | |
583a1ce5 TT |
648 | wprintw (show_pad,"%02x",ch_ptr [i]); |
649 | ||
650 | if (type_data.offset_in_block==offset+i) { | |
651 | wattrset (show_pad,A_NORMAL); | |
652 | show_pad_info.line=l-l % show_pad_info.display_lines; | |
653 | } | |
654 | ||
655 | wprintw (show_pad," "); | |
656 | } | |
657 | wprintw (show_pad,"\n"); | |
658 | offset+=16; | |
659 | ch_ptr+=16; | |
660 | } | |
661 | show_pad_info.max_line=l-1;show_pad_info.max_col=COLS-1; | |
662 | refresh_show_pad ();show_info (); | |
663 | } | |
664 | else { | |
665 | wmove (show_pad,0,0);l=0; | |
666 | for (i=0;i<current_type->fields_num;i++) { | |
667 | wprintw (show_pad,"%-20s = ",current_type->field_names [i]); | |
668 | ptr=type_data.u.buffer+offset; | |
7c36779a TT |
669 | len = current_type->field_lengths[i]; |
670 | switch (current_type->field_types[i]) { | |
671 | case FIELD_TYPE_INT: | |
672 | show_int(len, ptr); | |
673 | break; | |
674 | case FIELD_TYPE_UINT: | |
675 | show_uint(len, ptr); | |
676 | break; | |
677 | case FIELD_TYPE_CHAR: | |
678 | show_char(len, ptr); | |
679 | break; | |
680 | default: | |
681 | wprintw (show_pad, "unimplemented\n"); | |
682 | break; | |
583a1ce5 | 683 | } |
7c36779a TT |
684 | offset+=len; |
685 | l++; | |
583a1ce5 TT |
686 | } |
687 | current_type->length=offset; | |
688 | show_pad_info.max_line=l-1; | |
689 | refresh_show_pad ();show_info (); | |
690 | } | |
691 | } | |
692 | ||
693 | void next (char *command_line) | |
694 | ||
695 | { | |
696 | long offset=1; | |
697 | char *ptr,buffer [80]; | |
698 | ||
699 | ptr=parse_word (command_line,buffer); | |
efc6f628 | 700 | |
583a1ce5 TT |
701 | if (*ptr!=0) { |
702 | ptr=parse_word (ptr,buffer); | |
703 | offset*=atol (buffer); | |
704 | } | |
efc6f628 | 705 | |
583a1ce5 TT |
706 | if (current_type!=NULL) { |
707 | sprintf (buffer,"setoffset type +%ld",offset); | |
708 | dispatch (buffer); | |
709 | return; | |
710 | } | |
711 | ||
712 | if (type_data.offset_in_block+offset < file_system_info.block_size) { | |
713 | type_data.offset_in_block+=offset; | |
714 | sprintf (buffer,"show");dispatch (buffer); | |
715 | } | |
efc6f628 | 716 | |
583a1ce5 TT |
717 | else { |
718 | wprintw (command_win,"Error - Offset out of block\n");refresh_command_win (); | |
719 | } | |
720 | } | |
721 | ||
722 | void prev (char *command_line) | |
723 | ||
724 | { | |
725 | long offset=1; | |
726 | char *ptr,buffer [80]; | |
727 | ||
728 | ptr=parse_word (command_line,buffer); | |
efc6f628 | 729 | |
583a1ce5 TT |
730 | if (*ptr!=0) { |
731 | ptr=parse_word (ptr,buffer); | |
732 | offset*=atol (buffer); | |
733 | } | |
efc6f628 | 734 | |
583a1ce5 TT |
735 | if (current_type!=NULL) { |
736 | sprintf (buffer,"setoffset type -%ld",offset); | |
737 | dispatch (buffer); | |
738 | return; | |
739 | } | |
740 | ||
741 | if (type_data.offset_in_block-offset >= 0) { | |
742 | type_data.offset_in_block-=offset; | |
743 | sprintf (buffer,"show");dispatch (buffer); | |
744 | } | |
efc6f628 | 745 | |
583a1ce5 TT |
746 | else { |
747 | wprintw (command_win,"Error - Offset out of block\n");refresh_command_win (); | |
748 | } | |
749 | } | |
750 | ||
efc6f628 | 751 | void pgdn (char *commnad_line) |
583a1ce5 TT |
752 | |
753 | { | |
754 | show_pad_info.line+=show_pad_info.display_lines; | |
755 | refresh_show_pad ();refresh_show_win (); | |
756 | } | |
757 | ||
758 | void pgup (char *command_line) | |
759 | ||
760 | { | |
761 | show_pad_info.line-=show_pad_info.display_lines; | |
762 | refresh_show_pad ();refresh_show_win (); | |
763 | } | |
764 | ||
765 | void redraw (char *command_line) | |
766 | ||
767 | { | |
768 | redraw_all (); | |
769 | dispatch ("show"); | |
770 | } | |
771 | ||
772 | void remember (char *command_line) | |
773 | ||
774 | { | |
775 | long entry_num; | |
776 | char *ptr,buffer [80]; | |
efc6f628 | 777 | |
583a1ce5 TT |
778 | if (device_handle==NULL) { |
779 | wprintw (command_win,"Error - No device opened\n");refresh_command_win (); | |
780 | return; | |
781 | } | |
782 | ||
783 | ptr=parse_word (command_line,buffer); | |
efc6f628 | 784 | |
583a1ce5 TT |
785 | if (*ptr==0) { |
786 | wprintw (command_win,"Error - Argument not specified\n");refresh_command_win (); | |
efc6f628 | 787 | return; |
583a1ce5 | 788 | } |
efc6f628 | 789 | |
583a1ce5 TT |
790 | ptr=parse_word (ptr,buffer); |
791 | ||
792 | entry_num=remember_lifo.entries_count++; | |
793 | if (entry_num>REMEMBER_COUNT-1) { | |
794 | entry_num=0; | |
795 | remember_lifo.entries_count--; | |
796 | } | |
efc6f628 | 797 | |
583a1ce5 TT |
798 | remember_lifo.offset [entry_num]=device_offset; |
799 | remember_lifo.type [entry_num]=current_type; | |
800 | strcpy (remember_lifo.name [entry_num],buffer); | |
efc6f628 | 801 | |
583a1ce5 TT |
802 | if (current_type!=NULL) |
803 | wprintw (command_win,"Object %s in Offset %ld remembered as %s\n",current_type->name,device_offset,buffer); | |
804 | else | |
805 | wprintw (command_win,"Offset %ld remembered as %s\n",device_offset,buffer); | |
efc6f628 | 806 | |
583a1ce5 TT |
807 | refresh_command_win (); |
808 | } | |
809 | ||
810 | void recall (char *command_line) | |
811 | ||
812 | { | |
813 | char *ptr,buffer [80]; | |
814 | long entry_num; | |
815 | ||
816 | if (device_handle==NULL) { | |
817 | wprintw (command_win,"Error - No device opened\n");refresh_command_win (); | |
818 | return; | |
819 | } | |
820 | ||
821 | ptr=parse_word (command_line,buffer); | |
822 | ||
823 | if (*ptr==0) { | |
824 | wprintw (command_win,"Error - Argument not specified\n");refresh_command_win (); | |
efc6f628 | 825 | return; |
583a1ce5 TT |
826 | } |
827 | ||
828 | ptr=parse_word (ptr,buffer); | |
829 | ||
efc6f628 | 830 | |
583a1ce5 TT |
831 | for (entry_num=remember_lifo.entries_count-1;entry_num>=0;entry_num--) { |
832 | if (strcmp (remember_lifo.name [entry_num],buffer)==0) | |
efc6f628 | 833 | break; |
583a1ce5 | 834 | } |
efc6f628 | 835 | |
583a1ce5 TT |
836 | if (entry_num==-1) { |
837 | wprintw (command_win,"Error - Can not recall %s\n",buffer);refresh_command_win (); | |
838 | return; | |
839 | } | |
840 | ||
841 | sprintf (buffer,"setoffset %ld",remember_lifo.offset [entry_num]);dispatch (buffer); | |
842 | if (remember_lifo.type [entry_num] != NULL) { | |
efc6f628 | 843 | sprintf (buffer,"settype %s",remember_lifo.type [entry_num]->name);dispatch (buffer); |
583a1ce5 TT |
844 | } |
845 | ||
846 | else { | |
efc6f628 | 847 | sprintf (buffer,"settype none");dispatch (buffer); |
583a1ce5 | 848 | } |
efc6f628 | 849 | |
583a1ce5 TT |
850 | wprintw (command_win,"Object %s in Offset %ld recalled\n",current_type->name,device_offset); |
851 | refresh_command_win (); | |
852 | } | |
853 | ||
854 | void enable_write (char *command_line) | |
855 | ||
856 | { | |
857 | FILE *fp; | |
858 | ||
859 | if (device_handle==NULL) { | |
860 | wprintw (command_win,"Error - No device opened\n");refresh_command_win (); | |
861 | return; | |
862 | } | |
863 | ||
864 | if (!AllowChanges) { | |
865 | wprintw (command_win,"Sorry, write access is not allowed\n"); | |
866 | return; | |
867 | } | |
efc6f628 | 868 | |
583a1ce5 TT |
869 | if (mounted) { |
870 | wprintw (command_win,"Error - Filesystem is mounted\n"); | |
efc6f628 | 871 | return; |
583a1ce5 | 872 | } |
efc6f628 | 873 | |
583a1ce5 TT |
874 | if ( (fp=fopen (device_name,"r+b"))==NULL) { |
875 | wprintw (command_win,"Error - Can not open device %s for reading and writing\n",device_name);refresh_command_win (); | |
876 | return; | |
877 | } | |
878 | fclose (device_handle); | |
879 | device_handle=fp;write_access=1; | |
880 | wprintw (command_win,"Write access enabled - Be careful\n");refresh_command_win (); | |
881 | } | |
882 | ||
883 | void disable_write (char *command_line) | |
884 | ||
885 | { | |
886 | FILE *fp; | |
887 | ||
888 | if (device_handle==NULL) { | |
889 | wprintw (command_win,"Error - No device opened\n");refresh_command_win (); | |
890 | return; | |
891 | } | |
892 | ||
893 | if ( (fp=fopen (device_name,"rb"))==NULL) { | |
894 | wprintw (command_win,"Error - Can not open device %s\n",device_name);refresh_command_win (); | |
895 | return; | |
896 | } | |
efc6f628 | 897 | |
583a1ce5 TT |
898 | fclose (device_handle); |
899 | device_handle=fp;write_access=0; | |
900 | wprintw (command_win,"Write access disabled\n");refresh_command_win (); | |
901 | } | |
902 | ||
903 | void write_data (char *command_line) | |
904 | ||
905 | { | |
906 | write_type_data (); | |
907 | } |