libwvstreams-dev 4.6.1-11 / usr / include / wvstreams / wvconfemu.h

/* -*- Mode: C++ -*-
 * Worldvisions Weaver Software:
 *   Copyright (C) 1997-2004 Net Integration Technologies, Inc.
 *
 * Basic WvConf emulation layer for UniConf.
 */
#ifndef __WVCONFEMU_H
#define __WVCONFEMU_H

#include "uniconfroot.h"
#include "wvstringtable.h"
#include "wvsorter.h"

#define WvConf WvConfEmu
#define WvConfigSection WvConfigSectionEmu
#define WvConfigSectionList WvConfigSectionListEmu
#define WvConfigEntry WvConfigEntryEmu
#define WvConfigEntryList WvConfigEntryListEmu


class WvConfEmu;
class WvConfigEntryEmu;
class WvConfigSectionEmu;
class WvAuthDaemon;
class WvAuthDaemonSvc;

typedef WvConfEmu WvConfigSectionListEmu;
typedef WvConfigSectionEmu WvConfigEntryListEmu;


class WvConfigEntryEmu
{
public:
    const WvString name;
    WvString value;
    WvConfigEntryEmu(WvStringParm _name, WvStringParm _value):
	name(_name), value(_value)
    {}
};


DeclareWvDict(WvConfigEntryEmu, WvString, name);


class WvConfigSectionEmu
{
private:
    const UniConf uniconf;
    WvConfigEntryEmuDict entries;
    WvStringTable &values;
public:
    const WvString name;
    WvConfigSectionEmu(const UniConf& _uniconf, WvStringParm _name,
		       WvStringTable *_values):
	uniconf(_uniconf), entries(42), values(*_values), name(_name)
    {}
    WvConfigEntryEmu *operator[] (WvStringParm s);
    const char *get(WvStringParm entry, const char *def_val = NULL);
    void set(WvStringParm entry, WvStringParm value);
    void quick_set(WvStringParm entry, WvStringParm value);

    bool isempty() const;

    class Iter;
    friend class Iter;

    typedef WvSorter<WvConfigEntryEmu, WvConfigSectionEmu, Iter> Sorter;
};


DeclareWvDict(WvConfigSectionEmu, WvString, name);


class WvConfigSectionEmu::Iter
{
private:
    WvConfigSectionEmu& sect;
    UniConf::RecursiveIter iter;
    WvLink link;
    WvConfigEntryEmu* entry;
public:
    Iter(WvConfigSectionEmu& _sect):
	sect(_sect), iter(_sect.uniconf), link(NULL, false), entry(NULL)
    { 
        assert(&_sect);
    }
    ~Iter();
    void rewind();
    WvLink *next();
    WvLink *cur();
    WvConfigEntryEmu* ptr() const;
    void* vptr() const;
    WvIterStuff(WvConfigEntryEmu);
};


// parameters are: userdata, section, entry, oldval, newval
typedef wv::function<void(void*, WvStringParm, WvStringParm, WvStringParm, WvStringParm)> WvConfCallback;


class WvConfEmu
{
private:
    struct CallbackInfo
    {
	WvConfCallback callback;
	void* userdata;
	WvString section;
	WvString key;
	void* cookie;
	CallbackInfo(WvConfCallback _callback, void* _userdata,
		     WvStringParm _section, WvStringParm _key,
		     void* _cookie):
	    callback(_callback), userdata(_userdata), section(_section),
	    key(_key), cookie(_cookie)
	{}
    };

    WvConfigSectionEmuDict sections;
    bool hold;
    bool dirty;
    WvList<CallbackInfo> callbacks;
    WvStringTable values;

    void notify(const UniConf &_uni, const UniConfKey &_key);
public:
    const UniConf uniconf;

    WvConfEmu(const UniConf &_uniconf);
    ~WvConfEmu();
    void zap();
    bool isclean() const;
    bool isok() const;
    void load_file(WvStringParm filename);
    void save(WvStringParm filename, int _create_mode = 0666);
    void save();
    void flush();

    WvConfigSectionEmu *operator[] (WvStringParm sect);

