Merge tag 'android-7.1.0_r4' of... (ae1d7e2a) · Commits · e / os / android_frameworks_native

cmds/bugreportz/.clang-format

0 → 100644

+13 −0

Original line number	Diff line number	Diff line
		BasedOnStyle: Google
		AllowShortBlocksOnASingleLine: false
		AllowShortFunctionsOnASingleLine: false

		AccessModifierOffset: -2
		ColumnLimit: 100
		CommentPragmas: NOLINT:.*
		DerivePointerAlignment: false
		IndentWidth: 4
		PointerAlignment: Left
		TabWidth: 4
		UseTab: Never
		PenaltyExcessCharacter: 32

cmds/bugreportz/Android.mk

+34 −3

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)

		# bugreportz
		# ==========

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= bugreportz.cpp
		LOCAL_SRC_FILES:= \
		bugreportz.cpp \
		main.cpp \

		LOCAL_MODULE:= bugreportz

		LOCAL_CFLAGS := -Wall
		LOCAL_CFLAGS := -Werror -Wall

		LOCAL_SHARED_LIBRARIES := libcutils
		LOCAL_SHARED_LIBRARIES := \
		libbase \
		libcutils \

		include $(BUILD_EXECUTABLE)

		# bugreportz_test
		# ===============

		include $(CLEAR_VARS)

		LOCAL_MODULE := bugreportz_test
		LOCAL_MODULE_TAGS := tests

		LOCAL_CFLAGS := -Werror -Wall

		LOCAL_SRC_FILES := \
		bugreportz.cpp \
		bugreportz_test.cpp \

		LOCAL_STATIC_LIBRARIES := \
		libgmock \

		LOCAL_SHARED_LIBRARIES := \
		libbase \
		libutils \

		include $(BUILD_NATIVE_TEST)

cmds/bugreportz/bugreportz.cpp

+30 −84

