liblogcat: introduce getopt_long_r
Resolve one of the threading issues by creating a private C++ified copy of getopt_long_r that started out its life as the bionic getopt_long, but is reentrant. Adds a new state context for the stderr stream called optstderr. Utilize this new function in logcat. Control opterr and optstderr to match liblogcat expectations. Correct and fortify const. Alternative would be to lock around _all_ getopt callers. This has the advantage of requiring _no_ locks that could get in the way of using liblogcat in a signal handler. The log reader interface does run the risk of incurring locks and heap allocations though, so there is more work to be done for that final goal. Test: gTest logcat-unit-tests Bug: 35326290 Change-Id: Ibb1b374c55d357d5d7fa5ad00bfaf07ae0bc4ba5
This commit is contained in:
Mark Salyzyn
parent
07169227e1
commit
e9ade17418
|
|
@ -16,7 +16,7 @@ include $(BUILD_EXECUTABLE)
|
|||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := liblogcat
|
||||
LOCAL_SRC_FILES := logcat.cpp logcat_system.cpp
|
||||
LOCAL_SRC_FILES := logcat.cpp getopt_long.cpp logcat_system.cpp
|
||||
LOCAL_SHARED_LIBRARIES := $(logcatLibs)
|
||||
LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
|
||||
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
|
||||
|
|
|
|||
|
|
@ -0,0 +1,402 @@
|
|||
/* $OpenBSD: getopt_long.c,v 1.26 2013/06/08 22:47:56 millert Exp $ */
|
||||
/* $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Sponsored in part by the Defense Advanced Research Projects
|
||||
* Agency (DARPA) and Air Force Research Laboratory, Air Force
|
||||
* Materiel Command, USAF, under agreement number F39502-99-1-0512.
|
||||
*/
|
||||
/*-
|
||||
* Copyright (c) 2000 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Dieter Baron and Thomas Klausner.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/cdefs.h>
|
||||
|
||||
#include <log/getopt.h>
|
||||
|
||||
#define PRINT_ERROR ((context->opterr) && (*options != ':'))
|
||||
|
||||
#define FLAG_PERMUTE 0x01 // permute non-options to the end of argv
|
||||
#define FLAG_ALLARGS 0x02 // treat non-options as args to option "-1"
|
||||
|
||||
// return values
|
||||
#define BADCH (int)'?'
|
||||
#define BADARG ((*options == ':') ? (int)':' : (int)'?')
|
||||
#define INORDER (int)1
|
||||
|
||||
#define D_PREFIX 0
|
||||
#define DD_PREFIX 1
|
||||
#define W_PREFIX 2
|
||||
|
||||
// Compute the greatest common divisor of a and b.
|
||||
static int gcd(int a, int b) {
|
||||
int c = a % b;
|
||||
while (c) {
|
||||
a = b;
|
||||
b = c;
|
||||
c = a % b;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
// Exchange the block from nonopt_start to nonopt_end with the block from
|
||||
// nonopt_end to opt_end (keeping the same order of arguments in each block).
|
||||
// Returns optind - (nonopt_end - nonopt_start) for convenience.
|
||||
static int permute_args(getopt_context* context, char* const* nargv) {
|
||||
// compute lengths of blocks and number and size of cycles
|
||||
int nnonopts = context->nonopt_end - context->nonopt_start;
|
||||
int nopts = context->optind - context->nonopt_end;
|
||||
int ncycle = gcd(nnonopts, nopts);
|
||||
int cyclelen = (context->optind - context->nonopt_start) / ncycle;
|
||||
|
||||
for (int i = 0; i < ncycle; i++) {
|
||||
int cstart = context->nonopt_end + i;
|
||||
int pos = cstart;
|
||||
for (int j = 0; j < cyclelen; j++) {
|
||||
if (pos >= context->nonopt_end) {
|
||||
pos -= nnonopts;
|
||||
} else {
|
||||
pos += nopts;
|
||||
}
|
||||
char* swap = nargv[pos];
|
||||
const_cast<char**>(nargv)[pos] = nargv[cstart];
|
||||
const_cast<char**>(nargv)[cstart] = swap;
|
||||
}
|
||||
}
|
||||
return context->optind - (context->nonopt_end - context->nonopt_start);
|
||||
}
|
||||
|
||||
// parse_long_options_r --
|
||||
// Parse long options in argc/argv argument vector.
|
||||
// Returns -1 if short_too is set and the option does not match long_options.
|
||||
static int parse_long_options_r(char* const* nargv, const char* options,
|
||||
const struct option* long_options, int* idx,
|
||||
bool short_too, struct getopt_context* context) {
|
||||
const char* current_argv = context->place;
|
||||
const char* current_dash;
|
||||
switch (context->dash_prefix) {
|
||||
case D_PREFIX:
|
||||
current_dash = "-";
|
||||
break;
|
||||
case DD_PREFIX:
|
||||
current_dash = "--";
|
||||
break;
|
||||
case W_PREFIX:
|
||||
current_dash = "-W ";
|
||||
break;
|
||||
default:
|
||||
current_dash = "";
|
||||
break;
|
||||
}
|
||||
context->optind++;
|
||||
|
||||
const char* has_equal;
|
||||
size_t current_argv_len;
|
||||
if (!!(has_equal = strchr(current_argv, '='))) {
|
||||
// argument found (--option=arg)
|
||||
current_argv_len = has_equal - current_argv;
|
||||
has_equal++;
|
||||
} else {
|
||||
current_argv_len = strlen(current_argv);
|
||||
}
|
||||
|
||||
int match = -1;
|
||||
bool exact_match = false;
|
||||
bool second_partial_match = false;
|
||||
for (int i = 0; long_options[i].name; i++) {
|
||||
// find matching long option
|
||||
if (strncmp(current_argv, long_options[i].name, current_argv_len)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strlen(long_options[i].name) == current_argv_len) {
|
||||
// exact match
|
||||
match = i;
|
||||
exact_match = true;
|
||||
break;
|
||||
}
|
||||
// If this is a known short option, don't allow
|
||||
// a partial match of a single character.
|
||||
if (short_too && current_argv_len == 1) continue;
|
||||
|
||||
if (match == -1) { // first partial match
|
||||
match = i;
|
||||
} else if (long_options[i].has_arg != long_options[match].has_arg ||
|
||||
long_options[i].flag != long_options[match].flag ||
|
||||
long_options[i].val != long_options[match].val) {
|
||||
second_partial_match = true;
|
||||
}
|
||||
}
|
||||
if (!exact_match && second_partial_match) {
|
||||
// ambiguous abbreviation
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr,
|
||||
"option `%s%.*s' is ambiguous", current_dash,
|
||||
(int)current_argv_len, current_argv);
|
||||
}
|
||||
context->optopt = 0;
|
||||
return BADCH;
|
||||
}
|
||||
if (match != -1) { // option found
|
||||
if (long_options[match].has_arg == no_argument && has_equal) {
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr,
|
||||
"option `%s%.*s' doesn't allow an argument",
|
||||
current_dash, (int)current_argv_len, current_argv);
|
||||
}
|
||||
// XXX: GNU sets optopt to val regardless of flag
|
||||
context->optopt =
|
||||
long_options[match].flag ? 0 : long_options[match].val;
|
||||
return BADCH;
|
||||
}
|
||||
if (long_options[match].has_arg == required_argument ||
|
||||
long_options[match].has_arg == optional_argument) {
|
||||
if (has_equal) {
|
||||
context->optarg = has_equal;
|
||||
} else if (long_options[match].has_arg == required_argument) {
|
||||
// optional argument doesn't use next nargv
|
||||
context->optarg = nargv[context->optind++];
|
||||
}
|
||||
}
|
||||
if ((long_options[match].has_arg == required_argument) &&
|
||||
!context->optarg) {
|
||||
// Missing argument; leading ':' indicates no error
|
||||
// should be generated.
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr,
|
||||
"option `%s%s' requires an argument", current_dash,
|
||||
current_argv);
|
||||
}
|
||||
// XXX: GNU sets optopt to val regardless of flag
|
||||
context->optopt =
|
||||
long_options[match].flag ? 0 : long_options[match].val;
|
||||
context->optind--;
|
||||
return BADARG;
|
||||
}
|
||||
} else { // unknown option
|
||||
if (short_too) {
|
||||
context->optind--;
|
||||
return -1;
|
||||
}
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr, "unrecognized option `%s%s'",
|
||||
current_dash, current_argv);
|
||||
}
|
||||
context->optopt = 0;
|
||||
return BADCH;
|
||||
}
|
||||
if (idx) *idx = match;
|
||||
if (long_options[match].flag) {
|
||||
*long_options[match].flag = long_options[match].val;
|
||||
return 0;
|
||||
}
|
||||
return long_options[match].val;
|
||||
}
|
||||
|
||||
// getopt_long_r --
|
||||
// Parse argc/argv argument vector.
|
||||
int getopt_long_r(int nargc, char* const* nargv, const char* options,
|
||||
const struct option* long_options, int* idx,
|
||||
struct getopt_context* context) {
|
||||
if (!options) return -1;
|
||||
|
||||
// XXX Some GNU programs (like cvs) set optind to 0 instead of
|
||||
// XXX using optreset. Work around this braindamage.
|
||||
if (!context->optind) context->optind = context->optreset = 1;
|
||||
|
||||
// Disable GNU extensions if options string begins with a '+'.
|
||||
int flags = FLAG_PERMUTE;
|
||||
if (*options == '-') {
|
||||
flags |= FLAG_ALLARGS;
|
||||
} else if (*options == '+') {
|
||||
flags &= ~FLAG_PERMUTE;
|
||||
}
|
||||
if (*options == '+' || *options == '-') options++;
|
||||
|
||||
context->optarg = nullptr;
|
||||
if (context->optreset) context->nonopt_start = context->nonopt_end = -1;
|
||||
start:
|
||||
if (context->optreset || !*context->place) { // update scanning pointer
|
||||
context->optreset = 0;
|
||||
if (context->optind >= nargc) { // end of argument vector
|
||||
context->place = EMSG;
|
||||
if (context->nonopt_end != -1) {
|
||||
// do permutation, if we have to
|
||||
context->optind = permute_args(context, nargv);
|
||||
} else if (context->nonopt_start != -1) {
|
||||
// If we skipped non-options, set optind to the first of them.
|
||||
context->optind = context->nonopt_start;
|
||||
}
|
||||
context->nonopt_start = context->nonopt_end = -1;
|
||||
return -1;
|
||||
}
|
||||
if (*(context->place = nargv[context->optind]) != '-' ||
|
||||
context->place[1] == '\0') {
|
||||
context->place = EMSG; // found non-option
|
||||
if (flags & FLAG_ALLARGS) {
|
||||
// GNU extension: return non-option as argument to option 1
|
||||
context->optarg = nargv[context->optind++];
|
||||
return INORDER;
|
||||
}
|
||||
if (!(flags & FLAG_PERMUTE)) {
|
||||
// If no permutation wanted, stop parsing at first non-option.
|
||||
return -1;
|
||||
}
|
||||
// do permutation
|
||||
if (context->nonopt_start == -1) {
|
||||
context->nonopt_start = context->optind;
|
||||
} else if (context->nonopt_end != -1) {
|
||||
context->nonopt_start = permute_args(context, nargv);
|
||||
context->nonopt_end = -1;
|
||||
}
|
||||
context->optind++;
|
||||
// process next argument
|
||||
goto start;
|
||||
}
|
||||
if (context->nonopt_start != -1 && context->nonopt_end == -1) {
|
||||
context->nonopt_end = context->optind;
|
||||
}
|
||||
|
||||
// If we have "-" do nothing, if "--" we are done.
|
||||
if (context->place[1] != '\0' && *++(context->place) == '-' &&
|
||||
context->place[1] == '\0') {
|
||||
context->optind++;
|
||||
context->place = EMSG;
|
||||
// We found an option (--), so if we skipped
|
||||
// non-options, we have to permute.
|
||||
if (context->nonopt_end != -1) {
|
||||
context->optind = permute_args(context, nargv);
|
||||
}
|
||||
context->nonopt_start = context->nonopt_end = -1;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int optchar;
|
||||
// Check long options if:
|
||||
// 1) we were passed some
|
||||
// 2) the arg is not just "-"
|
||||
// 3) either the arg starts with -- we are getopt_long_only()
|
||||
if (long_options && context->place != nargv[context->optind] &&
|
||||
(*context->place == '-')) {
|
||||
bool short_too = false;
|
||||
context->dash_prefix = D_PREFIX;
|
||||
if (*context->place == '-') {
|
||||
context->place++; // --foo long option
|
||||
context->dash_prefix = DD_PREFIX;
|
||||
} else if (*context->place != ':' && strchr(options, *context->place)) {
|
||||
short_too = true; // could be short option too
|
||||
}
|
||||
|
||||
optchar = parse_long_options_r(nargv, options, long_options, idx,
|
||||
short_too, context);
|
||||
if (optchar != -1) {
|
||||
context->place = EMSG;
|
||||
return optchar;
|
||||
}
|
||||
}
|
||||
|
||||
const char* oli; // option letter list index
|
||||
if ((optchar = (int)*(context->place)++) == (int)':' ||
|
||||
(optchar == (int)'-' && *context->place != '\0') ||
|
||||
!(oli = strchr(options, optchar))) {
|
||||
// If the user specified "-" and '-' isn't listed in
|
||||
// options, return -1 (non-option) as per POSIX.
|
||||
// Otherwise, it is an unknown option character (or ':').
|
||||
if (optchar == (int)'-' && *context->place == '\0') return -1;
|
||||
if (!*context->place) context->optind++;
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr, "invalid option -- %c",
|
||||
optchar);
|
||||
}
|
||||
context->optopt = optchar;
|
||||
return BADCH;
|
||||
}
|
||||
|
||||
static const char recargchar[] = "option requires an argument -- %c";
|
||||
if (long_options && optchar == 'W' && oli[1] == ';') {
|
||||
// -W long-option
|
||||
if (*context->place) { // no space
|
||||
; // NOTHING
|
||||
} else if (++(context->optind) >= nargc) { // no arg
|
||||
context->place = EMSG;
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr, recargchar, optchar);
|
||||
}
|
||||
context->optopt = optchar;
|
||||
return BADARG;
|
||||
} else { // white space
|
||||
context->place = nargv[context->optind];
|
||||
}
|
||||
context->dash_prefix = W_PREFIX;
|
||||
optchar = parse_long_options_r(nargv, options, long_options, idx, false,
|
||||
context);
|
||||
context->place = EMSG;
|
||||
return optchar;
|
||||
}
|
||||
if (*++oli != ':') { // doesn't take argument
|
||||
if (!*context->place) context->optind++;
|
||||
} else { // takes (optional) argument
|
||||
context->optarg = nullptr;
|
||||
if (*context->place) { // no white space
|
||||
context->optarg = context->place;
|
||||
} else if (oli[1] != ':') { // arg not optional
|
||||
if (++(context->optind) >= nargc) { // no arg
|
||||
context->place = EMSG;
|
||||
if (PRINT_ERROR) {
|
||||
fprintf(context->optstderr ?: stderr, recargchar, optchar);
|
||||
}
|
||||
context->optopt = optchar;
|
||||
return BADARG;
|
||||
}
|
||||
context->optarg = nargv[context->optind];
|
||||
}
|
||||
context->place = EMSG;
|
||||
context->optind++;
|
||||
}
|
||||
// dump back option letter
|
||||
return optchar;
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
/*
|
||||
* Copyright (C) 2017 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef _LOG_GETOPT_H_
|
||||
#define _LOG_GETOPT_H_
|
||||
|
||||
#ifndef __ANDROID_USE_LIBLOG_LOGCAT_INTERFACE
|
||||
#ifndef __ANDROID_API__
|
||||
#define __ANDROID_USE_LIBLOG_LOGCAT_INTERFACE 1
|
||||
#elif __ANDROID_API__ > 24 /* > Nougat */
|
||||
#define __ANDROID_USE_LIBLOG_LOGCAT_INTERFACE 1
|
||||
#else
|
||||
#define __ANDROID_USE_LIBLOG_LOGCAT_INTERFACE 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if __ANDROID_USE_LIBLOG_LOGCAT_INTERFACE
|
||||
|
||||
#include <getopt.h>
|
||||
#include <sys/cdefs.h>
|
||||
|
||||
struct getopt_context {
|
||||
int opterr;
|
||||
int optind;
|
||||
int optopt;
|
||||
int optreset;
|
||||
const char* optarg;
|
||||
FILE* optstderr; /* NULL defaults to stderr */
|
||||
/* private */
|
||||
const char* place;
|
||||
int nonopt_start;
|
||||
int nonopt_end;
|
||||
int dash_prefix;
|
||||
/* expansion space */
|
||||
int __extra__;
|
||||
void* __stuff__;
|
||||
};
|
||||
|
||||
#define EMSG ""
|
||||
#define NO_PREFIX (-1)
|
||||
|
||||
#define INIT_GETOPT_CONTEXT(context) \
|
||||
context = { 1, 1, '?', 0, NULL, NULL, EMSG, -1, -1, NO_PREFIX, 0, NULL }
|
||||
|
||||
__BEGIN_DECLS
|
||||
int getopt_long_r(int nargc, char* const* nargv, const char* options,
|
||||
const struct option* long_options, int* idx,
|
||||
struct getopt_context* context);
|
||||
|
||||
__END_DECLS
|
||||
|
||||
#endif /* __ANDROID_USE_LIBLOG_LOGCAT_INTERFACE */
|
||||
|
||||
#endif /* !_LOG_GETOPT_H_ */
|
||||
|
|
@ -20,7 +20,6 @@
|
|||
#include <dirent.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <getopt.h>
|
||||
#include <math.h>
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
|
|
@ -47,6 +46,7 @@
|
|||
#include <cutils/sched_policy.h>
|
||||
#include <cutils/sockets.h>
|
||||
#include <log/event_tag_map.h>
|
||||
#include <log/getopt.h>
|
||||
#include <log/logcat.h>
|
||||
#include <log/logprint.h>
|
||||
#include <private/android_logger.h>
|
||||
|
|
@ -635,19 +635,17 @@ static char* parseTime(log_time& t, const char* cp) {
|
|||
}
|
||||
|
||||
// Find last logged line in <outputFileName>, or <outputFileName>.1
|
||||
static log_time lastLogTime(char* outputFileName) {
|
||||
static log_time lastLogTime(const char* outputFileName) {
|
||||
log_time retval(log_time::EPOCH);
|
||||
if (!outputFileName) return retval;
|
||||
|
||||
std::string directory;
|
||||
char* file = strrchr(outputFileName, '/');
|
||||
const char* file = strrchr(outputFileName, '/');
|
||||
if (!file) {
|
||||
directory = ".";
|
||||
file = outputFileName;
|
||||
} else {
|
||||
*file = '\0';
|
||||
directory = outputFileName;
|
||||
*file = '/';
|
||||
directory = std::string(outputFileName, file - outputFileName);
|
||||
++file;
|
||||
}
|
||||
|
||||
|
|
@ -736,8 +734,8 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
bool printStatistics = false;
|
||||
bool printDividers = false;
|
||||
unsigned long setLogSize = 0;
|
||||
char* setPruneList = nullptr;
|
||||
char* setId = nullptr;
|
||||
const char* setPruneList = nullptr;
|
||||
const char* setId = nullptr;
|
||||
int mode = ANDROID_LOG_RDONLY;
|
||||
std::string forceFilters;
|
||||
log_device_t* devices = nullptr;
|
||||
|
|
@ -855,8 +853,11 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
// net for stability dealing with possible mistaken inputs.
|
||||
static const char delimiters[] = ",:; \t\n\r\f";
|
||||
|
||||
// danger: getopt is _not_ reentrant
|
||||
optind = 1;
|
||||
struct getopt_context optctx;
|
||||
INIT_GETOPT_CONTEXT(optctx);
|
||||
optctx.opterr = !!context->error;
|
||||
optctx.optstderr = context->error;
|
||||
|
||||
for (;;) {
|
||||
int ret;
|
||||
|
||||
|
|
@ -899,9 +900,9 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
};
|
||||
// clang-format on
|
||||
|
||||
ret = getopt_long(argc, argv,
|
||||
":cdDLt:T:gG:sQf:r:n:v:b:BSpP:m:e:", long_options,
|
||||
&option_index);
|
||||
ret = getopt_long_r(argc, argv,
|
||||
":cdDLt:T:gG:sQf:r:n:v:b:BSpP:m:e:", long_options,
|
||||
&option_index, &optctx);
|
||||
if (ret < 0) break;
|
||||
|
||||
switch (ret) {
|
||||
|
|
@ -909,9 +910,10 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
// only long options
|
||||
if (long_options[option_index].name == pid_str) {
|
||||
// ToDo: determine runtime PID_MAX?
|
||||
if (!getSizeTArg(optarg, &pid, 1)) {
|
||||
if (!getSizeTArg(optctx.optarg, &pid, 1)) {
|
||||
logcat_panic(context, HELP_TRUE, "%s %s out of range\n",
|
||||
long_options[option_index].name, optarg);
|
||||
long_options[option_index].name,
|
||||
optctx.optarg);
|
||||
goto exit;
|
||||
}
|
||||
break;
|
||||
|
|
@ -921,9 +923,11 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
ANDROID_LOG_NONBLOCK;
|
||||
// ToDo: implement API that supports setting a wrap timeout
|
||||
size_t dummy = ANDROID_LOG_WRAP_DEFAULT_TIMEOUT;
|
||||
if (optarg && !getSizeTArg(optarg, &dummy, 1)) {
|
||||
if (optctx.optarg &&
|
||||
!getSizeTArg(optctx.optarg, &dummy, 1)) {
|
||||
logcat_panic(context, HELP_TRUE, "%s %s out of range\n",
|
||||
long_options[option_index].name, optarg);
|
||||
long_options[option_index].name,
|
||||
optctx.optarg);
|
||||
goto exit;
|
||||
}
|
||||
if ((dummy != ANDROID_LOG_WRAP_DEFAULT_TIMEOUT) &&
|
||||
|
|
@ -944,7 +948,8 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
break;
|
||||
}
|
||||
if (long_options[option_index].name == id_str) {
|
||||
setId = (optarg && optarg[0]) ? optarg : nullptr;
|
||||
setId = (optctx.optarg && optctx.optarg[0]) ? optctx.optarg
|
||||
: nullptr;
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -972,12 +977,13 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
mode |= ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK;
|
||||
// FALLTHRU
|
||||
case 'T':
|
||||
if (strspn(optarg, "0123456789") != strlen(optarg)) {
|
||||
char* cp = parseTime(tail_time, optarg);
|
||||
if (strspn(optctx.optarg, "0123456789") !=
|
||||
strlen(optctx.optarg)) {
|
||||
char* cp = parseTime(tail_time, optctx.optarg);
|
||||
if (!cp) {
|
||||
logcat_panic(context, HELP_FALSE,
|
||||
"-%c \"%s\" not in time format\n", ret,
|
||||
optarg);
|
||||
optctx.optarg);
|
||||
goto exit;
|
||||
}
|
||||
if (*cp) {
|
||||
|
|
@ -987,16 +993,16 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
fprintf(
|
||||
context->error,
|
||||
"WARNING: -%c \"%s\"\"%c%s\" time truncated\n",
|
||||
ret, optarg, c, cp + 1);
|
||||
ret, optctx.optarg, c, cp + 1);
|
||||
}
|
||||
*cp = c;
|
||||
}
|
||||
} else {
|
||||
if (!getSizeTArg(optarg, &tail_lines, 1)) {
|
||||
if (!getSizeTArg(optctx.optarg, &tail_lines, 1)) {
|
||||
if (context->error) {
|
||||
fprintf(context->error,
|
||||
"WARNING: -%c %s invalid, setting to 1\n",
|
||||
ret, optarg);
|
||||
ret, optctx.optarg);
|
||||
}
|
||||
tail_lines = 1;
|
||||
}
|
||||
|
|
@ -1008,22 +1014,22 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
break;
|
||||
|
||||
case 'e':
|
||||
context->regex = new pcrecpp::RE(optarg);
|
||||
context->regex = new pcrecpp::RE(optctx.optarg);
|
||||
break;
|
||||
|
||||
case 'm': {
|
||||
char* end = nullptr;
|
||||
if (!getSizeTArg(optarg, &context->maxCount)) {
|
||||
if (!getSizeTArg(optctx.optarg, &context->maxCount)) {
|
||||
logcat_panic(context, HELP_FALSE,
|
||||
"-%c \"%s\" isn't an "
|
||||
"integer greater than zero\n",
|
||||
ret, optarg);
|
||||
ret, optctx.optarg);
|
||||
goto exit;
|
||||
}
|
||||
} break;
|
||||
|
||||
case 'g':
|
||||
if (!optarg) {
|
||||
if (!optctx.optarg) {
|
||||
getLogSize = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -1031,8 +1037,8 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
|
||||
case 'G': {
|
||||
char* cp;
|
||||
if (strtoll(optarg, &cp, 0) > 0) {
|
||||
setLogSize = strtoll(optarg, &cp, 0);
|
||||
if (strtoll(optctx.optarg, &cp, 0) > 0) {
|
||||
setLogSize = strtoll(optctx.optarg, &cp, 0);
|
||||
} else {
|
||||
setLogSize = 0;
|
||||
}
|
||||
|
|
@ -1065,42 +1071,42 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
} break;
|
||||
|
||||
case 'p':
|
||||
if (!optarg) {
|
||||
if (!optctx.optarg) {
|
||||
getPruneList = true;
|
||||
break;
|
||||
}
|
||||
// FALLTHRU
|
||||
|
||||
case 'P':
|
||||
setPruneList = optarg;
|
||||
setPruneList = optctx.optarg;
|
||||
break;
|
||||
|
||||
case 'b': {
|
||||
std::unique_ptr<char, void (*)(void*)> buffers(strdup(optarg),
|
||||
free);
|
||||
optarg = buffers.get();
|
||||
std::unique_ptr<char, void (*)(void*)> buffers(
|
||||
strdup(optctx.optarg), free);
|
||||
char* arg = buffers.get();
|
||||
unsigned idMask = 0;
|
||||
char* sv = nullptr; // protect against -ENOMEM above
|
||||
while (!!(optarg = strtok_r(optarg, delimiters, &sv))) {
|
||||
if (!strcmp(optarg, "default")) {
|
||||
while (!!(arg = strtok_r(arg, delimiters, &sv))) {
|
||||
if (!strcmp(arg, "default")) {
|
||||
idMask |= (1 << LOG_ID_MAIN) | (1 << LOG_ID_SYSTEM) |
|
||||
(1 << LOG_ID_CRASH);
|
||||
} else if (!strcmp(optarg, "all")) {
|
||||
} else if (!strcmp(arg, "all")) {
|
||||
allSelected = true;
|
||||
idMask = (unsigned)-1;
|
||||
} else {
|
||||
log_id_t log_id = android_name_to_log_id(optarg);
|
||||
log_id_t log_id = android_name_to_log_id(arg);
|
||||
const char* name = android_log_id_to_name(log_id);
|
||||
|
||||
if (!!strcmp(name, optarg)) {
|
||||
if (!!strcmp(name, arg)) {
|
||||
logcat_panic(context, HELP_TRUE,
|
||||
"unknown buffer %s\n", optarg);
|
||||
"unknown buffer %s\n", arg);
|
||||
goto exit;
|
||||
}
|
||||
if (log_id == LOG_ID_SECURITY) allSelected = false;
|
||||
idMask |= (1 << log_id);
|
||||
}
|
||||
optarg = nullptr;
|
||||
arg = nullptr;
|
||||
}
|
||||
|
||||
for (int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {
|
||||
|
|
@ -1140,47 +1146,51 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
|
||||
case 'f':
|
||||
if ((tail_time == log_time::EPOCH) && !tail_lines) {
|
||||
tail_time = lastLogTime(optarg);
|
||||
tail_time = lastLogTime(optctx.optarg);
|
||||
}
|
||||
// redirect output to a file
|
||||
context->outputFileName = optarg;
|
||||
context->outputFileName = optctx.optarg;
|
||||
break;
|
||||
|
||||
case 'r':
|
||||
if (!getSizeTArg(optarg, &context->logRotateSizeKBytes, 1)) {
|
||||
if (!getSizeTArg(optctx.optarg, &context->logRotateSizeKBytes,
|
||||
1)) {
|
||||
logcat_panic(context, HELP_TRUE,
|
||||
"Invalid parameter \"%s\" to -r\n", optarg);
|
||||
"Invalid parameter \"%s\" to -r\n",
|
||||
optctx.optarg);
|
||||
goto exit;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'n':
|
||||
if (!getSizeTArg(optarg, &context->maxRotatedLogs, 1)) {
|
||||
if (!getSizeTArg(optctx.optarg, &context->maxRotatedLogs, 1)) {
|
||||
logcat_panic(context, HELP_TRUE,
|
||||
"Invalid parameter \"%s\" to -n\n", optarg);
|
||||
"Invalid parameter \"%s\" to -n\n",
|
||||
optctx.optarg);
|
||||
goto exit;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'v': {
|
||||
if (!strcmp(optarg, "help") || !strcmp(optarg, "--help")) {
|
||||
if (!strcmp(optctx.optarg, "help") ||
|
||||
!strcmp(optctx.optarg, "--help")) {
|
||||
show_format_help(context);
|
||||
context->retval = EXIT_SUCCESS;
|
||||
goto exit;
|
||||
}
|
||||
std::unique_ptr<char, void (*)(void*)> formats(strdup(optarg),
|
||||
free);
|
||||
optarg = formats.get();
|
||||
std::unique_ptr<char, void (*)(void*)> formats(
|
||||
strdup(optctx.optarg), free);
|
||||
char* arg = formats.get();
|
||||
unsigned idMask = 0;
|
||||
char* sv = nullptr; // protect against -ENOMEM above
|
||||
while (!!(optarg = strtok_r(optarg, delimiters, &sv))) {
|
||||
err = setLogFormat(context, optarg);
|
||||
while (!!(arg = strtok_r(arg, delimiters, &sv))) {
|
||||
err = setLogFormat(context, arg);
|
||||
if (err < 0) {
|
||||
logcat_panic(context, HELP_FORMAT,
|
||||
"Invalid parameter \"%s\" to -v\n", optarg);
|
||||
"Invalid parameter \"%s\" to -v\n", arg);
|
||||
goto exit;
|
||||
}
|
||||
optarg = nullptr;
|
||||
arg = nullptr;
|
||||
if (err) hasSetLogFormat = true;
|
||||
}
|
||||
} break;
|
||||
|
|
@ -1249,12 +1259,12 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
|
||||
case ':':
|
||||
logcat_panic(context, HELP_TRUE,
|
||||
"Option -%c needs an argument\n", optopt);
|
||||
"Option -%c needs an argument\n", optctx.optopt);
|
||||
goto exit;
|
||||
|
||||
default:
|
||||
logcat_panic(context, HELP_TRUE, "Unrecognized Option %c\n",
|
||||
optopt);
|
||||
optctx.optopt);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
|
@ -1343,7 +1353,7 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
"Invalid filter expression in logcat args\n");
|
||||
goto exit;
|
||||
}
|
||||
} else if (argc == optind) {
|
||||
} else if (argc == optctx.optind) {
|
||||
// Add from environment variable
|
||||
const char* env_tags_orig = android::getenv(context, "ANDROID_LOG_TAGS");
|
||||
|
||||
|
|
@ -1359,7 +1369,7 @@ static int __logcat(android_logcat_context_internal* context) {
|
|||
}
|
||||
} else {
|
||||
// Add from commandline
|
||||
for (int i = optind ; i < argc ; i++) {
|
||||
for (int i = optctx.optind ; i < argc ; i++) {
|
||||
// skip stderr redirections of _all_ kinds
|
||||
if ((argv[i][0] == '2') && (argv[i][1] == '>')) continue;
|
||||
// skip stdout redirections of _all_ kinds
|
||||
|
|
|
|||
Loading…
Reference in New Issue