    void add_callback(WvConfCallback callback, void *userdata,
		      WvStringParm section, WvStringParm key, void *cookie);
    void del_callback(WvStringParm section, WvStringParm key, void *cookie);

    void add_setbool(bool *b, WvStringParm _section, WvStringParm _key);
    void del_setbool(bool *b, WvStringParm _section, WvStringParm _key);

    // The addname callback will add the key "ent" in "sect" to the "list" 
    // whenever "ent" changes. If ent is empty, add any key in the sect to
    // the list when one is added/deleted/changed
    void add_addname(WvStringList *list, WvStringParm sect, WvStringParm ent);
    void del_addname(WvStringList *list, WvStringParm sect, WvStringParm ent);

    WvString getraw(WvString wvconfstr, int &parse_error);
    int getint(WvStringParm section, WvStringParm entry, int def_val);
    const char *get(WvStringParm section, WvStringParm entry,
		    const char *def_val = NULL);
    int fuzzy_getint(WvStringList &sect, WvStringParm entry,
		  int def_val);
    const char *fuzzy_get(WvStringList &sect, WvStringParm entry,
			  const char *def_val = NULL);

    void setraw(WvString wvconfstr, const char *&value, int &parse_error);
    void setint(WvStringParm section, WvStringParm entry, int value);
    void set(WvStringParm section, WvStringParm entry,
	     const char *value);

    void maybesetint(WvStringParm section, WvStringParm entry,
		     int value);
    void maybeset(WvStringParm section, WvStringParm entry,
		  const char *value);

    void delete_section(WvStringParm section);

    // Gets a user's password and decrypts it.  This isn't defined in wvconf.cc.
    WvString get_passwd(WvStringParm sect, WvStringParm user);
    WvString get_passwd(WvStringParm user)
        { return get_passwd("Users", user); }
    WvString get_passwd2(WvString pwenc);

    // Check the password passed in.  This isn't defined in wvconf.cc
    // We use this function to check passwords since we may not know what
    // the password actually is!
    // If s is not null and has continue_select enabled, check_passwd will
    // pause if the password is incorrect (the pause length depends on how
    // many password failures have occurred recently).
    bool check_passwd(WvStringParm sect, WvStringParm user,
		      WvStringParm passwd, WvStream *s);
    bool check_passwd(WvStringParm user, WvStringParm passwd, WvStream *s)
    {
	return check_passwd("Users", user, passwd, s);
    }

    // Check if the user exists.  This isn't defined in wvconf.cc
    bool user_exists(WvStringParm sect, WvStringParm user);
    bool user_exists(WvStringParm user)
    {
	return user_exists("Users", user);
    }

    // Encrypts and sets a user's password.  This isn't defined in wvconf.cc.
    void set_passwd(WvStringParm sect, WvStringParm user, WvStringParm passwd);
    void set_passwd(WvStringParm user, WvStringParm passwd)
        { set_passwd("Users", user, passwd); }
    WvString set_passwd2(WvStringParm passwd);

    // Converts all passwords to unencrypted format.  Not defined in wvconf.cc.
    void convert_to_old_pw();

    static int check_for_bool_string(const char *s);

    class Iter;
    friend class Iter;
    
private:
/* The following is an ugly hack, but since WvConf is being
 * deprecated, we don't care.
 * 
 * It seems that check_passwd() and user_exists() need to talk to a
 * WvAuthDaemon.  However, making them virtual functions would break since
 * everyone else has to implement them.  So we'll its pointer and accessors
 * here.
 */
private:
    WvAuthDaemon *wvauthd;	// Authentication Daemon
public:
    friend class WvAuthDaemonSvc;
};


class WvConfEmu::Iter
{
    WvConfEmu& conf;
    UniConf::Iter iter;
    WvLink link;
public:
    Iter(WvConfEmu& _conf):
	conf(_conf), iter(conf.uniconf), link(NULL, false)
    {}
    void rewind();
    WvLink *next();
    WvConfigSectionEmu* ptr() const;
    WvIterStuff(WvConfigSectionEmu);
};

#endif // __WVCONFEMU_H