![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to node.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / node|
Return to node.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / node |
1.1 root 1: /* NODE.C */
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: /* Synchronet BBS Node control program */
6:
7: #include <stdio.h>
8: #include <stdlib.h>
9: #include <io.h>
10: #include <dos.h>
11: #include <fcntl.h>
12: #include <string.h>
13: #include "sbbsdefs.h"
14:
15: enum {
16: MODE_LIST
17: ,MODE_ANON
18: ,MODE_LOCK
19: ,MODE_INTR
20: ,MODE_RRUN
21: ,MODE_DOWN
22: ,MODE_EVENT
23: ,MODE_NOPAGE
24: ,MODE_NOALERTS
25: ,MODE_STATUS
26: ,MODE_USERON
27: ,MODE_ACTION
28: ,MODE_ERRORS
29: ,MODE_MISC
30: ,MODE_CONN
31: ,MODE_AUX
32: ,MODE_EXTAUX
33: };
34:
35: char tmp[256];
36: int nodefile;
37:
38: /****************************************************************************/
39: /* Reads the data for node number 'number' into the structure 'node' */
40: /* from NODE.DAB */
41: /* if lockit is non-zero, locks this node's record. putnodedat() unlocks it */
42: /****************************************************************************/
43: void getnodedat(uchar number, node_t *node, char lockit)
44: {
45: char str[256];
46: int count=0;
47:
48: number--; /* make zero based */
49: while(count<LOOP_NODEDAB) {
50: lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
51: if(lockit
52: && lock(nodefile,(long)number*sizeof(node_t),sizeof(node_t))==-1) {
53: count++;
54: continue; }
55: if(read(nodefile,node,sizeof(node_t))==sizeof(node_t))
56: break;
57: count++; }
58: if(count)
59: printf("NODE.DAB COLLISION (READ) - Count:%d\n",count);
60: if(count==LOOP_NODEDAB) {
61: printf("Error reading nodefile for node %d\n",number+1);
62: return; }
63: }
64:
65: /****************************************************************************/
66: /* Write the data from the structure 'node' into NODE.DAB */
67: /* getnodedat(num,&node,1); must have been called before calling this func */
68: /* NOTE: ------^ the indicates the node record has been locked */
69: /****************************************************************************/
70: void putnodedat(uchar number, node_t node)
71: {
72: char str[256];
73: int count;
74:
75: number--; /* make zero based */
76: lseek(nodefile,(long)number*sizeof(node_t),SEEK_SET);
77: if(write(nodefile,&node,sizeof(node_t))!=sizeof(node_t)) {
78: unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
79: printf("Error writing to nodefile for node %d\n",number+1);
80: return; }
81: unlock(nodefile,(long)number*sizeof(node_t),sizeof(node_t));
82: }
83:
84: /****************************************************************************/
85: /* Unpacks the password 'pass' from the 5bit ASCII inside node_t. 32bits in */
86: /* node.extaux, and the other 8bits in the upper byte of node.aux */
87: /****************************************************************************/
88: char *unpackchatpass(char *pass, node_t node)
89: {
90: char bits;
91: int i;
92:
93: pass[0]=(node.aux&0x1f00)>>8;
94: pass[1]=((node.aux&0xe000)>>13)|((node.extaux&0x3)<<3);
95: bits=2;
96: for(i=2;i<8;i++) {
97: pass[i]=(node.extaux>>bits)&0x1f;
98: bits+=5; }
99: pass[8]=0;
100: for(i=0;i<8;i++)
101: if(pass[i])
102: pass[i]+=64;
103: return(pass);
104: }
105:
106: /****************************************************************************/
107: /* Displays the information for node number 'number' contained in 'node' */
108: /****************************************************************************/
109: void printnodedat(uchar number, node_t node)
110: {
111: uint i;
112: char hour,mer[3];
113:
114: printf("Node %2d: ",number);
115: switch(node.status) {
116: case NODE_WFC:
117: printf("Waiting for call");
118: break;
119: case NODE_OFFLINE:
120: printf("Offline");
121: break;
122: case NODE_NETTING:
123: printf("Networking");
124: break;
125: case NODE_LOGON:
126: printf("At logon prompt");
127: break;
128: case NODE_EVENT_WAITING:
129: printf("Waiting for all nodes to become inactive");
130: break;
131: case NODE_EVENT_LIMBO:
132: printf("Waiting for node %d to finish external event",node.aux);
133: break;
134: case NODE_EVENT_RUNNING:
135: printf("Running external event");
136: break;
137: case NODE_NEWUSER:
138: printf("New user");
139: printf(" applying for access ");
140: if(!node.connection)
141: printf("Locally");
142: else
143: printf("at %ubps",node.connection);
144: break;
145: case NODE_QUIET:
146: case NODE_INUSE:
147: printf("User #%d",node.useron);
148: printf(" ");
149: switch(node.action) {
150: case NODE_MAIN:
151: printf("at main menu");
152: break;
153: case NODE_RMSG:
154: printf("reading messages");
155: break;
156: case NODE_RMAL:
157: printf("reading mail");
158: break;
159: case NODE_RSML:
160: printf("reading sent mail");
161: break;
162: case NODE_RTXT:
163: printf("reading text files");
164: break;
165: case NODE_PMSG:
166: printf("posting message");
167: break;
168: case NODE_SMAL:
169: printf("sending mail");
170: break;
171: case NODE_AMSG:
172: printf("posting auto-message");
173: break;
174: case NODE_XTRN:
175: if(!node.aux)
176: printf("at external program menu");
177: else
178: printf("running external program #%d",node.aux);
179: break;
180: case NODE_DFLT:
181: printf("changing defaults");
182: break;
183: case NODE_XFER:
184: printf("at transfer menu");
185: break;
186: case NODE_RFSD:
187: printf("retrieving from device #%d",node.aux);
188: break;
189: case NODE_DLNG:
190: printf("downloading");
191: break;
192: case NODE_ULNG:
193: printf("uploading");
194: break;
195: case NODE_BXFR:
196: printf("transferring bidirectional");
197: break;
198: case NODE_LFIL:
199: printf("listing files");
200: break;
201: case NODE_LOGN:
202: printf("logging on");
203: break;
204: case NODE_LCHT:
205: printf("in local chat with sysop");
206: break;
207: case NODE_MCHT:
208: if(node.aux) {
209: printf("in multinode chat channel %d",node.aux&0xff);
210: if(node.aux&0x1f00) { /* password */
211: putchar('*');
212: printf(" %s",unpackchatpass(tmp,node)); } }
213: else
214: printf("in multinode global chat channel");
215: break;
216: case NODE_PAGE:
217: printf("paging node %u for private chat",node.aux);
218: break;
219: case NODE_PCHT:
220: printf("in private chat with node %u",node.aux);
221: break;
222: case NODE_GCHT:
223: printf("chatting with The Guru");
224: break;
225: case NODE_CHAT:
226: printf("in chat section");
227: break;
228: case NODE_TQWK:
229: printf("transferring QWK packet");
230: break;
231: case NODE_SYSP:
232: printf("performing sysop activities");
233: break;
234: default:
235: printf(itoa(node.action,tmp,10));
236: break; }
237: if(!node.connection)
238: printf(" locally");
239: else
240: printf(" at %ubps",node.connection);
241: if(node.action==NODE_DLNG) {
242: if((node.aux/60)>=12) {
243: if(node.aux/60==12)
244: hour=12;
245: else
246: hour=(node.aux/60)-12;
247: strcpy(mer,"pm"); }
248: else {
249: if((node.aux/60)==0) /* 12 midnite */
250: hour=12;
251: else hour=node.aux/60;
252: strcpy(mer,"am"); }
253: printf(" ETA %02d:%02d %s"
254: ,hour,node.aux-((node.aux/60)*60),mer); }
255: break; }
256: if(node.misc&(NODE_LOCK|NODE_POFF|NODE_AOFF|NODE_MSGW|NODE_NMSG)) {
257: printf(" (");
258: if(node.misc&NODE_AOFF)
259: putchar('A');
260: if(node.misc&NODE_LOCK)
261: putchar('L');
262: if(node.misc&(NODE_MSGW|NODE_NMSG))
263: putchar('M');
264: if(node.misc&NODE_POFF)
265: putchar('P');
266: putchar(')'); }
267: if(((node.misc
268: &(NODE_ANON|NODE_UDAT|NODE_INTR|NODE_RRUN|NODE_EVENT|NODE_DOWN))
269: || node.status==NODE_QUIET)) {
270: printf(" [");
271: if(node.misc&NODE_ANON)
272: putchar('A');
273: if(node.misc&NODE_INTR)
274: putchar('I');
275: if(node.misc&NODE_RRUN)
276: putchar('R');
277: if(node.misc&NODE_UDAT)
278: putchar('U');
279: if(node.status==NODE_QUIET)
280: putchar('Q');
281: if(node.misc&NODE_EVENT)
282: putchar('E');
283: if(node.misc&NODE_DOWN)
284: putchar('D');
285: putchar(']'); }
286: if(node.errors)
287: printf(" %d error%c",node.errors, node.errors>1 ? 's' : '\0' );
288: printf("\n");
289: }
290:
291:
292: /****************************/
293: /* Main program entry point */
294: /****************************/
295: int main(int argc, char **argv)
296: {
297: char str[256],ctrl_dir[41],*p,debug=0;
298: uchar sys_nodes,node_num=0,onoff=0;
299: uint i,j,mode=0,misc;
300: long value;
301: node_t node;
302:
303: printf("\nSynchronet Node Display/Control Utility v1.03\n\n");
304:
305: if(argc<2) {
306: printf("usage: node [/debug] [action [on|off]] [node numbers] [...]"
307: "\n\n");
308: printf("actions (default is list):\n\n");
309: printf("list = list status\n");
310: printf("anon = anonymous user\n");
311: printf("lock = locked\n");
312: printf("intr = interrupt\n");
313: printf("down = shut-down\n");
314: printf("rerun = rerun\n");
315: printf("event = run event\n");
316: printf("nopage = page disable\n");
317: printf("noalerts = activity alerts disable\n");
318: printf("status=# = set status value\n");
319: printf("useron=# = set useron number\n");
320: printf("action=# = set action value\n");
321: printf("errors=# = set error counter\n");
322: printf("conn=# = set connection value\n");
323: printf("misc=# = set misc value\n");
324: printf("aux=# = set aux value\n");
325: printf("extaux=# = set extended aux value\n");
326: exit(0); }
327:
328: p=getenv("SBBSCTRL");
329: if(p==NULL) {
330: printf("\7\nSBBSCTRL environment variable is not set.\n");
331: printf("This environment variable must be set to your CTRL directory.");
332: printf("\nExample: SET SBBSCTRL=C:\\SBBS\\CTRL\n");
333: exit(1); }
334: sprintf(ctrl_dir,"%.40s",p);
335: strupr(ctrl_dir);
336: if(ctrl_dir[strlen(ctrl_dir)-1]!='\\')
337: strcat(ctrl_dir,"\\");
338:
339: sprintf(str,"%sNODE.DAB",ctrl_dir);
340: if((nodefile=open(str,O_RDWR|O_DENYNONE|O_BINARY))==-1) {
341: printf("\7\nError opening %s.\n",str);
342: exit(1); }
343:
344: sys_nodes=filelength(nodefile)/sizeof(node_t);
345: if(!sys_nodes) {
346: printf("%s reflects 0 nodes!\n",str);
347: exit(1); }
348:
349: for(i=1;i<argc;i++) {
350: if(isdigit(argv[i][0]))
351: node_num=atoi(argv[i]);
352: else {
353: node_num=onoff=value=0;
354: if(!stricmp(argv[i],"/DEBUG"))
355: debug=1;
356: else if(!stricmp(argv[i],"LOCK"))
357: mode=MODE_LOCK;
358: else if(!stricmp(argv[i],"ANON"))
359: mode=MODE_ANON;
360: else if(!stricmp(argv[i],"INTR"))
361: mode=MODE_INTR;
362: else if(!stricmp(argv[i],"DOWN"))
363: mode=MODE_DOWN;
364: else if(!stricmp(argv[i],"RERUN"))
365: mode=MODE_RRUN;
366: else if(!stricmp(argv[i],"EVENT"))
367: mode=MODE_EVENT;
368: else if(!stricmp(argv[i],"NOPAGE"))
369: mode=MODE_NOPAGE;
370: else if(!stricmp(argv[i],"NOALERTS"))
371: mode=MODE_NOALERTS;
372: else if(!stricmp(argv[i],"ON"))
373: onoff=1;
374: else if(!stricmp(argv[i],"OFF"))
375: onoff=2;
376: else if(!strnicmp(argv[i],"STATUS=",7)) {
377: mode=MODE_STATUS;
378: value=atoi(argv[i]+7); }
379: else if(!strnicmp(argv[i],"ERRORS=",7)) {
380: mode=MODE_ERRORS;
381: value=atoi(argv[i]+7); }
382: else if(!strnicmp(argv[i],"USERON=",7)) {
383: mode=MODE_USERON;
384: value=atoi(argv[i]+7); }
385: else if(!strnicmp(argv[i],"ACTION=",7)) {
386: mode=MODE_ACTION;
387: value=atoi(argv[i]+7); }
388: else if(!strnicmp(argv[i],"CONN=",5)) {
389: mode=MODE_CONN;
390: value=atoi(argv[i]+5); }
391: else if(!strnicmp(argv[i],"MISC=",5)) {
392: mode=MODE_MISC;
393: value=atoi(argv[i]+5); }
394: else if(!strnicmp(argv[i],"AUX=",4)) {
395: mode=MODE_AUX;
396: value=atoi(argv[i]+4); }
397: else if(!strnicmp(argv[i],"EXTAUX=",7)) {
398: mode=MODE_EXTAUX;
399: value=atoi(argv[i]+7); }
400: }
401: if((mode && node_num) || i+1==argc)
402: for(j=1;j<=sys_nodes;j++)
403: if(!node_num || j==node_num) {
404: getnodedat(j,&node,1);
405: misc=0;
406: switch(mode) {
407: case MODE_ANON:
408: misc=NODE_ANON;
409: break;
410: case MODE_LOCK:
411: misc=NODE_LOCK;
412: break;
413: case MODE_INTR:
414: misc=NODE_INTR;
415: break;
416: case MODE_DOWN:
417: misc=NODE_DOWN;
418: break;
419: case MODE_RRUN:
420: misc=NODE_RRUN;
421: break;
422: case MODE_EVENT:
423: misc=NODE_EVENT;
424: break;
425: case MODE_NOPAGE:
426: misc=NODE_POFF;
427: break;
428: case MODE_NOALERTS:
429: misc=NODE_AOFF;
430: break;
431: case MODE_STATUS:
432: node.status=value;
433: break;
434: case MODE_ERRORS:
435: node.errors=value;
436: break;
437: case MODE_ACTION:
438: node.action=value;
439: break;
440: case MODE_USERON:
441: node.useron=value;
442: break;
443: case MODE_MISC:
444: node.misc=value;
445: break;
446: case MODE_CONN:
447: node.connection=value;
448: break;
449: case MODE_AUX:
450: node.aux=value;
451: break;
452: case MODE_EXTAUX:
453: node.extaux=value;
454: break; }
455: if(misc) {
456: if(onoff==0)
457: node.misc^=misc;
458: else if(onoff==1)
459: node.misc|=misc;
460: else if(onoff==2)
461: node.misc&=~misc; }
462: putnodedat(j,node);
463: printnodedat(j,node);
464: if(debug) {
465: printf("status=%u\n",node.status);
466: printf("errors=%u\n",node.errors);
467: printf("action=%d\n",node.action);
468: printf("useron=%u\n",node.useron);
469: printf("conn=%u\n",node.connection);
470: printf("misc=%u\n",node.misc);
471: printf("aux=%u\n",node.aux);
472: printf("extaux=%lu\n",node.extaux); } } }
473:
474: close(nodefile);
475: return(0);
476: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.