[unix-history] / usr / src / usr.bin / tn3270 / distribution / utilities / tnrecv.c

#include <stdio.h>

#include <apilib/apilib.h>

#include "tncomp.h"


#include "../api/api.h"

#include "../ctlr/function.h"
#include "../ctlr/hostctlr.h"
#include "../ctlr/oia.h"
#include "../ctlr/screen.h"

#include "../apilib/disp_asc.h"
#include "../apilib/astosc.h"

#include "../general/general.h"

ScreenImage Host[MAXSCREENSIZE];

static char
    a_send_sequence[SEND_SEQUENCE_LENGTH+1],
    a_ack_sequence[ACK_SEQUENCE_LENGTH+1],
    a_checksum[CHECKSUM_LENGTH+1],
    data_array[DATA_LENGTH+1];

static int
    verbose,
    blocks,
    enter_index,
    clear_index,
    ScreenSize,
    session_id;

static unsigned int
    send_sequence,
    ack_sequence = -1,
    checksum;

api_perror(string)
char *string;
{
    fprintf(stderr, "Error: [0x%x/0x%x:0x%x/0x%x] from %s.\n",
	api_sup_fcn_id, api_sup_errno,
	api_fcn_fcn_id, api_fcn_errno, string);
}


char *
session_type(type)
int	type;
{
    switch (type) {
    case TYPE_WSCTL:
	return "work station control";
    case TYPE_DFT:
	return "distributed function terminal";
    case TYPE_CUT:
	return "control unit terminal";
    case TYPE_NOTEPAD:
	return "notepad";
    case TYPE_PC:
	return "personal computer";
    default:
	return "(UNKNOWN)";
    }
}

static int
wait_for_ps_or_oia()
{
#if	defined(unix)
    return api_ps_or_oia_modified();
#endif	/* defined(unix) */
}


static int
wait_for_unlock()
{
    OIA oia;
    ReadOiaGroupParms re;
    static char zeroes[sizeof oia.input_inhibited] = { 0 };

    do {
	re.rc = re.function_id = 0;
	re.session_id = session_id;
	re.oia_buffer = (char far *) &oia;
	re.oia_group_number = API_OIA_ALL_GROUPS;
	if (api_read_oia_group(&re) == -1) {
	    api_perror("api_read_oia_group");
	    return -1;
	} else if (verbose) {
	    if (IsOiaReady3274(&oia)) {
		printf("3274 ready, ");
	    }
	    if (IsOiaMyJob(&oia)) {
		printf("my job, ");
	    }
	    if (IsOiaInsert(&oia)) {
		printf("insert mode, ");
	    }
	    if (IsOiaSystemLocked(&oia)) {
		printf("system locked, ");
	    }
	    if (IsOiaTWait(&oia)) {
		printf("terminal wait, ");
	    }
	    printf("are some bits from the OIA.\n");
	}
	/* We turned this on, so turn it off now */
	ResetOiaApiInhibit(&oia);
	if (memcmp(zeroes, oia.input_inhibited, sizeof oia.input_inhibited)) {
	    if (wait_for_ps_or_oia() == -1) {
		return -1;
	    }
	}
    } while (memcmp(zeroes, oia.input_inhibited, sizeof oia.input_inhibited));
    return 0;
}

