![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dlpt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / cci / pt|
Return to dlpt.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / cci / pt |
1.1 root 1: /************************************************************************
2: * *
3: * dlpt - download a CCI POWERTERMINAL or POWERTERMINAL II *
4: * *
5: ************************************************************************/
6:
7: /************************************************************************
8: * Compilation Notes -- *
9: * *
10: * - The symbol V7 must be defined when compiling for Version 7 *
11: * or Berkeley 4.2. *
12: * - No flags are needed when compiling for S3. *
13: * - This file contains the changes to support the new Berkeley *
14: * 4.2 signaling mechanism that were present at one point, then *
15: * deleted, and were restored in version 2.3.1. These changes *
16: * are required to make timed-out reads work correctly. *
17: * Compile with NEWSEG set to get these changes. *
18: * *
19: ************************************************************************/
20:
21: /************************************************************************
22: Version 1.2.1 changes:
23:
24: MDS 3/13/84 Implemented logic to circumvent 5/20 CPU port
25: problem. CPU port loses input characters
26: transmitted by the terminal at 9600 baud.
27: Therefore, if this program receives an invalid
28: DA response and it is talking to a cpu port,
29: then act as if a valid ROM DA response was
30: received.
31: Implemented "force" option. If specicified at
32: execution time the receipt of an invalid DA
33: response will be treated as a valid ROM DA
34: response.
35:
36: *************************************************************************
37:
38: Version 2.0.0 changes:
39:
40: MDS 11/6/84 Implemented logic to support CCI POWERTERMINAL II.
41:
42: *************************************************************************
43:
44: Version 2.1.0 changes:
45:
46: Version 2.1 is an interim version of dlpt created
47: by OSG.
48:
49: *************************************************************************
50:
51: Version 2.2.0 changes:
52:
53: SP & BM @osg
54: MDS 2/20/85 1) -a prompt came up twice on PT1 when 'n'
55: given. Fixed.
56: 2) If tty is tty01 or console, and dlpt
57: cannot determine terminal type, message is
58: given for user to manually 'dlpt -f[12]'.
59: 3) Added argument check to -t option to prevent
60: core dump if no arguments given with -t.
61: 4) In function whoisit() changed fputs to write.
62: Fputs did not work on PERPOS-S.
63: 5) Removed CR1 from ttyinit() for System 3.
64: CR1 caused a NULL,ACK to be output after CR
65: in Terminal loaded message.
66: 6) Added XOFF/XON recognition to download by
67: adding IXON to ttyinit().
68: 7) Changed source to default compile for S3
69: instead of V7. For V7 need to set V7 flag.
70:
71: *************************************************************************
72:
73: Version 2.3.0 changes:
74:
75: BJM @osg
76: BJM 3/6/85 Added XON/XOFF recognition to download for
77: Version 7 and Berkeley 4.2 version by setting
78: port to CBREAK mode for 'normal' download and
79: RAW mode for download in reliability mode.
80:
81: Added conditional compilation statements for
82: 19.2K baud.
83:
84: *************************************************************************
85:
86: Version 2.3.1 changes:
87:
88: woe@ccicpg
89: WOE 6/17/85 Restored changes for new Berkeley 4.2 signalling
90: mechanisms under the compile-time define NEWSIG.
91: Timed-out reads require these changes since the
92: read system call is "automatically" retried when
93: interrupted by a SIGALRM (or any other handled/
94: ignored signal).
95:
96: *************************************************************************/
97:
98:
99: /************************************************************************
100: * *
101: * Include files. *
102: * *
103: ************************************************************************/
104:
105: #include "stdio.h"
106: #include "signal.h"
107:
108: #ifdef V7 /********* if Version 7 *********/
109:
110: #include "sgtty.h"
111:
112: #else /********* else assume System 3 *********/
113:
114: #include "termio.h"
115:
116: #endif /********* end of System 3 *********/
117:
118: #ifdef NEWSIG /* new signal mechanism */
119: #include <setjmp.h>
120: #endif
121:
122: /************************************************************************
123: * *
124: * Defines. *
125: * *
126: ************************************************************************/
127:
128: #define VERSION "2.3.1" /* version to be displayed by -v option */
129:
130: typedef int BOOL;
131:
132: #define PT1_DEFLD "/lib/pt/DEFAULT.LD" /* default download file */
133: #define PT2_DEFLD "/lib/pt/PT2DEF.LD" /* default download file */
134: #define TTY_PREFIX "/dev/" /* appended to -t field */
135:
136: #define STX 0x02 /* cntrl b */
137: #define ENQ 0x05 /* cntrl e */
138: #define ACK 0x06 /* cntrl f */
139: #define CAN 0x18 /* cntrl x */
140: #define BELL 0x07 /* cntrl g */
141:
142: #define INVRESP 0 /* signal no valid DA response from tty */
143: #define PT1ROM 1 /* signal that PT1 ROM responded to DA */
144: #define PT1RAM 2 /* signal that PT1 RAM responded to DA */
145: #define PT2ROM 3 /* signal that PT2 ROM responded to DA */
146: #define PT2RAM 4 /* signal that PT2 RAM responded to DA */
147:
148: #define TRUE 1
149: #define FALSE 0
150:
151: #define STX_TIMES 3 /* Number of times to send STX block */
152: #define NRETRIES 10 /* Number of retries for load block */
153: #define LD_TIMEOUT 2 /* Loading timeout period */
154:
155: /************************************************************************
156: * *
157: * Local functions and variables. *
158: * *
159: ************************************************************************/
160:
161: #ifdef NEWSIG /* new signal mechanism */
162: jmp_buf jb;
163: #else
164: #define timoread read
165: #define timowrite write
166: #endif
167:
168: char stxrec [] = {STX,STX,STX,STX,STX,STX,STX,STX,STX,STX};
169: char nulls [15];
170: char can = CAN;
171: char enq = ENQ;
172: char ack = ACK;
173: char devname[25] = TTY_PREFIX;
174:
175: int nullcnt = 14;
176: int timout;
177: int bailout();
178: int toterm; /* to terminal file descriptor */
179: int fromterm; /* from terminal file descriptor */
180:
181:
182: #ifdef V7 /********* if Version 7 *********/
183:
184: char baudrate; /* baudrate , set by ttysave or main */
185:
186: #else /********* else assume System 3 *********/
187:
188: unsigned short baudrate; /* baudrate , set by ttysave or main */
189:
190: #endif /********* end of System 3 *********/
191:
192:
193: char *myname; /* name of this program */
194:
195: BOOL rflag = FALSE; /* reliability mode */
196: char fflag = 0; /* force mode (used if inv DA response */
197: char *intro[] = {
198: "\n",
199: "DO YOU WANT A TERMINAL LOAD SEQUENCE?",
200: " ",
201: " If you do not answer within 15 seconds,",
202: " the terminal load sequence will begin.",
203: " ",
204: "ENTER: y <return> or <return> to load ",
205: " n <return> to avoid load :",
206: NULL
207: };
208:
209: char *wrong[] = { "INVALID ANSWER",
210: NULL
211: };
212:
213: char *loading[]={
214: "\n",
215: "Terminal load in progress",
216: NULL
217: };
218:
219:
220: /************************************************************************
221: * *
222: * main - Do it. *
223: * *
224: ************************************************************************/
225:
226: int
227: main (argc, argv)
228: int argc;
229: char **argv;
230: {
231: char *pt1file;
232: char *pt2file;
233: int who; /* who is responding */
234: char *ttyname();
235: BOOL aflag = FALSE; /* TRUE if inquire wanted before load */
236:
237: myname = *argv++; /* get the name of this program */
238: --argc;
239:
240: ttysave(); /* save ioctl params and init default baudrate */
241:
242: pt1file = PT1_DEFLD; /* set default hex file for load */
243: pt2file = PT2_DEFLD; /* set default hex file for load */
244:
245: while( argc-- ) /* while there are arguments to process */
246: {
247: if( **argv == '-' ) /* while flags left */
248: {
249: char *fptr = *argv; /* get ptr to flags */
250:
251: while( *++fptr ) /* while flags left */
252: {
253: char atobaud();
254:
255: switch( *fptr ) /* process a flag */
256: {
257:
258: case 'a': /* ask if load wanted */
259: aflag = TRUE;
260: break;
261:
262: case 'b': /* specific baud rate */
263: if( fptr[1] != '\0' )
264: {
265: baudrate = atobaud(++fptr);
266: if(baudrate == (char) -1 )
267: {
268: fprintf(stderr,
269: "%s: %s - invalid baud\n",
270: myname, fptr);
271: usage();
272: }
273: fptr = "x"; /* fake out */
274: break;
275: }
276: else
277: {
278: if( argc < 1 )
279: usage();
280: baudrate = atobaud(*++argv);
281: --argc;
282: if(baudrate == (char) -1 )
283: {
284: fprintf(stderr,
285: "%s: %s - invalid baud\n",
286: myname, *argv);
287: usage();
288: }
289: }
290: break;
291:
292: case 'f': /* force mode *
293: * to force load if *
294: * invalid DA response */
295: /* get type '1' or '2' for *
296: * PT1 or PT2 */
297: fflag = *++fptr;
298: break;
299:
300: case 'r': /*reliability mode */
301: rflag = TRUE;
302: break;
303:
304: case 't': /* specific port */
305: if( fptr[1] != 0 )
306: {
307: strcat(devname,++fptr);
308: fptr = "x"; /* fake out */
309: }
310: else
311: {
312: if( argc < 1 )
313: usage();
314: strcat(devname, *++argv);
315: --argc;
316: }
317: if(freopen(devname,"w",stdout) ==
318: (FILE *)NULL)
319: {
320: fprintf(stderr,
321: "%s: cannot open port for write - %s\n",
322: myname,devname);
323: usage();
324: }
325: if(freopen(devname,"r",stdin) ==
326: (FILE *)NULL)
327: {
328: fprintf(stderr,
329: "%s: cannot open port for read - %s\n",
330: myname,devname);
331: usage();
332: }
333: break;
334:
335: case 'v': /* display version */
336: printf("%s: Version %s\n",myname,
337: VERSION);
338: exit(0);
339: break;
340:
341: default:
342: fprintf(stderr,
343: "%s: %c - unknown flag\n",
344: myname, *fptr);
345: usage();
346: break;
347: }
348: }
349: }
350: else
351: {
352: pt1file = *argv;
353: pt2file = *argv;
354: }
355: ++argv;
356: }
357:
358: signal (SIGALRM, bailout);
359: toterm = 1; /* standard output */
360: fromterm = 0; /* standard input */
361:
362: who = whoisit(); /* find out who is there */
363:
364: if( who == INVRESP ) /* if an invalid or no response */
365: switch( fflag ) { /* check for force wanted */
366: case '1': /* if PT1 force wanted */
367: who = PT1ROM; /* force a PT1 download */
368: break;
369:
370: case '2': /* if PT2 force wanted */
371: who = PT2ROM; /* force a PT2 download */
372: break;
373:
374: default: { /* else no force */
375: char *devwho;
376: devwho = ttyname(toterm); /* get name of port */
377: if ((strcmp(devwho,"/dev/console") == 0) ||
378: (strcmp(devwho,"/dev/tty01") == 0)) {
379: printf(
380: "%s: from console or tty01, enter 'dlpt -f#'\n-f1 for PT1, -f2 for PT2\n", myname);
381: ttyrestore();
382: exit(0);
383: }
384: break;
385: }
386: }
387:
388: switch( who ) /* depending on who responded */
389: {
390: case PT1RAM: /* is a downloaded PT1 ( CT ) */
391: case PT2RAM: /* is a downloaded PT2 */
392: ttytalk();
393: printf("\r\nTerminal loaded\r\n");
394: break;
395:
396: case PT1ROM: /* is a non-downloaded PT1 */
397: if((!aflag) || ((aflag) && (wantptload())))
398: {
399: ttytalk();
400: putmsg(loading, 0);
401: dlpt1(pt1file); /* load terminal */
402:
403: /************************************************
404: * NOTE: If terminal DTR is tied to CPU DCD *
405: * AND the terminal firmware re-initializes *
406: * the 8251 I/O chip, DCD is dropped which *
407: * causes this program to get killed at this *
408: * point. This is the case for the PT *
409: * terminal as of 10/25/83. *
410: ************************************************/
411:
412: sleep(3); /* wait for terminal to initialize */
413: printf("Terminal download complete\r\n");
414: }
415: break;
416:
417: case PT2ROM: /* is a non-downloaded PT2 */
418: if((!aflag) || ((aflag) && (wantptload())))
419: {
420: ttytalk();
421: putmsg(loading, 0);
422: dlpt2(pt2file); /* load terminal */
423: sleep(3); /* wait for terminal to initialize */
424: printf("Terminal download complete\r\n");
425: }
426: break;
427:
428: default:
429: break;
430: }
431: ttyrestore();
432: }
433:
434: /************************************************************************
435: * *
436: * usage - print usage statement and abort *
437: * *
438: ************************************************************************/
439:
440: usage()
441: {
442: fprintf(stderr,
443: "Usage: %s [-a] [-fTermNo] [-r] [-b BaudRate] [-t ttyXX] [load file]\n",
444: myname);
445: exit(1);
446: }
447:
448:
449: /************************************************************************
450: * *
451: * PT down-load rtn *
452: * *
453: ************************************************************************/
454: dlpt1(hexfile)
455:
456: char * hexfile;
457:
458: {
459:
460: FILE * in; /* input file */
461: int i; /* counter */
462: int rs; /* record size */
463: char record [524]; /* record */
464: int cs; /* checksum */
465: char * rp; /* record pointer */
466: char csum [2]; /* received checksum */
467:
468: in = stdin;
469: timout = 0; /* Alarm time-out flag */
470:
471: if ((in = fopen (hexfile, "r")) == (FILE *)NULL)
472: fatal ("Can't open input file.");
473:
474: ttyinit(); /* set up port for load */
475:
476: for (i = STX_TIMES ; i > 0 ; i--)
477: if (write (toterm, stxrec, sizeof(stxrec)) != sizeof(stxrec))
478: fatal ("1. Can't write STX to terminal.");
479:
480: while ((rs = getrec1 (in, record)) > 0)
481: {
482: for (cs = 0, i = rs, rp = record ; i > 0 ; i--)
483: cs += *rp++;
484:
485: for (i = NRETRIES ; i > 0 ; i--)
486: {
487: if (write (toterm, record, rs) != rs)
488: derror ("3. Can't write record to terminal.");
489:
490: if (write (toterm, nulls, nullcnt) != nullcnt)
491: derror ("4. Can't write NULLS to terminal.");
492:
493: if(rflag==TRUE)
494: {
495: alarm(LD_TIMEOUT); /* time limit */
496: timout = 0;
497: if (timowrite (toterm, &ack, 1) != 1 || (timout))
498: {
499: derror ("6. Can't write ACK to terminal.");
500: continue;
501: }
502:
503: alarm(LD_TIMEOUT); /* time limit */
504: timout = 0;
505: if (timoread (fromterm, csum, 1) != 1 || (timout))
506: {
507: derror ("7. Can't read ACK from terminal.");
508: continue;
509: }
510:
511: alarm(LD_TIMEOUT); /* time limit */
512: timout = 0;
513: if (timoread (fromterm, csum + 1, 1) != 1 || (timout))
514: {
515: derror ("8. Can't read csum count from terminal.");
516: continue;
517: }
518:
519: if (csum [0] != ACK)
520: {
521: derror ("9. Protocol violation not ACK.");
522: continue;
523: }
524:
525: if (((cs & 0x3f)+0x20) == csum[1])
526: break;
527:
528: } /* end of reliabilaty logic */
529:
530: else
531: break;
532:
533: } /* end of for loop */
534:
535: if (i == 0)
536: fatal ("10. Number of retries exceeded.");
537:
538: if (rs == 11) /* Last record */
539: return;
540:
541: }
542:
543: if (rs == 0)
544: fatal ("11. End of file reached before end-of-load record.");
545: else
546: fatal ("12. Bad record read.");
547:
548: }
549:
550: /************************************************************************
551: * *
552: * TITLE: dlpt2 - down load CCI POWERTERMINAL II *
553: * *
554: * RETURNS: nothing *
555: * *
556: ************************************************************************/
557: dlpt2( hexfile )
558:
559: char *hexfile;
560:
561: {
562: FILE * in; /* input file */
563: int i; /* counter */
564: int rs; /* record size */
565: char record [524]; /* record */
566:
567: in = stdin;
568: timout = 0; /* Alarm time-out flag */
569:
570: if ((in = fopen (hexfile, "r")) == (FILE *)NULL)
571: fatal ("Can't open input file.");
572:
573: ttyinit(); /* set up port for load */
574:
575: ttyflush(); /* flush port before attempting com */
576:
577: for (i = STX_TIMES ; i > 0 ; i--)
578: if (write (toterm, stxrec, sizeof(stxrec)) != sizeof(stxrec))
579: fatal ("1. Can't write STX to terminal.");
580:
581: if( rflag == TRUE ) /* if rel mode wanted - tell PT2 */
582: {
583: if( write( toterm, &enq, 1 ) != 1 )
584: {
585: d2error ("16. Can't write ENQ to terminal.");
586: }
587: }
588:
589: while( ( rs = getrec2(in, record) ) > 0 )
590: {
591: for( i = NRETRIES ; i > 0 ; i-- )
592: {
593: if( write ( toterm, record, rs ) != rs )
594: d2error ("3. Can't write record to terminal.");
595:
596: /*
597: if( write ( toterm, nulls, nullcnt ) != nullcnt )
598: d2error ("4. Can't write NULLS to terminal.");
599: */
600:
601: if( rflag == TRUE )
602: {
603: char resp; /* resp char */
604:
605: alarm(LD_TIMEOUT); /* time limit */
606: timout = 0;
607: if( (timoread( fromterm, &resp, 1 ) != 1 ) || (timout))
608: {
609: d2error ("17. Can't read ACK from terminal.");
610: continue;
611: }
612: if( resp == ACK )
613: break; /* get txmit next char */
614:
615: d2error ("19. Protocol violation not ACK.");
616: continue;
617:
618: } /* end of reliabilaty logic */
619:
620: else
621: break; /* no verification wanted */
622:
623: } /* end of error retry loop */
624:
625: if( i == 0 )
626: fatal ("20. Number of retries exceeded.");
627:
628: /* a complete record has been transmitted */
629: /* check if it was the last record */
630:
631: if( record[ 1 ] == '8' ) /* was it an S8 record? */
632: return; /* if so, done !! */
633:
634: }
635:
636: if( rs == 0 )
637: fatal ("21. End of file reached before end-of-load record.");
638: else
639: fatal ("22. Bad record read.");
640:
641: }
642:
643: /************************************************************************
644: * *
645: * derror - have an error handle and return *
646: * *
647: ************************************************************************/
648:
649: int
650: derror (s)
651:
652: char * s;
653:
654: {
655:
656: alarm(0); /* cancel alarms */
657: write (toterm,&can,sizeof(can)); /* cancel */
658: write (toterm,nulls,nullcnt); /* pad for next write */
659: fputs(s, stderr);
660: fputs("\r\n", stderr);
661: return;
662:
663: }
664:
665: /************************************************************************
666: * *
667: * d2error - have an error handle and return *
668: * *
669: ************************************************************************/
670:
671: int
672: d2error (s)
673:
674: char *s;
675:
676: {
677: alarm(0); /* cancel alarms */
678: fputs(s, stderr);
679: fputs("\r\n", stderr);
680: return;
681: }
682:
683: /************************************************************************
684: * *
685: * getrec1 - Get a PT1 (CT) record to transmit. *
686: * *
687: * Returns: *
688: * -1 Error in file format. *
689: * 0 End of file reached. *
690: * > 0 Size of record to transmit. *
691: * *
692: ************************************************************************/
693: int
694: getrec1(fd, rp)
695:
696: FILE * fd;
697: char * rp;
698:
699: {
700:
701: int c;
702: int nc; /* number of characters */
703: int l; /* length of record bytes */
704: int cc; /* checksum */
705: int i; /* counter */
706: int a; /* address piece */
707:
708: while ((c = getc (fd)) != ':') /* Look for start of record */
709: if (c == EOF)
710: return 0; /* End of file */
711:
712: /***** Start record off. */
713:
714: /*%%% printf("At record start\n");/*%%*/
715: *rp++ = ':';
716: nc = 1;
717:
718: /***** Get number of hex bytes in record. */
719:
720: if ((l = getxb (fd, rp)) < 0)
721: return -1;
722:
723: /*%%% printf("%d data bytes\n", l);/*%%*/
724: cc = l; /* Start checksum */
725: rp += 2; /* Past two characters */
726: nc += 2; /* Two more characters */
727:
728: /***** Get address portion of data record. */
729:
730: for (i = 2 ; i > 0 ; i--) /* Two hex bytes */
731: {
732: if ((a = getxb (fd, rp)) < 0)
733: return -1;
734:
735: cc += a; /* Figure address into checksum */
736: rp += 2; /* Past two characters */
737: nc += 2; /* Two more characters */
738: }
739:
740: /***** Read type byte, which should be zero. */
741:
742: if ((i = getxb (fd, rp)) != 0)
743: return -1;
744:
745: cc += i; /* Figure type into checksum */
746: rp += 2; /* Past two characters */
747: nc += 2; /* Two more characters */
748:
749: /***** Read in the data record. */
750:
751: while (l-- > 0) /* Count down */
752: {
753: if ((i = getxb (fd, rp)) < 0)
754: return -1;
755:
756: /*%%% printf ("Read %d\n", i);/*%%*/
757: cc += i; /* Checksum */
758: rp += 2; /* Pointer */
759: nc += 2; /* Number of characters */
760: }
761:
762: cc = (-cc) & 0377; /* Two's complement byte */
763:
764: /*%%% printf ("Checksum = %x\n", cc);/*%%*/
765: *rp = cc >> 4;
766: *rp += *rp < 10 ? '0' : 'A' - 10;
767: *++rp = cc & 0xF;
768: *rp += *rp < 10 ? '0' : 'A' - 10;
769:
770: /*%%% printf ("record size = %d\n", nc + 2);/*%%*/
771: return nc + 2;
772:
773: }
774:
775: /************************************************************************
776: * *
777: * TITLE: getrec2 - Get a POWERTERMINAL II record to transmit *
778: * *
779: * RETURNS: *
780: * -1 Error in file format. *
781: * 0 End of file reached. *
782: * > 0 Size of record to transmit. *
783: * *
784: ************************************************************************/
785: int
786: getrec2 (fd, rp)
787:
788: FILE *fd;
789: char *rp;
790:
791: {
792: register char *rrp; /* register copy of record ptr */
793: char c; /* temp store of read char */
794: int nc; /* number of characters */
795: int l; /* length of record bytes */
796:
797: rrp = rp; /* get addr in a register */
798:
799: while(( c = getc( fd )) != 'S') /* Look for start of record */
800: if( c == EOF )
801: return( 0 ); /* End of file */
802:
803: *rrp++ = c ; /* put first char of record */
804: nc = 1; /* start the char counter */
805:
806: if( ( *rrp++ = getc( fd ) ) < 0 ) /* get S-record type */
807: return( -1 ); /* if EOF, return */
808: nc++; /* incre num of chars */
809:
810: if( ( l = getxb(fd, rrp) ) < 0) /* get num of bytes */
811: return -1;
812: rrp += 2; /* Past two characters */
813: nc += 2; /* Two more characters */
814:
815: /* get address, data, and checksum fields */
816:
817: l <<= 1 ; /* chg to num nibbles (times 2) */
818:
819: while( l-- > 0 ) { /* l now contains num of nibbles*/
820: if ( ( *rrp++ = getc( fd ) ) < 0)
821: return( -1 );
822: nc++; /* bump char counter */
823: }
824:
825: return( nc ); /* return num of chars in rec */
826:
827: }
828:
829: /************************************************************************
830: * *
831: * getxb - Get a hex byte. *
832: * *
833: * Returns: *
834: * -1 Error in file format or end of file reached. *
835: * >= 0 Integer value of byte. *
836: * *
837: ************************************************************************/
838:
839: int
840: getxb (fd, sp)
841:
842: FILE * fd;
843: char * sp;
844:
845: {
846:
847: register int i, j;
848:
849: if ((i = getxn (fd, sp++)) < 0 || (j = getxn (fd, sp)) < 0)
850: return -1;
851:
852: return (i << 4) | j;
853:
854: }
855:
856: /************************************************************************
857: * *
858: * getxn - Get a hex nibble. *
859: * *
860: * Returns: *
861: * -1 Error in file format or end of file reached. *
862: * >= 0 Integer value of nibble. *
863: * *
864: ************************************************************************/
865:
866: int
867: getxn (fd, sp)
868:
869: FILE * fd;
870: char * sp;
871:
872: {
873:
874: register int c;
875:
876: *sp = c = getc (fd);
877:
878: if (c >= '0' && c <= '9')
879: return c - '0';
880: else if (c >= 'A' && c <= 'F')
881: return c - 'A' + 10;
882: else if (c >= 'a' && c <= 'f')
883: return c - 'a' + 10;
884:
885: return -1;
886:
887: }
888:
889:
890: #ifdef NEWSIG /* new signal mechanism */
891:
892: /************************************************************************
893: * *
894: * timoread/timowrite - read/write with timeout *
895: * *
896: ************************************************************************/
897:
898: timoread(fd, ptr, size)
899: char *ptr;
900: {
901: if(setjmp(jb) == 0)
902: return read(fd, ptr, size);
903: return -1;
904: }
905: timowrite(fd, ptr, size)
906: char *ptr;
907: {
908: if(setjmp(jb) == 0)
909: return write(fd, ptr, size);
910: return -1;
911: }
912: #endif
913:
914:
915: /************************************************************************
916: * *
917: * fatal - display error message and abort *
918: * *
919: ************************************************************************/
920:
921: int
922: fatal (s)
923:
924: char * s;
925:
926: {
927:
928: write(toterm,&can,sizeof(can)); /* write cancel to terminal */
929: write(toterm,nulls,nullcnt);
930: fputs(s, stderr);
931: fputs("\r\n", stderr);
932: ttyrestore(); /* put terminal back to orig state */
933: exit(1);
934:
935: }
936:
937: /************************************************************************
938: * *
939: * wantptload - inquire if the user wants a download *
940: * *
941: ************************************************************************/
942:
943: #define BUFSIZE 80 /* size of answer buffers */
944: #define WANT_WAIT 15 /* time to wait for answer */
945:
946: wantptload ()
947: {
948: char answer[BUFSIZE];
949:
950: ttytalk(); /* talk slow - do not lose chars */
951: while (1)
952: {
953: sleep(1); /* allow time to prevent truncation */
954: putmsg(intro, 0); /* output msg, 0 pad null per line */
955: alarm(WANT_WAIT);
956: timout=0;
957: *answer = '\0';
958: timoread(0, answer, sizeof answer);
959: if(timout)
960: return(TRUE);
961: else
962: {
963: alarm(0); /* reset the alarm */
964: switch (*answer)
965: {
966: case 'y':
967: case 'Y':
968: case '\n':
969: return(TRUE);
970:
971: case 'n':
972: case 'N':
973: return(FALSE);
974:
975: default:
976: putmsg(wrong, 0);
977: }
978: }
979: }
980: }
981:
982: /************************************************************************
983: * *
984: * putmsg - put a msg to terminal with null padding at end of line *
985: * *
986: ************************************************************************/
987:
988: putmsg(text,pad)
989: char **text; /* pointer to list of string pointers */
990: int pad; /* number of nulls to output after each line */
991: {
992: while( *text != NULL )
993: {
994: register int i;
995: char *ptr = *text;
996:
997: while( *ptr )
998: {
999: putchar(*ptr++);
1000: }
1001: putchar('\n');
1002: for( i = 0; i < pad; i++)
1003: putchar('\0');
1004: text++;
1005: }
1006: }
1007:
1008: /************************************************************************
1009: * *
1010: * whoisit - Determine if the PT terminal is already downloaded *
1011: * *
1012: * returns PT1ROM if ROM responds to DA command *
1013: * returns PT1RAM if RAM responds to DA command *
1014: * returns INVRESP if no or invalid response received *
1015: * *
1016: ************************************************************************/
1017:
1018: #define DA "\033[c" /* ANSI DA ESC seq to send to terminal */
1019:
1020: /* Note that in the following expected DA response sequences, only the
1021: first 7 chars are used to match. This allows for future
1022: changes in the software version number without having to change
1023: this program. (The PT ROM & RAM respond with version number(s)
1024: in addition to the following characters.)
1025: */
1026:
1027: #define RAM1RSP "\033[=0;1;" /* ANSI DA ESC response from PT (CT) RAM */
1028: #define ROM1RSP "\033[=0;0;" /* ANSI DA ESC response from PT (CT) ROM */
1029: #define RAM2RSP "\033[=1;1;" /* ANSI DA ESC response from PT2 RAM */
1030: #define ROM2RSP "\033[=1;0;" /* ANSI DA ESC response from PT2 ROM */
1031: #define DATERM 'c' /* ANSI DA ESC sequence terminator */
1032:
1033: #define ASK_WAIT 3 /* time to wait for ESC response */
1034: #define ASK_TIMES 3 /* number of times to send DA req block */
1035: #define MAX_WRONG_CHARS 30 /* max number of chars to wait for ESC */
1036:
1037: whoisit ()
1038:
1039: {
1040: char response[MAX_WRONG_CHARS+1];
1041: int i,j;
1042:
1043: ttyinit(); /* make port raw for ESC sequence */
1044:
1045: for( j=0 ; j < ASK_TIMES ; j++ ) /* allow retries */
1046: {
1047: ttyflush(); /* flush port before attempting com */
1048:
1049: /* send DA cmd, is terminal loaded ? */
1050: write (toterm,DA,sizeof(DA)-1);
1051:
1052: alarm(ASK_WAIT);
1053: timout = 0;
1054: response[0] = '\0';
1055:
1056: /* Synchronize on first character of expected response */
1057:
1058: while (response[0] != *ROM1RSP)
1059: {
1060: if(timoread(0,&response[0],sizeof(char)) != sizeof(char))
1061: {
1062: if(timout)
1063: break;
1064: alarm(0);
1065: puts("\n\rDA ESC char read error\n\r");
1066: return(FALSE);
1067: }
1068: }
1069:
1070: if(timout) /* time-out here means no good response */
1071: continue; /* try again */
1072:
1073: alarm(0); /* make sure alarm is cleared */
1074:
1075: /* At this point we have the first char of expected
1076: response. Now get the rest of it. */
1077:
1078: for( i=1 ; ((response[i-1] != DATERM) &&
1079: (i < MAX_WRONG_CHARS-1)) ; i++ )
1080: {
1081: alarm(ASK_WAIT);
1082: timout=0;
1083: if(timoread(0,&response[i],sizeof(char)) != sizeof(char))
1084: {
1085: if(timout)
1086: break;
1087: alarm(0);
1088: puts("\n\rDA string read error\n\r");
1089: return(FALSE);
1090: }
1091: alarm(0); /* make sure alarm is cleared */
1092: }
1093: if(timout) /* if time-out, did not get enough chars*/
1094: continue; /* retry DA command */
1095:
1096: /* At this point we have at least a matching first char
1097: in response. Now compare the complete string read in
1098: with the expected response. */
1099:
1100: if(strncmp(ROM1RSP,response,sizeof(ROM1RSP)-1) == 0)
1101: return(PT1ROM);
1102: if(strncmp(RAM1RSP,response,sizeof(RAM1RSP)-1) == 0)
1103: return(PT1RAM);
1104: if(strncmp(ROM2RSP,response,sizeof(ROM2RSP)-1) == 0)
1105: return(PT2ROM);
1106: if(strncmp(RAM2RSP,response,sizeof(RAM2RSP)-1) == 0)
1107: return(PT2RAM);
1108: }
1109: return(INVRESP);
1110: }
1111:
1112: /************************************************************************
1113: * *
1114: * atobaud - convert an ascii number to a baud rate ala B50, B1200, ... *
1115: * returns -1 if invalid baud rate is specified. *
1116: * *
1117: ************************************************************************/
1118:
1119: struct baud {
1120: char *abaud; /* name of baud rate */
1121: char ibaud; /* baud rate for ioclt(2) */
1122: };
1123:
1124: struct baud baudtbl[] = {
1125: { "110", B110 },
1126: { "300", B300 },
1127: { "600", B600 },
1128: { "1200", B1200 },
1129: { "2400", B2400 },
1130: { "4800", B4800 },
1131: { "9600", B9600 },
1132: #ifdef B19200
1133: { "19200", B19200 },
1134: #endif
1135: { NULL, 0 }
1136: };
1137:
1138: char
1139: atobaud(string)
1140: char *string;
1141: {
1142: struct baud *bptr = baudtbl; /* index in baud rate table */
1143:
1144: while( bptr->abaud != NULL )
1145: {
1146: if( strcmp( bptr->abaud, string) == 0)
1147: {
1148: switch (atoi(string))
1149: {
1150: case 19200: nullcnt=14;break;
1151: case 9600: nullcnt= 9;break;
1152: case 4800: nullcnt= 8;break;
1153: case 2400: nullcnt= 6;break;
1154: case 1200: nullcnt= 5;break;
1155: case 300:
1156: case 110: nullcnt= 3;break;
1157: default: nullcnt=14;break;
1158: }
1159: return( bptr->ibaud );
1160: }
1161: ++bptr;
1162: }
1163: return( (char) -1 );
1164: }
1165:
1166: /************************************************************************
1167: * *
1168: * bailout - alarm interrupt handler *
1169: * *
1170: ************************************************************************/
1171:
1172:
1173: bailout ()
1174: {
1175: #ifdef NEWSIG /* new signal mechanism */
1176: timout = 1;
1177: longjmp(jb, 1);
1178: #else
1179: signal(SIGALRM,bailout);
1180: timout = 1;
1181: return;
1182: #endif
1183: }
1184:
1185: /************************************************************************
1186: * *
1187: * tty utilities for performing get & put ioctl's *
1188: * *
1189: ************************************************************************/
1190:
1191: #define IOC_DELAY 1 /* Delay is needed after ioctl to allow baud-
1192: rate change to take effect. This requirement
1193: discovered on 2/21/84 when xmit of the DA
1194: seq would result in the first DA attempt to
1195: be sent at 9600 baud (irregardless of
1196: intended setting) and the second DA to go
1197: out at the intended (set by ioctl) rate. */
1198:
1199: #ifdef V7 /********* if Version 7 tty routines *********/
1200:
1201: struct sgttyb tp_new;
1202: struct sgttyb tp_orig;
1203: struct tchars tc_new = { '\177', '\034', '\021', '\023', '\004', '\377' };
1204: struct tchars tc_orig;
1205:
1206: ttysave ()
1207: {
1208: ioctl(0, TIOCGETP, &tp_orig);
1209: ioctl(0, TIOCGETC, &tc_orig);
1210: baudrate = tp_orig.sg_ospeed;
1211: }
1212:
1213: ttyrestore ()
1214: {
1215: ioctl(0, TIOCSETP, &tp_orig);
1216: ioctl(0, TIOCSETC, &tc_orig);
1217: sleep(IOC_DELAY); /* allow baud to settle */
1218: }
1219:
1220: ttyinit ()
1221: {
1222: /*
1223: * Use CBREAK mode for 'normal' download so that the Dow Jones
1224: * mux which generates XON/XOFF will be happy. XON/XOFF appears
1225: * to screw up reliability mode, however, so stick with RAW
1226: * mode for that.
1227: */
1228: ttysetup((short) ANYP + ((rflag) ? RAW : CBREAK));
1229: }
1230:
1231: ttytalk ()
1232: {
1233: ttysetup((short)ANYP+ECHO+CRMOD);
1234: }
1235:
1236: ttysetup (flags)
1237: short flags;
1238: {
1239:
1240: tp_new.sg_flags = flags;
1241: tp_new.sg_ispeed = baudrate;
1242: tp_new.sg_ospeed = baudrate;
1243: tp_new.sg_stopbits = tp_orig.sg_stopbits;
1244: ioctl(0, TIOCSETP, &tp_new);
1245: ioctl(0, TIOCSETC, &tc_new);
1246: sleep(IOC_DELAY); /* allow baud to settle */
1247:
1248: }
1249:
1250: ttyflush()
1251: {
1252: ioctl(0,TIOCFLUSH,0);
1253: }
1254:
1255: #else /********* else assume System 3 tty routines *********/
1256:
1257: struct termio term_orig; /* save area for orig port state */
1258: struct termio term_new; /* new port state */
1259:
1260: int count; /* used for 19200 baud delay */
1261:
1262: ttysave()
1263: {
1264: ioctl(0, TCGETA, &term_orig); /* save the initial port state */
1265: baudrate = term_orig.c_cflag & CBAUD; /* get orig baud */
1266: }
1267:
1268: ttyrestore()
1269: {
1270: ioctl(0, TCSETAF, &term_orig); /* restore saved port state */
1271: sleep(IOC_DELAY); /* allow baud to settle */
1272: }
1273:
1274: ttyinit()
1275: {
1276: term_new.c_iflag = ICRNL|ISTRIP|IXON;
1277: term_new.c_oflag = ONLRET|OPOST;
1278: term_new.c_cflag = baudrate|CREAD|CS8;
1279: term_new.c_lflag = 0;
1280: term_new.c_line = 0;
1281: term_new.c_cc[VINTR] = CINTR;
1282: term_new.c_cc[VQUIT] = CQUIT;
1283: term_new.c_cc[VERASE] = 0x08;
1284: term_new.c_cc[VKILL] = CKILL;
1285: term_new.c_cc[VMIN] = 1;
1286: term_new.c_cc[VTIME] = 1;
1287:
1288: ioctl( 0, TCSETAF, &term_new );
1289: sleep(IOC_DELAY); /* allow baud to settle */
1290:
1291: }
1292:
1293: ttytalk()
1294: {
1295: term_new.c_iflag = ICRNL|IXON;
1296: term_new.c_oflag = ONLCR|OPOST;
1297: term_new.c_cflag = baudrate|CREAD|CS8;
1298: term_new.c_lflag = ECHO|ECHOE|ECHOK|ICANON|ISIG;
1299:
1300: ioctl( 0, TCSETAF, &term_new );
1301: sleep(IOC_DELAY); /* allow baud to settle */
1302:
1303: }
1304:
1305: ttyflush()
1306: {
1307: ioctl( 0, TCFLSH, 2 ); /* flush input & output queues */
1308: }
1309:
1310: #endif /********* end of System 3 tty routines *********/
1311:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.