//  ------------------------------------------------------------------
//  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$
//  ------------------------------------------------------------------
//  QWK packet handling.
//  ------------------------------------------------------------------

#include <golded.h>
#include <gs_qwk.h>


//  ------------------------------------------------------------------

static void ReadGldFile() {

  if (QWK->FoundBBS())
  {
    Path gldfile;
    
    QWK->ResetConfNo();
    gsprintf(PRINTF_DECLARE_BUFFER(gldfile), "%s%s.GLD", CFG->goldpath, QWK->BbsID());
    
    gfile fp(gldfile, "rt");
    if (fp.isopen())
    {
      char* key;
      char* val;
      char buf[256];
      while (fp.Fgets(buf, sizeof(buf)))
      {
        val = strtrim(buf);
        getkeyval(&key, &val);
        strtrim(StripQuotes(val));
        if(QWK->FindEcho(val))
          QWK->ConfNo(atoi(key));
      }
    }
  }
}


//  ------------------------------------------------------------------

int ImportQWK() {

  if(not *QWK->ImportPath())
    return 0;

  gfile fpb;   // For BBSID.GLD
  Path file;
  Path gldfile;
  char bbsid[9] = {""};

  // Parse the control file
  strcpy(file, AddPath(QWK->ImportPath(), "CONTROL.DAT"));
  gfile fp(file, "rt");
  if (fp.isopen())
  {
    char buf[256];
    int line = 0;
    int confno = 0;
    int confcnt = 0;
    int confnos = 0;
    while (fp.Fgets(buf, sizeof(buf)))
    {
      line++;
      strtrim(buf);

      if((line >= 12) and (confcnt < confnos)) {
        if(line % 2)
        {
          if (fpb.isopen())
            fpb.Printf("%u \"%s\"\n", confno, buf);
          confcnt++;
        }
        else
          confno = atoi(buf);
      }
      else if(line == 5) {
        char* ptr = strchr(buf, ',');
        if (ptr)
        {
          strxcpy(bbsid, strskip_wht(ptr+1), 9);
          gsprintf(PRINTF_DECLARE_BUFFER(gldfile), "%s%s.GLD", CFG->goldpath, bbsid);
          fpb.Fopen(gldfile, "wt");
        }
      }
      else if(line == 11)
        confnos = atoi(buf) + 1;
    }

    fpb.Fclose();
    fp.Fclose();
    remove(file);
  }

  if(strblank(bbsid))
    return 0;

  QWK->FindBBS(bbsid);
  ReadGldFile();

  int imported = 0;

  OrigArea = CurrArea = -1;

  strcpy(file, AddPath(QWK->ImportPath(), "MESSAGES.DAT"));
  fp.Fopen(file, "rb");
  if (fp.isopen())
  {
    // Skip past product info header
    fp.FseekSet(sizeof(QWKHdr));

    QWKHdr hdr;

    GMsg* msg = (GMsg*)throw_calloc(1, sizeof(GMsg));

    // Read each message, header first
    int tosstobadmsgs = false;
    int lastconfno = -1;
    int more;
    do {

      ResetMsg(msg);

      memset(&hdr, 0, sizeof(QWKHdr));
      more = 1 == fp.Fread(&hdr, sizeof(QWKHdr));
      if(more) {

        char blocks[7];
        strxcpy(blocks, hdr.blocks, 7);
        uint msglen = atoi(blocks);
        if(msglen == 0) {
          break;
        }
        msglen = (msglen-1)*128;

        if(hdr.confno != lastconfno) {
          lastconfno = hdr.confno;
          if(QWK->FindEcho(hdr.confno)) {
            int areano = AL.AreaEchoToNo(QWK->EchoID());
            if(areano != -1) {
              CurrArea = AL.AreaNoToId(areano);
              tosstobadmsgs = false;
            }
          }
          else {
            int areano = AL.AreaEchoToNo(QWK->BadMsgs());
            if(areano != -1) {
              CurrArea = AL.AreaNoToId(areano);
              tosstobadmsgs = true;
            }
            else
            {
              tosstobadmsgs = -1;
              fp.Fseek(msglen, SEEK_CUR);
            }
          }
        }

        if(tosstobadmsgs != -1) {

          if(OrigArea != CurrArea) {
            if(AA->isopen()) {
              AA->Unlock();
              AA->Close();
            }
            AL.SetActiveAreaId(CurrArea);
            OrigArea = CurrArea;
            AA->Open();
            AA->Lock();
            AA->RandomizeData();
          }

          // Convert header
          msg->orig = msg->oorig = AA->aka();
          msg->dest = msg->odest = AA->aka();
          msg->attr.pvt(hdr.status == '*' or hdr.status == '+');
          msg->attr.rcv(hdr.status == '+' or hdr.status == '-' or hdr.status == '`' or hdr.status == '^' or hdr.status == '#');
          msg->attr.del(hdr.activestatus == 226);
          strtrim(strxcpy(msg->by, hdr.from, 26));
          strtrim(strxcpy(msg->to, hdr.to, 26));
          strtrim(strxcpy(msg->re, hdr.subject,  26));
          int _year, _month, _day, _hour, _minute;
          sscanf(hdr.date, "%d%*c%d%*c%2d", &_month, &_day, &_year);
          sscanf(hdr.time, "%d%*c%2d", &_hour, &_minute);
          struct tm _tm;
          _tm.tm_year  = (_year < 80) ? (_year+100) : _year;
          _tm.tm_mon   = _month - 1;
          _tm.tm_mday  = _day;
          _tm.tm_hour  = _hour;
          _tm.tm_min   = _minute;
          _tm.tm_sec   = 0;
          _tm.tm_isdst = -1;
          time32_t a   = gmktime(&_tm);
          struct tm tp; ggmtime(&tp, &a);
          tp.tm_isdst  = -1;
          time32_t b   = gmktime(&tp);
          msg->written = a + a - b;
          a = gtime(NULL);
          ggmtime(&tp, &a);
          tp.tm_isdst  = -1;
          b = gmktime(&tp);
          msg->arrived = a + a - b;

          // Read message text
          char* txtptr = msg->txt = (char*)throw_calloc(1, msglen+128);
          if(tosstobadmsgs) {
            sprintf(msg->txt, "AREA:%s_%u\r", bbsid, hdr.confno);
            txtptr += strlen(msg->txt);
          }
          fp.Fread(txtptr, msglen);
          strtrim(txtptr);
          strchg(txtptr, 0xE3, 0x0D);

          imported++;
          AA->istossed = true;
          update_statuslinef("%s: %u", "", AA->echoid(), imported);

          msg->TextToLines(CFG->dispmargin-1);
          if(msg->messageid or msg->references or msg->inreplyto or *msg->ifrom) {
            char kbuf[256];
            uint txtlen = strlen(msg->txt);
            if(*msg->ifrom) {
              INam _fromname;
              IAdr _fromaddr;
              ParseInternetAddr(msg->ifrom, _fromname, _fromaddr);
              if (AA->Internetgate().addr.valid())
              {
                char abuf[40];
                gsprintf(PRINTF_DECLARE_BUFFER(kbuf),
                  "\x1""REPLYTO %s %s\r""\x1""REPLYADDR %s\r",
                  AA->Internetgate().addr.make_string(abuf),
                  *AA->Internetgate().name ? AA->Internetgate().name : "UUCP",
                  _fromaddr
                );
                uint addlen = strlen(kbuf);
                msg->txt = (char*)throw_realloc(msg->txt, txtlen+addlen+1);
                memmove(msg->txt+addlen, msg->txt, txtlen+1);
                memcpy(msg->txt, kbuf, addlen);
                txtlen += addlen;
              }
            }
            if(msg->references) {
              char* mptr = msg->references;
              char* sptr = mptr;
              while(*mptr) {
                if(not strnieql(mptr, "<NOMSGID_", 9)) {
                  sptr = strpbrk(mptr, " ,");
                  if(sptr == NULL)
                    sptr = mptr + strlen(mptr);
                  while(((*sptr == ' ') or (*sptr == ',')) and *sptr)
                    *sptr++ = NUL;
                  CvtMessageIDtoMSGID(mptr, kbuf, AA->echoid(), "REPLY");
                  strcat(kbuf, "\r");
                  uint addlen = strlen(kbuf);
                  msg->txt = (char*)throw_realloc(msg->txt, txtlen+addlen+1);
                  memmove(msg->txt+addlen, msg->txt, txtlen+1);
                  memcpy(msg->txt, kbuf, addlen);
                  txtlen += addlen;
                }
                mptr = sptr;
              }
            }
            if(msg->inreplyto) {
              if(not strnieql(msg->inreplyto, "<NOMSGID_", 9)) {
                CvtMessageIDtoMSGID(msg->inreplyto, kbuf, AA->echoid(), "REPLY");
                strcat(kbuf, "\r");
                uint addlen = strlen(kbuf);
                msg->txt = (char*)throw_realloc(msg->txt, txtlen+addlen+1);
                memmove(msg->txt+addlen, msg->txt, txtlen+1);
                memcpy(msg->txt, kbuf, addlen);
                txtlen += addlen;
              }
            }
            if(msg->messageid) {
              if(not strnieql(msg->messageid, "<NOMSGID_", 9)) {
                CvtMessageIDtoMSGID(msg->messageid, kbuf, AA->echoid(), "MSGID");
                strcat(kbuf, "\r");
                uint addlen = strlen(kbuf);
                msg->txt = (char*)throw_realloc(msg->txt, txtlen+addlen+1);
                memmove(msg->txt+addlen, msg->txt, txtlen+1);
                memcpy(msg->txt, kbuf, addlen);
              }
            }
          }

          if(*msg->realto and (strieql(msg->to, AA->Whoto()) or not *msg->to))
            strcpy(msg->to, msg->realto);

          AA->SaveMsg(GMSG_NEW, msg);
        }
      }
    } while(more);

    if(AA->isopen()) {
      AA->Unlock();
      AA->Close();
    }

    ResetMsg(msg);
    throw_free(msg);

    fp.Fclose();
    remove(file);

    if (*QWK->TossLog())
    {
      fp.Fopen(QWK->TossLog(), "at");
      if (fp.isopen())
      {
        uint na = 0;
        while(na < AL.size()) {
          if(AL[na]->istossed) {
            AL[na]->istossed = false;
            AL[na]->isunreadchg = true;
            fp.Printf("%s\n", AL[na]->echoid());
          }
          na++;
        }
      }
    }

    if (imported and *QWK->ReplyLinker())
    {
      char buf[256];
      gsprintf(PRINTF_DECLARE_BUFFER(buf), LNG->Replylinker, QWK->ReplyLinker());
      ShellToDos(QWK->ReplyLinker(), buf, LGREY_|_BLACK, YES);
    }
  }

  if(imported)
    startupscan_success = true;

  return imported;
}


