NServer.h

Go to the documentation of this file.

#ifndef __NServer_h__
#define __NServer_h__
/* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
/* Portions Copyright (C) 2003 Herbert Straub
 *      Implementing the ArtSpooler class
 *      Reimplementing the complet methods:
 *              CServer::postspooled (void)
 *              CServer::spoolarticle (Article *article)
 */

#include <sys/param.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>

#include <iostream>
#include <fstream>

class NServer;
class LServer;
class RServer;
class CServer;

#include "config.h"
#include "Debug.h"

#include "sstream.h"
#include "util.h"

#include "OverviewFmt.h"
#include "ActiveDB.h"
#include "NVActiveDB.h"
#include "NVNewsgroup.h"
#include "CNewsgroup.h"
#include "Article.h"
#include "MPList.h"
#include "NSError.h"
#include "ArtSpooler.h"

/* NServer parent-class, RServer and LServer child-classes.
 */
extern char nntp_hostname[MAXHOSTNAMELEN];
extern char nntp_posting_host[MAXHOSTNAMELEN];

#ifdef EXP

class PostResult {
      public:
        MPListEntry ** server;
        int *error;
        int nservers;

         PostResult(int sz):server(NULL), errors(NULL), nserver(0) {
                if ((server =
                     (MPListEntry **) malloc(sz *
                                             sizeof(MPListEntry *))) ==
                    NULL) {
                        throw
                            SystemError
                            ("cannot allocate buffer for post servers",
                             errno, ERROR_LOCATION);
                }
                if ((error = (int *) malloc(sz * sizeof(int))) == NULL) {
                        free(server);
                        server = NULL;
                        throw
                            SystemError
                            ("cannot allocate buffer for result list",
                             errno, ERROR_LOCATION);
                }
        }

        ~PostResult() {
                if (server)
                        free(server);
                if (error)
                        free(error);
        }

        enum { Offline, None, Duplicate, NotAllowed, PostingFailed,
                    ResponseError, SystemError, InternalError };
};
#endif

class NServer {
      protected:
        OverviewFmt * _OverviewFormat;
        ActiveDB *_ActiveDB;

         NServer();
         virtual ~ NServer();
      public:
         virtual OverviewFmt * overviewfmt() {
                return _OverviewFormat;
        } virtual ActiveDB *active() = 0;
        virtual GroupInfo *groupinfo(const char *name) = 0;
        virtual Newsgroup *getgroup(const char *name) = 0;

        virtual void freegroup(Newsgroup * group);
        virtual int post(Article * article) = 0;
};                              //NServer

class LServer:virtual public NServer {
      protected:
        char _SpoolDirectory[MAXPATHLEN];
        ArtSpooler *pSpool;

         LServer():NServer(), pSpool(0) {
                _SpoolDirectory[0] = '\0';
        } void init(const char *spooldir);

      public:

        LServer(const char *spooldir);
        virtual ~ LServer();


        virtual ActiveDB *active();

        virtual GroupInfo *groupinfo(const char *name);

        virtual Newsgroup *getgroup(const char *name);

        virtual int post(Article * article);
};

class RServer:virtual public NServer {
      private:

        void post(MPListEntry * srvr, Article * article);

      protected:
         MPList * _ServerList;
        MPListEntry *_CurrentServer;
        GroupInfo _CurrentGroup;

        sstream *_pServerStream;

         RServer():NServer() {
                _ServerList = NULL;
                _CurrentServer = NULL;
                _pServerStream = NULL;
        } void init(MPList * serverlist);

        void connect();

        void disconnect();

        std::string issue(const char *command, const char *expresp = NULL);

        void setserver(MPListEntry * server);

        int is_connected() {
                return (_pServerStream != NULL) ? 1 : 0;
        }

        void selectgroup(const char *name, int force = 0);

      public:

        RServer(MPList * serverlist);

        virtual ~ RServer();

        void setserverlist(MPList * serverlist);

        MPList *getserverlist(void) {
                return _ServerList;
        }

        virtual ActiveDB *active();

        virtual GroupInfo *groupinfo(const char *name);

        virtual Newsgroup *getgroup(const char *name);

        virtual int post(Article * article);

        virtual void listgroup(const char *gname, char *lstgrp,
                               unsigned int f, unsigned int l);

        virtual void overviewdb(Newsgroup * ng, unsigned int fst,
                                unsigned int lst);

        virtual void article(const char *gname, unsigned int nb,
                             Article * artr);

        virtual void article(const char *id, Article * art);
};

class CServer:virtual public LServer, public RServer {
      protected:
        NVActiveDB * _NVActiveDB;

        nvtime_t _TTLActive;
        nvtime_t _TTLDesc;
        int active_valid() {
                unsigned long tm;
                 _NVActiveDB->getmtime(&tm);
                 return (tm + _TTLActive) > nvtime(NULL);
        } int desc_valid() {
                return 1;
        }
        int group_valid();

        // This variable indicates, whether a newsgroup has been 
        // already selected on the remote news server
        // int _RSGroup;
        // Select group on remote server, if not already selected
        // int RSGroup(const char *name);

      public:

        CServer(const char *spooldir, MPList * serverlist);

        ~CServer();

        void setttl(time_t ttl_list, time_t ttl_desc) {
                _TTLActive = ttl_list;
                _TTLDesc = ttl_desc;
        }

        // News retrieval functions
        virtual OverviewFmt *overviewfmt() {
                return _OverviewFormat;
        }

        virtual ActiveDB *active();

        void    invalidateActiveDB (void);

        virtual GroupInfo *groupinfo(const char *name);

        virtual Newsgroup *getgroup(const char *name);

        virtual int post(Article * article);

        virtual void spoolarticle(Article * article);

        virtual void postspooled(void);

        virtual void listgroup(const char *gname, char *lstgrp,
                               unsigned int f, unsigned int l);

        virtual void overviewdb(Newsgroup * ng, unsigned int fst,
                                unsigned int lst);

        virtual void article(const char *gname, unsigned int nbr,
                             Article * art);

        virtual void article(const char *id, Article * art);
};

inline void CServer::invalidateActiveDB (void)
{
        _NVActiveDB->setmtime (0,1); // force flag 1 !!
}
#endif

---