Return to chat.c CVS log

Up to [Synchronet] / sbbs / sbbs2

Annotation of sbbs/sbbs2/chat.c, revision 1.1

1.1     ! root        1: #line 1 "CHAT.C"
        !             2: 
        !             3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
        !             4: 
        !             5: /****************************************/
        !             6: /* Local and Node-to-Node Chat routines */
        !             7: /****************************************/
        !             8: 
        !             9: #include "sbbs.h"
        !            10: 
        !            11: #define PCHAT_LEN 1000         /* Size of Private chat file */
        !            12: 
        !            13: int getnodetopage(int all, int telegram);
        !            14: 
        !            15: 
        !            16: char *weekday[]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday"
        !            17:                                ,"Saturday"};
        !            18: char *month[]={"January","February","March","April","May","June"
        !            19:                        ,"July","August","September","October","November","December"};
        !            20: 
        !            21: 
        !            22: /****************************************************************************/
        !            23: /* Chat between local keyboard and remote user on current node.                                */
        !            24: /* Called from inkey (inkey is then re-entrant)                                                                */
        !            25: /****************************************************************************/
        !            26: void localchat()
        !            27: {
        !            28:        uchar   str[256],act;
        !            29:        int con=console;        /* save console state */
        !            30:        time_t  beg=time(NULL);
        !            31: 
        !            32: console&=~(CON_L_ECHOX|CON_R_ECHOX);   /* turn off X's */
        !            33: console|=(CON_L_ECHO|CON_R_ECHO);              /* make sure echo is enabled */
        !            34: nosound();
        !            35: sys_status&=~SS_SYSPAGE;
        !            36: act=action;                                    /* save the user's current action */
        !            37: action=NODE_LCHT;
        !            38: bprintf(text[SysopIsHere],sys_op);
        !            39: while(sys_status&SS_LCHAT && online) {
        !            40:        SYNC;
        !            41:        getstr(str,78,K_WRAP|K_MSG); }
        !            42: bputs(text[EndOfChat]);
        !            43: now=time(NULL);
        !            44: if(!(sys_status&SS_USERON))
        !            45:        answertime=now;
        !            46: starttime+=now-beg;   /* credit user for time in chat */
        !            47: RESTORELINE;
        !            48: action=act;
        !            49: console=con;                                   /* restore console */
        !            50: }
        !            51: 
        !            52: void sysop_page(void)
        !            53: {
        !            54:        int i;
        !            55: 
        !            56: for(i=0;i<total_pages;i++)
        !            57:        if(chk_ar(page[i]->ar,useron))
        !            58:                break;
        !            59: if(i<total_pages) {
        !            60:        bprintf(text[PagingGuru],sys_op);
        !            61:        external(cmdstr(page[i]->cmd,nulstr,nulstr,NULL)
        !            62:                ,page[i]->misc&IO_INTS ? EX_OUTL|EX_OUTR|EX_INR
        !            63:                        : EX_OUTL); }
        !            64: else if(sys_misc&SM_SHRTPAGE) {
        !            65:        bprintf(text[PagingGuru],sys_op);
        !            66:        for(i=0;i<10 && !lkbrd(1);i++) {
        !            67:                beep(1000,200);
        !            68:                mswait(200);
        !            69:                outchar('.'); }
        !            70:        CRLF; }
        !            71: else {
        !            72:        sys_status^=SS_SYSPAGE;
        !            73:        bprintf(text[SysopPageIsNow]
        !            74:                ,sys_status&SS_SYSPAGE ? text[ON] : text[OFF]);
        !            75:        nosound();      }
        !            76: }
        !            77: 
        !            78: /****************************************************************************/
        !            79: /* Returns 1 if user online has access to channel "channum"                 */
        !            80: /****************************************************************************/
        !            81: char chan_access(uint cnum)
        !            82: {
        !            83: 
        !            84: if(!total_chans || cnum>=total_chans || !chk_ar(chan[cnum]->ar,useron)) {
        !            85:        bputs(text[CantAccessThatChannel]);
        !            86:        return(0); }
        !            87: if(!(useron.exempt&FLAG('J')) && chan[cnum]->cost>useron.cdt+useron.freecdt) {
        !            88:        bputs(text[NotEnoughCredits]);
        !            89:        return(0); }
        !            90: return(1);
        !            91: }
        !            92: 
        !            93: void privchat(void)
        !            94: {
        !            95:        uchar   str[128],ch,c,*p,localbuf[5][81],remotebuf[5][81]
        !            96:                        ,localline=0,remoteline=0,localchar=0,remotechar=0
        !            97:                        ,*sep="\1w\1h�����[\1i\1r%c\1n\1h]���Ĵ "
        !            98:                                "\1yPrivate Chat - \1rCtrl-C to Quit \1y- "
        !            99:                                "Time Left: \1g%-8s\1w"
        !           100:                                " �����[\1i\1b%c\1n\1h]�����";
        !           101:        int     in,out,i,j,n,done,echo=1,x,y,activity;
        !           102:        node_t  node;
        !           103: 
        !           104: n=getnodetopage(0,0);
        !           105: if(!n)
        !           106:        return;
        !           107: if(n==node_num) {
        !           108:        bputs(text[NoNeedToPageSelf]);
        !           109:        return; }
        !           110: getnodedat(n,&node,0);
        !           111: if(node.action==NODE_PCHT && node.aux!=node_num) {
        !           112:        bprintf(text[NodeNAlreadyInPChat],n);
        !           113:        return; }
        !           114: if((node.action!=NODE_PAGE || node.aux!=node_num)
        !           115:        && node.misc&NODE_POFF && !SYSOP) {
        !           116:        bprintf(text[CantPageNode],node.misc&NODE_ANON
        !           117:                ? text[UNKNOWN_USER] : username(node.useron,tmp));
        !           118:        return; }
        !           119: if(node.action!=NODE_PAGE) {
        !           120:        bprintf("\r\n\1n\1mPaging \1h%s #%u\1n\1m for private chat\r\n"
        !           121:                ,node.misc&NODE_ANON ? text[UNKNOWN_USER] : username(node.useron,tmp)
        !           122:                ,node.useron);
        !           123:        sprintf(str,text[NodePChatPageMsg]
        !           124:                ,node_num,thisnode.misc&NODE_ANON
        !           125:                        ? text[UNKNOWN_USER] : useron.alias);
        !           126:        putnmsg(n,str);
        !           127:        sprintf(str,"Paged %s on node %d to private chat"
        !           128:                ,username(node.useron,tmp),n);
        !           129:        logline("C",str); }
        !           130: 
        !           131: getnodedat(node_num,&thisnode,1);
        !           132: thisnode.action=action=NODE_PAGE;
        !           133: thisnode.aux=n;
        !           134: putnodedat(node_num,thisnode);
        !           135: 
        !           136: if(node.action!=NODE_PAGE || node.aux!=node_num) {
        !           137:        bprintf(text[WaitingForNodeInPChat],n);
        !           138:        while(online && !(sys_status&SS_ABORT)) {
        !           139:                getnodedat(n,&node,0);
        !           140:                if((node.action==NODE_PAGE || node.action==NODE_PCHT)
        !           141:                        && node.aux==node_num) {
        !           142:                        bprintf(text[NodeJoinedPrivateChat]
        !           143:                                ,n,node.misc&NODE_ANON ? text[UNKNOWN_USER]
        !           144:                                        : username(node.useron,tmp));
        !           145:                        break; }
        !           146:                if(!inkey(0))
        !           147:                        mswait(1);
        !           148:                action=NODE_PAGE;
        !           149:                checkline();
        !           150:                gettimeleft();
        !           151:                SYNC; } }
        !           152: 
        !           153: getnodedat(node_num,&thisnode,1);
        !           154: thisnode.action=action=NODE_PCHT;
        !           155: putnodedat(node_num,thisnode);
        !           156: 
        !           157: if(!online || sys_status&SS_ABORT)
        !           158:        return;
        !           159: 
        !           160: if(useron.chat&CHAT_SPLITP && useron.misc&ANSI && rows>=24)
        !           161:        sys_status|=SS_SPLITP;
        !           162: /*
        !           163: if(!(useron.misc&EXPERT))
        !           164:        menu("PRIVCHAT");
        !           165: */
        !           166: 
        !           167: if(!(sys_status&SS_SPLITP))
        !           168:        bputs(text[WelcomeToPrivateChat]);
        !           169: 
        !           170: sprintf(str,"%sCHAT.DAB",node_dir);
        !           171: if((out=open(str,O_RDWR|O_DENYNONE|O_CREAT|O_BINARY
        !           172:        ,S_IREAD|S_IWRITE))==-1) {
        !           173:        errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_DENYNONE|O_CREAT);
        !           174:        return; }
        !           175: 
        !           176: sprintf(str,"%sCHAT.DAB",node_path[n-1]);
        !           177: if(!fexist(str))               /* Wait while it's created for the first time */
        !           178:        mswait(2000);
        !           179: if((in=open(str,O_RDWR|O_DENYNONE|O_CREAT|O_BINARY
        !           180:        ,S_IREAD|S_IWRITE))==-1) {
        !           181:        close(out);
        !           182:        errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_DENYNONE|O_CREAT);
        !           183:        return; }
        !           184: 
        !           185: if((p=(char *)MALLOC(PCHAT_LEN))==NULL) {
        !           186:        close(in);
        !           187:        close(out);
        !           188:        errormsg(WHERE,ERR_ALLOC,str,PCHAT_LEN);
        !           189:        return; }
        !           190: memset(p,0,PCHAT_LEN);
        !           191: write(in,p,PCHAT_LEN);
        !           192: write(out,p,PCHAT_LEN);
        !           193: FREE(p);
        !           194: lseek(in,0L,SEEK_SET);
        !           195: lseek(out,0L,SEEK_SET);
        !           196: 
        !           197: getnodedat(node_num,&thisnode,1);
        !           198: thisnode.misc&=~NODE_RPCHT;            /* Clear "reset pchat flag" */
        !           199: putnodedat(node_num,thisnode);
        !           200: 
        !           201: getnodedat(n,&node,1);
        !           202: node.misc|=NODE_RPCHT;                         /* Set "reset pchat flag" */
        !           203: putnodedat(n,node);                            /* on other node */
        !           204: 
        !           205:                                                                        /* Wait for other node */
        !           206:                                                                        /* to acknowledge and reset */
        !           207: while(online && !(sys_status&SS_ABORT)) {
        !           208:        getnodedat(n,&node,0);
        !           209:        if(!(node.misc&NODE_RPCHT))
        !           210:                break;
        !           211:        getnodedat(node_num,&thisnode,0);
        !           212:        if(thisnode.misc&NODE_RPCHT)
        !           213:                break;
        !           214:        checkline();
        !           215:        gettimeleft();
        !           216:        SYNC;
        !           217:        inkey(0);
        !           218:        mswait(1); }
        !           219: 
        !           220: 
        !           221: action=NODE_PCHT;
        !           222: SYNC;
        !           223: 
        !           224: if(sys_status&SS_SPLITP) {
        !           225:        lncntr=0;
        !           226:        CLS;
        !           227:        ANSI_SAVE();
        !           228:        GOTOXY(1,13);
        !           229:        bprintf(sep
        !           230:                ,thisnode.misc&NODE_MSGW ? 'T':SP
        !           231:                ,sectostr(timeleft,tmp)
        !           232:                ,thisnode.misc&NODE_NMSG ? 'M':SP);
        !           233:        CRLF; }
        !           234: 
        !           235: done=0;
        !           236: 
        !           237: while(online && !(sys_status&SS_ABORT) && !done) {
        !           238:        RIOSYNC(0);
        !           239:        lncntr=0;
        !           240:        if(sys_status&SS_SPLITP)
        !           241:                lbuflen=0;
        !           242:        action=NODE_PCHT;
        !           243:        if(!localchar) {
        !           244:                if(sys_status&SS_SPLITP) {
        !           245:                        getnodedat(node_num,&thisnode,0);
        !           246:                        if(thisnode.misc&NODE_INTR)
        !           247:                                break;
        !           248:                        if(thisnode.misc&NODE_UDAT && !(useron.rest&FLAG('G'))) {
        !           249:                                getuserdat(&useron);
        !           250:                                getnodedat(node_num,&thisnode,1);
        !           251:                                thisnode.misc&=~NODE_UDAT;
        !           252:                                putnodedat(node_num,thisnode); } }
        !           253:                else
        !           254:                        nodesync(); }
        !           255:        activity=0;
        !           256:        if((ch=inkey(K_GETSTR))!=0) {
        !           257:                activity=1;
        !           258:                if(echo)
        !           259:                        attr(color[clr_chatlocal]);
        !           260:                else
        !           261:                        lclatr(color[clr_chatlocal]);
        !           262:                if(ch==BS) {
        !           263:                        if(localchar) {
        !           264:                                if(echo)
        !           265:                                        bputs("\b \b");
        !           266:                                else
        !           267:                                        lputs("\b \b");
        !           268:                                localchar--;
        !           269:                                localbuf[localline][localchar]=0; } }
        !           270:                else if(ch==TAB) {
        !           271:                        if(echo)
        !           272:                                outchar(SP);
        !           273:                        else
        !           274:                                lputc(SP);
        !           275:                        localbuf[localline][localchar]=SP;
        !           276:                        localchar++;
        !           277:                        while(localchar<78 && localchar%8) {
        !           278:                                if(echo)
        !           279:                                        outchar(SP);
        !           280:                                else
        !           281:                                        lputc(SP);
        !           282:                                localbuf[localline][localchar++]=SP; } }
        !           283:                else if(ch>=SP || ch==CR) {
        !           284:                        if(ch!=CR) {
        !           285:                                if(echo)
        !           286:                                        outchar(ch);
        !           287:                                else
        !           288:                                        lputc(ch);
        !           289:                                localbuf[localline][localchar]=ch; }
        !           290: 
        !           291:                        if(ch==CR || (localchar>68 && ch==SP) || ++localchar>78) {
        !           292: 
        !           293:                                localbuf[localline][localchar]=0;
        !           294:                                localchar=0;
        !           295: 
        !           296:                                if(sys_status&SS_SPLITP && lclwy()==24) {
        !           297:                                        GOTOXY(1,13);
        !           298:                                        bprintf(sep
        !           299:                                                ,thisnode.misc&NODE_MSGW ? 'T':SP
        !           300:                                                ,sectostr(timeleft,tmp)
        !           301:                                                ,thisnode.misc&NODE_NMSG ? 'M':SP);
        !           302:                                        attr(color[clr_chatlocal]);
        !           303:                                        for(x=13,y=0;x<rows;x++,y++) {
        !           304:                                                bprintf("\x1b[%d;1H\x1b[K",x+1);
        !           305:                                                if(y<=localline)
        !           306:                                                        bprintf("%s\r\n",localbuf[y]); }
        !           307:                                        GOTOXY(1,15+localline);
        !           308:                                        localline=0; }
        !           309:                                else {
        !           310:                                        if(localline>=4)
        !           311:                                                for(i=0;i<4;i++)
        !           312:                                                        memcpy(localbuf[i],localbuf[i+1],81);
        !           313:                                        else
        !           314:                                                localline++;
        !           315:                                        if(echo) {
        !           316:                                                CRLF;
        !           317:                                                if(sys_status&SS_SPLITP)
        !           318:                                                        bputs("\x1b[K"); }
        !           319:                                        else
        !           320:                                                lputs(crlf); }
        !           321:                                // SYNC;
        !           322:                                } }
        !           323: 
        !           324:                read(out,&c,1);
        !           325:                lseek(out,-1L,SEEK_CUR);
        !           326:                if(!c)          /* hasn't wrapped */
        !           327:                        write(out,&ch,1);
        !           328:                else {
        !           329:                        if(!tell(out))
        !           330:                                lseek(out,0L,SEEK_END);
        !           331:                        lseek(out,-1L,SEEK_CUR);
        !           332:                        ch=0;
        !           333:                        write(out,&ch,1);
        !           334:                        lseek(out,-1L,SEEK_CUR); }
        !           335:                if(tell(out)>=PCHAT_LEN)
        !           336:                        lseek(out,0L,SEEK_SET);
        !           337:                }
        !           338:        else while(online) {
        !           339:                if(!(sys_status&SS_SPLITP))
        !           340:                        remotechar=localchar;
        !           341:                if(tell(in)>=PCHAT_LEN)
        !           342:                        lseek(in,0L,SEEK_SET);
        !           343:                ch=0;
        !           344:                read(in,&ch,1);
        !           345:                lseek(in,-1L,SEEK_CUR);
        !           346:                if(!ch) break;                                    /* char from other node */
        !           347:                activity=1;
        !           348:                x=lclwx();
        !           349:                y=lclwy();
        !           350:                if(sys_status&SS_SPLITP)
        !           351:                        ANSI_RESTORE();
        !           352:                attr(color[clr_chatremote]);
        !           353:                if(sys_status&SS_SPLITP)
        !           354:                        bputs("\b \b");             /* Delete fake cursor */
        !           355:                if(ch==BS) {
        !           356:                        if(remotechar) {
        !           357:                                bputs("\b \b");
        !           358:                                remotechar--;
        !           359:                                remotebuf[remoteline][remotechar]=0; } }
        !           360:                else if(ch==TAB) {
        !           361:                        outchar(SP);
        !           362:                        remotebuf[remoteline][remotechar]=SP;
        !           363:                        remotechar++;
        !           364:                        while(remotechar<78 && remotechar%8) {
        !           365:                                outchar(SP);
        !           366:                                remotebuf[remoteline][remotechar++]=SP; } }
        !           367:                else if(ch>=SP || ch==CR) {
        !           368:                        if(ch!=CR) {
        !           369:                                outchar(ch);
        !           370:                                remotebuf[remoteline][remotechar]=ch; }
        !           371: 
        !           372:                        if(ch==CR || (remotechar>68 && ch==SP) || ++remotechar>78) {
        !           373: 
        !           374:                                remotebuf[remoteline][remotechar]=0;
        !           375:                                remotechar=0;
        !           376: 
        !           377:                                if(sys_status&SS_SPLITP && lclwy()==12) {
        !           378:                                        CRLF;
        !           379:                                        bprintf(sep
        !           380:                                                ,thisnode.misc&NODE_MSGW ? 'T':SP
        !           381:                                                ,sectostr(timeleft,tmp)
        !           382:                                                ,thisnode.misc&NODE_NMSG ? 'M':SP);
        !           383:                                        attr(color[clr_chatremote]);
        !           384:                                        for(i=0;i<12;i++) {
        !           385:                                                bprintf("\x1b[%d;1H\x1b[K",i+1);
        !           386:                                                if(i<=remoteline)
        !           387:                                                        bprintf("%s\r\n",remotebuf[i]); }
        !           388:                                        remoteline=0;
        !           389:                                        GOTOXY(1,6); }
        !           390:                                else {
        !           391:                                        if(remoteline>=4)
        !           392:                                                for(i=0;i<4;i++)
        !           393:                                                        memcpy(remotebuf[i],remotebuf[i+1],81);
        !           394:                                        else
        !           395:                                                remoteline++;
        !           396:                                        if(echo) {
        !           397:                                                CRLF;
        !           398:                                                if(sys_status&SS_SPLITP)
        !           399:                                                        bputs("\x1b[K"); }
        !           400:                                        else
        !           401:                                                lputs(crlf); } } }
        !           402:                if(sys_status&SS_SPLITP) {
        !           403:                        bputs("\1i_\1n");  /* Fake cursor */
        !           404:                        ANSI_SAVE();
        !           405:                        GOTOXY(x,y); }
        !           406:                ch=0;
        !           407:                write(in,&ch,1);
        !           408: 
        !           409:                if(!(sys_status&SS_SPLITP))
        !           410:                        localchar=remotechar;
        !           411:                }
        !           412:        if(!activity) {                                                 /* no activity so chk node.dab */
        !           413:                getnodedat(n,&node,0);
        !           414:                if((node.action!=NODE_PCHT && node.action!=NODE_PAGE)
        !           415:                        || node.aux!=node_num) {
        !           416:                        bprintf(text[NodeLeftPrivateChat]
        !           417:                                ,n,node.misc&NODE_ANON ? text[UNKNOWN_USER]
        !           418:                                : username(node.useron,tmp));
        !           419:                        break; }
        !           420:                getnodedat(node_num,&thisnode,0);
        !           421:                if(thisnode.misc&NODE_RPCHT) {          /* pchat has been reset */
        !           422:                        lseek(in,0L,SEEK_SET);                  /* so seek to beginning */
        !           423:                        lseek(out,0L,SEEK_SET);
        !           424:                        getnodedat(node_num,&thisnode,1);
        !           425:                        thisnode.misc&=~NODE_RPCHT;
        !           426:                        putnodedat(node_num,thisnode); }
        !           427:                mswait(0); }
        !           428:        checkline();
        !           429:        gettimeleft(); }
        !           430: if(sys_status&SS_SPLITP)
        !           431:        CLS;
        !           432: sys_status&=~SS_SPLITP;
        !           433: close(in);
        !           434: close(out);
        !           435: }
        !           436: 
        !           437: /****************************************************************************/
        !           438: /* The chat section                                                         */
        !           439: /****************************************************************************/
        !           440: void chatsection()
        !           441: {
        !           442:        uchar   line[256],str[256],ch,c,done,no_rip_menu
        !           443:                        ,usrs,preusrs,qusrs,*gurubuf=NULL,channel,savch,*p
        !           444:                        ,pgraph[400],buf[400]
        !           445:                        ,usr[MAX_NODES],preusr[MAX_NODES],qusr[MAX_NODES];
        !           446:        int     file,in,out;
        !           447:        long    i,j,k,n;
        !           448:        node_t  node;
        !           449: 
        !           450: action=NODE_CHAT;
        !           451: if(useron.misc&(RIP|WIP) || !(useron.misc&EXPERT))
        !           452:     menu("CHAT");
        !           453: ASYNC;
        !           454: bputs(text[ChatPrompt]);
        !           455: while(online) {
        !           456:        no_rip_menu=0;
        !           457:        ch=getkeys("ACDJPQST?\r",0);
        !           458:        if(ch>SP)
        !           459:                logch(ch,0);
        !           460:        switch(ch) {
        !           461:                case 'S':
        !           462:                        useron.chat^=CHAT_SPLITP;
        !           463:                        putuserrec(useron.number,U_CHAT,8
        !           464:                 ,ltoa(useron.chat,str,16));
        !           465:                        bprintf("\r\nPrivate split-screen chat is now: %s\r\n"
        !           466:                                ,useron.chat&CHAT_SPLITP ? text[ON]:text[OFF]);
        !           467:                        break;
        !           468:                case 'A':
        !           469:                        CRLF;
        !           470:                        useron.chat^=CHAT_NOACT;
        !           471:                        putuserrec(useron.number,U_CHAT,8
        !           472:                                ,ltoa(useron.chat,str,16));
        !           473:                        getnodedat(node_num,&thisnode,1);
        !           474:                        thisnode.misc^=NODE_AOFF;
        !           475:                        printnodedat(node_num,thisnode);
        !           476:                        putnodedat(node_num,thisnode);
        !           477:                        no_rip_menu=1;
        !           478:                        break;
        !           479:                case 'D':
        !           480:                        CRLF;
        !           481:                        useron.chat^=CHAT_NOPAGE;
        !           482:                        putuserrec(useron.number,U_CHAT,8
        !           483:                 ,ltoa(useron.chat,str,16));
        !           484:                        getnodedat(node_num,&thisnode,1);
        !           485:                        thisnode.misc^=NODE_POFF;
        !           486:                        printnodedat(node_num,thisnode);
        !           487:                        putnodedat(node_num,thisnode);
        !           488:                        no_rip_menu=1;
        !           489:                        break;
        !           490:                case 'J':
        !           491:                        if(!chan_access(0))
        !           492:                                break;
        !           493:                        if(useron.misc&(RIP|WIP) ||!(useron.misc&EXPERT))
        !           494:                                menu("MULTCHAT");
        !           495:                        getnodedat(node_num,&thisnode,1);
        !           496:                        bputs(text[WelcomeToMultiChat]);
        !           497:                        channel=thisnode.aux=1;         /* default channel 1 */
        !           498:                        putnodedat(node_num,thisnode);
        !           499:                        bprintf(text[WelcomeToChannelN],channel,chan[0]->name);
        !           500:                        if(gurubuf) {
        !           501:                                FREE(gurubuf);
        !           502:                                gurubuf=NULL; }
        !           503:                        if(chan[0]->misc&CHAN_GURU && chan[0]->guru<total_gurus
        !           504:                                && chk_ar(guru[chan[0]->guru]->ar,useron)) {
        !           505:                                sprintf(str,"%s%s.DAT",ctrl_dir,guru[chan[0]->guru]->code);
        !           506:                                if((file=nopen(str,O_RDONLY))==-1) {
        !           507:                                        errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
        !           508:                                        break; }
        !           509:                                if((gurubuf=MALLOC(filelength(file)+1))==NULL) {
        !           510:                                        close(file);
        !           511:                                        errormsg(WHERE,ERR_ALLOC,str,filelength(file)+1);
        !           512:                                        break; }
        !           513:                                read(file,gurubuf,filelength(file));
        !           514:                                gurubuf[filelength(file)]=0;
        !           515:                                close(file); }
        !           516:                        usrs=0;
        !           517:                        for(i=1;i<=sys_nodes && i<=sys_lastnode;i++) {
        !           518:                                if(i==node_num)
        !           519:                                        continue;
        !           520:                                getnodedat(i,&node,0);
        !           521:                                if(node.action!=NODE_MCHT || node.status!=NODE_INUSE)
        !           522:                                        continue;
        !           523:                                if(node.aux && (node.aux&0xff)!=channel)
        !           524:                                        continue;
        !           525:                                printnodedat(i,node);
        !           526:                                preusr[usrs]=usr[usrs++]=i; }
        !           527:                        preusrs=usrs;
        !           528:                        if(gurubuf)
        !           529:                                bprintf(text[NodeInMultiChatLocally]
        !           530:                                        ,sys_nodes+1,guru[chan[channel-1]->guru]->name,channel);
        !           531:                        bputs(text[YoureOnTheAir]);
        !           532:                        done=0;
        !           533:                        while(online && !done) {
        !           534:                                checkline();
        !           535:                                gettimeleft();
        !           536:                                action=NODE_MCHT;
        !           537:                                qusrs=usrs=0;
        !           538:                for(i=1;i<=sys_nodes;i++) {
        !           539:                                        if(i==node_num)
        !           540:                                                continue;
        !           541:                                        getnodedat(i,&node,0);
        !           542:                                        if(node.action!=NODE_MCHT
        !           543:                                                || (node.aux && channel && (node.aux&0xff)!=channel))
        !           544:                                                continue;
        !           545:                                        if(node.status==NODE_QUIET)
        !           546:                                                qusr[qusrs++]=i;
        !           547:                                        else if(node.status==NODE_INUSE)
        !           548:                                                usr[usrs++]=i; }
        !           549:                                if(preusrs>usrs) {
        !           550:                                        if(!usrs && channel && chan[channel-1]->misc&CHAN_GURU
        !           551:                                                && chan[channel-1]->guru<total_gurus)
        !           552:                                                bprintf(text[NodeJoinedMultiChat]
        !           553:                                                        ,sys_nodes+1,guru[chan[channel-1]->guru]->name
        !           554:                                                        ,channel);
        !           555:                                        outchar(7);
        !           556:                                        for(i=0;i<preusrs;i++) {
        !           557:                                                for(j=0;j<usrs;j++)
        !           558:                                                        if(preusr[i]==usr[j])
        !           559:                                                                break;
        !           560:                                                if(j==usrs) {
        !           561:                                                        getnodedat(preusr[i],&node,0);
        !           562:                                                        if(node.misc&NODE_ANON)
        !           563:                                                                sprintf(str,"%.80s",text[UNKNOWN_USER]);
        !           564:                                                        else
        !           565:                                                                username(node.useron,str);
        !           566:                                                        bprintf(text[NodeLeftMultiChat]
        !           567:                                                                ,preusr[i],str,channel); } } }
        !           568:                                else if(preusrs<usrs) {
        !           569:                                        if(!preusrs && channel && chan[channel-1]->misc&CHAN_GURU
        !           570:                                                && chan[channel-1]->guru<total_gurus)
        !           571:                                                bprintf(text[NodeLeftMultiChat]
        !           572:                                                        ,sys_nodes+1,guru[chan[channel-1]->guru]->name
        !           573:                                                        ,channel);
        !           574:                                        outchar(7);
        !           575:                                        for(i=0;i<usrs;i++) {
        !           576:                                                for(j=0;j<preusrs;j++)
        !           577:                                                        if(usr[i]==preusr[j])
        !           578:                                                                break;
        !           579:                                                if(j==preusrs) {
        !           580:                                                        getnodedat(usr[i],&node,0);
        !           581:                             if(node.misc&NODE_ANON)
        !           582:                                                                sprintf(str,"%.80s",text[UNKNOWN_USER]);
        !           583:                                                        else
        !           584:                                                                username(node.useron,str);
        !           585:                                                        bprintf(text[NodeJoinedMultiChat]
        !           586:                                                                ,usr[i],str,channel); } } }
        !           587:                 preusrs=usrs;
        !           588:                                for(i=0;i<usrs;i++)
        !           589:                                        preusr[i]=usr[i];
        !           590:                                attr(color[clr_multichat]);
        !           591:                                SYNC;
        !           592:                                sys_status&=~SS_ABORT;
        !           593:                                if((ch=inkey(0))!=0 || wordwrap[0]) {
        !           594:                                        if(ch=='/') {
        !           595:                                                bputs(text[MultiChatCommandPrompt]);
        !           596:                                                strcpy(str,"ACELWQ?*");
        !           597:                                                if(SYSOP)
        !           598:                                                        strcat(str,"0");
        !           599:                                                i=getkeys(str,total_chans);
        !           600:                                                if(i&0x80000000L) {  /* change channel */
        !           601:                                                        savch=i&~0x80000000L;
        !           602:                                                        if(savch==channel)
        !           603:                                                                continue;
        !           604:                                                        if(!chan_access(savch-1))
        !           605:                                                                continue;
        !           606:                                                        bprintf(text[WelcomeToChannelN]
        !           607:                                                                ,savch,chan[savch-1]->name);
        !           608: 
        !           609:                                                        usrs=0;
        !           610:                                                        for(i=1;i<=sys_nodes;i++) {
        !           611:                                                                if(i==node_num)
        !           612:                                                                        continue;
        !           613:                                                                getnodedat(i,&node,0);
        !           614:                                                                if(node.action!=NODE_MCHT
        !           615:                                                                        || node.status!=NODE_INUSE)
        !           616:                                                                        continue;
        !           617:                                                                if(node.aux && (node.aux&0xff)!=savch)
        !           618:                                                                        continue;
        !           619:                                                                printnodedat(i,node);
        !           620:                                                                if(node.aux&0x1f00) {   /* password */
        !           621:                                                                        bprintf(text[PasswordProtected]
        !           622:                                                                                ,node.misc&NODE_ANON
        !           623:                                                                                ? text[UNKNOWN_USER]
        !           624:                                                                                : username(node.useron,tmp));
        !           625:                                                                        if(!getstr(str,8,K_UPPER|K_ALPHA|K_LINE))
        !           626:                                                                                break;
        !           627:                                                                        if(strcmp(str,unpackchatpass(tmp,node)))
        !           628:                                                                                break;
        !           629:                                                                                bputs(text[CorrectPassword]);  }
        !           630:                                                                preusr[usrs]=usr[usrs++]=i; }
        !           631:                                                        if(i<=sys_nodes) {      /* failed password */
        !           632:                                                                bputs(text[WrongPassword]);
        !           633:                                                                continue; }
        !           634:                                                        if(gurubuf) {
        !           635:                                                                FREE(gurubuf);
        !           636:                                                                gurubuf=NULL; }
        !           637:                                                        if(chan[savch-1]->misc&CHAN_GURU
        !           638:                                                                && chan[savch-1]->guru<total_gurus
        !           639:                                                                && chk_ar(guru[chan[savch-1]->guru]->ar,useron
        !           640:                                                                )) {
        !           641:                                                                sprintf(str,"%s%s.DAT",ctrl_dir
        !           642:                                                                        ,guru[chan[savch-1]->guru]->code);
        !           643:                                 if((file=nopen(str,O_RDONLY))==-1) {
        !           644:                                     errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
        !           645:                                     break; }
        !           646:                                 if((gurubuf=MALLOC(filelength(file)+1))==NULL) {
        !           647:                                     close(file);
        !           648:                                                                        errormsg(WHERE,ERR_ALLOC,str
        !           649:                                                                                ,filelength(file)+1);
        !           650:                                     break; }
        !           651:                                 read(file,gurubuf,filelength(file));
        !           652:                                 gurubuf[filelength(file)]=0;
        !           653:                                 close(file); }
        !           654:                                                        preusrs=usrs;
        !           655:                                                        if(gurubuf)
        !           656:                                                                bprintf(text[NodeInMultiChatLocally]
        !           657:                                                                        ,sys_nodes+1
        !           658:                                                                        ,guru[chan[savch-1]->guru]->name
        !           659:                                                                        ,savch);
        !           660:                                                        channel=savch;
        !           661:                                                        if(!usrs && chan[savch-1]->misc&CHAN_PW
        !           662:                                                                && !noyes(text[PasswordProtectChanQ])) {
        !           663:                                                                bputs(text[PasswordPrompt]);
        !           664:                                                                if(getstr(str,8,K_UPPER|K_ALPHA|K_LINE)) {
        !           665:                                                                        getnodedat(node_num,&thisnode,1);
        !           666:                                                                        thisnode.aux=channel;
        !           667:                                                                        packchatpass(str,&thisnode); }
        !           668:                                                                else {
        !           669:                                                                        getnodedat(node_num,&thisnode,1);
        !           670:                                                                        thisnode.aux=channel; } }
        !           671:                                                        else {
        !           672:                                                                getnodedat(node_num,&thisnode,1);
        !           673:                                                                thisnode.aux=channel; }
        !           674:                                                        putnodedat(node_num,thisnode);
        !           675:                                                        bputs(text[YoureOnTheAir]);
        !           676:                                                        if(chan[channel-1]->cost
        !           677:                                                                && !(useron.exempt&FLAG('J')))
        !           678:                                                                subtract_cdt(chan[channel-1]->cost); }
        !           679:                                                else switch(i) {        /* other command */
        !           680:                                                        case '0':       /* Global channel */
        !           681:                                                                if(!SYSOP)
        !           682:                                                                        break;
        !           683:                                usrs=0;
        !           684:                                                                for(i=1;i<=sys_nodes;i++) {
        !           685:                                                                        if(i==node_num)
        !           686:                                                                                continue;
        !           687:                                                                        getnodedat(i,&node,0);
        !           688:                                                                        if(node.action!=NODE_MCHT
        !           689:                                                                                || node.status!=NODE_INUSE)
        !           690:                                                                                continue;
        !           691:                                                                        printnodedat(i,node);
        !           692:                                                                        preusr[usrs]=usr[usrs++]=i; }
        !           693:                                                                preusrs=usrs;
        !           694:                                                                getnodedat(node_num,&thisnode,1);
        !           695:                                                                thisnode.aux=channel=0;
        !           696:                                                                putnodedat(node_num,thisnode);
        !           697:                                                                break;
        !           698:                                                        case 'A':   /* Action commands */
        !           699:                                                                useron.chat^=CHAT_ACTION;
        !           700:                                                                bprintf("\r\nAction commands are now %s\r\n"
        !           701:                                                                        ,useron.chat&CHAT_ACTION
        !           702:                                                                        ? text[ON]:text[OFF]);
        !           703:                                                                putuserrec(useron.number,U_CHAT,8
        !           704:                                     ,ltoa(useron.chat,str,16));
        !           705:                                                                break;
        !           706:                                                        case 'C':   /* List of action commands */
        !           707:                                                                CRLF;
        !           708:                                                                for(i=0;i<total_chatacts;i++) {
        !           709:                                                                        if(chatact[i]->actset
        !           710:                                                                                !=chan[channel-1]->actset)
        !           711:                                                                                continue;
        !           712:                                                                        bprintf("%-*.*s",LEN_CHATACTCMD
        !           713:                                                                                ,LEN_CHATACTCMD,chatact[i]->cmd);
        !           714:                                                                        if(!((i+1)%8)) {
        !           715:                                                                                CRLF; }
        !           716:                                                                        else
        !           717:                                                                                bputs(" "); }
        !           718:                                                                CRLF;
        !           719:                                                                break;
        !           720:                                                        case 'E':   /* Toggle echo */
        !           721:                                                                useron.chat^=CHAT_ECHO;
        !           722:                                                                bprintf(text[EchoIsNow]
        !           723:                                                                        ,useron.chat&CHAT_ECHO
        !           724:                                                                        ? text[ON]:text[OFF]);
        !           725:                                                                putuserrec(useron.number,U_CHAT,8
        !           726:                                     ,ltoa(useron.chat,str,16));
        !           727:                                                                break;
        !           728:                                                        case 'L':       /* list nodes */
        !           729:                                                                CRLF;
        !           730:                                                                for(i=1;i<=sys_nodes && i<=sys_lastnode;i++) {
        !           731:                                                                        getnodedat(i,&node,0);
        !           732:                                                                        printnodedat(i,node); }
        !           733:                                                                CRLF;
        !           734:                                                                break;
        !           735:                                                        case 'W':   /* page node(s) */
        !           736:                                                                j=getnodetopage(0,0);
        !           737:                                                                if(!j)
        !           738:                                                                        break;
        !           739:                                                                for(i=0;i<usrs;i++)
        !           740:                                                                        if(usr[i]==j)
        !           741:                                                                                break;
        !           742:                                                                if(i>=usrs) {
        !           743:                                                                        bputs(text[UserNotFound]);
        !           744:                                                                        break; }
        !           745: 
        !           746:                                                                bputs(text[NodeMsgPrompt]);
        !           747:                                                                if(!getstr(line,66,K_LINE|K_MSG))
        !           748:                                                                        break;
        !           749: 
        !           750:                                                                sprintf(buf,text[ChatLineFmt]
        !           751:                                                                        ,thisnode.misc&NODE_ANON
        !           752:                                                                        ? text[AnonUserChatHandle]
        !           753:                                                                        : useron.handle
        !           754:                                                                        ,node_num,'*',line);
        !           755:                                                                strcat(buf,crlf);
        !           756:                                                                if(useron.chat&CHAT_ECHO)
        !           757:                                                                        bputs(buf);
        !           758:                                                                putnmsg(j,buf);
        !           759:                                                                break;
        !           760:                                                        case 'Q':       /* quit */
        !           761:                                                                done=1;
        !           762:                                                                break;
        !           763:                                                        case '*':
        !           764:                                                                sprintf(str,"%sMENU\\CHAN.*",text_dir);
        !           765:                                                                if(fexist(str))
        !           766:                                                                        menu("CHAN");
        !           767:                                                                else {
        !           768:                                                                        bputs(text[ChatChanLstHdr]);
        !           769:                                                                        bputs(text[ChatChanLstTitles]);
        !           770:                                                                        if(total_chans>=10) {
        !           771:                                                                                bputs("     ");
        !           772:                                                                                bputs(text[ChatChanLstTitles]); }
        !           773:                                                                        CRLF;
        !           774:                                                                        bputs(text[ChatChanLstUnderline]);
        !           775:                                                                        if(total_chans>=10) {
        !           776:                                                                                bputs("     ");
        !           777:                                                                                bputs(text[ChatChanLstUnderline]); }
        !           778:                                                                        CRLF;
        !           779:                                                                        if(total_chans>=10)
        !           780:                                                                                j=(total_chans/2)+(total_chans&1);
        !           781:                                                                        else
        !           782:                                                                                j=total_chans;
        !           783:                                                                        for(i=0;i<j && !msgabort();i++) {
        !           784:                                                                                bprintf(text[ChatChanLstFmt],i+1
        !           785:                                                                                        ,chan[i]->name
        !           786:                                                                                        ,chan[i]->cost);
        !           787:                                                                                if(total_chans>=10) {
        !           788:                                                                                        k=(total_chans/2)
        !           789:                                                                                                +i+(total_chans&1);
        !           790:                                                                                        if(k<total_chans) {
        !           791:                                                                                                bputs("     ");
        !           792:                                                                                                bprintf(text[ChatChanLstFmt]
        !           793:                                                                                                        ,k+1
        !           794:                                                                                                        ,chan[k]->name
        !           795:                                                                                                        ,chan[k]->cost); } }
        !           796:                                                                                CRLF; }
        !           797:                                                                        CRLF; }
        !           798:                                                                break;
        !           799:                                                        case '?':       /* menu */
        !           800:                                                                menu("MULTCHAT");
        !           801:                                                                break;  } }
        !           802:                                        else {
        !           803:                                                ungetkey(ch);
        !           804:                                                j=0;
        !           805:                                                pgraph[0]=0;
        !           806:                                                while(j<5) {
        !           807:                                                        if(!getstr(line,66,K_WRAP|K_MSG|K_CHAT))
        !           808:                                                                break;
        !           809:                                                        if(j) {
        !           810:                                                                sprintf(str,text[ChatLineFmt]
        !           811:                                                                        ,thisnode.misc&NODE_ANON
        !           812:                                                                        ? text[AnonUserChatHandle]
        !           813:                                                                        : useron.handle
        !           814:                                                                        ,node_num,':',nulstr);
        !           815:                                                                sprintf(tmp,"%*s",bstrlen(str),nulstr);
        !           816:                                                                strcat(pgraph,tmp); }
        !           817:                                                        strcat(pgraph,line);
        !           818:                                                        strcat(pgraph,crlf);
        !           819:                                                        if(!wordwrap[0])
        !           820:                                                                break;
        !           821:                                                        j++; }
        !           822:                                                if(pgraph[0]) {
        !           823:                                                        if(useron.chat&CHAT_ACTION) {
        !           824:                                                                for(i=0;i<total_chatacts;i++) {
        !           825:                                                                        if(chatact[i]->actset
        !           826:                                                                                !=chan[channel-1]->actset)
        !           827:                                         continue;
        !           828:                                                                        sprintf(str,"%s ",chatact[i]->cmd);
        !           829:                                                                        if(!strnicmp(str,pgraph,strlen(str)))
        !           830:                                                                                break;
        !           831:                                                                        sprintf(str,"%.*s"
        !           832:                                                                                ,LEN_CHATACTCMD+2,pgraph);
        !           833:                                                                        str[strlen(str)-2]=0;
        !           834:                                                                        if(!stricmp(chatact[i]->cmd,str))
        !           835:                                                                                break; }
        !           836: 
        !           837:                                                                if(i<total_chatacts) {
        !           838:                                                                        p=pgraph+strlen(str);
        !           839:                                                                        n=atoi(p);
        !           840:                                                                        for(j=0;j<usrs;j++) {
        !           841:                                                                                getnodedat(usr[j],&node,0);
        !           842:                                                                                if(usrs==1) /* no need to search */
        !           843:                                                                                        break;
        !           844:                                                                                if(n) {
        !           845:                                                                                        if(usr[j]==n)
        !           846:                                                                                                break;
        !           847:                                                                                        continue; }
        !           848:                                                                                username(node.useron,str);
        !           849:                                                                                if(!strnicmp(str,p,strlen(str)))
        !           850:                                                                                        break;
        !           851:                                                                                getuserrec(node.useron,U_HANDLE
        !           852:                                                                                        ,LEN_HANDLE,str);
        !           853:                                                                                if(!strnicmp(str,p,strlen(str)))
        !           854:                                                                                        break; }
        !           855:                                                                        if(!usrs
        !           856:                                                                                && chan[channel-1]->guru<total_gurus)
        !           857:                                                                                strcpy(str
        !           858:                                                                                ,guru[chan[channel-1]->guru]->name);
        !           859:                                                                        else if(j>=usrs)
        !           860:                                                                                strcpy(str,"everyone");
        !           861:                                                                        else if(node.misc&NODE_ANON)
        !           862:                                                                                strcpy(str,text[UNKNOWN_USER]);
        !           863:                                                                        else
        !           864:                                                                                username(node.useron,str);
        !           865: 
        !           866:                                                                        /* Display on same node */
        !           867:                                                                        bprintf(chatact[i]->out
        !           868:                                                                                ,thisnode.misc&NODE_ANON
        !           869:                                                                                ? text[UNKNOWN_USER] : useron.alias
        !           870:                                                                                ,str);
        !           871:                                                                        CRLF;
        !           872: 
        !           873:                                                                        if(usrs && j<usrs) {
        !           874:                                                                                /* Display to dest user */
        !           875:                                                                                sprintf(buf,chatact[i]->out
        !           876:                                                                                        ,thisnode.misc&NODE_ANON
        !           877:                                                                                        ? text[UNKNOWN_USER] : useron.alias
        !           878:                                                                                        ,"you");
        !           879:                                                                                strcat(buf,crlf);
        !           880:                                                                                putnmsg(usr[j],buf); }
        !           881: 
        !           882: 
        !           883:                                                                        /* Display to all other users */
        !           884:                                                                        sprintf(buf,chatact[i]->out
        !           885:                                                                                ,thisnode.misc&NODE_ANON
        !           886:                                                                                ? text[UNKNOWN_USER] : useron.alias
        !           887:                                                                                ,str);
        !           888:                                                                        strcat(buf,crlf);
        !           889: 
        !           890:                                                                        for(i=0;i<usrs;i++) {
        !           891:                                                                                if(i==j)
        !           892:                                                                                        continue;
        !           893:                                                                                getnodedat(usr[i],&node,0);
        !           894:                                                                                putnmsg(usr[i],buf); }
        !           895:                                                                        for(i=0;i<qusrs;i++) {
        !           896:                                                                                getnodedat(qusr[i],&node,0);
        !           897:                                                                                putnmsg(qusr[i],buf); }
        !           898:                                                                        continue; } }
        !           899: 
        !           900:                                                        sprintf(buf,text[ChatLineFmt]
        !           901:                                                                ,thisnode.misc&NODE_ANON
        !           902:                                                                ? text[AnonUserChatHandle]
        !           903:                                                                : useron.handle
        !           904:                                                                ,node_num,':',pgraph);
        !           905:                                                        if(useron.chat&CHAT_ECHO)
        !           906:                                                                bputs(buf);
        !           907:                                                        for(i=0;i<usrs;i++) {
        !           908:                                                                getnodedat(usr[i],&node,0);
        !           909:                                                                putnmsg(usr[i],buf); }
        !           910:                                                        for(i=0;i<qusrs;i++) {
        !           911:                                                                getnodedat(qusr[i],&node,0);
        !           912:                                                                putnmsg(qusr[i],buf); }
        !           913:                                                        if(!usrs && channel && gurubuf
        !           914:                                                                && chan[channel-1]->misc&CHAN_GURU)
        !           915:                                                                guruchat(pgraph,gurubuf,chan[channel-1]->guru);
        !           916:                                                                } } }
        !           917:                                else
        !           918:                                        mswait(1);
        !           919:                                if(sys_status&SS_ABORT)
        !           920:                                        break; }
        !           921:                        lncntr=0;
        !           922:                        break;
        !           923:                case 'P':   /* private node-to-node chat */
        !           924:             privchat();
        !           925:             break;
        !           926:                case 'C':
        !           927:                        no_rip_menu=1;
        !           928:                        ch=kbd_state();          /* Check scroll lock */
        !           929:                        if(ch&16 || (sys_chat_ar[0] && chk_ar(sys_chat_ar,useron))
        !           930:                                || useron.exempt&FLAG('C')) {
        !           931:                                sysop_page();
        !           932:                                break; }
        !           933:                        bprintf(text[SysopIsNotAvailable],sys_op);
        !           934:                        if(total_gurus && chk_ar(guru[0]->ar,useron)) {
        !           935:                                sprintf(str,text[ChatWithGuruInsteadQ],guru[0]->name);
        !           936:                                if(!yesno(str))
        !           937:                                        break; }
        !           938:                        else
        !           939:                                break;
        !           940:                case 'T':
        !           941:                        if(!total_gurus) {
        !           942:                                bprintf(text[SysopIsNotAvailable],"The Guru");
        !           943:                                break; }
        !           944:                        if(total_gurus==1 && chk_ar(guru[0]->ar,useron))
        !           945:                                i=0;
        !           946:                        else {
        !           947:                                for(i=0;i<total_gurus;i++)
        !           948:                                        uselect(1,i,nulstr,guru[i]->name,guru[i]->ar);
        !           949:                                i=uselect(0,0,0,0,0);
        !           950:                                if(i<0)
        !           951:                                        break; }
        !           952:                        if(gurubuf)
        !           953:                                FREE(gurubuf);
        !           954:                        sprintf(str,"%s%s.DAT",ctrl_dir,guru[i]->code);
        !           955:                        if((file=nopen(str,O_RDONLY))==-1) {
        !           956:                                errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
        !           957:                                return; }
        !           958:                        if((gurubuf=MALLOC(filelength(file)+1))==NULL) {
        !           959:                                close(file);
        !           960:                                errormsg(WHERE,ERR_ALLOC,str,filelength(file)+1);
        !           961:                                return; }
        !           962:                        read(file,gurubuf,filelength(file));
        !           963:                        gurubuf[filelength(file)]=0;
        !           964:                        close(file);
        !           965:                        localguru(gurubuf,i);
        !           966:                        no_rip_menu=1;
        !           967:                        FREE(gurubuf);
        !           968:                        gurubuf=NULL;
        !           969:                        break;
        !           970:                case '?':
        !           971:                        if(useron.misc&EXPERT)
        !           972:                                menu("CHAT");
        !           973:                        break;
        !           974:                default:        /* 'Q' or <CR> */
        !           975:                        lncntr=0;
        !           976:                        if(gurubuf)
        !           977:                                FREE(gurubuf);
        !           978:                        return; }
        !           979:        action=NODE_CHAT;
        !           980:        if(!(useron.misc&EXPERT) || useron.misc&WIP
        !           981:                || (useron.misc&RIP && !no_rip_menu)) {
        !           982: #if 0
        !           983:                sys_status&=~SS_ABORT;
        !           984:                if(lncntr) {
        !           985:                        SYNC;
        !           986:                        CRLF;
        !           987:                        if(lncntr)                      /* CRLF or SYNC can cause pause */
        !           988:                                pause(); }
        !           989: #endif
        !           990:                menu("CHAT"); }
        !           991:        ASYNC;
        !           992:        bputs(text[ChatPrompt]); }
        !           993: if(gurubuf)
        !           994:        FREE(gurubuf);
        !           995: }
        !           996: 
        !           997: int getnodetopage(int all, int telegram)
        !           998: {
        !           999:        static  uchar last[26];
        !          1000:        char    str[128];
        !          1001:        int     i,j;
        !          1002:        ulong   l;
        !          1003:        node_t  node;
        !          1004: 
        !          1005: if(!lastnodemsg)
        !          1006:        last[0]=0;
        !          1007: if(lastnodemsg) {
        !          1008:        getnodedat(lastnodemsg,&node,0);
        !          1009:     if(node.status!=NODE_INUSE && !SYSOP)
        !          1010:                lastnodemsg=1; }
        !          1011: for(j=0,i=1;i<=sys_nodes && i<=sys_lastnode;i++) {
        !          1012:        getnodedat(i,&node,0);
        !          1013:        if(i==node_num)
        !          1014:                continue;
        !          1015:        if(node.status==NODE_INUSE || (SYSOP && node.status==NODE_QUIET)) {
        !          1016:                if(!lastnodemsg)
        !          1017:                        lastnodemsg=i;
        !          1018:                j++; } }
        !          1019: 
        !          1020: if(!last[0])
        !          1021:        sprintf(last,"%u",lastnodemsg);
        !          1022: 
        !          1023: if(!j && !telegram) {
        !          1024:     bputs(text[NoOtherActiveNodes]);
        !          1025:        return(0); }
        !          1026: 
        !          1027: if(all)
        !          1028:        sprintf(str,text[NodeToSendMsgTo],lastnodemsg);
        !          1029: else
        !          1030:        sprintf(str,text[NodeToPrivateChat],lastnodemsg);
        !          1031: mnemonics(str);
        !          1032: 
        !          1033: strcpy(str,last);
        !          1034: getstr(str,25,K_UPRLWR|K_LINE|K_EDIT|K_AUTODEL);
        !          1035: if(sys_status&SS_ABORT)
        !          1036:        return(0);
        !          1037: if(!str[0])
        !          1038:        return(0);
        !          1039: 
        !          1040: j=atoi(str);
        !          1041: if(j && j<=sys_lastnode && j<=sys_nodes) {
        !          1042:        getnodedat(j,&node,0);
        !          1043:        if(node.status!=NODE_INUSE && !SYSOP) {
        !          1044:                bprintf(text[NodeNIsNotInUse],j);
        !          1045:                return(0); }
        !          1046:        if(telegram && node.misc&(NODE_POFF|NODE_ANON) && !SYSOP) {
        !          1047:                bprintf(text[CantPageNode],node.misc&NODE_ANON
        !          1048:                        ? text[UNKNOWN_USER] : username(node.useron,tmp));
        !          1049:                return(0); }
        !          1050:        strcpy(last,str);
        !          1051:        if(telegram)
        !          1052:                return(node.useron);
        !          1053:        return(j); }
        !          1054: if(all && !stricmp(str,"ALL"))
        !          1055:        return(-1);
        !          1056: 
        !          1057: if(str[0]=='\'') {
        !          1058:        j=userdatdupe(0,U_HANDLE,LEN_HANDLE,str+1,0);
        !          1059:        if(!j) {
        !          1060:                bputs(text[UnknownUser]);
        !          1061:                return(0); } }
        !          1062: else if(str[0]=='#')
        !          1063:     j=atoi(str+1);
        !          1064: else
        !          1065:        j=finduser(str);
        !          1066: if(!j)
        !          1067:        return(0);
        !          1068: if(j>lastuser())
        !          1069:        return(0);
        !          1070: getuserrec(j,U_MISC,8,tmp);
        !          1071: l=ahtoul(tmp);
        !          1072: if(l&(DELETED|INACTIVE)) {              /* Deleted or Inactive User */
        !          1073:     bputs(text[UnknownUser]);
        !          1074:        return(0); }
        !          1075: 
        !          1076: for(i=1;i<=sys_nodes && i<=sys_lastnode;i++) {
        !          1077:        getnodedat(i,&node,0);
        !          1078:        if((node.status==NODE_INUSE || (SYSOP && node.status==NODE_QUIET))
        !          1079:                && node.useron==j) {
        !          1080:                if(telegram && node.misc&NODE_POFF && !SYSOP) {
        !          1081:                        bprintf(text[CantPageNode],node.misc&NODE_ANON
        !          1082:                                ? text[UNKNOWN_USER] : username(node.useron,tmp));
        !          1083:                        return(0); }
        !          1084:                if(telegram)
        !          1085:                        return(j);
        !          1086:                strcpy(last,str);
        !          1087:                return(i); } }
        !          1088: if(telegram) {
        !          1089:        strcpy(last,str);
        !          1090:        return(j); }
        !          1091: bputs(text[UserNotFound]);
        !          1092: return(0);
        !          1093: }
        !          1094: 
        !          1095: 
        !          1096: /****************************************************************************/
        !          1097: /* Sending single line messages between nodes                               */
        !          1098: /****************************************************************************/
        !          1099: void nodemsg()
        !          1100: {
        !          1101:        static  inside;
        !          1102:        char    str[256],line[256],buf[512],ch;
        !          1103:        int     i,j,usernumber,done=0;
        !          1104:        node_t  node,savenode;
        !          1105: 
        !          1106: if(inside>1)   /* nested once only */
        !          1107:        return;
        !          1108: sys_status|=SS_IN_CTRLP;
        !          1109: getnodedat(node_num,&savenode,0);
        !          1110: inside++;
        !          1111: wordwrap[0]=0;
        !          1112: while(online && !done) {
        !          1113:        if(useron.rest&FLAG('C')) {
        !          1114:                bputs(text[R_SendMessages]);
        !          1115:                break; }
        !          1116:        SYNC;
        !          1117:        mnemonics(text[PrivateMsgPrompt]);
        !          1118:        sys_status&=~SS_ABORT;
        !          1119:        while(online) {          /* Watch for incoming messages */
        !          1120:                ch=toupper(inkey(0));
        !          1121:                if(ch && strchr("TMCQ\r",ch))
        !          1122:                        break;
        !          1123:                if(sys_status&SS_ABORT)
        !          1124:                        break;
        !          1125:                if(online==ON_REMOTE && rioctl(IOSTATE)&ABORT) {
        !          1126:                        sys_status|=SS_ABORT;
        !          1127:                        break; }
        !          1128:                getnodedat(node_num,&thisnode,0);
        !          1129:                if(thisnode.misc&(NODE_MSGW|NODE_NMSG)) {
        !          1130:                        SAVELINE;
        !          1131:                        CRLF;
        !          1132:                        if(thisnode.misc&NODE_NMSG)
        !          1133:                                getnmsg();
        !          1134:                        if(thisnode.misc&NODE_MSGW)
        !          1135:                                getsmsg(useron.number);
        !          1136:                        CRLF;
        !          1137:                        RESTORELINE; }
        !          1138:                else
        !          1139:                        nodesync();
        !          1140:                gettimeleft();
        !          1141:                checkline(); }
        !          1142: 
        !          1143:        if(!online || sys_status&SS_ABORT) {
        !          1144:                sys_status&=~SS_ABORT;
        !          1145:                CRLF;
        !          1146:                break; }
        !          1147: 
        !          1148:        switch(toupper(ch)) {
        !          1149:                case 'T':   /* Telegram */
        !          1150:                        bputs("Telegram\r\n");
        !          1151:                        usernumber=getnodetopage(0,1);
        !          1152:                        if(!usernumber)
        !          1153:                                break;
        !          1154: 
        !          1155:                        if(usernumber==1 && useron.rest&FLAG('S')) { /* ! val fback */
        !          1156:                                bprintf(text[R_Feedback],sys_op);
        !          1157:                                break; }
        !          1158:                        if(usernumber!=1 && useron.rest&FLAG('E')) {
        !          1159:                                bputs(text[R_Email]);
        !          1160:                                break; }
        !          1161:                        now=time(NULL);
        !          1162:                        bprintf("\1n\r\n\1mSending telegram to \1h%s #%u\1n\1m (Max 5 "
        !          1163:                                "lines, Blank line ends):\r\n\r\n\1g\1h"
        !          1164:                                ,username(usernumber,tmp),usernumber);
        !          1165:                        sprintf(buf,"\1n\1g\7Telegram from \1n\1h%s\1n\1g on %s:\r\n\1h"
        !          1166:                                ,thisnode.misc&NODE_ANON ? text[UNKNOWN_USER] : useron.alias
        !          1167:                                ,timestr(&now));
        !          1168:                        i=0;
        !          1169:                        while(online && i<5) {
        !          1170:                                bprintf("%4s",nulstr);
        !          1171:                                if(!getstr(line,70,K_WRAP|K_MSG))
        !          1172:                                        break;
        !          1173:                                sprintf(str,"%4s%s\r\n",nulstr,line);
        !          1174:                                strcat(buf,str);
        !          1175:                                i++; }
        !          1176:                        if(!i)
        !          1177:                                break;
        !          1178:                        if(sys_status&SS_ABORT) {
        !          1179:                                CRLF;
        !          1180:                                break; }
        !          1181:                        putsmsg(usernumber,buf);
        !          1182:                        sprintf(str,"Sent telegram to %s #%u"
        !          1183:                                ,username(usernumber,tmp),usernumber);
        !          1184:                        logline("C",str);
        !          1185:                        logline(nulstr,line);
        !          1186:                        bprintf("\1n\1mTelegram sent to \1h%s\r\n"
        !          1187:                                ,username(usernumber,tmp));
        !          1188:                        break;
        !          1189:                case 'M':   /* Message */
        !          1190:                        bputs("Message\r\n");
        !          1191:                        i=getnodetopage(1,0);
        !          1192:                        if(!i)
        !          1193:                                break;
        !          1194:                        if(i!=-1) {
        !          1195:                                getnodedat(i,&node,0);
        !          1196:                                usernumber=node.useron;
        !          1197:                                if(node.misc&NODE_POFF && !SYSOP)
        !          1198:                                        bprintf(text[CantPageNode],node.misc&NODE_ANON
        !          1199:                                                ? text[UNKNOWN_USER] : username(node.useron,tmp));
        !          1200:                                else {
        !          1201:                                        bprintf("\r\n\1n\1mSending message to \1h%s\r\n"
        !          1202:                                                ,node.misc&NODE_ANON ? text[UNKNOWN_USER]
        !          1203:                                                : username(node.useron,tmp));
        !          1204:                                        bputs(text[NodeMsgPrompt]);
        !          1205:                                        if(!getstr(line,69,K_LINE))
        !          1206:                                                break;
        !          1207:                                        sprintf(buf,text[NodeMsgFmt],node_num
        !          1208:                                                ,thisnode.misc&NODE_ANON
        !          1209:                                                        ? text[UNKNOWN_USER] : useron.alias,line);
        !          1210:                                        putnmsg(i,buf);
        !          1211:                                        if(!(node.misc&NODE_ANON))
        !          1212:                                                bprintf("\r\n\1n\1mMessage sent to \1h%s #%u\r\n"
        !          1213:                                                        ,username(usernumber,tmp),usernumber);
        !          1214:                                        sprintf(str,"Sent message to %s on node %d:"
        !          1215:                                                ,username(usernumber,tmp),i);
        !          1216:                                        logline("C",str);
        !          1217:                                        logline(nulstr,line); } }
        !          1218:                        else {  /* ALL */
        !          1219:                                bputs(text[NodeMsgPrompt]);
        !          1220:                                if(!getstr(line,70,K_LINE))
        !          1221:                                        break;
        !          1222:                                sprintf(buf,text[AllNodeMsgFmt],node_num
        !          1223:                                        ,thisnode.misc&NODE_ANON
        !          1224:                                                ? text[UNKNOWN_USER] : useron.alias,line);
        !          1225:                                for(i=1;i<=sys_nodes;i++) {
        !          1226:                                        if(i==node_num)
        !          1227:                                                continue;
        !          1228:                                        getnodedat(i,&node,0);
        !          1229:                                        if((node.status==NODE_INUSE
        !          1230:                                                || (SYSOP && node.status==NODE_QUIET))
        !          1231:                                                && (SYSOP || !(node.misc&NODE_POFF)))
        !          1232:                                                putnmsg(i,buf); }
        !          1233:                                logline("C","Sent message to all nodes");
        !          1234:                                logline(nulstr,line); }
        !          1235:                        break;
        !          1236:                case 'C':   /* Chat */
        !          1237:                        bputs("Chat\r\n");
        !          1238:                        if(action==NODE_PCHT) { /* already in pchat */
        !          1239:                                done=1;
        !          1240:                                break; }
        !          1241:                        privchat();
        !          1242:                        action=savenode.action;
        !          1243:                        break;
        !          1244:                default:
        !          1245:                        bputs("Quit\r\n");
        !          1246:                        done=1;
        !          1247:                        break; } }
        !          1248: inside--;
        !          1249: if(!inside)
        !          1250:        sys_status&=~SS_IN_CTRLP;
        !          1251: getnodedat(node_num,&thisnode,1);
        !          1252: thisnode.action=action=savenode.action;
        !          1253: thisnode.aux=savenode.aux;
        !          1254: thisnode.extaux=savenode.extaux;
        !          1255: putnodedat(node_num,thisnode);
        !          1256: }
        !          1257: 
        !          1258: /****************************************************************************/
        !          1259: /* The guru will respond from the 'guru' buffer to 'line'                   */
        !          1260: /****************************************************************************/
        !          1261: void guruchat(char *line, char *gurubuf, int gurunum)
        !          1262: {
        !          1263:        char    str[256],cstr[256],*ptr,c,*answer[100],answers,theanswer[769]
        !          1264:                        ,mistakes=1,hu=0;
        !          1265:        int     i,j,k,file;
        !          1266:        long    len;
        !          1267:        struct  tm *tm;
        !          1268: 
        !          1269: now=time(NULL);
        !          1270: tm=localtime(&now);
        !          1271: 
        !          1272: for(i=0;i<100;i++) {
        !          1273:        if((answer[i]=MALLOC(513))==NULL) {
        !          1274:                errormsg(WHERE,ERR_ALLOC,nulstr,513);
        !          1275:                while(i) {
        !          1276:                        i--;
        !          1277:                        FREE(answer[i]); }
        !          1278:                sys_status&=~SS_GURUCHAT;
        !          1279:                return; } }
        !          1280: ptr=gurubuf;
        !          1281: len=strlen(gurubuf);
        !          1282: strupr(line);
        !          1283: j=strlen(line);
        !          1284: k=0;
        !          1285: for(i=0;i<j;i++) {
        !          1286:        if(!isalnum(line[i]) && !k)     /* beginning non-alphanumeric */
        !          1287:                continue;
        !          1288:        if(!isalnum(line[i]) && line[i]==line[i+1])     /* redundant non-alnum */
        !          1289:                continue;
        !          1290:        if(!isalnum(line[i]) && line[i+1]=='?') /* fix "WHAT ?" */
        !          1291:                continue;
        !          1292:        cstr[k++]=line[i]; }
        !          1293: cstr[k]=0;
        !          1294: while(--k) {
        !          1295:        if(!isalnum(cstr[k]))
        !          1296:                continue;
        !          1297:        break; }
        !          1298: if(k<1) {
        !          1299:        for(i=0;i<100;i++)
        !          1300:                FREE(answer[i]);
        !          1301:        return; }
        !          1302: if(cstr[k+1]=='?')
        !          1303:        k++;
        !          1304: cstr[k+1]=0;
        !          1305: while(*ptr && ptr<gurubuf+len) {
        !          1306:        if(*ptr=='(') {
        !          1307:                ptr++;
        !          1308:                if(!guruexp(&ptr,cstr)) {
        !          1309:                        while(*ptr && *ptr!='(' && ptr<gurubuf+len)
        !          1310:                                ptr++;
        !          1311:                        continue; } }
        !          1312:        else {
        !          1313:                while(*ptr && *ptr!=LF && ptr<gurubuf+len) /* skip LF after ')' */
        !          1314:                        ptr++;
        !          1315:                ptr++;
        !          1316:                answers=0;
        !          1317:                while(*ptr && answers<100 && ptr<gurubuf+len) {
        !          1318:                        i=0;
        !          1319:                        while(*ptr && *ptr!=CR && i<512 && ptr<gurubuf+len) {
        !          1320:                                answer[answers][i]=*ptr;
        !          1321:                                ptr++;
        !          1322:                                i++;
        !          1323:                                if(*ptr=='\\' && *(ptr+1)==CR) {        /* multi-line answer */
        !          1324:                                        ptr+=3; /* skip \CRLF */
        !          1325:                                        answer[answers][i++]=CR;
        !          1326:                                        answer[answers][i++]=LF; } }
        !          1327:                        answer[answers][i]=0;
        !          1328:                        if(!strlen(answer[answers]) || answer[answers][0]=='(') {
        !          1329:                                ptr-=strlen(answer[answers]);
        !          1330:                                break; }
        !          1331:                        ptr+=2; /* skip CRLF */
        !          1332:                        answers++; }
        !          1333:                if(answers==100)
        !          1334:                        while(*ptr && *ptr!='(' && ptr<gurubuf+len)
        !          1335:                                ptr++;
        !          1336:                i=random(answers);
        !          1337:                for(j=0,k=0;j<strlen(answer[i]);j++) {
        !          1338:                        if(answer[i][j]=='`') {
        !          1339:                                j++;
        !          1340:                                theanswer[k]=0;
        !          1341:                                switch(toupper(answer[i][j])) {
        !          1342:                                        case 'A':
        !          1343:                                                if(sys_status&SS_USERON)
        !          1344:                                                        strcat(theanswer,useron.alias);
        !          1345:                                                else
        !          1346:                                                        strcat(theanswer,text[UNKNOWN_USER]);
        !          1347:                                                break;
        !          1348:                                        case 'B':
        !          1349:                                                if(sys_status&SS_USERON)
        !          1350:                                                        strcat(theanswer,useron.birth);
        !          1351:                                                else
        !          1352:                                                        strcat(theanswer,"00/00/00");
        !          1353:                                                break;
        !          1354:                                        case 'C':
        !          1355:                        if(sys_status&SS_USERON)
        !          1356:                                                        strcat(theanswer,useron.comp);
        !          1357:                                                else
        !          1358:                                                        strcat(theanswer,"PC Jr.");
        !          1359:                                                break;
        !          1360:                                        case 'D':
        !          1361:                        if(sys_status&SS_USERON)
        !          1362:                                                        strcat(theanswer,ultoac(useron.dlb,tmp));
        !          1363:                                                else
        !          1364:                                                        strcat(theanswer,"0");
        !          1365:                                                break;
        !          1366:                                        case 'G':
        !          1367:                                                strcat(theanswer,guru[gurunum]->name);
        !          1368:                                                break;
        !          1369:                                        case 'H':
        !          1370:                                                hu=1;
        !          1371:                                                break;
        !          1372:                                        case 'I':
        !          1373:                                                strcat(theanswer,sys_id);
        !          1374:                                                break;
        !          1375:                                        case 'J':
        !          1376:                                                sprintf(tmp,"%u",tm->tm_mday);
        !          1377:                                                break;
        !          1378:                                        case 'L':
        !          1379:                        if(sys_status&SS_USERON)
        !          1380:                                                        strcat(theanswer,itoa(useron.level,tmp,10));
        !          1381:                                                else
        !          1382:                                                        strcat(theanswer,"0");
        !          1383:                                                break;
        !          1384:                                        case 'M':
        !          1385:                                                strcat(theanswer,month[tm->tm_mon]);
        !          1386:                                                break;
        !          1387:                                        case 'N':   /* Note */
        !          1388:                        if(sys_status&SS_USERON)
        !          1389:                                                        strcat(theanswer,useron.note);
        !          1390:                                                else
        !          1391:                                                        strcat(theanswer,text[UNKNOWN_USER]);
        !          1392:                                                break;
        !          1393:                                        case 'O':
        !          1394:                                                strcat(theanswer,sys_op);
        !          1395:                                                break;
        !          1396:                                        case 'P':
        !          1397:                        if(sys_status&SS_USERON)
        !          1398:                                                        strcat(theanswer,useron.phone);
        !          1399:                                                else
        !          1400:                                                        strcat(theanswer,"000-000-0000");
        !          1401:                                                break;
        !          1402:                                        case 'Q':
        !          1403:                                                        sys_status&=~SS_GURUCHAT;
        !          1404:                                                break;
        !          1405:                                        case 'R':
        !          1406:                        if(sys_status&SS_USERON)
        !          1407:                                                        strcat(theanswer,useron.name);
        !          1408:                                                else
        !          1409:                                                        strcat(theanswer,text[UNKNOWN_USER]);
        !          1410:                                                break;
        !          1411:                                        case 'S':
        !          1412:                                                strcat(theanswer,sys_name);
        !          1413:                                                break;
        !          1414:                                        case 'T':
        !          1415:                                                sprintf(tmp,"%u:%02u",tm->tm_hour>12 ? tm->tm_hour-12
        !          1416:                                                        : tm->tm_hour,tm->tm_min);
        !          1417:                                                strcat(theanswer,tmp);
        !          1418:                                                break;
        !          1419:                                        case 'U':
        !          1420:                        if(sys_status&SS_USERON)
        !          1421:                                                        strcat(theanswer,ultoac(useron.ulb,tmp));
        !          1422:                                                else
        !          1423:                                                        strcat(theanswer,"0");
        !          1424:                                                break;
        !          1425:                                        case 'W':
        !          1426:                                                strcat(theanswer,weekday[tm->tm_wday]);
        !          1427:                                                break;
        !          1428:                                        case 'Y':   /* Current year */
        !          1429:                                                sprintf(tmp,"%u",1900+tm->tm_year);
        !          1430:                                                strcat(theanswer,tmp);
        !          1431:                                                break;
        !          1432:                                        case 'Z':
        !          1433:                                                if(sys_status&SS_USERON)
        !          1434:                                                        strcat(theanswer,useron.zipcode);
        !          1435:                         else
        !          1436:                                                        strcat(theanswer,"90210");
        !          1437:                                                break;
        !          1438:                                        case '$':   /* Credits */
        !          1439:                        if(sys_status&SS_USERON)
        !          1440:                                                        strcat(theanswer,ultoac(useron.cdt,tmp));
        !          1441:                                                else
        !          1442:                                                        strcat(theanswer,"0");
        !          1443:                                                break;
        !          1444:                                        case '#':
        !          1445:                        if(sys_status&SS_USERON)
        !          1446:                                                        strcat(theanswer,itoa(getage(useron.birth)
        !          1447:                                                                ,tmp,10));
        !          1448:                                                else
        !          1449:                                                        strcat(theanswer,"0");
        !          1450:                                                break;
        !          1451:                                        case '!':
        !          1452:                                                mistakes=!mistakes;
        !          1453:                                                break;
        !          1454:                                        case '_':
        !          1455:                                                mswait(500);
        !          1456:                                                break; }
        !          1457:                                k=strlen(theanswer); }
        !          1458:                        else
        !          1459:                                theanswer[k++]=answer[i][j]; }
        !          1460:                theanswer[k]=0;
        !          1461:                mswait(500+random(1000));        /* thinking time */
        !          1462:                if(action!=NODE_MCHT) {
        !          1463:                        for(i=0;i<k;i++) {
        !          1464:                                if(mistakes && theanswer[i]!=theanswer[i-1] &&
        !          1465:                                        ((!isalnum(theanswer[i]) && !random(100))
        !          1466:                                        || (isalnum(theanswer[i]) && !random(30)))) {
        !          1467:                                        c=j=random(3)+1;        /* 1 to 3 chars */
        !          1468:                                        if(c<strcspn(theanswer+(i+1),"\0., "))
        !          1469:                                                c=j=1;
        !          1470:                                        while(j) {
        !          1471:                                                outchar(97+random(26));
        !          1472:                                                mswait(25+random(150));
        !          1473:                                                j--; }
        !          1474:                                        if(random(100)) {
        !          1475:                                                mswait(100+random(300));
        !          1476:                                                while(c) {
        !          1477:                                                        bputs("\b \b");
        !          1478:                                                        mswait(50+random(50));
        !          1479:                                                        c--; } } }
        !          1480:                                outchar(theanswer[i]);
        !          1481:                                if(theanswer[i]==theanswer[i+1])
        !          1482:                                        mswait(25+random(50));
        !          1483:                                else
        !          1484:                                        mswait(25+random(150));
        !          1485:                                if(theanswer[i]==SP)
        !          1486:                                        mswait(random(50)); } }
        !          1487:                else {
        !          1488:                        mswait(strlen(theanswer)*100);
        !          1489:                        bprintf(text[ChatLineFmt],guru[gurunum]->name
        !          1490:                                ,sys_nodes+1,':',theanswer); }
        !          1491:                CRLF;
        !          1492:                sprintf(str,"%sGURU.LOG",data_dir);
        !          1493:                if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1)
        !          1494:                        errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_APPEND);
        !          1495:                else {
        !          1496:                        if(action==NODE_MCHT) {
        !          1497:                                sprintf(str,"[Multi] ");
        !          1498:                                write(file,str,strlen(str)); }
        !          1499:                        sprintf(str,"%s:\r\n",sys_status&SS_USERON
        !          1500:                                ? useron.alias : "UNKNOWN");
        !          1501:                        write(file,str,strlen(str));
        !          1502:                        write(file,line,strlen(line));
        !          1503:                        if(action!=NODE_MCHT)
        !          1504:                                write(file,crlf,2);
        !          1505:                        sprintf(str,"%s:\r\n",guru[gurunum]->name);
        !          1506:                        write(file,str,strlen(str));
        !          1507:                        write(file,theanswer,strlen(theanswer));
        !          1508:                        write(file,crlf,2);
        !          1509:                        close(file); }
        !          1510:                if(hu)
        !          1511:                        hangup();
        !          1512:                break; } }
        !          1513: for(i=0;i<100;i++)
        !          1514:        FREE(answer[i]);
        !          1515: }
        !          1516: 
        !          1517: /****************************************************************************/
        !          1518: /* An expression from the guru's buffer 'ptrptr' is evaluated and true or   */
        !          1519: /* false is returned.                                                       */
        !          1520: /****************************************************************************/
        !          1521: char guruexp(char **ptrptr, char *line)
        !          1522: {
        !          1523:        char    c,*cp,str[256],true=0,and=0,or=0,nest,*ar;
        !          1524: 
        !          1525: if((**ptrptr)==')') {  /* expressions of () are always true */
        !          1526:        (*ptrptr)++;
        !          1527:        return(1); }
        !          1528: while((**ptrptr)!=')' && (**ptrptr)) {
        !          1529:        if((**ptrptr)=='[') {
        !          1530:                (*ptrptr)++;
        !          1531:                sprintf(str,"%.128s",*ptrptr);
        !          1532:                while(**ptrptr && (**ptrptr)!=']')
        !          1533:             (*ptrptr)++;
        !          1534:         (*ptrptr)++;
        !          1535:                cp=strchr(str,']');
        !          1536:                if(cp) *cp=0;
        !          1537:                ar=arstr(NULL,str);
        !          1538:                c=chk_ar(ar,useron);
        !          1539:                if(ar[0]!=AR_NULL)
        !          1540:                        FREE(ar);
        !          1541:                if(!c && and) {
        !          1542:                        true=0;
        !          1543:             break; }
        !          1544:                if(c && or) {
        !          1545:                        true=1;
        !          1546:                        break; }
        !          1547:                if(c)
        !          1548:                        true=1;
        !          1549:                continue; }
        !          1550:        if((**ptrptr)=='(') {
        !          1551:                (*ptrptr)++;
        !          1552:                c=guruexp(&(*ptrptr),line);
        !          1553:                if(!c && and) {
        !          1554:                        true=0;
        !          1555:                        break; }
        !          1556:                if(c && or) {
        !          1557:                        true=1;
        !          1558:                        break; }
        !          1559:                if(c)
        !          1560:                        true=1; }
        !          1561:        if((**ptrptr)==')')
        !          1562:                break;
        !          1563:        c=0;
        !          1564:        while((**ptrptr) && isspace(**ptrptr))
        !          1565:                (*ptrptr)++;
        !          1566:        while((**ptrptr)!='|' && (**ptrptr)!='&' && (**ptrptr)!=')' &&(**ptrptr)) {
        !          1567:                str[c++]=(**ptrptr);
        !          1568:                (*ptrptr)++; }
        !          1569:        str[c]=0;
        !          1570:        if((**ptrptr)=='|') {
        !          1571:                if(!c && true)
        !          1572:                        break;
        !          1573:                and=0;
        !          1574:                or=1; }
        !          1575:        else if((**ptrptr)=='&') {
        !          1576:                if(!c && !true)
        !          1577:                        break;
        !          1578:                and=1;
        !          1579:                or=0; }
        !          1580:        if(!c) {                                /* support ((exp)op(exp)) */
        !          1581:                (*ptrptr)++;
        !          1582:                continue; }
        !          1583:        if((**ptrptr)!=')')
        !          1584:                (*ptrptr)++;
        !          1585:        c=0;                                    /* c now used for start line flag */
        !          1586:        if(str[strlen(str)-1]=='^') {   /* ^signifies start of line only */
        !          1587:                str[strlen(str)-1]=0;
        !          1588:                c=1; }
        !          1589:        if(str[strlen(str)-1]=='~') {   /* ~signifies non-isolated word */
        !          1590:                str[strlen(str)-1]=0;
        !          1591:                cp=strstr(line,str);
        !          1592:                if(c && cp!=line)
        !          1593:                        cp=0; }
        !          1594:        else {
        !          1595:                cp=strstr(line,str);
        !          1596:                if(cp && c) {
        !          1597:                        if(cp!=line || isalnum(*(cp+strlen(str))))
        !          1598:                                cp=0; }
        !          1599:                else {  /* must be isolated word */
        !          1600:                        while(cp)
        !          1601:                                if((cp!=line && isalnum(*(cp-1)))
        !          1602:                                        || isalnum(*(cp+strlen(str))))
        !          1603:                                        cp=strstr(cp+strlen(str),str);
        !          1604:                                else
        !          1605:                                        break; } }
        !          1606:        if(!cp && and) {
        !          1607:                true=0;
        !          1608:                break; }
        !          1609:        if(cp && or) {
        !          1610:                true=1;
        !          1611:                break; }
        !          1612:        if(cp)
        !          1613:                true=1; }
        !          1614: nest=0;
        !          1615: while((**ptrptr)!=')' && (**ptrptr)) {         /* handle nested exp */
        !          1616:        if((**ptrptr)=='(')                                             /* (TRUE|(IGNORE)) */
        !          1617:                nest++;
        !          1618:        (*ptrptr)++;
        !          1619:        while((**ptrptr)==')' && nest && (**ptrptr)) {
        !          1620:                nest--;
        !          1621:                (*ptrptr)++; } }
        !          1622: (*ptrptr)++;   /* skip over ')' */
        !          1623: return(true);
        !          1624: }
        !          1625: 
        !          1626: /****************************************************************************/
        !          1627: /* Guru chat with the appearance of Local chat with sysop.                  */
        !          1628: /****************************************************************************/
        !          1629: void localguru(char *gurubuf, int gurunum)
        !          1630: {
        !          1631:        char    ch,str[256];
        !          1632:        int     con=console;             /* save console state */
        !          1633: 
        !          1634: if(sys_status&SS_GURUCHAT || !total_gurus)
        !          1635:        return;
        !          1636: sys_status|=SS_GURUCHAT;
        !          1637: console&=~(CON_L_ECHOX|CON_R_ECHOX);   /* turn off X's */
        !          1638: console|=(CON_L_ECHO|CON_R_ECHO);                                      /* make sure echo is on */
        !          1639: if(action==NODE_CHAT) {        /* only page if from chat section */
        !          1640:        bprintf(text[PagingGuru],guru[gurunum]->name);
        !          1641:        ch=random(25)+25;
        !          1642:        while(ch--) {
        !          1643:                mswait(200);
        !          1644:                outchar('.'); } }
        !          1645: bprintf(text[SysopIsHere],guru[gurunum]->name);
        !          1646: getnodedat(node_num,&thisnode,1);
        !          1647: thisnode.aux=gurunum;
        !          1648: putnodedat(node_num,thisnode);
        !          1649: attr(color[clr_chatlocal]);
        !          1650: guruchat("HELLO",gurubuf,gurunum);
        !          1651: while(online && (sys_status&SS_GURUCHAT)) {
        !          1652:        checkline();
        !          1653:        action=NODE_GCHT;
        !          1654:        SYNC;
        !          1655:        if((ch=inkey(0))!=0) {
        !          1656:                ungetkey(ch);
        !          1657:                attr(color[clr_chatremote]);
        !          1658:                if(getstr(str,78,K_WRAP|K_CHAT)) {
        !          1659:                        attr(color[clr_chatlocal]);
        !          1660:                        guruchat(str,gurubuf,gurunum); } }
        !          1661:        else
        !          1662:                mswait(1); }
        !          1663: bputs(text[EndOfChat]);
        !          1664: sys_status&=~SS_GURUCHAT;
        !          1665: console=con;                           /* restore console state */
        !          1666: }
        !          1667: 
        !          1668: /****************************************************************************/
        !          1669: /* Packs the password 'pass' into 5bit ASCII inside node_t. 32bits in          */
        !          1670: /* node.extaux, and the other 8bits in the upper byte of node.aux                      */
        !          1671: /****************************************************************************/
        !          1672: void packchatpass(char *pass, node_t *node)
        !          1673: {
        !          1674:        char    bits;
        !          1675:        int             i,j;
        !          1676: 
        !          1677: node->aux&=~0xff00;            /* clear the password */
        !          1678: node->extaux=0L;
        !          1679: if((j=strlen(pass))==0) /* there isn't a password */
        !          1680:        return;
        !          1681: node->aux|=(int)((pass[0]-64)<<8);  /* 1st char goes in low 5bits of aux */
        !          1682: if(j==1)       /* password is only one char, we're done */
        !          1683:        return;
        !          1684: node->aux|=(int)((pass[1]-64)<<13); /* low 3bits of 2nd char go in aux */
        !          1685: node->extaux|=(long)((pass[1]-64)>>3); /* high 2bits of 2nd char go extaux */
        !          1686: bits=2;
        !          1687: for(i=2;i<j;i++) {     /* now process the 3rd char through the last */
        !          1688:        node->extaux|=(long)((long)(pass[i]-64)<<bits);
        !          1689:        bits+=5; }
        !          1690: }
        !          1691: 
        !          1692: /****************************************************************************/
        !          1693: /* Unpacks the password 'pass' from the 5bit ASCII inside node_t. 32bits in */
        !          1694: /* node.extaux, and the other 8bits in the upper byte of node.aux                      */
        !          1695: /****************************************************************************/
        !          1696: char *unpackchatpass(char *pass, node_t node)
        !          1697: {
        !          1698:        char    bits;
        !          1699:        int     i;
        !          1700: 
        !          1701: pass[0]=(node.aux&0x1f00)>>8;
        !          1702: pass[1]=((node.aux&0xe000)>>13)|((node.extaux&0x3)<<3);
        !          1703: bits=2;
        !          1704: for(i=2;i<8;i++) {
        !          1705:        pass[i]=(node.extaux>>bits)&0x1f;
        !          1706:        bits+=5; }
        !          1707: pass[8]=0;
        !          1708: for(i=0;i<8;i++)
        !          1709:        if(pass[i])
        !          1710:                pass[i]+=64;
        !          1711: return(pass);
        !          1712: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.