CAMLprim value stub_asl_new_msg() {
CAMLparam0();
caml_release_runtime_system();
aslmsg msg = asl_new(ASL_TYPE_MSG);
caml_acquire_runtime_system();
CAMLreturn(alloc_message(msg));
}
int
main(void)
{
kern_return_t kr;
struct stat statbuf;
// Initialize a message for use with the Apple System Log (asl) facility.
logmsg = asl_new(ASL_TYPE_MSG);
asl_set(logmsg, "Facility", "Sleeper Daemon");
// If the shutdown flag file exists, we are destroying the service;
// otherwise, we are trying to be a server.
if (stat(SERVICE_SHUTDOWN_FILE, &statbuf) == 0) {
kr = unregister_bootstrap_service();
MY_ASL_LOG("destroying service %s\n", SERVICE_NAME);
} else {
kr = register_bootstrap_service();
MY_ASL_LOG("starting up service %s\n", SERVICE_NAME);
}
if (kr != KERN_SUCCESS) {
// NB: When unregistering, we will get here if the unregister succeeded.
mach_error("bootstrap_register", kr);
exit(kr);
}
MY_ASL_LOG("server loop ready\n");
while (1) // Dummy server loop.
sleep(60);
exit(0);
}
void SFB::Logger::Log(levels level, const char *facility, const char *message, const char *function, const char *file, int line)
{
if(currentLogLevel < level)
return;
aslmsg msg = asl_new(ASL_TYPE_MSG);
if(facility)
asl_set(msg, ASL_KEY_FACILITY, facility);
if(function)
asl_set(msg, "Function", function);
if(file)
asl_set(msg, "File", file);
if(-1 != line) {
char buf [32];
if(snprintf(buf, sizeof(buf), "%d", line))
asl_set(msg, "Line", buf);
}
asl_log(nullptr, msg, level, "%s", message);
asl_free(msg);
}
//
// MessageTracer support
//
MessageTrace::MessageTrace(const char *domain, const char *signature)
{
mAsl = asl_new(ASL_TYPE_MSG);
if (domain)
asl_set(mAsl, "com.apple.message.domain", domain);
if (signature)
asl_set(mAsl, "com.apple.message.signature", signature);
}
void __security_debug(const char *scope, const char *function,
const char *file, int line, const char *format, ...)
{
#if !defined(NDEBUG)
pthread_once(&__security_debug_once, __security_debug_init);
CFStringRef scopeName = NULL;
/* Scope NULL is always enabled. */
if (scope) {
/* Check if the scope is enabled. */
if (scopeSet) {
scopeName = copyScopeName(scope, strlen(scope));
if (negate == CFSetContainsValue(scopeSet, scopeName)) {
CFRelease(scopeName);
return;
}
} else if (!negate) {
return;
}
}
CFStringRef formatStr = CFStringCreateWithCString(kCFAllocatorDefault,
format, kCFStringEncodingUTF8);
va_list args;
va_start(args, format);
CFStringRef message = CFStringCreateWithFormatAndArguments(
kCFAllocatorDefault, NULL, formatStr, args);
va_end(args);
time_t now = time(NULL);
char *date = ctime(&now);
date[19] = '\0';
CFStringRef logStr = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%s %-*s %s %@\n"), date + 4, MAX_SCOPE_LENGTH - 1,
scope ? scope : "", function, message);
CFShow(logStr);
char logMsg[4096];
if (CFStringGetCString(logStr, logMsg, sizeof(logMsg), kCFStringEncodingUTF8)) {
#if 0
asl_log(NULL, NULL, ASL_LEVEL_INFO, logMsg);
#else
aslmsg msg = asl_new(ASL_TYPE_MSG);
if (scope) {
asl_set(msg, ASL_KEY_FACILITY, scope);
}
asl_set(msg, ASL_KEY_LEVEL, ASL_STRING_INFO);
asl_set(msg, ASL_KEY_MSG, logMsg);
asl_send(NULL, msg);
asl_free(msg);
#endif
}
CFRelease(logStr);
CFRelease(message);
CFRelease(formatStr);
if (scopeName)
CFRelease(scopeName);
#endif
}
// create a new ASL log
void asepsis_setup_logging(void) {
static int asepsis_logging_initialized = 0;
if (asepsis_logging_initialized) {
return;
}
asepsis_logging_initialized = 1;
g_asepsis_asl = asl_open("Asepsis", "dylib", 0);
g_asepsis_log_msg = asl_new(ASL_TYPE_MSG);
asl_set(g_asepsis_log_msg, ASL_KEY_SENDER, "Asepsis");
}
static void
sec_debug_init() {
char *ccEnvStdErr = getenv("CC_STDERR");
if(ccEnvStdErr != NULL && strncmp(ccEnvStdErr, "yes", 3) == 0) std_options |= ASL_OPT_STDERR;
aslhandle = asl_open(std_ident, std_facility, std_options);
msgptr = asl_new(ASL_TYPE_MSG);
asl_set(msgptr, ASL_KEY_FACILITY, "com.apple.infosec");
}
void RARCH_LOG_V(const char *tag, const char *fmt, va_list ap)
{
#if TARGET_OS_IPHONE
static int asl_inited = 0;
#if !TARGET_IPHONE_SIMULATOR
static aslclient asl_client;
#endif
#endif
if (!RARCH_LOG_VERBOSE())
return;
#if TARGET_OS_IPHONE
#if TARGET_IPHONE_SIMULATOR
vprintf(fmt, ap);
#else
if (!asl_inited)
{
asl_client = asl_open("RetroArch", "com.apple.console", ASL_OPT_STDERR | ASL_OPT_NO_DELAY);
asl_inited = 1;
}
aslmsg msg = asl_new(ASL_TYPE_MSG);
asl_set(msg, ASL_KEY_READ_UID, "-1");
if (tag)
asl_log(asl_client, msg, ASL_LEVEL_NOTICE, "%s", tag);
asl_vlog(asl_client, msg, ASL_LEVEL_NOTICE, fmt, ap);
asl_free(msg);
#endif
#elif defined(_XBOX1)
/* FIXME: Using arbitrary string as fmt argument is unsafe. */
char msg_new[1024], buffer[1024];
snprintf(msg_new, sizeof(msg_new), "%s: %s %s",
PROGRAM_NAME,
tag ? tag : "",
fmt);
wvsprintf(buffer, msg_new, ap);
OutputDebugStringA(buffer);
#elif defined(ANDROID)
int prio = ANDROID_LOG_INFO;
if (tag)
{
if (string_is_equal("[WARN]", tag))
prio = ANDROID_LOG_WARN;
else if (string_is_equal("[ERROR]", tag))
prio = ANDROID_LOG_ERROR;
}
__android_log_vprint(prio, PROGRAM_NAME, fmt, ap);
#else
fprintf(LOG_FILE, "%s %s :: ", PROGRAM_NAME, tag ? tag : "[INFO]");
vfprintf(LOG_FILE, fmt, ap);
fflush(LOG_FILE);
#endif
}
void SMBLogInfo(const char *fmt, int log_level,...)
{
int save_errno = errno;
va_list ap;
aslmsg m = asl_new(ASL_TYPE_MSG);
va_start(ap, log_level);
asl_vlog(NULL, m, log_level, fmt, ap);
va_end(ap);
asl_free(m);
errno = save_errno; /* Never let this routine change errno */
}
void _IOHIDLog(int level, const char *format, ...)
{
aslmsg msg = NULL;
if (1) {
msg = asl_new(ASL_TYPE_MSG);
asl_set(msg, ASL_KEY_FACILITY, "com.apple.iokit.IOHID");
}
va_list ap;
va_start(ap, format);
asl_vlog(NULL, msg, level, format, ap);
va_end(ap);
if (msg) {
asl_free(msg);
}
}
static
void
sessionLogEvent (const char *domain, const char *event_msg)
{
aslmsg m;
if (!domain || !event_msg) {
return;
}
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, domain);
asl_set(m, ASL_KEY_MSG, sessionString);
asl_log(NULL, m, ASL_LEVEL_NOTICE, "SCNCController: %s", event_msg);
asl_free(m);
}
uint32_t
asl_store_statistics(asl_store_t *s, aslmsg *msg)
{
aslmsg out;
if (s == NULL) return ASL_STATUS_INVALID_STORE;
if (msg == NULL) return ASL_STATUS_INVALID_ARG;
out = asl_new(ASL_TYPE_MSG);
if (out == NULL) return ASL_STATUS_NO_MEMORY;
/* does nothing for now */
*msg = out;
return ASL_STATUS_OK;
}
aslmsg createAslQuery(const QueryContext& context) {
aslmsg query = asl_new(ASL_TYPE_QUERY);
// Set constraints in query
for (const auto& it : context.constraints) {
const std::string& key = it.first;
ColumnType col_type = it.second.affinity;
for (const auto& constraint : it.second.getAll()) {
addQueryOp(query,
key,
constraint.expr,
static_cast<ConstraintOperator>(constraint.op),
col_type);
}
}
return query;
}
static void
sessionTracerLogStop (const char *domain, const char *type, int caused_by_failure, const char *reason, u_int32_t established, u_int32_t duration)
{
aslmsg m;
char * buf;
char data[256] = {0};
m = asl_new(ASL_TYPE_MSG);
asl_set(m, "com.apple.message.domain", domain);
asl_set(m, "com.apple.message.type", type);
asl_set(m, ASL_KEY_FACILITY, domain);
asl_set(m, ASL_KEY_MSG, sessionString);
if (caused_by_failure) {
asl_set(m, "com.apple.message.result", CONSTSTR("failure")); // failure
} else {
asl_set(m, "com.apple.message.result", CONSTSTR("success")); // success
}
if (reason) {
asl_set(m, "com.apple.message.reason", reason);
} else {
// reason was NULL; make sure success/failure have different signature
if (caused_by_failure) {
asl_set(m, "com.apple.message.reason", CONSTSTR("Internal/Server-side error"));
} else {
asl_set(m, "com.apple.message.reason", CONSTSTR("User/System initiated the disconnect"));
}
}
buf = sessionTracerBucketizeTime(duration);
if (established) {
asl_set(m, "com.apple.message.connectiontime", buf); // stuff the up time into value
snprintf(data, sizeof(data), "SCNCController: Disconnecting.");
asl_set(m, "com.apple.message.controller", data);
asl_log(NULL, m, ASL_LEVEL_NOTICE, "");
} else {
asl_set(m, "com.apple.message.negotiatingtime", buf); /// stuff the negoing time into value2
snprintf(data, sizeof(data), "SCNCController: Disconnecting.");
asl_set(m, "com.apple.message.controller", data);
asl_log(NULL, m, ASL_LEVEL_NOTICE, "");
}
asl_free(m);
}
TEST_F(AslTests, test_read_asl_row) {
aslmsg row = asl_new(ASL_TYPE_MSG);
ASSERT_EQ(0, asl_set(row, "Sender", "foo"));
ASSERT_EQ(0, asl_set(row, "Level", "1"));
ASSERT_EQ(0, asl_set(row, "Message", "bar"));
ASSERT_EQ(0, asl_set(row, "Bang", "bang_val"));
Row r;
readAslRow(row, r);
ASSERT_EQ((size_t)4, r.size());
ASSERT_EQ("foo", r["sender"]);
ASSERT_EQ("1", r["level"]);
ASSERT_EQ("bar", r["message"]);
ASSERT_EQ((size_t)0, r.count("bang"));
ASSERT_EQ("{\"Bang\":\"bang_val\"}\n", r["extra"]);
asl_release(row);
}
void __libclog_log( int level, char * fmt, va_list ap )
{
aslmsg msg;
if( __libclog_client_connected == false )
{
__libclog_create_client();
}
if( __libclog_client == NULL )
{
fprintf( stderr, "Impossible to create the ASL client\n" );
exit( EXIT_FAILURE );
}
msg = asl_new( ASL_TYPE_MSG );
asl_set( msg, ASL_KEY_FACILITY, "com.apple.console" );
asl_vlog( __libclog_client, msg, level, fmt, ap );
}
void
vsyslog(int pri, const char *fmt, va_list ap)
{
int fac;
aslmsg facmsg;
const char *facility;
facmsg = NULL;
fac = pri & LOG_FACMASK;
if (fac != 0)
{
facility = asl_syslog_faciliy_num_to_name(fac);
if (facility != NULL)
{
facmsg = asl_new(ASL_TYPE_MSG);
asl_set(facmsg, ASL_KEY_FACILITY, facility);
}
}
asl_vlog(_sl_asl, facmsg, LOG_PRI(pri), fmt, ap);
if (facmsg != NULL) asl_free(facmsg);
}
void
sessionTracerLogEstablished (struct service *serv)
{
if (serv) {
aslmsg m;
char data[256] = {0};
const char *type = sessionGetType(serv);
if (!strcmp(type, nullString)) {
/* We do not trace VPN */
return;
}
const char *domain = sessionGetConnectionLessDomain();
if (sessionCheckIfEstablished(serv)) {
// already established no need to log (mostly here due to sleep-wake)
return;
}
sessionIsEstablished(serv);
m = asl_new(ASL_TYPE_MSG);
asl_set(m, "com.apple.message.domain", domain);
asl_set(m, "com.apple.message.type", type);
asl_set(m, "com.apple.message.result", CONSTSTR("success"));
asl_set(m, "com.apple.message.reason", CONSTSTR("established"));
asl_set(m, ASL_KEY_FACILITY, domain);
asl_set(m, ASL_KEY_MSG, sessionString);
sessionTracerLogPPPInfo(m, serv);
snprintf(data, sizeof(data), "SCNCController: Connected.");
asl_set(m, "com.apple.message.controller", data);
asl_log(NULL, m, ASL_LEVEL_NOTICE, "");
asl_free(m);
}
}
/*
* Open and set up system logging.
*/
void
auditd_openlog(int debug, gid_t gid)
{
uint32_t opt = 0;
char *cp = NULL;
if (debug)
opt = ASL_OPT_STDERR;
au_aslclient = asl_open("auditd", "com.apple.auditd", opt);
au_aslmsg = asl_new(ASL_TYPE_MSG);
#ifdef ASL_KEY_READ_UID
/*
* Make it only so the audit administrator and members of the audit
* review group (if used) have access to the auditd system log messages.
*/
asl_set(au_aslmsg, ASL_KEY_READ_UID, "0");
asprintf(&cp, "%u", gid);
if (cp != NULL) {
#ifdef ASL_KEY_READ_GID
asl_set(au_aslmsg, ASL_KEY_READ_GID, cp);
#endif
free(cp);
}
#endif
/*
* Set the client-side system log filtering.
*/
if (debug)
asl_set_filter(au_aslclient,
ASL_FILTER_MASK_UPTO(ASL_LEVEL_DEBUG));
else
asl_set_filter(au_aslclient,
ASL_FILTER_MASK_UPTO(ASL_LEVEL_INFO));
}
static CFMutableArrayRef get_log_handlers()
{
static dispatch_once_t handlers_once;
dispatch_once(&handlers_once, ^{
sSecurityLogHandlers = CFArrayCreateMutableForCFTypes(kCFAllocatorDefault);
CFArrayAppendValue(sSecurityLogHandlers, ^(const char *level, CFStringRef scope, const char *function,
const char *file, int line, CFStringRef message){
CFStringRef logStr = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@ %s %@\n"), scope ? scope : CFSTR(""), function, message);
CFStringPerformWithCString(logStr, ^(const char *logMsg) {
aslmsg msg = asl_new(ASL_TYPE_MSG);
if (scope) {
CFStringPerformWithCString(scope, ^(const char *scopeStr) {
asl_set(msg, ASL_KEY_FACILITY, scopeStr);
});
}
asl_set(msg, ASL_KEY_LEVEL, level);
asl_set(msg, ASL_KEY_MSG, logMsg);
asl_send(NULL, msg);
asl_free(msg);
});
CFReleaseSafe(logStr);
});
void RARCH_LOG_V(const char *tag, const char *fmt, va_list ap)
{
#if TARGET_OS_IPHONE
#if TARGET_IPHONE_SIMULATOR
vprintf(fmt, ap);
#else
static aslclient asl_client;
static int asl_initialized = 0;
if (!asl_initialized)
{
asl_client = asl_open(
file_path_str(FILE_PATH_PROGRAM_NAME),
"com.apple.console",
ASL_OPT_STDERR | ASL_OPT_NO_DELAY);
asl_initialized = 1;
}
aslmsg msg = asl_new(ASL_TYPE_MSG);
asl_set(msg, ASL_KEY_READ_UID, "-1");
if (tag)
asl_log(asl_client, msg, ASL_LEVEL_NOTICE, "%s", tag);
asl_vlog(asl_client, msg, ASL_LEVEL_NOTICE, fmt, ap);
asl_free(msg);
#endif
#elif defined(_XBOX1)
{
/* FIXME: Using arbitrary string as fmt argument is unsafe. */
char msg_new[1024];
char buffer[1024];
msg_new[0] = buffer[0] = '\0';
snprintf(msg_new, sizeof(msg_new), "%s: %s %s",
file_path_str(FILE_PATH_PROGRAM_NAME),
tag ? tag : "",
fmt);
wvsprintf(buffer, msg_new, ap);
OutputDebugStringA(buffer);
}
#elif defined(ANDROID)
{
int prio = ANDROID_LOG_INFO;
if (tag)
{
if (string_is_equal(file_path_str(FILE_PATH_LOG_WARN), tag))
prio = ANDROID_LOG_WARN;
else if (string_is_equal(file_path_str(FILE_PATH_LOG_ERROR), tag))
prio = ANDROID_LOG_ERROR;
}
__android_log_vprint(prio,
file_path_str(FILE_PATH_PROGRAM_NAME),
fmt,
ap);
}
#else
{
#ifdef HAVE_QT
char buffer[1024];
#endif
#ifdef HAVE_FILE_LOGGER
FILE *fp = (FILE*)retro_main_log_file();
#else
FILE *fp = stderr;
#endif
#ifdef HAVE_QT
buffer[0] = '\0';
vsnprintf(buffer, sizeof(buffer), fmt, ap);
if (fp)
{
fprintf(fp, "%s %s", tag ? tag : file_path_str(FILE_PATH_LOG_INFO), buffer);
fflush(fp);
}
ui_companion_driver_log_msg(buffer);
#else
#if defined(NXLINK) && !defined(HAVE_FILE_LOGGER)
if (nxlink_connected)
mutexLock(&nxlink_mtx);
#endif
if (fp)
{
fprintf(fp, "%s ",
tag ? tag : file_path_str(FILE_PATH_LOG_INFO));
vfprintf(fp, fmt, ap);
fflush(fp);
}
#if defined(NXLINK) && !defined(HAVE_FILE_LOGGER)
if (nxlink_connected)
mutexUnlock(&nxlink_mtx);
#endif
#endif
}
#endif
}
TEST_F(AslTests, test_add_query_op) {
aslmsg query = asl_new(ASL_TYPE_QUERY);
ASSERT_EQ((uint32_t)ASL_TYPE_QUERY, asl_get_type(query));
ASSERT_EQ((size_t)0, asl_count(query));
const char *key, *val;
uint32_t op;
addQueryOp(query, "sender", "bar", EQUALS, TEXT_TYPE);
ASSERT_EQ((size_t)1, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 0, &key, &val, &op));
ASSERT_STREQ("Sender", key);
ASSERT_STREQ("bar", val);
ASSERT_EQ((uint32_t)ASL_QUERY_OP_EQUAL, op);
addQueryOp(query, "level", "1", GREATER_THAN, INTEGER_TYPE);
ASSERT_EQ((size_t)2, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 1, &key, &val, &op));
ASSERT_STREQ("Level", key);
ASSERT_STREQ("1", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_GREATER | ASL_QUERY_OP_NUMERIC), op);
addQueryOp(query, "gid", "999", LESS_THAN, BIGINT_TYPE);
ASSERT_EQ((size_t)3, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 2, &key, &val, &op));
ASSERT_STREQ("GID", key);
ASSERT_STREQ("999", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_LESS | ASL_QUERY_OP_NUMERIC), op);
addQueryOp(query, "facility", "hoo", GREATER_THAN_OR_EQUALS, TEXT_TYPE);
ASSERT_EQ((size_t)4, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 3, &key, &val, &op));
ASSERT_STREQ("Facility", key);
ASSERT_STREQ("hoo", val);
ASSERT_EQ((uint32_t)ASL_QUERY_OP_GREATER_EQUAL, op);
addQueryOp(query, "pid", "30", LESS_THAN_OR_EQUALS, INTEGER_TYPE);
ASSERT_EQ((size_t)5, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 4, &key, &val, &op));
ASSERT_STREQ("PID", key);
ASSERT_STREQ("30", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_LESS_EQUAL | ASL_QUERY_OP_NUMERIC), op);
addQueryOp(query, "ref_proc", "%tom%", LIKE, TEXT_TYPE);
ASSERT_EQ((size_t)6, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 5, &key, &val, &op));
ASSERT_STREQ("RefProc", key);
ASSERT_STREQ(".*tom.*", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_EQUAL | ASL_QUERY_OP_REGEX |
ASL_QUERY_OP_CASEFOLD),
op);
// Queries against the extra column should not be sent to ASL
addQueryOp(query, "extra", "tom", EQUALS, TEXT_TYPE);
ASSERT_EQ((size_t)6, asl_count(query));
// Queries with unsupported operators should not be sent to ASL
addQueryOp(query, "host", "tom", GLOB, TEXT_TYPE);
ASSERT_EQ((size_t)6, asl_count(query));
asl_release(query);
}
static bool OSX_SetCloudKeychainTraceValueForKey(CFStringRef key, int64_t value)
{
bool result = false;
if (NULL == key)
{
return result;
}
aslmsg mAsl = NULL;
mAsl = asl_new(ASL_TYPE_MSG);
if (NULL == mAsl)
{
return result;
}
CFStringRef key_str = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@%@"), gMessageTracerPrefix, key);
if (NULL == key_str)
{
asl_free(mAsl);
return result;
}
CFStringRef value_str = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%lld"), value);
if (NULL == value_str)
{
asl_free(mAsl);
CFRelease(key_str);
return result;
}
CFIndex key_str_numBytes = CFStringGetMaximumSizeForEncoding(CFStringGetLength(key_str), kCFStringEncodingUTF8);
key_str_numBytes += 1; // For null
char key_buffer[key_str_numBytes];
memset(key_buffer, 0, key_str_numBytes);
if (!CFStringGetCString(key_str, key_buffer, key_str_numBytes, kCFStringEncodingUTF8))
{
asl_free(mAsl);
CFRelease(key_str);
CFRelease(value_str);
return result;
}
CFRelease(key_str);
CFIndex value_str_numBytes = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value_str), kCFStringEncodingUTF8);
value_str_numBytes += 1; // For null
char value_buffer[value_str_numBytes];
memset(value_buffer, 0, value_str_numBytes);
if (!CFStringGetCString(value_str, value_buffer, value_str_numBytes, kCFStringEncodingUTF8))
{
asl_free(mAsl);
CFRelease(value_str);
return result;
}
CFRelease(value_str);
asl_set(mAsl, key_buffer, value_buffer);
asl_log(NULL, mAsl, ASL_LEVEL_NOTICE, "%s", gTopLevelKeyForiCloudKeychainTracing);
asl_free(mAsl);
return true;
}
int main(int argc, char *argv[])
{
OSStatus err;
int argIndex;
Boolean delay;
Boolean waitForWindowServerSession;
Boolean forceShow;
Boolean cleanExit;
IBNibRef nibRef;
WindowRef window;
// Initialise our ASL state.
gASLClient = asl_open(NULL, "PreLoginAgents", 0);
assert(gASLClient != NULL);
(void) asl_set_filter(gASLClient, ASL_FILTER_MASK_UPTO(ASL_LEVEL_INFO));
gASLMessage = asl_new(ASL_TYPE_MSG);
assert(gASLMessage != NULL);
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Start");
// Parse our arguments. We support arguments that allow you to turn off
// various special cases within the code. This makes it easy to test whether
// the special cases are still required.
delay = false;
waitForWindowServerSession = false;
forceShow = true;
cleanExit = true;
for (argIndex = 1; argIndex < argc; argIndex++) {
if ( strcasecmp(argv[argIndex], "--nodelay") == 0 ) {
delay = false;
} else if ( strcasecmp(argv[argIndex], "--delay") == 0 ) {
delay = true;
} else if ( strcasecmp(argv[argIndex], "--nowait") == 0 ) {
waitForWindowServerSession = false;
} else if ( strcasecmp(argv[argIndex], "--wait") == 0 ) {
waitForWindowServerSession = true;
} else if ( strcasecmp(argv[argIndex], "--noforce") == 0 ) {
forceShow = false;
} else if ( strcasecmp(argv[argIndex], "--force") == 0 ) {
forceShow = true;
} else if ( strcasecmp(argv[argIndex], "--nocleanexit") == 0 ) {
cleanExit = false;
} else if ( strcasecmp(argv[argIndex], "--cleanexit") == 0 ) {
cleanExit = true;
} else {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Unrecognised argument '%s'", argv[argIndex]);
}
}
// Handle various options.
if (waitForWindowServerSession) {
WaitForWindowServerSession();
} else {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Not waiting for CGSessionCopyCurrentDictionary");
}
if (delay) {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Delaying");
sleep(3);
} else {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Not delaying");
}
// Set up our UI.
err = CreateNibReference(CFSTR("main"), &nibRef);
assert(err == noErr);
err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window);
assert(err == noErr);
DisposeNibReference(nibRef);
// We have to set kHIWindowBitCanBeVisibleWithoutLogin to let the
// system know that we're not accidentally trying to display a window
// pre-login.
//
// Also, window is a utility window and, by default, these have the
// kWindowHideOnSuspendAttribute attribute set. As our application is a
// UI element which never activates, and we want our panel to show regardless,
// we must clear kWindowHideOnSuspendAttribute.
static const int kAttributesToSet[] = {
kHIWindowBitCanBeVisibleWithoutLogin,
0
};
static const int kAttributesToClear[] = {
kHIWindowBitHideOnSuspend,
0
};
err = HIWindowChangeAttributes(
window,
kAttributesToSet,
kAttributesToClear
);
assert(err == noErr);
// Due to a problem with the relationship between the UI frameworks and the
// window server <rdar://problem/5136400>, ShowWindow is not sufficient to
// show the window. We also have to use BringToFront.
ShowWindow(window);
if (forceShow) {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Showing window with extreme prejudice");
BringToFront(window);
} else {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Showing window normally");
}
// Set up our SIGTERM handler.
if (cleanExit) {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Installing SIGTERM handler");
InstallHandleSIGTERMFromRunLoop();
} else {
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Not installing SIGTERM handler");
}
// Go go gadget Carbon!
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "RunApplicationEventLoop");
RunApplicationEventLoop();
(void) asl_log(gASLClient, gASLMessage, ASL_LEVEL_INFO, "Stop");
return EXIT_SUCCESS;
}
int /* O - 1 if log file open */
cupsdCheckLogFile(cups_file_t **lf, /* IO - Log file */
const char *logname) /* I - Log filename */
{
char backname[1024], /* Backup log filename */
filename[1024], /* Formatted log filename */
*ptr; /* Pointer into filename */
const char *logptr; /* Pointer into log filename */
/*
* See if we have a log file to check...
*/
if (!lf || !logname || !logname[0])
return (1);
/*
* Handle logging to stderr...
*/
if (!strcmp(logname, "stderr"))
{
*lf = LogStderr;
return (1);
}
/*
* Format the filename as needed...
*/
if (!*lf ||
(strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
MaxLogSize > 0))
{
/*
* Handle format strings...
*/
filename[sizeof(filename) - 1] = '\0';
if (logname[0] != '/')
{
strlcpy(filename, ServerRoot, sizeof(filename));
strlcat(filename, "/", sizeof(filename));
}
else
filename[0] = '\0';
for (logptr = logname, ptr = filename + strlen(filename);
*logptr && ptr < (filename + sizeof(filename) - 1);
logptr ++)
if (*logptr == '%')
{
/*
* Format spec...
*/
logptr ++;
if (*logptr == 's')
{
/*
* Insert the server name...
*/
strlcpy(ptr, ServerName, sizeof(filename) - (size_t)(ptr - filename));
ptr += strlen(ptr);
}
else
{
/*
* Otherwise just insert the character...
*/
*ptr++ = *logptr;
}
}
else
*ptr++ = *logptr;
*ptr = '\0';
}
/*
* See if the log file is open...
*/
if (!*lf)
{
/*
* Nope, open the log file...
*/
if ((*lf = cupsFileOpen(filename, "a")) == NULL)
{
/*
* If the file is in CUPS_LOGDIR then try to create a missing directory...
*/
if (!strncmp(filename, CUPS_LOGDIR, strlen(CUPS_LOGDIR)))
{
/*
* Try updating the permissions of the containing log directory, using
* the log file permissions as a basis...
*/
mode_t log_dir_perm = (mode_t)(0300 | LogFilePerm);
/* LogFilePerm + owner write/search */
if (log_dir_perm & 0040)
log_dir_perm |= 0010; /* Add group search */
if (log_dir_perm & 0004)
log_dir_perm |= 0001; /* Add other search */
cupsdCheckPermissions(CUPS_LOGDIR, NULL, log_dir_perm, RunUser, Group, 1, -1);
*lf = cupsFileOpen(filename, "a");
}
if (*lf == NULL)
{
#ifdef HAVE_ASL_H
asl_object_t m; /* Log message */
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_log(NULL, m, ASL_LEVEL_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
asl_release(m);
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
sd_journal_print(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#else
syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#endif /* HAVE_ASL_H */
if (FatalErrors & CUPSD_FATAL_LOG)
cupsdEndProcess(getpid(), 0);
return (0);
}
}
if (strncmp(filename, "/dev/", 5))
{
/*
* Change ownership and permissions of non-device logs...
*/
fchown(cupsFileNumber(*lf), RunUser, Group);
fchmod(cupsFileNumber(*lf), LogFilePerm);
}
}
/*
* Do we need to rotate the log?
*/
if (strncmp(logname, "/dev/", 5) && cupsFileTell(*lf) > MaxLogSize &&
MaxLogSize > 0)
{
/*
* Rotate log file...
*/
cupsFileClose(*lf);
strlcpy(backname, filename, sizeof(backname));
strlcat(backname, ".O", sizeof(backname));
unlink(backname);
rename(filename, backname);
if ((*lf = cupsFileOpen(filename, "a")) == NULL)
{
#ifdef HAVE_ASL_H
asl_object_t m; /* Log message */
m = asl_new(ASL_TYPE_MSG);
asl_set(m, ASL_KEY_FACILITY, "org.cups.cupsd");
asl_log(NULL, m, ASL_LEVEL_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
asl_release(m);
#elif defined(HAVE_SYSTEMD_SD_JOURNAL_H)
sd_journal_print(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#else
syslog(LOG_ERR, "Unable to open log file \"%s\" - %s", filename, strerror(errno));
#endif /* HAVE_ASL_H */
if (FatalErrors & CUPSD_FATAL_LOG)
cupsdEndProcess(getpid(), 0);
return (0);
}
/*
* Change ownership and permissions of non-device logs...
*/
fchown(cupsFileNumber(*lf), RunUser, Group);
fchmod(cupsFileNumber(*lf), LogFilePerm);
}
return (1);
}
int
od_record_create(pam_handle_t *pamh, ODRecordRef *record, CFStringRef cfUser)
{
int retval = PAM_SERVICE_ERR;
const int attr_num = 5;
ODNodeRef cfNode = NULL;
CFErrorRef cferror = NULL;
CFArrayRef attrs = NULL;
CFTypeRef cfVals[attr_num];
if (NULL == record || NULL == cfUser) {
openpam_log(PAM_LOG_DEBUG, "NULL argument passed");
retval = PAM_SERVICE_ERR;
goto cleanup;
}
#ifdef OPENDIRECTORY_CACHE
#define CFRECORDNAME_CACHE "CFRecordName"
#define CFRECORDNAME_NAME CFSTR("name")
#define CFRECORDNAME_RECORD CFSTR("record")
CFDictionaryRef cfdict;
CFStringRef cachedUser;
if (pam_get_data(pamh, CFRECORDNAME_CACHE, (void *)&cfdict) == PAM_SUCCESS &&
(CFGetTypeID(cfdict) == CFDictionaryGetTypeID()) &&
(cachedUser = CFDictionaryGetValue(cfdict, CFRECORDNAME_NAME)) != NULL &&
CFGetTypeID(cachedUser) == CFStringGetTypeID() &&
CFStringCompare(cfUser, cachedUser, 0) == kCFCompareEqualTo &&
(*record = (ODRecordRef)CFDictionaryGetValue(cfdict, CFRECORDNAME_RECORD)) != NULL)
{
CFRetain(*record);
return PAM_SUCCESS;
}
#endif /* OPENDIRECTORY_CACHE */
int current_iterations = 0;
cfNode = ODNodeCreateWithNodeType(kCFAllocatorDefault,
kODSessionDefault,
eDSAuthenticationSearchNodeName,
&cferror);
if (NULL == cfNode || NULL != cferror) {
openpam_log(PAM_LOG_ERROR, "ODNodeCreateWithNodeType failed.");
retval = PAM_SERVICE_ERR;
goto cleanup;
}
cfVals[0] = kODAttributeTypeAuthenticationAuthority;
cfVals[1] = kODAttributeTypeHomeDirectory;
cfVals[2] = kODAttributeTypeNFSHomeDirectory;
cfVals[3] = kODAttributeTypeUserShell;
cfVals[4] = kODAttributeTypeUniqueID;
attrs = CFArrayCreate(kCFAllocatorDefault, cfVals, (CFIndex)attr_num, &kCFTypeArrayCallBacks);
if (NULL == attrs) {
openpam_log(PAM_LOG_DEBUG, "CFArrayCreate() failed");
retval = PAM_BUF_ERR;
goto cleanup;
}
retval = PAM_SERVICE_ERR;
while (current_iterations <= kMaxIterationCount) {
CFIndex unreachable_count = 0;
CFArrayRef unreachable_nodes = ODNodeCopyUnreachableSubnodeNames(cfNode, NULL);
if (unreachable_nodes) {
unreachable_count = CFArrayGetCount(unreachable_nodes);
CFRelease(unreachable_nodes);
openpam_log(PAM_LOG_DEBUG, "%lu OD nodes unreachable.", unreachable_count);
}
*record = ODNodeCopyRecord(cfNode, kODRecordTypeUsers, cfUser, attrs, &cferror);
if (*record)
break;
if (0 == unreachable_count)
break;
openpam_log(PAM_LOG_DEBUG, "Waiting %d seconds for nodes to become reachable", kWaitSeconds);
sleep(kWaitSeconds);
++current_iterations;
}
if (*record) {
#ifdef OPENDIRECTORY_CACHE
const void *keys[] = { CFRECORDNAME_NAME, CFRECORDNAME_RECORD };
const void *values[] = { cfUser, *record };
CFDictionaryRef dict;
dict = CFDictionaryCreate(NULL, keys, values, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (dict)
pam_set_data(pamh, CFRECORDNAME_CACHE, (void *)dict, cleanup_cache);
#endif /* OPENDIRECTORY_CACHE */
retval = PAM_SUCCESS;
} else {
retval = PAM_USER_UNKNOWN;
}
if (current_iterations > 0) {
char *wt = NULL, *found = NULL;
int retval2;
if (*record)
found = "failure";
else
found = "success";
retval2 = asprintf(&wt, "%d", kWaitSeconds * current_iterations);
if (-1 == retval2) {
openpam_log(PAM_LOG_DEBUG, "Failed to convert current wait time to string.");
retval = PAM_BUF_ERR;
goto cleanup;
}
aslmsg m = asl_new(ASL_TYPE_MSG);
asl_set(m, "com.apple.message.domain", "com.apple.pam_modules.odAvailableWaitTime" );
asl_set(m, "com.apple.message.signature", "wait_time");
asl_set(m, "com.apple.message.value", wt);
asl_set(m, "com.apple.message.result", found);
asl_log(NULL, m, ASL_LEVEL_NOTICE, "OD nodes online delay: %ss. User record lookup: %s.", wt, found);
asl_free(m);
free(wt);
}
cleanup:
if (NULL != attrs) {
CFRelease(attrs);
}
if (NULL != cferror) {
CFRelease(cferror);
}
if (NULL != cfNode) {
CFRelease(cfNode);
}
if (PAM_SUCCESS != retval) {
openpam_log(PAM_LOG_ERROR, "failed: %d", retval);
if (NULL != *record) {
CFRelease(*record);
*record = NULL;
}
}
return retval;
}
void RARCH_LOG_V(const char *tag, const char *fmt, va_list ap)
{
#if TARGET_OS_IPHONE
static int asl_initialized = 0;
#if !TARGET_IPHONE_SIMULATOR
static aslclient asl_client;
#endif
#else
FILE *fp = NULL;
(void)fp;
#endif
if (!verbosity_is_enabled())
return;
#if TARGET_OS_IPHONE
#if TARGET_IPHONE_SIMULATOR
vprintf(fmt, ap);
#else
if (!asl_initialized)
{
asl_client = asl_open(file_path_str(FILE_PATH_PROGRAM_NAME), "com.apple.console", ASL_OPT_STDERR | ASL_OPT_NO_DELAY);
asl_initialized = 1;
}
aslmsg msg = asl_new(ASL_TYPE_MSG);
asl_set(msg, ASL_KEY_READ_UID, "-1");
if (tag)
asl_log(asl_client, msg, ASL_LEVEL_NOTICE, "%s", tag);
asl_vlog(asl_client, msg, ASL_LEVEL_NOTICE, fmt, ap);
asl_free(msg);
#endif
#elif defined(_XBOX1)
/* FIXME: Using arbitrary string as fmt argument is unsafe. */
char msg_new[1024];
char buffer[1024];
msg_new[0] = buffer[0] = '\0';
snprintf(msg_new, sizeof(msg_new), "%s: %s %s",
file_path_str(FILE_PATH_PROGRAM_NAME),
tag ? tag : "",
fmt);
wvsprintf(buffer, msg_new, ap);
OutputDebugStringA(buffer);
#elif defined(ANDROID)
int prio = ANDROID_LOG_INFO;
if (tag)
{
if (string_is_equal(file_path_str(FILE_PATH_LOG_WARN), tag))
prio = ANDROID_LOG_WARN;
else if (string_is_equal(file_path_str(FILE_PATH_LOG_ERROR), tag))
prio = ANDROID_LOG_ERROR;
}
__android_log_vprint(prio,
file_path_str(FILE_PATH_PROGRAM_NAME),
fmt,
ap);
#else
#ifdef HAVE_FILE_LOGGER
fp = (FILE*)retro_main_log_file();
#else
fp = stderr;
#endif
fprintf(fp, "%s %s :: ",
file_path_str(FILE_PATH_PROGRAM_NAME),
tag ? tag : file_path_str(FILE_PATH_LOG_INFO));
vfprintf(fp, fmt, ap);
fflush(fp);
#endif
}
