xref: /original-bsd/usr.bin/tn3270/api/apilib.c (revision 6589fcc3)
1 /*-
2  * Copyright (c) 1988, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * %sccs.include.redist.c%
6  */
7 
8 #ifndef lint
9 static char sccsid[] = "@(#)apilib.c	8.1 (Berkeley) 06/06/93";
10 #endif /* not lint */
11 
12 #include "../ctlr/api.h"
13 
14 #include "apilib.h"
15 
16 int
17     api_sup_errno = 0,			/* Supervisor error number */
18     api_sup_fcn_id = 0,			/* Supervisor function id (0x12) */
19     api_fcn_errno = 0,			/* Function error number */
20     api_fcn_fcn_id = 0;			/* Function ID (0x6b, etc.) */
21 
22 static int
23     gate_sessmgr = 0,
24     gate_keyboard = 0,
25     gate_copy = 0,
26     gate_oiam = 0;
27 
28 /*
29  * Issue an API request, with reg structures supplied by the caller.
30  *
31  * Only certain routines need this (supervisor services come to mind).
32  */
33 
34 static int
api_issue_regs(ah,al,bh,bl,cx,dx,parms,length,regs,sregs)35 api_issue_regs(ah, al, bh, bl, cx, dx, parms, length, regs, sregs)
36 int		ah, al, bh, bl, cx, dx;
37 char 		*parms;
38 int		length;
39 union REGS 	*regs;
40 struct SREGS 	*sregs;
41 {
42     char far *ourseg = parms;
43 
44     regs->h.ah = ah;
45     regs->h.al = al;
46     regs->h.bh = bh;
47     regs->h.bl = bl;
48     regs->x.cx = cx;
49     regs->x.dx = dx;
50     sregs->es = FP_SEG(ourseg);
51     regs->x.di = FP_OFF(ourseg);
52 
53 #if	defined(MSDOS)
54     int86x(API_INTERRUPT_NUMBER, regs, regs, sregs);
55 #endif	/* defined(MSDOS) */
56 #if	defined(unix)
57     api_exch_api(regs, sregs, parms, length);
58 #endif	/* defined(unix) */
59 
60     if (regs->h.cl != 0) {
61 	api_sup_errno = regs->h.cl;
62 	return -1;
63     } else {
64 	return 0;
65     }
66 }
67 
68 
69 /*
70  * Issue an API request without requiring caller to supply
71  * registers.  Most routines use this.
72  */
73 
74 static int
api_issue(ah,al,bh,bl,cx,dx,parms,length)75 api_issue(ah, al, bh, bl, cx, dx, parms, length)
76 int
77     ah,
78     al,
79     bh,
80     bl,
81     cx,
82     dx;
83 char *parms;
84 int length;				/* Length of parms */
85 {
86     union REGS regs;
87     struct SREGS sregs;
88 
89     return api_issue_regs(ah, al, bh, bl, cx, dx, parms, length, &regs, &sregs);
90 }
91 
92 /*
93  * Supervisor Services
94  */
95 
96 int
api_name_resolve(name)97 api_name_resolve(name)
98 char *name;
99 {
100     NameResolveParms parms;
101     int i;
102     union REGS regs;
103     struct SREGS sregs;
104 
105     for (i = 0; i < sizeof parms.gate_name; i++) {
106 	if (*name) {
107 	    parms.gate_name[i] = *name++;
108 	} else {
109 	    parms.gate_name[i] = ' ';
110 	}
111     }
112 
113     if (api_issue_regs(NAME_RESOLUTION, 0, 0, 0, 0, 0, (char *) &parms,
114 			    sizeof parms, &regs, &sregs) == -1) {
115 	return -1;
116     } else {
117 	return regs.x.dx;
118     }
119 }
120 
121 #if	defined(unix)
122 /*
123  * Block until the oia or ps is modified.
124  */
125 
126 int
api_ps_or_oia_modified()127 api_ps_or_oia_modified()
128 {
129     union REGS regs;
130     struct SREGS sregs;
131 
132     if (api_issue_regs(PS_OR_OIA_MODIFIED, 0, 0, 0, 0, 0, (char *) 0,
133 				0, &regs, &sregs) == -1) {
134 	return -1;
135     } else {
136 	return 0;
137     }
138 }
139 #endif	/* defined(unix) */
140 
141 /*
142  * Session Information Services
143  */
144 
api_query_session_id(parms)145 api_query_session_id(parms)
146 QuerySessionIdParms *parms;
147 {
148     if (api_issue(0x09, QUERY_SESSION_ID, 0x80, 0x20, 0,
149 					gate_sessmgr, (char *)parms, sizeof *parms) == -1) {
150 	api_fcn_errno = 0;
151 	api_fcn_fcn_id = 0;
152 	return -1;
153     } else if (parms->rc == 0) {
154 	return 0;
155     } else {
156 	api_fcn_errno = parms->rc;
157 	api_fcn_fcn_id = parms->function_id;
158 	return -1;
159     }
160 }
161 
162 
api_query_session_parameters(parms)163 api_query_session_parameters(parms)
164 QuerySessionParametersParms *parms;
165 {
166     if (api_issue(0x09, QUERY_SESSION_PARAMETERS, 0x80, 0x20, 0,
167 			    gate_sessmgr, (char *)parms, sizeof *parms) == -1) {
168 	api_fcn_errno = 0;
169 	api_fcn_fcn_id = 0;
170 	return -1;
171     } else if (parms->rc == 0) {
172 	return 0;
173     } else {
174 	api_fcn_errno = parms->rc;
175 	api_fcn_fcn_id = parms->function_id;
176 	return -1;
177     }
178 }
179 
api_query_session_cursor(parms)180 api_query_session_cursor(parms)
181 QuerySessionCursorParms *parms;
182 {
183     if (api_issue(0x09, QUERY_SESSION_CURSOR, 0x80, 0x20, 0xff,
184 			gate_sessmgr, (char *)parms, sizeof *parms) == -1) {
185 	api_fcn_errno = 0;
186 	api_fcn_fcn_id = 0;
187 	return -1;
188     } else if (parms->rc == 0) {
189 	return 0;
190     } else {
191 	api_fcn_errno = parms->rc;
192 	api_fcn_fcn_id = parms->function_id;
193 	return -1;
194     }
195 }
196 
197 /*
198  * Keyboard Services
199  */
200 
api_connect_to_keyboard(parms)201 api_connect_to_keyboard(parms)
202 ConnectToKeyboardParms *parms;
203 {
204     if (api_issue(0x09, CONNECT_TO_KEYBOARD, 0x80, 0x20, 0,
205 			gate_keyboard, (char *)parms, sizeof *parms) == -1) {
206 	api_fcn_errno = 0;
207 	api_fcn_fcn_id = 0;
208 	return -1;
209     } else if (parms->rc == 0) {
210 	return 0;
211     } else {
212 	api_fcn_errno = parms->rc;
213 	api_fcn_fcn_id = parms->function_id;
214 	return -1;
215     }
216 }
217 
218 
api_disconnect_from_keyboard(parms)219 api_disconnect_from_keyboard(parms)
220 DisconnectFromKeyboardParms *parms;
221 {
222     if (api_issue(0x09, DISCONNECT_FROM_KEYBOARD, 0x80, 0x20, 0,
223 			gate_keyboard, (char *)parms, sizeof *parms) == -1) {
224 	api_fcn_errno = 0;
225 	api_fcn_fcn_id = 0;
226 	return -1;
227     } else if (parms->rc == 0) {
228 	return 0;
229     } else {
230 	api_fcn_errno = parms->rc;
231 	api_fcn_fcn_id = parms->function_id;
232 	return -1;
233     }
234 }
235 
236 
api_write_keystroke(parms)237 api_write_keystroke(parms)
238 WriteKeystrokeParms *parms;
239 {
240     if (api_issue(0x09, WRITE_KEYSTROKE, 0x80, 0x20, 0,
241 			gate_keyboard, (char *)parms, sizeof *parms) == -1) {
242 	api_fcn_errno = 0;
243 	api_fcn_fcn_id = 0;
244 	return -1;
245     } else if (parms->rc == 0) {
246 	return 0;
247     } else {
248 	api_fcn_errno = parms->rc;
249 	api_fcn_fcn_id = parms->function_id;
250 	return -1;
251     }
252 }
253 
254 
api_disable_input(parms)255 api_disable_input(parms)
256 DisableInputParms *parms;
257 {
258     if (api_issue(0x09, DISABLE_INPUT, 0x80, 0x20, 0,
259 			gate_keyboard, (char *)parms, sizeof *parms) == -1) {
260 	api_fcn_errno = 0;
261 	api_fcn_fcn_id = 0;
262 	return -1;
263     } else if (parms->rc == 0) {
264 	return 0;
265     } else {
266 	api_fcn_errno = parms->rc;
267 	api_fcn_fcn_id = parms->function_id;
268 	return -1;
269     }
270 }
271 
api_enable_input(parms)272 api_enable_input(parms)
273 EnableInputParms *parms;
274 {
275     if (api_issue(0x09, ENABLE_INPUT, 0x80, 0x20, 0,
276 			gate_keyboard, (char *)parms, sizeof *parms) == -1) {
277 	api_fcn_errno = 0;
278 	api_fcn_fcn_id = 0;
279 	return -1;
280     } else if (parms->rc == 0) {
281 	return 0;
282     } else {
283 	api_fcn_errno = parms->rc;
284 	api_fcn_fcn_id = parms->function_id;
285 	return -1;
286     }
287 }
288 
289 /*
290  * Copy Services
291  */
292 
api_copy_string(parms)293 api_copy_string(parms)
294 CopyStringParms *parms;
295 {
296     if (api_issue(0x09, COPY_STRING, 0x80, 0x20, 0xff,
297 			    gate_copy, (char *)parms, sizeof *parms) == -1) {
298 	api_fcn_errno = 0;
299 	api_fcn_fcn_id = 0;
300 	return -1;
301     } else if (parms->rc == 0) {
302 	return 0;
303     } else {
304 	api_fcn_errno = parms->rc;
305 	api_fcn_fcn_id = parms->function_id;
306 	return -1;
307     }
308 }
309 
310 /*
311  * Operator Information Area Services
312  */
313 
api_read_oia_group(parms)314 api_read_oia_group(parms)
315 ReadOiaGroupParms *parms;
316 {
317     if (api_issue(0x09, READ_OIA_GROUP, 0x80, 0x20, 0xff,
318 			    gate_oiam, (char *)parms, sizeof *parms) == -1) {
319 	api_fcn_errno = 0;
320 	api_fcn_fcn_id = 0;
321 	return -1;
322     } else if (parms->rc == 0) {
323 	return 0;
324     } else {
325 	api_fcn_errno = parms->rc;
326 	api_fcn_fcn_id = parms->function_id;
327 	return -1;
328     }
329 }
330 
331 /*
332  * The "we are done" routine.  This gets called last.
333  */
334 
api_finish()335 api_finish()
336 {
337 #if	defined(unix)
338     if (api_close_api() == -1) {
339 	return -1;
340     } else {
341 	return 0;
342     }
343 #endif	/* defined(unix) */
344 }
345 
346 
347 /*
348  * The initialization routine.  Be sure to call this first.
349  */
350 
api_init()351 api_init()
352 {
353 #if	defined(MSDOS)
354     union REGS regs;
355     struct SREGS sregs;
356 
357     regs.h.ah = 0x35;
358     regs.h.al = API_INTERRUPT_NUMBER;
359     intdosx(&regs, &regs, &sregs);
360 
361     if ((regs.x.bx == 0) && (sregs.es == 0)) {
362 	return 0;		/* Interrupt not being handled */
363     }
364 #endif	/* defined(MSDOS) */
365 #if	defined(unix)
366     if (api_open_api((char *)0) == -1) {
367 	return 0;
368     }
369 #endif	/* defined(unix) */
370 
371     gate_sessmgr = api_name_resolve("SESSMGR");
372     gate_keyboard = api_name_resolve("KEYBOARD");
373     gate_copy = api_name_resolve("COPY");
374     gate_oiam = api_name_resolve("OIAM");
375 
376     if ((gate_sessmgr == gate_keyboard) ||
377 	(gate_sessmgr == gate_copy) ||
378 	(gate_sessmgr == gate_oiam) ||
379 	(gate_keyboard == gate_copy) ||
380 	(gate_keyboard == gate_oiam) ||
381 	(gate_copy == gate_oiam)) {
382 	    return 0;		/* Interrupt doesn't seem correct */
383     }
384     return 1;
385 }
386