#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <stdarg.h>
#include <syslog.h>
#include <errno.h>
#include <time.h>
#include <crt_externs.h>
#include <asl.h>
#include <asl_private.h>
#include <regex.h>
#include <notify.h>
#include <mach/mach.h>
#include <pthread.h>
#define _PATH_ASL_IN "/var/run/asl_input"
#define streq(A, B) (strcmp(A, B) == 0)
#define strcaseeq(A, B) (strcasecmp(A, B) == 0)
#define forever for(;;)
#define TOKEN_NULL 0
#define TOKEN_OPEN 1
#define TOKEN_CLOSE 2
#define TOKEN_WORD 3
#define TOKEN_INT 4
time_t asl_parse_time(const char *);
const char *asl_syslog_faciliy_num_to_name(int n);
__private_extern__ asl_client_t *_asl_open_default();
uint32_t notify_get_state(int token, int *state);
uint32_t notify_register_plain(const char *name, int *out_token);
typedef struct
{
int notify_count;
int notify_token;
int master_token;
char *sender;
pthread_mutex_t lock;
asl_client_t *asl;
} _asl_global_t;
#ifndef BUILDING_VARIANT
__private_extern__ _asl_global_t _asl_global = {0, -1, -1, NULL, PTHREAD_MUTEX_INITIALIZER, NULL};
static int
_asl_connect(asl_client_t *asl)
{
uint32_t len, status;
if (asl->sock >= 0) return 0;
asl->sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (asl->sock < 0) return -1;
memset(&(asl->server), 0, sizeof(struct sockaddr_un));
asl->server.sun_family = AF_UNIX;
strcpy(asl->server.sun_path, _PATH_ASL_IN);
len = sizeof(asl->server.sun_len) + sizeof(asl->server.sun_family) + strlen(asl->server.sun_path) + 1;
asl->server.sun_len = strlen(_PATH_ASL_IN) + 1;
status = connect(asl->sock, (const struct sockaddr *)&(asl->server), len);
if (status < 0) return -1;
return 0;
}
static int
_asl_notify_open(int do_lock)
{
char *notify_name;
const char *prefix;
uint32_t status;
if (do_lock != 0) pthread_mutex_lock(&_asl_global.lock);
_asl_global.notify_count++;
if (_asl_global.notify_token != -1)
{
if (do_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return 0;
}
notify_name = NULL;
prefix = NOTIFY_PREFIX_USER;
if (getuid() == 0) prefix = NOTIFY_PREFIX_SYSTEM;
if (_asl_global.master_token == -1)
{
status = notify_register_plain(NOTIFY_SYSTEM_MASTER, &_asl_global.master_token);
if (status != NOTIFY_STATUS_OK) _asl_global.master_token = -1;
}
asprintf(¬ify_name, "%s.%d", prefix, getpid());
if (notify_name != NULL)
{
status = notify_register_plain(notify_name, &_asl_global.notify_token);
free(notify_name);
if (status != NOTIFY_STATUS_OK) _asl_global.notify_token = -1;
}
if (do_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
if (_asl_global.notify_token == -1) return -1;
return 0;
}
static void
_asl_notify_close()
{
pthread_mutex_lock(&_asl_global.lock);
if (_asl_global.notify_count > 0) _asl_global.notify_count--;
if (_asl_global.notify_count > 0)
{
pthread_mutex_unlock(&_asl_global.lock);
return;
}
if (_asl_global.master_token > 0) notify_cancel(_asl_global.master_token);
_asl_global.master_token = -1;
if (_asl_global.notify_token > 0) notify_cancel(_asl_global.notify_token);
_asl_global.notify_token = -1;
pthread_mutex_unlock(&_asl_global.lock);
}
aslclient
asl_open(const char *ident, const char *facility, uint32_t opts)
{
char *name, *x;
asl_client_t *asl;
asl = (asl_client_t *)calloc(1, sizeof(asl_client_t));
if (asl == NULL)
{
errno = ENOMEM;
return NULL;
}
asl->options = opts;
asl->sock = -1;
if (asl->options & ASL_OPT_NO_DELAY)
{
if (_asl_connect(asl) < 0)
{
free(asl);
return NULL;
}
}
asl->pid = getpid();
asl->uid = getuid();
asl->gid = getgid();
asl->filter = ASL_FILTER_MASK_UPTO(ASL_LEVEL_NOTICE);
if (ident != NULL)
{
asl->name = strdup(ident);
}
else
{
name = *(*_NSGetArgv());
if (name != NULL)
{
x = strrchr(name, '/');
if (x != NULL) x++;
else x = name;
asl->name = strdup(x);
}
}
if (facility != NULL) asl->facility = strdup(facility);
else asl->facility = strdup(asl_syslog_faciliy_num_to_name(LOG_USER));
if (!(asl->options & ASL_OPT_NO_REMOTE)) _asl_notify_open(1);
return (aslclient)asl;
}
void
asl_close(aslclient ac)
{
asl_client_t *asl;
asl = (asl_client_t *)ac;
if (asl == NULL) return;
if (asl->sock >= 0) close(asl->sock);
if (asl->name != NULL) free(asl->name);
if (asl->facility != NULL) free(asl->facility);
if (!(asl->options & ASL_OPT_NO_REMOTE)) _asl_notify_close();
if (asl->fd_list != NULL) free(asl->fd_list);
memset(asl, 0, sizeof(asl_client_t));
free(asl);
}
__private_extern__ asl_client_t *
_asl_open_default()
{
pthread_mutex_lock(&_asl_global.lock);
if (_asl_global.asl != NULL)
{
pthread_mutex_unlock(&_asl_global.lock);
return _asl_global.asl;
}
_asl_global.asl = asl_open(NULL, NULL, ASL_OPT_NO_REMOTE);
if (_asl_global.asl != NULL) _asl_global.asl->options = 0;
_asl_notify_open(0);
pthread_mutex_unlock(&_asl_global.lock);
return _asl_global.asl;
}
static uint32_t
_asl_msg_index(asl_msg_t *msg, const char *k)
{
uint32_t i;
if (msg == NULL) return (uint32_t)-1;
if (k == NULL) return (uint32_t)-1;
for (i = 0; i < msg->count; i++)
{
if (msg->key[i] == NULL) continue;
if (streq(msg->key[i], k)) return i;
}
return (uint32_t)-1;
}
static void
_asl_append_string(char **m, uint32_t *x, char *s, uint32_t encode, uint32_t escspace)
{
uint32_t i, n;
if (m == NULL) return;
if (x == NULL) return;
if (s == NULL) return;
n = 0;
if (encode == 0) n = strlen(s);
else
{
for (i = 0; s[i] != '\0'; i++)
{
if (s[i] == '\\') n++;
else if (s[i] == ']') n++;
else if ((escspace != 0) && (s[i] == ' ')) n++;
n++;
}
}
if (n == 0) return;
if (*m == NULL)
{
*m = malloc(n + 1);
*x = 1;
}
else
{
*m = realloc(*m, n + (*x));
}
if (encode == 0)
{
memcpy((*m) + (*x) - 1, s, n + 1);
*x += n;
return;
}
n = *x - 1;
for (i = 0; s[i] != '\0'; i++)
{
if ((s[i] == '\\') || (s[i] == ']') || ((escspace != 0) && (s[i] == ' ')))
{
(*m)[n++] = '\\';
(*m)[n++] = s[i];
}
else if (s[i] == '\n') (*m)[n++] = ';';
else (*m)[n++] = s[i];
}
(*m)[n++] = '\0';
*x = n;
return;
}
static void
_asl_append_op(char **m, uint32_t *x, uint32_t op)
{
char opstr[8];
uint32_t i;
if (m == NULL) return;
if (x == NULL) return;
if (op == ASL_QUERY_OP_NULL) return _asl_append_string(m, x, ".", 0, 0);
i = 0;
if (op & ASL_QUERY_OP_CASEFOLD) opstr[i++] = 'C';
if (op & ASL_QUERY_OP_CASEFOLD) opstr[i++] = 'R';
if (op & ASL_QUERY_OP_NUMERIC) opstr[i++] = 'N';
if (op & ASL_QUERY_OP_PREFIX)
{
if (op & ASL_QUERY_OP_SUFFIX) opstr[i++] = 'S';
else opstr[i++] = 'A';
}
if (op & ASL_QUERY_OP_SUFFIX) opstr[i++] = 'Z';
switch (op & ASL_QUERY_OP_TRUE)
{
case ASL_QUERY_OP_EQUAL:
opstr[i++] = '=';
break;
case ASL_QUERY_OP_GREATER:
opstr[i++] = '>';
break;
case ASL_QUERY_OP_GREATER_EQUAL:
opstr[i++] = '>';
opstr[i++] = '=';
break;
case ASL_QUERY_OP_LESS:
opstr[i++] = '<';
break;
case ASL_QUERY_OP_LESS_EQUAL:
opstr[i++] = '<';
opstr[i++] = '=';
break;
case ASL_QUERY_OP_NOT_EQUAL:
opstr[i++] = '!';
break;
case ASL_QUERY_OP_TRUE:
opstr[i++] = 'T';
break;
default:
break;
}
if (i == 0) return _asl_append_string(m, x, ".", 0, 0);
opstr[i++] = '\0';
return _asl_append_string(m, x, opstr, 0, 0);
}
char *
asl_msg_to_string(asl_msg_t *msg, uint32_t *len)
{
uint32_t i, outlen;
char *out, *s;
*len = 0;
if (msg == NULL) return NULL;
s = NULL;
out = NULL;
outlen = 0;
if (msg->type == ASL_TYPE_QUERY)
{
_asl_append_string(&out, &outlen, "Q ", 0, 0);
if (out == NULL) return NULL;
}
if (msg->count == 0)
{
if (out == NULL) return NULL;
*len = outlen;
return out;
}
for (i = 0; i < msg->count; i++)
{
if (msg->key[i] == NULL) continue;
if (i > 0) _asl_append_string(&out, &outlen, " [", 0, 0);
else _asl_append_string(&out, &outlen, "[", 0, 0);
if (msg->type == ASL_TYPE_QUERY)
{
_asl_append_op(&out, &outlen, msg->op[i]);
_asl_append_string(&out, &outlen, " ", 0, 0);
}
_asl_append_string(&out, &outlen, msg->key[i], 1, 1);
if (msg->val[i] != NULL)
{
_asl_append_string(&out, &outlen, " ", 0, 0);
_asl_append_string(&out, &outlen, msg->val[i], 1, 0);
}
_asl_append_string(&out, &outlen, "]", 0, 0);
}
*len = outlen;
return out;
}
static uint32_t
_asl_msg_op_from_string(char *o)
{
uint32_t op, i;
op = ASL_QUERY_OP_NULL;
if (o == NULL) return op;
for (i = 0; o[i] != '\0'; i++)
{
if (o[i] == '.') return ASL_QUERY_OP_NULL;
if (o[i] == 'C') op |= ASL_QUERY_OP_CASEFOLD;
if (o[i] == 'R') op |= ASL_QUERY_OP_CASEFOLD;
if (o[i] == 'N') op |= ASL_QUERY_OP_NUMERIC;
if (o[i] == 'S') op |= ASL_QUERY_OP_SUBSTRING;
if (o[i] == 'A') op |= ASL_QUERY_OP_PREFIX;
if (o[i] == 'Z') op |= ASL_QUERY_OP_SUFFIX;
if (o[i] == '<') op |= ASL_QUERY_OP_LESS;
if (o[i] == '>') op |= ASL_QUERY_OP_GREATER;
if (o[i] == '=') op |= ASL_QUERY_OP_EQUAL;
if (o[i] == '!') op |= ASL_QUERY_OP_NOT_EQUAL;
if (o[i] == 'T') op |= ASL_QUERY_OP_TRUE;
}
return op;
}
static char *
_asl_msg_get_next_word(char **p, uint32_t *tt, uint32_t spacedel)
{
char *start, *out;
uint32_t i, esc, len, n;
*tt = TOKEN_NULL;
if (p == NULL) return NULL;
if (*p == NULL) return NULL;
if (**p == '\0') return NULL;
if (**p == ' ') (*p)++;
if (spacedel != 0)
{
while ((**p == ' ') || (**p == '\t')) (*p)++;
}
if (**p == '\0') return NULL;
if (**p == '\n') return NULL;
if (**p == '[')
{
*tt = TOKEN_OPEN;
(*p)++;
out = malloc(2);
out[0] = '[';
out[1] = '\0';
return out;
}
start = *p;
len = 0;
forever
{
if (((spacedel != 0) && (**p == ' ')) || (**p == ']') || (**p == '\0')) break;
esc = 0;
if (**p == '\\') esc = 1;
(*p)++;
if ((esc == 1) && ((**p == ' ') || (**p == ']') || (**p == '\\'))) (*p)++;
len++;
}
if ((len == 0) && (**p == ']'))
{
*tt = TOKEN_CLOSE;
(*p)++;
out = malloc(2);
out[0] = ']';
out[1] = '\0';
return out;
}
*tt = TOKEN_INT;
out = malloc(len + 1);
for (n = 0, i = 0; n < len; i++)
{
if ((start[i] == '\\') && ((start[i+1] == ' ') || (start[i+1] == ']') || (start[i+1] == '\\')))
{
*tt = TOKEN_WORD;
i++;
}
if ((start[i] < '0') || (start[i] > '9')) *tt = TOKEN_WORD;
out[n++] = start[i];
}
out[n] = '\0';
return out;
}
asl_msg_t *
asl_msg_from_string(const char *buf)
{
uint32_t tt, type, op;
char *k, *v, *o, *p;
asl_msg_t *msg;
if (buf == NULL) return NULL;
type = ASL_TYPE_MSG;
p = (char *)buf;
k = _asl_msg_get_next_word(&p, &tt, 1);
if (k == NULL) return NULL;
if (streq(k, "Q"))
{
type = ASL_TYPE_QUERY;
free(k);
k = _asl_msg_get_next_word(&p, &tt, 1);
}
else if (tt == TOKEN_INT)
{
free(k);
k = _asl_msg_get_next_word(&p, &tt, 1);
if (k == NULL) return NULL;
}
msg = calloc(1, sizeof(asl_msg_t));
if (msg == NULL) return NULL;
msg->type = type;
while (k != NULL)
{
op = ASL_QUERY_OP_NULL;
if (tt != TOKEN_OPEN)
{
asl_free(msg);
return NULL;
}
free(k);
if (type == ASL_TYPE_QUERY)
{
o = _asl_msg_get_next_word(&p, &tt, 1);
if ((o == NULL) || (tt != TOKEN_WORD))
{
if (o != NULL) free(o);
asl_free(msg);
return NULL;
}
op = _asl_msg_op_from_string(o);
free(o);
}
k = _asl_msg_get_next_word(&p, &tt, 1);
if (tt == TOKEN_INT) tt = TOKEN_WORD;
if ((k == NULL) || (tt != TOKEN_WORD))
{
if (k != NULL) free(k);
asl_free(msg);
return NULL;
}
v = _asl_msg_get_next_word(&p, &tt, 0);
if (tt == TOKEN_INT) tt = TOKEN_WORD;
if (v == NULL)
{
asl_set_query(msg, k, NULL, op);
break;
}
if (tt == TOKEN_CLOSE)
{
asl_set_query(msg, k, NULL, op);
}
else if (tt == TOKEN_WORD)
{
asl_set_query(msg, k, v, op);
}
else
{
if (k != NULL) free(k);
if (v != NULL) free(v);
asl_free(msg);
return NULL;
}
if (k != NULL) free(k);
if (v != NULL) free(v);
if (tt != TOKEN_CLOSE)
{
k = _asl_msg_get_next_word(&p, &tt, 1);
if (k == NULL) break;
if (tt != TOKEN_CLOSE)
{
asl_free(msg);
return NULL;
}
free(k);
}
k = _asl_msg_get_next_word(&p, &tt, 1);
if (k == NULL) break;
}
return msg;
}
static int
_asl_msg_equal(asl_msg_t *a, asl_msg_t *b)
{
uint32_t i, j;
if (a->count != b->count) return 0;
for (i = 0; i < a->count; i++)
{
j = _asl_msg_index(b, a->key[i]);
if (j == (uint32_t)-1) return 0;
if (a->val[i] == NULL)
{
if (b->val[j] != NULL) return 0;
}
else
{
if (b->val[j] == NULL) return 0;
if (strcmp(a->val[i], b->val[j])) return 0;
}
if (a->type == ASL_TYPE_QUERY)
{
if (a->op[i] != b->op[j]) return 0;
}
}
return 1;
}
static int
_asl_isanumber(char *s)
{
int i;
if (s == NULL) return 0;
i = 0;
if ((s[0] == '-') || (s[0] == '+')) i = 1;
if (s[i] == '\0') return 0;
for (; s[i] != '\0'; i++)
{
if (!isdigit(s[i])) return 0;
}
return 1;
}
static int
_asl_msg_op_test(uint32_t op, char *q, char *m, uint32_t n)
{
int cmp;
uint32_t t;
int nq, nm, rflags;
regex_t rex;
t = op & ASL_QUERY_OP_TRUE;
if (op & ASL_QUERY_OP_REGEX)
{
memset(&rex, 0, sizeof(regex_t));
rflags = REG_EXTENDED | REG_NOSUB;
if (op & ASL_QUERY_OP_CASEFOLD) rflags |= REG_ICASE;
if (regcomp(&rex, q, rflags) != 0) return 0;
return (regexec(&rex, m, 0, NULL, 0) == 0);
}
if (op & ASL_QUERY_OP_NUMERIC)
{
if (_asl_isanumber(m) == 0) return 0;
nq = atoi(q);
nm = atoi(m);
switch (t)
{
case ASL_QUERY_OP_EQUAL: return (nm == nq);
case ASL_QUERY_OP_GREATER: return (nm > nq);
case ASL_QUERY_OP_GREATER_EQUAL: return (nm >= nq);
case ASL_QUERY_OP_LESS: return (nm < nq);
case ASL_QUERY_OP_LESS_EQUAL: return (nm <= nq);
case ASL_QUERY_OP_NOT_EQUAL: return (nm != nq);
default: return 0;
}
}
cmp = 0;
if (op & ASL_QUERY_OP_CASEFOLD)
{
if (n == 0) cmp = strcasecmp(m, q);
else cmp = strncasecmp(m, q, n);
}
else
{
if (n == 0) cmp = strcmp(m, q);
else cmp = strncmp(m, q, n);
}
switch (t)
{
case ASL_QUERY_OP_EQUAL: return (cmp == 0);
case ASL_QUERY_OP_GREATER: return (cmp > 0);
case ASL_QUERY_OP_GREATER_EQUAL: return (cmp >= 0);
case ASL_QUERY_OP_LESS: return (cmp < 0);
case ASL_QUERY_OP_LESS_EQUAL: return (cmp <= 0);
case ASL_QUERY_OP_NOT_EQUAL: return (cmp != 0);
default: return 0;
}
return 0;
}
static int
_asl_msg_test_op_substr(uint32_t op, char *q, char *m)
{
uint32_t i, d, lm, lq;
lm = strlen(m);
lq = strlen(q);
if (lq > lm) return 0;
d = lm - lq;
for (i = 0; i < d; i++)
{
if (_asl_msg_op_test(op, q, m + i, lq) != 0) return 1;
}
return 0;
}
static int
_asl_msg_test_op_prefix(uint32_t op, char *q, char *m)
{
uint32_t lm, lq;
lm = strlen(m);
lq = strlen(q);
if (lq > lm) return 0;
return _asl_msg_op_test(op, q, m, lq);
}
static int
_asl_msg_test_op_suffix(uint32_t op, char *q, char *m)
{
uint32_t lm, lq, d;
lm = strlen(m);
lq = strlen(q);
if (lq > lm) return 0;
d = lm - lq;
return _asl_msg_op_test(op, q, m + d, lq);
}
static int
_asl_msg_test_op(uint32_t op, char *q, char *m)
{
uint32_t t;
t = op & ASL_QUERY_OP_TRUE;
if (t == ASL_QUERY_OP_TRUE) return 1;
if (op & ASL_QUERY_OP_PREFIX)
{
if (op & ASL_QUERY_OP_SUFFIX) return _asl_msg_test_op_substr(op, q, m);
return _asl_msg_test_op_prefix(op, q, m);
}
if (op & ASL_QUERY_OP_SUFFIX) return _asl_msg_test_op_suffix(op, q, m);
return _asl_msg_op_test(op, q, m, 0);
}
static int
_asl_msg_test(asl_msg_t *q, asl_msg_t *m)
{
uint32_t i, j;
int cmp, freeval;
char *val;
struct tm gtime;
time_t tick;
for (i = 0; i < q->count; i++)
{
j = _asl_msg_index(m, q->key[i]);
if (j == (uint32_t)-1) return 0;
if (q->val[i] == NULL) continue;
if ((q->op[i] & ASL_QUERY_OP_TRUE) == ASL_QUERY_OP_TRUE) continue;
if (m->val[j] == NULL) return 0;
val = q->val[i];
freeval = 0;
if (streq(q->key[i], ASL_KEY_TIME))
{
tick = asl_parse_time(val);
if (tick != -1)
{
memset(>ime, 0, sizeof(struct tm));
gmtime_r(&tick, >ime);
val = NULL;
asprintf(&val, "%d.%02d.%02d %02d:%02d:%02d UTC", gtime.tm_year + 1900, gtime.tm_mon + 1, gtime.tm_mday, gtime.tm_hour, gtime.tm_min, gtime.tm_sec);
freeval = 1; }
}
cmp = _asl_msg_test_op(q->op[i], val, m->val[j]);
if ((freeval == 1) && (val != NULL)) free(val);
if (cmp == 0) return 0;
}
return 1;
}
int
asl_msg_cmp(asl_msg_t *a, asl_msg_t *b)
{
if (a == NULL) return 0;
if (b == NULL) return 0;
if (a->type == b->type) return _asl_msg_equal(a, b);
if (a->type == ASL_TYPE_QUERY) return _asl_msg_test(a, b);
return _asl_msg_test(b, a);
}
static char *
_get_line_from_file(FILE *f)
{
char *s, *out;
size_t len;
out = fgetln(f, &len);
if (out == NULL) return NULL;
if (len == 0) return NULL;
if (out[len] != '\n') len++;
s = malloc(len);
memcpy(s, out, len - 1);
s[len] = '\0';
return s;
}
int
asl_add_log_file(aslclient ac, int fd)
{
uint32_t i;
int use_global_lock;
asl_client_t *asl;
use_global_lock = 0;
asl = (asl_client_t *)ac;
if (asl == NULL)
{
asl = _asl_open_default();
if (asl == NULL) return -1;
pthread_mutex_lock(&_asl_global.lock);
use_global_lock = 1;
}
for (i = 0; i < asl->fd_count; i++)
{
if (asl->fd_list[i] == fd)
{
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return 0;
}
}
if (asl->fd_count == 0)
{
asl->fd_list = (int *)calloc(1, sizeof(int));
}
else
{
asl->fd_list = (int *)realloc(asl->fd_list, (1 + asl->fd_count) * sizeof(int));
}
if (asl->fd_list == NULL)
{
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return -1;
}
asl->fd_list[asl->fd_count] = fd;
asl->fd_count++;
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return 0;
}
int
asl_remove_log_file(aslclient ac, int fd)
{
uint32_t i;
int x, use_global_lock;
asl_client_t *asl;
use_global_lock = 0;
asl = (asl_client_t *)ac;
if (asl == NULL)
{
asl = _asl_open_default();
if (asl == NULL) return -1;
pthread_mutex_lock(&_asl_global.lock);
use_global_lock = 1;
}
if (asl->fd_count == 0)
{
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return 0;
}
x = -1;
for (i = 0; i < asl->fd_count; i++)
{
if (asl->fd_list[i] == fd)
{
x = i;
break;
}
}
if (x == -1)
{
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return 0;
}
for (i = x + 1; i < asl->fd_count; i++, x++) asl->fd_list[x] = asl->fd_list[i];
asl->fd_count--;
if (asl->fd_count == 0)
{
free(asl->fd_list);
asl->fd_list = NULL;
}
else
{
asl->fd_list = (int *)realloc(asl->fd_list, asl->fd_count * sizeof(int));
if (asl->fd_list == NULL)
{
asl->fd_count = 0;
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return -1;
}
}
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return 0;
}
int
asl_set_filter(aslclient ac, int f)
{
int last, use_global_lock;
asl_client_t *asl;
use_global_lock = 0;
asl = (asl_client_t *)ac;
if (asl == NULL)
{
asl = _asl_open_default();
if (asl == NULL) return -1;
pthread_mutex_lock(&_asl_global.lock);
use_global_lock = 1;
}
last = asl->filter;
asl->filter = f;
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
return last;
}
const char *
asl_key(aslmsg a, uint32_t n)
{
asl_msg_t *msg;
msg = (asl_msg_t *)a;
if (msg == NULL) return NULL;
if (n >= msg->count) return NULL;
return msg->key[n];
}
aslmsg
asl_new(uint32_t type)
{
uint32_t i;
asl_msg_t *msg;
char *name, *x;
msg = calloc(1, sizeof(asl_msg_t));
if (msg == NULL) return NULL;
msg->type = type;
if (type == ASL_TYPE_QUERY) return (aslmsg)msg;
msg->count = 8;
msg->key = calloc(msg->count, sizeof(char *));
if (msg->key == NULL)
{
free(msg);
return NULL;
}
msg->val = calloc(msg->count, sizeof(char *));
if (msg->val == NULL)
{
free(msg->key);
free(msg);
return NULL;
}
i = 0;
msg->key[i] = strdup(ASL_KEY_TIME);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
i++;
msg->key[i] = strdup(ASL_KEY_HOST);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
i++;
msg->key[i] = strdup(ASL_KEY_SENDER);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
if (_asl_global.sender == NULL)
{
name = *(*_NSGetArgv());
if (name != NULL)
{
x = strrchr(name, '/');
if (x != NULL) x++;
else x = name;
pthread_mutex_lock(&_asl_global.lock);
if (_asl_global.sender == NULL) _asl_global.sender = strdup(x);
pthread_mutex_unlock(&_asl_global.lock);
}
}
if (_asl_global.sender == NULL)
{
msg->val[i] = strdup("Unknown");
if (msg->val[i] == NULL)
{
asl_free(msg);
return NULL;
}
}
else
{
msg->val[i] = strdup(_asl_global.sender);
if (msg->val[i] == NULL)
{
asl_free(msg);
return NULL;
}
}
i++;
msg->key[i] = strdup(ASL_KEY_PID);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
i++;
msg->key[i] = strdup(ASL_KEY_UID);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
i++;
msg->key[i] = strdup(ASL_KEY_GID);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
i++;
msg->key[i] = strdup(ASL_KEY_LEVEL);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
i++;
msg->key[i] = strdup(ASL_KEY_MSG);
if (msg->key[i] == NULL)
{
asl_free(msg);
return NULL;
}
return (aslmsg)msg;
}
const char *
asl_get(aslmsg a, const char *key)
{
asl_msg_t *msg;
uint32_t i;
msg = (asl_msg_t *)a;
if (msg == NULL) return NULL;
i = _asl_msg_index(msg, key);
if (i == (uint32_t)-1) return NULL;
return msg->val[i];
}
#endif
int
asl_vlog(aslclient ac, aslmsg a, int level, const char *format, va_list ap)
{
int status, saved_errno;
asl_msg_t *msg;
char *str, *fmt, *estr;
uint32_t i, len, elen, expand, my_msg;
asl_client_t *asl;
asl = (asl_client_t *)ac;
if (asl == NULL)
{
asl = _asl_open_default();
if (asl == NULL) return -1;
}
saved_errno = errno;
if (format == NULL) return -1;
msg = (asl_msg_t *)a;
my_msg = 0;
if (msg == NULL)
{
my_msg = 1;
msg = asl_new(ASL_TYPE_MSG);
if (msg == NULL) return -1;
}
if (msg->type != ASL_TYPE_MSG) return -1;
if (level < ASL_LEVEL_EMERG) level = ASL_LEVEL_EMERG;
if (level > ASL_LEVEL_DEBUG) level = ASL_LEVEL_DEBUG;
str = NULL;
asprintf(&str, "%d", level);
if (str == NULL)
{
if ((msg != NULL) && (my_msg != 0)) asl_free(msg);
return -1;
}
asl_set(msg, ASL_KEY_LEVEL, str);
free(str);
len = 0;
elen = 0;
estr = strdup(strerror(saved_errno));
expand = 0;
if (estr != NULL)
{
elen = strlen(estr);
for (i = 0; format[i] != '\0'; i++)
{
if (format[i] == '%')
{
if (format[i+1] == '\0') len++;
else if (format[i+1] == 'm')
{
expand = 1;
len += elen;
i++;
}
else
{
len += 2;
i++;
}
}
else len++;
}
}
fmt = (char *)format;
if (expand != 0)
{
fmt = malloc(len + 1);
len = 0;
for (i = 0; format[i] != '\0'; i++)
{
if (format[i] == '%')
{
if (format[i+1] == '\0')
{
}
else if (format[i+1] == 'm')
{
memcpy(fmt+len, estr, elen);
len += elen;
i++;
}
else
{
fmt[len++] = format[i++];
fmt[len++] = format[i];
}
}
else fmt[len++] = format[i];
}
fmt[len] = '\0';
}
if (estr != NULL) free(estr);
vasprintf(&str, fmt, ap);
if (expand != 0) free(fmt);
if (str == NULL)
{
if ((msg != NULL) && (my_msg != 0)) asl_free(msg);
return -1;
}
asl_set(msg, ASL_KEY_MSG, str);
free(str);
status = asl_send(ac, (aslmsg)msg);
if ((msg != NULL) && (my_msg != 0)) asl_free(msg);
return status;
}
int
asl_log(aslclient ac, aslmsg a, int level, const char *format, ...)
{
va_list ap;
int status;
if (format == NULL) return -1;
va_start(ap, format);
status = asl_vlog(ac, a, level, format, ap);
va_end(ap);
return status;
}
#ifndef BUILDING_VARIANT
int
asl_send(aslclient ac, aslmsg msg)
{
char *str, *out;
uint32_t i, len, level, lmask, outstatus, filter;
const char *val;
time_t tick;
int status, rc_filter;
asl_client_t *asl;
int use_global_lock;
use_global_lock = 0;
asl = (asl_client_t *)ac;
if (asl == NULL)
{
asl = _asl_open_default();
if (asl == NULL) return -1;
use_global_lock = 1;
}
if (msg == NULL) return 0;
level = ASL_LEVEL_DEBUG;
val = asl_get(msg, ASL_KEY_LEVEL);
if (val != NULL) level = atoi(val);
lmask = ASL_FILTER_MASK(level);
filter = asl->filter;
rc_filter = 0;
if (!(asl->options & ASL_OPT_NO_REMOTE))
{
pthread_mutex_lock(&_asl_global.lock);
if (_asl_global.notify_token >= 0)
{
status = notify_get_state(_asl_global.notify_token, &i);
if ((status == NOTIFY_STATUS_OK) && (i != 0))
{
filter = i;
rc_filter = 1;
}
}
if ((rc_filter == 0) && (_asl_global.master_token >= 0))
{
status = notify_get_state(_asl_global.master_token, &i);
if ((status == NOTIFY_STATUS_OK) && (i != 0))
{
filter = i;
}
}
pthread_mutex_unlock(&_asl_global.lock);
}
str = NULL;
tick = time(NULL);
asprintf(&str, "%u", tick);
if (str != NULL)
{
asl_set(msg, ASL_KEY_TIME, str);
free(str);
}
str = NULL;
asprintf(&str, "%u", getpid());
if (str != NULL)
{
asl_set(msg, ASL_KEY_PID, str);
free(str);
}
str = NULL;
asprintf(&str, "%d", getuid());
if (str != NULL)
{
asl_set(msg, ASL_KEY_UID, str);
free(str);
}
str = NULL;
asprintf(&str, "%u", getgid());
if (str != NULL)
{
asl_set(msg, ASL_KEY_GID, str);
free(str);
}
len = 0;
str = asl_msg_to_string((asl_msg_t *)msg, &len);
if (str == NULL) return -1;
asprintf(&out, "%10u %s\n", len+1, str);
free(str);
if (out == NULL) return -1;
outstatus = 0;
if (use_global_lock != 0) pthread_mutex_lock(&_asl_global.lock);
if ((filter != 0) && ((filter & lmask) != 0))
{
if (asl->sock == -1) _asl_connect(asl);
status = write(asl->sock, out, len + 12);
if (status < 0)
{
asl->sock = -1;
_asl_connect(asl);
status = write(asl->sock, out, len + 12);
if (status < 0) outstatus = -1;
}
}
if (asl->options & ASL_OPT_STDERR) fprintf(stderr, "%s", out);
for (i = 0; i < asl->fd_count; i++)
{
if (asl->fd_list[i] < 0) continue;
status = write(asl->fd_list[i], out, len + 12);
if (status < 0)
{
asl->fd_list[i] = -1;
outstatus = -1;
}
}
if (use_global_lock != 0) pthread_mutex_unlock(&_asl_global.lock);
free(out);
return outstatus;
}
char *
asl_msg_string(aslmsg a)
{
uint32_t len;
return asl_msg_to_string((asl_msg_t *)a, &len);
}
void
asl_free(aslmsg a)
{
uint32_t i;
asl_msg_t *msg;
msg = (asl_msg_t *)a;
if (msg == NULL) return;
for (i = 0; i < msg->count; i++)
{
if (msg->key[i] != NULL) free(msg->key[i]);
if (msg->val[i] != NULL) free(msg->val[i]);
}
if (msg->count > 0)
{
if (msg->key != NULL) free(msg->key);
if (msg->val != NULL) free(msg->val);
if (msg->op != NULL) free(msg->op);
}
free(msg);
}
int asl_set_query(aslmsg a, const char *key, const char *val, uint32_t op)
{
uint32_t i;
char *dk, *dv;
asl_msg_t *msg;
msg = (asl_msg_t *)a;
if (msg == NULL) return 0;
if (key == NULL) return -1;
dv = NULL;
if (streq(key, ASL_KEY_LEVEL))
{
if (val == NULL) return -1;
if (val[0] == '\0') return -1;
if ((val[0] >= '0') && (val[0] <= '9'))
{
i = atoi(val);
asprintf(&dv, "%d", i);
if (dv == NULL) return -1;
}
else if (!strcasecmp(val, ASL_STRING_EMERG)) dv = strdup("0");
else if (!strcasecmp(val, ASL_STRING_ALERT)) dv = strdup("1");
else if (!strcasecmp(val, ASL_STRING_CRIT)) dv = strdup("2");
else if (!strcasecmp(val, ASL_STRING_ERR)) dv = strdup("3");
else if (!strcasecmp(val, ASL_STRING_WARNING)) dv = strdup("4");
else if (!strcasecmp(val, ASL_STRING_NOTICE)) dv = strdup("5");
else if (!strcasecmp(val, ASL_STRING_INFO)) dv = strdup("6");
else if (!strcasecmp(val, ASL_STRING_DEBUG)) dv = strdup("7");
else return -1;
}
if ((dv == NULL) && (val != NULL))
{
dv = strdup(val);
if (dv == NULL) return -1;
}
for (i = 0; i < msg->count; i++)
{
if (msg->key[i] == NULL) continue;
if ((msg->type != ASL_TYPE_QUERY) && (streq(msg->key[i], key)))
{
if (msg->val[i] != NULL) free(msg->val[i]);
msg->val[i] = NULL;
if (val != NULL) msg->val[i] = dv;
if (msg->op != NULL) msg->op[i] = op;
return 0;
}
}
if (msg->count == 0)
{
msg->key = (char **)calloc(1, sizeof(char *));
if (msg->key == NULL)
{
asl_free(msg);
return -1;
}
msg->val = (char **)calloc(1, sizeof(char *));
if (msg->val == NULL)
{
asl_free(msg);
return -1;
}
if (msg->type == ASL_TYPE_QUERY)
{
msg->op = (uint32_t *)calloc(1, sizeof(uint32_t));
if (msg->op == NULL)
{
asl_free(msg);
return -1;
}
}
}
else
{
msg->key = (char **)realloc(msg->key, (msg->count + 1) * sizeof(char *));
if (msg->key == NULL)
{
asl_free(msg);
return -1;
}
msg->val = (char **)realloc(msg->val, (msg->count + 1) * sizeof(char *));
if (msg->val == NULL)
{
asl_free(msg);
return -1;
}
if (msg->type == ASL_TYPE_QUERY)
{
msg->op = (uint32_t *)realloc(msg->op, (msg->count + 1) * sizeof(uint32_t));
if (msg->op == NULL)
{
asl_free(msg);
return -1;
}
}
}
dk = strdup(key);
if (dk == NULL) return -1;
msg->key[msg->count] = dk;
msg->val[msg->count] = dv;
if (msg->op != NULL) msg->op[msg->count] = op;
msg->count++;
return 0;
}
int
asl_set(aslmsg msg, const char *key, const char *val)
{
return asl_set_query(msg, key, val, 0);
}
int
asl_unset(aslmsg a, const char *key)
{
uint32_t i, j;
asl_msg_t *msg;
msg = (asl_msg_t *)a;
if (msg == NULL) return 0;
if (key == NULL) return 0;
for (i = 0; i < msg->count; i++)
{
if (msg->key[i] == NULL) continue;
if (streq(msg->key[i], key))
{
free(msg->key[i]);
if (msg->val[i] != NULL) free(msg->val[i]);
for (j = i + 1; j < msg->count; j++, i++)
{
msg->key[i] = msg->key[j];
msg->val[i] = msg->val[j];
if (msg->op != NULL) msg->op[i] = msg->op[j];
}
msg->count--;
if (msg->count == 0)
{
free(msg->key);
msg->key = NULL;
free(msg->val);
msg->val = NULL;
if (msg->op != NULL) free(msg->op);
msg->op = NULL;
}
else
{
msg->key = (char **)realloc(msg->key, msg->count * sizeof(char *));
if (msg->key == NULL) return -1;
msg->val = (char **)realloc(msg->val, msg->count * sizeof(char *));
if (msg->val == NULL) return -1;
if (msg->op != NULL)
{
msg->op = (uint32_t *)realloc(msg->op, msg->count * sizeof(uint32_t));
if (msg->op == NULL) return -1;
}
}
return 0;
}
}
return 0;
}
aslresponse
asl_search(aslclient ac, aslmsg a)
{
FILE *log;
asl_msg_t *q, *m;
asl_search_result_t *res;
char *str;
q = (asl_msg_t *)a;
if (q == NULL) return 0;
log = fopen(_PATH_ASL_OUT, "r");
if (log == NULL) return NULL;
res = (asl_search_result_t *)calloc(1, sizeof(asl_search_result_t));
while (NULL != (str = _get_line_from_file(log)))
{
m = asl_msg_from_string(str);
if (m == NULL) continue;
if (asl_msg_cmp(q, m) == 0)
{
asl_free(m);
continue;
}
if (res->count == 0)
{
res->msg = (asl_msg_t **)calloc(1, sizeof(asl_msg_t *));
}
else
{
res->msg = (asl_msg_t **)realloc(res->msg, (res->count + 1) * sizeof(asl_msg_t *));
}
res->msg[res->count] = m;
res->count++;
}
fclose(log);
return res;
}
aslmsg
aslresponse_next(aslresponse r)
{
asl_search_result_t *res;
aslmsg m;
res = (asl_search_result_t *)r;
if (res == NULL) return NULL;
if (res->curr >= res->count) return NULL;
m = res->msg[res->curr];
res->curr++;
return m;
}
void
aslresponse_free(aslresponse r)
{
asl_search_result_t *res;
uint32_t i;
res = (asl_search_result_t *)r;
if (res == NULL) return;
for (i = 0; i < res->count; i++) free(res->msg[i]);
free(res->msg);
free(res);
}
int
asl_syslog_faciliy_name_to_num(const char *name)
{
if (name == NULL) return -1;
if (strcaseeq(name, "auth")) return LOG_AUTH;
if (strcaseeq(name, "authpriv")) return LOG_AUTHPRIV;
if (strcaseeq(name, "cron")) return LOG_CRON;
if (strcaseeq(name, "daemon")) return LOG_DAEMON;
if (strcaseeq(name, "ftp")) return LOG_FTP;
if (strcaseeq(name, "install")) return LOG_INSTALL;
if (strcaseeq(name, "kern")) return LOG_KERN;
if (strcaseeq(name, "lpr")) return LOG_LPR;
if (strcaseeq(name, "mail")) return LOG_MAIL;
if (strcaseeq(name, "netinfo")) return LOG_NETINFO;
if (strcaseeq(name, "remoteauth")) return LOG_REMOTEAUTH;
if (strcaseeq(name, "news")) return LOG_NEWS;
if (strcaseeq(name, "security")) return LOG_AUTH;
if (strcaseeq(name, "syslog")) return LOG_SYSLOG;
if (strcaseeq(name, "user")) return LOG_USER;
if (strcaseeq(name, "uucp")) return LOG_UUCP;
if (strcaseeq(name, "local0")) return LOG_LOCAL0;
if (strcaseeq(name, "local1")) return LOG_LOCAL1;
if (strcaseeq(name, "local2")) return LOG_LOCAL2;
if (strcaseeq(name, "local3")) return LOG_LOCAL3;
if (strcaseeq(name, "local4")) return LOG_LOCAL4;
if (strcaseeq(name, "local5")) return LOG_LOCAL5;
if (strcaseeq(name, "local6")) return LOG_LOCAL6;
if (strcaseeq(name, "local7")) return LOG_LOCAL7;
if (strcaseeq(name, "launchd")) return LOG_LAUNCHD;
return -1;
}
const char *
asl_syslog_faciliy_num_to_name(int n)
{
if (n < 0) return NULL;
if (n == LOG_AUTH) return "auth";
if (n == LOG_AUTHPRIV) return "authpriv";
if (n == LOG_CRON) return "cron";
if (n == LOG_DAEMON) return "daemon";
if (n == LOG_FTP) return "ftp";
if (n == LOG_INSTALL) return "install";
if (n == LOG_KERN) return "kern";
if (n == LOG_LPR) return "lpr";
if (n == LOG_MAIL) return "mail";
if (n == LOG_NETINFO) return "netinfo";
if (n == LOG_REMOTEAUTH) return "remoteauth";
if (n == LOG_NEWS) return "news";
if (n == LOG_AUTH) return "security";
if (n == LOG_SYSLOG) return "syslog";
if (n == LOG_USER) return "user";
if (n == LOG_UUCP) return "uucp";
if (n == LOG_LOCAL0) return "local0";
if (n == LOG_LOCAL1) return "local1";
if (n == LOG_LOCAL2) return "local2";
if (n == LOG_LOCAL3) return "local3";
if (n == LOG_LOCAL4) return "local4";
if (n == LOG_LOCAL5) return "local5";
if (n == LOG_LOCAL6) return "local6";
if (n == LOG_LOCAL7) return "local7";
if (n == LOG_LAUNCHD) return "launchd";
return NULL;
}
#define CANONICAL_TIME_REX "^[0-9][0-9][0-9][0-9].[01]?[0-9].[0-3]?[0-9][ ]+[0-2]?[0-9]:[0-5][0-9]:[0-5][0-9][ ]+UTC$"
#define CTIME_REX "^[adfjmnos][aceopu][bcglnprtvy][ ]+[0-3]?[0-9][ ]+[0-2]?[0-9]:[0-5][0-9]:[0-5][0-9]$"
#define ABSOLUTE_TIME_REX "^[0-9]+[s]?$"
#define RELATIVE_TIME_REX "^[\\+-\\][0-9]+[smhdw]?$"
#define SECONDS_PER_MINUTE 60
#define SECONDS_PER_HOUR 3600
#define SECONDS_PER_DAY 86400
#define SECONDS_PER_WEEK 604800
static const int8_t MTH_LAST[] = {-1, 1, 11, -1, -1, -1, 7, -1, -1, -1, -1, 6, -1, 5, -1, 8, -1, 3, -1, 9, -1, 10, -1, -1, 4, -1};
static int
_month_num(char *s)
{
int i;
int8_t v8;
v8 = -1;
if (s[2] > 90) v8 = s[2] - 'a';
else v8 = s[2] - 'A';
if ((v8 < 0) || (v8 > 25)) return -1;
v8 = MTH_LAST[v8];
if (v8 < 0) return -1;
i = v8;
if ((i == 5) && ((s[1] == 'a') || (s[1] == 'A'))) return 0;
if ((i == 3) && ((s[1] == 'a') || (s[1] == 'A'))) return 2;
return i;
}
time_t
asl_parse_time(const char *in)
{
int len, y, status, rflags, factor;
struct tm t;
time_t tick, delta;
char *str, *p, *x;
static regex_t rex_canon, rex_ctime, rex_abs, rex_rel;
static int init_canon = 0;
static int init_ctime = 0;
static int init_abs = 0;
static int init_rel = 0;
if (in == NULL) return -1;
rflags = REG_EXTENDED | REG_NOSUB | REG_ICASE;
if (init_canon == 0)
{
memset(&rex_canon, 0, sizeof(regex_t));
status = regcomp(&rex_canon, CANONICAL_TIME_REX, rflags);
if (status != 0) return -1;
init_canon = 1;
}
if (init_ctime == 0)
{
memset(&rex_ctime, 0, sizeof(regex_t));
status = regcomp(&rex_ctime, CTIME_REX, rflags);
if (status != 0) return -1;
init_ctime = 1;
}
if (init_abs == 0)
{
memset(&rex_abs, 0, sizeof(regex_t));
status = regcomp(&rex_abs, ABSOLUTE_TIME_REX, rflags);
if (status != 0) return -1;
init_abs = 1;
}
if (init_rel == 0)
{
memset(&rex_rel, 0, sizeof(regex_t));
status = regcomp(&rex_rel, RELATIVE_TIME_REX, rflags);
if (status != 0) return -1;
init_rel = 1;
}
len = strlen(in) + 1;
if (regexec(&rex_abs, in, 0, NULL, 0) == 0)
{
str = strdup(in);
if ((str[len-2] == 's') || (str[len-2] == 'S')) str[len-2] = '\0';
tick = atoi(str);
free(str);
return tick;
}
else if (regexec(&rex_rel, in, 0, NULL, 0) == 0)
{
str = strdup(in);
factor = 1;
if ((str[len-2] == 's') || (str[len-2] == 'S'))
{
str[len-2] = '\0';
}
else if ((str[len-2] == 'm') || (str[len-2] == 'M'))
{
str[len-2] = '\0';
factor = SECONDS_PER_MINUTE;
}
else if ((str[len-2] == 'h') || (str[len-2] == 'H'))
{
str[len-2] = '\0';
factor = SECONDS_PER_HOUR;
}
else if ((str[len-2] == 'd') || (str[len-2] == 'D'))
{
str[len-2] = '\0';
factor = SECONDS_PER_DAY;
}
else if ((str[len-2] == 'w') || (str[len-2] == 'W'))
{
str[len-2] = '\0';
factor = SECONDS_PER_WEEK;
}
tick = time(NULL);
delta = factor * atoi(str);
tick += delta;
free(str);
return tick;
}
else if (regexec(&rex_canon, in, 0, NULL, 0) == 0)
{
memset(&t, 0, sizeof(struct tm));
str = strdup(in);
x = str;
p = strchr(x, '.');
*p = '\0';
t.tm_year = atoi(x) - 1900;
x = p + 1;
p = strchr(x, '.');
*p = '\0';
t.tm_mon = atoi(x) - 1;
x = p + 1;
p = strchr(x, ' ');
*p = '\0';
t.tm_mday = atoi(x);
for (x = p + 1; *x == ' '; x++);
p = strchr(x, ':');
*p = '\0';
t.tm_hour = atoi(x);
x = p + 1;
p = strchr(x, ':');
*p = '\0';
t.tm_min = atoi(x);
x = p + 1;
p = strchr(x, ' ');
*p = '\0';
t.tm_sec = atoi(x);
free(str);
return timegm(&t);
}
else if (regexec(&rex_ctime, in, 0, NULL, 0) == 0)
{
memset(&t, 0, sizeof(struct tm));
tick = time(NULL);
gmtime_r(&tick, &t);
y = t.tm_year;
memset(&t, 0, sizeof(struct tm));
str = strdup(in);
t.tm_year = y;
t.tm_mon = _month_num(str);
if (t.tm_mon < 0) return -1;
for (x = strchr(str, ' '); *x == ' '; x++);
p = strchr(x, ' ');
*p = '\0';
t.tm_mday = atoi(x);
for (x = p + 1; *x == ' '; x++);
p = strchr(x, ':');
*p = '\0';
t.tm_hour = atoi(x);
x = p + 1;
p = strchr(x, ':');
*p = '\0';
t.tm_min = atoi(x);
x = p + 1;
t.tm_sec = atoi(x);
t.tm_isdst = -1;
free(str);
return mktime(&t);
}
return -1;
}
#ifdef ASL_SYSLOG_COMPAT
__private_extern__ void
asl_syslog_syslog(int pri, const char *fmt, ...)
{
va_list ap;
asl_msg_t *m;
if (fmt == NULL) return;
m = asl_new(ASL_TYPE_MSG);
va_start(ap, fmt);
asl_vlog(NULL, m, pri, fmt, ap);
va_end(ap);
asl_free(m);
}
__private_extern__ void
asl_syslog_vsyslog(int pri, const char *fmt, va_list ap)
{
asl_msg_t *m;
m = asl_new(ASL_TYPE_MSG);
asl_vlog(NULL, m, pri, fmt, ap);
asl_free(m);
}
__private_extern__ void
asl_syslog_openlog(const char *ident, int flags, int facility)
{
const char *fname;
uint32_t opts;
opts = 0;
if (flags & LOG_NDELAY) opts |= ASL_OPT_NO_DELAY;
if (flags & LOG_PERROR) opts |= ASL_OPT_STDERR;
fname = asl_syslog_faciliy_num_to_name(facility);
if (fname == NULL) fname = "user";
asl_global_client = asl_open(ident, fname, opts);
}
__private_extern__ void
asl_syslog_closelog()
{
asl_close();
}
__private_extern__ int
asl_syslog_setlogmask(int p)
{
return asl_set_filter(p);
}
#endif ASL_SYSLOG_COMPAT
#endif