Merge "Minor cleanups."
diff --git a/adb/services.c b/adb/services.c
index f0d5878..951048e 100644
--- a/adb/services.c
+++ b/adb/services.c
@@ -144,7 +144,11 @@
if (ret < 0) {
snprintf(buf, sizeof(buf), "reboot failed: %d\n", ret);
writex(fd, buf, strlen(buf));
+ goto cleanup;
}
+ // Don't return early. Give the reboot command time to take effect
+ // to avoid messing up scripts which do "adb reboot && adb wait-for-device"
+ while(1) { pause(); }
cleanup:
free(arg);
adb_close(fd);
diff --git a/adf/Android.mk b/adf/Android.mk
new file mode 100644
index 0000000..64d486e
--- /dev/null
+++ b/adf/Android.mk
@@ -0,0 +1,18 @@
+#
+# Copyright (C) 2013 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.
+#
+LOCAL_PATH := $(my-dir)
+
+include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/adf/libadf/Android.mk b/adf/libadf/Android.mk
new file mode 100644
index 0000000..908aa6c
--- /dev/null
+++ b/adf/libadf/Android.mk
@@ -0,0 +1,23 @@
+# Copyright (C) 2013 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := adf.c
+LOCAL_MODULE := libadf
+LOCAL_MODULE_TAGS := optional
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
+LOCAL_C_INCLUDES += $(LOCAL_EXPORT_C_INCLUDE_DIRS)
+include $(BUILD_STATIC_LIBRARY)
diff --git a/adf/libadf/adf.c b/adf/libadf/adf.c
new file mode 100644
index 0000000..871629e
--- /dev/null
+++ b/adf/libadf/adf.c
@@ -0,0 +1,810 @@
+/*
+ * Copyright (C) 2013 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 <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <linux/limits.h>
+
+#include <sys/ioctl.h>
+
+#include <adf/adf.h>
+
+#define ADF_BASE_PATH "/dev/"
+
+static ssize_t adf_find_nodes(const char *pattern, adf_id_t **ids)
+{
+ DIR *dir;
+ struct dirent *dirent;
+ size_t n = 0;
+ ssize_t ret;
+ adf_id_t *ids_ret = NULL;
+
+ dir = opendir(ADF_BASE_PATH);
+ if (!dir)
+ return -errno;
+
+ errno = 0;
+ while ((dirent = readdir(dir))) {
+ adf_id_t id;
+ int matched = sscanf(dirent->d_name, pattern, &id);
+
+ if (matched < 0) {
+ ret = -errno;
+ goto done;
+ } else if (matched != 1) {
+ continue;
+ }
+
+ adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
+ if (!new_ids) {
+ ret = -ENOMEM;
+ goto done;
+ }
+
+ ids_ret = new_ids;
+ ids_ret[n] = id;
+ n++;
+ }
+ if (errno)
+ ret = -errno;
+ else
+ ret = n;
+
+done:
+ closedir(dir);
+ if (ret < 0)
+ free(ids_ret);
+ else
+ *ids = ids_ret;
+ return ret;
+}
+
+ssize_t adf_devices(adf_id_t **ids)
+{
+ return adf_find_nodes("adf%u", ids);
+}
+
+int adf_device_open(adf_id_t id, int flags, struct adf_device *dev)
+{
+ char filename[64];
+ int err;
+
+ dev->id = id;
+
+ snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf%u", id);
+ dev->fd = open(filename, flags);
+ if (dev->fd < 0)
+ return -errno;
+
+ return 0;
+}
+
+void adf_device_close(struct adf_device *dev)
+{
+ if (dev->fd >= 0)
+ close(dev->fd);
+}
+
+int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data)
+{
+ int err;
+ int ret = 0;
+
+ memset(data, 0, sizeof(*data));
+
+ err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
+ if (err < 0)
+ return -ENOMEM;
+
+ if (data->n_attachments) {
+ data->attachments = malloc(sizeof(data->attachments[0]) *
+ data->n_attachments);
+ if (!data->attachments)
+ return -ENOMEM;
+ }
+
+ if (data->n_allowed_attachments) {
+ data->allowed_attachments =
+ malloc(sizeof(data->allowed_attachments[0]) *
+ data->n_allowed_attachments);
+ if (!data->allowed_attachments) {
+ ret = -ENOMEM;
+ goto done;
+ }
+ }
+
+ if (data->custom_data_size) {
+ data->custom_data = malloc(data->custom_data_size);
+ if (!data->custom_data) {
+ ret = -ENOMEM;
+ goto done;
+ }
+ }
+
+ err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
+ if (err < 0)
+ ret = -errno;
+
+done:
+ if (ret < 0)
+ adf_free_device_data(data);
+ return ret;
+}
+
+void adf_free_device_data(struct adf_device_data *data)
+{
+ free(data->attachments);
+ free(data->allowed_attachments);
+ free(data->custom_data);
+}
+
+int adf_device_post(struct adf_device *dev,
+ adf_id_t *interfaces, size_t n_interfaces,
+ struct adf_buffer_config *bufs, size_t n_bufs,
+ void *custom_data, size_t custom_data_size)
+{
+ int err;
+ struct adf_post_config data;
+
+ memset(&data, 0, sizeof(data));
+ data.interfaces = interfaces;
+ data.n_interfaces = n_interfaces;
+ data.bufs = bufs;
+ data.n_bufs = n_bufs;
+ data.custom_data = custom_data;
+ data.custom_data_size = custom_data_size;
+
+ err = ioctl(dev->fd, ADF_POST_CONFIG, &data);
+ if (err < 0)
+ return -errno;
+
+ return (int)data.complete_fence;
+}
+
+static int adf_device_attachment(struct adf_device *dev,
+ adf_id_t overlay_engine, adf_id_t interface, bool attach)
+{
+ int err;
+ struct adf_attachment_config data;
+
+ memset(&data, 0, sizeof(data));
+ data.overlay_engine = overlay_engine;
+ data.interface = interface;
+
+ err = ioctl(dev->fd, attach ? ADF_ATTACH : ADF_DETACH, &data);
+ if (err < 0)
+ return -errno;
+
+ return 0;
+}
+
+int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine,
+ adf_id_t interface)
+{
+ return adf_device_attachment(dev, overlay_engine, interface, true);
+}
+
+int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine,
+ adf_id_t interface)
+{
+ return adf_device_attachment(dev, overlay_engine, interface, false);
+}
+
+ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces)
+{
+ char pattern[64];
+
+ snprintf(pattern, sizeof(pattern), "adf-interface%u.%%u", dev->id);
+ return adf_find_nodes(pattern, interfaces);
+}
+
+ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev,
+ adf_id_t overlay_engine, adf_id_t **interfaces)
+{
+ struct adf_device_data data;
+ ssize_t n = 0;
+ ssize_t ret;
+ adf_id_t *ids_ret = NULL;
+
+ ret = adf_get_device_data(dev, &data);
+ if (ret < 0)
+ return ret;
+
+ size_t i;
+ for (i = 0; i < data.n_allowed_attachments; i++) {
+ if (data.allowed_attachments[i].overlay_engine != overlay_engine)
+ continue;
+
+ adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
+ if (!new_ids) {
+ ret = -ENOMEM;
+ goto done;
+ }
+
+ ids_ret = new_ids;
+ ids_ret[n] = data.allowed_attachments[i].interface;
+ n++;
+ }
+
+ ret = n;
+
+done:
+ adf_free_device_data(&data);
+ if (ret < 0)
+ free(ids_ret);
+ else
+ *interfaces = ids_ret;
+ return ret;
+}
+
+static ssize_t adf_interfaces_filter(struct adf_device *dev,
+ adf_id_t *in, size_t n_in, adf_id_t **out,
+ bool (*filter)(struct adf_interface_data *data, __u32 match),
+ __u32 match)
+{
+ size_t n = 0;
+ ssize_t ret;
+ adf_id_t *ids_ret = NULL;
+
+ size_t i;
+ for (i = 0; i < n_in; i++) {
+ int fd = adf_interface_open(dev, in[i], O_RDONLY);
+ if (fd < 0) {
+ ret = fd;
+ goto done;
+ }
+
+ struct adf_interface_data data;
+ ret = adf_get_interface_data(fd, &data);
+ close(fd);
+ if (ret < 0)
+ goto done;
+
+ if (!filter(&data, match))
+ continue;
+
+ adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
+ if (!new_ids) {
+ ret = -ENOMEM;
+ goto done;
+ }
+
+ ids_ret = new_ids;
+ ids_ret[n] = in[i];
+ n++;
+ }
+
+ ret = n;
+
+done:
+ if (ret < 0)
+ free(ids_ret);
+ else
+ *out = ids_ret;
+ return ret;
+}
+
+static bool adf_interface_type_filter(struct adf_interface_data *data,
+ __u32 type)
+{
+ return data->type == (enum adf_interface_type)type;
+}
+
+ssize_t adf_interfaces_filter_by_type(struct adf_device *dev,
+ enum adf_interface_type type,
+ adf_id_t *in, size_t n_in, adf_id_t **out)
+{
+ return adf_interfaces_filter(dev, in, n_in, out, adf_interface_type_filter,
+ type);
+}
+
+static bool adf_interface_flags_filter(struct adf_interface_data *data,
+ __u32 flag)
+{
+ return !!(data->flags & flag);
+}
+
+ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag,
+ adf_id_t *in, size_t n_in, adf_id_t **out)
+{
+ return adf_interfaces_filter(dev, in, n_in, out, adf_interface_flags_filter,
+ flag);
+}
+
+int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags)
+{
+ char filename[64];
+
+ snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf-interface%u.%u",
+ dev->id, id);
+
+ int fd = open(filename, flags);
+ if (fd < 0)
+ return -errno;
+ return fd;
+}
+
+int adf_get_interface_data(int fd, struct adf_interface_data *data)
+{
+ int err;
+ int ret = 0;
+
+ memset(data, 0, sizeof(*data));
+
+ err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
+ if (err < 0)
+ return -errno;
+
+ if (data->n_available_modes) {
+ data->available_modes = malloc(sizeof(data->available_modes[0]) *
+ data->n_available_modes);
+ if (!data->available_modes)
+ return -ENOMEM;
+ }
+
+ if (data->custom_data_size) {
+ data->custom_data = malloc(data->custom_data_size);
+ if (!data->custom_data) {
+ ret = -ENOMEM;
+ goto done;
+ }
+ }
+
+ err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
+ if (err < 0)
+ ret = -errno;
+
+done:
+ if (ret < 0)
+ adf_free_interface_data(data);
+ return ret;
+}
+
+void adf_free_interface_data(struct adf_interface_data *data)
+{
+ free(data->available_modes);
+ free(data->custom_data);
+}
+
+int adf_interface_blank(int fd, __u8 mode)
+{
+ int err = ioctl(fd, ADF_BLANK, mode);
+ if (err < 0)
+ return -errno;
+ return 0;
+}
+
+int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode)
+{
+ int err = ioctl(fd, ADF_SET_MODE, mode);
+ if (err < 0)
+ return -errno;
+ return 0;
+}
+
+int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h,
+ __u32 format, __u32 *offset, __u32 *pitch)
+{
+ int err;
+ struct adf_simple_buffer_alloc data;
+
+ memset(&data, 0, sizeof(data));
+ data.w = w;
+ data.h = h;
+ data.format = format;
+
+ err = ioctl(fd, ADF_SIMPLE_BUFFER_ALLOC, &data);
+ if (err < 0)
+ return -errno;
+
+ *offset = data.offset;
+ *pitch = data.pitch;
+ return (int)data.fd;
+}
+
+int adf_interface_simple_post(int fd, __u32 overlay_engine,
+ __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
+ __u32 pitch, int acquire_fence)
+{
+ int ret;
+ struct adf_simple_post_config data;
+
+ memset(&data, 0, sizeof(data));
+ data.buf.overlay_engine = overlay_engine;
+ data.buf.w = w;
+ data.buf.h = h;
+ data.buf.format = format;
+ data.buf.fd[0] = buf_fd;
+ data.buf.offset[0] = offset;
+ data.buf.pitch[0] = pitch;
+ data.buf.n_planes = 1;
+ data.buf.acquire_fence = acquire_fence;
+
+ ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG, &data);
+ if (ret < 0)
+ return -errno;
+
+ return (int)data.complete_fence;
+}
+
+ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines)
+{
+ char pattern[64];
+
+ snprintf(pattern, sizeof(pattern), "adf-overlay-engine%u.%%u", dev->id);
+ return adf_find_nodes(pattern, overlay_engines);
+}
+
+ssize_t adf_overlay_engines_for_interface(struct adf_device *dev,
+ adf_id_t interface, adf_id_t **overlay_engines)
+{
+ struct adf_device_data data;
+ ssize_t n = 0;
+ ssize_t ret;
+ adf_id_t *ids_ret = NULL;
+
+ ret = adf_get_device_data(dev, &data);
+ if (ret < 0)
+ return ret;
+
+ size_t i;
+ for (i = 0; i < data.n_allowed_attachments; i++) {
+ if (data.allowed_attachments[i].interface != interface)
+ continue;
+
+ adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
+ if (!new_ids) {
+ ret = -ENOMEM;
+ goto done;
+ }
+
+ ids_ret = new_ids;
+ ids_ret[n] = data.allowed_attachments[i].overlay_engine;
+ n++;
+ }
+
+ ret = n;
+
+done:
+ adf_free_device_data(&data);
+ if (ret < 0)
+ free(ids_ret);
+ else
+ *overlay_engines = ids_ret;
+ return ret;
+}
+
+static ssize_t adf_overlay_engines_filter(struct adf_device *dev,
+ adf_id_t *in, size_t n_in, adf_id_t **out,
+ bool (*filter)(struct adf_overlay_engine_data *data, void *cookie),
+ void *cookie)
+{
+ size_t n = 0;
+ ssize_t ret;
+ adf_id_t *ids_ret = NULL;
+
+ size_t i;
+ for (i = 0; i < n_in; i++) {
+ int fd = adf_overlay_engine_open(dev, in[i], O_RDONLY);
+ if (fd < 0) {
+ ret = fd;
+ goto done;
+ }
+
+ struct adf_overlay_engine_data data;
+ ret = adf_get_overlay_engine_data(fd, &data);
+ close(fd);
+ if (ret < 0)
+ goto done;
+
+ if (!filter(&data, cookie))
+ continue;
+
+ adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0]));
+ if (!new_ids) {
+ ret = -ENOMEM;
+ goto done;
+ }
+
+ ids_ret = new_ids;
+ ids_ret[n] = in[i];
+ n++;
+ }
+
+ ret = n;
+
+done:
+ if (ret < 0)
+ free(ids_ret);
+ else
+ *out = ids_ret;
+ return ret;
+}
+
+struct format_filter_cookie {
+ const __u32 *formats;
+ size_t n_formats;
+};
+
+static bool adf_overlay_engine_format_filter(
+ struct adf_overlay_engine_data *data, void *cookie)
+{
+ struct format_filter_cookie *c = cookie;
+ size_t i;
+ for (i = 0; i < data->n_supported_formats; i++) {
+ size_t j;
+ for (j = 0; j < c->n_formats; j++)
+ if (data->supported_formats[i] == c->formats[j])
+ return true;
+ }
+ return false;
+}
+
+ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev,
+ const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in,
+ adf_id_t **out)
+{
+ struct format_filter_cookie cookie = { formats, n_formats };
+ return adf_overlay_engines_filter(dev, in, n_in, out,
+ adf_overlay_engine_format_filter, &cookie);
+}
+
+int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags)
+{
+ char filename[64];
+
+ snprintf(filename, sizeof(filename),
+ ADF_BASE_PATH "adf-overlay-engine%u.%u", dev->id, id);
+
+ int fd = open(filename, flags);
+ if (fd < 0)
+ return -errno;
+ return fd;
+}
+
+int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data)
+{
+ int err;
+ int ret = 0;
+
+ memset(data, 0, sizeof(*data));
+
+ err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
+ if (err < 0)
+ return -errno;
+
+ if (data->n_supported_formats) {
+ data->supported_formats = malloc(sizeof(data->supported_formats[0]) *
+ data->n_supported_formats);
+ if (!data->supported_formats)
+ return -ENOMEM;
+ }
+
+ if (data->custom_data_size) {
+ data->custom_data = malloc(data->custom_data_size);
+ if (!data->custom_data) {
+ ret = -ENOMEM;
+ goto done;
+ }
+ }
+
+ err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
+ if (err < 0)
+ ret = -errno;
+
+done:
+ if (ret < 0)
+ adf_free_overlay_engine_data(data);
+ return ret;
+}
+
+void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data)
+{
+ free(data->supported_formats);
+ free(data->custom_data);
+}
+
+bool adf_overlay_engine_supports_format(int fd, __u32 format)
+{
+ struct adf_overlay_engine_data data;
+ bool ret = false;
+ size_t i;
+
+ int err = adf_get_overlay_engine_data(fd, &data);
+ if (err < 0)
+ return false;
+
+ for (i = 0; i < data.n_supported_formats; i++) {
+ if (data.supported_formats[i] == format) {
+ ret = true;
+ break;
+ }
+ }
+
+ adf_free_overlay_engine_data(&data);
+ return ret;
+}
+
+int adf_set_event(int fd, enum adf_event_type type, bool enabled)
+{
+ struct adf_set_event data;
+
+ data.type = type;
+ data.enabled = enabled;
+
+ int err = ioctl(fd, ADF_SET_EVENT, &data);
+ if (err < 0)
+ return -errno;
+ return 0;
+}
+
+int adf_read_event(int fd, struct adf_event **event)
+{
+ struct adf_event header;
+ struct {
+ struct adf_event base;
+ uint8_t data[0];
+ } *event_ret;
+ size_t data_size;
+ int ret = 0;
+
+ int err = read(fd, &header, sizeof(header));
+ if (err < 0)
+ return -errno;
+ if ((size_t)err < sizeof(header))
+ return -EIO;
+ if (header.length < sizeof(header))
+ return -EIO;
+
+ event_ret = malloc(header.length);
+ if (!event_ret)
+ return -ENOMEM;
+ data_size = header.length - sizeof(header);
+
+ memcpy(event_ret, &header, sizeof(header));
+ ssize_t read_size = read(fd, &event_ret->data, data_size);
+ if (read_size < 0) {
+ ret = -errno;
+ goto done;
+ }
+ if ((size_t)read_size < data_size) {
+ ret = -EIO;
+ goto done;
+ }
+
+ *event = &event_ret->base;
+
+done:
+ if (ret < 0)
+ free(event_ret);
+ return ret;
+}
+
+void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE])
+{
+ buf[0] = format & 0xFF;
+ buf[1] = (format >> 8) & 0xFF;
+ buf[2] = (format >> 16) & 0xFF;
+ buf[3] = (format >> 24) & 0xFF;
+ buf[4] = '\0';
+}
+
+static bool adf_find_simple_post_overlay_engine(struct adf_device *dev,
+ const __u32 *formats, size_t n_formats,
+ adf_id_t interface, adf_id_t *overlay_engine)
+{
+ adf_id_t *engs;
+ ssize_t n_engs = adf_overlay_engines_for_interface(dev, interface, &engs);
+
+ if (n_engs <= 0)
+ return false;
+
+ adf_id_t *filtered_engs;
+ ssize_t n_filtered_engs = adf_overlay_engines_filter_by_format(dev,
+ formats, n_formats, engs, n_engs, &filtered_engs);
+ free(engs);
+
+ if (n_filtered_engs <= 0)
+ return false;
+
+ *overlay_engine = filtered_engs[0];
+ free(filtered_engs);
+ return true;
+}
+
+static const __u32 any_rgb_format[] = {
+ DRM_FORMAT_C8,
+ DRM_FORMAT_RGB332,
+ DRM_FORMAT_BGR233,
+ DRM_FORMAT_XRGB1555,
+ DRM_FORMAT_XBGR1555,
+ DRM_FORMAT_RGBX5551,
+ DRM_FORMAT_BGRX5551,
+ DRM_FORMAT_ARGB1555,
+ DRM_FORMAT_ABGR1555,
+ DRM_FORMAT_RGBA5551,
+ DRM_FORMAT_BGRA5551,
+ DRM_FORMAT_RGB565,
+ DRM_FORMAT_BGR565,
+ DRM_FORMAT_RGB888,
+ DRM_FORMAT_BGR888,
+ DRM_FORMAT_XRGB8888,
+ DRM_FORMAT_XBGR8888,
+ DRM_FORMAT_RGBX8888,
+ DRM_FORMAT_BGRX8888,
+ DRM_FORMAT_XRGB2101010,
+ DRM_FORMAT_XBGR2101010,
+ DRM_FORMAT_RGBX1010102,
+ DRM_FORMAT_BGRX1010102,
+ DRM_FORMAT_ARGB2101010,
+ DRM_FORMAT_ABGR2101010,
+ DRM_FORMAT_RGBA1010102,
+ DRM_FORMAT_BGRA1010102,
+ DRM_FORMAT_ARGB8888,
+ DRM_FORMAT_ABGR8888,
+ DRM_FORMAT_RGBA8888,
+ DRM_FORMAT_BGRA8888,
+};
+
+int adf_find_simple_post_configuration(struct adf_device *dev,
+ const __u32 *formats, size_t n_formats,
+ adf_id_t *interface, adf_id_t *overlay_engine)
+{
+ adf_id_t *intfs;
+ ssize_t n_intfs = adf_interfaces(dev, &intfs);
+
+ if (n_intfs < 0)
+ return n_intfs;
+ else if (!n_intfs)
+ return -ENODEV;
+
+ adf_id_t *primary_intfs;
+ ssize_t n_primary_intfs = adf_interfaces_filter_by_flag(dev,
+ ADF_INTF_FLAG_PRIMARY, intfs, n_intfs, &primary_intfs);
+ free(intfs);
+
+ if (n_primary_intfs < 0)
+ return n_primary_intfs;
+ else if (!n_primary_intfs)
+ return -ENODEV;
+
+ if (!formats) {
+ formats = any_rgb_format;
+ n_formats = sizeof(any_rgb_format) / sizeof(any_rgb_format[0]);
+ }
+
+ bool found = false;
+ ssize_t i = 0;
+ for (i = 0; i < n_primary_intfs; i++) {
+ found = adf_find_simple_post_overlay_engine(dev, formats, n_formats,
+ primary_intfs[i], overlay_engine);
+ if (found) {
+ *interface = primary_intfs[i];
+ break;
+ }
+ }
+ free(primary_intfs);
+
+ if (!found)
+ return -ENODEV;
+
+ return 0;
+}
diff --git a/adf/libadf/include/adf/adf.h b/adf/libadf/include/adf/adf.h
new file mode 100644
index 0000000..b6bda34
--- /dev/null
+++ b/adf/libadf/include/adf/adf.h
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2013 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 _LIBADF_ADF_H_
+#define _LIBADF_ADF_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <video/adf.h>
+
+typedef __u32 adf_id_t;
+
+struct adf_device {
+ adf_id_t id;
+ int fd;
+};
+
+__BEGIN_DECLS
+
+/**
+ * Enumerates all ADF devices.
+ *
+ * Returns the number of ADF devices, and sets ids to a list of device IDs.
+ * The caller must free() the returned list of device IDs.
+ *
+ * On error, returns -errno.
+ */
+ssize_t adf_devices(adf_id_t **ids);
+
+/**
+ * Opens an ADF device.
+ *
+ * On error, returns -errno.
+ */
+int adf_device_open(adf_id_t id, int flags, struct adf_device *dev);
+/**
+ * Closes an ADF device.
+ */
+void adf_device_close(struct adf_device *dev);
+/**
+ * Reads the ADF device data.
+ *
+ * adf_get_device_data() allocates buffers inside data, which the caller
+ * must free by calling adf_free_device_data(). On error, returns -errno.
+ */
+int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data);
+/**
+ * Frees the device data returned by adf_get_device_data().
+ */
+void adf_free_device_data(struct adf_device_data *data);
+
+/**
+ * Atomically posts a new display configuration to the specified interfaces.
+ *
+ * Returns a sync fence fd that will fire when the configuration is removed
+ * from the screen. On error, returns -errno.
+ */
+int adf_device_post(struct adf_device *dev,
+ adf_id_t *interfaces, size_t n_interfaces,
+ struct adf_buffer_config *bufs, size_t n_bufs,
+ void *custom_data, size_t custom_data_size);
+/**
+ * Attaches the specified interface and overlay engine.
+ */
+int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine,
+ adf_id_t interface);
+/**
+ * Detaches the specified interface and overlay engine.
+ */
+int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine,
+ adf_id_t interface);
+
+/**
+ * Enumerates all interfaces belonging to an ADF device.
+ *
+ * The caller must free() the returned list of interface IDs.
+ */
+ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces);
+
+/**
+ * Enumerates all interfaces which can be attached to the specified overlay
+ * engine.
+ *
+ * The caller must free() the returned list of interface IDs.
+ */
+ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev,
+ adf_id_t overlay_engine, adf_id_t **interfaces);
+/**
+ * Filters a list of interfaces by type.
+ *
+ * Returns the number of matching interfaces, and sets out to a list of matching
+ * interface IDs. The caller must free() the returned list of interface IDs.
+ *
+ * On error, returns -errno.
+ */
+ssize_t adf_interfaces_filter_by_type(struct adf_device *dev,
+ enum adf_interface_type type,
+ adf_id_t *in, size_t n_in, adf_id_t **out);
+/**
+ * Filters a list of interfaces by flag.
+ *
+ * The caller must free() the returned list of interface IDs.
+ */
+ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag,
+ adf_id_t *in, size_t n_in, adf_id_t **out);
+
+/**
+ * Opens an ADF interface.
+ *
+ * Returns a file descriptor. The caller must close() the fd when done.
+ * On error, returns -errno.
+ */
+int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags);
+/**
+ * Reads the interface data.
+ *
+ * adf_get_interface_data() allocates buffers inside data, which the caller
+ * must free by calling adf_free_interface_data(). On error, returns -errno.
+ */
+int adf_get_interface_data(int fd, struct adf_interface_data *data);
+/**
+ * Frees the interface data returned by adf_get_interface_data().
+ */
+void adf_free_interface_data(struct adf_interface_data *data);
+
+/**
+ * Sets the interface's DPMS mode.
+ */
+int adf_interface_blank(int fd, __u8 mode);
+/**
+ * Sets the interface's display mode.
+ */
+int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode);
+/**
+ * Allocates a single-plane RGB buffer of the specified size and format.
+ *
+ * Returns a dma-buf fd. On error, returns -errno.
+ */
+int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h,
+ __u32 format, __u32 *offset, __u32 *pitch);
+/**
+ * Posts a single-plane RGB buffer to the display using the specified
+ * overlay engine.
+ *
+ * Returns a sync fence fd that will fire when the buffer is removed
+ * from the screen. On error, returns -errno.
+ */
+int adf_interface_simple_post(int fd, adf_id_t overlay_engine,
+ __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset,
+ __u32 pitch, int acquire_fence);
+
+/**
+ * Enumerates all overlay engines belonging to an ADF device.
+ *
+ * The caller must free() the returned list of overlay engine IDs.
+ */
+ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines);
+
+/**
+ * Enumerates all overlay engines which can be attached to the specified
+ * interface.
+ *
+ * The caller must free() the returned list of overlay engine IDs.
+ */
+ssize_t adf_overlay_engines_for_interface(struct adf_device *dev,
+ adf_id_t interface, adf_id_t **overlay_engines);
+/**
+ * Filters a list of overlay engines by supported buffer format.
+ *
+ * Returns the overlay engines which support at least one of the specified
+ * formats. The caller must free() the returned list of overlay engine IDs.
+ */
+ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev,
+ const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in,
+ adf_id_t **out);
+
+/**
+ * Opens an ADF overlay engine.
+ *
+ * Returns a file descriptor. The caller must close() the fd when done.
+ * On error, returns -errno.
+ */
+int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags);
+/**
+ * Reads the overlay engine data.
+ *
+ * adf_get_overlay_engine_data() allocates buffers inside data, which the caller
+ * must free by calling adf_free_overlay_engine_data(). On error, returns
+ * -errno.
+ */
+int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data);
+/**
+ * Frees the overlay engine data returned by adf_get_overlay_engine_data().
+ */
+void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data);
+
+/**
+ * Returns whether the overlay engine supports the specified format.
+ */
+bool adf_overlay_engine_supports_format(int fd, __u32 format);
+
+/**
+ * Subscribes or unsubscribes from the specified hardware event.
+ */
+int adf_set_event(int fd, enum adf_event_type type, bool enabled);
+/**
+ * Reads one event from the fd, blocking if needed.
+ *
+ * The caller must free() the returned buffer. On error, returns -errno.
+ */
+int adf_read_event(int fd, struct adf_event **event);
+
+#define ADF_FORMAT_STR_SIZE 5
+/**
+ * Converts an ADF/DRM fourcc format to its string representation.
+ */
+void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE]);
+
+/**
+ * Finds an appropriate interface and overlay engine for a simple post.
+ *
+ * Specifically, finds the primary interface, and an overlay engine
+ * that can be attached to the primary interface and supports one of the
+ * specified formats. The caller may pass a NULL formats list, to indicate that
+ * any RGB format is acceptable.
+ *
+ * On error, returns -errno.
+ */
+int adf_find_simple_post_configuration(struct adf_device *dev,
+ const __u32 *formats, size_t n_formats,
+ adf_id_t *interface, adf_id_t *overlay_engine);
+
+__END_DECLS
+
+#endif /* _LIBADF_ADF_H_ */
diff --git a/adf/libadfhwc/Android.mk b/adf/libadfhwc/Android.mk
new file mode 100644
index 0000000..acea322
--- /dev/null
+++ b/adf/libadfhwc/Android.mk
@@ -0,0 +1,25 @@
+# Copyright (C) 2013 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := adfhwc.cpp
+LOCAL_MODULE := libadfhwc
+LOCAL_MODULE_TAGS := optional
+LOCAL_STATIC_LIBRARIES := libadf liblog libutils
+LOCAL_CFLAGS += -DLOG_TAG=\"adfhwc\"
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
+LOCAL_C_INCLUDES += $(LOCAL_EXPORT_C_INCLUDE_DIRS)
+include $(BUILD_STATIC_LIBRARY)
diff --git a/adf/libadfhwc/adfhwc.cpp b/adf/libadfhwc/adfhwc.cpp
new file mode 100644
index 0000000..dee3cae
--- /dev/null
+++ b/adf/libadfhwc/adfhwc.cpp
@@ -0,0 +1,293 @@
+/*
+ * Copyright (C) 2013 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 <fcntl.h>
+#include <poll.h>
+#include <pthread.h>
+#include <sys/resource.h>
+
+#include <adf/adf.h>
+#include <adfhwc/adfhwc.h>
+
+#include <cutils/log.h>
+#include <utils/Vector.h>
+
+struct adf_hwc_helper {
+ adf_hwc_event_callbacks const *event_cb;
+ void *event_cb_data;
+
+ pthread_t event_thread;
+
+ android::Vector<int> intf_fds;
+ android::Vector<drm_mode_modeinfo> display_configs;
+};
+
+template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
+
+int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event,
+ int enabled)
+{
+ if (enabled != !!enabled)
+ return -EINVAL;
+
+ if ((size_t)disp >= dev->intf_fds.size())
+ return -EINVAL;
+
+ switch (event) {
+ case HWC_EVENT_VSYNC:
+ return adf_set_event(dev->intf_fds[disp], ADF_EVENT_VSYNC, enabled);
+ }
+
+ return -EINVAL;
+}
+
+static inline int32_t dpi(uint16_t res, uint16_t size_mm)
+{
+ if (size_mm)
+ return 1000 * (res * 25.4f) / size_mm;
+ return 0;
+}
+
+int adf_blank(struct adf_hwc_helper *dev, int disp, int blank)
+{
+ if ((size_t)disp >= dev->intf_fds.size())
+ return -EINVAL;
+
+ uint8_t dpms_mode = blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON;
+ return adf_interface_blank(dev->intf_fds[disp], dpms_mode);
+}
+
+int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value)
+{
+ *value = 0;
+ if (dev->intf_fds.size() > 0)
+ *value |= HWC_DISPLAY_PRIMARY_BIT;
+ if (dev->intf_fds.size() > 1)
+ *value |= HWC_DISPLAY_EXTERNAL_BIT;
+
+ return 0;
+}
+
+int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp,
+ uint32_t *configs, size_t *numConfigs)
+{
+ if ((size_t)disp >= dev->intf_fds.size())
+ return -EINVAL;
+
+ adf_interface_data data;
+ int err = adf_get_interface_data(dev->intf_fds[disp], &data);
+ if (err < 0) {
+ ALOGE("failed to get ADF interface data: %s", strerror(err));
+ return err;
+ }
+
+ if (!data.hotplug_detect)
+ return -ENODEV;
+
+ android::Vector<drm_mode_modeinfo *> unique_configs;
+ unique_configs.push_back(&data.current_mode);
+ for (size_t i = 0; i < data.n_available_modes; i++)
+ if (memcmp(&data.available_modes[i], &data.current_mode,
+ sizeof(data.current_mode)))
+ unique_configs.push_back(&data.available_modes[i]);
+
+ for (size_t i = 0; i < min(*numConfigs, unique_configs.size()); i++) {
+ configs[i] = dev->display_configs.size();
+ dev->display_configs.push_back(*unique_configs[i]);
+ }
+ *numConfigs = unique_configs.size();
+
+ adf_free_interface_data(&data);
+ return 0;
+}
+
+static int32_t adf_display_attribute(const adf_interface_data &data,
+ const drm_mode_modeinfo &mode, const uint32_t attribute)
+{
+ switch (attribute) {
+ case HWC_DISPLAY_VSYNC_PERIOD:
+ if (mode.vrefresh)
+ return 1000000000 / mode.vrefresh;
+ return 0;
+
+ case HWC_DISPLAY_WIDTH:
+ return mode.hdisplay;
+
+ case HWC_DISPLAY_HEIGHT:
+ return mode.vdisplay;
+
+ case HWC_DISPLAY_DPI_X:
+ return dpi(mode.hdisplay, data.width_mm);
+
+ case HWC_DISPLAY_DPI_Y:
+ return dpi(mode.vdisplay, data.height_mm);
+
+ default:
+ ALOGE("unknown display attribute %u", attribute);
+ return -EINVAL;
+ }
+}
+
+int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp,
+ uint32_t config, const uint32_t *attributes, int32_t *values)
+{
+ if ((size_t)disp >= dev->intf_fds.size())
+ return -EINVAL;
+
+ if (config >= dev->display_configs.size())
+ return -EINVAL;
+
+ adf_interface_data data;
+ int err = adf_get_interface_data(dev->intf_fds[disp], &data);
+ if (err < 0) {
+ ALOGE("failed to get ADF interface data: %s", strerror(err));
+ return err;
+ }
+
+ for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++)
+ values[i] = adf_display_attribute(data, dev->display_configs[config],
+ attributes[i]);
+
+ adf_free_interface_data(&data);
+ return 0;
+}
+
+static void handle_adf_event(struct adf_hwc_helper *dev, int disp)
+{
+ adf_event *event;
+ int err = adf_read_event(dev->intf_fds[disp], &event);
+ if (err < 0) {
+ ALOGE("error reading event from display %d: %s", disp, strerror(err));
+ return;
+ }
+
+ void *vsync_temp;
+ adf_vsync_event *vsync;
+ adf_hotplug_event *hotplug;
+
+ switch (event->type) {
+ case ADF_EVENT_VSYNC:
+ vsync_temp = event;
+ vsync = static_cast<adf_vsync_event *>(vsync_temp);
+ // casting directly to adf_vsync_event * makes g++ warn about
+ // potential alignment issues that don't apply here
+ dev->event_cb->vsync(dev->event_cb_data, disp, vsync->timestamp);
+ break;
+ case ADF_EVENT_HOTPLUG:
+ hotplug = reinterpret_cast<adf_hotplug_event *>(event);
+ dev->event_cb->hotplug(dev->event_cb_data, disp, hotplug->connected);
+ break;
+ default:
+ if (event->type < ADF_EVENT_DEVICE_CUSTOM)
+ ALOGW("unrecognized event type %u", event->type);
+ else if (!dev->event_cb || !dev->event_cb->custom_event)
+ ALOGW("unhandled event type %u", event->type);
+ else
+ dev->event_cb->custom_event(dev->event_cb_data, disp, event);
+ }
+ free(event);
+}
+
+static void *adf_event_thread(void *data)
+{
+ adf_hwc_helper *dev = static_cast<adf_hwc_helper *>(data);
+
+ setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
+
+ pollfd *fds = new pollfd[dev->intf_fds.size()];
+ for (size_t i = 0; i < dev->intf_fds.size(); i++) {
+ fds[i].fd = dev->intf_fds[i];
+ fds[i].events = POLLIN | POLLPRI;
+ }
+
+ while (true) {
+ int err = poll(fds, dev->intf_fds.size(), -1);
+
+ if (err > 0) {
+ for (size_t i = 0; i < dev->intf_fds.size(); i++)
+ if (fds[i].revents & (POLLIN | POLLPRI))
+ handle_adf_event(dev, i);
+ }
+ else if (err == -1) {
+ if (errno == EINTR)
+ break;
+ ALOGE("error in event thread: %s", strerror(errno));
+ }
+ }
+
+ delete [] fds;
+ return NULL;
+}
+
+int adf_hwc_open(int *intf_fds, size_t n_intfs,
+ const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data,
+ struct adf_hwc_helper **dev)
+{
+ if (!n_intfs)
+ return -EINVAL;
+
+ adf_hwc_helper *dev_ret = new adf_hwc_helper;
+ dev_ret->event_cb = event_cb;
+ dev_ret->event_cb_data = event_cb_data;
+
+ int ret;
+
+ for (size_t i = 0; i < n_intfs; i++) {
+ int dup_intf_fd = dup(intf_fds[i]);
+ if (dup_intf_fd < 0) {
+ ALOGE("failed to dup interface fd: %s", strerror(errno));
+ ret = -errno;
+ goto err;
+ }
+
+ dev_ret->intf_fds.push_back(dup_intf_fd);
+
+ ret = adf_set_event(dup_intf_fd, ADF_EVENT_HOTPLUG, 1);
+ if (ret < 0 && ret != -EINVAL) {
+ ALOGE("failed to enable hotplug event on display %u: %s",
+ i, strerror(errno));
+ goto err;
+ }
+ }
+
+ ret = pthread_create(&dev_ret->event_thread, NULL, adf_event_thread,
+ dev_ret);
+ if (ret) {
+ ALOGE("failed to create event thread: %s", strerror(ret));
+ goto err;
+ }
+
+ *dev = dev_ret;
+ return 0;
+
+err:
+ for (size_t i = 0; i < dev_ret->intf_fds.size(); i++)
+ close(dev_ret->intf_fds[i]);
+
+ delete dev_ret;
+ return ret;
+}
+
+void adf_hwc_close(struct adf_hwc_helper *dev)
+{
+ pthread_kill(dev->event_thread, SIGTERM);
+ pthread_join(dev->event_thread, NULL);
+
+ for (size_t i = 0; i < dev->intf_fds.size(); i++)
+ close(dev->intf_fds[i]);
+
+ delete dev;
+}
diff --git a/adf/libadfhwc/include/adfhwc/adfhwc.h b/adf/libadfhwc/include/adfhwc/adfhwc.h
new file mode 100644
index 0000000..71e7624
--- /dev/null
+++ b/adf/libadfhwc/include/adfhwc/adfhwc.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2013 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 _LIBADFHWC_ADFHWC_H_
+#define _LIBADFHWC_ADFHWC_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <video/adf.h>
+
+#include <hardware/hwcomposer.h>
+
+struct adf_hwc_helper;
+
+struct adf_hwc_event_callbacks {
+ /**
+ * Called on vsync (required)
+ */
+ void (*vsync)(void *data, int disp, uint64_t timestamp);
+ /**
+ * Called on hotplug (required)
+ */
+ void (*hotplug)(void *data, int disp, bool connected);
+ /**
+ * Called on hardware-custom ADF events (optional)
+ */
+ void (*custom_event)(void *data, int disp, struct adf_event *event);
+};
+
+/**
+ * Converts HAL pixel formats to equivalent ADF/DRM format FourCCs.
+ */
+static inline uint32_t adf_fourcc_for_hal_pixel_format(int format)
+{
+ switch (format) {
+ case HAL_PIXEL_FORMAT_RGBA_8888:
+ return DRM_FORMAT_RGBA8888;
+ case HAL_PIXEL_FORMAT_RGBX_8888:
+ return DRM_FORMAT_RGBX8888;
+ case HAL_PIXEL_FORMAT_RGB_888:
+ return DRM_FORMAT_RGB888;
+ case HAL_PIXEL_FORMAT_RGB_565:
+ return DRM_FORMAT_RGB565;
+ case HAL_PIXEL_FORMAT_BGRA_8888:
+ return DRM_FORMAT_BGRA8888;
+ case HAL_PIXEL_FORMAT_YV12:
+ return DRM_FORMAT_YVU420;
+ case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+ return DRM_FORMAT_NV16;
+ case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+ return DRM_FORMAT_NV21;
+ case HAL_PIXEL_FORMAT_YCbCr_422_I:
+ return DRM_FORMAT_YUYV;
+ default:
+ return 0;
+ }
+}
+
+/**
+ * Converts HAL display types to equivalent ADF interface flags.
+ */
+static inline uint32_t adf_hwc_interface_flag_for_disp(int disp)
+{
+ switch (disp) {
+ case HWC_DISPLAY_PRIMARY:
+ return ADF_INTF_FLAG_PRIMARY;
+ case HWC_DISPLAY_EXTERNAL:
+ return ADF_INTF_FLAG_EXTERNAL;
+ default:
+ return 0;
+ }
+}
+
+__BEGIN_DECLS
+
+/**
+ * Create a HWC helper for the specified ADF interfaces.
+ *
+ * intf_fds must be indexed by HWC display type: e.g.,
+ * intf_fds[HWC_DISPLAY_PRIMARY] is the fd for the primary display
+ * interface. n_intfs must be >= 1.
+ *
+ * The caller retains ownership of the fds in intf_fds and must close()
+ * them when they are no longer needed.
+ *
+ * On error, returns -errno.
+ */
+int adf_hwc_open(int *intf_fds, size_t n_intfs,
+ const struct adf_hwc_event_callbacks *event_cb, void *event_cb_data,
+ struct adf_hwc_helper **dev);
+
+/**
+ * Destroys a HWC helper.
+ */
+void adf_hwc_close(struct adf_hwc_helper *dev);
+
+/**
+ * Generic implementations of common HWC ops.
+ *
+ * The HWC should not point its ops directly at these helpers. Instead, the HWC
+ * should provide stub ops which call these helpers after converting the
+ * hwc_composer_device_1* to a struct adf_hwc_helper*.
+ */
+int adf_eventControl(struct adf_hwc_helper *dev, int disp, int event,
+ int enabled);
+int adf_blank(struct adf_hwc_helper *dev, int disp, int blank);
+int adf_query_display_types_supported(struct adf_hwc_helper *dev, int *value);
+int adf_getDisplayConfigs(struct adf_hwc_helper *dev, int disp,
+ uint32_t *configs, size_t *numConfigs);
+int adf_getDisplayAttributes(struct adf_hwc_helper *dev, int disp,
+ uint32_t config, const uint32_t *attributes, int32_t *values);
+
+__END_DECLS
+
+#endif /* _LIBADFHWC_ADFHWC_H_ */
diff --git a/fastbootd/Android.mk b/fastbootd/Android.mk
index 76b28e2..0f32dbf 100644
--- a/fastbootd/Android.mk
+++ b/fastbootd/Android.mk
@@ -16,23 +16,89 @@
include $(CLEAR_VARS)
+LOCAL_C_INCLUDES := \
+ external/openssl/include \
+ external/mdnsresponder/mDNSShared \
+ $(LOCAL_PATH)/include \
+ external/zlib/ \
+
LOCAL_SRC_FILES := \
config.c \
commands.c \
+ commands/boot.c \
+ commands/flash.c \
+ commands/partitions.c \
+ commands/virtual_partitions.c \
fastbootd.c \
protocol.c \
+ network_discovery.c \
+ socket_client.c \
+ secure.c \
transport.c \
- usb_linux_client.c
+ transport_socket.c \
+ trigger.c \
+ usb_linux_client.c \
+ utils.c \
LOCAL_MODULE := fastbootd
LOCAL_MODULE_TAGS := optional
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter -DFLASH_CERT
+LOCAL_LDFLAGS := -ldl
+
+LOCAL_SHARED_LIBRARIES := \
+ libhardware \
+ libcrypto \
+ libhardware_legacy \
+ libmdnssd
+
+LOCAL_STATIC_LIBRARIES := \
+ libsparse_static \
+ libc \
+ libcutils \
+ libz
+
+#LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_C_INCLUDES := \
+ external/zlib/
+
+LOCAL_SRC_FILES := \
+ commands/partitions.c \
+ other/gptedit.c \
+ utils.c
+
+LOCAL_MODULE := gptedit
+LOCAL_MODULE_TAGS := optional
LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
LOCAL_STATIC_LIBRARIES := \
libsparse_static \
libc \
- libcutils
+ libcutils \
+ libz
LOCAL_FORCE_STATIC_EXECUTABLE := true
include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES := \
+ $(LOCAL_PATH)/include \
+
+LOCAL_STATIC_LIBRARIES := \
+ $(EXTRA_STATIC_LIBS) \
+ libcutils
+
+LOCAL_SRC_FILES := \
+ other/vendor_trigger.c
+
+LOCAL_MODULE := libvendortrigger.default
+LOCAL_MODULE_TAGS := optional
+LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter
+
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/fastbootd/commands.c b/fastbootd/commands.c
index 252f655..d8a601f 100644
--- a/fastbootd/commands.c
+++ b/fastbootd/commands.c
@@ -32,114 +32,304 @@
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <sys/reboot.h>
+#include <fcntl.h>
#include "bootimg.h"
+#include "commands/boot.h"
+#include "commands/flash.h"
+#include "commands/partitions.h"
+#include "commands/virtual_partitions.h"
#include "debug.h"
#include "protocol.h"
+#include "trigger.h"
+#include "utils.h"
+
+#define ATAGS_LOCATION "/proc/atags"
static void cmd_boot(struct protocol_handle *phandle, const char *arg)
{
-#if 0
+ int sz, atags_sz, new_atags_sz;
+ int rv;
unsigned kernel_actual;
unsigned ramdisk_actual;
- static struct boot_img_hdr hdr;
- char *ptr = ((char*) data);
+ unsigned second_actual;
+ void *kernel_ptr;
+ void *ramdisk_ptr;
+ void *second_ptr;
+ struct boot_img_hdr *hdr;
+ char *ptr = NULL;
+ char *atags_ptr = NULL;
+ char *new_atags = NULL;
+ int data_fd = 0;
- if (sz < sizeof(hdr)) {
+ D(DEBUG, "cmd_boot %s\n", arg);
+
+ if (phandle->download_fd < 0) {
+ fastboot_fail(phandle, "no kernel file");
+ return;
+ }
+
+ atags_ptr = read_atags(ATAGS_LOCATION, &atags_sz);
+ if (atags_ptr == NULL) {
+ fastboot_fail(phandle, "atags read error");
+ goto error;
+ }
+
+ // TODO: With cms we can also verify partition name included as
+ // cms signed attribute
+ if (flash_validate_certificate(phandle->download_fd, &data_fd) != 1) {
+ fastboot_fail(phandle, "Access forbiden you need the certificate");
+ return;
+ }
+
+ sz = get_file_size(data_fd);
+
+ ptr = (char *) mmap(NULL, sz, PROT_READ,
+ MAP_POPULATE | MAP_PRIVATE, data_fd, 0);
+
+ hdr = (struct boot_img_hdr *) ptr;
+
+ if (ptr == MAP_FAILED) {
+ fastboot_fail(phandle, "internal fastbootd error");
+ goto error;
+ }
+
+ if ((size_t) sz < sizeof(*hdr)) {
fastboot_fail(phandle, "invalid bootimage header");
- return;
+ goto error;
}
- memcpy(&hdr, data, sizeof(hdr));
+ kernel_actual = ROUND_TO_PAGE(hdr->kernel_size, hdr->page_size);
+ ramdisk_actual = ROUND_TO_PAGE(hdr->ramdisk_size, hdr->page_size);
+ second_actual = ROUND_TO_PAGE(hdr->second_size, hdr->page_size);
- /* ensure commandline is terminated */
- hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;
+ new_atags = (char *) create_atags((unsigned *) atags_ptr, atags_sz, hdr, &new_atags_sz);
- kernel_actual = ROUND_TO_PAGE(hdr.kernel_size);
- ramdisk_actual = ROUND_TO_PAGE(hdr.ramdisk_size);
+ if (new_atags == NULL) {
+ fastboot_fail(phandle, "atags generate error");
+ goto error;
+ }
+ if (new_atags_sz > 0x4000) {
+ fastboot_fail(phandle, "atags file to large");
+ goto error;
+ }
- if (2048 + kernel_actual + ramdisk_actual < sz) {
+ if ((int) (hdr->page_size + kernel_actual + ramdisk_actual) < sz) {
fastboot_fail(phandle, "incomplete bootimage");
- return;
+ goto error;
}
- /*memmove((void*) KERNEL_ADDR, ptr + 2048, hdr.kernel_size);
- memmove((void*) RAMDISK_ADDR, ptr + 2048 + kernel_actual, hdr.ramdisk_size);*/
+ kernel_ptr = (void *)((unsigned) ptr + hdr->page_size);
+ ramdisk_ptr = (void *)((unsigned) kernel_ptr + kernel_actual);
+ second_ptr = (void *)((unsigned) ramdisk_ptr + ramdisk_actual);
+
+ D(INFO, "preparing to boot");
+ // Prepares boot physical address. Addresses from header are ignored
+ rv = prepare_boot_linux(hdr->kernel_addr, kernel_ptr, kernel_actual,
+ hdr->ramdisk_addr, ramdisk_ptr, ramdisk_actual,
+ hdr->second_addr, second_ptr, second_actual,
+ hdr->tags_addr, new_atags, ROUND_TO_PAGE(new_atags_sz, hdr->page_size));
+ if (rv < 0) {
+ fastboot_fail(phandle, "kexec prepare failed");
+ goto error;
+ }
fastboot_okay(phandle, "");
- udc_stop();
+ free(atags_ptr);
+ munmap(ptr, sz);
+ free(new_atags);
+ close(data_fd);
- /*boot_linux((void*) KERNEL_ADDR, (void*) TAGS_ADDR,
- (const char*) hdr.cmdline, LINUX_MACHTYPE,
- (void*) RAMDISK_ADDR, hdr.ramdisk_size);*/
-#endif
+ D(INFO, "Kexec going to reboot");
+ reboot(LINUX_REBOOT_CMD_KEXEC);
+
+ fastboot_fail(phandle, "reboot error");
+
+ return;
+
+error:
+
+ if (atags_ptr != NULL)
+ free(atags_ptr);
+ if (ptr != NULL)
+ munmap(ptr, sz);
+
}
static void cmd_erase(struct protocol_handle *phandle, const char *arg)
{
-#if 0
- struct ptentry *ptn;
- struct ptable *ptable;
+ int partition_fd;
+ char path[PATH_MAX];
+ D(DEBUG, "cmd_erase %s\n", arg);
- ptable = flash_get_ptable();
- if (ptable == NULL) {
+ if (flash_find_entry(arg, path, PATH_MAX)) {
fastboot_fail(phandle, "partition table doesn't exist");
return;
}
- ptn = ptable_find(ptable, arg);
- if (ptn == NULL) {
- fastboot_fail(phandle, "unknown partition name");
+ if (path == NULL) {
+ fastboot_fail(phandle, "Couldn't find partition");
return;
}
- if (flash_erase(ptn)) {
+ partition_fd = flash_get_partiton(path);
+ if (partition_fd < 0) {
+ fastboot_fail(phandle, "partiton file does not exists");
+ }
+
+ if (flash_erase(partition_fd)) {
+ fastboot_fail(phandle, "failed to erase partition");
+ flash_close(partition_fd);
+ return;
+ }
+
+ if (flash_close(partition_fd) < 0) {
+ D(ERR, "could not close device %s", strerror(errno));
fastboot_fail(phandle, "failed to erase partition");
return;
}
fastboot_okay(phandle, "");
-#endif
+}
+
+static int GPT_header_location() {
+ const char *location_str = fastboot_getvar("gpt_sector");
+ char *str;
+ int location;
+
+ if (!strcmp("", location_str)) {
+ D(INFO, "GPT location not specified using second sector");
+ return 1;
+ }
+ else {
+ location = strtoul(location_str, &str, 10);
+ D(INFO, "GPT location specified as %d", location);
+
+ if (*str != '\0')
+ return -1;
+
+ return location - 1;
+ }
+}
+
+static void cmd_gpt_layout(struct protocol_handle *phandle, const char *arg) {
+ struct GPT_entry_table *oldtable;
+ int location;
+ struct GPT_content content;
+ const char *device;
+ device = fastboot_getvar("blockdev");
+
+ if (!strcmp(device, "")) {
+ fastboot_fail(phandle, "blockdev not defined in config file");
+ return;
+ }
+
+ //TODO: add same verification as in cmd_flash
+ if (phandle->download_fd < 0) {
+ fastboot_fail(phandle, "no layout file");
+ return;
+ }
+
+ location = GPT_header_location();
+ oldtable = GPT_get_device(device, location);
+
+ GPT_default_content(&content, oldtable);
+ if (oldtable == NULL)
+ D(WARN, "Could not get old gpt table");
+ else
+ GPT_release_device(oldtable);
+
+ if (!GPT_parse_file(phandle->download_fd, &content)) {
+ fastboot_fail(phandle, "Could not parse partition config file");
+ return;
+ }
+
+ if (trigger_gpt_layout(&content)) {
+ fastboot_fail(phandle, "Vendor forbids this opperation");
+ GPT_release_content(&content);
+ return;
+ }
+
+ if (!GPT_write_content(device, &content)) {
+ fastboot_fail(phandle, "Unable to write gpt file");
+ GPT_release_content(&content);
+ return;
+ }
+
+ GPT_release_content(&content);
+ fastboot_okay(phandle, "");
}
static void cmd_flash(struct protocol_handle *phandle, const char *arg)
{
-#if 0
- struct ptentry *ptn;
- struct ptable *ptable;
- unsigned extra = 0;
+ int partition;
+ uint64_t sz;
+ char data[BOOT_MAGIC_SIZE];
+ char path[PATH_MAX];
+ ssize_t header_sz = 0;
+ int data_fd = 0;
- ptable = flash_get_ptable();
- if (ptable == NULL) {
+ D(DEBUG, "cmd_flash %s\n", arg);
+
+ if (try_handle_virtual_partition(phandle, arg)) {
+ return;
+ }
+
+ if (phandle->download_fd < 0) {
+ fastboot_fail(phandle, "no kernel file");
+ return;
+ }
+
+ if (flash_find_entry(arg, path, PATH_MAX)) {
fastboot_fail(phandle, "partition table doesn't exist");
return;
}
- ptn = ptable_find(ptable, arg);
- if (ptn == NULL) {
- fastboot_fail(phandle, "unknown partition name");
+ if (flash_validate_certificate(phandle->download_fd, &data_fd) != 1) {
+ fastboot_fail(phandle, "Access forbiden you need certificate");
return;
}
- if (!strcmp(ptn->name, "boot") || !strcmp(ptn->name, "recovery")) {
+ // TODO: Maybe its goot idea to check whether the partition is bootable
+ if (!strcmp(arg, "boot") || !strcmp(arg, "recovery")) {
+ if (read_data_once(data_fd, data, BOOT_MAGIC_SIZE) < BOOT_MAGIC_SIZE) {
+ fastboot_fail(phandle, "incoming data read error, cannot read boot header");
+ return;
+ }
if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
fastboot_fail(phandle, "image is not a boot image");
return;
}
}
- if (!strcmp(ptn->name, "system") || !strcmp(ptn->name, "userdata"))
- extra = 64;
- else
- sz = ROUND_TO_PAGE(sz);
+ partition = flash_get_partiton(path);
- D(INFO, "writing %d bytes to '%s'\n", sz, ptn->name);
- if (flash_write(ptn, extra, data, sz)) {
+ sz = get_file_size64(data_fd);
+
+ sz -= header_sz;
+
+ if (sz > get_file_size64(partition)) {
+ flash_close(partition);
+ D(WARN, "size of file too large");
+ fastboot_fail(phandle, "size of file too large");
+ return;
+ }
+
+ D(INFO, "writing %lld bytes to '%s'\n", sz, arg);
+
+ if (flash_write(partition, phandle->download_fd, sz, header_sz)) {
fastboot_fail(phandle, "flash write failure");
return;
}
- D(INFO, "partition '%s' updated\n", ptn->name);
-#endif
+ D(INFO, "partition '%s' updated\n", arg);
+
+ flash_close(partition);
+ close(data_fd);
+
fastboot_okay(phandle, "");
}
@@ -184,7 +374,6 @@
phandle->download_fd = protocol_handle_download(phandle, len);
if (phandle->download_fd < 0) {
- //handle->state = STATE_ERROR;
fastboot_fail(phandle, "download failed");
return;
}
@@ -192,14 +381,27 @@
fastboot_okay(phandle, "");
}
+static void cmd_oem(struct protocol_handle *phandle, const char *arg) {
+ const char *response = "";
+
+ //TODO: Maybe it should get download descriptor also
+ if (trigger_oem_cmd(arg, &response))
+ fastboot_fail(phandle, response);
+ else
+ fastboot_okay(phandle, response);
+}
+
void commands_init()
{
+ virtual_partition_register("partition-table", cmd_gpt_layout);
+
fastboot_register("boot", cmd_boot);
fastboot_register("erase:", cmd_erase);
fastboot_register("flash:", cmd_flash);
fastboot_register("continue", cmd_continue);
fastboot_register("getvar:", cmd_getvar);
fastboot_register("download:", cmd_download);
+ fastboot_register("oem", cmd_oem);
//fastboot_publish("version", "0.5");
//fastboot_publish("product", "swordfish");
//fastboot_publish("kernel", "lk");
diff --git a/fastbootd/commands/boot.c b/fastbootd/commands/boot.c
new file mode 100644
index 0000000..8da9a28
--- /dev/null
+++ b/fastbootd/commands/boot.c
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <sys/syscall.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "boot.h"
+#include "debug.h"
+#include "utils.h"
+#include "bootimg.h"
+
+
+#define KEXEC_ARM_ATAGS_OFFSET 0x1000
+#define KEXEC_ARM_ZIMAGE_OFFSET 0x8000
+
+#define MEMORY_SIZE 0x0800000
+#define START_ADDRESS 0x44000000
+#define KERNEL_START (START_ADDRESS + KEXEC_ARM_ZIMAGE_OFFSET)
+
+#define ATAG_NONE_TYPE 0x00000000
+#define ATAG_CORE_TYPE 0x54410001
+#define ATAG_RAMDISK_TYPE 0x54410004
+#define ATAG_INITRD2_TYPE 0x54420005
+#define ATAG_CMDLINE_TYPE 0x54410009
+
+#define MAX_ATAG_SIZE 0x4000
+
+struct atag_info {
+ unsigned size;
+ unsigned type;
+};
+
+struct atag_initrd2 {
+ unsigned start;
+ unsigned size;
+};
+
+struct atag_cmdline {
+ char cmdline[0];
+};
+
+struct atag {
+ struct atag_info info;
+ union {
+ struct atag_initrd2 initrd2;
+ struct atag_cmdline cmdline;
+ } data;
+};
+
+
+long kexec_load(unsigned int entry, unsigned long nr_segments,
+ struct kexec_segment *segment, unsigned long flags) {
+ return syscall(__NR_kexec_load, entry, nr_segments, segment, flags);
+}
+
+/*
+ * Prepares arguments for kexec
+ * Kernel address is not set into kernel_phys
+ * Ramdisk is set to position relative to kernel
+ */
+int prepare_boot_linux(unsigned kernel_phys, void *kernel_addr, int kernel_size,
+ unsigned ramdisk_phys, void *ramdisk_addr, int ramdisk_size,
+ unsigned second_phys, void *second_addr, int second_size,
+ unsigned atags_phys, void *atags_addr, int atags_size) {
+ struct kexec_segment segment[4];
+ int segment_count = 2;
+ unsigned entry = START_ADDRESS + KEXEC_ARM_ZIMAGE_OFFSET;
+ int rv;
+ int page_size = getpagesize();
+
+ segment[0].buf = kernel_addr;
+ segment[0].bufsz = kernel_size;
+ segment[0].mem = (void *) KERNEL_START;
+ segment[0].memsz = ROUND_TO_PAGE(kernel_size, page_size);
+
+ if (kernel_size > MEMORY_SIZE - KEXEC_ARM_ZIMAGE_OFFSET) {
+ D(INFO, "Kernel image too big");
+ return -1;
+ }
+
+ segment[1].buf = atags_addr;
+ segment[1].bufsz = atags_size;
+ segment[1].mem = (void *) (START_ADDRESS + KEXEC_ARM_ATAGS_OFFSET);
+ segment[1].memsz = ROUND_TO_PAGE(atags_size, page_size);
+
+ D(INFO, "Ramdisk size is %d", ramdisk_size);
+
+ if (ramdisk_size != 0) {
+ segment[segment_count].buf = ramdisk_addr;
+ segment[segment_count].bufsz = ramdisk_size;
+ segment[segment_count].mem = (void *) (KERNEL_START + ramdisk_phys - kernel_phys);
+ segment[segment_count].memsz = ROUND_TO_PAGE(ramdisk_phys, page_size);
+ ++segment_count;
+ }
+
+ D(INFO, "Ramdisk size is %d", ramdisk_size);
+ if (second_size != 0) {
+ segment[segment_count].buf = second_addr;
+ segment[segment_count].bufsz = second_size;
+ segment[segment_count].mem = (void *) (KERNEL_START + second_phys - kernel_phys);
+ segment[segment_count].memsz = ROUND_TO_PAGE(second_size, page_size);
+ entry = second_phys;
+ ++segment_count;
+ }
+
+ rv = kexec_load(entry, segment_count, segment, KEXEC_ARCH_DEFAULT);
+
+ if (rv != 0) {
+ D(INFO, "Kexec_load returned non-zero exit code: %s\n", strerror(errno));
+ return -1;
+ }
+
+ return 1;
+
+}
+
+unsigned *create_atags(unsigned *atags_position, int atag_size, const struct boot_img_hdr *hdr, int *size) {
+ struct atag *current_tag = (struct atag *) atags_position;
+ unsigned *current_tag_raw = atags_position;
+ unsigned *new_atags = malloc(ROUND_TO_PAGE(atag_size + BOOT_ARGS_SIZE * sizeof(char),
+ hdr->page_size));
+ //This pointer will point into the beggining of buffer free space
+ unsigned *natags_raw_buff = new_atags;
+ int new_atags_size = 0;
+ int current_size;
+ int cmdl_length;
+
+ // copy tags from current atag file
+ while (current_tag->info.type != ATAG_NONE_TYPE) {
+ switch (current_tag->info.type) {
+ case ATAG_CMDLINE_TYPE:
+ case ATAG_RAMDISK_TYPE:
+ case ATAG_INITRD2_TYPE: break;
+ default:
+ memcpy((void *)natags_raw_buff, (void *)current_tag_raw, current_tag->info.size * sizeof(unsigned));
+ natags_raw_buff += current_tag->info.size;
+ new_atags_size += current_tag->info.size;
+ }
+
+ current_tag_raw += current_tag->info.size;
+ current_tag = (struct atag *) current_tag_raw;
+
+ if (current_tag_raw >= atags_position + atag_size) {
+ D(ERR, "Critical error in atags");
+ return NULL;
+ }
+ }
+
+ // set INITRD2 tag
+ if (hdr->ramdisk_size > 0) {
+ current_size = (sizeof(struct atag_info) + sizeof(struct atag_initrd2)) / sizeof(unsigned);
+ *((struct atag *) natags_raw_buff) = (struct atag) {
+ .info = {
+ .size = current_size,
+ .type = ATAG_INITRD2_TYPE
+ },
+ .data = {
+ .initrd2 = (struct atag_initrd2) {
+ .start = hdr->ramdisk_addr,
+ .size = hdr->ramdisk_size
+ }
+ }
+ };
+
+ new_atags_size += current_size;
+ natags_raw_buff += current_size;
+ }
+
+ // set ATAG_CMDLINE
+ cmdl_length = strnlen((char *) hdr->cmdline, BOOT_ARGS_SIZE - 1);
+ current_size = sizeof(struct atag_info) + (1 + cmdl_length);
+ current_size = (current_size + sizeof(unsigned) - 1) / sizeof(unsigned);
+ *((struct atag *) natags_raw_buff) = (struct atag) {
+ .info = {
+ .size = current_size,
+ .type = ATAG_CMDLINE_TYPE
+ },
+ };
+
+ //copy cmdline and ensure that there is null character
+ memcpy(((struct atag *) natags_raw_buff)->data.cmdline.cmdline,
+ (char *) hdr->cmdline, cmdl_length);
+ ((struct atag *) natags_raw_buff)->data.cmdline.cmdline[cmdl_length] = '\0';
+
+ new_atags_size += current_size;
+ natags_raw_buff += current_size;
+
+ // set ATAG_NONE
+ *((struct atag *) natags_raw_buff) = (struct atag) {
+ .info = {
+ .size = 0,
+ .type = ATAG_NONE_TYPE
+ },
+ };
+ new_atags_size += sizeof(struct atag_info) / sizeof(unsigned);
+ natags_raw_buff += sizeof(struct atag_info) / sizeof(unsigned);
+
+ *size = new_atags_size * sizeof(unsigned);
+ return new_atags;
+}
+
+char *read_atags(const char * path, int *atags_sz) {
+ int afd = -1;
+ char *atags_ptr = NULL;
+
+ afd = open(path, O_RDONLY);
+ if (afd < 0) {
+ D(ERR, "wrong atags file");
+ return 0;
+ }
+
+ atags_ptr = (char *) malloc(MAX_ATAG_SIZE);
+ if (atags_ptr == NULL) {
+ D(ERR, "insufficient memory");
+ return 0;
+ }
+
+ *atags_sz = read(afd, atags_ptr, MAX_ATAG_SIZE);
+
+ close(afd);
+ return atags_ptr;
+}
+
diff --git a/fastbootd/commands/boot.h b/fastbootd/commands/boot.h
new file mode 100644
index 0000000..901c38a
--- /dev/null
+++ b/fastbootd/commands/boot.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef __FASTBOOT_BOOT_H
+#define __FASTBOOT_BOOT_H
+
+#include <sys/cdefs.h>
+#include <linux/kexec.h>
+
+#include "bootimg.h"
+
+#define KEXEC_TYPE_DEFAULT 0
+#define KEXEC_TYPE_CRASH 1
+
+int prepare_boot_linux(unsigned, void *, int, unsigned, void *, int,
+ unsigned, void *, int, unsigned, void *, int);
+unsigned *create_atags(unsigned *, int, const struct boot_img_hdr *, int *);
+long kexec_load(unsigned int, unsigned long, struct kexec_segment *, unsigned long);
+char *read_atags(const char *, int *);
+
+#endif /* _SYS_KEXEC_H */
+
diff --git a/fastbootd/commands/flash.c b/fastbootd/commands/flash.c
new file mode 100644
index 0000000..0954217
--- /dev/null
+++ b/fastbootd/commands/flash.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+#include "flash.h"
+#include "protocol.h"
+#include "debug.h"
+#include "utils.h"
+#include "commands/partitions.h"
+
+#ifdef FLASH_CERT
+#include "secure.h"
+#endif
+
+#define ALLOWED_CHARS "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-."
+#define BUFFER_SIZE 1024 * 1024
+#define MIN(a, b) (a > b ? b : a)
+
+
+int flash_find_entry(const char *name, char *out, size_t outlen)
+{
+//TODO: Assumption: All the partitions has they unique name
+
+ const char *path = fastboot_getvar("device-directory");
+ size_t length;
+ if (strcmp(path, "") == 0) {
+ D(ERR, "device-directory: not defined in config file");
+ return -1;
+ }
+
+ length = strspn(name, ALLOWED_CHARS);
+ if (length != strlen(name)) {
+ D(ERR, "Not allowed char in name: %c", name[length]);
+ return -1;
+ }
+
+ if (snprintf(out, outlen, "%s%s", path, name) >= (int) outlen) {
+ D(ERR, "Too long path to partition file");
+ return -1;
+ }
+
+ if (access(out, F_OK ) == -1) {
+ D(ERR, "could not find partition file %s", name);
+ return -1;
+ }
+
+ return 0;
+}
+
+int flash_erase(int fd)
+{
+ int64_t size;
+ size = get_block_device_size(fd);
+ D(DEBUG, "erase %llu data from %d\n", size, fd);
+
+ return wipe_block_device(fd, size);
+}
+
+int flash_write(int partition_fd, int data_fd, ssize_t size, ssize_t skip)
+{
+ ssize_t written = 0;
+ struct GPT_mapping input;
+ struct GPT_mapping output;
+
+ while (written < size) {
+ int current_size = MIN(size - written, BUFFER_SIZE);
+
+ if (gpt_mmap(&input, written + skip, current_size, data_fd)) {
+ D(ERR, "Error in writing data, unable to map data file %d at %d size %d", size, skip, current_size);
+ return -1;
+ }
+ if (gpt_mmap(&output, written, current_size, partition_fd)) {
+ D(ERR, "Error in writing data, unable to map output partition");
+ return -1;
+ }
+
+ memcpy(output.ptr, input.ptr, current_size);
+
+ gpt_unmap(&input);
+ gpt_unmap(&output);
+
+ written += current_size;
+ }
+
+ return 0;
+}
+
+#ifdef FLASH_CERT
+
+int flash_validate_certificate(int signed_fd, int *data_fd) {
+ int ret = 0;
+ const char *cert_path;
+ X509_STORE *store = NULL;
+ CMS_ContentInfo *content_info;
+ BIO *content;
+
+ cert_path = fastboot_getvar("certificate-path");
+ if (!strcmp(cert_path, "")) {
+ D(ERR, "could not find cert-key value in config file");
+ goto finish;
+ }
+
+ store = cert_store_from_path(cert_path);
+ if (store == NULL) {
+ D(ERR, "unable to create certification store");
+ goto finish;
+ }
+
+ if (cert_read(signed_fd, &content_info, &content)) {
+ D(ERR, "reading data failed");
+ goto finish;
+ }
+
+ ret = cert_verify(content, content_info, store, data_fd);
+ cert_release(content, content_info);
+
+ return ret;
+
+finish:
+ if (store != NULL)
+ cert_release_store(store);
+
+ return ret;
+}
+
+#else
+int flash_validate_certificate(int signed_fd, int *data_fd) {
+ return 1;
+}
+#endif
diff --git a/fastbootd/commands/flash.h b/fastbootd/commands/flash.h
new file mode 100644
index 0000000..5a64cab
--- /dev/null
+++ b/fastbootd/commands/flash.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef _FASTBOOTD_ERASE_H
+#define _FASTBOOTD_ERASE_H
+
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include "debug.h"
+
+int flash_find_entry(const char *, char *, size_t);
+int flash_erase(int fd);
+
+static inline int flash_get_partiton(const char *path) {
+ return open(path, O_RDWR);
+}
+
+static inline int flash_close(int fd) {
+ return close(fd);
+}
+
+int flash_write(int partition, int data, ssize_t size, ssize_t skip);
+
+static inline ssize_t read_data_once(int fd, char *buffer, ssize_t size) {
+ ssize_t readcount = 0;
+ ssize_t len;
+
+ while ((len = TEMP_FAILURE_RETRY(read(fd, (void *) &buffer[readcount], size - readcount))) > 0) {
+ readcount += len;
+ }
+ if (len < 0) {
+ D(ERR, "Read error:%s", strerror(errno));
+ return len;
+ }
+
+ return readcount;
+}
+
+int flash_validate_certificate(int signed_fd, int *data_fd);
+
+#endif
+
diff --git a/fastbootd/commands/partitions.c b/fastbootd/commands/partitions.c
new file mode 100644
index 0000000..de80ea3
--- /dev/null
+++ b/fastbootd/commands/partitions.c
@@ -0,0 +1,771 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <endian.h>
+#include <zlib.h>
+#include <linux/hdreg.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <cutils/config_utils.h>
+
+#include "partitions.h"
+#include "debug.h"
+#include "utils.h"
+#include "protocol.h"
+
+#define BLKRRPART _IO(0x12,95) /* re-read partition table */
+#define BLKSSZGET _IO(0x12,104)
+
+#define DIV_ROUND_UP(x, y) (((x) + (y) - 1)/(y))
+#define ALIGN(x, y) ((y) * DIV_ROUND_UP((x), (y)))
+#define ALIGN_DOWN(x, y) ((y) * ((x) / (y)))
+
+
+const uint8_t partition_type_uuid[16] = {
+ 0xa2, 0xa0, 0xd0, 0xeb, 0xe5, 0xb9, 0x33, 0x44,
+ 0x87, 0xc0, 0x68, 0xb6, 0xb7, 0x26, 0x99, 0xc7,
+};
+
+//TODO: There is assumption that we are using little endian
+
+static void GPT_entry_clear(struct GPT_entry_raw *entry)
+{
+ memset(entry, 0, sizeof(*entry));
+}
+
+/*
+ * returns mapped location to choosen area
+ * mapped_ptr is pointer to whole area mapped (it can be bigger then requested)
+ */
+int gpt_mmap(struct GPT_mapping *mapping, uint64_t location, int size, int fd)
+{
+ unsigned int location_diff = location & ~PAGE_MASK;
+
+ mapping->size = ALIGN(size + location_diff, PAGE_SIZE);
+
+ uint64_t sz = get_file_size64(fd);
+ if (sz < size + location) {
+ D(ERR, "the location of mapping area is outside of the device size %lld", sz);
+ return 1;
+ }
+ location = ALIGN_DOWN(location, PAGE_SIZE);
+
+ mapping->map_ptr = mmap64(NULL, mapping->size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, location);
+
+ if (mapping->map_ptr == MAP_FAILED) {
+ mapping->ptr = MAP_FAILED;
+ D(ERR, "map failed %d", (int) mapping->map_ptr);
+ return 1;
+ }
+
+ mapping->ptr = (void *)((char *) mapping->map_ptr + location_diff);
+ return 0;
+}
+
+void gpt_unmap(struct GPT_mapping *mapping) {
+ munmap(mapping->map_ptr, mapping->size);
+}
+
+
+#define LBA_ADDR(table, value) ((uint64_t) (table)->sector_size * (value))
+
+int GPT_map_from_content(struct GPT_entry_table *table, const struct GPT_content *content)
+{
+
+ // Mapping header
+ if (gpt_mmap(&table->header_map, LBA_ADDR(table, content->header.current_lba),
+ table->sector_size, table->fd)) {
+ D(ERR, "unable to map header:%s\n", strerror(errno));
+ goto error_header;
+ }
+
+ table->header = (struct GPT_header *) table->header_map.ptr;
+
+ table->partition_table_size = ROUND_UP(content->header.entries_count * sizeof(*table->entries),
+ table->sector_size);
+
+ // Mapping entry table
+ if (gpt_mmap(&table->entries_map, LBA_ADDR(table, content->header.entries_lba),
+ table->partition_table_size, table->fd)) {
+ D(ERR, "unable to map entries");
+ goto error_signature;
+ }
+
+ table->entries = (struct GPT_entry_raw *) table->entries_map.ptr;
+
+ // Mapping secondary header
+ if (gpt_mmap(&table->sec_header_map, LBA_ADDR(table, content->header.backup_lba),
+ table->sector_size, table->fd)) {
+ D(ERR, "unable to map backup gpt header");
+ goto error_sec_header;
+ }
+
+ // Mapping secondary entries table
+ if (gpt_mmap(&table->sec_entries_map,
+ LBA_ADDR(table, content->header.backup_lba) - table->partition_table_size,
+ table->partition_table_size, table->fd)) {
+ D(ERR, "unable to map secondary gpt table");
+ goto error_sec_entries;
+ }
+
+ table->second_header = (struct GPT_header *) table->sec_header_map.ptr;
+ table->second_entries = (struct GPT_entry_raw *) table->sec_entries_map.ptr;
+ table->second_valid = strcmp("EFI PART", (char *) table->second_header->signature) == 0;
+
+ return 0;
+
+error_sec_entries:
+ gpt_unmap(&table->sec_header_map);
+error_sec_header:
+ gpt_unmap(&table->entries_map);
+error_signature:
+ gpt_unmap(&table->header_map);
+error_header:
+ return 1;
+}
+
+int GPT_map(struct GPT_entry_table *table, unsigned header_lba)
+{
+ struct GPT_content content;
+ struct GPT_mapping mapping;
+ struct GPT_header *header;
+
+ if (gpt_mmap(&mapping, LBA_ADDR(table, header_lba), table->sector_size, table->fd)) {
+ D(ERR, "unable to map header: %s", strerror(errno));
+ goto error_header;
+ }
+
+ header = (struct GPT_header *) mapping.ptr;
+
+ if (strcmp("EFI PART", (char *) header->signature)) {
+ D(ERR, "GPT entry not valid");
+ goto error_signature;
+ }
+
+ content.header = *header;
+
+ gpt_unmap(&mapping);
+
+ return GPT_map_from_content(table, &content);
+
+error_signature:
+ gpt_unmap(&table->header_map);
+error_header:
+ return 1;
+}
+
+struct GPT_entry_table* GPT_get_device(const char *path, unsigned header_lba)
+{
+ struct GPT_entry_table *table;
+ size_t sector_bytes;
+
+ table = (struct GPT_entry_table *) malloc(sizeof(*table));
+ table->fd = open(path, O_RDWR);
+
+ if (table->fd < 0) {
+ D(ERR, "unable to open file %s:%s\n", path, strerror(errno));
+ return NULL;
+ }
+
+ if (!ioctl(table->fd, BLKSSZGET, §or_bytes)) {
+ table->sector_size = (unsigned) sector_bytes;
+ D(INFO, "Got sector size %d", table->sector_size);
+ } else {
+ D(WARN, "unable to get sector size, assuming 512");
+ table->sector_size = 512;
+ }
+
+ if (GPT_map(table, header_lba)) {
+ D(ERR, "Could not map gpt");
+ return NULL;
+ }
+
+ return table;
+}
+
+static struct GPT_entry_table* GPT_get_from_content(const char *path, const struct GPT_content *content)
+{
+ struct GPT_entry_table *table;
+ size_t sector_bytes;
+
+ table = (struct GPT_entry_table *) malloc(sizeof(*table));
+ table->fd = open(path, O_RDWR);
+
+ if (table->fd < 0) {
+ D(ERR, "unable to open file %s:%s\n", path, strerror(errno));
+ return NULL;
+ }
+
+ if (!ioctl(table->fd, BLKSSZGET, §or_bytes)) {
+ table->sector_size = (unsigned) sector_bytes;
+ D(INFO, "Got sector size %d", table->sector_size);
+ } else {
+ D(WARN, "unable to get sector size %s, assuming 512", strerror(errno));
+ table->sector_size = 512;
+ }
+
+ if (GPT_map_from_content(table, content)) {
+ D(ERR, "Could not map gpt");
+ return NULL;
+ }
+
+ return table;
+}
+
+
+void GPT_release_device(struct GPT_entry_table *table)
+{
+ gpt_unmap(&table->header_map);
+ gpt_unmap(&table->entries_map);
+ gpt_unmap(&table->sec_header_map);
+ gpt_unmap(&table->sec_entries_map);
+ close(table->fd);
+ free(table);
+}
+
+static int GPT_check_overlap(struct GPT_entry_table *table, struct GPT_entry_raw *entry);
+static int GPT_check_overlap_except(struct GPT_entry_table *table,
+ struct GPT_entry_raw *entry,
+ struct GPT_entry_raw *exclude);
+
+void GPT_edit_entry(struct GPT_entry_table *table,
+ struct GPT_entry_raw *old_entry,
+ struct GPT_entry_raw *new_entry)
+{
+ struct GPT_entry_raw *current_entry = GPT_get_pointer(table, old_entry);
+
+ if (GPT_check_overlap_except(table, new_entry, current_entry)) {
+ D(ERR, "Couldn't add overlaping partition");
+ return;
+ }
+
+ if (current_entry == NULL) {
+ D(ERR, "Couldn't find entry");
+ return;
+ }
+
+ *current_entry = *new_entry;
+}
+
+int GPT_delete_entry(struct GPT_entry_table *table, struct GPT_entry_raw *entry)
+{
+ struct GPT_entry_raw *raw = GPT_get_pointer(table, entry);
+
+ if (raw == NULL) {
+ D(ERR, "could not find entry");
+ return 1;
+ }
+ D(DEBUG, "Deleting gpt entry '%s'\n", raw->partition_guid);
+
+ // Entry in the middle of table may become empty
+ GPT_entry_clear(raw);
+
+ return 0;
+}
+
+void GPT_add_entry(struct GPT_entry_table *table, struct GPT_entry_raw *entry)
+{
+ unsigned i;
+ int inserted = 0;
+ if (GPT_check_overlap(table, entry)) {
+ D(ERR, "Couldn't add overlaping partition");
+ return;
+ }
+
+ if (GPT_get_pointer(table, entry) != NULL) {
+ D(WARN, "Add entry fault, this entry already exists");
+ return;
+ }
+
+ struct GPT_entry_raw *entries = table->entries;
+
+ for (i = 0; i < table->header->entries_count; ++i) {
+ if (!entries[i].type_guid[0]) {
+ inserted = 1;
+ D(DEBUG, "inserting");
+ memcpy(&entries[i], entry, sizeof(entries[i]));
+ break;
+ }
+ }
+
+ if (!inserted) {
+ D(ERR, "Unable to find empty partion entry");
+ }
+}
+
+struct GPT_entry_raw *GPT_get_pointer_by_UTFname(struct GPT_entry_table *table, const uint16_t *name);
+
+struct GPT_entry_raw *GPT_get_pointer(struct GPT_entry_table *table, struct GPT_entry_raw *entry)
+{
+ if (entry->partition_guid[0] != 0)
+ return GPT_get_pointer_by_guid(table, (const char *) entry->partition_guid);
+ else if (entry->name[0] != 0)
+ return GPT_get_pointer_by_UTFname(table, entry->name);
+
+ D(WARN, "Name or guid needed to find entry");
+ return NULL;
+}
+
+struct GPT_entry_raw *GPT_get_pointer_by_guid(struct GPT_entry_table *table, const char *name)
+{
+ int current = (int) table->header->entries_count;
+
+ for (current = current - 1; current >= 0; --current) {
+ if (strncmp((char *) name,
+ (char *) table->entries[current].partition_guid, 16) == 0) {
+ return &table->entries[current];
+ }
+ }
+
+ return NULL;
+}
+
+int strncmp_UTF16_char(const uint16_t *s1, const char *s2, size_t n)
+{
+ if (n == 0)
+ return (0);
+ do {
+ if (((*s1) & 127) != *s2++)
+ return (((unsigned char) ((*s1) & 127)) - *(unsigned char *)--s2);
+ if (*s1++ == 0)
+ break;
+ } while (--n != 0);
+ return (0);
+}
+
+int strncmp_UTF16(const uint16_t *s1, const uint16_t *s2, size_t n)
+{
+ if (n == 0)
+ return (0);
+ do {
+ if ((*s1) != *s2++)
+ return (*s1 - *--s2);
+ if (*s1++ == 0)
+ break;
+ } while (--n != 0);
+ return (0);
+}
+
+struct GPT_entry_raw *GPT_get_pointer_by_name(struct GPT_entry_table *table, const char *name)
+{
+ int count = (int) table->header->entries_count;
+ int current;
+
+ for (current = 0; current < count; ++current) {
+ if (strncmp_UTF16_char(table->entries[current].name,
+ (char *) name, 16) == 0) {
+ return &table->entries[current];
+ }
+ }
+
+ return NULL;
+}
+
+struct GPT_entry_raw *GPT_get_pointer_by_UTFname(struct GPT_entry_table *table, const uint16_t *name)
+{
+ int count = (int) table->header->entries_count;
+ int current;
+
+ for (current = 0; current < count; ++current) {
+ if (strncmp_UTF16(table->entries[current].name,
+ name, GPT_NAMELEN) == 0) {
+ return &table->entries[current];
+ }
+ }
+
+ return NULL;
+}
+
+void GPT_sync(struct GPT_entry_table *table)
+{
+ uint32_t crc;
+
+ //calculate crc32
+ crc = crc32(0, Z_NULL, 0);
+ crc = crc32(crc, (void*) table->entries, table->header->entries_count * sizeof(*table->entries));
+ table->header->partition_array_checksum = crc;
+
+ table->header->header_checksum = 0;
+ crc = crc32(0, Z_NULL, 0);
+ crc = crc32(crc, (void*) table->header, table->header->header_size);
+ table->header->header_checksum = crc;
+
+ //sync secondary partion
+ if (table->second_valid) {
+ memcpy((void *)table->second_entries, (void *) table->entries, table->partition_table_size);
+ memcpy((void *)table->second_header, (void *)table->header, sizeof(*table->header));
+ }
+
+ if(!ioctl(table->fd, BLKRRPART, NULL)) {
+ D(WARN, "Unable to force kernel to refresh partition table");
+ }
+}
+
+void GPT_to_UTF16(uint16_t *to, const char *from, int n)
+{
+ int i;
+ for (i = 0; i < (n - 1) && (to[i] = from[i]) != '\0'; ++i);
+ to[i] = '\0';
+}
+
+void GPT_from_UTF16(char *to, const uint16_t *from, int n)
+{
+ int i;
+ for (i = 0; i < (n - 1) && (to[i] = from[i] & 127) != '\0'; ++i);
+ to[i] = '\0';
+}
+
+static int GPT_check_overlap_except(struct GPT_entry_table *table,
+ struct GPT_entry_raw *entry,
+ struct GPT_entry_raw *exclude) {
+ int current = (int) table->header->entries_count;
+ int dontcheck;
+ struct GPT_entry_raw *current_entry;
+ if (entry->last_lba < entry->first_lba) {
+ D(WARN, "Start address have to be less than end address");
+ return 1;
+ }
+
+ for (current = current - 1; current >= 0; --current) {
+ current_entry = &table->entries[current];
+ dontcheck = strncmp((char *) entry->partition_guid,
+ (char *) current_entry->partition_guid , 16) == 0;
+ dontcheck |= current_entry->type_guid[0] == 0;
+ dontcheck |= current_entry == exclude;
+
+ if (!dontcheck && ((entry->last_lba >= current_entry->first_lba &&
+ entry->first_lba < current_entry->last_lba ))) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static int GPT_check_overlap(struct GPT_entry_table *table, struct GPT_entry_raw *entry)
+{
+ return GPT_check_overlap_except(table, entry, NULL);
+}
+
+static char *get_key_value(char *ptr, char **key, char **value)
+{
+ *key = ptr;
+ ptr = strchr(ptr, '=');
+
+ if (ptr == NULL)
+ return NULL;
+
+ *ptr++ = '\0';
+ *value = ptr;
+ ptr = strchr(ptr, ';');
+
+ if (ptr == NULL)
+ ptr = *value + strlen(*value);
+ else
+ *ptr = '\0';
+
+ *key = strip(*key);
+ *value = strip(*value);
+
+ return ptr;
+}
+
+//TODO: little endian?
+static int add_key_value(const char *key, const char *value, struct GPT_entry_raw *entry)
+{
+ char *endptr;
+ if (!strcmp(key, "type")) {
+ strncpy((char *) entry->type_guid, value, 16);
+ entry->type_guid[15] = 0;
+ }
+ else if (!strcmp(key, "guid")) {
+ strncpy((char *) entry->partition_guid, value, 16);
+ entry->type_guid[15] = 0;
+ }
+ else if (!strcmp(key, "firstlba")) {
+ entry->first_lba = strtoul(value, &endptr, 10);
+ if (*endptr != '\0') goto error;
+ }
+ else if (!strcmp(key, "lastlba")) {
+ entry->last_lba = strtoul(value, &endptr, 10);
+ if (*endptr != '\0') goto error;
+ }
+ else if (!strcmp(key, "flags")) {
+ entry->flags = strtoul(value, &endptr, 16);
+ if (*endptr != '\0') goto error;
+ }
+ else if (!strcmp(key, "name")) {
+ GPT_to_UTF16(entry->name, value, GPT_NAMELEN);
+ }
+ else {
+ goto error;
+ }
+
+ return 0;
+
+error:
+ D(ERR, "Could not find key or parse value: %s,%s", key, value);
+ return 1;
+}
+
+int GPT_parse_entry(char *string, struct GPT_entry_raw *entry)
+{
+ char *ptr = string;
+ char *key, *value;
+
+ while ((ptr = get_key_value(ptr, &key, &value)) != NULL) {
+ if (add_key_value(key, value, entry)) {
+ D(WARN, "key or value not valid: %s %s", key, value);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+void entry_set_guid(int n, uint8_t *guid)
+{
+ int fd;
+ fd = open("/dev/urandom", O_RDONLY);
+ read(fd, guid, 16);
+ close(fd);
+
+ //rfc4122
+ guid[8] = (guid[8] & 0x3F) | 0x80;
+ guid[7] = (guid[7] & 0x0F) | 0x40;
+}
+
+void GPT_default_content(struct GPT_content *content, struct GPT_entry_table *table)
+{
+ if (table != NULL) {
+ memcpy(&content->header, table->header, sizeof(content->header));
+ content->header.header_size = sizeof(content->header);
+ content->header.entry_size = sizeof(struct GPT_entry_raw);
+ }
+ else {
+ D(WARN, "Could not locate old gpt table, using default values");
+ memset(&content->header, 0, sizeof(content->header) / sizeof(int));
+ content->header = (struct GPT_header) {
+ .revision = 0x10000,
+ .header_size = sizeof(content->header),
+ .header_checksum = 0,
+ .reserved_zeros = 0,
+ .current_lba = 1,
+ .backup_lba = 1,
+ .entry_size = sizeof(struct GPT_entry_raw),
+ .partition_array_checksum = 0
+ };
+ strncpy((char *)content->header.signature, "EFI PART", 8);
+ strncpy((char *)content->header.disk_guid, "ANDROID MMC DISK", 16);
+ }
+}
+
+static int get_config_uint64(cnode *node, uint64_t *ptr, const char *name)
+{
+ const char *tmp;
+ uint64_t val;
+ char *endptr;
+ if ((tmp = config_str(node, name, NULL))) {
+ val = strtoull(tmp, &endptr, 10);
+ if (*endptr != '\0') {
+ D(WARN, "Value for %s is not a number: %s", name, tmp);
+ return 1;
+ }
+ *ptr = val;
+ return 0;
+ }
+ return 1;
+}
+
+static int get_config_string(cnode *node, char *ptr, int max_len, const char *name)
+{
+ size_t begin, end;
+ const char *value = config_str(node, name, NULL);
+ if (!value)
+ return -1;
+
+ begin = strcspn(value, "\"") + 1;
+ end = strcspn(&value[begin], "\"");
+
+ if ((int) end > max_len) {
+ D(WARN, "Identifier \"%s\" too long", value);
+ return -1;
+ }
+
+ strncpy(ptr, &value[begin], end);
+ if((int) end < max_len)
+ ptr[end] = 0;
+ return 0;
+}
+
+static void GPT_parse_header(cnode *node, struct GPT_content *content)
+{
+ get_config_uint64(node, &content->header.current_lba, "header_lba");
+ get_config_uint64(node, &content->header.backup_lba, "backup_lba");
+ get_config_uint64(node, &content->header.first_usable_lba, "first_lba");
+ get_config_uint64(node, &content->header.last_usable_lba, "last_lba");
+ get_config_uint64(node, &content->header.entries_lba, "entries_lba");
+ get_config_string(node, (char *) content->header.disk_guid, 16, "guid");
+}
+
+static int GPT_parse_partitions(cnode *node, struct GPT_content *content)
+{
+ cnode *current;
+ int i;
+ uint64_t partition_size;
+ struct GPT_entry_raw *entry;
+ for (i = 0, current = node->first_child; current; current = current->next, ++i) {
+ entry = &content->entries[i];
+ entry_set_guid(i, content->entries[i].partition_guid);
+ memcpy(&content->entries[i].type_guid, partition_type_uuid, 16);
+ if (get_config_uint64(current, &entry->first_lba, "first_lba")) {
+ D(ERR, "first_lba not specified");
+ return 1;
+ }
+ if (get_config_uint64(current, &partition_size, "partition_size")) {
+ D(ERR, "partition_size not specified");
+ return 1;
+ }
+ if (config_str(current, "system", NULL)) {
+ entry->flags |= GPT_FLAG_SYSTEM;
+ }
+ if (config_str(current, "bootable", NULL)) {
+ entry->flags |= GPT_FLAG_BOOTABLE;
+ }
+ if (config_str(current, "readonly", NULL)) {
+ entry->flags |= GPT_FLAG_READONLY;
+ }
+ if (config_str(current, "automount", NULL)) {
+ entry->flags |= GPT_FLAG_DOAUTOMOUNT;
+ }
+
+ get_config_uint64(current, &content->entries[i].flags, "flags");
+ content->entries[i].last_lba = content->entries[i].first_lba + partition_size - 1;
+ GPT_to_UTF16(content->entries[i].name, current->name, 16);
+ }
+ return 0;
+}
+
+static inline int cnode_count(cnode *node)
+{
+ int i;
+ cnode *current;
+ for (i = 0, current = node->first_child; current; current = current->next, ++i)
+ ;
+ return i;
+}
+
+
+static int GPT_parse_cnode(cnode *root, struct GPT_content *content)
+{
+ cnode *partnode;
+
+ if (!(partnode = config_find(root, "partitions"))) {
+ D(ERR, "Could not find partition table");
+ return 0;
+ }
+
+ GPT_parse_header(root, content);
+
+ content->header.entries_count = cnode_count(partnode);
+ content->entries = malloc(content->header.entries_count * sizeof(struct GPT_entry_raw));
+
+ if (GPT_parse_partitions(partnode, content)) {
+ D(ERR, "Could not parse partitions");
+ return 0;
+ }
+
+ return 1;
+}
+
+int GPT_parse_file(int fd, struct GPT_content *content)
+{
+ char *data;
+ int size;
+ int ret;
+ cnode *root = config_node("", "");
+
+ size = get_file_size(fd);
+ data = (char *) mmap(NULL, size + 1, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+
+ if (data == NULL) {
+ if (size == 0)
+ D(ERR, "config file empty");
+ else
+ D(ERR, "Out of memory");
+ return 0;
+ }
+
+ data[size - 1] = 0;
+ config_load(root, data);
+
+ if (root->first_child == NULL) {
+ D(ERR, "Could not read config file");
+ return 0;
+ }
+
+ ret = GPT_parse_cnode(root, content);
+ munmap(data, size);
+ return ret;
+}
+
+void GPT_release_content(struct GPT_content *content)
+{
+ free(content->entries);
+}
+
+int GPT_write_content(const char *device, struct GPT_content *content)
+{
+ struct GPT_entry_table *maptable;
+
+ maptable = GPT_get_from_content(device, content);
+ if (maptable == NULL) {
+ D(ERR, "could not map device");
+ return 0;
+ }
+
+ memcpy(maptable->header, &content->header, sizeof(*maptable->header));
+ memcpy(maptable->entries, content->entries,
+ content->header.entries_count * sizeof(*maptable->entries));
+
+ GPT_sync(maptable);
+ GPT_release_device(maptable);
+
+ return 1;
+}
+
diff --git a/fastbootd/commands/partitions.h b/fastbootd/commands/partitions.h
new file mode 100644
index 0000000..9a6a88d
--- /dev/null
+++ b/fastbootd/commands/partitions.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+
+#ifndef __FASTBOOTD_PATITIONS_
+#define __FASTBOOTD_PATITIONS_
+
+#include <stdint.h>
+
+#define GPT_ENTRIES 128
+#define GPT_NAMELEN 36
+
+#define GPT_FLAG_SYSTEM (1ULL << 0)
+#define GPT_FLAG_BOOTABLE (1ULL << 2)
+#define GPT_FLAG_READONLY (1ULL << 60)
+#define GPT_FLAG_DOAUTOMOUNT (1ULL << 63)
+
+// it should be passed in little endian order
+struct GPT_entry_raw {
+ uint8_t type_guid[16];
+ uint8_t partition_guid[16];
+ uint64_t first_lba; // little endian
+ uint64_t last_lba;
+ uint64_t flags;
+ uint16_t name[GPT_NAMELEN]; // UTF-16 LE
+};
+
+struct GPT_mapping {
+ void *map_ptr;
+ void *ptr;
+ unsigned size;
+};
+
+struct GPT_entry_table {
+ int fd;
+
+ struct GPT_mapping header_map;
+ struct GPT_mapping entries_map;
+ struct GPT_mapping sec_header_map;
+ struct GPT_mapping sec_entries_map;
+
+ struct GPT_header *header;
+ struct GPT_entry_raw *entries;
+ struct GPT_header *second_header;
+ struct GPT_entry_raw *second_entries;
+
+ unsigned sector_size;
+ unsigned partition_table_size;
+ int second_valid;
+};
+
+struct GPT_header {
+ uint8_t signature[8];
+ uint32_t revision;
+ uint32_t header_size;
+ uint32_t header_checksum;
+ uint32_t reserved_zeros;
+ uint64_t current_lba;
+ uint64_t backup_lba;
+ uint64_t first_usable_lba;
+ uint64_t last_usable_lba;
+ uint8_t disk_guid[16];
+ uint64_t entries_lba;
+ uint32_t entries_count;
+ uint32_t entry_size;
+ uint32_t partition_array_checksum;
+ // the rest should be filled with zeros
+} __attribute__((packed));
+
+struct GPT_content {
+ struct GPT_header header;
+ struct GPT_entry_raw *entries;
+};
+
+
+struct GPT_entry_table* GPT_get_device(const char *, unsigned lba);
+
+void GPT_release_device(struct GPT_entry_table *);
+
+void GPT_edit_entry(struct GPT_entry_table *table,
+ struct GPT_entry_raw *old_entry,
+ struct GPT_entry_raw *new_entry);
+
+int GPT_delete_entry(struct GPT_entry_table *table, struct GPT_entry_raw *entry);
+
+void GPT_add_entry(struct GPT_entry_table *table, struct GPT_entry_raw *entry);
+
+struct GPT_entry_raw *GPT_get_pointer(struct GPT_entry_table *table, struct GPT_entry_raw *entry);
+struct GPT_entry_raw *GPT_get_pointer_by_guid(struct GPT_entry_table *, const char *);
+struct GPT_entry_raw *GPT_get_pointer_by_name(struct GPT_entry_table *, const char *);
+
+//Use after every edit operation
+void GPT_sync();
+
+void GPT_to_UTF16(uint16_t *, const char *, int );
+void GPT_from_UTF16(char *, const uint16_t *, int);
+
+int GPT_parse_entry(char *string, struct GPT_entry_raw *entry);
+
+void GPT_default_content(struct GPT_content *content, struct GPT_entry_table *table);
+
+void GPT_release_content(struct GPT_content *content);
+
+int GPT_parse_file(int fd, struct GPT_content *content);
+
+int GPT_write_content(const char *device, struct GPT_content *content);
+
+int gpt_mmap(struct GPT_mapping *mapping, uint64_t location, int size, int fd);
+
+void gpt_unmap(struct GPT_mapping *mapping);
+
+#endif
diff --git a/fastbootd/commands/virtual_partitions.c b/fastbootd/commands/virtual_partitions.c
new file mode 100644
index 0000000..813f485
--- /dev/null
+++ b/fastbootd/commands/virtual_partitions.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 "commands/virtual_partitions.h"
+#include "debug.h"
+
+static struct virtual_partition *partitions = NULL;
+
+int try_handle_virtual_partition(struct protocol_handle *handle, const char *arg)
+{
+ struct virtual_partition *current;
+
+ for (current = partitions; current != NULL; current = current->next) {
+ if (!strcmp(current->name, arg)) {
+ current->handler(handle, arg);
+ }
+ }
+
+ return 0;
+}
+
+void virtual_partition_register(
+ const char * name,
+ void (*handler)(struct protocol_handle *phandle, const char *arg))
+{
+ struct virtual_partition *new;
+ new = malloc(sizeof(*new));
+ if (new) {
+ new->name = name;
+ new->handler = handler;
+ new->next = partitions;
+ partitions = new;
+ }
+ else {
+ D(ERR, "Out of memory");
+ }
+}
diff --git a/fastbootd/commands/virtual_partitions.h b/fastbootd/commands/virtual_partitions.h
new file mode 100644
index 0000000..88df71e
--- /dev/null
+++ b/fastbootd/commands/virtual_partitions.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef FASTBOOTD_VIRTUAL_PARTITIONS_H
+#define FASTBOOTD_VIRTUAL_PARTITIONS_H
+
+#include "protocol.h"
+
+struct virtual_partition {
+ struct virtual_partition *next;
+ const char *name;
+ void (*handler)(struct protocol_handle *phandle, const char *arg);
+};
+
+int try_handle_virtual_partition(struct protocol_handle *handle, const char *arg);
+
+void virtual_partition_register(
+ const char * name,
+ void (*handler)(struct protocol_handle *phandle, const char *arg));
+
+#endif
diff --git a/fastbootd/config.c b/fastbootd/config.c
index b8503fd..fe6da69 100644
--- a/fastbootd/config.c
+++ b/fastbootd/config.c
@@ -35,29 +35,13 @@
#include <sys/types.h>
#include "protocol.h"
+#include "utils.h"
#include "debug.h"
// TODO: change config path
#define CONFIG_PATH "/data/fastboot.cfg"
-static char *strip(char *str)
-{
- int n;
-
- n = strspn(str, " \t");
- str += n;
-
- for (n = strlen(str) - 1; n >= 0; n--) {
- if (str[n] == ' ' || str[n] == '\t')
- str[n] = '\0';
- else
- break;
- }
-
- return str;
-}
-
static int config_parse_line(char *line)
{
char *c;
diff --git a/fastbootd/fastbootd.c b/fastbootd/fastbootd.c
index 98df0db..2b51b33 100644
--- a/fastbootd/fastbootd.c
+++ b/fastbootd/fastbootd.c
@@ -16,30 +16,85 @@
#include <stdio.h>
#include <unistd.h>
-
#include <cutils/klog.h>
+#include <getopt.h>
+#include <stdlib.h>
#include "debug.h"
+#include "trigger.h"
+#include "socket_client.h"
+#include "secure.h"
unsigned int debug_level = DEBUG;
void commands_init();
void usb_init();
void config_init();
+int transport_socket_init();
+int network_discovery_init();
+void ssh_server_start();
int main(int argc, char **argv)
{
+ int socket_client = 0;
+ int c;
+ int network = 1;
+
+ klog_init();
+ klog_set_level(6);
+
+ const struct option longopts[] = {
+ {"socket", no_argument, 0, 'S'},
+ {"nonetwork", no_argument, 0, 'n'},
+ {0, 0, 0, 0}
+ };
+
+ while (1) {
+ c = getopt_long(argc, argv, "Sn", longopts, NULL);
+ /* Alphabetical cases */
+ if (c < 0)
+ break;
+ switch (c) {
+ case 'S':
+ socket_client = 1;
+ break;
+ case 'n':
+ network = 0;
+ break;
+ case '?':
+ return 1;
+ default:
+ return 0;
+ }
+ }
+
(void)argc;
(void)argv;
klog_init();
klog_set_level(6);
- config_init();
- commands_init();
- usb_init();
- while (1) {
- sleep(1);
+ if (socket_client) {
+ //TODO: Shouldn't we change current tty into raw mode?
+ run_socket_client();
+ }
+ else {
+ cert_init_crypto();
+ config_init();
+ load_trigger();
+ commands_init();
+ usb_init();
+
+ if (network) {
+ if (!transport_socket_init())
+ exit(1);
+ ssh_server_start();
+ network_discovery_init();
+ }
+
+ while (1) {
+ sleep(1);
+ }
}
return 0;
}
diff --git a/fastbootd/include/vendor_trigger.h b/fastbootd/include/vendor_trigger.h
new file mode 100644
index 0000000..51204fa
--- /dev/null
+++ b/fastbootd/include/vendor_trigger.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef __VENDOR_TRIGGER_H_
+#define __VENDOR_TRIGGER_H_
+
+#define TRIGGER_MODULE_ID "fastbootd"
+#include <hardware/hardware.h>
+
+__BEGIN_DECLS
+
+struct GPT_entry_raw;
+struct GPT_content;
+
+/*
+ * Structer with function pointers may become longer in the future
+ */
+
+struct vendor_trigger_t {
+ struct hw_device_t common;
+
+ /*
+ * This function runs at the beggining and shoud never be changed
+ *
+ * version is number parameter indicating version on the fastbootd side
+ * libversion is version indicateing version of the library version
+ *
+ * returns 0 if it can cooperate with the current version and 1 in opposite
+ */
+ int (*check_version)(const int version, int *libversion);
+
+
+ /*
+ * Return value -1 forbid the action from the vendor site and sets errno
+ */
+ int (* gpt_layout)(struct GPT_content *);
+ int (* oem_cmd)(const char *arg, const char **response);
+};
+
+__END_DECLS
+
+#endif
diff --git a/fastbootd/network_discovery.c b/fastbootd/network_discovery.c
new file mode 100644
index 0000000..1cd3e48
--- /dev/null
+++ b/fastbootd/network_discovery.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <stdio.h>
+#include <string.h>
+#include <dns_sd.h>
+#include <cutils/properties.h>
+#include <unistd.h>
+
+#include "debug.h"
+#include "network_discovery.h"
+#include "utils.h"
+
+#define MDNS_SERVICE_NAME "mdnsd"
+#define MDNS_SERVICE_STATUS "init.svc.mdnsd"
+#define FASTBOOTD_TYPE "_fastbootd._tcp"
+#define FASTBOOTD_DOMAIN "local."
+#define FASTBOOTD_NAME "fastbootd"
+
+
+static void reg_reply(DNSServiceRef sdref, const DNSServiceFlags flags, DNSServiceErrorType errorCode,
+ const char *name, const char *regtype, const char *domain, void *context)
+{
+ (void)sdref; // Unused
+ (void)flags; // Unused
+ (void)context; // Unused
+ if (errorCode == kDNSServiceErr_ServiceNotRunning) {
+ fprintf(stderr, "Error code %d\n", errorCode);
+ }
+
+
+ printf("Got a reply for service %s.%s%s: ", name, regtype, domain);
+
+ if (errorCode == kDNSServiceErr_NoError)
+ {
+ if (flags & kDNSServiceFlagsAdd)
+ printf("Name now registered and active\n");
+ else
+ printf("Name registration removed\n");
+ if (errorCode == kDNSServiceErr_NameConflict)
+ printf("Name in use, please choose another\n");
+ else
+ printf("Error %d\n", errorCode);
+
+ if (!(flags & kDNSServiceFlagsMoreComing)) fflush(stdout);
+ }
+}
+
+static int register_service() {
+ DNSServiceRef sdref = NULL;
+ const char *domain = FASTBOOTD_DOMAIN;
+ const char *type = FASTBOOTD_TYPE;
+ const char *host = NULL;
+ char name[PROP_VALUE_MAX];
+ uint16_t port = 22;
+ int flags = 0;
+ DNSServiceErrorType result;
+ property_get("ro.serialno", name, "");
+ if (!strcmp(name, "")) {
+ D(ERR, "No property serialno");
+ return -1;
+ }
+
+ result = DNSServiceRegister(&sdref, flags, kDNSServiceInterfaceIndexAny,
+ name, type, domain, host, port,
+ 0, NULL, reg_reply, NULL);
+ if (result != kDNSServiceErr_NoError) {
+ D(ERR, "Unable to register service");
+ return -1;
+ }
+ return 0;
+}
+
+
+int network_discovery_init()
+{
+ D(INFO, "Starting discovery");
+ if (service_start(MDNS_SERVICE_NAME)) {
+ D(ERR, "Unable to start discovery");
+ return -1;
+ }
+
+ if (register_service()) {
+ D(ERR, "Unable to register service");
+ return -1;
+ }
+
+ return 0;
+}
+
diff --git a/fastbootd/network_discovery.h b/fastbootd/network_discovery.h
new file mode 100644
index 0000000..75fda63
--- /dev/null
+++ b/fastbootd/network_discovery.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef _FASTBOOTD_NETWORK_DISCOVERY_H
+#define _FASTBOOTD_NETWORK_DISCOVERY_H
+
+int network_discovery_init();
+
+#endif
diff --git a/fastbootd/other/gptedit.c b/fastbootd/other/gptedit.c
new file mode 100644
index 0000000..16d34a5
--- /dev/null
+++ b/fastbootd/other/gptedit.c
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <unistd.h>
+
+#include <cutils/klog.h>
+
+#include "commands/partitions.h"
+#include "debug.h"
+
+unsigned int debug_level = DEBUG;
+//TODO: add tool to generate config file
+
+void usage() {
+ fprintf(stderr,
+ "usage: test_gpt [ <option> ] <file>\n"
+ "\n"
+ "options:\n"
+ " -p print partitions\n"
+ " -c print config file\n"
+ " -a adds new partition\n"
+ " -d deletes partition (-o needed)\n"
+ "\n"
+ " -n name@startlba,endlba new partition detail\n"
+ " -o old partition name\n"
+ " -t type guid\n"
+ " -g partition guid\n"
+ " -l gpt_location specyfies gpt secto\n"
+ );
+
+}
+
+void printGPT(struct GPT_entry_table *table);
+void addGPT(struct GPT_entry_table *table, const char *arg, const char *guid, const char *tguid);
+void deleteGPT(struct GPT_entry_table *table, const char *name);
+void configPrintGPT(struct GPT_entry_table *table);
+
+int main(int argc, char *argv[]) {
+ int print_cmd = 0;
+ int config_cmd = 0;
+ int add_cmd = 0;
+ int del_cmd = 0;
+ int sync_cmd = 0;
+ int c;
+ const char *new_partition = NULL;
+ const char *old_partition = NULL;
+ const char *type_guid = NULL;
+ const char *partition_guid = NULL;
+ unsigned gpt_location = 1;
+
+ klog_init();
+ klog_set_level(6);
+
+ const struct option longopts[] = {
+ {"print", no_argument, 0, 'p'},
+ {"config-print", no_argument, 0, 'c'},
+ {"add", no_argument, 0, 'a'},
+ {"del", no_argument, 0, 'd'},
+ {"new", required_argument, 0, 'n'},
+ {"old", required_argument, 0, 'o'},
+ {"type", required_argument, 0, 't'},
+ {"sync", required_argument, 0, 's'},
+ {"guid", required_argument, 0, 'g'},
+ {"location", required_argument, 0, 'l'},
+ {0, 0, 0, 0}
+ };
+
+ while (1) {
+ c = getopt_long(argc, argv, "pcadt:g:n:o:sl:", longopts, NULL);
+ /* Alphabetical cases */
+ if (c < 0)
+ break;
+ switch (c) {
+ case 'p':
+ print_cmd = 1;
+ break;
+ case 'c':
+ config_cmd = 1;
+ break;
+ case 'a':
+ add_cmd = 1;
+ break;
+ case 'd':
+ del_cmd = 1;
+ break;
+ case 'n':
+ new_partition = optarg;
+ break;
+ case 'o':
+ old_partition = optarg;
+ break;
+ case 't':
+ type_guid = optarg;
+ case 'g':
+ partition_guid = optarg;
+ break;
+ case 's':
+ sync_cmd = 1;
+ break;
+ case 'l':
+ gpt_location = strtoul(optarg, NULL, 10);
+ fprintf(stderr, "Got offset as %d", gpt_location);
+ break;
+ case '?':
+ return 1;
+ default:
+ abort();
+ }
+ }
+
+ argc -= optind;
+ argv += optind;
+
+ if (argc < 1) {
+ usage();
+ return 1;
+ }
+
+ const char *path = argv[0];
+ struct GPT_entry_table *table = GPT_get_device(path, gpt_location);
+ if (table == NULL) {
+ fprintf(stderr, "unable to get GPT table from %s\n", path);
+ return 1;
+ }
+
+ if (add_cmd)
+ addGPT(table, new_partition, partition_guid, type_guid);
+ if (del_cmd)
+ deleteGPT(table, old_partition);
+ if (print_cmd)
+ printGPT(table);
+ if (config_cmd)
+ configPrintGPT(table);
+ if (sync_cmd)
+ GPT_sync(table);
+
+ GPT_release_device(table);
+
+ return 0;
+}
+
+void printGPT(struct GPT_entry_table *table) {
+ struct GPT_entry_raw *entry = table->entries;
+ unsigned n, m;
+ char name[GPT_NAMELEN + 1];
+
+ printf("ptn start block end block name\n");
+ printf("---- ------------- -------------\n");
+
+ for (n = 0; n < table->header->entries_count; n++, entry++) {
+ if (entry->type_guid[0] == 0)
+ continue;
+ for (m = 0; m < GPT_NAMELEN; m++) {
+ name[m] = entry->name[m] & 127;
+ }
+ name[m] = 0;
+ printf("#%03d %13lld %13lld %s\n",
+ n + 1, entry->first_lba, entry->last_lba, name);
+ }
+}
+
+void configPrintGPT(struct GPT_entry_table *table) {
+ struct GPT_entry_raw *entry = table->entries;
+ unsigned n, m;
+ char name[GPT_NAMELEN + 1];
+ char temp_guid[17];
+ temp_guid[16] = 0;
+
+ printf("header_lba %lld\n", table->header->current_lba);
+ printf("backup_lba %lld\n", table->header->backup_lba);
+ printf("first_lba %lld\n", table->header->first_usable_lba);
+ printf("last_lba %lld\n", table->header->last_usable_lba);
+ printf("entries_lba %lld\n", table->header->entries_lba);
+ snprintf(temp_guid, 17, "%s", table->header->disk_guid);
+ printf("guid \"%s\"", temp_guid);
+
+ printf("\npartitions {\n");
+
+ for (n = 0; n < table->header->entries_count; n++, entry++) {
+ uint64_t size = entry->last_lba - entry->first_lba + 1;
+
+ if (entry->type_guid[0] == 0)
+ continue;
+ for (m = 0; m < GPT_NAMELEN; m++) {
+ name[m] = entry->name[m] & 127;
+ }
+ name[m] = 0;
+
+ printf(" %s {\n", name);
+ snprintf(temp_guid, 17, "%s", entry->partition_guid);
+ printf(" guid \"%s\"\n", temp_guid);
+ printf(" first_lba %lld\n", entry->first_lba);
+ printf(" partition_size %lld\n", size);
+ if (entry->flags & GPT_FLAG_SYSTEM)
+ printf(" system\n");
+ if (entry->flags & GPT_FLAG_BOOTABLE)
+ printf(" bootable\n");
+ if (entry->flags & GPT_FLAG_READONLY)
+ printf(" readonly\n");
+ if (entry->flags & GPT_FLAG_DOAUTOMOUNT)
+ printf(" automount\n");
+ printf(" }\n\n");
+ }
+ printf("}\n");
+}
+
+void addGPT(struct GPT_entry_table *table, const char *str , const char *guid, const char *tguid) {
+ char *c, *c2;
+ char *arg = malloc(strlen(str));
+ char *name = arg;
+ unsigned start, end;
+ strcpy(arg, str);
+ if (guid == NULL || tguid == NULL) {
+ fprintf(stderr, "Type guid and partion guid needed");
+ free(arg);
+ return;
+ }
+
+ c = strchr(arg, '@');
+
+ if (c == NULL) {
+ fprintf(stderr, "Wrong entry format");
+ free(arg);
+ return;
+ }
+
+ *c++ = '\0';
+
+ c2 = strchr(c, ',');
+
+ if (c2 == NULL) {
+ fprintf(stderr, "Wrong entry format");
+ free(arg);
+ return;
+ }
+
+ start = strtoul(c, NULL, 10);
+ *c2++ = '\0';
+ end = strtoul(c2, NULL, 10);
+
+ struct GPT_entry_raw data;
+ strncpy((char *)data.partition_guid, guid, 15);
+ data.partition_guid[15] = '\0';
+ strncpy((char *)data.type_guid, tguid, 15);
+ data.type_guid[15] = '\0';
+ GPT_to_UTF16(data.name, name, GPT_NAMELEN);
+ data.first_lba = start;
+ data.last_lba = end;
+
+ fprintf(stderr, "Adding (%d,%d) %s as, [%s, %s]", start, end, name, (char *) data.type_guid, (char *) data.partition_guid);
+ GPT_add_entry(table, &data);
+ free(arg);
+}
+
+void deleteGPT(struct GPT_entry_table *table, const char *name) {
+ struct GPT_entry_raw *entry;
+
+ if (name == NULL) {
+ fprintf(stderr, "Need partition name");
+ return;
+ }
+
+ entry = GPT_get_pointer_by_name(table, name);
+
+ if (!entry) {
+ fprintf(stderr, "Unable to find partition: %s", name);
+ return;
+ }
+ GPT_delete_entry(table, entry);
+}
+
diff --git a/fastbootd/other/partitions.sample.cfg b/fastbootd/other/partitions.sample.cfg
new file mode 100644
index 0000000..49562cf
--- /dev/null
+++ b/fastbootd/other/partitions.sample.cfg
@@ -0,0 +1,60 @@
+
+header_lba 1
+backup_lba 101
+first_lba 43
+last_lba 100
+entries_lba 2
+
+partitions {
+ #You can generate this as output from gptedit -c
+ SOS {
+ first_lba 28672
+ partition_size 16384
+ }
+
+ DTB {
+ first_lba 45056
+ partition_size 8192
+ }
+
+ LNX {
+ first_lba 53248
+ partition_size 16384
+ }
+
+ APP {
+ first_lba 69632
+ partition_size 1048576
+ }
+
+ CAC {
+ first_lba 1118208
+ partition_size 1572864
+ }
+
+ MSC {
+ first_lba 2691072
+ partition_size 4096
+ }
+
+ USP {
+ first_lba 2695168
+ partition_size 65536
+ }
+
+ MDA {
+ first_lba 2760704
+ partition_size 4096
+ }
+
+ FCT {
+ first_lba 2764800
+ partition_size 32768
+ }
+
+ UDA {
+ first_lba 2797568
+ partition_size 27975680
+ }
+}
+
diff --git a/fastbootd/other/sign/src/SignImg.java b/fastbootd/other/sign/src/SignImg.java
new file mode 100644
index 0000000..338d427
--- /dev/null
+++ b/fastbootd/other/sign/src/SignImg.java
@@ -0,0 +1,181 @@
+package signtool;
+
+import java.io.*;
+import java.util.Properties;
+import java.util.ArrayList;
+
+import javax.mail.internet.*;
+import javax.mail.MessagingException;
+import javax.mail.Session;
+import javax.activation.MailcapCommandMap;
+import javax.activation.CommandMap;
+
+import java.security.PrivateKey;
+import java.security.Security;
+import java.security.KeyFactory;
+import java.security.KeyStore;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.InvalidKeySpecException;
+import java.security.cert.X509Certificate;
+import java.security.cert.CertificateFactory;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateEncodingException;
+
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
+import org.bouncycastle.cms.jcajce.JcaSignerInfoGeneratorBuilder;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.bouncycastle.cms.CMSProcessableByteArray;
+import org.bouncycastle.cms.CMSSignedGenerator;
+import org.bouncycastle.cms.CMSSignedDataGenerator;
+import org.bouncycastle.cms.CMSSignedGenerator;
+import org.bouncycastle.cms.CMSProcessable;
+import org.bouncycastle.cms.CMSSignedData;
+import org.bouncycastle.cms.CMSTypedData;
+import org.bouncycastle.cert.jcajce.JcaCertStore;
+import org.bouncycastle.util.Store;
+import org.bouncycastle.asn1.ASN1InputStream;
+import org.bouncycastle.asn1.DEROutputStream;
+import org.bouncycastle.asn1.ASN1Object;
+
+
+public class SignImg {
+
+ /* It reads private key in pkcs#8 formate
+ * Conversion:
+ * openssl pkcs8 -topk8 -nocrypt -outform DER < inkey.pem > outkey.pk8
+ */
+ private static PrivateKey getPrivateKey(String path) throws IOException, FileNotFoundException, NoSuchAlgorithmException, InvalidKeySpecException {
+ File file = new File(path);
+ FileInputStream fis = new FileInputStream(file);
+ byte[] data = new byte[(int)file.length()];
+ fis.read(data);
+ fis.close();
+
+ PKCS8EncodedKeySpec kspec = new PKCS8EncodedKeySpec(data);
+ KeyFactory kf = KeyFactory.getInstance("RSA");
+ PrivateKey privateKey = kf.generatePrivate(kspec);
+
+ return privateKey;
+ }
+
+ private static MimeBodyPart getContent(String path) throws IOException, FileNotFoundException, MessagingException {
+ MimeBodyPart body = new MimeBodyPart();
+
+ File file = new File(path);
+ FileInputStream fis = new FileInputStream(file);
+ byte[] data = new byte[(int)file.length()];
+ fis.read(data);
+ fis.close();
+
+ body.setContent(data, "application/octet-stream");
+
+ return body;
+ }
+
+ private static CMSProcessableByteArray getCMSContent(String path) throws IOException, FileNotFoundException, MessagingException {
+ File file = new File(path);
+ FileInputStream fis = new FileInputStream(file);
+ byte[] data = new byte[(int)file.length()];
+ fis.read(data);
+ fis.close();
+ CMSProcessableByteArray cms = new CMSProcessableByteArray(data);
+
+ return cms;
+ }
+
+ private static X509Certificate readCert(String path) throws IOException, FileNotFoundException, CertificateException {
+ File file = new File(path);
+ FileInputStream is = new FileInputStream(file);
+
+ CertificateFactory cf = CertificateFactory.getInstance("X.509");
+ Certificate cert = cf.generateCertificate(is);
+ is.close();
+
+ return (X509Certificate) cert;
+ }
+
+ private static void save(MimeBodyPart content, String path) throws IOException, FileNotFoundException, MessagingException {
+ File file = new File(path);
+ FileOutputStream os = new FileOutputStream(file);
+
+ content.writeTo(os);
+
+ os.close();
+ }
+
+ private static Store certToStore(X509Certificate certificate) throws CertificateEncodingException {
+ ArrayList<X509Certificate> certList = new ArrayList<X509Certificate>();
+ certList.add(certificate);
+ return new JcaCertStore(certList);
+ }
+
+ public static void setDefaultMailcap()
+ {
+ MailcapCommandMap _mailcap =
+ (MailcapCommandMap)CommandMap.getDefaultCommandMap();
+
+ _mailcap.addMailcap("application/pkcs7-signature;; x-java-content-handler=org.bouncycastle.mail.smime.handlers.pkcs7_signature");
+ _mailcap.addMailcap("application/pkcs7-mime;; x-java-content-handler=org.bouncycastle.mail.smime.handlers.pkcs7_mime");
+ _mailcap.addMailcap("application/x-pkcs7-signature;; x-java-content-handler=org.bouncycastle.mail.smime.handlers.x_pkcs7_signature");
+ _mailcap.addMailcap("application/x-pkcs7-mime;; x-java-content-handler=org.bouncycastle.mail.smime.handlers.x_pkcs7_mime");
+ _mailcap.addMailcap("multipart/signed;; x-java-content-handler=org.bouncycastle.mail.smime.handlers.multipart_signed");
+
+ CommandMap.setDefaultCommandMap(_mailcap);
+ }
+
+ public static void main(String[] args) {
+ try {
+ if (args.length < 4) {
+ System.out.println("Usage: signimg data private_key certificate output");
+ return;
+ }
+ System.out.println("Signing the image");
+ setDefaultMailcap();
+
+ Security.addProvider(new BouncyCastleProvider());
+
+ PrivateKey key = getPrivateKey(args[1]);
+ System.out.println("File read sucessfully");
+
+ CMSSignedDataGenerator generator = new CMSSignedDataGenerator();
+
+ CMSTypedData body = getCMSContent(args[0]);
+ System.out.println("Content read sucessfully");
+
+ X509Certificate cert = (X509Certificate) readCert(args[2]);
+ System.out.println("Certificate read sucessfully");
+
+ ContentSigner sha256Signer = new JcaContentSignerBuilder("SHA256withRSA").setProvider("BC").build(key);
+
+ Store certs = certToStore(cert);
+
+ generator.addCertificates(certs);
+ generator.addSignerInfoGenerator(
+ new JcaSignerInfoGeneratorBuilder(
+ new JcaDigestCalculatorProviderBuilder().setProvider("BC").build())
+ .build(sha256Signer, cert));
+
+ CMSSignedData signed = generator.generate(body, true);
+ System.out.println("Signed");
+
+ Properties props = System.getProperties();
+ Session session = Session.getDefaultInstance(props, null);
+
+ File file = new File(args[3]);
+ FileOutputStream os = new FileOutputStream(file);
+
+ ASN1InputStream asn1 = new ASN1InputStream(signed.getEncoded());
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ DEROutputStream dOut = new DEROutputStream(os);
+ dOut.writeObject(ASN1Object.fromByteArray(signed.getEncoded()));
+
+ }
+ catch (Exception ex) {
+ System.out.println("Exception during programm execution: " + ex.getMessage());
+ }
+ }
+}
diff --git a/fastbootd/other/vendor_trigger.c b/fastbootd/other/vendor_trigger.c
new file mode 100644
index 0000000..101959b
--- /dev/null
+++ b/fastbootd/other/vendor_trigger.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <stdlib.h>
+
+#include "vendor_trigger.h"
+#include "debug.h"
+
+unsigned int debug_level = DEBUG;
+
+static const int version = 1;
+
+int check_version(const int fastboot_version, int *libversion) {
+ *libversion = version;
+ return !(fastboot_version == version);
+}
+
+int gpt_layout(struct GPT_content *table) {
+ D(DEBUG, "message from libvendor");
+ return 0;
+}
+
+int oem_cmd(const char *arg, const char **response) {
+ D(DEBUG, "message from libvendor, oem catched request %s", arg);
+ return 0;
+}
+
+static int close_triggers(struct vendor_trigger_t *dev)
+{
+ if (dev)
+ free(dev);
+
+ return 0;
+}
+
+static int open_triggers(const struct hw_module_t *module, char const *name,
+ struct hw_device_t **device) {
+ struct vendor_trigger_t *dev = malloc(sizeof(struct vendor_trigger_t));
+ klog_init();
+ klog_set_level(6);
+
+ memset(dev, 0, sizeof(*dev));
+ dev->common.module = (struct hw_module_t *) module;
+ dev->common.close = (int (*)(struct hw_device_t *)) close_triggers;
+
+ dev->gpt_layout = gpt_layout;
+ dev->oem_cmd = oem_cmd;
+
+ *device = (struct hw_device_t *) dev;
+
+ return 0;
+}
+
+
+static struct hw_module_methods_t trigger_module_methods = {
+ .open = open_triggers,
+};
+
+struct hw_module_t HAL_MODULE_INFO_SYM = {
+ .tag = HARDWARE_MODULE_TAG,
+ .version_major = 1,
+ .version_minor = 0,
+ .id = TRIGGER_MODULE_ID,
+ .name = "vendor trigger library for fastbootd",
+ .author = "Google, Inc.",
+ .methods = &trigger_module_methods,
+};
+
diff --git a/fastbootd/secure.c b/fastbootd/secure.c
new file mode 100644
index 0000000..a657ad4
--- /dev/null
+++ b/fastbootd/secure.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <openssl/pem.h>
+#include <openssl/engine.h>
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/pem.h>
+#include <openssl/cms.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "secure.h"
+#include "debug.h"
+#include "utils.h"
+
+
+void cert_init_crypto() {
+ CRYPTO_malloc_init();
+ ERR_load_crypto_strings();
+ OpenSSL_add_all_algorithms();
+ ENGINE_load_builtin_engines();
+}
+
+X509_STORE *cert_store_from_path(const char *path) {
+
+ X509_STORE *store;
+ struct stat st;
+ X509_LOOKUP *lookup;
+
+ if (stat(path, &st)) {
+ D(ERR, "Unable to stat cert path");
+ goto error;
+ }
+
+ if (!(store = X509_STORE_new())) {
+ goto error;
+ }
+
+ if (S_ISDIR(st.st_mode)) {
+ lookup = X509_STORE_add_lookup(store,X509_LOOKUP_hash_dir());
+ if (lookup == NULL)
+ goto error;
+ if (!X509_LOOKUP_add_dir(lookup, path, X509_FILETYPE_PEM)) {
+ D(ERR, "Error loading cert directory %s", path);
+ goto error;
+ }
+ }
+ else if(S_ISREG(st.st_mode)) {
+ lookup = X509_STORE_add_lookup(store,X509_LOOKUP_file());
+ if (lookup == NULL)
+ goto error;
+ if (!X509_LOOKUP_load_file(lookup, path, X509_FILETYPE_PEM)) {
+ D(ERR, "Error loading cert directory %s", path);
+ goto error;
+ }
+ }
+ else {
+ D(ERR, "cert path is not directory or regular file");
+ goto error;
+ }
+
+ return store;
+
+error:
+ return NULL;
+}
+
+
+int cert_read(int fd, CMS_ContentInfo **content, BIO **output) {
+ BIO *input;
+ *output = NULL;
+
+
+ input = BIO_new_fd(fd, BIO_NOCLOSE);
+ if (input == NULL) {
+ D(ERR, "Unable to open input");
+ goto error;
+ }
+
+ //TODO:
+ // read with d2i_CMS_bio to support DER
+ // with java or just encode data with base64
+ *content = SMIME_read_CMS(input, output);
+ if (*content == NULL) {
+ unsigned long err = ERR_peek_last_error();
+ D(ERR, "Unable to parse input file: %s", ERR_lib_error_string(err));
+ goto error_read;
+ }
+
+ BIO_free(input);
+
+ return 0;
+
+error_read:
+ BIO_free(input);
+error:
+ return 1;
+}
+
+int cert_verify(BIO *content, CMS_ContentInfo *content_info, X509_STORE *store, int *out_fd) {
+ BIO *output_temp;
+ int ret;
+
+ *out_fd = create_temp_file();
+ if (*out_fd < 0) {
+ D(ERR, "unable to create temporary file");
+ return -1;
+ }
+
+ output_temp = BIO_new_fd(*out_fd, BIO_NOCLOSE);
+ if (output_temp == NULL) {
+ D(ERR, "unable to create temporary bio");
+ close(*out_fd);
+ return -1;
+ }
+
+ ret = CMS_verify(content_info, NULL ,store, content, output_temp, 0);
+
+ if (ret == 0) {
+ char buf[256];
+ unsigned long err = ERR_peek_last_error();
+ D(ERR, "Verification failed with reason: %s, %s", ERR_lib_error_string(err), ERR_error_string(err, buf));
+ D(ERR, "Data used: content %d", (int) content);
+ }
+
+ ERR_clear_error();
+ ERR_remove_state(0);
+
+ BIO_free(output_temp);
+
+ return ret;
+}
+
+void cert_release(BIO *content, CMS_ContentInfo *info) {
+ BIO_free(content);
+ CMS_ContentInfo_free(info);
+}
+
diff --git a/fastbootd/secure.h b/fastbootd/secure.h
new file mode 100644
index 0000000..878a643
--- /dev/null
+++ b/fastbootd/secure.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef _FASTBOOTD_SECURE_H
+#define _FASTBOOTD_SECURE_H
+
+#include <openssl/ssl.h>
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/pem.h>
+#include <openssl/cms.h>
+
+void cert_init_crypto();
+
+X509_STORE *cert_store_from_path(const char*stream);
+
+static inline void cert_release_store(X509_STORE *store) {
+ X509_STORE_free(store);
+}
+
+int cert_read(int fd, CMS_ContentInfo **content, BIO **output);
+int cert_verify(BIO *content, CMS_ContentInfo *content_info, X509_STORE *store, int *out_fd);
+void cert_release(BIO *content, CMS_ContentInfo *info);
+
+#endif
diff --git a/fastbootd/socket_client.c b/fastbootd/socket_client.c
new file mode 100644
index 0000000..da636db
--- /dev/null
+++ b/fastbootd/socket_client.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <stdio.h>
+#include <cutils/sockets.h>
+#include <poll.h>
+#include <unistd.h>
+
+#include "utils.h"
+
+#define BUFFER_SIZE 256
+
+#define STDIN_FD 0
+#define STDOUT_FD 1
+#define STDERR_FD 2
+
+void run_socket_client() {
+ int fd;
+ char buffer[BUFFER_SIZE];
+ int n;
+ struct pollfd fds[2];
+
+ fd = socket_local_client("fastbootd",
+ ANDROID_SOCKET_NAMESPACE_RESERVED,
+ SOCK_STREAM);
+
+ if (fd < 0) {
+ fprintf(stderr, "ERROR: Unable to open fastbootd socket\n");
+ return;
+ }
+
+ fds[0].fd = STDIN_FD;
+ fds[0].events = POLLIN;
+ fds[1].fd = fd;
+ fds[1].events = POLLIN;
+
+ while(true) {
+ if (poll(fds, 2, -1) <= 0) {
+ fprintf(stderr, "ERROR: socket error");
+ return;
+ }
+
+ if (fds[0].revents & POLLIN) {
+ if ((n = read(STDIN_FD, buffer, BUFFER_SIZE)) < 0) {
+ goto error;
+ }
+
+ if (bulk_write(fd, buffer, n) < 0) {
+ goto error;
+ }
+ }
+
+ if (fds[1].revents & POLLIN) {
+ if ((n = read(fd, buffer, BUFFER_SIZE)) < 0) {
+ goto error;
+ }
+
+ if (bulk_write(STDOUT_FD, buffer, n) < 0) {
+ goto error;
+ }
+ }
+ }
+
+error:
+ fprintf(stderr, "Transport error\n");
+}
diff --git a/fastbootd/socket_client.h b/fastbootd/socket_client.h
new file mode 100644
index 0000000..4481ff2
--- /dev/null
+++ b/fastbootd/socket_client.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef _FASTBOOTD_SOCKET_CLIENT_H
+#define _FASTBOOTD_SOCKET_CLIENT_H
+
+void run_socket_client();
+
+#endif
diff --git a/fastbootd/transport.c b/fastbootd/transport.c
index 01a5a8a..19a705c 100644
--- a/fastbootd/transport.c
+++ b/fastbootd/transport.c
@@ -99,6 +99,7 @@
}
if (ret > 0) {
buffer[ret] = 0;
+ //TODO: multiple threads
protocol_handle_command(phandle, buffer);
}
}
diff --git a/fastbootd/transport_socket.c b/fastbootd/transport_socket.c
new file mode 100644
index 0000000..ff0f3bd
--- /dev/null
+++ b/fastbootd/transport_socket.c
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <cutils/sockets.h>
+
+#include "debug.h"
+#include "transport.h"
+#include "utils.h"
+
+
+#define container_of(ptr, type, member) \
+ ((type*)((char*)(ptr) - offsetof(type, member)))
+
+#define SOCKET_WORKING 0
+#define SOCKET_STOPPED -1
+
+
+struct socket_transport {
+ struct transport transport;
+
+ int fd;
+};
+
+struct socket_handle {
+ struct transport_handle handle;
+
+ int fd;
+};
+
+void socket_close(struct transport_handle *thandle)
+{
+ struct socket_handle * handle = container_of(thandle, struct socket_handle, handle);
+ close(handle->fd);
+}
+
+struct transport_handle *socket_connect(struct transport *transport)
+{
+ struct socket_handle *handle = calloc(sizeof(struct socket_handle), 1);
+ struct socket_transport *socket_transport = container_of(transport, struct socket_transport, transport);
+ struct sockaddr addr;
+ socklen_t alen = sizeof(addr);
+
+ handle->fd = accept(socket_transport->fd, &addr, &alen);
+
+ if (handle->fd < 0) {
+ D(WARN, "socket connect error");
+ return NULL;
+ }
+
+ D(DEBUG, "[ socket_thread - registering device ]");
+ return &handle->handle;
+}
+
+ssize_t socket_write(struct transport_handle *thandle, const void *data, size_t len)
+{
+ ssize_t ret;
+ struct socket_handle *handle = container_of(thandle, struct socket_handle, handle);
+
+ D(DEBUG, "about to write (fd=%d, len=%d)", handle->fd, len);
+ ret = bulk_write(handle->fd, data, len);
+ if (ret < 0) {
+ D(ERR, "ERROR: fd = %d, ret = %zd", handle->fd, ret);
+ return -1;
+ }
+ D(DEBUG, "[ socket_write done fd=%d ]", handle->fd);
+ return ret;
+}
+
+ssize_t socket_read(struct transport_handle *thandle, void *data, size_t len)
+{
+ ssize_t ret;
+ struct socket_handle *handle = container_of(thandle, struct socket_handle, handle);
+
+ D(DEBUG, "about to read (fd=%d, len=%d)", handle->fd, len);
+ ret = bulk_read(handle->fd, data, len);
+ if (ret < 0) {
+ D(ERR, "ERROR: fd = %d, ret = %zd", handle->fd, ret);
+ return -1;
+ }
+ D(DEBUG, "[ socket_read done fd=%d ret=%zd]", handle->fd, ret);
+ return ret;
+}
+
+static int listen_socket_init(struct socket_transport *socket_transport)
+{
+ int s = android_get_control_socket("fastbootd");
+
+ if (s < 0) {
+ D(WARN, "android_get_control_socket(fastbootd): %s\n", strerror(errno));
+ return 0;
+ }
+
+ if (listen(s, 4) < 0) {
+ D(WARN, "listen(control socket): %s\n", strerror(errno));
+ return 0;
+ }
+
+ socket_transport->fd = s;
+
+ return 1;
+}
+
+
+int transport_socket_init()
+{
+ struct socket_transport *socket_transport = malloc(sizeof(struct socket_transport));
+
+ socket_transport->transport.connect = socket_connect;
+ socket_transport->transport.close = socket_close;
+ socket_transport->transport.read = socket_read;
+ socket_transport->transport.write = socket_write;
+
+ if (!listen_socket_init(socket_transport)) {
+ D(ERR, "socket transport init failed");
+ free(socket_transport);
+ return 0;
+ }
+
+ transport_register(&socket_transport->transport);
+ return 1;
+}
+
diff --git a/fastbootd/trigger.c b/fastbootd/trigger.c
new file mode 100644
index 0000000..e63e64d
--- /dev/null
+++ b/fastbootd/trigger.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <dlfcn.h>
+
+#include <hardware/hardware.h>
+#include "debug.h"
+#include "trigger.h"
+#include "protocol.h"
+#include "vendor_trigger.h"
+
+static const int version = 1;
+
+static struct vendor_trigger_t *triggers = NULL;
+
+int load_trigger() {
+ int err;
+ hw_module_t* module;
+ hw_device_t* device;
+ int libversion;
+
+ err = hw_get_module(TRIGGER_MODULE_ID, (hw_module_t const**)&module);
+
+ if (err == 0) {
+ err = module->methods->open(module, NULL, &device);
+
+ if (err == 0) {
+ triggers = (struct vendor_trigger_t *) device;
+ } else {
+ D(WARN, "Libvendor load error");
+ return 1;
+ }
+ }
+ else {
+ D(WARN, "Libvendor not load: %s", strerror(-err));
+ return 0;
+ }
+
+ if (triggers->check_version != NULL &&
+ triggers->check_version(version, &libversion)) {
+
+ triggers = NULL;
+ D(ERR, "Library report incompability");
+ return 1;
+ }
+ D(INFO, "libvendortrigger loaded");
+
+ return 0;
+}
+
+int trigger_oem_cmd(const char *arg, const char **response) {
+ if (triggers != NULL && triggers->oem_cmd != NULL)
+ return triggers->oem_cmd(arg, response);
+ return 0;
+}
+
+int trigger_gpt_layout(struct GPT_content *table) {
+ if (triggers != NULL && triggers->gpt_layout != NULL)
+ return triggers->gpt_layout(table);
+ return 0;
+}
+
diff --git a/fastbootd/trigger.h b/fastbootd/trigger.h
new file mode 100644
index 0000000..404acb4
--- /dev/null
+++ b/fastbootd/trigger.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef __FASTBOOTD_TRIGGER_H_
+#define __FASTBOOTD_TRIGGER_H_
+
+#include "commands/partitions.h"
+#include "vendor_trigger.h"
+
+int load_trigger();
+
+/* same as in struct triggers */
+
+int trigger_gpt_layout(struct GPT_content *table);
+int trigger_oem_cmd(const char *arg, const char **response);
+
+#endif
diff --git a/fastbootd/usb_linux_client.c b/fastbootd/usb_linux_client.c
index 111cf35..7a8e46f 100644
--- a/fastbootd/usb_linux_client.c
+++ b/fastbootd/usb_linux_client.c
@@ -30,6 +30,7 @@
#include "debug.h"
#include "transport.h"
+#include "utils.h"
#define TRACE_TAG TRACE_USB
@@ -50,8 +51,6 @@
#define USB_FFS_FASTBOOT_OUT USB_FFS_FASTBOOT_EP(ep1)
#define USB_FFS_FASTBOOT_IN USB_FFS_FASTBOOT_EP(ep2)
-#define READ_BUF_SIZE (16*1024)
-
#define container_of(ptr, type, member) \
((type*)((char*)(ptr) - offsetof(type, member)))
@@ -212,26 +211,6 @@
return -1;
}
-static ssize_t bulk_write(int bulk_in, const char *buf, size_t length)
-{
- size_t count = 0;
- ssize_t ret;
-
- do {
- ret = TEMP_FAILURE_RETRY(write(bulk_in, buf + count, length - count));
- if (ret < 0) {
- D(WARN, "[ bulk_read failed fd=%d length=%d errno=%d %s ]",
- bulk_in, length, errno, strerror(errno));
- return -1;
- } else {
- count += ret;
- }
- } while (count < length);
-
- D(VERBOSE, "[ bulk_write done fd=%d ]", bulk_in);
- return count;
-}
-
static ssize_t usb_write(struct transport_handle *thandle, const void *data, size_t len)
{
ssize_t ret;
@@ -248,30 +227,6 @@
return ret;
}
-static ssize_t bulk_read(int bulk_out, char *buf, size_t length)
-{
- ssize_t ret;
- size_t n = 0;
-
- while (n < length) {
- size_t to_read = (length - n > READ_BUF_SIZE) ? READ_BUF_SIZE : length - n;
- ret = TEMP_FAILURE_RETRY(read(bulk_out, buf + n, to_read));
- if (ret < 0) {
- D(WARN, "[ bulk_read failed fd=%d length=%d errno=%d %s ]",
- bulk_out, length, errno, strerror(errno));
- return ret;
- }
- n += ret;
- if (ret < (ssize_t)to_read) {
- D(VERBOSE, "bulk_read short read, ret=%zd to_read=%u n=%u length=%u",
- ret, to_read, n, length);
- break;
- }
- }
-
- return n;
-}
-
ssize_t usb_read(struct transport_handle *thandle, void *data, size_t len)
{
ssize_t ret;
diff --git a/fastbootd/utils.c b/fastbootd/utils.c
new file mode 100644
index 0000000..fe3f0f8
--- /dev/null
+++ b/fastbootd/utils.c
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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 <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <linux/fs.h>
+#include <stdlib.h>
+#include <cutils/properties.h>
+
+#include "utils.h"
+#include "debug.h"
+
+#ifndef BLKDISCARD
+#define BLKDISCARD _IO(0x12,119)
+#endif
+
+#ifndef BLKSECDISCARD
+#define BLKSECDISCARD _IO(0x12,125)
+#endif
+
+#define READ_BUF_SIZE (16*1024)
+
+int get_stream_size(FILE *stream) {
+ int size;
+ fseek(stream, 0, SEEK_END);
+ size = ftell(stream);
+ fseek(stream, 0, SEEK_SET);
+ return size;
+}
+
+uint64_t get_block_device_size(int fd)
+{
+ uint64_t size = 0;
+ int ret;
+
+ ret = ioctl(fd, BLKGETSIZE64, &size);
+
+ if (ret)
+ return 0;
+
+ return size;
+}
+
+uint64_t get_file_size(int fd)
+{
+ struct stat buf;
+ int ret;
+ int64_t computed_size;
+
+ ret = fstat(fd, &buf);
+ if (ret)
+ return 0;
+
+ if (S_ISREG(buf.st_mode))
+ computed_size = buf.st_size;
+ else if (S_ISBLK(buf.st_mode))
+ computed_size = get_block_device_size(fd);
+ else
+ computed_size = 0;
+
+ return computed_size;
+}
+
+uint64_t get_file_size64(int fd)
+{
+ struct stat64 buf;
+ int ret;
+ uint64_t computed_size;
+
+ ret = fstat64(fd, &buf);
+ if (ret)
+ return 0;
+
+ if (S_ISREG(buf.st_mode))
+ computed_size = buf.st_size;
+ else if (S_ISBLK(buf.st_mode))
+ computed_size = get_block_device_size(fd);
+ else
+ computed_size = 0;
+
+ return computed_size;
+}
+
+
+char *strip(char *str)
+{
+ int n;
+
+ n = strspn(str, " \t");
+ str += n;
+ n = strcspn(str, " \t");
+ str[n] = '\0';
+
+ return str;
+}
+
+int wipe_block_device(int fd, int64_t len)
+{
+ uint64_t range[2];
+ int ret;
+
+ range[0] = 0;
+ range[1] = len;
+ ret = ioctl(fd, BLKSECDISCARD, &range);
+ if (ret < 0) {
+ range[0] = 0;
+ range[1] = len;
+ ret = ioctl(fd, BLKDISCARD, &range);
+ if (ret < 0) {
+ D(WARN, "Discard failed\n");
+ return 1;
+ } else {
+ D(WARN, "Wipe via secure discard failed, used discard instead\n");
+ return 0;
+ }
+ }
+
+ return 0;
+}
+
+int create_temp_file() {
+ char tempname[] = "/dev/fastboot_data_XXXXXX";
+ int fd;
+
+ fd = mkstemp(tempname);
+ if (fd < 0)
+ return -1;
+
+ unlink(tempname);
+
+ return fd;
+}
+
+ssize_t bulk_write(int bulk_in, const char *buf, size_t length)
+{
+ size_t count = 0;
+ ssize_t ret;
+
+ do {
+ ret = TEMP_FAILURE_RETRY(write(bulk_in, buf + count, length - count));
+ if (ret < 0) {
+ D(WARN, "[ bulk_write failed fd=%d length=%d errno=%d %s ]",
+ bulk_in, length, errno, strerror(errno));
+ return -1;
+ } else {
+ count += ret;
+ }
+ } while (count < length);
+
+ D(VERBOSE, "[ bulk_write done fd=%d ]", bulk_in);
+ return count;
+}
+
+ssize_t bulk_read(int bulk_out, char *buf, size_t length)
+{
+ ssize_t ret;
+ size_t n = 0;
+
+ while (n < length) {
+ size_t to_read = (length - n > READ_BUF_SIZE) ? READ_BUF_SIZE : length - n;
+ ret = TEMP_FAILURE_RETRY(read(bulk_out, buf + n, to_read));
+ if (ret < 0) {
+ D(WARN, "[ bulk_read failed fd=%d length=%d errno=%d %s ]",
+ bulk_out, length, errno, strerror(errno));
+ return ret;
+ }
+ n += ret;
+ if (ret < (ssize_t)to_read) {
+ D(VERBOSE, "bulk_read short read, ret=%zd to_read=%u n=%u length=%u",
+ ret, to_read, n, length);
+ break;
+ }
+ }
+
+ return n;
+}
+
+#define NAP_TIME 200 // 200 ms between polls
+static int wait_for_property(const char *name, const char *desired_value, int maxwait)
+{
+ char value[PROPERTY_VALUE_MAX] = {'\0'};
+ int maxnaps = (maxwait * 1000) / NAP_TIME;
+
+ if (maxnaps < 1) {
+ maxnaps = 1;
+ }
+
+ while (maxnaps-- > 0) {
+ usleep(NAP_TIME * 1000);
+ if (property_get(name, value, NULL)) {
+ if (desired_value == NULL || strcmp(value, desired_value) == 0) {
+ return 0;
+ }
+ }
+ }
+ return -1; /* failure */
+}
+
+int service_start(const char *service_name)
+{
+ int result = 0;
+ char property_value[PROPERTY_VALUE_MAX];
+
+ property_get(service_name, property_value, "");
+ if (strcmp("running", property_value) != 0) {
+ D(INFO, "Starting %s", service_name);
+ property_set("ctl.start", service_name);
+ if (wait_for_property(service_name, "running", 5))
+ result = -1;
+ }
+
+ return result;
+}
+
+int service_stop(const char *service_name)
+{
+ int result = 0;
+
+ D(INFO, "Stopping MDNSD");
+ property_set("ctl.stop", service_name);
+ if (wait_for_property(service_name, "stopped", 5))
+ result = -1;
+
+ return result;
+}
+
+int ssh_server_start()
+{
+ return service_start("sshd");
+}
diff --git a/fastbootd/utils.h b/fastbootd/utils.h
new file mode 100644
index 0000000..3d98699
--- /dev/null
+++ b/fastbootd/utils.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2009-2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Google, Inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef _FASTBOOT_UTLIS_H
+#define _FASTBOOT_UTILS_H
+
+#include <stdio.h>
+
+int get_stream_size(FILE *);
+
+char *strip(char *str);
+
+uint64_t get_file_size64(int fd);
+uint64_t get_file_size(int fd);
+uint64_t get_block_device_size(int fd);
+int wipe_block_device(int fd, int64_t len);
+int create_temp_file();
+ssize_t bulk_read(int bulk_out, char *buf, size_t length);
+ssize_t bulk_write(int bulk_in, const char *buf, size_t length);
+int service_start(const char *service_name);
+int service_stop(const char *service_name);
+int ssh_server_start();
+
+#define ROUND_TO_PAGE(address,pagesize) ((address + pagesize - 1) & (~(pagesize - 1)))
+
+#define ROUND_UP(number,size) (((number + size - 1) / size) * size)
+
+#endif
diff --git a/include/utils/CallStack.h b/include/utils/CallStack.h
index 61dc832..2056751 100644
--- a/include/utils/CallStack.h
+++ b/include/utils/CallStack.h
@@ -17,50 +17,72 @@
#ifndef ANDROID_CALLSTACK_H
#define ANDROID_CALLSTACK_H
-#include <stdint.h>
-#include <sys/types.h>
-
+#include <android/log.h>
#include <utils/String8.h>
#include <corkscrew/backtrace.h>
-// ---------------------------------------------------------------------------
+#include <stdint.h>
+#include <sys/types.h>
namespace android {
-class CallStack
-{
+class Printer;
+
+// Collect/print the call stack (function, file, line) traces for a single thread.
+class CallStack {
public:
enum {
- MAX_DEPTH = 31
+ // Prune the lowest-most stack frames until we have at most MAX_DEPTH.
+ MAX_DEPTH = 31,
+ // Placeholder for specifying the current thread when updating the stack.
+ CURRENT_THREAD = -1,
};
+ // Create an empty call stack. No-op.
CallStack();
+ // Create a callstack with the current thread's stack trace.
+ // Immediately dump it to logcat using the given logtag.
CallStack(const char* logtag, int32_t ignoreDepth=1,
int32_t maxDepth=MAX_DEPTH);
+ // Copy the existing callstack (no other side effects).
CallStack(const CallStack& rhs);
~CallStack();
+ // Copy the existing callstack (no other side effects).
CallStack& operator = (const CallStack& rhs);
-
+
+ // Compare call stacks by their backtrace frame memory.
bool operator == (const CallStack& rhs) const;
bool operator != (const CallStack& rhs) const;
bool operator < (const CallStack& rhs) const;
bool operator >= (const CallStack& rhs) const;
bool operator > (const CallStack& rhs) const;
bool operator <= (const CallStack& rhs) const;
-
+
+ // Get the PC address for the stack frame specified by index.
const void* operator [] (int index) const;
-
+
+ // Reset the stack frames (same as creating an empty call stack).
void clear();
- void update(int32_t ignoreDepth=1, int32_t maxDepth=MAX_DEPTH);
+ // Immediately collect the stack traces for the specified thread.
+ void update(int32_t ignoreDepth=1, int32_t maxDepth=MAX_DEPTH, pid_t tid=CURRENT_THREAD);
- // Dump a stack trace to the log using the supplied logtag
- void dump(const char* logtag, const char* prefix = 0) const;
+ // Dump a stack trace to the log using the supplied logtag.
+ void log(const char* logtag,
+ android_LogPriority priority = ANDROID_LOG_DEBUG,
+ const char* prefix = 0) const;
- // Return a string (possibly very long) containing the complete stack trace
+ // Dump a stack trace to the specified file descriptor.
+ void dump(int fd, int indent = 0, const char* prefix = 0) const;
+
+ // Return a string (possibly very long) containing the complete stack trace.
String8 toString(const char* prefix = 0) const;
-
+
+ // Dump a serialized representation of the stack trace to the specified printer.
+ void print(Printer& printer) const;
+
+ // Get the count of stack frames that are in this call stack.
size_t size() const { return mCount; }
private:
@@ -70,7 +92,4 @@
}; // namespace android
-
-// ---------------------------------------------------------------------------
-
#endif // ANDROID_CALLSTACK_H
diff --git a/include/utils/Printer.h b/include/utils/Printer.h
new file mode 100644
index 0000000..bb66287
--- /dev/null
+++ b/include/utils/Printer.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2013 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 ANDROID_PRINTER_H
+#define ANDROID_PRINTER_H
+
+#include <android/log.h>
+
+namespace android {
+
+// Interface for printing to an arbitrary data stream
+class Printer {
+public:
+ // Print a new line specified by 'string'. \n is appended automatically.
+ // -- Assumes that the string has no new line in it.
+ virtual void printLine(const char* string = "") = 0;
+
+ // Print a new line specified by the format string. \n is appended automatically.
+ // -- Assumes that the resulting string has no new line in it.
+ virtual void printFormatLine(const char* format, ...) __attribute__((format (printf, 2, 3)));
+
+protected:
+ Printer();
+ virtual ~Printer();
+}; // class Printer
+
+// Print to logcat
+class LogPrinter : public Printer {
+public:
+ // Create a printer using the specified logcat and log priority
+ // - Unless ignoreBlankLines is false, print blank lines to logcat
+ // (Note that the default ALOG behavior is to ignore blank lines)
+ LogPrinter(const char* logtag,
+ android_LogPriority priority = ANDROID_LOG_DEBUG,
+ const char* prefix = 0,
+ bool ignoreBlankLines = false);
+
+ // Print the specified line to logcat. No \n at the end is necessary.
+ virtual void printLine(const char* string);
+
+private:
+ void printRaw(const char* string);
+
+ const char* mLogTag;
+ android_LogPriority mPriority;
+ const char* mPrefix;
+ bool mIgnoreBlankLines;
+}; // class LogPrinter
+
+// Print to a file descriptor
+class FdPrinter : public Printer {
+public:
+ // Create a printer using the specified file descriptor.
+ // - Each line will be prefixed with 'indent' number of blank spaces.
+ // - In addition, each line will be prefixed with the 'prefix' string.
+ FdPrinter(int fd, unsigned int indent = 0, const char* prefix = 0);
+
+ // Print the specified line to the file descriptor. \n is appended automatically.
+ virtual void printLine(const char* string);
+
+private:
+ enum {
+ MAX_FORMAT_STRING = 20,
+ };
+
+ int mFd;
+ unsigned int mIndent;
+ const char* mPrefix;
+ char mFormatString[MAX_FORMAT_STRING];
+}; // class FdPrinter
+
+class String8;
+
+// Print to a String8
+class String8Printer : public Printer {
+public:
+ // Create a printer using the specified String8 as the target.
+ // - In addition, each line will be prefixed with the 'prefix' string.
+ // - target's memory lifetime must be a superset of this String8Printer.
+ String8Printer(String8* target, const char* prefix = 0);
+
+ // Append the specified line to the String8. \n is appended automatically.
+ virtual void printLine(const char* string);
+
+private:
+ String8* mTarget;
+ const char* mPrefix;
+}; // class String8Printer
+
+// Print to an existing Printer by adding a prefix to each line
+class PrefixPrinter : public Printer {
+public:
+ // Create a printer using the specified printer as the target.
+ PrefixPrinter(Printer& printer, const char* prefix);
+
+ // Print the line (prefixed with prefix) using the printer.
+ virtual void printLine(const char* string);
+
+private:
+ Printer& mPrinter;
+ const char* mPrefix;
+};
+
+}; // namespace android
+
+#endif // ANDROID_PRINTER_H
diff --git a/include/utils/ProcessCallStack.h b/include/utils/ProcessCallStack.h
new file mode 100644
index 0000000..4a86869
--- /dev/null
+++ b/include/utils/ProcessCallStack.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2013 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 ANDROID_PROCESS_CALLSTACK_H
+#define ANDROID_PROCESS_CALLSTACK_H
+
+#include <utils/CallStack.h>
+#include <android/log.h>
+#include <utils/KeyedVector.h>
+#include <utils/String8.h>
+
+#include <time.h>
+#include <sys/types.h>
+
+namespace android {
+
+class Printer;
+
+// Collect/print the call stack (function, file, line) traces for all threads in a process.
+class ProcessCallStack {
+public:
+ // Create an empty call stack. No-op.
+ ProcessCallStack();
+ // Copy the existing process callstack (no other side effects).
+ ProcessCallStack(const ProcessCallStack& rhs);
+ ~ProcessCallStack();
+
+ // Immediately collect the stack traces for all threads.
+ void update(int32_t maxDepth = CallStack::MAX_DEPTH);
+
+ // Print all stack traces to the log using the supplied logtag.
+ void log(const char* logtag, android_LogPriority priority = ANDROID_LOG_DEBUG,
+ const char* prefix = 0) const;
+
+ // Dump all stack traces to the specified file descriptor.
+ void dump(int fd, int indent = 0, const char* prefix = 0) const;
+
+ // Return a string (possibly very long) containing all the stack traces.
+ String8 toString(const char* prefix = 0) const;
+
+ // Dump a serialized representation of all the stack traces to the specified printer.
+ void print(Printer& printer) const;
+
+ // Get the number of threads whose stack traces were collected.
+ size_t size() const;
+
+private:
+ void printInternal(Printer& printer, Printer& csPrinter) const;
+
+ // Reset the process's stack frames and metadata.
+ void clear();
+
+ struct ThreadInfo {
+ CallStack callStack;
+ String8 threadName;
+ };
+
+ // tid -> ThreadInfo
+ KeyedVector<pid_t, ThreadInfo> mThreadMap;
+ // Time that update() was last called
+ struct tm mTimeUpdated;
+};
+
+}; // namespace android
+
+#endif // ANDROID_PROCESS_CALLSTACK_H
diff --git a/include/ziparchive/zip_archive.h b/include/ziparchive/zip_archive.h
new file mode 100644
index 0000000..ac3d792
--- /dev/null
+++ b/include/ziparchive/zip_archive.h
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+/*
+ * Read-only access to Zip archives, with minimal heap allocation.
+ */
+#ifndef LIBZIPARCHIVE_ZIPARCHIVE_H_
+#define LIBZIPARCHIVE_ZIPARCHIVE_H_
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <utils/Compat.h>
+
+__BEGIN_DECLS
+
+/* Zip compression methods we support */
+enum {
+ kCompressStored = 0, // no compression
+ kCompressDeflated = 8, // standard deflate
+};
+
+struct ZipEntryName {
+ const char* name;
+ uint16_t name_length;
+};
+
+/*
+ * Represents information about a zip entry in a zip file.
+ */
+struct ZipEntry {
+ // Compression method: One of kCompressStored or
+ // kCompressDeflated.
+ uint16_t method;
+
+ // Modification time. The zipfile format specifies
+ // that the first two little endian bytes contain the time
+ // and the last two little endian bytes contain the date.
+ uint32_t mod_time;
+
+ // 1 if this entry contains a data descriptor segment, 0
+ // otherwise.
+ uint8_t has_data_descriptor;
+
+ // Crc32 value of this ZipEntry. This information might
+ // either be stored in the local file header or in a special
+ // Data descriptor footer at the end of the file entry.
+ uint32_t crc32;
+
+ // Compressed length of this ZipEntry. Might be present
+ // either in the local file header or in the data descriptor
+ // footer.
+ uint32_t compressed_length;
+
+ // Uncompressed length of this ZipEntry. Might be present
+ // either in the local file header or in the data descriptor
+ // footer.
+ uint32_t uncompressed_length;
+
+ // The offset to the start of data for this ZipEntry.
+ off64_t offset;
+};
+
+typedef void* ZipArchiveHandle;
+
+/*
+ * Open a Zip archive, and sets handle to the value of the opaque
+ * handle for the file. This handle must be released by calling
+ * CloseArchive with this handle.
+ *
+ * Returns 0 on success, and negative values on failure.
+ */
+int32_t OpenArchive(const char* fileName, ZipArchiveHandle* handle);
+
+/*
+ * Like OpenArchive, but takes a file descriptor open for reading
+ * at the start of the file. The descriptor must be mappable (this does
+ * not allow access to a stream).
+ *
+ * Sets handle to the value of the opaque handle for this file descriptor.
+ * This handle must be released by calling CloseArchive with this handle.
+ *
+ * This function maps and scans the central directory and builds a table
+ * of entries for future lookups.
+ *
+ * "debugFileName" will appear in error messages, but is not otherwise used.
+ *
+ * Returns 0 on success, and negative values on failure.
+ */
+int32_t OpenArchiveFd(const int fd, const char* debugFileName,
+ ZipArchiveHandle *handle);
+
+/*
+ * Close archive, releasing resources associated with it. This will
+ * unmap the central directory of the zipfile and free all internal
+ * data structures associated with the file. It is an error to use
+ * this handle for any further operations without an intervening
+ * call to one of the OpenArchive variants.
+ */
+void CloseArchive(ZipArchiveHandle handle);
+
+/*
+ * Find an entry in the Zip archive, by name. |entryName| must be a null
+ * terminated string, and |data| must point to a writeable memory location.
+ *
+ * Returns 0 if an entry is found, and populates |data| with information
+ * about this entry. Returns negative values otherwise.
+ *
+ * It's important to note that |data->crc32|, |data->compLen| and
+ * |data->uncompLen| might be set to values from the central directory
+ * if this file entry contains a data descriptor footer. To verify crc32s
+ * and length, a call to VerifyCrcAndLengths must be made after entry data
+ * has been processed.
+ */
+int32_t FindEntry(const ZipArchiveHandle handle, const char* entryName,
+ ZipEntry* data);
+
+/*
+ * Start iterating over all entries of a zip file. The order of iteration
+ * is not guaranteed to be the same as the order of elements
+ * in the central directory but is stable for a given zip file. |cookie|
+ * must point to a writeable memory location, and will be set to the value
+ * of an opaque cookie which can be used to make one or more calls to
+ * Next.
+ *
+ * This method also accepts an optional prefix to restrict iteration to
+ * entry names that start with |prefix|.
+ *
+ * Returns 0 on success and negative values on failure.
+ */
+int32_t StartIteration(ZipArchiveHandle handle, void** cookie_ptr,
+ const char* prefix);
+
+/*
+ * Advance to the next element in the zipfile in iteration order.
+ *
+ * Returns 0 on success, -1 if there are no more elements in this
+ * archive and lower negative values on failure.
+ */
+int32_t Next(void* cookie, ZipEntry* data, ZipEntryName *name);
+
+/*
+ * Uncompress and write an entry to a file descriptor.
+ *
+ * Returns 0 on success and negative values on failure.
+ */
+int32_t ExtractEntryToFile(ZipArchiveHandle handle, ZipEntry* entry, int fd);
+
+/**
+ * Uncompress a given zip entry to the memory region at |begin| and of
+ * size |size|. This size is expected to be the same as the *declared*
+ * uncompressed length of the zip entry. It is an error if the *actual*
+ * number of uncompressed bytes differs from this number.
+ *
+ * Returns 0 on success and negative values on failure.
+ */
+int32_t ExtractToMemory(ZipArchiveHandle handle, ZipEntry* entry,
+ uint8_t* begin, uint32_t size);
+
+int GetFileDescriptor(const ZipArchiveHandle handle);
+
+const char* ErrorCodeString(int32_t error_code);
+
+__END_DECLS
+
+#endif // LIBZIPARCHIVE_ZIPARCHIVE_H_
diff --git a/init/init.c b/init/init.c
index 864fc6c..365726c 100644
--- a/init/init.c
+++ b/init/init.c
@@ -221,6 +221,9 @@
}
rc = security_compute_create(mycon, fcon, string_to_security_class("process"), &scon);
+ if (rc == 0 && !strcmp(scon, mycon)) {
+ ERROR("Warning! Service %s needs a SELinux domain defined; please fix!\n", svc->name);
+ }
freecon(mycon);
freecon(fcon);
if (rc < 0) {
diff --git a/libutils/Android.mk b/libutils/Android.mk
index 7e6b1be..720443e 100644
--- a/libutils/Android.mk
+++ b/libutils/Android.mk
@@ -26,6 +26,8 @@
LinearAllocator.cpp \
LinearTransform.cpp \
Log.cpp \
+ Printer.cpp \
+ ProcessCallStack.cpp \
PropertyMap.cpp \
RefBase.cpp \
SharedBuffer.cpp \
diff --git a/libutils/CallStack.cpp b/libutils/CallStack.cpp
index e60f5d8..4ceaa7c 100644
--- a/libutils/CallStack.cpp
+++ b/libutils/CallStack.cpp
@@ -16,14 +16,12 @@
#define LOG_TAG "CallStack"
-#include <string.h>
-
-#include <utils/Log.h>
-#include <utils/Errors.h>
#include <utils/CallStack.h>
+#include <utils/Printer.h>
+#include <utils/Errors.h>
+#include <utils/Log.h>
#include <corkscrew/backtrace.h>
-/*****************************************************************************/
namespace android {
CallStack::CallStack() :
@@ -31,8 +29,8 @@
}
CallStack::CallStack(const char* logtag, int32_t ignoreDepth, int32_t maxDepth) {
- this->update(ignoreDepth+1, maxDepth);
- this->dump(logtag);
+ this->update(ignoreDepth+1, maxDepth, CURRENT_THREAD);
+ this->log(logtag);
}
CallStack::CallStack(const CallStack& rhs) :
@@ -93,31 +91,44 @@
mCount = 0;
}
-void CallStack::update(int32_t ignoreDepth, int32_t maxDepth) {
+void CallStack::update(int32_t ignoreDepth, int32_t maxDepth, pid_t tid) {
if (maxDepth > MAX_DEPTH) {
maxDepth = MAX_DEPTH;
}
- ssize_t count = unwind_backtrace(mStack, ignoreDepth + 1, maxDepth);
+ ssize_t count;
+
+ if (tid >= 0) {
+ count = unwind_backtrace_thread(tid, mStack, ignoreDepth + 1, maxDepth);
+ } else if (tid == CURRENT_THREAD) {
+ count = unwind_backtrace(mStack, ignoreDepth + 1, maxDepth);
+ } else {
+ ALOGE("%s: Invalid tid specified (%d)", __FUNCTION__, tid);
+ count = 0;
+ }
+
mCount = count > 0 ? count : 0;
}
-void CallStack::dump(const char* logtag, const char* prefix) const {
- backtrace_symbol_t symbols[mCount];
+void CallStack::log(const char* logtag, android_LogPriority priority, const char* prefix) const {
+ LogPrinter printer(logtag, priority, prefix, /*ignoreBlankLines*/false);
+ print(printer);
+}
- get_backtrace_symbols(mStack, mCount, symbols);
- for (size_t i = 0; i < mCount; i++) {
- char line[MAX_BACKTRACE_LINE_LENGTH];
- format_backtrace_line(i, &mStack[i], &symbols[i],
- line, MAX_BACKTRACE_LINE_LENGTH);
- ALOG(LOG_DEBUG, logtag, "%s%s",
- prefix ? prefix : "",
- line);
- }
- free_backtrace_symbols(symbols, mCount);
+void CallStack::dump(int fd, int indent, const char* prefix) const {
+ FdPrinter printer(fd, indent, prefix);
+ print(printer);
}
String8 CallStack::toString(const char* prefix) const {
String8 str;
+
+ String8Printer printer(&str, prefix);
+ print(printer);
+
+ return str;
+}
+
+void CallStack::print(Printer& printer) const {
backtrace_symbol_t symbols[mCount];
get_backtrace_symbols(mStack, mCount, symbols);
@@ -125,14 +136,9 @@
char line[MAX_BACKTRACE_LINE_LENGTH];
format_backtrace_line(i, &mStack[i], &symbols[i],
line, MAX_BACKTRACE_LINE_LENGTH);
- if (prefix) {
- str.append(prefix);
- }
- str.append(line);
- str.append("\n");
+ printer.printLine(line);
}
free_backtrace_symbols(symbols, mCount);
- return str;
}
}; // namespace android
diff --git a/libutils/Printer.cpp b/libutils/Printer.cpp
new file mode 100644
index 0000000..ac729e0
--- /dev/null
+++ b/libutils/Printer.cpp
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#define LOG_TAG "Printer"
+// #define LOG_NDEBUG 0
+
+#include <utils/Printer.h>
+#include <utils/String8.h>
+#include <utils/Log.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __BIONIC__
+#define fdprintf dprintf
+#endif
+
+namespace android {
+
+/*
+ * Implementation of Printer
+ */
+Printer::Printer() {
+ // Intentionally left empty
+}
+
+Printer::~Printer() {
+ // Intentionally left empty
+}
+
+void Printer::printFormatLine(const char* format, ...) {
+ va_list arglist;
+ va_start(arglist, format);
+
+ char* formattedString;
+
+#ifndef USE_MINGW
+ if (vasprintf(&formattedString, format, arglist) < 0) { // returns -1 on error
+ ALOGE("%s: Failed to format string", __FUNCTION__);
+ return;
+ }
+#else
+ return;
+#endif
+
+ va_end(arglist);
+
+ printLine(formattedString);
+ free(formattedString);
+}
+
+/*
+ * Implementation of LogPrinter
+ */
+LogPrinter::LogPrinter(const char* logtag,
+ android_LogPriority priority,
+ const char* prefix,
+ bool ignoreBlankLines) :
+ mLogTag(logtag),
+ mPriority(priority),
+ mPrefix(prefix ?: ""),
+ mIgnoreBlankLines(ignoreBlankLines) {
+}
+
+void LogPrinter::printLine(const char* string) {
+ if (string == NULL) {
+ ALOGW("%s: NULL string passed in", __FUNCTION__);
+ return;
+ }
+
+ if (mIgnoreBlankLines || (*string)) {
+ // Simple case: Line is not blank, or we don't care about printing blank lines
+ printRaw(string);
+ } else {
+ // Force logcat to print empty lines by adding prefixing with a space
+ printRaw(" ");
+ }
+}
+
+void LogPrinter::printRaw(const char* string) {
+ __android_log_print(mPriority, mLogTag, "%s%s", mPrefix, string);
+}
+
+
+/*
+ * Implementation of FdPrinter
+ */
+FdPrinter::FdPrinter(int fd, unsigned int indent, const char* prefix) :
+ mFd(fd), mIndent(indent), mPrefix(prefix ?: "") {
+
+ if (fd < 0) {
+ ALOGW("%s: File descriptor out of range (%d)", __FUNCTION__, fd);
+ }
+
+ // <indent><prefix><line> -- e.g. '%-4s%s\n' for indent=4
+ snprintf(mFormatString, sizeof(mFormatString), "%%-%us%%s\n", mIndent);
+}
+
+void FdPrinter::printLine(const char* string) {
+ if (string == NULL) {
+ ALOGW("%s: NULL string passed in", __FUNCTION__);
+ return;
+ } else if (mFd < 0) {
+ ALOGW("%s: File descriptor out of range (%d)", __FUNCTION__, mFd);
+ return;
+ }
+
+#ifndef USE_MINGW
+ fdprintf(mFd, mFormatString, mPrefix, string);
+#endif
+}
+
+/*
+ * Implementation of String8Printer
+ */
+String8Printer::String8Printer(String8* target, const char* prefix) :
+ mTarget(target),
+ mPrefix(prefix ?: "") {
+
+ if (target == NULL) {
+ ALOGW("%s: Target string was NULL", __FUNCTION__);
+ }
+}
+
+void String8Printer::printLine(const char* string) {
+ if (string == NULL) {
+ ALOGW("%s: NULL string passed in", __FUNCTION__);
+ return;
+ } else if (mTarget == NULL) {
+ ALOGW("%s: Target string was NULL", __FUNCTION__);
+ return;
+ }
+
+ mTarget->append(string);
+ mTarget->append("\n");
+}
+
+/*
+ * Implementation of PrefixPrinter
+ */
+PrefixPrinter::PrefixPrinter(Printer& printer, const char* prefix) :
+ mPrinter(printer), mPrefix(prefix ?: "") {
+}
+
+void PrefixPrinter::printLine(const char* string) {
+ mPrinter.printFormatLine("%s%s", mPrefix, string);
+}
+
+}; //namespace android
diff --git a/libutils/ProcessCallStack.cpp b/libutils/ProcessCallStack.cpp
new file mode 100644
index 0000000..f9340c5
--- /dev/null
+++ b/libutils/ProcessCallStack.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#define LOG_TAG "ProcessCallStack"
+// #define LOG_NDEBUG 0
+
+#include <string.h>
+#include <stdio.h>
+#include <dirent.h>
+
+#include <utils/Log.h>
+#include <utils/Errors.h>
+#include <utils/ProcessCallStack.h>
+#include <utils/Printer.h>
+
+#include <limits.h>
+
+namespace android {
+
+enum {
+ // Max sizes for various dynamically generated strings
+ MAX_TIME_STRING = 64,
+ MAX_PROC_PATH = 1024,
+
+ // Dump related prettiness constants
+ IGNORE_DEPTH_CURRENT_THREAD = 2,
+};
+
+static const char* CALL_STACK_PREFIX = " ";
+static const char* PATH_THREAD_NAME = "/proc/self/task/%d/comm";
+static const char* PATH_SELF_TASK = "/proc/self/task";
+
+static void dumpProcessHeader(Printer& printer, pid_t pid, const char* timeStr) {
+ if (timeStr == NULL) {
+ ALOGW("%s: timeStr was NULL", __FUNCTION__);
+ return;
+ }
+
+ char path[PATH_MAX];
+ char procNameBuf[MAX_PROC_PATH];
+ char* procName = NULL;
+ FILE* fp;
+
+ snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
+ if ((fp = fopen(path, "r"))) {
+ procName = fgets(procNameBuf, sizeof(procNameBuf), fp);
+ fclose(fp);
+ }
+
+ if (!procName) {
+ procName = const_cast<char*>("<unknown>");
+ }
+
+ printer.printLine();
+ printer.printLine();
+ printer.printFormatLine("----- pid %d at %s -----", pid, timeStr);
+ printer.printFormatLine("Cmd line: %s", procName);
+}
+
+static void dumpProcessFooter(Printer& printer, pid_t pid) {
+ printer.printLine();
+ printer.printFormatLine("----- end %d -----", pid);
+ printer.printLine();
+}
+
+static String8 getThreadName(pid_t tid) {
+ char path[PATH_MAX];
+ char* procName = NULL;
+ char procNameBuf[MAX_PROC_PATH];
+ FILE* fp;
+
+ snprintf(path, sizeof(path), PATH_THREAD_NAME, tid);
+ if ((fp = fopen(path, "r"))) {
+ procName = fgets(procNameBuf, sizeof(procNameBuf), fp);
+ fclose(fp);
+ } else {
+ ALOGE("%s: Failed to open %s", __FUNCTION__, path);
+ }
+
+ // Strip ending newline
+ strtok(procName, "\n");
+
+ return String8(procName);
+}
+
+static String8 getTimeString(struct tm tm) {
+ char timestr[MAX_TIME_STRING];
+ // i.e. '2013-10-22 14:42:05'
+ strftime(timestr, sizeof(timestr), "%F %T", &tm);
+
+ return String8(timestr);
+}
+
+/*
+ * Implementation of ProcessCallStack
+ */
+ProcessCallStack::ProcessCallStack() {
+}
+
+ProcessCallStack::ProcessCallStack(const ProcessCallStack& rhs) :
+ mThreadMap(rhs.mThreadMap),
+ mTimeUpdated(rhs.mTimeUpdated) {
+}
+
+ProcessCallStack::~ProcessCallStack() {
+}
+
+void ProcessCallStack::clear() {
+ mThreadMap.clear();
+ mTimeUpdated = tm();
+}
+
+void ProcessCallStack::update(int32_t maxDepth) {
+ DIR *dp;
+ struct dirent *ep;
+ struct dirent entry;
+
+ dp = opendir(PATH_SELF_TASK);
+ if (dp == NULL) {
+ ALOGE("%s: Failed to update the process's call stacks (errno = %d, '%s')",
+ __FUNCTION__, errno, strerror(errno));
+ return;
+ }
+
+ pid_t selfPid = getpid();
+
+ clear();
+
+ // Get current time.
+#ifndef USE_MINGW
+ {
+ time_t t = time(NULL);
+ struct tm tm;
+ localtime_r(&t, &tm);
+
+ mTimeUpdated = tm;
+ }
+
+ /*
+ * Each tid is a directory inside of /proc/self/task
+ * - Read every file in directory => get every tid
+ */
+ int code;
+ while ((code = readdir_r(dp, &entry, &ep)) == 0 && ep != NULL) {
+ pid_t tid = -1;
+ sscanf(ep->d_name, "%d", &tid);
+
+ if (tid < 0) {
+ // Ignore '.' and '..'
+ ALOGV("%s: Failed to read tid from %s/%s",
+ __FUNCTION__, PATH_SELF_TASK, ep->d_name);
+ continue;
+ }
+
+ ssize_t idx = mThreadMap.add(tid, ThreadInfo());
+ if (idx < 0) { // returns negative error value on error
+ ALOGE("%s: Failed to add new ThreadInfo (errno = %zd, '%s')",
+ __FUNCTION__, idx, strerror(-idx));
+ continue;
+ }
+
+ ThreadInfo& threadInfo = mThreadMap.editValueAt(static_cast<size_t>(idx));
+
+ /*
+ * Ignore CallStack::update and ProcessCallStack::update for current thread
+ * - Every other thread doesn't need this since we call update off-thread
+ */
+ int ignoreDepth = (selfPid == tid) ? IGNORE_DEPTH_CURRENT_THREAD : 0;
+
+ // Update thread's call stacks
+ CallStack& cs = threadInfo.callStack;
+ cs.update(ignoreDepth, maxDepth, tid);
+
+ // Read/save thread name
+ threadInfo.threadName = getThreadName(tid);
+
+ ALOGV("%s: Got call stack for tid %d (size %zu)",
+ __FUNCTION__, tid, cs.size());
+ }
+ if (code != 0) { // returns positive error value on error
+ ALOGE("%s: Failed to readdir from %s (errno = %d, '%s')",
+ __FUNCTION__, PATH_SELF_TASK, -code, strerror(code));
+ }
+#endif
+
+ closedir(dp);
+}
+
+void ProcessCallStack::log(const char* logtag, android_LogPriority priority,
+ const char* prefix) const {
+ LogPrinter printer(logtag, priority, prefix, /*ignoreBlankLines*/false);
+ print(printer);
+}
+
+void ProcessCallStack::print(Printer& printer) const {
+ /*
+ * Print the header/footer with the regular printer.
+ * Print the callstack with an additional two spaces as the prefix for legibility.
+ */
+ PrefixPrinter csPrinter(printer, CALL_STACK_PREFIX);
+ printInternal(printer, csPrinter);
+}
+
+void ProcessCallStack::printInternal(Printer& printer, Printer& csPrinter) const {
+ dumpProcessHeader(printer, getpid(),
+ getTimeString(mTimeUpdated).string());
+
+ for (size_t i = 0; i < mThreadMap.size(); ++i) {
+ pid_t tid = mThreadMap.keyAt(i);
+ const ThreadInfo& threadInfo = mThreadMap.valueAt(i);
+ const CallStack& cs = threadInfo.callStack;
+ const String8& threadName = threadInfo.threadName;
+
+ printer.printLine("");
+ printer.printFormatLine("\"%s\" sysTid=%d", threadName.string(), tid);
+
+ cs.print(csPrinter);
+ }
+
+ dumpProcessFooter(printer, getpid());
+}
+
+void ProcessCallStack::dump(int fd, int indent, const char* prefix) const {
+
+ if (indent < 0) {
+ ALOGW("%s: Bad indent (%d)", __FUNCTION__, indent);
+ return;
+ }
+
+ FdPrinter printer(fd, static_cast<unsigned int>(indent), prefix);
+ print(printer);
+}
+
+String8 ProcessCallStack::toString(const char* prefix) const {
+
+ String8 dest;
+ String8Printer printer(&dest, prefix);
+ print(printer);
+
+ return dest;
+}
+
+size_t ProcessCallStack::size() const {
+ return mThreadMap.size();
+}
+
+}; //namespace android
diff --git a/libutils/VectorImpl.cpp b/libutils/VectorImpl.cpp
index 5a79647..30ca663 100644
--- a/libutils/VectorImpl.cpp
+++ b/libutils/VectorImpl.cpp
@@ -384,7 +384,11 @@
{
const SharedBuffer* cur_sb = SharedBuffer::bufferFromData(mStorage);
SharedBuffer* sb = cur_sb->editResize(new_capacity * mItemSize);
- mStorage = sb->data();
+ if (sb) {
+ mStorage = sb->data();
+ } else {
+ return NULL;
+ }
} else {
SharedBuffer* sb = SharedBuffer::alloc(new_capacity * mItemSize);
if (sb) {
@@ -399,6 +403,8 @@
}
release_storage();
mStorage = const_cast<void*>(array);
+ } else {
+ return NULL;
}
}
} else {
@@ -436,7 +442,11 @@
{
const SharedBuffer* cur_sb = SharedBuffer::bufferFromData(mStorage);
SharedBuffer* sb = cur_sb->editResize(new_capacity * mItemSize);
- mStorage = sb->data();
+ if (sb) {
+ mStorage = sb->data();
+ } else {
+ return;
+ }
} else {
SharedBuffer* sb = SharedBuffer::alloc(new_capacity * mItemSize);
if (sb) {
@@ -451,6 +461,8 @@
}
release_storage();
mStorage = const_cast<void*>(array);
+ } else{
+ return;
}
}
} else {
diff --git a/libziparchive/Android.mk b/libziparchive/Android.mk
new file mode 100644
index 0000000..5d836a1
--- /dev/null
+++ b/libziparchive/Android.mk
@@ -0,0 +1,69 @@
+#
+# Copyright (C) 2013 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.
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+source_files := \
+ zip_archive.h \
+ zip_archive.cc
+
+includes := external/zlib
+
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_SRC_FILES := ${source_files}
+
+LOCAL_STATIC_LIBRARIES := libz
+LOCAL_SHARED_LIBRARIES := libutils
+LOCAL_MODULE:= libziparchive
+
+LOCAL_C_INCLUDES += ${includes}
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libziparchive
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_SRC_FILES := ${source_files}
+LOCAL_C_INCLUDES += ${includes}
+
+LOCAL_STATIC_LIBRARIES := libz libutils
+LOCAL_MODULE:= libziparchive-host
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := ziparchive-tests
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS += \
+ -DGTEST_OS_LINUX_ANDROID \
+ -DGTEST_HAS_STD_STRING
+LOCAL_SRC_FILES := zip_archive_test.cc
+LOCAL_LDFLAGS := -llog
+LOCAL_STATIC_LIBRARIES := libziparchive libz libgtest libgtest_main libutils
+include $(BUILD_NATIVE_TEST)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := ziparchive-tests-host
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS += \
+ -DGTEST_OS_LINUX \
+ -DGTEST_HAS_STD_STRING
+LOCAL_SRC_FILES := zip_archive_test.cc
+LOCAL_STATIC_LIBRARIES := libziparchive-host \
+ libz \
+ libgtest_host \
+ libgtest_main_host \
+ liblog \
+ libutils
+include $(BUILD_HOST_NATIVE_TEST)
diff --git a/libziparchive/testdata/valid.zip b/libziparchive/testdata/valid.zip
new file mode 100644
index 0000000..9e7cb78
--- /dev/null
+++ b/libziparchive/testdata/valid.zip
Binary files differ
diff --git a/libziparchive/zip_archive.cc b/libziparchive/zip_archive.cc
new file mode 100644
index 0000000..4143fac
--- /dev/null
+++ b/libziparchive/zip_archive.cc
@@ -0,0 +1,1040 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+/*
+ * Read-only access to Zip archives, with minimal heap allocation.
+ */
+#include "ziparchive/zip_archive.h"
+
+#include <zlib.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <log/log.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <utils/FileMap.h>
+
+#include <JNIHelp.h> // TEMP_FAILURE_RETRY may or may not be in unistd
+
+// This is for windows. If we don't open a file in binary mode, weirds
+// things will happen.
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+/*
+ * Zip file constants.
+ */
+static const uint32_t kEOCDSignature = 0x06054b50;
+static const uint32_t kEOCDLen = 2;
+static const uint32_t kEOCDNumEntries = 8; // offset to #of entries in file
+static const uint32_t kEOCDSize = 12; // size of the central directory
+static const uint32_t kEOCDFileOffset = 16; // offset to central directory
+
+static const uint32_t kMaxCommentLen = 65535; // longest possible in ushort
+static const uint32_t kMaxEOCDSearch = (kMaxCommentLen + kEOCDLen);
+
+static const uint32_t kLFHSignature = 0x04034b50;
+static const uint32_t kLFHLen = 30; // excluding variable-len fields
+static const uint32_t kLFHGPBFlags = 6; // general purpose bit flags
+static const uint32_t kLFHCRC = 14; // offset to CRC
+static const uint32_t kLFHCompLen = 18; // offset to compressed length
+static const uint32_t kLFHUncompLen = 22; // offset to uncompressed length
+static const uint32_t kLFHNameLen = 26; // offset to filename length
+static const uint32_t kLFHExtraLen = 28; // offset to extra length
+
+static const uint32_t kCDESignature = 0x02014b50;
+static const uint32_t kCDELen = 46; // excluding variable-len fields
+static const uint32_t kCDEMethod = 10; // offset to compression method
+static const uint32_t kCDEModWhen = 12; // offset to modification timestamp
+static const uint32_t kCDECRC = 16; // offset to entry CRC
+static const uint32_t kCDECompLen = 20; // offset to compressed length
+static const uint32_t kCDEUncompLen = 24; // offset to uncompressed length
+static const uint32_t kCDENameLen = 28; // offset to filename length
+static const uint32_t kCDEExtraLen = 30; // offset to extra length
+static const uint32_t kCDECommentLen = 32; // offset to comment length
+static const uint32_t kCDELocalOffset = 42; // offset to local hdr
+
+static const uint32_t kDDOptSignature = 0x08074b50; // *OPTIONAL* data descriptor signature
+static const uint32_t kDDSignatureLen = 4;
+static const uint32_t kDDLen = 12;
+static const uint32_t kDDMaxLen = 16; // max of 16 bytes with a signature, 12 bytes without
+static const uint32_t kDDCrc32 = 0; // offset to crc32
+static const uint32_t kDDCompLen = 4; // offset to compressed length
+static const uint32_t kDDUncompLen = 8; // offset to uncompressed length
+
+static const uint32_t kGPBDDFlagMask = 0x0008; // mask value that signifies that the entry has a DD
+
+static const uint32_t kMaxErrorLen = 1024;
+
+static const char* kErrorMessages[] = {
+ "Unknown return code.",
+ "Iteration ended",
+ "Zlib error",
+ "Invalid file",
+ "Invalid handle",
+ "Duplicate entries in archive",
+ "Empty archive",
+ "Entry not found",
+ "Invalid offset",
+ "Inconsistent information",
+ "Invalid entry name",
+ "I/O Error",
+ "File mapping failed"
+};
+
+static const int32_t kErrorMessageUpperBound = 0;
+
+static const int32_t kIterationEnd = -1;
+
+// We encountered a Zlib error when inflating a stream from this file.
+// Usually indicates file corruption.
+static const int32_t kZlibError = -2;
+
+// The input file cannot be processed as a zip archive. Usually because
+// it's too small, too large or does not have a valid signature.
+static const int32_t kInvalidFile = -3;
+
+// An invalid iteration / ziparchive handle was passed in as an input
+// argument.
+static const int32_t kInvalidHandle = -4;
+
+// The zip archive contained two (or possibly more) entries with the same
+// name.
+static const int32_t kDuplicateEntry = -5;
+
+// The zip archive contains no entries.
+static const int32_t kEmptyArchive = -6;
+
+// The specified entry was not found in the archive.
+static const int32_t kEntryNotFound = -7;
+
+// The zip archive contained an invalid local file header pointer.
+static const int32_t kInvalidOffset = -8;
+
+// The zip archive contained inconsistent entry information. This could
+// be because the central directory & local file header did not agree, or
+// if the actual uncompressed length or crc32 do not match their declared
+// values.
+static const int32_t kInconsistentInformation = -9;
+
+// An invalid entry name was encountered.
+static const int32_t kInvalidEntryName = -10;
+
+// An I/O related system call (read, lseek, ftruncate, map) failed.
+static const int32_t kIoError = -11;
+
+// We were not able to mmap the central directory or entry contents.
+static const int32_t kMmapFailed = -12;
+
+static const int32_t kErrorMessageLowerBound = -13;
+
+static const char kTempMappingFileName[] = "zip: ExtractFileToFile";
+
+/*
+ * A Read-only Zip archive.
+ *
+ * We want "open" and "find entry by name" to be fast operations, and
+ * we want to use as little memory as possible. We memory-map the zip
+ * central directory, and load a hash table with pointers to the filenames
+ * (which aren't null-terminated). The other fields are at a fixed offset
+ * from the filename, so we don't need to extract those (but we do need
+ * to byte-read and endian-swap them every time we want them).
+ *
+ * It's possible that somebody has handed us a massive (~1GB) zip archive,
+ * so we can't expect to mmap the entire file.
+ *
+ * To speed comparisons when doing a lookup by name, we could make the mapping
+ * "private" (copy-on-write) and null-terminate the filenames after verifying
+ * the record structure. However, this requires a private mapping of
+ * every page that the Central Directory touches. Easier to tuck a copy
+ * of the string length into the hash table entry.
+ */
+struct ZipArchive {
+ /* open Zip archive */
+ int fd;
+
+ /* mapped central directory area */
+ off64_t directory_offset;
+ android::FileMap* directory_map;
+
+ /* number of entries in the Zip archive */
+ uint16_t num_entries;
+
+ /*
+ * We know how many entries are in the Zip archive, so we can have a
+ * fixed-size hash table. We define a load factor of 0.75 and overallocat
+ * so the maximum number entries can never be higher than
+ * ((4 * UINT16_MAX) / 3 + 1) which can safely fit into a uint32_t.
+ */
+ uint32_t hash_table_size;
+ ZipEntryName* hash_table;
+};
+
+// Returns 0 on success and negative values on failure.
+static android::FileMap* MapFileSegment(const int fd, const off64_t start,
+ const size_t length, const bool read_only,
+ const char* debug_file_name) {
+ android::FileMap* file_map = new android::FileMap;
+ const bool success = file_map->create(debug_file_name, fd, start, length, read_only);
+ if (!success) {
+ file_map->release();
+ return NULL;
+ }
+
+ return file_map;
+}
+
+static int32_t CopyFileToFile(int fd, uint8_t* begin, const uint32_t length, uint64_t *crc_out) {
+ static const uint32_t kBufSize = 32768;
+ uint8_t buf[kBufSize];
+
+ uint32_t count = 0;
+ uint64_t crc = 0;
+ while (count < length) {
+ uint32_t remaining = length - count;
+
+ // Safe conversion because kBufSize is narrow enough for a 32 bit signed
+ // value.
+ ssize_t get_size = (remaining > kBufSize) ? kBufSize : remaining;
+ ssize_t actual = TEMP_FAILURE_RETRY(read(fd, buf, get_size));
+
+ if (actual != get_size) {
+ ALOGW("CopyFileToFile: copy read failed (%d vs %zd)",
+ (int) actual, get_size);
+ return kIoError;
+ }
+
+ memcpy(begin + count, buf, get_size);
+ crc = crc32(crc, buf, get_size);
+ count += get_size;
+ }
+
+ *crc_out = crc;
+
+ return 0;
+}
+
+/*
+ * Round up to the next highest power of 2.
+ *
+ * Found on http://graphics.stanford.edu/~seander/bithacks.html.
+ */
+static uint32_t RoundUpPower2(uint32_t val) {
+ val--;
+ val |= val >> 1;
+ val |= val >> 2;
+ val |= val >> 4;
+ val |= val >> 8;
+ val |= val >> 16;
+ val++;
+
+ return val;
+}
+
+static uint32_t ComputeHash(const char* str, uint16_t len) {
+ uint32_t hash = 0;
+
+ while (len--) {
+ hash = hash * 31 + *str++;
+ }
+
+ return hash;
+}
+
+/*
+ * Convert a ZipEntry to a hash table index, verifying that it's in a
+ * valid range.
+ */
+static int64_t EntryToIndex(const ZipEntryName* hash_table,
+ const uint32_t hash_table_size,
+ const char* name, uint16_t length) {
+ const uint32_t hash = ComputeHash(name, length);
+
+ // NOTE: (hash_table_size - 1) is guaranteed to be non-negative.
+ uint32_t ent = hash & (hash_table_size - 1);
+ while (hash_table[ent].name != NULL) {
+ if (hash_table[ent].name_length == length &&
+ memcmp(hash_table[ent].name, name, length) == 0) {
+ return ent;
+ }
+
+ ent = (ent + 1) & (hash_table_size - 1);
+ }
+
+ ALOGV("Zip: Unable to find entry %.*s", name_length, name);
+ return kEntryNotFound;
+}
+
+/*
+ * Add a new entry to the hash table.
+ */
+static int32_t AddToHash(ZipEntryName *hash_table, const uint64_t hash_table_size,
+ const char* name, uint16_t length) {
+ const uint64_t hash = ComputeHash(name, length);
+ uint32_t ent = hash & (hash_table_size - 1);
+
+ /*
+ * We over-allocated the table, so we're guaranteed to find an empty slot.
+ * Further, we guarantee that the hashtable size is not 0.
+ */
+ while (hash_table[ent].name != NULL) {
+ if (hash_table[ent].name_length == length &&
+ memcmp(hash_table[ent].name, name, length) == 0) {
+ // We've found a duplicate entry. We don't accept it
+ ALOGW("Zip: Found duplicate entry %.*s", length, name);
+ return kDuplicateEntry;
+ }
+ ent = (ent + 1) & (hash_table_size - 1);
+ }
+
+ hash_table[ent].name = name;
+ hash_table[ent].name_length = length;
+ return 0;
+}
+
+/*
+ * Get 2 little-endian bytes.
+ */
+static uint16_t get2LE(const uint8_t* src) {
+ return src[0] | (src[1] << 8);
+}
+
+/*
+ * Get 4 little-endian bytes.
+ */
+static uint32_t get4LE(const uint8_t* src) {
+ uint32_t result;
+
+ result = src[0];
+ result |= src[1] << 8;
+ result |= src[2] << 16;
+ result |= src[3] << 24;
+
+ return result;
+}
+
+static int32_t MapCentralDirectory0(int fd, const char* debug_file_name,
+ ZipArchive* archive, off64_t file_length,
+ uint32_t read_amount, uint8_t* scan_buffer) {
+ const off64_t search_start = file_length - read_amount;
+
+ if (lseek64(fd, search_start, SEEK_SET) != search_start) {
+ ALOGW("Zip: seek %lld failed: %s", search_start, strerror(errno));
+ return kIoError;
+ }
+ ssize_t actual = TEMP_FAILURE_RETRY(read(fd, scan_buffer, read_amount));
+ if (actual != (ssize_t) read_amount) {
+ ALOGW("Zip: read %zd failed: %s", read_amount, strerror(errno));
+ return kIoError;
+ }
+
+ /*
+ * Scan backward for the EOCD magic. In an archive without a trailing
+ * comment, we'll find it on the first try. (We may want to consider
+ * doing an initial minimal read; if we don't find it, retry with a
+ * second read as above.)
+ */
+ int i;
+ for (i = read_amount - kEOCDLen; i >= 0; i--) {
+ if (scan_buffer[i] == 0x50 && get4LE(&scan_buffer[i]) == kEOCDSignature) {
+ ALOGV("+++ Found EOCD at buf+%d", i);
+ break;
+ }
+ }
+ if (i < 0) {
+ ALOGD("Zip: EOCD not found, %s is not zip", debug_file_name);
+ return kInvalidFile;
+ }
+
+ const off64_t eocd_offset = search_start + i;
+ const uint8_t* eocd_ptr = scan_buffer + i;
+
+ assert(eocd_offset < file_length);
+
+ /*
+ * Grab the CD offset and size, and the number of entries in the
+ * archive. Verify that they look reasonable. Widen dir_size and
+ * dir_offset to the file offset type.
+ */
+ const uint16_t num_entries = get2LE(eocd_ptr + kEOCDNumEntries);
+ const off64_t dir_size = get4LE(eocd_ptr + kEOCDSize);
+ const off64_t dir_offset = get4LE(eocd_ptr + kEOCDFileOffset);
+
+ if (dir_offset + dir_size > eocd_offset) {
+ ALOGW("Zip: bad offsets (dir %lld, size %lld, eocd %lld)",
+ dir_offset, dir_size, eocd_offset);
+ return kInvalidOffset;
+ }
+ if (num_entries == 0) {
+ ALOGW("Zip: empty archive?");
+ return kEmptyArchive;
+ }
+
+ ALOGV("+++ num_entries=%d dir_size=%d dir_offset=%d", num_entries, dir_size,
+ dir_offset);
+
+ /*
+ * It all looks good. Create a mapping for the CD, and set the fields
+ * in archive.
+ */
+ android::FileMap* map = MapFileSegment(fd, dir_offset, dir_size,
+ true /* read only */, debug_file_name);
+ if (map == NULL) {
+ archive->directory_map = NULL;
+ return kMmapFailed;
+ }
+
+ archive->directory_map = map;
+ archive->num_entries = num_entries;
+ archive->directory_offset = dir_offset;
+
+ return 0;
+}
+
+/*
+ * Find the zip Central Directory and memory-map it.
+ *
+ * On success, returns 0 after populating fields from the EOCD area:
+ * directory_offset
+ * directory_map
+ * num_entries
+ */
+static int32_t MapCentralDirectory(int fd, const char* debug_file_name,
+ ZipArchive* archive) {
+
+ // Test file length. We use lseek64 to make sure the file
+ // is small enough to be a zip file (Its size must be less than
+ // 0xffffffff bytes).
+ off64_t file_length = lseek64(fd, 0, SEEK_END);
+ if (file_length == -1) {
+ ALOGV("Zip: lseek on fd %d failed", fd);
+ return kInvalidFile;
+ }
+
+ if (file_length > (off64_t) 0xffffffff) {
+ ALOGV("Zip: zip file too long %d", file_length);
+ return kInvalidFile;
+ }
+
+ if (file_length < (int64_t) kEOCDLen) {
+ ALOGV("Zip: length %ld is too small to be zip", file_length);
+ return kInvalidFile;
+ }
+
+ /*
+ * Perform the traditional EOCD snipe hunt.
+ *
+ * We're searching for the End of Central Directory magic number,
+ * which appears at the start of the EOCD block. It's followed by
+ * 18 bytes of EOCD stuff and up to 64KB of archive comment. We
+ * need to read the last part of the file into a buffer, dig through
+ * it to find the magic number, parse some values out, and use those
+ * to determine the extent of the CD.
+ *
+ * We start by pulling in the last part of the file.
+ */
+ uint32_t read_amount = kMaxEOCDSearch;
+ if (file_length < (off64_t) read_amount) {
+ read_amount = file_length;
+ }
+
+ uint8_t* scan_buffer = (uint8_t*) malloc(read_amount);
+ int32_t result = MapCentralDirectory0(fd, debug_file_name, archive,
+ file_length, read_amount, scan_buffer);
+
+ free(scan_buffer);
+ return result;
+}
+
+/*
+ * Parses the Zip archive's Central Directory. Allocates and populates the
+ * hash table.
+ *
+ * Returns 0 on success.
+ */
+static int32_t ParseZipArchive(ZipArchive* archive) {
+ int32_t result = -1;
+ const uint8_t* cd_ptr = (const uint8_t*) archive->directory_map->getDataPtr();
+ size_t cd_length = archive->directory_map->getDataLength();
+ uint16_t num_entries = archive->num_entries;
+
+ /*
+ * Create hash table. We have a minimum 75% load factor, possibly as
+ * low as 50% after we round off to a power of 2. There must be at
+ * least one unused entry to avoid an infinite loop during creation.
+ */
+ archive->hash_table_size = RoundUpPower2(1 + (num_entries * 4) / 3);
+ archive->hash_table = (ZipEntryName*) calloc(archive->hash_table_size,
+ sizeof(ZipEntryName));
+
+ /*
+ * Walk through the central directory, adding entries to the hash
+ * table and verifying values.
+ */
+ const uint8_t* ptr = cd_ptr;
+ for (uint16_t i = 0; i < num_entries; i++) {
+ if (get4LE(ptr) != kCDESignature) {
+ ALOGW("Zip: missed a central dir sig (at %d)", i);
+ goto bail;
+ }
+
+ if (ptr + kCDELen > cd_ptr + cd_length) {
+ ALOGW("Zip: ran off the end (at %d)", i);
+ goto bail;
+ }
+
+ const off64_t local_header_offset = get4LE(ptr + kCDELocalOffset);
+ if (local_header_offset >= archive->directory_offset) {
+ ALOGW("Zip: bad LFH offset %lld at entry %d", local_header_offset, i);
+ goto bail;
+ }
+
+ const uint16_t file_name_length = get2LE(ptr + kCDENameLen);
+ const uint16_t extra_length = get2LE(ptr + kCDEExtraLen);
+ const uint16_t comment_length = get2LE(ptr + kCDECommentLen);
+
+ /* add the CDE filename to the hash table */
+ const int add_result = AddToHash(archive->hash_table,
+ archive->hash_table_size, (const char*) ptr + kCDELen, file_name_length);
+ if (add_result) {
+ ALOGW("Zip: Error adding entry to hash table %d", add_result);
+ result = add_result;
+ goto bail;
+ }
+
+ ptr += kCDELen + file_name_length + extra_length + comment_length;
+ if ((size_t)(ptr - cd_ptr) > cd_length) {
+ ALOGW("Zip: bad CD advance (%d vs %zd) at entry %d",
+ (int) (ptr - cd_ptr), cd_length, i);
+ goto bail;
+ }
+ }
+ ALOGV("+++ zip good scan %d entries", num_entries);
+
+ result = 0;
+
+bail:
+ return result;
+}
+
+static int32_t OpenArchiveInternal(ZipArchive* archive,
+ const char* debug_file_name) {
+ int32_t result = -1;
+ if ((result = MapCentralDirectory(archive->fd, debug_file_name, archive))) {
+ return result;
+ }
+
+ if ((result = ParseZipArchive(archive))) {
+ return result;
+ }
+
+ return 0;
+}
+
+int32_t OpenArchiveFd(int fd, const char* debug_file_name,
+ ZipArchiveHandle* handle) {
+ ZipArchive* archive = (ZipArchive*) malloc(sizeof(ZipArchive));
+ memset(archive, 0, sizeof(*archive));
+ *handle = archive;
+
+ archive->fd = fd;
+
+ return OpenArchiveInternal(archive, debug_file_name);
+}
+
+int32_t OpenArchive(const char* fileName, ZipArchiveHandle* handle) {
+ ZipArchive* archive = (ZipArchive*) malloc(sizeof(ZipArchive));
+ memset(archive, 0, sizeof(*archive));
+ *handle = archive;
+
+ const int fd = open(fileName, O_RDONLY | O_BINARY, 0);
+ if (fd < 0) {
+ ALOGW("Unable to open '%s': %s", fileName, strerror(errno));
+ return kIoError;
+ } else {
+ archive->fd = fd;
+ }
+
+ return OpenArchiveInternal(archive, fileName);
+}
+
+/*
+ * Close a ZipArchive, closing the file and freeing the contents.
+ */
+void CloseArchive(ZipArchiveHandle handle) {
+ ZipArchive* archive = (ZipArchive*) handle;
+ ALOGV("Closing archive %p", archive);
+
+ if (archive->fd >= 0) {
+ close(archive->fd);
+ }
+
+ if (archive->directory_map != NULL) {
+ archive->directory_map->release();
+ }
+ free(archive->hash_table);
+
+ /* ensure nobody tries to use the ZipArchive after it's closed */
+ archive->directory_offset = -1;
+ archive->fd = -1;
+ archive->num_entries = -1;
+ archive->hash_table_size = -1;
+ archive->hash_table = NULL;
+}
+
+static int32_t UpdateEntryFromDataDescriptor(int fd,
+ ZipEntry *entry) {
+ uint8_t ddBuf[kDDMaxLen];
+ ssize_t actual = TEMP_FAILURE_RETRY(read(fd, ddBuf, sizeof(ddBuf)));
+ if (actual != sizeof(ddBuf)) {
+ return kIoError;
+ }
+
+ const uint32_t ddSignature = get4LE(ddBuf);
+ uint16_t ddOffset = 0;
+ if (ddSignature == kDDOptSignature) {
+ ddOffset = 4;
+ }
+
+ entry->crc32 = get4LE(ddBuf + ddOffset + kDDCrc32);
+ entry->compressed_length = get4LE(ddBuf + ddOffset + kDDCompLen);
+ entry->uncompressed_length = get4LE(ddBuf + ddOffset + kDDUncompLen);
+
+ return 0;
+}
+
+// Attempts to read |len| bytes into |buf| at offset |off|.
+//
+// This method uses pread64 on platforms that support it and
+// lseek64 + read on platforms that don't. This implies that
+// callers should not rely on the |fd| offset being incremented
+// as a side effect of this call.
+static inline ssize_t ReadAtOffset(int fd, uint8_t* buf, size_t len,
+ off64_t off) {
+#ifdef HAVE_PREAD
+ return TEMP_FAILURE_RETRY(pread64(fd, buf, len, off));
+#else
+ // The only supported platform that doesn't support pread at the moment
+ // is Windows. Only recent versions of windows support unix like forks,
+ // and even there the semantics are quite different.
+ if (lseek64(fd, off, SEEK_SET) != off) {
+ ALOGW("Zip: failed seek to offset %lld", off);
+ return kIoError;
+ }
+
+ return TEMP_FAILURE_RETRY(read(fd, buf, len));
+#endif // HAVE_PREAD
+}
+
+static int32_t FindEntry(const ZipArchive* archive, const int ent,
+ ZipEntry* data) {
+ const uint16_t nameLen = archive->hash_table[ent].name_length;
+ const char* name = archive->hash_table[ent].name;
+
+ // Recover the start of the central directory entry from the filename
+ // pointer. The filename is the first entry past the fixed-size data,
+ // so we can just subtract back from that.
+ const unsigned char* ptr = (const unsigned char*) name;
+ ptr -= kCDELen;
+
+ // This is the base of our mmapped region, we have to sanity check that
+ // the name that's in the hash table is a pointer to a location within
+ // this mapped region.
+ const unsigned char* base_ptr = (const unsigned char*)
+ archive->directory_map->getDataPtr();
+ if (ptr < base_ptr || ptr > base_ptr + archive->directory_map->getDataLength()) {
+ ALOGW("Zip: Invalid entry pointer");
+ return kInvalidOffset;
+ }
+
+ // The offset of the start of the central directory in the zipfile.
+ // We keep this lying around so that we can sanity check all our lengths
+ // and our per-file structures.
+ const off64_t cd_offset = archive->directory_offset;
+
+ // Fill out the compression method, modification time, crc32
+ // and other interesting attributes from the central directory. These
+ // will later be compared against values from the local file header.
+ data->method = get2LE(ptr + kCDEMethod);
+ data->mod_time = get4LE(ptr + kCDEModWhen);
+ data->crc32 = get4LE(ptr + kCDECRC);
+ data->compressed_length = get4LE(ptr + kCDECompLen);
+ data->uncompressed_length = get4LE(ptr + kCDEUncompLen);
+
+ // Figure out the local header offset from the central directory. The
+ // actual file data will begin after the local header and the name /
+ // extra comments.
+ const off64_t local_header_offset = get4LE(ptr + kCDELocalOffset);
+ if (local_header_offset + (off64_t) kLFHLen >= cd_offset) {
+ ALOGW("Zip: bad local hdr offset in zip");
+ return kInvalidOffset;
+ }
+
+ uint8_t lfh_buf[kLFHLen];
+ ssize_t actual = ReadAtOffset(archive->fd, lfh_buf, sizeof(lfh_buf),
+ local_header_offset);
+ if (actual != sizeof(lfh_buf)) {
+ ALOGW("Zip: failed reading lfh name from offset %lld", local_header_offset);
+ return kIoError;
+ }
+
+ if (get4LE(lfh_buf) != kLFHSignature) {
+ ALOGW("Zip: didn't find signature at start of lfh, offset=%lld",
+ local_header_offset);
+ return kInvalidOffset;
+ }
+
+ // Paranoia: Match the values specified in the local file header
+ // to those specified in the central directory.
+ const uint16_t lfhGpbFlags = get2LE(lfh_buf + kLFHGPBFlags);
+ const uint16_t lfhNameLen = get2LE(lfh_buf + kLFHNameLen);
+ const uint16_t lfhExtraLen = get2LE(lfh_buf + kLFHExtraLen);
+
+ if ((lfhGpbFlags & kGPBDDFlagMask) == 0) {
+ const uint32_t lfhCrc = get4LE(lfh_buf + kLFHCRC);
+ const uint32_t lfhCompLen = get4LE(lfh_buf + kLFHCompLen);
+ const uint32_t lfhUncompLen = get4LE(lfh_buf + kLFHUncompLen);
+
+ data->has_data_descriptor = 0;
+ if (data->compressed_length != lfhCompLen || data->uncompressed_length != lfhUncompLen
+ || data->crc32 != lfhCrc) {
+ ALOGW("Zip: size/crc32 mismatch. expected {%d, %d, %x}, was {%d, %d, %x}",
+ data->compressed_length, data->uncompressed_length, data->crc32,
+ lfhCompLen, lfhUncompLen, lfhCrc);
+ return kInconsistentInformation;
+ }
+ } else {
+ data->has_data_descriptor = 1;
+ }
+
+ // Check that the local file header name matches the declared
+ // name in the central directory.
+ if (lfhNameLen == nameLen) {
+ const off64_t name_offset = local_header_offset + kLFHLen;
+ if (name_offset + lfhNameLen >= cd_offset) {
+ ALOGW("Zip: Invalid declared length");
+ return kInvalidOffset;
+ }
+
+ uint8_t* name_buf = (uint8_t*) malloc(nameLen);
+ ssize_t actual = ReadAtOffset(archive->fd, name_buf, nameLen,
+ name_offset);
+
+ if (actual != nameLen) {
+ ALOGW("Zip: failed reading lfh name from offset %lld", name_offset);
+ free(name_buf);
+ return kIoError;
+ }
+
+ if (memcmp(name, name_buf, nameLen)) {
+ free(name_buf);
+ return kInconsistentInformation;
+ }
+
+ free(name_buf);
+ } else {
+ ALOGW("Zip: lfh name did not match central directory.");
+ return kInconsistentInformation;
+ }
+
+ const off64_t data_offset = local_header_offset + kLFHLen + lfhNameLen + lfhExtraLen;
+ if (data_offset >= cd_offset) {
+ ALOGW("Zip: bad data offset %lld in zip", (off64_t) data_offset);
+ return kInvalidOffset;
+ }
+
+ if ((off64_t)(data_offset + data->compressed_length) > cd_offset) {
+ ALOGW("Zip: bad compressed length in zip (%lld + %zd > %lld)",
+ data_offset, data->compressed_length, cd_offset);
+ return kInvalidOffset;
+ }
+
+ if (data->method == kCompressStored &&
+ (off64_t)(data_offset + data->uncompressed_length) > cd_offset) {
+ ALOGW("Zip: bad uncompressed length in zip (%lld + %zd > %lld)",
+ data_offset, data->uncompressed_length, cd_offset);
+ return kInvalidOffset;
+ }
+
+ data->offset = data_offset;
+ return 0;
+}
+
+struct IterationHandle {
+ uint32_t position;
+ const char* prefix;
+ uint16_t prefix_len;
+ ZipArchive* archive;
+};
+
+int32_t StartIteration(ZipArchiveHandle handle, void** cookie_ptr, const char* prefix) {
+ ZipArchive* archive = (ZipArchive *) handle;
+
+ if (archive == NULL || archive->hash_table == NULL) {
+ ALOGW("Zip: Invalid ZipArchiveHandle");
+ return kInvalidHandle;
+ }
+
+ IterationHandle* cookie = (IterationHandle*) malloc(sizeof(IterationHandle));
+ cookie->position = 0;
+ cookie->prefix = prefix;
+ cookie->archive = archive;
+ if (prefix != NULL) {
+ cookie->prefix_len = strlen(prefix);
+ }
+
+ *cookie_ptr = cookie ;
+ return 0;
+}
+
+int32_t FindEntry(const ZipArchiveHandle handle, const char* entryName,
+ ZipEntry* data) {
+ const ZipArchive* archive = (ZipArchive*) handle;
+ const int nameLen = strlen(entryName);
+ if (nameLen == 0 || nameLen > 65535) {
+ ALOGW("Zip: Invalid filename %s", entryName);
+ return kInvalidEntryName;
+ }
+
+ const int64_t ent = EntryToIndex(archive->hash_table,
+ archive->hash_table_size, entryName, nameLen);
+
+ if (ent < 0) {
+ ALOGW("Zip: Could not find entry %.*s", nameLen, entryName);
+ return ent;
+ }
+
+ return FindEntry(archive, ent, data);
+}
+
+int32_t Next(void* cookie, ZipEntry* data, ZipEntryName* name) {
+ IterationHandle* handle = (IterationHandle *) cookie;
+ if (handle == NULL) {
+ return kInvalidHandle;
+ }
+
+ ZipArchive* archive = handle->archive;
+ if (archive == NULL || archive->hash_table == NULL) {
+ ALOGW("Zip: Invalid ZipArchiveHandle");
+ return kInvalidHandle;
+ }
+
+ const uint32_t currentOffset = handle->position;
+ const uint32_t hash_table_length = archive->hash_table_size;
+ const ZipEntryName *hash_table = archive->hash_table;
+
+ for (uint32_t i = currentOffset; i < hash_table_length; ++i) {
+ if (hash_table[i].name != NULL &&
+ (handle->prefix == NULL ||
+ (memcmp(handle->prefix, hash_table[i].name, handle->prefix_len) == 0))) {
+ handle->position = (i + 1);
+ const int error = FindEntry(archive, i, data);
+ if (!error) {
+ name->name = hash_table[i].name;
+ name->name_length = hash_table[i].name_length;
+ }
+
+ return error;
+ }
+ }
+
+ handle->position = 0;
+ return kIterationEnd;
+}
+
+static int32_t InflateToFile(int fd, const ZipEntry* entry,
+ uint8_t* begin, uint32_t length,
+ uint64_t* crc_out) {
+ int32_t result = -1;
+ const uint32_t kBufSize = 32768;
+ uint8_t read_buf[kBufSize];
+ uint8_t write_buf[kBufSize];
+ z_stream zstream;
+ int zerr;
+
+ /*
+ * Initialize the zlib stream struct.
+ */
+ memset(&zstream, 0, sizeof(zstream));
+ zstream.zalloc = Z_NULL;
+ zstream.zfree = Z_NULL;
+ zstream.opaque = Z_NULL;
+ zstream.next_in = NULL;
+ zstream.avail_in = 0;
+ zstream.next_out = (Bytef*) write_buf;
+ zstream.avail_out = kBufSize;
+ zstream.data_type = Z_UNKNOWN;
+
+ /*
+ * Use the undocumented "negative window bits" feature to tell zlib
+ * that there's no zlib header waiting for it.
+ */
+ zerr = inflateInit2(&zstream, -MAX_WBITS);
+ if (zerr != Z_OK) {
+ if (zerr == Z_VERSION_ERROR) {
+ ALOGE("Installed zlib is not compatible with linked version (%s)",
+ ZLIB_VERSION);
+ } else {
+ ALOGW("Call to inflateInit2 failed (zerr=%d)", zerr);
+ }
+
+ return kZlibError;
+ }
+
+ const uint32_t uncompressed_length = entry->uncompressed_length;
+
+ uint32_t compressed_length = entry->compressed_length;
+ uint32_t write_count = 0;
+ do {
+ /* read as much as we can */
+ if (zstream.avail_in == 0) {
+ const ssize_t getSize = (compressed_length > kBufSize) ? kBufSize : compressed_length;
+ const ssize_t actual = TEMP_FAILURE_RETRY(read(fd, read_buf, getSize));
+ if (actual != getSize) {
+ ALOGW("Zip: inflate read failed (%d vs %zd)", actual, getSize);
+ result = kIoError;
+ goto z_bail;
+ }
+
+ compressed_length -= getSize;
+
+ zstream.next_in = read_buf;
+ zstream.avail_in = getSize;
+ }
+
+ /* uncompress the data */
+ zerr = inflate(&zstream, Z_NO_FLUSH);
+ if (zerr != Z_OK && zerr != Z_STREAM_END) {
+ ALOGW("Zip: inflate zerr=%d (nIn=%p aIn=%u nOut=%p aOut=%u)",
+ zerr, zstream.next_in, zstream.avail_in,
+ zstream.next_out, zstream.avail_out);
+ result = kZlibError;
+ goto z_bail;
+ }
+
+ /* write when we're full or when we're done */
+ if (zstream.avail_out == 0 ||
+ (zerr == Z_STREAM_END && zstream.avail_out != kBufSize)) {
+ const size_t write_size = zstream.next_out - write_buf;
+ // The file might have declared a bogus length.
+ if (write_size + write_count > length) {
+ goto z_bail;
+ }
+ memcpy(begin + write_count, write_buf, write_size);
+ write_count += write_size;
+
+ zstream.next_out = write_buf;
+ zstream.avail_out = kBufSize;
+ }
+ } while (zerr == Z_OK);
+
+ assert(zerr == Z_STREAM_END); /* other errors should've been caught */
+
+ // stream.adler holds the crc32 value for such streams.
+ *crc_out = zstream.adler;
+
+ if (zstream.total_out != uncompressed_length || compressed_length != 0) {
+ ALOGW("Zip: size mismatch on inflated file (%ld vs %zd)",
+ zstream.total_out, uncompressed_length);
+ result = kInconsistentInformation;
+ goto z_bail;
+ }
+
+ result = 0;
+
+z_bail:
+ inflateEnd(&zstream); /* free up any allocated structures */
+
+ return result;
+}
+
+int32_t ExtractToMemory(ZipArchiveHandle handle,
+ ZipEntry* entry, uint8_t* begin, uint32_t size) {
+ ZipArchive* archive = (ZipArchive*) handle;
+ const uint16_t method = entry->method;
+ off64_t data_offset = entry->offset;
+
+ if (lseek64(archive->fd, data_offset, SEEK_SET) != data_offset) {
+ ALOGW("Zip: lseek to data at %lld failed", (off64_t) data_offset);
+ return kIoError;
+ }
+
+ // this should default to kUnknownCompressionMethod.
+ int32_t return_value = -1;
+ uint64_t crc = 0;
+ if (method == kCompressStored) {
+ return_value = CopyFileToFile(archive->fd, begin, size, &crc);
+ } else if (method == kCompressDeflated) {
+ return_value = InflateToFile(archive->fd, entry, begin, size, &crc);
+ }
+
+ if (!return_value && entry->has_data_descriptor) {
+ return_value = UpdateEntryFromDataDescriptor(archive->fd, entry);
+ if (return_value) {
+ return return_value;
+ }
+ }
+
+ // TODO: Fix this check by passing the right flags to inflate2 so that
+ // it calculates the CRC for us.
+ if (entry->crc32 != crc && false) {
+ ALOGW("Zip: crc mismatch: expected %u, was %llu", entry->crc32, crc);
+ return kInconsistentInformation;
+ }
+
+ return return_value;
+}
+
+int32_t ExtractEntryToFile(ZipArchiveHandle handle,
+ ZipEntry* entry, int fd) {
+ const int32_t declared_length = entry->uncompressed_length;
+
+ int result = TEMP_FAILURE_RETRY(ftruncate(fd, declared_length));
+ if (result == -1) {
+ ALOGW("Zip: unable to truncate file to %ud", declared_length);
+ return kIoError;
+ }
+
+ android::FileMap* map = MapFileSegment(fd, 0, declared_length,
+ false, kTempMappingFileName);
+ if (map == NULL) {
+ return kMmapFailed;
+ }
+
+ const int32_t error = ExtractToMemory(handle, entry,
+ reinterpret_cast<uint8_t*>(map->getDataPtr()),
+ map->getDataLength());
+ map->release();
+ return error;
+}
+
+const char* ErrorCodeString(int32_t error_code) {
+ if (error_code > kErrorMessageLowerBound && error_code < kErrorMessageUpperBound) {
+ return kErrorMessages[error_code * -1];
+ }
+
+ return kErrorMessages[0];
+}
+
+int GetFileDescriptor(const ZipArchiveHandle handle) {
+ return ((ZipArchive*) handle)->fd;
+}
+
diff --git a/libziparchive/zip_archive_test.cc b/libziparchive/zip_archive_test.cc
new file mode 100644
index 0000000..55cb755
--- /dev/null
+++ b/libziparchive/zip_archive_test.cc
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2013 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 "ziparchive/zip_archive.h"
+
+#include "getopt.h"
+#include <stdio.h>
+#include <gtest/gtest.h>
+
+static std::string test_data_dir;
+
+static const std::string kValidZip = "valid.zip";
+
+static const uint8_t kATxtContents[] = {
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+ '\n'
+};
+
+static const uint8_t kBTxtContents[] = {
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+ '\n'
+};
+
+static int32_t OpenArchiveWrapper(const std::string& name,
+ ZipArchiveHandle* handle) {
+ const std::string abs_path = test_data_dir + "/" + name;
+ return OpenArchive(abs_path.c_str(), handle);
+}
+
+static void AssertNameEquals(const std::string& name_str,
+ const ZipEntryName& name) {
+ ASSERT_EQ(name_str.size(), name.name_length);
+ ASSERT_EQ(0, memcmp(name_str.c_str(), name.name, name.name_length));
+}
+
+TEST(ziparchive, Open) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(kValidZip, &handle));
+
+ CloseArchive(handle);
+}
+
+TEST(ziparchive, Iteration) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(kValidZip, &handle));
+
+ void* iteration_cookie;
+ ASSERT_EQ(0, StartIteration(handle, &iteration_cookie, NULL));
+
+ ZipEntry data;
+ ZipEntryName name;
+
+ // b/c.txt
+ ASSERT_EQ(0, Next(iteration_cookie, &data, &name));
+ AssertNameEquals("b/c.txt", name);
+
+ // b/d.txt
+ ASSERT_EQ(0, Next(iteration_cookie, &data, &name));
+ AssertNameEquals("b/d.txt", name);
+
+ // a.txt
+ ASSERT_EQ(0, Next(iteration_cookie, &data, &name));
+ AssertNameEquals("a.txt", name);
+
+ // b.txt
+ ASSERT_EQ(0, Next(iteration_cookie, &data, &name));
+ AssertNameEquals("b.txt", name);
+
+ // b/
+ ASSERT_EQ(0, Next(iteration_cookie, &data, &name));
+ AssertNameEquals("b/", name);
+
+ // End of iteration.
+ ASSERT_EQ(-1, Next(iteration_cookie, &data, &name));
+
+ CloseArchive(handle);
+}
+
+TEST(ziparchive, FindEntry) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(kValidZip, &handle));
+
+ ZipEntry data;
+ ASSERT_EQ(0, FindEntry(handle, "a.txt", &data));
+
+ // Known facts about a.txt, from zipinfo -v.
+ ASSERT_EQ(63, data.offset);
+ ASSERT_EQ(kCompressDeflated, data.method);
+ ASSERT_EQ(static_cast<uint32_t>(17), data.uncompressed_length);
+ ASSERT_EQ(static_cast<uint32_t>(13), data.compressed_length);
+ ASSERT_EQ(0x950821c5, data.crc32);
+
+ // An entry that doesn't exist. Should be a negative return code.
+ ASSERT_LT(FindEntry(handle, "nonexistent.txt", &data), 0);
+
+ CloseArchive(handle);
+}
+
+TEST(ziparchive, ExtractToMemory) {
+ ZipArchiveHandle handle;
+ ASSERT_EQ(0, OpenArchiveWrapper(kValidZip, &handle));
+
+ // An entry that's deflated.
+ ZipEntry data;
+ ASSERT_EQ(0, FindEntry(handle, "a.txt", &data));
+ const uint32_t a_size = data.uncompressed_length;
+ ASSERT_EQ(a_size, sizeof(kATxtContents));
+ uint8_t* buffer = new uint8_t[a_size];
+ ASSERT_EQ(0, ExtractToMemory(handle, &data, buffer, a_size));
+ ASSERT_EQ(0, memcmp(buffer, kATxtContents, a_size));
+ delete[] buffer;
+
+ // An entry that's stored.
+ ASSERT_EQ(0, FindEntry(handle, "b.txt", &data));
+ const uint32_t b_size = data.uncompressed_length;
+ ASSERT_EQ(b_size, sizeof(kBTxtContents));
+ buffer = new uint8_t[b_size];
+ ASSERT_EQ(0, ExtractToMemory(handle, &data, buffer, b_size));
+ ASSERT_EQ(0, memcmp(buffer, kBTxtContents, b_size));
+ delete[] buffer;
+
+ CloseArchive(handle);
+}
+
+int main(int argc, char** argv) {
+ ::testing::InitGoogleTest(&argc, argv);
+
+ static struct option options[] = {
+ { "test_data_dir", required_argument, NULL, 't' },
+ { NULL, 0, NULL, 0 }
+ };
+
+ while (true) {
+ int option_index;
+ const int c = getopt_long_only(argc, argv, "", options, &option_index);
+ if (c == -1) {
+ break;
+ }
+
+ if (c == 't') {
+ test_data_dir = optarg;
+ }
+ }
+
+ if (test_data_dir.size() == 0) {
+ printf("Test data flag (--test_data_dir) required\n\n");
+ return -1;
+ }
+
+ if (test_data_dir[0] != '/') {
+ printf("Test data must be an absolute path, was %s\n\n",
+ test_data_dir.c_str());
+ return -2;
+ }
+
+ return RUN_ALL_TESTS();
+}
+
diff --git a/reboot/reboot.c b/reboot/reboot.c
index 0e5170d..d9a4227 100644
--- a/reboot/reboot.c
+++ b/reboot/reboot.c
@@ -68,6 +68,11 @@
perror("reboot");
exit(EXIT_FAILURE);
}
+
+ // Don't return early. Give the reboot command time to take effect
+ // to avoid messing up scripts which do "adb shell reboot && adb wait-for-device"
+ while(1) { pause(); }
+
fprintf(stderr, "Done\n");
return 0;
}
diff --git a/rootdir/init.rc b/rootdir/init.rc
index cfc3d35..d1822cf 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -69,8 +69,6 @@
# Directory for putting things only root should see.
mkdir /mnt/secure 0700 root root
- # Create private mountpoint so we can MS_MOVE from staging
- mount tmpfs tmpfs /mnt/secure mode=0700,uid=0,gid=0
# Directory for staging bindmounts
mkdir /mnt/secure/staging 0700 root root
@@ -146,7 +144,6 @@
mount rootfs rootfs / ro remount
# mount shared so changes propagate into child namespaces
mount rootfs rootfs / shared rec
- mount tmpfs tmpfs /mnt/secure private rec
# We chown/chmod /cache again so because mount is run as root + defaults
chown system cache /cache
@@ -359,9 +356,6 @@
chown system system /sys/kernel/ipv4/tcp_rmem_max
chown root radio /proc/cmdline
-# Set these so we can remotely update SELinux policy
- chown system system /sys/fs/selinux/enforce
-
# Define TCP buffer sizes for various networks
# ReadMin, ReadInitial, ReadMax, WriteMin, WriteInitial, WriteMax,
setprop net.tcp.buffersize.default 4096,87380,110208,4096,16384,110208