const char *
sysapi_get_darwin_info(void)
{
char ver_str[255];
char *args[] = {"/usr/bin/sw_vers", "-productVersion", NULL};
FILE *output_fp;
char tmp_info[262];
char *info_str;
char *os_name = "MacOSX ";
if ((output_fp = my_popenv(args, "r", FALSE)) != NULL) {
fgets(ver_str, 255, output_fp);
my_pclose(output_fp);
} else
{
info_str = strdup( "Unknown" );
}
int ten = 0, major = 0, minor = 0;
int fields = sscanf(ver_str, "%d.%d.%d", &ten, &major, &minor);
if ((fields != 3) || ten != 10) {
dprintf(D_FULLDEBUG, "UNEXPECTED MacOS version string %s", ver_str);
}
sprintf( tmp_info, "%s%d.%d", os_name, major, minor);
info_str = strdup( tmp_info );
if( !info_str ) {
EXCEPT( "Out of memory!" );
}
return info_str;
}
void
GangliaD::initializeHostList()
{
m_monitored_hosts.clear();
m_need_heartbeat.clear();
m_ganglia_metrics_sent = 0;
FILE *fp = my_popenv(m_gstat_argv,"r",MY_POPEN_OPT_WANT_STDERR);
if( !fp ) {
dprintf(D_ALWAYS,"Failed to execute %s: %s\n",m_gstat_command.c_str(),strerror(errno));
return;
}
char line[1024];
while( fgets(line,sizeof(line),fp) ) {
if (char *colon = strchr(line, ':')) {
*colon = 0;
// if number of CPUs > 0, this host is monitored by ganglia
if (atoi(colon + 1) > 0) {
m_monitored_hosts.insert(line);
}
}
}
my_pclose(fp);
dprintf(D_ALWAYS, "Ganglia is monitoring %ld hosts\n", m_monitored_hosts.size());
}
FILE *
email_open_implementation(char *Mailer, const char * final_args[])
{
priv_state priv;
int prev_umask;
FILE *mailerstream;
/* Want the letter to come from "condor" if possible */
priv = set_condor_priv();
/* there are some oddities with how popen can open a pipe. In some
arches, popen will create temp files for locking and they need to
be of the correct perms in order to be deleted. So the umask is
set to something useable for the open operation. -pete 9/11/99
*/
prev_umask = umask(022);
mailerstream = my_popenv(final_args,EMAIL_POPEN_FLAGS,FALSE);
umask(prev_umask);
/* Set priv state back */
set_priv(priv);
if ( mailerstream == NULL ) {
dprintf(D_ALWAYS,"Failed to access email program \"%s\"\n",
Mailer);
}
return mailerstream;
}
PandadClassAdLogPlugin::PandadClassAdLogPlugin() : ClassAdLogPlugin(), pandad( NULL ), scheddInitialized( false ) {
std::string binary;
param( binary, "PANDAD" );
const char * arguments[] = { binary.c_str(), NULL };
pandad = my_popenv( arguments, "w", 0 );
// Never block the schedd.
if( pandad != NULL ) {
if( fcntl( fileno( pandad ), F_SETFL, O_NONBLOCK ) == -1 ) {
dprintf( D_ALWAYS, "PANDA: failed to set pandad pipe to nonblocking, monitor will not be updated.\n" );
pandad = NULL;
}
}
if( pandad == NULL ) {
dprintf( D_ALWAYS, "PANDA: failed to start pandad, monitor will not be updated.\n" );
pandad = fopen( DEVNULL, "w" );
}
// This doesn't handle commas, but boy is it simple.
std::string jaString;
param( jaString, "PANDA_JOB_ATTRIBUTES" );
if( ! jaString.empty() ) {
std::istringstream jaStream( jaString );
std::string attribute;
while( std::getline( jaStream, attribute, ' ' ) ) {
jobAttributes.insert( attribute );
}
}
}
Starter*
StarterMgr::makeStarter( const char* path )
{
Starter* new_starter;
FILE* fp;
char *args[] = { const_cast<char*>(path),
const_cast<char*>("-classad"),
NULL };
char buf[1024];
// first, try to execute the given path with a "-classad"
// option, and grab the output as a ClassAd
// note we run the starter here as root if possible,
// since that is how the starter will be invoked for real,
// and the real uid of the starter may influence the
// list of capabilities the "-classad" option returns.
{
TemporaryPrivSentry sentry(PRIV_ROOT);
fp = my_popenv( args, "r", FALSE );
}
if( ! fp ) {
dprintf( D_ALWAYS, "Failed to execute %s, ignoring\n", path );
return NULL;
}
ClassAd* ad = new ClassAd;
bool read_something = false;
while( fgets(buf, 1024, fp) ) {
read_something = true;
if( ! ad->Insert(buf) ) {
dprintf( D_ALWAYS, "Failed to insert \"%s\" into ClassAd, "
"ignoring invalid starter\n", buf );
delete( ad );
pclose( fp );
return NULL;
}
}
my_pclose( fp );
if( ! read_something ) {
dprintf( D_ALWAYS,
"\"%s -classad\" did not produce any output, ignoring\n",
path );
delete( ad );
return NULL;
}
new_starter = new Starter();
new_starter->setAd( ad );
new_starter->setPath( path );
int is_dc = 0;
ad->LookupBool( ATTR_IS_DAEMON_CORE, is_dc );
new_starter->setIsDC( (bool)is_dc );
return new_starter;
}
/*
How much disk space we need to reserve for the AFS cache. Answer is
in kilobytes.
*/
static int
reserve_for_afs_cache()
{
#ifdef WIN32
return 0;
#else
int answer;
FILE *fp;
const char *args[] = {FS_PROGRAM, FS_COMMAND, NULL};
int cache_size, cache_in_use;
int do_it;
/* See if we're configured to deal with an AFS cache */
do_it = _sysapi_reserve_afs_cache;
/* If we're not configured to deal with AFS cache, just return 0 */
if( !do_it ) {
return 0;
}
/* Run an AFS utility program to learn how big the cache is and
how much is in use. */
dprintf( D_FULLDEBUG, "Checking AFS cache parameters\n" );
fp = my_popenv( args, "r", FALSE );
if( !fp ) {
return 0;
}
if (fscanf( fp, FS_OUTPUT_FORMAT, &cache_in_use, &cache_size ) != 2) {
dprintf( D_ALWAYS, "Failed to parse AFS cache parameters, assuming no cache\n" );
cache_size = 0;
cache_in_use = 0;
}
my_pclose( fp );
dprintf( D_FULLDEBUG, "cache_in_use = %d, cache_size = %d\n",
cache_in_use,
cache_size
);
answer = cache_size - cache_in_use;
/* The cache may be temporarily over size, in this case AFS will
clean up itself, so we don't have to allow for that. */
if( answer < 0 ) {
answer = 0;
}
dprintf( D_FULLDEBUG, "Reserving %d kbytes for AFS cache\n", answer );
return answer;
#endif
}
Starter*
StarterMgr::makeStarter( const char* path )
{
Starter* new_starter;
FILE* fp;
char *args[] = { const_cast<char*>(path),
const_cast<char*>("-classad"),
NULL };
char buf[1024];
// first, try to execute the given path with a "-classad"
// option, and grab the output as a ClassAd
fp = my_popenv( args, "r", FALSE );
if( ! fp ) {
dprintf( D_ALWAYS, "Failed to execute %s, ignoring\n", path );
return NULL;
}
ClassAd* ad = new ClassAd;
bool read_something = false;
while( fgets(buf, 1024, fp) ) {
read_something = true;
if( ! ad->Insert(buf) ) {
dprintf( D_ALWAYS, "Failed to insert \"%s\" into ClassAd, "
"ignoring invalid starter\n", buf );
delete( ad );
pclose( fp );
return NULL;
}
}
my_pclose( fp );
if( ! read_something ) {
dprintf( D_ALWAYS,
"\"%s -classad\" did not produce any output, ignoring\n",
path );
delete( ad );
return NULL;
}
new_starter = new Starter();
new_starter->setAd( ad );
new_starter->setPath( path );
int is_dc = 0;
ad->LookupBool( ATTR_IS_DAEMON_CORE, is_dc );
new_starter->setIsDC( (bool)is_dc );
return new_starter;
}
Shadow*
ShadowMgr::makeShadow( const char* path )
{
Shadow* new_shadow;
FILE* fp;
const char *args[] = {const_cast<char*>(path), "-classad", NULL};
char buf[1024];
// first, try to execute the given path with a "-classad"
// option, and grab the output as a ClassAd
fp = my_popenv( args, "r", FALSE );
if( ! fp ) {
dprintf( D_ALWAYS, "Failed to execute %s, ignoring\n", path );
return NULL;
}
ClassAd* ad = new ClassAd;
bool read_something = false;
while( fgets(buf, 1024, fp) ) {
read_something = true;
if( ! ad->Insert(buf) ) {
dprintf( D_ALWAYS, "Failed to insert \"%s\" into ClassAd, "
"ignoring invalid shadow\n", buf );
delete( ad );
my_pclose( fp );
return NULL;
}
}
my_pclose( fp );
if( ! read_something ) {
dprintf( D_ALWAYS, "\"%s -classad\" did not produce any output, "
"ignoring\n", path );
delete( ad );
return NULL;
}
new_shadow = new Shadow( path, ad );
return new_shadow;
}
float
lookup_load_avg_via_uptime()
{
float loadavg;
FILE *output_fp;
int counter;
char word[20];
if (uptime_path == NULL) {
uptime_path = path_to_uptime();
}
/* We start uptime and pipe its output to ourselves.
* Then we read word by word till we get "load average". We read the
* next number. This is the number we want.
*/
if (uptime_path != NULL) {
char *args[2] = {uptime_path, NULL};
if ((output_fp = my_popenv(args, "r", FALSE)) == NULL) {
return DEFAULT_LOADAVG;
}
do {
if (fscanf(output_fp, "%s", word) == EOF) {
dprintf(D_ALWAYS,"can't get \"average:\" from uptime\n");
my_pclose(output_fp);
return DEFAULT_LOADAVG;
}
if (strcmp(word, "average:") == 0) {
/*
* We are at the required position. Read in the next
* floating
* point number. That is the required average.
*/
if (fscanf(output_fp, "%f", &loadavg) != 1) {
dprintf(D_ALWAYS, "can't read loadavg from uptime\n");
my_pclose(output_fp);
return DEFAULT_LOADAVG;
}
/*
* Some callers of this routine may have a SIGCHLD handler.
* If this is so, calling pclose will interfere withthat.
* We check if this is the case and use fclose instead.
* -- Ajitk
*/
my_pclose(output_fp);
return loadavg;
}
} while (!feof(output_fp));
/*
* Reached EOF before getting at load average! -- Ajitk
*/
my_pclose(output_fp);
}
/* not reached */
return DEFAULT_LOADAVG;
}
extern "C" int
my_systemv(const char *const args[])
{
FILE* fp = my_popenv(args, "w", FALSE);
return (fp != NULL) ? my_pclose(fp) : -1;
}