![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tnrecv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / tn3270 / utilities|
Return to tnrecv.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / tn3270 / utilities |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that this notice is preserved and that due credit is given
7: * to the University of California at Berkeley. The name of the University
8: * may not be used to endorse or promote products derived from this
9: * software without specific prior written permission. This software
10: * is provided ``as is'' without express or implied warranty.
11: */
12:
13: #ifndef lint
14: char copyright[] =
15: "@(#) Copyright (c) 1988 Regents of the University of California.\n\
16: All rights reserved.\n";
17: #endif /* not lint */
18:
19: #ifndef lint
20: static char sccsid[] = "@(#)tnrecv.c 3.2 (Berkeley) 3/28/88";
21: #endif /* not lint */
22:
23: #include <stdio.h>
24:
25: #include <api/apilib.h>
26:
27: #include "tncomp.h"
28:
29:
30: #include "../ctlr/api.h"
31: #include "../ctlr/function.h"
32: #include "../ctlr/hostctlr.h"
33: #include "../ctlr/oia.h"
34: #include "../ctlr/screen.h"
35:
36: #include "../api/disp_asc.h"
37: #include "../api/astosc.h"
38:
39: #include "../general/general.h"
40:
41: ScreenImage Host[MAXSCREENSIZE];
42:
43: static char
44: a_send_sequence[SEND_SEQUENCE_LENGTH+1],
45: a_ack_sequence[ACK_SEQUENCE_LENGTH+1],
46: a_checksum[CHECKSUM_LENGTH+1],
47: data_array[DATA_LENGTH+1];
48:
49: static int
50: verbose,
51: blocks,
52: enter_index,
53: clear_index,
54: ScreenSize,
55: session_id;
56:
57: static unsigned int
58: send_sequence,
59: ack_sequence = -1,
60: checksum;
61:
62: api_perror(string)
63: char *string;
64: {
65: fprintf(stderr, "Error: [0x%x/0x%x:0x%x/0x%x] from %s.\n",
66: api_sup_fcn_id, api_sup_errno,
67: api_fcn_fcn_id, api_fcn_errno, string);
68: }
69:
70:
71: char *
72: session_type(type)
73: int type;
74: {
75: switch (type) {
76: case TYPE_WSCTL:
77: return "work station control";
78: case TYPE_DFT:
79: return "distributed function terminal";
80: case TYPE_CUT:
81: return "control unit terminal";
82: case TYPE_NOTEPAD:
83: return "notepad";
84: case TYPE_PC:
85: return "personal computer";
86: default:
87: return "(UNKNOWN)";
88: }
89: }
90:
91: static int
92: wait_for_ps_or_oia()
93: {
94: #if defined(unix)
95: return api_ps_or_oia_modified();
96: #endif /* defined(unix) */
97: }
98:
99:
100: static int
101: wait_for_unlock()
102: {
103: OIA oia;
104: ReadOiaGroupParms re;
105: static char zeroes[sizeof oia.input_inhibited] = { 0 };
106:
107: do {
108: re.rc = re.function_id = 0;
109: re.session_id = session_id;
110: re.oia_buffer = (char far *) &oia;
111: re.oia_group_number = API_OIA_ALL_GROUPS;
112: if (api_read_oia_group(&re) == -1) {
113: api_perror("api_read_oia_group");
114: return -1;
115: } else if (verbose) {
116: if (IsOiaReady3274(&oia)) {
117: printf("3274 ready, ");
118: }
119: if (IsOiaMyJob(&oia)) {
120: printf("my job, ");
121: }
122: if (IsOiaInsert(&oia)) {
123: printf("insert mode, ");
124: }
125: if (IsOiaSystemLocked(&oia)) {
126: printf("system locked, ");
127: }
128: if (IsOiaTWait(&oia)) {
129: printf("terminal wait, ");
130: }
131: printf("are some bits from the OIA.\n");
132: }
133: /* We turned this on, so turn it off now */
134: ResetOiaApiInhibit(&oia);
135: if (memcmp(zeroes, oia.input_inhibited, sizeof oia.input_inhibited)) {
136: if (wait_for_ps_or_oia() == -1) {
137: return -1;
138: }
139: }
140: } while (memcmp(zeroes, oia.input_inhibited, sizeof oia.input_inhibited));
141: return 0;
142: }
143:
144: static int
145: initialize()
146: {
147: QuerySessionIdParms id;
148: QuerySessionParametersParms pa;
149: QuerySessionCursorParms cu;
150: ConnectToKeyboardParms conn;
151: DisableInputParms disable;
152: NameArray namearray;
153:
154: if (api_init() == 0) {
155: fprintf(stderr, "API function not available.\n");
156: return -1;
157: }
158:
159: id.rc = 0;
160: id.function_id = 0;
161: id.option_code = ID_OPTION_BY_NAME;
162: id.data_code = 'E';
163: id.name_array = &namearray;
164: namearray.length = sizeof namearray;
165: if (api_query_session_id(&id)) {
166: api_perror("api_query_session_id");
167: } else if (namearray.number_matching_session == 0) {
168: fprintf(stderr, "query_session_id: No matching sessions!\n");
169: return -1;
170: } else if (verbose) {
171: printf("Session short name 0x%x, type is ",
172: namearray.name_array_element.short_name);
173: printf("%s", session_type(namearray.name_array_element.type));
174: printf(", session ID is: 0x%x\n",
175: namearray.name_array_element.session_id);
176: }
177: session_id = namearray.name_array_element.session_id;
178:
179: pa.rc = pa.function_id = 0;
180: pa.session_id = session_id;
181: if (api_query_session_parameters(&pa) == -1) {
182: api_perror("api_query_session_parameters");
183: return -1;
184: } else if (verbose) {
185: printf("Session type %s, ", session_type(pa.session_type));
186: if (pa.session_characteristics&CHARACTERISTIC_EAB) {
187: printf(" has EAB, ");
188: }
189: if (pa.session_characteristics&CHARACTERISTIC_PSS) {
190: printf(" has PSS, ");
191: }
192: printf("%d rows, %d columns ", pa.rows, pa.columns);
193: if (pa.presentation_space) {
194: printf("presentation space at 0x%x:0x%x.\n",
195: FP_SEG(pa.presentation_space), FP_OFF(pa.presentation_space));
196: } else {
197: printf("(no direct presentation space access).\n");
198: }
199: }
200: ScreenSize = pa.rows*pa.columns;
201: if (pa.session_characteristics&CHARACTERISTIC_EAB) {
202: fprintf(stderr,
203: "tncomp utilities not designed to work with extended attribute buffers.\n");
204: return -1;
205: }
206:
207: if (verbose) {
208: cu.rc = cu.function_id = 0;
209: cu.session_id = session_id;
210: if (api_query_session_cursor(&cu) == -1) {
211: api_perror("api_query_session_cursor");
212: } else {
213: printf("cursor");
214: if (cu.cursor_type&CURSOR_INHIBITED_AUTOSCROLL) {
215: printf(" inhibited autoscroll");
216: }
217: if (cu.cursor_type&CURSOR_INHIBITED) {
218: printf(" inhibited");
219: }
220: if (cu.cursor_type&CURSOR_BLINKING) {
221: printf(" blinking");
222: } else {
223: printf(" not blinking");
224: }
225: if (cu.cursor_type&CURSOR_BOX) {
226: printf(" box ");
227: } else {
228: printf(" not box ");
229: }
230: printf("at row %d, column %d.\n",
231: cu.row_address, cu.column_address);
232: }
233: }
234:
235: conn.rc = conn.function_id = 0;
236: conn.session_id = session_id;
237: conn.event_queue_id = conn.input_queue_id = 0;
238: conn.intercept_options = 0;
239: if (api_connect_to_keyboard(&conn) == -1) {
240: api_perror("api_connect_to_keyboard");
241: } else if (verbose) {
242: if (conn.first_connection_identifier) {
243: printf("First keyboard connection.\n");
244: } else {
245: printf("Not first keyboard connection.\n");
246: }
247: }
248:
249: disable.rc = disable.function_id = 0;
250: disable.session_id = session_id;
251: disable.connectors_task_id = 0;
252: if (api_disable_input(&disable) == -1) {
253: api_perror("api_disable_input");
254: return -1;
255: } else if (verbose) {
256: printf("Disabled.\n");
257: }
258:
259: if ((enter_index = ascii_to_index("ENTER")) == -1) {
260: return -1;
261: }
262: if ((clear_index = ascii_to_index("CLEAR")) == -1) {
263: return -1;
264: }
265:
266: return 0; /* all ok */
267: }
268:
269: static int
270: send_key(index)
271: int index;
272: {
273: WriteKeystrokeParms wr;
274: extern struct astosc astosc[];
275:
276: wait_for_unlock();
277:
278: wr.rc = wr.function_id = 0;
279: wr.session_id = session_id;
280: wr.connectors_task_id = 0;
281: wr.options = OPTION_SINGLE_KEYSTROKE;
282: wr.number_of_keys_sent = 0;
283: wr.keystroke_specifier.keystroke_entry.scancode = astosc[index].scancode;
284: wr.keystroke_specifier.keystroke_entry.shift_state
285: = astosc[index].shiftstate;
286: if (api_write_keystroke(&wr) == -1) {
287: api_perror("api_write_keystroke");
288: return -1;
289: } else if (wr.number_of_keys_sent != 1) {
290: fprintf(stderr, "write_keystroke claims to have sent %d keystrokes.\n",
291: wr.number_of_keys_sent);
292: return -1;
293: } else if (verbose) {
294: printf("Keystroke sent.\n");
295: }
296: if (wait_for_ps_or_oia() == -1) {
297: return -1;
298: }
299: return 0;
300: }
301:
302: static int
303: terminate()
304: {
305: EnableInputParms enable;
306: DisconnectFromKeyboardParms disc;
307:
308: enable.rc = enable.function_id = 0;
309: enable.session_id = session_id;
310: enable.connectors_task_id = 0;
311: if (api_enable_input(&enable) == -1) {
312: api_perror("api_enable");
313: return -1;
314: } else if (verbose) {
315: printf("Enabled.\n");
316: }
317:
318: disc.rc = disc.function_id = 0;
319: disc.session_id = session_id;
320: disc.connectors_task_id = 0;
321: if (api_disconnect_from_keyboard(&disc) == -1) {
322: api_perror("api_disconnect_from_keyboard");
323: return -1;
324: } else if (verbose) {
325: printf("Disconnected from keyboard.\n");
326: }
327:
328: (void) api_finish();
329:
330: return 0;
331: }
332:
333:
334: static int
335: get_screen()
336: {
337: CopyStringParms copy;
338: /* Time copy services */
339:
340: wait_for_unlock();
341:
342: copy.copy_mode = 0;
343: copy.rc = copy.function_id = 0;
344: copy.source.session_id = session_id;
345: copy.source.buffer = 0;
346: copy.source.characteristics = 0;
347: copy.source.session_type = TYPE_DFT;
348: copy.source.begin = 0;
349:
350: copy.source_end = ScreenSize;
351:
352: copy.target.session_id = 0;
353: copy.target.buffer = (char *) &Host[0];
354: copy.target.characteristics = 0;
355: copy.target.session_type = TYPE_DFT;
356:
357: if (api_copy_string(©) == -1) {
358: api_perror("api_copy_string");
359: return -1;
360: }
361: return 0;
362: }
363:
364:
365: put_at(offset, from, length, attribute)
366: int offset;
367: char *from;
368: int length;
369: {
370: CopyStringParms copy;
371:
372: wait_for_unlock();
373:
374: copy.copy_mode = 0;
375: copy.rc = copy.function_id = 0;
376: copy.source.session_id = 0;
377: copy.source.buffer = from;
378: copy.source.characteristics = 0;
379: copy.source.session_type = TYPE_DFT;
380: copy.source.begin = 0;
381:
382: copy.source_end = length-1;
383:
384: copy.target.session_id = session_id;
385: copy.target.buffer = 0;
386: copy.target.characteristics = 0;
387: copy.target.session_type = TYPE_DFT;
388: copy.target.begin = offset;
389:
390: if (api_copy_string(©) == -1) {
391: api_perror("api_copy_string");
392: return -1;
393: }
394: return 0;
395: }
396:
397: static void
398: translate(input, output, table, length)
399: char *input, *output, table[];
400: int length;
401: {
402: unsigned char *indices = (unsigned char *) input;
403:
404: while (length--) {
405: *output++ = table[*indices++];
406: }
407: }
408:
409: static int
410: find_input_area(from)
411: int from;
412: {
413: #define FieldDec(p) (0) /* We don't really use this */
414: register int i, attr;
415:
416: for (i = from; i < MAXSCREENSIZE; ) {
417: if (IsStartField(i)) {
418: attr = FieldAttributes(i);
419: i++;
420: if (!IsProtectedAttr(i, attr)) {
421: return i;
422: }
423: } else {
424: i++;
425: }
426: }
427: return -1;
428: }
429:
430:
431: static void
432: getascii(offset, to, length)
433: int offset; /* Where in screen */
434: char *to; /* Where it goes to */
435: int length; /* Where to put it */
436: {
437: translate(Host+offset, to, disp_asc, length);
438: }
439:
440: static int
441: putascii(offset, from, length, before)
442: int offset; /* Where in screen */
443: char *from; /* Where it comes from */
444: int length; /* Where to put it */
445: int before; /* How much else should go */
446: {
447: translate(from, Host+offset, asc_disp, length);
448: if (put_at(offset-before,
449: (char *) Host+offset-before, length+before) == -1) {
450: return -1;
451: }
452: return 0;
453: }
454:
455: static int
456: ack()
457: {
458: static char ack_blanks[sizeof a_ack_sequence] = {0};
459:
460: if (ack_blanks[0] == 0) {
461: int i;
462:
463: for (i = 0; i < sizeof ack_blanks; i++) {
464: ack_blanks[i] = ' ';
465: }
466: }
467:
468: memcpy(a_ack_sequence, ack_blanks, sizeof a_ack_sequence);
469: sprintf(a_ack_sequence, "%d", ack_sequence);
470: a_ack_sequence[strlen(a_ack_sequence)] = ' ';
471: Host[ACK_SEQUENCE-1] |= ATTR_MDT;
472: if (putascii(ACK_SEQUENCE, a_ack_sequence, ACK_SEQUENCE_LENGTH, 1) == -1) {
473: return -1;
474: }
475: return 0;
476: }
477:
478: static int
479: formatted_correct()
480: {
481: if ((find_input_area(SEND_SEQUENCE-1) != SEND_SEQUENCE) ||
482: (find_input_area(SEND_SEQUENCE) != ACK_SEQUENCE) ||
483: (find_input_area(ACK_SEQUENCE) != CHECKSUM) ||
484: (find_input_area(CHECKSUM) != DATA)) {
485: return -1;
486: } else {
487: return 0;
488: }
489: }
490:
491:
492: main(argc, argv)
493: int argc;
494: char *argv[];
495: {
496: register int i;
497: int data_length, input_length;
498: char ascii[8]; /* Lots of room */
499: FILE *outfile;
500: char *data;
501: char *argv0 = argv[0];
502:
503: argc--;
504: argv++;
505: /* Process any flags */
506: while (argc && (argv[0][0] == '-')) {
507: switch (argv[0][1]) {
508: case 'v':
509: verbose = 1;
510: break;
511: case 'b':
512: blocks = 1;
513: break;
514: }
515: argc--;
516: argv++;
517: }
518:
519: if ((argc) < 2) {
520: fprintf(stderr,
521: "usage: %s [-b] [-v] local.file remote.file [remote.options]\n",
522: argv0);
523: exit(1);
524: }
525:
526: /* Open the local file */
527: if ((outfile = fopen(argv[0], "w")) == NULL) {
528: perror("fopen");
529: exit(2);
530: }
531: argc--;
532: argv++;
533:
534: if (initialize() == -1) {
535: return -1;
536: }
537:
538: /* build the command line */
539: data = data_array;
540: strcpy(data, "TNCOMP SEND");
541: data += strlen(data);
542: while (argc--) {
543: *data++ = ' ';
544: strcpy(data, argv[0]);
545: data += strlen(argv[0]);
546: argv++;
547: }
548: if (verbose) {
549: printf("%s\n", data_array);
550: }
551: if (get_screen() == -1) {
552: return -1;
553: }
554: data_length = strlen(data_array);
555: if ((i = find_input_area(0)) == -1) { /* Get an input area */
556: if (send_key(clear_index) == -1) {
557: return -1;
558: }
559: if ((i = find_input_area(0)) == -1) { /* Try again */
560: fprintf(stderr, "Unable to enter command line.\n");
561: return -1;
562: }
563: }
564: if (i == 0) {
565: Host[ScreenSize-1] |= ATTR_MDT;
566: } else {
567: Host[i-1] |= ATTR_MDT;
568: }
569: if (putascii(i, data_array, data_length, 1) == -1) {
570: return -1;
571: }
572: if (send_key(enter_index) == -1) {
573: return -1;
574: }
575: do {
576: if (get_screen() == -1) {
577: return -1;
578: }
579: } while (formatted_correct() == -1);
580:
581: do {
582: if (get_screen() == -1) {
583: return -1;
584: }
585: /* For each screen */
586: if (formatted_correct() == -1) {
587: fprintf(stderr, "Bad screen written by host.\n");
588: return -1;
589: }
590: /* If MDT isn't reset in the sequence number, go around again */
591: if (Host[ACK_SEQUENCE-1]&ATTR_MDT) {
592: if (wait_for_ps_or_oia() == -1) {
593: return -1;
594: }
595: continue;
596: }
597: getascii(SEND_SEQUENCE, a_send_sequence, SEND_SEQUENCE_LENGTH);
598: send_sequence = atoi(a_send_sequence);
599: getascii(CHECKSUM, a_checksum, CHECKSUM_LENGTH);
600: checksum = atoi(a_checksum);
601: getascii(DATA, data_array, DATA_LENGTH);
602: data = data_array;
603: if (send_sequence != (ack_sequence+1)) {
604: if (ack() == -1) {
605: return -1;
606: }
607: data = "1234"; /* Keep loop from failing */
608: if (send_key(enter_index) == -1) {
609: return -1;
610: }
611: if (get_screen() == -1) {
612: return -1;
613: }
614: continue;
615: }
616:
617: data_length = DATA_LENGTH;
618: while (data_length && memcmp(data, " EOF", 4)
619: && memcmp(data, " ", 4)) {
620: memcpy(ascii, data, 4);
621: data += 4;
622: data_length -= 4;
623: ascii[4] = 0;
624: input_length = atoi(ascii);
625: /* CMS can't live with zero length records */
626: if ((input_length > 1) ||
627: ((input_length == 1) && (data[0] != ' '))) {
628: if (fwrite(data, sizeof (char),
629: input_length, outfile) == 0) {
630: perror("fwrite");
631: exit(9);
632: }
633: }
634: fprintf(outfile, "\n");
635: data += input_length;
636: data_length -= input_length;
637: }
638:
639: ack_sequence = send_sequence;
640: if (blocks) {
641: printf("#");
642: fflush(stdout);
643: }
644: if (ack() == -1) {
645: return -1;
646: }
647: if (send_key(enter_index) == -1) {
648: return -1;
649: }
650: } while (memcmp(data, " EOF", 4));
651:
652: if (blocks) {
653: printf("\n");
654: }
655: if (terminate() == -1) {
656: return -1;
657: }
658: return 0;
659: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.