static int
initialize()
{
    QuerySessionIdParms id;
    QuerySessionParametersParms pa;
    QuerySessionCursorParms cu;
    ConnectToKeyboardParms conn;
    DisableInputParms disable;
    NameArray namearray;

    if (api_init() == 0) {
	fprintf(stderr, "API function not available.\n");
	return -1;
    }

    id.rc = 0;
    id.function_id = 0;
    id.option_code = ID_OPTION_BY_NAME;
    id.data_code = 'E';
    id.name_array = &namearray;
    namearray.length = sizeof namearray;
    if (api_query_session_id(&id)) {
	api_perror("api_query_session_id");
    } else if (namearray.number_matching_session == 0) {
	fprintf(stderr, "query_session_id:  No matching sessions!\n");
	return -1;
    } else if (verbose) {
	printf("Session short name 0x%x, type is ",
				namearray.name_array_element.short_name);
	printf("%s", session_type(namearray.name_array_element.type));
	printf(", session ID is: 0x%x\n",
				namearray.name_array_element.session_id);
    }
    session_id = namearray.name_array_element.session_id;

    pa.rc = pa.function_id = 0;
    pa.session_id = session_id;
    if (api_query_session_parameters(&pa) == -1) {
	api_perror("api_query_session_parameters");
	return -1;
    } else if (verbose) {
	printf("Session type %s, ", session_type(pa.session_type));
	if (pa.session_characteristics&CHARACTERISTIC_EAB) {
	    printf(" has EAB, ");
	}
	if (pa.session_characteristics&CHARACTERISTIC_PSS) {
	    printf(" has PSS, ");
	}
	printf("%d rows, %d columns ", pa.rows, pa.columns);
	if (pa.presentation_space) {
	    printf("presentation space at 0x%x:0x%x.\n",
		FP_SEG(pa.presentation_space), FP_OFF(pa.presentation_space));
	} else {
	    printf("(no direct presentation space access).\n");
	}
    }
    ScreenSize = pa.rows*pa.columns;
    if (pa.session_characteristics&CHARACTERISTIC_EAB) {
	fprintf(stderr,
    "tncomp utilities not designed to work with extended attribute buffers.\n");
	return -1;
    }

    if (verbose) {
	cu.rc = cu.function_id = 0;
	cu.session_id = session_id;
	if (api_query_session_cursor(&cu) == -1) {
	    api_perror("api_query_session_cursor");
	} else {
	    printf("cursor");
	    if (cu.cursor_type&CURSOR_INHIBITED_AUTOSCROLL) {
		printf(" inhibited autoscroll");
	    }
	    if (cu.cursor_type&CURSOR_INHIBITED) {
		printf(" inhibited");
	    }
	    if (cu.cursor_type&CURSOR_BLINKING) {
		printf(" blinking");
	    } else {
		printf(" not blinking");
	    }
	    if (cu.cursor_type&CURSOR_BOX) {
		printf(" box ");
	    } else {
		printf(" not box ");
	    }
	    printf("at row %d, column %d.\n",
				cu.row_address, cu.column_address);
	}
    }

    conn.rc = conn.function_id = 0;
    conn.session_id = session_id;
    conn.event_queue_id = conn.input_queue_id = 0;
    conn.intercept_options = 0;
    if (api_connect_to_keyboard(&conn) == -1) {
	api_perror("api_connect_to_keyboard");
    } else if (verbose) {
	if (conn.first_connection_identifier) {
	    printf("First keyboard connection.\n");
	} else {
	    printf("Not first keyboard connection.\n");
	}
    }

    disable.rc = disable.function_id = 0;
    disable.session_id = session_id;
    disable.connectors_task_id = 0;
    if (api_disable_input(&disable) == -1) {
	api_perror("api_disable_input");
	return -1;
    } else if (verbose) {
	printf("Disabled.\n");
    }

    if ((enter_index = ascii_to_index("ENTER")) == -1) {
	return -1;
    }
    if ((clear_index = ascii_to_index("CLEAR")) == -1) {
	return -1;
    }

    return 0;				/* all ok */
}

static int
send_key(index)
int	index;
{
    WriteKeystrokeParms wr;
    extern struct astosc astosc[];

    wait_for_unlock();

    wr.rc = wr.function_id = 0;
    wr.session_id = session_id;
    wr.connectors_task_id = 0;
    wr.options = OPTION_SINGLE_KEYSTROKE;
    wr.number_of_keys_sent = 0;
    wr.keystroke_specifier.keystroke_entry.scancode = astosc[index].scancode;
    wr.keystroke_specifier.keystroke_entry.shift_state
						= astosc[index].shiftstate;
    if (api_write_keystroke(&wr) == -1) {
	api_perror("api_write_keystroke");
	return -1;
    } else if (wr.number_of_keys_sent != 1) {
	fprintf(stderr, "write_keystroke claims to have sent %d keystrokes.\n",
		    wr.number_of_keys_sent);
	return -1;
    } else if (verbose) {
	printf("Keystroke sent.\n");
    }
    if (wait_for_ps_or_oia() == -1) {
	return -1;
    }
    return 0;
}

