![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to logon.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs3|
Return to logon.cpp CVS log | Up to [Synchronet] / sbbs / sbbs3 |
1.1 root 1: /* logon.cpp */
2:
3: /* Synchronet user logon routines */
4:
5: /* $Id: logon.cpp,v 1.10 2000/12/11 23:21:12 rswindell 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 2000 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: extern "C" void client_on(SOCKET sock, client_t* client);
42:
43: /****************************************************************************/
44: /* Called once upon each user logging on the board */
45: /* Returns 1 if user passed logon, 0 if user failed. */
46: /****************************************************************************/
47: bool sbbs_t::logon()
48: {
49: char str[256],c;
50: char tmp[512];
51: int file;
52: uint i,j,mailw;
53: ulong totallogons;
54: node_t node;
55: struct tm* tm_p;
56: struct tm tm;
57:
58: now=time(NULL);
59: tm_p=localtime(&now);
60: if(tm_p==NULL)
61: return(false);
62: tm=*tm_p;
63:
64: if(!useron.number)
65: return(false);
66:
67: client.user=useron.alias;
68: client_on(client_socket,&client);
69:
70: if(useron.rest&FLAG('Q'))
71: qwklogon=1;
72: if(SYSOP && ((online==ON_REMOTE && !(cfg.sys_misc&SM_R_SYSOP))
73: || (online==ON_LOCAL && !(cfg.sys_misc&SM_L_SYSOP))))
74: return(false);
75: if(cur_rate<cfg.node_minbps && !(useron.exempt&FLAG('M'))) {
76: bprintf(text[MinimumModemSpeed],cfg.node_minbps);
77: sprintf(str,"%stooslow.msg",cfg.text_dir);
78: if(fexist(str))
79: printfile(str,0);
80: sprintf(str,"(%04u) %-25s Modem speed: %u<%u"
81: ,useron.number,useron.alias,cur_rate,cfg.node_minbps);
82: logline("+!",str);
83: return(false); }
84:
85: if(useron.rest&FLAG('G')) { /* Guest account */
86: useron.misc=(cfg.new_misc&(~ASK_NSCAN));
87: useron.rows=0;
88: useron.misc&=~(ANSI|RIP|WIP|NO_EXASCII|COLOR);
89: useron.misc|=autoterm;
90: if(!(useron.misc&ANSI) && yesno(text[AnsiTerminalQ]))
91: useron.misc|=ANSI;
92: if(useron.misc&(RIP|WIP)
93: || (useron.misc&ANSI && yesno(text[ColorTerminalQ])))
94: useron.misc|=COLOR;
95: if(!yesno(text[ExAsciiTerminalQ]))
96: useron.misc|=NO_EXASCII;
97: for(i=0;i<cfg.total_xedits;i++)
98: if(!stricmp(cfg.xedit[i]->code,cfg.new_xedit)
99: && chk_ar(cfg.xedit[i]->ar,&useron))
100: break;
101: if(i<cfg.total_xedits)
102: useron.xedit=i+1;
103: else
104: useron.xedit=0;
105: useron.prot=cfg.new_prot;
106: useron.shell=cfg.new_shell; }
107:
108: if(cfg.node_dollars_per_call) {
109: adjustuserrec(&cfg,useron.number,U_CDT,10
110: ,cfg.cdt_per_dollar*cfg.node_dollars_per_call);
111: bprintf(text[CreditedAccount]
112: ,cfg.cdt_per_dollar*cfg.node_dollars_per_call);
113: sprintf(str,"%s #%u was billed $%d T: %u seconds"
114: ,useron.alias,useron.number
115: ,cfg.node_dollars_per_call,(uint)now-answertime);
116: logline("$+",str);
117: hangup();
118: return(false); }
119:
120: //lclini(node_scrnlen-1);
121:
122: if(!chk_ar(cfg.node_ar,&useron)) {
123: bputs(text[NoNodeAccess]);
124: sprintf(str,"(%04u) %-25s Insufficient node access"
125: ,useron.number,useron.alias);
126: logline("+!",str);
127: return(false); }
128:
129: getnodedat(cfg.node_num,&thisnode,1);
130: if(thisnode.misc&NODE_LOCK) {
131: putnodedat(cfg.node_num,&thisnode); /* must unlock! */
132: if(!SYSOP && !(useron.exempt&FLAG('N'))) {
133: bputs(text[NodeLocked]);
134: sprintf(str,"(%04u) %-25s Locked node logon attempt"
135: ,useron.number,useron.alias);
136: logline("+!",str);
137: return(false); }
138: if(yesno(text[RemoveNodeLockQ])) {
139: getnodedat(cfg.node_num,&thisnode,1);
140: logline("S-","Removed Node Lock");
141: thisnode.misc&=~NODE_LOCK; }
142: else
143: getnodedat(cfg.node_num,&thisnode,1); }
144:
145: if((useron.exempt&FLAG('Q') && useron.misc&QUIET))
146: thisnode.status=NODE_QUIET;
147: else
148: thisnode.status=NODE_INUSE;
149: action=thisnode.action=NODE_LOGN;
150: thisnode.connection=0xffff;
151: thisnode.misc&=~(NODE_ANON|NODE_INTR|NODE_MSGW|NODE_POFF|NODE_AOFF);
152: if(useron.chat&CHAT_NOACT)
153: thisnode.misc|=NODE_AOFF;
154: if(useron.chat&CHAT_NOPAGE)
155: thisnode.misc|=NODE_POFF;
156: thisnode.useron=useron.number;
157: putnodedat(cfg.node_num,&thisnode);
158:
159: getusrsubs();
160: getusrdirs();
161:
162: if(useron.misc&CURSUB && !(useron.rest&FLAG('G'))) {
163: for(i=0;i<usrgrps;i++) {
164: for(j=0;j<usrsubs[i];j++) {
165: if(!strcmp(cfg.sub[usrsub[i][j]]->code,useron.cursub))
166: break; }
167: if(j<usrsubs[i]) {
168: curgrp=i;
169: cursub[i]=j;
170: break; } }
171: for(i=0;i<usrlibs;i++) {
172: for(j=0;j<usrdirs[i];j++)
173: if(!strcmp(cfg.dir[usrdir[i][j]]->code,useron.curdir))
174: break;
175: if(j<usrdirs[i]) {
176: curlib=i;
177: curdir[i]=j;
178: break; } } }
179:
180:
181: if(useron.misc&AUTOTERM) {
182: useron.misc&=~(ANSI|RIP|WIP);
183: useron.misc|=autoterm; }
184:
185: if(!chk_ar(cfg.shell[useron.shell]->ar,&useron)) {
186: useron.shell=cfg.new_shell;
187: if(!chk_ar(cfg.shell[useron.shell]->ar,&useron)) {
188: for(i=0;i<cfg.total_shells;i++)
189: if(chk_ar(cfg.shell[i]->ar,&useron))
190: break;
191: if(i==cfg.total_shells)
192: useron.shell=0; } }
193:
194: logon_ml=useron.level;
195: logontime=time(NULL);
196: starttime=logontime;
197: last_ns_time=ns_time=useron.ns_time;
198: // ns_time-=(useron.tlast*60); /* file newscan time == last logon time */
199: delfiles(cfg.temp_dir,ALLFILES);
200: sprintf(str,"%smsgs/n%3.3u.msg",cfg.data_dir,cfg.node_num);
201: remove(str); /* remove any pending node messages */
202: sprintf(str,"%smsgs/n%3.3u.ixb",cfg.data_dir,cfg.node_num);
203: remove(str); /* remove any pending node message indices */
204:
205: if(!SYSOP && online==ON_REMOTE) {
206: rioctl(IOCM|ABORT); /* users can't abort anything */
207: rioctl(IOCS|ABORT); }
208:
209: CLS;
210: if(useron.rows)
211: rows=useron.rows;
212: else if(online==ON_LOCAL)
213: rows=cfg.node_scrnlen-1;
214: unixtodstr(&cfg,logontime,str);
215: if(!strncmp(str,useron.birth,5) && !(useron.rest&FLAG('Q'))) {
216: bputs(text[HappyBirthday]);
217: pause();
218: CLS;
219: user_event(EVENT_BIRTHDAY); }
220: unixtodstr(&cfg,useron.laston,tmp);
221: if(strcmp(str,tmp)) { /* str still equals logon time */
222: useron.ltoday=1;
223: useron.ttoday=useron.etoday=useron.ptoday=useron.textra=0;
224: useron.freecdt=cfg.level_freecdtperday[useron.level]; }
225: else
226: useron.ltoday++;
227:
228: gettimeleft();
229: sprintf(str,"%sfile/%04u.dwn",cfg.data_dir,useron.number);
230: batch_add_list(str);
231: if(!qwklogon) { /* QWK Nodes don't go through this */
232:
233: if(cfg.sys_pwdays
234: && (ulong)logontime>(useron.pwmod+((ulong)cfg.sys_pwdays*24UL*60UL*60UL))) {
235: bprintf(text[TimeToChangePw],cfg.sys_pwdays);
236:
237: c=0;
238: while(c<LEN_PASS) { /* Create random password */
239: str[c]=sbbs_random(43)+'0';
240: if(isalnum(str[c]))
241: c++; }
242: str[c]=0;
243: bprintf(text[YourPasswordIs],str);
244:
245: if(cfg.sys_misc&SM_PWEDIT && yesno(text[NewPasswordQ]))
246: while(online) {
247: bputs(text[NewPassword]);
248: getstr(str,LEN_PASS,K_UPPER|K_LINE);
249: truncsp(str);
250: if(chkpass(str,&useron,true))
251: break;
252: CRLF; }
253:
254: while(online) {
255: if(cfg.sys_misc&SM_PWEDIT) {
256: CRLF;
257: bputs(text[VerifyPassword]); }
258: else
259: bputs(text[NewUserPasswordVerify]);
260: console|=CON_R_ECHOX;
261: if(!(cfg.sys_misc&SM_ECHO_PW))
262: console|=CON_L_ECHOX;
263: getstr(tmp,LEN_PASS,K_UPPER);
264: console&=~(CON_R_ECHOX|CON_L_ECHOX);
265: if(strcmp(str,tmp)) {
266: bputs(text[Wrong]);
267: continue; }
268: break; }
269: strcpy(useron.pass,str);
270: useron.pwmod=time(NULL);
271: putuserrec(&cfg,useron.number,U_PWMOD,8,ultoa(useron.pwmod,str,16));
272: bputs(text[PasswordChanged]);
273: pause(); }
274: if(useron.ltoday>cfg.level_callsperday[useron.level]
275: && !(useron.exempt&FLAG('L'))) {
276: bputs(text[NoMoreLogons]);
277: sprintf(str,"(%04u) %-25s Out of logons"
278: ,useron.number,useron.alias);
279: logline("+!",str);
280: hangup();
281: return(false); }
282: if(useron.rest&FLAG('L') && useron.ltoday>1) {
283: bputs(text[R_Logons]);
284: sprintf(str,"(%04u) %-25s Out of logons"
285: ,useron.number,useron.alias);
286: logline("+!",str);
287: hangup();
288: return(false); }
289: if(!(useron.rest&FLAG('G'))) {
290: if(!useron.name[0] && ((cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME)
291: || cfg.uq&UQ_COMPANY))
292: while(online) {
293: if(cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME)
294: bputs(text[EnterYourRealName]);
295: else
296: bputs(text[EnterYourCompany]);
297: getstr(useron.name,LEN_NAME,K_UPRLWR|(cfg.uq&UQ_NOEXASC));
298: if(cfg.uq&UQ_ALIASES && cfg.uq&UQ_REALNAME) {
299: if(trashcan(useron.name,"name") || !useron.name[0]
300: || !strchr(useron.name,SP)
301: || strchr(useron.name,0xff)
302: || (cfg.uq&UQ_DUPREAL
303: && userdatdupe(useron.number,U_NAME,LEN_NAME
304: ,useron.name,0)))
305: bputs(text[YouCantUseThatName]);
306: else
307: break; }
308: else
309: break; }
310: if(cfg.uq&UQ_HANDLE && !useron.handle[0]) {
311: sprintf(useron.handle,"%.*s",LEN_HANDLE,useron.alias);
312: while(online) {
313: bputs(text[EnterYourHandle]);
314: if(!getstr(useron.handle,LEN_HANDLE
315: ,K_LINE|K_EDIT|K_AUTODEL|(cfg.uq&UQ_NOEXASC))
316: || strchr(useron.handle,0xff)
317: || (cfg.uq&UQ_DUPHAND
318: && userdatdupe(useron.number,U_HANDLE,LEN_HANDLE
319: ,useron.handle,0))
320: || trashcan(useron.handle,"name"))
321: bputs(text[YouCantUseThatName]);
322: else
323: break; } }
324: if(cfg.uq&UQ_LOCATION && !useron.location[0])
325: while(online) {
326: bputs(text[EnterYourCityState]);
327: if(getstr(useron.location,LEN_LOCATION,K_UPRLWR|(cfg.uq&UQ_NOEXASC)))
328: break; }
329: if(cfg.uq&UQ_ADDRESS && !useron.address[0])
330: while(online) {
331: bputs(text[EnterYourAddress]);
332: if(getstr(useron.address,LEN_ADDRESS,K_UPRLWR|(cfg.uq&UQ_NOEXASC)))
333: break; }
334: if(cfg.uq&UQ_ADDRESS && !useron.zipcode[0])
335: while(online) {
336: bputs(text[EnterYourZipCode]);
337: if(getstr(useron.zipcode,LEN_ZIPCODE,K_UPPER|(cfg.uq&UQ_NOEXASC)))
338: break; }
339: if(cfg.uq&UQ_PHONE && !useron.phone[0]) {
340: i=yesno(text[CallingFromNorthAmericaQ]);
341: while(online) {
342: bputs(text[EnterYourPhoneNumber]);
343: if(i) {
344: if(gettmplt(useron.phone,cfg.sys_phonefmt
345: ,K_LINE|(cfg.uq&UQ_NOEXASC))<strlen(cfg.sys_phonefmt))
346: continue; }
347: else {
348: if(getstr(useron.phone,LEN_PHONE
349: ,K_UPPER|(cfg.uq&UQ_NOEXASC))<5)
350: continue; }
351: if(!trashcan(useron.phone,"phone"))
352: break; } }
353: if(!(sys_status&SS_RLOGIN)
354: && /* cfg.uq&UQ_EMAIL && */ !useron.netmail[0]) {
355: while(online) {
356: bputs(text[EnterNetMailAddress]);
357: if(getstr(useron.netmail,LEN_NETMAIL,K_EDIT|K_AUTODEL|K_LINE))
358: break;
359: }
360: if(useron.netmail[0] && !noyes(text[ForwardMailQ]))
361: useron.misc|=NETMAIL;
362: else
363: useron.misc&=~NETMAIL;
364: }
365: if(cfg.new_sif[0]) {
366: sprintf(str,"%suser/%4.4u.dat",cfg.data_dir,useron.number);
367: if(flength(str)<1L)
368: create_sif_dat(cfg.new_sif,str); }
369: }
370: }
371: if(!online) {
372: sprintf(str,"(%04u) %-25s Unsuccessful logon"
373: ,useron.number,useron.alias);
374: logline("+!",str);
375: return(false); }
376: strcpy(useron.modem,connection);
377: useron.logons++;
378: putuserdat(&cfg,&useron);
379: getmsgptrs();
380: sys_status|=SS_USERON; /* moved from further down */
381:
382: if(useron.rest&FLAG('Q')) {
383: sprintf(str,"(%04u) %-25s QWK Network Connection"
384: ,useron.number,useron.alias);
385: logline("++",str);
386: return(true); }
387:
388: /********************/
389: /* SUCCESSFUL LOGON */
390: /********************/
391: totallogons=logonstats();
392: sprintf(str,"(%04u) %-25s Logon %lu - %u"
393: ,useron.number,useron.alias,totallogons,useron.ltoday);
394: logline("++",str);
395:
396: if(!qwklogon && cfg.logon_mod[0])
397: exec_bin(cfg.logon_mod,&main_csi);
398:
399: if(thisnode.status!=NODE_QUIET && (!REALSYSOP || cfg.sys_misc&SM_SYSSTAT)) {
400: sprintf(str,"%slogon.lst",cfg.data_dir);
401: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
402: errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_CREAT|O_APPEND);
403: return(false); }
404: sprintf(str,text[LastFewCallersFmt],cfg.node_num
405: ,totallogons,useron.alias
406: ,cfg.sys_misc&SM_LISTLOC ? useron.location : useron.note
407: ,tm.tm_hour,tm.tm_min
408: ,connection,useron.ltoday);
409: write(file,str,strlen(str));
410: close(file); }
411:
412: if(cfg.sys_logon[0]) /* execute system logon event */
413: external(cmdstr(cfg.sys_logon,nulstr,nulstr,NULL),EX_OUTR|EX_OUTL); /* EX_CC */
414:
415: if(qwklogon)
416: return(true);
417:
418: sys_status|=SS_PAUSEON; /* always force pause on during this section */
419: mailw=getmail(&cfg,useron.number,0);
420: bprintf(text[SiSysName],cfg.sys_name);
421: //bprintf(text[SiNodeNumberName],cfg.node_num,cfg.node_name);
422: bprintf(text[LiUserNumberName],useron.number,useron.alias);
423: bprintf(text[LiLogonsToday],useron.ltoday
424: ,cfg.level_callsperday[useron.level]);
425: bprintf(text[LiTimeonToday],useron.ttoday
426: ,cfg.level_timeperday[useron.level]+useron.min);
427: bprintf(text[LiMailWaiting],mailw);
428: strcpy(str,text[LiSysopIs]);
429: if(cfg.startup->options&BBS_OPT_SYSOP_AVAILABLE
430: || (cfg.sys_chat_ar[0] && chk_ar(cfg.sys_chat_ar,&useron)))
431: strcat(str,text[LiSysopAvailable]);
432: else
433: strcat(str,text[LiSysopNotAvailable]);
434: bprintf("%s\r\n\r\n",str);
435: if(sys_status&SS_EVENT)
436: bputs(text[ReducedTime]);
437: getnodedat(cfg.node_num,&thisnode,1);
438: thisnode.misc&=~(NODE_AOFF|NODE_POFF);
439: if(useron.chat&CHAT_NOACT)
440: thisnode.misc|=NODE_AOFF;
441: if(useron.chat&CHAT_NOPAGE)
442: thisnode.misc|=NODE_POFF;
443: putnodedat(cfg.node_num,&thisnode);
444: getsmsg(useron.number); /* Moved from further down */
445: SYNC;
446: c=0;
447: for(i=1;i<=cfg.sys_nodes;i++)
448: if(i!=cfg.node_num) {
449: getnodedat(i,&node,0);
450: if(node.status==NODE_INUSE
451: || ((node.status==NODE_QUIET || node.errors) && SYSOP)) {
452: if(!c)
453: bputs(text[NodeLstHdr]);
454: printnodedat(i,&node);
455: c=1; }
456: if(node.status==NODE_INUSE && i!=cfg.node_num && node.useron==useron.number
457: && !SYSOP && !(useron.exempt&FLAG('G'))) {
458: strcpy(tmp,"On two nodes at the same time");
459: sprintf(str,"(%04u) %-25s %s"
460: ,useron.number,useron.alias,tmp);
461: logline("+!",str);
462: errorlog(tmp);
463: bputs(text[UserOnTwoNodes]);
464: hangup();
465: return(false); }
466: if(thisnode.status!=NODE_QUIET
467: && (node.status==NODE_INUSE || node.status==NODE_QUIET)
468: && !(node.misc&NODE_AOFF) && node.useron!=useron.number) {
469: sprintf(str,text[NodeLoggedOnAtNbps]
470: ,cfg.node_num
471: ,thisnode.misc&NODE_ANON ? text[UNKNOWN_USER] : useron.alias
472: ,connection);
473: putnmsg(i,str); } }
474:
475: if(cfg.sys_exp_warn && useron.expire && useron.expire>now /* Warn user of coming */
476: && (useron.expire-now)/(1440L*60L)<=cfg.sys_exp_warn) /* expiration */
477: bprintf(text[AccountWillExpireInNDays],(useron.expire-now)/(1440L*60L));
478:
479: if(criterrs && SYSOP)
480: bprintf(text[CriticalErrors],criterrs);
481: if((i=getuserxfers(0,useron.number,0))!=0) {
482: bprintf(text[UserXferForYou],i,i>1 ? "s" : nulstr); }
483: if((i=getuserxfers(useron.number,0,0))!=0) {
484: bprintf(text[UnreceivedUserXfer],i,i>1 ? "s" : nulstr); }
485: SYNC;
486: sys_status&=~SS_PAUSEON; /* Turn off the pause override flag */
487: if(online==ON_REMOTE)
488: rioctl(IOSM|ABORT); /* Turn abort ability on */
489: if(mailw) {
490: if(yesno(text[ReadYourMailNowQ]))
491: readmail(useron.number,MAIL_YOUR); }
492: if(useron.misc&ASK_NSCAN && yesno(text[NScanAllGrpsQ]))
493: scanallsubs(SCAN_NEW);
494: if(useron.misc&ASK_SSCAN && yesno(text[SScanAllGrpsQ]))
495: scanallsubs(SCAN_TOYOU);
496: return(true);
497: }
498:
499: /****************************************************************************/
500: /* Checks the system dsts.dab to see if it is a new day, if it is, all the */
501: /* nodes' and the system's csts.dab are added to, and the dsts.dab's daily */
502: /* stats are cleared. Also increments the logon values in dsts.dab if */
503: /* applicable. */
504: /****************************************************************************/
505: ulong sbbs_t::logonstats()
506: {
507: char str[256];
508: int dsts,csts;
509: uint i;
510: time_t update_t;
511: stats_t stats;
512: node_t node;
513: struct tm * tm, update_tm;
514:
515: sprintf(str,"%sdsts.dab",cfg.ctrl_dir);
516: if((dsts=nopen(str,O_RDWR))==-1) {
517: errormsg(WHERE,ERR_OPEN,str,O_RDWR);
518: return(0L); }
519: read(dsts,&update_t,4); /* Last updated */
520: read(dsts,&stats.logons,4); /* Total number of logons on system */
521: close(dsts);
522: if(update_t>now+(24L*60L*60L)) /* More than a day in the future? */
523: errormsg(WHERE,ERR_CHK,"Daily stats time stamp",update_t);
524: tm = gmtime(&update_t);
525: if(tm==NULL)
526: return(0);
527: update_tm=*tm;
528: tm = gmtime(&now);
529: if(tm==NULL)
530: return(0);
531: if((tm->tm_mday>update_tm.tm_mday && tm->tm_mon==update_tm.tm_mon)
532: || tm->tm_mon>update_tm.tm_mon || tm->tm_year>update_tm.tm_year) {
533:
534: sprintf(str,"New Day - Prev: %s ",timestr(&update_t));
535: logentry("!=",str);
536:
537: sys_status|=SS_DAILY; /* New Day !!! */
538: sprintf(str,"%slogon.lst",cfg.data_dir); /* Truncate logon list */
539: if((dsts=nopen(str,O_TRUNC|O_CREAT|O_WRONLY))==-1) {
540: errormsg(WHERE,ERR_OPEN,str,O_TRUNC|O_CREAT|O_WRONLY);
541: return(0L); }
542: close(dsts);
543: for(i=0;i<=cfg.sys_nodes;i++) {
544: if(i) { /* updating a node */
545: getnodedat(i,&node,1);
546: node.misc|=NODE_EVENT;
547: putnodedat(i,&node); }
548: sprintf(str,"%sdsts.dab",i ? cfg.node_path[i-1] : cfg.ctrl_dir);
549: if((dsts=nopen(str,O_RDWR))==-1) /* node doesn't have stats yet */
550: continue;
551: sprintf(str,"%scsts.dab",i ? cfg.node_path[i-1] : cfg.ctrl_dir);
552: if((csts=nopen(str,O_WRONLY|O_APPEND|O_CREAT))==-1) {
553: close(dsts);
554: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_APPEND|O_CREAT);
555: continue; }
556: lseek(dsts,8L,SEEK_SET); /* Skip time and logons */
557: write(csts,&now,4);
558: read(dsts,&stats.ltoday,4);
559: write(csts,&stats.ltoday,4);
560: lseek(dsts,4L,SEEK_CUR); /* Skip total time on */
561: read(dsts,&stats.ttoday,4);
562: write(csts,&stats.ttoday,4);
563: read(dsts,&stats.uls,4);
564: write(csts,&stats.uls,4);
565: read(dsts,&stats.ulb,4);
566: write(csts,&stats.ulb,4);
567: read(dsts,&stats.dls,4);
568: write(csts,&stats.dls,4);
569: read(dsts,&stats.dlb,4);
570: write(csts,&stats.dlb,4);
571: read(dsts,&stats.ptoday,4);
572: write(csts,&stats.ptoday,4);
573: read(dsts,&stats.etoday,4);
574: write(csts,&stats.etoday,4);
575: read(dsts,&stats.ftoday,4);
576: write(csts,&stats.ftoday,4);
577: close(csts);
578: lseek(dsts,0L,SEEK_SET); /* Go back to beginning */
579: write(dsts,&now,4); /* Update time stamp */
580: lseek(dsts,4L,SEEK_CUR); /* Skip total logons */
581: stats.ltoday=0;
582: write(dsts,&stats.ltoday,4); /* Logons today to 0 */
583: lseek(dsts,4L,SEEK_CUR); /* Skip total time on */
584: stats.ttoday=0; /* Set all other today variables to 0 */
585: write(dsts,&stats.ttoday,4); /* Time on today to 0 */
586: write(dsts,&stats.ttoday,4); /* Uploads today to 0 */
587: write(dsts,&stats.ttoday,4); /* U/L Bytes today */
588: write(dsts,&stats.ttoday,4); /* Download today */
589: write(dsts,&stats.ttoday,4); /* Download bytes */
590: write(dsts,&stats.ttoday,4); /* Posts today */
591: write(dsts,&stats.ttoday,4); /* Emails today */
592: write(dsts,&stats.ttoday,4); /* Feedback today */
593: write(dsts,&stats.ttoday,2); /* New users Today */
594: close(dsts); } }
595:
596: if(thisnode.status==NODE_QUIET) /* Quiet users aren't counted */
597: return(0);
598:
599: if(REALSYSOP && !(cfg.sys_misc&SM_SYSSTAT))
600: return(0);
601:
602: for(i=0;i<2;i++) {
603: sprintf(str,"%sdsts.dab",i ? cfg.ctrl_dir : cfg.node_dir);
604: if((dsts=nopen(str,O_RDWR))==-1) {
605: errormsg(WHERE,ERR_OPEN,str,O_RDWR);
606: return(0L); }
607: lseek(dsts,4L,SEEK_SET); /* Skip time stamp */
608: read(dsts,&stats.logons,4);
609: read(dsts,&stats.ltoday,4);
610: stats.logons++;
611: stats.ltoday++;
612: lseek(dsts,4L,SEEK_SET); /* Rewind back and overwrite */
613: write(dsts,&stats.logons,4);
614: write(dsts,&stats.ltoday,4);
615: close(dsts); }
616: return(stats.logons);
617: }
618:
619:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.