[unix-history] / usr / src / usr.bin / tn3270 / ctlr / api.c

/*
 * This file implements the API used in the PC version.
 */

#include <stdio.h>

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

#include "../ascii/disp_asc.h"

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

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

/*
 * General utility routines.
 */

#if	defined(MSDOS)

#if	defined(LINT_ARGS)
static void movetous(char *, int, int, int);
static void movetothem(int, int, char *, int);
#endif	/* defined(LINT_ARGS) */

#define	access_api(foo,length,copyin)	(foo)
#define	unaccess_api(foo,goo,length,copyout)

static void
movetous(parms, es, di, length)
char *parms;
int es, di, length;
{
    char far *farparms = parms;

    movedata(es, di, (int) FP_SEG(farparms), (int) FP_OFF(farparms), length);
}

static void
movetothem(es, di, parms, length)
int es, di;
char *parms;
int length;
{
    char far *farparms = parms;

    movedata((int) FP_SEG(farparms), (int) FP_OFF(farparms), es, di, length);
}
#endif	/* defined(MSDOS) */

#if	defined(unix)
extern char *access_api(), *unaccess_api();
#endif	/* defined(unix) */


/*
 * Supervisor Services.
 */

static void
name_resolution(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    NameResolveParms parms;

    movetous((char *) &parms, sregs->es, regs->x.di, sizeof parms);

    regs->h.cl = 0;
    if (memcmp((char *)&parms, NAME_SESSMGR, sizeof parms.gate_name) == 0) {
	regs->x.dx = GATE_SESSMGR;
    } else if (memcmp((char *)&parms, NAME_KEYBOARD,
					sizeof parms.gate_name) == 0) {
	regs->x.dx = GATE_KEYBOARD;
    } else if (memcmp((char *)&parms, NAME_COPY, sizeof parms.gate_name) == 0) {
	regs->x.dx = GATE_COPY;
    } else if (memcmp((char *)&parms, NAME_OIAM, sizeof parms.gate_name) == 0) {
	regs->x.dx = GATE_OIAM;
    } else {
	regs->h.cl = 0x2e;	/* Name not found */
    }
    regs->h.ch = 0x12;
    regs->h.bh = 7;
}

/*
 * Session Information Services.
 */

static void
query_session_id(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    QuerySessionIdParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.option_code != 0x01) {
	parms.rc = 0x0d;	/* Invalid option code */
    } else if (parms.data_code != 0x45) {
	parms.rc = 0x0b;
    } else {
	NameArray list;
	NameArrayElement element;

	movetous((char *)&list, FP_SEG(parms.name_array),
			    FP_OFF(parms.name_array), sizeof list);
	if ((list.length < 14) || (list.length > 170)) {
	    parms.rc = 0x12;
	} else {
	    list.number_matching_session = 1;
	    list.name_array_element.short_name = parms.data_code;
	    list.name_array_element.type = TYPE_DFT;
	    list.name_array_element.session_id = 23;
	    memcpy(list.name_array_element.long_name, "ONLYSESS",
			    sizeof list.name_array_element.long_name);
	    movetothem(FP_SEG(parms.name_array),
		FP_OFF(parms.name_array), (char *)&list, sizeof list);
	    parms.rc = 0;
	}
    }
    parms.function_id = 0x6b;
    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}

static void
query_session_parameters(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    QuerySessionParametersParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc !=0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else {
	parms.rc = 0;
	parms.session_type = TYPE_DFT;
	parms.session_characteristics = 0;	/* Neither EAB nor PSS */
	parms.rows = MaxNumberLines;
	parms.columns = MaxNumberColumns;
	parms.presentation_space = 0;
    }
    parms.function_id = 0x6b;
    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}

static void
query_session_cursor(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    QuerySessionCursorParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else {
	parms.rc = 0;
	parms.cursor_type = CURSOR_BLINKING;	/* XXX what is inhibited? */
	parms.row_address = ScreenLine(CursorAddress);
	parms.column_address = ScreenLineOffset(CursorAddress);
    }

    parms.function_id = 0x6b;
    movetothem(sregs->es, regs->x.di, (char *) &parms, sizeof parms);
}

/*
 * Keyboard Services.
 */


static void
connect_to_keyboard(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    ConnectToKeyboardParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else if (parms.intercept_options != 0) {
	parms.rc = 0x01;
    } else {
	parms.rc = 0;
	parms.first_connection_identifier = 0;
    }
    parms.function_id = 0x62;

    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}

static void
disconnect_from_keyboard(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    DisconnectFromKeyboardParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else if (parms.connectors_task_id != 0) {
	parms.rc = 04;			/* XXX */
    } else {
	parms.rc = 0;
    }
    parms.function_id = 0x62;

    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}

