![[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 / sbbs2 / allusers|
Return to allusers.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / allusers |
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 <io.h>
11: #include <share.h>
12: #include <stdio.h>
13: #include <fcntl.h>
14: #include <errno.h>
15: #include <stdlib.h>
16: #include <sys/stat.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: /* Converts an ASCII Hex string into an ulong */
65: /****************************************************************************/
66: ulong ahtoul(char *str)
67: {
68: ulong l,val=0;
69:
70: while((l=(*str++)|0x20)!=0x20)
71: val=(l&0xf)+(l>>6&1)*9+val*16;
72: return(val);
73: }
74:
75: /****************************************************************************/
76: /* Truncates white-space chars off end of 'str' and terminates at first tab */
77: /****************************************************************************/
78: void truncsp(char *str)
79: {
80: char c;
81:
82: str[strcspn(str,"\t")]=0;
83: c=strlen(str);
84: while(c && (uchar)str[c-1]<=SP) c--;
85: str[c]=0;
86: }
87:
88: /****************************************************************************/
89: /* Returns bytes offset into user record for flag set # 'set' */
90: /****************************************************************************/
91: long getflagoff(int set)
92: {
93: switch(set) {
94: default:
95: return(U_FLAGS1);
96: case 2:
97: return(U_FLAGS2);
98: case 3:
99: return(U_FLAGS3);
100: case 4:
101: return(U_FLAGS4); }
102: }
103:
104: /****************************************************************************/
105: /* Checks a user record against the requirements set on the command line */
106: /* Returns 1 if the user meets the requirements (or no requirements were */
107: /* specified) or 0 if the user does not meet any of the requirements. */
108: /****************************************************************************/
109: int chkuser(FILE *stream, long offset)
110: {
111: char str[128];
112: int i;
113:
114: if(min || max!=99) { /* Check security level */
115: fseek(stream,offset+U_LEVEL,SEEK_SET);
116: if(!fread(str,2,1,stream))
117: return(0);
118: str[2]=0;
119: i=atoi(str);
120: if(i<min || i>max) /* not within range */
121: return(0); } /* so skip this user */
122:
123: for(i=0;i<4;i++)
124: if(reqflags[i]) {
125: fseek(stream,offset+getflagoff(i+1),SEEK_SET);
126: if(!fread(str,8,1,stream))
127: return(0);
128: str[8]=0;
129: truncsp(str);
130: if((ahtoul(str)&reqflags[i])!=reqflags[i])
131: return(0); } /* doesn't have 'em all */
132:
133: if(reqrest) {
134: fseek(stream,offset+U_REST,SEEK_SET);
135: if(!fread(str,8,1,stream))
136: return(0);
137: str[8]=0;
138: truncsp(str);
139: if((ahtoul(str)&reqrest)!=reqrest)
140: return(0); }
141:
142: if(reqexempt) {
143: fseek(stream,offset+U_REST,SEEK_SET);
144: if(!fread(str,8,1,stream))
145: return(0);
146: str[8]=0;
147: truncsp(str);
148: if((ahtoul(str)&reqexempt)!=reqexempt)
149: return(0); }
150:
151: return(1);
152: }
153:
154: int main(int argc, char **argv)
155: {
156: char dir[128],str[128];
157: int i,j,k,file,set,sub,mod;
158: long l,f,flags,flagoff,length,offset;
159: FILE *stream;
160:
161: printf("\nALLUSERS v2.10 - Bulk User Editor for Synchronet User Database\n");
162:
163: if(argc<2) {
164: printf(usage);
165: exit(1); }
166: dir[0]=0;
167: for(i=1;i<argc;i++) {
168: flags=flagoff=sub=mod=0;
169: if(argv[i][0]=='-')
170: switch(toupper(argv[i][1])) {
171: case 'L': /* Set minimum sec level */
172: min=atoi(argv[i]+2);
173: break;
174: case 'M': /* Set maximum sec level */
175: max=atoi(argv[i]+2);
176: break;
177: case 'F': /* Set required flags */
178: j=3;
179: set=1;
180: if(isdigit(argv[i][2]))
181: set=argv[i][2]&0xf;
182: else
183: j=2;
184: for(;argv[i][j];j++)
185: if(isalpha(argv[i][j]))
186: reqflags[set-1]|=FLAG(toupper(argv[i][j]));
187: break;
188: case 'R': /* Set required restrictions */
189: for(j=2;argv[i][j];j++)
190: if(isalpha(argv[i][j]))
191: reqrest|=FLAG(toupper(argv[i][j]));
192: break;
193: case 'E': /* Set required exemptions */
194: for(j=2;argv[i][j];j++)
195: if(isalpha(argv[i][j]))
196: reqexempt|=FLAG(toupper(argv[i][j]));
197: break;
198: default: /* Unrecognized include */
199: printf(usage);
200: exit(1); }
201:
202: else if(argv[i][0]=='/')
203: switch(toupper(argv[i][1])) {
204: case 'F': /* flags */
205: j=3;
206: set=1;
207: if(isdigit(argv[i][2]))
208: set=argv[i][2]&0xf;
209: else
210: j=2;
211: if(argv[i][j]=='+')
212: j++;
213: else if(argv[i][j]=='-') {
214: j++;
215: sub=1; }
216: for(;argv[i][j];j++)
217: if(isalpha(argv[i][j]))
218: flags|=FLAG(toupper(argv[i][j]));
219: sprintf(str,"%sUSER.DAT",dir);
220: if((file=sopen(str,O_RDWR|O_BINARY,SH_DENYNO))==-1) {
221: printf("Error opening %s\n",str);
222: exit(1); }
223: if((stream=fdopen(file,"w+b"))==NULL) {
224: printf("Error opening %s\n",str);
225: exit(1); }
226: setvbuf(stream,NULL,_IOFBF,2048);
227: length=filelength(file);
228: printf("\n%s Flags %s Set #%d\n",sub ? "Removing":"Adding"
229: ,sub ? "from":"to",set);
230: for(offset=0;offset<length;offset+=U_LEN) {
231: printf("%lu of %lu (%u modified)\r"
232: ,(offset/U_LEN)+1,length/U_LEN,mod);
233: if(lockuser(stream,offset)) {
234: printf("Error locking offset %lu\n",offset);
235: continue; }
236: if(!chkuser(stream,offset)) {
237: unlock(fileno(stream),offset,U_LEN);
238: continue; }
239: flagoff=getflagoff(set);
240: fseek(stream,offset+flagoff,SEEK_SET);
241: fread(str,8,1,stream);
242: str[8]=0;
243: truncsp(str);
244: l=f=ahtoul(str);
245: if(sub)
246: l&=~flags;
247: else
248: l|=flags;
249: if(l==f) { /* no change */
250: unlock(fileno(stream),offset,U_LEN);
251: continue; }
252: mod++;
253: sprintf(str,"%lx",l);
254: while(strlen(str)<8)
255: strcat(str,"\3");
256: fseek(stream,offset+flagoff,SEEK_SET);
257: fwrite(str,8,1,stream);
258: unlock(fileno(stream),offset,U_LEN); }
259: fclose(stream);
260: printf("\n");
261: break;
262: case 'E': /* Exemptions */
263: flagoff=U_EXEMPT;
264: case 'R': /* Restrictions */
265: if(!flagoff)
266: flagoff=U_REST;
267: j=2;
268: if(argv[i][j]=='+')
269: j++;
270: else if(argv[i][j]=='-') {
271: j++;
272: sub=1; }
273: for(;argv[i][j];j++)
274: if(isalpha(argv[i][j]))
275: flags|=FLAG(toupper(argv[i][j]));
276: sprintf(str,"%sUSER.DAT",dir);
277: if((file=sopen(str,O_RDWR|O_BINARY,SH_DENYNO))==-1) {
278: printf("Error opening %s\n",str);
279: exit(1); }
280: if((stream=fdopen(file,"w+b"))==NULL) {
281: printf("Error opening %s\n",str);
282: exit(1); }
283: setvbuf(stream,NULL,_IOFBF,2048);
284: length=filelength(file);
285: printf("\n%s %s\n"
286: ,sub ? "Removing":"Adding"
287: ,flagoff==U_REST ? "Restrictions":"Exemptions");
288: for(offset=0;offset<length;offset+=U_LEN) {
289: printf("%lu of %lu (%u modified)\r"
290: ,(offset/U_LEN)+1,length/U_LEN,mod);
291: if(lockuser(stream,offset)) {
292: printf("Error locking offset %lu\n",offset);
293: continue; }
294: if(!chkuser(stream,offset)) {
295: unlock(fileno(stream),offset,U_LEN);
296: continue; }
297: fseek(stream,offset+flagoff,SEEK_SET);
298: fread(str,8,1,stream);
299: str[8]=0;
300: truncsp(str);
301: l=f=ahtoul(str);
302: if(sub)
303: l&=~flags;
304: else
305: l|=flags;
306: if(l==f) { /* no change */
307: unlock(fileno(stream),offset,U_LEN);
308: continue; }
309: mod++;
310: sprintf(str,"%lx",l);
311: while(strlen(str)<8)
312: strcat(str,"\3");
313: fseek(stream,offset+flagoff,SEEK_SET);
314: fwrite(str,8,1,stream);
315: unlock(fileno(stream),offset,U_LEN); }
316: fclose(stream);
317: printf("\n");
318: break;
319: case 'L': /* Level */
320: j=atoi(argv[i]+2);
321: if(j>99)
322: j=99;
323: if(j<0)
324: j=0;
325: sprintf(str,"%sUSER.DAT",dir);
326: if((file=sopen(str,O_RDWR|O_BINARY,SH_DENYNO))==-1) {
327: printf("Error opening %s\n",str);
328: exit(1); }
329: if((stream=fdopen(file,"w+b"))==NULL) {
330: printf("Error opening %s\n",str);
331: exit(1); }
332: setvbuf(stream,NULL,_IOFBF,2048);
333: length=filelength(file);
334: printf("\nChanging Levels\n");
335: for(offset=0;offset<length;offset+=U_LEN) {
336: printf("%lu of %lu (%u modified)\r"
337: ,(offset/U_LEN)+1,length/U_LEN,mod);
338: if(lockuser(stream,offset)) {
339: printf("Error locking offset %lu\n",offset);
340: continue; }
341: if(!chkuser(stream,offset)) {
342: unlock(fileno(stream),offset,U_LEN);
343: continue; }
344: fseek(stream,offset+U_LEVEL,SEEK_SET);
345: fread(str,2,1,stream);
346: str[2]=0;
347: truncsp(str);
348: if(atoi(str)==j) { /* no change */
349: unlock(fileno(stream),offset,U_LEN);
350: continue; }
351: sprintf(str,"%02u",j);
352: fseek(stream,offset+U_LEVEL,SEEK_SET);
353: fwrite(str,2,1,stream);
354: unlock(fileno(stream),offset,U_LEN);
355: mod++; }
356: fclose(stream);
357: printf("\n");
358: break;
359: default:
360: printf(usage);
361: exit(1); }
362: else {
363: strcpy(dir,argv[i]);
364: if(dir[strlen(dir)-1]!='\\' && dir[strlen(dir)-1]!=':')
365: strcat(dir,"\\"); } }
366: return(0);
367: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.