Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2d3f38a6 authored by Mark Salyzyn's avatar Mark Salyzyn
Browse files

liblog: introduce ANDROID_LOG_* flags 

Move away from using POSIX open(2) flags and introduce ANDROID_LOG_* flags to
replace them. Add security by preventing random mode flags from getting into
underlying POSIX calls. ANDROID_LOG_* flags overlap POSIX O_* flag definitions.

Change-Id: Ib32bb64c287e8bf150be62242e1ba46bb37839fc
parent 72bf2a71

debuggerd/tombstone.cpp

+1 −1
Original line number Diff line number Diff line
@@ -453,7 +453,7 @@ static void dump_log_file( 
  }



  logger_list = android_logger_list_open(

      android_name_to_log_id(filename), O_RDONLY | O_NONBLOCK, tail, pid);

      android_name_to_log_id(filename), ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, tail, pid);



  if (!logger_list) {

    ALOGE("Unable to open %s: %s\n", filename, strerror(errno));

include/log/logger.h

+6 −0
Original line number Diff line number Diff line
@@ -154,6 +154,12 @@ ssize_t android_logger_get_prune_list(struct logger_list *logger_list, 
int android_logger_set_prune_list(struct logger_list *logger_list,

                                  char *buf, size_t len);



#define ANDROID_LOG_RDONLY   O_RDONLY

#define ANDROID_LOG_WRONLY   O_WRONLY

#define ANDROID_LOG_RDWR     O_RDWR

#define ANDROID_LOG_ACCMODE  O_ACCMODE

#define ANDROID_LOG_NONBLOCK O_NONBLOCK



struct logger_list *android_logger_list_alloc(int mode,

                                              unsigned int tail,

                                              pid_t pid);

liblog/README

+7 −6
Original line number Diff line number Diff line
@@ -111,20 +111,21 @@ DESCRIPTION 
       ger_list_alloc,  calling  in  turn the android_logger_open for each log

       id.  Each entry can be retrieved  with  android_logger_list_read.   The

       log(s) can be closed with android_logger_list_free.  The logs should be

       opened with an O_RDONLY mode.  O_NDELAY mode will report when  the  log

       reading  is  done  with  an  EAGAIN  error  return  code, otherwise the

       android_logger_list_read call will block for new entries.

       opened  with an  ANDROID_LOG_RDONLY  mode.   ANDROID_LOG_NONBLOCK  mode

       will report when the  log reading is done with an  EAGAIN  error return

       code,  otherwise the  android_logger_list_read  call will block for new

       entries.



       The value returned by android_logger_open can be used as a parameter to

       the  android_logger_clear  function to empty the sub-log.  It is recom‐

       mended to only open log O_WRONLY.

       mended to only open log ANDROID_LOG_WRONLY in that case.



       The value returned by android_logger_open can be used as a parameter to

       the android_logger_get_log_(size|readable_size|version) to retrieve the

       sub-log maximum size, readable size and log buffer format protocol ver‐

       sion  respectively.  android_logger_get_id returns the id that was used

       when opening the sub-log.  It is recommended to open the  log  O_RDONLY

       in these cases.

       when  opening  the  sub-log.    It  is  recommended  to  open  the  log

       ANDROID_LOG_RDONLY in these cases.



SEE ALSO

       syslogd(8)

liblog/log_read.c

+6 −6
Original line number Diff line number Diff line
@@ -582,7 +582,7 @@ int android_logger_list_read(struct logger_list *logger_list, 
        return -EINVAL;

    }



    if (logger_list->mode & O_NONBLOCK) {

    if (logger_list->mode & ANDROID_LOG_NONBLOCK) {

        memset(&ignore, 0, sizeof(ignore));

        ignore.sa_handler = caught_signal;

        sigemptyset(&ignore.sa_mask);
@@ -602,7 +602,7 @@ int android_logger_list_read(struct logger_list *logger_list, 
        }



        strcpy(buffer,

               (logger_list->mode & O_NONBLOCK) ? "dumpAndClose" : "stream");

               (logger_list->mode & ANDROID_LOG_NONBLOCK) ? "dumpAndClose" : "stream");

        cp = buffer + strlen(buffer);



        strcpy(cp, " lids");
@@ -640,14 +640,14 @@ int android_logger_list_read(struct logger_list *logger_list, 
            cp += ret;

        }



        if (logger_list->mode & O_NONBLOCK) {

        if (logger_list->mode & ANDROID_LOG_NONBLOCK) {

            /* Deal with an unresponsive logd */

            sigaction(SIGALRM, &ignore, &old_sigaction);

            old_alarm = alarm(30);

        }

        ret = write(sock, buffer, cp - buffer);

        e = errno;

        if (logger_list->mode & O_NONBLOCK) {

        if (logger_list->mode & ANDROID_LOG_NONBLOCK) {

            if (e == EINTR) {

                e = ETIMEDOUT;

            }
@@ -673,7 +673,7 @@ int android_logger_list_read(struct logger_list *logger_list, 
    while(1) {

        memset(log_msg, 0, sizeof(*log_msg));



        if (logger_list->mode & O_NONBLOCK) {

        if (logger_list->mode & ANDROID_LOG_NONBLOCK) {

            /* particularily useful if tombstone is reporting for logd */

            sigaction(SIGALRM, &ignore, &old_sigaction);

            old_alarm = alarm(30);
@@ -681,7 +681,7 @@ int android_logger_list_read(struct logger_list *logger_list, 
        /* NOTE: SOCK_SEQPACKET guarantees we read exactly one full entry */

        ret = recv(logger_list->sock, log_msg, LOGGER_ENTRY_MAX_LEN, 0);

        e = errno;

        if (logger_list->mode & O_NONBLOCK) {

        if (logger_list->mode & ANDROID_LOG_NONBLOCK) {

            if ((ret == 0) || (e == EINTR)) {

                e = EAGAIN;

                ret = -1;

liblog/log_read_kern.c

+11 −11
Original line number Diff line number Diff line
@@ -75,10 +75,10 @@ const char *android_log_id_to_name(log_id_t log_id) 


static int accessmode(int mode)

{

    if ((mode & O_ACCMODE) == O_WRONLY) {

    if ((mode & ANDROID_LOG_ACCMODE) == ANDROID_LOG_WRONLY) {

        return W_OK;

    }

    if ((mode & O_ACCMODE) == O_RDWR) {

    if ((mode & ANDROID_LOG_ACCMODE) == ANDROID_LOG_RDWR) {

        return R_OK | W_OK;

    }

    return R_OK;
@@ -117,7 +117,7 @@ log_id_t android_name_to_log_id(const char *logName) 
        ++b;

    }



    ret = check_allocate_accessible(&n, b, O_RDONLY);

    ret = check_allocate_accessible(&n, b, ANDROID_LOG_RDONLY);

    free(n);

    if (ret) {

        return ret;
@@ -201,8 +201,8 @@ static int logger_ioctl(struct logger *logger, int cmd, int mode) 
        return -EFAULT;

    }



    if (((mode & O_ACCMODE) == O_RDWR)

            || (((mode ^ logger->top->mode) & O_ACCMODE) == 0)) {

    if (((mode & ANDROID_LOG_ACCMODE) == ANDROID_LOG_RDWR)

            || (((mode ^ logger->top->mode) & ANDROID_LOG_ACCMODE) == 0)) {

        return ioctl(logger->fd, cmd);

    }
@@ -227,13 +227,13 @@ static int logger_ioctl(struct logger *logger, int cmd, int mode) 


int android_logger_clear(struct logger *logger)

{

    return logger_ioctl(logger, LOGGER_FLUSH_LOG, O_WRONLY);

    return logger_ioctl(logger, LOGGER_FLUSH_LOG, ANDROID_LOG_WRONLY);

}



/* returns the total size of the log's ring buffer */

long android_logger_get_log_size(struct logger *logger)

{

    return logger_ioctl(logger, LOGGER_GET_LOG_BUF_SIZE, O_RDWR);

    return logger_ioctl(logger, LOGGER_GET_LOG_BUF_SIZE, ANDROID_LOG_RDWR);

}



int android_logger_set_log_size(struct logger *logger __unused,
@@ -248,7 +248,7 @@ int android_logger_set_log_size(struct logger *logger __unused, 
 */

long android_logger_get_log_readable_size(struct logger *logger)

{

    return logger_ioctl(logger, LOGGER_GET_LOG_LEN, O_RDONLY);

    return logger_ioctl(logger, LOGGER_GET_LOG_LEN, ANDROID_LOG_RDONLY);

}



/*
@@ -256,7 +256,7 @@ long android_logger_get_log_readable_size(struct logger *logger) 
 */

int android_logger_get_log_version(struct logger *logger)

{

    int ret = logger_ioctl(logger, LOGGER_GET_VERSION, O_RDWR);

    int ret = logger_ioctl(logger, LOGGER_GET_VERSION, ANDROID_LOG_RDWR);

    return (ret < 0) ? 1 : ret;

}
@@ -342,7 +342,7 @@ struct logger *android_logger_open(struct logger_list *logger_list, 
        goto err_name;

    }



    logger->fd = open(n, logger_list->mode);

    logger->fd = open(n, logger_list->mode & (ANDROID_LOG_ACCMODE | ANDROID_LOG_NONBLOCK));

    if (logger->fd < 0) {

        goto err_name;

    }
@@ -565,7 +565,7 @@ int android_logger_list_read(struct logger_list *logger_list, 
        if (result <= 0) {

            if (result) {

                error = errno;

            } else if (logger_list->mode & O_NDELAY) {

            } else if (logger_list->mode & ANDROID_LOG_NONBLOCK) {

                error = EAGAIN;

            } else {

                logger_list->timeout_ms = LOG_TIMEOUT_NEVER;