def __init__(self, filename, historyFile, interval):
"""Initializes an EventLog that caches events in 'filename', and
periodically writes to 'historyFile' every 'interval' seconds."""
NilEventLog.__init__(self)
if os.path.exists(filename):
self.__dict__.update(readPickled(filename))
assert self.count is not None
assert self.lastRotation is not None
assert self.accumulatedTime is not None
for e in _EVENTS:
if not self.count.has_key(e):
self.count[e] = {}
else:
self.count = {}
for e in _EVENTS:
self.count[e] = {}
self.lastRotation = time()
self.accumulatedTime = 0
self.filename = filename
self.historyFilename = historyFile
for fn in filename, historyFile:
parent = os.path.split(fn)[0]
createPrivateDir(parent)
self.rotateInterval = interval
self.lastSave = time()
self._setNextRotation()
self._lock = RLock()
self.save()
def __init__(self, filename, historyFile, interval):
"""Initializes an EventLog that caches events in 'filename', and
periodically writes to 'historyFile' every 'interval' seconds."""
NilEventLog.__init__(self)
if os.path.exists(filename):
self.__dict__.update(readPickled(filename))
assert self.count is not None
assert self.lastRotation is not None
assert self.accumulatedTime is not None
for e in _EVENTS:
if not self.count.has_key(e):
self.count[e] = {}
else:
self.count = {}
for e in _EVENTS:
self.count[e] = {}
self.lastRotation = time()
self.accumulatedTime = 0
self.filename = filename
self.historyFilename = historyFile
for fn in filename, historyFile:
parent = os.path.split(fn)[0]
createPrivateDir(parent)
self.rotateInterval = interval
self.lastSave = time()
self._setNextRotation()
self._lock = RLock()
self.save()
def __init__(self, baseDir, config, idCache=None):
"""Initialize a ServerList to store servers under baseDir/servers,
creating directories as needed.
"""
self.baseDir = baseDir
self.config = config
if idCache is None:
idCache = mixminion.directory.Directory.IDCache(
os.path.join(baseDir, "xx_idcache"))
self.idCache = idCache
self.serverIDDir = os.path.join(self.baseDir, "server-ids")
self.serverDir = os.path.join(self.baseDir, "servers")
self.rejectDir = os.path.join(self.baseDir, "reject")
self.archiveDir = os.path.join(self.baseDir, "archive")
self.dirArchiveDir = os.path.join(self.baseDir, "dirArchive")
self.lockfile = Lockfile(os.path.join(self.baseDir, ".lock"))
self.rlock = threading.RLock()
self.servers = {}
self.serversByNickname = {}
createPrivateDir(self.serverIDDir)
createPrivateDir(self.serverDir)
createPrivateDir(self.rejectDir)
createPrivateDir(self.archiveDir)
createPrivateDir(self.dirArchiveDir)
self.rescan()
def __init__(self, baseDir, config, idCache=None):
"""Initialize a ServerList to store servers under baseDir/servers,
creating directories as needed.
"""
self.baseDir = baseDir
self.config = config
if idCache is None:
idCache = mixminion.directory.Directory.IDCache(
os.path.join(baseDir, "xx_idcache"))
self.idCache = idCache
self.serverIDDir = os.path.join(self.baseDir, "server-ids")
self.serverDir = os.path.join(self.baseDir, "servers")
self.rejectDir = os.path.join(self.baseDir, "reject")
self.archiveDir = os.path.join(self.baseDir, "archive")
self.dirArchiveDir = os.path.join(self.baseDir, "dirArchive")
self.lockfile = Lockfile(os.path.join(self.baseDir, ".lock"))
self.rlock = threading.RLock()
self.servers = {}
self.serversByNickname = {}
createPrivateDir(self.serverIDDir)
createPrivateDir(self.serverDir)
createPrivateDir(self.rejectDir)
createPrivateDir(self.archiveDir)
createPrivateDir(self.dirArchiveDir)
self.rescan()
def __init__(self, keyroot, keyname, hashroot):
"""Load a set of keys named "keyname" on a server where all keys
are stored under the directory "keyroot" and hashlogs are stored
under "hashroot". """
self.keyroot = keyroot
self.keyname = keyname
self.hashroot= hashroot
self.keydir = keydir = os.path.join(keyroot, "key_"+keyname)
self.hashlogFile = os.path.join(hashroot, "hash_"+keyname)
self.packetKeyFile = os.path.join(keydir, "mix.key")
self.mmtpKeyFile = os.path.join(keydir, "mmtp.key")
self.certFile = os.path.join(keydir, "mmtp.cert")
if os.path.exists(self.mmtpKeyFile):
secureDelete(self.mmtpKeyFile)
if os.path.exists(self.certFile):
secureDelete(self.certFile)
self.descFile = os.path.join(keydir, "ServerDesc")
self.publishedFile = os.path.join(keydir, "published")
self.serverinfo = None
self.validAfter = None
self.validUntil = None
self.published = os.path.exists(self.publishedFile)
if not os.path.exists(keydir):
createPrivateDir(keydir)
def openDB(filename, purpose):
"""Replacement for anydbm.open. Open a database stored in 'filename',
using the best available database implementation. The string 'purpose'
is used to indicate which database has succeeded or failed in any
messages.
Changes from anydbm.open:
- Create parent directory if it doesn't exist.
- Bail with sane error messages if file is non-readable.
- Handle the error case where the database file is created but never
filled.
- Always create the database if it doesn't exist.
- Warn if using a dumbdbm database.
- Return a 2-tuple of the database object and a no-arguments callable
that flushes the database's contents to disk.
"""
parent = os.path.split(filename)[0]
createPrivateDir(parent)
# If the file exists, but can't be read, bail.
try:
st = os.stat(filename)
except OSError, e:
if e.errno != errno.ENOENT:
raise
st = None
def openDB(filename, purpose):
"""Replacement for anydbm.open. Open a database stored in 'filename',
using the best available database implementation. The string 'purpose'
is used to indicate which database has succeeded or failed in any
messages.
Changes from anydbm.open:
- Create parent directory if it doesn't exist.
- Bail with sane error messages if file is non-readable.
- Handle the error case where the database file is created but never
filled.
- Always create the database if it doesn't exist.
- Warn if using a dumbdbm database.
- Return a 2-tuple of the database object and a no-arguments callable
that flushes the database's contents to disk.
"""
parent = os.path.split(filename)[0]
createPrivateDir(parent)
# If the file exists, but can't be read, bail.
try:
st = os.stat(filename)
except OSError, e:
if e.errno != errno.ENOENT:
raise
st = None
def __init__(self, keyroot, keyname, hashroot):
"""Load a set of keys named "keyname" on a server where all keys
are stored under the directory "keyroot" and hashlogs are stored
under "hashroot". """
self.keyroot = keyroot
self.keyname = keyname
self.hashroot = hashroot
self.keydir = keydir = os.path.join(keyroot, "key_" + keyname)
self.hashlogFile = os.path.join(hashroot, "hash_" + keyname)
self.packetKeyFile = os.path.join(keydir, "mix.key")
self.mmtpKeyFile = os.path.join(keydir, "mmtp.key")
self.certFile = os.path.join(keydir, "mmtp.cert")
if os.path.exists(self.mmtpKeyFile):
secureDelete(self.mmtpKeyFile)
if os.path.exists(self.certFile):
secureDelete(self.certFile)
self.descFile = os.path.join(keydir, "ServerDesc")
self.publishedFile = os.path.join(keydir, "published")
self.serverinfo = None
self.validAfter = None
self.validUntil = None
self.published = os.path.exists(self.publishedFile)
if not os.path.exists(keydir):
createPrivateDir(keydir)
def __init__(self, location, dbLocation, insertOnly=0):
self._loc = location
self._dbLoc = dbLocation
if not insertOnly:
self.clean()
self._statusDB = mixminion.Filestore.WritethroughDict(
self._dbLoc, "server cache")
else:
self._statusDB = None
createPrivateDir(location)
def __init__(self, location, dbLocation, insertOnly=0):
self._loc = location
self._dbLoc = dbLocation
if not insertOnly:
self.clean()
self._statusDB = mixminion.Filestore.WritethroughDict(
self._dbLoc, "server cache")
else:
self._statusDB = None
createPrivateDir(location)
def checkKeys(self):
"""Internal method: read information about all this server's
currently-prepared keys from disk.
May raise ConfigError if any of the server descriptors on disk
are invalid.
"""
self.keySets = []
badKeySets = []
firstKey = sys.maxint
lastKey = 0
LOG.debug("Scanning server keystore at %s", self.keyDir)
if not os.path.exists(self.keyDir):
LOG.info("Creating server keystore at %s", self.keyDir)
createPrivateDir(self.keyDir)
# Iterate over the entires in HOME/keys
for dirname in os.listdir(self.keyDir):
# Skip any that aren't directories named "key_INT"
if not os.path.isdir(os.path.join(self.keyDir, dirname)):
continue
if not dirname.startswith('key_'):
LOG.warn("Unexpected directory %s under %s", dirname,
self.keyDir)
continue
keysetname = dirname[4:]
try:
setNum = int(keysetname)
# keep trace of the first and last used key number
if setNum < firstKey: firstKey = setNum
if setNum > lastKey: lastKey = setNum
except ValueError:
LOG.warn("Unexpected directory %s under %s", dirname,
self.keyDir)
continue
# Find the server descriptor...
keyset = ServerKeyset(self.keyDir, keysetname, self.hashDir)
ok = 1
try:
keyset.checkKeys()
except MixError, e:
LOG.warn("Error checking private keys in keyset %s: %s",
keysetname, str(e))
ok = 0
try:
if ok:
keyset.getServerDescriptor()
except (ConfigError, IOError), e:
LOG.warn("Key set %s has invalid/missing descriptor: %s",
keysetname, str(e))
ok = 0
def checkKeys(self):
"""Internal method: read information about all this server's
currently-prepared keys from disk.
May raise ConfigError if any of the server descriptors on disk
are invalid.
"""
self.keySets = []
badKeySets = []
firstKey = sys.maxint
lastKey = 0
LOG.debug("Scanning server keystore at %s", self.keyDir)
if not os.path.exists(self.keyDir):
LOG.info("Creating server keystore at %s", self.keyDir)
createPrivateDir(self.keyDir)
# Iterate over the entires in HOME/keys
for dirname in os.listdir(self.keyDir):
# Skip any that aren't directories named "key_INT"
if not os.path.isdir(os.path.join(self.keyDir,dirname)):
continue
if not dirname.startswith('key_'):
LOG.warn("Unexpected directory %s under %s",
dirname, self.keyDir)
continue
keysetname = dirname[4:]
try:
setNum = int(keysetname)
# keep trace of the first and last used key number
if setNum < firstKey: firstKey = setNum
if setNum > lastKey: lastKey = setNum
except ValueError:
LOG.warn("Unexpected directory %s under %s",
dirname, self.keyDir)
continue
# Find the server descriptor...
keyset = ServerKeyset(self.keyDir, keysetname, self.hashDir)
ok = 1
try:
keyset.checkKeys()
except MixError, e:
LOG.warn("Error checking private keys in keyset %s: %s",
keysetname, str(e))
ok = 0
try:
if ok:
keyset.getServerDescriptor()
except (ConfigError, IOError), e:
LOG.warn("Key set %s has invalid/missing descriptor: %s",
keysetname, str(e))
ok = 0
def configure(self, config, manager):
self.loc = config['Testing/DirectoryDump'].get('Location')
if not self.loc:
return
self.useQueue = config['Testing/DirectoryDump']['UseQueue']
if not os.path.exists(self.loc):
createPrivateDir(self.loc)
self.next = 1 + max([-1] + [int(f) for f in os.listdir(self.loc)])
self.retry = config['Testing/DirectoryDump']['Retry']
manager.enableModule(self)
def configure(self, config, manager):
self.loc = config['Testing/DirectoryDump'].get('Location')
if not self.loc:
return
self.useQueue = config['Testing/DirectoryDump']['UseQueue']
if not os.path.exists(self.loc):
createPrivateDir(self.loc)
self.next = 1 + max([-1]+[int(f) for f in os.listdir(self.loc)])
self.retry = config['Testing/DirectoryDump']['Retry']
manager.enableModule(self)
def _getDHFile(self):
"""Return the filename for the diffie-helman parameters for the
server. Creates the file if it doesn't yet exist."""
dhdir = os.path.split(self.dhFile)[0]
createPrivateDir(dhdir)
if not os.path.exists(self.dhFile):
# ???? This is only using 512-bit Diffie-Hellman! That isn't
# ???? remotely enough.
LOG.info("Generating Diffie-Helman parameters for TLS...")
mixminion._minionlib.generate_dh_parameters(self.dhFile, verbose=0)
LOG.info("...done")
else:
LOG.debug("Using existing Diffie-Helman parameter from %s",
self.dhFile)
return self.dhFile
def _getDHFile(self):
"""Return the filename for the diffie-helman parameters for the
server. Creates the file if it doesn't yet exist."""
dhdir = os.path.split(self.dhFile)[0]
createPrivateDir(dhdir)
if not os.path.exists(self.dhFile):
# ???? This is only using 512-bit Diffie-Hellman! That isn't
# ???? remotely enough.
LOG.info("Generating Diffie-Helman parameters for TLS...")
mixminion._minionlib.generate_dh_parameters(self.dhFile, verbose=0)
LOG.info("...done")
else:
LOG.debug("Using existing Diffie-Helman parameter from %s",
self.dhFile)
return self.dhFile
def getPingerSeed(self):
"""DOCDOC"""
if self.pingerSeed is not None:
return self.pingerSeed
fn = os.path.join(self.keyDir, "pinger.seed")
if os.path.exists(fn):
checkPrivateFile(fn)
r = readFile(fn)
if len(r) == mixminion.Crypto.DIGEST_LEN:
self.pingerSeed = r
return r
self.pingerSeed = r = mixminion.Crypto.trng(mixminion.Crypto.DIGEST_LEN)
createPrivateDir(self.keyDir)
writeFile(fn, r, 0600)
return r
def getPingerSeed(self):
"""DOCDOC"""
if self.pingerSeed is not None:
return self.pingerSeed
fn = os.path.join(self.keyDir, "pinger.seed")
if os.path.exists(fn):
checkPrivateFile(fn)
r = readFile(fn)
if len(r) == mixminion.Crypto.DIGEST_LEN:
self.pingerSeed = r
return r
self.pingerSeed = r = mixminion.Crypto.trng(
mixminion.Crypto.DIGEST_LEN)
createPrivateDir(self.keyDir)
writeFile(fn, r, 0600)
return r
def __init__(self, directory, prng=None):
"""Create a new ClientQueue object, storing packets in 'directory'
and generating random filenames using 'prng'."""
self.dir = directory
createPrivateDir(directory)
# We used to name entries "pkt_X"; this has changed.
# XXXX008a remove this when it's no longer needed.
for fn in os.listdir(directory):
if fn.startswith("pkt_"):
handle = fn[4:]
fname_old = os.path.join(directory, fn)
fname_new = os.path.join(directory, "msg_"+handle)
os.rename(fname_old, fname_new)
self.store = mixminion.Filestore.ObjectMetadataStore(
directory, create=1)
self.metadataLoaded = 0
def __init__(self, directory, prng=None):
"""Create a new ClientQueue object, storing packets in 'directory'
and generating random filenames using 'prng'."""
self.dir = directory
createPrivateDir(directory)
# We used to name entries "pkt_X"; this has changed.
# XXXX008a remove this when it's no longer needed.
for fn in os.listdir(directory):
if fn.startswith("pkt_"):
handle = fn[4:]
fname_old = os.path.join(directory, fn)
fname_new = os.path.join(directory, "msg_" + handle)
os.rename(fname_old, fname_new)
self.store = mixminion.Filestore.ObjectMetadataStore(directory,
create=1)
self.metadataLoaded = 0
def __init__(self, location, create=0, scrub=0):
"""Creates a file store object for a given directory, 'location'. If
'create' is true, creates the directory if necessary. If 'scrub'
is true, removes any incomplete or invalidated messages from the
store."""
secureDelete([]) # Make sure secureDelete is configured. HACK!
self._lock = threading.RLock()
self.dir = location
if not os.path.isabs(location):
LOG.warn("Directory path %s isn't absolute.", location)
if os.path.exists(location) and not os.path.isdir(location):
raise MixFatalError("%s is not a directory" % location)
createPrivateDir(location, nocreate=(not create))
if scrub:
self.cleanQueue()
# Count messages on first time through.
self.n_entries = -1
def __init__(self, location, create=0, scrub=0):
"""Creates a file store object for a given directory, 'location'. If
'create' is true, creates the directory if necessary. If 'scrub'
is true, removes any incomplete or invalidated messages from the
store."""
secureDelete([]) # Make sure secureDelete is configured. HACK!
self._lock = threading.RLock()
self.dir = location
if not os.path.isabs(location):
LOG.warn("Directory path %s isn't absolute.", location)
if os.path.exists(location) and not os.path.isdir(location):
raise MixFatalError("%s is not a directory" % location)
createPrivateDir(location, nocreate=(not create))
if scrub:
self.cleanQueue()
# Count messages on first time through.
self.n_entries = -1
def __init__(self, directory):
"""Create a new FragmentPool storing its messages in 'directory'."""
createPrivateDir(directory)
self.dir = directory
self.pool = None
def __init__(self, directory):
"""Create a new FragmentPool storing its messages in 'directory'."""
createPrivateDir(directory)
self.dir = directory
self.pool = None