//  ------------------------------------------------------------------

int ExportQwkMsg(GMsg* msg, gfile& fp, int confno, int& pktmsgno) {

  // Prepare for Return Receipt Request
  char msg__re[26];
  if (QWK->ReceiptAllowed() and msg->attr.rrq())
    gsprintf(PRINTF_DECLARE_BUFFER(msg__re), "RRR%-22.22s", msg->re);
  else
    strxcpy(msg__re, msg->re, 26);

  // Build QWK header
  QWKHdr hdr;
  char buf[26];
  int tolen = strlen(msg->to);  tolen = MinV(25,tolen);
  int bylen = strlen(msg->by);  bylen = MinV(25,bylen);
  int relen = strlen(msg__re);  relen = MinV(25,relen);
  memset(&hdr, ' ', sizeof(QWKHdr));
  hdr.status = msg->attr.pvt() ? '*' : ' ';
  gsprintf(PRINTF_DECLARE_BUFFER(buf), "%u", confno);
  memcpy(hdr.msgno, buf, strlen(buf));
  struct tm _tm; ggmtime(&_tm, &msg->written);
  int _year = _tm.tm_year % 100;
  gsprintf(PRINTF_DECLARE_BUFFER(buf), "%02d-%02d-%02d", _tm.tm_mon+1, _tm.tm_mday, _year);
  memcpy(hdr.date, buf, 8);
  gsprintf(PRINTF_DECLARE_BUFFER(buf), "%02d:%02d", _tm.tm_hour, _tm.tm_min);
  memcpy(hdr.time, buf, 5);
  strxcpy(buf, msg->to, tolen+1);
  if(not QWK->MixCaseAllowed())
    strupr(buf);
  memcpy(hdr.to, buf, tolen);
  strxcpy(buf, msg->by, bylen+1);
  if(not QWK->MixCaseAllowed())
    strupr(buf);
  memcpy(hdr.from, buf, bylen);
  memcpy(hdr.subject, msg__re, relen);
  hdr.activestatus = '\xE1';
  hdr.confno = (word)confno;
  hdr.pktmsgno = (word)++pktmsgno;

  // Write preliminary header
  fp.Fwrite(&hdr, sizeof(QWKHdr));

  // Write body
  int level = 0;
  if(CharTable)
    level = CharTable->level ? CharTable->level : 2;

  char mbuf[512];
  uint msglen = 0;

  if(msg->charsetencoding & GCHENC_MNE) {
    if(not striinc("MNEMONIC", CharTable->exp))
      LoadCharset(CFG->xlatlocalset, "MNEMONIC");
  }
  // ASA: Do we need it at all?
  else if(IsQuotedPrintable(msg->charset)) {
    LoadCharset(CFG->xlatlocalset, ExtractPlainCharset(msg->charset));
  }
  else {
    LoadCharset(CFG->xlatlocalset, msg->charset);
  }

  char qwkterm = '\xE3';

  // Process kludges and write header lines
  Line* line = msg->lin;
  while(line) {
    if(line->type & GLINE_KLUDGE) {
      if(AA->isinternet()) {
        if ((line->kludge == GKLUD_RFC) or (line->kludge == 0))
        {
          XlatStr(mbuf, line->txt.c_str(), level, CharTable);
          msglen += fp.Printf("%s%c", mbuf, qwkterm);
        }
        else if(line->type & GLINE_WRAP) {
          while(line->next and (line->type & GLINE_WRAP))
            line = line->next;
        }
      }
      else {
        if ((line->type & GLINE_KLUDGE) and QWK->KludgesAllowed())
        {
          XlatStr(mbuf, line->txt.c_str(), level, CharTable);
          msglen += fp.Printf("%s%c", mbuf, qwkterm);
        }
      }
    }
    line = line->next;
  }

  // Write blank line after header lines
  if (AA->Internetrfcbody())
    msglen += fp.Printf("%c", qwkterm);

  // Write all message lines
  line = msg->lin;
  while(line) {
    if (not (line->type & GLINE_KLUDGE))
    {
      XlatStr(mbuf, line->txt.c_str(), level, CharTable);
      msglen += fp.Printf("%s%c", mbuf, qwkterm);
    }
    line = line->next;
  }

  // Calculate blocks
  uint endlen = msglen % 128;
  uint blocks = 1+(msglen/128)+(endlen?1:0);
  gsprintf(PRINTF_DECLARE_BUFFER(buf), "%u", blocks);
  memcpy(hdr.blocks, buf, strlen(buf));

  // Write padding spaces at the end if necessary
  if (endlen)
  {
    char padding[128];
    memset(padding, ' ', 128);
    fp.Fwrite(padding, 128-endlen);
  }

  // Re-write the header
  fp.Fseek(-(blocks*128), SEEK_CUR);
  fp.Fwrite(&hdr, sizeof(QWKHdr));
  fp.Fseek((blocks-1)*128, SEEK_CUR);

  // Mark msg as sent
  msg->attr.snt1();
  msg->attr.scn1();
  msg->attr.uns0();
  AA->SaveHdr(GMSG_UPDATE, msg);

  return 1;
}


