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, 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 __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 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 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, directory): """Create a new FragmentPool storing its messages in 'directory'.""" createPrivateDir(directory) self.dir = directory self.pool = None