gnustep/libs-ec
0
0
Fork 0
mirror of https://github.com/gnustep/libs-ec.git synced 2025-02-15 16:11:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libs-ec/EcProcess.m

7394 lines
187 KiB
Objective-C
Raw Permalink Blame History

/** Enterprise Control Configuration and Logging
Copyright (C) 2012 Free Software Foundation, Inc.
Written by: Richard Frith-Macdonald <rfm@gnu.org>
Date: Febrary 2010
Originally developed from 1996 to 2012 by Brainstorm, and donated to
the FSF.
This file is part of the GNUstep project.
This library 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 3 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02111 USA.
*/
#import <Foundation/Foundation.h>
#import <GNUstepBase/GSObjCRuntime.h>
#import <GNUstepBase/NSObject+GNUstepBase.h>
#if GS_USE_GNUTLS
#import <GNUstepBase/GSTLS.h>
static void
setupTLS(NSUserDefaults *u)
{
#if !defined(TLS_DISTRIBUTED_OBJECTS)
if ([u boolForKey: @"EncryptedDO"])
#endif
{
ENTER_POOL
/* Enable encrypted DO if supported by the base library.
*/
if ([NSSocketPort respondsToSelector:
@selector(setClientOptionsForTLS:)])
{
NSDictionary *d;
if (nil == (d = [u dictionaryForKey: @"ClientOptionsForTLS"])
&& nil == (d = [u dictionaryForKey: @"OptionsForTLS"]))
{
d = [NSDictionary dictionary];
}
else
{
NSMutableDictionary *opts;
id o;
/* If we were passed data rather than filenames
* we must set it up as cached data corresponding
* to well known names.
*/
opts = AUTORELEASE([d mutableCopy]);
o = [opts objectForKey: GSTLSCertificateKeyFile];
if ([o isKindOfClass: [NSData class]])
{
[GSTLSObject setData: o
forTLSFile: @"distributed-objects-client-key"];
[opts setObject: @"distributed-objects-client-key"
forKey: GSTLSCertificateKeyFile];
}
o = [opts objectForKey: GSTLSCertificateFile];
if ([o isKindOfClass: [NSData class]])
{
[GSTLSObject setData: o
forTLSFile: @"distributed-objects-client-crt"];
[opts setObject: @"distributed-objects-client-crt"
forKey: GSTLSCertificateFile];
}
d = opts;
}
[NSSocketPort
performSelector: @selector(setClientOptionsForTLS:)
withObject: d];
if (nil == (d = [u dictionaryForKey: @"ServerOptionsForTLS"])
&& nil == (d = [u dictionaryForKey: @"OptionsForTLS"]))
{
d = [NSDictionary dictionary];
}
else
{
NSMutableDictionary *opts;
id o;
/* If we were passed data rather than filenames
* we must set it up as cached data corresponding
* to well known names.
*/
opts = AUTORELEASE([d mutableCopy]);
o = [opts objectForKey: GSTLSCertificateKeyFile];
if ([o isKindOfClass: [NSData class]])
{
[GSTLSObject setData: o
forTLSFile: @"distributed-objects-server-key"];
[opts setObject: @"distributed-objects-server-key"
forKey: GSTLSCertificateKeyFile];
}
o = [opts objectForKey: GSTLSCertificateFile];
if ([o isKindOfClass: [NSData class]])
{
[GSTLSObject setData: o
forTLSFile: @"distributed-objects-server-crt"];
[opts setObject: @"distributed-objects-server-crt"
forKey: GSTLSCertificateFile];
}
d = opts;
}
[NSSocketPort
performSelector: @selector(setServerOptionsForTLS:)
withObject: d];
}
LEAVE_POOL
}
}
#else
static void
setupTLS(NSUserDefaults *u)
{
}
#endif
#import "EcProcess.h"
#import "EcLogger.h"
#import "EcAlarm.h"
#import "EcAlarmDestination.h"
#import "EcHost.h"
#import "EcUserDefaults.h"
#import "EcBroadcastProxy.h"
#import "EcMemoryLogger.h"
#include "config.h"
#if defined(HAVE_LIBCRYPT)
extern char *crypt(const char *key, const char *salt);
#endif
#if HAVE_VALGRIND_VALGRIND_H
#include <valgrind/valgrind.h>
#else
#if HAVE_VALGRIND_H
#include <valgrind.h>
#endif
#endif
#ifdef HAVE_SYS_SIGNAL_H
#include <sys/signal.h>
#endif
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
#ifdef HAVE_SYS_FCNTL_H
#include <sys/fcntl.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
#if defined(HAVE_TERMIOS_H)
#include <termios.h>
#endif
#if defined(HAVE_GETTID)
# include <sys/syscall.h>
# include <sys/types.h>
#endif
#include <stdio.h>
NSString * const EcDidQuitNotification = @"EcDidQuitNotification";
NSString * const EcWillQuitNotification = @"EcWillQuitNotification";
static NSLock_error_handler *original_NSLock_error_handler = NULL;
static void
EcLock_error_handler(id obj, SEL _cmd, BOOL stop, NSString *msg)
{
if (stop && EcProc)
{
EcAlarm *a;
a = [EcAlarm alarmForManagedObject: nil
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmSoftwareProgramError
specificProblem: @"Deadlock detected in this process"
perceivedSeverity: EcAlarmSeverityCritical
proposedRepairAction:
_(@"Please examine in gdb to determine the cause of the"
@" deadlock if possible, then obtain a core dump for examination;"
@" using 'kill -ABRT' for example")
additionalText: [obj description]];
[EcProc alarm: a];
}
(original_NSLock_error_handler)(obj, _cmd, stop, msg);
}
#ifndef __MINGW__
static int reservedPipe[2] = { 0, 0 };
static NSInteger descriptorsMaximum = 0;
#endif
/* Flag to say whether a restart was caused by the mememory maximum
*/
static BOOL memRestart = NO;
#if !defined(EC_DEFAULTS_PREFIX)
#define EC_DEFAULTS_PREFIX nil
#endif
#if !defined(EC_EFFECTIVE_USER)
#define EC_EFFECTIVE_USER nil
#endif
NSUInteger
ecNativeThreadID()
{
#if defined(__MINGW__)
return (NSUInteger)GetCurrentThreadId();
#elif defined(HAVE_GETTID)
return (NSUInteger)syscall(SYS_gettid);
#else
return NSNotFound;
#endif
}
static NSString * const ecControlKey = @"EcControlKey";
/* Return the number of bytes represented by a hexadecimal string (length/2)
* or the number of 8bit characters if the string is not hexadecimal digits.
* If the string is hexadecimal, standardise o uppercase.
*/
static size_t
checkHex(char *str)
{
const char *src = str;
uint8_t *dst = (uint8_t*)str;
size_t l;
while (*src)
{
if (isxdigit(*src))
{
if (islower(*src))
{
*dst = toupper(*src);
}
else
{
*dst = *src;
}
dst++;
}
else if (!isspace(*src))
{
*dst = '\0';
return 0; // Bad character
}
src++;
}
*dst = '\0';
l = ((char*)dst) - str;
if (l%2 == 1)
{
return 0; // Not an even number of digits
}
return l/2; // Return number of bytes represented
}
#if 0
static size_t
trim(char *str)
{
size_t len = 0;
char *frontp = str - 1;
char *endp = NULL;
if (NULL == str || '\0' == str[0])
{
return 0;
}
len = strlen(str);
endp = str + len;
while (isspace(*(++frontp)))
;
while (isspace(*(--endp)) && endp != frontp)
;
if (str + len - 1 != endp)
{
*++endp = '\0';
}
else if (frontp != str && endp == frontp)
{
*str = '\0';
}
if (frontp != str)
{
endp = str;
while (*frontp)
{
*endp++ = *frontp++;
}
*endp = '\0';
}
return endp - str;
}
#endif
@interface EcDefaultRegistration : NSObject
{
NSString *name; // The name/key of the default (without prefix)
NSString *type; // The type text for the default
NSString *help; // The help text for the default
SEL cmd; // method to update when default values change
id obj; // The latest value of the default
id val; // The fallback value of the default
}
+ (void) defaultsChanged: (NSUserDefaults*)defs;
+ (NSMutableString*) listHelp: (NSString*)key;
+ (NSDictionary*) merge: (NSDictionary*)d;
+ (void) registerDefault: (NSString*)name
withTypeText: (NSString*)type
andHelpText: (NSString*)help
action: (SEL)cmd
value: (id)value;
+ (void) showHelp;
@end
/* Lock for controlling access to per-process singleton instance.
*/
static NSRecursiveLock *ecLock = nil;
static NSString *configError = nil;
static BOOL configInProgress = NO;
static BOOL cmdFlagDaemon = NO;
static BOOL cmdFlagTesting = NO;
static BOOL cmdIsRunning = NO;
static BOOL cmdIsRegistered = NO;
static BOOL cmdKeepStderr = NO;
static BOOL cmdKillDebug = NO;
static NSString *cmdBase = nil;
static NSString *cmdInst = nil;
static NSString *cmdName = nil;
static NSString *cmdUser = nil;
static NSUserDefaults *cmdDefs = nil;
static NSString *cmdDebugName = nil;
static NSMutableDictionary *cmdLogMap = nil;
static id<EcMemoryLogger> cmdMemoryLogger = nil;
static NSMutableArray *ecConfigClients = nil;
static NSDate *started = nil; /* Time object was created. */
static NSDate *memStats = nil; /* Time stats were started. */
static NSTimeInterval lastIP = 0.0; /* Time of last input to object. */
static NSTimeInterval lastOP = 0.0; /* Time of last output by object. */
static Class cDateClass = 0;
static Class dateClass = 0;
static Class stringClass = 0;
static int cmdSignalled = 0;
static NSDictionary *ecOperators = nil; // Operator configuration
static NSTimeInterval initAt = 0.0;
/* Internal value for use only by quitting mechanism.
*/
static NSTimeInterval beganQuitting = 0.0; // Start of orderly shutdown
static BOOL ecQuitHandled = NO; // Has ecHandleQuit run?
static NSTimeInterval ecQuitLimit = 180.0; // Time allowed for quit
static NSInteger ecQuitStatus = 0; // Status for the quit
static NSString *ecQuitReason = nil; // Reason for the quit
/* Test to see if the process is trying to quit gracefully.
* If quitting has taken over three minutes, abort immediately.
*/
static BOOL
ecIsQuitting()
{
if (0.0 == beganQuitting)
{
return NO;
}
NSTimeInterval now = [NSDate timeIntervalSinceReferenceDate];
if (now - beganQuitting >= ecQuitLimit)
{
NSLog(@"abort: quitting took too long (after %g sec)\n",
(now - beganQuitting));
signal(SIGABRT, SIG_DFL);
abort();
}
return YES;
}
static RETSIGTYPE
ihandler(int sig)
{
static BOOL beenHere = NO;
signal(sig, ihandler);
if (NO == beenHere)
{
beenHere = YES;
signal(SIGABRT, SIG_DFL);
abort();
}
exit(sig);
#if RETSIGTYPE != void
return 0;
#endif
}
static RETSIGTYPE
qhandler(int sig)
{
if (SIGHUP == sig)
{
static int hupCount = 0;
/* We allow multiple HUP signals since, while shutting down we may
* attempt to write out messages to our terminal, generating more
* signals, and we want to ignore those and shut down cleanly.
*/
if (hupCount++ < 1000)
{
cmdSignalled = 0; // Allow signal to be set.
}
}
/* We store the signal value in a global variable and return to normal
* processing ... that way later code can check on the state of the
* variable and take action outside the handler.
* We can't act immediately here inside the handler as the signal may
* have interrupted some vital library (eg malloc()) and left it in a
* state such that our code can't continue. For instance if we try to
* cleanup after a signal and call free(), the process may hang waiting
* for a lock that the interupted function still holds.
*/
if (0 == cmdSignalled)
{
cmdSignalled = sig; // Record signal for event loop.
}
else
{
static BOOL beenHere = NO;
/* We have been signalled more than once ... so let's try to
* crash rather than continuing.
*/
if (NO == beenHere)
{
beenHere = YES;
signal(SIGABRT, SIG_DFL);
abort();
}
exit(cmdSignalled); // Exit with *first* signal number
}
#if RETSIGTYPE != void
return 0;
#endif
}
NSString*
cmdVersion(NSString *ver)
{
static NSString *version = @"1997-2013";
if (ver != nil)
{
ASSIGNCOPY(version, ver);
}
return version;
}
static NSString *homeDir = nil;
NSString*
cmdHomeDir()
{
return homeDir;
}
void
cmdSetHome(NSString *home)
{
ASSIGNCOPY(homeDir, home);
}
static NSString *logsDir = nil;
NSString*
ecLogsSubdirectory()
{
return logsDir;
}
void
ecSetLogsSubdirectory(NSString *pathComponent)
{
ASSIGNCOPY(logsDir, pathComponent);
}
static NSString *userDir = nil;
static NSString*
cmdUserDir()
{
if (userDir == nil)
return NSHomeDirectoryForUser(cmdUser);
else
return userDir;
}
static NSString*
cmdSetUserDirectory(NSString *dir)
{
if (dir == nil)
{
dir = NSHomeDirectoryForUser(cmdUser);
}
else if ([dir isAbsolutePath] == NO)
{
dir = [NSHomeDirectoryForUser(cmdUser)
stringByAppendingPathComponent: dir];
}
ASSIGNCOPY(userDir, dir);
return userDir;
}
static NSString *dataDir = nil;
/* Return the current data directory.
* Create the directory path if necessary.
*/
NSString*
cmdDataDir()
{
if (dataDir == nil)
{
NSFileManager *mgr = [NSFileManager defaultManager];
NSString *str = cmdUserDir();
BOOL flag;
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
str = [str stringByAppendingPathComponent: @"Data"];
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
if (homeDir != nil)
{
str = [str stringByAppendingPathComponent: homeDir];
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
}
ASSIGNCOPY(dataDir, str);
}
return dataDir;
}
/* Return the current logging directory - if 'today' is not nil, treat it as
* the name of a subdirectory in which todays logs should be archived.
* Create the directory path if necessary.
*/
NSString*
cmdLogsDir(NSString *date)
{
NSFileManager *mgr = [NSFileManager defaultManager];
NSString *str = cmdUserDir();
NSString *component;
BOOL flag;
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
component = ecLogsSubdirectory();
if (nil == component)
{
component = @"DebugLogs";
}
str = [str stringByAppendingPathComponent: component];
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
if (date != nil)
{
str = [str stringByAppendingPathComponent: date];
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
}
if (homeDir != nil)
{
str = [str stringByAppendingPathComponent: homeDir];
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
NSLog(@"Unable to create directory - %@", str);
return nil;
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
NSLog(@"The path '%@' is not a directory", str);
return nil;
}
}
return str;
}
NSString*
cmdLogKey(EcLogType t)
{
switch (t)
{
case LT_DEBUG: return @"Debug";
case LT_WARNING: return @"Warn";
case LT_ERROR: return @"Error";
case LT_AUDIT: return @"Audit";
case LT_ALERT: return @"Alert";
case LT_CONSOLE: return @"Audit"; // Console messages are audited
default: return @"UnknownLogType";
}
}
NSString*
cmdLogName()
{
static NSString *cmdLogName = nil;
if (nil == cmdLogName)
{
[ecLock lock];
if (nil == cmdLogName)
{
NSString *n = cmdName;
if (nil == n)
{
n = [[NSProcessInfo processInfo] processName];
}
cmdLogName = [n copy];
}
[ecLock unlock];
}
return cmdLogName;
}
NSString*
cmdLogFormat(EcLogType t, NSString *fmt)
{
static NSString *h = nil;
NSCalendarDate *c = [[cDateClass alloc] init];
NSString *f = cmdLogKey(t);
NSString *n = cmdLogName();
NSString *d;
NSString *result;
if (h == nil)
{
h = [[[NSHost currentHost] wellKnownName] copy];
}
d = [c descriptionWithCalendarFormat: @"%Y-%m-%d %H:%M:%S.%F %z" locale: nil];
result = [stringClass stringWithFormat: @"%@(%@): %@ %@ - %@\n",
n, h, d, f, fmt];
RELEASE(c);
return result;
}
EcProcess *EcProc = nil;
static NSConnection *EcProcConnection = nil;
static EcAlarmDestination *alarmDestination = nil;
static EcLogger *alertLogger = nil;
static EcLogger *auditLogger = nil;
static EcLogger *debugLogger = nil;
static EcLogger *errorLogger = nil;
static EcLogger *warningLogger = nil;
static NSMutableSet *cmdActions = nil;
static id cmdServer = nil;
static id cmdPTimer = nil;
static NSDictionary *cmdConf = nil;
static NSDate *cmdFirst = nil;
static NSDate *cmdLast = nil;
static BOOL cmdIsTransient = NO;
static NSMutableSet *cmdDebugModes = nil;
static NSMutableDictionary *cmdDebugKnown = nil;
static NSMutableString *replyBuffer = nil;
static SEL cmdTimSelector = 0;
static NSTimeInterval cmdTimInterval = 60.0;
static NSMutableArray *noNetConfig = nil;
static NSMutableDictionary *servers = nil;
static int coreSize = -2; // Not yet set
static BOOL __hasLSAN = NO;
static BOOL __setLSAN = NO;
int __lsan_do_recoverable_leak_check(void) __attribute__((weak));
static int (*ecLeakCheck)(void) = __lsan_do_recoverable_leak_check;
static BOOL
hasLSAN()
{
if (NO == __setLSAN)
{
if (ecLeakCheck)
{
__hasLSAN = YES;
}
__setLSAN = YES;
}
return __hasLSAN;
}
static NSString *hostName = nil;
static NSString *
ecHostName()
{
NSString *name;
[ecLock lock];
if (nil == hostName)
{
hostName = [[[NSHost currentHost] wellKnownName] retain];
}
name = [hostName retain];
[ecLock unlock];
return [name autorelease];
}
static NSString *fullName = nil;
NSString *
ecFullName()
{
NSString *name;
[ecLock lock];
if (nil == fullName)
{
fullName = [[NSString alloc] initWithFormat: @"%@:%@",
ecHostName(), cmdLogName()];
}
name = [fullName retain];
[ecLock unlock];
return [name autorelease];
}
static EcAlarmSeverity memAlarm = EcAlarmSeverityMajor;
static NSString *memType = nil;
static NSString *memUnit = @"KB";
static int memSize = 1024; // Report KB
static NSTimeInterval memTime = 0.0; // Time of last check
static uint64_t memMaximum = 0;
static uint64_t memAllowed = 0;
static uint64_t memInitial = 0;
static uint64_t excAvge = 0; // current period average
static uint64_t memAvge = 0; // current period average
static uint64_t excStrt = 0; // excluded usage at first check
static uint64_t memStrt = 0; // total usage at first check
static uint64_t excLast = 0; // excluded usage at last check
static uint64_t memLast = 0; // total usage at last check
static uint64_t excPrev = 0; // excluded usage at previous warning
static uint64_t memPrev = 0; // total usage at previous warning
static uint64_t excPeak = 0; // excluded peak usage
static uint64_t memPeak = 0; // total peak usage
static uint64_t memBase = 0; // base memory threshold
static uint64_t memWarn = 0; // warning alarm threshold
static uint64_t memMinr = 0; // minor alarm threshold
static uint64_t memMajr = 0; // major alarm threshold
static uint64_t memCrit = 0; // critical aarm threshold
static uint64_t memSlot = 0; // minute counter
static uint64_t excRoll[10]; // last N values
static uint64_t memRoll[10]; // last N values
#define MEMCOUNT (sizeof(memRoll)/sizeof(*memRoll))
static NSString*
setMemAlarm(NSString *str)
{
if (nil == str) str = @"Major";
if ([str caseInsensitiveCompare: @"critical"] == NSOrderedSame)
{
memAlarm = EcAlarmSeverityCritical;
}
else if ([str caseInsensitiveCompare: @"major"] == NSOrderedSame)
{
memAlarm = EcAlarmSeverityMajor;
}
else if ([str caseInsensitiveCompare: @"minor"] == NSOrderedSame)
{
memAlarm = EcAlarmSeverityMinor;
}
else if ([str caseInsensitiveCompare: @"warning"] == NSOrderedSame)
{
memAlarm = EcAlarmSeverityWarning;
}
else
{
memAlarm = EcAlarmSeverityMajor;
}
return [EcAlarm stringFromSeverity: memAlarm];
}
static void
setMemBase()
{
if (0 == memAllowed)
{
if (0 == memBase || memSlot < MEMCOUNT)
{
/* Base must be 20% larger than peak over first ten minutes.
*/
memBase = (memPeak * 120) / 100;
/* The base memory must be at least half the maximum memory.
*/
if (memMaximum > 0 && memBase < memMaximum * 1024 * 512)
{
memBase = memMaximum * 1024 * 512;
}
}
}
else
{
memBase = memAllowed * 1024 * 1024;
}
if (memMaximum > 0)
{
uint64_t max = memMaximum * 1024 * 1024;
if (max >= memBase + 1024)
{
uint64_t band = (max - memBase) / 4;
memWarn = memBase;
memMinr = memWarn + band;
memMajr = memMinr + band;
memCrit = memMajr + band;
}
else
{
memWarn = memMinr = memMajr = memCrit = memBase;
}
}
else
{
memWarn = memMinr = memMajr = memCrit = 0;
}
}
/* Returns the found command, or nil if none is found, or an empty string
* if there was a match but it was in the array of commands to be blockd.
*/
static NSString*
findAction(NSString *cmd, NSArray *allow)
{
NSString *found = nil;
BOOL match = NO;
cmd = [cmd lowercaseString];
[ecLock lock];
if (nil == (found = [cmdActions member: cmd])
|| (allow && NO == [allow containsObject: found]))
{
NSEnumerator *enumerator;
NSString *name;
if (found)
{
found = nil;
match = YES;
}
enumerator = [cmdActions objectEnumerator];
while (nil != (name = [enumerator nextObject]))
{
if (YES == [name hasPrefix: cmd])
{
match = YES;
if (allow && NO == [allow containsObject: name])
{
continue; // This match is not allowed
}
else if (nil == found)
{
found = name;
}
else
{
found = nil; // Ambiguous
break;
}
}
}
}
if (found)
{
cmd = [found retain];
}
else if (match)
{
cmd = @"";
}
else
{
cmd = nil;
}
[ecLock unlock];
return [cmd autorelease];
}
static NSString*
ecCommandHost()
{
NSString *host;
host = [cmdDefs stringForKey: @"CommandHost"];
if (nil == host)
{
host = @""; /* Local host */
}
return host;
}
static NSString*
ecCommandName()
{
NSString *name;
name = [cmdDefs stringForKey: @"CommandName"];
if (nil == name)
{
name = @"Command";
}
return name;
}
NSString *cmdBasicDbg = @"basicMode";
NSString *cmdDefaultDbg = @"basicMode"; // Allow older code to link
NSString *cmdConnectDbg = @"connectMode";
NSString *cmdDetailDbg = @"detailMode";
static int comp_len = 0;
static int
comp(const char* s0, const char* s1)
{
comp_len = 0;
if (s0 == 0) {
s0 = "";
}
if (s1 == 0) {
s1 = "";
}
while (*s0) {
if (*s0 != *s1) {
char c0 = islower(*s0) ? toupper(*s0) : *s0;
char c1 = islower(*s1) ? toupper(*s1) : *s1;
if (c0 != c1) {
if (c0 != '\0') {
comp_len = -1; /* s0 is not a substring of s1. */
}
return(-1);
}
}
comp_len++;
s0++;
s1++;
}
if (*s0 != *s1) {
return(-1);
}
return(0);
}
static NSString*
findMode(NSDictionary* d, NSString* s)
{
NSArray *a = [d allKeys];
NSString *o;
unsigned int i;
const char *s0 = [s UTF8String];
const char *s1;
int best_pos = -1;
int best_len = 0;
for (i = 0; i < [a count]; i++)
{
o = (NSString*)[a objectAtIndex: i];
s1 = [o UTF8String];
if (comp(s0, s1) == 0)
{
return o;
}
if (comp_len > best_len)
{
best_len = comp_len;
best_pos = i;
}
}
if (best_pos >= 0)
{
return (NSString*)[a objectAtIndex: best_pos];
}
return nil;
}
/*
* Auxiliary object representing a remote server a subclass might need
* to connect to. This class is for EcProcess.m internal use.
*/
@interface RemoteServer : NSObject
{
/* This is the string which identifies this server */
NSString *defaultName;
/* These are the actual name and host for this server, as obtained
by configuration for the `defaultName' server */
NSString *name;
NSString *host;
/* The same for multiple servers */
NSArray *multiple;
/* The real object representing the remote server. */
id proxy;
/* An object responding to cmdMadeConnectionToServer: and/or
cmdLostConnectionToServer: */
id delegate;
}
/* Initialize the object - string is the default server name */
- (id) initWithDefaultName: (NSString *)string
delegate: (id)object;
- (NSString *) defaultName;
- (void) setName: (NSString *)string;
- (NSString *) name;
- (void) setHost: (NSString *)string;
- (void) setMultiple: (NSArray*)config;
- (NSArray*) multiple;
/*
* Return a proxy to the remote server; create one if needed by making
* a connection, using name and host.
* If the server is multiple, create a EcBroadcastProxy object, and returns
* that object.
*/
- (id) proxy;
/*
* Internal connection management methods
*/
- (id) connectionBecameInvalid: (NSNotification*)notification;
- (BOOL) connection: (NSConnection*)ancestor
shouldMakeNewConnection: (NSConnection*)newConn;
- (void) BCP: (EcBroadcastProxy *)proxy
lostConnectionToServer: (NSString *)name
host: (NSString *)host;
- (void) BCP: (EcBroadcastProxy *)proxy
madeConnectionToServer: (NSString *)name
host: (NSString *)host;
/*
* Returns YES if the connection is ALIVE, NO if the connection is DEAD
*/
- (BOOL) isConnected;
- (NSString *)description;
- (void) update;
@end
@implementation RemoteServer
- (id) initWithDefaultName: (NSString *)string
delegate: (id)object
{
self = [super init];
if (self != nil)
{
ASSIGNCOPY(defaultName, string);
ASSIGN(name, defaultName);
host = @"*";
multiple = nil;
proxy = nil;
delegate = object;
/*
* Grab configuration information.
*/
[self update];
}
return self;
}
- (void) dealloc
{
DESTROY(defaultName);
DESTROY(name);
DESTROY(host);
DESTROY(multiple);
DESTROY(proxy);
[[NSNotificationCenter defaultCenter] removeObserver: self];
[super dealloc];
}
- (NSString *) defaultName
{
return defaultName;
}
- (void) setName: (NSString *)string
{
if ([name isEqual: string] == NO)
{
ASSIGNCOPY(name, string);
DESTROY(proxy);
}
}
- (NSString *) name
{
return name;
}
- (void) setHost: (NSString *)string
{
if ([host isEqual: string] == NO)
{
ASSIGNCOPY(host, string);
DESTROY(proxy);
}
}
- (NSString *) host
{
return host;
}
- (void) setMultiple: (NSArray *)config
{
if ([multiple isEqual: config] == NO)
{
ASSIGNCOPY(multiple, config);
DESTROY(proxy);
}
}
- (NSArray*) multiple
{
return multiple;
}
- (id) proxy
{
if (nil == proxy)
{
if (nil == multiple)
{
[EcProc cmdDbg: cmdConnectDbg
msg: @"Looking for service %@ on host %@", name, host];
proxy = [NSConnection rootProxyForConnectionWithRegisteredName: name
host: host
usingNameServer: [NSSocketPortNameServer sharedInstance]];
if (proxy != nil)
{
id connection = [proxy connectionForProxy];
RETAIN (proxy);
[connection setDelegate: self];
[[NSNotificationCenter defaultCenter]
addObserver: self
selector: @selector(connectionBecameInvalid:)
name: NSConnectionDidDieNotification
object: connection];
if ([delegate respondsToSelector:
@selector(cmdMadeConnectionToServer:)] == YES)
{
[delegate cmdMadeConnectionToServer: defaultName];
}
[EcProc cmdDbg: cmdConnectDbg
msg: @"Connected to %@ server on host %@",
name, host];
}
else
{
[EcProc cmdDbg: cmdConnectDbg
msg: @"Failed to contact %@ server on host %@",
name, host];
}
}
else /* a multiple server */
{
proxy = [[EcBroadcastProxy alloc] initWithReceivers: multiple];
[proxy BCPsetDelegate: self];
}
}
return proxy;
}
- (id) connectionBecameInvalid: (NSNotification*)notification
{
id connection = [notification object];
[[NSNotificationCenter defaultCenter]
removeObserver: self
name: NSConnectionDidDieNotification
object: connection];
if ([connection isKindOfClass: [NSConnection class]])
{
if (connection == [proxy connectionForProxy])
{
[EcProc cmdDbg: cmdConnectDbg
msg: @"lost connection - clearing %@.",
name];
if ([delegate respondsToSelector:
@selector(cmdLostConnectionToServer:)] == YES)
{
[delegate cmdLostConnectionToServer: defaultName];
}
RELEASE (proxy);
proxy = nil;
}
}
else
{
[self error: "non-Connection sent invalidation"];
}
return self;
}
/* Debugging purposes only */
- (BOOL) connection: (NSConnection*)ancestor
shouldMakeNewConnection: (NSConnection*)newConn
{
[EcProc cmdDbg: cmdConnectDbg
msg: @"New connection %p created", newConn];
return YES;
}
- (BOOL) isConnected
{
if (proxy != nil)
{
return YES;
}
else
{
return NO;
}
}
- (NSString*) description
{
if (multiple == nil)
{
NSString *status;
if (proxy != nil)
{
status = @"LIVE";
}
else
{
status = @"DEAD";
}
return [NSString stringWithFormat:
@"Connection to server `%@' on host `%@' is %@",
name, host, status];
}
else /* multiple server */
{
if (proxy == nil)
{
return [NSString stringWithFormat:
@"Multiple connection to servers %@\n"
@" has not yet been initialized",
multiple];
}
else
{
return [proxy BCPstatus];
}
}
}
- (void) BCP: (EcBroadcastProxy*)proxy
lostConnectionToServer: (NSString*)name
host: (NSString*)host
{
if ([delegate respondsToSelector:
@selector(cmdLostConnectionToServer:)] == YES)
{
/* FIXME: How do we inform delegate of this ? Is it of any use ? */
// [delegate cmdLostConnectionToServer: defaultName];
}
}
- (void) BCP: (EcBroadcastProxy*)proxy
madeConnectionToServer: (NSString*)name
host: (NSString*)host
{
if ([delegate respondsToSelector:
@selector(cmdLostConnectionToServer:)] == YES)
{
/* FIXME: How do we inform delegate of this ? Is it of any use ? */
//[delegate cmdMadConnectionToServer: defaultName];
}
}
- (void) update
{
NSString *configKey;
id configValue;
configKey = [defaultName stringByAppendingString: @"Name"];
configValue = [cmdDefs stringForKey: configKey];
if (nil != configValue)
{
[self setName: configValue];
}
configKey = [defaultName stringByAppendingString: @"Host"];
configValue = [cmdDefs stringForKey: configKey];
if (nil != configValue)
{
[self setHost: configValue];
}
configKey = [defaultName stringByAppendingString: @"BroadCast"];
configValue = [cmdDefs arrayForKey: configKey];
if (nil != configValue)
{
[self setMultiple: configValue];
}
}
@end
@interface EcProcess (Defaults)
- (void) _defMemory: (id)val;
- (void) _defRelease: (id)val;
- (void) _defTesting: (id)val;
@end
@interface EcProcess (Private)
- (void) cmdMesgrelease: (NSArray*)msg;
- (void) cmdMesgtesting: (NSArray*)msg;
- (void) _memCheck;
- (NSString*) _moveLog: (NSString*)name to: (NSDate*)when;
- (void) _timedOut: (NSTimer*)timer;
- (void) _update: (NSMutableDictionary*)info;
@end
@implementation EcProcess
+ (void) atExit
{
if ([NSObject shouldCleanUp])
{
DESTROY(EcProc);
DESTROY(EcProcConnection);
DESTROY(alarmDestination);
DESTROY(alertLogger);
DESTROY(auditLogger);
DESTROY(cmdActions);
DESTROY(cmdConf);
DESTROY(cmdDebugKnown);
DESTROY(cmdDebugModes);
DESTROY(cmdDebugName);
DESTROY(cmdDefs);
DESTROY(cmdFirst);
DESTROY(cmdInst);
DESTROY(cmdLast);
DESTROY(cmdLogMap);
DESTROY(cmdName);
DESTROY(cmdPTimer);
DESTROY(cmdServer);
DESTROY(cmdUser);
DESTROY(dataDir);
DESTROY(debugLogger);
DESTROY(ecLock);
DESTROY(errorLogger);
DESTROY(homeDir);
DESTROY(hostName);
DESTROY(noNetConfig);
DESTROY(replyBuffer);
DESTROY(servers);
DESTROY(started);
DESTROY(userDir);
DESTROY(warningLogger);
DESTROY(cmdMemoryLogger);
}
}
- (Class) _memoryLoggerClassFromBundle: (NSString*)bundleName
{
NSString *path = nil;
Class c = Nil;
NSBundle *bundle = nil;
NSArray *paths =
NSSearchPathForDirectoriesInDomains(NSLibraryDirectory,
NSAllDomainsMask,
YES);
NSEnumerator *e = [paths objectEnumerator];
while (nil != (path = [e nextObject]))
{
path = [path stringByAppendingPathComponent: @"Bundles"];
path = [path stringByAppendingPathComponent: bundleName];
path = [path stringByAppendingPathExtension: @"bundle"];
bundle = [NSBundle bundleWithPath: path];
if (bundle != nil)
{
break;
}
}
if (nil == bundle)
{
[self cmdWarn: @"Could not load bundle '%@'", bundleName];
}
else if (Nil == (c = [bundle principalClass]))
{
[self cmdWarn: @"Could not load principal class from %@ at %@.",
bundleName, path];
}
else if (NO == [c conformsToProtocol: @protocol(EcMemoryLogger)])
{
[self cmdWarn:
@"%@ does not implement the EcMemoryLogger protocol",
NSStringFromClass(c)];
c = Nil;
}
return c;
}
+ (NSString*) ecGetKey: (const char*)name
size: (unsigned)size
md5: (NSData*)digest
{
struct termios old;
struct termios new;
char *one = NULL;
char *two = NULL;
FILE *stream;
NSString *key;
if (size < 16) size = 16;
if (size > 128) size = 128;
/* Open the terminal
*/
if ((stream = fopen("/dev/tty", "r+")) == NULL)
{
return nil;
}
/* Turn echoing off
*/
if (tcgetattr(fileno(stream), &old) != 0)
{
fclose(stream);
return nil;
}
new = old;
new.c_lflag &= ~ECHO;
if (tcsetattr (fileno(stream), TCSAFLUSH, &new) != 0)
{
fclose(stream);
return nil;
}
while (NULL == one || NULL == two)
{
int olen = 0;
int tlen = 0;
while (olen != size)
{
size_t len = 0;
fprintf(stream, "\nPlease enter %s: ", name);
if (one != NULL) { free(one); one = NULL; }
olen = getline(&one, &len, stream);
if (olen < 0)
{
if (one != NULL) { free(one); one = NULL; }
fclose(stream);
return nil;
}
olen = checkHex(one);
if (olen != size)
{
fprintf(stream, "\n%s must be %u hexadecimal digits.\n", name,
size * 2);
olen = 0;
}
else if (nil != digest)
{
CREATE_AUTORELEASE_POOL(pool);
NSString *s;
NSData *d;
NSData *md5;
s = [NSString stringWithUTF8String: one];
d = [[NSData alloc] initWithHexadecimalRepresentation: s];
md5 = [d md5Digest];
RELEASE(d);
if ([digest isEqual: md5])
{
/* If the digest of the key matches the expected value,
* we assume entry was correct and set two to be the
* same as one so we will not prompt for a confirmation.
*/
two = malloc(len + 1);
strcpy(two, one);
tlen = olen;
}
DESTROY(pool);
}
}
while (0 == tlen)
{
size_t len = 0;
fprintf(stream, "\nPlease re-enter %s to confirm: ", name);
if (two != NULL) { free(two); two = NULL; }
tlen = getline(&two, &len, stream);
if (tlen < 0)
{
if (one != NULL) { free(one); one = NULL; }
if (two != NULL) { free(two); two = NULL; }
fclose(stream);
return nil;
}
tlen = checkHex(two);
if (tlen != size)
{
fprintf(stream, "\n%s must be %u hexadecimal digits.\n", name,
size * 2);
tlen = 0;
}
}
if (strcmp(one, two) != 0)
{
free(one); one = NULL;
free(two); two = NULL;
fprintf(stream,
"\nThe strings you entered do not match, please try again.");
}
}
/* Restore terminal. */
(void) tcsetattr(fileno(stream), TCSAFLUSH, &old);
key = [NSString stringWithUTF8String: one];
free(one);
free(two);
fprintf(stream, "\n%s accepted.\n", name);
fclose(stream);
return key;
}
+ (NSMutableDictionary*) ecInitialDefaults
{
NSProcessInfo *pi;
id objects[2];
id keys[2];
pi = [NSProcessInfo processInfo];
objects[0] = [pi processName];
objects[1] = @".";
keys[0] = @"ProgramName";
keys[1] = @"HomeDirectory";
return [NSMutableDictionary dictionaryWithObjects: objects
forKeys: keys
count: 2];
}
+ (NSDictionary*) ecPrepareWithDefaults: (NSDictionary*)defs
{
static BOOL prepared = NO;
[ecLock lock];
if (NO == prepared)
{
NSProcessInfo *pinfo;
NSFileManager *mgr;
NSEnumerator *enumerator;
NSString *str;
NSString *dbg;
NSString *prf;
BOOL flag;
started = RETAIN([dateClass date]);
pinfo = [NSProcessInfo processInfo];
mgr = [NSFileManager defaultManager];
prf = EC_DEFAULTS_PREFIX;
if (nil == prf)
{
prf = @"";
}
ASSIGN(cmdDefs, [NSUserDefaults userDefaultsWithPrefix: prf]);
defs = [EcDefaultRegistration merge: defs];
[cmdDefs registerDefaults: defs];
/* When a process is launched by the Command server it should have
* the desired name set using -LaunchedAs name in the arguments.
* In this case it is also expected to have a property list dictionary
* provided on STDIN preceded by a count specifying the number of bytes
* of property list data. The count is a four byte value in network
* byte order.
*/
if (nil != (str = [cmdDefs stringForKey: @"LaunchedAs"]))
{
NSFileHandle *fh = [NSFileHandle fileHandleWithStandardInput];
NSData *d = [fh readDataOfLength: 4];
uint32_t l = 0;
if (d)
{
uint32_t b;
memcpy(&b, [d bytes], 4);
l = GSSwapBigI32ToHost(b);
}
d = [fh readDataOfLength: l];
NS_DURING
{
defs = [NSPropertyListSerialization propertyListFromData: d
mutabilityOption: 0
format: NULL
errorDescription: NULL];
}
NS_HANDLER
{
defs = nil;
NSLog(@"Unable to de-serialize property list from STDIN");
}
NS_ENDHANDLER
if ([defs count] > 0)
{
NSMutableDictionary *m;
m = AUTORELEASE([[cmdDefs volatileDomainForName: NSArgumentDomain]
mutableCopy]);
[m addEntriesFromDictionary: defs];
[cmdDefs removeVolatileDomainForName: NSArgumentDomain];
[cmdDefs setVolatileDomain: m forName: NSArgumentDomain];
}
}
setupTLS(cmdDefs);
cmdUser = EC_EFFECTIVE_USER;
if (nil == cmdUser)
{
cmdUser = [[cmdDefs stringForKey: @"EffectiveUser"] retain];
}
if (YES == [cmdUser isEqual: @"*"]
|| YES == [cmdUser isEqualToString: NSUserName()])
{
ASSIGN(cmdUser, NSUserName());
}
else if ([cmdUser length] == 0)
{
NSLog(@"This software is not configured to run as any user.\n"
@"You may use the EffectiveUser user default setting"
@" to specify the user (setting this to an asterisk ('*')"
@" allows the software to run as any user). Alternatively"
@" an EC_EFFECTIVE_USER can be defined when the ec library"
@" is built.");
exit(1);
}
else
{
const char *user = [cmdUser UTF8String];
struct passwd *pwd = getpwnam(user);
int uid;
if (pwd != 0)
{
uid = pwd->pw_uid;
}
else
{
NSLog(@"This software is configured to run as the user '%@',"
@" but there does not appear to be any such user.", cmdUser);
if ([cmdUser isEqual: EC_EFFECTIVE_USER])
{
NSLog(@"You may use the EffectiveUser user default setting"
@" to override the user (setting this to an asterisk ('*')"
@" allows the software to run as any user). Alternatively"
@" a different EC_EFFECTIVE_USER can be defined when the"
@" ec library is built.");
}
exit(1);
}
if (uid != (int)geteuid())
{
if (geteuid() == 0 || (int)getuid() == uid)
{
if (0 != setuid(uid))
{
[ecLock unlock];
NSLog(@"You must be '%@' to run this.", cmdUser);
exit(1);
}
}
else
{
[ecLock unlock];
NSLog(@"You must be '%@' to run this.", cmdUser);
exit(1);
}
}
GSSetUserName(cmdUser);
if (NO == [cmdUser isEqualToString: NSUserName()])
{
[ecLock unlock];
NSLog(@"You must be '%@' to run this.", cmdUser);
exit(1);
}
ASSIGN(cmdDefs, [NSUserDefaults userDefaultsWithPrefix: prf]);
if (defs != nil)
{
[cmdDefs registerDefaults: defs];
}
}
/* See if we should keep stderr separate, or merge it with
* our debug output (the default).
* In addition, we can kill debug output (and standard error
* if it's not kept separate) by sending it to /dev/null
*/
cmdKeepStderr = [cmdDefs boolForKey: @"KeepStandardError"];
cmdKillDebug = [cmdDefs boolForKey: @"KillDebugOutput"];
if (nil == noNetConfig)
{
noNetConfig = [[NSMutableArray alloc] initWithCapacity: 4];
[noNetConfig
addObject: [prf stringByAppendingString: @"Daemon"]];
[noNetConfig
addObject: [prf stringByAppendingString: @"EffectiveUser"]];
[noNetConfig
addObject: [prf stringByAppendingString: @"Instance"]];
[noNetConfig
addObject: [prf stringByAppendingString: @"Transient"]];
}
defs = [cmdDefs dictionaryRepresentation];
enumerator = [defs keyEnumerator];
dbg = [prf stringByAppendingString: @"Debug-"];
while ((str = [enumerator nextObject]) != nil)
{
NSString *key = nil;
if ([str hasPrefix: @"Debug-"])
{
key = [str substringFromIndex: 6];
str = [prf stringByAppendingString: str];
}
else if ([str hasPrefix: dbg])
{
key = [str substringFromIndex: [dbg length]];
}
if (key != nil)
{
id obj = [defs objectForKey: str];
if ([cmdDebugKnown objectForKey: key] == nil)
{
[cmdDebugKnown setObject: key forKey: key];
}
if ([obj isKindOfClass: stringClass])
{
if ([obj intValue] != 0
|| [obj isEqual: @"YES"] || [obj isEqual: @"yes"])
{
if ([cmdDebugModes member: key] == nil)
{
[cmdDebugModes addObject: key];
}
}
else
{
if ([cmdDebugModes member: key] != nil)
{
[cmdDebugModes removeObject: key];
}
}
}
}
}
/* See if we have a name specified for this process.
*/
ASSIGN(cmdName, [cmdDefs stringForKey: @"ProgramName"]);
/* If there's no ProgramName specified, but this is a Control server,
* try looking for the ControlName instead.
*/
if (nil == cmdName
&& Nil != NSClassFromString(@"EcControl")
&& YES == [self isSubclassOfClass: NSClassFromString(@"EcControl")])
{
ASSIGN(cmdName, [cmdDefs stringForKey: @"ControlName"]);
}
/* If there's no ProgramName specified, but this is a Command server,
* try looking for the CommandName instead.
*/
if (nil == cmdName
&& Nil != NSClassFromString(@"EcCommand")
&& YES == [self isSubclassOfClass: NSClassFromString(@"EcCommand")])
{
ASSIGN(cmdName, [cmdDefs stringForKey: @"CommandName"]);
}
/* Finally, if no name is given at all, use the standard process name.
*/
if (nil == cmdName)
{
ASSIGN(cmdName, [pinfo processName]);
}
/* This is the base name of the process (without instance)
*/
if (nil == cmdBase)
{
ASSIGN(cmdBase, cmdName);
}
/*
* Make sure our users home directory exists.
*/
str = [cmdDefs objectForKey: @"UserDirectory"];
str = cmdSetUserDirectory(str);
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
[ecLock unlock];
NSLog(@"Unable to create directory - %@", str);
exit(1);
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
[ecLock unlock];
NSLog(@"The path '%@' is not a directory", str);
exit(1);
}
str = [cmdDefs objectForKey: @"HomeDirectory"];
if (str != nil)
{
if ([str length] == 0)
{
str = nil;
}
else if ([str isAbsolutePath] == YES)
{
NSLog(@"Absolute HomeDirectory ignored.");
str = nil;
}
cmdSetHome(str);
}
str = [[cmdDefs stringForKey: @"Instance"] stringByTrimmingSpaces];
if (nil != str)
{
if ([str length] > 0 && isdigit([str characterAtIndex: 0]))
{
str = [NSString stringWithFormat: @"%d", [str intValue]];
}
else
{
str = nil;
}
}
ASSIGN(cmdInst, str);
if (nil != cmdInst)
{
str = [[NSString alloc] initWithFormat: @"%@-%@", cmdName, cmdInst];
ASSIGN(cmdName, str);
[str release];
}
str = userDir;
if (cmdHomeDir() != nil)
{
str = [str stringByAppendingPathComponent: cmdHomeDir()];
}
str = [str stringByStandardizingPath];
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
if ([mgr createDirectoryAtPath: str
withIntermediateDirectories: YES
attributes: nil
error: NULL] == NO)
{
if ([mgr fileExistsAtPath: str isDirectory: &flag] == NO)
{
[ecLock unlock];
NSLog(@"Unable to create directory - %@", str);
exit(1);
}
}
else
{
flag = YES;
}
}
if (flag == NO)
{
[ecLock unlock];
NSLog(@"The path '%@' is not a directory", str);
exit(1);
}
if ([mgr changeCurrentDirectoryPath: str] == NO)
{
[ecLock unlock];
NSLog(@"Unable to move to directory - %@", str);
exit(1);
}
/*
* Make sure the data directory exists.
*/
if (cmdDataDir() == nil)
{
[ecLock unlock];
NSLog(@"Unable to create/access data directory");
exit(1);
}
/*
* Make sure the logs directory exists.
*/
if (cmdLogsDir(nil) == nil)
{
[ecLock unlock];
NSLog(@"Unable to create/access logs directory");
exit(1);
}
[[NSProcessInfo processInfo] setProcessName: cmdName];
prepared = YES;
}
[ecLock unlock];
return defs;
}
+ (void) ecRegisterDefault: (NSString*)name
withTypeText: (NSString*)type
andHelpText: (NSString*)help
action: (SEL)cmd
{
[EcDefaultRegistration registerDefault: name
withTypeText: type
andHelpText: help
action: cmd
value: nil];
}
+ (void) ecRegisterDefault: (NSString*)name
withTypeText: (NSString*)type
andHelpText: (NSString*)help
action: (SEL)cmd
value: (id)value
{
[EcDefaultRegistration registerDefault: name
withTypeText: type
andHelpText: help
action: cmd
value: value];
}
+ (void) ecSetup
{
if (nil != EcProc)
{
[NSException raise: NSGenericException
format: @"+ecSetup called when EcProcess is already set up"];
}
(void)[[self alloc] init];
}
- (void) _commandRemove
{
id connection = [cmdServer connectionForProxy];
if (nil != connection)
{
[connection setDelegate: nil];
[[NSNotificationCenter defaultCenter]
removeObserver: self
name: NSConnectionDidDieNotification
object: connection];
[connection invalidate];
}
DESTROY(cmdServer);
cmdIsRegistered = NO;
}
- (void) _connectionRegistered
{
cmdIsRegistered = YES;
[alarmDestination domanage: nil];
}
static NSString *noFiles = @"No log files to archive";
- (NSString*) cmdBase
{
return cmdBase;
}
- (id) cmdConfig: (NSString*)key
{
return [cmdDefs objectForKey: key];
}
- (NSString*) cmdDataDirectory
{
return cmdDataDir();
}
- (NSUserDefaults*) cmdDefaults
{
return cmdDefs;
}
/* This method handles the final stage of a configuration update either
* from the Control server or via the local NSUserDefaults system.
* If no error has occurred so far, we call the method to check/apply
* the updated config.
* If an error occurs at any stage, we reset the error string and call
* the method to report it.
*/
- (void) _checkUpdate
{
NSString *err;
if (nil == configError)
{
NS_DURING
ASSIGN(configError, [self cmdUpdated]);
NS_HANDLER
NSLog(@"Problem after updating config (in cmdUpdated) %@",
localException);
ASSIGN(configError, @"the -cmdUpdated method raised an exception");
NS_ENDHANDLER
}
err = AUTORELEASE(configError);
configError = nil;
/* NB. if err is nil this will clear any currently raised alarm
*/
[self ecConfigurationError: @"%@", (nil == err) ? @"" : err];
/* Forward new config to any listening clients.
* Remove any clients to which forwarding failed.
*/
if ([ecConfigClients count] > 0)
{
NSDictionary *d = [cmdDefs dictionaryRepresentation];
NSMutableArray *a;
NSUInteger c;
[self ecDoLock];
a = [ecConfigClients mutableCopy];
[self ecUnLock];
c = [a count];
while (c-- > 0)
{
id<EcConfigForwarded> client = [a objectAtIndex: c];
id o = (id)client;
if (YES == [o respondsToSelector: @selector(connectionForProxy)]
&& NO == [[o connectionForProxy] isValid])
{
continue; // Skip send on invalid DO connection
}
NS_DURING
[client ecForwardedConfig: d from: self];
[a removeObjectAtIndex: c];
NS_HANDLER
EcExceptionMajor(localException, @"Failed to forward config");
NS_ENDHANDLER
}
if ((c = [a count]) > 0)
{
[self ecDoLock];
while (c-- > 0)
{
[ecConfigClients removeObjectIdenticalTo: [a objectAtIndex: c]];
}
[self ecUnLock];
}
RELEASE(a);
}
}
/* This method is called when the defaults database is updated for any
* reason and also if the configuration from the Control server changes.
* In the latter case, the notification argument is nil.
* If no error has occurred, we call -cmdDefaultsChanged:
* After this is done, we check that the update is OK (on the next runloop
* iteration in the main thread). The async processing ensures that all
* handling of defaults database notifications has been done before we
* check the effects of the update.
*/
- (void) _defaultsChanged: (NSNotification*)n
{
if (YES == configInProgress)
{
return; // Ignore defaults updates during configuration update.
}
if (YES == ecIsQuitting())
{
NSLog(@"NSUserDefaults change during process shutdown ... ignored.");
return; // Ignore defaults changes during shutdown.
}
if (nil == configError)
{
NS_DURING
[self cmdDefaultsChanged: n];
NS_HANDLER
NSLog(@"Problem in cmdDefaultsChanged:) %@", localException);
ASSIGN(configError,
@"the -cmdDefaultsChanged: method raised an exception");
NS_ENDHANDLER
}
[self performSelectorOnMainThread: @selector(_checkUpdate)
withObject: nil
waitUntilDone: NO];
}
/* This method is only ever run asynchronously in the main thread.
*/
- (void) _ecQuit
{
if (ecDeferQuit > 0)
{
/* Some method needs to complete in this (the main) thread
* before we can quit. Try again in a short time.
*/
[self performSelector: _cmd
withObject: nil
afterDelay: 0.01];
}
else
{
[self ecHandleQuit];
}
}
- (void) cmdDefaultsChanged: (NSNotification*)n
{
NSEnumerator *enumerator;
NSDictionary *dict;
NSString *mode;
NSString *str;
int i;
[EcDefaultRegistration defaultsChanged: cmdDefs];
/* Update debug output kill status if necessary.
*/
if ([cmdDefs boolForKey: @"KillDebugOutput"] != cmdKillDebug)
{
NSFileHandle *hdl;
[ecLock lock];
hdl = [cmdLogMap objectForKey: cmdDebugName];
if (hdl != nil)
{
if (cmdKillDebug == NO)
{
NSString *msg;
msg = cmdLogFormat(LT_WARNING,
@"Logging suppressed by KillDebugOutput=YES");
[hdl writeData: [msg dataUsingEncoding: NSUTF8StringEncoding]];
}
[self ecLogEnd: cmdDebugName to: nil];
}
[ecLock unlock];
cmdKillDebug = (NO == cmdKillDebug ? YES : NO);
[self cmdLogFile: cmdDebugName];
}
enumerator = [cmdDebugKnown keyEnumerator];
while (nil != (mode = [enumerator nextObject]))
{
NSString *key = [@"Debug-" stringByAppendingString: mode];
if (YES == [cmdDefs boolForKey: key])
{
[cmdDebugModes addObject: mode];
}
else
{
[cmdDebugModes removeObject: mode];
}
}
dict = [cmdDefs dictionaryForKey: @"WellKnownHostNames"];
if (nil != dict)
{
[NSHost setWellKnownNames: dict];
[ecLock lock];
ASSIGN(hostName, [[NSHost currentHost] wellKnownName]);
[ecLock unlock];
}
if ((str = [cmdDefs stringForKey: @"CmdInterval"]) != nil)
{
[self setCmdInterval: [str floatValue]];
}
#ifndef __MINGW__
descriptorsMaximum = [cmdDefs integerForKey: @"DescriptorsMaximum"];
#endif
if (NO == hasLSAN())
{
setMemAlarm([cmdDefs stringForKey: @"MemoryAlarm"]);
memAllowed = (uint64_t)[cmdDefs integerForKey: @"MemoryAllowed"];
#if SIZEOF_VOIDP == 4
if (memAllowed >= 4*1024)
{
[self cmdError:
@"MemoryAllowed (%"PRIu64" too large for 32bit machine..."
@" using 0", memAllowed];
memAllowed = 0;
}
#endif
memMaximum = (uint64_t)[cmdDefs integerForKey: @"MemoryMaximum"];
#if SIZEOF_VOIDP == 4
if (memMaximum >= 4*1024)
{
[self cmdError:
@"MemoryMaximum (%"PRIu64" too large for 32bit machine..."
@" using 0", memMaximum];
memMaximum = 0; // Disabled
}
#endif
}
str = [cmdDefs stringForKey: @"CoreSize"];
if (nil == str)
{
i = 2*1024; // 2 GB default
}
else
{
i = [str intValue];
if (i < 0)
{
i = -1; // unlimited
}
}
if (i != coreSize)
{
struct rlimit rlim;
rlim_t want;
coreSize = i;
if (coreSize < 0)
{
want = RLIM_INFINITY;
}
else
{
want = i * 1024 * 1024;
}
if (getrlimit(RLIMIT_CORE, &rlim) < 0)
{
NSLog(@"Unable to get core file size limit: %d", errno);
}
else
{
if (RLIM_INFINITY != rlim.rlim_max && rlim.rlim_max < want)
{
int maxMB = (int)(rlim.rlim_max/(1024*1024));
if (RLIM_INFINITY == want)
{
NSLog(@"Hard limit for core file size (%dMB)"
@" less than requested (unlimited); using %dMB.",
maxMB, maxMB);
}
else
{
NSLog(@"Hard limit for core file size (%dMB)"
@" less than requested (%dMB); using %dMB.",
maxMB, coreSize, maxMB);
}
want = rlim.rlim_max;
}
rlim.rlim_cur = want;
if (setrlimit(RLIMIT_CORE, &rlim) < 0)
{
if (coreSize > 0)
{
NSLog(@"Unable to set core file size limit to %uMB"
@", errno: %d", coreSize, errno);
}
else if (coreSize < 0)
{
NSLog(@"Unable to set core file size unlimited"
@", errno: %d", errno);
}
else
{
NSLog(@"Unable to set core dumps disabled"
@", errno: %d", errno);
}
}
}
}
if (servers != nil)
{
NSEnumerator *e;
RemoteServer *server;
e = [servers objectEnumerator];
while ((server = [e nextObject]))
{
[server update];
}
}
}
- (NSString*) cmdInstance
{
return cmdInst;
}
- (BOOL) cmdIsDaemon
{
return cmdFlagDaemon;
}
- (BOOL) cmdIsTesting
{
return cmdFlagTesting;
}
- (NSDate*) cmdLastIP
{
if (0.0 == lastIP)
{
return nil;
}
return [dateClass dateWithTimeIntervalSinceReferenceDate: lastIP];
}
- (NSDate*) cmdLastOP
{
if (0.0 == lastOP)
{
return nil;
}
return [dateClass dateWithTimeIntervalSinceReferenceDate: lastOP];
}
- (NSString*) ecLogEnd: (NSString*)name to: (NSDate*)when
{
NSString *status = nil;
if ([name length] == 0)
{
NSLog(@"Attempt to end log with empty filename");
}
else
{
NSFileHandle *hdl;
name = [name lastPathComponent];
[self ecDoLock];
hdl = [cmdLogMap objectForKey: name];
if (hdl != nil)
{
/* If the file is empty, remove it, otherwise archive it.
*/
status = [self _moveLog: name to: when];
/* Ensure that all data is written to file, then close it unless it's
* stderr (which we must keep open for logging at all times).
*/
fflush(stderr);
if ([hdl fileDescriptor] != 2)
{
NS_DURING
[hdl closeFile];
NS_HANDLER
NS_ENDHANDLER
}
/*
* Unregister filename.
*/
[cmdLogMap removeObjectForKey: name];
}
[self ecUnLock];
}
return status;
}
- (NSString*) cmdLogEnd: (NSString*)name
{
return [self ecLogEnd: name to: nil];
}
- (NSFileHandle*) cmdLogFile: (NSString*)name
{
NSFileHandle *hdl;
NSString *status = nil;
if ([name length] == 0)
{
NSLog(@"Attempt to log with empty filename");
return nil;
}
name = [name lastPathComponent];
[self ecDoLock];
hdl = [cmdLogMap objectForKey: name];
if (nil == hdl)
{
/* Archive any old left-over file.
*/
[self _moveLog: name to: nil];
if (YES == cmdKillDebug && [name isEqual: cmdDebugName] == YES)
{
/* Output is killed so we don't need to create the file
* and can simply write to /dev/null
*/
hdl = [NSFileHandle fileHandleWithNullDevice];
}
else
{
NSFileManager *mgr = [NSFileManager defaultManager];
NSString *path;
path = [cmdLogsDir(nil) stringByAppendingPathComponent: name];
/* Create the file if necessary, and open it for updating.
*/
if ([mgr isWritableFileAtPath: path] == NO
&& [mgr createFileAtPath: path contents: nil attributes: nil] == NO)
{
NSLog(@"File '%@' is not writable and can't be created", path);
}
else
{
hdl = [NSFileHandle fileHandleForUpdatingAtPath: path];
if (hdl == nil)
{
if (status != nil)
{
NSLog(@"%@", status);
}
NSLog(@"Unable to log to %@", path);
}
else
{
[hdl seekToEndOfFile];
}
}
}
if (hdl == nil)
{
[self ecUnLock];
return nil;
}
/* As a special case, if this is the default debug file
* we must set it up to write to stderr.
*/
if (NO == cmdKeepStderr && [name isEqual: cmdDebugName] == YES)
{
int desc;
desc = [hdl fileDescriptor];
if (desc != 2)
{
dup2(desc, 2);
NS_DURING
[hdl closeFile];
NS_HANDLER
NS_ENDHANDLER
hdl = [NSFileHandle fileHandleWithStandardError];
}
}
/*
* Store the file handle in the dictionary for later use.
*/
[cmdLogMap setObject: hdl forKey: name];
if (status != nil)
{
NSLog(@"%@", status);
}
}
[hdl retain];
[self ecUnLock];
return [hdl autorelease];
}
- (void) cmdLostConnectionToServer: (NSString*)name
{
return;
}
- (void) cmdMadeConnectionToServer: (NSString*)name
{
return;
}
- (NSString*) cmdName
{
return cmdName;
}
- (int) cmdSignalled
{
return cmdSignalled;
}
- (EcAlarmDestination*) ecAlarmDestination
{
return alarmDestination;
}
static BOOL ecDidAwaken = NO;
static BOOL ecDidAwakenCompletely = NO;
- (void) ecAwaken
{
ecDidAwaken = YES;
}
- (void) ecConfigurationError: (NSString*)fmt, ...
{
NSString *err;
va_list ap;
va_start (ap, fmt);
err = [NSString stringWithFormat: fmt arguments: ap];
va_end (ap);
if ([err length] > 0)
{
EcAlarm *a;
/* We may need to truncate additional text to fit the limit for
* an alarm, so we must log to stderr *before* doing that.
*/
NSLog(@"ecConfigurationError: %@", err);
err = [err stringByTrimmingSpaces];
if ([err length] > 255)
{
err = [err substringToIndex: 255];
while (255 < strlen([err UTF8String]))
{
err = [err substringToIndex: [err length] - 1];
}
}
a = [EcAlarm alarmForManagedObject: nil
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmConfigurationOrCustomizationError
specificProblem: @"Fatal configuration error"
perceivedSeverity: EcAlarmSeverityMajor
proposedRepairAction:
_(@"Correct config (check additional text and/or log for details).")
additionalText: err];
[self alarm: a];
[[self ecAlarmDestination] shutdown];
/* Fatal configuration error should be -3 so the Command server knows
*/
[self ecQuitFor: @"configuration error" with: -3];
}
else
{
[self clearConfigurationFor: nil
specificProblem: @"Fatal configuration error"
additionalText: @"Configuration updated"];
}
}
- (BOOL) ecDidAwaken
{
return ecDidAwaken;
}
- (BOOL) ecDidAwakenCompletely
{
return ecDidAwakenCompletely;
}
- (oneway void) ecDidQuit
{
NSArray *keys;
NSUInteger index;
NSInteger status;
NSDate *now;
if (NO == ecIsQuitting())
{
[self ecWillQuit];
}
if (cmdPTimer != nil)
{
[cmdPTimer invalidate];
cmdPTimer = nil;
}
status = ecQuitStatus;
if (0 == status)
{
/* Normal shutdown ... unmanage this process first.
*/
[[self ecAlarmDestination] unmanage: nil];
}
[[self ecAlarmDestination] shutdown];
/* Almost done ... flush any logs then write the final audit log and
* flush again (so that audit log should be the last in the file).
*/
[self cmdFlushLogs];
if (0 == status)
{
[self cmdAudit: @"Shutdown '%@' (normal)", [self cmdName]];
}
else if (-1 == status)
{
[self cmdAudit: @"Shutdown '%@' (restart)", [self cmdName]];
}
else
{
[self cmdAudit: @"Shutdown '%@' (status %"PRIdPTR")",
[self cmdName], status];
}
[auditLogger flush];
/* Now that the audit log has been flushed to the Command/Control
* servers, we can unregister from Command.
*/
if (nil != cmdServer)
{
NS_DURING
{
if (cmdIsRegistered)
{
cmdIsRegistered = NO;
[cmdServer unregisterByObject: self status: ecQuitStatus];
}
}
NS_HANDLER
{
[self _commandRemove];
NSLog(@"Caught exception unregistering from Command: %@",
localException);
}
NS_ENDHANDLER
[self _commandRemove];
}
/* Re-do the alarm destination shut down, just in case an alarm
* occurred while we were flushing logs and/or unregistering.
*/
[[self ecAlarmDestination] shutdown];
DESTROY(alarmDestination);
/* Ensure our DO connection is invalidated so there will be no more
* remote communications or connection related events.
*/
[EcProcConnection setDelegate: nil];
[[NSNotificationCenter defaultCenter]
removeObserver: self
name: nil
object: EcProcConnection];
[EcProcConnection invalidate];
/* The very last thing we do is to close down the log filed so they
* are archived to the correct directory for the current date.
*/
keys = [cmdLogMap allKeys];
now = [NSDate date];
for (index = 0; index < [keys count]; index++)
{
[self ecLogEnd: [keys objectAtIndex: index] to: now];
}
[[NSNotificationCenter defaultCenter]
postNotificationName: EcDidQuitNotification
object: self];
exit(status);
}
- (EcAlarm*) ecException: (NSException*)cause
specificProblem: (NSString*)specificProblem
perceivedSeverity: (EcAlarmSeverity)perceivedSeverity
message: (NSString*)format, ...
{
va_list ap;
EcAlarm *a;
va_start (ap, format);
a = [self ecException: cause
specificProblem: specificProblem
perceivedSeverity: perceivedSeverity
message: format
arguments: ap];
va_end (ap);
return a;
}
- (EcAlarm*) ecException: (NSException*)cause
specificProblem: (NSString*)specificProblem
perceivedSeverity: (EcAlarmSeverity)perceivedSeverity
message: (NSString*)format
arguments: (va_list)args
{
EcAlarm *alarm;
NSArray *stack;
NSCalendarDate *now;
NSString *msg;
NSMutableString *full;
ENTER_POOL
if (nil == (msg = specificProblem))
{
msg = (nil == cause) ? @"Code/Data Error" : @"Exception";
}
if ([msg length] > 255)
{
msg = [msg substringToIndex: 255];
}
while (strlen([msg UTF8String]) > 255)
{
msg = [msg substringToIndex: [msg length] - 1];
}
specificProblem = msg;
msg = [NSString stringWithFormat: format arguments: args];
full = [NSMutableString stringWithCapacity: 1000];
[full appendFormat: @"%@: %@", specificProblem, msg];
if (nil == (stack = [cause callStackSymbols]))
{
stack = [NSThread callStackSymbols];
}
if (nil != cause)
{
NSDictionary *info = [cause userInfo];
[full appendFormat: @" <NSException> NAME:%@ REASON:%@",
[cause name], [cause reason]];
if (nil != info)
{
[full appendFormat: @" INFO:%@", info];
}
}
if (nil != stack)
{
NSUInteger count = [stack count];
NSUInteger index;
/* Delete the frame containign this method, so we show the
* trace to the actual point where the method was called.
*/
for (index = 0; index < count; index++)
{
NSString *line = [stack objectAtIndex: index];
NSRange r;
r = [line rangeOfString:
@"_ecException_specificProblem_perceivedSeverity_message_"];
if (r.length > 0)
{
NSMutableArray *m = AUTORELEASE([stack mutableCopy]);
r = NSMakeRange(0, index + 1);
[m removeObjectsInRange: r];
stack = m;
count = [stack count];
break;
}
}
[full appendString: @"\nCall Stack trace:\n"];
for (index = 0; index < count; index++)
{
NSString *line = [stack objectAtIndex: index];
[full appendFormat: @"%3u: %@\n", (unsigned)index, line];
}
}
NSLog(@"%@", full);
now = [NSCalendarDate date];
if ([msg length] > 250)
{
msg = [[msg substringToIndex: 250] stringByAppendingString: @" ..."];
}
while (strlen([msg UTF8String]) > 255)
{
msg = [msg substringToIndex: [msg length] - 1];
}
if (EcAlarmSeverityCleared == perceivedSeverity)
{
alarm = nil;
}
else
{
alarm = [EcAlarm alarmForManagedObject: nil
at: now
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmSoftwareProgramError
specificProblem: specificProblem
perceivedSeverity: perceivedSeverity
proposedRepairAction: @"Check debug log file for details,"
@" correct the problem, use the Console to clear the alarm"
@" in the originating process."
additionalText: msg];
[self alarm: alarm];
RETAIN(alarm);
}
LEAVE_POOL;
return AUTORELEASE(alarm);
}
- (void) ecHandleQuit
{
if (NO == ecIsQuitting())
{
[self ecWillQuit];
}
ecQuitHandled = YES;
[self performSelectorOnMainThread: @selector(ecDidQuit)
withObject: nil
waitUntilDone: NO];
}
- (BOOL) ecIsQuitting
{
return ecIsQuitting();
}
- (NSTimeInterval) ecQuitDuration
{
if (ecIsQuitting())
{
return [NSDate timeIntervalSinceReferenceDate] - beganQuitting;
}
return 0.0;
}
- (oneway void) ecQuitFor: (NSString*)reason with: (NSInteger)status
{
[ecLock lock];
if (0.0 == beganQuitting)
{
NSLog(@"-[%@ ecQuit: %@ for: %ld]", NSStringFromClass([self class]),
reason, (long)status);
RELEASE(ecQuitReason);
ecQuitReason = [reason copy];
ecQuitStatus = status;
}
[ecLock unlock];
[self ecWillQuit];
if (class_getMethodImplementation([EcProcess class], @selector(cmdQuit:))
!= class_getMethodImplementation([self class], @selector(cmdQuit:)))
{
/* The -cmdQuit: method was overridden by a subclass, so we must call
* it for backward compatibility.
*/
[self cmdQuit: status];
}
else
{
[self performSelectorOnMainThread: @selector(_ecQuit)
withObject: nil
waitUntilDone: NO];
}
}
- (NSTimeInterval) ecQuitLimit: (NSTimeInterval)seconds
{
NSTimeInterval old = ecQuitLimit;
ecQuitLimit = seconds;
return old;
}
- (NSString*) ecQuitReason
{
return ecQuitReason;
}
- (NSInteger) ecQuitStatus
{
return ecQuitStatus;
}
- (oneway void) ecRestart: (NSString*)reason
{
if (NO == [NSThread isMainThread])
{
[self performSelectorOnMainThread: _cmd
withObject: reason
waitUntilDone: NO];
return;
}
[self cmdAudit: @"Restarting '%@' (%@)", [self cmdName], reason];
[auditLogger flush];
if (memRestart)
{
[self ecQuitFor: reason with: -5]; // -5 tells Command to relaunch
}
else
{
[self ecQuitFor: reason with: -1]; // -1 tells Command to relaunch
}
}
- (void) ecLoggersChanged: (NSNotification*)n
{
DESTROY(alertLogger);
DESTROY(auditLogger);
DESTROY(debugLogger);
DESTROY(errorLogger);
DESTROY(warningLogger);
}
- (NSDate*) ecStarted
{
return started;
}
- (void) ecWillQuit
{
NSTimeInterval now = [NSDate timeIntervalSinceReferenceDate];
if (0.0 == beganQuitting)
{
beganQuitting = now;
#ifndef __MINGW__
if (reservedPipe[1] > 0)
{
close(reservedPipe[0]); reservedPipe[0] = 0;
close(reservedPipe[1]); reservedPipe[1] = 0;
}
#endif
if ([ecQuitReason length] > 0)
{
NSLog(@"will quit: %@", ecQuitReason);
}
[[NSNotificationCenter defaultCenter]
postNotificationName: EcWillQuitNotification
object: self];
}
else
{
if ([ecQuitReason length] > 0)
{
NSLog(@"ignored: quit requested (%@) while quitting after %g sec.\n",
ecQuitReason, (now - beganQuitting));
}
else
{
NSLog(@"ignored: quit requested while quitting after %g sec.\n",
(now - beganQuitting));
}
}
}
- (oneway void) alarm: (in bycopy EcAlarm*)event
{
[[self ecAlarmDestination] alarm: event];
}
- (EcAlarm*) alarmConfigurationFor: (NSString*)managedObject
specificProblem: (NSString*)specificProblem
additionalText: (NSString*)additionalText
critical: (BOOL)isCritical
{
EcAlarmSeverity severity;
NSString *action;
EcAlarm *a;
NSString *s;
s = specificProblem;
if ([s length] > 255)
{
s = [s substringToIndex: 255];
}
while (strlen([s UTF8String]) > 255)
{
s = [s substringToIndex: [s length] - 1];
}
specificProblem = s;
s = additionalText;
if ([s length] > 255)
{
s = [s substringToIndex: 255];
}
while (strlen([s UTF8String]) > 255)
{
s = [s substringToIndex: [s length] - 1];
}
additionalText = s;
if (YES == isCritical)
{
severity = EcAlarmSeverityCritical;
}
else
{
severity = EcAlarmSeverityMajor;
}
action = @"Check/correct configuration"; // FIXME ... localize
a = [EcAlarm alarmForManagedObject: managedObject
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmConfigurationOrCustomizationError
specificProblem: specificProblem
perceivedSeverity: severity
proposedRepairAction: action
additionalText: additionalText];
[self alarm: a];
return a;
}
- (NSArray*) alarms
{
return [[self ecAlarmDestination] alarms];
}
- (void) clearConfigurationFor: (NSString*)managedObject
specificProblem: (NSString*)specificProblem
additionalText: (NSString*)additionalText
{
EcAlarm *a;
a = [EcAlarm alarmForManagedObject: managedObject
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmConfigurationOrCustomizationError
specificProblem: specificProblem
perceivedSeverity: EcAlarmSeverityCleared
proposedRepairAction: nil
additionalText: additionalText];
[self alarm: a];
}
- (oneway void) domanage: (in bycopy NSString*)managedObject
{
[[self ecAlarmDestination] domanage: managedObject];
}
- (oneway void) unmanage: (in bycopy NSString*)managedObject
{
[[self ecAlarmDestination] unmanage: managedObject];
}
- (int) processIdentifier
{
static int pi = 0;
if (0 == pi)
{
pi = [[NSProcessInfo processInfo] processIdentifier];
}
return pi;
}
- (void) setCmdInterval: (NSTimeInterval)interval
{
if (interval > 300.0)
{
NSLog(@"Ignored attempt to set timer interval to %g ... using 60.0", interval);
interval = 60.0;
}
if (interval < 0.001)
{
NSLog(@"Ignored attempt to set timer interval to %g ... using 10.0", interval);
interval = 10.0;
}
if (interval != cmdTimInterval)
{
cmdTimInterval = interval;
[self triggerCmdTimeout];
}
}
- (oneway void) ecCancelConfigFwdTo: (id<EcConfigForwarded>)client
{
[self ecDoLock];
[ecConfigClients removeObjectIdenticalTo: client];
[self ecUnLock];
}
- (NSString*) ecCopyright
{
return @"";
}
- (void) ecDoLock
{
[ecLock lock];
}
- (bycopy NSDictionary*) ecSetupConfigFwdTo: (id<EcConfigForwarded>)client
{
NSDictionary *config = nil;
[self ecDoLock];
/* Ensure the array exists; do this before -indexOfObjectIdenticalTo: as
* calling the method on a nil arraqy would always return 0.
*/
if (nil == ecConfigClients)
{
ecConfigClients = [NSMutableArray new];
}
if ([ecConfigClients indexOfObjectIdenticalTo: client] == NSNotFound)
{
[ecConfigClients addObject: client];
}
config = [cmdDefs dictionaryRepresentation];
[self ecUnLock];
return config;
}
- (void) ecUnLock
{
[ecLock unlock];
}
+ (NSRecursiveLock*) ecLock
{
return ecLock;
}
+ (void) initialize
{
if (NULL == original_NSLock_error_handler)
{
original_NSLock_error_handler = _NSLock_error_handler;
_NSLock_error_handler = EcLock_error_handler;
}
if (nil == ecLock)
{
setupTLS([NSUserDefaults standardUserDefaults]);
ecLock = [NSRecursiveLock new];
dateClass = [NSDate class];
cDateClass = [NSCalendarDate class];
stringClass = [NSString class];
cmdLogMap = [[NSMutableDictionary alloc] initWithCapacity: 4];
cmdDebugModes = [[NSMutableSet alloc] initWithCapacity: 4];
cmdDebugKnown = [[NSMutableDictionary alloc] initWithCapacity: 4];
[cmdDebugKnown setObject: @"Mode for distributed object connections"
forKey: cmdConnectDbg];
[cmdDebugKnown setObject: @"Standard mode for basic debug information"
forKey: cmdBasicDbg];
[cmdDebugKnown setObject: @"Detailed but general purpose debugging"
forKey: cmdDetailDbg];
[cmdDebugModes addObject: cmdBasicDbg];
[self ecRegisterDefault: @"Memory"
withTypeText: @"YES/NO"
andHelpText: @"Enable memory allocation checks"
action: @selector(_defMemory:)
value: @"YES"];
[self ecRegisterDefault: @"Release"
withTypeText: @"YES/NO"
andHelpText: @"Turn on double release checks (debug)"
action: @selector(_defRelease:)
value: @"NO"];
[self ecRegisterDefault: @"Testing"
withTypeText: @"YES/NO"
andHelpText: @"Run in test mode (if supported)"
action: @selector(_defTesting:)
value: @"NO"];
/*
* Set the timeouts for the default connection so that
* they will be inherited by other connections.
* A two minute timeout is long enough for almost all
* circumstances.
*/
[[NSConnection defaultConnection] setRequestTimeout: 120.0];
[[NSConnection defaultConnection] setReplyTimeout: 120.0];
[self registerAtExit];
}
}
- (void) addServerToList: (NSString *)serverName
{
[self addServerToList: serverName for: nil];
}
- (void) addServerToList: (NSString *)serverName for: (id)anObject
{
RemoteServer *remote;
if ((serverName == nil)
|| ([serverName isKindOfClass: [NSString class]] == NO))
{
NSLog (@"Warning: invalid string passed to addServerToList:for:");
return;
}
if (anObject == nil)
{
anObject = self;
}
if (servers == nil)
{
servers = [[NSMutableDictionary alloc] initWithCapacity: 2];
}
remote = [[RemoteServer alloc] initWithDefaultName: serverName
delegate: anObject];
[servers setObject: remote forKey: serverName];
[remote release];
}
- (void) removeServerFromList: (NSString *)serverName
{
if ((serverName == nil)
|| ([serverName isKindOfClass: [NSString class]] == NO))
{
NSLog (@"Warning: invalid array passed to removeServerFromList:");
return;
}
[servers removeObjectForKey: serverName];
}
- (id) cmdConnectionBecameInvalid: (NSNotification*)notification
{
id connection;
connection = [notification object];
[connection setDelegate: nil];
[[NSNotificationCenter defaultCenter]
removeObserver: self
name: NSConnectionDidDieNotification
object: connection];
if (cmdServer != nil && connection == [cmdServer connectionForProxy])
{
[[self ecAlarmDestination] setDestination: nil];
DESTROY(cmdServer);
NSLog(@"lost connection %p to command server\n", connection);
/*
* Cause timeout to go off really soon so we will try to
* re-establish the link to the server.
*/
[self triggerCmdTimeout];
}
else
{
NSLog(@"unknown connection sent invalidation\n");
}
return self;
}
- (void) cmdAlert: (NSString*)fmt arguments: (va_list)args
{
if (nil == alertLogger)
{
alertLogger = [[EcLogger loggerForType: LT_ALERT] retain];
}
[alertLogger log: fmt arguments: args];
}
- (void) cmdAlert: (NSString*)fmt, ...
{
va_list ap;
va_start (ap, fmt);
[self cmdAlert: fmt arguments: ap];
va_end (ap);
}
- (NSString*) ecArchive: (NSDate*)when
{
NSString *status = @"";
if ([cmdLogMap count] == 0)
{
status = noFiles;
}
else
{
NSEnumerator *enumerator;
NSString *name;
[self ecDoLock];
enumerator = [[cmdLogMap allKeys] objectEnumerator];
[self ecUnLock];
while ((name = [enumerator nextObject]) != nil)
{
NSString *s;
s = [self ecLogEnd: name to: when];
if (nil != s)
{
if ([status length] > 0)
status = [status stringByAppendingString: @"\n"];
status = [status stringByAppendingString: s];
}
if (NO == ecIsQuitting())
{
[self cmdLogFile: name];
}
}
}
return status;
}
- (void) cmdAudit: (NSString*)fmt arguments: (va_list)args
{
if (nil == auditLogger)
{
auditLogger = [[EcLogger loggerForType: LT_AUDIT] retain];
}
[auditLogger log: fmt arguments: args];
}
- (void) cmdAudit: (NSString*)fmt, ...
{
va_list ap;
va_start (ap, fmt);
[self cmdAudit: fmt arguments: ap];
va_end (ap);
}
- (void) cmdDbg: (NSString*)type msg: (NSString*)fmt arguments: (va_list)args
{
if (nil != [cmdDebugModes member: type])
{
if (nil == debugLogger)
{
debugLogger = [[EcLogger loggerForType: LT_DEBUG] retain];
}
[debugLogger log: fmt arguments: args];
}
}
- (void) cmdDbg: (NSString*)type msg: (NSString*)fmt, ...
{
va_list ap;
va_start (ap, fmt);
[self cmdDbg: type msg: fmt arguments: ap];
va_end (ap);
}
- (void) cmdDebug: (NSString*)fmt arguments: (va_list)args
{
if (nil != [cmdDebugModes member: cmdBasicDbg])
{
if (nil == debugLogger)
{
debugLogger = [[EcLogger loggerForType: LT_DEBUG] retain];
}
[debugLogger log: fmt arguments: args];
}
}
- (void) cmdDebug: (NSString*)fmt, ...
{
va_list ap;
va_start (ap, fmt);
[self cmdDebug: fmt arguments: ap];
va_end (ap);
}
- (void) cmdError: (NSString*)fmt arguments: (va_list)args
{
if (nil == errorLogger)
{
errorLogger = [[EcLogger loggerForType: LT_ERROR] retain];
}
[errorLogger log: fmt arguments: args];
}
- (void) cmdError: (NSString*)fmt, ...
{
va_list ap;
va_start (ap, fmt);
[self cmdError: fmt arguments: ap];
va_end (ap);
}
- (void) cmdFlushLogs
{
[alertLogger flush];
[auditLogger flush];
[debugLogger flush];
[errorLogger flush];
[warningLogger flush];
}
- (NSTimeInterval) cmdInterval
{
return cmdTimInterval;
}
- (BOOL) cmdIsClient
{
return YES;
}
- (void) log: (NSString*)message type: (EcLogType)t
{
switch (t)
{
case LT_DEBUG:
[self cmdDebug: @"%@", message];
break;
case LT_WARNING:
[self cmdWarn: @"%@", message];
break;
case LT_ERROR:
[self cmdError: @"%@", message];
break;
case LT_ALERT:
[self cmdAlert: @"%@", message];
break;
case LT_AUDIT:
case LT_CONSOLE:
[self cmdAudit: @"%@", message];
break;
default:
[self cmdError: @"%@", message];
break;
}
}
- (id) cmdNewServer
{
static BOOL connecting = NO;
if (NO == connecting)
{
/*
* Use the 'cmdLast' variable to ensure that we don't try to
* check memory usage or connect to the command server more
* than once every 10 sec.
*/
if (cmdLast == nil || [cmdLast timeIntervalSinceNow] < -10.0)
{
connecting = YES;
ASSIGN(cmdLast, [dateClass date]);
if (cmdFirst == nil)
{
ASSIGN(cmdFirst, cmdLast);
}
if (nil == cmdServer && YES == [self cmdIsClient])
{
NSString *name = nil;
NSString *host = nil;
id proxy;
NS_DURING
{
NSSocketPortNameServer *ns;
host = ecCommandHost();
name = ecCommandName();
ns = [NSSocketPortNameServer sharedInstance];
proxy = [NSConnection
rootProxyForConnectionWithRegisteredName: name
host: host
usingNameServer: ns];
[proxy setProtocolForProxy: @protocol(Command)];
if (nil == proxy)
{
NSLog(@"Unable to connect to Command server");
}
else
{
NSConnection *connection;
ASSIGN(cmdServer, proxy);
connection = [cmdServer connectionForProxy];
[connection enableMultipleThreads];
if (nil == alarmDestination)
{
alarmDestination = [EcAlarmDestination new];
}
[[self ecAlarmDestination] setDestination: cmdServer];
[[NSNotificationCenter defaultCenter]
addObserver: self
selector: @selector(cmdConnectionBecameInvalid:)
name: NSConnectionDidDieNotification
object: connection];
}
}
NS_HANDLER
{
proxy = nil;
NSLog(@"Exception connecting to Command server %@ on %@): %@",
name, host, localException);
}
NS_ENDHANDLER
/* We only register and fetch new configuration information
* if we are NOT in the process of shutting down: a process
* which is shutting down should only use the Command server
* for logging/alerting purposes.
*/
if (proxy != nil && 0.0 == beganQuitting)
{
NSMutableDictionary *r = nil;
NS_DURING
{
NSData *d;
d = [proxy registerClient: self
identifier: [self processIdentifier]
name: cmdLogName()
transient: cmdIsTransient];
r = [NSPropertyListSerialization
propertyListWithData: d
options: NSPropertyListMutableContainers
format: 0
error: 0];
}
NS_HANDLER
{
r = [NSMutableDictionary dictionaryWithCapacity: 1];
[r setObject: [localException reason]
forKey: @"rejected"];
NSLog(@"Caught exception registering with Command: %@",
localException);
}
NS_ENDHANDLER
/* We could be rejected or told to back off,
* otherwise we continue as normal.
*/
if ([r objectForKey: @"rejected"] != nil)
{
NSString *shutdown;
shutdown = [NSString stringWithFormat:
@" rejected by Command - %@",
[r objectForKey: @"rejected"]];
NSLog(@"Unable to connect to Command server ... %@",
shutdown);
/* Rejected by Command server.
* NB. The Command server should expect a -4 exit
*/
[self ecQuitFor: shutdown with: -4];
}
else if ([r objectForKey: @"back-off"] != nil)
{
NSLog(@"Unable to register with Command server ..."
@" back-off");
}
else
{
[self _update: r];
/* If we just connected to the command server,
* and we have a registered connection, then we
* can tell it that any alarm for failure to
* register must be cleared.
*/
if (nil != cmdServer && [EcProcConnection isValid])
{
[self _connectionRegistered];
}
}
}
}
connecting = NO;
if (nil == cmdLast && nil == cmdServer && YES == [self cmdIsClient])
{
/* If cmdLast is nil, a reconnect must have been requested
* while we were attempting a connect ... so try again.
*/
cmdServer = [self cmdNewServer];
}
}
else
{
// NSLog(@"Unable to connect to Command server ... not retry time yet");
}
}
else
{
NSLog(@"Unable to connect to Command server ... attempt in progress");
}
return cmdServer;
}
- (void) cmdWarn: (NSString*)fmt arguments: (va_list)args
{
if (nil == warningLogger)
{
warningLogger = [[EcLogger loggerForType: LT_WARNING] retain];
}
[warningLogger log: fmt arguments: args];
}
- (void) cmdWarn: (NSString*)fmt, ...
{
va_list ap;
va_start (ap, fmt);
[self cmdWarn: fmt arguments: ap];
va_end (ap);
}
- (void) ecNewDay: (NSCalendarDate*)when
{
static BOOL beenHere = NO;
static NSDictionary *defs = nil;
NSDictionary *d = [cmdDefs volatileDomainForName: @"EcCommand"];
if (YES == beenHere)
{
/* Archive previous day's logs. Force logs to be archived for
* yesterday even if they have been modified today (on the basis
* that only the very latest info in them should be from today).
*/
when = [when dateByAddingTimeInterval: -3600.0];
NSLog(@"Daily: %@", [self ecArchive: when]);
if (nil != defs)
{
NSEnumerator *e;
NSString *k;
/* Check information left in the EcCommand domain.
*/
e = [[d allKeys] objectEnumerator];
while (nil != (k = [e nextObject]))
{
id v = [d objectForKey: k];
if ([v isEqual: [defs objectForKey: k]])
{
[self cmdWarn: @"The Console defaults override for '%@'"
@" has been left at '%@' for more than a day."
@" Please reset it ('tell %@ defaults delete %@') after"
@" updating Control.plist as required.",
k, v, [self cmdName], k];
}
}
}
}
else
{
/* First time round we must not archive since that will have
* been done on startup anyway.
*/
beenHere = YES;
}
ASSIGNCOPY(defs, d);
}
- (void) ecNewHour: (NSCalendarDate*)when
{
return;
}
- (void) ecNewMinute: (NSCalendarDate*)when
{
#ifndef __MINGW__
if (NO == ecIsQuitting())
{
NSString *shutdown = nil;
int p[2];
if (pipe(p) == 0)
{
if (0 == reservedPipe[1])
{
reservedPipe[0] = p[0];
reservedPipe[1] = p[1];
}
else
{
close(p[0]);
close(p[1]);
}
if (descriptorsMaximum > 0)
{
if (p[0] > descriptorsMaximum || p[1] > descriptorsMaximum)
{
shutdown = [NSString stringWithFormat:
@"Open file descriptor limit (%lu) exceeded",
(unsigned long) descriptorsMaximum];
}
}
}
else
{
shutdown = @"Process ran out of file descriptors";
}
if (nil != shutdown)
{
/* We hope that closing two reserved file descriptors will allow
* us to shut down gracefully and restart.
*/
if (reservedPipe[1] > 0)
{
close(reservedPipe[0]); reservedPipe[0] = 0;
close(reservedPipe[1]); reservedPipe[1] = 0;
}
[self ecQuitFor: shutdown with: -1]; // relaunch
return;
}
}
#endif
/* We want to be sure we work with reasonably up to date information.
*/
[NSHost flushHostCache];
[cmdDefs purgeSettings];
[self _memCheck];
}
- (void) ecHadIP: (NSDate*)when
{
if (nil == when)
{
lastIP = [dateClass timeIntervalSinceReferenceDate];
}
else
{
lastIP = [when timeIntervalSinceReferenceDate];
}
}
- (void) ecHadOP: (NSDate*)when
{
if (nil == when)
{
lastOP = [dateClass timeIntervalSinceReferenceDate];
}
else
{
lastOP = [when timeIntervalSinceReferenceDate];
}
}
- (NSUInteger) ecNotLeaked
{
return 0;
}
- (int) ecRun
{
CREATE_AUTORELEASE_POOL(arp);
NSSocketPortNameServer *ns;
NSString *name;
NSRunLoop *loop;
NSDate *future;
if (YES == cmdIsTransient)
{
[self cmdWarn: @"Attempted to run transient process."];
[self cmdFlushLogs];
[arp release];
return 1;
}
/* Now that startup has completed we re-register our connection under
* our normal name (which removes the name used during startup).
*/
NSAssert(nil != EcProcConnection, NSGenericException);
ns = [NSSocketPortNameServer sharedInstance];
name = [self cmdName];
if ([EcProcConnection registerName: name withNameServer: ns] == NO)
{
EcAlarm *a;
DESTROY(EcProcConnection);
NSLog(@"Unable to register with name server. Perhaps a copy of this process is already running (or is hung or blocked waiting for a database query etc), or perhaps an old version was killed and is still registered. Check the state of any running process and and check the process registration with gdomap.");
a = [EcAlarm alarmForManagedObject: nil
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmSoftwareProgramAbnormallyTerminated
specificProblem: @"Unable to register"
perceivedSeverity: EcAlarmSeverityMajor
proposedRepairAction:
_(@"Check for running copy of process and/or registration in gdomap.")
additionalText: _(@"Process probably already running (possibly hung/delayed) or problem in name registration with distributed objects system (gdomap)")];
[self alarm: a];
[[self ecAlarmDestination] shutdown];
/* NB. The Command server knowns that -2 means a name server failure.
*/
[self ecQuitFor: @"unable to register with name server" with: -2];
[self cmdFlushLogs];
[arp release];
return 2;
}
else
{
EcAlarm *a;
a = [EcAlarm alarmForManagedObject: nil
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmSoftwareProgramAbnormallyTerminated
specificProblem: @"Unable to register"
perceivedSeverity: EcAlarmSeverityCleared
proposedRepairAction: nil
additionalText: nil];
[self alarm: a];
}
[EcProcConnection setDelegate: self];
[[NSNotificationCenter defaultCenter]
addObserver: self
selector: @selector(cmdConnectionBecameInvalid:)
name: NSConnectionDidDieNotification
object: EcProcConnection];
[self _connectionRegistered];
/* Called to permit subclasses to initialise before entering run loop.
*/
[self ecAwaken];
ecDidAwakenCompletely = YES;
RELEASE(arp);
arp = [NSAutoreleasePool new];
[self cmdAudit: @"Started '%@' in %g seconds",
[self cmdName], [NSDate timeIntervalSinceReferenceDate] - initAt];
[self cmdFlushLogs];
cmdIsRunning = YES;
[self triggerCmdTimeout]; /* make sure that regular timers run. */
NS_DURING
[cmdServer woken: self];
NS_HANDLER
DESTROY(cmdServer);
NS_ENDHANDLER
if (nil == cmdServer)
{
DESTROY(cmdLast); // Allow immediate retry
[self cmdNewServer];
}
loop = [NSRunLoop currentRunLoop];
future = [NSDate distantFuture];
while (YES == [EcProcConnection isValid])
{
NS_DURING
{
NSDate *d = [loop limitDateForMode: NSDefaultRunLoopMode];
if (0 == cmdSignalled)
{
if (nil == d)
{
d = future;
}
[loop acceptInputForMode: NSDefaultRunLoopMode beforeDate: d];
}
if (0 != cmdSignalled)
{
int sig = cmdSignalled;
NSString *shutdown;
shutdown
= [NSString stringWithFormat: @"signal %d received", sig];
cmdSignalled = 0;
[self ecQuitFor: shutdown with: sig];
}
}
NS_HANDLER
{
[self cmdAlert: @"Problem running server: %@", localException];
[NSThread sleepForTimeInterval: 1.0];
}
NS_ENDHANDLER;
[arp emptyPool];
}
[arp release];
/* finish server */
[self ecQuitFor: nil with: 0];
cmdIsRunning = NO;
DESTROY(EcProcConnection);
return 0;
}
- (void) ecReconnect
{
if (NO == [NSThread isMainThread]
|| NO == [[[NSRunLoop currentRunLoop] currentMode]
isEqual: NSDefaultRunLoopMode])
{
NSArray *modes = [NSArray arrayWithObject: NSDefaultRunLoopMode];
[self performSelectorOnMainThread: _cmd
withObject: nil
waitUntilDone: NO
modes: modes];
}
else
{
NS_DURING
[cmdServer registerClient: self
identifier: [self processIdentifier]
name: cmdLogName()
transient: cmdIsTransient];
NS_HANDLER
DESTROY(cmdServer);
NS_ENDHANDLER
if (nil == cmdServer)
{
DESTROY(cmdLast); // Allow immediate retry
[self cmdNewServer];
}
}
}
- (void) ecTestLog: (NSString*)fmt arguments: (va_list)args
{
if (YES == cmdFlagTesting)
{
NSLogv(fmt, args);
}
}
- (void) ecTestLog: (NSString*)fmt, ...
{
if (YES == cmdFlagTesting)
{
va_list ap;
va_start (ap, fmt);
[self ecTestLog: fmt arguments: ap];
va_end (ap);
}
}
- (void) ecUpdateRegisteredDefaults
{
NSDictionary *d;
[ecLock lock];
d = [cmdDefs volatileDomainForName: NSRegistrationDomain];
d = [EcDefaultRegistration merge: d];
[cmdDefs registerDefaults: d];
[ecLock unlock];
}
- (NSString*) ecUserDirectory
{
return cmdUserDir();
}
- (void) setCmdDebug: (NSString*)mode withDescription: (NSString*)desc
{
[cmdDebugKnown setObject: desc forKey: mode];
if (YES == [cmdDefs boolForKey: [@"Debug-" stringByAppendingString: mode]])
{
[cmdDebugModes addObject: mode];
}
else
{
[cmdDebugModes removeObject: mode];
}
}
- (void) setCmdTimeout: (SEL)sel
{
cmdTimSelector = sel;
[self triggerCmdTimeout];
}
- (void) triggerCmdTimeout
{
if (NO == [NSThread isMainThread])
{
[self performSelectorOnMainThread: _cmd
withObject: nil
waitUntilDone: NO];
return;
}
if (cmdPTimer != nil)
{
/*
* If the timer is due to go off soon - don't reset it -
* continually resetting could lead to it never firing.
*/
if ([[cmdPTimer fireDate] timeIntervalSinceNow] <= 0.01)
{
return;
}
[cmdPTimer invalidate];
cmdPTimer = nil;
}
cmdPTimer = [NSTimer scheduledTimerWithTimeInterval: 0.001
target: self
selector: @selector(_timedOut:)
userInfo: nil
repeats: NO];
}
- (BOOL) cmdDebugMode: (NSString*)mode
{
if ([cmdDebugModes member: mode] == nil)
return NO;
return YES;
}
- (void) cmdDebugMode: (NSString*)mode active: (BOOL)flag
{
if ((mode = findMode(cmdDebugKnown, mode)) != nil)
{
if (flag == YES && [cmdDebugModes member: mode] == nil)
{
[cmdDebugModes addObject: mode];
}
if (flag == NO && [cmdDebugModes member: mode] != nil)
{
[cmdDebugModes removeObject: mode];
}
}
}
- (oneway void) cmdGnip: (id <CmdPing>)from
sequence: (unsigned)num
extra: (in bycopy NSData*)data
{
[self cmdDbg: cmdConnectDbg msg: @"cmdGnip: %lx sequence: %u extra: %lx",
(unsigned long)from, num, (unsigned long)data];
}
- (BOOL) cmdIsConnected
{
return cmdServer != nil;
}
- (BOOL) cmdMatch: (NSString*)val toKey: (NSString*)key
{
unsigned int len = [val length];
if (len == 0)
{
return NO;
}
if (len > [key length])
{
return NO;
}
if ([key compare: val
options: NSCaseInsensitiveSearch|NSLiteralSearch
range: NSMakeRange(0, len)] != NSOrderedSame)
{
return NO;
}
return YES;
}
- (void) cmdMesgCache
{
NSEnumerator *enumerator;
NSString *name;
/* The cmdActions set contains the names of all the commands this
* instance will accept from the Command server. These are methods
* taking an array of strings as an argument and returning a string
* as their result. All have names of the form cmdMesgXXX: where
* XXX is the (lowercase) command.
*/
[ecLock lock];
if (nil == cmdActions)
{
cmdActions = [NSMutableSet new];
}
[cmdActions removeAllObjects];
enumerator = [GSObjCMethodNames(self, YES) objectEnumerator];
while (nil != (name = [enumerator nextObject]))
{
NSRange r = [name rangeOfString: @":"];
if ([name hasPrefix: @"cmdMesg"] && 1 == r.length && r.location > 7)
{
name = [name substringWithRange: NSMakeRange(7, r.location - 7)];
if (YES == [name isEqual: [name lowercaseString]])
{
[cmdActions addObject: name];
}
}
}
[ecLock unlock];
}
- (void) ecOperators: (NSDictionary*)dict
{
if (NO == [dict isKindOfClass: [NSDictionary class]])
{
dict = nil;
}
[ecLock lock];
ASSIGN(ecOperators, dict);
[ecLock unlock];
}
- (NSArray*) ecCommands: (NSString*)operator
{
static NSArray *empty = nil;
NSArray *allow = nil;
NSString *name;
id obj;
if (nil == operator)
{
name = @"";
}
else
{
NSRange r = [operator rangeOfString: @":"];
if (r.length > 0)
{
name = [operator substringToIndex: r.location];
}
else
{
name = operator;
}
}
[ecLock lock];
if (nil == empty)
{
empty = [NSArray new];
}
obj = [ecOperators objectForKey: name];
if (NO == [obj isKindOfClass: [NSDictionary class]])
{
NSLog(@"Operator '%@' not found; no access to commands", operator);
obj = empty;
}
else if (nil == [obj objectForKey: @"Commands"] && [name length] > 0)
{
obj = [ecOperators objectForKey: @""];
if (NO == [obj isKindOfClass: [NSDictionary class]])
{
obj = nil; // Non-dictionary default entry ignored.
}
}
if ([obj isKindOfClass: [NSDictionary class]])
{
obj = [obj objectForKey: @"Commands"];
if ([obj isKindOfClass: [NSString class]])
{
/* A string is the name to get the Commands of another agent.
*/
name = (NSString*)obj;
obj = [ecOperators objectForKey: name];
if ([obj isKindOfClass: [NSDictionary class]])
{
obj = [obj objectForKey: @"Commands"];
if (NO == [obj isKindOfClass: [NSArray class]])
{
NSLog(@"Operator '%@' Commands link to '%@' which does"
@" not have Commands; no access to commands",
operator, name);
obj = empty;
}
}
else
{
NSLog(@"Operator '%@' Commands link to '%@' not found;"
@" no access to commands", operator, name);
obj = empty;
}
}
else if (obj != nil && NO == [obj isKindOfClass: [NSArray class]])
{
NSLog(@"Operator '%@' Commands entry invalid;"
@" no access to commands", operator);
obj = empty;
}
}
allow = (NSArray*)AUTORELEASE(RETAIN(obj));
[ecLock unlock];
return allow;
}
- (NSString*) ecMesg: (NSArray*)msg from: (NSString*)operator
{
NSMutableString *saved;
NSString *result;
NSString *cmd;
SEL sel;
if (msg == nil || [msg count] < 1)
{
return @"no command specified\n";
}
cmd = findAction([msg objectAtIndex: 0], [self ecCommands: operator]);
if (nil == cmd)
{
return @"unrecognised command\n";
}
else if (0 == [cmd length])
{
return @"blocked command\n";
}
sel = NSSelectorFromString([NSString stringWithFormat: @"cmdMesg%@:", cmd]);
saved = replyBuffer;
replyBuffer = [NSMutableString stringWithCapacity: 50000];
NS_DURING
{
[self performSelector: sel withObject: msg];
}
NS_HANDLER
{
[self cmdPrintf: @"\n%@ during command\n", localException];
}
NS_ENDHANDLER
result = replyBuffer;
replyBuffer = saved;
return result;
}
/*
* Name - cmdMesgData: from:
* Purpose - Invoke other methods to handle commands.
*/
- (void) cmdMesgData: (NSData*)dat from: (NSString*)name
{
NSArray *msg;
NSString *val;
msg = [NSPropertyListSerialization
propertyListWithData: dat
options: NSPropertyListMutableContainers
format: 0
error: 0];
val = [self ecMesg: msg from: name];
if (cmdServer)
{
NS_DURING
{
[cmdServer reply: val to: name from: ecFullName()];
}
NS_HANDLER
{
[self _commandRemove];
NSLog(@"Caught exception sending client reply to Command: %@ %@",
name, localException);
}
NS_ENDHANDLER
}
}
- (void) cmdMesgalarms: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"reports current alarms"];
}
else
{
if ([[msg objectAtIndex: 0] isEqualToString: @"help"])
{
[self cmdPrintf: @"\nThe alarms command is used to report the"];
[self cmdPrintf: @" alarms currently active for this process.\n"];
[self cmdPrintf: @"NB. Each individual process identifies current"];
[self cmdPrintf: @" alarms by address within the process.\n"];
[self cmdPrintf: @"This differs from the Control server which"];
[self cmdPrintf: @" uses a unique notification ID intended\n"];
[self cmdPrintf: @"for working with external SNMP systems.\n"];
}
else
{
NSArray *a = [[self ecAlarmDestination] alarms];
if (0 == [a count])
{
[self cmdPrintf: @"No alarms currently active.\n"];
}
else
{
int i;
a = [a sortedArrayUsingSelector: @selector(compare:)];
[self cmdPrintf: @"Current alarms -\n"];
for (i = 0; i < [a count]; i++)
{
EcAlarm *alarm = [a objectAtIndex: i];
[self cmdPrintf: @"%@\n", [alarm description]];
}
}
}
}
}
- (void) cmdMesgarchive: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"archives log files"];
}
else
{
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"]
== NSOrderedSame)
{
[self cmdPrintf: @"\nThe archive command is used to archive the"];
[self cmdPrintf: @" debug file to a subdirectory.\n"];
[self cmdPrintf: @"You should not need it - as archiving should"];
[self cmdPrintf: @"be done automatically at midnight.\n"];
}
else
{
[self cmdPrintf: @"\n%@\n", [self ecArchive: nil]];
}
}
}
- (void) cmdMesgclear: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"clears current alarms"];
}
else
{
if ([[msg objectAtIndex: 0] isEqualToString: @"help"])
{
[self cmdPrintf: @"\nThe clear command is used to clear the"];
[self cmdPrintf: @" alarms currently active for this process.\n"];
[self cmdPrintf: @"You may use the word 'all' or a space separated"];
[self cmdPrintf: @" list of alarm addresses.\n"];
[self cmdPrintf: @"NB. Each individual process identifies current"];
[self cmdPrintf: @" alarms by address within the process.\n"];
[self cmdPrintf: @"This differs from the Control server which"];
[self cmdPrintf: @" uses a unique notification ID intended\n"];
[self cmdPrintf: @"for working with external SNMP systems.\n"];
[self cmdPrintf: @"Clearing an alarm in this process will also"];
[self cmdPrintf: @"clear it in the Control server.\n"];
}
else
{
NSArray *a = [[self ecAlarmDestination] alarms];
NSUInteger count = [msg count];
if (count < 2)
{
[self cmdPrintf: @"The 'clear' command requires an alarm"
@" address or the word all\n"];
}
else
{
NSUInteger alarmCount = [a count];
EcAlarm *alarm;
NSUInteger index;
for (index = 1; index < count; index++)
{
NSUInteger addr;
NSString *arg = [msg objectAtIndex: index];
if ([arg caseInsensitiveCompare: _(@"all")]
== NSOrderedSame)
{
NSUInteger i;
for (i = 0; i < alarmCount; i++)
{
alarm = [a objectAtIndex: i];
[self cmdPrintf: @"Clearing %@\n", alarm];
alarm = [alarm clear];
[[self ecAlarmDestination] alarm: alarm];
}
}
else if (1 == sscanf([arg UTF8String], "%" PRIxPTR, &addr))
{
NSUInteger i;
alarm = nil;
for (i = 0; i < alarmCount; i++)
{
alarm = [a objectAtIndex: i];
if ((NSUInteger)alarm == addr)
{
break;
}
alarm = nil;
}
if (nil == alarm)
{
[self cmdPrintf:
@"No alarm found with the address '%@'\n",
arg];
}
else
{
[self cmdPrintf: @"Clearing %@\n", alarm];
alarm = [alarm clear];
[[self ecAlarmDestination] alarm: alarm];
}
}
else
{
[self cmdPrintf: @"Not a hexadecimal address: '%@'\n",
arg];
}
}
}
}
}
}
- (void) cmdMesgdebug: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"turns on debug logging"];
}
else
{
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"]
== NSOrderedSame)
{
[self cmdPrintf: @"\nWithout parameters, the debug command is "];
[self cmdPrintf: @"used to list the currently active "];
[self cmdPrintf: @"debug modes.\n"];
[self cmdPrintf: @"With the single parameter 'default', the debug "];
[self cmdPrintf: @"command is used to revert to default "];
[self cmdPrintf: @"debug settings.\n"];
[self cmdPrintf: @"With the single parameter 'all', the debug "];
[self cmdPrintf: @"command is used to activate all "];
[self cmdPrintf: @"debugging.\n"];
[self cmdPrintf: @"With any other parameter, the debug command "];
[self cmdPrintf: @"is used to activate one of the "];
[self cmdPrintf: @"debug modes listed below.\n\n"];
[self cmdPrintf: @"%@\n", cmdDebugKnown];
}
else if (YES == cmdKillDebug)
{
[self cmdPrintf:
@"All output to STDERR suppressed by KillDebugOutput=YES\n"];
}
else if ([msg count] > 1)
{
NSString *mode = (NSString*)[msg objectAtIndex: 1];
NSString *key;
if ([mode caseInsensitiveCompare: @"default"] == NSOrderedSame)
{
NSEnumerator *enumerator = [cmdDebugKnown keyEnumerator];
while (nil != (mode = [enumerator nextObject]))
{
key = [@"Debug-" stringByAppendingString: mode];
[cmdDefs setCommand: nil forKey: [cmdDefs key: key]];
}
[self cmdPrintf: @"Now using debug settings from config.\n"];
}
else if ([mode caseInsensitiveCompare: @"all"] == NSOrderedSame)
{
NSEnumerator *enumerator = [cmdDebugKnown keyEnumerator];
while (nil != (mode = [enumerator nextObject]))
{
key = [@"Debug-" stringByAppendingString: mode];
[cmdDefs setCommand: @"YES" forKey: [cmdDefs key: key]];
}
[self cmdPrintf: @"All debugging is now active.\n"];
}
else
{
[self cmdPrintf: @"debug mode '"];
if ((mode = findMode(cmdDebugKnown, mode)) == nil)
{
[self cmdPrintf: @"%@' is not known.\n", mode];
}
else
{
[self cmdPrintf: @"%@", mode];
if ([cmdDebugModes member: mode] == nil)
{
[self cmdPrintf: @"' is now active."];
}
else
{
[self cmdPrintf: @"' is already active."];
}
key = [@"Debug-" stringByAppendingString: mode];
[cmdDefs setCommand: @"YES" forKey: [cmdDefs key: key]];
}
}
}
else
{
[self cmdPrintf: @"%@\n", [EcLogger loggerForType: LT_DEBUG]];
[self cmdPrintf: @"Current active debug modes -\n"];
if ([cmdDebugModes count] == 0)
{
[self cmdPrintf: @"\nNone.\n"];
}
else
{
[self cmdPrintf: @"%@\n", cmdDebugModes];
}
}
}
}
- (void) cmdMesgdefaults: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf:
@"temporarily overrides defaults/Control.plist settings"];
}
else
{
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"]
== NSOrderedSame)
{
[self cmdPrintf: @"\nWithout parameters,\n the defaults command is"];
[self cmdPrintf: @" used to list the current defaults overrides.\n"];
[self cmdPrintf: @"With the 'delete' parameter followed by a name,"];
[self cmdPrintf: @"\n removes an override.\n"];
[self cmdPrintf: @"With the 'life' parameter followed by a number\n"];
[self cmdPrintf: @" of hours (1 to 168), a name, and a value,\n"];
[self cmdPrintf: @" sets an override of the default.\n"];
[self cmdPrintf: @"With the 'write' parameter followed by a name "];
[self cmdPrintf: @"and value,\n sets an override of the default.\n"];
[self cmdPrintf: @"With the 'read' parameter followed by a name,\n"];
[self cmdPrintf: @" shows the effective default after overrides.\n"];
[self cmdPrintf: @"With the 'revert' parameter,\n the command"];
[self cmdPrintf: @" is used to revert all overides.\n"];
[self cmdPrintf: @"With the 'list' parameter,\n this lists"];
[self cmdPrintf: @" registered (not all) defaults names.\n"];
[self cmdPrintf: @"With the 'list' parameter followed by a name,\n"];
[self cmdPrintf: @" shows the help for the specified default.\n"];
[self cmdPrintf: @"With the 'show' parameter,\n"];
[self cmdPrintf: @" shows all current names and lifes.\n"];
}
else if ([msg count] > 1 && [[msg objectAtIndex: 1] isEqual: @"list"])
{
NSString *key = nil;
if ([msg count] > 2)
{
key = [msg objectAtIndex: 2];
}
[self cmdPrintf: @"%@", [EcDefaultRegistration listHelp: key]];
}
else if ([msg count] > 1 && [[msg objectAtIndex: 1] isEqual: @"revert"])
{
[cmdDefs revertSettings];
[self cmdPrintf: @"All override settings are removed.\n"];
}
else if ([msg count] > 1 && [[msg objectAtIndex: 1] isEqual: @"show"])
{
NSDictionary *d = [cmdDefs commandExpiries];
if ([d count] == 0)
{
[self cmdPrintf: @"There are currently no default overrides.\n"];
}
else
{
[self cmdPrintf: @"Current default overrides: %@\n",
[d descriptionWithLocale: [NSLocale autoupdatingCurrentLocale]
indent: 0]];
}
}
else if ([msg count] > 2)
{
NSString *mode = (NSString*)[msg objectAtIndex: 1];
NSString *key = (NSString*)[msg objectAtIndex: 2];
unsigned hours = 0;
id old;
id val;
/* Lifetime may be from 1 to 168 hours
*/
if ([msg count] > 3 && [key length] > 0
&& (hours = [key intValue]) > 0 && hours <= 168)
{
key = (NSString*)[msg objectAtIndex: 3];
}
old = [cmdDefs objectForKey: key];
if ([mode caseInsensitiveCompare: @"delete"] == NSOrderedSame)
{
if ([key isEqualToString: ecControlKey])
{
[self cmdPrintf: @"%@ can only be set on startup.\n", key];
return;
}
else if ([key isEqualToString: @"KillDebugOutput"])
{
[self cmdPrintf: @"%@ can not be overridden.\n", key];
return;
}
else
{
[cmdDefs setCommand: nil forKey: [cmdDefs key: key]];
val = [cmdDefs objectForKey: key];
}
}
else if (hours > 0
&& [mode caseInsensitiveCompare: @"life"] == NSOrderedSame)
{
if ([key isEqualToString: ecControlKey])
{
[self cmdPrintf: @"%@ can only be set on startup.\n", key];
return;
}
else if ([key isEqualToString: @"KillDebugOutput"])
{
[self cmdPrintf: @"%@ can not be overridden.\n", key];
return;
}
else if ([msg count] == 5)
{
NSTimeInterval t = hours * 60.0 * 60.0;
val = [msg objectAtIndex: 4];
[cmdDefs setCommand: val
forKey: [cmdDefs key: key]
lifetime: t];
val = [cmdDefs objectForKey: key];
}
else if ([msg count] == 4)
{
[self cmdPrintf: @"Missing value for '%@ %@' (no effect).\n",
mode, key];
val = old;
}
else
{
[self cmdPrintf: @"Too many values for '%@ %@' (ignored).\n",
mode, key];
val = old;
}
}
else if ([mode caseInsensitiveCompare: @"write"] == NSOrderedSame
|| [mode caseInsensitiveCompare: @"set"] == NSOrderedSame)
{
if ([key isEqualToString: ecControlKey])
{
[self cmdPrintf: @"%@ can only be set on startup.\n", key];
return;
}
else if ([key isEqualToString: @"KillDebugOutput"])
{
[self cmdPrintf: @"%@ can not be overridden.\n", key];
return;
}
else if ([msg count] == 4)
{
val = [msg objectAtIndex: 3];
[cmdDefs setCommand: val forKey: [cmdDefs key: key]];
val = [cmdDefs objectForKey: key];
}
else if ([msg count] == 3)
{
[self cmdPrintf: @"Missing value for '%@ %@' (no effect).\n",
mode, key];
val = old;
}
else
{
[self cmdPrintf: @"Too many values for '%@ %@' (ignored).\n",
mode, key];
val = old;
}
}
else if ([mode caseInsensitiveCompare: @"read"] == NSOrderedSame
|| [mode caseInsensitiveCompare: @"get"] == NSOrderedSame)
{
if ([key isEqualToString: ecControlKey])
{
[self cmdPrintf: @"%@ can not be displayed.\n", key];
val = nil;
}
else
{
val = [cmdDefs objectForKey: key];
}
}
else
{
/* To be tolerant of typing errors and maintain backward
* compatibility, anything else is treated as a 'read'
*/
[self cmdPrintf: @"Unrecognised command '%@' (assume 'read').\n",
key];
val = [cmdDefs objectForKey: key];
}
if ([key isEqualToString: ecControlKey])
{
if ([old length] == 0)
{
[self cmdPrintf: @"%@ is not set.\n", key];
}
else
{
[self cmdPrintf: @"%@ was set on startup.\n", key];
}
}
else if (val == old || [val isEqual: old])
{
if (nil == val)
{
[self cmdPrintf:
@"The override setting for the default '%@' is"
@" unchanged (and not set).\n", key];
}
else
{
[self cmdPrintf:
@"The override setting for the default '%@' is"
@" unchanged (%@).\n", key, val];
}
}
else if (nil == val)
{
[self cmdPrintf: @"The override setting for the default '%@' is"
@" deleted (was %@).\n", key, old];
}
else if (nil == old)
{
[self cmdPrintf: @"The override setting for the default '%@' is"
@" set to: %@ (was not set).\n", key, val];
}
else
{
[self cmdPrintf: @"The override setting for the default '%@' is"
@" set to: %@ (was %@).\n", key, val, old];
}
}
else
{
NSDictionary *d = [cmdDefs volatileDomainForName: @"EcCommand"];
NSArray *a;
NSEnumerator *e;
NSString *k;
[self cmdPrintf: @"Console temporary overrides of defaults:\n"];
a = [[d allKeys] sortedArrayUsingSelector: @selector(compare:)];
e = [a objectEnumerator];
k = [e nextObject];
if (nil == k)
{
[self cmdPrintf: @" None.\n"];
}
else
{
while (nil != k)
{
id v = [d objectForKey: k];
[self cmdPrintf: @" %@ = %@\n", k, v];
k = [e nextObject];
}
}
}
}
}
- (void) cmdMesghelp: (NSArray*)msg
{
NSEnumerator *e;
NSString *cmd;
SEL sel;
[ecLock lock];
e = [[[cmdActions allObjects] sortedArrayUsingSelector: @selector(compare:)]
objectEnumerator];
[ecLock unlock];
if ([msg count] == 0)
{
[self cmdPrintf: @"provides helpful information :-)"];
return;
}
else if ([msg count] > 1)
{
NSString *found;
cmd = [msg objectAtIndex: 1];
found = findAction(cmd, nil);
if ([cmd caseInsensitiveCompare: @"control"] == NSOrderedSame)
{
[self cmdPrintf: @"Detailed help on the 'control' command -\n"];
[self cmdPrintf: @"This command enables you to send an"];
[self cmdPrintf: @"instruction to the 'Control' server rather\n"];
[self cmdPrintf: @"than to the currently connected server.\n"];
[self cmdPrintf: @"Everything typed on the line after the word"];
[self cmdPrintf: @" 'control' is treated as a command to\n"];
[self cmdPrintf: @"the 'Control' server process.\n"];
[self cmdPrintf: @"\nTo disconnect from the server type -\n"];
[self cmdPrintf: @" control connect\n"];
[self cmdPrintf: @"\nTo disconnect from the host type -\n"];
[self cmdPrintf: @" control host\n"];
return;
}
else if (nil == found)
{
[self cmdPrintf: @"Unable to find the '%@' command -\n", cmd];
}
else if ([found length] == 0)
{
[self cmdPrintf: @"The '%@' command is blocked -\n", cmd];
}
else if ([found caseInsensitiveCompare: @"help"] != NSOrderedSame)
{
NSMutableArray *m;
[self cmdPrintf: @"Detailed help on the '%@' command -\n", found];
sel = NSSelectorFromString(
[NSString stringWithFormat: @"cmdMesg%@:", found]);
/* To get the help on a command, we invoke that command
* by passing the command and arguments (ie, the msg array).
* The command implementation should check the argument 0 -
* if it is "help", it should print out help on itself.
* Save expanded (unabbreviated) commands so the methods
* getting the help request don't need to recheck the values.
*/
m = [[msg mutableCopy] autorelease];
[m replaceObjectAtIndex: 0 withObject: @"help"];
[m replaceObjectAtIndex: 1 withObject: found];
[self performSelector: sel withObject: m];
return;
}
}
[self cmdPrintf: @"\n"];
[self cmdPrintf: @"For help on a particular command, type 'help <cmd>'\n"];
[self cmdPrintf: @"\n"];
[self cmdPrintf: @"These are the commands available to you -\n"];
[self cmdPrintf: @"\n"];
while ((cmd = [e nextObject]) != nil)
{
unsigned l;
sel = NSSelectorFromString(
[NSString stringWithFormat: @"cmdMesg%@:", cmd]);
[self cmdPrintf: @"%@ - ", cmd];
l = [cmd length];
while (l++ < 9)
{
[self cmdPrintf: @" "];
}
[self performSelector: sel withObject: nil];
[self cmdPrintf: @"\n"];
}
}
- (void) cmdMesgnodebug: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"turns off debug logging"];
}
else
{
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"]
== NSOrderedSame)
{
[self cmdPrintf: @"\n"];
[self cmdPrintf: @"Without parameters, the nodebug command is "];
[self cmdPrintf: @"used to list the currently inactive\n"];
[self cmdPrintf: @"debug modes.\n"];
[self cmdPrintf: @"With the single parameter 'all', the nodebug "];
[self cmdPrintf: @"command is used to deactivate all\n"];
[self cmdPrintf: @"debugging.\n"];
[self cmdPrintf: @"With the single parameter 'default', the "];
[self cmdPrintf: @"nodebug command is used to revert to default "];
[self cmdPrintf: @"debug settings.\n"];
[self cmdPrintf: @"With any other parameter, the nodebug command is"];
[self cmdPrintf: @" used to deactivate one of the\n"];
[self cmdPrintf: @"debug modes listed below.\n"];
[self cmdPrintf: @"\n"];
[self cmdPrintf: @"%@\n", cmdDebugKnown];
}
else if ([msg count] > 1)
{
NSString *mode = (NSString*)[msg objectAtIndex: 1];
NSString *key;
if ([mode caseInsensitiveCompare: @"default"] == NSOrderedSame)
{
NSEnumerator *enumerator = [cmdDebugKnown keyEnumerator];
while (nil != (mode = [enumerator nextObject]))
{
key = [@"Debug-" stringByAppendingString: mode];
[cmdDefs setCommand: nil forKey: [cmdDefs key: key]];
}
[self cmdPrintf: @"Now using debug settings from config.\n"];
}
else if ([mode caseInsensitiveCompare: @"all"] == NSOrderedSame)
{
NSEnumerator *enumerator = [cmdDebugKnown keyEnumerator];
while (nil != (mode = [enumerator nextObject]))
{
key = [@"Debug-" stringByAppendingString: mode];
[cmdDefs setCommand: @"NO" forKey: [cmdDefs key: key]];
}
[self cmdPrintf: @"All debugging is now inactive.\n"];
}
else
{
[self cmdPrintf: @"debug mode '"];
if ((mode = findMode(cmdDebugKnown, mode)) == nil)
{
[self cmdPrintf: @"%@' is not known.\n", mode];
}
else
{
[self cmdPrintf: @"%@' is ", mode];
if ([cmdDebugModes member: mode] == nil)
{
[self cmdPrintf: @"already inactive.\n"];
}
else
{
[self cmdPrintf: @"now deactivated.\n"];
}
key = [@"Debug-" stringByAppendingString: mode];
[cmdDefs setCommand: @"NO" forKey: [cmdDefs key: key]];
}
}
}
else
{
NSArray *a = [cmdDebugKnown allKeys];
NSMutableSet *s = [NSMutableSet setWithArray: a];
/*
* Find items known but not active.
*/
[s minusSet: cmdDebugModes];
[self cmdPrintf: @"Current inactive debug modes -\n"];
if (a == 0)
{
[self cmdPrintf: @"none.\n"];
}
else
{
[self cmdPrintf: @"%@\n", s];
}
}
}
}
- (void) cmdMesgmemory: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"controls recording of memory management statistics"];
}
else
{
[self cmdPrintf: @"\n%@ on %@ running since %@\n\n",
cmdLogName(), ecHostName(), [self ecStarted]];
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"]
== NSOrderedSame || ([msg count] > 1
&& [[msg objectAtIndex: 1] caseInsensitiveCompare: @"help"]
== NSOrderedSame))
{
[self cmdPrintf: @"\n\
Without parameters,\n\
the memory command is used to list the changes in the numbers of objects\n\
allocated since the command was last issued.\n\
With the single parameter 'all',\n\
the memory command is used to list the cumulative totals of objects\n\
allocated since the gathering of memory usage statistics was turned on.\n\
With the single parameter 'current',\n\
the memory command is used to list the current totals of objects\n\
allocated (and not deallocated) since the gathering of memory usage\n\
statistics was turned on.\n\
With the single parameter 'yes',\n\
the memory command is used to turn on gathering of memory usage statistics.\n\
With the single parameter 'no',\n\
the memory command is used to turn off gathering of memory usage statistics.\n\
With the single parameter 'default',\n\
the gathering of memory usage statistics reverts to the default setting.\n"];
if (hasLSAN())
{
[self cmdPrintf: @"\
With the single parameter 'leakcheck',\n\
performs a leak check using LeakAnalyzer pritning the results to the log.\n"];
}
else
{
[self cmdPrintf: @"\
With two parameters ('alarm' and a severity name),\n\
the threshold for severity of alarms (warning, minor, major, critical).\n\
Set to 'default' to revert to the default.\n\
With two parameters ('allowed' and a number),\n\
the base/allowed process memory size is set (in MB).\n\
Set to 'default' to revert to the default.\n\
With two parameters ('idle' and a number),\n\
the hour of the day when the process is considered idle is set.\n\
Set to 'default' to revert to the default.\n\
With two parameters ('maximum' and a number),\n\
the maximum process size (in MB) is set. On reaching the limit, the\n\
process restarts unless the limit is zero (meaning no maximum).\n\
Set to 'default' to revert to the default."];
}
[self cmdPrintf: @"\
With two parameters ('class' and a class name),\n\
new instances of the class are recorded/traced.\n\
With two parameters ('list' and a class),\n\
recorded instances of the class are reported.\n"];
[self cmdPrintf: @"\n"];
return;
}
#if defined(__VALGRIND_MAJOR__)
VALGRIND_PRINTF("Console 'memory' command %s\n",
[[msg description] UTF8String]);
#endif
if ([msg count] == 2)
{
NSString *word = [[msg objectAtIndex: 1] lowercaseString];
NSString *s;
if ([word isEqual: @"current"]
|| [word isEqual: @"cur"])
{
if (NO == [cmdDefs boolForKey: @"Memory"])
{
[self cmdPrintf:
@"Memory statistics were not being gathered.\n"];
[self cmdPrintf: @"Memory statistics Will start from NOW.\n"];
}
else
{
const char* list;
list = (const char*)GSDebugAllocationList(NO);
[self cmdPrintf: @"Memory current stats at %@:\n%s",
[NSDate date], list];
}
[cmdDefs setCommand: @"YES" forKey: [cmdDefs key: @"Memory"]];
}
else if ([word isEqual: @"default"] || [word isEqual: @"def"])
{
[cmdDefs setCommand: nil forKey: [cmdDefs key: @"Memory"]];
[self cmdPrintf: @"Memory checking: %s\n",
[cmdDefs boolForKey: @"Memory"] ? "YES" : "NO"];
}
else if ([word isEqual: @"all"])
{
if (NO == [cmdDefs boolForKey: @"Memory"])
{
[self cmdPrintf:
@"Memory statistics were not being gathered.\n"];
[self cmdPrintf: @"Memory statistics Will start from NOW.\n"];
}
else
{
const char* list;
list = (const char*)GSDebugAllocationListAll();
[self cmdPrintf: @"Memory total allocation stats at %@:\n%s",
[NSDate date], list];
}
[cmdDefs setCommand: @"YES" forKey: [cmdDefs key: @"Memory"]];
}
else if ([word isEqual: @"on"] || [word isEqual: @"yes"]
|| [word isEqual: @"true"] || [word isEqual: @"1"])
{
if (NO == [cmdDefs boolForKey: @"Memory"])
{
[self cmdPrintf:
@"Memory statistics were not being gathered.\n"];
[self cmdPrintf: @"Statistics Will start from NOW.\n"];
}
else
{
[self cmdPrintf:
@"Memory statistics are already being gathered.\n"];
}
[cmdDefs setCommand: @"YES" forKey: [cmdDefs key: @"Memory"]];
}
else if ([word isEqual: @"off"] || [word isEqual: @"no"]
|| [word isEqual: @"false"] || [word isEqual: @"0"])
{
if (NO == [cmdDefs boolForKey: @"Memory"])
{
[self cmdPrintf:
@"Memory statistics were not being gathered.\n"];
}
[self cmdPrintf: @"Memory statistics are turned off NOW.\n"];
[cmdDefs setCommand: @"NO" forKey: [cmdDefs key: @"Memory"]];
}
else if (hasLSAN()
&& ([word isEqual: @"leakcheck"] || [word isEqual: @"leak"]))
{
if (ecLeakCheck && ecLeakCheck())
{
s = @"Memory leaks found and logged!";
}
else
{
s = @"No memory leaks found.";
}
[self cmdPrintf: @"%@\n", s];
}
else if (NO == hasLSAN() && [word isEqual: @"alarm"])
{
if (nil == (s = [cmdDefs stringForKey: @"MemoryAlarm"]))
{
s = [[EcAlarm stringFromSeverity: memAlarm]
stringByAppendingString: @" (default)"];
}
else
{
s = [EcAlarm stringFromSeverity: memAlarm];
}
[self cmdPrintf: @"MemoryAlarm is %@.\n", s];
}
else if (NO == hasLSAN() && [word isEqual: @"allowed"])
{
if (nil == (s = [cmdDefs stringForKey: @"MemoryAllowed"]))
{
s = @"default";
}
[self cmdPrintf: @"MemoryAllowed setting is %@.\n", s];
}
else if (NO == hasLSAN() && [word isEqual: @"idle"])
{
if (nil == (s = [cmdDefs stringForKey: @"MemoryIdle"]))
{
s = @"default";
}
[self cmdPrintf: @"MemoryIdle setting is %@.\n", s];
}
else if (NO == hasLSAN()
&& ([word isEqual: @"maximum"] || [word isEqual: @"max"]))
{
if (nil == (s = [cmdDefs stringForKey: @"MemoryMaximum"]))
{
s = @"default";
}
[self cmdPrintf: @"MemoryMaximum setting is %@.\n", s];
}
else
{
if ([cmdDefs boolForKey: @"Memory"])
{
[self cmdPrintf:
@"Memory statistics are currently being gathered.\n"];
}
else
{
[self cmdPrintf:
@"Memory statistics are NOT being gathered.\n"];
}
}
}
else if ([msg count] == 3)
{
NSString *op = [[msg objectAtIndex: 1] lowercaseString];
NSString *arg = [msg objectAtIndex: 2];
NSInteger val = [arg integerValue];
Class c;
if (hasLSAN())
{
if ([op isEqual: @"alarm"]
|| [op isEqual: @"allowed"]
|| [op isEqual: @"idle"]
|| [op isEqual: @"maximum"] || [op isEqual: @"max"])
{
[self cmdPrintf:
@"Command meaningless: linked with asan/lsan.\n"];
return;
}
}
else
{
if ([op isEqual: @"alarm"])
{
arg = [arg stringByTrimmingSpaces];
if ([arg caseInsensitiveCompare: @"default"] == NSOrderedSame)
{
[cmdDefs setCommand: nil
forKey: [cmdDefs key: @"MemoryAlarm"]];
[self cmdPrintf: @"MemoryAlarm using default value.\n"];
}
else
{
arg = setMemAlarm(arg);
[cmdDefs setCommand: arg
forKey: [cmdDefs key: @"MemoryAlarm"]];
[self cmdPrintf: @"MemoryAlarm set to %@.\n", arg];
}
return;
}
else if ([op isEqual: @"allowed"])
{
if (val <= 0)
{
[cmdDefs setCommand: nil
forKey: [cmdDefs key: @"MemoryAllowed"]];
if (0 == memAllowed)
{
/* The threshold was set back to zero ... to be
* calculated from a ten minute baseline.
*/
memSlot = 0;
}
[self cmdPrintf: @"MemoryAllowed using default value.\n"];
}
else
{
arg = [NSString stringWithFormat:
@"%"PRIu64, (uint64_t)val];
[cmdDefs setCommand: arg
forKey: [cmdDefs key: @"MemoryAllowed"]];
[self cmdPrintf: @"MemoryAllowed set to %@MB.\n", arg];
}
[self _memCheck];
return;
}
else if ([op isEqual: @"idle"])
{
if (!isdigit([arg characterAtIndex: 0]))
{
val = -1;
}
if (val >= 0 && val < 24)
{
arg = [NSString stringWithFormat: @"%d", (int)val];
[cmdDefs setCommand: arg
forKey: [cmdDefs key: @"MemoryIdle"]];
[self cmdPrintf: @"MemoryIdle set to %@.\n", arg];
}
else
{
[cmdDefs setCommand: nil
forKey: [cmdDefs key: @"MemoryIdle"]];
[self cmdPrintf: @"MemoryIdle using default value.\n"];
}
[self _memCheck];
return;
}
else if ([op isEqual: @"maximum"] || [op isEqual: @"max"])
{
if (val <= 0)
{
if ([arg caseInsensitiveCompare: @"default"]
== NSOrderedSame)
{
[cmdDefs setCommand: nil
forKey: [cmdDefs key: @"MemoryMaximum"]];
[self cmdPrintf:
@"MemoryMaximum using default value.\n"];
}
else
{
[cmdDefs setCommand: @"0"
forKey: [cmdDefs key: @"MemoryMaximum"]];
[self cmdPrintf:
@"MemoryMaximum restart turned off.\n"];
}
}
else
{
arg = [NSString stringWithFormat:
@"%"PRIu64, (uint64_t)val];
[cmdDefs setCommand: arg
forKey: [cmdDefs key: @"MemoryMaximum"]];
[self cmdPrintf: @"MemoryMaximum set to %@MB.\n", arg];
}
[self _memCheck];
return;
}
}
/* Not a recognised command ... assume it's the namer of a class.
*/
c = NSClassFromString(arg);
if (Nil == c)
{
[self cmdPrintf: @"Unable to find class '%@'.\n", arg];
}
else
{
if ([op caseInsensitiveCompare: @"class"] == NSOrderedSame)
{
GSDebugAllocationRecordAndTrace(c,
YES, (NSObject*(*)(id))1);
[self cmdPrintf: @"Tracking instances of '%@'.\n", arg];
}
else if ([op caseInsensitiveCompare: @"list"] == NSOrderedSame)
{
NSMapTable *map;
NSEnumerator *e;
NSObject *k;
map = GSDebugAllocationTaggedObjects(c);
[self cmdPrintf: @"Tracked instances of '%@':\n", arg];
e = [map keyEnumerator];
while ((k = [e nextObject]) != nil)
{
NSObject *v = [map objectForKey: k];
[self cmdPrintf: @"%@ allocated at %@\n", k, v];
}
}
else
{
[self cmdPrintf: @"Unknown memory command '%@'.\n", op];
}
}
}
else
{
if (NO == [cmdDefs boolForKey: @"Memory"])
{
[self cmdPrintf: @"Memory stats are not being gathered.\n"];
}
else
{
const char *list;
NSDate *now;
now = [NSDate date];
list = (const char*)GSDebugAllocationList(YES);
if (nil == memStats)
{
[self cmdPrintf: @"Memory change stats at %@:\n%s",
now, list];
}
else
{
[self cmdPrintf: @"Memory change stats at %@\n"
@" (since %@):\n%s", now, memStats, list];
}
ASSIGN(memStats, now);
}
}
}
}
- (void) cmdMesgstatus: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"provides server status information"];
}
else
{
NSTimeInterval ti = [self ecQuitDuration];
NSString *s;
[self cmdPrintf: @"\n%@ on %@ running since %@\n",
cmdLogName(), ecHostName(), [self ecStarted]];
if (lastIP > 0.0)
{
[self cmdPrintf: @"Last IP at %@\n", [self cmdLastIP]];
}
if (lastOP > 0.0)
{
[self cmdPrintf: @"Last OP at %@\n", [self cmdLastOP]];
}
if (ti > 0)
{
if (nil == (s = [self ecQuitReason]))
{
[self cmdPrintf: @"Quitting for %g seconds\n", ti];
}
else
{
[self cmdPrintf: @"Quitting for %g seconds: %@\n", ti, s];
}
}
if (servers != nil)
{
NSEnumerator *e;
RemoteServer *server;
e = [servers objectEnumerator];
while ((server = (RemoteServer *)[e nextObject]) != 0)
{
[self cmdPrintf: @"%@\n", server];
}
}
if (hasLSAN())
{
[self cmdPrintf: @"Unknown memory usage: built with asan/lsan.\n"];
}
else
{
if (memTime <= 0.0)
{
s = @"";
}
else
{
s = [NSString stringWithFormat: @" (last checked at %@)",
[NSDate dateWithTimeIntervalSinceReferenceDate: memTime]];
}
[self cmdPrintf: @"%@ memory usage%@:\n"
@" %"PRIu64"%@ (current), %"PRIu64"%@ (peak)\n",
memType, s, memLast/memSize, memUnit, memPeak/memSize, memUnit];
[self cmdPrintf: @" %"PRIu64"%@ (average),"
@" %"PRIu64"%@ (start)\n",
memAvge/memSize, memUnit, memStrt/memSize, memUnit];
setMemBase();
if (memSlot < MEMCOUNT)
{
[self cmdPrintf: @"Waiting (for %d min"
@" of baseline stats collection).\n",
(int)(MEMCOUNT - memSlot)];
}
if (memAllowed > 0)
{
[self cmdPrintf: @"MemoryAllowed: %"PRIu64 @"%@\n the process"
@" is expected to use up to this much memory.\n",
memAllowed * 1024 * 1024 / memSize, memUnit];
}
if (memMaximum > 0)
{
NSString *idle;
int hour;
uint64_t limit;
if (0 == memAllowed)
{
[self cmdPrintf: @"Estimated base: %"PRIu64
@"%@\n the process is expected to use up to"
@" this much memory.\n",
memAllowed * 1024 * 1024 / memSize, memUnit];
}
[self cmdPrintf: @"MemoryMaximum: %"PRIu64
@"%@\n the process is restarted when peak memory usage"
@" is above this limit.\n",
memMaximum * 1024 * 1024 / memSize, memUnit];
idle = [cmdDefs stringForKey: @"MemoryIdle"];
if ([idle length] > 0
&& (hour = [idle intValue]) >= 0 && hour < 24)
{
[self cmdPrintf: @" The process is also restarted if"
@" memory is above %"PRIu64"%@\n during the hour"
@" from %02d:00.\n",
memCrit/memSize, memUnit, hour];
}
limit = memWarn;
switch (memAlarm)
{
case EcAlarmSeverityCritical: limit = memCrit; break;
case EcAlarmSeverityMajor: limit = memMajr; break;
case EcAlarmSeverityMinor: limit = memMinr; break;
default: limit = memWarn; break;
}
[self cmdPrintf: @"Alarms are raised when memory usage"
@" is above: %"PRIu64"%@.\n", limit / memSize, memUnit];
}
}
}
}
- (oneway void) cmdPing: (id <CmdPing>)from
sequence: (unsigned)num
extra: (in bycopy NSData*)data
{
/* When responding to a ping from a remote process, we also check
* and abort if we have spent too long trying to quit.
*/
ecIsQuitting();
[self cmdDbg: cmdConnectDbg msg: @"cmdPing: %lx sequence: %u extra: %lx",
(unsigned long)from, num, (unsigned long)data];
[from cmdGnip: self sequence: num extra: nil];
}
- (void) cmdPrintf: (NSString*)fmt arguments: (va_list)args
{
NSString *tmp;
tmp = [[stringClass alloc] initWithFormat: fmt arguments: args];
[replyBuffer appendString: tmp];
[tmp release];
}
- (void) cmdPrintf: (NSString*)fmt, ...
{
va_list ap;
va_start(ap, fmt);
[self cmdPrintf: fmt arguments: ap];
va_end(ap);
}
- (oneway void) cmdQuit: (NSInteger)status
{
/* NB. must not call -ecQuitFor:with: since that method calls ths one
* and we do not want nmutual recursion.
*/
[ecLock lock];
if (0.0 == beganQuitting)
{
NSLog(@"-[%@ cmdQuit: %ld]", NSStringFromClass([self class]),
(long)status);
DESTROY(ecQuitReason);
ecQuitStatus = status;
}
[ecLock unlock];
[self ecWillQuit];
[self performSelectorOnMainThread: @selector(_ecQuit)
withObject: nil
waitUntilDone: NO];
}
- (void) cmdUpdate: (NSMutableDictionary*)info
{
ASSIGNCOPY(cmdConf, info);
[cmdDefs setConfiguration: cmdConf];
}
- (NSString*) cmdUpdated
{
return nil;
}
- (void) dealloc
{
[[NSNotificationCenter defaultCenter] removeObserver: self];
[ecLock lock];
if (self == EcProc)
{
EcProc = nil;
}
[ecLock unlock];
[super dealloc];
}
- (NSString*) description
{
return [stringClass stringWithFormat: @"%@ (%@) on %@",
[super description], cmdLogName(), ecHostName()];
}
- (id) init
{
CREATE_AUTORELEASE_POOL(pool);
self = [self initWithDefaults: [[self class] ecInitialDefaults]];
RELEASE(pool);
return self;
}
- (BOOL) ecPrepareUnique
{
NSSocketPortNameServer *ns = [NSSocketPortNameServer sharedInstance];
NSString *name = [self cmdName];
NSString *prep = [name stringByAppendingString: @" (starting)"];
NSPort *p;
/* First try registering as a non-functional process using our unique
* name with th suffix '(starting)' to prevent other instances trying
* to start up at the same time.
*/
p = (NSPort*)[NSSocketPort port];
EcProcConnection = [[NSConnection alloc] initWithReceivePort: p
sendPort: nil];
[EcProcConnection setRootObject: self];
if ([EcProcConnection registerName: prep withNameServer: ns] == NO)
{
p = [ns portForName: prep onHost: @""];
DESTROY(EcProcConnection);
NSLog(@"There is already a process: %@, on %@", prep, p);
return NO;
}
/* Now check to see if there is an instance already running.
*/
p = [ns portForName: name onHost: @""];
if (nil != p)
{
[ns removePortForName: prep];
DESTROY(EcProcConnection);
NSLog(@"There is already a process: %@, on %@", name, p);
return NO;
}
/* Yippee ... there is no other copy of this process running and we have
* grabbed the name of a process starting up, so no other process can
* conflict with our startup.
*/
return YES;
}
- (id) initWithDefaults: (NSDictionary*) defs
{
[ecLock lock];
initAt = [NSDate timeIntervalSinceReferenceDate];
if (nil != EcProc)
{
[self release];
[ecLock unlock];
[NSException raise: NSGenericException
format: @"EcProcess initialiser called more than once"];
}
if (nil == (self = [super init]))
{
[ecLock unlock];
return nil;
}
else
{
NSArray *args = [[NSProcessInfo processInfo] arguments];
NSString *str;
NSString *prf;
NSInteger i;
EcProc = self;
prf = EC_DEFAULTS_PREFIX;
if (nil == prf)
{
prf = @"";
}
started = RETAIN([dateClass date]);
[[self class] ecPrepareWithDefaults: defs];
if ([args containsObject: @"--help"] || [args containsObject: @"-H"])
{
GSPrintf(stderr, @"Standard command-line arguments ...\n\n");
if ([self isKindOfClass: NSClassFromString(@"EcControl")])
{
GSPrintf(stderr,
@"-%@Daemon NO Run process in the foreground.\n",
prf);
}
else if ([self isKindOfClass: NSClassFromString(@"EcConsole")])
{
GSPrintf(stderr,
@"-%@ControlHost [aHost] Host of the Control server to use.\n"
@"-%@ControlName [aName] Name of the Control server to use.\n"
@"-%@Daemon [YES/NO] Fork process to run in background?\n",
prf, prf, prf);
}
else if ([self isKindOfClass: NSClassFromString(@"EcCommand")])
{
GSPrintf(stderr,
@"-%@ControlHost [aHost] Host of the Control server to use.\n"
@"-%@ControlName [aName] Name of the Control server to use.\n"
@"-%@Daemon NO Run process in in the foreground.\n",
prf, prf, prf);
}
else
{
GSPrintf(stderr,
@"-%@CommandHost [aHost] Host of the Command server to use.\n"
@"-%@CommandName [aName] Name of the Command server to use.\n"
@"-%@Daemon [YES/NO] Fork process to run in background?\n"
@"-%@Transient [YES/NO] Expect this process be short-lived?\n",
prf, prf, prf, prf);
}
GSPrintf(stderr, @"\n");
GSPrintf(stderr,
@"-%@CoreSize [MB] Maximum core dump size\n"
@" 0 = no dumps, -1 = unlimited\n"
@"-%@DescriptorsMaximum [N]\n"
@" Set maximum file descriptors to use\n"
@"-%@Debug-name [YES/NO] Turn on/off the named type of debug\n"
@"-%@EffectiveUser [aName] User to run this process as\n"
@"-%@HomeDirectory [relDir] Relative home within user directory\n"
@"-%@UserDirectory [dir] Override home directory for user\n"
@"-%@Instance [aNumber] Instance number for multiple copies\n"
@"-%@MemoryAlarm [severity] When to start raising alarms\n"
@"-%@MemoryAllowed [MB] Expected memory usage (base size)\n"
@"-%@MemoryIdle [0-23] Hour of day preferred for restart\n"
@"-%@MemoryMaximum [MB] Maximum memory usage (before restart)\n"
@"-%@MemoryType [aName] Type of memory to measure. One of\n"
@" Total, Resident or Data.\n"
@"-%@MemoryUnit [aName] Unit to display memory in. One of\n"
@" KB, MB or Page (KB by default).\n"
@"-%@ProgramName [aName] Name to use for this program\n"
@"\n--version to get version information and quit\n\n",
prf, prf, prf, prf, prf, prf, prf, prf, prf, prf,
prf, prf, prf, prf);
[EcDefaultRegistration showHelp];
RELEASE(self);
[ecLock unlock];
return nil;
}
if ([args containsObject: @"--version"])
{
NSLog(@"%@ %@", [self ecCopyright], cmdVersion(nil));
RELEASE(self);
[ecLock unlock];
return nil;
}
cmdIsTransient = [cmdDefs boolForKey: @"Transient"];
if (NO == cmdIsTransient)
{
if (NO == [self ecPrepareUnique])
{
RELEASE(self);
[ecLock unlock];
exit(-2); // Unable to register with name server
}
}
for (i = 0; i < 32; i++)
{
switch (i)
{
case SIGPROF:
case SIGABRT:
break; /* Not overridable */
case SIGUSR1:
case SIGUSR2:
break; /* For apps ... not errors */
case SIGPIPE:
case SIGTTOU:
case SIGTTIN:
case SIGCHLD:
/* SIGWINCH is generated when the terminal size
changes (for example when you resize the xterm).
Ignore it. */
#ifdef SIGWINCH
case SIGWINCH:
#endif
signal(i, SIG_IGN);
break;
case SIGHUP:
if ([cmdDefs boolForKey: @"Daemon"] == YES)
{
signal(i, SIG_IGN);
}
else
{
signal(i, qhandler);
}
break;
case SIGINT:
case SIGTERM:
signal(i, qhandler);
break;
case SIGSTOP:
case SIGCONT:
case SIGTSTP:
signal(i, SIG_DFL);
break;
default:
signal(i, ihandler);
break;
}
}
/* Archive any existing debug log left over by a crash.
*/
str = [cmdName stringByAppendingPathExtension: @"debug"];
if (cmdDebugName == nil || [cmdDebugName isEqual: str] == NO)
{
NSFileHandle *hdl;
NSString *result;
/* Force archiving of old logfile.
*/
result = [self ecArchive: nil];
if (result != noFiles)
{
NSLog(@"Startup: %@", result);
}
ASSIGNCOPY(cmdDebugName, str);
hdl = [self cmdLogFile: cmdDebugName];
if (hdl == nil)
{
DESTROY(EcProcConnection);
[ecLock unlock];
exit(1);
}
}
[[NSNotificationCenter defaultCenter]
addObserver: self
selector: @selector(_defaultsChanged:)
name: NSUserDefaultsDidChangeNotification
object: [NSUserDefaults standardUserDefaults]];
[[NSNotificationCenter defaultCenter]
addObserver: self
selector: @selector(ecLoggersChanged:)
name: EcLoggersDidChangeNotification
object: nil];
[self cmdMesgCache];
[self cmdDefaultsChanged: nil];
if ([cmdDefs objectForKey: @"CmdInterval"] != nil)
{
[self setCmdInterval: [cmdDefs floatForKey: @"CmdInterval"]];
}
/* Log that we are starting up, after the config required for logging
* is in place, but before we have updated config from the Command
* server (since updating config may generater log files).
*/
[self cmdAudit: @"Starting '%@'", [self cmdName]];
if (YES == [self cmdIsClient] && nil == [self cmdNewServer])
{
NSLog(@"Giving up - unable to contact '%@' server on '%@'",
ecCommandName(), ecCommandHost());
[self release];
self = nil;
}
}
[ecLock unlock];
if (self != nil)
{
/* Put self in background.
*/
if ([cmdDefs boolForKey: @"Daemon"] == YES)
{
int pid = fork();
if (pid == 0)
{
cmdFlagDaemon = YES;
setpgid(0, getpid());
}
else
{
if (pid < 0)
{
printf("Failed fork to run as daemon.\r\n");
}
else
{
printf("Process backgrounded (running as daemon)\r\n");
}
exit(0);
}
}
}
return self;
}
/*
* Implement the CmdConfig protocol.
*/
- (void) replaceFile: (NSData*)data
name: (NSString*)name
isConfig: (BOOL)f
{
[NSException raise: NSGenericException
format: @"Illegal method call"];
}
- (oneway void) requestConfigFor: (id<CmdConfig>)c
{
[NSException raise: NSGenericException
format: @"Illegal method call"];
}
- (void) requestFile: (BOOL)flag
name: (NSString*)name
for: (id<CmdConfig>)c
{
[NSException raise: NSGenericException
format: @"Illegal method call"];
}
- (oneway void) updateConfig: (in bycopy NSData*)info
{
id plist = [NSPropertyListSerialization
propertyListWithData: info
options: NSPropertyListMutableContainers
format: 0
error: 0];
if (nil != plist)
{
[self _update: plist];
}
}
- (id) server: (NSString *)serverName
{
RemoteServer *server;
server = (RemoteServer *)[servers objectForKey: serverName];
if (server == nil)
{
NSLog (@"Trying to ask for not-existent server %@", serverName);
return nil;
}
return [server proxy];
}
- (id) server: (NSString *)serverName forNumber: (NSString*)num
{
RemoteServer *server;
NSArray *config;
server = (RemoteServer *)[servers objectForKey: serverName];
if (server == nil)
{
NSLog (@"Trying to ask for not-existent server %@", serverName);
return nil;
}
config = [server multiple];
if (config != nil && [config count] > 1)
{
int val = -1;
unsigned count = [config count];
/*
* Get trailing two digits of number ... in range 00 to 99
*/
if ([num length] >= 2)
{
val = [[num substringFromIndex: [num length] - 2] intValue];
}
if (val < 0)
{
val = 0;
}
/*
* Try to find a broadcast server with a numeric range matching
* the number we were given.
*/
while (count-- > 0)
{
NSDictionary *d = [config objectAtIndex: count];
if (val >= [[d objectForKey: @"Low"] intValue]
&& val <= [[d objectForKey: @"High"] intValue])
{
return [[server proxy] BCPproxy: count];
}
}
[self cmdError: @"Attempt to get %@ server for number %@ with bad config",
serverName, num];
return nil;
}
return [server proxy];
}
- (BOOL) isServerMultiple: (NSString *)serverName
{
RemoteServer *server;
server = (RemoteServer *)[servers objectForKey: serverName];
if (server == nil)
{
NSLog (@"Trying to ask for not-existent server %@", serverName);
return NO;
}
return ([server multiple] == nil) ? NO : YES;
}
/* Allow the process to be terminated using the same API as Command server
*/
- (oneway void) terminate
{
[self ecQuitFor: @"external -terminate: requested" with: 0];
}
@end
@implementation EcProcess (Private)
- (void) cmdMesgrelease: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"controls double release memory error detection"];
return;
}
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"] == NSOrderedSame)
{
[self cmdPrintf: @"controls double release memory error detection\n"];
[self cmdPrintf: @"to report if an object is released too many times.\n"];
[self cmdPrintf: @"This has a big impact on program performance.\n"];
[self cmdPrintf: @"'release yes' turns on checking\n"];
[self cmdPrintf: @"'release no' turns off checking\n"];
[self cmdPrintf: @"'release default' reverts to default setting\n"];
[self cmdPrintf: @"'release' reports current status\n"];
return;
}
if ([msg count] == 1)
{
[self cmdPrintf: @"Double release checking: %s\n",
[cmdDefs boolForKey: @"Release"] ? "YES" : "NO"];
}
if ([msg count] > 1)
{
if ([[msg objectAtIndex: 1] caseInsensitiveCompare: @"default"]
== NSOrderedSame)
{
[cmdDefs setCommand: nil
forKey: [cmdDefs key: @"Release"]];
}
else
{
[cmdDefs setCommand: [msg objectAtIndex: 1]
forKey: [cmdDefs key: @"Release"]];
}
[self cmdPrintf: @"Double release checking: %s\n",
[cmdDefs boolForKey: @"Release"] ? "YES" : "NO"];
}
}
- (void) cmdMesgtesting: (NSArray*)msg
{
if ([msg count] == 0)
{
[self cmdPrintf: @"controls whether server is running in testing mode"];
return;
}
if ([[msg objectAtIndex: 0] caseInsensitiveCompare: @"help"] == NSOrderedSame)
{
[self cmdPrintf: @"controls whether server is running in testing mode\n"];
[self cmdPrintf: @"Behavior in testing mode is server dependent.\n"];
[self cmdPrintf: @"'testing yes' turns on testing mode\n"];
[self cmdPrintf: @"'testing no' turns off testing mode\n"];
[self cmdPrintf: @"'testing default' reverts to default setting\n"];
[self cmdPrintf: @"'testing' reports current status\n"];
return;
}
if ([msg count] == 1)
{
[self cmdPrintf: @"Server running in testing mode: %s\n",
cmdFlagTesting ? "YES" : "NO"];
}
if ([msg count] > 1)
{
if ([[msg objectAtIndex: 1] caseInsensitiveCompare: @"default"]
== NSOrderedSame)
{
[cmdDefs setCommand: nil
forKey: [cmdDefs key: @"Testing"]];
}
else
{
[cmdDefs setCommand: [msg objectAtIndex: 1]
forKey: [cmdDefs key: @"Testing"]];
}
[self cmdPrintf: @"Server running in testing mode: %s\n",
cmdFlagTesting ? "YES" : "NO"];
}
}
- (void) _ensureMemLogger
{
NSString *bundle = [cmdDefs stringForKey: @"MemoryLoggerBundle"];
Class cls = Nil;
if (nil == bundle)
{
DESTROY(cmdMemoryLogger);
return;
}
// This is a reasonable fast path if we have already loaded the bundle
cls = NSClassFromString(bundle);
if ((Nil == cls)
|| (NO == [cls conformsToProtocol: @protocol(EcMemoryLogger)]))
{
cls = [self _memoryLoggerClassFromBundle: bundle];
}
if (Nil == cls)
{
// No usable logger class, destroy any we might have
DESTROY(cmdMemoryLogger);
return;
}
if (NO == [cmdMemoryLogger isKindOfClass: cls])
{
// If it's no longer the right class, destroy it
DESTROY(cmdMemoryLogger);
}
if (nil == cmdMemoryLogger)
{
NS_DURING
{
cmdMemoryLogger = [cls new];
}
NS_HANDLER
{
[self cmdWarn: @"Exception creating memory logger: %@",
localException];
}
NS_ENDHANDLER
}
}
- (void) _memCheck
{
if (NO == hasLSAN())
{
static EcAlarm *alarm = nil;
static char buf[64] = {0};
EcAlarmSeverity severity = EcAlarmSeverityCleared;
uint64_t mTotal, mResident, mShared, mText, mLib, mData, mDirty;
BOOL memDebug = [cmdDefs boolForKey: @"Memory"];
int pageSize = 4096;
FILE *fptr;
NSString *str;
int i;
memTime = [NSDate timeIntervalSinceReferenceDate];
if (nil == (str = [cmdDefs stringForKey: @"MemoryUnit"]))
{
memSize = 1024;
memUnit = @"KB";
}
else if ([str caseInsensitiveCompare: @"MB"] == NSOrderedSame)
{
memSize = 1024 * 1024;
memUnit = @"MB";
}
else if ([str caseInsensitiveCompare: @"Page"] == NSOrderedSame)
{
memSize = pageSize;
memUnit = @"Pg";
}
else
{
memSize = 1024;
memUnit = @"KB";
}
if (nil == (str = [cmdDefs stringForKey: @"MemoryType"]))
{
str = @"Total";
}
else if ([str caseInsensitiveCompare: @"Resident"] == NSOrderedSame)
{
str = @"Resident";
}
else if ([str caseInsensitiveCompare: @"Data"] == NSOrderedSame)
{
str = @"Data";
}
else
{
str = @"Total";
}
if (NO == [memType isEqual: str])
{
ASSIGNCOPY(memType, str);
memSlot = 0;
}
/* /proc/pid/statm reports the process memory size in 4KB pages
*/
if ('\0' == *buf)
{
sprintf(buf, "/proc/%d/statm",
[[NSProcessInfo processInfo] processIdentifier]);
}
fptr = fopen(buf, "r");
memLast = 1;
mTotal = mResident = mShared = mText = mLib = mData = mDirty = 0;
if (NULL != fptr)
{
if (fscanf(fptr, "%"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64
" %"PRIu64" %"PRIu64,
&mTotal, &mResident, &mShared, &mText, &mLib, &mData, &mDirty) != 7)
{
memLast = 1;
}
else
{
if ([memType isEqualToString: @"Resident"])
{
memLast = mResident;
}
else if ([memType isEqualToString: @"Data"])
{
memLast = mData;
}
else
{
memLast = mTotal;
}
memLast *= pageSize;
if (memLast <= 0) memLast = 1;
}
fclose(fptr);
}
excLast = (uint64_t)[self ecNotLeaked];
[self _ensureMemLogger];
if (nil != cmdMemoryLogger)
{
NS_DURING
{
[cmdMemoryLogger process: self
didUseMemory: mTotal * pageSize
notLeaked: excLast
resident: mResident * pageSize
data: mData * pageSize];
}
NS_HANDLER
{
[self cmdWarn:
@"Exception logging memory usage to bundle: %@",
localException];
}
NS_ENDHANDLER
}
/* Do initial population so we can work immediately.
*/
if (0 == memSlot)
{
for (i = 1; i < MEMCOUNT; i++)
{
excRoll[i] = excLast;
memRoll[i] = memLast;
}
memPrev = memStrt = memLast;
excPrev = excStrt = excLast;
}
excRoll[memSlot % MEMCOUNT] = excLast;
memRoll[memSlot % MEMCOUNT] = memLast;
memSlot++;
/* Find the average usage over the last set of samples.
* Round up to a block size.
*/
excAvge = 0;
memAvge = 0;
for (i = 0; i < MEMCOUNT; i++)
{
excAvge += excRoll[i];
memAvge += memRoll[i];
}
excAvge /= MEMCOUNT;
memAvge /= MEMCOUNT;
/* Convert to 1KB blocks.
*/
if (memAvge % 1024)
{
memAvge = ((memAvge / 1024) + 1) * 1024;
}
if (excAvge % 1024)
{
excAvge = ((excAvge / 1024) + 1) * 1024;
}
/* Update peak memory usage if necessary.
*/
if (memLast > memPeak)
{
memPeak = memLast;
}
if (excLast > excPeak)
{
excPeak = excLast;
}
if (0 == memInitial)
{
memInitial = memPeak;
}
/* If we have a defined maximum memory usage for the process,
* we should perform a restart once that limit is passed.
*/
if (memMaximum > 0)
{
static EcAlarm *raised = nil;
uint64_t minMax = (memInitial * 12) / 10;
if (minMax > (memMaximum * 1024 * 1024))
{
unsigned long oldMaximum = (unsigned long)memMaximum;
memMaximum = 0;
if (nil == raised)
{
EcAlarm *a;
NSString *repair;
NSString *additional;
repair = [NSString stringWithFormat:
@"Reconfigure MemoryMaximum to good value (at least %luMB)",
(unsigned long)(minMax / (1024 * 1024))];
additional = [NSString stringWithFormat:
@"configured value (%luMB) ignored", oldMaximum];
a = [EcAlarm alarmForManagedObject: nil
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmConfigurationOrCustomizationError
specificProblem: @"MemoryMaximum too low"
perceivedSeverity: EcAlarmSeverityMajor
proposedRepairAction: repair
additionalText: additional];
ASSIGN(raised, a);
[self alarm: raised];
}
}
else
{
if (raised)
{
EcAlarm *a = [raised clear];
DESTROY(raised);
[self alarm: a];
}
}
if (memMaximum > 0)
{
int64_t excess = memPeak - (memMaximum * 1024 * 1024);
if (excess > 0)
{
if (NO == memRestart)
{
memRestart = YES;
NSLog(@"MemoryMaximum exceeded by %"PRId64" bytes"
@" ... initiating restart", excess);
[self ecRestart: @"memory usage limit reached"];
}
return;
}
}
}
setMemBase();
if (memWarn > 0 && memAvge > memWarn)
{
if (memAvge > memCrit)
{
severity = EcAlarmSeverityCritical;
}
else if (memAvge > memMajr)
{
if (memAlarm != EcAlarmSeverityCritical)
{
severity = EcAlarmSeverityMajor;
}
}
else if (memAvge > memMinr)
{
if (memAlarm != EcAlarmSeverityCritical
&& memAlarm != EcAlarmSeverityMajor)
{
severity = EcAlarmSeverityMinor;
}
}
else
{
if (memAlarm != EcAlarmSeverityCritical
&& memAlarm != EcAlarmSeverityMajor
&& memAlarm != EcAlarmSeverityMinor)
{
severity = EcAlarmSeverityWarning;
}
}
}
if (EcAlarmSeverityCleared == severity)
{
if (nil != alarm)
{
EcAlarm *clear = [alarm clear];
DESTROY(alarm);
[self alarm: clear];
}
}
else
{
NSString *additional;
additional = [NSString stringWithFormat:
@"Average %@ memory usage %lu%@ (base %lu%@, max %lu%@)",
memType,
(unsigned long)memAvge/memSize, memUnit,
(unsigned long)memBase/memSize, memUnit,
(unsigned long)memMaximum*1024*1024/memSize, memUnit];
NSLog(@"%@", additional);
/* When we are critically close to reaching our memory limit
* AND it's the time of day when the process is idle, we need
* to restart.
*/
if (EcAlarmSeverityCritical == severity)
{
NSString *idle;
int hour;
/* Idle period is hour of the day and number of hours from 1 to 10
*/
idle = [cmdDefs stringForKey: @"MemoryIdle"];
if ([idle length] > 0
&& (hour = [idle intValue]) >= 0 && hour < 24)
{
if ([[NSCalendarDate date] hourOfDay] == hour)
{
if (NO == memRestart)
{
memRestart = YES;
NSLog(@"MemoryMaximum near in idle time; restart");
[self ecRestart: @"memory usage limit when idle"];
}
return;
}
}
}
if ([alarm perceivedSeverity] != severity)
{
EcAlarm *a;
a = [EcAlarm alarmForManagedObject: nil
at: nil
withEventType: EcAlarmEventTypeProcessingError
probableCause: EcAlarmOutOfMemory
specificProblem: @"MemoryAllowed exceeded"
perceivedSeverity: severity
proposedRepairAction: @"Investigate possible leak,"
@" monitor usage, restart process when necessary."
additionalText: additional];
ASSIGN(alarm, a);
[self alarm: alarm];
}
}
if (YES == memDebug)
{
[self cmdDbg: cmdDetailDbg
msg: @"%@ memory usage %"PRIu64"%@ (reserved: %"PRIu64"%@)",
memType, memLast/memSize, memUnit, excLast/memSize, memUnit];
}
}
}
- (NSString*) _moveLog: (NSString*)name to: (NSDate*)when
{
NSString *status = nil;
NS_DURING
{
NSFileManager *mgr = [NSFileManager defaultManager];
NSString *from;
NSDictionary *attr;
from = [cmdLogsDir(nil) stringByAppendingPathComponent: name];
attr = [mgr fileAttributesAtPath: from traverseLink: NO];
if (nil != attr)
{
if ([[attr objectForKey: NSFileSize] intValue] == 0)
{
[mgr removeFileAtPath: from handler: nil];
status = [NSString stringWithFormat:
@"Removed empty log %@", from];
}
else
{
NSString *where;
NSString *sub;
if (nil == when)
{
when = [attr fileModificationDate];
}
sub = [when descriptionWithCalendarFormat: @"%Y-%m-%d"
timeZone: nil
locale: nil];
where = cmdLogsDir(sub);
if (where != nil)
{
NSString *path;
NSString *base;
NSString *gzpath;
unsigned count = 0;
path = [where stringByAppendingPathComponent: name];
/*
* Check for pre-existing file - if found, try another.
*/
base = path;
path = [base stringByAppendingPathExtension: @"0"];
gzpath = [path stringByAppendingPathExtension: @"gz"];
while ([mgr fileExistsAtPath: path] == YES
|| [mgr fileExistsAtPath: gzpath] == YES)
{
NSString *ext;
ext = [stringClass stringWithFormat: @"%u", ++count];
path = [base stringByAppendingPathExtension: ext];
gzpath = [path stringByAppendingPathExtension: @"gz"];
}
if ([mgr movePath: from
toPath: path
handler: nil] == NO)
{
status = [NSString stringWithFormat:
@"Unable to move %@ to %@", from, path];
}
else
{
status = [NSString stringWithFormat:
@"Moved %@ to %@", from, path];
}
}
else
{
status = [NSString stringWithFormat:
@"Unable to archive log %@ into %@", name, sub];
}
}
}
}
NS_HANDLER
{
status = [NSString stringWithFormat: @"Problem in %@ with %@ to %@ - %@",
NSStringFromSelector(_cmd), name, when, localException];
}
NS_ENDHANDLER
return status;
}
- (void) _timedOut: (NSTimer*)timer
{
static BOOL inProgress = NO;
int sig = [self cmdSignalled];
cmdPTimer = nil;
if (sig > 0)
{
NSString *shutdown;
shutdown = [NSString stringWithFormat: @"signal %d received", sig];
[self ecQuitFor: shutdown with: sig];
}
if (YES == ecIsQuitting())
{
NSLog(@"_timedOut: ignored because process is quitting");
}
else if (YES == inProgress)
{
NSLog(@"_timedOut: ignored because timeout already in progress");
}
else
{
BOOL delay = NO;
inProgress = YES;
/* We only perform timeouts if the process is actually
* running (don't want them during startup before the
* thing is fully initialised.
* So if not running, skip to scheduling next timeout.
*/
if (YES == cmdIsRunning)
{
NS_DURING
{
NSCalendarDate *now = [NSCalendarDate date];
static int lastDay = -1;
static int lastHour = -1;
static int lastMinute = -1;
static int lastTenSecond = -1;
BOOL newDay = NO;
BOOL newHour = NO;
BOOL newMinute = NO;
BOOL newTenSecond = NO;
int i;
i = [now dayOfWeek];
if (i != lastDay)
{
lastDay = i;
newDay = YES;
newHour = YES;
newMinute = YES;
newTenSecond = YES;
}
i = [now hourOfDay];
if (i != lastHour)
{
lastHour = i;
newHour = YES;
newMinute = YES;
newTenSecond = YES;
}
i = [now minuteOfHour];
if (i != lastMinute)
{
lastMinute = i;
newMinute = YES;
newTenSecond = YES;
}
i = [now secondOfMinute] / 10;
if (i != lastTenSecond)
{
lastTenSecond = i;
newTenSecond = YES;
}
if (YES == newTenSecond)
{
[self cmdNewServer];
}
if (YES == newMinute)
{
[self ecNewMinute: now];
}
if (YES == newHour)
{
[self ecNewHour: now];
}
if (YES == newDay)
{
[self ecNewDay: now];
}
if (cmdTimSelector != 0)
{
[self performSelector: cmdTimSelector];
}
}
NS_HANDLER
{
NSLog(@"Exception performing regular timeout: %@",
localException);
delay = YES; // Avoid runaway logging.
}
NS_ENDHANDLER
}
if (cmdPTimer == nil)
{
NSTimeInterval when = cmdTimInterval;
if (when < 0.001 || (when < 10.0 && YES == delay))
{
when = 10.0;
}
if (when > 300.0)
{
when = 60.0;
}
cmdPTimer =
[NSTimer scheduledTimerWithTimeInterval: when
target: self
selector: @selector(_timedOut:)
userInfo: nil
repeats: NO];
}
inProgress = NO;
}
}
- (void) _update: (NSMutableDictionary*)info
{
NSMutableDictionary *newConfig;
NSDictionary *dict;
NSEnumerator *enumerator;
NSString *key;
if (YES == ecIsQuitting())
{
NSLog(@"Configuration change during process shutdown ... ignored.");
return; // Ignore config updates while quitting
}
/* The configuration should contain information about any operators
* who are allowed to issue commands to this process.
*/
[self ecOperators: [info objectForKey: @"Operators"]];
newConfig = [NSMutableDictionary dictionaryWithCapacity: 32];
/*
* Put all values for this application in the cmdConf dictionary.
*/
dict = [info objectForKey: cmdLogName()];
if (dict != nil)
{
enumerator = [dict keyEnumerator];
while ((key = [enumerator nextObject]) != nil)
{
id obj;
if ([noNetConfig containsObject: key])
{
[self cmdWarn: @"Bad key '%@' in net config.", key];
continue;
}
obj = [dict objectForKey: key];
[newConfig setObject: obj forKey: key];
}
}
/*
* Add any default values to the cmdConf
* dictionary where we don't have application
* specific values.
*/
dict = [info objectForKey: @"*"];
if (dict)
{
enumerator = [dict keyEnumerator];
while ((key = [enumerator nextObject]) != nil)
{
if ([newConfig objectForKey: key] == nil)
{
id obj;
if ([noNetConfig containsObject: key])
{
[self cmdWarn: @"Bad key '%@' in net config.", key];
continue;
}
obj = [dict objectForKey: key];
[newConfig setObject: obj forKey: key];
}
}
}
if (nil == cmdConf || [cmdConf isEqual: newConfig] == NO)
{
DESTROY(configError);
configInProgress = YES;
NS_DURING
[self cmdUpdate: newConfig];
NS_HANDLER
NSLog(@"Problem before updating config (in cmdUpdate:) %@",
localException);
ASSIGN(configError, @"the -cmdUpdate: method raised an exception");
NS_ENDHANDLER
configInProgress = NO;
[self _defaultsChanged: nil];
}
}
@end
@implementation EcProcess (Test)
- (bycopy NSString*) ecTestCommand: (in bycopy NSString*)command
{
NSEnumerator *enumerator;
NSMutableArray *words;
NSString *word;
command = [command stringByTrimmingSpaces];
words = [NSMutableArray arrayWithCapacity: 16];
enumerator = [[command componentsSeparatedByString: @" "] objectEnumerator];
while ((word = [enumerator nextObject]) != nil)
{
[words addObject: [word stringByTrimmingSpaces]];
}
if ([words count] == 0)
{
return nil;
}
return [self ecMesg: words from: nil];
}
- (bycopy NSData*) ecTestConfigForKey: (in bycopy NSString*)key
{
id result = [cmdDefs objectForKey: key];
if (nil != result)
{
result = [NSPropertyListSerialization
dataFromPropertyList: result
format: NSPropertyListBinaryFormat_v1_0
errorDescription: 0];
}
return result;
}
- (void) ecTestSetConfig: (in bycopy NSData*)data
forKey: (in bycopy NSString*)key
{
id val;
if (nil == data)
{
val = data;
}
else
{
val = [NSPropertyListSerialization
propertyListWithData: data
options: NSPropertyListMutableContainers
format: 0
error: 0];
}
[cmdDefs setCommand: val forKey: [cmdDefs key: key]];
}
@end
@implementation EcProcess (Defaults)
- (void) _defMemory: (id)val
{
BOOL stats = [val boolValue];
GSDebugAllocationActive(stats);
if (YES == stats && nil == memStats)
{
ASSIGN(memStats, [NSDate date]);
}
if (NO == stats && nil != memStats)
{
DESTROY(memStats);
}
}
- (void) _defRelease: (id)val
{
[NSObject enableDoubleReleaseCheck: [val boolValue]];
}
- (void) _defTesting: (id)val
{
cmdFlagTesting = [val boolValue];
}
@end
@implementation EcDefaultRegistration
static NSMutableDictionary *regDefs = nil;
+ (void) defaultsChanged: (NSUserDefaults*)defs
{
NSEnumerator *e;
NSString *n;
[ecLock lock];
e = [[regDefs allKeys] objectEnumerator];
[ecLock unlock];
while (nil != (n = [e nextObject]))
{
EcDefaultRegistration *d;
id o = nil;
SEL c = NULL;
[ecLock lock];
d = [regDefs objectForKey: n];
if (nil != d)
{
o = [defs objectForKey: n];
if (o != d->obj && NO == [o isEqual: d->obj])
{
ASSIGNCOPY(d->obj, o);
o = d->obj;
c = d->cmd;
}
}
[ecLock unlock];
if (NULL != c && [EcProc respondsToSelector: c])
{
[EcProc performSelector: c withObject: o];
}
}
}
+ (void) initialize
{
regDefs = [NSMutableDictionary new];
}
/* Key may be one of:
* nil list all registered defaults keys
* empty list all registered defaults help
* other list the registered defaults help for the specified key
*/
+ (NSMutableString*) listHelp: (NSString*)key
{
NSMutableString *out = [NSMutableString stringWithCapacity: 1000];
NSArray *keys;
NSString *prf;
NSEnumerator *e;
NSString *k;
NSUInteger max = 0;
prf = EC_DEFAULTS_PREFIX;
if (nil == prf)
{
prf = @"";
}
[ecLock lock];
keys = [regDefs allKeys];
[ecLock unlock];
e = [keys objectEnumerator];
while (nil != (k = [e nextObject]))
{
EcDefaultRegistration *d;
[ecLock lock];
d = [regDefs objectForKey: k];
if (nil != d->type && nil != d->help)
{
NSUInteger length = [prf length] + 5;
length += [k length] + [d->type length];
if (length > max)
{
max = length;
}
}
[ecLock unlock];
}
keys = [keys sortedArrayUsingSelector: @selector(compare:)];
e = [keys objectEnumerator];
if (nil == key)
{
unsigned col = 0;
/* We just want to list all the keys ...
*/
while (nil != (k = [e nextObject]))
{
if (col + [k length] > 70)
{
[out appendString: @"\n"];
col = 0;
}
if (col > 0)
{
[out appendString: @" "];
col++;
}
[out appendString: k];
col = [k length];
}
if (col > 0)
{
[out appendString: @"\n"];
}
}
else
{
while (nil != (k = [e nextObject]))
{
EcDefaultRegistration *d;
if ([key length] > 0)
{
/* We want help for a specific key.
*/
if ([key caseInsensitiveCompare: k] != NSOrderedSame)
{
NSString *pk = [prf stringByAppendingString: k];
if ([key caseInsensitiveCompare: pk] != NSOrderedSame)
{
continue; /* This is not the key we are looking for */
}
}
}
[ecLock lock];
d = [regDefs objectForKey: k];
if (nil != d->type && nil != d->help)
{
/* If the help text is short enough, put it all on one line.
*/
if ([d->help length] + max < 80)
{
NSMutableString *m;
m = [NSMutableString stringWithFormat: @"-%@%@ [%@] ",
prf, k, d->type];
while ([m length] < max)
{
[m appendString: @" "];
}
[out appendFormat: @"%@%@\n", m, d->help];
}
else
{
[out appendFormat: @"-%@%@ [%@]\n %@\n",
prf, k, d->type, d->help];
}
}
[ecLock unlock];
}
}
return out;
}
+ (NSDictionary*) merge: (NSDictionary*)d
{
NSMutableDictionary *m = AUTORELEASE([d mutableCopy]);
NSEnumerator *e;
NSString *k;
if (nil == m)
{
m = [NSMutableDictionary dictionaryWithCapacity: [regDefs count]];
}
[ecLock lock];
e = [regDefs keyEnumerator];
while (nil != (k = [e nextObject]))
{
EcDefaultRegistration *r = [regDefs objectForKey: k];
if (nil != r->val && nil == [d objectForKey: k])
{
[m setObject: r->val forKey: k];
}
}
[ecLock unlock];
return m;
}
+ (void) registerDefault: (NSString*)name
withTypeText: (NSString*)type
andHelpText: (NSString*)help
action: (SEL)cmd
value: (id)value
{
static NSCharacterSet *w = nil;
EcDefaultRegistration *d;
if (nil == w)
{
w = RETAIN([NSCharacterSet whitespaceAndNewlineCharacterSet]);
}
if ([type length] > 0)
{
type = [type stringByTrimmingSpaces];
if ([type length] == 0)
{
type = nil;
}
else
{
NSUInteger length = [type length];
NSMutableString *m = nil;
while (length-- > 0)
{
unichar u = [type characterAtIndex: length];
if (u != ' ' && [w characterIsMember: u])
{
if (nil == m)
{
m = AUTORELEASE([type mutableCopy]);
type = m;
}
[m replaceCharactersInRange: NSMakeRange(length, 1)
withString: @" "];
}
}
}
}
if ([help length] > 0)
{
help = [help stringByTrimmingSpaces];
if ([help length] == 0)
{
help = nil;
}
}
[ecLock lock];
d = [regDefs objectForKey: name];
if (nil == d)
{
d = [EcDefaultRegistration new];
ASSIGNCOPY(d->name, name);
[regDefs setObject: d forKey: d->name];
RELEASE(d);
}
ASSIGNCOPY(d->type, type);
ASSIGNCOPY(d->help, help);
if (0 != cmd)
{
d->cmd = cmd;
}
ASSIGNCOPY(d->val, value);
[ecLock unlock];
}
+ (void) showHelp
{
GSPrintf(stderr, @"%@", [self listHelp: @""]);
}
- (void) dealloc
{
RELEASE(name);
RELEASE(type);
RELEASE(help);
RELEASE(obj);
[super dealloc];
}
@end
Reference in a new issue View git blame Copy permalink