![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xsdk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / sdk|
Return to xsdk.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / sdk |
1.1 root 1: /* XSDK.C */
2:
3: /****************************************************************************/
4: /* Synchronet External Program Software Development Kit */
5: /* 1995 Digital Dynamics */
6: /****************************************************************************/
7:
8: /****************************************************************************/
9: /* This source code file is public domain and may be modified, compiled */
10: /* distributed, or used in any way, in part or whole for any purposes */
11: /* without the consent or notification of Digital Dynamics. */
12: /* */
13: /* We only request that you display to the user, at some point, in your */
14: /* program the character "XSDK" and the version number. */
15: /* example: bprintf("XSDK v%s",xsdk_ver); */
16: /****************************************************************************/
17:
18: /****************************************************************************/
19: /* The source code for two external programs developed by Digital Dynamics */
20: /* using XSDK (Synchronet Blackjack [SBJ] and Synchronet BBS List [SBL]) */
21: /* are available to the public domain as examples of how to implement the */
22: /* functions and variables included in this software development kit. */
23: /****************************************************************************/
24:
25: /****************************************************/
26: /* For use with Borland/Turbo C and C++ compilers. */
27: /* Tabstop set to 4. */
28: /****************************************************/
29:
30: /***************************** Revision History *****************************\
31:
32: Initial version for use with Synchronet v1a r6
33: 1.0�
34: Added bgotoxy() macro
35: Added mnehigh and mnelow vars for control of the mnemonic colors
36: Added sys_nodes and node_num variables to xtrn_sdk.c
37: Added MAX_NODES to xtrn_sdk.h
38: Added printfile() function to xtrn_sdk.c
39: Added rputs() (Raw put string)
40: Added getstr() (Get string)
41: Added redrwstr() (Redraw string)
42: Added stripattr() (String attributes)
43: Added sys_op var and the reading from the xtrn.dat
44: Removed user_min and the reading from the xtrn.dat
45: Changed read_xtrn_dat() to initdata()
46: Added ctrl-break handler to xtrn_sdk
47: Changed xtrn.dat format (again), adding system operator,
48: guru name, user ml, tl, birthdate and sex.
49: Added username() function
50: Renamed xtrn_sdk.* to xsdk.* and xtrnvars.c to xsdkvars.c
51: and xtrndefs.h to xsdkdefs.h
52: Added fexist() function
53: 1.0
54: Ctrl-p is now switched into ctrl-^ by SBBS
55: Fixed relative data_dir bug in username()
56: 1.01
57: Added flength() function and lowered disk activity
58: Lowered MAX_CARDS from 20 to 10 and made the re-shuffling happen
59: less often.
60: 1.02
61: Fixed bug in attr() for monochrome users
62: 1.03
63: Made warning and timeout times variables (sec_warn and sec_timeout)
64: Added SYSOP macro
65: Made it so sysop won't get timeout
66: Added user's phone number to XTRN.DAT
67: Added modem and com port information to XTRN.DAT
68: Added ahtoul function
69: Changed getstr commands Ctrl-L to Ctrl-R and Ctrl-P to Ctrl-\
70: 1.04
71: Added intercommunication between the external programs and users
72: on the BBS or other external programs written with XSDK.
73: Added rprintf() function
74: Made many changes to getstr() function
75: 2.00
76: Added DESQview awareness
77: Removed difftime() function calls completely
78: Added ungetkey() function
79: Added memory address of last modem status register for com routines
80: so we can track DCD incase user hangs up.
81: Added checkline function that does the checking of DCD.
82: Added new bug-free fdelay() routine to replace TC's delay() that
83: crashes multi-taskers such as DESQview and Windows
84: 2.01
85: Added external program name access for user listings.
86: Added last node to send message to remembering and defaulting.
87: Added MALLOC and FREE macros for memory model non-specific memory
88: allocation.
89: 2.02
90: Added INTRSBBS.DAT support for Synchronet shrinking to run programs
91: written with XSDK (new with v1b rev 01).
92: Added user's main flags, transfer flags, exemptions, and
93: restrictions to XTRN.DAT
94: Added support for the NODE_PAGE action (paging for private chat)
95: when listing nodes (printnodedat()).
96: Added user expiration date support to XTRN.DAT
97: 2.03
98: Fixed bug with com_base variable being messed up.
99: New messaging system supported (for v1b r2 and higher)
100: (putnmsg and getnmsg functions).
101: 2.10
102: Added support for file retrieving node status display.
103: NOPEN collision notice only appears after 25 retries.
104: 2.11
105: Changed getnmsg function to not use IXB files.
106: Changed getsmsg function to not re-open for truncate.
107: Added user address, location, and zip/postal code suppport.
108: Added support for local arrow keys, home, end, ins, and del.
109: Remote keys ^] (back one space) and ^BkSpc (del) supported now.
110: Added support for high-bit Ctrl-A codes (for cursor positioning)
111: Removed file locking check - slowed down initialization sometimes.
112: Change user_ml to user_level, removed user_tl, changed user_mf to
113: user_flags1, changed user_tf to user_flags2, and added
114: user_flags3 and user_flags4.
115: cls() now updates lncntr like it should have.
116: Added ctrl-break handler so that users can abort printfile()
117: If a ctrl-c is received by inkey, the aborted flag is set.
118: Removed fdelay from XSDK and replaced with mswait for better
119: multitasker performance
120: 2.20
121: New mswait that support OS2/Windows, DOS Idle, and non-DV modes.
122: XTRN.DAT passes mode of mswait configured in node setup.
123: 2.21
124: Added user's real name/company name (user_realname) to XTRN.DAT
125: 2.22
126: Added usernumber() function to get user number from a user name.
127: 2.23
128: DTE rate (com_rate) now a ulong (instead of uint) to allow 115.2K
129: 2.24
130: New K_AUTODEL mode for getstr() function, to be used in conjunction
131: with the K_EDIT mode. Makes overwriting existing strings very
132: easy for users.
133: Supports intelligent timeslice APIs while waiting for a key with
134: getkey() and with getstr() if K_LOWPRIO mode is used.
135: Hitting Ctrl-C sets the 'aborted' variable to 1.
136: Time zone and daylight savings automatically initialized to 0.
137: Modem strings up to 63 chars in XTRN.DAT now supported.
138: Fixed 10 character zip code bug in XSDKVARS.C.
139: Node directories (node_dir) up to 127 chars now supported.
140: nopen() can now open DENYNONE if passed access O_DENYNONE.
141: 2.30
142: Added support for the following Ctrl-A codes: ;,.<>[]A
143: Changed definitions of TAB, SP, etc. to hex
144: 2.31
145: C restriction disallows users to use Ctrl-P.
146: T exemption disables "Time's up" message.
147: Added center() function for outputting centered lines of text.
148: Added auto-pause to cls() and outchar() functions when clearing
149: the screen and lncntr is greater than 1
150: Changed bstrlen() to not count control characters (CR,LF,TAB,etc)
151: XSDK is now Watcom C++ compatible (although SBJ.C and SBL.C aren't)
152: XSDK.H is now *.CPP compatible
153: Added support for Ctrl-AQ (reset pause) and Ctrl-AZ (premature EOF)
154: 2.32
155: Change bstrlen(char *str) to bstrlen(uchar *str)
156: Fixed bug in getstr() when word-wrapping a line that contains
157: ctrl-a codes and the input string did not begin at column 1.
158: Added user_dce variable (initialized by initdata from XTRN.DAT)
159: Fixed printnodedat() to not show Waiting for call (M)
160: Fixed typo in C restriction Ctrl-P message.
161: Moved call of checkline() in getkey() to immediately abort when
162: user hangs-up, even when keys are in the input buffer.
163: Added setmode() call to initdata() to set stderr to binary mode
164: Changed putchar() to write() in outchar() to elminate LF to CRLF
165: expansion
166: 2.33
167: Improved cls() routine for auto-pause feature.
168: Added get_term() automatic RIP and WIP terminal detection function.
169: 2.34
170: Added exec_dir, text_dir, and temp_dir variables to XTRN.DAT
171: format and initdata() function.
172: Added _fullpath() calls to initdata() to fix dir paths.
173: Added sys_id (QWK ID) to XTRN.DAT format and initdat() func.
174: Added node_misc to XTRN.DAT format and initdata() function.
175: If NM_LOWPRIO (low priority string input) is toggled on in
176: node_misc, then time-slices are always given up during input.
177: XSDK is now Symantec C++ compatible
178: 2.40
179: node_misc was being read as a decimal number (it's stored in
180: the XTRN.DAT as hex), thus causing time-slice APIs to not
181: function correctly.
182: 2.41
183: Ctrl-T is now intercepted by inkey() and displays the time the
184: program was launched, the current time, time used, and time
185: left (similar to SBBS).
186: Users are now warned of their last 5 minutes available (like SBBS).
187: 2.42
188:
189: \****************************************************************************/
190:
191: #include "xsdk.h"
192:
193: char *xsdk_ver="2.42";
194:
195: #ifdef __TURBOC__
196: extern long timezone=0L;
197: extern daylight=0;
198: #endif
199:
200: #ifdef __SC__
201: #include <disp.h>
202: short wherey(void);
203: void clrscr(void);
204: #endif
205:
206:
207: /****************************************************************************/
208: /* This allows users to abort the listing of text by using Ctrl-C */
209: /****************************************************************************/
210: int cbreakh(void) /* ctrl-break handler */
211: {
212: aborted=1;
213: return(1); /* 1 to continue, 0 to abort */
214: }
215:
216: /****************************************************************************/
217: /* Performs printf() using bbs bputs function */
218: /****************************************************************************/
219: int bprintf(char *fmt, ...)
220: {
221: va_list argptr;
222: char sbuf[1024];
223: int chcount;
224:
225: va_start(argptr,fmt);
226: chcount=vsprintf(sbuf,fmt,argptr);
227: va_end(argptr);
228: bputs(sbuf);
229: return(chcount);
230: }
231:
232: /****************************************************************************/
233: /* Performs printf() using bbs rputs function */
234: /****************************************************************************/
235: int rprintf(char *fmt, ...)
236: {
237: va_list argptr;
238: char sbuf[1024];
239: int chcount;
240:
241: va_start(argptr,fmt);
242: chcount=vsprintf(sbuf,fmt,argptr);
243: va_end(argptr);
244: rputs(sbuf);
245: return(chcount);
246: }
247:
248: /****************************************************************************/
249: /* Outputs a NULL terminated string locally and remotely (if applicable) */
250: /****************************************************************************/
251: void bputs(char *str)
252: {
253: ulong l=0;
254:
255: while(str[l] && !aborted) {
256: if(str[l]==1) { /* ctrl-a */
257: ctrl_a(str[++l]); /* skip the ctrl-a */
258: if(str[l]=='Z') /* Ctrl-AZ marks premature end of file */
259: break;
260: l++; } /* skip the attribute code */
261: else
262: outchar(str[l++]); }
263: }
264:
265: /****************************************************************************/
266: /* Outputs a NULL terminated string locally and remotely (if applicable) */
267: /* Does not process ctrl-a codes (raw output) */
268: /* Max length of str is 64 kbytes */
269: /****************************************************************************/
270: void rputs(char *str)
271: {
272: ulong l=0;
273:
274: while(str[l])
275: outchar(str[l++]);
276: }
277:
278: /****************************************************************************/
279: /* Returns the number of characters in 'str' not counting ctrl-ax codes */
280: /* or the null terminator */
281: /****************************************************************************/
282: int bstrlen(uchar *str)
283: {
284: int i=0;
285:
286: while(*str) {
287: if(*str<SP) { /* ctrl char */
288: if(*str==1) /* ctrl-A */
289: str++;
290: else if(*str!=CR && *str!=LF && *str!=FF)
291: i++; }
292: else
293: i++;
294: if(!(*str))
295: break;
296: str++; }
297: return(i);
298: }
299:
300: /****************************************************************************/
301: /* Outputs the string 'str' centered for an 80 column display */
302: /* Automatically appends "\r\n" to output */
303: /****************************************************************************/
304: void center(char *str)
305: {
306: int i,j;
307:
308: j=bstrlen(str);
309: for(i=0;i<(80-j)/2;i++)
310: outchar(SP);
311: bputs(str);
312: }
313:
314: /****************************************************************************/
315: /* Outputs one character to the screen. Handles, pause, saving and */
316: /* restoring lines, etc. */
317: /****************************************************************************/
318: void outchar(char ch)
319: {
320:
321: write(fileno(con_fp),&ch,1);
322:
323: if(ch==LF) {
324: lncntr++;
325: lbuflen=0;
326: tos=0; }
327: else if(ch==FF) {
328: if(lncntr>1) {
329: lncntr=0;
330: CRLF;
331: pause(); }
332: lncntr=0;
333: lbuflen=0;
334: tos=1; }
335: else if(ch==BS) {
336: if(lbuflen)
337: lbuflen--; }
338: else {
339: if(!lbuflen)
340: latr=curatr;
341: if(lbuflen>=LINE_BUFSIZE) lbuflen=0;
342: lbuf[lbuflen++]=ch; }
343: if(lncntr==user_rows-1) {
344: lncntr=0;
345: pause(); }
346: }
347:
348: /****************************************************************************/
349: /* Prints PAUSE message and waits for a key stoke */
350: /****************************************************************************/
351: void pause(void)
352: {
353: uchar tempattrs=curatr,*msg="\1_\1r\1h[Hit a key] ";
354: int i,j;
355:
356: lncntr=0;
357: bputs(msg);
358: j=bstrlen(msg);
359: getkey(0);
360: for(i=0;i<j;i++)
361: bputs("\b \b");
362: attr(tempattrs);
363: }
364:
365: /****************************************************************************/
366: /* Prompts user for Y or N (yes or no) and CR is interpreted as a Y */
367: /* Returns 1 for Y or 0 for N */
368: /* Called from quite a few places */
369: /****************************************************************************/
370: char yesno(char *str)
371: {
372: char ch;
373:
374: bprintf("\1_\1b\1h%s (Y/n) ? \1w",str);
375: while(1) {
376: ch=getkey(K_UPPER);
377: if(ch=='Y' || ch==CR) {
378: bputs("Yes\r\n");
379: return(1); }
380: if(ch=='N' || aborted) {
381: bputs("No\r\n");
382: return(0); } }
383: }
384:
385: /****************************************************************************/
386: /* Prompts user for N or Y (no or yes) and CR is interpreted as a N */
387: /* Returns 1 for N or 0 for Y */
388: /* Called from quite a few places */
389: /****************************************************************************/
390: char noyes(char *str)
391: {
392: char ch;
393:
394: bprintf("\1_\1b\1h%s (y/N) ? \1w",str);
395: while(1) {
396: ch=getkey(K_UPPER);
397: if(ch=='N' || ch==CR || aborted) {
398: bputs("No\r\n");
399: return(1); }
400: if(ch=='Y') {
401: bputs("Yes\r\n");
402: return(0); } }
403: }
404:
405: /****************************************************************************/
406: /* Outputs a string highlighting characters preceeded by a tilde with the */
407: /* color specified in mnehigh and the rest of the line is in color mnelow. */
408: /* If the user doesn't have ANSI, it puts the character following the tilde */
409: /* in parenthesis. */
410: /****************************************************************************/
411: void mnemonics(char *str)
412: {
413: long l;
414:
415: attr(mnelow);
416: l=0L;
417: while(str[l]) {
418: if(str[l]=='~' && str[l+1]) {
419: if(!(user_misc&ANSI))
420: outchar('(');
421: l++;
422: attr(mnehigh);
423: outchar(str[l]);
424: l++;
425: if(!(user_misc&ANSI))
426: outchar(')');
427: attr(mnelow); }
428: else
429: outchar(str[l++]); }
430: attr(LIGHTGRAY);
431: }
432:
433: /****************************************************************************/
434: /* If a key has been pressed, the ASCII code is returned. If not, 0 is */
435: /* returned. Ctrl-P and Ctrl-U are intercepted here. */
436: /****************************************************************************/
437: char inkey(int mode)
438: {
439: static in_ctrl_p;
440: uchar ch=0,hour,min,sec;
441: ushort tleft;
442: uint i;
443: time_t now;
444:
445: if(keybufbot!=keybuftop) {
446: ch=keybuf[keybufbot++];
447: if(keybufbot==KEY_BUFSIZE)
448: keybufbot=0; }
449: else if(_bios_keybrd(1)) {
450: i=_bios_keybrd(0);
451: if(i&0xff)
452: ch=i&0xff;
453: else { /* Local Alt or Function key hit */
454: i>>=8;
455: switch(i) {
456: case 0x47: /* Home - Same as Ctrl-B */
457: return(2); /* ctrl-b beginning of line */
458: case 0x4b: /* Left Arrow - same as ctrl-] */
459: return(0x1d);
460: case 0x4d: /* Right Arrow - same as ctrl-f */
461: return(6);
462: case 0x48: /* Up arrow - same as ctrl-^ */
463: return(0x1e);
464: case 0x50: /* Down arrow - same as CR */
465: return(CR);
466: case 0x4f: /* End - same as Ctrl-E */
467: return(5); /* ctrl-e - end of line */
468: case 0x52: /* Insert */
469: return(0x1f); /* ctrl-minus - insert mode */
470: case 0x53: /* Delete */
471: return(0x7f); /* ctrl-bkspc - del cur char */
472: }
473: return(0); } }
474:
475: if(ch==0x10 || ch==0x1e) { /* Ctrl-P or Ctrl-^ */
476: if(in_ctrl_p || !ctrl_dir[0]) /* keep from being recursive */
477: return(0);
478: in_ctrl_p=1;
479: SAVELINE;
480: CRLF;
481: nodemsg();
482: CRLF;
483: RESTORELINE;
484: lncntr=0;
485: in_ctrl_p=0;
486: return(0); }
487:
488: if(ch==20) { /* Ctrl-T Time left online */
489: SAVELINE;
490: attr(LIGHTGRAY);
491: now=time(NULL);
492: checktimeleft();
493: CRLF;
494: bprintf("\r\nStart : %.24s",ctime(&starttime));
495: bprintf("\r\nNow : %.24s",ctime(&now));
496: i=now-starttime;
497: hour=(i/60)/60;
498: min=(i/60)-(hour*60);
499: sec=i-((min+(hour*60))*60);
500: bprintf("\r\nTime Used : %02u:%02u:%02u",hour,min,sec);
501: tleft=timeleft-(now-starttime);
502: hour=(tleft/60)/60;
503: min=(tleft/60)-(hour*60);
504: sec=tleft-((min+(hour*60))*60);
505: bprintf("\r\nTime Left : %02u:%02u:%02u\r\n\r\n",hour,min,sec);
506: RESTORELINE;
507: lncntr=0;
508: return(0); }
509:
510: if(ch==21) { /* Ctrl-U Users online */
511: if(!ctrl_dir[0])
512: return(0);
513: SAVELINE;
514: CRLF;
515: whos_online(1);
516: CRLF;
517: RESTORELINE;
518: lncntr=0;
519: return(0); }
520:
521: if(ch==3)
522: aborted=1;
523: else if(aborted)
524: ch=3;
525:
526: if(!ch && (!(mode&K_GETSTR) || mode&K_LOWPRIO|| node_misc&NM_LOWPRIO))
527: mswait(0);
528: return(ch);
529: }
530:
531: /****************************************************************************/
532: /* Waits for remote or local user to hit a key. Inactivity timer is checked */
533: /* and hangs up if inactive for 4 minutes. Returns key hit, or uppercase of */
534: /* key hit if mode&K_UPPER or key out of KEY BUFFER. Does not print key. */
535: /****************************************************************************/
536: char getkey(int mode)
537: {
538: char ch,warn=0;
539: ushort tleft;
540: time_t timeout,now;
541:
542: aborted=lncntr=0;
543: timeout=time(NULL);
544: do {
545: checkline();
546: ch=inkey(mode);
547: now=time(NULL);
548: if(ch) {
549: if(mode&K_NUMBER && isprint(ch) && !isdigit(ch))
550: continue;
551: if(mode&K_ALPHA && isprint(ch) && !isalpha(ch))
552: continue;
553: if(ch==LF) continue;
554: if(mode&K_UPPER)
555: return(toupper(ch));
556: return(ch); }
557: checktimeleft();
558:
559: tleft=timeleft-(now-starttime);
560: if((tleft/60)<(5-timeleft_warn)) { /* Running out of time warning */
561: timeleft_warn=5-(tleft/60);
562: SAVELINE;
563: bprintf("&n&h\r\n\7\r\nYou only have &r&i%u&n&h minute%s "
564: "left.\r\n\r\n"
565: ,((ushort)tleft/60)+1,(tleft/60) ? "s" : "");
566: RESTORELINE; }
567:
568: if(now-timeout>=sec_warn && !warn) /* Inactivity warning */
569: for(warn=0;warn<5;warn++)
570: outchar(7);
571: } while(now-timeout<sec_timeout);
572: bputs("\r\nInactive too long.\r\n");
573: exit(0);
574: return(0); /* never gets here, but makes compiler happy */
575: }
576:
577: /****************************************************************************/
578: /* If remote user, checks DCD to see if user has hung up or not. */
579: /****************************************************************************/
580: void checkline(void)
581: {
582: if(com_port && !((*msr)&DCD)) exit(0);
583: }
584:
585: /****************************************************************************/
586: /* Waits for remote or local user to hit a key that is contained inside str.*/
587: /* 'str' should contain uppercase characters only. When a valid key is hit, */
588: /* it is echoed (upper case) and is the return value. */
589: /* If max is non-zero and a number is hit that is not in str, it will be */
590: /* returned with the high bit set. If the return of this function has the */
591: /* high bit set (&0x8000), just flip the bit (^0x8000) to get the number. */
592: /****************************************************************************/
593: int getkeys(char *str,int max)
594: {
595: uchar ch,n=0;
596: int i=0;
597:
598: strupr(str);
599: while(!aborted) {
600: ch=getkey(K_UPPER);
601: if(max && ch>0x7f) /* extended ascii chars are digits to isdigit() */
602: continue;
603: if(ch && !n && (strchr(str,ch))) { /* return character if in string */
604: outchar(ch);
605: attr(LIGHTGRAY);
606: CRLF;
607: return(ch); }
608: if(ch==CR && max) { /* return 0 if no number */
609: attr(LIGHTGRAY);
610: CRLF;
611: if(n)
612: return(i|0x8000); /* return number plus high bit */
613: return(0); }
614: if(ch==BS && n) {
615: bputs("\b \b");
616: i/=10;
617: n--; }
618: else if(max && isdigit(ch) && (i*10)+(ch&0xf)<=max && (ch!='0' || n)) {
619: i*=10;
620: n++;
621: i+=ch&0xf;
622: outchar(ch);
623: if(i*10>max) {
624: attr(LIGHTGRAY);
625: CRLF;
626: return(i|0x8000); } } }
627: return(0);
628: }
629:
630: /****************************************************************************/
631: /* Hot keyed number input routine. */
632: /****************************************************************************/
633: int getnum(int max)
634: {
635: uchar ch,n=0;
636: int i=0;
637:
638: while(1) {
639: ch=getkey(K_UPPER);
640: if(ch>0x7f)
641: continue;
642: if(ch=='Q') {
643: outchar('Q');
644: CRLF;
645: return(-1); }
646: else if(ch==3) { /* ctrl-c */
647: CRLF;
648: return(-1); }
649: else if(ch==CR) {
650: CRLF;
651: return(i); }
652: else if(ch==BS && n) {
653: bputs("\b \b");
654: i/=10;
655: n--; }
656: else if(isdigit(ch) && (i*10)+(ch&0xf)<=max && (ch!='0' || n)) {
657: i*=10;
658: n++;
659: i+=ch&0xf;
660: outchar(ch);
661: if(i*10>max) {
662: CRLF;
663: return(i); } } }
664: return(-1);
665: }
666:
667: /****************************************************************************/
668: /* Waits for remote or local user to input a CR terminated string. 'length' */
669: /* is the maximum number of characters that getstr will allow the user to */
670: /* input into the string. 'mode' specifies upper case characters are echoed */
671: /* or wordwrap or if in message input (^A sequences allowed). ^W backspaces */
672: /* a word, ^X backspaces a line, ^Gs, BSs, TABs are processed, LFs ignored. */
673: /* ^N non-destructive BS, ^V center line. Valid keys are echoed. */
674: /****************************************************************************/
675: int getstr(char *strout, int maxlen, int mode)
676: {
677: int i,l,x,z; /* i=current position, l=length, j=printed chars */
678: /* x&z=misc */
679: uchar ch,str1[256],str2[256],ins=0,atr;
680:
681: if(mode&K_LINE && user_misc&ANSI) {
682: attr(LIGHTGRAY|HIGH|(BLUE<<4)); /* white on blue */
683: for(i=0;i<maxlen;i++)
684: outchar(SP);
685: bprintf("\x1b[%dD",maxlen); }
686: i=l=0; /* i=total number of chars, j=number of printable chars */
687: if(wordwrap[0]) {
688: strcpy(str1,wordwrap);
689: wordwrap[0]=0; }
690: else str1[0]=0;
691: if(mode&K_EDIT)
692: strcat(str1,strout);
693: if(strlen(str1)>maxlen)
694: str1[maxlen]=0;
695: atr=curatr;
696: if(mode&K_AUTODEL && str1[0])
697: attr(BLUE|(LIGHTGRAY<<4));
698: rputs(str1);
699: if(mode&K_EDIT && !(mode&(K_LINE|K_AUTODEL)) && user_misc&ANSI)
700: bputs("\x1b[K"); /* destroy to eol */
701: i=l=strlen(str1);
702:
703: if(mode&K_AUTODEL && str1[0]) {
704: ch=getkey(mode);
705: attr(atr);
706: if(isprint(ch) || ch==0x7f) {
707: for(i=0;i<l;i++)
708: bputs("\b \b");
709: i=l=0; }
710: else {
711: for(i=0;i<l;i++)
712: outchar(BS);
713: rputs(str1);
714: i=l; }
715: if(ch!=SP && ch!=TAB)
716: ungetkey(ch); }
717:
718: while((ch=getkey(mode|K_GETSTR))!=CR && !aborted) {
719: switch(ch) {
720: case 1: /* Ctrl-A for ANSI */
721: if(!(mode&K_MSG) || i>maxlen-3)
722: break;
723: if(ins) {
724: if(l<maxlen)
725: l++;
726: for(x=l;x>i;x--)
727: str1[x]=str1[x-1];
728: rprintf("%.*s",l-i,str1+i);
729: rprintf("\x1b[%dD",l-i);
730: if(i==maxlen-1)
731: ins=0; }
732: outchar(str1[i++]=1);
733: break;
734: case 2: /* Ctrl-B Beginning of Line */
735: if(user_misc&ANSI && i) {
736: bprintf("\x1b[%dD",i);
737: i=0; }
738: break;
739: case 4: /* Ctrl-D Delete word right */
740: if(i<l) {
741: x=i;
742: while(x<l && str1[x]!=SP) {
743: outchar(SP);
744: x++; }
745: while(x<l && str1[x]==SP) {
746: outchar(SP);
747: x++; }
748: bprintf("\x1b[%dD",x-i); /* move cursor back */
749: z=i;
750: while(z<l-(x-i)) { /* move chars in string */
751: outchar(str1[z]=str1[z+(x-i)]);
752: z++; }
753: while(z<l) { /* write over extra chars */
754: outchar(SP);
755: z++; }
756: bprintf("\x1b[%dD",z-i);
757: l-=x-i; } /* l=new length */
758: break;
759: case 5: /* Ctrl-E End of line */
760: if(user_misc&ANSI && i<l) {
761: bprintf("\x1b[%dC",l-i); /* move cursor right one */
762: i=l; }
763: break;
764: case 6: /* Ctrl-F move cursor forewards */
765: if(i<l && (user_misc&ANSI)) {
766: bputs("\x1b[C"); /* move cursor right one */
767: i++; }
768: break;
769: case 7:
770: if(!(mode&K_MSG))
771: break;
772: if(ins) {
773: if(l<maxlen)
774: l++;
775: for(x=l;x>i;x--)
776: str1[x]=str1[x-1];
777: if(i==maxlen-1)
778: ins=0; }
779: if(i<maxlen) {
780: str1[i++]=7;
781: outchar(7); }
782: break;
783: case 14: /* Ctrl-N Next word */
784: if(i<l && (user_misc&ANSI)) {
785: x=i;
786: while(str1[i]!=SP && i<l)
787: i++;
788: while(str1[i]==SP && i<l)
789: i++;
790: bprintf("\x1b[%dC",i-x); }
791: break;
792: case 0x1c: /* Ctrl-\ Previous word */
793: if(i && (user_misc&ANSI)) {
794: x=i;
795: while(str1[i-1]==SP && i)
796: i--;
797: while(str1[i-1]!=SP && i)
798: i--;
799: bprintf("\x1b[%dD",x-i); }
800: break;
801: case 18: /* Ctrl-R Redraw Line */
802: redrwstr(str1,i,l,0);
803: break;
804: case TAB:
805: if(!(i%TABSIZE)) {
806: if(ins) {
807: if(l<maxlen)
808: l++;
809: for(x=l;x>i;x--)
810: str1[x]=str1[x-1];
811: if(i==maxlen-1)
812: ins=0; }
813: str1[i++]=SP;
814: outchar(SP); }
815: while(i<maxlen && i%TABSIZE) {
816: if(ins) {
817: if(l<maxlen)
818: l++;
819: for(x=l;x>i;x--)
820: str1[x]=str1[x-1];
821: if(i==maxlen-1)
822: ins=0; }
823: str1[i++]=SP;
824: outchar(SP); }
825: if(ins)
826: redrwstr(str1,i,l,0);
827: break;
828: case BS:
829: if(!i)
830: break;
831: i--;
832: l--;
833: if(i!=l) { /* Deleting char in middle of line */
834: outchar(BS);
835: z=i;
836: while(z<l) { /* move the characters in the line */
837: outchar(str1[z]=str1[z+1]);
838: z++; }
839: outchar(SP); /* write over the last char */
840: bprintf("\x1b[%dD",(l-i)+1); }
841: else
842: bputs("\b \b");
843: break;
844: case 22: /* Ctrl-V Center line */
845: str1[l]=0;
846: l=bstrlen(str1);
847: for(x=0;x<(maxlen-l)/2;x++)
848: str2[x]=SP;
849: str2[x]=0;
850: strcat(str2,str1);
851: strcpy(strout,str2);
852: l=strlen(strout);
853: if(mode&K_MSG)
854: redrwstr(strout,i,l,K_MSG);
855: else {
856: while(i--)
857: bputs("\b");
858: bputs(strout);
859: if(mode&K_LINE)
860: attr(LIGHTGRAY); }
861: CRLF;
862: return(l);
863: case 23: /* Ctrl-W Delete word left */
864: if(i<l) {
865: x=i; /* x=original offset */
866: while(i && str1[i-1]==SP) {
867: outchar(BS);
868: i--; }
869: while(i && str1[i-1]!=SP) {
870: outchar(BS);
871: i--; }
872: z=i; /* i=z=new offset */
873: while(z<l-(x-i)) { /* move chars in string */
874: outchar(str1[z]=str1[z+(x-i)]);
875: z++; }
876: while(z<l) { /* write over extra chars */
877: outchar(SP);
878: z++; }
879: bprintf("\x1b[%dD",z-i); /* back to new x corridnant */
880: l-=x-i; } /* l=new length */
881: else {
882: while(i && str1[i-1]==SP) {
883: i--;
884: l--;
885: bputs("\b \b"); }
886: while(i && str1[i-1]!=SP) {
887: i--;
888: l--;
889: bputs("\b \b"); } }
890: break;
891: case 24: /* Ctrl-X Delete entire line */
892: while(i<l) {
893: outchar(SP);
894: i++; }
895: while(l) {
896: l--;
897: bputs("\b \b"); }
898: i=0;
899: break;
900: case 25: /* Ctrl-Y Delete to end of line */
901: if(user_misc&ANSI) {
902: bputs("\x1b[s\x1b[K\x1b[u");
903: l=i; }
904: break;
905: case 31: /* Ctrl-Minus Toggles Insert/Overwrite */
906: if(!(user_misc&ANSI))
907: break;
908: if(ins) {
909: ins=0;
910: redrwstr(str1,i,l,0); }
911: else if(i<l) {
912: ins=1;
913: bprintf("\x1b[s\x1b[%dC",80-i); /* save pos */
914: z=curatr; /* and got to EOL */
915: attr(z|BLINK|HIGH);
916: outchar('�');
917: attr(z);
918: bputs("\x1b[u"); } /* restore pos */
919: break;
920: case 0x1d: /* Ctrl-] Reverse Cursor Movement */
921: if(i && (user_misc&ANSI)) {
922: bputs("\x1b[D"); /* move cursor left one */
923: i--; }
924: break;
925: case 0x7f: /* Ctrl-BkSpc (DEL) Delete current char */
926: if(i==l)
927: break;
928: l--;
929: z=i;
930: while(z<l) { /* move the characters in the line */
931: outchar(str1[z]=str1[z+1]);
932: z++; }
933: outchar(SP); /* write over the last char */
934: bprintf("\x1b[%dD",(l-i)+1);
935: break;
936: case ESC:
937: if(!(user_misc&ANSI))
938: break;
939: if((ch=getkey(0x8000))!='[') {
940: ungetch(ch);
941: break; }
942: if((ch=getkey(0x8000))=='C') {
943: if(i<l) {
944: bputs("\x1b[C"); /* move cursor right one */
945: i++; } }
946: else if(ch=='D') {
947: if(i) {
948: bputs("\x1b[D"); /* move cursor left one */
949: i--; } }
950: else {
951: while(isdigit(ch) || ch==';' || isalpha(ch)) {
952: if(isalpha(ch)) {
953: ch=getkey(0);
954: break; }
955: ch=getkey(0); }
956: ungetch(ch); }
957: break;
958: default:
959: if(mode&K_WRAP && i==maxlen && ch>=SP && !ins) {
960: str1[i]=0;
961: if(ch==SP) { /* don't wrap a space as last char */
962: strcpy(strout,str1);
963: if(stripattr(strout))
964: redrwstr(strout,i,l,K_MSG);
965: CRLF;
966: return(i); }
967: x=i-1;
968: z=1;
969: wordwrap[0]=ch;
970: while(str1[x]!=SP && x)
971: wordwrap[z++]=str1[x--];
972: if(x<(maxlen/2)) {
973: wordwrap[1]=0; /* only wrap one character */
974: strcpy(strout,str1);
975: if(stripattr(strout))
976: redrwstr(strout,i,l,K_MSG);
977: CRLF;
978: return(i); }
979: wordwrap[z]=0;
980: while(z--) {
981: i--;
982: bputs("\b \b"); }
983: strrev(wordwrap);
984: str1[x]=0;
985: strcpy(strout,str1);
986: if(stripattr(strout))
987: redrwstr(strout,i,x,mode);
988: CRLF;
989: return(x); }
990: if(i<maxlen && ch>=SP) {
991: if(mode&K_UPRLWR)
992: if(!i || (i && (str1[i-1]==SP || str1[i-1]=='-'
993: || str1[i-1]=='.' || str1[i-1]=='_')))
994: ch=toupper(ch);
995: else
996: ch=tolower(ch);
997: if(ins) {
998: if(l<maxlen) /* l<maxlen */
999: l++;
1000: for(x=l;x>i;x--)
1001: str1[x]=str1[x-1];
1002: rprintf("%.*s",l-i,str1+i);
1003: rprintf("\x1b[%dD",l-i);
1004: if(i==maxlen-1) {
1005: bputs(" \b\b");
1006: ins=0; } }
1007: str1[i++]=ch;
1008: outchar(ch); } }
1009: if(i>l)
1010: l=i;
1011: if(mode&K_CHAT && !l)
1012: return(0); }
1013: if(i>l)
1014: l=i;
1015: str1[l]=0;
1016: if(!aborted) {
1017: strcpy(strout,str1);
1018: if(stripattr(strout) || ins)
1019: redrwstr(strout,i,l,K_MSG); }
1020: else
1021: l=0;
1022: if(mode&K_LINE) attr(LIGHTGRAY);
1023: if(!(mode&K_NOCRLF)) {
1024: outchar(CR);
1025: if(!(mode&K_MSG && aborted))
1026: outchar(LF); }
1027: return(l);
1028: }
1029:
1030: /****************************************************************************/
1031: /* Redraws str using i as current cursor position and l as length */
1032: /****************************************************************************/
1033: void redrwstr(char *strin, int i, int l, char mode)
1034: {
1035: char str[256],c;
1036:
1037: sprintf(str,"%-*.*s",l,l,strin);
1038: c=i;
1039: while(c--)
1040: outchar(BS);
1041: if(mode&K_MSG)
1042: bputs(str);
1043: else
1044: rputs(str);
1045: if(user_misc&ANSI) {
1046: bputs("\x1b[K");
1047: if(i<l)
1048: bprintf("\x1b[%dD",l-i); }
1049: else {
1050: while(c<79) { /* clear to end of line */
1051: outchar(SP);
1052: c++; }
1053: while(c>l) { /* back space to end of string */
1054: outchar(BS);
1055: c--; } }
1056: }
1057:
1058: /****************************************************************************/
1059: /* Strips invalid Ctrl-Ax sequences from str */
1060: /* Returns number of ^A's in line */
1061: /****************************************************************************/
1062: char stripattr(char *strin)
1063: {
1064: uchar str[81];
1065: uchar a,c,d,e;
1066:
1067: e=strlen(strin);
1068: for(a=c=d=0;c<e;c++) {
1069: if(strin[c]==1) {
1070: a++;
1071: switch(toupper(strin[c+1])) {
1072: case '-': /* clear */
1073: case '_': /* clear */
1074: case 'B': /* blue fg */
1075: case 'C': /* cyan fg */
1076: case 'G': /* green fg */
1077: case 'H': /* high fg */
1078: case 'I': /* blink */
1079: case 'K': /* black fg */
1080: case 'L': /* cls */
1081: case 'M': /* magenta fg */
1082: case 'N': /* normal */
1083: case 'P': /* pause */
1084: case 'Q': /* pause reset */
1085: case 'R': /* red fg */
1086: case 'W': /* white fg */
1087: case 'Y': /* yellow fg */
1088: case '0': /* black bg */
1089: case '1': /* red bg */
1090: case '2': /* green bg */
1091: case '3': /* brown bg */
1092: case '4': /* blue bg */
1093: case '5': /* magenta bg */
1094: case '6': /* cyan bg */
1095: case '7': /* white bg */
1096: break;
1097: default:
1098: c++;
1099: continue; } }
1100: str[d++]=strin[c]; }
1101: str[d]=0;
1102: strcpy(strin,str);
1103: return(a);
1104: }
1105:
1106: /***************************************************************************/
1107: /* Changes local and remote text attributes accounting for monochrome */
1108: /***************************************************************************/
1109: void attr(char atr)
1110: {
1111:
1112: if(!(user_misc&ANSI) || aborted)
1113: return;
1114: if(!(user_misc&COLOR)) { /* eliminate colors if user doesn't have them */
1115: if(atr&LIGHTGRAY) /* if any bits set, set all */
1116: atr|=LIGHTGRAY;
1117: if(atr&(LIGHTGRAY<<4))
1118: atr|=(LIGHTGRAY<<4);
1119: if(atr&LIGHTGRAY && atr&(LIGHTGRAY<<4))
1120: atr&=~LIGHTGRAY; } /* if background is solid, forground is black */
1121: if(curatr==atr) /* attribute hasn't changed. don't send codes */
1122: return;
1123:
1124: if((!(atr&HIGH) && curatr&HIGH) || (!(atr&BLINK) && curatr&BLINK)
1125: || atr==LIGHTGRAY) {
1126: bprintf("\x1b[0m");
1127: curatr=LIGHTGRAY; }
1128:
1129: if(atr==LIGHTGRAY) { /* no attributes */
1130: curatr=atr;
1131: return; }
1132:
1133: if(atr&BLINK) { /* special attributes */
1134: if(!(curatr&BLINK))
1135: bprintf("\x1b[5m"); }
1136: if(atr&HIGH) {
1137: if(!(curatr&HIGH))
1138: bprintf("\x1b[1m"); }
1139:
1140: if((atr&0x7)==BLACK) { /* foreground colors */
1141: if((curatr&0x7)!=BLACK)
1142: bprintf("\x1b[30m"); }
1143: else if((atr&0x7)==RED) {
1144: if((curatr&0x7)!=RED)
1145: bprintf("\x1b[31m"); }
1146: else if((atr&0x7)==GREEN) {
1147: if((curatr&0x7)!=GREEN)
1148: bprintf("\x1b[32m"); }
1149: else if((atr&0x7)==BROWN) {
1150: if((curatr&0x7)!=BROWN)
1151: bprintf("\x1b[33m"); }
1152: else if((atr&0x7)==BLUE) {
1153: if((curatr&0x7)!=BLUE)
1154: bprintf("\x1b[34m"); }
1155: else if((atr&0x7)==MAGENTA) {
1156: if((curatr&0x7)!=MAGENTA)
1157: bprintf("\x1b[35m"); }
1158: else if((atr&0x7)==CYAN) {
1159: if((curatr&0x7)!=CYAN)
1160: bprintf("\x1b[36m"); }
1161: else if((atr&0x7)==LIGHTGRAY) {
1162: if((curatr&0x7)!=LIGHTGRAY)
1163: bprintf("\x1b[37m"); }
1164:
1165: if((atr&0x70)==(BLACK<<4)) { /* background colors */
1166: if((curatr&0x70)!=(BLACK<<4))
1167: bprintf("\x1b[40m"); }
1168: else if((atr&0x70)==(RED<<4)) {
1169: if((curatr&0x70)!=(RED<<4))
1170: bprintf("\x1b[41m"); }
1171: else if((atr&0x70)==(GREEN<<4)) {
1172: if((curatr&0x70)!=(GREEN<<4))
1173: bprintf("\x1b[42m"); }
1174: else if((atr&0x70)==(BROWN<<4)) {
1175: if((curatr&0x70)!=(BROWN<<4))
1176: bprintf("\x1b[43m"); }
1177: else if((atr&0x70)==(BLUE<<4)) {
1178: if((curatr&0x70)!=(BLUE<<4))
1179: bprintf("\x1b[44m"); }
1180: else if((atr&0x70)==(MAGENTA<<4)) {
1181: if((curatr&0x70)!=(MAGENTA<<4))
1182: bprintf("\x1b[45m"); }
1183: else if((atr&0x70)==(CYAN<<4)) {
1184: if((curatr&0x70)!=(CYAN<<4))
1185: bprintf("\x1b[46m"); }
1186: else if((atr&0x70)==(LIGHTGRAY<<4)) {
1187: if((curatr&0x70)!=(LIGHTGRAY<<4))
1188: bprintf("\x1b[47m"); }
1189:
1190: curatr=atr;
1191: }
1192:
1193: /****************************************************************************/
1194: /* Peform clear screen */
1195: /****************************************************************************/
1196: void cls(void)
1197: {
1198: int i;
1199:
1200: if(lncntr>1 && !tos) {
1201: lncntr=0;
1202: CRLF;
1203: pause();
1204: while(lncntr && !aborted)
1205: pause(); }
1206:
1207: if(user_misc&ANSI)
1208: bprintf("\x1b[2J");
1209: else {
1210: outchar(FF);
1211: clrscr(); }
1212: tos=1;
1213: lncntr=0;
1214: }
1215:
1216: #ifdef __WATCOMC__
1217:
1218: short wherey(void)
1219: {
1220: struct rccoord rc;
1221:
1222: rc=_gettextposition();
1223: return(rc.col);
1224: }
1225:
1226: void clrscr(void)
1227: {
1228: _clearscreen(_GCLEARSCREEN);
1229: }
1230:
1231: #endif
1232:
1233: /****************************************************************************/
1234: /* performs the correct attribute modifications for the Ctrl-A code */
1235: /****************************************************************************/
1236: void ctrl_a(char x)
1237: {
1238: char atr=curatr;
1239: int i,j;
1240:
1241: if((uchar)x>=0x7f) {
1242: if(user_misc&ANSI)
1243: bprintf("\x1b[%uC",(uchar)x-0x7f);
1244: else
1245: for(i=0;i<(uchar)x-0x7f;i++)
1246: outchar(SP);
1247: return; }
1248:
1249: switch(toupper(x)) {
1250: case '-': /* turn off all attributes if */
1251: if(atr&(HIGH|BLINK|(LIGHTGRAY<<4))) /* high intensity, blink or */
1252: attr(LIGHTGRAY); /* background bits are set */
1253: break;
1254: case '_': /* turn off all attributes if */
1255: if(atr&(BLINK|(LIGHTGRAY<<4))) /* blink or background is set */
1256: attr(LIGHTGRAY);
1257: break;
1258: case ',': /* Delay 1/10 sec */
1259: mswait(100);
1260: break;
1261: case ';': /* Delay 1/2 sec */
1262: mswait(500);
1263: break;
1264: case '.': /* Delay 2 secs */
1265: mswait(2000);
1266: break;
1267: case 'P': /* Pause */
1268: pause();
1269: break;
1270: case 'Q': /* Pause reset */
1271: lncntr=0;
1272: break;
1273: case 'L': /* CLS (form feed) */
1274: cls();
1275: break;
1276: case '>': /* CLREOL */
1277: if(user_misc&ANSI)
1278: bputs("\x1b[K");
1279: else {
1280: i=j=wherey();
1281: while(i++<80)
1282: outchar(SP);
1283: while(j++<80)
1284: outchar(BS); }
1285: break;
1286: case '<': /* Non-destructive backspace */
1287: outchar(BS);
1288: break;
1289: case '[': /* Carriage return */
1290: outchar(CR);
1291: break;
1292: case ']': /* Line feed */
1293: outchar(LF);
1294: break;
1295: case 'A': /* Ctrl-A */
1296: outchar(1);
1297: break;
1298: case 'H': /* High intensity */
1299: atr|=HIGH;
1300: attr(atr);
1301: break;
1302: case 'I': /* Blink */
1303: atr|=BLINK;
1304: attr(atr);
1305: break;
1306: case 'N': /* Normal */
1307: attr(LIGHTGRAY);
1308: break;
1309: case 'R':
1310: atr=(atr&0xf8)|RED;
1311: attr(atr);
1312: break;
1313: case 'S':
1314: nodesync();
1315: break;
1316: case 'G':
1317: atr=(atr&0xf8)|GREEN;
1318: attr(atr);
1319: break;
1320: case 'B':
1321: atr=(atr&0xf8)|BLUE;
1322: attr(atr);
1323: break;
1324: case 'W': /* White */
1325: atr=(atr&0xf8)|LIGHTGRAY;
1326: attr(atr);
1327: break;
1328: case 'C':
1329: atr=(atr&0xf8)|CYAN;
1330: attr(atr);
1331: break;
1332: case 'M':
1333: atr=(atr&0xf8)|MAGENTA;
1334: attr(atr);
1335: break;
1336: case 'Y':
1337: atr=(atr&0xf8)|BROWN;
1338: attr(atr);
1339: break;
1340: case 'K': /* Black */
1341: atr=(atr&0xf8)|BLACK;
1342: attr(atr);
1343: break;
1344: case '0': /* Black Background */
1345: atr=(atr&0x8f)|(BLACK<<4);
1346: attr(atr);
1347: break;
1348: case '1': /* Red Background */
1349: atr=(atr&0x8f)|(RED<<4);
1350: attr(atr);
1351: break;
1352: case '2': /* Green Background */
1353: atr=(atr&0x8f)|(GREEN<<4);
1354: attr(atr);
1355: break;
1356: case '3': /* Yellow Background */
1357: atr=(atr&0x8f)|(BROWN<<4);
1358: attr(atr);
1359: break;
1360: case '4': /* Blue Background */
1361: atr=(atr&0x8f)|(BLUE<<4);
1362: attr(atr);
1363: break;
1364: case '5': /* Magenta Background */
1365: atr=(atr&0x8f)|(MAGENTA<<4);
1366: attr(atr);
1367: break;
1368: case '6': /* Cyan Background */
1369: atr=(atr&0x8f)|(CYAN<<4);
1370: attr(atr);
1371: break;
1372: case '7': /* White Background */
1373: atr=(atr&0x8f)|(LIGHTGRAY<<4);
1374: attr(atr);
1375: break; }
1376: }
1377:
1378: /****************************************************************************/
1379: /* Network open function. Opens all files DENYALL and retries LOOP_NOPEN */
1380: /* number of times if the attempted file is already open or denying access */
1381: /* for some other reason. All files are opened in BINARY mode. */
1382: /****************************************************************************/
1383: int nopen(char *str, int access)
1384: {
1385: char count=0;
1386: int file,share;
1387:
1388: if(access&SH_DENYNO) share=SH_DENYNO;
1389: else if(access==O_RDONLY) share=SH_DENYWR;
1390: else share=SH_DENYRW;
1391: while(((file=sopen(str,O_BINARY|access,share,S_IWRITE))==-1)
1392: && errno==EACCES && count++<LOOP_NOPEN)
1393: if(count>10)
1394: mswait(50);
1395: if(count>(LOOP_NOPEN/2) && count<=LOOP_NOPEN)
1396: bprintf("\r\nNOPEN COLLISION - File: %s Count: %d\r\n"
1397: ,str,count);
1398: if(file==-1 && errno==EACCES)
1399: bputs("\7\r\nNOPEN: ACCESS DENIED\r\n\7");
1400: return(file);
1401: }
1402:
1403: /****************************************************************************/
1404: /* Reads data from XTRN.DAT in the node directory and fills the appropriate */
1405: /* global variables. */
1406: /* Initializes starttime variable with current time. */
1407: /****************************************************************************/
1408: void initdata(void)
1409: {
1410: char str[256],tmp[256];
1411: int i;
1412: FILE *stream;
1413:
1414: #if defined(__TURBOC__) || defined(__SC__) /* Borland or Symantec */
1415: ctrlbrk(cbreakh);
1416: #endif
1417:
1418: #ifdef __WATCOMC__
1419: putenv("TZ=UCT0");
1420: setvbuf(stdout,NULL,_IONBF,0);
1421: setvbuf(stderr,NULL,_IONBF,0);
1422: #endif
1423:
1424: #ifdef __SC__
1425: setvbuf(stdout,NULL,_IONBF,0);
1426: con_fp=stdout;
1427: #else
1428: con_fp=stderr;
1429: #endif
1430:
1431: if(setmode(fileno(con_fp),O_BINARY)==-1) { /* eliminate LF expansion */
1432: printf("Can't set console output to BINARY\n");
1433: exit(1); }
1434:
1435: sprintf(str,"%sXTRN.DAT",node_dir);
1436: if((stream=fopen(str,"rt"))==NULL) {
1437: printf("Can't open %s\r\n",str);
1438: exit(1); }
1439: fgets(str,81,stream); /* username */
1440: sprintf(user_name,"%.25s",str);
1441: truncsp(user_name);
1442: fgets(str,81,stream); /* system name */
1443: sprintf(sys_name,"%.40s",str);
1444: truncsp(sys_name);
1445: fgets(str,81,stream); /* system operator */
1446: sprintf(sys_op,"%.40s",str);
1447: truncsp(sys_op);
1448: fgets(str,81,stream); /* system guru */
1449: sprintf(sys_guru,"%.40s",str);
1450: truncsp(sys_guru);
1451:
1452: fgets(str,81,stream); /* ctrl dir */
1453: str[50]=0;
1454: if(str[0]=='.')
1455: sprintf(ctrl_dir,"%s%s",node_dir,str);
1456: else
1457: strcpy(ctrl_dir,str);
1458: truncsp(ctrl_dir);
1459: if(_fullpath(str,ctrl_dir,50))
1460: strcpy(ctrl_dir,str);
1461: backslash(ctrl_dir);
1462:
1463: fgets(str,81,stream); /* data dir */
1464: if(str[0]=='.')
1465: sprintf(data_dir,"%s%s",node_dir,str);
1466: else
1467: sprintf(data_dir,"%.40s",str);
1468: truncsp(data_dir);
1469: if(_fullpath(str,data_dir,50))
1470: strcpy(data_dir,str);
1471: backslash(data_dir);
1472:
1473: fgets(str,81,stream); /* total nodes */
1474: sys_nodes=atoi(str);
1475: fgets(str,81,stream); /* current node */
1476: node_num=atoi(str);
1477: fgets(str,81,stream); /* time left */
1478: timeleft=atoi(str);
1479: fgets(str,81,stream); /* ANSI? (Yes, Mono, or No) */
1480: user_misc=0;
1481: if(str[0]=='Y')
1482: user_misc|=(ANSI|COLOR);
1483: else if(str[0]=='M')
1484: user_misc|=ANSI;
1485: fgets(str,81,stream); /* screen lines */
1486: user_rows=atoi(str);
1487: fgets(str,81,stream); /* credits */
1488: user_cdt=atol(str);
1489: fgets(str,81,stream); /* level */
1490: user_level=atoi(str);
1491: fgets(str,81,stream); /* was transfer level, left for compat. */
1492: fgets(str,81,stream); /* birthdate */
1493: truncsp(str);
1494: sprintf(user_birth,"%.8s",str);
1495: fgets(str,81,stream); /* sex */
1496: user_sex=str[0];
1497: fgets(str,81,stream); /* user number */
1498: user_number=atoi(str);
1499: fgets(str,81,stream); /* user phone number */
1500: sprintf(user_phone,"%.12s",str);
1501: truncsp(user_phone);
1502: fgets(str,81,stream); /* com port (0 if local or no modem) */
1503: com_port=atoi(str);
1504: fgets(str,81,stream); /* com (UART) irq */
1505: com_irq=atoi(str);
1506: fgets(str,81,stream); /* com (UART) base address in hex */
1507: truncsp(str);
1508: com_base=(uint)ahtoul(str);
1509: fgets(str,81,stream); /* com rate */
1510: com_rate=(ulong)atol(str);
1511: fgets(str,81,stream); /* hardware flow control (Y/N) */
1512: if(toupper(str[0])=='Y')
1513: mdm_misc|=MDM_FLOWCTRL;
1514: fgets(str,81,stream); /* locked DTE rate (Y/N) */
1515: if(toupper(str[0])=='Y')
1516: mdm_misc|=MDM_STAYHIGH;
1517: fgets(str,81,stream); /* modem initialization string */
1518: sprintf(mdm_init,"%.63s",str);
1519: truncsp(mdm_init);
1520: fgets(str,81,stream); /* modem special init string */
1521: sprintf(mdm_spec,"%.63s",str);
1522: truncsp(mdm_spec);
1523: fgets(str,81,stream); /* modem terminal mode string */
1524: sprintf(mdm_term,"%.63s",str);
1525: truncsp(mdm_term);
1526: fgets(str,81,stream); /* modem dial string */
1527: sprintf(mdm_dial,"%.63s",str);
1528: truncsp(mdm_dial);
1529: fgets(str,81,stream); /* modem off-hook string */
1530: sprintf(mdm_offh,"%.63s",str);
1531: truncsp(mdm_offh);
1532: fgets(str,81,stream); /* modem answer string */
1533: sprintf(mdm_answ,"%.63s",str);
1534: truncsp(mdm_answ);
1535: fgets(str,81,stream); /* memory address of modem status register */
1536: msr=(uint far *)atol(str);
1537: if(!fgets(str,81,stream)) /* total number of external programs */
1538: total_xtrns=0;
1539: else
1540: total_xtrns=atoi(str);
1541: if(total_xtrns && (xtrn=(char **)MALLOC(sizeof(char *)*total_xtrns))==NULL) {
1542: printf("Allocation error 1: %u\r\n",sizeof(char *)*total_xtrns);
1543: exit(1); }
1544: for(i=0;i<total_xtrns;i++) {
1545: fgets(str,81,stream);
1546: truncsp(str);
1547: if((xtrn[i]=(char *)MALLOC(strlen(str)+1))==NULL) {
1548: printf("Allocation error 2 (%u): %u\r\n",i,strlen(str)+1);
1549: exit(1); }
1550: strcpy(xtrn[i],str); }
1551: fgets(str,81,stream); /* user's main flags */
1552: sprintf(user_flags1,"%.26s",str);
1553: fgets(str,81,stream); /* user's xfer flags */
1554: sprintf(user_flags2,"%.26s",str);
1555: fgets(str,81,stream); /* user's exemptions */
1556: sprintf(user_exempt,"%.26s",str);
1557: fgets(str,81,stream); /* user's restrictions */
1558: sprintf(user_rest,"%.26s",str);
1559: fgets(str,81,stream); /* user's expiration date */
1560: truncsp(str);
1561: user_expire=ahtoul(str);
1562: str[0]=0;
1563: fgets(str,81,stream); /* user's address */
1564: sprintf(user_address,"%.30s",str);
1565: truncsp(user_address);
1566: fgets(str,81,stream); /* user's location (city, state) */
1567: sprintf(user_location,"%.30s",str);
1568: truncsp(user_location);
1569: fgets(str,81,stream); /* user's zip/postal code */
1570: sprintf(user_zipcode,"%.10s",str);
1571: truncsp(user_zipcode);
1572: str[0]=0;
1573: fgets(str,81,stream);
1574: sprintf(user_flags3,"%.26s",str);
1575: fgets(str,81,stream);
1576: sprintf(user_flags4,"%.26s",str);
1577: if(fgets(str,81,stream)) /* Time-slice API type */
1578: mswtyp=ahtoul(str);
1579: str[0]=0;
1580: fgets(str,81,stream);
1581: truncsp(str);
1582: sprintf(user_realname,"%.25s",str);
1583: str[0]=0;
1584: fgets(str,81,stream);
1585: user_dce=atol(str);
1586:
1587: str[0]=0;
1588: fgets(str,81,stream); /* exec dir */
1589: if(!str[0])
1590: sprintf(exec_dir,"%s..\\EXEC\\",ctrl_dir);
1591: else {
1592: if(str[0]=='.')
1593: sprintf(exec_dir,"%s%s",node_dir,str);
1594: else
1595: sprintf(exec_dir,"%.50s",str); }
1596: truncsp(exec_dir);
1597: if(_fullpath(str,exec_dir,50))
1598: strcpy(exec_dir,str);
1599: backslash(exec_dir);
1600:
1601: str[0]=0;
1602: fgets(str,81,stream); /* text dir */
1603: if(!str[0])
1604: sprintf(text_dir,"%s..\\TEXT\\",ctrl_dir);
1605: else {
1606: if(str[0]=='.')
1607: sprintf(text_dir,"%s%s",node_dir,str);
1608: else
1609: sprintf(text_dir,"%.50s",str); }
1610: truncsp(text_dir);
1611: if(_fullpath(str,text_dir,50))
1612: strcpy(text_dir,str);
1613: backslash(text_dir);
1614:
1615: str[0]=0;
1616: fgets(str,81,stream); /* temp dir */
1617: if(!str[0])
1618: sprintf(temp_dir,"%sTEMP\\",node_dir);
1619: else {
1620: if(str[0]!='\\' && str[1]!=':')
1621: sprintf(temp_dir,"%s%s",node_dir,str);
1622: else
1623: sprintf(temp_dir,"%.50s",str); }
1624: truncsp(temp_dir);
1625: if(_fullpath(str,temp_dir,50))
1626: strcpy(temp_dir,str);
1627: backslash(temp_dir);
1628:
1629: str[0]=0;
1630: fgets(str,81,stream);
1631: sprintf(sys_id,"%.8s",str);
1632:
1633: str[0]=0;
1634: fgets(str,81,stream);
1635: truncsp(str);
1636: if(str[0])
1637: node_misc=(uint)ahtoul(str);
1638: else
1639: node_misc=NM_LOWPRIO;
1640:
1641: fclose(stream);
1642:
1643: sprintf(str,"%sINTRSBBS.DAT",node_dir); /* Shrank to run! */
1644: if(fexist(str)) {
1645: if((stream=fopen(str,"rt"))==NULL) {
1646: printf("Can't open %s\n",str);
1647: exit(1); }
1648: fgets(tmp,81,stream); /* so get MSR address from file */
1649: msr=(uint far *)atol(tmp);
1650: fclose(stream);
1651: remove(str); }
1652:
1653: starttime=time(NULL); /* initialize start time stamp */
1654: wordwrap[0]=0; /* set wordwrap to null */
1655: attr(LIGHTGRAY); /* initialize color and curatr to plain */
1656: mnehigh=LIGHTGRAY|HIGH; /* mnemonics highlight color */
1657: mnelow=GREEN; /* mnemonics normal text color */
1658: sec_warn=180; /* seconds till inactivity warning */
1659: sec_timeout=300; /* seconds till inactivity timeout */
1660: tos=lncntr=0; /* init topofscreen and linecounter to 0 */
1661: lastnodemsg=0; /* Last node to send message to */
1662: aborted=0; /* Ctrl-C hit flag */
1663: sysop_level=90; /* Minimum level to be considered sysop */
1664: timeleft_warn=0; /* Running out of time warning */
1665:
1666: sprintf(str,"%s%s",ctrl_dir,"NODE.DAB");
1667: if((nodefile=sopen(str,O_BINARY|O_RDWR,SH_DENYNO))==-1) {
1668: bprintf("\r\n\7Error opening %s\r\n",str);
1669: exit(1); }
1670:
1671: sprintf(str,"%sUSER\\NAME.DAT",data_dir);
1672: if((i=nopen(str,O_RDONLY))==-1) {
1673: printf("\r\n\7Error opening %s\r\n",str);
1674: exit(1); }
1675: memset(str,0,30);
1676: read(i,str,26);
1677: close(i);
1678: if(str[25]==CR) /* Version 1b */
1679: name_len=25;
1680: else /* Version 1a */
1681: name_len=30;
1682: }
1683:
1684: /****************************************************************************/
1685: /* Automatic RIP & WIP terminal detection function. Sets RIP and WIP bits */
1686: /* in user_misc variable. Must be called AFTER initdat(), not before. */
1687: /****************************************************************************/
1688: void get_term(void)
1689: {
1690: char str[128],ch;
1691: int i;
1692:
1693: bputs("\r\x1b[!_\x1b[0t_\r \r");
1694: mswait(500);
1695: for(i=0;i<120;i++) {
1696: ch=inkey(0);
1697: if(!ch)
1698: break;
1699: mswait(1);
1700: str[i]=ch; }
1701: str[i]=0;
1702: if(strstr(str,"RIPSCRIP"))
1703: user_misc|=RIP;
1704: if(strstr(str,"DC-TERM"))
1705: user_misc|=WIP;
1706: }
1707:
1708: /****************************************************************************/
1709: /* Truncates white-space chars off end of 'str' and terminates at first tab */
1710: /****************************************************************************/
1711: void truncsp(uchar *str)
1712: {
1713: char c;
1714:
1715: str[strcspn(str,"\t")]=0;
1716: c=strlen(str);
1717: while(c && (uchar)str[c-1]<=SP) c--;
1718: str[c]=0;
1719: }
1720:
1721: /****************************************************************************/
1722: /* Puts a backslash on path strings */
1723: /****************************************************************************/
1724: void backslash(char *str)
1725: {
1726: int i;
1727:
1728: i=strlen(str);
1729: if(i && str[i-1]!='\\') {
1730: str[i]='\\'; str[i+1]=0; }
1731: }
1732:
1733:
1734: /****************************************************************************/
1735: /* Checks the amount of time inside the external program against the amount */
1736: /* of time the user had left online before running the external program and */
1737: /* prints a message and exits the program if time has run out. */
1738: /****************************************************************************/
1739: void checktimeleft(void)
1740: {
1741: if(!SYSOP && !strchr(user_exempt,'T') && time(NULL)-starttime>timeleft) {
1742: bputs("\1_\n\1r\1hTime's up.\n");
1743: exit(0); }
1744: }
1745:
1746: /****************************************************************************/
1747: /* Prints a file remotely and locally, interpreting ^A sequences. */
1748: /* 'str' is the path of the file to print */
1749: /****************************************************************************/
1750: void printfile(char *str)
1751: {
1752: char *buf;
1753: int file;
1754: ulong length;
1755:
1756: strupr(str);
1757: if(!tos)
1758: CRLF;
1759: if((file=nopen(str,O_RDONLY))==-1) {
1760: bprintf("File not Found: %s\r\n",str);
1761: return; }
1762: length=filelength(file);
1763: if((buf=MALLOC(length+1L))==NULL) {
1764: close(file);
1765: bprintf("\7\r\nPRINTFILE: Error allocating %lu bytes of memory for %s.\r\n"
1766: ,length+1L,str);
1767: return; }
1768: buf[read(file,buf,length)]=0;
1769: close(file);
1770: bputs(buf);
1771: aborted=0;
1772: FREE(buf);
1773: }
1774:
1775: /****************************************************************************/
1776: /* Returns a char pointer to the name of the user that corresponds to */
1777: /* usernumber. Takes value directly from database. */
1778: /****************************************************************************/
1779: char *username(uint usernumber)
1780: {
1781: static char name[26];
1782: char str[128];
1783: int i,file;
1784:
1785: strcpy(name,"UNKNOWN USER");
1786: if(!data_dir[0])
1787: return(name);
1788: if(!usernumber) {
1789: bputs("\7username: called with zero usernumber\r\n");
1790: return(name); }
1791: sprintf(str,"%sUSER\\NAME.DAT",data_dir);
1792: if((file=nopen(str,O_RDONLY))==-1) {
1793: bprintf("\7username: couldn't open %s\r\n",str);
1794: return(name); }
1795: if(filelength(file)<(long)(usernumber-1)*((long)name_len+2L)) {
1796: close(file);
1797: return(name); }
1798: lseek(file,(long)(usernumber-1)*((long)name_len+2L),SEEK_SET);
1799: read(file,name,25);
1800: close(file);
1801: for(i=0;i<25;i++)
1802: if(name[i]==3)
1803: break;
1804: name[i]=0;
1805: if(!name[0])
1806: strcpy(name,"DELETED USER");
1807: return(name);
1808: }
1809:
1810: /****************************************************************************/
1811: /* Returns the number of the user 'username' from the NAME.DAT file. */
1812: /* If the username is not found, the function returns 0. */
1813: /****************************************************************************/
1814: uint usernumber(char *username)
1815: {
1816: char str[128];
1817: int i,file;
1818: FILE *stream;
1819:
1820: if(!data_dir[0])
1821: return(0);
1822: sprintf(str,"%sUSER\\NAME.DAT",data_dir);
1823: if((file=nopen(str,O_RDONLY))==-1 || (stream=fdopen(file,"rb"))==NULL) {
1824: if(file!=-1)
1825: close(file);
1826: bprintf("\7usernumber: couldn't open %s\r\n",str);
1827: return(0); }
1828: for(i=1;!feof(stream);i++) {
1829: if(!fread(str,27,1,stream))
1830: break;
1831: str[25]=0;
1832: truncsp(str); /* chop of trailing EOTs and spaces */
1833: if(!stricmp(str,username)) {
1834: fclose(stream);
1835: return(i); } }
1836: fclose(stream);
1837: return(0);
1838: }
1839:
1840:
1841: /****************************************************************************/
1842: /* Checks the disk drive for the existance of a file. Returns 1 if it */
1843: /* exists, 0 if it doesn't. */
1844: /* Called from upload */
1845: /****************************************************************************/
1846: char fexist(char *filespec)
1847: {
1848: #ifdef __SC__ /* Symantec */
1849: if(findfirst(filespec,0)==NULL)
1850: return(0);
1851: return(1);
1852: #else /* Not Symantec */
1853: struct ffblk f;
1854:
1855: if(findfirst(filespec,&f,0)==NULL)
1856: return(1);
1857: return(0);
1858: #endif /* !__SC__ */
1859: }
1860:
1861: /****************************************************************************/
1862: /* Returns the length of the first file found that matches 'filespec' */
1863: /* -1 if the file doesn't exist. */
1864: /****************************************************************************/
1865: long flength(char *filespec)
1866: {
1867: #ifdef __SC__ /* Symantec */
1868: struct FILE *f;
1869:
1870: if((f=findfirst(filespec,0))==NULL)
1871: return(-1);
1872: return(f->size);
1873:
1874: #else /* Not Symantec */
1875:
1876: struct ffblk f;
1877:
1878: if(findfirst(filespec,&f,0)==NULL)
1879: #ifdef __TURBOC__ /* Borland */
1880: return(f.ff_fsize);
1881: #else /* Other (Watcom) */
1882: return(f.size);
1883: #endif
1884: return(-1L);
1885: #endif /* !__SC__ */
1886: }
1887:
1888: /****************************************************************************/
1889: /* Returns in 'string' a character representation of the number in l with */
1890: /* commas. Maximum value of l is 4 gigabytes. */
1891: /****************************************************************************/
1892: char *ultoac(ulong l, char *string)
1893: {
1894: char str[81];
1895: char i,j,k;
1896:
1897: ultoa(l,str,10);
1898: i=strlen(str)-1;
1899: j=i/3+1+i;
1900: string[j--]=0;
1901: for(k=1;i>-1;k++) {
1902: string[j--]=str[i--];
1903: if(j>0 && !(k%3))
1904: string[j--]=','; }
1905: return(string);
1906: }
1907:
1908: /****************************************************************************/
1909: /* Converts an ASCII Hex string into a ulong */
1910: /****************************************************************************/
1911: ulong ahtoul(char *str)
1912: {
1913: ulong l,val=0;
1914:
1915: while((l=(*str++)|0x20)!=0x20)
1916: val=(l&0xf)+(l>>6&1)*9+val*16;
1917: return(val);
1918: }
1919:
1920: /****************************************************************************/
1921: /* Reads the data for node number 'number' into the structure 'node' */
1922: /* from NODE.DAB */
1923: /* if lockit is non-zero, locks this node's record. putnodedat() unlocks it */
1924: /****************************************************************************/
1925: void getnodedat(uchar number, node_t *node, char lockit)
1926: {
1927: char str[256];
1928: int count=0;
1929:
1930: if(nodefile<0)
1931: return;
1932: number--; /* make zero based */
1933: while(count<LOOP_NODEDAB) {
1934: lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
1935: if(lockit
1936: && lock(nodefile,(long)number*sizeof(node_t),sizeof(node_t))==-1) {
1937: count++;
1938: continue; }
1939: if(read(nodefile,node,sizeof(node_t))==sizeof(node_t))
1940: break;
1941: count++; }
1942: if(count==LOOP_NODEDAB)
1943: bprintf("\7Error unlocking and reading NODE.DAB\r\n");
1944: }
1945:
1946: /****************************************************************************/
1947: /* Write the data from the structure 'node' into NODE.DAB */
1948: /* getnodedat(num,&node,1); must have been called before calling this func */
1949: /* NOTE: ------^ the indicates the node record has been locked */
1950: /****************************************************************************/
1951: void putnodedat(uchar number, node_t node)
1952: {
1953: char str[256];
1954: int count;
1955:
1956: if(nodefile<0)
1957: return;
1958: number--; /* make zero based */
1959: lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
1960: if(write(nodefile,&node,sizeof(node_t))!=sizeof(node_t)) {
1961: unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
1962: bprintf("\7Error writing NODE.DAB for node %u\r\n",number+1);
1963: return; }
1964: unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
1965: }
1966:
1967: /****************************************************************************/
1968: /* Checks for messages waiting for this node or interruption. */
1969: /****************************************************************************/
1970: void nodesync(void)
1971: {
1972: node_t node;
1973:
1974: if(!ctrl_dir[0])
1975: return;
1976: getnodedat(node_num,&node,0);
1977:
1978: if(node.misc&NODE_MSGW)
1979: getsmsg(user_number); /* getsmsg clears MSGW flag */
1980:
1981: if(node.misc&NODE_NMSG) /* getnmsg clears NMSG flag */
1982: getnmsg();
1983:
1984: if(node.misc&NODE_INTR)
1985: exit(0);
1986:
1987: }
1988:
1989: /****************************************************************************/
1990: /* Displays the information for node number 'number' contained in 'node' */
1991: /****************************************************************************/
1992: void printnodedat(uchar number, node_t node)
1993: {
1994: char hour,mer[3],tmp[256];
1995: int i;
1996:
1997: attr(LIGHTGRAY|HIGH);
1998: bprintf("Node %2d: ",number);
1999: attr(GREEN);
2000: switch(node.status) {
2001: case NODE_WFC:
2002: bputs("Waiting for call");
2003: break;
2004: case NODE_OFFLINE:
2005: bputs("Offline");
2006: break;
2007: case NODE_NETTING:
2008: bputs("Networking");
2009: break;
2010: case NODE_LOGON:
2011: bputs("At logon prompt");
2012: break;
2013: case NODE_EVENT_WAITING:
2014: bputs("Waiting for all nodes to become inactive");
2015: break;
2016: case NODE_EVENT_LIMBO:
2017: bprintf("Waiting for node %d to finish external event",node.aux);
2018: break;
2019: case NODE_EVENT_RUNNING:
2020: bputs("Running external event");
2021: break;
2022: case NODE_NEWUSER:
2023: attr(GREEN|HIGH);
2024: bputs("New user");
2025: attr(GREEN);
2026: bputs(" applying for access ");
2027: if(!node.connection)
2028: bputs("Locally");
2029: else
2030: bprintf("at %ubps",node.connection);
2031: break;
2032: case NODE_QUIET:
2033: if(!SYSOP) {
2034: bputs("Waiting for call");
2035: break; }
2036: case NODE_INUSE:
2037: attr(GREEN|HIGH);
2038: if(node.misc&NODE_ANON && !SYSOP)
2039: bputs("UNKNOWN USER");
2040: else
2041: bputs(username(node.useron));
2042: attr(GREEN);
2043: bputs(" ");
2044: switch(node.action) {
2045: case NODE_MAIN:
2046: bputs("at main menu");
2047: break;
2048: case NODE_RMSG:
2049: bputs("reading messages");
2050: break;
2051: case NODE_RMAL:
2052: bputs("reading mail");
2053: break;
2054: case NODE_RSML:
2055: bputs("reading sent mail");
2056: break;
2057: case NODE_RTXT:
2058: bputs("reading text files");
2059: break;
2060: case NODE_PMSG:
2061: bputs("posting message");
2062: break;
2063: case NODE_SMAL:
2064: bputs("sending mail");
2065: break;
2066: case NODE_AMSG:
2067: bputs("posting auto-message");
2068: break;
2069: case NODE_XTRN:
2070: if(!node.aux)
2071: bputs("at external program menu");
2072: else {
2073: bputs("running ");
2074: i=node.aux-1;
2075: if(i>=total_xtrns || !xtrn[i][0])
2076: bputs("external program");
2077: else
2078: bputs(xtrn[i]); }
2079: break;
2080: case NODE_DFLT:
2081: bputs("changing defaults");
2082: break;
2083: case NODE_XFER:
2084: bputs("at transfer menu");
2085: break;
2086: case NODE_RFSD:
2087: bprintf("retrieving from device #%d",node.aux);
2088: break;
2089: case NODE_DLNG:
2090: bprintf("downloading");
2091: break;
2092: case NODE_ULNG:
2093: bputs("uploading");
2094: break;
2095: case NODE_BXFR:
2096: bputs("transferring bidirectional");
2097: break;
2098: case NODE_LFIL:
2099: bputs("listing files");
2100: break;
2101: case NODE_LOGN:
2102: bputs("logging on");
2103: break;
2104: case NODE_LCHT:
2105: bprintf("in local chat with %s",sys_op);
2106: break;
2107: case NODE_MCHT:
2108: if(node.aux) {
2109: bprintf("in multinode chat channel %d",node.aux&0xff);
2110: if(node.aux&0x1f00) /* password */
2111: outchar('*'); }
2112: else
2113: bputs("in multinode global chat channel");
2114: break;
2115: case NODE_PAGE:
2116: bprintf("paging node %u for private chat",node.aux);
2117: break;
2118: case NODE_PCHT:
2119: bprintf("in private chat with node %u",node.aux);
2120: break;
2121: case NODE_GCHT:
2122: bprintf("chatting with %s",sys_guru);
2123: break;
2124: case NODE_CHAT:
2125: bputs("in chat section");
2126: break;
2127: case NODE_TQWK:
2128: bputs("transferring QWK packet");
2129: break;
2130: case NODE_SYSP:
2131: bputs("performing sysop activities");
2132: break;
2133: default:
2134: bputs(itoa(node.action,tmp,10));
2135: break; }
2136: if(!node.connection)
2137: bputs(" locally");
2138: else
2139: bprintf(" at %ubps",node.connection);
2140: if(node.action==NODE_DLNG) {
2141: if((node.aux/60)>12) {
2142: hour=(node.aux/60)-12;
2143: strcpy(mer,"pm"); }
2144: else {
2145: if((node.aux/60)==0) /* 12 midnite */
2146: hour=12;
2147: else hour=node.aux/60;
2148: strcpy(mer,"am"); }
2149: bprintf(" ETA %02d:%02d %s"
2150: ,hour,node.aux%60,mer); }
2151: break; }
2152: i=NODE_LOCK;
2153: if(node.status==NODE_INUSE || SYSOP)
2154: i|=NODE_POFF|NODE_AOFF|NODE_MSGW|NODE_NMSG;
2155: if(node.misc&i) {
2156: bputs(" (");
2157: if(node.misc&(i&NODE_AOFF))
2158: outchar('A');
2159: if(node.misc&NODE_LOCK)
2160: outchar('L');
2161: if(node.misc&(i&(NODE_MSGW|NODE_NMSG)))
2162: outchar('M');
2163: if(node.misc&(i&NODE_POFF))
2164: outchar('P');
2165: outchar(')'); }
2166: if(SYSOP && ((node.misc
2167: &(NODE_ANON|NODE_UDAT|NODE_INTR|NODE_RRUN|NODE_EVENT|NODE_DOWN))
2168: || node.status==NODE_QUIET)) {
2169: bputs(" [");
2170: if(node.misc&NODE_ANON)
2171: outchar('A');
2172: if(node.misc&NODE_INTR)
2173: outchar('I');
2174: if(node.misc&NODE_RRUN)
2175: outchar('R');
2176: if(node.misc&NODE_UDAT)
2177: outchar('U');
2178: if(node.status==NODE_QUIET)
2179: outchar('Q');
2180: if(node.misc&NODE_EVENT)
2181: outchar('E');
2182: if(node.misc&NODE_DOWN)
2183: outchar('D');
2184: outchar(']'); }
2185: if(node.errors && SYSOP) {
2186: attr(RED|HIGH|BLINK);
2187: bprintf(" %d error%c",node.errors, node.errors>1 ? 's' : '\0' ); }
2188: CRLF;
2189: }
2190:
2191: /****************************************************************************/
2192: /* Prints short messages waiting for 'usernumber', if any... */
2193: /* then deletes them. */
2194: /****************************************************************************/
2195: void getsmsg(int usernumber)
2196: {
2197: char str[256], *buf;
2198: int file;
2199: long length;
2200: node_t node;
2201:
2202: if(!data_dir[0])
2203: return;
2204: sprintf(str,"%sMSGS\\%4.4u.MSG",data_dir,usernumber);
2205: if(flength(str)<1L) {
2206: return; }
2207: if((file=nopen(str,O_RDWR))==-1) {
2208: bprintf("\7Error opening %s for read/write access\r\n",str);
2209: return; }
2210: length=filelength(file);
2211: if((buf=MALLOC(length+1))==NULL) {
2212: close(file);
2213: bprintf("\7Error allocating %u bytes of memory for %s\r\n",length+1,str);
2214: return; }
2215: if(read(file,buf,length)!=length) {
2216: close(file);
2217: FREE(buf);
2218: bprintf("\7Error reading %u bytes from %s\r\n",length,str);
2219: return; }
2220: chsize(file,0L);
2221: close(file);
2222: buf[length]=0;
2223: getnodedat(node_num,&node,0);
2224: if(node.action==NODE_MAIN || node.action==NODE_XFER) {
2225: CRLF; }
2226: if(node.misc&NODE_MSGW) {
2227: getnodedat(node_num,&node,1);
2228: node.misc&=~NODE_MSGW;
2229: putnodedat(node_num,node); }
2230: bputs(buf);
2231: FREE(buf);
2232: }
2233:
2234: /****************************************************************************/
2235: /* Creates a short message for 'usernumber' than contains 'strin' */
2236: /****************************************************************************/
2237: void putsmsg(int usernumber, char *strin)
2238: {
2239: char str[256];
2240: int file,i;
2241: node_t node;
2242:
2243: if(!data_dir[0])
2244: return;
2245: sprintf(str,"%sMSGS\\%4.4u.MSG",data_dir,usernumber);
2246: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
2247: bprintf("\7Error opening/creating %s for creat/append access\r\n",str);
2248: return; }
2249: i=strlen(strin);
2250: if(write(file,strin,i)!=i) {
2251: close(file);
2252: bprintf("\7Error writing %u bytes to %s\r\n",i,str);
2253: return; }
2254: close(file);
2255: for(i=1;i<=sys_nodes;i++) { /* flag node if user on that msg waiting */
2256: getnodedat(i,&node,0);
2257: if(node.useron==usernumber
2258: && (node.status==NODE_INUSE || node.status==NODE_QUIET)
2259: && !(node.misc&NODE_MSGW)) {
2260: getnodedat(i,&node,1);
2261: node.misc|=NODE_MSGW;
2262: putnodedat(i,node); } }
2263: }
2264:
2265: /****************************************************************************/
2266: /* Prints short messages waiting for this node, if any... */
2267: /****************************************************************************/
2268: void getnmsg(void)
2269: {
2270: char str[256], *buf;
2271: int file;
2272: long length;
2273: node_t thisnode;
2274:
2275: if(!data_dir[0])
2276: return;
2277: getnodedat(node_num,&thisnode,1);
2278: thisnode.misc&=~NODE_NMSG; /* clear the NMSG flag */
2279: putnodedat(node_num,thisnode);
2280:
2281: sprintf(str,"%sMSGS\\N%3.3u.MSG",data_dir,node_num);
2282: if(flength(str)<1L) {
2283: return; }
2284: if((file=nopen(str,O_RDWR))==-1) {
2285: printf("Couldn't open %s for read/write\r\n",str);
2286: return; }
2287: length=filelength(file);
2288: if((buf=MALLOC(length+1))==NULL) {
2289: close(file);
2290: printf("Couldn't allocate %lu bytes for %s\r\n",length+1,str);
2291: return; }
2292: if(read(file,buf,length)!=length) {
2293: close(file);
2294: FREE(buf);
2295: printf("Couldn't read %lu bytes from %s\r\n",length,str);
2296: return; }
2297: chsize(file,0L);
2298: close(file);
2299: buf[length]=0;
2300:
2301: bputs(buf);
2302: FREE(buf);
2303: }
2304:
2305: /****************************************************************************/
2306: /* Creates a short message for node 'num' than contains 'strin' */
2307: /****************************************************************************/
2308: void putnmsg(int num, char *strin)
2309: {
2310: char str[256];
2311: int file,i;
2312: node_t node;
2313:
2314: if(!data_dir[0])
2315: return;
2316: sprintf(str,"%sMSGS\\N%3.3u.MSG",data_dir,num);
2317: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
2318: printf("Couldn't open %s for append\r\n",str);
2319: return; }
2320: i=strlen(strin);
2321: if(write(file,strin,i)!=i) {
2322: close(file);
2323: printf("Error writing %u bytes to %s\r\n",i,str);
2324: return; }
2325: close(file);
2326: getnodedat(num,&node,0);
2327: if((node.status==NODE_INUSE || node.status==NODE_QUIET)
2328: && !(node.misc&NODE_NMSG)) {
2329: getnodedat(num,&node,1);
2330: node.misc|=NODE_NMSG;
2331: putnodedat(num,node); }
2332: }
2333:
2334: /****************************************************************************/
2335: /* This function lists users that are online. */
2336: /* If listself is true, it will list the current node. */
2337: /* Returns number of active nodes (not including current node). */
2338: /****************************************************************************/
2339: int whos_online(char listself)
2340: {
2341: int i,j;
2342: node_t node;
2343:
2344: if(!ctrl_dir[0])
2345: return(0);
2346: CRLF;
2347: for(j=0,i=1;i<=sys_nodes;i++) {
2348: getnodedat(i,&node,0);
2349: if(i==node_num) {
2350: if(listself)
2351: printnodedat(i,node);
2352: continue; }
2353: if(node.status==NODE_INUSE || (SYSOP && node.status==NODE_QUIET)) {
2354: printnodedat(i,node);
2355: if(!lastnodemsg)
2356: lastnodemsg=i;
2357: j++; } }
2358: if(!j)
2359: bputs("\1nNo other active nodes.\r\n");
2360: return(j);
2361: }
2362:
2363: /****************************************************************************/
2364: /* Sending single line messages between nodes */
2365: /****************************************************************************/
2366: void nodemsg(void)
2367: {
2368: char str[256],line[256],buf[512];
2369: int i,j;
2370: node_t thisnode;
2371: node_t node;
2372:
2373: if(!ctrl_dir[0])
2374: return;
2375: if(strchr(user_rest,'C')) {
2376: bputs("You cannot send messages.\r\n");
2377: return; }
2378: getnodedat(node_num,&thisnode,0);
2379: wordwrap[0]=0;
2380: if(lastnodemsg) {
2381: getnodedat(lastnodemsg,&node,0);
2382: if(node.status!=NODE_INUSE)
2383: lastnodemsg=0; }
2384: if(!whos_online(0))
2385: return;
2386: bprintf("\r\n&n&gNumber of node to send message to, &w&hA&n&gll, "
2387: "or &w&hQ&n&guit [%u]: &w&h",lastnodemsg);
2388: i=getkeys("QA",sys_nodes);
2389: if(i==-1)
2390: return;
2391: if(i&0x8000 || !i) {
2392: if(!i)
2393: i=lastnodemsg;
2394: else {
2395: i^=0x8000;
2396: lastnodemsg=i; }
2397: if(!i || i>sys_nodes)
2398: return;
2399: getnodedat(i,&node,0);
2400: if(node.status!=NODE_INUSE && !SYSOP)
2401: bprintf("\r\n&_&w&hNode %d is not in use.\r\n",i);
2402: else if(i==node_num)
2403: bputs("\r\nThere's no need to send a message to yourself.\r\n");
2404: else if(node.misc&NODE_POFF && !SYSOP)
2405: bprintf("\r\n&r&h&iDon't bug %s.&n\r\n"
2406: ,node.misc&NODE_ANON ? "UNKNOWN USER"
2407: : username(node.useron));
2408: else {
2409: bputs("&_&y&hMessage: ");
2410: if(!getstr(line,70,K_LINE))
2411: return;
2412: sprintf(buf
2413: ,"\7&_&w&hNode %2d: &g%s&n&g sent you a message:\r\n&w&h&4%s&n\r\n"
2414: ,node_num
2415: ,thisnode.misc&NODE_ANON ? "UNKNOWN USER" : user_name,line);
2416: putnmsg(i,buf); } }
2417: else if(i=='A') {
2418: bputs("&_&y&hMessage: ");
2419: if(!getstr(line,70,K_LINE))
2420: return;
2421: sprintf(buf
2422: ,"\7&_&w&hNode %2d: &g%s&n&g sent all nodes a message:\r\n"
2423: "&w&h&4%s&n\r\n"
2424: ,node_num
2425: ,thisnode.misc&NODE_ANON ? "UNKNOWN USER" : user_name,line);
2426: for(i=1;i<=sys_nodes;i++) {
2427: if(i==node_num)
2428: continue;
2429: getnodedat(i,&node,0);
2430: if((node.status==NODE_INUSE || (SYSOP && node.status==NODE_QUIET))
2431: && (SYSOP || !(node.misc&NODE_POFF)))
2432: putnmsg(i,buf); } }
2433:
2434: }
2435:
2436: /****************************************************************************/
2437: /* Puts a character into the input buffer */
2438: /****************************************************************************/
2439: void ungetkey(char ch)
2440: {
2441:
2442: keybuf[keybuftop++]=ch;
2443: if(keybuftop==KEY_BUFSIZE)
2444: keybuftop=0;
2445: }
2446:
2447: #ifdef __SC__ /* Missing from Symantec RTL */
2448: void clrscr(void)
2449: {
2450: asm
2451: { mov ah,8 /*function # for "Get char with attr*/
2452: xor bh,bh /*page 0*/
2453: int 10h /*Call interrupt 10h (video)*/
2454:
2455: mov bh,ah /*set "set attr" to "current attr"*/
2456: mov ah,6 /*function # for "Scroll Window Up"*/
2457: xor cx,cx /*set upper row & column (0,0)*/
2458: xor al,al /*set "# lines to scroll" to 0*/
2459: mov dh,119 /*set lowqer colum*/
2460: int 10h /*Call interrupt 10h*/
2461:
2462: mov ah,2 /*function # for "Set Cursor Position"*/
2463: xor bh,bh /*set page to 0*/
2464: xor dx,dx /*set row & colum to 0 (upper left)*/
2465: int 10h /*Call interrupt 10h*/
2466: }
2467: return;
2468: }
2469:
2470: short wherey(void)
2471: {
2472: struct disp_t rc;
2473: return(rc.cursorcol);
2474: }
2475: #endif /* __SC__ */
2476:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.