![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to allusers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to allusers.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* ALLUSERS.C */
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: /****************************************************************************/
6: /* Makes global changes to Synchronet user database (USER.DAT) */
7: /* Compatible with Version 2.1 of Synchronet BBS Software */
8: /****************************************************************************/
9:
10: #include <stdio.h>
11: #include <fcntl.h>
12: #include <errno.h>
13: #include <stdlib.h>
14: #include <sys/stat.h>
15:
16: #include "dirwrap.h"
17:
18: #include "sbbsdefs.h"
19:
20: int min=0,max=99;
21: long reqflags[4]={0},reqrest=0,reqexempt=0;
22:
23: char *usage=
24: "\nusage: allusers [data\\user path] [[-require] [...]] "
25: "/modify [[/modify] [...]]\n"
26: "\nwhere require is one of:\n"
27: " L# set minimum level to # (default=0)\n"
28: " M# set maximum level to # (default=99)\n"
29: " F#<flags> set required flags from flag set #\n"
30: " E<flags> set required exemptions\n"
31: " R<flags> set required restrictions\n"
32: "\nwhere modify is one of:\n"
33: " L# change security level to #\n"
34: " F#[+|-]<flags> add or remove flags from flag set #\n"
35: " E[+|-]<flags> add or remove exemption flags\n"
36: " R[+|-]<flags> add or remove restriction flags\n"
37: "\nExamples:\n"
38: " ALLUSERS -L30 /FA add 'A' to flag set #1 for all level 30+ users\n"
39: " ALLUSERS /F3-G remove 'G' from flag set #3 for all users\n"
40: " ALLUSERS -F2B /E-P remove 'P' exemption for all users with FLAG '2B'\n"
41: " ALLUSERS /R+W add 'W' restriction for all users\n"
42: ;
43:
44: /****************************************************************************/
45: /* Attempts to lock a user record, retries for up to 10 seconds */
46: /* Returns 0 on success, -1 on failure */
47: /****************************************************************************/
48: int lockuser(FILE *stream, ulong offset)
49: {
50: time_t start;
51:
52: if(lock(fileno(stream),offset,U_LEN)==0)
53: return(0);
54: start=time(NULL);
55: while(1) {
56: if(lock(fileno(stream),offset,U_LEN)==0)
57: return(0);
58: if(time(NULL)-start>=10L)
59: break; }
60: return(-1);
61: }
62:
63: /****************************************************************************/
64: /* Returns bytes offset into user record for flag set # 'set' */
65: /****************************************************************************/
66: long getflagoff(int set)
67: {
68: switch(set) {
69: default:
70: return(U_FLAGS1);
71: case 2:
72: return(U_FLAGS2);
73: case 3:
74: return(U_FLAGS3);
75: case 4:
76: return(U_FLAGS4); }
77: }
78:
79: /****************************************************************************/
80: /* Checks a user record against the requirements set on the command line */
81: /* Returns 1 if the user meets the requirements (or no requirements were */
82: /* specified) or 0 if the user does not meet any of the requirements. */
83: /****************************************************************************/
84: int chkuser(FILE *stream, long offset)
85: {
86: char str[128];
87: int i;
88:
89: if(min || max!=99) { /* Check security level */
90: fseek(stream,offset+U_LEVEL,SEEK_SET);
91: if(!fread(str,2,1,stream))
92: return(0);
93: str[2]=0;
94: i=atoi(str);
95: if(i<min || i>max) /* not within range */
96: return(0); } /* so skip this user */
97:
98: for(i=0;i<4;i++)
99: if(reqflags[i]) {
100: fseek(stream,offset+getflagoff(i+1),SEEK_SET);
101: if(!fread(str,8,1,stream))
102: return(0);
103: str[8]=0;
104: truncsp(str);
105: if((ahtoul(str)&reqflags[i])!=reqflags[i])
106: return(0); } /* doesn't have 'em all */
107:
108: if(reqrest) {
109: fseek(stream,offset+U_REST,SEEK_SET);
110: if(!fread(str,8,1,stream))
111: return(0);
112: str[8]=0;
113: truncsp(str);
114: if((ahtoul(str)&reqrest)!=reqrest)
115: return(0); }
116:
117: if(reqexempt) {
118: fseek(stream,offset+U_REST,SEEK_SET);
119: if(!fread(str,8,1,stream))
120: return(0);
121: str[8]=0;
122: truncsp(str);
123: if((ahtoul(str)&reqexempt)!=reqexempt)
124: return(0); }
125:
126: return(1);
127: }
128:
129: int main(int argc, char **argv)
130: {
131: char dir[128],str[128];
132: int i,j,k,file,set,sub,mod;
133: long l,f,flags,flagoff,length,offset;
134: FILE *stream;
135:
136: printf("\nALLUSERS v2.10 - Bulk User Editor for Synchronet User Database\n");
137:
138: if(argc<2) {
139: printf(usage);
140: exit(1); }
141: dir[0]=0;
142: for(i=1;i<argc;i++) {
143: flags=flagoff=sub=mod=0;
144: if(argv[i][0]=='-')
145: switch(toupper(argv[i][1])) {
146: case 'L': /* Set minimum sec level */
147: min=atoi(argv[i]+2);
148: break;
149: case 'M': /* Set maximum sec level */
150: max=atoi(argv[i]+2);
151: break;
152: case 'F': /* Set required flags */
153: j=3;
154: set=1;
155: if(isdigit(argv[i][2]))
156: set=argv[i][2]&0xf;
157: else
158: j=2;
159: for(;argv[i][j];j++)
160: if(isalpha(argv[i][j]))
161: reqflags[set-1]|=FLAG(toupper(argv[i][j]));
162: break;
163: case 'R': /* Set required restrictions */
164: for(j=2;argv[i][j];j++)
165: if(isalpha(argv[i][j]))
166: reqrest|=FLAG(toupper(argv[i][j]));
167: break;
168: case 'E': /* Set required exemptions */
169: for(j=2;argv[i][j];j++)
170: if(isalpha(argv[i][j]))
171: reqexempt|=FLAG(toupper(argv[i][j]));
172: break;
173: default: /* Unrecognized include */
174: printf(usage);
175: exit(1); }
176:
177: else if(argv[i][0]=='/')
178: switch(toupper(argv[i][1])) {
179: case 'F': /* flags */
180: j=3;
181: set=1;
182: if(isdigit(argv[i][2]))
183: set=argv[i][2]&0xf;
184: else
185: j=2;
186: if(argv[i][j]=='+')
187: j++;
188: else if(argv[i][j]=='-') {
189: j++;
190: sub=1; }
191: for(;argv[i][j];j++)
192: if(isalpha(argv[i][j]))
193: flags|=FLAG(toupper(argv[i][j]));
194: sprintf(str,"%suser.dat",dir);
195: if(!fexistcase(str) || (file=sopen(str,O_RDWR|O_BINARY,SH_DENYNO))==-1) {
196: printf("Error opening %s\n",str);
197: exit(1); }
198: if((stream=fdopen(file,"w+b"))==NULL) {
199: printf("Error opening %s\n",str);
200: exit(1); }
201: setvbuf(stream,NULL,_IOFBF,2048);
202: length=filelength(file);
203: printf("\n%s Flags %s Set #%d\n",sub ? "Removing":"Adding"
204: ,sub ? "from":"to",set);
205: for(offset=0;offset<length;offset+=U_LEN) {
206: printf("%lu of %lu (%u modified)\r"
207: ,(offset/U_LEN)+1,length/U_LEN,mod);
208: if(lockuser(stream,offset)) {
209: printf("Error locking offset %lu\n",offset);
210: continue; }
211: if(!chkuser(stream,offset)) {
212: unlock(fileno(stream),offset,U_LEN);
213: continue; }
214: flagoff=getflagoff(set);
215: fseek(stream,offset+flagoff,SEEK_SET);
216: fread(str,8,1,stream);
217: str[8]=0;
218: truncsp(str);
219: l=f=ahtoul(str);
220: if(sub)
221: l&=~flags;
222: else
223: l|=flags;
224: if(l==f) { /* no change */
225: unlock(fileno(stream),offset,U_LEN);
226: continue; }
227: mod++;
228: sprintf(str,"%lx",l);
229: while(strlen(str)<8)
230: strcat(str,"\3");
231: fseek(stream,offset+flagoff,SEEK_SET);
232: fwrite(str,8,1,stream);
233: unlock(fileno(stream),offset,U_LEN); }
234: fclose(stream);
235: printf("\n");
236: break;
237: case 'E': /* Exemptions */
238: flagoff=U_EXEMPT;
239: case 'R': /* Restrictions */
240: if(!flagoff)
241: flagoff=U_REST;
242: j=2;
243: if(argv[i][j]=='+')
244: j++;
245: else if(argv[i][j]=='-') {
246: j++;
247: sub=1; }
248: for(;argv[i][j];j++)
249: if(isalpha(argv[i][j]))
250: flags|=FLAG(toupper(argv[i][j]));
251: sprintf(str,"%suser.dat",dir);
252: if(!fexistcase(str) || (file=sopen(str,O_RDWR|O_BINARY,SH_DENYNO))==-1) {
253: printf("Error opening %s\n",str);
254: exit(1); }
255: if((stream=fdopen(file,"w+b"))==NULL) {
256: printf("Error opening %s\n",str);
257: exit(1); }
258: setvbuf(stream,NULL,_IOFBF,2048);
259: length=filelength(file);
260: printf("\n%s %s\n"
261: ,sub ? "Removing":"Adding"
262: ,flagoff==U_REST ? "Restrictions":"Exemptions");
263: for(offset=0;offset<length;offset+=U_LEN) {
264: printf("%lu of %lu (%u modified)\r"
265: ,(offset/U_LEN)+1,length/U_LEN,mod);
266: if(lockuser(stream,offset)) {
267: printf("Error locking offset %lu\n",offset);
268: continue; }
269: if(!chkuser(stream,offset)) {
270: unlock(fileno(stream),offset,U_LEN);
271: continue; }
272: fseek(stream,offset+flagoff,SEEK_SET);
273: fread(str,8,1,stream);
274: str[8]=0;
275: truncsp(str);
276: l=f=ahtoul(str);
277: if(sub)
278: l&=~flags;
279: else
280: l|=flags;
281: if(l==f) { /* no change */
282: unlock(fileno(stream),offset,U_LEN);
283: continue; }
284: mod++;
285: sprintf(str,"%lx",l);
286: while(strlen(str)<8)
287: strcat(str,"\3");
288: fseek(stream,offset+flagoff,SEEK_SET);
289: fwrite(str,8,1,stream);
290: unlock(fileno(stream),offset,U_LEN); }
291: fclose(stream);
292: printf("\n");
293: break;
294: case 'L': /* Level */
295: j=atoi(argv[i]+2);
296: if(j>99)
297: j=99;
298: if(j<0)
299: j=0;
300: sprintf(str,"%suser.dat",dir);
301: if(!fexistcase(str) || (file=sopen(str,O_RDWR|O_BINARY,SH_DENYNO))==-1) {
302: printf("Error opening %s\n",str);
303: exit(1); }
304: if((stream=fdopen(file,"w+b"))==NULL) {
305: printf("Error opening %s\n",str);
306: exit(1); }
307: setvbuf(stream,NULL,_IOFBF,2048);
308: length=filelength(file);
309: printf("\nChanging Levels\n");
310: for(offset=0;offset<length;offset+=U_LEN) {
311: printf("%lu of %lu (%u modified)\r"
312: ,(offset/U_LEN)+1,length/U_LEN,mod);
313: if(lockuser(stream,offset)) {
314: printf("Error locking offset %lu\n",offset);
315: continue; }
316: if(!chkuser(stream,offset)) {
317: unlock(fileno(stream),offset,U_LEN);
318: continue; }
319: fseek(stream,offset+U_LEVEL,SEEK_SET);
320: fread(str,2,1,stream);
321: str[2]=0;
322: truncsp(str);
323: if(atoi(str)==j) { /* no change */
324: unlock(fileno(stream),offset,U_LEN);
325: continue; }
326: sprintf(str,"%02u",j);
327: fseek(stream,offset+U_LEVEL,SEEK_SET);
328: fwrite(str,2,1,stream);
329: unlock(fileno(stream),offset,U_LEN);
330: mod++; }
331: fclose(stream);
332: printf("\n");
333: break;
334: default:
335: printf(usage);
336: exit(1); }
337: else {
338: strcpy(dir,argv[i]);
339: backslash(dir); } }
340: return(0);
341: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.