MDSSession.cpp   [plain text]

/*
 * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
 * 
 * The contents of this file constitute Original Code as defined in and are
 * subject to the Apple Public Source License Version 1.2 (the 'License').
 * You may not use this file except in compliance with the License. Please obtain
 * a copy of the License at http://www.apple.com/publicsource and read it before
 * using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
 * specific language governing rights and limitations under the License.
 */


#include "MDSSession.h"

#include <Security/DbContext.h>
#include "MDSModule.h"

#include <memory>
#include <Security/cssmerr.h>
#include <Security/utilities.h>
#include <Security/logging.h>

#include <sys/types.h>
#include <dirent.h>
#include <fcntl.h>
#include <time.h>

// Location of security plugins.

#define kPluginPath "/System/Library/Security/"

// Location of MDS database and lock files.

#define kDatabasePath "/var/tmp/"
#define kLockFilename kDatabasePath "mds.lock"

// Minimum interval, in seconds, between rescans for plugin changes.

#define kScanInterval 10

//
// Get the current time in a format that matches that in which
// a file's modification time is expressed.
//

static void
getCurrentTime(struct timespec &now)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	TIMEVAL_TO_TIMESPEC(&tv, &now);
}

//
// Create an MDS session.
//

MDSSession::MDSSession (const Guid *inCallerGuid,
                        const CSSM_MEMORY_FUNCS &inMemoryFunctions) :
    DatabaseSession(MDSModule::get().databaseManager()),
    mCssmMemoryFunctions (inMemoryFunctions),
	mLockFd(-1)
{
	fprintf(stderr, "MDSSession::MDSSession\n");
		
    mCallerGuidPresent =  inCallerGuid != nil;
    if (mCallerGuidPresent)
        mCallerGuid = *inCallerGuid;
		
	// make sure the MDS databases have been created, and the required
	// tables have been constructed
	initializeDatabases();
	
	// schedule a scan for plugin changes
	getCurrentTime(mLastScanTime);
}

MDSSession::~MDSSession ()
{
	fprintf(stderr, "MDSSession::~MDSSession\n");
	releaseLock();
}

void
MDSSession::terminate ()
{
	fprintf(stderr, "MDSSession::terminate\n");

    closeAll();
}

//
// In this implementation, install() does nothing, since the databases
// are implicitly created as needed by initialize().
//

void
MDSSession::install ()
{
	// this space intentionally left blank
}

//
// In this implementation, the uninstall() call is not supported since
// we do not allow programmatic deletion of the MDS databases.
//

void
MDSSession::uninstall ()
{
	CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED);
}

//
// Obtain and free a list of names of current databases.
//

void
MDSSession::GetDbNames(CSSM_NAME_LIST_PTR &outNameList)
{
	outNameList = mDatabaseManager.getDbNames(*this);
}

void
MDSSession::FreeNameList(CSSM_NAME_LIST &inNameList)
{
	mDatabaseManager.freeNameList(*this, inNameList);
}

//
// Scan the plugin directory.
//

static bool intervalHasElapsed(const struct timespec &then, const struct timespec &now,
	int intervalSeconds)
{
	return (now.tv_sec - then.tv_sec > intervalSeconds) ||
		((now.tv_sec - then.tv_sec == intervalSeconds) && (now.tv_nsec >= then.tv_nsec));
}

static bool operator <=(const struct timespec &a, const struct timespec &b)
{
	return (a.tv_sec < b.tv_sec) || ((a.tv_sec == b.tv_sec) && (a.tv_nsec <= b.tv_nsec));
}

class PluginInfo
{
public:
	PluginInfo(const char *pluginName, const struct timespec &modTime) : mModTime(modTime) {
		mPluginName = new char[strlen(pluginName) + 1];
		strcpy(mPluginName, pluginName);
	}

	~PluginInfo() { delete [] mPluginName; }
	
	const char *name() { return mPluginName; }
	const struct timespec &modTime() { return mModTime; }
	
private:
	char *mPluginName;
	struct timespec mModTime;
};

//
// Attempt to obtain an exclusive lock over the the MDS databases. The
// parameter is the maximum amount of time, in milliseconds, to spend
// trying to obtain the lock. A value of zero means to return failure
// right away if the lock cannot be obtained.
//

bool
MDSSession::obtainLock(int timeout /* = 0 */)
{
	static const int kRetryDelay = 250; // ms
	
	if (mLockFd >= 0)
		// this session already holds the lock
		return true;
		
	mLockFd = open(kLockFilename, O_CREAT | O_EXCL, 0544);
	while (mLockFd == -1 && timeout >= kRetryDelay) {
		timeout -= kRetryDelay;
		usleep(1000 * kRetryDelay);
		mLockFd = open(kLockFilename, O_CREAT | O_EXCL, 0544);
	}
	
	return (mLockFd != -1);
}

//
// Release the exclusive lock over the MDS databases. If this session
// does not hold the lock, this method does nothing.
//

void
MDSSession::releaseLock()
{
	if (mLockFd != -1) {
		close(mLockFd);
		unlink(kLockFilename);
		mLockFd = -1;
	}
}

