![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to con_mid.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to con_mid.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "CON_MID.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: extern char *wday[]; /* 3 char days of week */
8:
9: /****************************************************************************/
10: /* Waits for remote or local user to hit a key. Inactivity timer is checked */
11: /* and hangs up if inactive for 4 minutes. Returns key hit, or uppercase of */
12: /* key hit if mode&K_UPPER or key out of KEY BUFFER. Does not print key. */
13: /* Called from functions all over the place. */
14: /****************************************************************************/
15: char getkey(long mode)
16: {
17: char ch,coldkey,c=0,spin=random(5);
18:
19: if(!online)
20: return(0);
21: sys_status&=~SS_ABORT;
22: if((sys_status&SS_USERON || action==NODE_DFLT) && !(mode&K_GETSTR))
23: mode|=(useron.misc&SPIN);
24: lncntr=0;
25: timeout=time(NULL);
26: if(mode&K_SPIN)
27: outchar(' ');
28: do {
29: checkline(); /* check to make sure remote user is still online */
30: if(online==ON_REMOTE && console&CON_R_INPUT && rioctl(IOSTATE)&ABORT) {
31: rioctl(IOCS|ABORT);
32: sys_status|=SS_ABORT;
33: if(mode&K_SPIN) /* back space once if on spinning cursor */
34: bputs("\b \b");
35: return(0); }
36: if(sys_status&SS_SYSPAGE)
37: beep(random(800),100);
38: if(mode&K_SPIN)
39: switch(spin) {
40: case 0:
41: switch(c++) {
42: case 0:
43: outchar(BS);
44: outchar('�');
45: break;
46: case 10:
47: outchar(BS);
48: outchar('/');
49: break;
50: case 20:
51: outchar(BS);
52: outchar('�');
53: break;
54: case 30:
55: outchar(BS);
56: outchar('\\');
57: break;
58: case 40:
59: c=0;
60: break;
61: default:
62: if(!inDV && !(node_misc&NM_WINOS2))
63: mswait(DELAY_SPIN);
64: break; }
65: break;
66: case 1:
67: switch(c++) {
68: case 0:
69: outchar(BS);
70: outchar('�');
71: break;
72: case 10:
73: outchar(BS);
74: outchar('�');
75: break;
76: case 20:
77: outchar(BS);
78: outchar('�');
79: break;
80: case 30:
81: outchar(BS);
82: outchar('�');
83: break;
84: case 40:
85: outchar(BS);
86: outchar('�');
87: break;
88: case 50:
89: outchar(BS);
90: outchar('�');
91: break;
92: case 60:
93: c=0;
94: break;
95: default:
96: if(!inDV && !(node_misc&NM_WINOS2))
97: mswait(DELAY_SPIN);
98: break; }
99: break;
100: case 2:
101: switch(c++) {
102: case 0:
103: outchar(BS);
104: outchar('-');
105: break;
106: case 10:
107: outchar(BS);
108: outchar('=');
109: break;
110: case 20:
111: outchar(BS);
112: outchar('�');
113: break;
114: case 30:
115: outchar(BS);
116: outchar('=');
117: break;
118: case 40:
119: c=0;
120: break;
121: default:
122: if(!inDV && !(node_misc&NM_WINOS2))
123: mswait(DELAY_SPIN);
124: break; }
125: break;
126: case 3:
127: switch(c++) {
128: case 0:
129: outchar(BS);
130: outchar('�');
131: break;
132: case 10:
133: outchar(BS);
134: outchar('�');
135: break;
136: case 20:
137: outchar(BS);
138: outchar('�');
139: break;
140: case 30:
141: outchar(BS);
142: outchar('�');
143: break;
144: case 40:
145: c=0;
146: break;
147: default:
148: if(!inDV && !(node_misc&NM_WINOS2))
149: mswait(DELAY_SPIN);
150: break; }
151: break;
152: case 4:
153: switch(c++) {
154: case 0:
155: outchar(BS);
156: outchar('�');
157: break;
158: case 10:
159: outchar(BS);
160: outchar('�');
161: break;
162: case 20:
163: outchar(BS);
164: outchar('�');
165: break;
166: case 30:
167: outchar(BS);
168: outchar('�');
169: break;
170: case 40:
171: c=0;
172: break;
173: default:
174: if(!inDV && !(node_misc&NM_WINOS2))
175: mswait(DELAY_SPIN);
176: break; }
177: break; }
178: if(keybuftop!=keybufbot) {
179: ch=keybuf[keybufbot++];
180: if(keybufbot==KEY_BUFSIZE)
181: keybufbot=0; }
182: else
183: ch=inkey(mode);
184: if(sys_status&SS_ABORT)
185: return(0);
186: now=time(NULL);
187: if(ch) {
188: if(mode&K_NUMBER && isprint(ch) && !isdigit(ch))
189: continue;
190: if(mode&K_ALPHA && isprint(ch) && !isalpha(ch))
191: continue;
192: if(mode&K_NOEXASC && ch&0x80)
193: continue;
194: if(mode&K_SPIN)
195: bputs("\b \b");
196: if(mode&K_COLD && ch>SP && useron.misc&COLDKEYS) {
197: if(mode&K_UPPER)
198: outchar(toupper(ch));
199: else
200: outchar(ch);
201: while((coldkey=inkey(mode))==0 && online && !(sys_status&SS_ABORT))
202: checkline();
203: bputs("\b \b");
204: if(coldkey==BS)
205: continue;
206: if(coldkey>SP)
207: ungetkey(coldkey); }
208: if(mode&K_UPPER)
209: return(toupper(ch));
210: return(ch); }
211: if(sys_status&SS_USERON && !(sys_status&SS_LCHAT)) gettimeleft();
212: else if(online &&
213: ((node_dollars_per_call && now-answertime>SEC_BILLING)
214: || (now-answertime>SEC_LOGON && !(sys_status&SS_LCHAT)))) {
215: console&=~(CON_R_ECHOX|CON_L_ECHOX);
216: console|=(CON_R_ECHO|CON_L_ECHO);
217: bputs(text[TakenTooLongToLogon]);
218: hangup(); }
219: if(sys_status&SS_USERON && online && (timeleft/60)<(5-timeleft_warn)
220: && !SYSOP && !(sys_status&SS_LCHAT)) {
221: timeleft_warn=5-(timeleft/60);
222: SAVELINE;
223: attr(LIGHTGRAY);
224: bprintf(text[OnlyXminutesLeft]
225: ,((ushort)timeleft/60)+1,(timeleft/60) ? "s" : nulstr);
226: RESTORELINE; }
227:
228: if(online==ON_LOCAL && node_misc&NM_NO_INACT)
229: timeout=now;
230: if(now-timeout>=sec_warn) { /* warning */
231: if(sys_status&SS_USERON) {
232: SAVELINE;
233: bputs(text[AreYouThere]); }
234: else
235: bputs("\7\7");
236: while(!inkey(0) && online && now-timeout>=sec_warn) {
237: now=time(NULL);
238: if(now-timeout>=sec_hangup) {
239: if(online==ON_REMOTE) {
240: console|=CON_R_ECHO;
241: console&=~CON_R_ECHOX; }
242: bputs(text[CallBackWhenYoureThere]);
243: logline(nulstr,"Inactive");
244: hangup();
245: return(0); }
246: mswait(100); }
247: if(sys_status&SS_USERON) {
248: bputs("\r\1n\1>");
249: RESTORELINE; }
250: timeout=now; }
251:
252: } while(online);
253: return(0);
254: }
255:
256: /****************************************************************************/
257: /* This function lists users that are online. */
258: /* If listself is true, it will list the current node. */
259: /* Returns number of active nodes (not including current node). */
260: /****************************************************************************/
261: int whos_online(char listself)
262: {
263: int i,j;
264: node_t node;
265:
266: CRLF;
267: bputs(text[NodeLstHdr]);
268: for(j=0,i=1;i<=sys_nodes && i<=sys_lastnode;i++) {
269: getnodedat(i,&node,0);
270: if(i==node_num) {
271: if(listself)
272: printnodedat(i,node);
273: continue; }
274: if(node.status==NODE_INUSE || (SYSOP && node.status==NODE_QUIET)) {
275: printnodedat(i,node);
276: if(!lastnodemsg)
277: lastnodemsg=i;
278: j++; } }
279: if(!j)
280: bputs(text[NoOtherActiveNodes]);
281: return(j);
282: }
283:
284: /****************************************************************************/
285: /* Displays the information for node number 'number' contained in 'node' */
286: /****************************************************************************/
287: void printnodedat(uint number, node_t node)
288: {
289: uint i;
290: char hour,mer[3];
291:
292: attr(color[clr_nodenum]);
293: bprintf("%3d ",number);
294: attr(color[clr_nodestatus]);
295: switch(node.status) {
296: case NODE_WFC:
297: bputs("Waiting for call");
298: break;
299: case NODE_OFFLINE:
300: bputs("Offline");
301: break;
302: case NODE_NETTING:
303: bputs("Networking");
304: break;
305: case NODE_LOGON:
306: bputs("At logon prompt");
307: break;
308: case NODE_EVENT_WAITING:
309: bputs("Waiting for all nodes to become inactive");
310: break;
311: case NODE_EVENT_LIMBO:
312: bprintf("Waiting for node %d to finish external event",node.aux);
313: break;
314: case NODE_EVENT_RUNNING:
315: bputs("Running external event");
316: break;
317: case NODE_NEWUSER:
318: attr(color[clr_nodeuser]);
319: bputs("New user");
320: attr(color[clr_nodestatus]);
321: bputs(" applying for access ");
322: if(!node.connection)
323: bputs("Locally");
324: else
325: bprintf("at %ubps",node.connection);
326: break;
327: case NODE_QUIET:
328: if(!SYSOP) {
329: bputs("Waiting for call");
330: break; }
331: case NODE_INUSE:
332: if(node.misc&NODE_EXT) {
333: getnodeext(number,tmp);
334: bputs(tmp);
335: break; }
336: attr(color[clr_nodeuser]);
337: if(node.misc&NODE_ANON && !SYSOP)
338: bputs("UNKNOWN USER");
339: else
340: bputs(username(node.useron,tmp));
341: attr(color[clr_nodestatus]);
342: bputs(" ");
343: switch(node.action) {
344: case NODE_MAIN:
345: bputs("at main menu");
346: break;
347: case NODE_RMSG:
348: bputs("reading messages");
349: break;
350: case NODE_RMAL:
351: bputs("reading mail");
352: break;
353: case NODE_RSML:
354: bputs("reading sent mail");
355: break;
356: case NODE_RTXT:
357: bputs("reading text files");
358: break;
359: case NODE_PMSG:
360: bputs("posting message");
361: break;
362: case NODE_SMAL:
363: bputs("sending mail");
364: break;
365: case NODE_AMSG:
366: bputs("posting auto-message");
367: break;
368: case NODE_XTRN:
369: if(!node.aux)
370: bputs("at external program menu");
371: else {
372: bputs("running ");
373: i=node.aux-1;
374: if(SYSOP || chk_ar(xtrn[i]->ar,useron))
375: bputs(xtrn[node.aux-1]->name);
376: else
377: bputs("external program"); }
378: break;
379: case NODE_DFLT:
380: bputs("changing defaults");
381: break;
382: case NODE_XFER:
383: bputs("at transfer menu");
384: break;
385: case NODE_RFSD:
386: bprintf("retrieving from device #%d",node.aux);
387: break;
388: case NODE_DLNG:
389: bprintf("downloading");
390: break;
391: case NODE_ULNG:
392: bputs("uploading");
393: break;
394: case NODE_BXFR:
395: bputs("transferring bidirectional");
396: break;
397: case NODE_LFIL:
398: bputs("listing files");
399: break;
400: case NODE_LOGN:
401: bputs("logging on");
402: break;
403: case NODE_LCHT:
404: bprintf("in local chat with %s",sys_op);
405: break;
406: case NODE_MCHT:
407: if(node.aux) {
408: bprintf("in multinode chat channel %d",node.aux&0xff);
409: if(node.aux&0x1f00) { /* password */
410: outchar('*');
411: if(SYSOP)
412: bprintf(" %s",unpackchatpass(tmp,node)); } }
413: else
414: bputs("in multinode global chat channel");
415: break;
416: case NODE_PAGE:
417: bprintf("paging node %u for private chat",node.aux);
418: break;
419: case NODE_PCHT:
420: bprintf("in private chat with node %u",node.aux);
421: break;
422: case NODE_GCHT:
423: i=node.aux;
424: if(i>=total_gurus)
425: i=0;
426: bprintf("chatting with %s",guru[i]->name);
427: break;
428: case NODE_CHAT:
429: bputs("in chat section");
430: break;
431: case NODE_TQWK:
432: bputs("transferring QWK packet");
433: break;
434: case NODE_SYSP:
435: bputs("performing sysop activities");
436: break;
437: default:
438: bputs(itoa(node.action,tmp,10));
439: break; }
440: if(!node.connection)
441: bputs(" locally");
442: else
443: bprintf(" at %ubps",node.connection);
444: if(node.action==NODE_DLNG) {
445: if(sys_misc&SM_MILITARY) {
446: hour=node.aux/60;
447: mer[0]=0; }
448: else if((node.aux/60)>=12) {
449: if(node.aux/60==12)
450: hour=12;
451: else
452: hour=(node.aux/60)-12;
453: strcpy(mer,"pm"); }
454: else {
455: if((node.aux/60)==0) /* 12 midnite */
456: hour=12;
457: else hour=node.aux/60;
458: strcpy(mer,"am"); }
459: bprintf(" ETA %02d:%02d %s"
460: ,hour,node.aux%60,mer); }
461: break; }
462: i=NODE_LOCK;
463: if(node.status==NODE_INUSE || SYSOP)
464: i|=NODE_POFF|NODE_AOFF|NODE_MSGW|NODE_NMSG;
465: if(node.misc&i) {
466: bputs(" (");
467: if(node.misc&(i&NODE_AOFF))
468: outchar('A');
469: if(node.misc&NODE_LOCK)
470: outchar('L');
471: if(node.misc&(i&(NODE_MSGW|NODE_NMSG)))
472: outchar('M');
473: if(node.misc&(i&NODE_POFF))
474: outchar('P');
475: outchar(')'); }
476: if(SYSOP && ((node.misc
477: &(NODE_ANON|NODE_UDAT|NODE_INTR|NODE_RRUN|NODE_EVENT|NODE_DOWN))
478: || node.status==NODE_QUIET)) {
479: bputs(" [");
480: if(node.misc&NODE_ANON)
481: outchar('A');
482: if(node.misc&NODE_INTR)
483: outchar('I');
484: if(node.misc&NODE_RRUN)
485: outchar('R');
486: if(node.misc&NODE_UDAT)
487: outchar('U');
488: if(node.status==NODE_QUIET)
489: outchar('Q');
490: if(node.misc&NODE_EVENT)
491: outchar('E');
492: if(node.misc&NODE_DOWN)
493: outchar('D');
494: outchar(']'); }
495: if(node.errors && SYSOP) {
496: attr(color[clr_err]);
497: bprintf(" %d error%c",node.errors, node.errors>1 ? 's' : '\0' ); }
498: attr(LIGHTGRAY);
499: CRLF;
500: }
501:
502: /****************************************************************************/
503: /* Prints/updates the local status line (line #25) with the user/system */
504: /* information. Which info depends on value of statline. */
505: /* Called from several functions */
506: /****************************************************************************/
507: void statusline()
508: {
509: int row,col,atr;
510: char tmp1[128],tmp2[256],tmp3[256],age;
511:
512: #ifndef __OS2__
513: if(lclaes())
514: return;
515: #endif
516: col=lclwx();
517: row=lclwy();
518: STATUSLINE;
519: lclxy(1,node_scrnlen);
520: age=getage(useron.birth);
521: if(sys_status&(SS_CAP|SS_TMPSYSOP)) {
522: atr=lclatr((LIGHTGRAY<<4)|BLINK);
523: sys_status&SS_CAP ? lputc('C') : lputc(SP);
524: sys_status&SS_TMPSYSOP ? lputc('*') : lputc(SP);
525: lclatr(LIGHTGRAY<<4); }
526: else {
527: atr=lclatr(LIGHTGRAY<<4);
528: lputs(" "); }
529: switch(statline) {
530: case -1:
531: lputs("Terminal: Alt-X Exit Alt-D DOS Alt-H Hangup "
532: "Alt-L Logon Alt-U User Edit");
533: break;
534: case 0: /* Alias ML Password Modem Birthday Age Sex Phone */
535: lprintf("%-24.24s %02d %-8.8s %-8.8s %-8.8s %02d %c %s"
536: ,useron.alias,useron.level,sys_misc&SM_ECHO_PW ? useron.pass:"XXXX"
537: ,useron.modem,useron.birth,age,useron.sex,useron.phone);
538: break;
539: case 1: /* Alias ML RealName Alt-Z for Help */
540: lprintf("%-24.24s %02d %-25.25s "
541: ,useron.alias,useron.level,useron.name);
542: lputs("Alt-Z for Help");
543: break;
544: case 2: /* Alias ML RealName Age Sex Phone */
545: lprintf("%-24.24s %02d %-25.25s %02d %c %s"
546: ,useron.alias,useron.level,useron.name,age,useron.sex,useron.phone);
547: break;
548: case 3: /* Alias ML Location Phone */
549: lprintf("%-24.24s %02d %-30.30s %s"
550: ,useron.alias,useron.level,useron.location,useron.phone);
551: break;
552: case 4: /* Alias ML Note Phone */
553: lprintf("%-24.24s %02d %-30.30s %s"
554: ,useron.alias,useron.level,useron.note,useron.phone);
555: break;
556: case 5: /* Alias ML MF Age Sex Phone */
557: lprintf("%-24.24s %02d %-26.26s %02d %c %s"
558: ,useron.alias,useron.level,ltoaf(useron.flags1,tmp1)
559: ,age,useron.sex,useron.phone);
560: break;
561: case 6: /* Alias ML MF Expiration */
562: lprintf("%-24.24s %02d %-26.26s Exp: %s"
563: ,useron.alias,useron.level,ltoaf(useron.flags1,tmp1)
564: ,unixtodstr(useron.expire,tmp2));
565: break;
566: case 7: /* Alias ML Firston Laston Expire */
567: lprintf("%-24.24s %02d First: %s Last: %s Exp: %s"
568: ,useron.alias,useron.level,unixtodstr(useron.firston,tmp1)
569: ,unixtodstr(useron.laston,tmp2),unixtodstr(useron.expire,tmp3));
570: break;
571: case 8: /* Alias Credits Minutes Expire */
572: lprintf("%-24.24s Cdt: %-13.13s Min: %-10luExp: %s"
573: ,useron.alias,ultoac(useron.cdt,tmp1),useron.min
574: ,unixtodstr(useron.expire,tmp2));
575: break;
576: case 9: /* Exemptions Restrictions */
577: lprintf(" Exempt:%-26.26s Restrict:%s"
578: ,ltoaf(useron.exempt,tmp1),ltoaf(useron.rest,tmp2));
579: break;
580: case 10: /* Computer Modem Handle*/
581: lprintf("Comp: %-30.30s Modem: %-8.8s Handle: %s"
582: ,useron.comp,connection,useron.handle);
583: break;
584: case 11: /* StreetAddress Location Zip */
585: lprintf("%-30.30s %-30.30s %s"
586: ,useron.address,useron.location,useron.zipcode);
587: break;
588: case 12: /* UploadBytes Uploads DownloadBytes Downloads Leeches */
589: lprintf("Uloads: %-13.13s / %-5u Dloads: %-13.13s / %-5u Leech: %u"
590: ,ultoac(useron.ulb,tmp1),useron.uls
591: ,ultoac(useron.dlb,tmp2),useron.dls,useron.leech);
592: break;
593: case 13: /* Posts Emails Fbacks Waiting Logons Timeon */
594: lprintf("P: %-5u E: %-5u F: %-5u W: %-5u L: %-5u T: %-5u"
595: ,useron.posts,useron.emails,useron.fbacks,getmail(useron.number,0)
596: ,useron.logons,useron.timeon);
597: break;
598: case 14: /* NetMail forwarding address */
599: lprintf("NetMail: %s",useron.netmail);
600: break;
601: case 15: /* Comment */
602: lprintf("Comment: %s",useron.comment);
603: break;
604: }
605: lputc(CLREOL);
606: lclxy(75,lclwy());
607: getnodedat(node_num,&thisnode,0);
608: if(sys_status&SS_SYSALERT
609: || thisnode.misc&(NODE_RRUN|NODE_DOWN|NODE_LOCK|NODE_EVENT)) {
610: lclatr((LIGHTGRAY<<4)|BLINK);
611: sys_status&SS_SYSALERT ? lputc('A'):lputc(SP);
612: thisnode.misc&NODE_RRUN ? lputc('R'):lputc(SP);
613: thisnode.misc&NODE_DOWN ? lputc('D'):lputc(SP);
614: thisnode.misc&NODE_LOCK ? lputc('L'):lputc(SP);
615: thisnode.misc&NODE_EVENT ? lputc('E'):lputc(SP); }
616: TEXTWINDOW;
617: lclxy(col,row);
618: lclatr(atr);
619: }
620:
621: /****************************************************************************/
622: /* Prints PAUSE message and waits for a key stoke */
623: /****************************************************************************/
624: void pause()
625: {
626: uchar tempattrs=curatr; /* was lclatr(-1) */
627: int i,j;
628: long l=K_UPPER;
629:
630: RIOSYNC(0);
631: if(sys_status&SS_ABORT)
632: return;
633: lncntr=0;
634: if(online==ON_REMOTE)
635: rioctl(IOFI);
636: bputs(text[Pause]);
637: j=bstrlen(text[Pause]);
638: if(sys_status&SS_USERON && !(useron.misc&NO_EXASCII) && !(useron.misc&WIP))
639: l|=K_SPIN;
640: if(getkey(l)==text[YN][1])
641: sys_status|=SS_ABORT;
642: if(text[Pause][0]!='@')
643: for(i=0;i<j;i++)
644: bputs("\b \b");
645: getnodedat(node_num,&thisnode,0);
646: nodesync();
647: attr(tempattrs);
648: }
649:
650: void getlines()
651: {
652: if(useron.misc&ANSI && !useron.rows /* Auto-detect rows */
653: && online==ON_REMOTE) { /* Remote */
654: SYNC;
655: putcom("\x1b[s\x1b[99B\x1b[6n\x1b[u");
656: while(online && !rioctl(RXBC) && !lkbrd(1))
657: checkline();
658: inkey(0); }
659:
660: }
661:
662:
663: /****************************************************************************/
664: /* Prints a file remotely and locally, interpreting ^A sequences, checks */
665: /* for pauses, aborts and ANSI. 'str' is the path of the file to print */
666: /* Called from functions menu and text_sec */
667: /****************************************************************************/
668: void printfile(char *str, int mode)
669: {
670: char HUGE16 *buf;
671: int file,wip=0,rip=0;
672: long length,savcon=console;
673: FILE *stream;
674:
675: if(strstr(str,".WIP"))
676: wip=1;
677: if(strstr(str,".RIP"))
678: rip=1;
679:
680: if(mode&P_NOABORT || wip || rip) {
681: if(online==ON_REMOTE && console&CON_R_ECHO) {
682: rioctl(IOCM|ABORT);
683: rioctl(IOCS|ABORT); }
684: sys_status&=~SS_ABORT; }
685:
686: if(!tos && !wip && !rip)
687: CRLF;
688:
689: if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
690: bputs(text[FileNotFound]);
691: if(SYSOP) bputs(str);
692: CRLF;
693: return; }
694:
695: if(wip || rip || !(console&CON_L_ECHO)) {
696: if(online!=ON_REMOTE || !(console&CON_R_ECHO)) {
697: fclose(stream);
698: return; }
699: console&=~CON_L_ECHO;
700: lprintf("PRINTFILE (Remote Only): %s\r\n",str); }
701: if(mode&P_OPENCLOSE) {
702: length=filelength(file);
703: if((buf=MALLOC(length+1L))==NULL) {
704: close(file);
705: console=savcon;
706: errormsg(WHERE,ERR_ALLOC,str,length+1L);
707: return; }
708: buf[lread(file,buf,length)]=0;
709: fclose(stream);
710: putmsg(buf,mode);
711: FREE((char *)buf); }
712: else {
713: putmsg_fp(stream,filelength(file),mode);
714: fclose(stream); }
715: if((mode&P_NOABORT || wip || rip) && online==ON_REMOTE) {
716: SYNC;
717: rioctl(IOSM|ABORT); }
718: if(rip)
719: getlines();
720: console=savcon;
721: }
722:
723: void printtail(char *str, int lines, int mode)
724: {
725: char HUGE16 *buf,HUGE16 *p;
726: int file,cur=0;
727: ulong length,l;
728:
729: if(mode&P_NOABORT) {
730: if(online==ON_REMOTE) {
731: rioctl(IOCM|ABORT);
732: rioctl(IOCS|ABORT); }
733: sys_status&=~SS_ABORT; }
734: strupr(str);
735: if(!tos) {
736: CRLF; }
737: if((file=nopen(str,O_RDONLY))==-1) {
738: bputs(text[FileNotFound]);
739: if(SYSOP) bputs(str);
740: CRLF;
741: return; }
742: length=filelength(file);
743: if((buf=MALLOC(length+1L))==NULL) {
744: close(file);
745: errormsg(WHERE,ERR_ALLOC,str,length+1L);
746: return; }
747: l=lread(file,buf,length);
748: buf[l]=0;
749: close(file);
750: p=(buf+l)-1;
751: if(*p==LF) p--;
752: while(*p && p>buf) {
753: if(*p==LF)
754: cur++;
755: if(cur>=lines) {
756: p++;
757: break; }
758: p--; }
759: putmsg(p,mode);
760: if(mode&P_NOABORT && online==ON_REMOTE) {
761: SYNC;
762: rioctl(IOSM|ABORT); }
763: FREE((char *)buf);
764: }
765:
766: /****************************************************************************/
767: /* Prints the menu number 'menunum' from the text directory. Checks for ^A */
768: /* ,ANSI sequences, pauses and aborts. Usually accessed by user inputing '?'*/
769: /* Called from every function that has an available menu. */
770: /* The code definitions are as follows: */
771: /****************************************************************************/
772: void menu(char *code)
773: {
774: char str[256],path[256];
775: int c,i,l;
776:
777: sys_status&=~SS_ABORT;
778: if(menu_file[0])
779: strcpy(path,menu_file);
780: else {
781: sprintf(str,"%sMENU\\",text_dir);
782: if(menu_dir[0]) {
783: strcat(str,menu_dir);
784: strcat(str,"\\"); }
785: strcat(str,code);
786: strcat(str,".");
787: sprintf(path,"%s%s",str,useron.misc&WIP ? "WIP":"RIP");
788: if(!(useron.misc&(RIP|WIP)) || !fexist(path)) {
789: sprintf(path,"%sMON",str);
790: if((useron.misc&(COLOR|ANSI))!=ANSI || !fexist(path)) {
791: sprintf(path,"%sANS",str);
792: if(!(useron.misc&ANSI) || !fexist(path))
793: sprintf(path,"%sASC",str); } } }
794:
795: printfile(path,P_OPENCLOSE);
796: }
797:
798: /****************************************************************************/
799: /* Puts a character into the input buffer */
800: /****************************************************************************/
801: void ungetkey(char ch)
802: {
803:
804: keybuf[keybuftop++]=ch;
805: if(keybuftop==KEY_BUFSIZE)
806: keybuftop=0;
807: }
808:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.