![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vtuser.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / vt|
Return to vtuser.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / vt |
1.1 root 1: /* vtuser.c - VT user routines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/vt/RCS/vtuser.c,v 7.2 90/07/09 14:52:10 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/vt/RCS/vtuser.c,v 7.2 90/07/09 14:52:10 mrose Exp $
9: *
10: *
11: * $Log: vtuser.c,v $
12: * Revision 7.2 90/07/09 14:52:10 mrose
13: * sync
14: *
15: * Revision 7.1 89/11/30 23:51:45 mrose
16: * pa2str
17: *
18: * Revision 7.0 89/11/23 22:32:00 mrose
19: * Release 6.0
20: *
21: */
22:
23: /*
24: * NOTICE
25: *
26: * Acquisition, use, and distribution of this module and related
27: * materials are subject to the restrictions of a license agreement.
28: * Consult the Preface in the User's Manual for the full terms of
29: * this agreement.
30: *
31: */
32:
33:
34: #include "vtpm.h"
35: #include "sector1.h"
36: #include "sector5.h"
37: #include <sys/ioctl.h>
38:
39: #undef PTYBUG /*When testing Break and demon not started from rc.local,
40: this turns off resetting local echo so ioctl to pty
41: will not cause demon to hang up.
42: */
43:
44: #undef PEPYPARM
45: #define PEPYPARM int *
46:
47:
48: extern char peerhost[];
49: extern struct PSAPaddr ts_bound;
50: static char *myservice = "terminal";
51:
52: static char *mycontext = "iso vt";
53: static char *mypci = "iso vt pci";
54:
55: static char ascii_go_repertoire[] = {0x1a,0x28,0x42,0x00}; /*ESC 2/8 4/2*/
56: /*should be followed by 3 "voids" whatever that is*/
57: static char full_ascii_repertoire[] = {0x1a,0x28,0x42,/*VOID*/0x1a,0x21,0x40,0x00};
58: /*Approximation to GO & CO ASCII sets*/
59:
60: extern char *isodeversion;
61: extern char *my_displayobj;
62: extern int G_Func_Units; /*Functional Units for this Association*/
63: extern int vcwa; /*Collision Winner (TRUE if owned by this peer)*/
64: extern int vsmd, vtok;
65: extern int transparent;
66: extern char na_image;
67: extern char ni_image;
68: extern VT_PROFILE vtp_profile;
69: extern int telnet_profile;
70: extern int do_break;
71: extern int debug;
72:
73: int default_rep_flag = 0;
74:
75: /*************************************************************************/
76: /* VASS_REQ - create an ASQ PDU and generate a VASSreq event to */
77: /* send it. */
78: /* */
79: /* PARAMETERS - */
80: /* */
81: /* CLASS - class of VTP service (only BASIC supported) */
82: /* */
83: /* ACC_RI - access rights */
84: /* */
85: /* PROFILE - designator of the VT profile to request */
86: /*************************************************************************/
87: /* ARGSUSED */
88: vass_req(class, acc_ri, profile)
89: int class, acc_ri;
90: VT_PROFILE *profile;
91: {
92: PE a_req;
93: ASQ_MSG ud;
94: char my_version, my_fu;
95: OID p_oid;
96: int i;
97:
98: my_version = 0x01;
99: if(do_break) my_fu = destBreak;
100: else my_fu = 0x00;
101:
102: bzero ((char *) &ud, sizeof ud);
103: ud.class = class;
104: ud.valid_imp = 0;
105: ud.coll_winner = ACHOICE;
106: ud.valid_coll = 1;
107: ud.version.bitstring = my_version;
108: ud.version.bitcount = 1;
109: if( !strcmp(profile->profile_name,"telnet") )
110: {
111: ud.valid_prof = 1;
112: ud.asq_profile.oid_true = 1;
113: if((p_oid = ode2oid(profile->profile_name)) == NULLOID)
114: adios(NULLCP,"%s: unknown profile", profile->profile_name);
115: ud.asq_profile.prof_oid = p_oid;
116:
117: ud.asq_profile.num_sp_param = 0;
118: ud.asq_profile.num_cds_objects = 0;
119: ud.asq_profile.num_css_objects = 0;
120: ud.asq_profile.num_dev_objects = 0;
121: ud.asq_profile.del_ctrl.bitcount = 0;
122:
123: ud.asq_profile.num_cds_objects = 1;
124: ud.asq_profile.cds_offer_list[0].obj_name = "D";
125: for(i=0; i<ud.asq_profile.num_cds_objects; i++)
126: {
127: ud.asq_profile.cds_offer_list[i].valid_x_dim = 0;
128: ud.asq_profile.cds_offer_list[i].valid_y_dim= 0;
129: ud.asq_profile.cds_offer_list[i].valid_z_dim = 0;
130: ud.asq_profile.cds_offer_list[i].erasure.bitcount = 0;
131: ud.asq_profile.cds_offer_list[i].valid_emp_list = 0;
132: ud.asq_profile.cds_offer_list[i].valid_fore_color = 0;
133: ud.asq_profile.cds_offer_list[i].valid_back_color = 0;
134: ud.asq_profile.cds_offer_list[i].access_right.bitcount = 0;
135: ud.asq_profile.cds_offer_list[i].valid_rep_list = 0;
136: }
137: if(!vtp_profile.arg_val.tel_arg_list.full_ascii)
138: {
139: ud.asq_profile.cds_offer_list[0].valid_rep_list = 1;
140: ud.asq_profile.cds_offer_list[0].rep_offer.valid_cap = 1;
141: ud.asq_profile.cds_offer_list[0].rep_offer.capability.type = 0;
142: ud.asq_profile.cds_offer_list[0].rep_offer.capability.value = 1;
143: ud.asq_profile.cds_offer_list[0].rep_offer.num_reps = 1;
144: ud.asq_profile.cds_offer_list[0].rep_offer.repertoire[0].rep_type = 2;
145: ud.asq_profile.cds_offer_list[0].rep_offer.repertoire[0].valid_font_cap = 0;
146: ud.asq_profile.cds_offer_list[0].rep_offer.repertoire[0].num_fonts = 0;
147: ud.asq_profile.cds_offer_list[0].rep_offer.repertoire[0].rep_assign =
148: ascii_go_repertoire;
149: }
150:
151: ud.asq_profile.cds_offer_list[0].valid_x_dim = 1;
152: ud.asq_profile.cds_offer_list[0].x_dim.bound_type = 0;
153: ud.asq_profile.cds_offer_list[0].x_dim.addressing.bitcount = 0;
154: ud.asq_profile.cds_offer_list[0].x_dim.absolute.bitcount = 0;
155: ud.asq_profile.cds_offer_list[0].x_dim.window_type = 2;
156: ud.asq_profile.cds_offer_list[0].x_dim.window.type = 0;
157: ud.asq_profile.cds_offer_list[0].x_dim.window.value =
158: vtp_profile.arg_val.tel_arg_list.x_window;
159:
160: vtok = 1;
161: vsmd = 0;
162: }
163: else if( !strcmp(profile->profile_name,"default") )
164: {
165: ud.valid_prof = 0;
166: ud.asq_profile.oid_true = 0;
167: ud.asq_profile.num_sp_param = 0;
168: ud.asq_profile.num_cds_objects = 0;
169: ud.asq_profile.num_css_objects = 0;
170: ud.asq_profile.num_dev_objects = 0;
171: vtok = 1;
172: vsmd = 0;
173: }
174: else
175: adios(NULLCP, "%s: unsupported profile", profile->profile_name);
176:
177: ud.func_units.bitstring = my_fu;
178: ud.func_units.bitcount = 5;
179:
180: if(build_ASQPDU_ASQpdu(&a_req,1,NULL,NULLCP,(PEPYPARM)&ud) == NOTOK)
181: adios(NULLCP, "ASQ build failure (%s)", PY_pepy);
182:
183: (void)do_event(VASSreq, a_req);
184: }
185:
186:
187: /******************************************************************************/
188: /* VASS_RESP - create an ASR PDU and generate a VASSRSP event to send it.*/
189: /* */
190: /* PARAMETERS - */
191: /* */
192: /* RESULT - SUCCESS or FAILURE */
193: /******************************************************************************/
194:
195: vass_resp(result)
196: int result;
197: {
198: PE a_resp;
199: char my_version, my_fu;
200: ASR_MSG ud;
201: int i;
202:
203: my_version = 0x01;
204: if(G_Func_Units & destBreak) do_break = 1;
205: else do_break = 0;
206: my_fu = G_Func_Units & destBreak; /*VT-Break is only Functional Unit
207: we will accept*/
208: bzero ((char *) &ud, sizeof ud);
209: ud.valid_reason = 0;
210: ud.result = result;
211: ud.valid_imp = 0;
212: ud.valid_coll = 1;
213: if(vcwa == TRUE) ud.coll_winner = ACCEPTOR;
214: else ud.coll_winner = INITIATOR;
215: ud.version.bitstring = my_version;
216: ud.version.bitcount = 1;
217: if( !strcmp(vtp_profile.profile_name,"telnet") )
218: {
219: ud.valid_arg_list = 1;
220: ud.arg_list.num_css_objects = 0;
221: ud.arg_list.num_dev_objects = 0;
222: ud.arg_list.num_cds_objects = 1;
223:
224: ud.arg_list.cds_val[0].obj_name = "D";
225: for(i=0; i<ud.arg_list.num_cds_objects; i++)
226: {
227: ud.arg_list.cds_val[i].dimensions = 0;
228: ud.arg_list.cds_val[i].valid_x_dim = 0;
229: ud.arg_list.cds_val[i].valid_y_dim = 0;
230: ud.arg_list.cds_val[i].valid_z_dim = 0;
231: ud.arg_list.cds_val[i].valid_erasure= 0;
232: ud.arg_list.cds_val[i].valid_emp_list = 0;
233: ud.arg_list.cds_val[i].valid_fore_color = 0;
234: ud.arg_list.cds_val[i].valid_back_color = 0;
235: ud.arg_list.cds_val[i].valid_access_right = 0;
236: ud.arg_list.cds_val[i].valid_rep_list = 0;
237: ud.arg_list.cds_val[i].rep_value.repertoire[0].valid_font_cap = 0;
238: ud.arg_list.cds_val[i].rep_value.repertoire[0].num_fonts = 0;
239: }
240: if( !default_rep_flag)
241: {
242: ud.arg_list.cds_val[0].valid_rep_list = 1;
243: ud.arg_list.cds_val[0].rep_value.valid_cap = 1;
244: ud.arg_list.cds_val[0].rep_value.capability = 1;
245: ud.arg_list.cds_val[0].rep_value.num_reps = 1;
246: ud.arg_list.cds_val[0].rep_value.repertoire[0].rep_type = 2;
247: ud.arg_list.cds_val[0].rep_value.repertoire[0].rep_assign =
248: vtp_profile.arg_val.tel_arg_list.full_ascii ?
249: full_ascii_repertoire : ascii_go_repertoire;
250: }
251: ud.arg_list.num_sp_param = 0;
252: ud.arg_list.cds_val[0].valid_x_dim = 1;
253: ud.arg_list.cds_val[0].x_dim.bound_type = 0;
254: ud.arg_list.cds_val[0].x_dim.valid_addr = 0;
255: ud.arg_list.cds_val[0].x_dim.valid_abs = 0;
256: ud.arg_list.cds_val[0].x_dim.window_type = 2;
257: ud.arg_list.cds_val[0].x_dim.window =
258: vtp_profile.arg_val.tel_arg_list.x_window;
259:
260: }
261: else if( !strcmp(vtp_profile.profile_name,"default") )
262: {
263: ud.valid_arg_list = 0;
264: ud.arg_list.num_sp_param = 0;
265: ud.arg_list.num_cds_objects = 0;
266: ud.arg_list.num_css_objects = 0;
267: ud.arg_list.num_dev_objects = 0;
268: }
269: else
270: adios (NULLCP, "invalid profile stored");
271: ud.func_units.bitstring = my_fu;
272: ud.func_units.bitcount = 5;
273:
274: if(build_ASRPDU_ASRpdu((PE *)&a_resp,1,NULL,NULLCP,(PEPYPARM)&ud) == NOTOK)
275: advise(LLOG_NOTICE,NULLCP, "ASR build failure (%s) -- continuing",
276: PY_pepy);
277: return(do_event(VASSrsp, a_resp));
278: }
279:
280:
281: /*************************************************************************/
282: /* "pe" will be to store NDQ contents that could not be mapped to */
283: /* the cbuf because of lack of buffer space. There is only one, */
284: /* because a new NDQ can be combined with "pe" rather than creating */
285: /* a queue of PEs */
286: /*************************************************************************/
287:
288: PE pe_buf = NULLPE;
289:
290:
291: /************************************************************************/
292: /* VRELREQ - Generate a VRELREQ to VT State Machine */
293: /* */
294: /* PARAMETERS - none */
295: /************************************************************************/
296:
297: vrelreq()
298: {
299: PE r_req;
300:
301: r_req = NULLPE;
302: (void)do_event(VRELreq,r_req);
303: }
304:
305: /*************************************************************************/
306: /* VRELRSP - create an RLR PDU and send it and generate a VRELRSP-S */
307: /* */
308: /* PARAMETERS - */
309: /* */
310: /* RESULT - success or failure */
311: /* */
312: /*************************************************************************/
313:
314: vrelrsp(result)
315: int result;
316: {
317:
318: int offset = 0;
319: PE r_rsp, r_result, r_coll;
320:
321: if ((r_rsp = pe_alloc(PE_CLASS_CONT, PE_FORM_CONS, RLR_PDU)) == NULLPE)
322: adios (NULLCP, "RLR build failure (out of memory)");
323:
324: if ((r_result = num2prim(result,PE_CLASS_CONT,0)) == NULLPE)
325: adios (NULLCP, "RLR build failure (out of memory)");
326:
327: if (seq_add(r_rsp,r_result,offset) == NOTOK)
328: adios (NULLCP, "RLR build failure (%s)", pe_error(r_rsp -> pe_errno));
329:
330: if(result == COLL_DET)
331: {
332: if((r_coll = num2prim(0,PE_CLASS_CONT,2)) == NULLPE)
333: adios (NULLCP, "RLR build failure (out of memory)");
334: if (seq_add(r_rsp,r_coll,++offset) == NOTOK)
335: adios (NULLCP, "RLR build failure (%s)",
336: pe_error(r_rsp -> pe_errno));
337: }
338: if (seq2prim(r_rsp) == NULLPE)
339: adios(NULLCP, "RLR encode error, seq2prim: (%s)", PY_pepy);
340: (void)do_event(VRELrsp,r_rsp);
341:
342: pe_free(r_coll);
343: pe_free(r_result);
344: pe_free(r_rsp);
345:
346: }
347:
348:
349: vrelcnf()
350: {
351: if (debug)
352: advise(LLOG_DEBUG, NULLCP, "Release Confirmed");
353: }
354:
355:
356: vrelind()
357: {
358: if (AcFINISHser(sd,pf,aci) == NOTOK)
359: acs_adios (&aci->aci_abort, "A-RELEASE.INDICATION");
360:
361: vrelrsp(SUCCESS);
362: return(OK);
363: }
364:
365:
366:
367: PE p_ondq = NULLPE; /* the current "ndq" being prepared for sending*/
368: PE p_ovtsdi = NULLPE; /* the current "vtsdi" */
369: int sdi_count = 0; /* count of "vtsdi"s in current NDQ*/
370: PE p_oobjupdt = NULLPE; /* the current "object_update" */
371: int obj_count = 0; /* count of "object_update"s in current "vtsdi"*/
372: int updt_count = 0; /* count of updates in the current "object update"*/
373: int cur_emode = NOT_ECHO_NOW; /* echo mode (ECHO_NOW or NOT_ECHO_NOW)*/
374:
375: /*************************************************************************/
376: /* VT_TEXT - Add a text update to the PE that represents */
377: /* an NDQ of buffered updates awaiting delivery. */
378: /* */
379: /* When we do a control object update, the current buffer of */
380: /* display object updates is terminated and a new one will be */
381: /* started next time a display object update is queued. */
382: /* (this is so we can synchronize control updates with */
383: /* display updates.) */
384: /* */
385: /* Likewise, whenever we queue a display object update, we */
386: /* terminate the current sequence of control object updates. */
387: /* */
388: /* Whenever we change echo mode (ECHO_NOW or NOT_ECHO_NOW) */
389: /* we have to start a new "vtsdi". */
390: /* This requires that we terminate the current buffers of */
391: /* display object and control object updates. */
392: /* */
393: /* PARAMETERS - */
394: /* */
395: /* STR - the character string to be added to the NDQ PDU. */
396: /* LEN - Number of characters in the string. */
397: /*************************************************************************/
398:
399: vt_text(str, len)
400: char *str;
401: int len;
402: {
403: TEXT_UPDATE ud;
404:
405: if (debug > 6)
406: {
407: int i;
408:
409: (void)ll_log(vt_log, LLOG_DEBUG, NULLCP, ("vt_text sending"));
410: (void)ll_printf (vt_log, "<<");
411: for(i=0; i<len; i++)
412: (void)ll_printf (vt_log, "%02x ", *(str+i));
413: (void)ll_printf (vt_log, ">>\n");
414: (void)ll_sync (vt_log);
415: }
416:
417: bzero ((char *) &ud, sizeof ud);
418: ud.echo_sw = cur_emode;
419: ud.type_sw = 0; /*Display object*/
420: ud.updates.do_list.do_name = my_displayobj;
421: ud.updates.do_list.do_type = DO_TEXT; /*Text*/
422: ud.updates.do_list.do_cmd.text_ud.text_ptr = str;
423: ud.updates.do_list.do_cmd.text_ud.text_count = len;
424: send_queue(ud);
425:
426: return(OK);
427: }
428:
429:
430: send_queue(ud) /*Build NDQ with update supplied in ud structure*/
431: TEXT_UPDATE ud;
432: {
433:
434: PE vtsdip;
435:
436: if(p_ondq == NULLPE) /*Nothing waiting to be sent*/
437: {
438: if(build_NDQPDU_NDQpdu(&p_ondq,1,NULL,NULLCP,(PEPYPARM)&ud) == NOTOK)
439: adios(NULLCP,"NDQ build failure (%s)", PY_pepy);
440: p_ondq->pe_context = 1;
441: }
442: else
443: {
444: if(build_NDQPDU_VTsdi(&vtsdip,1,NULL,NULLCP,(int *)&ud) == NOTOK)
445: adios(NULLCP,"VTsdi build failure (%s)", PY_pepy);
446: vtsdip->pe_context = 1;
447: if(seq_add(p_ondq,vtsdip,-1) == NOTOK)
448: adios(NULLCP,"NDQ build failure (%s)",
449: pe_error(p_ondq->pe_errno));
450: }
451: }
452:
453:
454:
455: /* SETEMODE - set echo mode
456:
457: PARAMETERS -
458:
459: MODE - ECHO_NOW or NOT_ECHO_NOW
460: */
461:
462: setemode(mode)
463: int mode;
464: {
465: if (mode != ECHO_NOW && mode != NOT_ECHO_NOW)
466: return(NOTOK);
467: if (cur_emode != mode) {
468: p_ovtsdi = NULLPE;
469: sdi_count = 0;
470: p_oobjupdt = NULLPE;
471: obj_count = 0;
472: cur_emode = mode;
473: }
474: return(OK);
475: }
476:
477:
478: /* this data structure will buffer character output
479: that is ready to be read by the application or terminal.
480: */
481:
482: #define CBUFSIZE 10240
483:
484: struct char_buffer {
485: int max_len, queued;
486: unsigned char *head, *tail;
487: unsigned char buf[CBUFSIZE];
488: };
489:
490: struct char_buffer cbuf = { CBUFSIZE, 0 };
491:
492: /************************************************************************/
493: /* GETCH - get a character from the buffer waiting to */
494: /* be read by the application */
495: /* */
496: /* RETURNS - the character, NOTOK if no data, or an error code (<0)*/
497: /************************************************************************/
498:
499:
500: int
501: getch()
502: {
503: int c;
504:
505: if (data_pending() == FALSE) {
506: if (!connected)
507: return(E_EOF);
508: else
509: return(WOULDBLOCK);
510: }
511: c = *cbuf.head;
512: if (++cbuf.head >= cbuf.buf + CBUFSIZE)
513: cbuf.head = cbuf.buf;
514: cbuf.queued--;
515: if (debug > 1)
516: advise(LLOG_DEBUG, NULLCP, "normal return from getch, c is %c,queued is %d", c,cbuf.queued);
517: return(c);
518: }
519:
520: /* at some point we need to use the async. interface to the network
521: so that at any time when data becomes available, we trap to a vtpm
522: function to handle it. This function will examine the type of
523: network event and act accordingly. Each time the function is invoked
524: it should completely process the data received and free the PSAPdata
525: structure for use in processing the next network event.
526: If it is an expedited
527: data request, for instance, it is treated differently from a P-DATA.
528: If an NDQ is
529: received all the data should be read from the PSAPread structure and
530: mapped to the cbuf.
531: If the cbuf fills up in the process of doing this, the PE containing the
532: remaining updates should be put in a queue of pending PEs.
533: */
534:
535:
536: /* This macro does the same thing as PXFREE except it does not free
537: the PEs in the px_info array. We will use this instead of PXFREE
538: because we need to free the data PEs one at a time as they are
539: processed.
540: Any unprocessed (pending) PEs are maintained in a queue
541: by the VTPM. If some of the PEs received from a PDATArequest are in
542: this queue a call to PXFREE would free the
543: data and leave dangling references in the queue.
544:
545: Note that the vtuser may have at most one unprocessed or partially
546: processed PE. The VTPM can potentially have any number of unprocessed
547: PEs in its queue.
548: */
549:
550: #define PFIN(px) \
551: { \
552: register int PXI; \
553: \
554: if ((px) -> px_realinfo) \
555: pe_free ((px) -> px_realinfo), (px) -> px_realinfo = NULLPE; \
556: else { \
557: for (PXI = (px) -> px_ninfo - 1; PXI >= 0; PXI--) \
558: if ((px) -> px_info[PXI]) \
559: (px) -> px_info[PXI] = NULLPE; \
560: (px) -> px_ninfo = 0; \
561: } \
562: }
563:
564:
565: int
566: data_pending()
567: {
568: int result;
569: PE *peptr = NULLPEP;
570:
571: if (queued())
572: return(TRUE);
573:
574: /* something was already in the cbuf
575: */
576:
577: if (pe_buf != NULLPE) {
578:
579: /* there seems to be something to map
580: */
581:
582: map(pe_buf);
583: if (queued())
584: return(TRUE);
585: }
586: result = get_event(sd, peptr);
587:
588: /* if there was no network event
589: */
590: if (result == NOTOK)
591: return(FALSE);
592:
593: /* get_event may have resulted in data being read and mapped to the
594: cbuf
595: */
596:
597: if (queued())
598: return(TRUE);
599:
600: /* if there is no data left and get_event resulted in the association
601: being released
602: */
603: if (!connected) {
604: (void)putch(EOF);
605: return(TRUE);
606: }
607:
608: /* there's nothing to read right now, but we're still connected
609: */
610: return(FALSE);
611: }
612:
613:
614: int
615: queued()
616: {
617: return(cbuf.queued);
618: }
619:
620:
621: /*************************************************************************/
622: /* PUTCH - put a character on the buffer to be read by the */
623: /* application */
624: /* */
625: /* RETURNS - OK on success, NOTOK otherwise */
626: /*************************************************************************/
627: int
628: putch(c)
629: char c;
630: {
631: if (debug > 1) {
632: advise(LLOG_DEBUG, NULLCP, "in putch, queued is %d, c is %c", cbuf.queued, c);
633: advise(LLOG_DEBUG, NULLCP, "cbuf.buf is %d, cbuf.head is %d, cbuf.tail is %d", (int)cbuf.buf, (int)cbuf.head, (int)cbuf.tail);
634: advise(LLOG_DEBUG, NULLCP, "cbuf.max_len is %d", (int)cbuf.max_len);
635: }
636: if (cbuf.queued >= CBUFSIZE) {
637: if (debug > 1)
638: advise(LLOG_DEBUG, NULLCP, "***********************\nputch: queued exceeds CBUFSIZE ***************");
639: return(NOTOK);
640: }
641: if (cbuf.queued <= 0) {
642: cbuf.tail = cbuf.head = cbuf.buf;
643: cbuf.queued = 0;
644: if (debug)
645: advise(LLOG_DEBUG, NULLCP, "tail and head set to %d", (int)cbuf.buf);
646: }
647: *(cbuf.tail) = c;
648: if (++(cbuf.tail) > cbuf.buf + CBUFSIZE)
649: cbuf.tail = cbuf.buf;
650: cbuf.queued++;
651: return(OK);
652: }
653:
654:
655: /*************************************************************************/
656: /* VTSEND - send the updates that have been put into the PE */
657: /* called "p_ondq". */
658: /*************************************************************************/
659:
660: vtsend()
661: {
662: if(p_ondq == NULLPE) return;
663: vtdata(p_ondq);
664: pe_free(p_ondq);
665: p_ondq = NULLPE;
666: p_ovtsdi = NULLPE;
667: sdi_count = 0;
668: p_oobjupdt = NULLPE;
669: obj_count = 0;
670: updt_count = 0;
671: }
672:
673: /************************************************************************/
674: /* VTDATA - generate a VDATREQ event to send an NDQ */
675: /* */
676: /* PARAMETERS */
677: /* */
678: /* NDQ - a presentation element containing an NDQ. */
679: /************************************************************************/
680:
681: vtdata(ndq)
682: PE ndq;
683: {
684: if (ndq == NULLPE)
685: return;
686:
687: (void)do_event(VDATreq_n,ndq);
688: }
689:
690:
691: /************************************************************************/
692: /* MKDELIVER - create a DLQ. Requests for an acknowlegement are not */
693: /* allowed at this time. */
694: /************************************************************************/
695:
696: PE
697: mkdeliver(ack)
698: int ack;
699: {
700: PE p_dlq;
701:
702: if (ack != FALSE)
703: adios(NULLCP, "DLQ PDUs can only be sent without an ACK request");
704: if ((p_dlq = bool2prim(ack)) == NULLPE)
705: adios (NULLCP, "DLQ build failure (out of memory)");
706: p_dlq->pe_id = DLQ_PDU;
707: p_dlq->pe_class = PE_CLASS_CONT;
708: p_dlq->pe_context = 1;
709: return(p_dlq);
710: }
711:
712: /**************************************************************************/
713: /* VDELREQ - create a deliver request PE and generate a VDELreq */
714: /* event to send it. */
715: /**************************************************************************/
716:
717: vdelreq(ack)
718: int ack;
719: {
720: PE p_dlq;
721:
722: if (ack)
723: adios(NULLCP,
724: "ACK requests in deliver PDUs not supported at this time");
725: p_dlq = mkdeliver(FALSE);
726:
727: (void)do_event(VDELreq,p_dlq);
728: }
729:
730:
731: /**************************************************************************/
732: /* VDELIND - we queue up data to go to the terminal when the NDQ */
733: /* is received, so there's really nothing */
734: /* to do when we get a VDELIND */
735: /* */
736: /* PARAMETERS: */
737: /* ACK - TRUE or FALSE according to whether */
738: /* acknowledgement is requested or not. */
739: /**************************************************************************/
740:
741: vdelind(del_pe,ack)
742: PE del_pe;
743: int ack;
744: {
745: if (ack) {
746: if (debug)
747: advise(LLOG_DEBUG, NULLCP, "vdelind with ack requested not implemented!");
748: }
749: pe_free(del_pe);
750: }
751:
752: /************************************************************************/
753: /* VDATIND - On receiving a data indication we will go ahead and */
754: /* map the contents onto the character buffer to go to the terminal */
755: /* */
756: /* PARAMETERS - "type" can be SEQUENCED or NONSEQUENCED */
757: /* only SEQUENCED is implemented now */
758: /************************************************************************/
759:
760: vdatind(type, pe)
761: int type;
762: PE pe;
763: {
764: if (type != SEQUENCED)
765: adios(NULLCP, "unimplemented NDQ type %d", type);
766: map(pe);
767: }
768:
769: vhdatind(pe)
770: PE pe;
771: {
772:
773: advise(LLOG_NOTICE,NULLCP,"vhdatind(): HDQ's not supported\n");
774: pe_free(pe);
775: }
776:
777: vudatind(pe)
778: PE pe;
779: {
780:
781: TEXT_UPDATE ud;
782:
783: if(unbuild_UDQPDU_UDQpdu(pe,1,NULLIP,NULLVP,(PEPYPARM) &ud) == NOTOK)
784: {
785: advise(LLOG_NOTICE,NULLCP,"UDQ parse failure\n");
786: }
787: else
788: {
789: control_ud((CO_UPDATE *) &(ud.updates.co_list) );
790: free( (char *)ud.updates.co_list.co_name);
791: pe_free(pe);
792: }
793: }
794:
795: /*****************************************************************************/
796: /* Connect_request: */
797: /* */
798: /* Sends an ASQ, waits for a confirm. */
799: /* */
800: /* Returns the file descriptor that corresponds to the network socket */
801: /* for the association, or NOTOK if the association failed. */
802: /* */
803: /* The assumption is made that the acs_sd data element of the AcSAPstart*/
804: /* structure is same as the file descriptor for the network socket used */
805: /* by the association. */
806: /*****************************************************************************/
807:
808: con_req()
809: {
810: int uevent;
811:
812: if (debug)
813: advise(LLOG_DEBUG, NULLCP, "in con_req");
814:
815: vass_req(1,WACI_WACA,&vtp_profile);
816: if (acc->acc_result != ACS_ACCEPT) {
817: advise(LLOG_NOTICE,NULLCP, "association rejected: [%s]",
818: AcErrString (acc -> acc_result));
819: state = S1_01;
820: return NOTOK;
821: }
822:
823: if (debug) {
824: advise(LLOG_DEBUG, NULLCP, "got associate confirm event, sd is %d", acc->acc_sd);
825: advise(LLOG_DEBUG, NULLCP, "acc_ninfo is %d", acc->acc_ninfo);
826: advise(LLOG_DEBUG, NULLCP, "pe_id is %d", acc->acc_info[0]->pe_id);
827: advise(LLOG_DEBUG, NULLCP, "pe_class is %d", acc->acc_info[0]->pe_class);
828: advise(LLOG_DEBUG, NULLCP, "pe_form is %d", acc->acc_info[0]->pe_form);
829: }
830:
831: if (acc->acc_ninfo < 1)
832: adios(NULLCP, "no ASQ PDU sent with the associate confirm");
833:
834: sd = acc->acc_sd;
835: uevent = do_event(ASR,acc->acc_info[0]);
836:
837: if (debug)
838: advise(LLOG_DEBUG, NULLCP, "got user event %d", uevent);
839:
840: if(uevent == SUCCESS) return(sd);
841: else return(-1);
842: }
843:
844:
845:
846: read_asq(pe) /*Unwrap ASQ PDU. Use information it contains to fill in
847: some global values (profile_id,G_Func_Units,vcwa).
848: Return 0 if ASQ is improperly formatted or missing a
849: required field. For now, only the more obvious fields are
850: checked and only transparent and telnet profiles
851: are handled. Return PROFILE_NG if profile is not
852: supported. Return 1 if ASQ is valid.
853: */
854: PE pe;
855: {
856:
857: int i,n, D;
858: ASQ_MSG ud;
859:
860: bzero ((char *) &ud, sizeof ud);
861: if(unbuild_ASQPDU_ASQpdu(pe,1,NULLIP,NULLVP,(PEPYPARM)&ud) == NOTOK)
862: {
863: advise(LLOG_NOTICE,NULLCP, "ASQ parse failure (%s)", PY_pepy);
864: return(0);
865: }
866:
867:
868: if(!ud.class)
869: {
870: advise(LLOG_DEBUG, NULLCP, "ASQ without Class");
871: return(0);
872: }
873: if(ud.valid_coll)
874: {
875: if(ud.coll_winner == INITIATOR) vcwa = FALSE;
876: else vcwa = TRUE;
877: }
878: G_Func_Units = ud.func_units.bitstring & 0x1f;
879: if( (!ud.valid_prof) || (!ud.asq_profile.oid_true) ||
880: !oid_cmp(ud.asq_profile.prof_oid,ode2oid("default")) )
881: {
882: vtp_profile.profile_name = "default";
883: my_displayobj = "DISPLAY-OBJECT-1";
884: telnet_profile = 0;
885: return(1);
886: }
887: if( !oid_cmp(ud.asq_profile.prof_oid,ode2oid("telnet")) )
888: {
889: vtp_profile.profile_name = "telnet";
890: vtp_profile.arg_val.tel_arg_list.full_ascii = 0xff;
891: vtp_profile.arg_val.tel_arg_list.x_window = -1;
892:
893: D = -1;
894: for(n=0; n<ud.asq_profile.num_cds_objects; n++)
895: {
896: if( *ud.asq_profile.cds_offer_list[n].obj_name == 'D')
897: {
898: D = n;
899: break;
900: }
901: }
902: if(D < 0)
903: {
904: advise(LLOG_DEBUG, NULLCP, "ASQ with no D Display Object");
905: return(0);
906: }
907:
908: if( !ud.asq_profile.cds_offer_list[D].valid_rep_list )
909: {
910: vtp_profile.arg_val.tel_arg_list.full_ascii = 1;
911: default_rep_flag = 1;
912: }
913: else /*Repertoire specified*/
914: {
915: if(ud.asq_profile.cds_offer_list[D].rep_offer.num_reps
916: > MAXREPS)
917: {
918: advise(LLOG_DEBUG, NULLCP, "ASQ with too many repertoires");
919: return(0);
920: }
921: for(i=0; i< ud.asq_profile.cds_offer_list[D].rep_offer.num_reps;
922: i++)
923: {
924: if(ud.asq_profile.cds_offer_list[D].rep_offer.repertoire[i].rep_type != 2)
925: continue;
926: if(!strncmp(ud.asq_profile.cds_offer_list[D].rep_offer.repertoire[i].rep_assign,
927: ascii_go_repertoire,sizeof(ascii_go_repertoire)))
928: {
929: vtp_profile.arg_val.tel_arg_list.full_ascii = 0;
930: advise(LLOG_DEBUG, NULLCP, "Using ASCII GO Repertoire.");
931: break;
932: }
933: if(!strncmp(ud.asq_profile.cds_offer_list[D].rep_offer.repertoire[i].rep_assign,
934: full_ascii_repertoire,sizeof(full_ascii_repertoire)))
935: {
936: vtp_profile.arg_val.tel_arg_list.full_ascii = 1;
937: break;
938: }
939: }
940: if(vtp_profile.arg_val.tel_arg_list.full_ascii < 0) return(0);
941: }
942: transparent = 0;
943:
944: if(ud.asq_profile.cds_offer_list[D].valid_x_dim == 0)
945: {
946: advise(LLOG_DEBUG, NULLCP, "ASQ with no X-Window");
947: return(0);
948: }
949: if(ud.asq_profile.cds_offer_list[D].x_dim.window_type != 2)
950: /*If not integer type window field*/
951: {
952: advise(LLOG_DEBUG, NULLCP, "ASQ with invalid X-Window");
953: return(0);
954: }
955: if(ud.asq_profile.cds_offer_list[D].x_dim.window.type
956: == 0) /*If single value*/
957: {
958: vtp_profile.arg_val.tel_arg_list.x_window =
959: ud.asq_profile.cds_offer_list[D].x_dim.window.value;
960: }
961: else if(ud.asq_profile.cds_offer_list[D].x_dim.window.type == 1)
962: /*If range*/
963: {
964: if((ud.asq_profile.cds_offer_list[D].x_dim.window.min_val
965: <= 80) &&
966: (ud.asq_profile.cds_offer_list[D].x_dim.window.max_val
967: >= 80))
968: {
969: vtp_profile.arg_val.tel_arg_list.x_window = 80;
970: }
971: else
972: {
973: vtp_profile.arg_val.tel_arg_list.x_window =
974: ud.asq_profile.cds_offer_list[D].x_dim.window.min_val;
975: }
976:
977: }
978: if(vtp_profile.arg_val.tel_arg_list.x_window < 0)
979: {
980: advise(LLOG_DEBUG, NULLCP, "ASQ without x-window");
981: return(0);
982: }
983: if(vtp_profile.arg_val.tel_arg_list.full_ascii < 0)
984: {
985: advise(LLOG_DEBUG, NULLCP, "Using Default for ASCII repertoire (Full ASCII)");
986: vtp_profile.arg_val.tel_arg_list.full_ascii = 1;
987: }
988: }
989: else
990: {
991: advise(LLOG_DEBUG, NULLCP, "Unknown Profile Requested");
992: return(PROFILE_NG);
993: }
994:
995: return(1);
996: }
997:
998: vasscnf(pe) /*Handle ASR received from Acceptor*/
999: PE pe;
1000: {
1001:
1002: ASR_MSG udr;
1003: int rep, n;
1004: int window_flag = 0;
1005: int rep_flag = 0;
1006:
1007: bzero ((char *) &udr, sizeof udr);
1008: if(unbuild_ASRPDU_ASRpdu(pe,1,NULLIP,NULLVP,(PEPYPARM)&udr) == NOTOK)
1009: {
1010: advise (LLOG_NOTICE,NULLCP, "ASR parse failure (%s)", PY_pepy);
1011: return(NOTOK);
1012: }
1013: if(udr.result != SUCCESS)
1014: {
1015: advise(LLOG_NOTICE,NULLCP, "Association rejected by Peer VT");
1016: return(NOTOK);
1017: }
1018: if(udr.valid_coll) vcwa = udr.coll_winner;
1019: else
1020: advise(LLOG_DEBUG, NULLCP, "Received ASR with no collision winner");
1021: if(!strcmp(vtp_profile.profile_name,"transparent"))
1022: {
1023: if(!udr.arg_list.cds_val[0].valid_rep_list) /*No repertoires*/
1024: {
1025: if(strcmp(vtp_profile.arg_val.tr_arg_list.cur_rep,
1026: TRANSPARENT))
1027: /*If don't want default for this profile*/
1028: {
1029: advise(LLOG_DEBUG, NULLCP, "ASR with no repertoire");
1030: return(NOTOK);
1031: }
1032: }
1033: if(strcmp(vtp_profile.arg_val.tr_arg_list.cur_rep,
1034: udr.arg_list.cds_val[0].rep_value.repertoire[0].rep_assign))
1035: /*Only support 1 repertoire in transparent*/
1036: {
1037: advise(LLOG_DEBUG, NULLCP, "ASR--Invalid repertoire for transparent profile");
1038: return(NOTOK);
1039: }
1040: }
1041: else if(!strcmp(vtp_profile.profile_name,"telnet"))
1042: {
1043: if(udr.arg_list.num_sp_param < 1)
1044: {
1045: advise(LLOG_DEBUG, NULLCP, "ASR without enough Special Arguments");
1046: return(0);
1047: }
1048: for(n=0; n<udr.arg_list.num_sp_param; n++)
1049: {
1050: if(udr.arg_list.sp_val[n].param_num == 1)
1051: {
1052: if(udr.arg_list.sp_val[n].param_type == 1)
1053: /*If integer type*/
1054: {
1055: if(vtp_profile.arg_val.tel_arg_list.x_window !=
1056: udr.arg_list.sp_val[n].args.int_arg)
1057: {
1058: advise(LLOG_DEBUG, NULLCP, "ASR with invalid X-Window");
1059: return(NOTOK);
1060: }
1061: else ++window_flag;
1062: }
1063: }
1064: else if(udr.arg_list.sp_val[n].param_num == 2)
1065: /*ASCII Repertoire type*/
1066: {
1067: if(udr.arg_list.sp_val[n].param_type == 0)
1068: /*If Boolean*/
1069: {
1070: if(vtp_profile.arg_val.tel_arg_list.full_ascii)
1071: rep = 1;
1072: else rep = 0;
1073: if(udr.arg_list.sp_val[n].args.bool_arg != rep)
1074: {
1075: advise(LLOG_DEBUG, NULLCP, "ASR with invalid Repertoire");
1076: return(NOTOK);
1077: }
1078: ++rep_flag;
1079: }
1080: }
1081: } /*End for loop*/
1082: if(!window_flag)
1083: {
1084: advise(LLOG_DEBUG, NULLCP, "ASR without x-window");
1085: return(NOTOK);
1086: }
1087: if(!rep_flag)
1088: {
1089: advise(LLOG_DEBUG, NULLCP, "ASR with no repertoire");
1090: return(NOTOK);
1091: }
1092: }
1093: return(OK);
1094: }
1095:
1096:
1097: asq(data)
1098: PE data;
1099: {
1100: int srequirements;
1101: struct PSAPctxlist vclist;
1102: OID vt_asn;
1103: struct QOStype qos;
1104:
1105: qos.qos_reliability = HIGH_QUALITY;
1106: qos.qos_sversion = 2;
1107:
1108: if (debug)
1109: advise(LLOG_DEBUG, NULLCP, "in asq");
1110:
1111: acc = &accs;
1112: acr = &acrs;
1113: aci = &acis;
1114:
1115: /* I'm relying on "peerhost" being an external char * that
1116: has the name of the host we want to connect to
1117: */
1118: if ((aei = _str2aei (peerhost, myservice, "iso vt", 1)) == NULLAEI)
1119: adios (NULLCP, "unable to resolve service: %s", PY_pepy);
1120: if ((pa = aei2addr (aei)) == NULLPA)
1121: adios (NULLCP, "address translation failed");
1122:
1123: if ((ctx = ode2oid (mycontext)) == NULLOID)
1124: adios (NULLCP, "%s: unknown object descriptor", mycontext);
1125: if ((ctx = oid_cpy (ctx)) == NULLOID)
1126: adios (NULLCP, "out of memory");
1127: if ((pci = ode2oid (mypci)) == NULLOID)
1128: adios (NULLCP, "%s: unknown object descriptor", mypci);
1129: if ((pci = oid_cpy (pci)) == NULLOID)
1130: adios (NULLCP, "out of memory");
1131:
1132: if ((sf = addr2ref (PLocalHostName ())) == NULL) {
1133: sf = &sfs;
1134: (void) bzero ((char *) sf, sizeof *sf);
1135: }
1136:
1137: PLOG (vt_log, print_VT_PDUs, data, NULLCP, 0);
1138: aca = &aci->aci_abort;
1139: srequirements = SR_DUPLEX | SR_RESYNC | SR_TYPEDATA;
1140: srequirements &= ~SR_RLS_EXISTS;
1141:
1142: if((vt_asn = oid_cpy (pci)) == NULLOID)
1143: adios (NULLCP, "out of memory");
1144: vclist.pc_nctx = 1;
1145: vclist.pc_ctx[0].pc_id = 1;
1146: vclist.pc_ctx[0].pc_asn = vt_asn;
1147: vclist.pc_ctx[0].pc_atn = NULLOID;
1148: data -> pe_context = 1;
1149:
1150: if (AcAssocRequest (ctx, NULLAEI, aei, NULLPA, pa,
1151: &vclist, pci,
1152: 0, srequirements, SERIAL_MIN, 0, sf, &data, 1, &qos,
1153: acc, aci) == NOTOK)
1154: acs_adios (aca, "A-ASSOCIATE.REQUEST");
1155:
1156: if (acc -> acc_result != ACS_ACCEPT)
1157: return;
1158:
1159: sd = acc->acc_sd;
1160: ts_bound = acc -> acc_connect.pc_responding; /* struct copy */
1161: #ifdef DEBUG
1162: {
1163: register int i;
1164: register struct PSAPconnect *pc = &acc -> acc_connect;
1165: register struct PSAPctxlist *pl = &pc -> pc_ctxlist;
1166:
1167: advise (LLOG_DEBUG, NULLCP, "context: %s",
1168: oid2ode (acc -> acc_context));
1169:
1170: advise (LLOG_DEBUG, NULLCP,
1171: "responding AE title: %s, responding PSAP address: %s",
1172: sprintaei (&acc -> acc_respondtitle),
1173: paddr2str (&pc -> pc_responding, NULLNA));
1174:
1175: for (i = 0; i < pl -> pc_nctx; i++)
1176: advise (LLOG_DEBUG, NULLCP, "ctx %d: 0x%x 0x%x %d",
1177: pl -> pc_ctx[i].pc_id, pl -> pc_ctx[i].pc_asn,
1178: pl -> pc_ctx[i].pc_atn, pl -> pc_ctx[i].pc_result);
1179: advise (LLOG_DEBUG, NULLCP, "default %d", pc -> pc_defctxresult);
1180: advise (LLOG_DEBUG, NULLCP, "p/s requirements 0x%x/0x%x",
1181: pc -> pc_prequirements, pc -> pc_srequirements);
1182: }
1183: #endif
1184: }
1185:
1186: vt_disconnect()
1187: {
1188: if (AcRelRequest (sd, ACF_NORMAL, NULLPEP, 0, NOTOK, acr, aci)
1189: == NOTOK)
1190: acs_adios (aca, "A-RELEASE.REQUEST");
1191: if(acr->acr_affirmative) {
1192: connected = FALSE;
1193: (void) do_event (RLR, acr -> acr_info[0]);
1194: }
1195:
1196: ACRFREE (acr);
1197:
1198: }
1199:
1200:
1201:
1202: #define ASYNC 0
1203:
1204: #define RMASK \
1205: "\020\01HALFDUPLEX\02DUPLEX\03EXPEDITED\04MINORSYNC\05MAJORSYNC\06RESYNC\
1206: \07ACTIVITY\010NEGOTIATED\011CAPABILITY\012EXCEPTIONS\013TYPEDATA"
1207:
1208: #define PMASK \
1209: "\020\01MANAGEMENT\02RESTORATION"
1210:
1211: /* DATA */
1212:
1213: long time ();
1214: char *ctime ();
1215: int result;
1216:
1217: /*PE pe;*/
1218:
1219: /*************************************************************************/
1220: /* ASS_IND */
1221: /*************************************************************************/
1222:
1223: ass_ind (argc, argv)
1224: int argc;
1225: char **argv;
1226: {
1227: register struct PSAPctxlist *pl;
1228:
1229:
1230: aca = &aci->aci_abort;
1231: ps = &acs->acs_start;
1232: pl = &ps -> ps_ctxlist;
1233:
1234: if (AcInit (argc, argv, acs, aci) == NOTOK)
1235: acs_adios (aca, "initialization fails");
1236:
1237: advise (LLOG_NOTICE,NULLCP,
1238: "A-ASSOCIATE.INDICATION: <%d, %s, %s, %s, %d>",
1239: acs -> acs_sd, oid2ode (acs -> acs_context),
1240: sprintaei (&acs -> acs_callingtitle),
1241: sprintaei (&acs -> acs_calledtitle), acs -> acs_ninfo);
1242:
1243: advise (LLOG_NOTICE,NULLCP,
1244: "PSAP: <%d, %s, %s, %d, %s,",
1245: ps -> ps_sd,
1246: paddr2str (&ps -> ps_calling, NULLNA),
1247: paddr2str (&ps -> ps_called, NULLNA),
1248: pl -> pc_nctx, sprintb (ps -> ps_prequirements, PMASK));
1249: advise (LLOG_NOTICE,NULLCP,
1250: " %s, %d, %d>",
1251: sprintb (ps -> ps_srequirements, RMASK), ps -> ps_isn,
1252: ps -> ps_ssdusize);
1253:
1254: (void) strcpy (peerhost,
1255: na2str (ps -> ps_calling.pa_addr.sa_addr.ta_addrs));
1256:
1257: sd = acs->acs_sd;
1258:
1259: /* ACSFREE(acs);
1260: */
1261:
1262: PLOG (vt_log, print_VT_PDUs, acs -> acs_info[0], NULLCP, 1);
1263:
1264: return( do_event(ASQ,acs->acs_info[0]) );
1265: }
1266:
1267:
1268:
1269: /* ARGSUSED */
1270:
1271: vassind(pe)
1272: PE pe;
1273: {
1274: return(vass_resp(SUCCESS));
1275: }
1276:
1277:
1278: vbrkreq()
1279: {
1280: PE brk_pe;
1281: BRcnt brk;
1282:
1283: bzero ((char *) &brk, sizeof brk);
1284: brk.BKQcont.token_val = NOBKTOK;
1285: brk.BKQcont.ExplPtr.xval = 0;
1286: brk.BKQcont.ExplPtr.yval = 0;
1287: brk.BKQcont.ExplPtr.zval = NULLCOORD;
1288: if ((build_VT_BKQ__pdu(&brk_pe,1,NULL,NULLCP,(PEPYPARM)&brk)) == NOTOK)
1289: adios (NULLCP, "BKQ build failed (%s)", PY_pepy);
1290: brk_pe->pe_context = 1;
1291: flushbufs(); /* flush local buffers */
1292: (void)do_event(VBRKreq,brk_pe);
1293: }
1294:
1295: vbrkrsp()
1296: {
1297: PE brk_pe;
1298: BRcnt brk;
1299:
1300: bzero ((char *) &brk, sizeof brk);
1301: brk.BKRcont.token_val = NOBKTOK;
1302: brk.BKRcont.ExplPtr.xval = 0;
1303: brk.BKRcont.ExplPtr.yval = 0;
1304: brk.BKRcont.ExplPtr.zval = NULLCOORD;
1305: if ((build_VT_BKR__pdu(&brk_pe,1,NULL,NULLCP,(int *)&brk)) == NOTOK)
1306: adios (NULLCP, "BKR build failed (%s)", PY_pepy);
1307: brk_pe->pe_context = 1;
1308: (void)do_event(VBRKrsp,brk_pe);
1309: }
1310:
1311:
1312: /* ARGSUSED */
1313: vbrkind(brk_pe)
1314: PE brk_pe;
1315: {
1316: flushbufs();
1317: vtok = 1; /* got tokens from peer */
1318: advise(LLOG_DEBUG, NULLCP, "Received VT-BREAK");
1319: vt_clr_obj(); /*Initialize Control Objects*/
1320: vbrkrsp();
1321: if(telnet_profile)
1322: {
1323: #ifndef PTYBUG
1324: #ifdef BSD44
1325: ptyecho(0);
1326: #else
1327: setmode(0,ECHO); /*Return to Local Echo. This call is not
1328: the same for user (vtp) and server (vtpd) so for
1329: now, VT-BREAK can only be requested at user side.*/
1330: #endif
1331: vt_rem_echo(&na_image);
1332: #endif
1333: vt_sup_ga(&na_image);
1334: kill_proc();
1335: }
1336: /*Re-Negotiate Remote Echo and Suppress Go Ahead*/
1337: }
1338:
1339: /*ARGSUSED */
1340: vbrkcnf(brk_pe)
1341: PE brk_pe;
1342: {
1343: (void)printf("\r\n[break]\r\n");
1344: if(telnet_profile)
1345: {
1346: #ifndef PTYBUG
1347: vt_rem_echo(&ni_image);
1348: #endif
1349: vt_sup_ga(&ni_image);
1350: }
1351: }
1352:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.