//  ------------------------------------------------------------------

int ExportQwkArea(int areano, gfile& fp, int confno, int& pktmsgno) {

  int exported = 0;

  AL.SetActiveAreaNo(areano);

  AA->Open();
  AA->Lock();
  AA->RandomizeData();

  GMsg* msg = (GMsg*)throw_calloc(1, sizeof(GMsg));

  for(uint n=0; n<AA->Expo.Count(); n++) {
    if(AA->LoadMsg(msg, AA->Expo[n], 80)) {
      if(msg->attr.uns()) {
        exported += ExportQwkMsg(msg, fp, confno, pktmsgno);
        update_statuslinef("%s: %u", "", AA->echoid(), exported);
      }
    }
  }

  ResetMsg(msg);
  throw_free(msg);

  AA->Unlock();
  AA->Close();

  AA->Expo.ResetAll();

  return exported;
}


//  ------------------------------------------------------------------

int ExportQWK() {

  if(not *QWK->ExportPath())
    return 0;

  int exported = 0;

  gfile fp;
  Path scanfile;

  // Get the scan list
  strcpy(scanfile, AddPath(CFG->goldpath, "GOLDQWK.LST"));
  fp.Fopen(scanfile, "rt");
  if (fp.isopen())
  {
    char buf[256];
    while (fp.Fgets(buf, sizeof(buf)))
    {
      char* ptr = strchr(buf, ' ');
      if(ptr) {
        *ptr++ = NUL;
        int a = AL.AreaEchoToNo(buf);
        if(a != -1 and AL[a]->isqwk())
          AL[a]->Expo.Add(atol(ptr));
      }
    }
    fp.Fclose();
  }

  // Export from the QWK areas
  if(QWK->FirstBBS()) {
    do {
      ReadGldFile();
      Path replyfile;
      int pktmsgno = 0;
      if (QWK->FirstConf())
      {
        gsprintf(PRINTF_DECLARE_BUFFER(replyfile), "%s%s.MSG", QWK->ExportPath(), QWK->BbsID());
        fp.Fopen(replyfile, "wb");
        if (fp.isopen())
        {
          char firstrec[128];
          memset(firstrec, ' ', 128);
          memcpy(firstrec, QWK->BbsID(), strlen(QWK->BbsID()));
          fp.Fwrite(firstrec, 128);
          pktmsgno = 0;
        }
        do {
          int a = AL.AreaEchoToNo(QWK->EchoID());
          if(a != -1 and AL[a]->Expo.Count()) {
            if(QWK->ConfNo() != -1)
              exported += ExportQwkArea(a, fp, QWK->ConfNo(), pktmsgno);
          }
        } while(QWK->NextConf());
      }
      if (fp.isopen())
      {
        fp.Fclose();
        if(pktmsgno == 0)
          remove(replyfile);
      }
    } while(QWK->NextBBS());
  }

  // Delete the scanfile
  remove(scanfile);

  return exported;
}