static void
write_keystroke(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    WriteKeystrokeParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else if (parms.connectors_task_id != 0) {
	parms.rc = 0x04;
    } else {
	parms.number_of_keys_sent = 0;
	parms.rc = 0;
	if (parms.options == OPTION_SINGLE_KEYSTROKE) {
	    KeystrokeEntry *entry = &parms.keystroke_specifier.keystroke_entry;
	    
	    if (AcceptKeystroke(entry->scancode, entry->shift_state) == 0) {
		parms.rc = 0x10;		/* XXX needs 0x12 too! */
	    }
	    parms.number_of_keys_sent++;
	} else if (parms.options == OPTION_MULTIPLE_KEYSTROKES) {
	    KeystrokeList
		list,
		far *atlist = parms.keystroke_specifier.keystroke_list;
	    KeystrokeEntry
		entry[10],		/* 10 at a time */
		*ourentry,
		far *theirentry;
	    int
		todo;

	    movetous((char *)&list, FP_SEG(atlist),
				FP_OFF(atlist), sizeof *atlist);
	    todo = list.length/2;
	    ourentry = entry+(highestof(entry)+1);

	    while (todo) {
		if (ourentry > &entry[highestof(entry)]) {
		    int thistime;

		    thistime = todo;
		    if (thistime > numberof(entry)) {
			thistime = numberof(entry);
		    }
		    movetous((char *)entry, FP_SEG(theirentry),
			    FP_OFF(theirentry), thistime*sizeof *theirentry);
		    theirentry += thistime;
		    ourentry = entry;
		}
		if (AcceptKeystroke(ourentry->scancode,
						ourentry->shift_state) == 0) {
		    parms.rc = 0x10;		/* XXX needs 0x12 too! */
		    break;
		}
		parms.number_of_keys_sent++;
		ourentry++;
		todo--;
	    }
	} else {
	    parms.rc = 0x01;
	}
    }
    parms.function_id = 0x62;

    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
/* XXX */
}


static void
disable_input(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    DisableInputParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else if (parms.connectors_task_id != 0) {
	parms.rc = 0x04;
    } else {
	SetOiaApiInhibit(&OperatorInformationArea);
	parms.rc = 0;
    }
    parms.function_id = 0x62;

    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}

static void
enable_input(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    EnableInputParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else if (parms.connectors_task_id != 0) {
	parms.rc = 0x04;
    } else {
	ResetOiaApiInhibit(&OperatorInformationArea);
	parms.rc = 0;
    }
    parms.function_id = 0x62;

    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}

/*
 * Copy Services.
 */

static
copy_subroutine(target, source, parms, what_is_user, length)
BufferDescriptor *target, *source;
CopyStringParms *parms;
int what_is_user;
#define	USER_IS_TARGET	0
#define	USER_IS_SOURCE	1
{
#define	TARGET_NO_EAB		1
#define	SOURCE_NO_EAB		2
#define	TARGET_PC		4
#define	SOURCE_PC		8
#define	NO_FIELD_ATTRIBUTES	16
    int needtodo = 0;
    int access_length;
    char far *input;
    char far *output;
    char far *access_pointer;

    if ((target->characteristics^source->characteristics)
		    &CHARACTERISTIC_EAB) {
	if (target->characteristics&CHARACTERISTIC_EAB) {
	    needtodo |= TARGET_NO_EAB;	/* Need to bump for EAB in target */
	} else {
	    needtodo |= SOURCE_NO_EAB;	/* Need to bump for EAB in source */
	}
    }
    if (target->session_type != source->session_type) {
	if (target->session_type == TYPE_PC) {
	    needtodo |= TARGET_PC;	/* scan codes to PC */
	} else {
	    needtodo |= SOURCE_PC;	/* PC to scan codes */
	}
    }
    if ((parms->copy_mode&COPY_MODE_FIELD_ATTRIBUTES) == 0) {
	needtodo |= NO_FIELD_ATTRIBUTES;
    }
    access_length = length;
    if (what_is_user == USER_IS_TARGET) {
	if (target->characteristics&CHARACTERISTIC_EAB) {
	    access_length *= 2;
	}
	input = (char far *) &Host[source->begin];
	access_pointer = target->buffer;
	output = access_api(target->buffer, access_length, 0);
    } else {
	if (source->characteristics&CHARACTERISTIC_EAB) {
	    access_length *= 2;
	}
	access_pointer = source->buffer;
	input = access_api(source->buffer, access_length, 1);
	output = (char far *) &Host[target->begin];
    }
    while (length--) {
	if (needtodo&TARGET_PC) {
	    *output++ = disp_asc[*input++];
	} else if (needtodo&SOURCE_PC) {
	    *output++ = asc_disp[*input++];
	} else {
	    *output++ = *input++;
	}
	if (needtodo&TARGET_NO_EAB) {
	    *input++;
	} else if (needtodo&SOURCE_NO_EAB) {
	    *output++ = 0;		/* Should figure out good EAB? */
	}
    }
    if (what_is_user == USER_IS_TARGET) {
	unaccess_api(target->buffer, access_pointer, access_length, 1);
    } else {
	unaccess_api(source->buffer, access_pointer, access_length, 0);
    }
}