Original line number	Diff line number	Diff line
		@@ -15,89 +15,38 @@
		*/

		#include <errno.h>
		#include <getopt.h>
		#include <stdio.h>
		#include <sys/socket.h>
		#include <sys/types.h>
		#include <stdlib.h>
		#include <string.h>
		#include <unistd.h>

		#include <cutils/properties.h>
		#include <cutils/sockets.h>
		#include <string>

		static constexpr char VERSION[] = "1.0";
		#include <android-base/file.h>
		#include <android-base/strings.h>

		static void show_usage() {
		fprintf(stderr,
		"usage: bugreportz [-h \| -v]\n"
		" -h: to display this help message\n"
		" -v: to display the version\n"
		" or no arguments to generate a zipped bugreport\n");
		}

		static void show_version() {
		fprintf(stderr, "%s\n", VERSION);
		}

		int main(int argc, char *argv[]) {

		if (argc > 1) {
		/* parse arguments */
		int c;
		while ((c = getopt(argc, argv, "vh")) != -1) {
		switch (c) {
		case 'h':
		show_usage();
		return EXIT_SUCCESS;
		case 'v':
		show_version();
		return EXIT_SUCCESS;
		default:
		show_usage();
		return EXIT_FAILURE;
		}
		}
		// passed an argument not starting with -
		if (optind > 1 \|\| argv[optind] != nullptr) {
		show_usage();
		return EXIT_FAILURE;
		}
		}
		#include "bugreportz.h"

		// TODO: code below was copy-and-pasted from bugreport.cpp (except by the timeout value);
		// should be reused instead.
		static constexpr char BEGIN_PREFIX[] = "BEGIN:";
		static constexpr char PROGRESS_PREFIX[] = "PROGRESS:";

		// Start the dumpstatez service.
		property_set("ctl.start", "dumpstatez");
		static void write_line(const std::string& line, bool show_progress) {
		if (line.empty()) return;

		// Socket will not be available until service starts.
		int s;
		for (int i = 0; i < 20; i++) {
		s = socket_local_client("dumpstate", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM);
		if (s >= 0)
		break;
		// Try again in 1 second.
		sleep(1);
		}
		// When not invoked with the -p option, it must skip BEGIN and PROGRESS lines otherwise it
		// will break adb (which is expecting either OK or FAIL).
		if (!show_progress && (android::base::StartsWith(line, PROGRESS_PREFIX) \|\|
		android::base::StartsWith(line, BEGIN_PREFIX)))
		return;

		if (s == -1) {
		printf("FAIL:Failed to connect to dumpstatez service: %s\n", strerror(errno));
		return EXIT_SUCCESS;
		}

		// Set a timeout so that if nothing is read in 10 minutes, we'll stop
		// reading and quit. No timeout in dumpstate is longer than 60 seconds,
		// so this gives lots of leeway in case of unforeseen time outs.
		struct timeval tv;
		tv.tv_sec = 10 * 60;
		tv.tv_usec = 0;
		if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) == -1) {
		fprintf(stderr, "WARNING: Cannot set socket timeout: %s\n", strerror(errno));
		android::base::WriteStringToFd(line, STDOUT_FILENO);
		}

		int bugreportz(int s, bool show_progress) {
		std::string line;
		while (1) {
		char buffer[65536];
		ssize_t bytes_read = TEMP_FAILURE_RETRY(
		read(s, buffer, sizeof(buffer)));
		ssize_t bytes_read = TEMP_FAILURE_RETRY(read(s, buffer, sizeof(buffer)));
		if (bytes_read == 0) {
		break;
		} else if (bytes_read == -1) {
		@@ -109,21 +58,18 @@ int main(int argc, char *argv[]) {
		break;
		}

		ssize_t bytes_to_send = bytes_read;
		ssize_t bytes_written;
		do {
		bytes_written = TEMP_FAILURE_RETRY(
		write(STDOUT_FILENO, buffer + bytes_read - bytes_to_send,
		bytes_to_send));
		if (bytes_written == -1) {
		fprintf(stderr,
		"Failed to write data to stdout: read %zd, trying to send %zd (%s)\n",
		bytes_read, bytes_to_send, strerror(errno));
		break;
		// Writes line by line.
		for (int i = 0; i < bytes_read; i++) {
		char c = buffer[i];
		line.append(1, c);
		if (c == '\n') {
		write_line(line, show_progress);
		line.clear();
		}
		}
		bytes_to_send -= bytes_written;
		} while (bytes_written != 0 && bytes_to_send > 0);
		}
		// Process final line, in case it didn't finish with newline
		write_line(line, show_progress);

		if (close(s) == -1) {
		fprintf(stderr, "WARNING: error closing socket: %s\n", strerror(errno));

cmds/bugreportz/bugreportz.h

0 → 100644

+21 −0

Original line number	Diff line number	Diff line
		// Copyright 2016 Google Inc. All Rights Reserved.
		//
		// 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 BUGREPORTZ_H
		#define BUGREPORTZ_H

		// Calls dumpstate using the given socket and output its result to stdout.
		int bugreportz(int s, bool show_progress);

		#endif // BUGREPORTZ_H

cmds/bugreportz/bugreportz_test.cpp

0 → 100644

+128 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#include <gmock/gmock.h>
		#include <gtest/gtest.h>

		#include <stdio.h>
		#include <sys/types.h>
		#include <unistd.h>

		#include <string>

		#include "bugreportz.h"

		using ::testing::StrEq;
		using ::testing::internal::CaptureStdout;
		using ::testing::internal::GetCapturedStdout;

		class BugreportzTest : public ::testing::Test {
		public:
		// Creates the pipe used to communicate with bugreportz()
		void SetUp() {
		int fds[2];
		ASSERT_EQ(0, pipe(fds));
		read_fd_ = fds[0];
		write_fd_ = fds[1];
		}

		// Closes the pipe FDs.
		// If a FD is closed manually during a test, set it to -1 to prevent TearDown() trying to close
		// it again.
		void TearDown() {
		for (int fd : {read_fd_, write_fd_}) {
		if (fd >= 0) {
		close(fd);
		}
		}
		}

		// Emulates dumpstate output by writing to the socket passed to bugreportz()
		void WriteToSocket(const std::string& data) {
		if (write_fd_ < 0) {
		ADD_FAILURE() << "cannot write '" << data << "' because socket is already closed";
		return;
		}
		int expected = data.length();
		int actual = write(write_fd_, data.data(), data.length());
		ASSERT_EQ(expected, actual) << "wrong number of bytes written to socket";
		}

		void AssertStdoutEquals(const std::string& expected) {
		ASSERT_THAT(stdout_, StrEq(expected)) << "wrong stdout output";
		}

		// Calls bugreportz() using the internal pipe.
		//
		// Tests must call WriteToSocket() to set what's written prior to calling it, since the writing
		// end of the pipe will be closed before calling bugreportz() (otherwise that function would
		// hang).
		void Bugreportz(bool show_progress) {
		close(write_fd_);
		write_fd_ = -1;

		CaptureStdout();
		int status = bugreportz(read_fd_, show_progress);

		close(read_fd_);
		read_fd_ = -1;
		stdout_ = GetCapturedStdout();

		ASSERT_EQ(0, status) << "bugrepotz() call failed (stdout: " << stdout_ << ")";
		}

		private:
		int read_fd_;
		int write_fd_;
		std::string stdout_;
		};

		// Tests 'bugreportz', without any argument - it will ignore progress lines.
		TEST_F(BugreportzTest, NoArgument) {
		WriteToSocket("BEGIN:THE IGNORED PATH WARS HAS!\n"); // Should be ommited.
		WriteToSocket("What happens on 'dumpstate',");
		WriteToSocket("stays on 'bugreportz'.\n");
		WriteToSocket("PROGRESS:Y U NO OMITTED?\n"); // Should be ommited.
		WriteToSocket("But ");
		WriteToSocket("PROGRESS IN THE MIDDLE"); // Ok - not starting a line.
		WriteToSocket(" is accepted\n");

		Bugreportz(false);

		AssertStdoutEquals(
		"What happens on 'dumpstate',stays on 'bugreportz'.\n"
		"But PROGRESS IN THE MIDDLE is accepted\n");
		}

		// Tests 'bugreportz -p' - it will just echo dumpstate's output to stdout
		TEST_F(BugreportzTest, WithProgress) {
		WriteToSocket("BEGIN:I AM YOUR PATH\n");
		WriteToSocket("What happens on 'dumpstate',");
		WriteToSocket("stays on 'bugreportz'.\n");
		WriteToSocket("PROGRESS:IS INEVITABLE\n");
		WriteToSocket("PROG");
		WriteToSocket("RESS:IS NOT AUTOMATIC\n");
		WriteToSocket("Newline is optional");

		Bugreportz(true);

		AssertStdoutEquals(
		"BEGIN:I AM YOUR PATH\n"
		"What happens on 'dumpstate',stays on 'bugreportz'.\n"
		"PROGRESS:IS INEVITABLE\n"
		"PROGRESS:IS NOT AUTOMATIC\n"
		"Newline is optional");
		}