![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to getnode.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to getnode.cpp CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* getnode.cpp */
2:
3: /* Synchronet node information retrieval functions */
4:
5: /* $Id: getnode.cpp,v 1.29 2005/09/20 03:39:51 deuce Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2003 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This program is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU General Public License for more details: gpl.txt or *
18: * http://www.fsf.org/copyleft/gpl.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include "sbbs.h"
39: #include "cmdshell.h"
40:
41: /****************************************************************************/
42: /* Reads the data for node number 'number' into the structure 'node' */
43: /* from NODE.DAB */
44: /* if lockit is non-zero, locks this node's record. putnodedat() unlocks it */
45: /****************************************************************************/
46: int sbbs_t::getnodedat(uint number, node_t *node, bool lockit)
47: {
48: char str[MAX_PATH+1];
49: int rd=sizeof(node_t);
50: int count;
51:
52: if(node==NULL || number<1)
53: return(-1);
54:
55: if(number>cfg.sys_nodes) {
56: errormsg(WHERE,ERR_CHK,"node number",number);
57: return(-1);
58: }
59:
60: if(node!=&thisnode)
61: memset(node,0,sizeof(node_t));
62: sprintf(str,"%snode.dab",cfg.ctrl_dir);
63: if(nodefile==-1) {
64: if((nodefile=nopen(str,O_RDWR|O_DENYNONE))==-1) {
65: errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_DENYNONE);
66: return(errno);
67: }
68: }
69: else
70: utime(str,NULL); /* NFS fix... utime() forces a cache refresh */
71:
72: number--; /* make zero based */
73: for(count=0;count<LOOP_NODEDAB;count++) {
74: if(count)
75: mswait(100);
76: if(lockit && lock(nodefile,(long)number*sizeof(node_t),sizeof(node_t))!=0) {
77: unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
78: continue;
79: }
80: lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
81: rd=read(nodefile,node,sizeof(node_t));
82: if(!lockit || rd!=sizeof(node_t))
83: unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
84: if(rd==sizeof(node_t))
85: break;
86: }
87: if(!lockit && cfg.node_misc&NM_CLOSENODEDAB) {
88: close(nodefile);
89: nodefile=-1;
90: }
91:
92: if(count==LOOP_NODEDAB) {
93: errormsg(WHERE,rd==sizeof(node_t) ? ERR_LOCK : ERR_READ,"node.dab",number+1);
94: return(-2);
95: }
96: if(count>(LOOP_NODEDAB/2)) {
97: sprintf(str,"NODE.DAB (node %d) COLLISION - Count: %d"
98: ,number+1, count);
99: logline("!!",str);
100: }
101:
102: return(0);
103: }
104:
105: /****************************************************************************/
106: /* Synchronizes all the nodes knowledge of the other nodes' actions, mode, */
107: /* status and other flags. */
108: /* Assumes that getnodedat(node_num,&thisnode,0) was called right before it */
109: /* is called. */
110: /****************************************************************************/
111: void sbbs_t::nodesync()
112: {
113: char str[256],today[32];
114: int atr=curatr;
115:
116: if(nodesync_inside || !online)
117: return;
118: nodesync_inside=1;
119:
120: if(thisnode.action!=action) {
121: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
122: thisnode.action=action;
123: putnodedat(cfg.node_num,&thisnode);
124: }
125: }
126:
127: criterrs=thisnode.errors;
128:
129: if(sys_status&SS_USERON) {
130:
131: if(thisnode.status==NODE_WFC) {
132: errorlog("NODE STATUS FIXUP");
133: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
134: thisnode.status=NODE_INUSE;
135: putnodedat(cfg.node_num,&thisnode);
136: }
137: }
138:
139: if(!(sys_status&SS_NEWDAY)) {
140: now=time(NULL);
141: unixtodstr(&cfg,logontime,str);
142: unixtodstr(&cfg,now,today);
143: if(strcmp(str,today)) { /* New day, clear "today" user vars */
144: sys_status|=SS_NEWDAY; // So we don't keep doing this over&over
145: resetdailyuserdat(&cfg,&useron);
146: }
147: }
148: if(thisnode.misc&NODE_UDAT && !(useron.rest&FLAG('G'))) { /* not guest */
149: getuserdat(&cfg, &useron);
150: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
151: thisnode.misc&=~NODE_UDAT;
152: putnodedat(cfg.node_num,&thisnode);
153: }
154: }
155: if(thisnode.misc&NODE_MSGW)
156: getsmsg(useron.number); /* getsmsg clears MSGW flag */
157: if(thisnode.misc&NODE_NMSG)
158: getnmsg(); /* getnmsg clears NMSG flag */
159: }
160:
161: if(cfg.sync_mod[0])
162: exec_bin(cfg.sync_mod,&main_csi);
163:
164: if(thisnode.misc&NODE_INTR) {
165: bputs(text[NodeLocked]);
166: logline(nulstr,"Interrupted");
167: hangup();
168: nodesync_inside=0;
169: return;
170: }
171:
172: if(thisnode.misc&NODE_LCHAT) { // pulled into local chat with sysop
173: SAVELINE;
174: privchat(true);
175: RESTORELINE;
176: }
177:
178: if(sys_status&SS_USERON && memcmp(&nodesync_user,&useron,sizeof(user_t))) {
179: getusrdirs();
180: getusrsubs();
181: memcpy(&nodesync_user,&useron,sizeof(nodesync_user));
182: }
183:
184: if(sys_status&SS_USERON && online && (timeleft/60)<(5-timeleft_warn)
185: && !SYSOP) {
186: timeleft_warn=5-(timeleft/60);
187: attr(LIGHTGRAY);
188: bprintf(text[OnlyXminutesLeft]
189: ,((ushort)timeleft/60)+1,(timeleft/60) ? "s" : nulstr);
190: }
191:
192: attr(atr); /* replace original attributes */
193: nodesync_inside=0;
194: }
195:
196: /****************************************************************************/
197: /* Prints short messages waiting for this node, if any... */
198: /****************************************************************************/
199: int sbbs_t::getnmsg()
200: {
201: char str[MAX_PATH+1], *buf;
202: int file;
203: long length;
204:
205: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
206: thisnode.misc&=~NODE_NMSG; /* clear the NMSG flag */
207: putnodedat(cfg.node_num,&thisnode);
208: }
209:
210: sprintf(str,"%smsgs/n%3.3u.msg",cfg.data_dir,cfg.node_num);
211: if(flength(str)<1L)
212: return(0);
213: if((file=nopen(str,O_RDWR))==-1) {
214: /**
215: errormsg(WHERE,ERR_OPEN,str,O_RDWR);
216: **/
217: return(errno);
218: }
219: length=filelength(file);
220: if(!length) {
221: close(file);
222: return(0);
223: }
224: if((buf=(char *)malloc(length+1))==NULL) {
225: close(file);
226: errormsg(WHERE,ERR_ALLOC,str,length+1);
227: return(-1);
228: }
229: if(lread(file,buf,length)!=length) {
230: close(file);
231: free(buf);
232: errormsg(WHERE,ERR_READ,str,length);
233: return(errno);
234: }
235: chsize(file,0L);
236: close(file);
237: buf[length]=0;
238:
239: if(thisnode.action==NODE_MAIN || thisnode.action==NODE_XFER
240: || sys_status&SS_IN_CTRLP) {
241: CRLF;
242: }
243: putmsg(buf,P_NOATCODES);
244: free(buf);
245:
246: return(0);
247: }
248:
249: /****************************************************************************/
250: /* 'ext' must be at least 128 bytes! */
251: /****************************************************************************/
252: int sbbs_t::getnodeext(uint number, char *ext)
253: {
254: char str[MAX_PATH+1];
255: int rd,count;
256:
257: if(!number || number>cfg.sys_nodes) {
258: errormsg(WHERE,ERR_CHK,"node number",number);
259: return(-1);
260: }
261:
262: sprintf(str,"%snode.exb",cfg.ctrl_dir);
263: if((node_ext=nopen(str,O_RDONLY|O_DENYNONE))==-1) {
264: memset(ext,0,128);
265: errormsg(WHERE,ERR_OPEN,str,O_RDONLY|O_DENYNONE);
266: return(errno);
267: }
268:
269: number--; /* make zero based */
270: for(count=0;count<LOOP_NODEDAB;count++) {
271: if(count)
272: mswait(100);
273: if(lock(node_ext,(long)number*128L,128)!=0)
274: continue;
275: lseek(node_ext,(long)number*128L,SEEK_SET);
276: rd=read(node_ext,ext,128);
277: unlock(node_ext,(long)number*128L,128);
278: if(rd==128)
279: break;
280: }
281: close(node_ext);
282: node_ext=-1;
283:
284:
285: if(count==LOOP_NODEDAB) {
286: errormsg(WHERE,ERR_READ,"node.exb",number+1);
287: return(-2);
288: }
289: if(count>(LOOP_NODEDAB/2)) {
290: sprintf(str,"NODE.EXB (node %d) COLLISION - Count: %d"
291: ,number+1, count);
292: logline("!!",str);
293: }
294:
295: return(0);
296: }
297:
298:
299: /****************************************************************************/
300: /* Prints short messages waiting for 'usernumber', if any... */
301: /* then deletes them. */
302: /****************************************************************************/
303: int sbbs_t::getsmsg(int usernumber)
304: {
305: char str[MAX_PATH+1], *buf;
306: int file;
307: long length;
308:
309: sprintf(str,"%smsgs/%4.4u.msg",cfg.data_dir,usernumber);
310: if(flength(str)<1L)
311: return(0);
312: if((file=nopen(str,O_RDWR))==-1) {
313: errormsg(WHERE,ERR_OPEN,str,O_RDWR);
314: return(errno);
315: }
316: length=filelength(file);
317: if((buf=(char *)malloc(length+1))==NULL) {
318: close(file);
319: errormsg(WHERE,ERR_ALLOC,str,length+1);
320: return(-1);
321: }
322: if(lread(file,buf,length)!=length) {
323: close(file);
324: free(buf);
325: errormsg(WHERE,ERR_READ,str,length);
326: return(errno);
327: }
328: chsize(file,0L);
329: close(file);
330: buf[length]=0;
331: getnodedat(cfg.node_num,&thisnode,0);
332: if(thisnode.action==NODE_MAIN || thisnode.action==NODE_XFER
333: || sys_status&SS_IN_CTRLP) {
334: CRLF;
335: }
336: if(thisnode.misc&NODE_MSGW) {
337: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
338: thisnode.misc&=~NODE_MSGW;
339: putnodedat(cfg.node_num,&thisnode);
340: }
341: }
342: putmsg(buf,P_NOATCODES);
343: free(buf);
344:
345: return(0);
346: }
347:
348: /****************************************************************************/
349: /* This function lists users that are online. */
350: /* If listself is true, it will list the current node. */
351: /* Returns number of active nodes (not including current node). */
352: /****************************************************************************/
353: int sbbs_t::whos_online(bool listself)
354: {
355: int i,j;
356: node_t node;
357:
358: CRLF;
359: bputs(text[NodeLstHdr]);
360: for(j=0,i=1;i<=cfg.sys_nodes && i<=cfg.sys_lastnode;i++) {
361: getnodedat(i,&node,0);
362: if(i==cfg.node_num) {
363: if(listself)
364: printnodedat(i,&node);
365: continue;
366: }
367: if(node.status==NODE_INUSE || (SYSOP && node.status==NODE_QUIET)) {
368: printnodedat(i,&node);
369: if(!lastnodemsg)
370: lastnodemsg=i;
371: j++;
372: }
373: }
374: if(!j)
375: bputs(text[NoOtherActiveNodes]);
376: return(j);
377: }
378:
379: void sbbs_t::nodelist(void)
380: {
381: node_t node;
382:
383: CRLF;
384: bputs(text[NodeLstHdr]);
385: for(int i=1;i<=cfg.sys_nodes && i<=cfg.sys_lastnode;i++) {
386: getnodedat(i,&node,0);
387: printnodedat(i,&node);
388: }
389: }
390:
391: /****************************************************************************/
392: /* Displays the information for node number 'number' contained in 'node' */
393: /****************************************************************************/
394: void sbbs_t::printnodedat(uint number, node_t* node)
395: {
396: uint i;
397: char hour,mer[3];
398: char tmp[512];
399:
400: attr(cfg.color[clr_nodenum]);
401: bprintf("%3d ",number);
402: attr(cfg.color[clr_nodestatus]);
403: switch(node->status) {
404: case NODE_WFC:
405: bputs("Waiting for call");
406: break;
407: case NODE_OFFLINE:
408: bputs("Offline");
409: break;
410: case NODE_NETTING:
411: bputs("Networking");
412: break;
413: case NODE_LOGON:
414: bputs("At logon prompt");
415: break;
416: case NODE_EVENT_WAITING:
417: bputs("Waiting for all nodes to become inactive");
418: break;
419: case NODE_EVENT_LIMBO:
420: bprintf("Waiting for node %d to finish external event",node->aux);
421: break;
422: case NODE_EVENT_RUNNING:
423: bputs("Running external event");
424: break;
425: case NODE_NEWUSER:
426: attr(cfg.color[clr_nodeuser]);
427: bputs("New user");
428: attr(cfg.color[clr_nodestatus]);
429: bputs(" applying for access ");
430: if(!node->connection)
431: bputs("Locally");
432: else if(node->connection==0xffff)
433: bprintf("via telnet");
434: else
435: bprintf("at %ubps",node->connection);
436: break;
437: case NODE_QUIET:
438: if(!SYSOP) {
439: bputs("Waiting for call");
440: break;
441: }
442: case NODE_INUSE:
443: if(node->misc&NODE_EXT) {
444: getnodeext(number,tmp);
445: bputs(tmp);
446: break;
447: }
448: attr(cfg.color[clr_nodeuser]);
449: if(node->misc&NODE_ANON && !SYSOP)
450: bputs("UNKNOWN USER");
451: else
452: bputs(username(&cfg,node->useron,tmp));
453: attr(cfg.color[clr_nodestatus]);
454: bputs(" ");
455: switch(node->action) {
456: case NODE_MAIN:
457: bputs("at main menu");
458: break;
459: case NODE_RMSG:
460: bputs("reading messages");
461: break;
462: case NODE_RMAL:
463: bputs("reading mail");
464: break;
465: case NODE_RSML:
466: bputs("reading sent mail");
467: break;
468: case NODE_RTXT:
469: bputs("reading text files");
470: break;
471: case NODE_PMSG:
472: bputs("posting message");
473: break;
474: case NODE_SMAL:
475: bputs("sending mail");
476: break;
477: case NODE_AMSG:
478: bputs("posting auto-message");
479: break;
480: case NODE_XTRN:
481: if(node->aux<1 || node->aux>cfg.total_xtrns)
482: bputs("at external program menu");
483: else {
484: bputs("running ");
485: i=node->aux-1;
486: if(SYSOP || chk_ar(cfg.xtrn[i]->ar,&useron))
487: bputs(cfg.xtrn[node->aux-1]->name);
488: else
489: bputs("external program");
490: }
491: break;
492: case NODE_DFLT:
493: bputs("changing defaults");
494: break;
495: case NODE_XFER:
496: bputs("at transfer menu");
497: break;
498: case NODE_RFSD:
499: bprintf("retrieving from device #%d",node->aux);
500: break;
501: case NODE_DLNG:
502: bprintf("downloading");
503: break;
504: case NODE_ULNG:
505: bputs("uploading");
506: break;
507: case NODE_BXFR:
508: bputs("transferring bidirectional");
509: break;
510: case NODE_LFIL:
511: bputs("listing files");
512: break;
513: case NODE_LOGN:
514: bputs("logging on");
515: break;
516: case NODE_LCHT:
517: bprintf("in local chat with %s",cfg.sys_op);
518: break;
519: case NODE_MCHT:
520: if(node->aux) {
521: bprintf("in multinode chat channel %d",node->aux&0xff);
522: if(node->aux&0x1f00) { /* password */
523: outchar('*');
524: if(SYSOP)
525: bprintf(" %s",unpackchatpass(tmp,node));
526: }
527: }
528: else
529: bputs("in multinode global chat channel");
530: break;
531: case NODE_PAGE:
532: bprintf("paging node %u for private chat",node->aux);
533: break;
534: case NODE_PCHT:
535: if(node->aux)
536: bprintf("in private chat with node %u",node->aux);
537: else
538: bprintf("in local chat with %s",cfg.sys_op);
539: break;
540: case NODE_GCHT:
541: i=node->aux;
542: if(i>=cfg.total_gurus)
543: i=0;
544: bprintf("chatting with %s",cfg.guru[i]->name);
545: break;
546: case NODE_CHAT:
547: bputs("in chat section");
548: break;
549: case NODE_TQWK:
550: bputs("transferring QWK packet");
551: break;
552: case NODE_SYSP:
553: bputs("performing sysop activities");
554: break;
555: default:
556: bputs(ultoa(node->action,tmp,10));
557: break; }
558: if(!node->connection)
559: bputs(" locally");
560: else if(node->connection==0xffff)
561: bprintf(" via telnet");
562: else
563: bprintf(" at %ubps",node->connection);
564: if(node->action==NODE_DLNG) {
565: if(cfg.sys_misc&SM_MILITARY) {
566: hour=node->aux/60;
567: mer[0]=0;
568: }
569: else if((node->aux/60)>=12) {
570: if(node->aux/60==12)
571: hour=12;
572: else
573: hour=(node->aux/60)-12;
574: strcpy(mer,"pm");
575: }
576: else {
577: if((node->aux/60)==0) /* 12 midnite */
578: hour=12;
579: else hour=node->aux/60;
580: strcpy(mer,"am");
581: }
582: bprintf(" ETA %02d:%02d %s"
583: ,hour,node->aux%60,mer);
584: }
585: break;
586: }
587: i=NODE_LOCK;
588: if(node->status==NODE_INUSE || SYSOP)
589: i|=NODE_POFF|NODE_AOFF|NODE_MSGW|NODE_NMSG;
590: if(node->misc&i) {
591: bputs(" (");
592: if(node->misc&(i&NODE_AOFF))
593: outchar('A');
594: if(node->misc&NODE_LOCK)
595: outchar('L');
596: if(node->misc&(i&(NODE_MSGW|NODE_NMSG)))
597: outchar('M');
598: if(node->misc&(i&NODE_POFF))
599: outchar('P');
600: outchar(')');
601: }
602: if(SYSOP && ((node->misc
603: &(NODE_ANON|NODE_UDAT|NODE_INTR|NODE_RRUN|NODE_EVENT|NODE_DOWN|NODE_LCHAT))
604: || node->status==NODE_QUIET)) {
605: bputs(" [");
606: if(node->misc&NODE_ANON)
607: outchar('A');
608: if(node->misc&NODE_INTR)
609: outchar('I');
610: if(node->misc&NODE_RRUN)
611: outchar('R');
612: if(node->misc&NODE_UDAT)
613: outchar('U');
614: if(node->status==NODE_QUIET)
615: outchar('Q');
616: if(node->misc&NODE_EVENT)
617: outchar('E');
618: if(node->misc&NODE_DOWN)
619: outchar('D');
620: if(node->misc&NODE_LCHAT)
621: outchar('C');
622: outchar(']');
623: }
624: if(node->errors && SYSOP) {
625: attr(cfg.color[clr_err]);
626: bprintf(" %d error%c",node->errors, node->errors>1 ? 's' : '\0' );
627: }
628: attr(LIGHTGRAY);
629: CRLF;
630: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.