static void
copy_string(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    CopyStringParms parms;
    BufferDescriptor *target = &parms.target, *source = &parms.source;
    int length;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    length = 1+parms.source_end-source->begin;
    if ((parms.rc != 0) || (parms.function_id !=0)) {
	parms.rc = 0x0c;
    } else if (target->session_id == 0) {	/* Target is buffer */
	if (source->session_id != 23) {		/* A no-no */
	    parms.rc = 0x2;
	} else {
	    if ((source->begin < 0) || (source->begin > highestof(Host))) {
		parms.rc = 0x06;		/* invalid source definition */
	    } else {
		if ((source->begin+length) > highestof(Host)) {
		    length = highestof(Host)-source->begin;
		    parms.rc = 0x0f;	/* Truncate */
		}
	        if ((source->characteristics == target->characteristics) &&
		    (source->session_type == target->session_type)) {
		    if (source->characteristics&CHARACTERISTIC_EAB) {
			length *= 2;
		    }
		    movetothem( (int) FP_SEG(target->buffer),
			    (int) FP_OFF(target->buffer),
			    (char *)&Host[source->begin], length);
		} else {
		    copy_subroutine(target, source, &parms,
							USER_IS_TARGET, length);
		}
	    }
	}
    } else if (source->session_id != 0) {
	    parms.rc = 0xd;
    } else {
	if ((target->begin < 0) || (source->begin > highestof(Host))) {
	    parms.rc = 0x07;		/* invalid source definition */
	} else {
	    if ((source->begin+length) > highestof(Host)) {
		length = highestof(Host)-source->begin;
		parms.rc = 0x0f;	/* Truncate */
	    }
	    if ((source->characteristics == target->characteristics) &&
		    (source->session_type == target->session_type)) {
		if (source->characteristics&CHARACTERISTIC_EAB) {
		    length *= 2;
		}
		movetous((char *)&Host[target->begin],
			    (int) FP_SEG(source->buffer),
			    (int) FP_OFF(source->buffer), length);
	    } else {
		copy_subroutine(target, source, &parms, USER_IS_SOURCE, length);
	    }
	}
    }
    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}
/*
 * Operator Information Area Services.
 */

static void
read_oia_group(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    ReadOiaGroupParms parms;

    movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);

    if ((parms.rc != 0) || (parms.function_id != 0)) {
	parms.rc = 0x0c;
    } else if (parms.session_id != 23) {
	parms.rc = 0x02;
    } else {
	int group = parms.oia_group_number;
	char *from;
	int size;

	if ((group != API_OIA_ALL_GROUPS) &&
		((group > API_OIA_LAST_LEGAL_GROUP) || (group < 0))) {
	} else {
	    if (group == API_OIA_ALL_GROUPS) {
		size = API_OIA_BYTES_ALL_GROUPS;
		from = (char *)&OperatorInformationArea;
	    } else if (group == API_OIA_INPUT_INHIBITED) {
		size = sizeof OperatorInformationArea.input_inhibited;
		from = (char *)&OperatorInformationArea.input_inhibited[0];
	    } else {
		size = 1;
		from = ((char *)&OperatorInformationArea)+group;
	    }
	    movetothem(FP_SEG(parms.oia_buffer), FP_OFF(parms.oia_buffer),
			from, size);
	}
    }
    parms.function_id = 0x6d;
    movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
}
\f
static void
unknown_op(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    regs->h.ch = 0x12;
    regs->h.cl = 0x05;
}


handle_api(regs, sregs)
union REGS *regs;
struct SREGS *sregs;
{
    if (regs->h.ah == NAME_RESOLUTION) {
	name_resolution(regs, sregs);
    } else if (regs->h.ah != 0x09) {
	regs->h.ch = 0x12;
	regs->h.cl = 0x0f;		/* XXX Invalid environmental access */
    } else if (regs->x.bx != 0x8020) {
	regs->h.ch = 0x12;
	regs->h.cl = 0x08;		/* XXX Invalid wait specified */
    } else if (regs->h.ch != 0) {
	regs->x.cx = 0x1206;		/* XXX Invalid priority */
    } else {
	switch (regs->x.dx) {
	case GATE_SESSMGR:
	    switch (regs->h.al) {
	    case QUERY_SESSION_ID:
		if (regs->h.cl != 0) {
		    regs->x.cx = 0x1206;
		} else {
		    regs->x.cx = 0x1200;
		    query_session_id(regs, sregs);
		}
		break;
	    case QUERY_SESSION_PARAMETERS:
		if (regs->h.cl != 0) {
		    regs->x.cx = 0x1206;
		} else {
		    regs->x.cx = 0x1200;
		    query_session_parameters(regs, sregs);
		}
		break;
	    case QUERY_SESSION_CURSOR:
		if (regs->h.cl != 0xff) {
		    regs->x.cx = 0x1206;
		} else {
		    regs->x.cx = 0x1200;
		    query_session_cursor(regs, sregs);
		}
		break;
	    default:
		unknown_op(regs, sregs);
		break;
	    }
	    break;
	case GATE_KEYBOARD:
	    if (regs->h.cl != 00) {
		regs->x.cx = 0x1206;
	    } else {
		regs->x.cx = 0x1200;
		switch (regs->h.al) {
		case CONNECT_TO_KEYBOARD:
		    connect_to_keyboard(regs, sregs);
		    break;
		case DISABLE_INPUT:
		    disable_input(regs, sregs);
		    break;
		case WRITE_KEYSTROKE:
		    write_keystroke(regs, sregs);
		    break;
		case ENABLE_INPUT:
		    enable_input(regs, sregs);
		    break;
		case DISCONNECT_FROM_KEYBOARD:
		    disconnect_from_keyboard(regs, sregs);
		    break;
		default:
		    unknown_op(regs, sregs);
		    break;
		}
	    }
	    break;
	case GATE_COPY:
	    if (regs->h.cl != 0xff) {
		regs->x.cx = 0x1206;
	    } else {
		regs->x.cx = 0x1200;
		switch (regs->h.al) {
		case COPY_STRING:
		    copy_string(regs, sregs);
		    break;
		default:
		    unknown_op(regs, sregs);
		    break;
		}
	    }
	    break;
	case GATE_OIAM:
	    if (regs->h.cl != 0xff) {
		regs->x.cx = 0x1206;
	    } else {
		regs->x.cx = 0x1200;
		switch (regs->h.al) {
		case READ_OIA_GROUP:
		    read_oia_group(regs, sregs);
		    break;
		default:
		    unknown_op(regs, sregs);
		    break;
		}
	    }
	    break;
	default:
	    regs->h.ch = 0x12;
	    regs->h.cl = 0x34;		/* Invalid GATE entry */
	    break;
	}
    }
}
Commit	Line	Data
abd201e9 GM	1	/*
	2	* This file implements the API used in the PC version.
	3	*/
	4
	5	#include <stdio.h>
