QueryData genAsl(QueryContext &context) {
QueryData results;
aslmsg query = createAslQuery(context);
aslresponse result = asl_search(nullptr, query);
aslmsg row = nullptr;
while ((row = asl_next(result)) != nullptr) {
Row r;
readAslRow(row, r);
results.push_back(r);
}
asl_release(result);
asl_release(query);
return results;
}
static void
__SCThreadSpecificDataFinalize(void *arg)
{
__SCThreadSpecificDataRef tsd = (__SCThreadSpecificDataRef)arg;
if (tsd != NULL) {
if (tsd->_asl != NULL) asl_release(tsd->_asl);
if (tsd->_sc_store != NULL) CFRelease(tsd->_sc_store);
CFAllocatorDeallocate(kCFAllocatorSystemDefault, tsd);
}
return;
}
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);
}
TEST_F(AslTests, test_create_asl_query) {
QueryContext ctx;
ctx.constraints["sender"].add(Constraint(EQUALS, "bar"));
ctx.constraints["sender"].add(Constraint(LIKE, "%a%"));
ctx.constraints["message"].affinity = INTEGER_TYPE;
ctx.constraints["message"].add(Constraint(LESS_THAN, "10"));
aslmsg query = createAslQuery(ctx);
ASSERT_EQ((uint32_t)ASL_TYPE_QUERY, asl_get_type(query));
ASSERT_EQ((size_t)3, asl_count(query));
const char *key, *val;
uint32_t op;
// Ordering doesn't really matter here, only that we only ended up with
// (message, baz, LESS) and (sender, bar, EQUAL)
ASSERT_EQ(0, asl_fetch_key_val_op(query, 0, &key, &val, &op));
ASSERT_STREQ("Message", key);
ASSERT_STREQ("10", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_LESS | ASL_QUERY_OP_NUMERIC), op);
ASSERT_EQ(0, asl_fetch_key_val_op(query, 1, &key, &val, &op));
ASSERT_STREQ("Sender", key);
ASSERT_STREQ("bar", val);
ASSERT_EQ((uint32_t)ASL_QUERY_OP_EQUAL, op);
ASSERT_EQ(0, asl_fetch_key_val_op(query, 2, &key, &val, &op));
ASSERT_STREQ("Sender", key);
ASSERT_STREQ(".*a.*", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_EQUAL | ASL_QUERY_OP_REGEX |
ASL_QUERY_OP_CASEFOLD),
op);
asl_release(query);
}
void
asl_msg_list_release(asl_msg_list_t *list)
{
if (list == NULL) return;
asl_release((asl_object_t)list);
}
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);
}
void
asl_close(asl_object_t obj)
{
asl_release(obj);
}
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);
}
