Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

UniSecureGen Class Reference

#include <unisecuregen.h>

Inheritance diagram for UniSecureGen:

Inheritance graph
[legend]
List of all members.

Detailed Description

UniSecureGen wraps a given generator and checks permissions (using a Unix-style scheme) before responding to requests.

The permissions for generator gen are stored in a parallel tree, perms.

It is up to the caller to ensure that the UniPermGen is itself secure. (The easiest way is probably to back it with an ini file in a secure directory.) Note that there is a race condition here: there is no locking to be sure that the UniPermGen is not altered while a key is being looked up. This could come into play, for instance, if the exec permission is removed from a subtree while the UniSecureGen is in the middle of drilldown().

UniSecureGen can be created with a moniker, but only if the particular implementation of file permissions you want is UniPermGen. Otherwise, create a different kind of UniPermGen yourself, pass it to the constructor of this class, and mount it in your UniConf by hand.


Public Member Functions

 UniSecureGen (IUniConfGen *_gen, UniPermGen *_perms)
 UniSecureGen (WvStringParm moniker, UniPermGen *_perms=NULL)
void setcredentials (const UniPermGen::Credentials &_cred)
void setcredentials (WvStringParm user, const WvStringList &groups)
virtual void flush_buffers ()
 Overridden methods.
virtual WvString get (const UniConfKey &key)
 Fetches a string value for a key from the registry.
virtual bool exists (const UniConfKey &key)
 Without fetching its value, returns true if a key exists.
virtual void set (const UniConfKey &key, WvStringParm value)
 Stores a string value for a key into the registry.
virtual bool haschildren (const UniConfKey &key)
 Returns true if a key has children.
virtual Iter * iterator (const UniConfKey &key)
 Returns an iterator over the children of the specified key.
virtual Iter * recursiveiterator (const UniConfKey &key)
 Like iterator(), but the returned iterator is recursive, that is, it will return children of the immediate children, not just the immediate children themselves.
virtual bool refresh ()
 Refreshes information about a key recursively.
virtual void commit ()
 Commits any changes.
IUniConfGeninner () const
 Returns the inner generator.
virtual UniConfKey keymap (const UniConfKey &key)
 A mapping function for filters that remap one keyspace onto another.
virtual UniConfKey reversekeymap (const UniConfKey &key)
 A mapping function for filters that unmap a keyspace.
virtual void prefetch (const UniConfKey &key, bool recursive)
 Indicate that we will eventually be interested in doing get(), haschildren(), or other "get-like" operations on a particular key or tree of keys.
virtual bool isok ()
 Determines if the generator is usable and working properly.
void setcallback (const UniConfGenCallback &callback, void *userdata)
 Sets the callback for change notification.
void dispatch_delta (const UniConfKey &key, WvStringParm value)
 Immediately sends notification that a key has possibly changed.
void hold_delta ()
 Pauses notifications until matched with a call to unhold_delta().
void unhold_delta ()
 Resumes notifications when each hold_delta() has been matched.
void clear_delta ()
 Clears the list of pending notifications without sending them.
void flush_delta ()
 Flushes the list of pending notifications by sending them.
void delta (const UniConfKey &key, WvStringParm value)
 Call this when a key's value or children have possibly changed.
virtual int str2int (WvStringParm s, int defvalue) const
 Converts a string to an integer.
virtual unsigned int addRef ()=0
 Indicate you are using this object.
virtual unsigned int release ()=0
 Indicate that you are finished using this object.
virtual IObjectgetInterface (const UUID &)=0
 Returns the requested XPLC interface.
virtual IWeakRefgetWeakRef ()=0
 Return a weak reference to this object.

Protected Member Functions

void setinner (IUniConfGen *inner)
 Rebinds the inner generator and prepares its callback.


Member Function Documentation

WvString UniSecureGen::get const UniConfKey key  )  [virtual]
 

Fetches a string value for a key from the registry.

If the key doesn't exist, the return value has .isnull() == true.

Reimplemented from UniFilterGen.

bool UniSecureGen::exists const UniConfKey key  )  [virtual]
 

Without fetching its value, returns true if a key exists.

This is provided because it is often more efficient to test existance than to actually retrieve the value.

The default implementation returns !get(key).isnull().

Reimplemented from UniFilterGen.

void UniSecureGen::set const UniConfKey key,
WvStringParm  value
[virtual]
 

Stores a string value for a key into the registry.

If the value is WvString::null, the key is deleted.

Returns true on success.

Reimplemented from UniFilterGen.

bool UniSecureGen::haschildren const UniConfKey key  )  [virtual]
 

Returns true if a key has children.

This is provided because it is often more efficient to test existance than to actually retrieve the keys.

The default implementation uses the iterator returned by iterator() to test whether the child has any keys. Subclasses are strongly encouraged to provide a better implementation.

Reimplemented from UniFilterGen.

UniConfGen::Iter * UniSecureGen::iterator const UniConfKey key  )  [virtual]
 

Returns an iterator over the children of the specified key.

May return NULL or an empty iterator if the key has no children.

The caller takes ownership of the returned iterator and is responsible for deleting it when finished.

Reimplemented from UniFilterGen.

UniConfGen::Iter * UniSecureGen::recursiveiterator const UniConfKey key  )  [virtual]
 

Like iterator(), but the returned iterator is recursive, that is, it will return children of the immediate children, not just the immediate children themselves.

May return NULL if the key has no immediate children (since that means there are also no indirect children).

Note that UniConfGen::recursiveiterator() is a default implementation that just calls iterator() recursively, so it'll work in any derived class without you overriding this function. However, you might want to do it anyway if it would be more efficient in your particular case.