abd201e9	6
abd201e9	7	#include "api.h"
d4967272	8	#include "../general/general.h"
abd201e9	9
6376f1f2 GM	10	#include "../ascii/disp_asc.h"
6376f1f2 GM	11
65c9fa1f	12	#include "../ctlr/screen.h"
92f7501a GM	13	#include "../ctlr/oia.h"
92f7501a GM	14
d4967272	15	#include "../general/globals.h"
65c9fa1f	16
92f7501a GM	17	/*
	18	* General utility routines.
	19	*/
	20
	21	#if defined(MSDOS)
ffff8f6a GM	22
	23	#if defined(LINT_ARGS)
	24	static void movetous(char *, int, int, int);
	25	static void movetothem(int, int, char *, int);
	26	#endif /* defined(LINT_ARGS) */
92f7501a	27
ec5b8360 GM	28	#define access_api(foo,length,copyin) (foo)
ec5b8360 GM	29	#define unaccess_api(foo,goo,length,copyout)
6376f1f2	30
92f7501a GM	31	static void
	32	movetous(parms, es, di, length)
	33	char *parms;
ffff8f6a	34	int es, di, length;
92f7501a	35	{
ffff8f6a	36	char far *farparms = parms;
92f7501a	37
ffff8f6a	38	movedata(es, di, (int) FP_SEG(farparms), (int) FP_OFF(farparms), length);
92f7501a GM	39	}
	40
	41	static void
ffff8f6a GM	42	movetothem(es, di, parms, length)
	43	int es, di;
	44	char *parms;
	45	int length;
92f7501a	46	{
ffff8f6a	47	char far *farparms = parms;
92f7501a	48
ffff8f6a	49	movedata((int) FP_SEG(farparms), (int) FP_OFF(farparms), es, di, length);
92f7501a GM	50	}
	51	#endif /* defined(MSDOS) */
	52
6376f1f2	53	#if defined(unix)
4604a66c	54	extern char access_api(), unaccess_api();
6376f1f2	55	#endif /* defined(unix) */
92f7501a	56
4604a66c	57
abd201e9 GM	58	/*
	59	* Supervisor Services.
	60	*/
	61
	62	static void
