![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to userdat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs3|
Return to userdat.c CVS log | Up to [Synchronet] / sbbs / sbbs3 |
1.1 root 1: /* userdat.c */
2:
3: /* Synchronet user data-related routines (exported) */
4:
5: /* $Id: userdat.c,v 1.10 2000/12/05 19:06:41 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: /* convenient space-saving global variables */
42: char* crlf="\r\n";
43: char* nulstr="";
44:
45: /****************************************************************************/
46: /* Looks for a perfect match amoung all usernames (not deleted users) */
47: /* Makes dots and underscores synomynous with spaces for comparisions */
48: /* Returns the number of the perfect matched username or 0 if no match */
49: /****************************************************************************/
50: uint DLLCALL matchuser(scfg_t* cfg, char *name)
51: {
52: int file;
53: char str[256],c;
54: ulong l,length;
55: FILE *stream;
56:
57: sprintf(str,"%suser/name.dat",cfg->data_dir);
58: if((file=nopen(str,O_RDONLY))==-1)
59: return(0);
60: length=filelength(file);
61: if((stream=fdopen(file,"rb"))==NULL)
62: return(0);
63: for(l=0;l<length;l+=LEN_ALIAS+2) {
64: fread(str,LEN_ALIAS+2,1,stream);
65: for(c=0;c<LEN_ALIAS;c++)
66: if(str[c]==ETX) break;
67: str[c]=0;
68: if(!stricmp(str,name))
69: break;
70: /* convert dots to spaces */
71: for(c=0;str[c];c++)
72: if(str[c]=='.')
73: str[c]=' ';
74: if(!stricmp(str,name))
75: break;
76: /* convert spaces to dots */
77: for(c=0;str[c];c++)
78: if(str[c]==' ')
79: str[c]='.';
80: if(!stricmp(str,name))
81: break;
82: /* convert dots to underscores */
83: for(c=0;str[c];c++)
84: if(str[c]=='.')
85: str[c]='_';
86: if(!stricmp(str,name))
87: break;
88: /* convert underscores to spaces */
89: for(c=0;str[c];c++)
90: if(str[c]=='_')
91: str[c]=' ';
92: if(!stricmp(str,name))
93: break;
94: }
95: fclose(stream);
96: if(l<length)
97: return((l/(LEN_ALIAS+2))+1);
98: return(0);
99: }
100:
101: /****************************************************************************/
102: /* Returns the number of the last user in user.dat (deleted ones too) */
103: /****************************************************************************/
104: uint DLLCALL lastuser(scfg_t* cfg)
105: {
106: char str[256];
107: long length;
108:
109: sprintf(str,"%suser/user.dat", cfg->data_dir);
110: if((length=flength(str))>0)
111: return((uint)(length/U_LEN));
112: return(0);
113: }
114:
115: /****************************************************************************/
116: /* Fills the structure 'user' with info for user.number from user.dat */
117: /* Called from functions useredit, waitforcall and main_sec */
118: /****************************************************************************/
119: int DLLCALL getuserdat(scfg_t* cfg, user_t *user)
120: {
121: char userdat[U_LEN+1],str[U_LEN+1],tmp[64];
122: int i,file;
123:
124: if(!user->number || user->number>lastuser(cfg)) {
125: memset(user,0,sizeof(user_t));
126: return(-1);
127: }
128: sprintf(userdat,"%suser/user.dat",cfg->data_dir);
129: if((file=nopen(userdat,O_RDONLY|O_DENYNONE))==-1) {
130: memset(user,0,sizeof(user_t));
131: return(errno);
132: }
133: lseek(file,(long)((long)(user->number-1)*U_LEN),SEEK_SET);
134: i=0;
135: while(i<LOOP_NODEDAB
136: && lock(file,(long)((long)(user->number-1)*U_LEN),U_LEN)==-1) {
137: if(i>10)
138: mswait(55);
139: i++;
140: }
141:
142: if(i>=LOOP_NODEDAB) {
143: close(file);
144: memset(user,0L,sizeof(user_t));
145: return(-2);
146: }
147:
148: if(read(file,userdat,U_LEN)!=U_LEN) {
149: unlock(file,(long)((long)(user->number-1)*U_LEN),U_LEN);
150: close(file);
151: memset(user,0L,sizeof(user_t));
152: return(-3);
153: }
154:
155: unlock(file,(long)((long)(user->number-1)*U_LEN),U_LEN);
156: close(file);
157: getrec(userdat,U_ALIAS,LEN_ALIAS,user->alias);
158: /* order of these function */
159: getrec(userdat,U_NAME,LEN_NAME,user->name);
160: /* calls is irrelevant */
161: getrec(userdat,U_HANDLE,LEN_HANDLE,user->handle);
162: getrec(userdat,U_NOTE,LEN_NOTE,user->note);
163: getrec(userdat,U_COMP,LEN_COMP,user->comp);
164: getrec(userdat,U_COMMENT,LEN_COMMENT,user->comment);
165: getrec(userdat,U_NETMAIL,LEN_NETMAIL,user->netmail);
166: getrec(userdat,U_ADDRESS,LEN_ADDRESS,user->address);
167: getrec(userdat,U_LOCATION,LEN_LOCATION,user->location);
168: getrec(userdat,U_ZIPCODE,LEN_ZIPCODE,user->zipcode);
169: getrec(userdat,U_PASS,LEN_PASS,user->pass);
170: getrec(userdat,U_PHONE,LEN_PHONE,user->phone);
171: getrec(userdat,U_BIRTH,LEN_BIRTH,user->birth);
172: getrec(userdat,U_MODEM,LEN_MODEM,user->modem);
173: getrec(userdat,U_LASTON,8,str); user->laston=ahtoul(str);
174: getrec(userdat,U_FIRSTON,8,str); user->firston=ahtoul(str);
175: getrec(userdat,U_EXPIRE,8,str); user->expire=ahtoul(str);
176: getrec(userdat,U_PWMOD,8,str); user->pwmod=ahtoul(str);
177: getrec(userdat,U_NS_TIME,8,str);
178: user->ns_time=ahtoul(str);
179: if(user->ns_time<0x20000000L)
180: user->ns_time=user->laston; /* Fix for v2.00->v2.10 */
181:
182: getrec(userdat,U_LOGONS,5,str); user->logons=atoi(str);
183: getrec(userdat,U_LTODAY,5,str); user->ltoday=atoi(str);
184: getrec(userdat,U_TIMEON,5,str); user->timeon=atoi(str);
185: getrec(userdat,U_TEXTRA,5,str); user->textra=atoi(str);
186: getrec(userdat,U_TTODAY,5,str); user->ttoday=atoi(str);
187: getrec(userdat,U_TLAST,5,str); user->tlast=atoi(str);
188: getrec(userdat,U_POSTS,5,str); user->posts=atoi(str);
189: getrec(userdat,U_EMAILS,5,str); user->emails=atoi(str);
190: getrec(userdat,U_FBACKS,5,str); user->fbacks=atoi(str);
191: getrec(userdat,U_ETODAY,5,str); user->etoday=atoi(str);
192: getrec(userdat,U_PTODAY,5,str); user->ptoday=atoi(str);
193: getrec(userdat,U_ULB,10,str); user->ulb=atol(str);
194: getrec(userdat,U_ULS,5,str); user->uls=atoi(str);
195: getrec(userdat,U_DLB,10,str); user->dlb=atol(str);
196: getrec(userdat,U_DLS,5,str); user->dls=atoi(str);
197: getrec(userdat,U_CDT,10,str); user->cdt=atol(str);
198: getrec(userdat,U_MIN,10,str); user->min=atol(str);
199: getrec(userdat,U_LEVEL,2,str); user->level=atoi(str);
200: getrec(userdat,U_FLAGS1,8,str); user->flags1=ahtoul(str); /***
201: getrec(userdat,U_TL,2,str); user->tl=atoi(str); ***/
202: getrec(userdat,U_FLAGS2,8,str); user->flags2=ahtoul(str);
203: getrec(userdat,U_FLAGS3,8,str); user->flags3=ahtoul(str);
204: getrec(userdat,U_FLAGS4,8,str); user->flags4=ahtoul(str);
205: getrec(userdat,U_EXEMPT,8,str); user->exempt=ahtoul(str);
206: getrec(userdat,U_REST,8,str); user->rest=ahtoul(str);
207: getrec(userdat,U_ROWS,2,str); user->rows=atoi(str);
208: if(user->rows && user->rows<10)
209: user->rows=10;
210: user->sex=userdat[U_SEX];
211: if(!user->sex)
212: user->sex=SP; /* fix for v1b04 that could save as 0 */
213: user->prot=userdat[U_PROT];
214: if(user->prot<SP)
215: user->prot=SP;
216: getrec(userdat,U_MISC,8,str); user->misc=ahtoul(str);
217: if(user->rest&FLAG('Q'))
218: user->misc&=~SPIN;
219:
220: getrec(userdat,U_LEECH,2,str);
221: user->leech=(uchar)ahtoul(str);
222: getrec(userdat,U_CURSUB,8,user->cursub); /* was useron.cursub (01/19/00) */
223: getrec(userdat,U_CURDIR,8,user->curdir); /* was useron.curdir (01/19/00) */
224:
225: getrec(userdat,U_FREECDT,10,str);
226: user->freecdt=atol(str);
227:
228: getrec(userdat,U_XEDIT,8,str);
229: for(i=0;i<cfg->total_xedits;i++)
230: if(!stricmp(str,cfg->xedit[i]->code) /* && chk_ar(cfg->xedit[i]->ar,user) */)
231: break;
232: user->xedit=i+1;
233: if(user->xedit>cfg->total_xedits)
234: user->xedit=0;
235:
236: getrec(userdat,U_SHELL,8,str);
237: for(i=0;i<cfg->total_shells;i++)
238: if(!stricmp(str,cfg->shell[i]->code))
239: break;
240: if(i==cfg->total_shells)
241: i=0;
242: user->shell=i;
243:
244: getrec(userdat,U_QWK,8,str);
245: if(str[0]<SP) { /* v1c, so set defaults */
246: if(user->rest&FLAG('Q'))
247: user->qwk=(QWK_RETCTLA);
248: else
249: user->qwk=(QWK_FILES|QWK_ATTACH|QWK_EMAIL|QWK_DELMAIL); }
250: else
251: user->qwk=ahtoul(str);
252:
253: getrec(userdat,U_TMPEXT,3,user->tmpext);
254: if((!user->tmpext[0] || !strcmp(user->tmpext,"0")) && cfg->total_fcomps)
255: strcpy(user->tmpext,cfg->fcomp[0]->ext); /* For v1x to v2x conversion */
256:
257: getrec(userdat,U_CHAT,8,str);
258: user->chat=ahtoul(str);
259:
260: unixtodstr(cfg, time(NULL),str);
261: unixtodstr(cfg, user->laston,tmp);
262: if(strcmp(str,tmp) && user->ltoday) {
263: user->ltoday=user->ttoday=user->ptoday=user->etoday=user->textra=0;
264: user->freecdt=cfg->level_freecdtperday[user->level];
265: }
266:
267:
268: #if 0 // removed 01/19/00
269: if(useron.number==user->number) {
270: if(user!=&useron)
271: useron=*user;
272:
273: if(online) {
274:
275: #if 0 /* legacy? */
276: getusrdirs();
277: getusrsubs();
278: #endif
279: if(user->misc&AUTOTERM) { // was useron.misc (01/19/00)
280: user->misc&=~(ANSI|RIP|WIP);
281: user->misc|=autoterm; }
282: } }
283: #endif
284: return(0);
285: }
286:
287: /****************************************************************************/
288: /* Writes into user.number's slot in user.dat data in structure 'user' */
289: /* Called from functions newuser, useredit and main */
290: /****************************************************************************/
291: int DLLCALL putuserdat(scfg_t* cfg, user_t* user)
292: {
293: int i,file;
294: char userdat[U_LEN+1],str[U_LEN+1];
295: node_t node;
296:
297: if(!user->number)
298: return(-1);
299:
300: memset(userdat,ETX,U_LEN);
301: putrec(userdat,U_ALIAS,LEN_ALIAS+5,user->alias);
302: putrec(userdat,U_NAME,LEN_NAME,user->name);
303: putrec(userdat,U_HANDLE,LEN_HANDLE,user->handle);
304: putrec(userdat,U_HANDLE+LEN_HANDLE,2,crlf);
305:
306: putrec(userdat,U_NOTE,LEN_NOTE,user->note);
307: putrec(userdat,U_COMP,LEN_COMP,user->comp);
308: putrec(userdat,U_COMP+LEN_COMP,2,crlf);
309:
310: putrec(userdat,U_COMMENT,LEN_COMMENT,user->comment);
311: putrec(userdat,U_COMMENT+LEN_COMMENT,2,crlf);
312:
313: putrec(userdat,U_NETMAIL,LEN_NETMAIL,user->netmail);
314: putrec(userdat,U_NETMAIL+LEN_NETMAIL,2,crlf);
315:
316: putrec(userdat,U_ADDRESS,LEN_ADDRESS,user->address);
317: putrec(userdat,U_LOCATION,LEN_LOCATION,user->location);
318: putrec(userdat,U_ZIPCODE,LEN_ZIPCODE,user->zipcode);
319: putrec(userdat,U_ZIPCODE+LEN_ZIPCODE,2,crlf);
320:
321: putrec(userdat,U_PASS,LEN_PASS,user->pass);
322: putrec(userdat,U_PHONE,LEN_PHONE,user->phone);
323: putrec(userdat,U_BIRTH,LEN_BIRTH,user->birth);
324: putrec(userdat,U_MODEM,LEN_MODEM,user->modem);
325: putrec(userdat,U_LASTON,8,ultoa(user->laston,str,16));
326: putrec(userdat,U_FIRSTON,8,ultoa(user->firston,str,16));
327: putrec(userdat,U_EXPIRE,8,ultoa(user->expire,str,16));
328: putrec(userdat,U_PWMOD,8,ultoa(user->pwmod,str,16));
329: putrec(userdat,U_PWMOD+8,2,crlf);
330:
331: putrec(userdat,U_LOGONS,5,ultoa(user->logons,str,10));
332: putrec(userdat,U_LTODAY,5,ultoa(user->ltoday,str,10));
333: putrec(userdat,U_TIMEON,5,ultoa(user->timeon,str,10));
334: putrec(userdat,U_TEXTRA,5,ultoa(user->textra,str,10));
335: putrec(userdat,U_TTODAY,5,ultoa(user->ttoday,str,10));
336: putrec(userdat,U_TLAST,5,ultoa(user->tlast,str,10));
337: putrec(userdat,U_POSTS,5,ultoa(user->posts,str,10));
338: putrec(userdat,U_EMAILS,5,ultoa(user->emails,str,10));
339: putrec(userdat,U_FBACKS,5,ultoa(user->fbacks,str,10));
340: putrec(userdat,U_ETODAY,5,ultoa(user->etoday,str,10));
341: putrec(userdat,U_PTODAY,5,ultoa(user->ptoday,str,10));
342: putrec(userdat,U_PTODAY+5,2,crlf);
343:
344: putrec(userdat,U_ULB,10,ultoa(user->ulb,str,10));
345: putrec(userdat,U_ULS,5,ultoa(user->uls,str,10));
346: putrec(userdat,U_DLB,10,ultoa(user->dlb,str,10));
347: putrec(userdat,U_DLS,5,ultoa(user->dls,str,10));
348: putrec(userdat,U_CDT,10,ultoa(user->cdt,str,10));
349: putrec(userdat,U_MIN,10,ultoa(user->min,str,10));
350: putrec(userdat,U_MIN+10,2,crlf);
351:
352: putrec(userdat,U_LEVEL,2,ultoa(user->level,str,10));
353: putrec(userdat,U_FLAGS1,8,ultoa(user->flags1,str,16));
354: putrec(userdat,U_TL,2,nulstr); /* unused */
355: putrec(userdat,U_FLAGS2,8,ultoa(user->flags2,str,16));
356: putrec(userdat,U_EXEMPT,8,ultoa(user->exempt,str,16));
357: putrec(userdat,U_REST,8,ultoa(user->rest,str,16));
358: putrec(userdat,U_REST+8,2,crlf);
359:
360: putrec(userdat,U_ROWS,2,ultoa(user->rows,str,10));
361: userdat[U_SEX]=user->sex;
362: userdat[U_PROT]=user->prot;
363: putrec(userdat,U_MISC,8,ultoa(user->misc,str,16));
364: putrec(userdat,U_LEECH,2,ultoa(user->leech,str,16));
365:
366: putrec(userdat,U_CURSUB,8,user->cursub);
367: putrec(userdat,U_CURDIR,8,user->curdir);
368:
369: // putrec(userdat,U_CMDSET,2,ultoa(user->cmdset,str,16)); /* Unused */
370: putrec(userdat,U_CMDSET+2,2,crlf);
371:
372: putrec(userdat,U_XFER_CMD+LEN_XFER_CMD,2,crlf);
373:
374: putrec(userdat,U_MAIL_CMD+LEN_MAIL_CMD,2,crlf);
375:
376: putrec(userdat,U_FREECDT,10,ultoa(user->freecdt,str,10));
377:
378: putrec(userdat,U_FLAGS3,8,ultoa(user->flags3,str,16));
379: putrec(userdat,U_FLAGS4,8,ultoa(user->flags4,str,16));
380:
381: if(user->xedit)
382: putrec(userdat,U_XEDIT,8,cfg->xedit[user->xedit-1]->code);
383: else
384: putrec(userdat,U_XEDIT,8,nulstr);
385:
386: putrec(userdat,U_SHELL,8,cfg->shell[user->shell]->code);
387:
388: putrec(userdat,U_QWK,8,ultoa(user->qwk,str,16));
389: putrec(userdat,U_TMPEXT,3,user->tmpext);
390: putrec(userdat,U_CHAT,8,ultoa(user->chat,str,16));
391: putrec(userdat,U_NS_TIME,8,ultoa(user->ns_time,str,16));
392:
393: putrec(userdat,U_UNUSED,29,crlf);
394: putrec(userdat,U_UNUSED+29,2,crlf);
395:
396: sprintf(str,"%suser/user.dat", cfg->data_dir);
397: if((file=nopen(str,O_WRONLY|O_CREAT|O_DENYNONE))==-1) {
398: return(errno);
399: }
400:
401: lseek(file,(long)((long)((long)user->number-1)*U_LEN),SEEK_SET);
402:
403: i=0;
404: while(i<LOOP_NODEDAB
405: && lock(file,(long)((long)(user->number-1)*U_LEN),U_LEN)==-1) {
406: if(i>10)
407: mswait(55);
408: i++;
409: }
410:
411: if(i>=LOOP_NODEDAB) {
412: close(file);
413: return(-2);
414: }
415:
416: if(write(file,userdat,U_LEN)!=U_LEN) {
417: unlock(file,(long)((long)(user->number-1)*U_LEN),U_LEN);
418: close(file);
419: return(-3);
420: }
421: unlock(file,(long)((long)(user->number-1)*U_LEN),U_LEN);
422: close(file);
423: for(i=1;i<=cfg->sys_nodes;i++) { /* instant user data update */
424: if(i==cfg->node_num)
425: continue;
426: getnodedat(cfg, i,&node,0);
427: if(node.useron==user->number && (node.status==NODE_INUSE
428: || node.status==NODE_QUIET)) {
429: getnodedat(cfg, i,&node,1);
430: node.misc|=NODE_UDAT;
431: putnodedat(cfg, i,&node);
432: break;
433: }
434: }
435: return(0);
436: }
437:
438:
439: /****************************************************************************/
440: /* Returns the username in 'str' that corresponds to the 'usernumber' */
441: /* Called from functions everywhere */
442: /****************************************************************************/
443: char* DLLCALL username(scfg_t* cfg, int usernumber,char *strin)
444: {
445: char str[256];
446: char c;
447: int file;
448:
449: if(usernumber<1) {
450: strin[0]=0;
451: return(strin); }
452: sprintf(str,"%suser/name.dat",cfg->data_dir);
453: if(flength(str)<1L) {
454: strin[0]=0;
455: return(strin); }
456: if((file=nopen(str,O_RDONLY))==-1) {
457: strin[0]=0;
458: return(strin); }
459: if(filelength(file)<(long)((long)usernumber*(LEN_ALIAS+2))) {
460: close(file);
461: strin[0]=0;
462: return(strin); }
463: lseek(file,(long)((long)(usernumber-1)*(LEN_ALIAS+2)),SEEK_SET);
464: read(file,strin,LEN_ALIAS);
465: close(file);
466: for(c=0;c<LEN_ALIAS;c++)
467: if(strin[c]==ETX) break;
468: strin[c]=0;
469: if(!c)
470: strcpy(strin,"DELETED USER");
471: return(strin);
472: }
473:
474: /****************************************************************************/
475: /* Places into 'strout' CR or ETX terminated string starting at */
476: /* 'start' and ending at 'start'+'length' or terminator from 'strin' */
477: /****************************************************************************/
478: void DLLCALL getrec(char *strin,int start,int length,char *strout)
479: {
480: int i=0,stop;
481:
482: stop=start+length;
483: while(start<stop) {
484: if(strin[start]==ETX || strin[start]==CR || strin[start]==LF)
485: break;
486: strout[i++]=strin[start++];
487: }
488: strout[i]=0;
489: }
490:
491: /****************************************************************************/
492: /* Places into 'strout', 'strin' starting at 'start' and ending at */
493: /* 'start'+'length' */
494: /****************************************************************************/
495: void DLLCALL putrec(char *strout,int start,int length,char *strin)
496: {
497: int i=0,j;
498:
499: j=strlen(strin);
500: while(i<j && i<length)
501: strout[start++]=strin[i++];
502: while(i++<length)
503: strout[start++]=ETX;
504: }
505:
506:
507: /****************************************************************************/
508: /* Returns the age derived from the string 'birth' in the format MM/DD/YY */
509: /* Called from functions statusline, main_sec, xfer_sec, useredit and */
510: /* text files */
511: /****************************************************************************/
512: char DLLCALL getage(scfg_t* cfg, char *birth)
513: {
514: char age;
515: struct tm * tm;
516: time_t now;
517:
518: if(!atoi(birth) || !atoi(birth+3)) /* Invalid */
519: return(0);
520:
521: now=time(NULL);
522: tm=gmtime(&now);
523: if(tm==NULL)
524: return(0);
525: age=(tm->tm_year)-(((birth[6]&0xf)*10)+(birth[7]&0xf));
526: if(age>105)
527: age-=105;
528: tm->tm_mon++; /* convert to 1 based */
529: if(cfg->sys_misc&SM_EURODATE) { /* DD/MM/YY format */
530: if(atoi(birth)>31 || atoi(birth+3)>12)
531: return(0);
532: if(((birth[3]&0xf)*10)+(birth[4]&0xf)>tm->tm_mon ||
533: (((birth[3]&0xf)*10)+(birth[4]&0xf)==tm->tm_mon &&
534: ((birth[0]&0xf)*10)+(birth[1]&0xf)>tm->tm_mday))
535: age--; }
536: else { /* MM/DD/YY format */
537: if(atoi(birth)>12 || atoi(birth+3)>31)
538: return(0);
539: if(((birth[0]&0xf)*10)+(birth[1]&0xf)>tm->tm_mon ||
540: (((birth[0]&0xf)*10)+(birth[1]&0xf)==tm->tm_mon &&
541: ((birth[3]&0xf)*10)+(birth[4]&0xf)>tm->tm_mday))
542: age--; }
543: if(age<0)
544: return(0);
545: return(age);
546: }
547:
548:
549: /****************************************************************************/
550: /* Reads the data for node number 'number' into the structure 'node' */
551: /* from node.dab */
552: /* if lockit is non-zero, locks this node's record. putnodedat() unlocks it */
553: /****************************************************************************/
554: int DLLCALL getnodedat(scfg_t* cfg, uint number, node_t *node, char lockit)
555: {
556: char str[256];
557: int count=0;
558: int file;
559:
560: if(!number || number>cfg->sys_nodes)
561: return(-1);
562:
563: sprintf(str,"%snode.dab",cfg->ctrl_dir);
564: if((file=nopen(str,O_RDONLY|O_DENYNONE))==-1) {
565: memset(node,0,sizeof(node_t));
566: return(errno);
567: }
568:
569: number--; /* make zero based */
570: while(count<LOOP_NODEDAB) {
571: if(count>10)
572: mswait(100);
573: lseek(file,(long)number*sizeof(node_t),SEEK_SET);
574: if(lockit
575: && lock(file,(long)number*sizeof(node_t),sizeof(node_t))==-1) {
576: count++;
577: continue; }
578: if(read(file,node,sizeof(node_t))==sizeof(node_t))
579: break;
580: count++; }
581:
582: close(file);
583: if(count==LOOP_NODEDAB)
584: return(-2);
585:
586: return(0);
587: }
588:
589: /****************************************************************************/
590: /* Write the data from the structure 'node' into node.dab */
591: /* getnodedat(num,&node,1); must have been called before calling this func */
592: /* NOTE: ------^ the indicates the node record has been locked */
593: /****************************************************************************/
594: int DLLCALL putnodedat(scfg_t* cfg, uint number, node_t* node)
595: {
596: char str[256];
597: int file;
598:
599: if(!number || number>cfg->sys_nodes)
600: return(-1);
601:
602: sprintf(str,"%snode.dab",cfg->ctrl_dir);
603: if((file=nopen(str,O_RDWR|O_CREAT|O_DENYNONE))==-1) {
604: memset(node,0,sizeof(node_t));
605: return(errno);
606: }
607:
608: number--; /* make zero based */
609: lseek(file,(long)number*sizeof(node_t),SEEK_SET);
610: if(write(file,node,sizeof(node_t))!=sizeof(node_t)) {
611: unlock(file,(long)number*sizeof(node_t),sizeof(node_t));
612: close(file);
613: return(-2);
614: }
615: unlock(file,(long)number*sizeof(node_t),sizeof(node_t));
616: close(file);
617:
618: return(0);
619: }
620:
621: /****************************************************************************/
622: uint DLLCALL userdatdupe(scfg_t* cfg, uint usernumber, uint offset, uint datlen, char *dat
623: ,BOOL del)
624: {
625: char str[256];
626: uint i;
627: int file;
628: long l,length;
629:
630: truncsp(dat);
631: sprintf(str,"%suser/user.dat", cfg->data_dir);
632: if((file=nopen(str,O_RDONLY|O_DENYNONE))==-1)
633: return(0);
634: length=filelength(file);
635: for(l=0;l<length;l+=U_LEN) {
636: if(usernumber && l/U_LEN==(long)usernumber-1)
637: continue;
638: lseek(file,l+offset,SEEK_SET);
639: i=0;
640: while(i<LOOP_NODEDAB && lock(file,l,U_LEN)==-1) {
641: if(i>10)
642: mswait(55);
643: i++; }
644:
645: if(i>=LOOP_NODEDAB) {
646: close(file);
647: return(0); }
648:
649: read(file,str,datlen);
650: for(i=0;i<datlen;i++)
651: if(str[i]==ETX) break;
652: str[i]=0;
653: truncsp(str);
654: if(!stricmp(str,dat)) {
655: if(!del) { /* Don't include deleted users in search */
656: lseek(file,l+U_MISC,SEEK_SET);
657: read(file,str,8);
658: getrec(str,0,8,str);
659: if(ahtoul(str)&(DELETED|INACTIVE)) {
660: unlock(file,l,U_LEN);
661: continue; } }
662: unlock(file,l,U_LEN);
663: close(file);
664: return((l/U_LEN)+1); }
665: else
666: unlock(file,l,U_LEN); }
667: close(file);
668: return(0);
669: }
670:
671: /****************************************************************************/
672: /* Creates a short message for 'usernumber' than contains 'strin' */
673: /****************************************************************************/
674: int DLLCALL putsmsg(scfg_t* cfg, int usernumber, char *strin)
675: {
676: char str[256];
677: int file,i;
678: node_t node;
679:
680: sprintf(str,"%smsgs/%4.4u.msg",cfg->data_dir,usernumber);
681: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
682: return(errno);
683: }
684: i=strlen(strin);
685: if(write(file,strin,i)!=i) {
686: close(file);
687: return(errno);
688: }
689: close(file);
690: for(i=1;i<=cfg->sys_nodes;i++) { /* flag node if user on that msg waiting */
691: getnodedat(cfg,i,&node,0);
692: if(node.useron==usernumber
693: && (node.status==NODE_INUSE || node.status==NODE_QUIET)
694: && !(node.misc&NODE_MSGW)) {
695: getnodedat(cfg,i,&node,1);
696: node.misc|=NODE_MSGW;
697: putnodedat(cfg,i,&node);
698: }
699: }
700: return(0);
701: }
702:
703: static BOOL ar_exp(scfg_t* cfg, uchar **ptrptr, user_t* user)
704: {
705: BOOL result,not,or,equal;
706: uint i,n,artype=AR_LEVEL,age;
707: ulong l;
708: time_t now;
709: struct tm * tm;
710:
711: result = TRUE;
712:
713: for(;(**ptrptr);(*ptrptr)++) {
714:
715: if((**ptrptr)==AR_ENDNEST)
716: break;
717:
718: not=or=equal = FALSE;
719:
720: if((**ptrptr)==AR_OR) {
721: or=1;
722: (*ptrptr)++; }
723:
724: if((**ptrptr)==AR_NOT) {
725: not=1;
726: (*ptrptr)++; }
727:
728: if((**ptrptr)==AR_EQUAL) {
729: equal=1;
730: (*ptrptr)++; }
731:
732: if((result && or) || (!result && !or))
733: break;
734:
735: if((**ptrptr)==AR_BEGNEST) {
736: (*ptrptr)++;
737: if(ar_exp(cfg,ptrptr,user))
738: result=!not;
739: else
740: result=not;
741: while((**ptrptr)!=AR_ENDNEST && (**ptrptr)) /* in case of early exit */
742: (*ptrptr)++;
743: if(!(**ptrptr))
744: break;
745: continue; }
746:
747: artype=(**ptrptr);
748: switch(artype) {
749: case AR_ANSI: /* No arguments */
750: case AR_RIP:
751: case AR_WIP:
752: case AR_LOCAL:
753: case AR_EXPERT:
754: case AR_SYSOP:
755: case AR_QUIET:
756: case AR_OS2:
757: case AR_DOS:
758: break;
759: default:
760: (*ptrptr)++;
761: break; }
762:
763: n=(**ptrptr);
764: i=(*(short *)*ptrptr);
765: switch(artype) {
766: case AR_LEVEL:
767: if((equal && user->level!=n) || (!equal && user->level<n))
768: result=not;
769: else
770: result=!not;
771: break;
772: case AR_AGE:
773: age=getage(cfg,user->birth);
774: if((equal && age!=n) || (!equal && age<n))
775: result=not;
776: else
777: result=!not;
778: break;
779: case AR_BPS:
780: result=!not;
781: (*ptrptr)++;
782: break;
783: case AR_ANSI:
784: if(!(user->misc&ANSI))
785: result=not;
786: else result=!not;
787: break;
788: case AR_RIP:
789: if(!(user->misc&RIP))
790: result=not;
791: else result=!not;
792: break;
793: case AR_WIP:
794: if(!(user->misc&WIP))
795: result=not;
796: else result=!not;
797: break;
798: case AR_OS2:
799: #ifndef __OS2__
800: result=not;
801: #else
802: result=!not;
803: #endif
804: break;
805: case AR_DOS:
806: #ifdef __FLAT__
807: result=not;
808: #else
809: result=!not;
810: #endif
811: break;
812: case AR_WIN32:
813: #ifndef _WIN32
814: result=not;
815: #else
816: result=!not;
817: #endif
818: break;
819: case AR_UNIX:
820: #ifndef __unix__
821: result=not;
822: #else
823: result=!not;
824: #endif
825: break;
826: case AR_LINUX:
827: #ifndef __linux__
828: result=not;
829: #else
830: result=!not;
831: #endif
832: break;
833: case AR_EXPERT:
834: if(!(user->misc&EXPERT))
835: result=not;
836: else result=!not;
837: break;
838: case AR_SYSOP:
839: if(user->level<SYSOP_LEVEL)
840: result=not;
841: else result=!not;
842: break;
843: case AR_QUIET:
844: result=not;
845: break;
846: case AR_LOCAL:
847: result=not;
848: break;
849: case AR_DAY:
850: now=time(NULL);
851: tm=localtime(&now);
852: if(tm==NULL || (equal && tm->tm_wday!=(int)n)
853: || (!equal && tm->tm_wday<(int)n))
854: result=not;
855: else
856: result=!not;
857: break;
858: case AR_CREDIT:
859: l=(ulong)i*1024UL;
860: if((equal && user->cdt+user->freecdt!=l)
861: || (!equal && user->cdt+user->freecdt<l))
862: result=not;
863: else
864: result=!not;
865: (*ptrptr)++;
866: break;
867: case AR_NODE:
868: if((equal && cfg->node_num!=n) || (!equal && cfg->node_num<n))
869: result=not;
870: else
871: result=!not;
872: break;
873: case AR_USER:
874: if((equal && user->number!=i) || (!equal && user->number<i))
875: result=not;
876: else
877: result=!not;
878: (*ptrptr)++;
879: break;
880: case AR_GROUP:
881: result=not;
882: (*ptrptr)++;
883: break;
884: case AR_SUB:
885: result=not;
886: (*ptrptr)++;
887: break;
888: case AR_SUBCODE:
889: result=not;
890: while(*(*ptrptr))
891: (*ptrptr)++;
892: break;
893: case AR_LIB:
894: result=not;
895: (*ptrptr)++;
896: break;
897: case AR_DIR:
898: result=not;
899: (*ptrptr)++;
900: break;
901: case AR_DIRCODE:
902: result=not;
903: while(*(*ptrptr))
904: (*ptrptr)++;
905: break;
906: case AR_EXPIRE:
907: now=time(NULL);
908: if(!user->expire || now+((long)i*24L*60L*60L)>user->expire)
909: result=not;
910: else
911: result=!not;
912: (*ptrptr)++;
913: break;
914: case AR_RANDOM:
915: n=sbbs_random(i+1);
916: if((equal && n!=i) || (!equal && n<i))
917: result=not;
918: else
919: result=!not;
920: (*ptrptr)++;
921: break;
922: case AR_LASTON:
923: now=time(NULL);
924: if((now-user->laston)/(24L*60L*60L)<(long)i)
925: result=not;
926: else
927: result=!not;
928: (*ptrptr)++;
929: break;
930: case AR_LOGONS:
931: if((equal && user->logons!=i) || (!equal && user->logons<i))
932: result=not;
933: else
934: result=!not;
935: (*ptrptr)++;
936: break;
937: case AR_MAIN_CMDS:
938: result=not;
939: (*ptrptr)++;
940: break;
941: case AR_FILE_CMDS:
942: result=not;
943: (*ptrptr)++;
944: break;
945: case AR_TLEFT:
946: result=not;
947: break;
948: case AR_TUSED:
949: result=not;
950: break;
951: case AR_TIME:
952: now=time(NULL);
953: tm=gmtime(&now);
954: if(tm==NULL || (tm->tm_hour*60)+tm->tm_min<(int)i)
955: result=not;
956: else
957: result=!not;
958: (*ptrptr)++;
959: break;
960: case AR_PCR:
961: if(user->logons>user->posts
962: && (!user->posts || 100/(user->logons/user->posts)<(long)n))
963: result=not;
964: else
965: result=!not;
966: break;
967: case AR_UDR: /* up/download byte ratio */
968: l=user->dlb;
969: if(!l) l=1;
970: if(user->dlb>user->ulb
971: && (!user->ulb || 100/(l/user->ulb)<n))
972: result=not;
973: else
974: result=!not;
975: break;
976: case AR_UDFR: /* up/download file ratio */
977: i=user->dls;
978: if(!i) i=1;
979: if(user->dls>user->uls
980: && (!user->uls || 100/(i/user->uls)<n))
981: result=not;
982: else
983: result=!not;
984: break;
985: case AR_FLAG1:
986: if((!equal && !(user->flags1&FLAG(n)))
987: || (equal && user->flags1!=FLAG(n)))
988: result=not;
989: else
990: result=!not;
991: break;
992: case AR_FLAG2:
993: if((!equal && !(user->flags2&FLAG(n)))
994: || (equal && user->flags2!=FLAG(n)))
995: result=not;
996: else
997: result=!not;
998: break;
999: case AR_FLAG3:
1000: if((!equal && !(user->flags3&FLAG(n)))
1001: || (equal && user->flags3!=FLAG(n)))
1002: result=not;
1003: else
1004: result=!not;
1005: break;
1006: case AR_FLAG4:
1007: if((!equal && !(user->flags4&FLAG(n)))
1008: || (equal && user->flags4!=FLAG(n)))
1009: result=not;
1010: else
1011: result=!not;
1012: break;
1013: case AR_REST:
1014: if((!equal && !(user->rest&FLAG(n)))
1015: || (equal && user->rest!=FLAG(n)))
1016: result=not;
1017: else
1018: result=!not;
1019: break;
1020: case AR_EXEMPT:
1021: if((!equal && !(user->exempt&FLAG(n)))
1022: || (equal && user->exempt!=FLAG(n)))
1023: result=not;
1024: else
1025: result=!not;
1026: break;
1027: case AR_SEX:
1028: if(user->sex!=n)
1029: result=not;
1030: else
1031: result=!not;
1032: break; } }
1033: return(result);
1034: }
1035:
1036: BOOL DLLCALL chk_ar(scfg_t* cfg, uchar *ar, user_t* user)
1037: {
1038: uchar *p;
1039:
1040: if(ar==NULL)
1041: return(TRUE);
1042: p=ar;
1043: return(ar_exp(cfg,&p,user));
1044: }
1045:
1046: /****************************************************************************/
1047: /* Fills 'str' with record for usernumber starting at start for length bytes*/
1048: /* Called from function ??? */
1049: /****************************************************************************/
1050: int DLLCALL getuserrec(scfg_t* cfg, int usernumber,int start, int length, char *str)
1051: {
1052: char c,path[256];
1053: int i,file;
1054:
1055: if(!usernumber)
1056: return(-1);
1057: sprintf(path,"%suser/user.dat",cfg->data_dir);
1058: if((file=nopen(path,O_RDONLY|O_DENYNONE))==-1)
1059: return(errno);
1060: if(usernumber<1
1061: || filelength(file)<(long)((long)(usernumber-1L)*U_LEN)+(long)start) {
1062: close(file);
1063: return(-2);
1064: }
1065: lseek(file,(long)((long)(usernumber-1)*U_LEN)+start,SEEK_SET);
1066:
1067: i=0;
1068: while(i<LOOP_NODEDAB
1069: && lock(file,(long)((long)(usernumber-1)*U_LEN)+start,length)==-1) {
1070: if(i>10)
1071: mswait(55);
1072: i++; }
1073:
1074: if(i>=LOOP_NODEDAB) {
1075: close(file);
1076: return(-3);
1077: }
1078:
1079: if(read(file,str,length)!=length) {
1080: unlock(file,(long)((long)(usernumber-1)*U_LEN)+start,length);
1081: close(file);
1082: return(-4);
1083: }
1084:
1085: unlock(file,(long)((long)(usernumber-1)*U_LEN)+start,length);
1086: close(file);
1087: for(c=0;c<length;c++)
1088: if(str[c]==ETX || str[c]==CR) break;
1089: str[c]=0;
1090:
1091: return(0);
1092: }
1093:
1094: /****************************************************************************/
1095: /* Places into user.dat at the offset for usernumber+start for length bytes */
1096: /* Called from various locations */
1097: /****************************************************************************/
1098: int DLLCALL putuserrec(scfg_t* cfg, int usernumber,int start, uint length, char *str)
1099: {
1100: char str2[256];
1101: int file;
1102: uint c,i;
1103: node_t node;
1104:
1105: if(usernumber<1)
1106: return(-1);
1107:
1108: sprintf(str2,"%suser/user.dat",cfg->data_dir);
1109: if((file=nopen(str2,O_WRONLY|O_DENYNONE))==-1)
1110: return(errno);
1111:
1112: strcpy(str2,str);
1113: if(strlen(str2)<length) {
1114: for(c=strlen(str2);c<length;c++)
1115: str2[c]=ETX;
1116: str2[c]=0;
1117: }
1118: lseek(file,(long)((long)((long)((long)usernumber-1)*U_LEN)+start),SEEK_SET);
1119:
1120: i=0;
1121: while(i<LOOP_NODEDAB
1122: && lock(file,(long)((long)(usernumber-1)*U_LEN)+start,length)==-1) {
1123: if(i>10)
1124: mswait(55);
1125: i++; }
1126:
1127: if(i>=LOOP_NODEDAB)
1128: return(-3);
1129:
1130: write(file,str2,length);
1131: unlock(file,(long)((long)(usernumber-1)*U_LEN)+start,length);
1132: close(file);
1133: for(i=1;i<=cfg->sys_nodes;i++) { /* instant user data update */
1134: if(i==cfg->node_num)
1135: continue;
1136: getnodedat(cfg, i,&node,0);
1137: if(node.useron==usernumber && (node.status==NODE_INUSE
1138: || node.status==NODE_QUIET)) {
1139: getnodedat(cfg, i,&node,1);
1140: node.misc|=NODE_UDAT;
1141: putnodedat(cfg, i,&node);
1142: break;
1143: }
1144: }
1145:
1146: return(0);
1147: }
1148:
1149: /****************************************************************************/
1150: /* Updates user 'usernumber's record (numeric string) by adding 'adj' to it */
1151: /* returns the new value. */
1152: /****************************************************************************/
1153: ulong DLLCALL adjustuserrec(scfg_t* cfg, int usernumber, int start, int length, long adj)
1154: {
1155: char str[256],c,path[256];
1156: char tmp[32];
1157: int i,file;
1158: long val;
1159: node_t node;
1160:
1161: if(usernumber<1)
1162: return(0UL);
1163:
1164: sprintf(path,"%suser/user.dat",cfg->data_dir);
1165: if((file=nopen(path,O_RDWR|O_DENYNONE))==-1)
1166: return(0UL);
1167:
1168: lseek(file,(long)((long)(usernumber-1)*U_LEN)+start,SEEK_SET);
1169:
1170: i=0;
1171: while(i<LOOP_NODEDAB
1172: && lock(file,(long)((long)(usernumber-1)*U_LEN)+start,length)==-1) {
1173: if(i>10)
1174: mswait(55);
1175: i++; }
1176:
1177: if(i>=LOOP_NODEDAB) {
1178: close(file);
1179: return(0);
1180: }
1181:
1182: if(read(file,str,length)!=length) {
1183: unlock(file,(long)((long)(usernumber-1)*U_LEN)+start,length);
1184: close(file);
1185: return(0UL);
1186: }
1187: for(c=0;c<length;c++)
1188: if(str[c]==ETX || str[c]==CR) break;
1189: str[c]=0;
1190: val=atol(str);
1191: if(adj<0L && val<-adj) /* don't go negative */
1192: val=0UL;
1193: else val+=adj;
1194: lseek(file,(long)((long)(usernumber-1)*U_LEN)+start,SEEK_SET);
1195: putrec(str,0,length,ultoa(val,tmp,10));
1196: if(write(file,str,length)!=length) {
1197: unlock(file,(long)((long)(usernumber-1)*U_LEN)+start,length);
1198: close(file);
1199: return(val);
1200: }
1201: unlock(file,(long)((long)(usernumber-1)*U_LEN)+start,length);
1202: close(file);
1203: for(i=1;i<=cfg->sys_nodes;i++) { /* instant user data update */
1204: if(i==cfg->node_num)
1205: continue;
1206: getnodedat(cfg, i,&node,0);
1207: if(node.useron==usernumber && (node.status==NODE_INUSE
1208: || node.status==NODE_QUIET)) {
1209: getnodedat(cfg, i,&node,1);
1210: node.misc|=NODE_UDAT;
1211: putnodedat(cfg, i,&node);
1212: break;
1213: }
1214: }
1215: return(val);
1216: }
1217:
1218: /****************************************************************************/
1219: /* Subtract credits from the current user online, accounting for the new */
1220: /* "free credits" field. */
1221: /****************************************************************************/
1222: void DLLCALL subtract_cdt(scfg_t* cfg, user_t* user, long amt)
1223: {
1224: char tmp[64];
1225: long mod;
1226:
1227: if(!amt)
1228: return;
1229: if(user->freecdt) {
1230: if((ulong)amt>user->freecdt) { /* subtract both credits and */
1231: mod=amt-user->freecdt; /* free credits */
1232: putuserrec(cfg, user->number,U_FREECDT,10,"0");
1233: user->freecdt=0;
1234: user->cdt=adjustuserrec(cfg, user->number,U_CDT,10,-mod); }
1235: else { /* subtract just free credits */
1236: user->freecdt-=amt;
1237: putuserrec(cfg, user->number,U_FREECDT,10
1238: ,ultoa(user->freecdt,tmp,10)); } }
1239: else /* no free credits */
1240: user->cdt=adjustuserrec(cfg, user->number,U_CDT,10,-amt);
1241: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.