Reimplemented from UniFilterGen.

bool UniSecureGen::refresh  )  [virtual]
 

Refreshes information about a key recursively.

May discard uncommitted data.

The default implementation always returns true.

Reimplemented from UniFilterGen.

void UniSecureGen::commit  )  [virtual]
 

Commits any changes.

The default implementation does nothing.

Reimplemented from UniFilterGen.

void UniFilterGen::setinner IUniConfGen inner  )  [protected, inherited]
 

Rebinds the inner generator and prepares its callback.

The previous generator is NOT destroyed.

UniConfKey UniFilterGen::keymap const UniConfKey key  )  [virtual, inherited]
 

A mapping function for filters that remap one keyspace onto another.

The default implementation of the various functions (get, set, exists, etc) run their keys through this function before forwarding the requests on to the inner generator.

The default implementation of this function doesn't change the key.

Reimplemented in UniSubtreeGen.

UniConfKey UniFilterGen::reversekeymap const UniConfKey key  )  [virtual, inherited]
 

A mapping function for filters that unmap a keyspace.

The default implementation of this function doesn't change the key.

Reimplemented in UniSubtreeGen.

void UniFilterGen::prefetch const UniConfKey key,
bool  recursive
[virtual, inherited]
 

Indicate that we will eventually be interested in doing get(), haschildren(), or other "get-like" operations on a particular key or tree of keys.

The generator may be able to speed up these operations by, say, caching them in advance.

This function is not allowed to do blocking operations. It is allowed to do nothing at all, however, and then get() might block later.

Reimplemented from UniConfGen.

Reimplemented in UniRetryGen.

bool UniFilterGen::isok  )  [virtual, inherited]
 

Determines if the generator is usable and working properly.

The default implementation always returns true.

Reimplemented from UniConfGen.

Reimplemented in UniRetryGen.

void UniConfGen::setcallback const UniConfGenCallback &  callback,
void *  userdata
[virtual, inherited]
 

Sets the callback for change notification.

Must not be reimplemented by subclasses.

Implements IUniConfGen.

void UniConfGen::dispatch_delta const UniConfKey key,
WvStringParm  value
[inherited]
 

Immediately sends notification that a key has possibly changed.

Takes care of the details of invoking the callback.

Note: You probably want to be using delta() instead.

void UniConfGen::hold_delta  )  [inherited]
 

Pauses notifications until matched with a call to unhold_delta().

While paused, notification events are placed into a pending list. Redundant notifications may be discarded.

Use this to safeguard non-reentrant code.

void UniConfGen::unhold_delta  )  [inherited]
 

Resumes notifications when each hold_delta() has been matched.

On resumption, dispatches all pending notifications except those that were destined to watches that were removed.

Use this to safeguard non-reentrant code.

void UniConfGen::clear_delta  )  [inherited]
 

Clears the list of pending notifications without sending them.

Does not affect the hold nesting count.

void UniConfGen::flush_delta  )  [inherited]
 

Flushes the list of pending notifications by sending them.

Does not affect the hold nesting count.

void UniConfGen::delta const UniConfKey key,
WvStringParm  value
[inherited]
 

Call this when a key's value or children have possibly changed.

If the hold nesting count is 0, the notification is sent immediately. Otherwise it is added to a pending list for later.

int UniConfGen::str2int WvStringParm  s,
int  defvalue
const [virtual, inherited]
 

Converts a string to an integer.

If the string is null or not recognized, return defvalue.

This is here to support the common str2int(get(key)).

The default implementation recognizes the booleans 'true', 'yes', 'on' and 'enabled' as 1, and 'false', 'no', 'off' and 'disabled' as 0.

Implements IUniConfGen.

virtual unsigned int IObject::addRef  )  [pure virtual, inherited]
 

Indicate you are using this object.

This increases the reference count of the object by one. Usually, when the reference count reaches zero, the object is freed automatically.

This called a "strong reference", because they will prevent the object from being destroyed. They should thus be used carefully, as they control the lifetime of the object. For example, you do not need to call addRef() on object passed as parameters, unless you intend on keeping them.

addRef() is often called automatically for you in XPLC, but you'll have to call release() by hand sometimes unless you use xplc_ptr.

virtual unsigned int IObject::release  )  [pure virtual, inherited]
 

Indicate that you are finished using this object.

This decreases the reference count of the object by one. Usually, when the reference count reaches zero, the object is freed automatically.

You will usually need to manually release() any object given to you by any other XPLC function, unless you give the object to someone else who will call release.

If you use xplc_ptr, it will do this for you.

virtual IObject* IObject::getInterface const UUID  )  [pure virtual, inherited]
 

Returns the requested XPLC interface.

Will return NULL if the interface is not supported. The returned interface has been addRef()ed, so you will need to release() it when done. Note that the interface returned may be a pointer to the same object or a different one - that's none of your business. Asking for the IObject interface should always return the same pointer for a given logical object, so this can be used for comparison by identity.

You should probably use the convenient mutate() and get() functions instead of this, or use an xplc_ptr, which mutates the object for you.

virtual IWeakRef* IObject::getWeakRef  )  [pure virtual, inherited]
 

Return a weak reference to this object.

A weak reference points at the object, but does not control the lifetime of the object. An object can thus still be deleted while someone holds a weak reference. You will still need to release() the weak reference when you are done with it.

See also:
IWeakRef


The documentation for this class was generated from the following files:
Generated on Tue Jul 12 03:00:22 2005 for WvStreams by  doxygen 1.4.0