92f7501a	63	name_resolution(regs, sregs)
abd201e9 GM	64	union REGS *regs;
	65	struct SREGS *sregs;
	66	{
86057566	67	NameResolveParms parms;
e75c75e7	68
86057566	69	movetous((char *) &parms, sregs->es, regs->x.di, sizeof parms);
e75c75e7 GM	70
e75c75e7 GM	71	regs->h.cl = 0;
92f7501a	72	if (memcmp((char *)&parms, NAME_SESSMGR, sizeof parms.gate_name) == 0) {
e75c75e7	73	regs->x.dx = GATE_SESSMGR;
92f7501a GM	74	} else if (memcmp((char *)&parms, NAME_KEYBOARD,
92f7501a GM	75	sizeof parms.gate_name) == 0) {
e75c75e7	76	regs->x.dx = GATE_KEYBOARD;
92f7501a	77	} else if (memcmp((char *)&parms, NAME_COPY, sizeof parms.gate_name) == 0) {
e75c75e7	78	regs->x.dx = GATE_COPY;
92f7501a	79	} else if (memcmp((char *)&parms, NAME_OIAM, sizeof parms.gate_name) == 0) {
e75c75e7 GM	80	regs->x.dx = GATE_OIAM;
	81	} else {
	82	regs->h.cl = 0x2e; /* Name not found */
	83	}
	84	regs->h.ch = 0x12;
	85	regs->h.bh = 7;
abd201e9 GM	86	}
	87
	88	/*
	89	* Session Information Services.
	90	*/
	91
	92	static void
	93	query_session_id(regs, sregs)
	94	union REGS *regs;
	95	struct SREGS *sregs;
	96	{
86057566	97	QuerySessionIdParms parms;
e75c75e7	98
86057566	99	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
e75c75e7	100
ffff8f6a GM	101	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	102	parms.rc = 0x0c;
	103	} else if (parms.option_code != 0x01) {
	104	parms.rc = 0x0d; /* Invalid option code */
86057566	105	} else if (parms.data_code != 0x45) {
ffff8f6a	106	parms.rc = 0x0b;
e75c75e7	107	} else {
65c9fa1f	108	NameArray list;
86057566 GM	109	NameArrayElement element;
	110
	111	movetous((char *)&list, FP_SEG(parms.name_array),
92f7501a	112	FP_OFF(parms.name_array), sizeof list);
65c9fa1f	113	if ((list.length < 14) \|\| (list.length > 170)) {
86057566	114	parms.rc = 0x12;
e75c75e7	115	} else {
86057566 GM	116	list.number_matching_session = 1;
	117	list.name_array_element.short_name = parms.data_code;
	118	list.name_array_element.type = TYPE_DFT;
	119	list.name_array_element.session_id = 23;
	120	memcpy(list.name_array_element.long_name, "ONLYSESS",
	121	sizeof list.name_array_element.long_name);
	122	movetothem(FP_SEG(parms.name_array),
92f7501a	123	FP_OFF(parms.name_array), (char *)&list, sizeof list);
86057566	124	parms.rc = 0;
e75c75e7 GM	125	}
e75c75e7 GM	126	}
ffff8f6a	127	parms.function_id = 0x6b;
86057566	128	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	129	}
	130
	131	static void
	132	query_session_parameters(regs, sregs)
	133	union REGS *regs;
	134	struct SREGS *sregs;
	135	{
86057566 GM	136	QuerySessionParametersParms parms;
	137
	138	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	139
65c9fa1f	140	if ((parms.rc !=0) \|\| (parms.function_id != 0)) {
ffff8f6a GM	141	parms.rc = 0x0c;
	142	} else if (parms.session_id != 23) {
	143	parms.rc = 0x02;
86057566	144	} else {
ffff8f6a	145	parms.rc = 0;
86057566 GM	146	parms.session_type = TYPE_DFT;
	147	parms.session_characteristics = 0; /* Neither EAB nor PSS */
	148	parms.rows = MaxNumberLines;
	149	parms.columns = MaxNumberColumns;
	150	parms.presentation_space = 0;
	151	}
ffff8f6a	152	parms.function_id = 0x6b;
65c9fa1f	153	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	154	}
	155
	156	static void
	157	query_session_cursor(regs, sregs)
	158	union REGS *regs;
	159	struct SREGS *sregs;
	160	{
86057566 GM	161	QuerySessionCursorParms parms;
	162
	163	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	164
	165	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	166	parms.rc = 0x0c;
	167	} else if (parms.session_id != 23) {
	168	parms.rc = 0x02;
	169	} else {
	170	parms.rc = 0;
86057566 GM	171	parms.cursor_type = CURSOR_BLINKING; /* XXX what is inhibited? */
	172	parms.row_address = ScreenLine(CursorAddress);
	173	parms.column_address = ScreenLineOffset(CursorAddress);
	174	}
	175
ffff8f6a GM	176	parms.function_id = 0x6b;
ffff8f6a GM	177	movetothem(sregs->es, regs->x.di, (char *) &parms, sizeof parms);
abd201e9 GM	178	}
	179
	180	/*
	181	* Keyboard Services.
	182	*/
	183
	184
	185	static void
	186	connect_to_keyboard(regs, sregs)
	187	union REGS *regs;
	188	struct SREGS *sregs;
	189	{
86057566 GM	190	ConnectToKeyboardParms parms;
86057566 GM	191
d4967272	192	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
86057566 GM	193
	194	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	195	parms.rc = 0x0c;
	196	} else if (parms.session_id != 23) {
	197	parms.rc = 0x02;
	198	} else if (parms.intercept_options != 0) {
	199	parms.rc = 0x01;
	200	} else {
	201	parms.rc = 0;
	202	parms.first_connection_identifier = 0;
	203	}
	204	parms.function_id = 0x62;
	205
	206	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	207	}
	208
	209	static void
86057566	210	disconnect_from_keyboard(regs, sregs)
abd201e9 GM	211	union REGS *regs;
	212	struct SREGS *sregs;
	213	{
86057566 GM	214	DisconnectFromKeyboardParms parms;
	215
	216	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	217
	218	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	219	parms.rc = 0x0c;
	220	} else if (parms.session_id != 23) {
	221	parms.rc = 0x02;
	222	} else if (parms.connectors_task_id != 0) {
	223	parms.rc = 04; /* XXX */
	224	} else {
	225	parms.rc = 0;
	226	}
	227	parms.function_id = 0x62;
	228
	229	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	230	}
	231
	232	static void
	233	write_keystroke(regs, sregs)
	234	union REGS *regs;
	235	struct SREGS *sregs;
	236	{
cbdd0b03 GM	237	WriteKeystrokeParms parms;
	238
	239	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	240
	241	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	242	parms.rc = 0x0c;
	243	} else if (parms.session_id != 23) {
	244	parms.rc = 0x02;
	245	} else if (parms.connectors_task_id != 0) {
	246	parms.rc = 0x04;
	247	} else {
	248	parms.number_of_keys_sent = 0;
	249	parms.rc = 0;
	250	if (parms.options == OPTION_SINGLE_KEYSTROKE) {
	251	KeystrokeEntry *entry = &parms.keystroke_specifier.keystroke_entry;
	252
	253	if (AcceptKeystroke(entry->scancode, entry->shift_state) == 0) {
	254	parms.rc = 0x10; /* XXX needs 0x12 too! */
	255	}
	256	parms.number_of_keys_sent++;
	257	} else if (parms.options == OPTION_MULTIPLE_KEYSTROKES) {
	258	KeystrokeList
	259	list,
	260	far *atlist = parms.keystroke_specifier.keystroke_list;
	261	KeystrokeEntry
	262	entry[10], /* 10 at a time */
	263	*ourentry,
	264	far *theirentry;
	265	int
	266	todo;
	267
	268	movetous((char *)&list, FP_SEG(atlist),
	269	FP_OFF(atlist), sizeof *atlist);
	270	todo = list.length/2;
	271	ourentry = entry+(highestof(entry)+1);
	272
	273	while (todo) {
	274	if (ourentry > &entry[highestof(entry)]) {
	275	int thistime;
	276
	277	thistime = todo;
	278	if (thistime > numberof(entry)) {
	279	thistime = numberof(entry);
	280	}
	281	movetous((char *)entry, FP_SEG(theirentry),
	282	FP_OFF(theirentry), thistimesizeof theirentry);
	283	theirentry += thistime;
	284	ourentry = entry;
	285	}
	286	if (AcceptKeystroke(ourentry->scancode,
	287	ourentry->shift_state) == 0) {
	288	parms.rc = 0x10; /* XXX needs 0x12 too! */
	289	break;
	290	}
	291	parms.number_of_keys_sent++;
	292	ourentry++;
	293	todo--;
	294	}
	295	} else {
	296	parms.rc = 0x01;
	297	}
	298	}
	299	parms.function_id = 0x62;
	300