//  ------------------------------------------------------------------

Qwk::Qwk() {

  bbs = bbsp = NULL;
  mapp = NULL;
  bbss = 0;
}


//  ------------------------------------------------------------------

Qwk::~Qwk() {

  Reset();
}


//  ------------------------------------------------------------------

void Qwk::Reset() {

  for(int n=0; n<bbss; n++)
    throw_release(bbs[n].map);
  throw_xrelease(bbs);
  bbsp = NULL;
  mapp = NULL;
  bbss = 0;
}


//  ------------------------------------------------------------------

void Qwk::AddBBS(char* bbsid) {

  bbs = (QwkBbs*)throw_realloc(bbs, (bbss+1)*sizeof(QwkBbs));
  bbsp = bbs + bbss++;
  strxcpy(bbsp->bbsid, bbsid, sizeof(bbsp->bbsid));
  bbsp->kludges = false;
  bbsp->mixcase = false;
  bbsp->receipt = false;
  bbsp->maxlines = -1;
  bbsp->map = NULL;
  bbsp->maps = 0;
  mapp = NULL;
}


//  ------------------------------------------------------------------

void Qwk::AddMap(char* bbsid, char* echoid, char* confname, int confno) {

  FindAddBBS(bbsid);
  bbsp->map = (QwkMap*)throw_realloc(bbsp->map, (bbsp->maps+1)*sizeof(QwkMap));
  mapp = bbsp->map + bbsp->maps++;
  strxcpy(mapp->confname, confname, sizeof(mapp->confname));
  strxcpy(mapp->echoid, echoid, sizeof(mapp->echoid));
  mapp->confno = confno;
}