static int
terminate()
{
    EnableInputParms enable;
    DisconnectFromKeyboardParms disc;

    enable.rc = enable.function_id = 0;
    enable.session_id = session_id;
    enable.connectors_task_id = 0;
    if (api_enable_input(&enable) == -1) {
	api_perror("api_enable");
	return -1;
    } else if (verbose) {
	printf("Enabled.\n");
    }

    disc.rc = disc.function_id = 0;
    disc.session_id = session_id;
    disc.connectors_task_id = 0;
    if (api_disconnect_from_keyboard(&disc) == -1) {
	api_perror("api_disconnect_from_keyboard");
	return -1;
    } else if (verbose) {
	printf("Disconnected from keyboard.\n");
    }

    (void) api_finish();

    return 0;
}


static int
get_screen()
{
    CopyStringParms copy;
    /* Time copy services */

    wait_for_unlock();

    copy.copy_mode = 0;
    copy.rc = copy.function_id = 0;
    copy.source.session_id = session_id;
    copy.source.buffer = 0;
    copy.source.characteristics = 0;
    copy.source.session_type = TYPE_DFT;
    copy.source.begin = 0;

    copy.source_end = ScreenSize;

    copy.target.session_id = 0;
    copy.target.buffer = (char *) &Host[0];
    copy.target.characteristics = 0;
    copy.target.session_type = TYPE_DFT;

    if (api_copy_string(&copy) == -1) {
	api_perror("api_copy_string");
	return -1;
    }
    return 0;
}


put_at(offset, from, length, attribute)
int	offset;
char	*from;
int	length;
{
    CopyStringParms copy;

    wait_for_unlock();

    copy.copy_mode = 0;
    copy.rc = copy.function_id = 0;
    copy.source.session_id = 0;
    copy.source.buffer = from;
    copy.source.characteristics = 0;
    copy.source.session_type = TYPE_DFT;
    copy.source.begin = 0;

    copy.source_end = length-1;

    copy.target.session_id = session_id;
    copy.target.buffer = 0;
    copy.target.characteristics = 0;
    copy.target.session_type = TYPE_DFT;
    copy.target.begin = offset;

    if (api_copy_string(&copy) == -1) {
	api_perror("api_copy_string");
	return -1;
    }
    return 0;
}

static void
translate(input, output, table, length)
char *input, *output, table[];
int length;
{
    unsigned char *indices = (unsigned char *) input;

    while (length--) {
	*output++ = table[*indices++];
    }
}

static int
find_input_area(from)
int	from;
{
#define	FieldDec(p)	(0)		/* We don't really use this */
    register int i, attr;

    for (i = from; i < MAXSCREENSIZE; ) {
	if (IsStartField(i)) {
	    attr = FieldAttributes(i);
	    i++;
	    if (!IsProtectedAttr(i, attr)) {
		return i;
	    }
	} else {
	    i++;
	}
    }
    return -1;
}


static void
getascii(offset, to, length)
int	offset;				/* Where in screen */
char	*to;				/* Where it goes to */
int	length;				/* Where to put it */
{
    translate(Host+offset, to, disp_asc, length);
}

static int
putascii(offset, from, length, before)
int	offset;				/* Where in screen */
char	*from;				/* Where it comes from */
int	length;				/* Where to put it */
int	before;				/* How much else should go */
{
    translate(from, Host+offset, asc_disp, length);
    if (put_at(offset-before,
			(char *) Host+offset-before, length+before) == -1) {
	return -1;
    }
    return 0;
}

static int
ack()
{
    static char ack_blanks[sizeof a_ack_sequence] = {0};

    if (ack_blanks[0] == 0) {
	int i;

	for (i = 0; i < sizeof ack_blanks; i++) {
	    ack_blanks[i] = ' ';
	}
    }

    memcpy(a_ack_sequence, ack_blanks, sizeof a_ack_sequence);
    sprintf(a_ack_sequence, "%d", ack_sequence);
    a_ack_sequence[strlen(a_ack_sequence)] = ' ';
    Host[ACK_SEQUENCE-1] |= ATTR_MDT;
    if (putascii(ACK_SEQUENCE, a_ack_sequence, ACK_SEQUENCE_LENGTH, 1) == -1) {
	return -1;
    }
    return 0;
}

static int
formatted_correct()
{
    if ((find_input_area(SEND_SEQUENCE-1) != SEND_SEQUENCE) ||
	    (find_input_area(SEND_SEQUENCE) != ACK_SEQUENCE) ||
	    (find_input_area(ACK_SEQUENCE) != CHECKSUM) ||
	    (find_input_area(CHECKSUM) != DATA)) {
	return -1;
    } else {
	return 0;
    }
}