301	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
86057566 GM	302	/* XXX */
	303	}
	304
	305
	306	static void
	307	disable_input(regs, sregs)
	308	union REGS *regs;
	309	struct SREGS *sregs;
	310	{
	311	DisableInputParms parms;
	312
	313	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	314
	315	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	316	parms.rc = 0x0c;
	317	} else if (parms.session_id != 23) {
	318	parms.rc = 0x02;
	319	} else if (parms.connectors_task_id != 0) {
	320	parms.rc = 0x04;
	321	} else {
ffff8f6a	322	SetOiaApiInhibit(&OperatorInformationArea);
86057566 GM	323	parms.rc = 0;
	324	}
	325	parms.function_id = 0x62;
	326
	327	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	328	}
	329
	330	static void
	331	enable_input(regs, sregs)
	332	union REGS *regs;
	333	struct SREGS *sregs;
	334	{
86057566 GM	335	EnableInputParms parms;
	336
	337	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	338
	339	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	340	parms.rc = 0x0c;
	341	} else if (parms.session_id != 23) {
	342	parms.rc = 0x02;
	343	} else if (parms.connectors_task_id != 0) {
	344	parms.rc = 0x04;
	345	} else {
ffff8f6a	346	ResetOiaApiInhibit(&OperatorInformationArea);
86057566 GM	347	parms.rc = 0;
	348	}
	349	parms.function_id = 0x62;
	350
	351	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	352	}
	353
	354	/*
	355	* Copy Services.
	356	*/
	357
ec5b8360 GM	358	static
ec5b8360 GM	359	copy_subroutine(target, source, parms, what_is_user, length)
6376f1f2 GM	360	BufferDescriptor target, source;
	361	CopyStringParms *parms;
	362	int what_is_user;
	363	#define USER_IS_TARGET 0
	364	#define USER_IS_SOURCE 1
	365	{
	366	#define TARGET_NO_EAB 1
	367	#define SOURCE_NO_EAB 2
	368	#define TARGET_PC 4
	369	#define SOURCE_PC 8
	370	#define NO_FIELD_ATTRIBUTES 16
	371	int needtodo = 0;
6376f1f2 GM	372	int access_length;
	373	char far *input;
	374	char far *output;
	375	char far *access_pointer;
	376
	377	if ((target->characteristics^source->characteristics)
	378	&CHARACTERISTIC_EAB) {
	379	if (target->characteristics&CHARACTERISTIC_EAB) {
	380	needtodo \|= TARGET_NO_EAB; /* Need to bump for EAB in target */
	381	} else {
	382	needtodo \|= SOURCE_NO_EAB; /* Need to bump for EAB in source */
	383	}
	384	}
	385	if (target->session_type != source->session_type) {
	386	if (target->session_type == TYPE_PC) {
	387	needtodo \|= TARGET_PC; /* scan codes to PC */
	388	} else {
	389	needtodo \|= SOURCE_PC; /* PC to scan codes */
	390	}
	391	}
	392	if ((parms->copy_mode&COPY_MODE_FIELD_ATTRIBUTES) == 0) {
	393	needtodo \|= NO_FIELD_ATTRIBUTES;
	394	}
ec5b8360	395	access_length = length;
6376f1f2 GM	396	if (what_is_user == USER_IS_TARGET) {
	397	if (target->characteristics&CHARACTERISTIC_EAB) {
	398	access_length *= 2;
	399	}
	400	input = (char far *) &Host[source->begin];
	401	access_pointer = target->buffer;
ec5b8360	402	output = access_api(target->buffer, access_length, 0);
6376f1f2 GM	403	} else {
	404	if (source->characteristics&CHARACTERISTIC_EAB) {
	405	access_length *= 2;
	406	}
	407	access_pointer = source->buffer;
ec5b8360	408	input = access_api(source->buffer, access_length, 1);
6376f1f2 GM	409	output = (char far *) &Host[target->begin];
	410	}
	411	while (length--) {
	412	if (needtodo&TARGET_PC) {
	413	output++ = disp_asc[input++];
	414	} else if (needtodo&SOURCE_PC) {
	415	output++ = asc_disp[input++];
	416	} else {
	417	output++ = input++;
	418	}
	419	if (needtodo&TARGET_NO_EAB) {
	420	*input++;
	421	} else if (needtodo&SOURCE_NO_EAB) {
	422	output++ = 0; / Should figure out good EAB? */
	423	}
	424	}
	425	if (what_is_user == USER_IS_TARGET) {
ec5b8360	426	unaccess_api(target->buffer, access_pointer, access_length, 1);
6376f1f2	427	} else {
ec5b8360	428	unaccess_api(source->buffer, access_pointer, access_length, 0);
6376f1f2 GM	429	}
	430	}
	431
	432
