![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to logfile.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 logfile.cpp CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* logfile.cpp */
2:
3: /* Synchronet log file routines */
4:
5: /* $Id: logfile.cpp,v 1.38 2006/02/03 03:47:10 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 2006 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:
40: extern "C" BOOL DLLCALL hacklog(scfg_t* cfg, char* prot, char* user, char* text, char* host, SOCKADDR_IN* addr)
41: {
42: char hdr[1024];
43: char tstr[64];
44: char fname[MAX_PATH+1];
45: int file;
46: time_t now=time(NULL);
47:
48: sprintf(fname,"%shack.log",cfg->logs_dir);
49:
50: if((file=sopen(fname,O_CREAT|O_RDWR|O_BINARY|O_APPEND,SH_DENYWR,S_IREAD|S_IWRITE))==-1)
51: return(FALSE);
52:
53: sprintf(hdr,"SUSPECTED %s HACK ATTEMPT from %s on %.24s\r\nUsing port %u at %s [%s]\r\nDetails: "
54: ,prot
55: ,user
56: ,timestr(cfg,&now,tstr)
57: ,addr->sin_port
58: ,host
59: ,inet_ntoa(addr->sin_addr)
60: );
61: write(file,hdr,strlen(hdr));
62: write(file,text,strlen(text));
63: write(file,crlf,2);
64: write(file,crlf,2);
65: close(file);
66:
67: return(TRUE);
68: }
69:
70: extern "C" BOOL DLLCALL spamlog(scfg_t* cfg, char* prot, char* action
71: ,char* reason, char* host, char* ip_addr
72: ,char* to, char* from)
73: {
74: char hdr[1024];
75: char to_user[256];
76: char tstr[64];
77: char fname[MAX_PATH+1];
78: int file;
79: time_t now=time(NULL);
80:
81: sprintf(fname,"%sspam.log",cfg->logs_dir);
82:
83: if((file=sopen(fname,O_CREAT|O_RDWR|O_BINARY|O_APPEND,SH_DENYWR,S_IREAD|S_IWRITE))==-1)
84: return(FALSE);
85:
86: if(to==NULL)
87: to_user[0]=0;
88: else
89: sprintf(to_user,"to: %.128s",to);
90:
91: if(from==NULL)
92: from=host;
93:
94: sprintf(hdr,"SUSPECTED %s SPAM %s on %.24s\r\nHost: %s [%s]\r\nFrom: %.128s %s\r\nReason: "
95: ,prot
96: ,action
97: ,timestr(cfg,&now,tstr)
98: ,host
99: ,ip_addr
100: ,from
101: ,to_user
102: );
103: write(file,hdr,strlen(hdr));
104: if(reason!=NULL)
105: write(file,reason,strlen(reason));
106: write(file,crlf,2);
107: write(file,crlf,2);
108: close(file);
109:
110: return(TRUE);
111: }
112:
113: void sbbs_t::logentry(char *code, char *entry)
114: {
115: char str[512];
116:
117: now=time(NULL);
118: sprintf(str,"Node %2d %s\r\n %s",cfg.node_num,timestr(&now),entry);
119: logline(code,str);
120: }
121:
122: /****************************************************************************/
123: /* Writes 'str' verbatim into node.log */
124: /****************************************************************************/
125: void sbbs_t::log(char *str)
126: {
127: if(logfile_fp==NULL || online==ON_LOCAL) return;
128: if(logcol>=78 || (78-logcol)<strlen(str)) {
129: fprintf(logfile_fp,"\r\n");
130: logcol=1; }
131: if(logcol==1) {
132: fprintf(logfile_fp," ");
133: logcol=4; }
134: fprintf(logfile_fp,str);
135: if(str[strlen(str)-1]==LF)
136: logcol=1;
137: else
138: logcol+=strlen(str);
139: }
140:
141: bool sbbs_t::syslog(char* code, char *entry)
142: {
143: char fname[MAX_PATH+1];
144: char str[128];
145: char tmp[64];
146: int file;
147: struct tm tm;
148:
149: now=time(NULL);
150: if(localtime_r(&now,&tm)==NULL)
151: return(false);
152: sprintf(fname,"%slogs/%2.2d%2.2d%2.2d.log",cfg.logs_dir,tm.tm_mon+1,tm.tm_mday
153: ,TM_YEAR(tm.tm_year));
154: if((file=nopen(fname,O_WRONLY|O_APPEND|O_CREAT))==-1) {
155: lprintf(LOG_ERR,"!ERRROR %d opening/creating %s",errno,fname);
156: return(false);
157: }
158:
159: sprintf(str,"%-2.2s %s %s\r\n\r\n",code, hhmmtostr(&cfg,&tm,tmp), entry);
160: write(file,str,strlen(str));
161: close(file);
162:
163: return(true);
164: }
165:
166: /****************************************************************************/
167: /* Writes 'str' on it's own line in node.log */
168: /****************************************************************************/
169: void sbbs_t::logline(char *code, char *str)
170: {
171: if(strchr(str,'\n')==NULL) { // Keep the console log pretty
172: if(online==ON_LOCAL)
173: eprintf(LOG_INFO,"%s",str);
174: else
175: lprintf(LOG_INFO,"Node %d %s", cfg.node_num, str);
176: }
177: if(logfile_fp==NULL || (online==ON_LOCAL && strcmp(code,"!!"))) return;
178: if(logcol!=1)
179: fprintf(logfile_fp,"\r\n");
180: fprintf(logfile_fp,"%-2.2s %s\r\n",code,str);
181: logcol=1;
182: }
183:
184: /****************************************************************************/
185: /* Writes a comma then 'ch' to log, tracking column. */
186: /****************************************************************************/
187: void sbbs_t::logch(char ch, bool comma)
188: {
189:
190: if(logfile_fp==NULL || (online==ON_LOCAL)) return;
191: if((uchar)ch<' ') /* Don't log control chars */
192: return;
193: if(logcol==1) {
194: logcol=4;
195: fprintf(logfile_fp," ");
196: }
197: else if(logcol>=78) {
198: logcol=4;
199: fprintf(logfile_fp,"\r\n ");
200: }
201: if(comma && logcol!=4) {
202: fprintf(logfile_fp,",");
203: logcol++;
204: }
205: if(ch&0x80) {
206: ch&=0x7f;
207: if(ch<' ')
208: return;
209: fprintf(logfile_fp,"/");
210: }
211: fprintf(logfile_fp,"%c",ch);
212: logcol++;
213: }
214:
215: /****************************************************************************/
216: /* Error handling routine. Prints to local and remote screens the error */
217: /* information, function, action, object and access and then attempts to */
218: /* write the error information into the file ERROR.LOG and NODE.LOG */
219: /****************************************************************************/
220: void sbbs_t::errormsg(int line, const char *source, const char* action, const char *object
221: ,ulong access, const char *extinfo)
222: {
223: const char* src;
224: char str[2048];
225: char tmp[512];
226:
227: /* prevent recursion */
228: if(errormsg_inside)
229: return;
230: errormsg_inside=true;
231:
232: /* Don't log path to source code */
233: src=getfname(source);
234: #if 0
235: switch(action) {
236: case ERR_OPEN:
237: actstr="opening";
238: break;
239: case ERR_CLOSE:
240: actstr="closing";
241: break;
242: case ERR_FDOPEN:
243: actstr="fdopen";
244: break;
245: case ERR_READ:
246: actstr="reading";
247: break;
248: case ERR_WRITE:
249: actstr="writing";
250: break;
251: case ERR_REMOVE:
252: actstr="removing";
253: break;
254: case ERR_ALLOC:
255: actstr="allocating memory";
256: break;
257: case ERR_CHK:
258: actstr="checking";
259: break;
260: case ERR_LEN:
261: actstr="checking length";
262: break;
263: case ERR_EXEC:
264: actstr="executing";
265: break;
266: case ERR_CHDIR:
267: actstr="changing directory";
268: break;
269: case ERR_CREATE:
270: actstr="creating";
271: break;
272: case ERR_LOCK:
273: actstr="locking";
274: break;
275: case ERR_UNLOCK:
276: actstr="unlocking";
277: break;
278: case ERR_TIMEOUT:
279: actstr="time-out waiting for resource";
280: break;
281: case ERR_IOCTL:
282: actstr="sending IOCTL";
283: break;
284: default:
285: actstr="UNKNOWN";
286: break;
287: }
288: #endif
289: sprintf(str,"Node %d !ERROR %d "
290: #ifdef _WIN32
291: "(WinError %d) "
292: #endif
293: "in %s line %d %s \"%s\" access=%ld"
294: ,cfg.node_num, errno
295: #ifdef _WIN32
296: ,GetLastError()
297: #endif
298: ,src, line, action, object, access);
299: if(online==ON_LOCAL)
300: eprintf(LOG_ERR,"%s",str);
301: else {
302: lprintf(LOG_ERR,"%s",str);
303: bprintf("\7\r\nERROR - action: %s",action); /* tell user about error */
304: bprintf("\7\r\n object: %s",object);
305: bprintf("\7\r\n access: %ld",access);
306: if(access>9 && (long)access!=-1 && (short)access!=-1 && (char)access!=-1)
307: bprintf(" (0x%lX)",access);
308: if(cfg.sys_misc&SM_ERRALARM) {
309: sbbs_beep(500,220); sbbs_beep(250,220);
310: sbbs_beep(500,220); sbbs_beep(250,220);
311: sbbs_beep(500,220); sbbs_beep(250,220);
312: nosound(); }
313: bputs("\r\n\r\nThe sysop has been notified. <Hit a key>");
314: getkey(0);
315: CRLF;
316: }
317: sprintf(str,"\r\n source: %s\r\n line: %d\r\n action: %s\r\n"
318: " object: %s\r\n access: %ld"
319: ,src,line,action,object,access);
320: if(access>9 && (long)access!=-1 && (short)access!=-1 && (char)access!=-1) {
321: sprintf(tmp," (0x%lX)",access);
322: strcat(str,tmp); }
323: if(extinfo!=NULL) {
324: sprintf(tmp,"\r\n info: %s",extinfo);
325: strcat(str,tmp);
326: }
327: if(errno) {
328: sprintf(tmp,"\r\n errno: %d (%s)",errno,strerror(errno));
329: strcat(str,tmp);
330: errno=0;
331: }
332: #if defined(_WIN32)
333: if(GetLastError()!=0) {
334: sprintf(tmp,"\r\n WinError: %d (0x%X)",GetLastError(), GetLastError());
335: strcat(str,tmp);
336: }
337: #endif
338: errorlog(str);
339: errormsg_inside=false;
340: }
341:
342: /*****************************************************************************/
343: /* Error logging to NODE.LOG and DATA\ERROR.LOG function */
344: /*****************************************************************************/
345: void sbbs_t::errorlog(char *text)
346: {
347: char hdr[256],str[256],tmp2[256];
348: int file;
349:
350: if(errorlog_inside) /* let's not go recursive on this puppy */
351: return;
352: errorlog_inside=1;
353: if(cfg.node_num>0) {
354: getnodedat(cfg.node_num,&thisnode,1);
355: if(thisnode.errors<UCHAR_MAX)
356: thisnode.errors++;
357: criterrs=thisnode.errors;
358: putnodedat(cfg.node_num,&thisnode);
359: }
360: now=time(NULL);
361: logline("!!",text);
362: sprintf(str,"%serror.log",cfg.logs_dir);
363: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
364: sprintf(tmp2,"!ERROR %d opening/creating %s",errno,str);
365: logline("!!",tmp2);
366: errorlog_inside=0;
367: return; }
368: sprintf(hdr,"%s Node %2d: %s #%d"
369: ,timestr(&now),cfg.node_num,useron.alias,useron.number);
370: write(file,hdr,strlen(hdr));
371: write(file,crlf,2);
372: write(file,text,strlen(text));
373: write(file,"\r\n\r\n",4);
374: close(file);
375: errorlog_inside=0;
376: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.