status_t ChromiumHTTPDataSource::reconnectAtOffset(off64_t offset) {
Mutex::Autolock autoLock(mLock);
if (mURI.empty()) {
return INVALID_OPERATION;
}
LOG_PRI(ANDROID_LOG_INFO, LOG_TAG, "Reconnecting...");
status_t err = connect_l(mURI.c_str(), &mHeaders, offset);
if (err != OK) {
LOG_PRI(ANDROID_LOG_INFO, LOG_TAG, "Reconnect failed w/ err 0x%08x", err);
}
return err;
}
void vsyslog(int prio, const char *format, va_list ap)
{
char buf[BUFLEN];
int len;
int fd;
if (__syslog_fd == -1)
openlog(NULL, 0, 0);
buf[0] = '<';
buf[1] = LOG_PRI(prio) + '0';
buf[2] = '>';
len = 3;
if (syslog_flags & LOG_PID)
len += sprintf(buf + 3, "%s[%u]: ", id, getpid());
else if (*id)
len += sprintf(buf + 3, "%s: ", id);
len += vsnprintf(buf + len, BUFLEN - len, format, ap);
if (len > BUFLEN - 1)
len = BUFLEN - 1;
if (buf[len - 1] != '\n')
buf[len++] = '\n';
fd = __syslog_fd;
if (fd == -1)
fd = 2; /* Failed to open log, write to stderr */
write(fd, buf, len);
if (syslog_flags & LOG_PERROR)
_fwrite(buf + 3, len - 3, stderr);
}
const char *
logging_level_prefix(int priority)
{
/*
* Using LOG_PRI probably isn't standard, but I don't know a more
* portable way to determine the log level from priority, since
* it's perfectly legal for the user to OR the level with the
* facility when forming priority.
*/
switch (LOG_PRI(priority)) {
case LOG_DEBUG:
return "DEBUG: ";
case LOG_INFO:
return "INFO: ";
case LOG_NOTICE:
return "NOTICE: ";
case LOG_WARNING:
return "WARNING: ";
case LOG_ERR:
return "ERR: ";
case LOG_CRIT:
return "CRIT: ";
case LOG_ALERT:
return "ALERT: ";
case LOG_EMERG:
return "EMERG: ";
default:
return "UNKNOWN: ";
}
}
/******************************************************************************
* vsyslog
*
* Generate a log message using FMT and using arguments pointed to by AP.
*/
void vsyslog( int pri, char* fmt, va_list ap )
{
static char *month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
SYSTEMTIME stm;
int len;
char *p;
if( !(LOG_MASK( LOG_PRI( pri )) & log_mask) )
return;
openlog( NULL, 0, pri & LOG_FACMASK );
if( !initialized )
return;
if( !(pri & LOG_FACMASK) )
pri |= syslog_facility;
GetLocalTime( &stm );
len = sprintf( datagramm, "<%d>%s %2d %02d:%02d:%02d %s %s%s: ",
pri,
month[ stm.wMonth - 1 ], stm.wDay, stm.wHour, stm.wMinute, stm.wSecond,
local_hostname, syslog_ident? syslog_ident : "", str_pid );
vsnprintf( datagramm + len, datagramm_size - len, fmt, ap );
p = strchr( datagramm, '\n' );
if( p )
*p = 0;
p = strchr( datagramm, '\r' );
if( p )
*p = 0;
sendto( sock, datagramm, strlen(datagramm), 0, (SOCKADDR*) &sa_logger, sizeof(SOCKADDR_IN) );
}
void __syslog_chk(int priority, int flag, const char *message, ...)
{
LOCK(lock);
va_list ap;
va_start(ap, message);
char timebuf[16];
time_t now;
struct tm tm;
char buf[256];
int pid;
int l, l2;
if (!(priority & LOG_FACMASK)) priority |= log_facility;
now = time(NULL);
gmtime_r(&now, &tm);
strftime(timebuf, sizeof timebuf, "%b %e %T", &tm);
pid = (log_opt & LOG_PID) ? getpid() : 0;
l = snprintf(buf, sizeof buf, "<%d>%s %s%s%.0d%s: ",
priority, timebuf, log_ident, "["+!pid, pid, "]"+!pid);
l2 = vsnprintf(buf+l, sizeof buf - l, message, ap);
if (l2 >= 0) {
if (l2 >= sizeof buf - l) l = sizeof buf - 1;
else l += l2;
if (buf[l-1] != '\n') buf[l++] = '\n';
fwrite(buf, 1, l, LOG_PRI(priority) >= LOG_ERR ? stderr : stdout);
}
va_end(ap);
UNLOCK(lock);
}
void server_forward_kmsg(
Server *s,
int priority,
const char *identifier,
const char *message,
struct ucred *ucred) {
struct iovec iovec[5];
char header_priority[6], header_pid[16];
int n = 0;
char *ident_buf = NULL;
assert(s);
assert(priority >= 0);
assert(priority <= 999);
assert(message);
if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
return;
if (_unlikely_(s->dev_kmsg_fd < 0))
return;
/* Never allow messages with kernel facility to be written to
* kmsg, regardless where the data comes from. */
priority = syslog_fixup_facility(priority);
/* First: priority field */
snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
char_array_0(header_priority);
IOVEC_SET_STRING(iovec[n++], header_priority);
/* Second: identifier and PID */
if (ucred) {
if (!identifier) {
get_process_comm(ucred->pid, &ident_buf);
identifier = ident_buf;
}
snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
char_array_0(header_pid);
if (identifier)
IOVEC_SET_STRING(iovec[n++], identifier);
IOVEC_SET_STRING(iovec[n++], header_pid);
} else if (identifier) {
IOVEC_SET_STRING(iovec[n++], identifier);
IOVEC_SET_STRING(iovec[n++], ": ");
}
/* Fourth: message */
IOVEC_SET_STRING(iovec[n++], message);
IOVEC_SET_STRING(iovec[n++], "\n");
if (writev(s->dev_kmsg_fd, iovec, n) < 0)
log_debug("Failed to write to /dev/kmsg for logging: %m");
free(ident_buf);
}
status_t ChromiumHTTPDataSource::connect_l(
const char *uri,
const KeyedVector<String8, String8> *headers,
off64_t offset) {
if (mState != DISCONNECTED) {
disconnect_l();
}
LOG_PRI(ANDROID_LOG_INFO, LOG_TAG,
"connect to <URL suppressed> @%lld", offset);
mURI = uri;
mContentType = String8("application/octet-stream");
if (headers != NULL) {
mHeaders = *headers;
} else {
mHeaders.clear();
}
mState = CONNECTING;
mContentSize = -1;
mCurrentOffset = offset;
mDelegate->initiateConnection(mURI.c_str(), &mHeaders, offset);
while (mState == CONNECTING || mState == DISCONNECTING) {
mCondition.wait(mLock);
}
return mState == CONNECTED ? OK : mIOResult;
}
/* enqueue the the kernel message into the message queue.
* The provided msg string is not freed - thus must be done
* by the caller.
* rgerhards, 2008-04-12
*/
static rsRetVal
enqMsg(uchar *msg, uchar* pszTag, int iFacility, int iSeverity)
{
DEFiRet;
msg_t *pMsg;
assert(msg != NULL);
assert(pszTag != NULL);
CHKiRet(msgConstruct(&pMsg));
MsgSetFlowControlType(pMsg, eFLOWCTL_LIGHT_DELAY);
MsgSetInputName(pMsg, pInputName);
MsgSetRawMsgWOSize(pMsg, (char*)msg);
MsgSetMSGoffs(pMsg, 0); /* we do not have a header... */
MsgSetRcvFrom(pMsg, glbl.GetLocalHostNameProp());
MsgSetRcvFromIP(pMsg, pLocalHostIP);
MsgSetHOSTNAME(pMsg, glbl.GetLocalHostName(), ustrlen(glbl.GetLocalHostName()));
MsgSetTAG(pMsg, pszTag, ustrlen(pszTag));
pMsg->iFacility = LOG_FAC(iFacility);
pMsg->iSeverity = LOG_PRI(iSeverity);
CHKiRet(submitMsg(pMsg));
finalize_it:
RETiRet;
}
static void parse_fac_prio_20(int pri, char *res20)
{
CODE *c_pri, *c_fac;
if (pri != 0) {
c_fac = facilitynames;
while (c_fac->c_name) {
if (c_fac->c_val != (LOG_FAC(pri) << 3)) {
c_fac++; continue;
}
/* facility is found, look for prio */
c_pri = prioritynames;
while (c_pri->c_name) {
if (c_pri->c_val != LOG_PRI(pri)) {
c_pri++; continue;
}
snprintf(res20, 20, "%s.%s",
c_fac->c_name, c_pri->c_name);
return;
}
/* prio not found, bail out */
break;
}
snprintf(res20, 20, "<%d>", pri);
}
}
int log_internalv(
int level,
int error,
const char *file,
int line,
const char *func,
const char *format,
va_list ap) {
PROTECT_ERRNO;
char buffer[LINE_MAX];
if (error < 0)
error = -error;
if (_likely_(LOG_PRI(level) > log_max_level))
return -error;
/* Make sure that %m maps to the specified error */
if (error != 0)
errno = error;
vsnprintf(buffer, sizeof(buffer), format, ap);
return log_dispatch(level, error, file, line, func, NULL, NULL, buffer);
}
int log_object_internalv(
int level,
int error,
const char *file,
int line,
const char *func,
const char *object_field,
const char *object,
const char *format,
va_list ap) {
PROTECT_ERRNO;
char *buffer, *b;
size_t l;
if (error < 0)
error = -error;
if (_likely_(LOG_PRI(level) > log_max_level))
return -error;
/* Make sure that %m maps to the specified error */
if (error != 0)
errno = error;
/* Prepend the object name before the message */
if (object) {
size_t n;
n = strlen(object);
l = n + 2 + LINE_MAX;
buffer = newa(char, l);
b = stpcpy(stpcpy(buffer, object), ": ");
} else {
/**
* Log a message to a filedescriptor.
* @param fd File descritpor where the log will be written to
* @param lf Logging priority (equal to syslog)
* @param fmt Format string
* @param ap Variable parameter list
* @param with_errno Flag if errno should be printed too
*/
void
vlog_msgf(int fd, int lf, const char* fmt, va_list ap, int with_errno)
{
int level = LOG_PRI(lf);
char buf[1024];
if (level_ < level)
{
return;
}
if (fd > -1)
{
dprintf(fd, "%s;", flty_[level]);
vdprintf(fd, fmt, ap);
if (with_errno)
{
dprintf(fd, " (%s)", strerror(errno));
}
dprintf(fd, "\n");
}
else
{
vsnprintf(buf, sizeof(buf), fmt, ap);
syslog(level | LOG_DAEMON, "%s", buf);
}
}
static int write_to_console(
int level,
int error,
const char *file,
int line,
const char *func,
const char *object_field,
const char *object,
const char *buffer) {
char location[256], prefix[1 + DECIMAL_STR_MAX(int) + 2];
struct iovec iovec[6] = {};
unsigned n = 0;
bool highlight;
if (console_fd < 0)
return 0;
if (log_target == LOG_TARGET_CONSOLE_PREFIXED) {
sprintf(prefix, "<%i>", level);
IOVEC_SET_STRING(iovec[n++], prefix);
}
highlight = LOG_PRI(level) <= LOG_ERR && show_color;
if (show_location) {
snprintf(location, sizeof(location), "(%s:%i) ", file, line);
IOVEC_SET_STRING(iovec[n++], location);
}
if (highlight)
IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_RED);
IOVEC_SET_STRING(iovec[n++], buffer);
if (highlight)
IOVEC_SET_STRING(iovec[n++], ANSI_NORMAL);
IOVEC_SET_STRING(iovec[n++], "\n");
if (writev(console_fd, iovec, n) < 0) {
if (errno == EIO && getpid() == 1) {
/* If somebody tried to kick us from our
* console tty (via vhangup() or suchlike),
* try to reconnect */
log_close_console();
log_open_console();
if (console_fd < 0)
return 0;
if (writev(console_fd, iovec, n) < 0)
return -errno;
} else
return -errno;
}
return 1;
}
ssize_t ChromiumHTTPDataSource::readAt(off64_t offset, void *data, size_t size) {
Mutex::Autolock autoLock(mLock);
if (mState != CONNECTED) {
return INVALID_OPERATION;
}
#if 0
char value[PROPERTY_VALUE_MAX];
if (property_get("media.stagefright.disable-net", value, 0)
&& (!strcasecmp(value, "true") || !strcmp(value, "1"))) {
LOG_PRI(ANDROID_LOG_INFO, LOG_TAG, "Simulating that the network is down.");
disconnect_l();
return ERROR_IO;
}
#endif
if (offset != mCurrentOffset) {
AString tmp = mURI;
KeyedVector<String8, String8> tmpHeaders = mHeaders;
disconnect_l();
status_t err = connect_l(tmp.c_str(), &tmpHeaders, offset);
if (err != OK) {
LCHLOGD1("err = %d", (int ) err);
return err;
}
}
mState = READING;
int64_t startTimeUs = ALooper::GetNowUs();
mDelegate->initiateRead(data, size);
while (mState == READING) {
mCondition.wait(mLock);
}
if (mIOResult < OK) {
return mIOResult;
}
if (mState == CONNECTED) {
int64_t delayUs = ALooper::GetNowUs() - startTimeUs;
// The read operation was successful, mIOResult contains
// the number of bytes read.
addBandwidthMeasurement(mIOResult, delayUs);
mCurrentOffset += mIOResult;
return mIOResult;
}
return ERROR_IO;
}
void server_forward_kmsg(
Server *s,
int priority,
const char *identifier,
const char *message,
const struct ucred *ucred) {
_cleanup_free_ char *ident_buf = NULL;
struct iovec iovec[5];
char header_priority[DECIMAL_STR_MAX(priority) + 3],
header_pid[STRLEN("[]: ") + DECIMAL_STR_MAX(pid_t) + 1];
int n = 0;
assert(s);
assert(priority >= 0);
assert(priority <= 999);
assert(message);
if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
return;
if (_unlikely_(s->dev_kmsg_fd < 0))
return;
/* Never allow messages with kernel facility to be written to
* kmsg, regardless where the data comes from. */
priority = syslog_fixup_facility(priority);
/* First: priority field */
xsprintf(header_priority, "<%i>", priority);
iovec[n++] = IOVEC_MAKE_STRING(header_priority);
/* Second: identifier and PID */
if (ucred) {
if (!identifier) {
get_process_comm(ucred->pid, &ident_buf);
identifier = ident_buf;
}
xsprintf(header_pid, "["PID_FMT"]: ", ucred->pid);
if (identifier)
iovec[n++] = IOVEC_MAKE_STRING(identifier);
iovec[n++] = IOVEC_MAKE_STRING(header_pid);
} else if (identifier) {
iovec[n++] = IOVEC_MAKE_STRING(identifier);
iovec[n++] = IOVEC_MAKE_STRING(": ");
}
/* Fourth: message */
iovec[n++] = IOVEC_MAKE_STRING(message);
iovec[n++] = IOVEC_MAKE_STRING("\n");
if (writev(s->dev_kmsg_fd, iovec, n) < 0)
log_debug_errno(errno, "Failed to write to /dev/kmsg for logging: %m");
}
void async_vsyslog(struct async_syslog_state* state, int priority, const char *format, va_list ap) {
if (!(state->mask & LOG_MASK(LOG_PRI(priority))) || (priority &~ (LOG_PRIMASK|LOG_FACMASK)))
return;
if (state->buffer_get == state->buffer_put && !state->buffers_empty)
return;
connect_to_syslog(state);
add_to_log_buffer(state, priority, format, ap);
write_to_syslog(state);
}
void
getprio(int pri, char *res, int reslen) {
CODE *c_pri;
c_pri = prioritynames;
while (c_pri->c_name && !(c_pri->c_val == LOG_PRI(pri)))
c_pri++;
if(c_pri->c_name == NULL)
snprintf(res, reslen, "<%d>", pri);
else
snprintf(res, reslen, "%s", c_pri->c_name);
}
void ChromiumHTTPDataSource::onReadCompleted(ssize_t size) {
Mutex::Autolock autoLock(mLock);
mIOResult = size;
if (mState == READING) {
if(mForceDisconnect) {
LOG_PRI(ANDROID_LOG_INFO, LOG_TAG, "onReadCompleted, but we have disconnected");
return ;
}
mState = CONNECTED;
mCondition.broadcast();
}
}
status_t ChromiumHTTPDataSource::connect(
const char *uri,
const KeyedVector<String8, String8> *headers,
off64_t offset) {
Mutex::Autolock autoLock(mLock);
uid_t uid;
if (getUID(&uid)) {
mDelegate->setUID(uid);
}
LOG_PRI(ANDROID_LOG_VERBOSE, LOG_TAG, "connect on behalf of uid %d", uid);
return connect_l(uri, headers, offset);
}
/*! Log a message to a file.
* @param out Open FILE pointer
* @param lf Logging priority (equal to syslog)
* @param fmt Format string
* @param ap Variable parameter list
*/
void vlog_msgf(FILE *out, int lf, const char *fmt, va_list ap)
{
struct timeval tv;
struct tm *tm;
time_t t;
char timestr[TIMESTRLEN] = "", timez[TIMESTRLEN] = "";
const OcatThread_t *th = get_thread();
OcatThread_t ths;
int level = LOG_PRI(lf);
char buf[SIZE_1K];
if (CNF(debug_level) < level)
return;
//t = time(NULL);
if (gettimeofday(&tv, NULL) == -1)
fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, strerror(errno)), exit(1);
t = tv.tv_sec;
if ((tm = localtime(&t)))
{
(void) strftime(timestr, TIMESTRLEN, "%a, %d %b %Y %H:%M:%S", tm);
(void) strftime(timez, TIMESTRLEN, "%z", tm);
}
// if thread struct not in list
if (!th)
{
strlcpy(ths.name, "<NEW/DIE>", THREAD_NAME_LEN);
ths.id = -1;
th = &ths;
}
(void) pthread_mutex_lock(&log_mutex_);
if (out)
{
fprintf(out, "%s.%03d %s [%d:%-*s:%6s] ", timestr, (int) (tv.tv_usec / 1000), timez, th->id, THREAD_NAME_LEN - 1, th->name, flty_[level]);
vfprintf(out, fmt, ap);
fprintf(out, "\n");
}
else
{
// log to syslog if no output stream is available
//vsyslog(level | LOG_DAEMON, fmt, ap);
vsnprintf(buf, SIZE_1K, fmt, ap);
syslog(level | LOG_DAEMON, "[%s] %s", th->name, buf);
}
(void) pthread_mutex_unlock(&log_mutex_);
}
void _lc_core_log_systemd(int lpriority, const char *format, ...)
{
va_list arglist;
char obuf[LC_LOG_MSG_MAX_SIZE];
int n;
int priority;
/* Return on MASKed log priorities */
priority = LOG_PRI(lpriority);
va_start(arglist, format);
n = 0;
n += vsnprintf(obuf+n, LC_LOG_MSG_MAX_SIZE - n, format, arglist);
va_end(arglist);
sd_journal_print(priority, "%.*s", n, obuf);
}
static void print_priority(int arg)
{
int level = LOG_PRI(arg);
int facility = arg & ~level;
const char *level_str = get_level_str(level);
const char *facility_str = get_facility_str(facility);
if (facility_str)
{
fprintf(stderr, "%s | %s", level_str, facility_str);
}
else
{
fprintf(stderr, "%s | 0x%02X", level_str, facility);
}
}
/* log an imklog-internal message
* rgerhards, 2008-04-14
*/
rsRetVal imklogLogIntMsg(int priority, char *fmt, ...)
{
DEFiRet;
va_list ap;
uchar msgBuf[2048]; /* we use the same size as sysklogd to remain compatible */
uchar *pLogMsg;
va_start(ap, fmt);
vsnprintf((char*)msgBuf, sizeof(msgBuf) / sizeof(char), fmt, ap);
pLogMsg = msgBuf;
va_end(ap);
iRet = enqMsg((uchar*)pLogMsg, (uchar*) ((iFacilIntMsg == LOG_KERN) ? "kernel:" : "imklog:"),
iFacilIntMsg, LOG_PRI(priority));
RETiRet;
}
void server_forward_wall(
Server *s,
int priority,
const char *identifier,
const char *message,
const struct ucred *ucred) {
_cleanup_free_ char *ident_buf = NULL, *l_buf = NULL;
const char *l;
int r;
assert(s);
assert(message);
if (LOG_PRI(priority) > s->max_level_wall)
return;
if (ucred) {
if (!identifier) {
get_process_comm(ucred->pid, &ident_buf);
identifier = ident_buf;
}
if (asprintf(&l_buf, "%s["PID_FMT"]: %s", strempty(identifier), ucred->pid, message) < 0) {
log_oom();
return;
}
l = l_buf;
} else if (identifier) {
l = l_buf = strjoin(identifier, ": ", message, NULL);
if (!l_buf) {
log_oom();
return;
}
} else
l = message;
r = utmp_wall(l, "systemd-journald", NULL, NULL, NULL);
if (r < 0)
log_debug_errno(r, "Failed to send wall message: %m");
}
/******************************************************************************
* vsyslog
*
* Generate a log message using FMT and using arguments pointed to by AP.
*/
ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
vsyslog( int pri, char* fmt, va_list ap )
{
static char *month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
char datagramm[ SYSLOG_DGRAM_SIZE ];
SYSTEMTIME stm;
int len;
char *p;
if ( !initialized )
return;
EnterCriticalSection(&cs_syslog);
if( !(LOG_MASK( LOG_PRI( pri )) & syslog_mask) )
goto done;
openlog( NULL, 0, pri & LOG_FACMASK );
if( !syslog_opened )
goto done;
if( !(pri & LOG_FACMASK) )
pri |= syslog_facility;
GetLocalTime( &stm );
len = sprintf_s( datagramm, sizeof(datagramm),
"<%d>%s %2d %02d:%02d:%02d %s %s%s: ",
pri,
month[ stm.wMonth - 1 ], stm.wDay, stm.wHour, stm.wMinute, stm.wSecond,
local_hostname, syslog_ident, syslog_procid_str );
vsprintf_s( datagramm + len, datagramm_size - len, fmt, ap );
p = strchr( datagramm, '\n' );
if( p )
*p = 0;
p = strchr( datagramm, '\r' );
if( p )
*p = 0;
sendto( syslog_socket, datagramm, strlen(datagramm), 0, (SOCKADDR*) &syslog_hostaddr, sizeof(SOCKADDR_IN) );
done:
LeaveCriticalSection(&cs_syslog);
}
/* This function receives data from a socket indicated to be ready
* to receive and submits the message received for processing.
* rgerhards, 2007-12-20
* Interface changed so that this function is passed the array index
* of the socket which is to be processed. This eases access to the
* growing number of properties. -- rgerhards, 2008-08-01
*/
static rsRetVal
readLog(int fd, uchar *pRcv, int iMaxLine)
{
DEFiRet;
struct strbuf data;
struct strbuf ctl;
struct log_ctl hdr;
int flags;
msg_t *pMsg;
int ret;
char errStr[1024];
data.buf = (char*)pRcv;
data.maxlen = iMaxLine;
ctl.maxlen = sizeof (struct log_ctl);
ctl.buf = (caddr_t)&hdr;
flags = 0;
ret = getmsg(fd, &ctl, &data, &flags);
if(ret < 0) {
if(errno == EINTR) {
FINALIZE;
} else {
int en = errno;
rs_strerror_r(errno, errStr, sizeof(errStr));
DBGPRINTF("imsolaris: stream input error on fd %d: %s.\n", fd, errStr);
errmsg.LogError(en, NO_ERRCODE, "imsolaris: stream input error: %s", errStr);
tryRecover();
}
} else {
DBGPRINTF("imsolaris: message from log stream %d: %s\n", fd, pRcv);
pRcv[data.len] = '\0'; /* make sure it is a valid C-String */
CHKiRet(msgConstruct(&pMsg));
MsgSetInputName(pMsg, pInputName);
MsgSetRawMsg(pMsg, (char*)pRcv, strlen((char*)pRcv));
MsgSetHOSTNAME(pMsg, glbl.GetLocalHostName(), ustrlen(glbl.GetLocalHostName()));
pMsg->iFacility = LOG_FAC(hdr.pri);
pMsg->iSeverity = LOG_PRI(hdr.pri);
pMsg->msgFlags = NEEDS_PARSING | NO_PRI_IN_RAW;
CHKiRet(submitMsg(pMsg));
}
finalize_it:
RETiRet;
}
static int log_do_header(
char *header,
size_t size,
int level,
int error,
const char *file, int line, const char *func,
const char *object_field, const char *object,
const char *extra_field, const char *extra) {
snprintf(header, size,
"PRIORITY=%i\n"
"SYSLOG_FACILITY=%i\n"
"%s%s%s"
"%s%.*i%s"
"%s%s%s"
"%s%.*i%s"
"%s%s%s"
"%s%s%s"
"SYSLOG_IDENTIFIER=%s\n",
LOG_PRI(level),
LOG_FAC(level),
isempty(file) ? "" : "CODE_FILE=",
isempty(file) ? "" : file,
isempty(file) ? "" : "\n",
line ? "CODE_LINE=" : "",
line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
line ? "\n" : "",
isempty(func) ? "" : "CODE_FUNCTION=",
isempty(func) ? "" : func,
isempty(func) ? "" : "\n",
error ? "ERRNO=" : "",
error ? 1 : 0, error,
error ? "\n" : "",
isempty(object) ? "" : object_field,
isempty(object) ? "" : object,
isempty(object) ? "" : "\n",
isempty(extra) ? "" : extra_field,
isempty(extra) ? "" : extra,
isempty(extra) ? "" : "\n",
program_invocation_short_name);
return 0;
}
void
syslog (int priority, const char *format, ...)
{
WORD wType, category;
char buffer[BUFSIZ];
va_list ap;
LPCTSTR strs[2] = { buffer, syslog_instance_name };
if (!virt_err_log)
return;
switch (LOG_PRI (priority))
{
case LOG_EMERG: wType = EVENTLOG_ERROR_TYPE; category = 1; break;
case LOG_ALERT: wType = EVENTLOG_ERROR_TYPE; category = 2; break;
case LOG_CRIT: wType = EVENTLOG_ERROR_TYPE; category = 3; break;
case LOG_ERR: wType = EVENTLOG_ERROR_TYPE; category = 4; break;
case LOG_WARNING: wType = EVENTLOG_WARNING_TYPE; category = 5; break;
case LOG_NOTICE: wType = EVENTLOG_INFORMATION_TYPE; category = 6; break;
case LOG_INFO: wType = EVENTLOG_INFORMATION_TYPE; category = 7; break;
case LOG_DEBUG: wType = EVENTLOG_INFORMATION_TYPE; category = 8; break;
default: wType = EVENTLOG_INFORMATION_TYPE; category = 9; break;
}
va_start (ap, format);
#ifdef HAVE_VSNPRINTF
vsnprintf (buffer, sizeof (buffer), format, ap);
#else
vsprintf (buffer, format, ap);
#endif
if (!ReportEvent (
virt_err_log,
wType,
category,
0x10,
NULL,
2,
0,
strs,
NULL))
return;
}
int log_dump_internal(
int level,
int error,
const char *file,
int line,
const char *func,
char *buffer) {
PROTECT_ERRNO;
/* This modifies the buffer... */
if (error < 0)
error = -error;
if (_likely_(LOG_PRI(level) > log_max_level))
return -error;
return log_dispatch(level, error, file, line, func, NULL, NULL, buffer);
}
/*
* Output a code verifier warning message. For the pre-verifier it's not
* a big deal if something fails (and it may even be expected), but if
* we're doing just-in-time verification it's significant.
*/
void dvmLogVerifyFailure(const Method *meth, const char *format, ...) {
va_list ap;
int logLevel;
if (gDvm.optimizing) {
return;
//logLevel = ANDROID_LOG_DEBUG;
} else {
logLevel = ANDROID_LOG_WARN;
}
va_start(ap, format);
LOG_PRI_VA(logLevel, LOG_TAG, format, ap);
if (meth != NULL) {
char *desc = dexProtoCopyMethodDescriptor(&meth->prototype);
LOG_PRI(logLevel, LOG_TAG, "VFY: rejected %s.%s %s",
meth->clazz->descriptor, meth->name, desc);
free(desc);
}
}