abd201e9	433	static void
86057566	434	copy_string(regs, sregs)
abd201e9 GM	435	union REGS *regs;
	436	struct SREGS *sregs;
	437	{
86057566	438	CopyStringParms parms;
6376f1f2 GM	439	BufferDescriptor target = &parms.target, source = &parms.source;
6376f1f2 GM	440	int length;
86057566 GM	441
86057566 GM	442	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
abd201e9	443
ec5b8360	444	length = 1+parms.source_end-source->begin;
86057566 GM	445	if ((parms.rc != 0) \|\| (parms.function_id !=0)) {
86057566 GM	446	parms.rc = 0x0c;
6376f1f2 GM	447	} else if (target->session_id == 0) { /* Target is buffer */
	448	if (source->session_id != 23) { /* A no-no */
	449	parms.rc = 0x2;
	450	} else {
ec5b8360 GM	451	if ((source->begin < 0) \|\| (source->begin > highestof(Host))) {
	452	parms.rc = 0x06; /* invalid source definition */
	453	} else {
	454	if ((source->begin+length) > highestof(Host)) {
	455	length = highestof(Host)-source->begin;
	456	parms.rc = 0x0f; /* Truncate */
	457	}
	458	if ((source->characteristics == target->characteristics) &&
6376f1f2	459	(source->session_type == target->session_type)) {
ec5b8360 GM	460	if (source->characteristics&CHARACTERISTIC_EAB) {
	461	length *= 2;
	462	}
	463	movetothem( (int) FP_SEG(target->buffer),
	464	(int) FP_OFF(target->buffer),
	465	(char *)&Host[source->begin], length);
	466	} else {
	467	copy_subroutine(target, source, &parms,
	468	USER_IS_TARGET, length);
6376f1f2	469	}
6376f1f2 GM	470	}
	471	}
	472	} else if (source->session_id != 0) {
	473	parms.rc = 0xd;
	474	} else {
ec5b8360 GM	475	if ((target->begin < 0) \|\| (source->begin > highestof(Host))) {
ec5b8360 GM	476	parms.rc = 0x07; /* invalid source definition */
6376f1f2	477	} else {
ec5b8360 GM	478	if ((source->begin+length) > highestof(Host)) {
	479	length = highestof(Host)-source->begin;
	480	parms.rc = 0x0f; /* Truncate */
	481	}
	482	if ((source->characteristics == target->characteristics) &&
	483	(source->session_type == target->session_type)) {
	484	if (source->characteristics&CHARACTERISTIC_EAB) {
	485	length *= 2;
	486	}
	487	movetous((char *)&Host[target->begin],
	488	(int) FP_SEG(source->buffer),
	489	(int) FP_OFF(source->buffer), length);
	490	} else {
	491	copy_subroutine(target, source, &parms, USER_IS_SOURCE, length);
	492	}
6376f1f2	493	}
86057566	494	}
d4967272	495	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
86057566	496	}
abd201e9 GM	497	/*
	498	* Operator Information Area Services.
	499	*/
	500
	501	static void
	502	read_oia_group(regs, sregs)
	503	union REGS *regs;
	504	struct SREGS *sregs;
	505	{
86057566 GM	506	ReadOiaGroupParms parms;
	507
	508	movetous((char *)&parms, sregs->es, regs->x.di, sizeof parms);
	509
	510	if ((parms.rc != 0) \|\| (parms.function_id != 0)) {
	511	parms.rc = 0x0c;
	512	} else if (parms.session_id != 23) {
	513	parms.rc = 0x02;
	514	} else {
	515	int group = parms.oia_group_number;
92f7501a GM	516	char *from;
92f7501a GM	517	int size;
86057566	518
ffff8f6a GM	519	if ((group != API_OIA_ALL_GROUPS) &&
ffff8f6a GM	520	((group > API_OIA_LAST_LEGAL_GROUP) \|\| (group < 0))) {
92f7501a GM	521	} else {
	522	if (group == API_OIA_ALL_GROUPS) {
	523	size = API_OIA_BYTES_ALL_GROUPS;
	524	from = (char *)&OperatorInformationArea;
	525	} else if (group == API_OIA_INPUT_INHIBITED) {
	526	size = sizeof OperatorInformationArea.input_inhibited;
	527	from = (char *)&OperatorInformationArea.input_inhibited[0];
	528	} else {
	529	size = 1;
	530	from = ((char *)&OperatorInformationArea)+group;
	531	}
	532	movetothem(FP_SEG(parms.oia_buffer), FP_OFF(parms.oia_buffer),
	533	from, size);
65c9fa1f	534	}
86057566	535	}
65c9fa1f	536	parms.function_id = 0x6d;
86057566	537	movetothem(sregs->es, regs->x.di, (char *)&parms, sizeof parms);
abd201e9 GM	538	}
	539	\f
	540	static void
	541	unknown_op(regs, sregs)
	542	union REGS *regs;
	543	struct SREGS *sregs;
	544	{
	545	regs->h.ch = 0x12;
	546	regs->h.cl = 0x05;
	547	}
	548
	549
	550	handle_api(regs, sregs)
	551	union REGS *regs;
	552	struct SREGS *sregs;
	553	{
	554	if (regs->h.ah == NAME_RESOLUTION) {
	555	name_resolution(regs, sregs);
65c9fa1f GM	556	} else if (regs->h.ah != 0x09) {
	557	regs->h.ch = 0x12;
	558	regs->h.cl = 0x0f; /* XXX Invalid environmental access */
	559	} else if (regs->x.bx != 0x8020) {
	560	regs->h.ch = 0x12;
	561	regs->h.cl = 0x08; /* XXX Invalid wait specified */
	562	} else if (regs->h.ch != 0) {
ffff8f6a	563	regs->x.cx = 0x1206; /* XXX Invalid priority */
abd201e9 GM	564	} else {
	565	switch (regs->x.dx) {
	566	case GATE_SESSMGR:
	567	switch (regs->h.al) {
	568	case QUERY_SESSION_ID:
65c9fa1f	569	if (regs->h.cl != 0) {
ffff8f6a	570	regs->x.cx = 0x1206;
65c9fa1f	571	} else {
ffff8f6a	572	regs->x.cx = 0x1200;
65c9fa1f GM	573	query_session_id(regs, sregs);
65c9fa1f GM	574	}
abd201e9	575	break;
ffff8f6a	576	case QUERY_SESSION_PARAMETERS:
65c9fa1f	577	if (regs->h.cl != 0) {
ffff8f6a	578	regs->x.cx = 0x1206;
65c9fa1f	579	} else {
ffff8f6a	580	regs->x.cx = 0x1200;
92f7501a	581	query_session_parameters(regs, sregs);
65c9fa1f	582	}
abd201e9 GM	583	break;
abd201e9 GM	584	case QUERY_SESSION_CURSOR:
65c9fa1f	585	if (regs->h.cl != 0xff) {
ffff8f6a	586	regs->x.cx = 0x1206;
65c9fa1f	587	} else {
ffff8f6a	588	regs->x.cx = 0x1200;
65c9fa1f GM	589	query_session_cursor(regs, sregs);
65c9fa1f GM	590	}
abd201e9 GM	591	break;
	592	default:
	593	unknown_op(regs, sregs);
	594	break;
	595	}
	596	break;
	597	case GATE_KEYBOARD:
65c9fa1f	598	if (regs->h.cl != 00) {
ffff8f6a	599	regs->x.cx = 0x1206;
65c9fa1f	600	} else {
ffff8f6a	601	regs->x.cx = 0x1200;
65c9fa1f GM	602	switch (regs->h.al) {
	603	case CONNECT_TO_KEYBOARD:
	604	connect_to_keyboard(regs, sregs);
	605	break;
	606	case DISABLE_INPUT:
	607	disable_input(regs, sregs);
	608	break;
	609	case WRITE_KEYSTROKE:
	610	write_keystroke(regs, sregs);
	611	break;
	612	case ENABLE_INPUT:
	613	enable_input(regs, sregs);
	614	break;
	615	case DISCONNECT_FROM_KEYBOARD:
	616	disconnect_from_keyboard(regs, sregs);
	617	break;
	618	default:
	619	unknown_op(regs, sregs);
	620	break;
	621	}
abd201e9 GM	622	}
	623	break;
	624	case GATE_COPY:
65c9fa1f	625	if (regs->h.cl != 0xff) {
ffff8f6a	626	regs->x.cx = 0x1206;
65c9fa1f	627	} else {
ffff8f6a	628	regs->x.cx = 0x1200;
65c9fa1f GM	629	switch (regs->h.al) {
	630	case COPY_STRING:
	631	copy_string(regs, sregs);
	632	break;
	633	default:
	634	unknown_op(regs, sregs);
	635	break;
	636	}
abd201e9 GM	637	}
	638	break;
	639	case GATE_OIAM:
65c9fa1f	640	if (regs->h.cl != 0xff) {
ffff8f6a	641	regs->x.cx = 0x1206;
65c9fa1f	642	} else {
ffff8f6a	643	regs->x.cx = 0x1200;
65c9fa1f GM	644	switch (regs->h.al) {
	645	case READ_OIA_GROUP:
	646	read_oia_group(regs, sregs);
	647	break;
	648	default:
	649	unknown_op(regs, sregs);
	650	break;
	651	}
abd201e9 GM	652	}
	653	break;
	654	default:
65c9fa1f GM	655	regs->h.ch = 0x12;
65c9fa1f GM	656	regs->h.cl = 0x34; /* Invalid GATE entry */
abd201e9 GM	657	break;
	658	}
	659	}
	660	}