453 lines
10 KiB
C++
453 lines
10 KiB
C++
|
|
// ------------------------------------------------------------------
|
|
// GoldED+
|
|
// Copyright (C) 1990-1999 Odinn Sorensen
|
|
// Copyright (C) 1999-2000 Alexander S. Aganichev
|
|
// ------------------------------------------------------------------
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License as
|
|
// published by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
// MA 02111-1307 USA
|
|
// ------------------------------------------------------------------
|
|
// $Id$
|
|
// ------------------------------------------------------------------
|
|
// Configuration functions, part 1.
|
|
// ------------------------------------------------------------------
|
|
|
|
#include <golded.h>
|
|
#include <gcprot.h>
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
extern char* val;
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAddress() { CfgAddress(val); }
|
|
void CfgAddress(char* v)
|
|
{
|
|
if (not strblank(v))
|
|
{
|
|
if (veryverbose)
|
|
STD_PRINTNL(" CfgAddress(" << v << ")");
|
|
|
|
gaka aka;
|
|
aka.domain[0] = NUL;
|
|
aka.pointnet = 0;
|
|
|
|
char* ptr = strchr(v, ',');
|
|
if(ptr) {
|
|
aka.pointnet = atow(ptr+1);
|
|
*ptr = NUL;
|
|
}
|
|
if(not CFG->aka.empty()) {
|
|
aka.addr = CFG->aka[0].addr;
|
|
strcpy(aka.domain, CFG->aka[0].domain);
|
|
}
|
|
aka.addr.set(v, aka.domain);
|
|
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AKA, &aka, sizeof(gaka));
|
|
|
|
int gotaka = GetAkaNo(aka.addr);
|
|
if(gotaka == -1)
|
|
CFG->aka.push_back(aka);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAddressbookadd() {
|
|
|
|
CFG->addressbookadd = GetYesno(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAddresslookupfirst(){
|
|
|
|
if(strieql(val, "MSGID"))
|
|
CFG->addresslookupfirst = YES;
|
|
else
|
|
CFG->addresslookupfirst = NO;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAddressmacro(char* v) { val = v; CfgAddressmacro(); }
|
|
void CfgAddressmacro() {
|
|
|
|
AddrMacro tmp;
|
|
tmp.attr.reset();
|
|
int subjwasquoted = NO;
|
|
char* ptr = val;
|
|
char* ptr2 = strchr(ptr, ','); // macro^,name,address,subj,attribs
|
|
if(ptr2) {
|
|
// Got macroname
|
|
*ptr2++ = NUL;
|
|
strxcpy(tmp.macro, ptr, 20);
|
|
ptr = strskip_wht(ptr2);
|
|
ptr2 = strchr(ptr, ','); // macro,name^,address,subj,attribs
|
|
if(ptr2) {
|
|
// Got real name
|
|
*ptr2++ = NUL;
|
|
strxcpy(tmp.name, ptr, sizeof(IAdr));
|
|
ptr = strskip_wht(ptr2);
|
|
ptr2 = strchr(ptr, ','); // macro,name,address^,subj,attribs
|
|
if(ptr2)
|
|
*ptr2++ = NUL;
|
|
// Got address
|
|
if(not CFG->aka.empty())
|
|
tmp.addr = CFG->aka[0].addr;
|
|
tmp.addr.set(ptr);
|
|
if(ptr2) {
|
|
// Got subject
|
|
ptr = strskip_wht(ptr2);
|
|
if((*ptr == '\"') or (*ptr == '\'')) {
|
|
ptr2 = strchr(ptr+1, *ptr);
|
|
if(ptr2) {
|
|
subjwasquoted = YES;
|
|
*ptr2++ = NUL;
|
|
ptr++;
|
|
}
|
|
}
|
|
strxcpy(tmp.subj, ptr, sizeof(Subj));
|
|
|
|
// Got quoted subj, so look for attribs
|
|
if(subjwasquoted) {
|
|
ptr2 = strchr(ptr2, ','); // macro,name,address,subj^,attribs
|
|
if(ptr2)
|
|
GetAttribstr(&tmp.attr, ptr2+1);
|
|
}
|
|
}
|
|
else
|
|
tmp.subj[0] = NUL;
|
|
CFG->addressmacro.push_back(tmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAdeptxbbspath(const char *path, bool force) {
|
|
|
|
if (force or strblank(CFG->adeptxbbspath))
|
|
MapPath(PathCopy(CFG->adeptxbbspath, path));
|
|
}
|
|
|
|
void CfgAdeptxbbspath() {
|
|
|
|
CfgAdeptxbbspath(val, true);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAdeptxbbsuserno() {
|
|
|
|
CFG->adeptxbbsuserno = atoi(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAkamatch() {
|
|
|
|
char* key;
|
|
getkeyval(&key, &val);
|
|
|
|
AkaMatchG akamatchg;
|
|
akamatchg.mask.set_all(GFTN_ALL);
|
|
akamatchg.mask.set(key);
|
|
akamatchg.aka.reset(val);
|
|
CFG->akamatch.push_back(akamatchg);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAkamatchfromto() {
|
|
CFG->akamatchfromto = GetYesno(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAkamatching() {
|
|
|
|
if(cfgingroup) {
|
|
bool flag = make_bool(GetYesno(val));
|
|
CFG->grp.AddItm(GRP_AKAMATCHING, flag);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAkamatchmanually()
|
|
{
|
|
CFG->akamatchmanually = make_bool(GetYesno(val));
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArea() {
|
|
|
|
AL.GetArea(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreaautoid() {
|
|
|
|
if(striinc("VERBOSE", val))
|
|
CFG->areaautoid = AUTOID_VERBOSE;
|
|
else if(striinc("SHORT", val))
|
|
CFG->areaautoid = AUTOID_SHORT;
|
|
else if(striinc("LONG", val))
|
|
CFG->areaautoid = AUTOID_LONG;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreacfmreplyto() {
|
|
|
|
strxcpy(CFG->areacfmreplyto, val, sizeof(Echo));
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreacopydirect() {
|
|
|
|
bool flag = make_bool(GetYesno(val));
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AREACOPYDIRECT, flag);
|
|
else
|
|
CFG->areacopydirect = flag;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreacopyto() {
|
|
|
|
Echo buf;
|
|
strxcpy(buf, val, sizeof(buf));
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AREACOPYTO, buf, strlen(buf)+1);
|
|
else
|
|
strcpy(CFG->areacopyto, buf);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreacopyaddid() {
|
|
|
|
bool flag = make_bool(GetYesno(val));
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AREACOPYADDID, flag);
|
|
else
|
|
CFG->areacopyaddid = flag;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreadef() {
|
|
|
|
AL.GetAreaDef(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreadesc() {
|
|
|
|
AL.GetAreaDesc(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreaexcl() {
|
|
|
|
tokenize(CFG->areaexcl, val);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreaforwarddirect() {
|
|
|
|
bool flag = make_bool(GetYesno(val));
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AREAFORWARDDIRECT, flag);
|
|
else
|
|
CFG->areaforwarddirect = flag;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreafreqdirect() {
|
|
|
|
bool flag = make_bool(GetYesno(val));
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AREAFREQDIRECT, flag);
|
|
else
|
|
CFG->areafreqdirect = flag;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreafreqto() {
|
|
|
|
Echo buf;
|
|
strxcpy(buf, val, sizeof(buf));
|
|
if(cfgingroup)
|
|
CFG->grp.AddItm(GRP_AREAFREQTO, buf, strlen(buf)+1);
|
|
else
|
|
strcpy(CFG->areafreqto, buf);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreaincl() {
|
|
|
|
tokenize(CFG->areaincl, val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreaisemail() {
|
|
|
|
tokenize(CFG->areaisemail, val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreaisnews() {
|
|
|
|
tokenize(CFG->areaisnews, val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArealistechomax() {
|
|
|
|
CFG->arealistechomax = atoi(val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArealistformat() {
|
|
|
|
strxcpy(CFG->arealistformat, StripQuotes(val), sizeof(CFG->arealistformat));
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArealistgrouporder() {
|
|
|
|
strxcpy(CFG->arealistgrouporder, StripQuotes(val), sizeof(CFG->arealistgrouporder));
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArealistscan() {
|
|
|
|
char* _key;
|
|
getkeyval(&_key, &val);
|
|
AL.ListScan.Add(std::pair<std::string, std::string>(StripQuotes(_key), val));
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArealistsort() {
|
|
|
|
strxcpy(CFG->arealistsort, val, sizeof(CFG->arealistsort));
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArealisttype() {
|
|
|
|
if(strieql(val, "New"))
|
|
CFG->arealisttype = AL_TOTNEW;
|
|
else if(strieql(val, "Last"))
|
|
CFG->arealisttype = AL_TOTLST;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreapath() {
|
|
|
|
MapPath(PathCopy(CFG->areapath, val));
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreapmscan() {
|
|
|
|
tokenize(CFG->areapmscan, val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreapmscanexcl() {
|
|
|
|
tokenize(CFG->areapmscanexcl, val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreapmscanincl() {
|
|
|
|
tokenize(CFG->areapmscanincl, val);
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgAreareadonly() {
|
|
|
|
if(strieql(val, "Soft"))
|
|
CFG->areareadonly = READONLY_SOFT;
|
|
else if(strieql(val, "Hard"))
|
|
CFG->areareadonly = READONLY_HARD;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArearecyclebin()
|
|
{
|
|
char* key;
|
|
getkeyval(&key, &val);
|
|
strupr(strxcpy(CFG->arearecyclebin, key, sizeof(Echo)));
|
|
|
|
if (*val)
|
|
{
|
|
if (strieql(val, "NoAsk"))
|
|
CFG->arearecyclebinask = false;
|
|
else if (strieql(val, "Ask"))
|
|
CFG->arearecyclebinask = true;
|
|
else
|
|
CFG->arearecyclebinask = make_bool(GetYesno(val));
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
void CfgArearename() {
|
|
|
|
char* key;
|
|
getkeyval(&key, &val);
|
|
CFG->arearename.push_back(EchoRen(key, strtrim(val)));
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|