![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xtrn_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 xtrn_ovl.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "XTRN_OVL.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: char *hungupstr="\1n\1h%s\1n hung up on \1h%s\1n %s\r\n";
8:
9: #ifndef __FLAT__
10: extern uint riobp;
11: #endif
12:
13: extern mswtyp;
14: extern uint fakeriobp;
15:
16: /****************************************************************************/
17: /* Convert C string to pascal string */
18: /****************************************************************************/
19: void str2pas(char *instr, char *outstr)
20: {
21: int i;
22:
23: outstr[0]=strlen(instr);
24: for(i=0;i<outstr[0];i++)
25: outstr[i+1]=instr[i];
26: }
27:
28: /****************************************************************************/
29: /* Convert from unix time (seconds since 1/70) to julian (days since 1900) */
30: /****************************************************************************/
31: int unixtojulian(time_t unix)
32: {
33: int days[12]={0,31,59,90,120,151,181,212,243,273,304,334};
34: long j;
35: struct date d;
36: struct time t;
37:
38: unixtodos(unix,&d,&t);
39: j=36525L*d.da_year;
40: if(!(j%100) && d.da_mon<3)
41: j--;
42: j=(j-(1900*36525))/100;
43: j+=d.da_day+days[d.da_mon-1];
44: return(j);
45: }
46:
47: /****************************************************************************/
48: /* Convert julian date into unix format */
49: /****************************************************************************/
50: time_t juliantounix(ulong j)
51: {
52: int days[2][12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
53: 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
54: long temp;
55: int leap,counter;
56:
57: if(!j) return(0L);
58:
59: date.da_year=(100L*j)/36525L;
60: temp=(long)date.da_year*36525L;
61: date.da_year+=1900;
62: j-=temp/100L;
63:
64: if (!(temp%100)) {
65: j++;
66: leap=1; }
67: else leap=0;
68:
69: for(date.da_mon=counter=0;counter<12;counter++)
70: if(days[leap][counter]<j)
71: date.da_mon=counter;
72:
73: date.da_day=j-days[leap][date.da_mon];
74: date.da_mon++; /* go from 0 to 1 based */
75:
76: curtime.ti_hour=curtime.ti_min=curtime.ti_sec=0;
77: return(dostounix(&date,&curtime));
78: }
79:
80: /****************************************************************************/
81: /* Creates various types of xtrn (Doors, Chains, etc.) data files. */
82: /****************************************************************************/
83: void xtrndat(char *name, char *dropdir, uchar type, ulong tleft)
84: {
1.1.1.2 ! root 85: char str[1024],tmp2[128],c,*p;
! 86: int i,file;
! 87: long l;
! 88: ushort w;
! 89: FILE * stream;
! 90: struct time lastcall;
1.1 root 91: stats_t stats;
92:
93: if(type==XTRN_SBBS) { /* SBBS XTRN.DAT file */
94: sprintf(str,"%sXTRN.DAT",dropdir);
95: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
96: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
97: return; }
98:
99: sprintf(str,"%s\r\n%s\r\n%s\r\n%s\r\n"
100: ,name /* User name */
101: ,sys_name /* System name */
102: ,sys_op /* Sysop name */
103: ,sys_guru); /* Guru name */
104: write(file,str,strlen(str));
105:
106: sprintf(str,"%s\r\n%s\r\n%u\r\n%u\r\n%lu\r\n%s\r\n%lu\r\n%lu\r\n"
107: ,ctrl_dir /* Ctrl dir */
108: ,data_dir /* Data dir */
109: ,sys_nodes /* Total system nodes */
110: ,node_num /* Current node */
111: ,tleft /* User Timeleft in seconds */
112: ,useron.misc&ANSI /* User ANSI ? (Yes/Mono/No) */
113: ? useron.misc&COLOR
114: ? "Yes":"Mono":"No"
115: ,rows /* User Screen lines */
116: ,useron.cdt+useron.freecdt); /* User Credits */
117: write(file,str,strlen(str));
118:
119: sprintf(str,"%u\r\n%u\r\n%s\r\n%c\r\n%u\r\n%s\r\n"
120: ,useron.level /* User main level */
121: ,useron.level /* User transfer level */
122: ,useron.birth /* User birthday */
123: ,useron.sex /* User sex (M/F) */
124: ,useron.number /* User number */
125: ,useron.phone); /* User phone number */
126: write(file,str,strlen(str));
127:
128: sprintf(str,"%u\r\n%u\r\n%x\r\n%lu\r\n%s\r\n%s\r\n"
129: "%s\r\n%s\r\n%s\r\n%s\r\n%s\r\n%s\r\n%lu\r\n"
130: ,online==ON_LOCAL ? 0:com_port /* Com port or 0 if local */
131: ,com_irq /* Com IRQ */
132: ,com_base /* Com base in hex */
133: ,dte_rate /* Com rate */
134: ,mdm_misc&MDM_CTS ? "Yes":"No" /* Hardware flow ctrl Y/N */
135: ,mdm_misc&MDM_STAYHIGH ? "Yes":"No" /* Locked DTE rate Y/N */
136: ,mdm_init /* Modem initialization string */
137: ,mdm_spec /* Modem special init string */
138: ,mdm_term /* Modem terminal mode init str */
139: ,mdm_dial /* Modem dial string */
140: ,mdm_offh /* Modem off-hook string */
141: ,mdm_answ /* Modem answer string */
142: #ifndef __FLAT__
143: ,sys_status&SS_DCDHIGH ? &fakeriobp : &riobp-1 /* Modem status register */
144: #else
145: ,0
146: #endif
147: );
148: write(file,str,strlen(str));
149:
150: sprintf(str,"%u\r\n",total_xtrns);
151: write(file,str,strlen(str)); /* Total external programs */
152:
153: for(i=0;i<total_xtrns;i++) { /* Each program's name */
154: if(SYSOP || chk_ar(xtrn[i]->ar,useron))
155: strcpy(str,xtrn[i]->name);
156: else
157: str[0]=0; /* Blank if no access */
158: strcat(str,crlf);
159: write(file,str,strlen(str)); }
160:
161: sprintf(str,"%s\r\n%s\r\n"
162: ,ltoaf(useron.flags1,tmp) /* Main flags */
163: ,ltoaf(useron.flags2,tmp2) /* Transfer flags */
164: );
165: write(file,str,strlen(str));
166:
167: sprintf(str,"%s\r\n%s\r\n%lx\r\n%s\r\n%s\r\n%s\r\n"
168: ,ltoaf(useron.exempt,tmp) /* Exemptions */
169: ,ltoaf(useron.rest,tmp2) /* Restrictions */
170: ,useron.expire /* Expiration date in unix form */
171: ,useron.address /* Address */
172: ,useron.location /* City/State */
173: ,useron.zipcode /* Zip/Postal code */
174: );
175: write(file,str,strlen(str));
176:
177: sprintf(str,"%s\r\n%s\r\n%d\r\n%s\r\n%lu\r\n%s\r\n%s\r\n%s\r\n%s\r\n"
178: "%lx\r\n%d\r\n"
179: ,ltoaf(useron.flags3,tmp) /* Flag set #3 */
180: ,ltoaf(useron.flags4,tmp2) /* Flag set #4 */
181: ,mswtyp /* Time-slice type */
182: ,useron.name /* Real name/company */
183: ,cur_rate /* DCE rate */
184: ,exec_dir
185: ,text_dir
186: ,temp_dir
187: ,sys_id
188: ,node_misc
189: #ifdef __FLAT__
190: ,rio_handle
191: #else
192: ,-1
193: #endif
194: );
195: write(file,str,strlen(str));
196:
197: close(file); }
198:
199: else if(type==XTRN_WWIV) { /* WWIV CHAIN.TXT File */
200: sprintf(str,"%sCHAIN.TXT",dropdir);
201: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
202: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
203: return; }
204:
205: sprintf(str,"%u\r\n%s\r\n%s\r\n%s\r\n%u\r\n%c\r\n"
206: ,useron.number /* User number */
207: ,name /* User name */
208: ,useron.name /* User real name */
209: ,nulstr /* User call sign */
210: ,getage(useron.birth) /* User age */
211: ,useron.sex); /* User sex (M/F) */
212: strupr(str);
213: write(file,str,strlen(str));
214:
215: sprintf(str,"%lu\r\n%s\r\n%u\r\n%lu\r\n%u\r\n%u\r\n%u\r\n%u\r\n%u\r\n"
216: ,useron.cdt+useron.freecdt /* Gold */
217: ,unixtodstr(useron.laston,tmp) /* User last on date */
218: ,80 /* User screen width */
219: ,rows /* User screen length */
220: ,useron.level /* User SL */
221: ,0 /* Cosysop? */
222: ,SYSOP /* Sysop? (1/0) */
223: ,(useron.misc&ANSI) ? 1:0 /* ANSI ? (1/0) */
224: ,online==ON_REMOTE); /* Remote (1/0) */
225: write(file,str,strlen(str));
226:
227: sprintf(str,"%lu\r\n%s\r\n%s\r\n%s\r\n%lu\r\n%d\r\n%s\r\n%s\r\n"
228: "%u\r\n%u\r\n%lu\r\n%u\r\n%lu\r\n%u\r\n%s\r\n"
229: ,tleft /* Time left in seconds */
230: ,node_dir /* Gfiles dir (log dir) */
231: ,data_dir /* Data dir */
232: ,"NODE.LOG" /* Name of log file */
233: ,dte_rate /* DTE rate */
234: ,com_port /* COM port number */
235: ,sys_name /* System name */
236: ,sys_op /* Sysop name */
237: ,0 /* Logon time (sec past 12am) */
238: ,0 /* Current time (sec past 12am) */
239: ,useron.ulb/1024UL /* User uploaded kbytes */
240: ,useron.uls /* User uploaded files */
241: ,useron.dlb/1024UL /* User downloaded kbytes */
242: ,useron.dls /* User downloaded files */
243: ,"8N1"); /* Data, parity, stop bits */
244: write(file,str,strlen(str));
245:
246: close(file); }
247:
248: else if(type==XTRN_GAP) { /* Gap DOOR.SYS File */
249: sprintf(str,"%sDOOR.SYS",dropdir);
250: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
251: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
252: return; }
253:
254: sprintf(str,"COM%d:\r\n%lu\r\n%u\r\n%u\r\n%lu\r\n%c\r\n%c\r\n%c\r\n%c\r\n"
255: ,online==ON_REMOTE ? com_port:0 /* 01: COM port - 0 if Local */
256: ,cur_rate /* 02: DCE rate */
257: ,8 /* 03: Data bits */
258: ,node_num /* 04: Node number */
259: ,dte_rate /* 05: DTE rate */
260: ,console&CON_L_ECHO ? 'Y':'N' /* 06: Screen display */
261: ,'Y' /* 07: Printer toggle */
262: ,'Y' /* 08: Page bell */
263: ,'Y'); /* 09: Caller alarm */
264: write(file,str,strlen(str));
265:
266: sprintf(str,"%s\r\n%s\r\n%s\r\n%s\r\n%s\r\n"
267: ,name /* 10: User name */
268: ,useron.location /* 11: User location */
269: ,useron.phone /* 12: User home phone */
270: ,useron.phone /* 13: User work/data phone */
271: ,useron.pass); /* 14: User password */
272: write(file,str,strlen(str));
273:
274: sprintf(str,"%u\r\n%u\r\n%s\r\n%lu\r\n%lu\r\n%s\r\n"
275: ,useron.level /* 15: User security level */
276: ,useron.logons /* 16: User total logons */
277: ,unixtodstr(useron.laston,tmp) /* 17: User last on date */
278: ,tleft /* 18: User time left in sec */
279: ,tleft/60 /* 19: User time left in min */
280: ,useron.misc&NO_EXASCII /* 20: GR if COLOR ANSI */
281: ? "7E" : (useron.misc&(ANSI|COLOR))==(ANSI|COLOR) ? "GR" : "NG");
282: write(file,str,strlen(str));
283:
284: sprintf(str,"%lu\r\n%c\r\n%s\r\n%u\r\n%s\r\n%u\r\n%c\r\n%u\r\n%u\r\n"
285: ,rows /* 21: User screen length */
286: ,useron.misc&EXPERT ? 'Y':'N' /* 22: Expert? (Y/N) */
287: ,ltoaf(useron.flags1,tmp2) /* 23: Registered conferences */
288: ,0 /* 24: Conference came from */
289: ,unixtodstr(useron.expire,tmp) /* 25: User expiration date */
290: ,useron.number /* 26: User number */
291: ,'Y' /* 27: Default protocol */
292: ,useron.uls /* 28: User total uploads */
293: ,useron.dls); /* 29: User total downloads */
294: write(file,str,strlen(str));
295:
296: sprintf(str,"%u\r\n%lu\r\n%s\r\n%s\r\n%s\r\n%s"
297: "\r\n%s\r\n%02d:%02d\r\n%c\r\n"
298: ,0 /* 30: Kbytes downloaded today */
299: ,(useron.cdt+useron.freecdt)/1024UL /* 31: Max Kbytes to download today */
300: ,useron.birth /* 32: User birthday */
301: ,node_dir /* 33: Path to MAIN directory */
302: ,data_dir /* 34: Path to GEN directory */
303: ,sys_op /* 35: Sysop name */
304: ,nulstr /* 36: Alias name */
305: ,0 // sys_eventtime/60 /* 37: Event time HH:MM */
306: ,0 // sys_eventtime%60
307: ,'Y'); /* 38: Error correcting connection */
308: write(file,str,strlen(str));
309:
310: unixtodos(ns_time,&date,&curtime);
311: sprintf(str,"%c\r\n%c\r\n%u\r\n%lu\r\n%02d/%02d/%02d\r\n"
312: ,(useron.misc&(NO_EXASCII|ANSI|COLOR))==ANSI
313: ? 'Y':'N' /* 39: ANSI supported but NG mode */
314: ,'Y' /* 40: Use record locking */
315: ,14 /* 41: BBS default color */
316: ,useron.min /* 42: Time credits in minutes */
317: ,date.da_mon /* 43: File new-scan date */
318: ,date.da_day
1.1.1.2 ! root 319: ,TM_YEAR(date.da_year-1900));
1.1 root 320: write(file,str,strlen(str));
321:
322: unixtodos(logontime,&date,&curtime);
323: unixtodos(useron.laston,&date,&lastcall);
324: sprintf(str,"%02d:%02d\r\n%02d:%02d\r\n%u\r\n%u\r\n%lu\r\n"
325: "%lu\r\n%s\r\n%u\r\n%u\r\n"
326: ,curtime.ti_hour /* 44: Time of this call */
327: ,curtime.ti_min
328: ,lastcall.ti_hour /* 45: Time of last call */
329: ,lastcall.ti_min
330: ,999 /* 46: Max daily files available */
331: ,0 /* 47: Files downloaded so far today */
332: ,useron.ulb/1024UL /* 48: Total Kbytes uploaded */
333: ,useron.dlb/1024UL /* 49: Total Kbytes downloaded */
334: ,useron.comment /* 50: User comment */
335: ,0 /* 51: Total doors opened */
336: ,useron.posts); /* 52: User message left */
337: write(file,str,strlen(str));
338:
339: close(file); }
340:
341: else if(type==XTRN_RBBS || type==XTRN_RBBS1) {
342: if(type==XTRN_RBBS)
343: sprintf(str,"%sDORINFO%X.DEF",dropdir,node_num); /* support 1-F */
344: else
345: sprintf(str,"%sDORINFO1.DEF",dropdir);
346: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
347: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
348: return; }
349:
350: strcpy(tmp,sys_op);
351: p=strchr(tmp,SP);
352: if(p)
353: *(p++)=0;
354: else
355: p=nulstr;
356:
357: sprintf(str,"%s\r\n%s\r\n%s\r\nCOM%d\r\n%lu BAUD,N,8,1\r\n%u\r\n"
358: ,sys_name /* Name of BBS */
359: ,tmp /* Sysop's firstname */
360: ,p /* Sysop's lastname */
361: ,online==ON_REMOTE ? com_port:0 /* COM port number, 0 if local */
362: ,dte_rate /* DTE rate */
363: ,0); /* Network type */
364: strupr(str);
365: write(file,str,strlen(str));
366:
367: strcpy(tmp,name);
368: p=strchr(tmp,SP);
369: if(p)
370: *(p++)=0;
371: else
372: p=nulstr;
373: sprintf(str,"%s\r\n%s\r\n%s\r\n%u\r\n%u\r\n%lu\r\n"
374: ,tmp /* User's firstname */
375: ,p /* User's lastname */
376: ,useron.location /* User's city */
377: ,(useron.misc&ANSI)==ANSI /* 1=ANSI 0=ASCII */
378: ,useron.level /* Security level */
379: ,tleft/60); /* Time left in minutes */
380: strupr(str);
381: write(file,str,strlen(str));
382:
383: close(file);
384:
385: sprintf(str,"%sEXITINFO.BBS",dropdir);
386: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
387: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
388: return; }
1.1.1.2 ! root 389: w=dte_rate;
! 390: write(file,&w,sizeof(short)); /* BaudRate */
1.1 root 391: /* SysInfo */
392: getstats(0,&stats);
393: write(file,&stats.logons,sizeof(long)); /* CallCount */
394: write(file,nulstr,36); /* LastCallerName */
395: write(file,nulstr,36); /* LastCallerAlias */
396: write(file,nulstr,92); /* ExtraSpace */
397: /* TimeLogInfo */
398: write(file,nulstr,9); /* StartDate */
1.1.1.2 ! root 399: write(file,nulstr,24*sizeof(short)); /* BusyPerHour */
! 400: write(file,nulstr,7*sizeof(short)); /* BusyPerDay */
1.1 root 401: /* UserInfo */
402: str2pas(name,str); /* Name */
403: write(file,str,36);
404: str2pas(useron.location,str);
405: write(file,str,26); /* City */
406: str2pas(useron.pass,str);
407: write(file,str,16); /* Pwd */
408: str2pas(useron.phone,str);
409: write(file,str,13); /* DataPhone */
410: write(file,str,13); /* HomePhone */
411: unixtodos(useron.laston,&date,&lastcall);
412: sprintf(tmp,"%02d:%02d",lastcall.ti_hour,lastcall.ti_min);
413: str2pas(tmp,str);
414: write(file,str,6); /* LastTime */
415: unixtodstr(useron.laston,tmp);
416: str2pas(tmp,str);
417: write(file,str,9); /* LastDate */
418: c=0;
419: if(useron.misc&DELETED) c|=(1<<0);
420: if(useron.misc&CLRSCRN) c|=(1<<1);
421: if(useron.misc&UPAUSE) c|=(1<<2);
422: if(useron.misc&ANSI) c|=(1<<3);
423: if(useron.sex=='F') c|=(1<<7);
424: write(file,&c,1); /* Attrib */
425: write(file,&useron.flags1,4); /* Flags */
426: i=0;
1.1.1.2 ! root 427: w=0;
! 428: write(file,&w,sizeof(short)); /* Credit */
! 429: write(file,&w,sizeof(short)); /* Pending */
! 430: write(file,&useron.posts,sizeof(short)); /* TimesPosted */
! 431: write(file,&w,sizeof(short)); /* HighMsgRead */
! 432: w=useron.level;
! 433: write(file,&w,sizeof(short)); /* SecLvl */
! 434: w=0;
! 435: write(file,&w,sizeof(short)); /* Times */
! 436: write(file,&useron.uls,sizeof(short)); /* Ups */
! 437: write(file,&useron.dls,sizeof(short)); /* Downs */
! 438: w=useron.ulb/1024UL;
! 439: write(file,&w,sizeof(short)); /* UpK */
! 440: w=useron.dlb/1024UL;
! 441: write(file,&w,sizeof(short)); /* DownK */
! 442: w=logon_dlb/1024UL;
! 443: write(file,&w,sizeof(short)); /* TodayK */
! 444: w=0;
! 445: write(file,&w,sizeof(short)); /* Elapsed */
! 446: write(file,&w,sizeof(short)); /* Len */
! 447: write(file,&w,sizeof(short)); /* CombinedPtr */
! 448: write(file,&w,sizeof(short)); /* AliasPtr */
1.1 root 449: l=0;
450: write(file,&l,sizeof(long)); /* Birthday (as a long?) */
451: /* EventInfo */
452: c=0;
453: write(file,&c,sizeof(char)); /* Status */
454: write(file,&l /* sys_eventtime */,sizeof(long)); /* RunTime */
455: write(file,&c,sizeof(char)); /* ErrorLevel */
456: c=0xff;
457: write(file,&c,sizeof(char)); /* Days */
458: // c=sys_eventnode==node_num || sys_misc&SM_TIMED_EX ? 1 : 0;
459: c=0;
460: write(file,&c,sizeof(char)); /* Forced */
461: if(!total_events)
462: l=0;
463: else
464: l=event[0]->last;
465: write(file,&l,sizeof(long)); /* LastTimeRun */
466: memset(str,0,40);
467: write(file,str,7); /* Spare */
468:
469: c=0;
470: write(file,&c,1); /* NetMailEntered */
471: write(file,&c,1); /* EchoMailEntered */
472:
473: unixtodos(logontime,&date,&curtime);
474: sprintf(tmp,"%02d:%02d",curtime.ti_hour,curtime.ti_min);
475: str2pas(tmp,str);
476: write(file,str,6); /* LoginTime */
477: unixtodstr(logontime,tmp);
478: str2pas(tmp,str);
479: write(file,str,9); /* LoginDate */
1.1.1.2 ! root 480: write(file,&level_timepercall[useron.level],sizeof(short)); /* TmLimit */
1.1 root 481: write(file,&logontime,sizeof(long)); /* LoginSec */
482: write(file,&useron.cdt,sizeof(long)); /* Credit */
1.1.1.2 ! root 483: write(file,&useron.number,sizeof(short)); /* UserRecNum */
1.1 root 484: write(file,&i,2); /* ReadThru */
485: write(file,&i,2); /* PageTimes */
486: write(file,&i,2); /* DownLimit */
487: c=sys_status&SS_SYSPAGE ? 1:0;
488: write(file,&c,1); /* WantChat */
489: c=0;
490: write(file,&c,1); /* GosubLevel */
491:
492: memset(str,0,255);
493: for(i=1;i<20;i++)
494: write(file,str,9); /* GosubData */
495: write(file,str,9); /* Menu */
496: c=useron.misc&CLRSCRN ? 1:0;
497: write(file,&c,1); /* ScreenClear */
498: c=useron.misc&UPAUSE ? 1:0;
499: write(file,&c,1); /* MorePrompts */
500: c=useron.misc&NO_EXASCII ? 0:1;
501: write(file,&c,1); /* GraphicsMode */
502: c=useron.xedit ? 1:0;
503: write(file,&c,1); /* ExternEdit */
504: i=rows;
505: write(file,&i,2); /* ScreenLength */
506: c=1;
507: write(file,&c,1); /* MNP_Connect */
508: write(file,str,49); /* ChatReason */
509: c=0;
510: write(file,&c,1); /* ExternLogoff */
511: c=useron.misc&ANSI ? 1:0;
512: write(file,&c,1); /* ANSI_Capable */
513: close(file);
514: }
515:
516: else if(type==XTRN_WILDCAT) { /* WildCat CALLINFO.BBS File */
517: sprintf(str,"%sCALLINFO.BBS",dropdir);
518: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
519: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
520: return; }
521:
522: if(online==ON_LOCAL) i=5;
523: else
524: switch(dte_rate) {
525: case 300:
526: i=1;
527: break;
528: case 1200:
529: i=2;
530: break;
531: case 2400:
532: i=0;
533: break;
534: case 9600:
535: i=3;
536: break;
537: case 19200:
538: i=4;
539: break;
540: case 38400:
541: i=6;
542: break;
543: default:
544: i=7;
545: break; }
546: sprintf(str,"%s\r\n%u\r\n%s\r\n%u\r\n%lu\r\n%s\r\n%s\r\n%u\r\n"
547: ,name /* User name */
548: ,i /* DTE rate */
549: ,useron.location /* User location */
550: ,useron.level /* Security level */
551: ,tleft/60 /* Time left in min */
552: ,useron.misc&ANSI ? "COLOR":"MONO" /* ANSI ??? */
553: ,useron.pass /* Password */
554: ,useron.number); /* User number */
555: write(file,str,strlen(str));
556:
557: unixtodos(now,&date,&curtime);
558: sprintf(str,"%lu\r\n%02d:%02d\r\n%02d:%02d %02d/%02d/%02d\r\n%s\r\n"
559: ,tleft /* Time left in seconds */
560: ,curtime.ti_hour,curtime.ti_min /* Current time HH:MM */
561: ,curtime.ti_hour,curtime.ti_min /* Current time and date HH:MM */
562: ,date.da_mon,date.da_day /* MM/DD/YY */
1.1.1.2 ! root 563: ,TM_YEAR(date.da_year-1900)
1.1 root 564: ,nulstr); /* Conferences with access */
565: write(file,str,strlen(str));
566:
567: unixtodos(useron.laston,&date,&lastcall);
568: sprintf(str,"%u\r\n%u\r\n%u\r\n%u\r\n%s\r\n%s %02u:%02u\r\n"
569: ,0 /* Daily download total */
570: ,0 /* Max download files */
571: ,0 /* Daily download k total */
572: ,0 /* Max download k total */
573: ,useron.phone /* User phone number */
574: ,unixtodstr(useron.laston,tmp) /* Last on date and time */
575: ,lastcall.ti_hour /* MM/DD/YY HH:MM */
576: ,lastcall.ti_min);
577: write(file,str,strlen(str));
578:
579: unixtodos(ns_time,&date,&curtime);
580: sprintf(str,"%s\r\n%s\r\n%02d/%02d/%02d\r\n%u\r\n%lu\r\n%u"
581: "\r\n%u\r\n%u\r\n"
582: ,useron.misc&EXPERT /* Expert or Novice mode */
583: ? "EXPERT":"NOVICE"
584: ,"All" /* Transfer Protocol */
585: ,date.da_mon,date.da_day /* File new-scan date */
1.1.1.2 ! root 586: ,TM_YEAR(date.da_year-1900) /* in MM/DD/YY */
1.1 root 587: ,useron.logons /* Total logons */
588: ,rows /* Screen length */
589: ,0 /* Highest message read */
590: ,useron.uls /* Total files uploaded */
591: ,useron.dls); /* Total files downloaded */
592: write(file,str,strlen(str));
593:
594: sprintf(str,"%u\r\n%s\r\nCOM%u\r\n%s\r\n%lu\r\n%s\r\n%s\r\n"
595: ,8 /* Data bits */
596: ,online==ON_LOCAL?"LOCAL":"REMOTE" /* Online local or remote */
597: ,com_port /* COMx port */
598: ,useron.birth /* User birthday */
599: ,dte_rate /* DTE rate */
600: ,"FALSE" /* Already connected? */
601: ,"Normal Connection"); /* Normal or ARQ connect */
602: write(file,str,strlen(str));
603:
604: sprintf(str,"%02d/%02d/%02d %02d:%02d\r\n%u\r\n%u\r\n"
605: ,date.da_mon,date.da_day /* Current date MM/DD/YY */
1.1.1.2 ! root 606: ,TM_YEAR(date.da_year-1900)
1.1 root 607: ,curtime.ti_hour,curtime.ti_min /* Current time HH:MM */
608: ,node_num /* Node number */
609: ,0); /* Door number */
610: write(file,str,strlen(str));
611:
612: close(file); }
613:
614: else if(type==XTRN_PCBOARD) { /* PCBoard Files */
615: sprintf(str,"%sPCBOARD.SYS",dropdir);
616: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
617: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
618: return; }
619:
620: sprintf(str,"%2d%2d%2d%2d%c%2d%c%c%5u%-5.5s"
621: ,-1 /* Display on/off */
622: ,0 /* Printer on/off */
623: ,sys_status&SS_SYSPAGE ? -1:0 /* Page Bell on/off */
624: ,node_misc&NM_ANSALARM ? -1:0 /* Caller Alarm on/off */
625: ,SP /* Sysop next flag */
626: ,0 /* Error corrected */
627: ,useron.misc&NO_EXASCII ? '7' /* Graphics mode */
628: : (useron.misc&(COLOR|ANSI))==(COLOR|ANSI) ? 'Y':'N'
629: ,'A' /* Node chat status */
630: ,(uint)dte_rate /* DTE Port Speed */
631: ,connection /* Connection description */
632: );
633: write(file,str,23);
634:
635: write(file,&useron.number,2); /* User record number */
636:
637: strcpy(tmp,name);
638: p=strchr(tmp,SP);
639: if(p) *p=0;
640: sprintf(str,"%-15.15s%-12s"
641: ,tmp /* User's first name */
642: ,useron.pass); /* User's password */
643: write(file,str,27);
644:
645: unixtodos(logontime,&date,&curtime);
646: i=(curtime.ti_hour*60)+curtime.ti_min;
647: write(file,&i,2); /* Logon time in min since mid */
648:
649: now=time(NULL);
650: i=-(((now-starttime)/60)+useron.ttoday); /* Negative minutes used */
651: write(file,&i,2);
652:
653: sprintf(str,"%02d:%02d",curtime.ti_hour,curtime.ti_min);
654: write(file,str,5);
655:
656: i=level_timepercall[useron.level]; /* Time allowed on */
657: write(file,&i,2);
658:
659: i=0; /* Allowed K-bytes for D/L */
660: write(file,&i,2);
661: write(file,&i,1); /* Conference user was in */
662: write(file,&i,2); /* Conferences joined */
663: write(file,&i,2); /* "" */
664: write(file,&i,2); /* "" */
665: write(file,&i,2); /* Conferences scanned */
666: write(file,&i,2); /* "" */
667: write(file,&i,2); /* Conference add time */
668: write(file,&i,2); /* Upload/Sysop Chat time min */
669:
670: strcpy(str," ");
671: write(file,str,4); /* Language extension */
672:
673: sprintf(str,"%-25.25s",name); /* User's full name */
674: write(file,str,25);
675:
676: i=(tleft/60);
677: write(file,&i,2); /* Minutes remaining */
678:
679: write(file,&node_num,1); /* Node number */
680:
681: sprintf(str,"%02d:%02d%2d%2d" /* Scheduled Event time */
682: ,0 // sys_eventtime/60
683: ,0 // sys_eventtime%60
684: ,0 // sys_timed[0] ? -1:0 /* Event active ? */
685: ,0 /* Slide event ? */
686: );
687: write(file,str,9);
688:
689: l=0L;
690: write(file,&l,4); /* Memorized message number */
691:
692: sprintf(str,"%d%c%c%d%s%c%c%d%d%d%c%c"
693: ,com_port /* COM Port number */
694: ,SP /* Reserved */
695: ,SP /* "" */
696: ,(useron.misc&ANSI)==ANSI /* 1=ANSI 0=NO ANSI */
697: ,"01-01-80" /* last event date */
698: ,0,0 /* last event minute */
699: ,0 /* caller exited to dos */
700: ,sys_status&SS_EVENT ? 1:0 /* event up coming */
701: ,0 /* stop uploads */
702: ,0,0 /* conference user was in */
703: );
704: write(file,str,19);
705:
706: close(file); /* End of PCBOARD.SYS creation */
707:
708: sprintf(str,"%sUSERS.SYS",dropdir);
709: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
710: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
711: return; }
712:
713: /* Write goof-ball header */
714:
715: i=145;
716: write(file,&i,2); /* PCBoard version number (i.e. 145) */
717: l=useron.number;
718: write(file,&l,4); /* Record number for USER's file */
719: i=218;
720: write(file,&i,2); /* Size of "fixed" user record */
721: i=1;
722: write(file,&i,2); /* Number of conference areas */
723: i=7;
724: write(file,&i,2); /* Number of bit map fields for conferences */
725: i=5;
726: write(file,&i,2); /* Size of each bit map field */
727: memset(str,0,15);
728: write(file,str,15); /* Name of Third Party Application (if any) */
729: i=0;
730: write(file,&i,2); /* Version number for application (if any) */
731: write(file,&i,2); /* Size of a "fixed length" record (if any) */
732: write(file,&i,2); /* Size of conference record (if any) */
733: l=0;
734: write(file,&l,4); /* Offset of AppRec into USERS.INF (if any) */
735: i=0;
736: write(file,&i,1); /* 1, if USERS.SYS file has been updated */
737:
738: /* Write fixed record portion */
739:
740: write(file,name,26); /* Name */
741: sprintf(str,"%.24s",useron.location);
742: write(file,str,25); /* Location */
743: write(file,useron.pass,13); /* Password */
744: write(file,useron.phone,14); /* Business or Data Phone */
745: write(file,useron.phone,14); /* Home or Voice Phone */
746: i=unixtojulian(useron.laston);
747: write(file,&i,2); /* Date last on */
748: unixtodos(useron.laston,&date,&curtime);
749: sprintf(str,"%02d:%02d",curtime.ti_hour,curtime.ti_min);
750: write(file,str,6); /* Last time on */
751: if(useron.misc&EXPERT)
752: i=1;
753: else
754: i=0;
755: write(file,&i,1); /* Expert mode */
756: i='Z';
757: write(file,&i,1); /* Protocol (A-Z) */
758: if(useron.misc&CLRSCRN)
759: i=2;
760: else
761: i=0;
762: write(file,&i,1); /* bit packed flags */
763: i=0;
764: write(file,&i,2); /* DOS date for last DIR Scan */
765: i=useron.level;
766: write(file,&i,2); /* Security level */
767: write(file,&useron.logons,2); /* Number of times caller has connected */
768: c=rows;
769: write(file,&c,1); /* Page length */
770: write(file,&useron.uls,2); /* Number of uploads */
771: write(file,&useron.dls,2); /* Number of downloads */
772: l=0;
773: write(file,&l,4); /* Number of download bytes today */
774: write(file,&useron.note,31); /* Comment #1 */
775: write(file,&useron.comp,31); /* Comment #2 */
776: i=(now-starttime)/60;
777: write(file,&i,2); /* Minutes online (this logon?) */
778: i=unixtojulian(useron.expire);
779: write(file,&i,2); /* Expiration date */
780: i=expired_level;
781: write(file,&i,2); /* Expired security level */
782: i=1;
783: write(file,&i,2); /* Current conference */
784: write(file,&useron.dlb,4); /* Bytes downloaded */
785: write(file,&useron.ulb,4); /* Bytes uploaded */
786: if(useron.misc&DELETED)
787: i=1;
788: else
789: i=0;
790: write(file,&i,1); /* Deleted? */
791: l=useron.number;
792: write(file,&l,4); /* Record number in USERS.INF file */
793: l=0;
794: memset(str,0,9);
795: write(file,str,9); /* Reserved */
796: write(file,&l,4); /* Number of messages read */
797: l=useron.posts+useron.emails+useron.fbacks;
798: write(file,&l,4); /* Number of messages left */
799: close(file);
800:
801: /* End of USERS.SYS creation */
802:
803: }
804:
805: else if(type==XTRN_SPITFIRE) { /* SpitFire SFDOORS.DAT File */
806: sprintf(str,"%sSFDOORS.DAT",dropdir);
807: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
808: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
809: return; }
810:
811: now=time(NULL);
812: unixtodos(now,&date,&curtime);
813: l=((((long)curtime.ti_hour*60L)+(long)curtime.ti_min)*60L)
814: +(long)curtime.ti_sec;
815:
816: strcpy(tmp,name);
817: if((p=strchr(tmp,SP))!=NULL)
818: *p=0;
819:
820: sprintf(str,"%u\r\n%s\r\n%s\r\n%s\r\n%lu\r\n%u\r\n%lu\r\n%lu\r\n"
821: ,useron.number /* User number */
822: ,name /* User name */
823: ,useron.pass /* Password */
824: ,tmp /* User's first name */
825: ,dte_rate /* DTE Rate */
826: ,com_port /* COM Port */
827: ,tleft/60 /* Time left in minutes */
828: ,l /* Seconds since midnight (now) */
829: );
830: write(file,str,strlen(str));
831:
832: unixtodos(logontime,&date,&curtime);
833: l=((((long)curtime.ti_hour*60L)+(long)curtime.ti_min)*60L)
834: +(long)curtime.ti_sec;
835:
836: sprintf(str,"%s\r\n%s\r\n%u\r\n%u\r\n%u\r\n%u\r\n%lu\r\n%lu\r\n%s\r\n"
837: "%s\r\n%s\r\n%lu\r\n%s\r\n%u\r\n%u\r\n%u\r\n%u\r\n%u\r\n%lu\r\n%u\r\n"
838: "%lu\r\n%lu\r\n%s\r\n%s\r\n"
839: ,dropdir
840: ,useron.misc&ANSI ? "TRUE":"FALSE" /* ANSI ? True or False */
841: ,useron.level /* Security level */
842: ,useron.uls /* Total uploads */
843: ,useron.dls /* Total downloads */
844: ,level_timepercall[useron.level] /* Minutes allowed this call */
845: ,l /* Secs since midnight (logon) */
846: ,starttime-logontime /* Extra time in seconds */
847: ,"FALSE" /* Sysop next? */
848: ,"FALSE" /* From Front-end? */
849: ,"FALSE" /* Software Flow Control? */
850: ,dte_rate /* DTE Rate */
851: ,"FALSE" /* Error correcting connection? */
852: ,0 /* Current conference */
853: ,0 /* Current file dir */
854: ,node_num /* Node number */
855: ,15 /* Downloads allowed per day */
856: ,0 /* Downloads already this day */
857: ,100000 /* Download bytes allowed/day */
858: ,0 /* Downloaded bytes already today */
859: ,useron.ulb/1024L /* Kbytes uploaded */
860: ,useron.dlb/1024L /* Kbytes downloaded */
861: ,useron.phone /* Phone Number */
862: ,useron.location /* City, State */
863: );
864: write(file,str,strlen(str));
865:
866: close(file); }
867:
868: else if(type==XTRN_UTI) { /* UTI v2.1 - UTIDOOR.TXT */
869: sprintf(str,"%sUTIDOOR.TXT",dropdir);
870: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
871: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
872: return; }
873:
874: strcpy(tmp,name);
875: strupr(tmp);
876: sprintf(str,"%s\r\n%lu\r\n%u\r\n%lu\r\n%lu\r\n"
877: ,tmp /* User name */
878: ,cur_rate /* Actual BPS rate */
879: ,online==ON_LOCAL ? 0: com_port /* COM Port */
880: ,dte_rate /* DTE rate */
881: ,tleft); /* Time left in sec */
882: write(file,str,strlen(str));
883:
884: close(file); }
885:
886: else if(type==XTRN_SR) { /* Solar Realms DOORFILE.SR */
887: sprintf(str,"%sDOORFILE.SR",dropdir);
888: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
889: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
890: return; }
891:
892: sprintf(str,"%s\r\n%d\r\n%d\r\n%lu\r\n%lu\r\n%u\r\n%lu\r\n"
893: ,name /* Complete name of user */
894: ,useron.misc&ANSI ? 1:0 /* ANSI ? */
895: ,useron.misc&NO_EXASCII ? 0:1 /* IBM characters ? */
896: ,rows /* Page length */
897: ,dte_rate /* Baud rate */
898: ,online==ON_LOCAL ? 0:com_port /* COM port */
899: ,tleft/60 /* Time left (in minutes) */
900: );
901: write(file,str,strlen(str));
902: close(file); }
903:
904: else if(type==XTRN_TRIBBS) { /* TRIBBS.SYS */
905: sprintf(str,"%sTRIBBS.SYS",dropdir);
906: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
907: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
908: return; }
909:
910: sprintf(str,"%u\r\n%s\r\n%s\r\n%u\r\n%c\r\n%c\r\n%lu\r\n%s\r\n%s\r\n%s\r\n"
911: ,useron.number /* User's record number */
912: ,name /* User's name */
913: ,useron.pass /* User's password */
914: ,useron.level /* User's level */
915: ,useron.misc&EXPERT ? 'Y':'N' /* Expert? */
916: ,useron.misc&ANSI ? 'Y':'N' /* ANSI? */
917: ,tleft/60 /* Minutes left */
918: ,useron.phone /* User's phone number */
919: ,useron.location /* User's city and state */
920: ,useron.birth /* User's birth date */
921: );
922: write(file,str,strlen(str));
923:
924: sprintf(str,"%u\r\n%u\r\n%lu\r\n%lu\r\n%c\r\n%c\r\n%s\r\n%s\r\n%s\r\n"
925: ,node_num /* Node number */
926: ,com_port /* Serial port */
927: ,online==ON_LOCAL ? 0L:cur_rate /* Baud rate */
928: ,dte_rate /* Locked rate */
929: ,mdm_misc&(MDM_RTS|MDM_CTS) ? 'Y':'N'
930: ,'Y' /* Error correcting connection */
931: ,sys_name /* Board's name */
932: ,sys_op /* Sysop's name */
933: ,useron.handle /* User's alias */
934: );
935: write(file,str,strlen(str));
936: close(file); }
937:
938: else if(type)
939: errormsg(WHERE,ERR_CHK,"Drop file type",type);
940:
941: }
942:
943: /****************************************************************************/
944: /* Reads in MODUSER.DAT, EXITINFO.BBS, or DOOR.SYS and modify the current */
945: /* user's values. */
946: /****************************************************************************/
947: void moduserdat(uint xtrnnum)
948: {
949: char str[256],path[256],c,startup[128];
950: uint i;
951: long mod;
952: int file;
953: FILE *stream;
954:
955: sprintf(startup,"%s\\",xtrn[xtrnnum]->path);
956: if(xtrn[xtrnnum]->type==XTRN_RBBS) {
957: sprintf(path,"%sEXITINFO.BBS"
958: ,xtrn[xtrnnum]->misc&STARTUPDIR ? startup : node_dir);
959: if((file=nopen(path,O_RDONLY))!=-1) {
960: lseek(file,361,SEEK_SET);
961: read(file,&useron.flags1,4); /* Flags */
962: putuserrec(useron.number,U_FLAGS1,8,ultoa(useron.flags1,tmp,16));
963: lseek(file,373,SEEK_SET);
964: read(file,&i,2); /* SecLvl */
965: if(i<90) {
966: useron.level=i;
967: putuserrec(useron.number,U_LEVEL,2,itoa(useron.level,tmp,10)); }
968: close(file);
969: remove(path); }
970: return; }
971: else if(xtrn[xtrnnum]->type==XTRN_GAP) {
972: sprintf(path,"%sDOOR.SYS"
973: ,xtrn[xtrnnum]->misc&STARTUPDIR ? startup : node_dir);
974: if((stream=fopen(path,"rb"))!=NULL) {
975: for(i=0;i<15;i++) /* skip first 14 lines */
976: if(!fgets(str,128,stream))
977: break;
978: if(i==15 && isdigit(str[0])) {
979: mod=atoi(str);
980: if(mod<90) {
981: useron.level=mod;
982: putuserrec(useron.number,U_LEVEL,2,itoa(useron.level,tmp,10)); } }
983:
984: for(;i<23;i++)
985: if(!fgets(str,128,stream))
986: break;
987: if(i==23) { /* set main flags */
988: useron.flags1=aftol(str);
989: putuserrec(useron.number,U_FLAGS1,8,ultoa(useron.flags1,tmp,16)); }
990:
991: for(;i<25;i++)
992: if(!fgets(str,128,stream))
993: break;
994: if(i==25 && isdigit(str[0]) && isdigit(str[1])
995: && (str[2]=='/' || str[2]=='-') /* xx/xx/xx or xx-xx-xx */
996: && isdigit(str[3]) && isdigit(str[4])
997: && (str[5]=='/' || str[5]=='-')
998: && isdigit(str[6]) && isdigit(str[7])) { /* valid expire date */
999: useron.expire=dstrtounix(str);
1000: putuserrec(useron.number,U_EXPIRE,8,ultoa(useron.expire,tmp,16)); }
1001:
1002: for(;i<29;i++) /* line 29, total downloaded files */
1003: if(!fgets(str,128,stream))
1004: break;
1005: if(i==29) {
1006: truncsp(str);
1007: useron.dls=atoi(str);
1008: putuserrec(useron.number,U_DLS,5,str); }
1009:
1010: if(fgets(str,128,stream)) { /* line 30, Kbytes downloaded today */
1011: i++;
1012: truncsp(str);
1013: mod=atol(str)*1024L;
1014: if(mod) {
1015: useron.dlb=adjustuserrec(useron.number,U_DLB,10,mod);
1016: subtract_cdt(mod); } }
1017:
1018: for(;i<42;i++)
1019: if(!fgets(str,128,stream))
1020: break;
1021: if(i==42 && isdigit(str[0])) { /* Time Credits in Minutes */
1022: useron.min=atol(str);
1023: putuserrec(useron.number,U_MIN,10,ultoa(useron.min,tmp,10)); }
1024:
1025: fclose(stream); }
1026: return; }
1027:
1028: else if(xtrn[xtrnnum]->type==XTRN_PCBOARD) {
1029: sprintf(path,"%sUSERS.SYS"
1030: ,xtrn[xtrnnum]->misc&STARTUPDIR ? startup : node_dir);
1031: if((file=nopen(path,O_RDONLY))!=-1) {
1032: lseek(file,39,SEEK_SET);
1033: read(file,&c,1);
1034: if(c==1) { /* file has been updated */
1035: lseek(file,105,SEEK_CUR); /* read security level */
1036: read(file,&i,2);
1037: if(i<90) {
1038: useron.level=i;
1039: putuserrec(useron.number,U_LEVEL,2,itoa(useron.level,tmp,10)); }
1040: lseek(file,75,SEEK_CUR); /* read in expiration date */
1041: read(file,&i,2); /* convert from julian to unix */
1042: useron.expire=juliantounix(i);
1043: putuserrec(useron.number,U_EXPIRE,8,ltoa(useron.expire,tmp,16)); }
1044: close(file); }
1045: return; }
1046:
1047: sprintf(path,"%sMODUSER.DAT"
1048: ,xtrn[xtrnnum]->misc&STARTUPDIR ? startup : node_dir);
1049: if((stream=fopen(path,"rb"))!=NULL) { /* File exists */
1050: if(fgets(str,81,stream) && (mod=atol(str))!=0) {
1051: ultoac(mod>0L ? mod : -mod,tmp); /* put commas in the # */
1052: strcpy(str,"Credit Adjustment: ");
1053: if(mod<0L)
1054: strcat(str,"-"); /* negative, put '-' */
1055: strcat(str,tmp);
1056: if(mod>0L)
1057: strcpy(tmp,"$+");
1058: else
1059: strcpy(tmp,"$-");
1060: logline(tmp,str);
1061: if(mod>0L) /* always add to real cdt */
1062: useron.cdt=adjustuserrec(useron.number,U_CDT,10,mod);
1063: else
1064: subtract_cdt(-mod); } /* subtract from free cdt first */
1065: if(fgets(str,81,stream)) { /* main level */
1066: mod=atoi(str);
1067: if(isdigit(str[0]) && mod<90) {
1068: useron.level=mod;
1069: putuserrec(useron.number,U_LEVEL,2,itoa(useron.level,tmp,10)); } }
1070: fgets(str,81,stream); /* was transfer level, now ignored */
1071: if(fgets(str,81,stream)) { /* flags #1 */
1072: if(strchr(str,'-')) /* remove flags */
1073: useron.flags1&=~aftol(str);
1074: else /* add flags */
1075: useron.flags1|=aftol(str);
1076: putuserrec(useron.number,U_FLAGS1,8,ultoa(useron.flags1,tmp,16)); }
1077:
1078: if(fgets(str,81,stream)) { /* flags #2 */
1079: if(strchr(str,'-')) /* remove flags */
1080: useron.flags2&=~aftol(str);
1081: else /* add flags */
1082: useron.flags2|=aftol(str);
1083: putuserrec(useron.number,U_FLAGS2,8,ultoa(useron.flags2,tmp,16)); }
1084:
1085: if(fgets(str,81,stream)) { /* exemptions */
1086: if(strchr(str,'-'))
1087: useron.exempt&=~aftol(str);
1088: else
1089: useron.exempt|=aftol(str);
1090: putuserrec(useron.number,U_EXEMPT,8,ultoa(useron.exempt,tmp,16)); }
1091: if(fgets(str,81,stream)) { /* restrictions */
1092: if(strchr(str,'-'))
1093: useron.rest&=~aftol(str);
1094: else
1095: useron.rest|=aftol(str);
1096: putuserrec(useron.number,U_REST,8,ultoa(useron.rest,tmp,16)); }
1097: if(fgets(str,81,stream)) { /* Expiration date */
1098: if(isxdigit(str[0]))
1099: putuserrec(useron.number,U_EXPIRE,8,str); }
1100: if(fgets(str,81,stream)) { /* additional minutes */
1101: mod=atol(str);
1102: if(mod) {
1103: sprintf(str,"Minute Adjustment: %s",ultoac(mod,tmp));
1104: logline("*+",str);
1105: useron.min=adjustuserrec(useron.number,U_MIN,10,mod); } }
1106:
1107: if(fgets(str,81,stream)) { /* flags #3 */
1108: if(strchr(str,'-')) /* remove flags */
1109: useron.flags3&=~aftol(str);
1110: else /* add flags */
1111: useron.flags3|=aftol(str);
1112: putuserrec(useron.number,U_FLAGS3,8,ultoa(useron.flags3,tmp,16)); }
1113:
1114: if(fgets(str,81,stream)) { /* flags #4 */
1115: if(strchr(str,'-')) /* remove flags */
1116: useron.flags4&=~aftol(str);
1117: else /* add flags */
1118: useron.flags4|=aftol(str);
1119: putuserrec(useron.number,U_FLAGS4,8,ultoa(useron.flags4,tmp,16)); }
1120:
1121: if(fgets(str,81,stream)) { /* flags #1 to REMOVE only */
1122: useron.flags1&=~aftol(str);
1123: putuserrec(useron.number,U_FLAGS1,8,ultoa(useron.flags1,tmp,16)); }
1124: if(fgets(str,81,stream)) { /* flags #2 to REMOVE only */
1125: useron.flags2&=~aftol(str);
1126: putuserrec(useron.number,U_FLAGS2,8,ultoa(useron.flags2,tmp,16)); }
1127: if(fgets(str,81,stream)) { /* flags #3 to REMOVE only */
1128: useron.flags3&=~aftol(str);
1129: putuserrec(useron.number,U_FLAGS3,8,ultoa(useron.flags3,tmp,16)); }
1130: if(fgets(str,81,stream)) { /* flags #4 to REMOVE only */
1131: useron.flags4&=~aftol(str);
1132: putuserrec(useron.number,U_FLAGS4,8,ultoa(useron.flags4,tmp,16)); }
1133: if(fgets(str,81,stream)) { /* exemptions to remove */
1134: useron.exempt&=~aftol(str);
1135: putuserrec(useron.number,U_EXEMPT,8,ultoa(useron.exempt,tmp,16)); }
1136: if(fgets(str,81,stream)) { /* restrictions to remove */
1137: useron.rest&=~aftol(str);
1138: putuserrec(useron.number,U_REST,8,ultoa(useron.rest,tmp,16)); }
1139:
1140: fclose(stream);
1141: remove(path); }
1142: }
1143:
1144: /****************************************************************************/
1145: /* This is the external programs (doors) section of the bbs */
1146: /* Return 1 if no externals available, 0 otherwise. */
1147: /****************************************************************************/
1148: char xtrn_sec()
1149: {
1150: char str[256];
1151: int file,j,k,xsec,*usrxtrn,usrxtrns,*usrxsec,usrxsecs;
1152: uint i;
1153:
1154: if(!total_xtrns || !total_xtrnsecs) {
1155: bputs(text[NoXtrnPrograms]);
1156: return(1); }
1157:
1158: if((usrxtrn=(int *)MALLOC(total_xtrns*sizeof(int)))==NULL) {
1159: errormsg(WHERE,ERR_ALLOC,nulstr,total_xtrns);
1160: return(1); }
1161: if((usrxsec=(int *)MALLOC(total_xtrnsecs*sizeof(int)))==NULL) {
1162: errormsg(WHERE,ERR_ALLOC,nulstr,total_xtrnsecs);
1163: FREE(usrxtrn);
1164: return(1); }
1165:
1166: while(online) {
1167: for(i=0,usrxsecs=0;i<total_xtrnsecs;i++)
1168: if(chk_ar(xtrnsec[i]->ar,useron))
1169: usrxsec[usrxsecs++]=i;
1170: if(!usrxsecs) {
1171: bputs(text[NoXtrnPrograms]);
1172: FREE(usrxtrn);
1173: FREE(usrxsec);
1174: return(1); }
1175: if(usrxsecs>1) {
1176: sprintf(str,"%sMENU\\XTRN_SEC.*",text_dir);
1177: if(fexist(str)) {
1178: menu("XTRN_SEC");
1179: xsec=getnum(usrxsecs);
1180: if(xsec<=0)
1181: break;
1182: xsec--;
1183: xsec=usrxsec[xsec]; }
1184: else {
1185: for(i=0;i<total_xtrnsecs;i++)
1186: uselect(1,i,"External Program Section"
1187: ,xtrnsec[i]->name,xtrnsec[i]->ar);
1188: xsec=uselect(0,0,0,0,0); }
1189: if(xsec==-1)
1190: break; }
1191: else
1192: xsec=0;
1193:
1194: while(!chk_ar(xtrnsec[xsec]->ar,useron))
1195: xsec++;
1196:
1197: if(xsec>=total_xtrnsecs) {
1198: bputs(text[NoXtrnPrograms]);
1199: FREE(usrxtrn);
1200: FREE(usrxsec);
1201: return(1); }
1202:
1203: while(online) {
1204: for(i=0,usrxtrns=0;i<total_xtrns; i++) {
1205: if(xtrn[i]->sec!=xsec)
1206: continue;
1207: if(xtrn[i]->misc&EVENTONLY)
1208: continue;
1209: if(!chk_ar(xtrn[i]->ar,useron))
1210: continue;
1211: usrxtrn[usrxtrns++]=i; }
1212: if(!usrxtrns) {
1213: bputs(text[NoXtrnPrograms]);
1214: pause();
1215: break; }
1216: sprintf(str,"%sMENU\\XTRN%u.*",text_dir,xsec+1);
1217: if(fexist(str)) {
1218: sprintf(str,"XTRN%u",xsec+1);
1219: menu(str); }
1220: else {
1221: bprintf(text[XtrnProgLstHdr],xtrnsec[xsec]->name);
1222: bputs(text[XtrnProgLstTitles]);
1223: if(usrxtrns>=10) {
1224: bputs(" ");
1225: bputs(text[XtrnProgLstTitles]); }
1226: CRLF;
1227: bputs(text[XtrnProgLstUnderline]);
1228: if(usrxtrns>=10) {
1229: bputs(" ");
1230: bputs(text[XtrnProgLstUnderline]); }
1231: CRLF;
1232: if(usrxtrns>=10)
1233: j=(usrxtrns/2)+(usrxtrns&1);
1234: else
1235: j=usrxtrns;
1236: for(i=0;i<j && !msgabort();i++) {
1237: bprintf(text[XtrnProgLstFmt],i+1
1238: ,xtrn[usrxtrn[i]]->name,xtrn[usrxtrn[i]]->cost);
1239: if(usrxtrns>=10) {
1240: k=(usrxtrns/2)+i+(usrxtrns&1);
1241: if(k<usrxtrns) {
1242: bputs(" ");
1243: bprintf(text[XtrnProgLstFmt],k+1
1244: ,xtrn[usrxtrn[k]]->name
1245: ,xtrn[usrxtrn[k]]->cost); } }
1246: CRLF; }
1247: ASYNC;
1248: mnemonics(text[WhichXtrnProg]); }
1249: getnodedat(node_num,&thisnode,1);
1250: thisnode.aux=0; /* aux is 0, only if at menu */
1251: putnodedat(node_num,thisnode);
1252: action=NODE_XTRN;
1253: SYNC;
1254: if((j=getnum(usrxtrns))<1)
1255: break;
1256: exec_xtrn(usrxtrn[j-1]); }
1257: if(usrxsecs<2)
1258: break; }
1259: FREE(usrxtrn);
1260: FREE(usrxsec);
1261: return(0);
1262: }
1263:
1264: /****************************************************************************/
1265: /* This function handles configured external program execution. */
1266: /****************************************************************************/
1267: void exec_xtrn(uint xtrnnum)
1268: {
1269: char str[256],str2[256],path[256],dropdir[128],name[32],c,e,mode;
1270: int file;
1271: uint i;
1272: long mod;
1273: ulong tleft;
1274: FILE *stream;
1275: node_t node;
1276: time_t start,end;
1277:
1278:
1279: if(!chk_ar(xtrn[xtrnnum]->run_ar,useron)
1280: || !chk_ar(xtrnsec[xtrn[xtrnnum]->sec]->ar,useron)) {
1281: bputs(text[CantRunThatProgram]);
1282: return; }
1283:
1284: if(xtrn[xtrnnum]->cost && !(useron.exempt&FLAG('X'))) { /* costs */
1285: if(xtrn[xtrnnum]->cost>useron.cdt+useron.freecdt) {
1286: bputs(text[NotEnoughCredits]);
1287: pause();
1288: return; }
1289: subtract_cdt(xtrn[xtrnnum]->cost); }
1290:
1291: if(!(xtrn[xtrnnum]->misc&MULTIUSER)) {
1292: for(i=1;i<=sys_nodes;i++) {
1293: getnodedat(i,&node,0);
1294: c=i;
1295: if((node.status==NODE_INUSE || node.status==NODE_QUIET)
1296: && node.action==NODE_XTRN && node.aux==(xtrnnum+1)) {
1297: if(node.status==NODE_QUIET) {
1298: strcpy(str,sys_guru);
1299: c=sys_nodes+1; }
1300: else if(node.misc&NODE_ANON)
1301: strcpy(str,"UNKNOWN USER");
1302: else
1303: username(node.useron,str);
1304: bprintf(text[UserRunningXtrn],str
1305: ,xtrn[xtrnnum]->name,c);
1306: pause();
1307: break; } }
1308: if(i<=sys_nodes)
1309: return; }
1310:
1311: sprintf(str,"%s\\",xtrn[xtrnnum]->path);
1312: strcpy(path,xtrn[xtrnnum]->misc&STARTUPDIR ? str : node_dir);
1313: strcpy(dropdir,xtrn[xtrnnum]->misc&STARTUPDIR ? str : node_dir);
1314:
1315: switch(xtrn[xtrnnum]->type) {
1316: case XTRN_WWIV:
1317: strcat(path,"CHAIN.TXT");
1318: break;
1319: case XTRN_GAP:
1320: strcat(path,"DOOR.SYS");
1321: break;
1322: case XTRN_RBBS:
1323: sprintf(str,"DORINFO%X.DEF",node_num);
1324: strcat(path,str);
1325: break;
1326: case XTRN_RBBS1:
1327: strcat(path,"DORINFO1.DEF");
1328: break;
1329: case XTRN_WILDCAT:
1330: strcat(path,"CALLINFO.BBS");
1331: break;
1332: case XTRN_PCBOARD:
1333: strcat(path,"PCBOARD.SYS");
1334: break;
1335: case XTRN_UTI:
1336: strcat(path,"UTIDOOR.TXT");
1337: break;
1338: case XTRN_SR:
1339: strcat(path,"DOORFILE.SR");
1340: break;
1341: default:
1342: strcat(path,"XTRN.DAT");
1343: break; }
1344: getnodedat(node_num,&thisnode,1);
1345: thisnode.aux=xtrnnum+1;
1346: thisnode.action=NODE_XTRN;
1347: putnodedat(node_num,thisnode);
1348:
1349: if(xtrn[xtrnnum]->misc&REALNAME)
1350: strcpy(name,useron.name);
1351: else
1352: strcpy(name,useron.alias);
1353:
1354: gettimeleft();
1355: tleft=timeleft+(xtrn[xtrnnum]->textra*60);
1356: if(xtrn[xtrnnum]->maxtime && tleft>xtrn[xtrnnum]->maxtime)
1357: tleft=(xtrn[xtrnnum]->maxtime*60);
1358: xtrndat(name,dropdir,xtrn[xtrnnum]->type,tleft);
1359: if(!online)
1360: return;
1361: sprintf(str,"Ran external: %s",xtrn[xtrnnum]->name);
1362: logline("X-",str);
1363: if(xtrn[xtrnnum]->cmd[0]!='*' && sys_status&SS_LOGOPEN) {
1364: close(logfile);
1365: sys_status&=~SS_LOGOPEN; }
1366:
1367: sprintf(str,"%sINTRSBBS.DAT"
1368: ,xtrn[xtrnnum]->path[0] ? xtrn[xtrnnum]->path : node_dir);
1369: remove(str);
1370: sprintf(str,"%sHANGUP.NOW",node_dir);
1371: remove(str);
1372: sprintf(str,"%sFILE\\%04u.DWN",data_dir,useron.number);
1373: remove(str);
1374:
1375: mode=0; /* EX_CC */
1376: if(xtrn[xtrnnum]->misc&IO_INTS)
1377: mode|=(EX_OUTR|EX_INR|EX_OUTL);
1378: if(xtrn[xtrnnum]->misc&WWIVCOLOR)
1379: mode|=EX_WWIV;
1380: if(xtrn[xtrnnum]->misc&SWAP)
1381: mode|=EX_SWAP;
1382: if(xtrn[xtrnnum]->misc&MODUSERDAT) { /* Delete MODUSER.DAT */
1383: sprintf(str,"%sMODUSER.DAT",dropdir); /* if for some weird */
1384: remove(str); } /* reason it's there */
1385:
1386: if(xtrn[xtrnnum]->path[0]) {
1387: if(xtrn[xtrnnum]->path[1]==':') /* drive letter specified */
1388: setdisk(toupper(xtrn[xtrnnum]->path[0])-'A');
1389: if(chdir(xtrn[xtrnnum]->path))
1390: errormsg(WHERE,ERR_CHDIR,xtrn[xtrnnum]->path,0); }
1391:
1392: start=time(NULL);
1393: external(cmdstr(xtrn[xtrnnum]->cmd,path,dropdir,NULL),mode);
1394: end=time(NULL);
1395: if(xtrn[xtrnnum]->misc&FREETIME)
1396: starttime+=end-start;
1397: if(xtrn[xtrnnum]->clean[0]) {
1398: if(xtrn[xtrnnum]->path[0]) {
1399: if(xtrn[xtrnnum]->path[1]==':') /* drive letter specified */
1400: setdisk(toupper(xtrn[xtrnnum]->path[0])-'A');
1401: if(chdir(xtrn[xtrnnum]->path))
1402: errormsg(WHERE,ERR_CHDIR,xtrn[xtrnnum]->path,0); }
1403: external(cmdstr(xtrn[xtrnnum]->clean,path,nulstr,NULL)
1404: ,mode&~EX_INR); }
1405: /* Re-open the logfile */
1406: if(!(sys_status&SS_LOGOPEN)) {
1407: sprintf(str,"%sNODE.LOG",node_dir);
1408: if((logfile=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1)
1409: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_APPEND);
1410: else
1411: sys_status|=SS_LOGOPEN; }
1412:
1413: sprintf(str,"%sFILE\\%04u.DWN",data_dir,useron.number);
1414: batch_add_list(str);
1415:
1416: sprintf(str,"%sHANGUP.NOW",node_dir);
1417: if(fexist(str)) {
1418: remove(str);
1419: hangup(); }
1420: if(online==ON_REMOTE) {
1421: checkline();
1422: if(!online) {
1423: sprintf(str,"%sHUNGUP.LOG",data_dir);
1424: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
1425: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_APPEND);
1426: return; }
1427: getnodedat(node_num,&thisnode,0);
1428: now=time(NULL);
1429: sprintf(str,hungupstr,useron.alias,xtrn[thisnode.aux-1]->name
1430: ,timestr(&now));
1431: write(file,str,strlen(str));
1432: close(file); } }
1433: if(xtrn[xtrnnum]->misc&MODUSERDAT) { /* Modify user data */
1434: moduserdat(xtrnnum);
1435: statusline(); }
1436:
1.1.1.2 ! root 1437: getnodedat(node_num,&thisnode,1);
! 1438: thisnode.aux=0; /* aux is 0, only if at menu */
! 1439: putnodedat(node_num,thisnode);
1.1 root 1440: }
1441:
1442: /****************************************************************************/
1443: /* This function will execute an external program if it is configured to */
1444: /* run during the event specified. */
1445: /****************************************************************************/
1446: void user_event(char event)
1447: {
1448: uint i;
1449:
1450: for(i=0;i<total_xtrns;i++) {
1451: if(xtrn[i]->event!=event)
1452: continue;
1453: if(!chk_ar(xtrn[i]->ar,useron)
1454: || !chk_ar(xtrnsec[xtrn[i]->sec]->ar,useron))
1455: continue;
1456: exec_xtrn(i); }
1457: }
1458:
1459:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.