![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scfgsave.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 scfgsave.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* scfgsave.c */
2:
3: /* Synchronet configuration file save routines */
4:
1.1.1.2 ! root 5: /* $Id: scfgsave.c,v 1.55 2009/11/12 04:34:41 rswindell Exp $ */
1.1 root 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: * *
1.1.1.2 ! root 11: * Copyright 2009 Rob Swindell - http://www.synchro.net/copyright.html *
1.1 root 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:
40: BOOL no_msghdr=FALSE,all_msghdr=FALSE;
41:
42: static char nulbuf[256]={0};
43: static int pslen;
44: #define put_int(var,stream) fwrite(&var,1,sizeof(var),stream)
45: #define put_str(var,stream) { pslen=strlen(var); \
46: fwrite(var,1,pslen > sizeof(var) \
47: ? sizeof(var) : pslen ,stream); \
48: fwrite(nulbuf,1,pslen > sizeof(var) \
49: ? 0 : sizeof(var)-pslen,stream); }
50:
51: /****************************************************************************/
52: /****************************************************************************/
53: BOOL DLLCALL save_cfg(scfg_t* cfg, int backup_level)
54: {
55: int i;
56:
57: if(cfg->prepped)
58: return(FALSE);
59:
60: for(i=0;i<cfg->sys_nodes;i++) {
61: if(cfg->node_path[i][0]==0)
62: sprintf(cfg->node_path[i],"../node%d",i+1);
63: cfg->node_num=i+1;
64: if(!write_node_cfg(cfg,backup_level))
65: return(FALSE);
66: }
67: if(!write_main_cfg(cfg,backup_level))
68: return(FALSE);
69: if(!write_msgs_cfg(cfg,backup_level))
70: return(FALSE);
71: if(!write_file_cfg(cfg,backup_level))
72: return(FALSE);
73: if(!write_chat_cfg(cfg,backup_level))
74: return(FALSE);
75: if(!write_xtrn_cfg(cfg,backup_level))
76: return(FALSE);
77:
78: return(TRUE);
79: }
80:
81: BOOL DLLCALL fcopy(char* src, char* dest)
82: {
83: int ch;
84: ulong count=0;
85: FILE* in;
86: FILE* out;
87: BOOL success=TRUE;
88:
89: if((in=fopen(src,"rb"))==NULL)
90: return(FALSE);
91: if((out=fopen(dest,"wb"))==NULL) {
92: fclose(in);
93: return(FALSE);
94: }
95:
96: while(!feof(in)) {
97: if((ch=fgetc(in))==EOF)
98: break;
99: if(fputc(ch,out)==EOF) {
100: success=FALSE;
101: break;
102: }
103: if(((count++)%(32*1024))==0)
104: YIELD();
105: }
106:
107: fclose(in);
108: fclose(out);
109:
110: return(success);
111: }
112:
113: BOOL DLLCALL fcompare(char* fn1, char* fn2)
114: {
115: FILE* fp1;
116: FILE* fp2;
117: BOOL success=TRUE;
118:
119: if(flength(fn1) != flength(fn2))
120: return(FALSE);
121: if((fp1=fopen(fn1,"rb"))==NULL)
122: return(FALSE);
123: if((fp2=fopen(fn2,"rb"))==NULL) {
124: fclose(fp1);
125: return(FALSE);
126: }
127:
128: while(!feof(fp1) && success) {
129: if(fgetc(fp1) != fgetc(fp2))
130: success=FALSE;
131: }
132:
133: fclose(fp1);
134: fclose(fp2);
135:
136: return(success);
137: }
138:
139:
140: /****************************************************************************/
141: /****************************************************************************/
142: BOOL DLLCALL backup(char *fname, int backup_level, BOOL ren)
143: {
144: char oldname[MAX_PATH+1];
145: char newname[MAX_PATH+1];
146: char* ext;
147: int i;
148: int len;
149:
150: if((ext=strrchr(fname,'.'))==NULL)
151: ext="";
152:
153: len=strlen(fname)-strlen(ext);
154:
155: for(i=backup_level;i;i--) {
156: safe_snprintf(newname,sizeof(newname),"%.*s.%d%s",len,fname,i-1,ext);
157: if(i==backup_level)
158: if(fexist(newname) && remove(newname)!=0)
159: return(FALSE);
160: if(i==1) {
161: if(ren == TRUE) {
162: if(rename(fname,newname)!=0)
163: return(FALSE);
164: } else
165: if(!fcopy(fname,newname))
166: return(FALSE);
167: continue;
168: }
169: safe_snprintf(oldname,sizeof(oldname),"%.*s.%d%s",len,fname,i-2,ext);
170: if(fexist(oldname) && rename(oldname,newname)!=0)
171: return(FALSE);
172: }
173:
174: return(TRUE);
175: }
176:
177: /****************************************************************************/
178: /****************************************************************************/
179: BOOL DLLCALL write_node_cfg(scfg_t* cfg, int backup_level)
180: {
181: char str[MAX_PATH+1];
182: int i,file;
1.1.1.2 ! root 183: uint16_t n;
1.1 root 184: FILE *stream;
185:
186: if(cfg->prepped)
187: return(FALSE);
188:
189: if(cfg->node_num<1 || cfg->node_num>MAX_NODES)
190: return(FALSE);
191:
192: SAFECOPY(str,cfg->node_path[cfg->node_num-1]);
193: prep_dir(cfg->ctrl_dir,str,sizeof(str));
194: md(str);
195: strcat(str,"node.cnf");
196: backup(str, backup_level, TRUE);
197:
198: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1
199: || (stream=fdopen(file,"wb"))==NULL) {
200: return(FALSE);
201: }
202: setvbuf(stream,NULL,_IOFBF,2048);
203:
204: put_int(cfg->node_num,stream);
205: put_str(cfg->node_name,stream);
206: put_str(cfg->node_phone,stream);
207: put_str(cfg->node_comspec,stream); /* Was node_logon */
208: put_int(cfg->node_misc,stream);
209: put_int(cfg->node_ivt,stream);
210: put_int(cfg->node_swap,stream);
211: #if 0
212: if(cfg->node_swapdir[0]) {
213: backslash(cfg->node_swapdir);
214: md(cfg->node_swapdir); /* make sure it's a valid directory */
215: }
216: #endif
217: put_str(cfg->node_swapdir,stream);
218: put_int(cfg->node_valuser,stream);
219: put_int(cfg->node_minbps,stream);
220: put_str(cfg->node_arstr,stream);
221: put_int(cfg->node_dollars_per_call,stream);
222: put_str(cfg->node_editor,stream);
223: put_str(cfg->node_viewer,stream);
224: put_str(cfg->node_daily,stream);
225: put_int(cfg->node_scrnlen,stream);
226: put_int(cfg->node_scrnblank,stream);
227: backslash(cfg->ctrl_dir);
228: put_str(cfg->ctrl_dir,stream);
229: backslash(cfg->text_dir);
230: put_str(cfg->text_dir,stream);
231: backslash(cfg->temp_dir);
232: put_str(cfg->temp_dir,stream);
233: for(i=0;i<10;i++)
234: put_str(cfg->wfc_cmd[i],stream);
235: for(i=0;i<12;i++)
236: put_str(cfg->wfc_scmd[i],stream);
237: put_str(cfg->mdm_hang,stream);
238: put_int(cfg->node_sem_check,stream);
239: put_int(cfg->node_stat_check,stream);
240: put_str(cfg->scfg_cmd,stream);
241: put_int(cfg->sec_warn,stream);
242: put_int(cfg->sec_hangup,stream);
243: n=0;
244: for(i=0;i<188;i++) /* unused init to NULL */
245: fwrite(&n,1,2,stream);
246: n=0xffff; /* unused init to 0xff */
247: for(i=0;i<256;i++)
248: fwrite(&n,1,2,stream);
249: put_int(cfg->com_port,stream);
250: put_int(cfg->com_irq,stream);
251: put_int(cfg->com_base,stream);
252: put_int(cfg->com_rate,stream);
253: put_int(cfg->mdm_misc,stream);
254: put_str(cfg->mdm_init,stream);
255: put_str(cfg->mdm_spec,stream);
256: put_str(cfg->mdm_term,stream);
257: put_str(cfg->mdm_dial,stream);
258: put_str(cfg->mdm_offh,stream);
259: put_str(cfg->mdm_answ,stream);
260: put_int(cfg->mdm_reinit,stream);
261: put_int(cfg->mdm_ansdelay,stream);
262: put_int(cfg->mdm_rings,stream);
263: put_int(cfg->mdm_results,stream);
264: for(i=0;i<cfg->mdm_results;i++) {
265: put_int(cfg->mdm_result[i].code,stream);
266: put_int(cfg->mdm_result[i].rate,stream);
267: put_int(cfg->mdm_result[i].cps,stream);
268: put_str(cfg->mdm_result[i].str,stream);
269: }
270: fclose(stream);
271:
272: return(TRUE);
273: }
274:
275: /****************************************************************************/
276: /****************************************************************************/
277: BOOL DLLCALL write_main_cfg(scfg_t* cfg, int backup_level)
278: {
279: char str[MAX_PATH+1],c=0;
280: int file;
1.1.1.2 ! root 281: ushort i,j;
! 282: uint16_t n;
1.1 root 283: FILE *stream;
284:
285: if(cfg->prepped)
286: return(FALSE);
287:
288: SAFEPRINTF(str,"%smain.cnf",cfg->ctrl_dir);
289: backup(str, backup_level, TRUE);
290:
291: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1
292: || (stream=fdopen(file,"wb"))==NULL) {
293: return(FALSE);
294: }
295: setvbuf(stream,NULL,_IOFBF,2048);
296:
297: put_str(cfg->sys_name,stream);
298: put_str(cfg->sys_id,stream);
299: put_str(cfg->sys_location,stream);
300: put_str(cfg->sys_phonefmt,stream);
301: put_str(cfg->sys_op,stream);
302: put_str(cfg->sys_guru,stream);
303: put_str(cfg->sys_pass,stream);
304: put_int(cfg->sys_nodes,stream);
305: for(i=0;i<cfg->sys_nodes;i++)
306: put_str(cfg->node_path[i],stream);
307: backslash(cfg->data_dir);
308: put_str(cfg->data_dir,stream);
309:
310: backslash(cfg->exec_dir);
311: put_str(cfg->exec_dir,stream);
312: put_str(cfg->sys_logon,stream);
313: put_str(cfg->sys_logout,stream);
314: put_str(cfg->sys_daily,stream);
315: put_int(cfg->sys_timezone,stream);
316: put_int(cfg->sys_misc,stream);
317: put_int(cfg->sys_lastnode,stream);
318: put_int(cfg->sys_autonode,stream);
319: put_int(cfg->uq,stream);
320: put_int(cfg->sys_pwdays,stream);
321: put_int(cfg->sys_deldays,stream);
322: put_int(cfg->sys_exp_warn,stream);
323: put_int(cfg->sys_autodel,stream);
324: put_int(cfg->sys_def_stat,stream);
325: put_str(cfg->sys_chat_arstr,stream);
326: put_int(cfg->cdt_min_value,stream);
327: put_int(cfg->max_minutes,stream);
328: put_int(cfg->cdt_per_dollar,stream);
329: put_str(cfg->new_pass,stream);
330: put_str(cfg->new_magic,stream);
331: put_str(cfg->new_sif,stream);
332: put_str(cfg->new_sof,stream);
333:
334: put_int(cfg->new_level,stream);
335: put_int(cfg->new_flags1,stream);
336: put_int(cfg->new_flags2,stream);
337: put_int(cfg->new_flags3,stream);
338: put_int(cfg->new_flags4,stream);
339: put_int(cfg->new_exempt,stream);
340: put_int(cfg->new_rest,stream);
341: put_int(cfg->new_cdt,stream);
342: put_int(cfg->new_min,stream);
343: put_str(cfg->new_xedit,stream);
344: put_int(cfg->new_expire,stream);
345: if(cfg->new_shell>=cfg->total_shells)
346: cfg->new_shell=0;
347: put_int(cfg->new_shell,stream);
348: put_int(cfg->new_misc,stream);
349: put_int(cfg->new_prot,stream);
350: put_int(cfg->new_install,stream);
351: n=0;
352: for(i=0;i<7;i++)
353: put_int(n,stream);
354:
355: put_int(cfg->expired_level,stream);
356: put_int(cfg->expired_flags1,stream);
357: put_int(cfg->expired_flags2,stream);
358: put_int(cfg->expired_flags3,stream);
359: put_int(cfg->expired_flags4,stream);
360: put_int(cfg->expired_exempt,stream);
361: put_int(cfg->expired_rest,stream);
362:
363: put_str(cfg->logon_mod,stream);
364: put_str(cfg->logoff_mod,stream);
365: put_str(cfg->newuser_mod,stream);
366: put_str(cfg->login_mod,stream);
367: put_str(cfg->logout_mod,stream);
368: put_str(cfg->sync_mod,stream);
369: put_str(cfg->expire_mod,stream);
370: put_int(cfg->ctrlkey_passthru,stream);
371: put_str(cfg->mods_dir,stream);
372: put_str(cfg->logs_dir,stream);
373:
374: put_int(c,stream);
375: n=0;
376: for(i=0;i<158;i++)
377: put_int(n,stream);
378: n=0xffff;
379: for(i=0;i<254;i++)
380: put_int(n,stream);
381:
382: put_int(cfg->user_backup_level,stream);
383: put_int(cfg->mail_backup_level,stream);
384:
385: n=0;
386: for(i=0;i<10;i++) {
387: put_int(cfg->val_level[i],stream);
388: put_int(cfg->val_expire[i],stream);
389: put_int(cfg->val_flags1[i],stream);
390: put_int(cfg->val_flags2[i],stream);
391: put_int(cfg->val_flags3[i],stream);
392: put_int(cfg->val_flags4[i],stream);
393: put_int(cfg->val_cdt[i],stream);
394: put_int(cfg->val_exempt[i],stream);
395: put_int(cfg->val_rest[i],stream);
396: for(j=0;j<8;j++)
397: put_int(n,stream); }
398:
399: c=0;
400: for(i=0;i<100 && !feof(stream);i++) {
401: put_int(cfg->level_timeperday[i],stream);
402: put_int(cfg->level_timepercall[i],stream);
403: put_int(cfg->level_callsperday[i],stream);
404: put_int(cfg->level_freecdtperday[i],stream);
405: put_int(cfg->level_linespermsg[i],stream);
406: put_int(cfg->level_postsperday[i],stream);
407: put_int(cfg->level_emailperday[i],stream);
408: put_int(cfg->level_misc[i],stream);
409: put_int(cfg->level_expireto[i],stream);
410: put_int(c,stream);
411: for(j=0;j<5;j++)
412: put_int(n,stream); }
413:
414: /* Command Shells */
415:
416: put_int(cfg->total_shells,stream);
417: for(i=0;i<cfg->total_shells;i++) {
418: put_str(cfg->shell[i]->name,stream);
419: put_str(cfg->shell[i]->code,stream);
420: put_str(cfg->shell[i]->arstr,stream);
421: put_int(cfg->shell[i]->misc,stream);
422: n=0;
423: for(j=0;j<8;j++)
424: put_int(n,stream);
425: }
426:
427: fclose(stream);
428:
429: return(TRUE);
430: }
431:
432: /****************************************************************************/
433: /****************************************************************************/
434: BOOL DLLCALL write_msgs_cfg(scfg_t* cfg, int backup_level)
435: {
436: char str[MAX_PATH+1],c;
437: char dir[LEN_DIR+1]="";
438: int i,j,k,file;
1.1.1.2 ! root 439: uint16_t n;
! 440: int32_t l;
1.1 root 441: FILE *stream;
442: smb_t smb;
443:
444: if(cfg->prepped)
445: return(FALSE);
446:
447: SAFEPRINTF(str,"%smsgs.cnf",cfg->ctrl_dir);
448: backup(str, backup_level, TRUE);
449:
450: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1
451: || (stream=fdopen(file,"wb"))==NULL) {
452: return(FALSE);
453: }
454: setvbuf(stream,NULL,_IOFBF,2048);
455:
456: put_int(cfg->max_qwkmsgs,stream);
457: put_int(cfg->mail_maxcrcs,stream);
458: put_int(cfg->mail_maxage,stream);
459: put_str(cfg->preqwk_arstr,stream);
460: put_int(cfg->smb_retry_time,stream);
1.1.1.2 ! root 461: put_int(cfg->max_qwkmsgage,stream);
1.1 root 462: n=0;
1.1.1.2 ! root 463: for(i=0;i<233;i++)
1.1 root 464: put_int(n,stream);
1.1.1.2 ! root 465: put_int(cfg->msg_misc,stream);
1.1 root 466: n=0xffff;
1.1.1.2 ! root 467: for(i=0;i<255;i++)
1.1 root 468: put_int(n,stream);
469:
470: /* Message Groups */
471:
472: put_int(cfg->total_grps,stream);
473: for(i=0;i<cfg->total_grps;i++) {
474: put_str(cfg->grp[i]->lname,stream);
475: put_str(cfg->grp[i]->sname,stream);
476: put_str(cfg->grp[i]->arstr,stream);
477: put_str(cfg->grp[i]->code_prefix,stream);
478: c=0;
479: put_int(c,stream);
480: n=0;
481: for(j=0;j<27;j++)
482: put_int(n,stream);
483: n=0xffff;
484: for(j=0;j<16;j++)
485: put_int(n,stream);
486: }
487:
488: /* Message Sub-boards */
489:
490: backslash(cfg->echomail_dir);
491:
492: str[0]=0;
493: for(i=n=0;i<cfg->total_subs;i++)
494: if(cfg->sub[i]->grp<cfg->total_grps) /* total VALID sub-boards */
495: n++;
496: put_int(n,stream);
497: for(i=0;i<cfg->total_subs;i++) {
498: if(cfg->sub[i]->grp>=cfg->total_grps) /* skip bogus group numbers */
499: continue;
500: put_int(cfg->sub[i]->grp,stream);
501: put_str(cfg->sub[i]->lname,stream);
502: put_str(cfg->sub[i]->sname,stream);
503: put_str(cfg->sub[i]->qwkname,stream);
504: put_str(cfg->sub[i]->code_suffix,stream);
505: #if 1
506: if(cfg->sub[i]->data_dir[0]) {
507: backslash(cfg->sub[i]->data_dir);
508: md(cfg->sub[i]->data_dir);
509: }
510: #endif
511: put_str(cfg->sub[i]->data_dir,stream);
512: put_str(cfg->sub[i]->arstr,stream);
513: put_str(cfg->sub[i]->read_arstr,stream);
514: put_str(cfg->sub[i]->post_arstr,stream);
515: put_str(cfg->sub[i]->op_arstr,stream);
516: l=(cfg->sub[i]->misc&(~SUB_HDRMOD)); /* Don't write mod bit */
517: put_int(l,stream);
518: put_str(cfg->sub[i]->tagline,stream);
519: put_str(cfg->sub[i]->origline,stream);
520: put_str(cfg->sub[i]->post_sem,stream);
521: put_str(cfg->sub[i]->newsgroup,stream);
522: put_int(cfg->sub[i]->faddr,stream);
523: put_int(cfg->sub[i]->maxmsgs,stream);
524: put_int(cfg->sub[i]->maxcrcs,stream);
525: put_int(cfg->sub[i]->maxage,stream);
526: put_int(cfg->sub[i]->ptridx,stream);
527: put_str(cfg->sub[i]->mod_arstr,stream);
528: put_int(cfg->sub[i]->qwkconf,stream);
529: c=0;
530: put_int(c,stream);
531: n=0;
532: for(k=0;k<26;k++)
533: put_int(n,stream);
534:
535: if(all_msghdr || (cfg->sub[i]->misc&SUB_HDRMOD && !no_msghdr)) {
536: if(!cfg->sub[i]->data_dir[0])
537: SAFEPRINTF(smb.file,"%ssubs",cfg->data_dir);
538: else
539: SAFECOPY(smb.file,cfg->sub[i]->data_dir);
540: prep_dir(cfg->ctrl_dir,smb.file,sizeof(smb.file));
541: SAFEPRINTF2(str,"%s%s"
542: ,cfg->grp[cfg->sub[i]->grp]->code_prefix
543: ,cfg->sub[i]->code_suffix);
544: strlwr(str);
545: strcat(smb.file,str);
546: if(smb_open(&smb)!=0) {
547: /* errormsg(WHERE,ERR_OPEN,smb.file,x); */
548: continue;
549: }
550: if(!filelength(fileno(smb.shd_fp))) {
551: smb.status.max_crcs=cfg->sub[i]->maxcrcs;
552: smb.status.max_msgs=cfg->sub[i]->maxmsgs;
553: smb.status.max_age=cfg->sub[i]->maxage;
554: smb.status.attr=cfg->sub[i]->misc&SUB_HYPER ? SMB_HYPERALLOC :0;
555: if(smb_create(&smb)!=0)
556: /* errormsg(WHERE,ERR_CREATE,smb.file,x) */;
557: smb_close(&smb);
558: continue;
559: }
560: if(smb_locksmbhdr(&smb)!=0) {
561: smb_close(&smb);
562: /* errormsg(WHERE,ERR_LOCK,smb.file,x) */;
563: continue;
564: }
565: if(smb_getstatus(&smb)!=0) {
566: smb_close(&smb);
567: /* errormsg(WHERE,ERR_READ,smb.file,x) */;
568: continue;
569: }
570: if((!(cfg->sub[i]->misc&SUB_HYPER) || smb.status.attr&SMB_HYPERALLOC)
571: && smb.status.max_msgs==cfg->sub[i]->maxmsgs
572: && smb.status.max_crcs==cfg->sub[i]->maxcrcs
573: && smb.status.max_age==cfg->sub[i]->maxage) { /* No change */
574: smb_close(&smb);
575: continue;
576: }
577: smb.status.max_msgs=cfg->sub[i]->maxmsgs;
578: smb.status.max_crcs=cfg->sub[i]->maxcrcs;
579: smb.status.max_age=cfg->sub[i]->maxage;
580: if(cfg->sub[i]->misc&SUB_HYPER)
581: smb.status.attr|=SMB_HYPERALLOC;
582: if(smb_putstatus(&smb)!=0) {
583: smb_close(&smb);
584: /* errormsg(WHERE,ERR_WRITE,smb.file,x); */
585: continue;
586: }
587: smb_close(&smb);
588: }
589: }
590:
591: /* FidoNet */
592:
593: put_int(cfg->total_faddrs,stream);
594: for(i=0;i<cfg->total_faddrs;i++) {
595: put_int(cfg->faddr[i].zone,stream);
596: put_int(cfg->faddr[i].net,stream);
597: put_int(cfg->faddr[i].node,stream);
598: put_int(cfg->faddr[i].point,stream); }
599:
600: put_str(cfg->origline,stream);
601: put_str(cfg->netmail_sem,stream);
602: put_str(cfg->echomail_sem,stream);
603: backslash(cfg->netmail_dir);
604: put_str(cfg->netmail_dir,stream);
605: put_str(cfg->echomail_dir,stream);
606: backslash(cfg->fidofile_dir);
607: put_str(cfg->fidofile_dir,stream);
608: put_int(cfg->netmail_misc,stream);
609: put_int(cfg->netmail_cost,stream);
610: put_int(cfg->dflt_faddr,stream);
611: n=0;
612: for(i=0;i<28;i++)
613: put_int(n,stream);
614:
615: /* QWKnet Config */
616:
617: put_str(cfg->qnet_tagline,stream);
618:
619: put_int(cfg->total_qhubs,stream);
620: for(i=0;i<cfg->total_qhubs;i++) {
621: put_str(cfg->qhub[i]->id,stream);
622: put_int(cfg->qhub[i]->time,stream);
623: put_int(cfg->qhub[i]->freq,stream);
624: put_int(cfg->qhub[i]->days,stream);
625: put_int(cfg->qhub[i]->node,stream);
626: put_str(cfg->qhub[i]->call,stream);
627: put_str(cfg->qhub[i]->pack,stream);
628: put_str(cfg->qhub[i]->unpack,stream);
629: put_int(cfg->qhub[i]->subs,stream);
630: for(j=0;j<cfg->qhub[i]->subs;j++) {
631: put_int(cfg->qhub[i]->conf[j],stream);
1.1.1.2 ! root 632: n=(uint16_t)cfg->qhub[i]->sub[j];
! 633: put_int(n,stream);
1.1 root 634: put_int(cfg->qhub[i]->mode[j],stream); }
635: n=0;
636: for(j=0;j<32;j++)
637: put_int(n,stream); }
638: n=0;
639: for(i=0;i<32;i++)
640: put_int(n,stream);
641:
642: /* PostLink Config */
643:
644: memset(str,0,11);
645: fwrite(str,11,1,stream); /* unused, used to be site name */
646: put_int(cfg->sys_psnum,stream);
647:
648: put_int(cfg->total_phubs,stream);
649: for(i=0;i<cfg->total_phubs;i++) {
650: put_str(cfg->phub[i]->name,stream);
651: put_int(cfg->phub[i]->time,stream);
652: put_int(cfg->phub[i]->freq,stream);
653: put_int(cfg->phub[i]->days,stream);
654: put_int(cfg->phub[i]->node,stream);
655: put_str(cfg->phub[i]->call,stream);
656: n=0;
657: for(j=0;j<32;j++)
658: put_int(n,stream); }
659:
660: put_str(cfg->sys_psname,stream);
661: n=0;
662: for(i=0;i<32;i++)
663: put_int(n,stream);
664:
665: put_str(cfg->sys_inetaddr,stream); /* Internet address */
666: put_str(cfg->inetmail_sem,stream);
667: put_int(cfg->inetmail_misc,stream);
668: put_int(cfg->inetmail_cost,stream);
669: put_str(cfg->smtpmail_sem,stream);
670:
671: fclose(stream);
672:
673: /* MUST BE AT END */
674:
675: if(!no_msghdr) {
676: strcpy(dir,cfg->data_dir);
677: prep_dir(cfg->ctrl_dir,dir,sizeof(dir));
678: SAFEPRINTF(smb.file,"%smail",dir);
679: if(smb_open(&smb)!=0) {
680: return(FALSE);
681: }
682: if(!filelength(fileno(smb.shd_fp))) {
683: smb.status.max_msgs=0;
684: smb.status.max_crcs=cfg->mail_maxcrcs;
685: smb.status.max_age=cfg->mail_maxage;
686: smb.status.attr=SMB_EMAIL;
687: i=smb_create(&smb);
688: smb_close(&smb);
689: return(i==0);
690: }
691: if(smb_locksmbhdr(&smb)!=0) {
692: smb_close(&smb);
693: /* errormsg disabled. Why? ToDo */
694: /* errormsg(WHERE,ERR_LOCK,smb.file,x); */
695: return(FALSE);
696: }
697: if(smb_getstatus(&smb)!=0) {
698: smb_close(&smb);
699: /* errormsg disabled. Why? ToDo */
700: /* errormsg(WHERE,ERR_READ,smb.file,x); */
701: return(FALSE);
702: }
703: smb.status.max_msgs=0;
704: smb.status.max_crcs=cfg->mail_maxcrcs;
705: smb.status.max_age=cfg->mail_maxage;
706: if(smb_putstatus(&smb)!=0) {
707: smb_close(&smb);
708: /* errormsg disabled. Why? ToDo */
709: /* errormsg(WHERE,ERR_WRITE,smb.file,x); */
710: return(FALSE);
711: }
712: smb_close(&smb);
713: }
714:
715: return(TRUE);
716: }
717:
718:
719: /****************************************************************************/
720: /****************************************************************************/
721: BOOL DLLCALL write_file_cfg(scfg_t* cfg, int backup_level)
722: {
723: char str[MAX_PATH+1],cmd[LEN_CMD+1],c;
724: char path[MAX_PATH+1];
725: int i,j,k,file;
1.1.1.2 ! root 726: uint16_t n;
! 727: int32_t l=0;
1.1 root 728: FILE *stream;
729:
730: if(cfg->prepped)
731: return(FALSE);
732:
733: SAFEPRINTF(str,"%sfile.cnf",cfg->ctrl_dir);
734: backup(str, backup_level, TRUE);
735:
736: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1
737: || (stream=fdopen(file,"wb"))==NULL) {
738: return(FALSE);
739: }
740: setvbuf(stream,NULL,_IOFBF,2048);
741:
742: put_int(cfg->min_dspace,stream);
743: put_int(cfg->max_batup,stream);
744: put_int(cfg->max_batdn,stream);
745: put_int(cfg->max_userxfer,stream);
746: put_int(l,stream); /* unused */
747: put_int(cfg->cdt_up_pct,stream);
748: put_int(cfg->cdt_dn_pct,stream);
749: put_int(l,stream); /* unused */
750: put_str(cmd,stream);
751: put_int(cfg->leech_pct,stream);
752: put_int(cfg->leech_sec,stream);
753: put_int(cfg->file_misc,stream);
754: n=0;
755: for(i=0;i<30;i++)
756: put_int(n,stream);
757:
758: /* Extractable File Types */
759:
760: put_int(cfg->total_fextrs,stream);
761: for(i=0;i<cfg->total_fextrs;i++) {
762: put_str(cfg->fextr[i]->ext,stream);
763: put_str(cfg->fextr[i]->cmd,stream);
764: put_str(cfg->fextr[i]->arstr,stream);
765: n=0;
766: for(j=0;j<8;j++)
767: put_int(n,stream); }
768:
769: /* Compressable File Types */
770:
771: put_int(cfg->total_fcomps,stream);
772: for(i=0;i<cfg->total_fcomps;i++) {
773: put_str(cfg->fcomp[i]->ext,stream);
774: put_str(cfg->fcomp[i]->cmd,stream);
775: put_str(cfg->fcomp[i]->arstr,stream);
776: n=0;
777: for(j=0;j<8;j++)
778: put_int(n,stream); }
779:
780: /* Viewable File Types */
781:
782: put_int(cfg->total_fviews,stream);
783: for(i=0;i<cfg->total_fviews;i++) {
784: put_str(cfg->fview[i]->ext,stream);
785: put_str(cfg->fview[i]->cmd,stream);
786: put_str(cfg->fview[i]->arstr,stream);
787: n=0;
788: for(j=0;j<8;j++)
789: put_int(n,stream); }
790:
791: /* Testable File Types */
792:
793: put_int(cfg->total_ftests,stream);
794: for(i=0;i<cfg->total_ftests;i++) {
795: put_str(cfg->ftest[i]->ext,stream);
796: put_str(cfg->ftest[i]->cmd,stream);
797: put_str(cfg->ftest[i]->workstr,stream);
798: put_str(cfg->ftest[i]->arstr,stream);
799: n=0;
800: for(j=0;j<8;j++)
801: put_int(n,stream); }
802:
803: /* Download Events */
804:
805: put_int(cfg->total_dlevents,stream);
806: for(i=0;i<cfg->total_dlevents;i++) {
807: put_str(cfg->dlevent[i]->ext,stream);
808: put_str(cfg->dlevent[i]->cmd,stream);
809: put_str(cfg->dlevent[i]->workstr,stream);
810: put_str(cfg->dlevent[i]->arstr,stream);
811: n=0;
812: for(j=0;j<8;j++)
813: put_int(n,stream); }
814:
815: /* File Transfer Protocols */
816:
817: put_int(cfg->total_prots,stream);
818: for(i=0;i<cfg->total_prots;i++) {
819: put_int(cfg->prot[i]->mnemonic,stream);
820: put_str(cfg->prot[i]->name,stream);
821: put_str(cfg->prot[i]->ulcmd,stream);
822: put_str(cfg->prot[i]->dlcmd,stream);
823: put_str(cfg->prot[i]->batulcmd,stream);
824: put_str(cfg->prot[i]->batdlcmd,stream);
825: put_str(cfg->prot[i]->blindcmd,stream);
826: put_str(cfg->prot[i]->bicmd,stream);
827: put_int(cfg->prot[i]->misc,stream);
828: put_str(cfg->prot[i]->arstr,stream);
829: n=0;
830: for(j=0;j<8;j++)
831: put_int(n,stream); }
832:
833: /* Alternate File Paths */
834:
835: put_int(cfg->altpaths,stream);
836: for(i=0;i<cfg->altpaths;i++) {
837: backslash(cfg->altpath[i]);
838: fwrite(cfg->altpath[i],LEN_DIR+1,1,stream);
839: n=0;
840: for(j=0;j<8;j++)
841: put_int(n,stream); }
842:
843: /* File Libraries */
844:
845: put_int(cfg->total_libs,stream);
846: for(i=0;i<cfg->total_libs;i++) {
847: put_str(cfg->lib[i]->lname,stream);
848: put_str(cfg->lib[i]->sname,stream);
849: put_str(cfg->lib[i]->arstr,stream);
850: put_str(cfg->lib[i]->parent_path,stream);
851: put_str(cfg->lib[i]->code_prefix,stream);
852:
853: c=0;
854: put_int(c,stream);
855: n=0x0000;
856: for(j=0;j<3;j++)
857: put_int(n,stream);
858:
859: n=0xffff;
860: for(j=0;j<16;j++)
861: put_int(n,stream);
862: }
863:
864: /* File Directories */
865:
866: put_int(cfg->total_dirs,stream);
867: for(j=0;j<cfg->total_libs;j++)
868: for(i=0;i<cfg->total_dirs;i++)
869: if(cfg->dir[i]->lib==j) {
870: put_int(cfg->dir[i]->lib,stream);
871: put_str(cfg->dir[i]->lname,stream);
872: put_str(cfg->dir[i]->sname,stream);
873: put_str(cfg->dir[i]->code_suffix,stream);
874: #if 1
875: if(cfg->dir[i]->data_dir[0]) {
876: backslash(cfg->dir[i]->data_dir);
877: md(cfg->dir[i]->data_dir);
878: }
879: #endif
880: put_str(cfg->dir[i]->data_dir,stream);
881: put_str(cfg->dir[i]->arstr,stream);
882: put_str(cfg->dir[i]->ul_arstr,stream);
883: put_str(cfg->dir[i]->dl_arstr,stream);
884: put_str(cfg->dir[i]->op_arstr,stream);
885: backslash(cfg->dir[i]->path);
886: put_str(cfg->dir[i]->path,stream);
887: #if 1
888: if(cfg->dir[i]->misc&DIR_FCHK) {
889: SAFECOPY(path,cfg->dir[i]->path);
890: if(!path[0]) { /* no file storage path specified */
891: SAFEPRINTF2(str,"%s%s"
892: ,cfg->lib[cfg->dir[i]->lib]->code_prefix
893: ,cfg->dir[i]->code_suffix);
894: strlwr(str);
895: safe_snprintf(path,sizeof(path),"%sdirs/%s/"
896: ,cfg->data_dir
897: ,str);
898: }
899: else if(cfg->lib[cfg->dir[i]->lib]->parent_path[0]) {
900: SAFECOPY(path,cfg->lib[cfg->dir[i]->lib]->parent_path);
901: prep_dir(cfg->ctrl_dir,path,sizeof(path));
902: md(path);
903: backslash(path);
904: strcat(path,cfg->dir[i]->path);
905: }
906: else
907: prep_dir(cfg->ctrl_dir, path,sizeof(path));
908: md(path);
909: }
910: #endif
911:
912: put_str(cfg->dir[i]->upload_sem,stream);
913: put_int(cfg->dir[i]->maxfiles,stream);
914: put_str(cfg->dir[i]->exts,stream);
915: put_int(cfg->dir[i]->misc,stream);
916: put_int(cfg->dir[i]->seqdev,stream);
917: put_int(cfg->dir[i]->sort,stream);
918: put_str(cfg->dir[i]->ex_arstr,stream);
919: put_int(cfg->dir[i]->maxage,stream);
920: put_int(cfg->dir[i]->up_pct,stream);
921: put_int(cfg->dir[i]->dn_pct,stream);
922: c=0;
923: put_int(c,stream);
924: n=0;
925: for(k=0;k<8;k++)
926: put_int(n,stream);
927: n=0xffff;
928: for(k=0;k<16;k++)
929: put_int(n,stream);
930: }
931:
932: /* Text File Sections */
933:
934: put_int(cfg->total_txtsecs,stream);
935: for(i=0;i<cfg->total_txtsecs;i++) {
936: #if 1
937: SAFECOPY(str,cfg->txtsec[i]->code);
938: strlwr(str);
939: safe_snprintf(path,sizeof(path),"%stext/%s",cfg->data_dir,str);
940: md(path);
941: #endif
942: put_str(cfg->txtsec[i]->name,stream);
943: put_str(cfg->txtsec[i]->code,stream);
944: put_str(cfg->txtsec[i]->arstr,stream);
945: n=0;
946: for(j=0;j<8;j++)
947: put_int(n,stream);
948: }
949:
950: fclose(stream);
951:
952: return(TRUE);
953: }
954:
955:
956:
957: /****************************************************************************/
958: /****************************************************************************/
959: BOOL DLLCALL write_chat_cfg(scfg_t* cfg, int backup_level)
960: {
961: char str[MAX_PATH+1];
962: int i,j,file;
1.1.1.2 ! root 963: uint16_t n;
1.1 root 964: FILE *stream;
965:
966: if(cfg->prepped)
967: return(FALSE);
968:
969: sprintf(str,"%schat.cnf",cfg->ctrl_dir);
970: backup(str, backup_level, TRUE);
971:
972: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1
973: || (stream=fdopen(file,"wb"))==NULL) {
974: return(FALSE);
975: }
976: setvbuf(stream,NULL,_IOFBF,2048);
977:
978: put_int(cfg->total_gurus,stream);
979: for(i=0;i<cfg->total_gurus;i++) {
980: put_str(cfg->guru[i]->name,stream);
981: put_str(cfg->guru[i]->code,stream);
982: put_str(cfg->guru[i]->arstr,stream);
983: n=0;
984: for(j=0;j<8;j++)
985: put_int(n,stream);
986: }
987:
988: put_int(cfg->total_actsets,stream);
989: for(i=0;i<cfg->total_actsets;i++)
990: put_str(cfg->actset[i]->name,stream);
991:
992: put_int(cfg->total_chatacts,stream);
993: for(i=0;i<cfg->total_chatacts;i++) {
994: put_int(cfg->chatact[i]->actset,stream);
995: put_str(cfg->chatact[i]->cmd,stream);
996: put_str(cfg->chatact[i]->out,stream);
997: n=0;
998: for(j=0;j<8;j++)
999: put_int(n,stream);
1000: }
1001:
1002: put_int(cfg->total_chans,stream);
1003: for(i=0;i<cfg->total_chans;i++) {
1004: put_int(cfg->chan[i]->actset,stream);
1005: put_str(cfg->chan[i]->name,stream);
1006: put_str(cfg->chan[i]->code,stream);
1007: put_str(cfg->chan[i]->arstr,stream);
1008: put_int(cfg->chan[i]->cost,stream);
1009: put_int(cfg->chan[i]->guru,stream);
1010: put_int(cfg->chan[i]->misc,stream);
1011: n=0;
1012: for(j=0;j<8;j++)
1013: put_int(n,stream);
1014: }
1015:
1016: put_int(cfg->total_pages,stream);
1017: for(i=0;i<cfg->total_pages;i++) {
1018: put_str(cfg->page[i]->cmd,stream);
1019: put_str(cfg->page[i]->arstr,stream);
1020: put_int(cfg->page[i]->misc,stream);
1021: n=0;
1022: for(j=0;j<8;j++)
1023: put_int(n,stream);
1024: }
1025:
1026: fclose(stream);
1027:
1028: return(TRUE);
1029: }
1030:
1031:
1032: /****************************************************************************/
1033: /****************************************************************************/
1034: BOOL DLLCALL write_xtrn_cfg(scfg_t* cfg, int backup_level)
1035: {
1036: uchar str[MAX_PATH+1],c;
1037: int i,j,sec,file;
1.1.1.2 ! root 1038: uint16_t n;
1.1 root 1039: FILE *stream;
1040:
1041: if(cfg->prepped)
1042: return(FALSE);
1043:
1044: sprintf(str,"%sxtrn.cnf",cfg->ctrl_dir);
1045: backup(str, backup_level, TRUE);
1046:
1047: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1
1048: || (stream=fdopen(file,"wb"))==NULL) {
1049: return(FALSE);
1050: }
1051: setvbuf(stream,NULL,_IOFBF,2048);
1052:
1053: put_int(cfg->total_swaps,stream);
1054: for(i=0;i<cfg->total_swaps;i++)
1055: put_str(cfg->swap[i]->cmd,stream);
1056:
1057: put_int(cfg->total_xedits,stream);
1058: for(i=0;i<cfg->total_xedits;i++) {
1059: put_str(cfg->xedit[i]->name,stream);
1060: put_str(cfg->xedit[i]->code,stream);
1061: put_str(cfg->xedit[i]->lcmd,stream);
1062: put_str(cfg->xedit[i]->rcmd,stream);
1063: put_int(cfg->xedit[i]->misc,stream);
1064: put_str(cfg->xedit[i]->arstr,stream);
1065: put_int(cfg->xedit[i]->type,stream);
1066: c=0;
1067: put_int(c,stream);
1068: n=0;
1069: for(j=0;j<7;j++)
1070: put_int(n,stream);
1071: }
1072:
1073: put_int(cfg->total_xtrnsecs,stream);
1074: for(i=0;i<cfg->total_xtrnsecs;i++) {
1075: put_str(cfg->xtrnsec[i]->name,stream);
1076: put_str(cfg->xtrnsec[i]->code,stream);
1077: put_str(cfg->xtrnsec[i]->arstr,stream);
1078: n=0;
1079: for(j=0;j<8;j++)
1080: put_int(n,stream);
1081: }
1082:
1083: put_int(cfg->total_xtrns,stream);
1084: for(sec=0;sec<cfg->total_xtrnsecs;sec++)
1085: for(i=0;i<cfg->total_xtrns;i++) {
1086: if(cfg->xtrn[i]->sec!=sec)
1087: continue;
1088: put_int(cfg->xtrn[i]->sec,stream);
1089: put_str(cfg->xtrn[i]->name,stream);
1090: put_str(cfg->xtrn[i]->code,stream);
1091: put_str(cfg->xtrn[i]->arstr,stream);
1092: put_str(cfg->xtrn[i]->run_arstr,stream);
1093: put_int(cfg->xtrn[i]->type,stream);
1094: put_int(cfg->xtrn[i]->misc,stream);
1095: put_int(cfg->xtrn[i]->event,stream);
1096: put_int(cfg->xtrn[i]->cost,stream);
1097: put_str(cfg->xtrn[i]->cmd,stream);
1098: put_str(cfg->xtrn[i]->clean,stream);
1099: put_str(cfg->xtrn[i]->path,stream);
1100: put_int(cfg->xtrn[i]->textra,stream);
1101: put_int(cfg->xtrn[i]->maxtime,stream);
1102: n=0;
1103: for(j=0;j<7;j++)
1104: put_int(n,stream);
1105: }
1106:
1107: put_int(cfg->total_events,stream);
1108: for(i=0;i<cfg->total_events;i++) {
1109: put_str(cfg->event[i]->code,stream);
1110: put_str(cfg->event[i]->cmd,stream);
1111: put_int(cfg->event[i]->days,stream);
1112: put_int(cfg->event[i]->time,stream);
1113: put_int(cfg->event[i]->node,stream);
1114: put_int(cfg->event[i]->misc,stream);
1115: put_str(cfg->event[i]->dir,stream);
1116: put_int(cfg->event[i]->freq,stream);
1117: put_int(cfg->event[i]->mdays,stream);
1.1.1.2 ! root 1118: put_int(cfg->event[i]->months,stream);
1.1 root 1119: n=0;
1.1.1.2 ! root 1120: for(j=0;j<4;j++)
1.1 root 1121: put_int(n,stream);
1122: }
1123:
1124: put_int(cfg->total_natvpgms,stream);
1125: for(i=0;i<cfg->total_natvpgms;i++)
1126: put_str(cfg->natvpgm[i]->name,stream);
1127: for(i=0;i<cfg->total_natvpgms;i++)
1128: put_int(cfg->natvpgm[i]->misc,stream);
1129:
1130: put_int(cfg->total_hotkeys,stream);
1131: for(i=0;i<cfg->total_hotkeys;i++) {
1132: put_int(cfg->hotkey[i]->key,stream);
1133: put_str(cfg->hotkey[i]->cmd,stream);
1134: n=0;
1135: for(j=0;j<8;j++)
1136: put_int(n,stream);
1137: }
1138:
1139: fclose(stream);
1140:
1141: return(TRUE);
1142: }
1143:
1144: void DLLCALL refresh_cfg(scfg_t* cfg)
1145: {
1146: char str[MAX_PATH+1];
1147: int i;
1148: int file;
1149: node_t node;
1150:
1151: for(i=0;i<cfg->sys_nodes;i++) {
1152: if(getnodedat(cfg,i+1,&node,&file)!=0)
1153: continue;
1154: node.misc|=NODE_RRUN;
1155: if(putnodedat(cfg,i+1,&node,file))
1156: break;
1157: }
1158:
1159: SAFEPRINTF(str,"%srecycle",cfg->ctrl_dir); ftouch(str);
1160: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.