//  ------------------------------------------------------------------

int Qwk::FindBBS(char* bbsid) {

  bbsp = bbs;
  for(int n=0; n<bbss; n++,bbsp++) {
    if(strieql(bbsid, bbsp->bbsid)) {
      mapp = bbsp->map;
      return true;
    }
  }
  mapp = NULL;
  return false;
}


//  ------------------------------------------------------------------

void Qwk::FindAddBBS(char* bbsid) {

  if(not FindBBS(bbsid))
    AddBBS(bbsid);
}


//  ------------------------------------------------------------------

int Qwk::FirstBBS() {

  if(bbs) {
    bbsp = bbs;
    bbsn = 1;
    return true;
  }

  bbsp = NULL;
  bbsn = 0;
  return false;
}


//  ------------------------------------------------------------------

int Qwk::NextBBS() {

  if(bbsp and (bbsn < bbss)) {
    bbsp++;
    bbsn++;
    return true;
  }

  bbsp = NULL;
  bbsn = 0;
  return false;
}


//  ------------------------------------------------------------------

int Qwk::FindConf(char* echoid) {

  if(bbsp) {
    mapp = bbsp->map;
    for(int n=0; n<bbsp->maps; n++,mapp++)
      if(strieql(echoid, mapp->echoid))
        return true;
  }

  mapp = NULL;
  return false;
}


