![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to main.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "MAIN.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: /*********************************************************/
6: /* Entry point to the BBS and the waitforcall() function */
7: /*********************************************************/
8:
9: #include "sbbs.h"
10: #include "cmdshell.h"
11:
12: csi_t main_csi;
13: uint curshell=0;
14:
15: char onquiet=0,qwklogon;
16: char term_ret=0;
17: ulong connect_rate=0; /* already connected at xbps */
18:
19: #if __OS2__
20: void cbreakh(int sig) /* Ctrl-C */
21: {
22: sys_status|=SS_ABORT;
23: signal(sig,cbreakh);
24: }
25:
26: #else
27:
28: int cbreakh() /* ctrl-break handler */
29: {
30: sys_status|=SS_ABORT;
31: return(1); /* 1 to continue, 0 to abort */
32: }
33: #endif
34:
35: /****************************************************************************/
36: /* This is the entry point to the BBS from dos */
37: /* No arguments are defined as of yet. */
38: /****************************************************************************/
39: main(int argc, char *argv[])
40: {
41: char str[256];
42: int i,j,file,twenty;
43: node_t node;
44:
45: startup(argc,argv); /* startup code overlaid */
46:
47: while(1) {
48:
49: while(1) {
50: qwklogon=0;
51: twenty=0;
52:
53: /* Reset TEXT.DAT */
54:
55: for(i=0;i<TOTAL_TEXT;i++)
56: if(text[i]!=text_sav[i]) {
57: if(text[i]!=nulstr)
58: FREE(text[i]);
59: text[i]=text_sav[i]; }
60:
61: /* Reset COMMAND SHELL */
62:
63: if(main_csi.cs)
64: FREE(main_csi.cs);
65: if(main_csi.str)
66: FREE(main_csi.str);
67: freevars(&main_csi);
68: memset(&main_csi,0,sizeof(csi_t));
69: main_csi.str=MALLOC(1024);
70: if(!main_csi.str) {
71: errormsg(WHERE,ERR_ALLOC,"command shell",1024);
72: bail(1); }
73: memset(main_csi.str,0,1024);
74: menu_dir[0]=0;
75: twenty+=10;
76:
77: /* Reset Global Variables */
78:
79: if(global_str_var)
80: for(i=0;i<global_str_vars;i++)
81: if(global_str_var[i]) {
82: FREE(global_str_var[i]);
83: global_str_var[i]=0; }
84: if(global_str_var) {
85: FREE(global_str_var);
86: global_str_var=0; }
87: if(global_str_var_name) {
88: FREE(global_str_var_name);
89: global_str_var_name=0; }
90: global_str_vars=0;
91: if(global_int_var) {
92: FREE(global_int_var);
93: global_int_var=0; }
94: if(global_int_var_name) {
95: FREE(global_int_var_name);
96: global_int_var_name=0; }
97: global_int_vars=0;
98: twenty*=2;
99:
100: if(waitforcall()) /* Got caller/logon */
101: break; }
102:
103: if(qwklogon) {
104: getsmsg(useron.number);
105: qwk_sec();
106: hangup();
107: logout();
108: continue; }
109:
110: while(useron.number && (main_csi.misc&CS_OFFLINE_EXEC || online)) {
111:
112: if(!main_csi.cs || curshell!=useron.shell) {
113: if(useron.shell>=total_shells)
114: useron.shell=0;
115: sprintf(str,"%s%s.BIN",exec_dir,shell[useron.shell]->code);
116: if((file=nopen(str,O_RDONLY|O_BINARY))==-1) {
117: errormsg(WHERE,ERR_OPEN,str,O_RDONLY|O_BINARY);
118: hangup();
119: break; }
120: if(main_csi.cs)
121: FREE(main_csi.cs);
122: freevars(&main_csi);
123: clearvars(&main_csi);
124:
125: main_csi.length=filelength(file);
126: if((main_csi.cs=(uchar *)MALLOC(main_csi.length))==NULL) {
127: close(file);
128: errormsg(WHERE,ERR_ALLOC,str,main_csi.length);
129: hangup();
130: break; }
131:
132: if(lread(file,main_csi.cs,main_csi.length)!=main_csi.length) {
133: errormsg(WHERE,ERR_READ,str,main_csi.length);
134: close(file);
135: FREE(main_csi.cs);
136: main_csi.cs=NULL;
137: hangup();
138: break; }
139: close(file);
140:
141: main_csi.ip=main_csi.cs;
142: curshell=useron.shell;
143: menu_dir[0]=0;
144: menu_file[0]=0;
145: #ifdef __MSDOS__
146: freedosmem=farcoreleft();
147: #endif
148: }
149: if(exec(&main_csi))
150: break;
151:
152: if(!(main_csi.misc&CS_OFFLINE_EXEC))
153: checkline();
154:
155: #if 0
156: if(freedosmem!=farcoreleft()) {
157: if(freedosmem>farcoreleft())
158: errormsg(WHERE,ERR_CHK,"memory",freedosmem-farcoreleft());
159: freedosmem=farcoreleft(); }
160: #endif
161: }
162: logout();
163: catsyslog(0);
164: if(!REALSYSOP || sys_misc&SM_SYSSTAT)
165: logoffstats(); /* Updates both system and node dsts.dab files */
166: if(qoc) {
167: while(!wfc_events(time(NULL)))
168: ;
169: catsyslog(0);
170: if(qoc==1)
171: offhook();
172: lclini(node_scrnlen);
173: lputc(FF);
174: bail(0); }
175: }
176: }
177:
178: /************************************/
179: /* encrypted string output function */
180: /************************************/
181: char *decrypt(ulong l[], char *instr)
182: {
183: static char str[128];
184: uchar ch,bits,len;
185: ushort i,j,lc=0;
186:
187: len=(uchar)(l[0]&0x7f)^0x49;
188: bits=7;
189: for(i=0,j=0;i<len;i++) {
190: ch=(char)((l[j]>>bits)&0x7fL);
191: ch^=(i^0x2c);
192: str[lc++]=ch;
193: bits+=7;
194: if(bits>=26 && i+1<len) {
195: if(bits==32)
196: ch=0;
197: else
198: ch=(char)((l[j]>>bits)&0x7fL);
199: bits=(32-bits);
200: j++;
201: ch|=((l[j]&0x7f)<<(bits))&0x7f;
202: i++;
203: ch^=(i^0x2c);
204: bits=7-bits;
205: str[lc++]=ch; } }
206: str[lc]=0;
207: if(instr) {
208: strcpy(instr,str);
209: return(instr); }
210: else
211: return(str);
212: }
213:
214: /****************************************************************************/
215: /* Writes NODE.LOG at end of SYSTEM.LOG */
216: /****************************************************************************/
217: void catsyslog(int crash)
218: {
219: char str[256];
220: char HUGE16 *buf;
221: int i,file;
222: ulong length;
223:
224: if(sys_status&SS_LOGOPEN) {
225: if(close(logfile)) {
226: errormsg(WHERE,ERR_CLOSE,"logfile",0);
227: return; }
228: sys_status&=~SS_LOGOPEN; }
229: sprintf(str,"%sNODE.LOG",node_dir);
230: if((file=nopen(str,O_RDONLY))==-1) {
231: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
232: return; }
233: length=filelength(file);
234: if(length) {
235: if((buf=(char HUGE16 *)LMALLOC(length))==NULL) {
236: close(file);
237: errormsg(WHERE,ERR_ALLOC,str,length);
238: return; }
239: if(lread(file,buf,length)!=length) {
240: close(file);
241: errormsg(WHERE,ERR_READ,str,length);
242: FREE((char *)buf);
243: return; }
244: close(file);
245: now=time(NULL);
246: unixtodos(now,&date,&curtime);
247: sprintf(str,"%sLOGS\\%2.2d%2.2d%2.2d.LOG",data_dir,date.da_mon,date.da_day
248: ,date.da_year-1900);
249: if((file=nopen(str,O_WRONLY|O_APPEND|O_CREAT))==-1) {
250: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_APPEND|O_CREAT);
251: FREE((char *)buf);
252: return; }
253: if(lwrite(file,buf,length)!=length) {
254: close(file);
255: errormsg(WHERE,ERR_WRITE,str,length);
256: FREE((char *)buf);
257: return; }
258: close(file);
259: if(crash) {
260: for(i=0;i<2;i++) {
261: sprintf(str,"%sCRASH.LOG",i ? data_dir : node_dir);
262: if((file=nopen(str,O_WRONLY|O_APPEND|O_CREAT))==-1) {
263: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_APPEND|O_CREAT);
264: FREE((char *)buf);
265: return; }
266: if(lwrite(file,buf,length)!=length) {
267: close(file);
268: errormsg(WHERE,ERR_WRITE,str,length);
269: FREE((char *)buf);
270: return; }
271: close(file); } }
272: FREE((char *)buf); }
273: else
274: close(file);
275: sprintf(str,"%sNODE.LOG",node_dir);
276: if((logfile=nopen(str,O_WRONLY|O_TRUNC))==-1) /* Truncate NODE.LOG */
277: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_TRUNC);
278: else sys_status|=SS_LOGOPEN;
279: }
280:
281: void quicklogonstuff()
282: {
283: int i;
284: node_t node;
285:
286: reset_logon_vars();
287:
288: lclini(node_scrnlen-1);
289: if(com_port && !DCDHIGH) /* don't take phone offhook if */
290: offhook(); /* connected */
291: useron.number=1;
292: getuserdat(&useron);
293: autoterm=ANSI;
294: if(!useron.number)
295: useron.level=99;
296: console=CON_L_ECHO|CON_L_INPUT;
297: online=ON_LOCAL;
298: statline=sys_def_stat;
299: statusline();
300: answertime=logontime=time(NULL);
301: sprintf(connection,"%.*s",LEN_MODEM,text[Locally]);
302: cur_rate=14400;
303: cur_cps=1750;
304: sys_status|=SS_USERON;
305: }
306:
307:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.