main(argc, argv)
int	argc;
char	*argv[];
{
    register int i;
    int data_length, input_length;
    char ascii[8];			/* Lots of room */
    FILE *outfile;
    char *data;
    extern int optind;

    /* Process any flags */
    while ((i = getopt(argc, argv, "vb")) != EOF) {
	switch (i) {
	case 'v':
	    verbose = 1;
	    break;
	case 'b':
	    blocks = 1;
	    break;
	}
    }

    if ((argc-optind) < 2) {
	fprintf(stderr, "usage: %s local.file remote.file [remote.options]\n");
	exit(1);
    }

    /* Open the local file */
    if ((outfile = fopen(argv[optind], "w")) == NULL) {
	perror("fopen");
	exit(2);
    }

    optind++;

    if (initialize() == -1) {
	return -1;
    }

    /* build the command line */
    data = data_array;
    strcpy(data, "TNCOMP SEND");
    data += strlen(data);
    for (; optind < argc; optind++) {
	*data++ = ' ';
	strcpy(data, argv[optind]);
	data += strlen(argv[optind]);
    }
    if (verbose) {
	printf("%s\n", data_array);
    }
    if (get_screen() == -1) {
	return -1;
    }
    data_length = strlen(data_array);
    if ((i = find_input_area()) == -1) {		/* Get an input area */
	if (send_key(clear_index) == -1) {
	    return -1;
	}
	if ((i = find_input_area(0)) == -1) {		/* Try again */
	    fprintf(stderr, "Unable to enter command line.\n");
	    return -1;
	}
    }
    if (i == 0) {
	Host[ScreenSize-1] |= ATTR_MDT;
    } else {
	Host[i-1] |= ATTR_MDT;
    }
    if (putascii(i, data_array, data_length, 1) == -1) {
	return -1;
    }
    if (send_key(enter_index) == -1) {
	return -1;
    }
    do {
	if (get_screen() == -1) {
	    return -1;
	}
    } while (formatted_correct() == -1);

    do {
	if (get_screen() == -1) {
	    return -1;
	}
	/* For each screen */
	if (formatted_correct() == -1) {
	    fprintf(stderr, "Bad screen written by host.\n");
	    return -1;
	}
	/* If MDT isn't reset in the sequence number, go around again */
	if (Host[ACK_SEQUENCE-1]&ATTR_MDT) {
	    if (wait_for_ps_or_oia() == -1) {
		return -1;
	    }
	    continue;
	}
	getascii(SEND_SEQUENCE, a_send_sequence, SEND_SEQUENCE_LENGTH);
	send_sequence = atoi(a_send_sequence);
	getascii(CHECKSUM, a_checksum, CHECKSUM_LENGTH);
	checksum = atoi(a_checksum);
	getascii(DATA, data_array, DATA_LENGTH);
	data = data_array;
	if (send_sequence != (ack_sequence+1)) {
	    if (ack() == -1) {
		return -1;
	    }
	    data = "1234";		/* Keep loop from failing */
	    if (send_key(enter_index) == -1) {
		return -1;
	    }
	    if (get_screen() == -1) {
		return -1;
	    }
	    continue;
	}

	data_length = DATA_LENGTH;
	while (data_length && memcmp(data, " EOF", 4)
						&& memcmp(data, "    ", 4)) {
	    memcpy(ascii, data, 4);
	    data += 4;
	    data_length -= 4;
	    ascii[4] = 0;
	    input_length = atoi(ascii);
	    /* CMS can't live with zero length records */
	    if ((input_length > 1) ||
			((input_length == 1) && (data[0] != ' '))) {
		if (fwrite(data, sizeof (char),
					input_length, outfile) == 0) {
		    perror("fwrite");
		    exit(9);
		}
	    }
	    fprintf(outfile, "\n");
	    data += input_length;
	    data_length -= input_length;
	}

	ack_sequence = send_sequence;
	if (blocks) {
	    printf("#");
	    fflush(stdout);
	}
	if (ack() == -1) {
	    return -1;
	}
	if (send_key(enter_index) == -1) {
	    return -1;
	}
    } while (memcmp(data, " EOF", 4));

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