//  ------------------------------------------------------------------

int Qwk::FindEcho(char* confname) {
           
  if(bbsp) {
    mapp = bbsp->map;
    for(int n=0; n<bbsp->maps; n++,mapp++)
      if(strieql(confname, mapp->confname))
        return true;
  }

  mapp = NULL;
  return false;
}


//  ------------------------------------------------------------------

int Qwk::FindEcho(int confno) {

  if(bbsp) {
    mapp = bbsp->map;
    for(int n=0; n<bbsp->maps; n++,mapp++)
      if(confno == mapp->confno)
        return true;
  }

  mapp = NULL;
  return false;
}


//  ------------------------------------------------------------------

int Qwk::FirstConf() {

  if(bbsp and bbsp->map) {
    mapp = bbsp->map;
    mapn = 1;
    return true;
  }

  mapp = NULL;
  mapn = 0;
  return false;
}


//  ------------------------------------------------------------------

int Qwk::NextConf() {

  if(mapp and (mapn < bbsp->maps)) {
    mapp++;
    mapn++;
    return true;
  }

  mapp = NULL;
  mapn = 0;
  return false;
}


//  ------------------------------------------------------------------

const char* Qwk::BbsID() {

  return bbsp ? bbsp->bbsid : "";
}


//  ------------------------------------------------------------------

const char* Qwk::ConfName() {

  return mapp ? mapp->confname : "";
}


//  ------------------------------------------------------------------

int Qwk::ConfNo(int set) {

  if(mapp) {
    if(set != -2)
      mapp->confno = set;
    return mapp->confno;
  }
  return -1;
}


//  ------------------------------------------------------------------

const char* Qwk::EchoID() {

  return mapp ? mapp->echoid : "";
}


//  ------------------------------------------------------------------

int Qwk::KludgesAllowed(int set) {

  if(bbsp) {
    if(set != -1)
      bbsp->kludges = set;
    return bbsp->kludges;
  }

  return false;
}


//  ------------------------------------------------------------------

int Qwk::MixCaseAllowed(int set) {

  if(bbsp) {
    if(set != -1)
      bbsp->mixcase = set;
    return bbsp->mixcase;
  }

  return false;
}


//  ------------------------------------------------------------------

int Qwk::ReceiptAllowed(int set) {

  if(bbsp) {
    if(set != -1)
      bbsp->receipt = set;
    return bbsp->receipt;
  }

  return false;
}


//  ------------------------------------------------------------------

int Qwk::MaxLines(int set) {

  if(bbsp) {
    if(set != -1)
      bbsp->maxlines = set;
    return bbsp->maxlines;
  }

  return 0;
}


//  ------------------------------------------------------------------

void Qwk::ResetConfNo(int set) {

  if(bbsp) {
    mapp = bbsp->map;
    for(int n=0; n<bbsp->maps; n++,mapp++)
      mapp->confno = set;
  }
}


//  ------------------------------------------------------------------

char* Qwk::BadMsgs(char* set) {

  if(set)
    strxcpy(cfg.badmsgs, set, sizeof(Echo));

  return cfg.badmsgs;
}


//  ------------------------------------------------------------------

char* Qwk::ExportPath(char* set) {

  if(set)
    PathCopy(cfg.exportpath, set);

  return cfg.exportpath;
}


//  ------------------------------------------------------------------

char* Qwk::ImportPath(char* set) {

  if(set)
    PathCopy(cfg.importpath, set);

  return cfg.importpath;
}


//  ------------------------------------------------------------------

char* Qwk::ReplyLinker(char* set) {

  if(set)
    strxcpy(cfg.replylinker, set, sizeof(Path));

  return cfg.replylinker;
}


//  ------------------------------------------------------------------

char* Qwk::TossLog(char* set) {

  if(set)
    strxcpy(cfg.tosslog, set, sizeof(Path));

  return cfg.tosslog;
}


//  ------------------------------------------------------------------