![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to data_ovl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to data_ovl.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "DATA_OVL.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: /****************************************************************************/
8: /* Writes into user.number's slot in USER.DAT data in structure 'user' */
9: /* Called from functions newuser, useredit and main */
10: /****************************************************************************/
11: void putuserdat(user_t user)
12: {
13: int i,file;
14: char userdat[U_LEN+1],str[U_LEN+1];
15: node_t node;
16:
17: if(!user.number) {
18: errormsg(WHERE,ERR_CHK,"user number",0);
19: return; }
20: memset(userdat,ETX,U_LEN);
21: putrec(userdat,U_ALIAS,LEN_ALIAS+5,user.alias);
22: putrec(userdat,U_NAME,LEN_NAME,user.name);
23: putrec(userdat,U_HANDLE,LEN_HANDLE,user.handle);
24: putrec(userdat,U_HANDLE+LEN_HANDLE,2,crlf);
25:
26: putrec(userdat,U_NOTE,LEN_NOTE,user.note);
27: putrec(userdat,U_COMP,LEN_COMP,user.comp);
28: putrec(userdat,U_COMP+LEN_COMP,2,crlf);
29:
30: putrec(userdat,U_COMMENT,LEN_COMMENT,user.comment);
31: putrec(userdat,U_COMMENT+LEN_COMMENT,2,crlf);
32:
33: putrec(userdat,U_NETMAIL,LEN_NETMAIL,user.netmail);
34: putrec(userdat,U_NETMAIL+LEN_NETMAIL,2,crlf);
35:
36: putrec(userdat,U_ADDRESS,LEN_ADDRESS,user.address);
37: putrec(userdat,U_LOCATION,LEN_LOCATION,user.location);
38: putrec(userdat,U_ZIPCODE,LEN_ZIPCODE,user.zipcode);
39: putrec(userdat,U_ZIPCODE+LEN_ZIPCODE,2,crlf);
40:
41: putrec(userdat,U_PASS,LEN_PASS,user.pass);
42: putrec(userdat,U_PHONE,LEN_PHONE,user.phone);
43: putrec(userdat,U_BIRTH,LEN_BIRTH,user.birth);
44: putrec(userdat,U_MODEM,LEN_MODEM,user.modem);
45: putrec(userdat,U_LASTON,8,ultoa(user.laston,str,16));
46: putrec(userdat,U_FIRSTON,8,ultoa(user.firston,str,16));
47: putrec(userdat,U_EXPIRE,8,ultoa(user.expire,str,16));
48: putrec(userdat,U_PWMOD,8,ultoa(user.pwmod,str,16));
49: putrec(userdat,U_PWMOD+8,2,crlf);
50:
51: putrec(userdat,U_LOGONS,5,itoa(user.logons,str,10));
52: putrec(userdat,U_LTODAY,5,itoa(user.ltoday,str,10));
53: putrec(userdat,U_TIMEON,5,itoa(user.timeon,str,10));
54: putrec(userdat,U_TEXTRA,5,itoa(user.textra,str,10));
55: putrec(userdat,U_TTODAY,5,itoa(user.ttoday,str,10));
56: putrec(userdat,U_TLAST,5,itoa(user.tlast,str,10));
57: putrec(userdat,U_POSTS,5,itoa(user.posts,str,10));
58: putrec(userdat,U_EMAILS,5,itoa(user.emails,str,10));
59: putrec(userdat,U_FBACKS,5,itoa(user.fbacks,str,10));
60: putrec(userdat,U_ETODAY,5,itoa(user.etoday,str,10));
61: putrec(userdat,U_PTODAY,5,itoa(user.ptoday,str,10));
62: putrec(userdat,U_PTODAY+5,2,crlf);
63:
64: putrec(userdat,U_ULB,10,ultoa(user.ulb,str,10));
65: putrec(userdat,U_ULS,5,itoa(user.uls,str,10));
66: putrec(userdat,U_DLB,10,ultoa(user.dlb,str,10));
67: putrec(userdat,U_DLS,5,itoa(user.dls,str,10));
68: putrec(userdat,U_CDT,10,ultoa(user.cdt,str,10));
69: putrec(userdat,U_MIN,10,ultoa(user.min,str,10));
70: putrec(userdat,U_MIN+10,2,crlf);
71:
72: putrec(userdat,U_LEVEL,2,itoa(user.level,str,10));
73: putrec(userdat,U_FLAGS1,8,ultoa(user.flags1,str,16));
74: putrec(userdat,U_TL,2,nulstr); /* unused */
75: putrec(userdat,U_FLAGS2,8,ultoa(user.flags2,str,16));
76: putrec(userdat,U_EXEMPT,8,ultoa(user.exempt,str,16));
77: putrec(userdat,U_REST,8,ultoa(user.rest,str,16));
78: putrec(userdat,U_REST+8,2,crlf);
79:
80: putrec(userdat,U_ROWS,2,itoa(user.rows,str,10));
81: userdat[U_SEX]=user.sex;
82: userdat[U_PROT]=user.prot;
83: putrec(userdat,U_MISC,8,ultoa(user.misc,str,16));
84: putrec(userdat,U_LEECH,2,itoa(user.leech,str,16));
85:
86: putrec(userdat,U_CURSUB,8,user.cursub);
87: putrec(userdat,U_CURDIR,8,user.curdir);
88:
89: // putrec(userdat,U_CMDSET,2,itoa(user.cmdset,str,16)); /* Unused */
90: putrec(userdat,U_CMDSET+2,2,crlf);
91:
92: putrec(userdat,U_XFER_CMD+LEN_XFER_CMD,2,crlf);
93:
94: putrec(userdat,U_MAIL_CMD+LEN_MAIL_CMD,2,crlf);
95:
96: putrec(userdat,U_FREECDT,10,ultoa(user.freecdt,str,10));
97:
98: putrec(userdat,U_FLAGS3,8,ultoa(user.flags3,str,16));
99: putrec(userdat,U_FLAGS4,8,ultoa(user.flags4,str,16));
100:
101: if(user.xedit)
102: putrec(userdat,U_XEDIT,8,xedit[user.xedit-1]->code);
103: else
104: putrec(userdat,U_XEDIT,8,nulstr);
105:
106: putrec(userdat,U_SHELL,8,shell[user.shell]->code);
107:
108: putrec(userdat,U_QWK,8,ultoa(user.qwk,str,16));
109: putrec(userdat,U_TMPEXT,3,user.tmpext);
110: putrec(userdat,U_CHAT,8,ultoa(user.chat,str,16));
111: putrec(userdat,U_NS_TIME,8,ultoa(user.ns_time,str,16));
112:
113: putrec(userdat,U_UNUSED,29,crlf);
114: putrec(userdat,U_UNUSED+29,2,crlf);
115:
116: sprintf(str,"%sUSER\\USER.DAT",data_dir);
117: if((file=nopen(str,O_WRONLY|O_CREAT|O_DENYNONE))==-1) {
118: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_DENYNONE);
119: return; }
120:
121: /*** This shouldn't be necessary
122: if(filelength(file)<(long)((long)user.number*U_LEN))
123: lseek(file,0L,SEEK_END);
124: else
125: ***/
126:
127: lseek(file,(long)((long)((long)user.number-1)*U_LEN),SEEK_SET);
128:
129: i=0;
130: while(i<LOOP_NODEDAB
131: && lock(file,(long)((long)(user.number-1)*U_LEN),U_LEN)==-1) {
132: if(i>10)
133: mswait(55);
134: i++; }
135:
136: if(i>=LOOP_NODEDAB) {
137: close(file);
138: errormsg(WHERE,ERR_LOCK,"USER.DAT",user.number);
139: return; }
140:
141: if(write(file,userdat,U_LEN)!=U_LEN) {
142: unlock(file,(long)((long)(user.number-1)*U_LEN),U_LEN);
143: close(file);
144: errormsg(WHERE,ERR_WRITE,str,U_LEN);
145: return; }
146: unlock(file,(long)((long)(user.number-1)*U_LEN),U_LEN);
147: close(file);
148: for(i=1;i<=sys_nodes;i++) { /* instant user data update */
149: if(i==node_num)
150: continue;
151: getnodedat(i,&node,0);
152: if(node.useron==user.number && (node.status==NODE_INUSE
153: || node.status==NODE_QUIET)) {
154: getnodedat(i,&node,1);
155: node.misc|=NODE_UDAT;
156: putnodedat(i,node);
157: break; } }
158: }
159:
160:
161: /****************************************************************************/
162: /* Puts 'name' into slot 'number' in USER\\NAME.DAT */
163: /****************************************************************************/
164: void putusername(int number, char *name)
165: {
166: char str[256];
167: int file;
168: long length,l;
169:
170: sprintf(str,"%sUSER\\NAME.DAT",data_dir);
171: if((file=nopen(str,O_RDWR|O_CREAT))==-1) {
172: errormsg(WHERE,ERR_OPEN,str,O_RDWR|O_CREAT);
173: return; }
174: length=filelength(file);
175: if(length && length%(LEN_ALIAS+2)) {
176: close(file);
177: errormsg(WHERE,ERR_LEN,str,length);
178: return; }
179: if(length<(((long)number-1)*(LEN_ALIAS+2))) {
180: sprintf(str,"%*s",LEN_ALIAS,nulstr);
181: strset(str,ETX);
182: strcat(str,crlf);
183: lseek(file,0L,SEEK_END);
184: while(filelength(file)<((long)number*(LEN_ALIAS+2)))
185: write(file,str,(LEN_ALIAS+2)); }
186: lseek(file,(long)(((long)number-1)*(LEN_ALIAS+2)),SEEK_SET);
187: putrec(str,0,LEN_ALIAS,name);
188: putrec(str,LEN_ALIAS,2,crlf);
189: write(file,str,LEN_ALIAS+2);
190: close(file);
191: }
192:
193: /****************************************************************************/
194: /* Fills the 'ptr' element of the each element of the sub[] array of sub_t */
195: /* and the sub_misc and sub_ptr global variables */
196: /* Called from function main */
197: /****************************************************************************/
198: void getmsgptrs()
199: {
200: char str[256];
201: ushort ch;
202: uint i;
203: int file;
204: long length;
205: FILE *stream;
206:
207: now=time(NULL);
208: if(!useron.number)
209: return;
210: bputs(text[LoadingMsgPtrs]);
211: sprintf(str,"%sUSER\\PTRS\\%4.4u.IXB",data_dir,useron.number);
212: if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
213: for(i=0;i<total_subs;i++) {
214: sub_ptr[i]=sub[i]->ptr=sub_last[i]=sub[i]->last=0;
215: if(sub[i]->misc&SUB_NSDEF)
216: sub[i]->misc|=SUB_NSCAN;
217: else
218: sub[i]->misc&=~SUB_NSCAN;
219: if(sub[i]->misc&SUB_SSDEF)
220: sub[i]->misc|=SUB_SSCAN;
221: else
222: sub[i]->misc&=~SUB_SSCAN;
223: sub_misc[i]=sub[i]->misc; }
224: bputs(text[LoadedMsgPtrs]);
225: return; }
226: length=filelength(file);
227: for(i=0;i<total_subs;i++) {
228: if(length<(sub[i]->ptridx+1)*10L) {
229: sub[i]->ptr=sub[i]->last=0L;
230: if(sub[i]->misc&SUB_NSDEF)
231: sub[i]->misc|=SUB_NSCAN;
232: else
233: sub[i]->misc&=~SUB_NSCAN;
234: if(sub[i]->misc&SUB_SSDEF)
235: sub[i]->misc|=SUB_SSCAN;
236: else
237: sub[i]->misc&=~SUB_SSCAN; }
238: else {
239: fseek(stream,(long)sub[i]->ptridx*10L,SEEK_SET);
240: fread(&sub[i]->ptr,4,1,stream);
241: fread(&sub[i]->last,4,1,stream);
242: fread(&ch,2,1,stream);
243: if(ch&5) /* Either bit 0 or 2 */
244: sub[i]->misc|=SUB_NSCAN;
245: else
246: sub[i]->misc&=~SUB_NSCAN;
247: if(ch&2)
248: sub[i]->misc|=SUB_SSCAN;
249: else
250: sub[i]->misc&=~SUB_SSCAN;
251: if(ch&0x100)
252: sub[i]->misc|=SUB_YSCAN;
253: else
254: sub[i]->misc&=~SUB_YSCAN; }
255: sub_ptr[i]=sub[i]->ptr;
256: sub_last[i]=sub[i]->last;
257: sub_misc[i]=sub[i]->misc; }
258: fclose(stream);
259: bputs(text[LoadedMsgPtrs]);
260: }
261:
262: /****************************************************************************/
263: /* Writes to DATA\USER\PTRS\xxxx.DAB the msgptr array for the current user */
264: /* Called from functions main and newuser */
265: /****************************************************************************/
266: void putmsgptrs()
267: {
268: char str[256];
269: ushort idx,ch;
270: uint i,j;
271: int file;
272: ulong l=0L,length;
273:
274: if(!useron.number)
275: return;
276: sprintf(str,"%sUSER\\PTRS\\%4.4u.IXB",data_dir,useron.number);
277: if((file=nopen(str,O_WRONLY|O_CREAT))==-1) {
278: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT);
279: return; }
280: length=filelength(file);
281: for(i=0;i<total_subs;i++) {
282: if(sub[i]->ptr==sub_ptr[i] && sub[i]->last==sub_last[i]
283: && length>=((long)(sub[i]->ptridx+1)*10)
284: && ((sub[i]->misc&(SUB_NSCAN|SUB_SSCAN|SUB_YSCAN))
285: ==(sub_misc[i]&(SUB_NSCAN|SUB_SSCAN|SUB_YSCAN))))
286: continue;
287: while(filelength(file)<(long)(sub[i]->ptridx)*10) {
288: lseek(file,0L,SEEK_END);
289: idx=tell(file)/10;
290: for(j=0;j<total_subs;j++)
291: if(sub[j]->ptridx==idx)
292: break;
293: write(file,&l,4);
294: write(file,&l,4);
295: ch=0xff; /* default to scan ON for new sub */
296: if(j<total_subs) {
297: if(!(sub[j]->misc&SUB_NSCAN))
298: ch&=~5;
299: if(!(sub[j]->misc&SUB_SSCAN))
300: ch&=~2;
301: if(sub[j]->misc&SUB_YSCAN)
302: ch|=0x100; }
303: write(file,&ch,2); }
304: lseek(file,(long)((long)(sub[i]->ptridx)*10),SEEK_SET);
305: write(file,&(sub[i]->ptr),4);
306: write(file,&(sub[i]->last),4);
307: ch=0xff;
308: if(!(sub[i]->misc&SUB_NSCAN))
309: ch&=~5;
310: if(!(sub[i]->misc&SUB_SSCAN))
311: ch&=~2;
312: if(sub[i]->misc&SUB_YSCAN)
313: ch|=0x100;
314: write(file,&ch,2); }
315: close(file);
316: if(!flength(str)) /* Don't leave 0 byte files */
317: remove(str);
318: }
319:
320: /****************************************************************************/
321: /* Checks for a duplicate user filed starting at user record offset */
322: /* 'offset', reading in 'datlen' chars, comparing to 'str' for each user */
323: /* except 'usernumber' if it is non-zero. Comparison is NOT case sensitive. */
324: /* del is 1 if the search is to included deleted/inactive users 0 otherwise */
325: /* Returns the usernumber of the dupe if found, 0 if not */
326: /****************************************************************************/
327: uint userdatdupe(uint usernumber, uint offset, uint datlen, char *dat
328: , char del)
329: {
330: char str[256];
331: int i,file;
332: long l,length;
333:
334: truncsp(dat);
335: sprintf(str,"%sUSER\\USER.DAT",data_dir);
336: if((file=nopen(str,O_RDONLY|O_DENYNONE))==-1)
337: return(0);
338: length=filelength(file);
339: bputs(text[SearchingForDupes]);
340: for(l=0;l<length && online;l+=U_LEN) {
341: checkline();
342: if(usernumber && l/U_LEN==usernumber-1)
343: continue;
344: lseek(file,l+offset,SEEK_SET);
345: i=0;
346: while(i<LOOP_NODEDAB && lock(file,l,U_LEN)==-1) {
347: if(i>10)
348: mswait(55);
349: i++; }
350:
351: if(i>=LOOP_NODEDAB) {
352: close(file);
353: errormsg(WHERE,ERR_LOCK,"USER.DAT",l);
354: return(0); }
355:
356: read(file,str,datlen);
357: for(i=0;i<datlen;i++)
358: if(str[i]==ETX) break;
359: str[i]=0;
360: truncsp(str);
361: if(!stricmp(str,dat)) {
362: if(!del) { /* Don't include deleted users in search */
363: lseek(file,l+U_MISC,SEEK_SET);
364: read(file,str,8);
365: getrec(str,0,8,str);
366: if(ahtoul(str)&(DELETED|INACTIVE)) {
367: unlock(file,l,U_LEN);
368: continue; } }
369: unlock(file,l,U_LEN);
370: close(file);
371: bputs(text[SearchedForDupes]);
372: return((l/U_LEN)+1); }
373: else
374: unlock(file,l,U_LEN); }
375: close(file);
376: bputs(text[SearchedForDupes]);
377: return(0);
378: }
379:
380:
381: /****************************************************************************/
382: /* Removes any files in the user transfer index (XFER.IXT) that match the */
383: /* specifications of dest, or source user, or filename or any combination. */
384: /****************************************************************************/
385: void rmuserxfers(int fromuser, int destuser, char *fname)
386: {
387: char str[256],*ixtbuf;
388: int file;
389: long l,length;
390:
391: sprintf(str,"%sXFER.IXT",data_dir);
392: if(!fexist(str))
393: return;
394: if(!flength(str)) {
395: remove(str);
396: return; }
397: if((file=nopen(str,O_RDONLY))==-1) {
398: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
399: return; }
400: length=filelength(file);
401: if((ixtbuf=(char *)MALLOC(length))==NULL) {
402: close(file);
403: errormsg(WHERE,ERR_ALLOC,str,length);
404: return; }
405: if(read(file,ixtbuf,length)!=length) {
406: close(file);
407: FREE(ixtbuf);
408: errormsg(WHERE,ERR_READ,str,length);
409: return; }
410: close(file);
411: if((file=nopen(str,O_WRONLY|O_TRUNC))==-1) {
412: FREE(ixtbuf);
413: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_TRUNC);
414: return; }
415: for(l=0;l<length;l+=24) {
416: if(fname!=NULL && fname[0]) { /* fname specified */
417: if(!strncmp(ixtbuf+l+5,fname,12)) { /* this is the file */
418: if(destuser && fromuser) { /* both dest and from user */
419: if(atoi(ixtbuf+l)==destuser && atoi(ixtbuf+l+18)==fromuser)
420: continue; } /* both match */
421: else if(fromuser) { /* from user */
422: if(atoi(ixtbuf+l+18)==fromuser) /* matches */
423: continue; }
424: else if(destuser) { /* dest user */
425: if(atoi(ixtbuf+l)==destuser) /* matches */
426: continue; }
427: else continue; } } /* no users, so match */
428: else if(destuser && fromuser) {
429: if(atoi(ixtbuf+l+18)==fromuser && atoi(ixtbuf+l)==destuser)
430: continue; }
431: else if(destuser && atoi(ixtbuf+l)==destuser)
432: continue;
433: else if(fromuser && atoi(ixtbuf+l+18)==fromuser)
434: continue;
435: write(file,ixtbuf+l,24); }
436: close(file);
437: FREE(ixtbuf);
438: }
439:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.