//
// If necessary, create the two MDS databases and construct the required
// tables in each database.
//

void
MDSSession::initializeDatabases()
{
	printf("MDSSession::initializeDatabases\n");
	
	static int kLockTimeout = 2000; // ms
	
	// obtain an exclusive lock. in this case we really want the lock, so
	// if it's not immediately available we wait around for a bit
	
	if (!obtainLock(kLockTimeout))
		// something is wrong; either a stale lock file is lying around or
		// some other process is stuck updating the databases
		CssmError::throwMe(CSSM_ERRCODE_MDS_ERROR);
	
	try {
		// check for the existence of the MDS database file; if it exists,
		// assume that the databases have already been properly created
	
		// look for added/removed/changed plugins
	
		scanPluginDirectory();
	}
	catch (...) {
		releaseLock();
		throw;
	}

	// release the exclusive lock
	
	releaseLock();
}

//
// Update the databases due to added/removed/changed plugins. This obtains
// an exclusive lock over the databases, if possible, and then scans the
// module path. If the lock cannot be obtained, it does nothing. The intent
// is that this will be called periodically, so a failure at any given time
// is not a big deal and may simply imply that another process is already
// updating the MDS databases.
//

void
MDSSession::updateDatabases()
{
	// get the current time in the appropriate format
	
	struct timespec now;
	getCurrentTime(now);
	
	if (!intervalHasElapsed(mLastScanTime, now, kScanInterval))
		// its not yet time to rescan
		return;
		
	// regardless of what happens, we don't want to scan again for a while, so reset
	// the last scan time before proceeding
	
	mLastScanTime = now;

	// obtain a lock to avoid having multiple processes scanning for changed plugins;
	// if the lock cannot be obtained immediately, just return and do nothing
	
	if (!obtainLock())
		return;

	// we want to make sure that the lock gets released at all costs, hence
	// this try block:
	
	try {
		scanPluginDirectory();
	}
	catch (...) {
		releaseLock();
		throw;
	}
	
	releaseLock();
}

//
// Determine if a filesystem object is a bundle that should be considered
// as a potential CDSA module by MDS.
//

static bool
isBundle(const char *path)
{
	static const char *bundleSuffix = ".bundle";

	int suffixLen = strlen(bundleSuffix);
	int len = strlen(path);
	
	return (len >= suffixLen) && !strcmp(path + len - suffixLen, bundleSuffix);
}

//
// Scan the module directory looking for added/removed/changed plugins, and
// update the MDS databases accordingly. This assumes that an exclusive lock
// has already been obtained, and that the databases and the required tables
// already exist.
//

void
MDSSession::scanPluginDirectory()
{
	printf("MDSSession::scanPluginDirectory\n");

	// check the modification time on the plugin directory: if it has not changed
	// since the last scan, we're done
	
	struct stat sb;
	if (stat(kPluginPath, &sb)) {
		// can't stat the plugin directory...
		Syslog::warning("MDS: cannot stat plugin directory \"%s\"", kPluginPath);
		return;
	}

	if (sb.st_mtimespec <= mLastScanTime)
		// no changes, we're done until its time for the next scan
		return;
	
	// attempt to open the plugin directory
	
	DIR *dir = opendir(kPluginPath);
	if (dir == NULL) {
		// no plugin directory, hence no modules. clear the MDS directory
		// and log a warning
		Syslog::warning("MDS: cannot open plugin directory \"%s\"", kPluginPath);
		return;
	}
	
	// build a list of the plugins are are currently in the directory, along with
	// their modification times
	
	struct dirent *dp;
	PluginInfoList pluginList;
	
	char tempPath[PATH_MAX];
	
	while ((dp = readdir(dir)) != NULL) {
	
		// stat the file to get its modification time
		
		strncpy(tempPath, kPluginPath, PATH_MAX);
		strncat(tempPath, dp->d_name, PATH_MAX - strlen(kPluginPath));
		
		struct stat sb;
		if (stat(tempPath, &sb) == 0) {
			// do some checking to determine that this path refers to an
			// actual bundle that is likely to be a module
			if (isBundle(tempPath))
				pluginList.push_back(new PluginInfo(tempPath, sb.st_mtimespec));
		}
	}
	
	closedir(dir);
	
	// step 1: for any plugin in the common relation which is no longer present,
	// or which is present but which has been modified since the last scan, remove
	// all its records from the MDS database
		
	removeOutdatedPlugins(pluginList);

	// step 2: for any plugin present but not in the common relation (note it may
	// have been removed in step 1 because it was out-of-date), insert its records
	// into the MDS database

	insertNewPlugins(pluginList);
	
	// free the list of current plugins
	
	for_each_delete(pluginList.begin(), pluginList.end());
}

void
MDSSession::removeOutdatedPlugins(const PluginInfoList &pluginList)
{
	PluginInfoList::const_iterator it;
	for (it = pluginList.begin(); it != pluginList.end(); it++)
		fprintf(stderr, "%s\n", (*it)->name());
}

void
MDSSession::insertNewPlugins(const PluginInfoList &pluginList)
{
}