jack2/common/JackTools.cpp

/*
  Copyright (C) 2001 Paul Davis
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public License
  along with this program; if not, write to the Free Software 
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackTools.h"
#include "JackError.h"

namespace Jack
{

#define DEFAULT_TMP_DIR "/tmp"
char* jack_tmpdir = DEFAULT_TMP_DIR;

int JackTools::GetPID() 
{
#ifdef WIN32
	return  _getpid();
#else
	 return getpid();
#endif
}

int JackTools::GetUID() 
{
#ifdef WIN32
	//return  _getpid();
	#error "No getuid function available"
#else
	 return getuid();
#endif
}

char* JackTools::DefaultServerName()
{
    char* server_name;
    if ((server_name = getenv("JACK_DEFAULT_SERVER")) == NULL)
        server_name = "default";
    return server_name;
}

/* returns the name of the per-user subdirectory of jack_tmpdir */
char* JackTools::UserDir()
{
	static char user_dir[PATH_MAX + 1] = "";

	/* format the path name on the first call */
	if (user_dir[0] == '\0') {
		if (getenv ("JACK_PROMISCUOUS_SERVER")) {
			snprintf(user_dir, sizeof(user_dir), "%s/jack", jack_tmpdir);
		} else {
			snprintf(user_dir, sizeof(user_dir), "%s/jack-%d", jack_tmpdir, GetUID());
		}
	}

	return user_dir;
}

/* returns the name of the per-server subdirectory of jack_user_dir() */
char* JackTools::ServerDir(const char* server_name, char* server_dir)
{
	/* format the path name into the suppled server_dir char array,
	 * assuming that server_dir is at least as large as PATH_MAX+1 */

	snprintf(server_dir, PATH_MAX  + 1, "%s/%s", UserDir(), server_name);
	return server_dir;
}

void JackTools::CleanupFiles(const char* server_name)
{
    DIR* dir;
	struct dirent *dirent;
	char dir_name[PATH_MAX + 1] = "";
	ServerDir(server_name, dir_name);

	/* On termination, we remove all files that jackd creates so
	 * subsequent attempts to start jackd will not believe that an
	 * instance is already running. If the server crashes or is
	 * terminated with SIGKILL, this is not possible. So, cleanup
	 * is also attempted when jackd starts.
	 *
	 * There are several tricky issues. First, the previous JACK
	 * server may have run for a different user ID, so its files
	 * may be inaccessible. This is handled by using a separate
	 * JACK_TMP_DIR subdirectory for each user. Second, there may
	 * be other servers running with different names. Each gets
	 * its own subdirectory within the per-user directory. The
	 * current process has already registered as `server_name', so
	 * we know there is no other server actively using that name.
	 */

	/* nothing to do if the server directory does not exist */
	if ((dir = opendir(dir_name)) == NULL) {
		return;
	}

	/* unlink all the files in this directory, they are mine */
	while ((dirent = readdir(dir)) != NULL) {

		char fullpath[PATH_MAX + 1];

		if ((strcmp(dirent->d_name, ".") == 0) || (strcmp (dirent->d_name, "..") == 0)) {
			continue;
		}

		snprintf(fullpath, sizeof(fullpath), "%s/%s", dir_name, dirent->d_name);

		if (unlink(fullpath)) {
			jack_error("cannot unlink `%s' (%s)", fullpath, strerror(errno));
		}
	} 

	closedir(dir);

	/* now, delete the per-server subdirectory, itself */
	if (rmdir(dir_name)) {
 		jack_error("cannot remove `%s' (%s)", dir_name, strerror(errno));
	}

	/* finally, delete the per-user subdirectory, if empty */
	if (rmdir(UserDir())) {
		if (errno != ENOTEMPTY) {
			jack_error("cannot remove `%s' (%s)", UserDir(), strerror(errno));
		}
	}
}


}