resolved conflicts for merge of d18dc005 to master
Change-Id: I91015a835880f3619452107239a4fc8ea0fafbf6
Signed-off-by: JP Abgrall <jpa@google.com>
diff --git a/Android.mk b/Android.mk
index a307719..7c57258 100644
--- a/Android.mk
+++ b/Android.mk
@@ -15,17 +15,4 @@
#
LOCAL_PATH := $(my-dir)
-ifneq ($(TARGET_SIMULATOR),true)
- include $(call first-makefiles-under,$(LOCAL_PATH))
-else
- include $(addprefix $(LOCAL_PATH)/,$(addsuffix /Android.mk, \
- adb \
- libcutils \
- libsysutils \
- liblog \
- libnetutils \
- libpixelflinger \
- libusbhost \
- libzipfile \
- ))
-endif
+include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/adb/Android.mk b/adb/Android.mk
index 6ed31eb..7744d2b 100644
--- a/adb/Android.mk
+++ b/adb/Android.mk
@@ -95,11 +95,7 @@
# adbd device daemon
# =========================================================
-# build adbd in all non-simulator builds
-BUILD_ADBD := false
-ifneq ($(TARGET_SIMULATOR),true)
- BUILD_ADBD := true
-endif
+BUILD_ADBD := true
# build adbd for the Linux simulator build
# so we can use it to test the adb USB gadget driver on x86
@@ -113,6 +109,7 @@
LOCAL_SRC_FILES := \
adb.c \
+ backup_service.c \
fdevent.c \
transport.c \
transport_local.c \
@@ -142,21 +139,14 @@
LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT_SBIN)
LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED)
-ifeq ($(TARGET_SIMULATOR),true)
- LOCAL_STATIC_LIBRARIES := libcutils
- LOCAL_LDLIBS += -lpthread
- include $(BUILD_HOST_EXECUTABLE)
-else
- LOCAL_STATIC_LIBRARIES := libcutils libc
- include $(BUILD_EXECUTABLE)
-endif
+LOCAL_STATIC_LIBRARIES := libcutils libc
+include $(BUILD_EXECUTABLE)
endif
# adb host tool for device-as-host
# =========================================================
-ifneq ($(TARGET_SIMULATOR),true)
ifneq ($(SDK_ONLY),true)
include $(CLEAR_VARS)
@@ -195,4 +185,3 @@
include $(BUILD_EXECUTABLE)
endif
-endif
diff --git a/adb/adb.c b/adb/adb.c
index a7d327b..a91004c 100644
--- a/adb/adb.c
+++ b/adb/adb.c
@@ -36,6 +36,9 @@
#include "usb_vendors.h"
#endif
+#if ADB_TRACE
+ADB_MUTEX_DEFINE( D_lock );
+#endif
int HOST = 0;
@@ -90,6 +93,7 @@
{ "sysdeps", TRACE_SYSDEPS },
{ "transport", TRACE_TRANSPORT },
{ "jdwp", TRACE_JDWP },
+ { "services", TRACE_SERVICES },
{ NULL, 0 }
};
@@ -591,14 +595,6 @@
return 0;
}
-#ifdef HAVE_FORKEXEC
-static void sigchld_handler(int n)
-{
- int status;
- while(waitpid(-1, &status, WNOHANG) > 0) ;
-}
-#endif
-
#ifdef HAVE_WIN32_PROC
static BOOL WINAPI ctrlc_handler(DWORD type)
{
@@ -641,6 +637,7 @@
fd = unix_open("/dev/null", O_RDONLY);
dup2(fd, 0);
+ adb_close(fd);
fd = unix_open("/tmp/adb.log", O_WRONLY | O_CREAT | O_APPEND, 0640);
if(fd < 0) {
@@ -648,6 +645,7 @@
}
dup2(fd, 1);
dup2(fd, 2);
+ adb_close(fd);
fprintf(stderr,"--- adb starting (pid %d) ---\n", getpid());
#endif
}
@@ -807,9 +805,10 @@
// wait for the "OK\n" message
adb_close(fd[1]);
int ret = adb_read(fd[0], temp, 3);
+ int saved_errno = errno;
adb_close(fd[0]);
if (ret < 0) {
- fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", errno);
+ fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
return -1;
}
if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
@@ -848,7 +847,7 @@
#ifdef HAVE_WIN32_PROC
SetConsoleCtrlHandler( ctrlc_handler, TRUE );
#elif defined(HAVE_FORKEXEC)
- signal(SIGCHLD, sigchld_handler);
+ // No SIGCHLD. Let the service subproc handle its children.
signal(SIGPIPE, SIG_IGN);
#endif
@@ -872,7 +871,7 @@
*/
property_get("ro.kernel.qemu", value, "");
if (strcmp(value, "1") != 0) {
- property_get("ro.secure", value, "");
+ property_get("ro.secure", value, "1");
if (strcmp(value, "1") == 0) {
// don't run as root if ro.secure is set...
secure = 1;
@@ -957,7 +956,9 @@
// listen on default port
local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
}
+ D("adb_main(): pre init_jdwp()\n");
init_jdwp();
+ D("adb_main(): post init_jdwp()\n");
#endif
if (is_daemon)
@@ -971,6 +972,7 @@
#endif
start_logging();
}
+ D("Event loop starting\n");
fdevent_loop();
@@ -1269,8 +1271,9 @@
int main(int argc, char **argv)
{
#if ADB_HOST
- adb_trace_init();
adb_sysdeps_init();
+ adb_trace_init();
+ D("Handling commandline()\n");
return adb_commandline(argc - 1, argv + 1);
#else
if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
@@ -1279,6 +1282,7 @@
}
start_device_log();
+ D("Handling main()\n");
return adb_main(0, DEFAULT_ADB_PORT);
#endif
}
diff --git a/adb/adb.h b/adb/adb.h
index 0aa98d3..ac31f11 100644
--- a/adb/adb.h
+++ b/adb/adb.h
@@ -19,6 +19,8 @@
#include <limits.h>
+#include "transport.h" /* readx(), writex() */
+
#define MAX_PAYLOAD 4096
#define A_SYNC 0x434e5953
@@ -33,7 +35,7 @@
#define ADB_VERSION_MAJOR 1 // Used for help/version information
#define ADB_VERSION_MINOR 0 // Used for help/version information
-#define ADB_SERVER_VERSION 26 // Increment this when we want to force users to start a new adb server
+#define ADB_SERVER_VERSION 29 // Increment this when we want to force users to start a new adb server
typedef struct amessage amessage;
typedef struct apacket apacket;
@@ -302,6 +304,11 @@
#endif
#if !ADB_HOST
+typedef enum {
+ BACKUP,
+ RESTORE
+} BackupOperation;
+int backup_service(BackupOperation operation, char* args);
void framebuffer_service(int fd, void *cookie);
void log_service(int fd, void *cookie);
void remount_service(int fd, void *cookie);
@@ -315,13 +322,6 @@
int check_header(apacket *p);
int check_data(apacket *p);
-/* convenience wrappers around read/write that will retry on
-** EINTR and/or short read/write. Returns 0 on success, -1
-** on error or EOF.
-*/
-int readx(int fd, void *ptr, size_t len);
-int writex(int fd, const void *ptr, size_t len);
-
/* define ADB_TRACE to 1 to enable tracing support, or 0 to disable it */
#define ADB_TRACE 1
@@ -331,33 +331,56 @@
* the adb_trace_init() function implemented in adb.c
*/
typedef enum {
- TRACE_ADB = 0,
+ TRACE_ADB = 0, /* 0x001 */
TRACE_SOCKETS,
TRACE_PACKETS,
TRACE_TRANSPORT,
- TRACE_RWX,
+ TRACE_RWX, /* 0x010 */
TRACE_USB,
TRACE_SYNC,
TRACE_SYSDEPS,
- TRACE_JDWP,
+ TRACE_JDWP, /* 0x100 */
+ TRACE_SERVICES,
} AdbTrace;
#if ADB_TRACE
- int adb_trace_mask;
-
+ extern int adb_trace_mask;
+ extern unsigned char adb_trace_output_count;
void adb_trace_init(void);
# define ADB_TRACING ((adb_trace_mask & (1 << TRACE_TAG)) != 0)
/* you must define TRACE_TAG before using this macro */
- #define D(...) \
+# define D(...) \
do { \
- if (ADB_TRACING) \
+ if (ADB_TRACING) { \
+ int save_errno = errno; \
+ adb_mutex_lock(&D_lock); \
+ fprintf(stderr, "%s::%s():", \
+ __FILE__, __FUNCTION__); \
+ errno = save_errno; \
fprintf(stderr, __VA_ARGS__ ); \
+ fflush(stderr); \
+ adb_mutex_unlock(&D_lock); \
+ errno = save_errno; \
+ } \
+ } while (0)
+# define DR(...) \
+ do { \
+ if (ADB_TRACING) { \
+ int save_errno = errno; \
+ adb_mutex_lock(&D_lock); \
+ errno = save_errno; \
+ fprintf(stderr, __VA_ARGS__ ); \
+ fflush(stderr); \
+ adb_mutex_unlock(&D_lock); \
+ errno = save_errno; \
+ } \
} while (0)
#else
# define D(...) ((void)0)
+# define DR(...) ((void)0)
# define ADB_TRACING 0
#endif
@@ -413,6 +436,7 @@
#define CS_NOPERM 5 /* Insufficient permissions to communicate with the device */
extern int HOST;
+extern int SHELL_EXIT_NOTIFY_FD;
#define CHUNK_SIZE (64*1024)
diff --git a/adb/adb_client.c b/adb/adb_client.c
index 882810a..9a812f0 100644
--- a/adb/adb_client.c
+++ b/adb/adb_client.c
@@ -202,6 +202,7 @@
return -1;
}
+ D("_adb_connect: return fd %d\n", fd);
return fd;
}
@@ -210,6 +211,7 @@
// first query the adb server's version
int fd = _adb_connect("host:version");
+ D("adb_connect: service %s\n", service);
if(fd == -2) {
fprintf(stdout,"* daemon not running. starting it now on port %d *\n",
__adb_server_port);
@@ -266,6 +268,7 @@
if(fd == -2) {
fprintf(stderr,"** daemon still not running");
}
+ D("adb_connect: return fd %d\n", fd);
return fd;
error:
diff --git a/adb/backup_service.c b/adb/backup_service.c
new file mode 100644
index 0000000..669ff86
--- /dev/null
+++ b/adb/backup_service.c
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2011 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 <unistd.h>
+#include <stdio.h>
+
+#include "sysdeps.h"
+
+#define TRACE_TAG TRACE_ADB
+#include "adb.h"
+
+typedef struct {
+ pid_t pid;
+ int fd;
+} backup_harvest_params;
+
+// socketpair but do *not* mark as close_on_exec
+static int backup_socketpair(int sv[2]) {
+ int rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv );
+ if (rc < 0)
+ return -1;
+
+ return 0;
+}
+
+// harvest the child process then close the read end of the socketpair
+static void* backup_child_waiter(void* args) {
+ int status;
+ backup_harvest_params* params = (backup_harvest_params*) args;
+
+ waitpid(params->pid, &status, 0);
+ adb_close(params->fd);
+ free(params);
+ return NULL;
+}
+
+/* returns the data socket passing the backup data here for forwarding */
+int backup_service(BackupOperation op, char* args) {
+ pid_t pid;
+ int s[2];
+ char* operation;
+ int socketnum;
+
+ // Command string and choice of stdin/stdout for the pipe depend on our invocation
+ if (op == BACKUP) {
+ operation = "backup";
+ socketnum = STDOUT_FILENO;
+ } else {
+ operation = "restore";
+ socketnum = STDIN_FILENO;
+ }
+
+ D("backup_service(%s, %s)\n", operation, args);
+
+ // set up the pipe from the subprocess to here
+ // parent will read s[0]; child will write s[1]
+ if (backup_socketpair(s)) {
+ D("can't create backup/restore socketpair\n");
+ fprintf(stderr, "unable to create backup/restore socketpair\n");
+ return -1;
+ }
+
+ D("Backup/restore socket pair: (send=%d, receive=%d)\n", s[1], s[0]);
+ close_on_exec(s[0]); // only the side we hold on to
+
+ // spin off the child process to run the backup command
+ pid = fork();
+ if (pid < 0) {
+ // failure
+ D("can't fork for %s\n", operation);
+ fprintf(stderr, "unable to fork for %s\n", operation);
+ adb_close(s[0]);
+ adb_close(s[1]);
+ return -1;
+ }
+
+ // Great, we're off and running.
+ if (pid == 0) {
+ // child -- actually run the backup here
+ char* p;
+ int argc;
+ char portnum[16];
+ char** bu_args;
+
+ // fixed args: [0] is 'bu', [1] is the port number, [2] is the 'operation' string
+ argc = 3;
+ for (p = (char*)args; p && *p; ) {
+ argc++;
+ while (*p && *p != ':') p++;
+ if (*p == ':') p++;
+ }
+
+ bu_args = (char**) alloca(argc*sizeof(char*) + 1);
+
+ // run through again to build the argv array
+ argc = 0;
+ bu_args[argc++] = "bu";
+ snprintf(portnum, sizeof(portnum), "%d", s[1]);
+ bu_args[argc++] = portnum;
+ bu_args[argc++] = operation;
+ for (p = (char*)args; p && *p; ) {
+ bu_args[argc++] = p;
+ while (*p && *p != ':') p++;
+ if (*p == ':') {
+ *p = 0;
+ p++;
+ }
+ }
+ bu_args[argc] = NULL;
+
+ // Close the half of the socket that we don't care about, route 'bu's console
+ // to the output socket, and off we go
+ adb_close(s[0]);
+
+ // off we go
+ execvp("/system/bin/bu", (char * const *)bu_args);
+ // oops error - close up shop and go home
+ fprintf(stderr, "Unable to exec 'bu', bailing\n");
+ exit(-1);
+ } else {
+ adb_thread_t t;
+ backup_harvest_params* params;
+
+ // parent, i.e. adbd -- close the sending half of the socket
+ D("fork() returned pid %d\n", pid);
+ adb_close(s[1]);
+
+ // spin a thread to harvest the child process
+ params = (backup_harvest_params*) malloc(sizeof(backup_harvest_params));
+ params->pid = pid;
+ params->fd = s[0];
+ if (adb_thread_create(&t, backup_child_waiter, params)) {
+ adb_close(s[0]);
+ free(params);
+ D("Unable to create child harvester\n");
+ return -1;
+ }
+ }
+
+ // we'll be reading from s[0] as the data is sent by the child process
+ return s[0];
+}
diff --git a/adb/commandline.c b/adb/commandline.c
index b0c2b80..64fbe16 100644
--- a/adb/commandline.c
+++ b/adb/commandline.c
@@ -37,12 +37,6 @@
#include "adb_client.h"
#include "file_sync_service.h"
-enum {
- IGNORE_DATA,
- WIPE_DATA,
- FLASH_DATA
-};
-
static int do_cmd(transport_type ttype, char* serial, char *cmd, ...);
void get_my_path(char *s, size_t maxLen);
@@ -135,14 +129,24 @@
" adb bugreport - return all information from the device\n"
" that should be included in a bug report.\n"
"\n"
+ " adb backup [-f <file>] [-apk|-noapk] [-shared|-noshared] [-all] [<packages...>]\n"
+ " - Write an archive of the device's data to <file>.\n"
+ " If a -f option is not supplied then the data is\n"
+ " written to \"backup.ab\" in the current directory.\n"
+ " (-apk|-noapk enable/disable backup of the .apks themselves\n"
+ " in the archive; the default is noapk.)\n"
+ " (-shared|-noshared enable/disable backup of the device's\n"
+ " shared storage / SD card contents; the default is noshared.)\n"
+ " (-all means to back up all installed applications)\n"
+ " (<packages...> is the list of applications to be backed up. If\n"
+ " the -all or -shared flags are passed, then the package\n"
+ " list is optional.)\n"
+ "\n"
+ " adb restore <file> - restore device contents from the <file> backup archive\n"
+ "\n"
" adb help - show this help message\n"
" adb version - show version num\n"
"\n"
- "DATAOPTS:\n"
- " (no option) - don't touch the data partition\n"
- " -w - wipe the data partition\n"
- " -d - flash the data partition\n"
- "\n"
"scripting:\n"
" adb wait-for-device - block until device is online\n"
" adb start-server - ensure that there is a server running\n"
@@ -218,7 +222,9 @@
int len;
while(fd >= 0) {
+ D("read_and_dump(): pre adb_read(fd=%d)\n", fd);
len = adb_read(fd, buf, 4096);
+ D("read_and_dump(): post adb_read(fd=%d): len=%d\n", fd, len);
if(len == 0) {
break;
}
@@ -232,6 +238,34 @@
}
}
+static void copy_to_file(int inFd, int outFd) {
+ const size_t BUFSIZE = 32 * 1024;
+ char* buf = (char*) malloc(BUFSIZE);
+ int len;
+ long total = 0;
+
+ D("copy_to_file(%d -> %d)\n", inFd, outFd);
+ for (;;) {
+ len = adb_read(inFd, buf, BUFSIZE);
+ if (len == 0) {
+ D("copy_to_file() : read 0 bytes; exiting\n");
+ break;
+ }
+ if (len < 0) {
+ if (errno == EINTR) {
+ D("copy_to_file() : EINTR, retrying\n");
+ continue;
+ }
+ D("copy_to_file() : error %d\n", errno);
+ break;
+ }
+ adb_write(outFd, buf, len);
+ total += len;
+ }
+ D("copy_to_file() finished after %lu bytes\n", total);
+ free(buf);
+}
+
static void *stdin_read_thread(void *x)
{
int fd, fdi;
@@ -246,7 +280,9 @@
for(;;) {
/* fdi is really the client's stdin, so use read, not adb_read here */
+ D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi);
r = unix_read(fdi, buf, 1024);
+ D("stdin_read_thread(): post unix_read(fdi=%d,...)\n", fdi);
if(r == 0) break;
if(r < 0) {
if(errno == EINTR) continue;
@@ -537,6 +573,85 @@
return 0;
}
+static int backup(int argc, char** argv) {
+ char buf[4096];
+ const char* filename = "./backup.ab";
+ int fd, outFd;
+ int i, j;
+
+ /* bare "adb backup" is not a valid command */
+ if (argc < 2) return usage();
+
+ /* find, extract, and use any -f argument */
+ for (i = 1; i < argc; i++) {
+ if (!strcmp("-f", argv[i])) {
+ if (i == argc-1) {
+ fprintf(stderr, "adb: -f passed with no filename\n");
+ return usage();
+ }
+ filename = argv[i+1];
+ for (j = i+2; j <= argc; ) {
+ argv[i++] = argv[j++];
+ }
+ argc -= 2;
+ argv[argc] = NULL;
+ }
+ }
+
+ outFd = adb_open_mode(filename, O_WRONLY | O_CREAT | O_TRUNC, 0640);
+ if (outFd < 0) {
+ fprintf(stderr, "adb: unable to open file %s\n", filename);
+ return -1;
+ }
+
+ snprintf(buf, sizeof(buf), "backup");
+ for (argc--, argv++; argc; argc--, argv++) {
+ strncat(buf, ":", sizeof(buf) - strlen(buf) - 1);
+ strncat(buf, argv[0], sizeof(buf) - strlen(buf) - 1);
+ }
+
+ D("backup. filename=%s buf=%s\n", filename, buf);
+ fd = adb_connect(buf);
+ if (fd < 0) {
+ fprintf(stderr, "adb: unable to connect for backup\n");
+ adb_close(outFd);
+ return -1;
+ }
+
+ copy_to_file(fd, outFd);
+
+ adb_close(fd);
+ adb_close(outFd);
+ return 0;
+}
+
+static int restore(int argc, char** argv) {
+ const char* filename;
+ int fd, tarFd;
+
+ if (argc != 2) return usage();
+
+ filename = argv[1];
+ tarFd = adb_open(filename, O_RDONLY);
+ if (tarFd < 0) {
+ fprintf(stderr, "adb: unable to open file %s\n", filename);
+ return -1;
+ }
+
+ fd = adb_connect("restore:");
+ if (fd < 0) {
+ fprintf(stderr, "adb: unable to connect for backup\n");
+ adb_close(tarFd);
+ return -1;
+ }
+
+ copy_to_file(tarFd, fd);
+
+ adb_close(fd);
+ adb_close(tarFd);
+ return 0;
+}
+
#define SENTINEL_FILE "config" OS_PATH_SEPARATOR_STR "envsetup.make"
static int top_works(const char *top)
{
@@ -853,6 +968,7 @@
}
if(argc < 2) {
+ D("starting interactive shell\n");
r = interactive_shell();
if (h) {
printf("\x1b[0m");
@@ -877,9 +993,12 @@
}
for(;;) {
+ D("interactive shell loop. buff=%s\n", buf);
fd = adb_connect(buf);
if(fd >= 0) {
+ D("about to read_and_dump(fd=%d)\n", fd);
read_and_dump(fd);
+ D("read_and_dump() done.\n");
adb_close(fd);
r = 0;
} else {
@@ -896,6 +1015,7 @@
printf("\x1b[0m");
fflush(stdout);
}
+ D("interactive shell loop. return r=%d\n", r);
return r;
}
}
@@ -1091,6 +1211,14 @@
return adb_connect("host:start-server");
}
+ if (!strcmp(argv[0], "backup")) {
+ return backup(argc, argv);
+ }
+
+ if (!strcmp(argv[0], "restore")) {
+ return restore(argc, argv);
+ }
+
if (!strcmp(argv[0], "jdwp")) {
int fd = adb_connect("jdwp");
if (fd >= 0) {
diff --git a/adb/fdevent.c b/adb/fdevent.c
index c179b20..5c374a7 100644
--- a/adb/fdevent.c
+++ b/adb/fdevent.c
@@ -15,6 +15,8 @@
** limitations under the License.
*/
+#include <sys/ioctl.h>
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -27,10 +29,20 @@
#include <stddef.h>
#include "fdevent.h"
+#include "transport.h"
+#include "sysdeps.h"
-#define TRACE(x...) fprintf(stderr,x)
-#define DEBUG 0
+/* !!! Do not enable DEBUG for the adb that will run as the server:
+** both stdout and stderr are used to communicate between the client
+** and server. Any extra output will cause failures.
+*/
+#define DEBUG 0 /* non-0 will break adb server */
+
+// This socket is used when a subproc shell service exists.
+// It wakes up the fdevent_loop() and cause the correct handling
+// of the shell's pseudo-tty master. I.e. force close it.
+int SHELL_EXIT_NOTIFY_FD = -1;
static void fatal(const char *fn, const char *fmt, ...)
{
@@ -45,15 +57,28 @@
#define FATAL(x...) fatal(__FUNCTION__, x)
#if DEBUG
+#define D(...) \
+ do { \
+ adb_mutex_lock(&D_lock); \
+ int save_errno = errno; \
+ fprintf(stderr, "%s::%s():", __FILE__, __FUNCTION__); \
+ errno = save_errno; \
+ fprintf(stderr, __VA_ARGS__); \
+ adb_mutex_unlock(&D_lock); \
+ errno = save_errno; \
+ } while(0)
static void dump_fde(fdevent *fde, const char *info)
{
+ adb_mutex_lock(&D_lock);
fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
fde->state & FDE_READ ? 'R' : ' ',
fde->state & FDE_WRITE ? 'W' : ' ',
fde->state & FDE_ERROR ? 'E' : ' ',
info);
+ adb_mutex_unlock(&D_lock);
}
#else
+#define D(...) ((void)0)
#define dump_fde(fde, info) do { } while(0)
#endif
@@ -67,6 +92,7 @@
static void fdevent_plist_enqueue(fdevent *node);
static void fdevent_plist_remove(fdevent *node);
static fdevent *fdevent_plist_dequeue(void);
+static void fdevent_subproc_event_func(int fd, unsigned events, void *userdata);
static fdevent list_pending = {
.next = &list_pending,
@@ -270,9 +296,72 @@
FD_CLR(fde->fd, &error_fds);
}
- fde->state = (fde->state & FDE_STATEMASK) | events;
+ fde->state = (fde->state & FDE_STATEMASK) | events;
}
+/* Looks at fd_table[] for bad FDs and sets bit in fds.
+** Returns the number of bad FDs.
+*/
+static int fdevent_fd_check(fd_set *fds)
+{
+ int i, n = 0;
+ fdevent *fde;
+
+ for(i = 0; i < select_n; i++) {
+ fde = fd_table[i];
+ if(fde == 0) continue;
+ if(fcntl(i, F_GETFL, NULL) < 0) {
+ FD_SET(i, fds);
+ n++;
+ // fde->state |= FDE_DONT_CLOSE;
+
+ }
+ }
+ return n;
+}
+
+#if !DEBUG
+static inline void dump_all_fds(const char *extra_msg) {}
+#else
+static void dump_all_fds(const char *extra_msg)
+{
+int i;
+ fdevent *fde;
+ // per fd: 4 digits (but really: log10(FD_SETSIZE)), 1 staus, 1 blank
+ char msg_buff[FD_SETSIZE*6 + 1], *pb=msg_buff;
+ size_t max_chars = FD_SETSIZE * 6 + 1;
+ int printed_out;
+#define SAFE_SPRINTF(...) \
+ do { \
+ printed_out = snprintf(pb, max_chars, __VA_ARGS__); \
+ if (printed_out <= 0) { \
+ D("... snprintf failed.\n"); \
+ return; \
+ } \
+ if (max_chars < (unsigned int)printed_out) { \
+ D("... snprintf out of space.\n"); \
+ return; \
+ } \
+ pb += printed_out; \
+ max_chars -= printed_out; \
+ } while(0)
+
+ for(i = 0; i < select_n; i++) {
+ fde = fd_table[i];
+ SAFE_SPRINTF("%d", i);
+ if(fde == 0) {
+ SAFE_SPRINTF("? ");
+ continue;
+ }
+ if(fcntl(i, F_GETFL, NULL) < 0) {
+ SAFE_SPRINTF("b");
+ }
+ SAFE_SPRINTF(" ");
+ }
+ D("%s fd_table[]->fd = {%s}\n", extra_msg, msg_buff);
+}
+#endif
+
static void fdevent_process()
{
int i, n;
@@ -284,28 +373,49 @@
memcpy(&wfd, &write_fds, sizeof(fd_set));
memcpy(&efd, &error_fds, sizeof(fd_set));
- n = select(select_n, &rfd, &wfd, &efd, 0);
+ dump_all_fds("pre select()");
+
+ n = select(select_n, &rfd, &wfd, &efd, NULL);
+ int saved_errno = errno;
+ D("select() returned n=%d, errno=%d\n", n, n<0?saved_errno:0);
+
+ dump_all_fds("post select()");
if(n < 0) {
- if(errno == EINTR) return;
- perror("select");
- return;
+ switch(saved_errno) {
+ case EINTR: return;
+ case EBADF:
+ // Can't trust the FD sets after an error.
+ FD_ZERO(&wfd);
+ FD_ZERO(&efd);
+ FD_ZERO(&rfd);
+ break;
+ default:
+ D("Unexpected select() error=%d\n", saved_errno);
+ return;
+ }
+ }
+ if(n <= 0) {
+ // We fake a read, as the rest of the code assumes
+ // that errors will be detected at that point.
+ n = fdevent_fd_check(&rfd);
}
for(i = 0; (i < select_n) && (n > 0); i++) {
events = 0;
- if(FD_ISSET(i, &rfd)) events |= FDE_READ;
- if(FD_ISSET(i, &wfd)) events |= FDE_WRITE;
- if(FD_ISSET(i, &efd)) events |= FDE_ERROR;
+ if(FD_ISSET(i, &rfd)) { events |= FDE_READ; n--; }
+ if(FD_ISSET(i, &wfd)) { events |= FDE_WRITE; n--; }
+ if(FD_ISSET(i, &efd)) { events |= FDE_ERROR; n--; }
if(events) {
- n--;
-
fde = fd_table[i];
- if(fde == 0) FATAL("missing fde for fd %d\n", i);
+ if(fde == 0)
+ FATAL("missing fde for fd %d\n", i);
fde->events |= events;
+ D("got events fde->fd=%d events=%04x, state=%04x\n",
+ fde->fd, fde->events, fde->state);
if(fde->state & FDE_PENDING) continue;
fde->state |= FDE_PENDING;
fdevent_plist_enqueue(fde);
@@ -350,14 +460,14 @@
}
if(fd_table[fde->fd] != fde) {
- FATAL("fd_table out of sync");
+ FATAL("fd_table out of sync [%d]\n", fde->fd);
}
fd_table[fde->fd] = 0;
if(!(fde->state & FDE_DONT_CLOSE)) {
dump_fde(fde, "close");
- close(fde->fd);
+ adb_close(fde->fd);
}
}
@@ -394,6 +504,74 @@
return node;
}
+static void fdevent_call_fdfunc(fdevent* fde)
+{
+ unsigned events = fde->events;
+ fde->events = 0;
+ if(!(fde->state & FDE_PENDING)) return;
+ fde->state &= (~FDE_PENDING);
+ dump_fde(fde, "callback");
+ fde->func(fde->fd, events, fde->arg);
+}
+
+static void fdevent_subproc_event_func(int fd, unsigned ev, void *userdata)
+{
+
+ D("subproc handling on fd=%d ev=%04x\n", fd, ev);
+
+ // Hook oneself back into the fde's suitable for select() on read.
+ if((fd < 0) || (fd >= fd_table_max)) {
+ FATAL("fd %d out of range for fd_table \n", fd);
+ }
+ fdevent *fde = fd_table[fd];
+ fdevent_add(fde, FDE_READ);
+
+ if(ev & FDE_READ){
+ int subproc_fd;
+
+ if(readx(fd, &subproc_fd, sizeof(subproc_fd))) {
+ FATAL("Failed to read the subproc's fd from fd=%d\n", fd);
+ }
+ if((subproc_fd < 0) || (subproc_fd >= fd_table_max)) {
+ D("subproc_fd %d out of range 0, fd_table_max=%d\n",
+ subproc_fd, fd_table_max);
+ return;
+ }
+ fdevent *subproc_fde = fd_table[subproc_fd];
+ if(!subproc_fde) {
+ D("subproc_fd %d cleared from fd_table\n", subproc_fd);
+ return;
+ }
+ if(subproc_fde->fd != subproc_fd) {
+ // Already reallocated?
+ D("subproc_fd %d != fd_table[].fd %d\n", subproc_fd, subproc_fde->fd);
+ return;
+ }
+
+ subproc_fde->force_eof = 1;
+
+ int rcount = 0;
+ ioctl(subproc_fd, FIONREAD, &rcount);
+ D("subproc with fd=%d has rcount=%d err=%d\n",
+ subproc_fd, rcount, errno);
+
+ if(rcount) {
+ // If there is data left, it will show up in the select().
+ // This works because there is no other thread reading that
+ // data when in this fd_func().
+ return;
+ }
+
+ D("subproc_fde.state=%04x\n", subproc_fde->state);
+ subproc_fde->events |= FDE_READ;
+ if(subproc_fde->state & FDE_PENDING) {
+ return;
+ }
+ subproc_fde->state |= FDE_PENDING;
+ fdevent_call_fdfunc(subproc_fde);
+ }
+}
+
fdevent *fdevent_create(int fd, fd_func func, void *arg)
{
fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
@@ -412,11 +590,12 @@
fdevent_remove(fde);
}
-void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
+void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
{
memset(fde, 0, sizeof(fdevent));
fde->state = FDE_ACTIVE;
fde->fd = fd;
+ fde->force_eof = 0;
fde->func = func;
fde->arg = arg;
@@ -437,7 +616,7 @@
if(fde->state & FDE_ACTIVE) {
fdevent_disconnect(fde);
- dump_fde(fde, "disconnect");
+ dump_fde(fde, "disconnect");
fdevent_unregister(fde);
}
@@ -484,23 +663,33 @@
fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK)));
}
+void fdevent_subproc_setup()
+{
+ int s[2];
+
+ if(adb_socketpair(s)) {
+ FATAL("cannot create shell-exit socket-pair\n");
+ }
+ SHELL_EXIT_NOTIFY_FD = s[0];
+ fdevent *fde;
+ fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL);
+ if(!fde)
+ FATAL("cannot create fdevent for shell-exit handler\n");
+ fdevent_add(fde, FDE_READ);
+}
+
void fdevent_loop()
{
fdevent *fde;
+ fdevent_subproc_setup();
for(;;) {
-#if DEBUG
- fprintf(stderr,"--- ---- waiting for events\n");
-#endif
+ D("--- ---- waiting for events\n");
+
fdevent_process();
while((fde = fdevent_plist_dequeue())) {
- unsigned events = fde->events;
- fde->events = 0;
- fde->state &= (~FDE_PENDING);
- dump_fde(fde, "callback");
- fde->func(fde->fd, events, fde->arg);
+ fdevent_call_fdfunc(fde);
}
}
}
-
diff --git a/adb/fdevent.h b/adb/fdevent.h
index 6b7e7ec..a0ebe2a 100644
--- a/adb/fdevent.h
+++ b/adb/fdevent.h
@@ -70,6 +70,8 @@
fdevent *prev;
int fd;
+ int force_eof;
+
unsigned short state;
unsigned short events;
diff --git a/adb/file_sync_client.c b/adb/file_sync_client.c
index 5c7a26f..64e393c 100644
--- a/adb/file_sync_client.c
+++ b/adb/file_sync_client.c
@@ -641,8 +641,9 @@
} else {
ci = mkcopyinfo(lpath, rpath, name, 0);
if(lstat(ci->src, &st)) {
- closedir(d);
fprintf(stderr,"cannot stat '%s': %s\n", ci->src, strerror(errno));
+ closedir(d);
+
return -1;
}
if(!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) {
diff --git a/adb/file_sync_service.c b/adb/file_sync_service.c
index a231e93..d3e841b 100644
--- a/adb/file_sync_service.c
+++ b/adb/file_sync_service.c
@@ -193,9 +193,11 @@
if(fd < 0)
continue;
if(writex(fd, buffer, len)) {
+ int saved_errno = errno;
adb_close(fd);
adb_unlink(path);
fd = -1;
+ errno = saved_errno;
if(fail_errno(s)) return -1;
}
}
diff --git a/adb/mutex_list.h b/adb/mutex_list.h
index eebe0df..652dd73 100644
--- a/adb/mutex_list.h
+++ b/adb/mutex_list.h
@@ -1,8 +1,11 @@
-/* the list of mutexes used by addb */
+/* the list of mutexes used by adb */
+/* #ifndef __MUTEX_LIST_H
+ * Do not use an include-guard. This file is included once to declare the locks
+ * and once in win32 to actually do the runtime initialization.
+ */
#ifndef ADB_MUTEX
#error ADB_MUTEX not defined when including this file
#endif
-
ADB_MUTEX(dns_lock)
ADB_MUTEX(socket_list_lock)
ADB_MUTEX(transport_lock)
@@ -11,4 +14,13 @@
#endif
ADB_MUTEX(usb_lock)
+// Sadly logging to /data/adb/adb-... is not thread safe.
+// After modifying adb.h::D() to count invocations:
+// DEBUG(jpa):0:Handling main()
+// DEBUG(jpa):1:[ usb_init - starting thread ]
+// (Oopsies, no :2:, and matching message is also gone.)
+// DEBUG(jpa):3:[ usb_thread - opening device ]
+// DEBUG(jpa):4:jdwp control socket started (10)
+ADB_MUTEX(D_lock)
+
#undef ADB_MUTEX
diff --git a/adb/services.c b/adb/services.c
index 7eab17a..6940be8 100644
--- a/adb/services.c
+++ b/adb/services.c
@@ -22,7 +22,7 @@
#include "sysdeps.h"
-#define TRACE_TAG TRACE_ADB
+#define TRACE_TAG TRACE_SERVICES
#include "adb.h"
#include "file_sync_service.h"
@@ -30,6 +30,7 @@
# ifndef HAVE_WINSOCK
# include <netinet/in.h>
# include <netdb.h>
+# include <sys/ioctl.h>
# endif
#else
# include <cutils/android_reboot.h>
@@ -124,14 +125,12 @@
return;
}
- property_set("service.adb.root", "1");
snprintf(buf, sizeof(buf), "restarting adbd as root\n");
writex(fd, buf, strlen(buf));
adb_close(fd);
- // quit, and init will restart us as root
- sleep(1);
- exit(1);
+ // This will cause a property trigger in init.rc to restart us
+ property_set("service.adb.root", "1");
}
}
@@ -267,15 +266,16 @@
return s[0];
}
-static int create_subprocess(const char *cmd, const char *arg0, const char *arg1)
+#if !ADB_HOST
+static int create_subprocess(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
{
#ifdef HAVE_WIN32_PROC
- fprintf(stderr, "error: create_subprocess not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
- return -1;
+ D("create_subprocess(cmd=%s, arg0=%s, arg1=%s)\n", cmd, arg0, arg1);
+ fprintf(stderr, "error: create_subprocess not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
+ return -1;
#else /* !HAVE_WIN32_PROC */
char *devname;
int ptm;
- pid_t pid;
ptm = unix_open("/dev/ptmx", O_RDWR); // | O_NOCTTY);
if(ptm < 0){
@@ -287,22 +287,27 @@
if(grantpt(ptm) || unlockpt(ptm) ||
((devname = (char*) ptsname(ptm)) == 0)){
printf("[ trouble with /dev/ptmx - %s ]\n", strerror(errno));
+ adb_close(ptm);
return -1;
}
- pid = fork();
- if(pid < 0) {
+ *pid = fork();
+ if(*pid < 0) {
printf("- fork failed: %s -\n", strerror(errno));
+ adb_close(ptm);
return -1;
}
- if(pid == 0){
+ if(*pid == 0){
int pts;
setsid();
pts = unix_open(devname, O_RDWR);
- if(pts < 0) exit(-1);
+ if(pts < 0) {
+ fprintf(stderr, "child failed to open pseudo-term slave: %s\n", devname);
+ exit(-1);
+ }
dup2(pts, 0);
dup2(pts, 1);
@@ -311,15 +316,9 @@
adb_close(pts);
adb_close(ptm);
- execl(cmd, cmd, arg0, arg1, NULL);
- fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
- cmd, strerror(errno), errno);
- exit(-1);
- } else {
-#if !ADB_HOST
- // set child's OOM adjustment to zero
+ // set OOM adjustment to zero
char text[64];
- snprintf(text, sizeof text, "/proc/%d/oom_adj", pid);
+ snprintf(text, sizeof text, "/proc/%d/oom_adj", getpid());
int fd = adb_open(text, O_WRONLY);
if (fd >= 0) {
adb_write(fd, "0", 1);
@@ -327,11 +326,20 @@
} else {
D("adb: unable to open %s\n", text);
}
-#endif
+ execl(cmd, cmd, arg0, arg1, NULL);
+ fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
+ cmd, strerror(errno), errno);
+ exit(-1);
+ } else {
+ // Don't set child's OOM adjustment to zero.
+ // Let the child do it itself, as sometimes the parent starts
+ // running before the child has a /proc/pid/oom_adj.
+ // """adb: unable to open /proc/644/oom_adj""" seen in some logs.
return ptm;
}
#endif /* !HAVE_WIN32_PROC */
}
+#endif /* !ABD_HOST */
#if ADB_HOST
#define SHELL_COMMAND "/bin/sh"
@@ -339,6 +347,70 @@
#define SHELL_COMMAND "/system/bin/sh"
#endif
+#if !ADB_HOST
+static void subproc_waiter_service(int fd, void *cookie)
+{
+ pid_t pid = (pid_t)cookie;
+
+ D("entered. fd=%d of pid=%d\n", fd, pid);
+ for (;;) {
+ int status;
+ pid_t p = waitpid(pid, &status, 0);
+ if (p == pid) {
+ D("fd=%d, post waitpid(pid=%d) status=%04x\n", fd, p, status);
+ if (WIFSIGNALED(status)) {
+ D("*** Killed by signal %d\n", WTERMSIG(status));
+ break;
+ } else if (!WIFEXITED(status)) {
+ D("*** Didn't exit!!. status %d\n", status);
+ break;
+ } else if (WEXITSTATUS(status) >= 0) {
+ D("*** Exit code %d\n", WEXITSTATUS(status));
+ break;
+ }
+ }
+ usleep(100000); // poll every 0.1 sec
+ }
+ D("shell exited fd=%d of pid=%d err=%d\n", fd, pid, errno);
+ if (SHELL_EXIT_NOTIFY_FD >=0) {
+ int res;
+ res = writex(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd));
+ D("notified shell exit via fd=%d for pid=%d res=%d errno=%d\n",
+ SHELL_EXIT_NOTIFY_FD, pid, res, errno);
+ }
+}
+
+static int create_subproc_thread(const char *name)
+{
+ stinfo *sti;
+ adb_thread_t t;
+ int ret_fd;
+ pid_t pid;
+ if(name) {
+ ret_fd = create_subprocess(SHELL_COMMAND, "-c", name, &pid);
+ } else {
+ ret_fd = create_subprocess(SHELL_COMMAND, "-", 0, &pid);
+ }
+ D("create_subprocess() ret_fd=%d pid=%d\n", ret_fd, pid);
+
+ sti = malloc(sizeof(stinfo));
+ if(sti == 0) fatal("cannot allocate stinfo");
+ sti->func = subproc_waiter_service;
+ sti->cookie = (void*)pid;
+ sti->fd = ret_fd;
+
+ if(adb_thread_create( &t, service_bootstrap_func, sti)){
+ free(sti);
+ adb_close(ret_fd);
+ printf("cannot create service thread\n");
+ return -1;
+ }
+
+ D("service thread started, fd=%d pid=%d\n",ret_fd, pid);
+ return ret_fd;
+}
+#endif
+
int service_to_fd(const char *name)
{
int ret = -1;
@@ -389,14 +461,12 @@
ret = create_jdwp_connection_fd(atoi(name+5));
} else if (!strncmp(name, "log:", 4)) {
ret = create_service_thread(log_service, get_log_file_path(name + 4));
-#endif
} else if(!HOST && !strncmp(name, "shell:", 6)) {
if(name[6]) {
- ret = create_subprocess(SHELL_COMMAND, "-c", name + 6);
+ ret = create_subproc_thread(name + 6);
} else {
- ret = create_subprocess(SHELL_COMMAND, "-", 0);
+ ret = create_subproc_thread(0);
}
-#if !ADB_HOST
} else if(!strncmp(name, "sync:", 5)) {
ret = create_service_thread(file_sync_service, NULL);
} else if(!strncmp(name, "remount:", 8)) {
@@ -407,6 +477,12 @@
ret = create_service_thread(reboot_service, arg);
} else if(!strncmp(name, "root:", 5)) {
ret = create_service_thread(restart_root_service, NULL);
+ } else if(!strncmp(name, "backup:", 7)) {
+ char* arg = strdup(name+7);
+ if (arg == NULL) return -1;
+ ret = backup_service(BACKUP, arg);
+ } else if(!strncmp(name, "restore:", 8)) {
+ ret = backup_service(RESTORE, NULL);
} else if(!strncmp(name, "tcpip:", 6)) {
int port;
if (sscanf(name + 6, "%d", &port) == 0) {
diff --git a/adb/sockets.c b/adb/sockets.c
index f0357d6..df223b1 100644
--- a/adb/sockets.c
+++ b/adb/sockets.c
@@ -199,6 +199,7 @@
static void local_socket_destroy(asocket *s)
{
apacket *p, *n;
+ D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
/* IMPORTANT: the remove closes the fd
** that belongs to this socket
@@ -218,7 +219,10 @@
static void local_socket_close_locked(asocket *s)
{
+ D("entered. LS(%d) fd=%d\n", s->id, s->fd);
if(s->peer) {
+ D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
+ s->id, s->peer->id, s->peer->fd);
s->peer->peer = 0;
// tweak to avoid deadlock
if (s->peer->close == local_socket_close) {
@@ -245,6 +249,7 @@
s->closing = 1;
fdevent_del(&s->fde, FDE_READ);
remove_socket(s);
+ D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
insert_local_socket(s, &local_socket_closing_list);
}
@@ -252,6 +257,8 @@
{
asocket *s = _s;
+ D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
+
/* put the FDE_WRITE processing before the FDE_READ
** in order to simplify the code.
*/
@@ -273,6 +280,7 @@
if(errno == EAGAIN) return;
if(errno == EINTR) continue;
}
+ D(" closing after write because r=%d and errno is %d\n", r, errno);
s->close(s);
return;
}
@@ -288,6 +296,7 @@
** we can now destroy it.
*/
if (s->closing) {
+ D(" closing because 'closing' is set after write\n");
s->close(s);
return;
}
@@ -310,6 +319,7 @@
while(avail > 0) {
r = adb_read(fd, x, avail);
+ D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%d\n", s->id, s->fd, r, r<0?errno:0, avail);
if(r > 0) {
avail -= r;
x += r;
@@ -324,13 +334,15 @@
is_eof = 1;
break;
}
-
+ D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
+ s->id, s->fd, r, is_eof, s->fde.force_eof);
if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
put_apacket(p);
} else {
p->len = MAX_PAYLOAD - avail;
r = s->peer->enqueue(s->peer, p);
+ D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
if(r < 0) {
/* error return means they closed us as a side-effect
@@ -352,8 +364,9 @@
fdevent_del(&s->fde, FDE_READ);
}
}
-
- if(is_eof) {
+ /* Don't allow a forced eof if data is still there */
+ if((s->fde.force_eof && !r) || is_eof) {
+ D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
s->close(s);
}
}
@@ -364,6 +377,8 @@
** bytes of readable data.
*/
// s->close(s);
+ D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
+
return;
}
}
@@ -372,11 +387,11 @@
{
asocket *s = calloc(1, sizeof(asocket));
if (s == NULL) fatal("cannot allocate socket");
- install_local_socket(s);
s->fd = fd;
s->enqueue = local_socket_enqueue;
s->ready = local_socket_ready;
s->close = local_socket_close;
+ install_local_socket(s);
fdevent_install(&s->fde, fd, local_socket_event_func, s);
/* fdevent_add(&s->fde, FDE_ERROR); */
@@ -402,7 +417,7 @@
if(fd < 0) return 0;
s = create_local_socket(fd);
- D("LS(%d): bound to '%s'\n", s->id, name);
+ D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
return s;
}
@@ -432,7 +447,8 @@
static int remote_socket_enqueue(asocket *s, apacket *p)
{
- D("Calling remote_socket_enqueue\n");
+ D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
+ s->id, s->fd, s->peer->fd);
p->msg.command = A_WRTE;
p->msg.arg0 = s->peer->id;
p->msg.arg1 = s->id;
@@ -443,7 +459,8 @@
static void remote_socket_ready(asocket *s)
{
- D("Calling remote_socket_ready\n");
+ D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
+ s->id, s->fd, s->peer->fd);
apacket *p = get_apacket();
p->msg.command = A_OKAY;
p->msg.arg0 = s->peer->id;
@@ -453,12 +470,15 @@
static void remote_socket_close(asocket *s)
{
- D("Calling remote_socket_close\n");
+ D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
+ s->id, s->fd, s->peer?s->peer->fd:-1);
apacket *p = get_apacket();
p->msg.command = A_CLSE;
if(s->peer) {
p->msg.arg0 = s->peer->id;
s->peer->peer = 0;
+ D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
+ s->id, s->peer->id, s->peer->fd);
s->peer->close(s->peer);
}
p->msg.arg1 = s->id;
@@ -503,7 +523,7 @@
void connect_to_remote(asocket *s, const char *destination)
{
- D("Connect_to_remote call \n");
+ D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
apacket *p = get_apacket();
int len = strlen(destination) + 1;
diff --git a/adb/sysdeps.h b/adb/sysdeps.h
index 74f4ed1..b518076 100644
--- a/adb/sysdeps.h
+++ b/adb/sysdeps.h
@@ -44,6 +44,7 @@
#define ADB_MUTEX_DEFINE(x) adb_mutex_t x
/* declare all mutexes */
+/* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */
#define ADB_MUTEX(x) extern adb_mutex_t x;
#include "mutex_list.h"
@@ -195,6 +196,8 @@
fdevent *prev;
int fd;
+ int force_eof;
+
unsigned short state;
unsigned short events;
@@ -274,13 +277,14 @@
#define OS_PATH_SEPARATOR_STR "/"
typedef pthread_mutex_t adb_mutex_t;
+
#define ADB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
#define adb_mutex_init pthread_mutex_init
#define adb_mutex_lock pthread_mutex_lock
#define adb_mutex_unlock pthread_mutex_unlock
#define adb_mutex_destroy pthread_mutex_destroy
-#define ADB_MUTEX_DEFINE(m) static adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER
+#define ADB_MUTEX_DEFINE(m) adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER
#define adb_cond_t pthread_cond_t
#define adb_cond_init pthread_cond_init
@@ -289,6 +293,10 @@
#define adb_cond_signal pthread_cond_signal
#define adb_cond_destroy pthread_cond_destroy
+/* declare all mutexes */
+#define ADB_MUTEX(x) extern adb_mutex_t x;
+#include "mutex_list.h"
+
static __inline__ void close_on_exec(int fd)
{
fcntl( fd, F_SETFD, FD_CLOEXEC );
diff --git a/adb/transport.c b/adb/transport.c
index 2baf340..83a349a 100644
--- a/adb/transport.c
+++ b/adb/transport.c
@@ -35,24 +35,30 @@
ADB_MUTEX_DEFINE( transport_lock );
#if ADB_TRACE
+#define MAX_DUMP_HEX_LEN 16
static void dump_hex( const unsigned char* ptr, size_t len )
{
int nn, len2 = len;
+ // Build a string instead of logging each character.
+ // MAX chars in 2 digit hex, one space, MAX chars, one '\0'.
+ char buffer[MAX_DUMP_HEX_LEN *2 + 1 + MAX_DUMP_HEX_LEN + 1 ], *pb = buffer;
- if (len2 > 16) len2 = 16;
+ if (len2 > MAX_DUMP_HEX_LEN) len2 = MAX_DUMP_HEX_LEN;
- for (nn = 0; nn < len2; nn++)
- D("%02x", ptr[nn]);
- D(" ");
+ for (nn = 0; nn < len2; nn++) {
+ sprintf(pb, "%02x", ptr[nn]);
+ pb += 2;
+ }
+ sprintf(pb++, " ");
for (nn = 0; nn < len2; nn++) {
int c = ptr[nn];
if (c < 32 || c > 127)
c = '.';
- D("%c", c);
+ *pb++ = c;
}
- D("\n");
- fflush(stdout);
+ *pb++ = '\0';
+ DR("%s\n", buffer);
}
#endif
@@ -192,6 +198,7 @@
static void transport_socket_events(int fd, unsigned events, void *_t)
{
atransport *t = _t;
+ D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
if(events & FDE_READ){
apacket *p = 0;
if(read_packet(fd, t->serial, &p)){
@@ -221,8 +228,10 @@
print_packet("send", p);
if (t == NULL) {
- fatal_errno("Transport is null");
D("Transport is null \n");
+ // Zap errno because print_packet() and other stuff have errno effect.
+ errno = 0;
+ fatal_errno("Transport is null");
}
if(write_packet(t->transport_socket, t->serial, &p)){
@@ -1069,4 +1078,3 @@
return 0;
}
}
-
diff --git a/adb/transport.h b/adb/transport.h
new file mode 100644
index 0000000..992e052
--- /dev/null
+++ b/adb/transport.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2011 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 __TRANSPORT_H
+#define __TRANSPORT_H
+
+/* convenience wrappers around read/write that will retry on
+** EINTR and/or short read/write. Returns 0 on success, -1
+** on error or EOF.
+*/
+int readx(int fd, void *ptr, size_t len);
+int writex(int fd, const void *ptr, size_t len);
+#endif /* __TRANSPORT_H */
diff --git a/adb/usb_linux.c b/adb/usb_linux.c
index cd61083..4d55b74 100644
--- a/adb/usb_linux.c
+++ b/adb/usb_linux.c
@@ -45,7 +45,7 @@
/* usb scan debugging is waaaay too verbose */
#define DBGX(x...)
-static adb_mutex_t usb_lock = ADB_MUTEX_INITIALIZER;
+ADB_MUTEX_DEFINE( usb_lock );
struct usb_handle
{
@@ -369,6 +369,7 @@
h->reaper_thread = pthread_self();
adb_mutex_unlock(&h->lock);
res = ioctl(h->desc, USBDEVFS_REAPURB, &out);
+ int saved_errno = errno;
adb_mutex_lock(&h->lock);
h->reaper_thread = 0;
if(h->dead) {
@@ -376,7 +377,7 @@
break;
}
if(res < 0) {
- if(errno == EINTR) {
+ if(saved_errno == EINTR) {
continue;
}
D("[ reap urb - error ]\n");
@@ -604,6 +605,7 @@
ctrl.wIndex = 0;
ctrl.wLength = sizeof(languages);
ctrl.data = languages;
+ ctrl.timeout = 1000;
result = ioctl(usb->desc, USBDEVFS_CONTROL, &ctrl);
if (result > 0)
@@ -619,6 +621,7 @@
ctrl.wIndex = __le16_to_cpu(languages[i]);
ctrl.wLength = sizeof(buffer);
ctrl.data = buffer;
+ ctrl.timeout = 1000;
result = ioctl(usb->desc, USBDEVFS_CONTROL, &ctrl);
if (result > 0) {
@@ -685,4 +688,3 @@
fatal_errno("cannot create input thread");
}
}
-
diff --git a/adb/usb_linux_client.c b/adb/usb_linux_client.c
index 0a21c6f..635fa4b 100644
--- a/adb/usb_linux_client.c
+++ b/adb/usb_linux_client.c
@@ -83,14 +83,14 @@
{
int n;
- D("[ write %d ]\n", len);
+ D("about to write (fd=%d, len=%d)\n", h->fd, len);
n = adb_write(h->fd, data, len);
if(n != len) {
- D("ERROR: n = %d, errno = %d (%s)\n",
- n, errno, strerror(errno));
+ D("ERROR: fd = %d, n = %d, errno = %d (%s)\n",
+ h->fd, n, errno, strerror(errno));
return -1;
}
- D("[ done ]\n");
+ D("[ done fd=%d ]\n", h->fd);
return 0;
}
@@ -98,13 +98,14 @@
{
int n;
- D("[ read %d ]\n", len);
+ D("about to read (fd=%d, len=%d)\n", h->fd, len);
n = adb_read(h->fd, data, len);
if(n != len) {
- D("ERROR: n = %d, errno = %d (%s)\n",
- n, errno, strerror(errno));
+ D("ERROR: fd = %d, n = %d, errno = %d (%s)\n",
+ h->fd, n, errno, strerror(errno));
return -1;
}
+ D("[ done fd=%d ]\n", h->fd);
return 0;
}
diff --git a/adb/usb_windows.c b/adb/usb_windows.c
index 38c4cf4..b216999 100644
--- a/adb/usb_windows.c
+++ b/adb/usb_windows.c
@@ -246,10 +246,10 @@
}
// Something went wrong.
- errno = GetLastError();
+ int saved_errno = GetLastError();
usb_cleanup_handle(ret);
free(ret);
- SetLastError(errno);
+ SetLastError(saved_errno);
return NULL;
}
@@ -267,7 +267,7 @@
(unsigned long)len,
&written,
time_out);
- errno = GetLastError();
+ int saved_errno = GetLastError();
if (ret) {
// Make sure that we've written what we were asked to write
@@ -285,9 +285,10 @@
}
} else {
// assume ERROR_INVALID_HANDLE indicates we are disconnected
- if (errno == ERROR_INVALID_HANDLE)
+ if (saved_errno == ERROR_INVALID_HANDLE)
usb_kick(handle);
}
+ errno = saved_errno;
} else {
D("usb_write NULL handle\n");
SetLastError(ERROR_INVALID_HANDLE);
@@ -313,20 +314,21 @@
(unsigned long)xfer,
&read,
time_out);
- errno = GetLastError();
- D("usb_write got: %ld, expected: %d, errno: %d\n", read, xfer, errno);
+ int saved_errno = GetLastError();
+ D("usb_write got: %ld, expected: %d, errno: %d\n", read, xfer, saved_errno);
if (ret) {
data += read;
len -= read;
if (len == 0)
return 0;
- } else if (errno != ERROR_SEM_TIMEOUT) {
+ } else if (saved_errno != ERROR_SEM_TIMEOUT) {
// assume ERROR_INVALID_HANDLE indicates we are disconnected
- if (errno == ERROR_INVALID_HANDLE)
+ if (saved_errno == ERROR_INVALID_HANDLE)
usb_kick(handle);
break;
}
+ errno = saved_errno;
}
} else {
D("usb_read NULL handle\n");
diff --git a/debuggerd/debuggerd.c b/debuggerd/debuggerd.c
index 7a3e781..d03c214 100644
--- a/debuggerd/debuggerd.c
+++ b/debuggerd/debuggerd.c
@@ -37,7 +37,6 @@
#include <private/android_filesystem_config.h>
-#include <byteswap.h>
#include "debuggerd.h"
#include "utility.h"
@@ -196,73 +195,6 @@
if(sig) dump_fault_addr(tfd, tid, sig);
}
-/* After randomization (ASLR), stack contents that point to randomized
- * code become uninterpretable (e.g. can't be resolved to line numbers).
- * Here, we bundle enough information so that stack analysis on the
- * server side can still be performed. This means we are leaking some
- * information about the device (its randomization base). We have to make
- * sure an attacker has no way of intercepting the tombstone.
- */
-
-typedef struct {
- int32_t mmap_addr;
- char tag[4]; /* 'P', 'R', 'E', ' ' */
-} prelink_info_t __attribute__((packed));
-
-static inline void set_prelink(long *prelink_addr,
- prelink_info_t *info)
-{
- // We will assume the binary is little-endian, and test the
- // host endianness here.
- unsigned long test_endianness = 0xFF;
-
- if (sizeof(prelink_info_t) == 8 && prelink_addr) {
- if (*(unsigned char *)&test_endianness)
- *prelink_addr = info->mmap_addr;
- else
- *prelink_addr = bswap_32(info->mmap_addr);
- }
-}
-
-static int check_prelinked(const char *fname,
- long *prelink_addr)
-{
- *prelink_addr = 0;
- if (sizeof(prelink_info_t) != 8) return 0;
-
- int fd = open(fname, O_RDONLY);
- if (fd < 0) return 0;
- off_t end = lseek(fd, 0, SEEK_END);
- int nr = sizeof(prelink_info_t);
-
- off_t sz = lseek(fd, -nr, SEEK_CUR);
- if ((long)(end - sz) != (long)nr) return 0;
- if (sz == (off_t)-1) return 0;
-
- prelink_info_t info;
- int num_read = read(fd, &info, nr);
- if (num_read < 0) return 0;
- if (num_read != sizeof(info)) return 0;
-
- int prelinked = 0;
- if (!strncmp(info.tag, "PRE ", 4)) {
- set_prelink(prelink_addr, &info);
- prelinked = 1;
- }
- if (close(fd) < 0) return 0;
- return prelinked;
-}
-
-void dump_randomization_base(int tfd, bool at_fault) {
- bool only_in_tombstone = !at_fault;
- long prelink_addr;
- check_prelinked("/system/lib/libc.so", &prelink_addr);
- _LOG(tfd, only_in_tombstone,
- "\nlibc base address: %08x\n", prelink_addr);
-}
-
-/* End of ASLR-related logic. */
-
static void parse_elf_info(mapinfo *milist, pid_t pid)
{
mapinfo *mi;
@@ -353,7 +285,6 @@
dump_pc_and_lr(tfd, tid, milist, stack_depth, at_fault);
}
- dump_randomization_base(tfd, at_fault);
dump_stack_and_code(tfd, tid, milist, stack_depth, sp_list, at_fault);
#elif __i386__
/* If stack unwinder fails, use the default solution to dump the stack
@@ -662,19 +593,39 @@
* debugger_signal_handler().
*/
tid_attach_status = ptrace(PTRACE_ATTACH, tid, 0, 0);
+ int ptrace_error = errno;
- TEMP_FAILURE_RETRY(write(fd, &tid, 1));
+ if (TEMP_FAILURE_RETRY(write(fd, &tid, 1)) != 1) {
+ XLOG("failed responding to client: %s\n",
+ strerror(errno));
+ goto done;
+ }
if(tid_attach_status < 0) {
- LOG("ptrace attach failed: %s\n", strerror(errno));
+ LOG("ptrace attach failed: %s\n", strerror(ptrace_error));
goto done;
}
close(fd);
fd = -1;
+ const int sleep_time_usec = 200000; /* 0.2 seconds */
+ const int max_total_sleep_usec = 3000000; /* 3 seconds */
+ int loop_limit = max_total_sleep_usec / sleep_time_usec;
for(;;) {
- n = waitpid(tid, &status, __WALL);
+ if (loop_limit-- == 0) {
+ LOG("timed out waiting for pid=%d tid=%d uid=%d to die\n",
+ cr.pid, tid, cr.uid);
+ goto done;
+ }
+ n = waitpid(tid, &status, __WALL | WNOHANG);
+
+ if (n == 0) {
+ /* not ready yet */
+ XLOG("not ready yet\n");
+ usleep(sleep_time_usec);
+ continue;
+ }
if(n < 0) {
if(errno == EAGAIN) continue;
@@ -764,6 +715,18 @@
struct sigaction act;
int logsocket = -1;
+ /*
+ * debuggerd crashes can't be reported to debuggerd. Reset all of the
+ * crash handlers.
+ */
+ signal(SIGILL, SIG_DFL);
+ signal(SIGABRT, SIG_DFL);
+ signal(SIGBUS, SIG_DFL);
+ signal(SIGFPE, SIG_DFL);
+ signal(SIGSEGV, SIG_DFL);
+ signal(SIGSTKFLT, SIG_DFL);
+ signal(SIGPIPE, SIG_DFL);
+
logsocket = socket_local_client("logd",
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM);
if(logsocket < 0) {
@@ -791,8 +754,12 @@
int fd;
alen = sizeof(addr);
+ XLOG("waiting for connection\n");
fd = accept(s, &addr, &alen);
- if(fd < 0) continue;
+ if(fd < 0) {
+ XLOG("accept failed: %s\n", strerror(errno));
+ continue;
+ }
fcntl(fd, F_SETFD, FD_CLOEXEC);
diff --git a/include/arch/darwin-x86/AndroidConfig.h b/include/arch/darwin-x86/AndroidConfig.h
index d99072a..c8ccc7e 100644
--- a/include/arch/darwin-x86/AndroidConfig.h
+++ b/include/arch/darwin-x86/AndroidConfig.h
@@ -305,12 +305,4 @@
*/
#define HAVE_PRINTF_ZD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /*_ANDROID_CONFIG_H*/
diff --git a/include/arch/freebsd-x86/AndroidConfig.h b/include/arch/freebsd-x86/AndroidConfig.h
index 9703c76..d828bd5 100644
--- a/include/arch/freebsd-x86/AndroidConfig.h
+++ b/include/arch/freebsd-x86/AndroidConfig.h
@@ -363,12 +363,4 @@
*/
#define HAVE_PRINTF_ZD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /*_ANDROID_CONFIG_H*/
diff --git a/include/arch/linux-arm/AndroidConfig.h b/include/arch/linux-arm/AndroidConfig.h
index 5138d90..83891cd 100644
--- a/include/arch/linux-arm/AndroidConfig.h
+++ b/include/arch/linux-arm/AndroidConfig.h
@@ -361,12 +361,4 @@
*/
#define HAVE_PRINTF_ZD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /* _ANDROID_CONFIG_H */
diff --git a/include/arch/linux-ppc/AndroidConfig.h b/include/arch/linux-ppc/AndroidConfig.h
index 60bddd6..00706dc 100644
--- a/include/arch/linux-ppc/AndroidConfig.h
+++ b/include/arch/linux-ppc/AndroidConfig.h
@@ -323,12 +323,4 @@
*/
#define HAVE_PREAD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /*_ANDROID_CONFIG_H*/
diff --git a/include/arch/linux-sh/AndroidConfig.h b/include/arch/linux-sh/AndroidConfig.h
index 9303bb6..5562eae 100644
--- a/include/arch/linux-sh/AndroidConfig.h
+++ b/include/arch/linux-sh/AndroidConfig.h
@@ -366,12 +366,4 @@
*/
#define HAVE_PRINTF_ZD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /* _ANDROID_CONFIG_H */
diff --git a/include/arch/linux-x86/AndroidConfig.h b/include/arch/linux-x86/AndroidConfig.h
index 6fd26ea..7dcaa98 100644
--- a/include/arch/linux-x86/AndroidConfig.h
+++ b/include/arch/linux-x86/AndroidConfig.h
@@ -333,12 +333,4 @@
*/
#define HAVE_PRINTF_ZD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /*_ANDROID_CONFIG_H*/
diff --git a/include/arch/target_linux-x86/AndroidConfig.h b/include/arch/target_linux-x86/AndroidConfig.h
index a6f7090..05dd220 100644
--- a/include/arch/target_linux-x86/AndroidConfig.h
+++ b/include/arch/target_linux-x86/AndroidConfig.h
@@ -350,12 +350,4 @@
*/
#define HAVE_PRINTF_ZD 1
-/*
- * We need to open binary files using O_BINARY on Windows.
- * Most systems lack (and actually don't need) this flag.
- */
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
-
#endif /* _ANDROID_CONFIG_H */
diff --git a/include/arch/windows/AndroidConfig.h b/include/arch/windows/AndroidConfig.h
index 8a7e062..ad890b4 100644
--- a/include/arch/windows/AndroidConfig.h
+++ b/include/arch/windows/AndroidConfig.h
@@ -338,10 +338,4 @@
*/
/* #define HAVE_PRINTF_ZD 1 */
-/*
- * We need to open binary files using O_BINARY on Windows.
- * We don't define it on Windows since it is part of the io headers.
- */
-/* #define O_BINARY 0 */
-
#endif /*_ANDROID_CONFIG_H*/
diff --git a/include/cutils/atomic-inline.h b/include/cutils/atomic-inline.h
index 6acb67c..49f3e70 100644
--- a/include/cutils/atomic-inline.h
+++ b/include/cutils/atomic-inline.h
@@ -17,6 +17,10 @@
#ifndef ANDROID_CUTILS_ATOMIC_INLINE_H
#define ANDROID_CUTILS_ATOMIC_INLINE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
/*
* Inline declarations and macros for some special-purpose atomic
* operations. These are intended for rare circumstances where a
@@ -61,4 +65,8 @@
#define ANDROID_MEMBAR_STORE android_memory_store_barrier
#endif
+#ifdef __cplusplus
+}
+#endif
+
#endif /* ANDROID_CUTILS_ATOMIC_INLINE_H */
diff --git a/include/cutils/config_utils.h b/include/cutils/config_utils.h
index f3fb370..2dea6f1 100644
--- a/include/cutils/config_utils.h
+++ b/include/cutils/config_utils.h
@@ -54,6 +54,9 @@
/* add a named child to a config node (or modify it if it already exists) */
void config_set(cnode *root, const char *name, const char *value);
+/* free a config node tree */
+void config_free(cnode *root);
+
#ifdef __cplusplus
}
#endif
diff --git a/include/cutils/log.h b/include/cutils/log.h
index f602017..42d7382 100644
--- a/include/cutils/log.h
+++ b/include/cutils/log.h
@@ -289,13 +289,17 @@
* It is NOT stripped from release builds. Note that the condition test
* is -inverted- from the normal assert() semantics.
*/
+#ifndef LOG_ALWAYS_FATAL_IF
#define LOG_ALWAYS_FATAL_IF(cond, ...) \
( (CONDITION(cond)) \
? ((void)android_printAssert(#cond, LOG_TAG, ## __VA_ARGS__)) \
: (void)0 )
+#endif
+#ifndef LOG_ALWAYS_FATAL
#define LOG_ALWAYS_FATAL(...) \
( ((void)android_printAssert(NULL, LOG_TAG, ## __VA_ARGS__)) )
+#endif
/*
* Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that
@@ -303,13 +307,21 @@
*/
#if LOG_NDEBUG
+#ifndef LOG_FATAL_IF
#define LOG_FATAL_IF(cond, ...) ((void)0)
+#endif
+#ifndef LOG_FATAL
#define LOG_FATAL(...) ((void)0)
+#endif
#else
+#ifndef LOG_FATAL_IF
#define LOG_FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ## __VA_ARGS__)
+#endif
+#ifndef LOG_FATAL
#define LOG_FATAL(...) LOG_ALWAYS_FATAL(__VA_ARGS__)
+#endif
#endif
@@ -317,8 +329,10 @@
* Assertion that generates a log message when the assertion fails.
* Stripped out of release builds. Uses the current LOG_TAG.
*/
+#ifndef LOG_ASSERT
#define LOG_ASSERT(cond, ...) LOG_FATAL_IF(!(cond), ## __VA_ARGS__)
//#define LOG_ASSERT(cond) LOG_FATAL_IF(!(cond), "Assertion failed: " #cond)
+#endif
// ---------------------------------------------------------------------
@@ -377,18 +391,24 @@
} AndroidEventLogType;
+#ifndef LOG_EVENT_INT
#define LOG_EVENT_INT(_tag, _value) { \
int intBuf = _value; \
(void) android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf, \
sizeof(intBuf)); \
}
+#endif
+#ifndef LOG_EVENT_LONG
#define LOG_EVENT_LONG(_tag, _value) { \
long long longBuf = _value; \
(void) android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf, \
sizeof(longBuf)); \
}
+#endif
+#ifndef LOG_EVENT_STRING
#define LOG_EVENT_STRING(_tag, _value) \
((void) 0) /* not implemented -- must combine len with string */
+#endif
/* TODO: something for LIST */
/*
diff --git a/include/cutils/native_handle.h b/include/cutils/native_handle.h
index 89d6b65..268c5d3 100644
--- a/include/cutils/native_handle.h
+++ b/include/cutils/native_handle.h
@@ -21,7 +21,7 @@
extern "C" {
#endif
-typedef struct
+typedef struct native_handle
{
int version; /* sizeof(native_handle_t) */
int numFds; /* number of file-descriptors at &data[0] */
@@ -29,10 +29,6 @@
int data[0]; /* numFds + numInts ints */
} native_handle_t;
-
-/* keep the old definition for backward source-compatibility */
-typedef native_handle_t native_handle;
-
/*
* native_handle_close
*
diff --git a/include/cutils/partition_utils.h b/include/cutils/partition_utils.h
new file mode 100644
index 0000000..597df92
--- /dev/null
+++ b/include/cutils/partition_utils.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2011, 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 __CUTILS_PARTITION_WIPED_H__
+#define __CUTILS_PARTITION_WIPED_H__
+
+__BEGIN_DECLS
+
+int partition_wiped(char *source);
+void erase_footer(const char *dev_path, long long size);
+
+__END_DECLS
+
+#endif /* __CUTILS_PARTITION_WIPED_H__ */
diff --git a/include/cutils/sockets.h b/include/cutils/sockets.h
index aa8682e..19cae0c 100644
--- a/include/cutils/sockets.h
+++ b/include/cutils/sockets.h
@@ -20,6 +20,7 @@
#include <errno.h>
#include <stdlib.h>
#include <string.h>
+#include <stdbool.h>
#ifdef HAVE_WINSOCK
#include <winsock2.h>
@@ -92,7 +93,18 @@
const char *name, int namespaceId, int type);
extern int socket_local_client(const char *name, int namespaceId, int type);
extern int socket_inaddr_any_server(int port, int type);
-
+
+/*
+ * socket_peer_is_trusted - Takes a socket which is presumed to be a
+ * connected local socket (e.g. AF_LOCAL) and returns whether the peer
+ * (the userid that owns the process on the other end of that socket)
+ * is one of the two trusted userids, root or shell.
+ *
+ * Note: This only works as advertised on the Android OS and always
+ * just returns true when called on other operating systems.
+ */
+extern bool socket_peer_is_trusted(int fd);
+
#ifdef __cplusplus
}
#endif
diff --git a/include/cutils/uevent.h b/include/cutils/uevent.h
index 587149c..5f5e6ca 100644
--- a/include/cutils/uevent.h
+++ b/include/cutils/uevent.h
@@ -23,7 +23,7 @@
extern "C" {
#endif
-ssize_t uevent_checked_recv(int socket, void *buffer, size_t length);
+ssize_t uevent_kernel_multicast_recv(int socket, void *buffer, size_t length);
#ifdef __cplusplus
}
diff --git a/include/private/android_filesystem_config.h b/include/private/android_filesystem_config.h
index f23c235..fc71a1e 100644
--- a/include/private/android_filesystem_config.h
+++ b/include/private/android_filesystem_config.h
@@ -71,6 +71,8 @@
#define AID_INET 3003 /* can create AF_INET and AF_INET6 sockets */
#define AID_NET_RAW 3004 /* can create raw INET sockets */
#define AID_NET_ADMIN 3005 /* can configure interfaces and routing tables. */
+#define AID_NET_BW_STATS 3006 /* read bandwidth statistics */
+#define AID_NET_BW_ACCT 3007 /* change bandwidth statistics accounting */
#define AID_MISC 9998 /* access to misc storage */
#define AID_NOBODY 9999
@@ -118,6 +120,8 @@
{ "inet", AID_INET, },
{ "net_raw", AID_NET_RAW, },
{ "net_admin", AID_NET_ADMIN, },
+ { "net_bw_stats", AID_NET_BW_STATS, },
+ { "net_bw_acct", AID_NET_BW_ACCT, },
{ "misc", AID_MISC, },
{ "nobody", AID_NOBODY, },
};
diff --git a/include/system/audio.h b/include/system/audio.h
index 8f2ac0c..52ba5e7 100644
--- a/include/system/audio.h
+++ b/include/system/audio.h
@@ -88,8 +88,10 @@
/* PCM sub formats */
typedef enum {
- AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1, /* DO NOT CHANGE */
- AUDIO_FORMAT_PCM_SUB_8_BIT = 0x2, /* DO NOT CHANGE */
+ AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1, /* DO NOT CHANGE - PCM signed 16 bits */
+ AUDIO_FORMAT_PCM_SUB_8_BIT = 0x2, /* DO NOT CHANGE - PCM unsigned 8 bits */
+ AUDIO_FORMAT_PCM_SUB_32_BIT = 0x3, /* PCM signed .31 fixed point */
+ AUDIO_FORMAT_PCM_SUB_8_24_BIT = 0x4, /* PCM signed 7.24 fixed point */
} audio_format_pcm_sub_fmt_t;
/* MP3 sub format field definition : can use 11 LSBs in the same way as MP3
@@ -144,21 +146,32 @@
AUDIO_FORMAT_PCM_SUB_16_BIT),
AUDIO_FORMAT_PCM_8_BIT = (AUDIO_FORMAT_PCM |
AUDIO_FORMAT_PCM_SUB_8_BIT),
+ AUDIO_FORMAT_PCM_32_BIT = (AUDIO_FORMAT_PCM |
+ AUDIO_FORMAT_PCM_SUB_32_BIT),
+ AUDIO_FORMAT_PCM_8_24_BIT = (AUDIO_FORMAT_PCM |
+ AUDIO_FORMAT_PCM_SUB_8_24_BIT),
} audio_format_t;
-/* Channel mask definitions must be kept in sync with JAVA values in
- * frameworks/base/media/java/android/media/AudioFormat.java */
typedef enum {
/* output channels */
- AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x4,
- AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x8,
- AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x10,
- AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x20,
- AUDIO_CHANNEL_OUT_BACK_LEFT = 0x40,
- AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x80,
- AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x100,
- AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x200,
- AUDIO_CHANNEL_OUT_BACK_CENTER = 0x400,
+ AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1,
+ AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2,
+ AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4,
+ AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8,
+ AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10,
+ AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20,
+ AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40,
+ AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80,
+ AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100,
+ AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200,
+ AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400,
+ AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800,
+ AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000,
+ AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000,
+ AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000,
+ AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000,
+ AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000,
+ AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000,
AUDIO_CHANNEL_OUT_MONO = AUDIO_CHANNEL_OUT_FRONT_LEFT,
AUDIO_CHANNEL_OUT_STEREO = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
@@ -177,14 +190,15 @@
AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
AUDIO_CHANNEL_OUT_BACK_LEFT |
AUDIO_CHANNEL_OUT_BACK_RIGHT),
+ // matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND definition for 7.1
AUDIO_CHANNEL_OUT_7POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
AUDIO_CHANNEL_OUT_FRONT_RIGHT |
AUDIO_CHANNEL_OUT_FRONT_CENTER |
AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
AUDIO_CHANNEL_OUT_BACK_LEFT |
AUDIO_CHANNEL_OUT_BACK_RIGHT |
- AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER |
- AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER),
+ AUDIO_CHANNEL_OUT_SIDE_LEFT |
+ AUDIO_CHANNEL_OUT_SIDE_RIGHT),
AUDIO_CHANNEL_OUT_ALL = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
AUDIO_CHANNEL_OUT_FRONT_RIGHT |
AUDIO_CHANNEL_OUT_FRONT_CENTER |
@@ -193,7 +207,16 @@
AUDIO_CHANNEL_OUT_BACK_RIGHT |
AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER |
AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER |
- AUDIO_CHANNEL_OUT_BACK_CENTER),
+ AUDIO_CHANNEL_OUT_BACK_CENTER|
+ AUDIO_CHANNEL_OUT_SIDE_LEFT|
+ AUDIO_CHANNEL_OUT_SIDE_RIGHT|
+ AUDIO_CHANNEL_OUT_TOP_CENTER|
+ AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT|
+ AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER|
+ AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT|
+ AUDIO_CHANNEL_OUT_TOP_BACK_LEFT|
+ AUDIO_CHANNEL_OUT_TOP_BACK_CENTER|
+ AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT),
/* input channels */
AUDIO_CHANNEL_IN_LEFT = 0x4,
@@ -363,6 +386,10 @@
{
switch (format & AUDIO_FORMAT_MAIN_MASK) {
case AUDIO_FORMAT_PCM:
+ if (format != AUDIO_FORMAT_PCM_16_BIT &&
+ format != AUDIO_FORMAT_PCM_8_BIT) {
+ return false;
+ }
case AUDIO_FORMAT_MP3:
case AUDIO_FORMAT_AMR_NB:
case AUDIO_FORMAT_AMR_WB:
@@ -378,15 +405,29 @@
static inline bool audio_is_linear_pcm(uint32_t format)
{
- switch (format) {
- case AUDIO_FORMAT_PCM_16_BIT:
- case AUDIO_FORMAT_PCM_8_BIT:
- return true;
- default:
- return false;
- }
+ return ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM);
}
+static inline size_t audio_bytes_per_sample(uint32_t format)
+{
+ size_t size = 0;
+
+ switch (format) {
+ case AUDIO_FORMAT_PCM_32_BIT:
+ case AUDIO_FORMAT_PCM_8_24_BIT:
+ size = sizeof(int32_t);
+ break;
+ case AUDIO_FORMAT_PCM_16_BIT:
+ size = sizeof(int16_t);
+ break;
+ case AUDIO_FORMAT_PCM_8_BIT:
+ size = sizeof(uint8_t);
+ break;
+ default:
+ break;
+ }
+ return size;
+}
__END_DECLS
diff --git a/include/system/audio_policy.h b/include/system/audio_policy.h
new file mode 100644
index 0000000..1e0af7d
--- /dev/null
+++ b/include/system/audio_policy.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2011 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_AUDIO_POLICY_CORE_H
+#define ANDROID_AUDIO_POLICY_CORE_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+#include <cutils/bitops.h>
+
+__BEGIN_DECLS
+
+/* The enums were moved here mostly from
+ * frameworks/base/include/media/AudioSystem.h
+ */
+
+/* request to open a direct output with get_output() (by opposition to
+ * sharing an output with other AudioTracks)
+ */
+typedef enum {
+ AUDIO_POLICY_OUTPUT_FLAG_INDIRECT = 0x0,
+ AUDIO_POLICY_OUTPUT_FLAG_DIRECT = 0x1
+} audio_policy_output_flags_t;
+
+/* device categories used for audio_policy->set_force_use() */
+typedef enum {
+ AUDIO_POLICY_FORCE_NONE,
+ AUDIO_POLICY_FORCE_SPEAKER,
+ AUDIO_POLICY_FORCE_HEADPHONES,
+ AUDIO_POLICY_FORCE_BT_SCO,
+ AUDIO_POLICY_FORCE_BT_A2DP,
+ AUDIO_POLICY_FORCE_WIRED_ACCESSORY,
+ AUDIO_POLICY_FORCE_BT_CAR_DOCK,
+ AUDIO_POLICY_FORCE_BT_DESK_DOCK,
+ AUDIO_POLICY_FORCE_ANALOG_DOCK,
+ AUDIO_POLICY_FORCE_DIGITAL_DOCK,
+
+ AUDIO_POLICY_FORCE_CFG_CNT,
+ AUDIO_POLICY_FORCE_CFG_MAX = AUDIO_POLICY_FORCE_CFG_CNT - 1,
+
+ AUDIO_POLICY_FORCE_DEFAULT = AUDIO_POLICY_FORCE_NONE,
+} audio_policy_forced_cfg_t;
+
+/* usages used for audio_policy->set_force_use() */
+typedef enum {
+ AUDIO_POLICY_FORCE_FOR_COMMUNICATION,
+ AUDIO_POLICY_FORCE_FOR_MEDIA,
+ AUDIO_POLICY_FORCE_FOR_RECORD,
+ AUDIO_POLICY_FORCE_FOR_DOCK,
+
+ AUDIO_POLICY_FORCE_USE_CNT,
+ AUDIO_POLICY_FORCE_USE_MAX = AUDIO_POLICY_FORCE_USE_CNT - 1,
+} audio_policy_force_use_t;
+
+/* device connection states used for audio_policy->set_device_connection_state()
+ */
+typedef enum {
+ AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
+ AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
+
+ AUDIO_POLICY_DEVICE_STATE_CNT,
+ AUDIO_POLICY_DEVICE_STATE_MAX = AUDIO_POLICY_DEVICE_STATE_CNT - 1,
+} audio_policy_dev_state_t;
+
+typedef enum {
+ /* Used to generate a tone to notify the user of a
+ * notification/alarm/ringtone while they are in a call. */
+ AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION = 0,
+
+ AUDIO_POLICY_TONE_CNT,
+ AUDIO_POLICY_TONE_MAX = AUDIO_POLICY_TONE_CNT - 1,
+} audio_policy_tone_t;
+
+
+static inline bool audio_is_low_visibility(audio_stream_type_t stream)
+{
+ switch (stream) {
+ case AUDIO_STREAM_SYSTEM:
+ case AUDIO_STREAM_NOTIFICATION:
+ case AUDIO_STREAM_RING:
+ return true;
+ default:
+ return false;
+ }
+}
+
+
+__END_DECLS
+
+#endif // ANDROID_AUDIO_POLICY_CORE_H
diff --git a/include/system/camera.h b/include/system/camera.h
new file mode 100644
index 0000000..81ce4cb
--- /dev/null
+++ b/include/system/camera.h
@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2011 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 SYSTEM_CORE_INCLUDE_ANDROID_CAMERA_H
+#define SYSTEM_CORE_INCLUDE_ANDROID_CAMERA_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <cutils/native_handle.h>
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+
+__BEGIN_DECLS
+
+/**
+ * A set of bit masks for specifying how the received preview frames are
+ * handled before the previewCallback() call.
+ *
+ * The least significant 3 bits of an "int" value are used for this purpose:
+ *
+ * ..... 0 0 0
+ * ^ ^ ^
+ * | | |---------> determine whether the callback is enabled or not
+ * | |-----------> determine whether the callback is one-shot or not
+ * |-------------> determine whether the frame is copied out or not
+ *
+ * WARNING: When a frame is sent directly without copying, it is the frame
+ * receiver's responsiblity to make sure that the frame data won't get
+ * corrupted by subsequent preview frames filled by the camera. This flag is
+ * recommended only when copying out data brings significant performance price
+ * and the handling/processing of the received frame data is always faster than
+ * the preview frame rate so that data corruption won't occur.
+ *
+ * For instance,
+ * 1. 0x00 disables the callback. In this case, copy out and one shot bits
+ * are ignored.
+ * 2. 0x01 enables a callback without copying out the received frames. A
+ * typical use case is the Camcorder application to avoid making costly
+ * frame copies.
+ * 3. 0x05 is enabling a callback with frame copied out repeatedly. A typical
+ * use case is the Camera application.
+ * 4. 0x07 is enabling a callback with frame copied out only once. A typical
+ * use case is the Barcode scanner application.
+ */
+
+enum {
+ CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK = 0x01,
+ CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK = 0x02,
+ CAMERA_FRAME_CALLBACK_FLAG_COPY_OUT_MASK = 0x04,
+ /** Typical use cases */
+ CAMERA_FRAME_CALLBACK_FLAG_NOOP = 0x00,
+ CAMERA_FRAME_CALLBACK_FLAG_CAMCORDER = 0x01,
+ CAMERA_FRAME_CALLBACK_FLAG_CAMERA = 0x05,
+ CAMERA_FRAME_CALLBACK_FLAG_BARCODE_SCANNER = 0x07
+};
+
+/** msgType in notifyCallback and dataCallback functions */
+enum {
+ CAMERA_MSG_ERROR = 0x0001, // notifyCallback
+ CAMERA_MSG_SHUTTER = 0x0002, // notifyCallback
+ CAMERA_MSG_FOCUS = 0x0004, // notifyCallback
+ CAMERA_MSG_ZOOM = 0x0008, // notifyCallback
+ CAMERA_MSG_PREVIEW_FRAME = 0x0010, // dataCallback
+ CAMERA_MSG_VIDEO_FRAME = 0x0020, // data_timestamp_callback
+ CAMERA_MSG_POSTVIEW_FRAME = 0x0040, // dataCallback
+ CAMERA_MSG_RAW_IMAGE = 0x0080, // dataCallback
+ CAMERA_MSG_COMPRESSED_IMAGE = 0x0100, // dataCallback
+ CAMERA_MSG_RAW_IMAGE_NOTIFY = 0x0200, // dataCallback
+ // Preview frame metadata. This can be combined with
+ // CAMERA_MSG_PREVIEW_FRAME in dataCallback. For example, the apps can
+ // request FRAME and METADATA. Or the apps can request only FRAME or only
+ // METADATA.
+ CAMERA_MSG_PREVIEW_METADATA = 0x0400, // dataCallback
+ CAMERA_MSG_ALL_MSGS = 0xFFFF
+};
+
+/** cmdType in sendCommand functions */
+enum {
+ CAMERA_CMD_START_SMOOTH_ZOOM = 1,
+ CAMERA_CMD_STOP_SMOOTH_ZOOM = 2,
+
+ /**
+ * Set the clockwise rotation of preview display (setPreviewDisplay) in
+ * degrees. This affects the preview frames and the picture displayed after
+ * snapshot. This method is useful for portrait mode applications. Note
+ * that preview display of front-facing cameras is flipped horizontally
+ * before the rotation, that is, the image is reflected along the central
+ * vertical axis of the camera sensor. So the users can see themselves as
+ * looking into a mirror.
+ *
+ * This does not affect the order of byte array of
+ * CAMERA_MSG_PREVIEW_FRAME, CAMERA_MSG_VIDEO_FRAME,
+ * CAMERA_MSG_POSTVIEW_FRAME, CAMERA_MSG_RAW_IMAGE, or
+ * CAMERA_MSG_COMPRESSED_IMAGE. This is not allowed to be set during
+ * preview
+ */
+ CAMERA_CMD_SET_DISPLAY_ORIENTATION = 3,
+
+ /**
+ * cmdType to disable/enable shutter sound. In sendCommand passing arg1 =
+ * 0 will disable, while passing arg1 = 1 will enable the shutter sound.
+ */
+ CAMERA_CMD_ENABLE_SHUTTER_SOUND = 4,
+
+ /* cmdType to play recording sound */
+ CAMERA_CMD_PLAY_RECORDING_SOUND = 5,
+
+ /**
+ * Start the face detection. This should be called after preview is started.
+ * The camera will notify the listener of CAMERA_MSG_FACE and the detected
+ * faces in the preview frame. The detected faces may be the same as the
+ * previous ones. Apps should call CAMERA_CMD_STOP_FACE_DETECTION to stop
+ * the face detection. This method is supported if CameraParameters
+ * KEY_MAX_NUM_HW_DETECTED_FACES or KEY_MAX_NUM_SW_DETECTED_FACES is
+ * bigger than 0. Hardware and software face detection should not be running
+ * at the same time. If the face detection has started, apps should not send
+ * this again.
+ *
+ * In hardware face detection mode, CameraParameters KEY_WHITE_BALANCE,
+ * KEY_FOCUS_AREAS and KEY_METERING_AREAS have no effect.
+ *
+ * arg1 is the face detection type. It can be CAMERA_FACE_DETECTION_HW or
+ * CAMERA_FACE_DETECTION_SW.
+ */
+ CAMERA_CMD_START_FACE_DETECTION = 6,
+
+ /**
+ * Stop the face detection.
+ */
+ CAMERA_CMD_STOP_FACE_DETECTION = 7,
+};
+
+/** camera fatal errors */
+enum {
+ CAMERA_ERROR_UNKNOWN = 1,
+ CAMERA_ERROR_SERVER_DIED = 100
+};
+
+enum {
+ /** The facing of the camera is opposite to that of the screen. */
+ CAMERA_FACING_BACK = 0,
+ /** The facing of the camera is the same as that of the screen. */
+ CAMERA_FACING_FRONT = 1
+};
+
+enum {
+ /** Hardware face detection. It does not use much CPU. */
+ CAMERA_FACE_DETECTION_HW = 0,
+ /**
+ * Software face detection. It uses some CPU. Applications must use
+ * Camera.setPreviewTexture for preview in this mode.
+ */
+ CAMERA_FACE_DETECTION_SW = 1
+};
+
+/**
+ * The information of a face from camera face detection.
+ */
+typedef struct camera_face {
+ /**
+ * Bounds of the face [left, top, right, bottom]. (-1000, -1000) represents
+ * the top-left of the camera field of view, and (1000, 1000) represents the
+ * bottom-right of the field of view. The width and height cannot be 0 or
+ * negative. This is supported by both hardware and software face detection.
+ *
+ * The direction is relative to the sensor orientation, that is, what the
+ * sensor sees. The direction is not affected by the rotation or mirroring
+ * of CAMERA_CMD_SET_DISPLAY_ORIENTATION.
+ */
+ int32_t rect[4];
+
+ /**
+ * The confidence level of the face. The range is 1 to 100. 100 is the
+ * highest confidence. This is supported by both hardware and software
+ * face detection.
+ */
+ int32_t score;
+
+ /**
+ * An unique id per face while the face is visible to the tracker. If
+ * the face leaves the field-of-view and comes back, it will get a new
+ * id. If the value is 0, id is not supported.
+ */
+ int32_t id;
+
+ /**
+ * The coordinates of the center of the left eye. The range is -1000 to
+ * 1000. -2000, -2000 if this is not supported.
+ */
+ int32_t left_eye[2];
+
+ /**
+ * The coordinates of the center of the right eye. The range is -1000 to
+ * 1000. -2000, -2000 if this is not supported.
+ */
+ int32_t right_eye[2];
+
+ /**
+ * The coordinates of the center of the mouth. The range is -1000 to 1000.
+ * -2000, -2000 if this is not supported.
+ */
+ int32_t mouth[2];
+
+} camera_face_t;
+
+/**
+ * The metadata of the frame data.
+ */
+typedef struct camera_frame_metadata {
+ /**
+ * The number of detected faces in the frame.
+ */
+ int32_t number_of_faces;
+
+ /**
+ * An array of the detected faces. The length is number_of_faces. The list
+ * is sorted by the score. The highest score is the first element.
+ */
+ camera_face_t *faces;
+} camera_frame_metadata_t;
+
+__END_DECLS
+
+#endif /* SYSTEM_CORE_INCLUDE_ANDROID_CAMERA_H */
diff --git a/include/system/graphics.h b/include/system/graphics.h
new file mode 100644
index 0000000..729e92c
--- /dev/null
+++ b/include/system/graphics.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2011 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 SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H
+#define SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * If the HAL needs to create service threads to handle graphics related
+ * tasks, these threads need to run at HAL_PRIORITY_URGENT_DISPLAY priority
+ * if they can block the main rendering thread in any way.
+ *
+ * the priority of the current thread can be set with:
+ *
+ * #include <sys/resource.h>
+ * setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
+ *
+ */
+
+#define HAL_PRIORITY_URGENT_DISPLAY (-8)
+
+/**
+ * pixel format definitions
+ */
+
+enum {
+ HAL_PIXEL_FORMAT_RGBA_8888 = 1,
+ HAL_PIXEL_FORMAT_RGBX_8888 = 2,
+ HAL_PIXEL_FORMAT_RGB_888 = 3,
+ HAL_PIXEL_FORMAT_RGB_565 = 4,
+ HAL_PIXEL_FORMAT_BGRA_8888 = 5,
+ HAL_PIXEL_FORMAT_RGBA_5551 = 6,
+ HAL_PIXEL_FORMAT_RGBA_4444 = 7,
+
+ /* 0x8 - 0xFF range unavailable */
+
+ /*
+ * 0x100 - 0x1FF
+ *
+ * This range is reserved for pixel formats that are specific to the HAL
+ * implementation. Implementations can use any value in this range to
+ * communicate video pixel formats between their HAL modules. These formats
+ * must not have an alpha channel. Additionally, an EGLimage created from a
+ * gralloc buffer of one of these formats must be supported for use with the
+ * GL_OES_EGL_image_external OpenGL ES extension.
+ */
+
+ /*
+ * Android YUV format:
+ *
+ * This format is exposed outside of the HAL to software decoders and
+ * applications. EGLImageKHR must support it in conjunction with the
+ * OES_EGL_image_external extension.
+ *
+ * YV12 is a 4:2:0 YCrCb planar format comprised of a WxH Y plane followed
+ * by (W/2) x (H/2) Cr and Cb planes.
+ *
+ * This format assumes
+ * - an even width
+ * - an even height
+ * - a horizontal stride multiple of 16 pixels
+ * - a vertical stride equal to the height
+ *
+ * y_size = stride * height
+ * c_size = ALIGN(stride/2, 16) * height/2
+ * size = y_size + c_size * 2
+ * cr_offset = y_size
+ * cb_offset = y_size + c_size
+ *
+ */
+ HAL_PIXEL_FORMAT_YV12 = 0x32315659, // YCrCb 4:2:0 Planar
+
+
+
+ /* Legacy formats (deprecated), used by ImageFormat.java */
+ HAL_PIXEL_FORMAT_YCbCr_422_SP = 0x10, // NV16
+ HAL_PIXEL_FORMAT_YCrCb_420_SP = 0x11, // NV21
+ HAL_PIXEL_FORMAT_YCbCr_422_I = 0x14, // YUY2
+};
+
+
+/**
+ * Transformation definitions
+ *
+ * IMPORTANT NOTE:
+ * HAL_TRANSFORM_ROT_90 is applied CLOCKWISE and AFTER HAL_TRANSFORM_FLIP_{H|V}.
+ *
+ */
+
+enum {
+ /* flip source image horizontally (around the vertical axis) */
+ HAL_TRANSFORM_FLIP_H = 0x01,
+ /* flip source image vertically (around the horizontal axis)*/
+ HAL_TRANSFORM_FLIP_V = 0x02,
+ /* rotate source image 90 degrees clockwise */
+ HAL_TRANSFORM_ROT_90 = 0x04,
+ /* rotate source image 180 degrees */
+ HAL_TRANSFORM_ROT_180 = 0x03,
+ /* rotate source image 270 degrees clockwise */
+ HAL_TRANSFORM_ROT_270 = 0x07,
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SYSTEM_CORE_INCLUDE_ANDROID_GRAPHICS_H */
diff --git a/include/system/window.h b/include/system/window.h
new file mode 100644
index 0000000..959bd23
--- /dev/null
+++ b/include/system/window.h
@@ -0,0 +1,614 @@
+/*
+ * Copyright (C) 2011 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 SYSTEM_CORE_INCLUDE_ANDROID_WINDOW_H
+#define SYSTEM_CORE_INCLUDE_ANDROID_WINDOW_H
+
+#include <stdint.h>
+#include <sys/cdefs.h>
+#include <system/graphics.h>
+#include <cutils/native_handle.h>
+
+__BEGIN_DECLS
+
+/*****************************************************************************/
+
+#define ANDROID_NATIVE_MAKE_CONSTANT(a,b,c,d) \
+ (((unsigned)(a)<<24)|((unsigned)(b)<<16)|((unsigned)(c)<<8)|(unsigned)(d))
+
+#define ANDROID_NATIVE_WINDOW_MAGIC \
+ ANDROID_NATIVE_MAKE_CONSTANT('_','w','n','d')
+
+#define ANDROID_NATIVE_BUFFER_MAGIC \
+ ANDROID_NATIVE_MAKE_CONSTANT('_','b','f','r')
+
+// ---------------------------------------------------------------------------
+
+typedef const native_handle_t* buffer_handle_t;
+
+// ---------------------------------------------------------------------------
+
+typedef struct android_native_rect_t
+{
+ int32_t left;
+ int32_t top;
+ int32_t right;
+ int32_t bottom;
+} android_native_rect_t;
+
+// ---------------------------------------------------------------------------
+
+typedef struct android_native_base_t
+{
+ /* a magic value defined by the actual EGL native type */
+ int magic;
+
+ /* the sizeof() of the actual EGL native type */
+ int version;
+
+ void* reserved[4];
+
+ /* reference-counting interface */
+ void (*incRef)(struct android_native_base_t* base);
+ void (*decRef)(struct android_native_base_t* base);
+} android_native_base_t;
+
+typedef struct ANativeWindowBuffer
+{
+#ifdef __cplusplus
+ ANativeWindowBuffer() {
+ common.magic = ANDROID_NATIVE_BUFFER_MAGIC;
+ common.version = sizeof(ANativeWindowBuffer);
+ memset(common.reserved, 0, sizeof(common.reserved));
+ }
+
+ // Implement the methods that sp<ANativeWindowBuffer> expects so that it
+ // can be used to automatically refcount ANativeWindowBuffer's.
+ void incStrong(const void* id) const {
+ common.incRef(const_cast<android_native_base_t*>(&common));
+ }
+ void decStrong(const void* id) const {
+ common.decRef(const_cast<android_native_base_t*>(&common));
+ }
+#endif
+
+ struct android_native_base_t common;
+
+ int width;
+ int height;
+ int stride;
+ int format;
+ int usage;
+
+ void* reserved[2];
+
+ buffer_handle_t handle;
+
+ void* reserved_proc[8];
+} ANativeWindowBuffer_t;
+
+// Old typedef for backwards compatibility.
+typedef ANativeWindowBuffer_t android_native_buffer_t;
+
+// ---------------------------------------------------------------------------
+
+/* attributes queriable with query() */
+enum {
+ NATIVE_WINDOW_WIDTH = 0,
+ NATIVE_WINDOW_HEIGHT = 1,
+ NATIVE_WINDOW_FORMAT = 2,
+
+ /* The minimum number of buffers that must remain un-dequeued after a buffer
+ * has been queued. This value applies only if set_buffer_count was used to
+ * override the number of buffers and if a buffer has since been queued.
+ * Users of the set_buffer_count ANativeWindow method should query this
+ * value before calling set_buffer_count. If it is necessary to have N
+ * buffers simultaneously dequeued as part of the steady-state operation,
+ * and this query returns M then N+M buffers should be requested via
+ * native_window_set_buffer_count.
+ *
+ * Note that this value does NOT apply until a single buffer has been
+ * queued. In particular this means that it is possible to:
+ *
+ * 1. Query M = min undequeued buffers
+ * 2. Set the buffer count to N + M
+ * 3. Dequeue all N + M buffers
+ * 4. Cancel M buffers
+ * 5. Queue, dequeue, queue, dequeue, ad infinitum
+ */
+ NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS = 3,
+
+ /* Check whether queueBuffer operations on the ANativeWindow send the buffer
+ * to the window compositor. The query sets the returned 'value' argument
+ * to 1 if the ANativeWindow DOES send queued buffers directly to the window
+ * compositor and 0 if the buffers do not go directly to the window
+ * compositor.
+ *
+ * This can be used to determine whether protected buffer content should be
+ * sent to the ANativeWindow. Note, however, that a result of 1 does NOT
+ * indicate that queued buffers will be protected from applications or users
+ * capturing their contents. If that behavior is desired then some other
+ * mechanism (e.g. the GRALLOC_USAGE_PROTECTED flag) should be used in
+ * conjunction with this query.
+ */
+ NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER = 4,
+
+ /* Get the concrete type of a ANativeWindow. See below for the list of
+ * possible return values.
+ *
+ * This query should not be used outside the Android framework and will
+ * likely be removed in the near future.
+ */
+ NATIVE_WINDOW_CONCRETE_TYPE = 5,
+
+
+ /*
+ * Default width and height of the ANativeWindow, these are the dimensions
+ * of the window irrespective of the NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
+ * call.
+ */
+ NATIVE_WINDOW_DEFAULT_WIDTH = 6,
+ NATIVE_WINDOW_DEFAULT_HEIGHT = 7,
+
+ /*
+ * transformation that will most-likely be applied to buffers. This is only
+ * a hint, the actual transformation applied might be different.
+ *
+ * INTENDED USE:
+ *
+ * The transform hint can be used by a producer, for instance the GLES
+ * driver, to pre-rotate the rendering such that the final transformation
+ * in the composer is identity. This can be very useful when used in
+ * conjunction with the h/w composer HAL, in situations where it
+ * cannot handle arbitrary rotations.
+ *
+ * 1. Before dequeuing a buffer, the GL driver (or any other ANW client)
+ * queries the ANW for NATIVE_WINDOW_TRANSFORM_HINT.
+ *
+ * 2. The GL driver overrides the width and height of the ANW to
+ * account for NATIVE_WINDOW_TRANSFORM_HINT. This is done by querying
+ * NATIVE_WINDOW_DEFAULT_{WIDTH | HEIGHT}, swapping the dimensions
+ * according to NATIVE_WINDOW_TRANSFORM_HINT and calling
+ * native_window_set_buffers_dimensions().
+ *
+ * 3. The GL driver dequeues a buffer of the new pre-rotated size.
+ *
+ * 4. The GL driver renders to the buffer such that the image is
+ * already transformed, that is applying NATIVE_WINDOW_TRANSFORM_HINT
+ * to the rendering.
+ *
+ * 5. The GL driver calls native_window_set_transform to apply
+ * inverse transformation to the buffer it just rendered.
+ * In order to do this, the GL driver needs
+ * to calculate the inverse of NATIVE_WINDOW_TRANSFORM_HINT, this is
+ * done easily:
+ *
+ * int hintTransform, inverseTransform;
+ * query(..., NATIVE_WINDOW_TRANSFORM_HINT, &hintTransform);
+ * inverseTransform = hintTransform;
+ * if (hintTransform & HAL_TRANSFORM_ROT_90)
+ * inverseTransform ^= HAL_TRANSFORM_ROT_180;
+ *
+ *
+ * 6. The GL driver queues the pre-transformed buffer.
+ *
+ * 7. The composer combines the buffer transform with the display
+ * transform. If the buffer transform happens to cancel out the
+ * display transform then no rotation is needed.
+ *
+ */
+ NATIVE_WINDOW_TRANSFORM_HINT = 8,
+};
+
+/* valid operations for the (*perform)() hook */
+enum {
+ NATIVE_WINDOW_SET_USAGE = 0,
+ NATIVE_WINDOW_CONNECT = 1, /* deprecated */
+ NATIVE_WINDOW_DISCONNECT = 2, /* deprecated */
+ NATIVE_WINDOW_SET_CROP = 3,
+ NATIVE_WINDOW_SET_BUFFER_COUNT = 4,
+ NATIVE_WINDOW_SET_BUFFERS_GEOMETRY = 5, /* deprecated */
+ NATIVE_WINDOW_SET_BUFFERS_TRANSFORM = 6,
+ NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP = 7,
+ NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS = 8,
+ NATIVE_WINDOW_SET_BUFFERS_FORMAT = 9,
+ NATIVE_WINDOW_SET_SCALING_MODE = 10,
+ NATIVE_WINDOW_LOCK = 11, /* private */
+ NATIVE_WINDOW_UNLOCK_AND_POST = 12, /* private */
+ NATIVE_WINDOW_API_CONNECT = 13, /* private */
+ NATIVE_WINDOW_API_DISCONNECT = 14, /* private */
+};
+
+/* parameter for NATIVE_WINDOW_[API_][DIS]CONNECT */
+enum {
+ /* Buffers will be queued by EGL via eglSwapBuffers after being filled using
+ * OpenGL ES.
+ */
+ NATIVE_WINDOW_API_EGL = 1,
+
+ /* Buffers will be queued after being filled using the CPU
+ */
+ NATIVE_WINDOW_API_CPU = 2,
+
+ /* Buffers will be queued by Stagefright after being filled by a video
+ * decoder. The video decoder can either be a software or hardware decoder.
+ */
+ NATIVE_WINDOW_API_MEDIA = 3,
+
+ /* Buffers will be queued by the the camera HAL.
+ */
+ NATIVE_WINDOW_API_CAMERA = 4,
+};
+
+/* parameter for NATIVE_WINDOW_SET_BUFFERS_TRANSFORM */
+enum {
+ /* flip source image horizontally */
+ NATIVE_WINDOW_TRANSFORM_FLIP_H = HAL_TRANSFORM_FLIP_H ,
+ /* flip source image vertically */
+ NATIVE_WINDOW_TRANSFORM_FLIP_V = HAL_TRANSFORM_FLIP_V,
+ /* rotate source image 90 degrees clock-wise */
+ NATIVE_WINDOW_TRANSFORM_ROT_90 = HAL_TRANSFORM_ROT_90,
+ /* rotate source image 180 degrees */
+ NATIVE_WINDOW_TRANSFORM_ROT_180 = HAL_TRANSFORM_ROT_180,
+ /* rotate source image 270 degrees clock-wise */
+ NATIVE_WINDOW_TRANSFORM_ROT_270 = HAL_TRANSFORM_ROT_270,
+};
+
+/* parameter for NATIVE_WINDOW_SET_SCALING_MODE */
+enum {
+ /* the window content is not updated (frozen) until a buffer of
+ * the window size is received (enqueued)
+ */
+ NATIVE_WINDOW_SCALING_MODE_FREEZE = 0,
+ /* the buffer is scaled in both dimensions to match the window size */
+ NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW = 1,
+};
+
+/* values returned by the NATIVE_WINDOW_CONCRETE_TYPE query */
+enum {
+ NATIVE_WINDOW_FRAMEBUFFER = 0, /* FramebufferNativeWindow */
+ NATIVE_WINDOW_SURFACE = 1, /* Surface */
+ NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT = 2, /* SurfaceTextureClient */
+};
+
+/* parameter for NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
+ *
+ * Special timestamp value to indicate that timestamps should be auto-generated
+ * by the native window when queueBuffer is called. This is equal to INT64_MIN,
+ * defined directly to avoid problems with C99/C++ inclusion of stdint.h.
+ */
+static const int64_t NATIVE_WINDOW_TIMESTAMP_AUTO = (-9223372036854775807LL-1);
+
+struct ANativeWindow
+{
+#ifdef __cplusplus
+ ANativeWindow()
+ : flags(0), minSwapInterval(0), maxSwapInterval(0), xdpi(0), ydpi(0)
+ {
+ common.magic = ANDROID_NATIVE_WINDOW_MAGIC;
+ common.version = sizeof(ANativeWindow);
+ memset(common.reserved, 0, sizeof(common.reserved));
+ }
+
+ /* Implement the methods that sp<ANativeWindow> expects so that it
+ can be used to automatically refcount ANativeWindow's. */
+ void incStrong(const void* id) const {
+ common.incRef(const_cast<android_native_base_t*>(&common));
+ }
+ void decStrong(const void* id) const {
+ common.decRef(const_cast<android_native_base_t*>(&common));
+ }
+#endif
+
+ struct android_native_base_t common;
+
+ /* flags describing some attributes of this surface or its updater */
+ const uint32_t flags;
+
+ /* min swap interval supported by this updated */
+ const int minSwapInterval;
+
+ /* max swap interval supported by this updated */
+ const int maxSwapInterval;
+
+ /* horizontal and vertical resolution in DPI */
+ const float xdpi;
+ const float ydpi;
+
+ /* Some storage reserved for the OEM's driver. */
+ intptr_t oem[4];
+
+ /*
+ * Set the swap interval for this surface.
+ *
+ * Returns 0 on success or -errno on error.
+ */
+ int (*setSwapInterval)(struct ANativeWindow* window,
+ int interval);
+
+ /*
+ * hook called by EGL to acquire a buffer. After this call, the buffer
+ * is not locked, so its content cannot be modified.
+ * this call may block if no buffers are available.
+ *
+ * Returns 0 on success or -errno on error.
+ */
+ int (*dequeueBuffer)(struct ANativeWindow* window,
+ struct ANativeWindowBuffer** buffer);
+
+ /*
+ * hook called by EGL to lock a buffer. This MUST be called before modifying
+ * the content of a buffer. The buffer must have been acquired with
+ * dequeueBuffer first.
+ *
+ * Returns 0 on success or -errno on error.
+ */
+ int (*lockBuffer)(struct ANativeWindow* window,
+ struct ANativeWindowBuffer* buffer);
+ /*
+ * hook called by EGL when modifications to the render buffer are done.
+ * This unlocks and post the buffer.
+ *
+ * Buffers MUST be queued in the same order than they were dequeued.
+ *
+ * Returns 0 on success or -errno on error.
+ */
+ int (*queueBuffer)(struct ANativeWindow* window,
+ struct ANativeWindowBuffer* buffer);
+
+ /*
+ * hook used to retrieve information about the native window.
+ *
+ * Returns 0 on success or -errno on error.
+ */
+ int (*query)(const struct ANativeWindow* window,
+ int what, int* value);
+
+ /*
+ * hook used to perform various operations on the surface.
+ * (*perform)() is a generic mechanism to add functionality to
+ * ANativeWindow while keeping backward binary compatibility.
+ *
+ * DO NOT CALL THIS HOOK DIRECTLY. Instead, use the helper functions
+ * defined below.
+ *
+ * (*perform)() returns -ENOENT if the 'what' parameter is not supported
+ * by the surface's implementation.
+ *
+ * The valid operations are:
+ * NATIVE_WINDOW_SET_USAGE
+ * NATIVE_WINDOW_CONNECT (deprecated)
+ * NATIVE_WINDOW_DISCONNECT (deprecated)
+ * NATIVE_WINDOW_SET_CROP
+ * NATIVE_WINDOW_SET_BUFFER_COUNT
+ * NATIVE_WINDOW_SET_BUFFERS_GEOMETRY (deprecated)
+ * NATIVE_WINDOW_SET_BUFFERS_TRANSFORM
+ * NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
+ * NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
+ * NATIVE_WINDOW_SET_BUFFERS_FORMAT
+ * NATIVE_WINDOW_SET_SCALING_MODE
+ * NATIVE_WINDOW_LOCK (private)
+ * NATIVE_WINDOW_UNLOCK_AND_POST (private)
+ * NATIVE_WINDOW_API_CONNECT (private)
+ * NATIVE_WINDOW_API_DISCONNECT (private)
+ *
+ */
+
+ int (*perform)(struct ANativeWindow* window,
+ int operation, ... );
+
+ /*
+ * hook used to cancel a buffer that has been dequeued.
+ * No synchronization is performed between dequeue() and cancel(), so
+ * either external synchronization is needed, or these functions must be
+ * called from the same thread.
+ */
+ int (*cancelBuffer)(struct ANativeWindow* window,
+ struct ANativeWindowBuffer* buffer);
+
+
+ void* reserved_proc[2];
+};
+
+ /* Backwards compatibility: use ANativeWindow (struct ANativeWindow in C).
+ * android_native_window_t is deprecated.
+ */
+typedef struct ANativeWindow ANativeWindow;
+typedef struct ANativeWindow android_native_window_t;
+
+/*
+ * native_window_set_usage(..., usage)
+ * Sets the intended usage flags for the next buffers
+ * acquired with (*lockBuffer)() and on.
+ * By default (if this function is never called), a usage of
+ * GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE
+ * is assumed.
+ * Calling this function will usually cause following buffers to be
+ * reallocated.
+ */
+
+static inline int native_window_set_usage(
+ struct ANativeWindow* window, int usage)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_USAGE, usage);
+}
+
+/* deprecated. Always returns 0. Don't call. */
+static inline int native_window_connect(
+ struct ANativeWindow* window, int api) {
+ return 0;
+}
+
+/* deprecated. Always returns 0. Don't call. */
+static inline int native_window_disconnect(
+ struct ANativeWindow* window, int api) {
+ return 0;
+}
+
+/*
+ * native_window_set_crop(..., crop)
+ * Sets which region of the next queued buffers needs to be considered.
+ * A buffer's crop region is scaled to match the surface's size.
+ *
+ * The specified crop region applies to all buffers queued after it is called.
+ *
+ * if 'crop' is NULL, subsequently queued buffers won't be cropped.
+ *
+ * An error is returned if for instance the crop region is invalid,
+ * out of the buffer's bound or if the window is invalid.
+ */
+static inline int native_window_set_crop(
+ struct ANativeWindow* window,
+ android_native_rect_t const * crop)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_CROP, crop);
+}
+
+/*
+ * native_window_set_buffer_count(..., count)
+ * Sets the number of buffers associated with this native window.
+ */
+static inline int native_window_set_buffer_count(
+ struct ANativeWindow* window,
+ size_t bufferCount)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_BUFFER_COUNT, bufferCount);
+}
+
+/*
+ * native_window_set_buffers_geometry(..., int w, int h, int format)
+ * All buffers dequeued after this call will have the dimensions and format
+ * specified. A successful call to this function has the same effect as calling
+ * native_window_set_buffers_size and native_window_set_buffers_format.
+ *
+ * XXX: This function is deprecated. The native_window_set_buffers_dimensions
+ * and native_window_set_buffers_format functions should be used instead.
+ */
+static inline int native_window_set_buffers_geometry(
+ struct ANativeWindow* window,
+ int w, int h, int format)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_GEOMETRY,
+ w, h, format);
+}
+
+/*
+ * native_window_set_buffers_dimensions(..., int w, int h)
+ * All buffers dequeued after this call will have the dimensions specified.
+ * In particular, all buffers will have a fixed-size, independent form the
+ * native-window size. They will be scaled according to the scaling mode
+ * (see native_window_set_scaling_mode) upon window composition.
+ *
+ * If w and h are 0, the normal behavior is restored. That is, dequeued buffers
+ * following this call will be sized to match the window's size.
+ *
+ * Calling this function will reset the window crop to a NULL value, which
+ * disables cropping of the buffers.
+ */
+static inline int native_window_set_buffers_dimensions(
+ struct ANativeWindow* window,
+ int w, int h)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS,
+ w, h);
+}
+
+/*
+ * native_window_set_buffers_format(..., int format)
+ * All buffers dequeued after this call will have the format specified.
+ *
+ * If the specified format is 0, the default buffer format will be used.
+ */
+static inline int native_window_set_buffers_format(
+ struct ANativeWindow* window,
+ int format)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_FORMAT, format);
+}
+
+/*
+ * native_window_set_buffers_transform(..., int transform)
+ * All buffers queued after this call will be displayed transformed according
+ * to the transform parameter specified.
+ */
+static inline int native_window_set_buffers_transform(
+ struct ANativeWindow* window,
+ int transform)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_TRANSFORM,
+ transform);
+}
+
+/*
+ * native_window_set_buffers_timestamp(..., int64_t timestamp)
+ * All buffers queued after this call will be associated with the timestamp
+ * parameter specified. If the timestamp is set to NATIVE_WINDOW_TIMESTAMP_AUTO
+ * (the default), timestamps will be generated automatically when queueBuffer is
+ * called. The timestamp is measured in nanoseconds, and is normally monotonically
+ * increasing. The timestamp should be unaffected by time-of-day adjustments,
+ * and for a camera should be strictly monotonic but for a media player may be
+ * reset when the position is set.
+ */
+static inline int native_window_set_buffers_timestamp(
+ struct ANativeWindow* window,
+ int64_t timestamp)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP,
+ timestamp);
+}
+
+/*
+ * native_window_set_scaling_mode(..., int mode)
+ * All buffers queued after this call will be associated with the scaling mode
+ * specified.
+ */
+static inline int native_window_set_scaling_mode(
+ struct ANativeWindow* window,
+ int mode)
+{
+ return window->perform(window, NATIVE_WINDOW_SET_SCALING_MODE,
+ mode);
+}
+
+
+/*
+ * native_window_api_connect(..., int api)
+ * connects an API to this window. only one API can be connected at a time.
+ * Returns -EINVAL if for some reason the window cannot be connected, which
+ * can happen if it's connected to some other API.
+ */
+static inline int native_window_api_connect(
+ struct ANativeWindow* window, int api)
+{
+ return window->perform(window, NATIVE_WINDOW_API_CONNECT, api);
+}
+
+/*
+ * native_window_api_disconnect(..., int api)
+ * disconnect the API from this window.
+ * An error is returned if for instance the window wasn't connected in the
+ * first place.
+ */
+static inline int native_window_api_disconnect(
+ struct ANativeWindow* window, int api)
+{
+ return window->perform(window, NATIVE_WINDOW_API_DISCONNECT, api);
+}
+
+
+__END_DECLS
+
+#endif /* SYSTEM_CORE_INCLUDE_ANDROID_WINDOW_H */
diff --git a/include/sysutils/NetlinkEvent.h b/include/sysutils/NetlinkEvent.h
index b329b09..25a56f7 100644
--- a/include/sysutils/NetlinkEvent.h
+++ b/include/sysutils/NetlinkEvent.h
@@ -16,6 +16,8 @@
#ifndef _NETLINKEVENT_H
#define _NETLINKEVENT_H
+#include <sysutils/NetlinkListener.h>
+
#define NL_PARAMS_MAX 32
class NetlinkEvent {
@@ -30,17 +32,23 @@
const static int NlActionAdd;
const static int NlActionRemove;
const static int NlActionChange;
+ const static int NlActionLinkDown;
+ const static int NlActionLinkUp;
NetlinkEvent();
virtual ~NetlinkEvent();
- bool decode(char *buffer, int size);
+ bool decode(char *buffer, int size, int format = NetlinkListener::NETLINK_FORMAT_ASCII);
const char *findParam(const char *paramName);
const char *getSubsystem() { return mSubsystem; }
int getAction() { return mAction; }
void dump();
+
+ protected:
+ bool parseBinaryNetlinkMessage(char *buffer, int size);
+ bool parseAsciiNetlinkMessage(char *buffer, int size);
};
#endif
diff --git a/include/sysutils/NetlinkListener.h b/include/sysutils/NetlinkListener.h
index 2880046..beb8bda 100644
--- a/include/sysutils/NetlinkListener.h
+++ b/include/sysutils/NetlinkListener.h
@@ -22,13 +22,27 @@
class NetlinkListener : public SocketListener {
char mBuffer[64 * 1024];
+ int mFormat;
public:
+ static const int NETLINK_FORMAT_ASCII = 0;
+ static const int NETLINK_FORMAT_BINARY = 1;
+
+#if 1
+ /* temporary version until we can get Motorola to update their
+ * ril.so. Their prebuilt ril.so is using this private class
+ * so changing the NetlinkListener() constructor breaks their ril.
+ */
NetlinkListener(int socket);
+ NetlinkListener(int socket, int format);
+#else
+ NetlinkListener(int socket, int format = NETLINK_FORMAT_ASCII);
+#endif
virtual ~NetlinkListener() {}
protected:
virtual bool onDataAvailable(SocketClient *cli);
virtual void onEvent(NetlinkEvent *evt) = 0;
};
+
#endif
diff --git a/init/builtins.c b/init/builtins.c
index f2f76b7..06ef96d 100644
--- a/init/builtins.c
+++ b/init/builtins.c
@@ -30,6 +30,7 @@
#include <sys/mount.h>
#include <sys/resource.h>
#include <linux/loop.h>
+#include <cutils/partition_utils.h>
#include "init.h"
#include "keywords.h"
@@ -225,14 +226,10 @@
return do_insmod_inner(nargs, args, size);
}
-int do_import(int nargs, char **args)
-{
- return init_parse_config_file(args[1]);
-}
-
int do_mkdir(int nargs, char **args)
{
mode_t mode = 0755;
+ int ret;
/* mkdir <path> [mode] [owner] [group] */
@@ -240,7 +237,12 @@
mode = strtoul(args[2], 0, 8);
}
- if (mkdir(args[1], mode)) {
+ ret = mkdir(args[1], mode);
+ /* chmod in case the directory already exists */
+ if (ret == -1 && errno == EEXIST) {
+ ret = chmod(args[1], mode);
+ }
+ if (ret == -1) {
return -errno;
}
@@ -367,7 +369,9 @@
if (wait)
wait_for_file(source, COMMAND_RETRY_TIMEOUT);
if (mount(source, target, system, flags, options) < 0) {
- /* If this fails, it may be an encrypted filesystem.
+ /* If this fails, it may be an encrypted filesystem
+ * or it could just be wiped. If wiped, that will be
+ * handled later in the boot process.
* We only support encrypting /data. Check
* if we're trying to mount it, and if so,
* assume it's encrypted, mount a tmpfs instead.
@@ -375,7 +379,7 @@
* for vold to query when it mounts the real
* encrypted /data.
*/
- if (!strcmp(target, DATA_MNT_POINT)) {
+ if (!strcmp(target, DATA_MNT_POINT) && !partition_wiped(source)) {
const char *tmpfs_options;
tmpfs_options = property_get("ro.crypto.tmpfs_options");
@@ -442,7 +446,24 @@
int do_setprop(int nargs, char **args)
{
- property_set(args[1], args[2]);
+ const char *name = args[1];
+ const char *value = args[2];
+
+ if (value[0] == '$') {
+ /* Use the value of a system property if value starts with '$' */
+ value++;
+ if (value[0] != '$') {
+ value = property_get(value);
+ if (!value) {
+ ERROR("property %s has no value for assigning to %s\n", value, name);
+ return -EINVAL;
+ }
+ } /* else fall through to support double '$' prefix for setting properties
+ * to string literals that start with '$'
+ */
+ }
+
+ property_set(name, value);
return 0;
}
@@ -524,7 +545,23 @@
int do_write(int nargs, char **args)
{
- return write_file(args[1], args[2]);
+ const char *path = args[1];
+ const char *value = args[2];
+ if (value[0] == '$') {
+ /* Write the value of a system property if value starts with '$' */
+ value++;
+ if (value[0] != '$') {
+ value = property_get(value);
+ if (!value) {
+ ERROR("property %s has no value for writing to %s\n", value, path);
+ return -EINVAL;
+ }
+ } /* else fall through to support double '$' prefix for writing
+ * string literals that start with '$'
+ */
+ }
+
+ return write_file(path, value);
}
int do_copy(int nargs, char **args)
diff --git a/init/devices.c b/init/devices.c
index 9c07e99..60659ce 100644
--- a/init/devices.c
+++ b/init/devices.c
@@ -99,8 +99,15 @@
struct listnode plist;
};
+struct platform_node {
+ char *name;
+ int name_len;
+ struct listnode list;
+};
+
static list_declare(sys_perms);
static list_declare(dev_perms);
+static list_declare(platform_names);
int add_dev_perms(const char *name, const char *attr,
mode_t perm, unsigned int uid, unsigned int gid,
@@ -214,6 +221,68 @@
setegid(AID_ROOT);
}
+static void add_platform_device(const char *name)
+{
+ int name_len = strlen(name);
+ struct listnode *node;
+ struct platform_node *bus;
+
+ list_for_each_reverse(node, &platform_names) {
+ bus = node_to_item(node, struct platform_node, list);
+ if ((bus->name_len < name_len) &&
+ (name[bus->name_len] == '/') &&
+ !strncmp(name, bus->name, bus->name_len))
+ /* subdevice of an existing platform, ignore it */
+ return;
+ }
+
+ INFO("adding platform device %s\n", name);
+
+ bus = calloc(1, sizeof(struct platform_node));
+ bus->name = strdup(name);
+ bus->name_len = name_len;
+ list_add_tail(&platform_names, &bus->list);
+}
+
+/*
+ * given a name that may start with a platform device, find the length of the
+ * platform device prefix. If it doesn't start with a platform device, return
+ * 0.
+ */
+static const char *find_platform_device(const char *name)
+{
+ int name_len = strlen(name);
+ struct listnode *node;
+ struct platform_node *bus;
+
+ list_for_each_reverse(node, &platform_names) {
+ bus = node_to_item(node, struct platform_node, list);
+ if ((bus->name_len < name_len) &&
+ (name[bus->name_len] == '/') &&
+ !strncmp(name, bus->name, bus->name_len))
+ return bus->name;
+ }
+
+ return NULL;
+}
+
+static void remove_platform_device(const char *name)
+{
+ struct listnode *node;
+ struct platform_node *bus;
+
+ list_for_each_reverse(node, &platform_names) {
+ bus = node_to_item(node, struct platform_node, list);
+ if (!strcmp(name, bus->name)) {
+ INFO("removing platform device %s\n", name);
+ free(bus->name);
+ list_remove(node);
+ free(bus);
+ return;
+ }
+ }
+}
+
#if LOG_UEVENTS
static inline suseconds_t get_usecs(void)
@@ -334,7 +403,7 @@
static char **parse_platform_block_device(struct uevent *uevent)
{
- const char *driver;
+ const char *device;
const char *path;
char *slash;
int width;
@@ -354,16 +423,14 @@
/* Drop "/devices/platform/" */
path = uevent->path;
- driver = path + 18;
- slash = strchr(driver, '/');
- if (!slash)
- goto err;
- width = slash - driver;
- if (width <= 0)
+ device = path + 18;
+ device = find_platform_device(device);
+ if (!device)
goto err;
- snprintf(link_path, sizeof(link_path), "/dev/block/platform/%.*s",
- width, driver);
+ INFO("found platform device %s\n", device);
+
+ snprintf(link_path, sizeof(link_path), "/dev/block/platform/%s", device);
if (uevent->partition_name) {
p = strdup(uevent->partition_name);
@@ -395,104 +462,20 @@
return NULL;
}
-static void handle_device_event(struct uevent *uevent)
+static void handle_device(const char *action, const char *devpath,
+ const char *path, int block, int major, int minor, char **links)
{
- char devpath[96];
- int devpath_ready = 0;
- char *base, *name;
- char **links = NULL;
- int block;
int i;
- if (!strcmp(uevent->action,"add"))
- fixup_sys_perms(uevent->path);
-
- /* if it's not a /dev device, nothing else to do */
- if((uevent->major < 0) || (uevent->minor < 0))
- return;
-
- /* do we have a name? */
- name = strrchr(uevent->path, '/');
- if(!name)
- return;
- name++;
-
- /* too-long names would overrun our buffer */
- if(strlen(name) > 64)
- return;
-
- /* are we block or char? where should we live? */
- if(!strncmp(uevent->subsystem, "block", 5)) {
- block = 1;
- base = "/dev/block/";
- mkdir(base, 0755);
- if (!strncmp(uevent->path, "/devices/platform/", 18))
- links = parse_platform_block_device(uevent);
- } else {
- block = 0;
- /* this should probably be configurable somehow */
- if (!strncmp(uevent->subsystem, "usb", 3)) {
- if (!strcmp(uevent->subsystem, "usb")) {
- /* This imitates the file system that would be created
- * if we were using devfs instead.
- * Minors are broken up into groups of 128, starting at "001"
- */
- int bus_id = uevent->minor / 128 + 1;
- int device_id = uevent->minor % 128 + 1;
- /* build directories */
- mkdir("/dev/bus", 0755);
- mkdir("/dev/bus/usb", 0755);
- snprintf(devpath, sizeof(devpath), "/dev/bus/usb/%03d", bus_id);
- mkdir(devpath, 0755);
- snprintf(devpath, sizeof(devpath), "/dev/bus/usb/%03d/%03d", bus_id, device_id);
- devpath_ready = 1;
- } else {
- /* ignore other USB events */
- return;
- }
- } else if (!strncmp(uevent->subsystem, "graphics", 8)) {
- base = "/dev/graphics/";
- mkdir(base, 0755);
- } else if (!strncmp(uevent->subsystem, "oncrpc", 6)) {
- base = "/dev/oncrpc/";
- mkdir(base, 0755);
- } else if (!strncmp(uevent->subsystem, "adsp", 4)) {
- base = "/dev/adsp/";
- mkdir(base, 0755);
- } else if (!strncmp(uevent->subsystem, "msm_camera", 10)) {
- base = "/dev/msm_camera/";
- mkdir(base, 0755);
- } else if(!strncmp(uevent->subsystem, "input", 5)) {
- base = "/dev/input/";
- mkdir(base, 0755);
- } else if(!strncmp(uevent->subsystem, "mtd", 3)) {
- base = "/dev/mtd/";
- mkdir(base, 0755);
- } else if(!strncmp(uevent->subsystem, "sound", 5)) {
- base = "/dev/snd/";
- mkdir(base, 0755);
- } else if(!strncmp(uevent->subsystem, "misc", 4) &&
- !strncmp(name, "log_", 4)) {
- base = "/dev/log/";
- mkdir(base, 0755);
- name += 4;
- } else
- base = "/dev/";
- links = get_character_device_symlinks(uevent);
- }
-
- if (!devpath_ready)
- snprintf(devpath, sizeof(devpath), "%s%s", base, name);
-
- if(!strcmp(uevent->action, "add")) {
- make_device(devpath, uevent->path, block, uevent->major, uevent->minor);
+ if(!strcmp(action, "add")) {
+ make_device(devpath, path, block, major, minor);
if (links) {
for (i = 0; links[i]; i++)
make_link(devpath, links[i]);
}
}
- if(!strcmp(uevent->action, "remove")) {
+ if(!strcmp(action, "remove")) {
if (links) {
for (i = 0; links[i]; i++)
remove_link(devpath, links[i]);
@@ -507,6 +490,138 @@
}
}
+static void handle_platform_device_event(struct uevent *uevent)
+{
+ const char *name = uevent->path + 18; /* length of /devices/platform/ */
+
+ if (!strcmp(uevent->action, "add"))
+ add_platform_device(name);
+ else if (!strcmp(uevent->action, "remove"))
+ remove_platform_device(name);
+}
+
+static const char *parse_device_name(struct uevent *uevent, unsigned int len)
+{
+ const char *name;
+
+ /* if it's not a /dev device, nothing else to do */
+ if((uevent->major < 0) || (uevent->minor < 0))
+ return NULL;
+
+ /* do we have a name? */
+ name = strrchr(uevent->path, '/');
+ if(!name)
+ return NULL;
+ name++;
+
+ /* too-long names would overrun our buffer */
+ if(strlen(name) > len)
+ return NULL;
+
+ return name;
+}
+
+static void handle_block_device_event(struct uevent *uevent)
+{
+ const char *base = "/dev/block/";
+ const char *name;
+ char devpath[96];
+ char **links = NULL;
+
+ name = parse_device_name(uevent, 64);
+ if (!name)
+ return;
+
+ snprintf(devpath, sizeof(devpath), "%s%s", base, name);
+ mkdir(base, 0755);
+
+ if (!strncmp(uevent->path, "/devices/platform/", 18))
+ links = parse_platform_block_device(uevent);
+
+ handle_device(uevent->action, devpath, uevent->path, 1,
+ uevent->major, uevent->minor, links);
+}
+
+static void handle_generic_device_event(struct uevent *uevent)
+{
+ char *base;
+ const char *name;
+ char devpath[96] = {0};
+ char **links = NULL;
+
+ name = parse_device_name(uevent, 64);
+ if (!name)
+ return;
+
+ if (!strncmp(uevent->subsystem, "usb", 3)) {
+ if (!strcmp(uevent->subsystem, "usb")) {
+ /* This imitates the file system that would be created
+ * if we were using devfs instead.
+ * Minors are broken up into groups of 128, starting at "001"
+ */
+ int bus_id = uevent->minor / 128 + 1;
+ int device_id = uevent->minor % 128 + 1;
+ /* build directories */
+ mkdir("/dev/bus", 0755);
+ mkdir("/dev/bus/usb", 0755);
+ snprintf(devpath, sizeof(devpath), "/dev/bus/usb/%03d", bus_id);
+ mkdir(devpath, 0755);
+ snprintf(devpath, sizeof(devpath), "/dev/bus/usb/%03d/%03d", bus_id, device_id);
+ } else {
+ /* ignore other USB events */
+ return;
+ }
+ } else if (!strncmp(uevent->subsystem, "graphics", 8)) {
+ base = "/dev/graphics/";
+ mkdir(base, 0755);
+ } else if (!strncmp(uevent->subsystem, "oncrpc", 6)) {
+ base = "/dev/oncrpc/";
+ mkdir(base, 0755);
+ } else if (!strncmp(uevent->subsystem, "adsp", 4)) {
+ base = "/dev/adsp/";
+ mkdir(base, 0755);
+ } else if (!strncmp(uevent->subsystem, "msm_camera", 10)) {
+ base = "/dev/msm_camera/";
+ mkdir(base, 0755);
+ } else if(!strncmp(uevent->subsystem, "input", 5)) {
+ base = "/dev/input/";
+ mkdir(base, 0755);
+ } else if(!strncmp(uevent->subsystem, "mtd", 3)) {
+ base = "/dev/mtd/";
+ mkdir(base, 0755);
+ } else if(!strncmp(uevent->subsystem, "sound", 5)) {
+ base = "/dev/snd/";
+ mkdir(base, 0755);
+ } else if(!strncmp(uevent->subsystem, "misc", 4) &&
+ !strncmp(name, "log_", 4)) {
+ base = "/dev/log/";
+ mkdir(base, 0755);
+ name += 4;
+ } else
+ base = "/dev/";
+ links = get_character_device_symlinks(uevent);
+
+ if (!devpath[0])
+ snprintf(devpath, sizeof(devpath), "%s%s", base, name);
+
+ handle_device(uevent->action, devpath, uevent->path, 0,
+ uevent->major, uevent->minor, links);
+}
+
+static void handle_device_event(struct uevent *uevent)
+{
+ if (!strcmp(uevent->action,"add"))
+ fixup_sys_perms(uevent->path);
+
+ if (!strncmp(uevent->subsystem, "block", 5)) {
+ handle_block_device_event(uevent);
+ } else if (!strncmp(uevent->subsystem, "platform", 8)) {
+ handle_platform_device_event(uevent);
+ } else {
+ handle_generic_device_event(uevent);
+ }
+}
+
static int load_firmware(int fw_fd, int loading_fd, int data_fd)
{
struct stat st;
@@ -553,13 +668,19 @@
return ret;
}
+static int is_booting(void)
+{
+ return access("/dev/.booting", F_OK) == 0;
+}
+
static void process_firmware_event(struct uevent *uevent)
{
char *root, *loading, *data, *file1 = NULL, *file2 = NULL;
int l, loading_fd, data_fd, fw_fd;
+ int booting = is_booting();
- log_event_print("firmware event { '%s', '%s' }\n",
- uevent->path, uevent->firmware);
+ INFO("firmware: loading '%s' for '%s'\n",
+ uevent->firmware, uevent->path);
l = asprintf(&root, SYSFS_PREFIX"%s/", uevent->path);
if (l == -1)
@@ -589,19 +710,29 @@
if(data_fd < 0)
goto loading_close_out;
+try_loading_again:
fw_fd = open(file1, O_RDONLY);
if(fw_fd < 0) {
fw_fd = open(file2, O_RDONLY);
if (fw_fd < 0) {
+ if (booting) {
+ /* If we're not fully booted, we may be missing
+ * filesystems needed for firmware, wait and retry.
+ */
+ usleep(100000);
+ booting = is_booting();
+ goto try_loading_again;
+ }
+ INFO("firmware: could not open '%s' %d\n", uevent->firmware, errno);
write(loading_fd, "-1", 2);
goto data_close_out;
}
}
if(!load_firmware(fw_fd, loading_fd, data_fd))
- log_event_print("firmware copy success { '%s', '%s' }\n", root, uevent->firmware);
+ INFO("firmware: copy success { '%s', '%s' }\n", root, uevent->firmware);
else
- log_event_print("firmware copy failure { '%s', '%s' }\n", root, uevent->firmware);
+ INFO("firmware: copy failure { '%s', '%s' }\n", root, uevent->firmware);
close(fw_fd);
data_close_out:
@@ -622,7 +753,6 @@
static void handle_firmware_event(struct uevent *uevent)
{
pid_t pid;
- int status;
int ret;
if(strcmp(uevent->subsystem, "firmware"))
@@ -636,10 +766,6 @@
if (!pid) {
process_firmware_event(uevent);
exit(EXIT_SUCCESS);
- } else {
- do {
- ret = waitpid(pid, &status, 0);
- } while (ret == -1 && errno == EINTR);
}
}
@@ -648,7 +774,7 @@
{
char msg[UEVENT_MSG_LEN+2];
int n;
- while ((n = uevent_checked_recv(device_fd, msg, UEVENT_MSG_LEN)) > 0) {
+ while ((n = uevent_kernel_multicast_recv(device_fd, msg, UEVENT_MSG_LEN)) > 0) {
if(n >= UEVENT_MSG_LEN) /* overflow -- discard */
continue;
diff --git a/init/init.c b/init/init.c
index bb27c4e..a1d6be1 100755
--- a/init/init.c
+++ b/init/init.c
@@ -651,6 +651,10 @@
ERROR("init startup failure\n");
exit(1);
}
+
+ /* signal that we hit this point */
+ unlink("/dev/.booting");
+
return 0;
}
@@ -710,6 +714,9 @@
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
+ /* indicate that booting is in progress to background fw loaders, etc */
+ close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
+
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won't
* be able to remount / read-only later on.
diff --git a/init/init_parser.c b/init/init_parser.c
index e8e65ac..d9d3084 100644
--- a/init/init_parser.c
+++ b/init/init_parser.c
@@ -179,6 +179,14 @@
return;
}
break;
+ case K_import:
+ if (nargs != 2) {
+ ERROR("single argument needed for import\n");
+ } else {
+ int ret = init_parse_config_file(args[1]);
+ if (ret)
+ ERROR("could not import file %s\n", args[1]);
+ }
}
state->parse_line = parse_line_no_op;
}
@@ -347,7 +355,8 @@
if (!strncmp(name, test, name_length) &&
test[name_length] == '=' &&
- !strcmp(test + name_length + 1, value)) {
+ (!strcmp(test + name_length + 1, value) ||
+ !strcmp(test + name_length + 1, "*"))) {
action_add_queue_tail(act);
}
}
@@ -377,7 +386,8 @@
/* does the property exist, and match the trigger value? */
value = property_get(prop_name);
- if (value && !strcmp(equals + 1, value)) {
+ if (value && (!strcmp(equals + 1, value) ||
+ !strcmp(equals + 1, "*"))) {
action_add_queue_tail(act);
}
}
diff --git a/init/keywords.h b/init/keywords.h
index 95acd01..3e3733f 100644
--- a/init/keywords.h
+++ b/init/keywords.h
@@ -11,7 +11,6 @@
int do_hostname(int nargs, char **args);
int do_ifup(int nargs, char **args);
int do_insmod(int nargs, char **args);
-int do_import(int nargs, char **args);
int do_mkdir(int nargs, char **args);
int do_mount(int nargs, char **args);
int do_restart(int nargs, char **args);
@@ -54,7 +53,7 @@
KEYWORD(hostname, COMMAND, 1, do_hostname)
KEYWORD(ifup, COMMAND, 1, do_ifup)
KEYWORD(insmod, COMMAND, 1, do_insmod)
- KEYWORD(import, COMMAND, 1, do_import)
+ KEYWORD(import, SECTION, 1, 0)
KEYWORD(keycodes, OPTION, 0, 0)
KEYWORD(mkdir, COMMAND, 1, do_mkdir)
KEYWORD(mount, COMMAND, 3, do_mount)
diff --git a/init/property_service.c b/init/property_service.c
index c8d6c09..dd61b1b 100644
--- a/init/property_service.c
+++ b/init/property_service.c
@@ -62,6 +62,8 @@
{ "net.gprs.", AID_RADIO, 0 },
{ "net.ppp", AID_RADIO, 0 },
{ "net.qmi", AID_RADIO, 0 },
+ { "net.lte", AID_RADIO, 0 },
+ { "net.cdma", AID_RADIO, 0 },
{ "ril.", AID_RADIO, 0 },
{ "gsm.", AID_RADIO, 0 },
{ "persist.radio", AID_RADIO, 0 },
@@ -75,8 +77,6 @@
{ "wlan.", AID_SYSTEM, 0 },
{ "dhcp.", AID_SYSTEM, 0 },
{ "dhcp.", AID_DHCP, 0 },
- { "vpn.", AID_SYSTEM, 0 },
- { "vpn.", AID_VPN, 0 },
{ "debug.", AID_SHELL, 0 },
{ "log.", AID_SHELL, 0 },
{ "service.adb.root", AID_SHELL, 0 },
@@ -374,11 +374,11 @@
return;
}
- r = recv(s, &msg, sizeof(msg), 0);
+ r = TEMP_FAILURE_RETRY(recv(s, &msg, sizeof(msg), 0));
if(r != sizeof(prop_msg)) {
+ ERROR("sys_prop: mis-match msg size recieved: %d expected: %d errno: %d\n",
+ r, sizeof(prop_msg), errno);
close(s);
- ERROR("sys_prop: mis-match msg size recieved: %d expected: %d\n",
- r, sizeof(prop_msg));
return;
}
diff --git a/init/ueventd.c b/init/ueventd.c
index 0e97be7..1328d19 100644
--- a/init/ueventd.c
+++ b/init/ueventd.c
@@ -20,6 +20,8 @@
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
+#include <signal.h>
+
#include <private/android_filesystem_config.h>
#include "ueventd.h"
@@ -37,6 +39,13 @@
int nr;
char tmp[32];
+ /* Prevent fire-and-forget children from becoming zombies.
+ * If we should need to wait() for some children in the future
+ * (as opposed to none right now), double-forking here instead
+ * of ignoring SIGCHLD may be the better solution.
+ */
+ signal(SIGCHLD, SIG_IGN);
+
open_devnull_stdio();
log_init();
diff --git a/libcutils/Android.mk b/libcutils/Android.mk
index 283a6bf..0c4e235 100644
--- a/libcutils/Android.mk
+++ b/libcutils/Android.mk
@@ -35,6 +35,7 @@
socket_loopback_client.c \
socket_loopback_server.c \
socket_network_client.c \
+ sockets.c \
config_utils.c \
cpu_info.c \
load_file.c \
@@ -92,25 +93,11 @@
include $(BUILD_HOST_STATIC_LIBRARY)
-ifeq ($(TARGET_SIMULATOR),true)
-
-# Shared library for simulator
-# ========================================================
-include $(CLEAR_VARS)
-LOCAL_MODULE := libcutils
-LOCAL_SRC_FILES := $(commonSources) $(commonHostSources) memory.c dlmalloc_stubs.c
-LOCAL_LDLIBS := -lpthread
-LOCAL_SHARED_LIBRARIES := liblog
-LOCAL_CFLAGS += $(targetSmpFlag)
-include $(BUILD_SHARED_LIBRARY)
-
-else #!sim
-
# Shared and static library for target
# ========================================================
include $(CLEAR_VARS)
LOCAL_MODULE := libcutils
-LOCAL_SRC_FILES := $(commonSources) ashmem-dev.c mq.c android_reboot.c uevent.c qtaguid.c
+LOCAL_SRC_FILES := $(commonSources) ashmem-dev.c mq.c android_reboot.c partition_utils.c uevent.c qtaguid.c
ifeq ($(TARGET_ARCH),arm)
LOCAL_SRC_FILES += arch-arm/memset32.S
@@ -139,4 +126,10 @@
LOCAL_CFLAGS += $(targetSmpFlag)
include $(BUILD_SHARED_LIBRARY)
-endif #!sim
+include $(CLEAR_VARS)
+LOCAL_MODULE := tst_str_parms
+LOCAL_CFLAGS += -DTEST_STR_PARMS
+LOCAL_SRC_FILES := str_parms.c hashmap.c memory.c
+LOCAL_SHARED_LIBRARIES := liblog
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_EXECUTABLE)
diff --git a/libcutils/config_utils.c b/libcutils/config_utils.c
index 75fa6c6..fc5ca78 100644
--- a/libcutils/config_utils.c
+++ b/libcutils/config_utils.c
@@ -315,3 +315,15 @@
data = load_file(fn, 0);
config_load(root, data);
}
+
+void config_free(cnode *root)
+{
+ cnode *cur = root->first_child;
+
+ while (cur) {
+ cnode *prev = cur;
+ config_free(cur);
+ cur = cur->next;
+ free(prev);
+ }
+}
diff --git a/libcutils/hashmap.c b/libcutils/hashmap.c
index e29bc24..65539ea 100644
--- a/libcutils/hashmap.c
+++ b/libcutils/hashmap.c
@@ -310,10 +310,11 @@
for (i = 0; i < map->bucketCount; i++) {
Entry* entry = map->buckets[i];
while (entry != NULL) {
+ Entry *next = entry->next;
if (!callback(entry->key, entry->value, context)) {
return;
}
- entry = entry->next;
+ entry = next;
}
}
}
diff --git a/libcutils/partition_utils.c b/libcutils/partition_utils.c
new file mode 100644
index 0000000..10539fa
--- /dev/null
+++ b/libcutils/partition_utils.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2011, 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 <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h> /* for BLKGETSIZE */
+#include <cutils/properties.h>
+
+static int only_one_char(char *buf, int len, char c)
+{
+ int i, ret;
+
+ ret = 1;
+ for (i=0; i<len; i++) {
+ if (buf[i] != c) {
+ ret = 0;
+ break;
+ }
+ }
+ return ret;
+}
+
+int partition_wiped(char *source)
+{
+ char buf[4096];
+ int fd, ret, wiped;
+
+ if ((fd = open(source, O_RDONLY)) < 0) {
+ return 0;
+ }
+
+ ret = read(fd, buf, sizeof(buf));
+ close(fd);
+
+ if (ret != sizeof(buf)) {
+ return 0;
+ }
+
+ /* Check for all zeros */
+ if (only_one_char(buf, sizeof(buf), 0)) {
+ return 1;
+ }
+
+ /* Check for all ones */
+ if (only_one_char(buf, sizeof(buf), 0xff)) {
+ return 1;
+ }
+
+ return 0;
+}
+
diff --git a/libcutils/sockets.c b/libcutils/sockets.c
new file mode 100644
index 0000000..101a382
--- /dev/null
+++ b/libcutils/sockets.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2011 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 <cutils/log.h>
+#include <cutils/sockets.h>
+
+#ifdef HAVE_ANDROID_OS
+/* For the socket trust (credentials) check */
+#include <private/android_filesystem_config.h>
+#endif
+
+bool socket_peer_is_trusted(int fd)
+{
+#ifdef HAVE_ANDROID_OS
+ struct ucred cr;
+ socklen_t len = sizeof(cr);
+ int n = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
+
+ if (n != 0) {
+ LOGE("could not get socket credentials: %s\n", strerror(errno));
+ return false;
+ }
+
+ if ((cr.uid != AID_ROOT) && (cr.uid != AID_SHELL)) {
+ LOGE("untrusted userid on other end of socket: userid %d\n", cr.uid);
+ return false;
+ }
+#endif
+
+ return true;
+}
diff --git a/libcutils/uevent.c b/libcutils/uevent.c
index 3533c00..320f8d1 100644
--- a/libcutils/uevent.c
+++ b/libcutils/uevent.c
@@ -24,7 +24,7 @@
/**
* Like recv(), but checks that messages actually originate from the kernel.
*/
-ssize_t uevent_checked_recv(int socket, void *buffer, size_t length) {
+ssize_t uevent_kernel_multicast_recv(int socket, void *buffer, size_t length) {
struct iovec iov = { buffer, length };
struct sockaddr_nl addr;
char control[CMSG_SPACE(sizeof(struct ucred))];
diff --git a/libdiskconfig/Android.mk b/libdiskconfig/Android.mk
index c887955..74be2d9 100644
--- a/libdiskconfig/Android.mk
+++ b/libdiskconfig/Android.mk
@@ -1,8 +1,6 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
-ifneq ($(TARGET_SIMULATOR),true)
-
commonSources := \
diskconfig.c \
diskutils.c \
@@ -23,5 +21,3 @@
LOCAL_CFLAGS := -O2 -g -W -Wall -Werror -D_LARGEFILE64_SOURCE
include $(BUILD_HOST_STATIC_LIBRARY)
endif # HOST_OS == linux
-
-endif # ! TARGET_SIMULATOR
diff --git a/liblog/Android.mk b/liblog/Android.mk
index 0eec87f..bd4fed4 100644
--- a/liblog/Android.mk
+++ b/liblog/Android.mk
@@ -48,25 +48,14 @@
LOCAL_CFLAGS := -DFAKE_LOG_DEVICE=1
include $(BUILD_HOST_STATIC_LIBRARY)
-ifeq ($(TARGET_SIMULATOR),true)
- # Shared library for simulator
- # ========================================================
- include $(CLEAR_VARS)
- LOCAL_MODULE := liblog
- LOCAL_SRC_FILES := $(liblog_host_sources)
- LOCAL_LDLIBS := -lpthread
- LOCAL_CFLAGS := -DFAKE_LOG_DEVICE=1
- include $(BUILD_SHARED_LIBRARY)
-else # !sim
- # Shared and static library for target
- # ========================================================
- include $(CLEAR_VARS)
- LOCAL_MODULE := liblog
- LOCAL_SRC_FILES := $(liblog_sources)
- include $(BUILD_STATIC_LIBRARY)
+# Shared and static library for target
+# ========================================================
+include $(CLEAR_VARS)
+LOCAL_MODULE := liblog
+LOCAL_SRC_FILES := $(liblog_sources)
+include $(BUILD_STATIC_LIBRARY)
- include $(CLEAR_VARS)
- LOCAL_MODULE := liblog
- LOCAL_WHOLE_STATIC_LIBRARIES := liblog
- include $(BUILD_SHARED_LIBRARY)
-endif # !sim
+include $(CLEAR_VARS)
+LOCAL_MODULE := liblog
+LOCAL_WHOLE_STATIC_LIBRARIES := liblog
+include $(BUILD_SHARED_LIBRARY)
diff --git a/libnetutils/Android.mk b/libnetutils/Android.mk
index 46102d5..1ef7da9 100644
--- a/libnetutils/Android.mk
+++ b/libnetutils/Android.mk
@@ -11,13 +11,6 @@
LOCAL_SHARED_LIBRARIES := \
libcutils
-# need "-lrt" on Linux simulator to pick up clock_gettime
-ifeq ($(TARGET_SIMULATOR),true)
- ifeq ($(HOST_OS),linux)
- LOCAL_LDLIBS += -lrt -lpthread
- endif
-endif
-
LOCAL_MODULE:= libnetutils
include $(BUILD_SHARED_LIBRARY)
diff --git a/libnetutils/dhcp_utils.c b/libnetutils/dhcp_utils.c
index 8496725..5991ea8 100644
--- a/libnetutils/dhcp_utils.c
+++ b/libnetutils/dhcp_utils.c
@@ -265,15 +265,16 @@
}
/**
- * DHCP renewal request
+ * Run WiMAX dhcp renew service.
+ * "wimax_renew" service shoud be included in init.rc.
*/
int dhcp_do_request_renew(const char *interface,
- char *ipaddr,
- char *gateway,
- uint32_t *prefixLength,
- char *dns1,
- char *dns2,
- char *server,
+ in_addr_t *ipaddr,
+ in_addr_t *gateway,
+ in_addr_t *mask,
+ in_addr_t *dns1,
+ in_addr_t *dns2,
+ in_addr_t *server,
uint32_t *lease)
{
char result_prop_name[PROPERTY_KEY_MAX];
@@ -305,10 +306,7 @@
return -1;
}
if (strcmp(prop_value, "ok") == 0) {
- if(fill_ip_info(interface, ipaddr, gateway, prefixLength, dns1, dns2, server, lease)
- == -1) {
- return -1;
- }
+ fill_ip_info(interface, ipaddr, gateway, mask, dns1, dns2, server, lease);
return 0;
} else {
snprintf(errmsg, sizeof(errmsg), "DHCP Renew result was %s", prop_value);
diff --git a/libnetutils/dhcpclient.c b/libnetutils/dhcpclient.c
index 5039e26..4f2d1c1 100644
--- a/libnetutils/dhcpclient.c
+++ b/libnetutils/dhcpclient.c
@@ -197,7 +197,7 @@
}
switch(opt) {
case OPT_SUBNET_MASK:
- if (optlen >= 4) info->prefixLength = ipv4NetmaskToPrefixLength((int)x);
+ if (optlen >= 4) info->prefixLength = ipv4NetmaskToPrefixLength(*((uint32_t*)x));
break;
case OPT_GATEWAY:
if (optlen >= 4) memcpy(&info->gateway, x, 4);
diff --git a/libnetutils/ifc_utils.c b/libnetutils/ifc_utils.c
index c9d6ed2..04b0dfa 100644
--- a/libnetutils/ifc_utils.c
+++ b/libnetutils/ifc_utils.c
@@ -51,6 +51,8 @@
static int ifc_ctl_sock6 = -1;
void printerr(char *fmt, ...);
+#define DBG 0
+
in_addr_t prefixLengthToIpv4Netmask(int prefix_length)
{
in_addr_t mask = 0;
@@ -88,13 +90,17 @@
int ifc_init(void)
{
+ int ret;
if (ifc_ctl_sock == -1) {
- ifc_ctl_sock = socket(AF_INET, SOCK_DGRAM, 0);
+ ifc_ctl_sock = socket(AF_INET, SOCK_DGRAM, 0);
if (ifc_ctl_sock < 0) {
printerr("socket() failed: %s\n", strerror(errno));
}
}
- return ifc_ctl_sock < 0 ? -1 : 0;
+
+ ret = ifc_ctl_sock < 0 ? -1 : 0;
+ if (DBG) printerr("ifc_init_returning %d", ret);
+ return ret;
}
int ifc_init6(void)
@@ -110,6 +116,7 @@
void ifc_close(void)
{
+ if (DBG) printerr("ifc_close");
if (ifc_ctl_sock != -1) {
(void)close(ifc_ctl_sock);
ifc_ctl_sock = -1;
@@ -141,7 +148,7 @@
if(r < 0) return -1;
memcpy(ptr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
- return 0;
+ return 0;
}
int ifc_get_ifindex(const char *name, int *if_indexp)
@@ -169,12 +176,16 @@
int ifc_up(const char *name)
{
- return ifc_set_flags(name, IFF_UP, 0);
+ int ret = ifc_set_flags(name, IFF_UP, 0);
+ if (DBG) printerr("ifc_up(%s) = %d", name, ret);
+ return ret;
}
int ifc_down(const char *name)
{
- return ifc_set_flags(name, 0, IFF_UP);
+ int ret = ifc_set_flags(name, 0, IFF_UP);
+ if (DBG) printerr("ifc_down(%s) = %d", name, ret);
+ return ret;
}
static void init_sockaddr_in(struct sockaddr *sa, in_addr_t addr)
@@ -188,11 +199,14 @@
int ifc_set_addr(const char *name, in_addr_t addr)
{
struct ifreq ifr;
+ int ret;
ifc_init_ifr(name, &ifr);
init_sockaddr_in(&ifr.ifr_addr, addr);
- return ioctl(ifc_ctl_sock, SIOCSIFADDR, &ifr);
+ ret = ioctl(ifc_ctl_sock, SIOCSIFADDR, &ifr);
+ if (DBG) printerr("ifc_set_addr(%s, xx) = %d", name, ret);
+ return ret;
}
int ifc_set_hwaddr(const char *name, const void *ptr)
@@ -206,6 +220,19 @@
return ioctl(ifc_ctl_sock, SIOCSIFHWADDR, &ifr);
}
+int ifc_set_mask(const char *name, in_addr_t mask)
+{
+ struct ifreq ifr;
+ int ret;
+
+ ifc_init_ifr(name, &ifr);
+ init_sockaddr_in(&ifr.ifr_addr, mask);
+
+ ret = ioctl(ifc_ctl_sock, SIOCSIFNETMASK, &ifr);
+ if (DBG) printerr("ifc_set_mask(%s, xx) = %d", name, ret);
+ return ret;
+}
+
int ifc_set_prefixLength(const char *name, int prefixLength)
{
struct ifreq ifr;
@@ -313,6 +340,7 @@
return result;
}
+/* deprecated - v4 only */
int ifc_create_default_route(const char *name, in_addr_t gw)
{
struct in_addr in_dst, in_gw;
@@ -320,7 +348,20 @@
in_dst.s_addr = 0;
in_gw.s_addr = gw;
- return ifc_act_on_route(SIOCADDRT, name, in_dst, 0, in_gw);
+ int ret = ifc_act_on_ipv4_route(SIOCADDRT, name, in_dst, 0, in_gw);
+ if (DBG) printerr("ifc_create_default_route(%s, %d) = %d", name, gw, ret);
+ return ret;
+}
+
+/* deprecated v4-only */
+int ifc_add_host_route(const char *name, in_addr_t dst)
+{
+ struct in_addr in_dst, in_gw;
+
+ in_dst.s_addr = dst;
+ in_gw.s_addr = 0;
+
+ return ifc_act_on_ipv4_route(SIOCADDRT, name, in_dst, 32, in_gw);
}
int ifc_enable(const char *ifname)
@@ -449,6 +490,70 @@
}
/*
+ * Return the address of the default gateway
+ *
+ * TODO: factor out common code from this and remove_host_routes()
+ * so that we only scan /proc/net/route in one place.
+ *
+ * DEPRECATED
+ */
+int ifc_get_default_route(const char *ifname)
+{
+ char name[64];
+ in_addr_t dest, gway, mask;
+ int flags, refcnt, use, metric, mtu, win, irtt;
+ int result;
+ FILE *fp;
+
+ fp = fopen("/proc/net/route", "r");
+ if (fp == NULL)
+ return 0;
+ /* Skip the header line */
+ if (fscanf(fp, "%*[^\n]\n") < 0) {
+ fclose(fp);
+ return 0;
+ }
+ ifc_init();
+ result = 0;
+ for (;;) {
+ int nread = fscanf(fp, "%63s%X%X%X%d%d%d%X%d%d%d\n",
+ name, &dest, &gway, &flags, &refcnt, &use, &metric, &mask,
+ &mtu, &win, &irtt);
+ if (nread != 11) {
+ break;
+ }
+ if ((flags & (RTF_UP|RTF_GATEWAY)) == (RTF_UP|RTF_GATEWAY)
+ && dest == 0
+ && strcmp(ifname, name) == 0) {
+ result = gway;
+ break;
+ }
+ }
+ fclose(fp);
+ ifc_close();
+ return result;
+}
+
+/*
+ * Sets the specified gateway as the default route for the named interface.
+ * DEPRECATED
+ */
+int ifc_set_default_route(const char *ifname, in_addr_t gateway)
+{
+ struct in_addr addr;
+ int result;
+
+ ifc_init();
+ addr.s_addr = gateway;
+ if ((result = ifc_create_default_route(ifname, gateway)) < 0) {
+ LOGD("failed to add %s as default route for %s: %s",
+ inet_ntoa(addr), ifname, strerror(errno));
+ }
+ ifc_close();
+ return result;
+}
+
+/*
* Removes the default route for the named interface.
*/
int ifc_remove_default_route(const char *ifname)
@@ -627,9 +732,31 @@
return ret;
}
+/*
+ * DEPRECATED
+ */
+int ifc_add_ipv4_route(const char *ifname, struct in_addr dst, int prefix_length,
+ struct in_addr gw)
+{
+ int i =ifc_act_on_ipv4_route(SIOCADDRT, ifname, dst, prefix_length, gw);
+ printerr("ifc_add_ipv4_route(%s, xx, %d, xx) = %d", ifname, prefix_length, i);
+ return i;
+}
+
+/*
+ * DEPRECATED
+ */
+int ifc_add_ipv6_route(const char *ifname, struct in6_addr dst, int prefix_length,
+ struct in6_addr gw)
+{
+ return ifc_act_on_ipv6_route(SIOCADDRT, ifname, dst, prefix_length, gw);
+}
+
int ifc_add_route(const char *ifname, const char *dst, int prefix_length, const char *gw)
{
- return ifc_act_on_route(SIOCADDRT, ifname, dst, prefix_length, gw);
+ int i = ifc_act_on_route(SIOCADDRT, ifname, dst, prefix_length, gw);
+ printerr("ifc_add_route(%s, %s, %d, %s) = %d", ifname, dst, prefix_length, gw, i);
+ return i;
}
int ifc_remove_route(const char *ifname, const char*dst, int prefix_length, const char *gw)
diff --git a/libnl_2/.gitignore b/libnl_2/.gitignore
new file mode 100644
index 0000000..d4ca744
--- /dev/null
+++ b/libnl_2/.gitignore
@@ -0,0 +1,2 @@
+include/netlink/version.h.in
+cscope.*
diff --git a/libnl_2/Android.mk b/libnl_2/Android.mk
new file mode 100644
index 0000000..1745f5a
--- /dev/null
+++ b/libnl_2/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+ attr.c \
+ cache.c \
+ genl/genl.c \
+ genl/family.c \
+ handlers.c \
+ msg.c \
+ netlink.c \
+ object.c \
+ socket.c \
+ dbg.c
+
+LOCAL_C_INCLUDES += \
+ external/libnl-headers
+
+# Static Library
+LOCAL_MODULE := libnl_2
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_STATIC_LIBRARY)
+
+#######################################
+# Shared library currently unavailiable
+# * Netlink cache not implemented
+# * Library is not thread safe
+#######################################
+
diff --git a/libnl_2/README b/libnl_2/README
new file mode 100644
index 0000000..7559fdf
--- /dev/null
+++ b/libnl_2/README
@@ -0,0 +1,84 @@
+Netlink Protocol Library
+
+This library is a clean room re-implementation of libnl 2.0 and
+re-licensed under Apache 2.0. It was developed primarily to support
+wpa_supplicant. However, with additional development can be extended
+to support other netlink applications.
+
+Netlink Protocol Format (RFC3549)
+
++-----------------+-+-------------------+-+
+|Netlink Message |P| Generic Netlink |P|
+| Header |A| Message Header |A|
+|(struct nlmsghdr)|D|(struct genlmsghdr)|D|
++-----------------+-+-------------------+-+
++-----------------+-+-----------------+-+-----------------+-+-----------------+-+---+
+|Netlink Attribute|P|Netlink Attribute|P|Netlink Attribute|P|Netlink Attribute|P|...|
+| #0 Header |A| #0 Payload |A| #1 Header |A| #1 Payload |A| |
+| (struct nlattr) |D| (void) |D| (struct nlattr) |D| (void) |D| |
++-----------------+-+-----------------+-+-----------------+-+-----------------+-+---+
+
+NETLINK OVERVIEW
+
+* Each netlink message consists of a bitstream with a netlink header.
+* After this header a second header *can* be used specific to the netlink
+ family in use. This library was tested using the generic netlink
+ protocol defined by struct genlmsghdr to support nl80211.
+* After the header(s) netlink attributes can be appended to the message
+ which hold can hold basic types such as unsigned integers and strings.
+* Attributes can also be nested. This is accomplished by calling "nla_nest_start"
+ which creates an empty attribute with nest attributes as its payload. Then to
+ close the nest, "nla_nest_end" is called.
+* All data structures in this implementation are byte-aligned (Currently 4 bytes).
+* Acknowledgements (ACKs) are sent as NLMSG_ERROR netlink message types (0x2) and
+ have an error value of 0.
+
+KNOWN ISSUES
+
+ GENERAL
+ * Not tested for thread safety
+
+ Android.mk
+ * No static library because of netlink cache not implemented and
+ not tested for thread safety
+
+ attr.c
+ * nla_parse - does not use nla_policy argument
+
+ cache.c
+ * netlink cache not implemented and only supports one netlink family id
+ which is stored in the nl_cache pointer instead of an actual cache
+
+ netlink.c
+ * nl_recvmsgs - does not support nl_cb_overwrite_recv()
+ * nl_recv - sets/unsets asynchronous socket flag
+
+SOURCE FILES
+
+* Android.mk - Android makefile
+* README - This file
+* attr.c - Netlink attributes
+* cache.c - Netlink cache
+* genl/family.c - Generic netlink family id
+* genl/genl.c - Generic netlink
+* handlers.c - Netlink callbacks
+* msg.c - Netlink messages construction
+* netlink.c - Netlink socket communication
+* object.c - libnl object wrapper
+* socket.c - Netlink kernel socket utils
+
+IMPORTANT HEADER FILES - NOTE: These are based on the the origin GPL libnl headers
+
+* netlink-types.h - Contains many important structs for libnl
+ to represent netlink objects
+* netlink/netlink-kernel.h - Netlink kernel headers and field constants.
+* netlink/msg.h - macros for iterating over netlink messages
+* netlink/attr.h - netlink attribute constants, iteration macros and setters
+
+REFERENCES
+
+* nl80211.h
+* netlink_types.h
+* $LINUX_KERNEL/net/wireless/nl80211.c
+* http://www.infradead.org/~tgr/libnl/doc-3.0/index.html
+* http://www.netfilter.org/projects/libmnl/doxygen/index.html
diff --git a/libnl_2/attr.c b/libnl_2/attr.c
new file mode 100644
index 0000000..f3a2b58
--- /dev/null
+++ b/libnl_2/attr.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <errno.h>
+#include "netlink/netlink.h"
+#include "netlink/msg.h"
+#include "netlink/attr.h"
+#include "netlink-types.h"
+
+/* Return payload of string attribute. */
+char *nla_get_string(struct nlattr *nla)
+{
+ return (char *) nla_data(nla);
+}
+
+/* Return payload of 16 bit integer attribute. */
+uint16_t nla_get_u16(struct nlattr *nla)
+{
+ return *((uint16_t *) nla_data(nla));
+}
+
+/* Return payload of 32 bit integer attribute. */
+uint32_t nla_get_u32(struct nlattr *nla)
+{
+ return *((uint32_t *) nla_data(nla));
+}
+
+/* Return value of 8 bit integer attribute. */
+uint8_t nla_get_u8(struct nlattr *nla)
+{
+ return *((uint8_t *) nla_data(nla));
+}
+
+/* Return payload of uint64_t attribute. */
+uint64_t nla_get_u64(struct nlattr *nla)
+{
+ uint64_t tmp;
+ nla_memcpy(&tmp, nla, sizeof(tmp));
+ return tmp;
+}
+
+/* Head of payload */
+void *nla_data(const struct nlattr *nla)
+{
+ return (void *) ((char *) nla + NLA_HDRLEN);
+}
+
+/* Return length of the payload . */
+int nla_len(const struct nlattr *nla)
+{
+ return nla->nla_len - NLA_HDRLEN;
+}
+
+int nla_padlen(int payload)
+{
+ return NLA_ALIGN(payload) - payload;
+}
+
+/* Start a new level of nested attributes. */
+struct nlattr *nla_nest_start(struct nl_msg *msg, int attrtype)
+{
+ struct nlattr *start = (struct nlattr *)nlmsg_tail(msg->nm_nlh);
+ int rc;
+
+ rc = nla_put(msg, attrtype, 0, NULL);
+ if (rc < 0)
+ return NULL;
+
+ return start;
+}
+
+/* Finalize nesting of attributes. */
+int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
+{
+ /* Set attribute size */
+ start->nla_len = (unsigned char *)nlmsg_tail(nlmsg_hdr(msg)) -
+ (unsigned char *)start;
+ return 0;
+}
+
+/* Return next attribute in a stream of attributes. */
+struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
+{
+ struct nlattr *next_nla = NULL;
+ if (nla->nla_len >= sizeof(struct nlattr) &&
+ nla->nla_len <= *remaining){
+ next_nla = (struct nlattr *) \
+ ((char *) nla + NLA_ALIGN(nla->nla_len));
+ *remaining = *remaining - NLA_ALIGN(nla->nla_len);
+ }
+
+ return next_nla;
+
+}
+
+/* Check if the attribute header and payload can be accessed safely. */
+int nla_ok(const struct nlattr *nla, int remaining)
+{
+ return remaining > 0 &&
+ nla->nla_len >= sizeof(struct nlattr) &&
+ sizeof(struct nlattr) <= (unsigned int) remaining &&
+ nla->nla_len <= remaining;
+}
+
+/* Create attribute index based on a stream of attributes. */
+/* NOTE: Policy not used ! */
+int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
+ int len, struct nla_policy *policy)
+{
+ struct nlattr *pos;
+ int rem;
+
+ /* First clear table */
+ memset(tb, 0, (maxtype + 1) * sizeof(struct nlattr *));
+
+ nla_for_each_attr(pos, head, len, rem) {
+ int type = nla_type(pos);
+
+ if ((type <= maxtype) && (type != 0))
+ tb[type] = pos;
+ }
+
+ return 0;
+}
+
+
+/* Create attribute index based on nested attribute. */
+int nla_parse_nested(struct nlattr *tb[], int maxtype,
+ struct nlattr *nla, struct nla_policy *policy)
+{
+ return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+}
+
+
+/* Add a unspecific attribute to netlink message. */
+int nla_put(struct nl_msg *msg, int attrtype, int datalen, const void *data)
+{
+ struct nlattr *nla;
+
+ /* Reserve space and init nla header */
+ nla = nla_reserve(msg, attrtype, datalen);
+ if (nla) {
+ memcpy(nla_data(nla), data, datalen);
+ return 0;
+ }
+
+ return -EINVAL;
+
+}
+
+
+/* Add nested attributes to netlink message. */
+/* Takes the attributes found in the nested message and appends them
+ * to the message msg nested in a container of the type attrtype. The
+ * nested message may not have a family specific header */
+int nla_put_nested(struct nl_msg *msg, int attrtype, struct nl_msg *nested)
+{
+ int rc;
+
+ rc = nla_put(msg, attrtype, nlmsg_attrlen(nlmsg_hdr(nested), 0),
+ nlmsg_attrdata(nlmsg_hdr(nested), 0));
+ return rc;
+
+}
+
+/* Return type of the attribute. */
+int nla_type(const struct nlattr *nla)
+{
+ return (int)nla->nla_type & NLA_TYPE_MASK;
+}
+
+/* Reserves room for an attribute in specified netlink message and fills
+ * in the attribute header (type,length). Return NULL if insufficient space */
+struct nlattr *nla_reserve(struct nl_msg *msg, int attrtype, int data_len)
+{
+
+ struct nlattr *nla;
+ const unsigned int NEW_SIZE = NLMSG_ALIGN(msg->nm_nlh->nlmsg_len) +
+ NLA_ALIGN(NLA_HDRLEN + data_len);
+
+ /* Check enough space for attribute */
+ if (NEW_SIZE > msg->nm_size)
+ return NULL;
+
+ nla = (struct nlattr *)nlmsg_tail(msg->nm_nlh);
+ nla->nla_type = attrtype;
+ nla->nla_len = NLA_HDRLEN + data_len;
+ memset((unsigned char *)nla + nla->nla_len, 0, nla_padlen(data_len));
+ msg->nm_nlh->nlmsg_len = NEW_SIZE;
+ return nla;
+}
+
+/* Copy attribute payload to another memory area. */
+int nla_memcpy(void *dest, struct nlattr *src, int count)
+{
+ if (!src || !dest)
+ return 0;
+ if (count > nla_len(src))
+ count = nla_len(src);
+ memcpy(dest, nla_data(src), count);
+ return count;
+}
diff --git a/libnl_2/cache.c b/libnl_2/cache.c
new file mode 100644
index 0000000..c21974d
--- /dev/null
+++ b/libnl_2/cache.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include "netlink/cache.h"
+#include "netlink/object.h"
+
+void nl_cache_free(struct nl_cache *cache)
+{
+
+}
+
+void nl_cache_clear(struct nl_cache *cache)
+{
+
+}
+
+void nl_cache_remove(struct nl_object *obj)
+{
+
+}
+
+
diff --git a/libnl_2/dbg.c b/libnl_2/dbg.c
new file mode 100644
index 0000000..9764de6
--- /dev/null
+++ b/libnl_2/dbg.c
@@ -0,0 +1,12 @@
+#include "netlink/netlink.h"
+#include <android/log.h>
+
+void libnl_printf(int level, char *format, ...)
+{
+ va_list ap;
+
+ level = ANDROID_LOG_ERROR;
+ va_start(ap, format);
+ __android_log_vprint(level, "libnl_2", format, ap);
+ va_end(ap);
+}
diff --git a/libnl_2/genl/family.c b/libnl_2/genl/family.c
new file mode 100644
index 0000000..1beee6e
--- /dev/null
+++ b/libnl_2/genl/family.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include "netlink-types.h"
+
+static struct genl_family *genl_family_find_byname(const char *name)
+{
+ return NULL;
+}
+
+/* Release reference and none outstanding */
+void genl_family_put(struct genl_family *family)
+{
+ family->ce_refcnt--;
+ if (family->ce_refcnt <= 0)
+ free(family);
+}
+
+unsigned int genl_family_get_id(struct genl_family *family)
+{
+ const int NO_FAMILY_ID = 0;
+
+ if (!family)
+ return NO_FAMILY_ID;
+ else
+ return family->gf_id;
+
+}
+
diff --git a/libnl_2/genl/genl.c b/libnl_2/genl/genl.c
new file mode 100644
index 0000000..dd20717
--- /dev/null
+++ b/libnl_2/genl/genl.c
@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <linux/netlink.h>
+#include "netlink-types.h"
+
+/* Get head of attribute data. */
+struct nlattr *genlmsg_attrdata(const struct genlmsghdr *gnlh, int hdrlen)
+{
+ return (struct nlattr *) \
+ ((char *) gnlh + GENL_HDRLEN + NLMSG_ALIGN(hdrlen));
+
+}
+
+/* Get length of attribute data. */
+int genlmsg_attrlen(const struct genlmsghdr *gnlh, int hdrlen)
+{
+ struct nlattr *nla;
+ struct nlmsghdr *nlh;
+
+ nla = genlmsg_attrdata(gnlh, hdrlen);
+ nlh = (struct nlmsghdr *) ((char *) gnlh - NLMSG_HDRLEN);
+ return (char *) nlmsg_tail(nlh) - (char *) nla;
+}
+
+/* Add generic netlink header to netlink message. */
+void *genlmsg_put(struct nl_msg *msg, uint32_t pid, uint32_t seq, int family,
+ int hdrlen, int flags, uint8_t cmd, uint8_t version)
+{
+ int new_size;
+ struct nlmsghdr *nlh;
+ struct timeval tv;
+ struct genlmsghdr *gmh;
+
+ /* Make sure nl_msg has enough space */
+ new_size = NLMSG_HDRLEN + GENL_HDRLEN + hdrlen;
+ if ((sizeof(struct nl_msg) + new_size) > msg->nm_size)
+ goto fail;
+
+ /* Fill in netlink header */
+ nlh = msg->nm_nlh;
+ nlh->nlmsg_len = new_size;
+ nlh->nlmsg_type = family;
+ nlh->nlmsg_pid = getpid();
+ nlh->nlmsg_flags = flags | NLM_F_REQUEST | NLM_F_ACK;
+
+ /* Get current time for sequence number */
+ if (gettimeofday(&tv, NULL))
+ nlh->nlmsg_seq = 1;
+ else
+ nlh->nlmsg_seq = (int) tv.tv_sec;
+
+ /* Setup genlmsghdr in new message */
+ gmh = (struct genlmsghdr *) ((char *)nlh + NLMSG_HDRLEN);
+ gmh->cmd = (__u8) cmd;
+ gmh->version = version;
+
+ return gmh;
+fail:
+ return NULL;
+
+}
+
+/* Socket has already been alloced to connect it to kernel? */
+int genl_connect(struct nl_sock *sk)
+{
+ return nl_connect(sk, NETLINK_GENERIC);
+
+}
+
+int genl_ctrl_alloc_cache(struct nl_sock *sock, struct nl_cache **result)
+{
+ int rc = -1;
+ int nl80211_genl_id = -1;
+ char sendbuf[sizeof(struct nlmsghdr)+sizeof(struct genlmsghdr)];
+ struct nlmsghdr nlmhdr;
+ struct genlmsghdr gmhhdr;
+ struct iovec sendmsg_iov;
+ struct msghdr msg;
+ int num_char;
+ const int RECV_BUF_SIZE = getpagesize();
+ char *recvbuf;
+ struct iovec recvmsg_iov;
+ int nl80211_flag = 0, nlm_f_multi = 0, nlmsg_done = 0;
+ struct nlmsghdr *nlh;
+
+ /* REQUEST GENERIC NETLINK FAMILY ID */
+ /* Message buffer */
+ nlmhdr.nlmsg_len = sizeof(sendbuf);
+ nlmhdr.nlmsg_type = NETLINK_GENERIC;
+ nlmhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP;
+ nlmhdr.nlmsg_seq = sock->s_seq_next;
+ nlmhdr.nlmsg_pid = sock->s_local.nl_pid;
+
+ /* Generic netlink header */
+ gmhhdr.cmd = CTRL_CMD_GETFAMILY;
+ gmhhdr.version = CTRL_ATTR_FAMILY_ID;
+
+ /* Combine netlink and generic netlink headers */
+ memcpy(&sendbuf[0], &nlmhdr, sizeof(nlmhdr));
+ memcpy(&sendbuf[0]+sizeof(nlmhdr), &gmhhdr, sizeof(gmhhdr));
+
+ /* Create IO vector with Netlink message */
+ sendmsg_iov.iov_base = &sendbuf;
+ sendmsg_iov.iov_len = sizeof(sendbuf);
+
+ /* Socket message */
+ msg.msg_name = (void *) &sock->s_peer;
+ msg.msg_namelen = sizeof(sock->s_peer);
+ msg.msg_iov = &sendmsg_iov;
+ msg.msg_iovlen = 1; /* Only sending one iov */
+ msg.msg_control = NULL;
+ msg.msg_controllen = 0;
+ msg.msg_flags = 0;
+
+ /* Send message and verify sent */
+ num_char = sendmsg(sock->s_fd, &msg, 0);
+ if (num_char == -1)
+ return -errno;
+
+ /* RECEIVE GENL CMD RESPONSE */
+
+ /* Create receive iov buffer */
+ recvbuf = (char *) malloc(RECV_BUF_SIZE);
+
+ /* Attach to iov */
+ recvmsg_iov.iov_base = recvbuf;
+ recvmsg_iov.iov_len = RECV_BUF_SIZE;
+
+ msg.msg_iov = &recvmsg_iov;
+ msg.msg_iovlen = 1;
+
+ /***************************************************************/
+ /* Receive message. If multipart message, keep receiving until */
+ /* message type is NLMSG_DONE */
+ /***************************************************************/
+
+ do {
+
+ int recvmsg_len, nlmsg_rem;
+
+ /* Receive message */
+ memset(recvbuf, 0, RECV_BUF_SIZE);
+ recvmsg_len = recvmsg(sock->s_fd, &msg, 0);
+
+ /* Make sure receive successful */
+ if (recvmsg_len < 0) {
+ rc = -errno;
+ goto error_recvbuf;
+ }
+
+ /* Parse nlmsghdr */
+ nlmsg_for_each_msg(nlh, (struct nlmsghdr *) recvbuf, \
+ recvmsg_len, nlmsg_rem) {
+ struct nlattr *nla;
+ int nla_rem;
+
+ /* Check type */
+ switch (nlh->nlmsg_type) {
+ case NLMSG_DONE:
+ goto return_genl_id;
+ break;
+ case NLMSG_ERROR:
+
+ /* Should check nlmsgerr struct received */
+ fprintf(stderr, "Receive message error\n");
+ goto error_recvbuf;
+ case NLMSG_OVERRUN:
+ fprintf(stderr, "Receive data partly lost\n");
+ goto error_recvbuf;
+ case NLMSG_MIN_TYPE:
+ case NLMSG_NOOP:
+ break;
+ default:
+ break;
+ }
+
+
+
+ /* Check flags */
+ if (nlh->nlmsg_flags & NLM_F_MULTI)
+ nlm_f_multi = 1;
+ else
+ nlm_f_multi = 0;
+
+ if (nlh->nlmsg_type & NLMSG_DONE)
+ nlmsg_done = 1;
+ else
+ nlmsg_done = 0;
+
+ /* Iteratve over attributes */
+ nla_for_each_attr(nla,
+ nlmsg_attrdata(nlh, GENL_HDRLEN),
+ nlmsg_attrlen(nlh, GENL_HDRLEN),
+ nla_rem){
+
+ /* If this family is nl80211 */
+ if (nla->nla_type == CTRL_ATTR_FAMILY_NAME &&
+ !strcmp((char *)nla_data(nla),
+ "nl80211"))
+ nl80211_flag = 1;
+
+ /* Save the family id */
+ else if (nl80211_flag &&
+ nla->nla_type == CTRL_ATTR_FAMILY_ID)
+ nl80211_genl_id = \
+ *((int *)nla_data(nla));
+
+ }
+
+ }
+
+ } while (nlm_f_multi && !nlmsg_done);
+
+return_genl_id:
+ /* Return family id as cache pointer */
+ *result = (struct nl_cache *) nl80211_genl_id;
+ rc = 0;
+error_recvbuf:
+ free(recvbuf);
+error:
+ return rc;
+}
+
+/* Checks the netlink cache to find family reference by name string */
+/* NOTE: Caller needs to call genl_family_put() when done with *
+ * returned object */
+struct genl_family *genl_ctrl_search_by_name(struct nl_cache *cache, \
+ const char *name)
+{
+ /* TODO: When will we release this memory ? */
+ struct genl_family *gf = (struct genl_family *) \
+ malloc(sizeof(struct genl_family));
+ if (!gf)
+ goto fail;
+ memset(gf, 0, sizeof(*gf));
+
+ /* Add ref */
+ gf->ce_refcnt++;
+
+ /* Overriding cache pointer as family id for now */
+ gf->gf_id = (uint16_t) ((uint32_t) cache);
+ strcpy(gf->gf_name, "nl80211");
+
+ return gf;
+fail:
+ return NULL;
+
+}
+
+int genl_ctrl_resolve(struct nl_sock *sk, const char *name)
+{
+ /* Hack to support wpa_supplicant */
+ if (strcmp(name, "nlctrl") == 0)
+ return NETLINK_GENERIC;
+ else {
+ int errsv = errno;
+ fprintf(stderr, \
+ "Only nlctrl supported by genl_ctrl_resolve!\n");
+ return -errsv;
+ }
+
+}
+
diff --git a/libnl_2/handlers.c b/libnl_2/handlers.c
new file mode 100644
index 0000000..ec8d512
--- /dev/null
+++ b/libnl_2/handlers.c
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <malloc.h>
+#include "netlink-types.h"
+#include "netlink/handlers.h"
+
+/* Allocate a new callback handle. */
+struct nl_cb *nl_cb_alloc(enum nl_cb_kind kind)
+{
+ struct nl_cb *cb;
+
+ cb = (struct nl_cb *) malloc(sizeof(struct nl_cb));
+ if (cb == NULL)
+ goto fail;
+ memset(cb, 0, sizeof(*cb));
+
+ return nl_cb_get(cb);
+fail:
+ return NULL;
+}
+
+/* Clone an existing callback handle */
+struct nl_cb *nl_cb_clone(struct nl_cb *orig)
+{
+ struct nl_cb *new_cb;
+ int new_refcnt;
+
+ new_cb = nl_cb_alloc(NL_CB_DEFAULT);
+ if (new_cb == NULL)
+ goto fail;
+
+ /* Preserve reference count and copy original */
+ new_refcnt = new_cb->cb_refcnt;
+ memcpy(new_cb, orig, sizeof(*orig));
+ new_cb->cb_refcnt = new_refcnt;
+
+ return new_cb;
+fail:
+ return NULL;
+}
+
+/* Set up a callback. */
+int nl_cb_set(struct nl_cb *cb, enum nl_cb_type type, enum nl_cb_kind kind, \
+ nl_recvmsg_msg_cb_t func, void *arg)
+{
+ cb->cb_set[type] = func;
+ cb->cb_args[type] = arg;
+ return 0;
+}
+
+
+
+/* Set up an error callback. */
+int nl_cb_err(struct nl_cb *cb, enum nl_cb_kind kind, \
+ nl_recvmsg_err_cb_t func, void *arg)
+{
+ cb->cb_err = func;
+ cb->cb_err_arg = arg;
+ return 0;
+
+}
+
+struct nl_cb *nl_cb_get(struct nl_cb *cb)
+{
+ cb->cb_refcnt++;
+ return cb;
+}
+
+void nl_cb_put(struct nl_cb *cb)
+{
+ cb->cb_refcnt--;
+ if (cb->cb_refcnt <= 0)
+ free(cb);
+
+}
+
diff --git a/libnl_2/msg.c b/libnl_2/msg.c
new file mode 100644
index 0000000..283da6e
--- /dev/null
+++ b/libnl_2/msg.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <malloc.h>
+#include <unistd.h>
+#include <linux/netlink.h>
+#include "netlink-types.h"
+
+/* Allocate a new netlink message with the default maximum payload size. */
+struct nl_msg *nlmsg_alloc(void)
+{
+ /* Whole page will store nl_msg + nlmsghdr + genlmsghdr + payload */
+ const int page_sz = getpagesize();
+ struct nl_msg *nm;
+ struct nlmsghdr *nlh;
+
+ /* Netlink message */
+ nm = (struct nl_msg *) malloc(page_sz);
+ if (!nm)
+ goto fail;
+
+ /* Netlink message header pointer */
+ nlh = (struct nlmsghdr *) ((char *) nm + sizeof(struct nl_msg));
+
+ /* Initialize */
+ memset(nm, 0, page_sz);
+ nm->nm_size = page_sz;
+
+ nm->nm_src.nl_family = AF_NETLINK;
+ nm->nm_src.nl_pid = getpid();
+
+ nm->nm_dst.nl_family = AF_NETLINK;
+ nm->nm_dst.nl_pid = 0; /* Kernel */
+
+ /* Initialize and add to netlink message */
+ nlh->nlmsg_len = NLMSG_HDRLEN;
+ nm->nm_nlh = nlh;
+
+ /* Add to reference count and return nl_msg */
+ nlmsg_get(nm);
+ return nm;
+fail:
+ return NULL;
+}
+
+/* Return pointer to message payload. */
+void *nlmsg_data(const struct nlmsghdr *nlh)
+{
+ return (char *) nlh + NLMSG_HDRLEN;
+}
+
+/* Add reference count to nl_msg */
+void nlmsg_get(struct nl_msg *nm)
+{
+ nm->nm_refcnt++;
+}
+
+/* Release a reference from an netlink message. */
+void nlmsg_free(struct nl_msg *nm)
+{
+ if (nm) {
+ nm->nm_refcnt--;
+ if (nm->nm_refcnt <= 0)
+ free(nm);
+ }
+
+}
+
+/* Return actual netlink message. */
+struct nlmsghdr *nlmsg_hdr(struct nl_msg *n)
+{
+ return n->nm_nlh;
+}
+
+/* Return head of attributes data / payload section */
+struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh, int hdrlen)
+{
+ unsigned char *data = nlmsg_data(nlh);
+ return (struct nlattr *)(data + NLMSG_ALIGN(hdrlen));
+}
+
+/* Returns pointer to end of netlink message */
+void *nlmsg_tail(const struct nlmsghdr *nlh)
+{
+ return (void *)((char *)nlh + NLMSG_ALIGN(nlh->nlmsg_len));
+}
+
+/* Next netlink message in message stream */
+struct nlmsghdr *nlmsg_next(struct nlmsghdr *nlh, int *remaining)
+{
+ struct nlmsghdr *next_nlh = NULL;
+ int len = nlmsg_len(nlh);
+
+ len = NLMSG_ALIGN(len);
+ if (*remaining > 0 &&
+ len <= *remaining &&
+ len >= (int) sizeof(struct nlmsghdr)) {
+ next_nlh = (struct nlmsghdr *)((char *)nlh + len);
+ *remaining -= len;
+ }
+
+ return next_nlh;
+}
+
+int nlmsg_datalen(const struct nlmsghdr *nlh)
+{
+ return nlh->nlmsg_len - NLMSG_HDRLEN;
+}
+
+/* Length of attributes data */
+int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
+{
+ return nlmsg_datalen(nlh) - NLMSG_ALIGN(hdrlen);
+}
+
+/* Length of netlink message */
+int nlmsg_len(const struct nlmsghdr *nlh)
+{
+ return nlh->nlmsg_len;
+}
+
+/* Check if the netlink message fits into the remaining bytes */
+int nlmsg_ok(const struct nlmsghdr *nlh, int rem)
+{
+ return rem >= (int)sizeof(struct nlmsghdr) &&
+ rem >= nlmsg_len(nlh) &&
+ nlmsg_len(nlh) >= (int) sizeof(struct nlmsghdr) &&
+ nlmsg_len(nlh) <= (rem);
+}
+
+int nlmsg_padlen(int payload)
+{
+ return NLMSG_ALIGN(payload) - payload;
+}
diff --git a/libnl_2/netlink.c b/libnl_2/netlink.c
new file mode 100644
index 0000000..cc2f88e
--- /dev/null
+++ b/libnl_2/netlink.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include "netlink-types.h"
+
+#define NL_BUFFER_SZ (32768U)
+
+/* Checks message for completeness and sends it out */
+int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
+{
+ struct nlmsghdr *nlh = msg->nm_nlh;
+ struct timeval tv;
+
+ if (!nlh) {
+ int errsv = errno;
+ fprintf(stderr, "Netlink message header is NULL!\n");
+ return -errsv;
+ }
+
+ /* Complete the nl_msg header */
+ if (gettimeofday(&tv, NULL))
+ nlh->nlmsg_seq = 1;
+ else
+ nlh->nlmsg_seq = (int) tv.tv_sec;
+ nlh->nlmsg_pid = sk->s_local.nl_pid;
+ nlh->nlmsg_flags |= NLM_F_REQUEST | NLM_F_ACK;
+
+ return nl_send(sk, msg);
+}
+
+/* Receives a netlink message, allocates a buffer in *buf and stores
+ * the message content. The peer's netlink address is stored in
+ * *nla. The caller is responsible for freeing the buffer allocated in
+ * *buf if a positive value is returned. Interrupted system calls are
+ * handled by repeating the read. The input buffer size is determined
+ * by peeking before the actual read is done */
+int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla, \
+ unsigned char **buf, struct ucred **creds)
+{
+ int rc = -1;
+ int sk_flags;
+ int RECV_BUF_SIZE;
+ int errsv;
+ struct iovec recvmsg_iov;
+ struct msghdr msg;
+
+ /* Allocate buffer */
+ RECV_BUF_SIZE = getpagesize();
+ *buf = (unsigned char *) malloc(RECV_BUF_SIZE);
+ if (!buf) {
+ rc = -ENOMEM;
+ goto fail;
+ }
+
+ /* Prepare to receive message */
+ recvmsg_iov.iov_base = *buf;
+ recvmsg_iov.iov_len = RECV_BUF_SIZE;
+
+ msg.msg_name = (void *) &sk->s_peer;
+ msg.msg_namelen = sizeof(sk->s_peer);
+ msg.msg_iov = &recvmsg_iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = NULL;
+ msg.msg_controllen = 0;
+ msg.msg_flags = 0;
+
+ /* Make non blocking and then restore previous setting */
+ sk_flags = fcntl(sk->s_fd, F_GETFL, 0);
+ fcntl(sk->s_fd, F_SETFL, O_NONBLOCK);
+ rc = recvmsg(sk->s_fd, &msg, 0);
+ errsv = errno;
+ fcntl(sk->s_fd, F_SETFL, sk_flags);
+
+ if (rc < 0)
+ rc = -errsv;
+
+fail:
+ return rc;
+}
+
+/* Receive a set of messages from a netlink socket */
+/* NOTE: Does not currently support callback replacements!!! */
+int nl_recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
+{
+ struct sockaddr_nl nla;
+ struct ucred *creds;
+
+ int rc, cb_rc = NL_OK, done = 0;
+
+ do {
+
+ unsigned char *buf;
+ int i, rem, flags;
+ struct nlmsghdr *nlh;
+ struct nlmsgerr *nlme;
+ struct nl_msg *msg;
+
+ done = 0;
+ rc = nl_recv(sk, &nla, &buf, &creds);
+ if (rc < 0)
+ break;
+
+ nlmsg_for_each_msg(nlh, (struct nlmsghdr *) buf, rc, rem) {
+
+ if (rc <= 0 || cb_rc == NL_STOP)
+ break;
+
+ /* Check for callbacks */
+
+ msg = (struct nl_msg *)malloc(sizeof(struct nl_msg));
+ memset(msg, 0, sizeof(*msg));
+ msg->nm_nlh = nlh;
+
+ /* Check netlink message type */
+
+ switch (msg->nm_nlh->nlmsg_type) {
+ case NLMSG_ERROR: /* Used for ACK too */
+ /* Certainly we should be doing some
+ * checking here to make sure this
+ * message is intended for us */
+ nlme = nlmsg_data(msg->nm_nlh);
+ if (nlme->error == 0)
+ msg->nm_nlh->nlmsg_flags |= NLM_F_ACK;
+
+ rc = nlme->error;
+ cb_rc = cb->cb_err(&nla, nlme, cb->cb_err_arg);
+ nlme = NULL;
+ break;
+
+ case NLMSG_DONE:
+ done = 1;
+
+ case NLMSG_OVERRUN:
+ case NLMSG_NOOP:
+ default:
+ break;
+ };
+
+ for (i = 0; i <= NL_CB_TYPE_MAX; i++) {
+
+ if (cb->cb_set[i]) {
+ switch (i) {
+ case NL_CB_VALID:
+ if (rc > 0)
+ cb_rc = cb->cb_set[i](msg, cb->cb_args[i]);
+ break;
+
+ case NL_CB_FINISH:
+ if ((msg->nm_nlh->nlmsg_flags & NLM_F_MULTI) &&
+ (msg->nm_nlh->nlmsg_type & NLMSG_DONE))
+ cb_rc = cb->cb_set[i](msg, cb->cb_args[i]);
+
+ break;
+
+ case NL_CB_ACK:
+ if (msg->nm_nlh->nlmsg_flags & NLM_F_ACK)
+ cb_rc = cb->cb_set[i](msg, cb->cb_args[i]);
+
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ free(msg);
+ if (done)
+ break;
+ }
+
+ free(buf);
+ buf = NULL;
+
+ if (done)
+ break;
+ } while (rc > 0 && cb_rc != NL_STOP);
+
+success:
+fail:
+ return rc;
+}
+
+/* Send raw data over netlink socket */
+int nl_send(struct nl_sock *sk, struct nl_msg *msg)
+{
+ struct nlmsghdr *nlh = nlmsg_hdr(msg);
+ struct iovec msg_iov;
+
+ /* Create IO vector with Netlink message */
+ msg_iov.iov_base = nlh;
+ msg_iov.iov_len = nlh->nlmsg_len;
+
+ return nl_send_iovec(sk, msg, &msg_iov, 1);
+}
+
+/* Send netlink message */
+int nl_send_iovec(struct nl_sock *sk, struct nl_msg *msg,
+ struct iovec *iov, unsigned iovlen)
+{
+ int rc;
+
+ /* Socket message */
+ struct msghdr mh = {
+ .msg_name = (void *) &sk->s_peer,
+ .msg_namelen = sizeof(sk->s_peer),
+ .msg_iov = iov,
+ .msg_iovlen = iovlen,
+ .msg_control = NULL,
+ .msg_controllen = 0,
+ .msg_flags = 0
+ };
+
+ /* Send message and verify sent */
+ rc = nl_sendmsg(sk, (struct nl_msg *) &mh, 0);
+ if (rc < 0)
+ fprintf(stderr, "Error sending netlink message: %d\n", errno);
+ return rc;
+
+}
+
+/* Send netlink message with control over sendmsg() message header */
+int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr)
+{
+ return sendmsg(sk->s_fd, (struct msghdr *) msg, (int) hdr);
+}
+
+/* Create and connect netlink socket */
+int nl_connect(struct nl_sock *sk, int protocol)
+{
+ struct sockaddr addr;
+ socklen_t addrlen;
+ int rc;
+
+ /* Create RX socket */
+ sk->s_fd = socket(PF_NETLINK, SOCK_RAW, protocol);
+ if (sk->s_fd < 0)
+ return -errno;
+
+ /* Set size of RX and TX buffers */
+ if (nl_socket_set_buffer_size(sk, NL_BUFFER_SZ, NL_BUFFER_SZ) < 0)
+ return -errno;
+
+ /* Bind RX socket */
+ rc = bind(sk->s_fd, (struct sockaddr *)&sk->s_local, \
+ sizeof(sk->s_local));
+ if (rc < 0)
+ return -errno;
+ addrlen = sizeof(addr);
+ getsockname(sk->s_fd, &addr, &addrlen);
+
+ return 0;
+
+}
diff --git a/libnl_2/object.c b/libnl_2/object.c
new file mode 100644
index 0000000..c53accf
--- /dev/null
+++ b/libnl_2/object.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include "netlink-types.h"
+
+void nl_object_put(struct nl_object *obj)
+{
+ obj->ce_refcnt--;
+ if (!obj->ce_refcnt)
+ nl_object_free(obj);
+}
+
+void nl_object_free(struct nl_object *obj)
+{
+ nl_cache_remove(obj);
+}
+
+
diff --git a/libnl_2/socket.c b/libnl_2/socket.c
new file mode 100644
index 0000000..ce54f19
--- /dev/null
+++ b/libnl_2/socket.c
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <errno.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include "netlink-types.h"
+
+/* Join group */
+int nl_socket_add_membership(struct nl_sock *sk, int group)
+{
+ return setsockopt(sk->s_fd, SOL_NETLINK,
+ NETLINK_ADD_MEMBERSHIP, &group, sizeof(group));
+}
+
+/* Allocate new netlink socket. */
+struct nl_sock *nl_socket_alloc(void)
+{
+ struct nl_sock *sk;
+ struct timeval tv;
+ struct nl_cb *cb;
+
+ sk = (struct nl_sock *) malloc(sizeof(struct nl_sock));
+ if (!sk)
+ goto fail;
+ memset(sk, 0, sizeof(*sk));
+
+ /* Get current time */
+
+ if (gettimeofday(&tv, NULL))
+ return NULL;
+ else
+ sk->s_seq_next = (int) tv.tv_sec;
+
+ /* Create local socket */
+ sk->s_local.nl_family = AF_NETLINK;
+ sk->s_local.nl_pid = 0; /* Kernel fills in pid */
+ sk->s_local.nl_groups = 0; /* No groups */
+
+ /* Create peer socket */
+ sk->s_peer.nl_family = AF_NETLINK;
+ sk->s_peer.nl_pid = 0; /* Kernel */
+ sk->s_peer.nl_groups = 0; /* No groups */
+
+ cb = (struct nl_cb *) malloc(sizeof(struct nl_cb));
+ if (!cb)
+ goto cb_fail;
+ memset(cb, 0, sizeof(*cb));
+ sk->s_cb = nl_cb_alloc(NL_CB_DEFAULT);
+
+
+ return sk;
+cb_fail:
+ free(sk);
+fail:
+ return NULL;
+}
+
+/* Allocate new socket with custom callbacks. */
+struct nl_sock *nl_socket_alloc_cb(struct nl_cb *cb)
+{
+ struct nl_sock *sk = nl_socket_alloc();
+ if (!sk)
+ return NULL;
+
+ sk->s_cb = cb;
+ nl_cb_get(cb);
+
+ return sk;
+
+}
+
+/* Free a netlink socket. */
+void nl_socket_free(struct nl_sock *sk)
+{
+ nl_cb_put(sk->s_cb);
+ close(sk->s_fd);
+ free(sk);
+}
+
+/* Sets socket buffer size of netlink socket */
+int nl_socket_set_buffer_size(struct nl_sock *sk, int rxbuf, int txbuf)
+{
+ if (setsockopt(sk->s_fd, SOL_SOCKET, SO_SNDBUF, \
+ &rxbuf, (socklen_t) sizeof(rxbuf)))
+ goto error;
+
+ if (setsockopt(sk->s_fd, SOL_SOCKET, SO_RCVBUF, \
+ &txbuf, (socklen_t) sizeof(txbuf)))
+ goto error;
+
+ return 0;
+error:
+ return -errno;
+
+}
+
+int nl_socket_get_fd(struct nl_sock *sk)
+{
+ return sk->s_fd;
+}
+
+
diff --git a/libsysutils/Android.mk b/libsysutils/Android.mk
index 3b1f618..cccf484 100644
--- a/libsysutils/Android.mk
+++ b/libsysutils/Android.mk
@@ -1,10 +1,4 @@
ifneq ($(BUILD_TINY_ANDROID),true)
-BUILD_LIBSYSUTILS := false
-ifneq ($(TARGET_SIMULATOR),true)
- BUILD_LIBSYSUTILS := true
-endif
-
-ifeq ($(BUILD_LIBSYSUTILS),true)
LOCAL_PATH:= $(call my-dir)
@@ -27,11 +21,6 @@
LOCAL_SHARED_LIBRARIES := libcutils
-ifeq ($(TARGET_SIMULATOR),true)
- LOCAL_LDLIBS += -lpthread
-endif
-
include $(BUILD_SHARED_LIBRARY)
endif
-endif
diff --git a/libsysutils/src/NetlinkEvent.cpp b/libsysutils/src/NetlinkEvent.cpp
index c8d3b1f..fe96976 100644
--- a/libsysutils/src/NetlinkEvent.cpp
+++ b/libsysutils/src/NetlinkEvent.cpp
@@ -21,10 +21,23 @@
#include <sysutils/NetlinkEvent.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <linux/if.h>
+#include <linux/netfilter/nfnetlink.h>
+#include <linux/netfilter_ipv4/ipt_ULOG.h>
+/* From kernel's net/netfilter/xt_quota2.c */
+const int QLOG_NL_EVENT = 112;
+
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
const int NetlinkEvent::NlActionUnknown = 0;
const int NetlinkEvent::NlActionAdd = 1;
const int NetlinkEvent::NlActionRemove = 2;
const int NetlinkEvent::NlActionChange = 3;
+const int NetlinkEvent::NlActionLinkUp = 4;
+const int NetlinkEvent::NlActionLinkDown = 5;
NetlinkEvent::NetlinkEvent() {
mAction = NlActionUnknown;
@@ -56,6 +69,74 @@
}
}
+/*
+ * Parse an binary message from a NETLINK_ROUTE netlink socket.
+ */
+bool NetlinkEvent::parseBinaryNetlinkMessage(char *buffer, int size) {
+ size_t sz = size;
+ const struct nlmsghdr *nh = (struct nlmsghdr *) buffer;
+
+ while (NLMSG_OK(nh, sz) && (nh->nlmsg_type != NLMSG_DONE)) {
+
+ if (nh->nlmsg_type == RTM_NEWLINK) {
+ int len = nh->nlmsg_len - sizeof(*nh);
+ struct ifinfomsg *ifi;
+
+ if (sizeof(*ifi) > (size_t) len) {
+ SLOGE("Got a short RTM_NEWLINK message\n");
+ continue;
+ }
+
+ ifi = (ifinfomsg *)NLMSG_DATA(nh);
+ if ((ifi->ifi_flags & IFF_LOOPBACK) != 0) {
+ continue;
+ }
+
+ struct rtattr *rta = (struct rtattr *)
+ ((char *) ifi + NLMSG_ALIGN(sizeof(*ifi)));
+ len = NLMSG_PAYLOAD(nh, sizeof(*ifi));
+
+ while(RTA_OK(rta, len)) {
+ switch(rta->rta_type) {
+ case IFLA_IFNAME:
+ char buffer[16 + IFNAMSIZ];
+ snprintf(buffer, sizeof(buffer), "INTERFACE=%s",
+ (char *) RTA_DATA(rta));
+ mParams[0] = strdup(buffer);
+ mAction = (ifi->ifi_flags & IFF_LOWER_UP) ?
+ NlActionLinkUp : NlActionLinkDown;
+ mSubsystem = strdup("net");
+ break;
+ }
+
+ rta = RTA_NEXT(rta, len);
+ }
+
+ } else if (nh->nlmsg_type == QLOG_NL_EVENT) {
+ char *devname;
+ ulog_packet_msg_t *pm;
+ size_t len = nh->nlmsg_len - sizeof(*nh);
+ if (sizeof(*pm) > len) {
+ SLOGE("Got a short QLOG message\n");
+ continue;
+ }
+ pm = (ulog_packet_msg_t *)NLMSG_DATA(nh);
+ devname = pm->indev_name[0] ? pm->indev_name : pm->outdev_name;
+ SLOGD("QLOG prefix=%s dev=%s\n", pm->prefix, devname);
+ asprintf(&mParams[0], "ALERT_NAME=%s", pm->prefix);
+ asprintf(&mParams[1], "INTERFACE=%s", devname);
+ mSubsystem = strdup("qlog");
+ mAction = NlActionChange;
+
+ } else {
+ SLOGD("Unexpected netlink message. type=0x%x\n", nh->nlmsg_type);
+ }
+ nh = NLMSG_NEXT(nh, size);
+ }
+
+ return true;
+}
+
/* If the string between 'str' and 'end' begins with 'prefixlen' characters
* from the 'prefix' array, then return 'str + prefixlen', otherwise return
* NULL.
@@ -76,7 +157,11 @@
#define HAS_CONST_PREFIX(str,end,prefix) has_prefix((str),(end),prefix,CONST_STRLEN(prefix))
-bool NetlinkEvent::decode(char *buffer, int size) {
+/*
+ * Parse an ASCII-formatted message from a NETLINK_KOBJECT_UEVENT
+ * netlink socket.
+ */
+bool NetlinkEvent::parseAsciiNetlinkMessage(char *buffer, int size) {
const char *s = buffer;
const char *end;
int param_idx = 0;
@@ -123,6 +208,14 @@
return true;
}
+bool NetlinkEvent::decode(char *buffer, int size, int format) {
+ if (format == NetlinkListener::NETLINK_FORMAT_BINARY) {
+ return parseBinaryNetlinkMessage(buffer, size);
+ } else {
+ return parseAsciiNetlinkMessage(buffer, size);
+ }
+}
+
const char *NetlinkEvent::findParam(const char *paramName) {
size_t len = strlen(paramName);
for (int i = 0; i < NL_PARAMS_MAX && mParams[i] != NULL; ++i) {
diff --git a/libsysutils/src/NetlinkListener.cpp b/libsysutils/src/NetlinkListener.cpp
index ddf6537..e67b5c6 100644
--- a/libsysutils/src/NetlinkListener.cpp
+++ b/libsysutils/src/NetlinkListener.cpp
@@ -22,55 +22,43 @@
#define LOG_TAG "NetlinkListener"
#include <cutils/log.h>
+#include <cutils/uevent.h>
-#include <sysutils/NetlinkListener.h>
#include <sysutils/NetlinkEvent.h>
+#if 1
+/* temporary version until we can get Motorola to update their
+ * ril.so. Their prebuilt ril.so is using this private class
+ * so changing the NetlinkListener() constructor breaks their ril.
+ */
NetlinkListener::NetlinkListener(int socket) :
SocketListener(socket, false) {
+ mFormat = NETLINK_FORMAT_ASCII;
+}
+#endif
+
+NetlinkListener::NetlinkListener(int socket, int format) :
+ SocketListener(socket, false), mFormat(format) {
}
bool NetlinkListener::onDataAvailable(SocketClient *cli)
{
int socket = cli->getSocket();
ssize_t count;
- char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
- struct sockaddr_nl snl;
- struct iovec iov = {mBuffer, sizeof(mBuffer)};
- struct msghdr hdr = {&snl, sizeof(snl), &iov, 1, cred_msg, sizeof(cred_msg), 0};
- count = TEMP_FAILURE_RETRY(recvmsg(socket, &hdr, 0));
+ count = TEMP_FAILURE_RETRY(uevent_kernel_multicast_recv(socket, mBuffer, sizeof(mBuffer)));
if (count < 0) {
SLOGE("recvmsg failed (%s)", strerror(errno));
return false;
}
- if ((snl.nl_groups != 1) || (snl.nl_pid != 0)) {
- SLOGE("ignoring non-kernel netlink multicast message");
- return false;
- }
-
- struct cmsghdr * cmsg = CMSG_FIRSTHDR(&hdr);
-
- if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {
- SLOGE("ignoring message with no sender credentials");
- return false;
- }
-
- struct ucred * cred = (struct ucred *)CMSG_DATA(cmsg);
- if (cred->uid != 0) {
- SLOGE("ignoring message from non-root UID %d", cred->uid);
- return false;
- }
-
NetlinkEvent *evt = new NetlinkEvent();
- if (!evt->decode(mBuffer, count)) {
+ if (!evt->decode(mBuffer, count, mFormat)) {
SLOGE("Error decoding NetlinkEvent");
- goto out;
+ } else {
+ onEvent(evt);
}
- onEvent(evt);
-out:
delete evt;
return true;
}
diff --git a/rootdir/init.lowmem.rc b/rootdir/init.lowmem.rc
deleted file mode 100644
index 7c08054..0000000
--- a/rootdir/init.lowmem.rc
+++ /dev/null
@@ -1,19 +0,0 @@
-# Adjustments to the out-of-memory killer, for devices that are
-# tight on memory. These should not be used if not needed, as they
-# can result in more paging.
-
-on early-boot
-
- setprop ro.FOREGROUND_APP_MEM 1536
- setprop ro.VISIBLE_APP_MEM 2048
- setprop ro.PERCEPTIBLE_APP_MEM 2048
- setprop ro.HEAVY_WEIGHT_APP_MEM 2048
- setprop ro.SECONDARY_SERVER_MEM 4096
- setprop ro.BACKUP_APP_MEM 4096
- setprop ro.HOME_APP_MEM 4096
- setprop ro.HIDDEN_APP_MEM 5120
- setprop ro.EMPTY_APP_MEM 6144
-
-on boot
-
- write /sys/module/lowmemorykiller/parameters/minfree 1536,2048,3072,4096,5120,6144
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 54f4be2..e2832d8 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -19,7 +19,7 @@
export ANDROID_DATA /data
export ASEC_MOUNTPOINT /mnt/asec
export LOOP_MOUNTPOINT /mnt/obb
- export BOOTCLASSPATH /system/framework/core.jar:/system/framework/apache-xml.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/android.policy.jar:/system/framework/services.jar:/system/framework/core-junit.jar
+ export BOOTCLASSPATH /system/framework/core.jar:/system/framework/core-junit.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/android.policy.jar:/system/framework/services.jar:/system/framework/apache-xml.jar:/system/framework/filterfw.jar
# Backward compatibility
symlink /system/etc /etc
@@ -115,11 +115,7 @@
chmod 0220 /proc/sysrq-trigger
# create the lost+found directories, so as to enforce our permissions
- mkdir /cache/lost+found 0770
-
- # double check the perms, in case lost+found already exists, and set owner
- chown root root /cache/lost+found
- chmod 0770 /cache/lost+found
+ mkdir /cache/lost+found 0770 root root
on post-fs-data
# We chown/chmod /data again so because mount is run as root + defaults
@@ -129,10 +125,7 @@
# Create dump dir and collect dumps.
# Do this before we mount cache so eventually we can use cache for
# storing dumps on platforms which do not have a dedicated dump partition.
-
- mkdir /data/dontpanic
- chown root log /data/dontpanic
- chmod 0750 /data/dontpanic
+ mkdir /data/dontpanic 0750 root log
# Collect apanic data, free resources and re-arm trigger
copy /proc/apanic_console /data/dontpanic/apanic_console
@@ -150,12 +143,11 @@
mkdir /data/misc/bluetoothd 0770 bluetooth bluetooth
mkdir /data/misc/bluetooth 0770 system system
mkdir /data/misc/keystore 0700 keystore keystore
- mkdir /data/misc/vpn 0770 system system
+ mkdir /data/misc/keychain 0771 system system
+ mkdir /data/misc/vpn 0770 system vpn
mkdir /data/misc/systemkeys 0700 system system
- mkdir /data/misc/vpn/profiles 0770 system system
# give system access to wpa_supplicant.conf for backup and restore
mkdir /data/misc/wifi 0770 wifi wifi
- chmod 0770 /data/misc/wifi
chmod 0660 /data/misc/wifi/wpa_supplicant.conf
mkdir /data/local 0771 shell shell
mkdir /data/local/tmp 0771 shell shell
@@ -164,10 +156,8 @@
mkdir /data/app 0771 system system
mkdir /data/property 0700 root root
- # create dalvik-cache and double-check the perms
+ # create dalvik-cache, so as to enforce our permissions
mkdir /data/dalvik-cache 0771 system system
- chown system system /data/dalvik-cache
- chmod 0771 /data/dalvik-cache
# create resource-cache and double-check the perms
mkdir /data/resource-cache 0771 system system
@@ -175,11 +165,7 @@
chmod 0771 /data/resource-cache
# create the lost+found directories, so as to enforce our permissions
- mkdir /data/lost+found 0770
-
- # double check the perms, in case lost+found already exists, and set owner
- chown root root /data/lost+found
- chmod 0770 /data/lost+found
+ mkdir /data/lost+found 0770 root root
# create directory for DRM plug-ins
mkdir /data/drm 0774 drm drm
@@ -190,6 +176,11 @@
# Set indication (checked by vold) that we have finished this action
#setprop vold.post_fs_data_done 1
+ chown system system /sys/class/android_usb/android0/f_mass_storage/lun/file
+ chmod 0660 /sys/class/android_usb/android0/f_mass_storage/lun/file
+ chown system system /sys/class/android_usb/android0/f_rndis/ethaddr
+ chmod 0660 /sys/class/android_usb/android0/f_rndis/ethaddr
+
on boot
# basic network init
ifup lo
@@ -199,54 +190,17 @@
# set RLIMIT_NICE to allow priorities from 19 to -20
setrlimit 13 40 40
-# Define the oom_adj values for the classes of processes that can be
-# killed by the kernel. These are used in ActivityManagerService.
- setprop ro.FOREGROUND_APP_ADJ 0
- setprop ro.VISIBLE_APP_ADJ 1
- setprop ro.PERCEPTIBLE_APP_ADJ 2
- setprop ro.HEAVY_WEIGHT_APP_ADJ 3
- setprop ro.SECONDARY_SERVER_ADJ 4
- setprop ro.BACKUP_APP_ADJ 5
- setprop ro.HOME_APP_ADJ 6
- setprop ro.HIDDEN_APP_MIN_ADJ 7
- setprop ro.EMPTY_APP_ADJ 15
-
-# Define the memory thresholds at which the above process classes will
-# be killed. These numbers are in pages (4k).
- # These are currently tuned for tablets with approx 1GB RAM.
- setprop ro.FOREGROUND_APP_MEM 8192
- setprop ro.VISIBLE_APP_MEM 10240
- setprop ro.PERCEPTIBLE_APP_MEM 12288
- setprop ro.HEAVY_WEIGHT_APP_MEM 12288
- setprop ro.SECONDARY_SERVER_MEM 14336
- setprop ro.BACKUP_APP_MEM 14336
- setprop ro.HOME_APP_MEM 14336
- setprop ro.HIDDEN_APP_MEM 16384
- setprop ro.EMPTY_APP_MEM 20480
-
- # Old values for phones. Should probably be adjusted up for the next
- # phone version.
- #setprop ro.FOREGROUND_APP_MEM 2048
- #setprop ro.VISIBLE_APP_MEM 3072
- #setprop ro.PERCEPTIBLE_APP_MEM 4096
- #setprop ro.HEAVY_WEIGHT_APP_MEM 4096
- #setprop ro.SECONDARY_SERVER_MEM 6144
- #setprop ro.BACKUP_APP_MEM 6144
- #setprop ro.HOME_APP_MEM 6144
- #setprop ro.HIDDEN_APP_MEM 7168
- #setprop ro.EMPTY_APP_MEM 8192
-
-# Write value must be consistent with the above properties.
-# Note that the driver only supports 6 slots, so we have combined some of
-# the classes into the same memory level; the associated processes of higher
-# classes will still be killed first.
- write /sys/module/lowmemorykiller/parameters/adj 0,1,2,4,7,15
-
+# Memory management. Basic kernel parameters, and allow the high
+# level system server to be able to adjust the kernel OOM driver
+# paramters to match how it is managing things.
write /proc/sys/vm/overcommit_memory 1
write /proc/sys/vm/min_free_order_shift 4
- write /sys/module/lowmemorykiller/parameters/minfree 8192,10240,12288,14336,16384,20480
+ chown root system /sys/module/lowmemorykiller/parameters/adj
+ chmod 0664 /sys/module/lowmemorykiller/parameters/adj
+ chown root system /sys/module/lowmemorykiller/parameters/minfree
+ chmod 0664 /sys/module/lowmemorykiller/parameters/minfree
- # Set init its forked children's oom_adj.
+ # Set init and its forked children's oom_adj.
write /proc/1/oom_adj -16
# Tweak background writeout
@@ -329,6 +283,49 @@
class_reset late_start
class_reset main
+# Used to disable USB when switching states
+on property:sys.usb.config=none
+ stop adbd
+ write /sys/class/android_usb/android0/enable 0
+ write /sys/class/android_usb/android0/bDeviceClass 0
+ setprop sys.usb.state $sys.usb.config
+
+# adb only USB configuration
+# This should only be used during device bringup
+# and as a fallback if the USB manager fails to set a standard configuration
+on property:sys.usb.config=adb
+ write /sys/class/android_usb/android0/enable 0
+ write /sys/class/android_usb/android0/idVendor 18d1
+ write /sys/class/android_usb/android0/idProduct D002
+ write /sys/class/android_usb/android0/functions $sys.usb.config
+ write /sys/class/android_usb/android0/enable 1
+ start adbd
+ setprop sys.usb.state $sys.usb.config
+
+# USB accessory configuration
+on property:sys.usb.config=accessory
+ write /sys/class/android_usb/android0/enable 0
+ write /sys/class/android_usb/android0/idVendor 18d1
+ write /sys/class/android_usb/android0/idProduct 2d00
+ write /sys/class/android_usb/android0/functions $sys.usb.config
+ write /sys/class/android_usb/android0/enable 1
+ setprop sys.usb.state $sys.usb.config
+
+# USB accessory configuration, with adb
+on property:sys.usb.config=accessory,adb
+ write /sys/class/android_usb/android0/enable 0
+ write /sys/class/android_usb/android0/idVendor 18d1
+ write /sys/class/android_usb/android0/idProduct 2d01
+ write /sys/class/android_usb/android0/functions $sys.usb.config
+ write /sys/class/android_usb/android0/enable 1
+ start adbd
+ setprop sys.usb.state $sys.usb.config
+
+# Used to set USB configuration at boot and to switch the configuration
+# when changing the default configuration
+on property:persist.sys.usb.config=*
+ setprop sys.usb.config $persist.sys.usb.config
+
## Daemon processes to be run by init.
##
service ueventd /sbin/ueventd
@@ -345,7 +342,7 @@
on property:ro.debuggable=1
start console
-# adbd is controlled by the persist.service.adb.enable system property
+# adbd is controlled via property triggers in init.<platform>.usb.rc
service adbd /sbin/adbd
class core
disabled
@@ -354,11 +351,17 @@
on property:ro.kernel.qemu=1
start adbd
-on property:persist.service.adb.enable=1
- start adbd
-
-on property:persist.service.adb.enable=0
- stop adbd
+# This property trigger has added to imitiate the previous behavior of "adb root".
+# The adb gadget driver used to reset the USB bus when the adbd daemon exited,
+# and the host side adb relied on this behavior to force it to reconnect with the
+# new adbd instance after init relaunches it. So now we force the USB bus to reset
+# here when adbd sets the service.adb.root property to 1. We also restart adbd here
+# rather than waiting for init to notice its death and restarting it so the timing
+# of USB resetting and adb restarting more closely matches the previous behavior.
+on property:service.adb.root=1
+ write /sys/class/android_usb/android0/enable 0
+ restart adbd
+ write /sys/class/android_usb/android0/enable 1
service servicemanager /system/bin/servicemanager
class core
@@ -399,7 +402,6 @@
socket zygote stream 666
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
- onrestart restart surfaceflinger
onrestart restart media
onrestart restart netd
@@ -447,8 +449,8 @@
service racoon /system/bin/racoon
class main
socket racoon stream 600 system system
- # racoon will setuid to vpn after getting necessary resources.
- group net_admin
+ # IKE uses UDP port 500. Racoon will setuid to vpn after binding the port.
+ group vpn net_admin inet
disabled
oneshot
@@ -456,7 +458,7 @@
class main
socket mtpd stream 600 system system
user vpn
- group vpn net_admin net_raw
+ group vpn net_admin inet net_raw
disabled
oneshot
diff --git a/rootdir/ueventd.rc b/rootdir/ueventd.rc
index 51a4337..438cf0a 100644
--- a/rootdir/ueventd.rc
+++ b/rootdir/ueventd.rc
@@ -70,11 +70,11 @@
/dev/bus/usb/* 0660 root usb
/dev/mtp_usb 0660 root mtp
/dev/usb_accessory 0660 root usb
+/dev/tun 0660 system vpn
# CDMA radio interface MUX
/dev/ts0710mux* 0640 radio radio
/dev/ppp 0660 radio vpn
-/dev/tun 0640 vpn vpn
# sysfs properties
/sys/devices/virtual/input/input* enable 0660 root input
diff --git a/sdcard/sdcard.c b/sdcard/sdcard.c
index 7112ebf..689cd2a 100644
--- a/sdcard/sdcard.c
+++ b/sdcard/sdcard.c
@@ -326,15 +326,9 @@
fuse->all = &fuse->root;
+ memset(&fuse->root, 0, sizeof(fuse->root));
fuse->root.nid = FUSE_ROOT_ID; /* 1 */
- fuse->root.next = 0;
- fuse->root.child = 0;
- fuse->root.parent = 0;
-
- fuse->root.all = 0;
fuse->root.refcount = 2;
-
- fuse->root.name = 0;
rename_node(&fuse->root, path);
}
@@ -762,7 +756,7 @@
h->fd = open(path, req->flags);
if (h->fd < 0) {
ERROR("ERROR\n");
- fuse_status(fuse, hdr->unique, errno);
+ fuse_status(fuse, hdr->unique, -errno);
free(h);
return;
}
@@ -784,7 +778,7 @@
}
res = pread64(h->fd, buffer, req->size, req->offset);
if (res < 0) {
- fuse_status(fuse, hdr->unique, errno);
+ fuse_status(fuse, hdr->unique, -errno);
return;
}
fuse_reply(fuse, hdr->unique, buffer, res);
@@ -798,7 +792,7 @@
TRACE("WRITE %p(%d) %u@%llu\n", h, h->fd, req->size, req->offset);
res = pwrite64(h->fd, ((char*) data) + sizeof(*req), req->size, req->offset);
if (res < 0) {
- fuse_status(fuse, hdr->unique, errno);
+ fuse_status(fuse, hdr->unique, -errno);
return;
}
out.size = res;
diff --git a/toolbox/Android.mk b/toolbox/Android.mk
index ff01172..d7a675a 100644
--- a/toolbox/Android.mk
+++ b/toolbox/Android.mk
@@ -54,8 +54,13 @@
vmstat \
nandread \
ionice \
+ touch \
lsof
+ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT)))
+TOOLS += r
+endif
+
LOCAL_SRC_FILES:= \
dynarray.c \
toolbox.c \
diff --git a/toolbox/getevent.c b/toolbox/getevent.c
index 256720d..e3ab41a 100644
--- a/toolbox/getevent.c
+++ b/toolbox/getevent.c
@@ -8,9 +8,11 @@
#include <sys/inotify.h>
#include <sys/limits.h>
#include <sys/poll.h>
-#include <linux/input.h> // this does not compile
+#include <linux/input.h>
#include <errno.h>
+#include "getevent.h"
+
static struct pollfd *ufds;
static char **device_names;
static int nfds;
@@ -22,18 +24,66 @@
PRINT_DEVICE_INFO = 1U << 3,
PRINT_VERSION = 1U << 4,
PRINT_POSSIBLE_EVENTS = 1U << 5,
+ PRINT_INPUT_PROPS = 1U << 6,
+ PRINT_HID_DESCRIPTOR = 1U << 7,
+
+ PRINT_ALL_INFO = (1U << 8) - 1,
+
+ PRINT_LABELS = 1U << 16,
};
-static int print_possible_events(int fd)
+static const char *get_label(const struct label *labels, int value)
+{
+ while(labels->name && value != labels->value) {
+ labels++;
+ }
+ return labels->name;
+}
+
+static int print_input_props(int fd)
+{
+ uint8_t bits[INPUT_PROP_CNT / 8];
+ int i, j;
+ int res;
+ int count;
+ const char *bit_label;
+
+ printf(" input props:\n");
+ res = ioctl(fd, EVIOCGPROP(sizeof(bits)), bits);
+ if(res < 0) {
+ printf(" <not available\n");
+ return 1;
+ }
+ count = 0;
+ for(i = 0; i < res; i++) {
+ for(j = 0; j < 8; j++) {
+ if (bits[i] & 1 << j) {
+ bit_label = get_label(input_prop_labels, i * 8 + j);
+ if(bit_label)
+ printf(" %s\n", bit_label);
+ else
+ printf(" %04x\n", i * 8 + j);
+ count++;
+ }
+ }
+ }
+ if (!count)
+ printf(" <none>\n");
+ return 0;
+}
+
+static int print_possible_events(int fd, int print_flags)
{
uint8_t *bits = NULL;
ssize_t bits_size = 0;
const char* label;
int i, j, k;
int res, res2;
-
+ struct label* bit_labels;
+ const char *bit_label;
+
printf(" events:\n");
- for(i = 0; i <= EV_MAX; i++) {
+ for(i = EV_KEY; i <= EV_MAX; i++) { // skip EV_SYN since we cannot query its available codes
int count = 0;
while(1) {
res = ioctl(fd, EVIOCGBIT(i, bits_size), bits);
@@ -42,52 +92,64 @@
bits_size = res + 16;
bits = realloc(bits, bits_size * 2);
if(bits == NULL) {
- fprintf(stderr, "failed to allocate buffer of size %d\n", bits_size);
+ fprintf(stderr, "failed to allocate buffer of size %d\n", (int)bits_size);
return 1;
}
}
res2 = 0;
switch(i) {
- case EV_SYN:
- label = "SYN";
- break;
case EV_KEY:
res2 = ioctl(fd, EVIOCGKEY(res), bits + bits_size);
label = "KEY";
+ bit_labels = key_labels;
break;
case EV_REL:
label = "REL";
+ bit_labels = rel_labels;
break;
case EV_ABS:
label = "ABS";
+ bit_labels = abs_labels;
break;
case EV_MSC:
label = "MSC";
+ bit_labels = msc_labels;
break;
case EV_LED:
res2 = ioctl(fd, EVIOCGLED(res), bits + bits_size);
label = "LED";
+ bit_labels = led_labels;
break;
case EV_SND:
res2 = ioctl(fd, EVIOCGSND(res), bits + bits_size);
label = "SND";
+ bit_labels = snd_labels;
break;
case EV_SW:
res2 = ioctl(fd, EVIOCGSW(bits_size), bits + bits_size);
label = "SW ";
+ bit_labels = sw_labels;
break;
case EV_REP:
label = "REP";
+ bit_labels = rep_labels;
break;
case EV_FF:
label = "FF ";
+ bit_labels = ff_labels;
break;
case EV_PWR:
label = "PWR";
+ bit_labels = NULL;
+ break;
+ case EV_FF_STATUS:
+ label = "FFS";
+ bit_labels = ff_status_labels;
break;
default:
res2 = 0;
label = "???";
+ bit_labels = NULL;
}
for(j = 0; j < res; j++) {
for(k = 0; k < 8; k++)
@@ -99,13 +161,21 @@
down = ' ';
if(count == 0)
printf(" %s (%04x):", label, i);
- else if((count & 0x7) == 0 || i == EV_ABS)
+ else if((count & (print_flags & PRINT_LABELS ? 0x3 : 0x7)) == 0 || i == EV_ABS)
printf("\n ");
- printf(" %04x%c", j * 8 + k, down);
+ if(bit_labels && (print_flags & PRINT_LABELS)) {
+ bit_label = get_label(bit_labels, j * 8 + k);
+ if(bit_label)
+ printf(" %.20s%c%*s", bit_label, down, 20 - strlen(bit_label), "");
+ else
+ printf(" %04x%c ", j * 8 + k, down);
+ } else {
+ printf(" %04x%c", j * 8 + k, down);
+ }
if(i == EV_ABS) {
struct input_absinfo abs;
if(ioctl(fd, EVIOCGABS(j * 8 + k), &abs) == 0) {
- printf(" value %d, min %d, max %d, fuzz %d flat %d", abs.value, abs.minimum, abs.maximum, abs.fuzz, abs.flat);
+ printf(" : value %d, min %d, max %d, fuzz %d flat %d", abs.value, abs.minimum, abs.maximum, abs.fuzz, abs.flat);
}
}
count++;
@@ -118,6 +188,107 @@
return 0;
}
+static void print_event(int type, int code, int value, int print_flags)
+{
+ const char *type_label, *code_label, *value_label;
+
+ if (print_flags & PRINT_LABELS) {
+ type_label = get_label(ev_labels, type);
+ code_label = NULL;
+ value_label = NULL;
+
+ switch(type) {
+ case EV_SYN:
+ code_label = get_label(syn_labels, code);
+ break;
+ case EV_KEY:
+ code_label = get_label(key_labels, code);
+ value_label = get_label(key_value_labels, value);
+ break;
+ case EV_REL:
+ code_label = get_label(rel_labels, code);
+ break;
+ case EV_ABS:
+ code_label = get_label(abs_labels, code);
+ switch(code) {
+ case ABS_MT_TOOL_TYPE:
+ value_label = get_label(mt_tool_labels, value);
+ }
+ break;
+ case EV_MSC:
+ code_label = get_label(msc_labels, code);
+ break;
+ case EV_LED:
+ code_label = get_label(led_labels, code);
+ break;
+ case EV_SND:
+ code_label = get_label(snd_labels, code);
+ break;
+ case EV_SW:
+ code_label = get_label(sw_labels, code);
+ break;
+ case EV_REP:
+ code_label = get_label(rep_labels, code);
+ break;
+ case EV_FF:
+ code_label = get_label(ff_labels, code);
+ break;
+ case EV_FF_STATUS:
+ code_label = get_label(ff_status_labels, code);
+ break;
+ }
+
+ if (type_label)
+ printf("%-12.12s", type_label);
+ else
+ printf("%04x ", type);
+ if (code_label)
+ printf(" %-20.20s", code_label);
+ else
+ printf(" %04x ", code);
+ if (value_label)
+ printf(" %-20.20s", value_label);
+ else
+ printf(" %08x ", value);
+ } else {
+ printf("%04x %04x %08x", type, code, value);
+ }
+}
+
+static void print_hid_descriptor(int bus, int vendor, int product)
+{
+ const char *dirname = "/sys/kernel/debug/hid";
+ char prefix[16];
+ DIR *dir;
+ struct dirent *de;
+ char filename[PATH_MAX];
+ FILE *file;
+ char line[2048];
+
+ snprintf(prefix, sizeof(prefix), "%04X:%04X:%04X.", bus, vendor, product);
+
+ dir = opendir(dirname);
+ if(dir == NULL)
+ return;
+ while((de = readdir(dir))) {
+ if (strstr(de->d_name, prefix) == de->d_name) {
+ snprintf(filename, sizeof(filename), "%s/%s/rdesc", dirname, de->d_name);
+
+ file = fopen(filename, "r");
+ if (file) {
+ printf(" HID descriptor: %s\n\n", de->d_name);
+ while (fgets(line, sizeof(line), file)) {
+ fputs(" ", stdout);
+ fputs(line, stdout);
+ }
+ fclose(file);
+ puts("");
+ }
+ }
+ }
+ closedir(dir);
+}
+
static int open_device(const char *device, int print_flags)
{
int version;
@@ -193,7 +364,14 @@
version >> 16, (version >> 8) & 0xff, version & 0xff);
if(print_flags & PRINT_POSSIBLE_EVENTS) {
- print_possible_events(fd);
+ print_possible_events(fd, print_flags);
+ }
+
+ if(print_flags & PRINT_INPUT_PROPS) {
+ print_input_props(fd);
+ }
+ if(print_flags & PRINT_HID_DESCRIPTOR) {
+ print_hid_descriptor(id.bustype, id.vendor, id.product);
}
ufds[nfds].fd = fd;
@@ -292,13 +470,16 @@
static void usage(int argc, char *argv[])
{
- fprintf(stderr, "Usage: %s [-t] [-n] [-s switchmask] [-S] [-v [mask]] [-p] [-q] [-c count] [-r] [device]\n", argv[0]);
+ fprintf(stderr, "Usage: %s [-t] [-n] [-s switchmask] [-S] [-v [mask]] [-d] [-p] [-i] [-l] [-q] [-c count] [-r] [device]\n", argv[0]);
fprintf(stderr, " -t: show time stamps\n");
fprintf(stderr, " -n: don't print newlines\n");
fprintf(stderr, " -s: print switch states for given bits\n");
fprintf(stderr, " -S: print all switch states\n");
- fprintf(stderr, " -v: verbosity mask (errs=1, dev=2, name=4, info=8, vers=16, pos. events=32)\n");
+ fprintf(stderr, " -v: verbosity mask (errs=1, dev=2, name=4, info=8, vers=16, pos. events=32, props=64)\n");
+ fprintf(stderr, " -d: show HID descriptor, if available\n");
fprintf(stderr, " -p: show possible events (errs, dev, name, pos. events)\n");
+ fprintf(stderr, " -i: show all device info and possible events\n");
+ fprintf(stderr, " -l: label event types and names in plain text\n");
fprintf(stderr, " -q: quiet (clear verbosity mask)\n");
fprintf(stderr, " -c: print given number of events then exit\n");
fprintf(stderr, " -r: print rate events are received\n");
@@ -316,7 +497,7 @@
uint16_t get_switch = 0;
struct input_event event;
int version;
- int print_flags = PRINT_DEVICE_ERRORS | PRINT_DEVICE | PRINT_DEVICE_NAME;
+ int print_flags = 0;
int print_flags_set = 0;
int dont_block = -1;
int event_count = 0;
@@ -327,7 +508,7 @@
opterr = 0;
do {
- c = getopt(argc, argv, "tns:Sv::pqc:rh");
+ c = getopt(argc, argv, "tns:Sv::dpilqc:rh");
if (c == EOF)
break;
switch (c) {
@@ -349,19 +530,31 @@
break;
case 'v':
if(optarg)
- print_flags = strtoul(optarg, NULL, 0);
+ print_flags |= strtoul(optarg, NULL, 0);
else
print_flags |= PRINT_DEVICE | PRINT_DEVICE_NAME | PRINT_DEVICE_INFO | PRINT_VERSION;
print_flags_set = 1;
break;
+ case 'd':
+ print_flags |= PRINT_HID_DESCRIPTOR;
+ break;
case 'p':
- print_flags = PRINT_DEVICE_ERRORS | PRINT_DEVICE | PRINT_DEVICE_NAME | PRINT_POSSIBLE_EVENTS;
+ print_flags |= PRINT_DEVICE_ERRORS | PRINT_DEVICE
+ | PRINT_DEVICE_NAME | PRINT_POSSIBLE_EVENTS | PRINT_INPUT_PROPS;
print_flags_set = 1;
if(dont_block == -1)
dont_block = 1;
break;
+ case 'i':
+ print_flags |= PRINT_ALL_INFO;
+ print_flags_set = 1;
+ if(dont_block == -1)
+ dont_block = 1;
+ break;
+ case 'l':
+ print_flags |= PRINT_LABELS;
+ break;
case 'q':
- print_flags = 0;
print_flags_set = 1;
break;
case 'c':
@@ -396,13 +589,14 @@
ufds[0].events = POLLIN;
if(device) {
if(!print_flags_set)
- print_flags = PRINT_DEVICE_ERRORS;
+ print_flags |= PRINT_DEVICE_ERRORS;
res = open_device(device, print_flags);
if(res < 0) {
return 1;
}
- }
- else {
+ } else {
+ if(!print_flags_set)
+ print_flags |= PRINT_DEVICE_ERRORS | PRINT_DEVICE | PRINT_DEVICE_NAME;
print_device = 1;
res = inotify_add_watch(ufds[0].fd, device_path, IN_DELETE | IN_CREATE);
if(res < 0) {
@@ -451,7 +645,7 @@
}
if(print_device)
printf("%s: ", device_names[i]);
- printf("%04x %04x %08x", event.type, event.code, event.value);
+ print_event(event.type, event.code, event.value, print_flags);
if(sync_rate && event.type == 0 && event.code == 0) {
int64_t now = event.time.tv_sec * 1000000LL + event.time.tv_usec;
if(last_sync_time)
diff --git a/toolbox/getevent.h b/toolbox/getevent.h
new file mode 100644
index 0000000..2b76209
--- /dev/null
+++ b/toolbox/getevent.h
@@ -0,0 +1,725 @@
+#include <linux/input.h>
+
+struct label {
+ const char *name;
+ int value;
+};
+
+#define LABEL(constant) { #constant, constant }
+#define LABEL_END { NULL, -1 }
+
+static struct label input_prop_labels[] = {
+ LABEL(INPUT_PROP_POINTER),
+ LABEL(INPUT_PROP_DIRECT),
+ LABEL(INPUT_PROP_BUTTONPAD),
+ LABEL(INPUT_PROP_SEMI_MT),
+ LABEL_END,
+};
+
+static struct label ev_labels[] = {
+ LABEL(EV_SYN),
+ LABEL(EV_KEY),
+ LABEL(EV_REL),
+ LABEL(EV_ABS),
+ LABEL(EV_MSC),
+ LABEL(EV_SW),
+ LABEL(EV_LED),
+ LABEL(EV_SND),
+ LABEL(EV_REP),
+ LABEL(EV_FF),
+ LABEL(EV_PWR),
+ LABEL(EV_FF_STATUS),
+ LABEL_END,
+};
+
+static struct label syn_labels[] = {
+ LABEL(SYN_REPORT),
+ LABEL(SYN_CONFIG),
+ LABEL(SYN_MT_REPORT),
+ LABEL(SYN_DROPPED),
+ LABEL_END,
+};
+
+static struct label key_labels[] = {
+ LABEL(KEY_RESERVED),
+ LABEL(KEY_ESC),
+ LABEL(KEY_1),
+ LABEL(KEY_2),
+ LABEL(KEY_3),
+ LABEL(KEY_4),
+ LABEL(KEY_5),
+ LABEL(KEY_6),
+ LABEL(KEY_7),
+ LABEL(KEY_8),
+ LABEL(KEY_9),
+ LABEL(KEY_0),
+ LABEL(KEY_MINUS),
+ LABEL(KEY_EQUAL),
+ LABEL(KEY_BACKSPACE),
+ LABEL(KEY_TAB),
+ LABEL(KEY_Q),
+ LABEL(KEY_W),
+ LABEL(KEY_E),
+ LABEL(KEY_R),
+ LABEL(KEY_T),
+ LABEL(KEY_Y),
+ LABEL(KEY_U),
+ LABEL(KEY_I),
+ LABEL(KEY_O),
+ LABEL(KEY_P),
+ LABEL(KEY_LEFTBRACE),
+ LABEL(KEY_RIGHTBRACE),
+ LABEL(KEY_ENTER),
+ LABEL(KEY_LEFTCTRL),
+ LABEL(KEY_A),
+ LABEL(KEY_S),
+ LABEL(KEY_D),
+ LABEL(KEY_F),
+ LABEL(KEY_G),
+ LABEL(KEY_H),
+ LABEL(KEY_J),
+ LABEL(KEY_K),
+ LABEL(KEY_L),
+ LABEL(KEY_SEMICOLON),
+ LABEL(KEY_APOSTROPHE),
+ LABEL(KEY_GRAVE),
+ LABEL(KEY_LEFTSHIFT),
+ LABEL(KEY_BACKSLASH),
+ LABEL(KEY_Z),
+ LABEL(KEY_X),
+ LABEL(KEY_C),
+ LABEL(KEY_V),
+ LABEL(KEY_B),
+ LABEL(KEY_N),
+ LABEL(KEY_M),
+ LABEL(KEY_COMMA),
+ LABEL(KEY_DOT),
+ LABEL(KEY_SLASH),
+ LABEL(KEY_RIGHTSHIFT),
+ LABEL(KEY_KPASTERISK),
+ LABEL(KEY_LEFTALT),
+ LABEL(KEY_SPACE),
+ LABEL(KEY_CAPSLOCK),
+ LABEL(KEY_F1),
+ LABEL(KEY_F2),
+ LABEL(KEY_F3),
+ LABEL(KEY_F4),
+ LABEL(KEY_F5),
+ LABEL(KEY_F6),
+ LABEL(KEY_F7),
+ LABEL(KEY_F8),
+ LABEL(KEY_F9),
+ LABEL(KEY_F10),
+ LABEL(KEY_NUMLOCK),
+ LABEL(KEY_SCROLLLOCK),
+ LABEL(KEY_KP7),
+ LABEL(KEY_KP8),
+ LABEL(KEY_KP9),
+ LABEL(KEY_KPMINUS),
+ LABEL(KEY_KP4),
+ LABEL(KEY_KP5),
+ LABEL(KEY_KP6),
+ LABEL(KEY_KPPLUS),
+ LABEL(KEY_KP1),
+ LABEL(KEY_KP2),
+ LABEL(KEY_KP3),
+ LABEL(KEY_KP0),
+ LABEL(KEY_KPDOT),
+ LABEL(KEY_ZENKAKUHANKAKU),
+ LABEL(KEY_102ND),
+ LABEL(KEY_F11),
+ LABEL(KEY_F12),
+ LABEL(KEY_RO),
+ LABEL(KEY_KATAKANA),
+ LABEL(KEY_HIRAGANA),
+ LABEL(KEY_HENKAN),
+ LABEL(KEY_KATAKANAHIRAGANA),
+ LABEL(KEY_MUHENKAN),
+ LABEL(KEY_KPJPCOMMA),
+ LABEL(KEY_KPENTER),
+ LABEL(KEY_RIGHTCTRL),
+ LABEL(KEY_KPSLASH),
+ LABEL(KEY_SYSRQ),
+ LABEL(KEY_RIGHTALT),
+ LABEL(KEY_LINEFEED),
+ LABEL(KEY_HOME),
+ LABEL(KEY_UP),
+ LABEL(KEY_PAGEUP),
+ LABEL(KEY_LEFT),
+ LABEL(KEY_RIGHT),
+ LABEL(KEY_END),
+ LABEL(KEY_DOWN),
+ LABEL(KEY_PAGEDOWN),
+ LABEL(KEY_INSERT),
+ LABEL(KEY_DELETE),
+ LABEL(KEY_MACRO),
+ LABEL(KEY_MUTE),
+ LABEL(KEY_VOLUMEDOWN),
+ LABEL(KEY_VOLUMEUP),
+ LABEL(KEY_POWER),
+ LABEL(KEY_KPEQUAL),
+ LABEL(KEY_KPPLUSMINUS),
+ LABEL(KEY_PAUSE),
+ LABEL(KEY_SCALE),
+ LABEL(KEY_KPCOMMA),
+ LABEL(KEY_HANGEUL),
+ LABEL(KEY_HANGUEL),
+ LABEL(KEY_HANJA),
+ LABEL(KEY_YEN),
+ LABEL(KEY_LEFTMETA),
+ LABEL(KEY_RIGHTMETA),
+ LABEL(KEY_COMPOSE),
+ LABEL(KEY_STOP),
+ LABEL(KEY_AGAIN),
+ LABEL(KEY_PROPS),
+ LABEL(KEY_UNDO),
+ LABEL(KEY_FRONT),
+ LABEL(KEY_COPY),
+ LABEL(KEY_OPEN),
+ LABEL(KEY_PASTE),
+ LABEL(KEY_FIND),
+ LABEL(KEY_CUT),
+ LABEL(KEY_HELP),
+ LABEL(KEY_MENU),
+ LABEL(KEY_CALC),
+ LABEL(KEY_SETUP),
+ LABEL(KEY_SLEEP),
+ LABEL(KEY_WAKEUP),
+ LABEL(KEY_FILE),
+ LABEL(KEY_SENDFILE),
+ LABEL(KEY_DELETEFILE),
+ LABEL(KEY_XFER),
+ LABEL(KEY_PROG1),
+ LABEL(KEY_PROG2),
+ LABEL(KEY_WWW),
+ LABEL(KEY_MSDOS),
+ LABEL(KEY_COFFEE),
+ LABEL(KEY_SCREENLOCK),
+ LABEL(KEY_DIRECTION),
+ LABEL(KEY_CYCLEWINDOWS),
+ LABEL(KEY_MAIL),
+ LABEL(KEY_BOOKMARKS),
+ LABEL(KEY_COMPUTER),
+ LABEL(KEY_BACK),
+ LABEL(KEY_FORWARD),
+ LABEL(KEY_CLOSECD),
+ LABEL(KEY_EJECTCD),
+ LABEL(KEY_EJECTCLOSECD),
+ LABEL(KEY_NEXTSONG),
+ LABEL(KEY_PLAYPAUSE),
+ LABEL(KEY_PREVIOUSSONG),
+ LABEL(KEY_STOPCD),
+ LABEL(KEY_RECORD),
+ LABEL(KEY_REWIND),
+ LABEL(KEY_PHONE),
+ LABEL(KEY_ISO),
+ LABEL(KEY_CONFIG),
+ LABEL(KEY_HOMEPAGE),
+ LABEL(KEY_REFRESH),
+ LABEL(KEY_EXIT),
+ LABEL(KEY_MOVE),
+ LABEL(KEY_EDIT),
+ LABEL(KEY_SCROLLUP),
+ LABEL(KEY_SCROLLDOWN),
+ LABEL(KEY_KPLEFTPAREN),
+ LABEL(KEY_KPRIGHTPAREN),
+ LABEL(KEY_NEW),
+ LABEL(KEY_REDO),
+ LABEL(KEY_F13),
+ LABEL(KEY_F14),
+ LABEL(KEY_F15),
+ LABEL(KEY_F16),
+ LABEL(KEY_F17),
+ LABEL(KEY_F18),
+ LABEL(KEY_F19),
+ LABEL(KEY_F20),
+ LABEL(KEY_F21),
+ LABEL(KEY_F22),
+ LABEL(KEY_F23),
+ LABEL(KEY_F24),
+ LABEL(KEY_PLAYCD),
+ LABEL(KEY_PAUSECD),
+ LABEL(KEY_PROG3),
+ LABEL(KEY_PROG4),
+ LABEL(KEY_DASHBOARD),
+ LABEL(KEY_SUSPEND),
+ LABEL(KEY_CLOSE),
+ LABEL(KEY_PLAY),
+ LABEL(KEY_FASTFORWARD),
+ LABEL(KEY_BASSBOOST),
+ LABEL(KEY_PRINT),
+ LABEL(KEY_HP),
+ LABEL(KEY_CAMERA),
+ LABEL(KEY_SOUND),
+ LABEL(KEY_QUESTION),
+ LABEL(KEY_EMAIL),
+ LABEL(KEY_CHAT),
+ LABEL(KEY_SEARCH),
+ LABEL(KEY_CONNECT),
+ LABEL(KEY_FINANCE),
+ LABEL(KEY_SPORT),
+ LABEL(KEY_SHOP),
+ LABEL(KEY_ALTERASE),
+ LABEL(KEY_CANCEL),
+ LABEL(KEY_BRIGHTNESSDOWN),
+ LABEL(KEY_BRIGHTNESSUP),
+ LABEL(KEY_MEDIA),
+ LABEL(KEY_SWITCHVIDEOMODE),
+ LABEL(KEY_KBDILLUMTOGGLE),
+ LABEL(KEY_KBDILLUMDOWN),
+ LABEL(KEY_KBDILLUMUP),
+ LABEL(KEY_SEND),
+ LABEL(KEY_REPLY),
+ LABEL(KEY_FORWARDMAIL),
+ LABEL(KEY_SAVE),
+ LABEL(KEY_DOCUMENTS),
+ LABEL(KEY_BATTERY),
+ LABEL(KEY_BLUETOOTH),
+ LABEL(KEY_WLAN),
+ LABEL(KEY_UWB),
+ LABEL(KEY_UNKNOWN),
+ LABEL(KEY_VIDEO_NEXT),
+ LABEL(KEY_VIDEO_PREV),
+ LABEL(KEY_BRIGHTNESS_CYCLE),
+ LABEL(KEY_BRIGHTNESS_ZERO),
+ LABEL(KEY_DISPLAY_OFF),
+ LABEL(KEY_WIMAX),
+ LABEL(KEY_RFKILL),
+ LABEL(BTN_0),
+ LABEL(BTN_1),
+ LABEL(BTN_2),
+ LABEL(BTN_3),
+ LABEL(BTN_4),
+ LABEL(BTN_5),
+ LABEL(BTN_6),
+ LABEL(BTN_7),
+ LABEL(BTN_8),
+ LABEL(BTN_9),
+ LABEL(BTN_LEFT),
+ LABEL(BTN_RIGHT),
+ LABEL(BTN_MIDDLE),
+ LABEL(BTN_SIDE),
+ LABEL(BTN_EXTRA),
+ LABEL(BTN_FORWARD),
+ LABEL(BTN_BACK),
+ LABEL(BTN_TASK),
+ LABEL(BTN_JOYSTICK),
+ LABEL(BTN_TRIGGER),
+ LABEL(BTN_THUMB),
+ LABEL(BTN_THUMB2),
+ LABEL(BTN_TOP),
+ LABEL(BTN_TOP2),
+ LABEL(BTN_PINKIE),
+ LABEL(BTN_BASE),
+ LABEL(BTN_BASE2),
+ LABEL(BTN_BASE3),
+ LABEL(BTN_BASE4),
+ LABEL(BTN_BASE5),
+ LABEL(BTN_BASE6),
+ LABEL(BTN_DEAD),
+ LABEL(BTN_A),
+ LABEL(BTN_B),
+ LABEL(BTN_C),
+ LABEL(BTN_X),
+ LABEL(BTN_Y),
+ LABEL(BTN_Z),
+ LABEL(BTN_TL),
+ LABEL(BTN_TR),
+ LABEL(BTN_TL2),
+ LABEL(BTN_TR2),
+ LABEL(BTN_SELECT),
+ LABEL(BTN_START),
+ LABEL(BTN_MODE),
+ LABEL(BTN_THUMBL),
+ LABEL(BTN_THUMBR),
+ LABEL(BTN_TOOL_PEN),
+ LABEL(BTN_TOOL_RUBBER),
+ LABEL(BTN_TOOL_BRUSH),
+ LABEL(BTN_TOOL_PENCIL),
+ LABEL(BTN_TOOL_AIRBRUSH),
+ LABEL(BTN_TOOL_FINGER),
+ LABEL(BTN_TOOL_MOUSE),
+ LABEL(BTN_TOOL_LENS),
+ LABEL(BTN_TOUCH),
+ LABEL(BTN_STYLUS),
+ LABEL(BTN_STYLUS2),
+ LABEL(BTN_TOOL_DOUBLETAP),
+ LABEL(BTN_TOOL_TRIPLETAP),
+ LABEL(BTN_TOOL_QUADTAP),
+ LABEL(BTN_GEAR_DOWN),
+ LABEL(BTN_GEAR_UP),
+ LABEL(KEY_OK),
+ LABEL(KEY_SELECT),
+ LABEL(KEY_GOTO),
+ LABEL(KEY_CLEAR),
+ LABEL(KEY_POWER2),
+ LABEL(KEY_OPTION),
+ LABEL(KEY_INFO),
+ LABEL(KEY_TIME),
+ LABEL(KEY_VENDOR),
+ LABEL(KEY_ARCHIVE),
+ LABEL(KEY_PROGRAM),
+ LABEL(KEY_CHANNEL),
+ LABEL(KEY_FAVORITES),
+ LABEL(KEY_EPG),
+ LABEL(KEY_PVR),
+ LABEL(KEY_MHP),
+ LABEL(KEY_LANGUAGE),
+ LABEL(KEY_TITLE),
+ LABEL(KEY_SUBTITLE),
+ LABEL(KEY_ANGLE),
+ LABEL(KEY_ZOOM),
+ LABEL(KEY_MODE),
+ LABEL(KEY_KEYBOARD),
+ LABEL(KEY_SCREEN),
+ LABEL(KEY_PC),
+ LABEL(KEY_TV),
+ LABEL(KEY_TV2),
+ LABEL(KEY_VCR),
+ LABEL(KEY_VCR2),
+ LABEL(KEY_SAT),
+ LABEL(KEY_SAT2),
+ LABEL(KEY_CD),
+ LABEL(KEY_TAPE),
+ LABEL(KEY_RADIO),
+ LABEL(KEY_TUNER),
+ LABEL(KEY_PLAYER),
+ LABEL(KEY_TEXT),
+ LABEL(KEY_DVD),
+ LABEL(KEY_AUX),
+ LABEL(KEY_MP3),
+ LABEL(KEY_AUDIO),
+ LABEL(KEY_VIDEO),
+ LABEL(KEY_DIRECTORY),
+ LABEL(KEY_LIST),
+ LABEL(KEY_MEMO),
+ LABEL(KEY_CALENDAR),
+ LABEL(KEY_RED),
+ LABEL(KEY_GREEN),
+ LABEL(KEY_YELLOW),
+ LABEL(KEY_BLUE),
+ LABEL(KEY_CHANNELUP),
+ LABEL(KEY_CHANNELDOWN),
+ LABEL(KEY_FIRST),
+ LABEL(KEY_LAST),
+ LABEL(KEY_AB),
+ LABEL(KEY_NEXT),
+ LABEL(KEY_RESTART),
+ LABEL(KEY_SLOW),
+ LABEL(KEY_SHUFFLE),
+ LABEL(KEY_BREAK),
+ LABEL(KEY_PREVIOUS),
+ LABEL(KEY_DIGITS),
+ LABEL(KEY_TEEN),
+ LABEL(KEY_TWEN),
+ LABEL(KEY_VIDEOPHONE),
+ LABEL(KEY_GAMES),
+ LABEL(KEY_ZOOMIN),
+ LABEL(KEY_ZOOMOUT),
+ LABEL(KEY_ZOOMRESET),
+ LABEL(KEY_WORDPROCESSOR),
+ LABEL(KEY_EDITOR),
+ LABEL(KEY_SPREADSHEET),
+ LABEL(KEY_GRAPHICSEDITOR),
+ LABEL(KEY_PRESENTATION),
+ LABEL(KEY_DATABASE),
+ LABEL(KEY_NEWS),
+ LABEL(KEY_VOICEMAIL),
+ LABEL(KEY_ADDRESSBOOK),
+ LABEL(KEY_MESSENGER),
+ LABEL(KEY_DISPLAYTOGGLE),
+ LABEL(KEY_SPELLCHECK),
+ LABEL(KEY_LOGOFF),
+ LABEL(KEY_DOLLAR),
+ LABEL(KEY_EURO),
+ LABEL(KEY_FRAMEBACK),
+ LABEL(KEY_FRAMEFORWARD),
+ LABEL(KEY_CONTEXT_MENU),
+ LABEL(KEY_MEDIA_REPEAT),
+ LABEL(KEY_10CHANNELSUP),
+ LABEL(KEY_10CHANNELSDOWN),
+ LABEL(KEY_IMAGES),
+ LABEL(KEY_DEL_EOL),
+ LABEL(KEY_DEL_EOS),
+ LABEL(KEY_INS_LINE),
+ LABEL(KEY_DEL_LINE),
+ LABEL(KEY_FN),
+ LABEL(KEY_FN_ESC),
+ LABEL(KEY_FN_F1),
+ LABEL(KEY_FN_F2),
+ LABEL(KEY_FN_F3),
+ LABEL(KEY_FN_F4),
+ LABEL(KEY_FN_F5),
+ LABEL(KEY_FN_F6),
+ LABEL(KEY_FN_F7),
+ LABEL(KEY_FN_F8),
+ LABEL(KEY_FN_F9),
+ LABEL(KEY_FN_F10),
+ LABEL(KEY_FN_F11),
+ LABEL(KEY_FN_F12),
+ LABEL(KEY_FN_1),
+ LABEL(KEY_FN_2),
+ LABEL(KEY_FN_D),
+ LABEL(KEY_FN_E),
+ LABEL(KEY_FN_F),
+ LABEL(KEY_FN_S),
+ LABEL(KEY_FN_B),
+ LABEL(KEY_BRL_DOT1),
+ LABEL(KEY_BRL_DOT2),
+ LABEL(KEY_BRL_DOT3),
+ LABEL(KEY_BRL_DOT4),
+ LABEL(KEY_BRL_DOT5),
+ LABEL(KEY_BRL_DOT6),
+ LABEL(KEY_BRL_DOT7),
+ LABEL(KEY_BRL_DOT8),
+ LABEL(KEY_BRL_DOT9),
+ LABEL(KEY_BRL_DOT10),
+ LABEL(KEY_NUMERIC_0),
+ LABEL(KEY_NUMERIC_1),
+ LABEL(KEY_NUMERIC_2),
+ LABEL(KEY_NUMERIC_3),
+ LABEL(KEY_NUMERIC_4),
+ LABEL(KEY_NUMERIC_5),
+ LABEL(KEY_NUMERIC_6),
+ LABEL(KEY_NUMERIC_7),
+ LABEL(KEY_NUMERIC_8),
+ LABEL(KEY_NUMERIC_9),
+ LABEL(KEY_NUMERIC_STAR),
+ LABEL(KEY_NUMERIC_POUND),
+ LABEL(KEY_CAMERA_FOCUS),
+ LABEL(KEY_WPS_BUTTON),
+ LABEL(KEY_TOUCHPAD_TOGGLE),
+ LABEL(KEY_TOUCHPAD_ON),
+ LABEL(KEY_TOUCHPAD_OFF),
+ LABEL(KEY_CAMERA_ZOOMIN),
+ LABEL(KEY_CAMERA_ZOOMOUT),
+ LABEL(KEY_CAMERA_UP),
+ LABEL(KEY_CAMERA_DOWN),
+ LABEL(KEY_CAMERA_LEFT),
+ LABEL(KEY_CAMERA_RIGHT),
+ LABEL(BTN_TRIGGER_HAPPY1),
+ LABEL(BTN_TRIGGER_HAPPY2),
+ LABEL(BTN_TRIGGER_HAPPY3),
+ LABEL(BTN_TRIGGER_HAPPY4),
+ LABEL(BTN_TRIGGER_HAPPY5),
+ LABEL(BTN_TRIGGER_HAPPY6),
+ LABEL(BTN_TRIGGER_HAPPY7),
+ LABEL(BTN_TRIGGER_HAPPY8),
+ LABEL(BTN_TRIGGER_HAPPY9),
+ LABEL(BTN_TRIGGER_HAPPY10),
+ LABEL(BTN_TRIGGER_HAPPY11),
+ LABEL(BTN_TRIGGER_HAPPY12),
+ LABEL(BTN_TRIGGER_HAPPY13),
+ LABEL(BTN_TRIGGER_HAPPY14),
+ LABEL(BTN_TRIGGER_HAPPY15),
+ LABEL(BTN_TRIGGER_HAPPY16),
+ LABEL(BTN_TRIGGER_HAPPY17),
+ LABEL(BTN_TRIGGER_HAPPY18),
+ LABEL(BTN_TRIGGER_HAPPY19),
+ LABEL(BTN_TRIGGER_HAPPY20),
+ LABEL(BTN_TRIGGER_HAPPY21),
+ LABEL(BTN_TRIGGER_HAPPY22),
+ LABEL(BTN_TRIGGER_HAPPY23),
+ LABEL(BTN_TRIGGER_HAPPY24),
+ LABEL(BTN_TRIGGER_HAPPY25),
+ LABEL(BTN_TRIGGER_HAPPY26),
+ LABEL(BTN_TRIGGER_HAPPY27),
+ LABEL(BTN_TRIGGER_HAPPY28),
+ LABEL(BTN_TRIGGER_HAPPY29),
+ LABEL(BTN_TRIGGER_HAPPY30),
+ LABEL(BTN_TRIGGER_HAPPY31),
+ LABEL(BTN_TRIGGER_HAPPY32),
+ LABEL(BTN_TRIGGER_HAPPY33),
+ LABEL(BTN_TRIGGER_HAPPY34),
+ LABEL(BTN_TRIGGER_HAPPY35),
+ LABEL(BTN_TRIGGER_HAPPY36),
+ LABEL(BTN_TRIGGER_HAPPY37),
+ LABEL(BTN_TRIGGER_HAPPY38),
+ LABEL(BTN_TRIGGER_HAPPY39),
+ LABEL(BTN_TRIGGER_HAPPY40),
+ LABEL_END,
+};
+
+static struct label rel_labels[] = {
+ LABEL(REL_X),
+ LABEL(REL_Y),
+ LABEL(REL_Z),
+ LABEL(REL_RX),
+ LABEL(REL_RY),
+ LABEL(REL_RZ),
+ LABEL(REL_HWHEEL),
+ LABEL(REL_DIAL),
+ LABEL(REL_WHEEL),
+ LABEL(REL_MISC),
+ LABEL_END,
+};
+
+static struct label abs_labels[] = {
+ LABEL(ABS_X),
+ LABEL(ABS_Y),
+ LABEL(ABS_Z),
+ LABEL(ABS_RX),
+ LABEL(ABS_RY),
+ LABEL(ABS_RZ),
+ LABEL(ABS_THROTTLE),
+ LABEL(ABS_RUDDER),
+ LABEL(ABS_WHEEL),
+ LABEL(ABS_GAS),
+ LABEL(ABS_BRAKE),
+ LABEL(ABS_HAT0X),
+ LABEL(ABS_HAT0Y),
+ LABEL(ABS_HAT1X),
+ LABEL(ABS_HAT1Y),
+ LABEL(ABS_HAT2X),
+ LABEL(ABS_HAT2Y),
+ LABEL(ABS_HAT3X),
+ LABEL(ABS_HAT3Y),
+ LABEL(ABS_PRESSURE),
+ LABEL(ABS_DISTANCE),
+ LABEL(ABS_TILT_X),
+ LABEL(ABS_TILT_Y),
+ LABEL(ABS_TOOL_WIDTH),
+ LABEL(ABS_VOLUME),
+ LABEL(ABS_MISC),
+ LABEL(ABS_MT_SLOT),
+ LABEL(ABS_MT_TOUCH_MAJOR),
+ LABEL(ABS_MT_TOUCH_MINOR),
+ LABEL(ABS_MT_WIDTH_MAJOR),
+ LABEL(ABS_MT_WIDTH_MINOR),
+ LABEL(ABS_MT_ORIENTATION),
+ LABEL(ABS_MT_POSITION_X),
+ LABEL(ABS_MT_POSITION_Y),
+ LABEL(ABS_MT_TOOL_TYPE),
+ LABEL(ABS_MT_BLOB_ID),
+ LABEL(ABS_MT_TRACKING_ID),
+ LABEL(ABS_MT_PRESSURE),
+ LABEL(ABS_MT_DISTANCE),
+ LABEL_END,
+};
+
+static struct label sw_labels[] = {
+ LABEL(SW_LID),
+ LABEL(SW_TABLET_MODE),
+ LABEL(SW_HEADPHONE_INSERT),
+ LABEL(SW_RFKILL_ALL),
+ LABEL(SW_RADIO),
+ LABEL(SW_MICROPHONE_INSERT),
+ LABEL(SW_DOCK),
+ LABEL(SW_LINEOUT_INSERT),
+ LABEL(SW_JACK_PHYSICAL_INSERT),
+ LABEL(SW_VIDEOOUT_INSERT),
+ LABEL(SW_CAMERA_LENS_COVER),
+ LABEL(SW_KEYPAD_SLIDE),
+ LABEL(SW_FRONT_PROXIMITY),
+ LABEL(SW_ROTATE_LOCK),
+ LABEL_END,
+};
+
+static struct label msc_labels[] = {
+ LABEL(MSC_SERIAL),
+ LABEL(MSC_PULSELED),
+ LABEL(MSC_GESTURE),
+ LABEL(MSC_RAW),
+ LABEL(MSC_SCAN),
+ LABEL_END,
+};
+
+static struct label led_labels[] = {
+ LABEL(LED_NUML),
+ LABEL(LED_CAPSL),
+ LABEL(LED_SCROLLL),
+ LABEL(LED_COMPOSE),
+ LABEL(LED_KANA),
+ LABEL(LED_SLEEP),
+ LABEL(LED_SUSPEND),
+ LABEL(LED_MUTE),
+ LABEL(LED_MISC),
+ LABEL(LED_MAIL),
+ LABEL(LED_CHARGING),
+ LABEL_END,
+};
+
+static struct label rep_labels[] = {
+ LABEL(REP_DELAY),
+ LABEL(REP_PERIOD),
+ LABEL_END,
+};
+
+static struct label snd_labels[] = {
+ LABEL(SND_CLICK),
+ LABEL(SND_BELL),
+ LABEL(SND_TONE),
+ LABEL_END,
+};
+
+static struct label id_labels[] = {
+ LABEL(ID_BUS),
+ LABEL(ID_VENDOR),
+ LABEL(ID_PRODUCT),
+ LABEL(ID_VERSION),
+ LABEL_END,
+};
+
+static struct label bus_labels[] = {
+ LABEL(BUS_PCI),
+ LABEL(BUS_ISAPNP),
+ LABEL(BUS_USB),
+ LABEL(BUS_HIL),
+ LABEL(BUS_BLUETOOTH),
+ LABEL(BUS_VIRTUAL),
+ LABEL(BUS_ISA),
+ LABEL(BUS_I8042),
+ LABEL(BUS_XTKBD),
+ LABEL(BUS_RS232),
+ LABEL(BUS_GAMEPORT),
+ LABEL(BUS_PARPORT),
+ LABEL(BUS_AMIGA),
+ LABEL(BUS_ADB),
+ LABEL(BUS_I2C),
+ LABEL(BUS_HOST),
+ LABEL(BUS_GSC),
+ LABEL(BUS_ATARI),
+ LABEL(BUS_SPI),
+ LABEL_END,
+};
+
+static struct label mt_tool_labels[] = {
+ LABEL(MT_TOOL_FINGER),
+ LABEL(MT_TOOL_PEN),
+ LABEL(MT_TOOL_MAX),
+ LABEL_END,
+};
+
+static struct label ff_status_labels[] = {
+ LABEL(FF_STATUS_STOPPED),
+ LABEL(FF_STATUS_PLAYING),
+ LABEL(FF_STATUS_MAX),
+ LABEL_END,
+};
+
+static struct label ff_labels[] = {
+ LABEL(FF_RUMBLE),
+ LABEL(FF_PERIODIC),
+ LABEL(FF_CONSTANT),
+ LABEL(FF_SPRING),
+ LABEL(FF_FRICTION),
+ LABEL(FF_DAMPER),
+ LABEL(FF_INERTIA),
+ LABEL(FF_RAMP),
+ LABEL(FF_SQUARE),
+ LABEL(FF_TRIANGLE),
+ LABEL(FF_SINE),
+ LABEL(FF_SAW_UP),
+ LABEL(FF_SAW_DOWN),
+ LABEL(FF_CUSTOM),
+ LABEL(FF_GAIN),
+ LABEL(FF_AUTOCENTER),
+ LABEL_END,
+};
+
+static struct label key_value_labels[] = {
+ { "UP", 0 },
+ { "DOWN", 1 },
+ { "REPEAT", 2 },
+ LABEL_END,
+};
diff --git a/toolbox/lsof.c b/toolbox/lsof.c
index c55384b..4e2f77a 100644
--- a/toolbox/lsof.c
+++ b/toolbox/lsof.c
@@ -37,11 +37,16 @@
#include <stdlib.h>
#include <unistd.h>
+#include <pwd.h>
+#include <sys/stat.h>
+
#define BUF_MAX 1024
-#define CMD_DISPLAY_MAX 10
+#define CMD_DISPLAY_MAX (9 + 1)
+#define USER_DISPLAY_MAX (10 + 1)
struct pid_info_t {
pid_t pid;
+ char user[USER_DISPLAY_MAX];
char cmdline[CMD_DISPLAY_MAX];
@@ -82,7 +87,8 @@
if (!strcmp(link_dest, "/"))
goto out;
- printf("%-9s %5d %10s %4s %9s %18s %9s %10s %s\n", info->cmdline, info->pid, "???", type,
+ printf("%-9s %5d %10s %4s %9s %18s %9s %10s %s\n",
+ info->cmdline, info->pid, info->user, type,
"???", "???", "???", "???", link_dest);
out:
@@ -113,7 +119,8 @@
if (inode == 0 || !strcmp(device, "00:00"))
continue;
- printf("%-9s %5d %10s %4s %9s %18s %9zd %10ld %s\n", info->cmdline, info->pid, "???", "mem",
+ printf("%-9s %5d %10s %4s %9s %18s %9zd %10ld %s\n",
+ info->cmdline, info->pid, info->user, "mem",
"???", device, offset, inode, file);
}
@@ -136,7 +143,8 @@
if (dir == NULL) {
char msg[BUF_MAX];
snprintf(msg, sizeof(msg), "%s (opendir: %s)", info->path, strerror(errno));
- printf("%-9s %5d %10s %4s %9s %18s %9s %10s %s\n", info->cmdline, info->pid, "???", "FDS",
+ printf("%-9s %5d %10s %4s %9s %18s %9s %10s %s\n",
+ info->cmdline, info->pid, info->user, "FDS",
"", "", "", "", msg);
goto out;
}
@@ -159,12 +167,26 @@
{
int fd;
struct pid_info_t info;
+ struct stat pidstat;
+ struct passwd *pw;
+
info.pid = pid;
-
snprintf(info.path, sizeof(info.path), "/proc/%d/", pid);
-
info.parent_length = strlen(info.path);
+ // Get the UID by calling stat on the proc/pid directory.
+ if (!stat(info.path, &pidstat)) {
+ pw = getpwuid(pidstat.st_uid);
+ if (pw) {
+ strncpy(info.user, pw->pw_name, USER_DISPLAY_MAX - 1);
+ info.user[USER_DISPLAY_MAX - 1] = '\0';
+ } else {
+ snprintf(info.user, USER_DISPLAY_MAX, "%d", (int)pidstat.st_uid);
+ }
+ } else {
+ strcpy(info.user, "???");
+ }
+
// Read the command line information; each argument is terminated with NULL.
strncat(info.path, "cmdline", sizeof(info.path));
fd = open(info.path, O_RDONLY);
@@ -219,7 +241,7 @@
continue;
// Only inspect directories that are PID numbers
- pid = strtol(de->d_name, &endptr, 10);
+ pid = strtol(de->d_name, &endptr, 10);
if (*endptr != '\0')
continue;
diff --git a/toolbox/mount.c b/toolbox/mount.c
index 82ecc56..27cf3c9 100644
--- a/toolbox/mount.c
+++ b/toolbox/mount.c
@@ -15,8 +15,8 @@
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-// FIXME - only one loop mount is supported at a time
-#define LOOP_DEVICE "/dev/block/loop0"
+#define DEFAULT_LOOP_DEVICE "/dev/block/loop0"
+#define LOOPDEV_MAXLEN 64
struct mount_opts {
const char str[8];
@@ -87,7 +87,7 @@
}
static unsigned long
-parse_mount_options(char *arg, unsigned long rwflag, struct extra_opts *extra, int* loop)
+parse_mount_options(char *arg, unsigned long rwflag, struct extra_opts *extra, int* loop, char *loopdev)
{
char *s;
@@ -100,8 +100,15 @@
if (no)
s += 2;
+ if (strncmp(s, "loop=", 5) == 0) {
+ *loop = 1;
+ strlcpy(loopdev, s + 5, LOOPDEV_MAXLEN);
+ continue;
+ }
+
if (strcmp(s, "loop") == 0) {
*loop = 1;
+ strlcpy(loopdev, DEFAULT_LOOP_DEVICE, LOOPDEV_MAXLEN);
continue;
}
for (i = 0, res = 1; i < ARRAY_SIZE(options); i++) {
@@ -131,7 +138,8 @@
static unsigned long rwflag;
static int
-do_mount(char *dev, char *dir, char *type, unsigned long rwflag, void *data, int loop)
+do_mount(char *dev, char *dir, char *type, unsigned long rwflag, void *data, int loop,
+ char *loopdev)
{
char *s;
int error = 0;
@@ -142,14 +150,13 @@
flags = (rwflag & MS_RDONLY) ? O_RDONLY : O_RDWR;
- // FIXME - only one loop mount supported at a time
file_fd = open(dev, flags);
- if (file_fd < -1) {
+ if (file_fd < 0) {
perror("open backing file failed");
return 1;
}
- device_fd = open(LOOP_DEVICE, flags);
- if (device_fd < -1) {
+ device_fd = open(loopdev, flags);
+ if (device_fd < 0) {
perror("open loop device failed");
close(file_fd);
return 1;
@@ -163,7 +170,7 @@
close(file_fd);
close(device_fd);
- dev = LOOP_DEVICE;
+ dev = loopdev;
}
while ((s = strsep(&type, ",")) != NULL) {
@@ -268,6 +275,7 @@
char *dir = NULL;
int c;
int loop = 0;
+ char loopdev[LOOPDEV_MAXLEN];
progname = argv[0];
rwflag = MS_VERBOSE;
@@ -281,7 +289,7 @@
break;
switch (c) {
case 'o':
- rwflag = parse_mount_options(optarg, rwflag, &extra, &loop);
+ rwflag = parse_mount_options(optarg, rwflag, &extra, &loop, loopdev);
break;
case 'r':
rwflag |= MS_RDONLY;
@@ -319,6 +327,6 @@
exit(1);
}
- return do_mount(dev, dir, type, rwflag, extra.str, loop);
+ return do_mount(dev, dir, type, rwflag, extra.str, loop, loopdev);
/* We leak dev and dir in some cases, but we're about to exit */
}
diff --git a/toolbox/start.c b/toolbox/start.c
index 3bd9fbb..665a941 100644
--- a/toolbox/start.c
+++ b/toolbox/start.c
@@ -8,13 +8,14 @@
int start_main(int argc, char *argv[])
{
char buf[1024];
+
if(argc > 1) {
property_set("ctl.start", argv[1]);
} else {
- /* default to "start zygote" "start runtime" */
+ /* defaults to starting the common services stopped by stop.c */
+ property_set("ctl.start", "surfaceflinger");
property_set("ctl.start", "zygote");
- property_set("ctl.start", "runtime");
}
-
+
return 0;
}
diff --git a/toolbox/stop.c b/toolbox/stop.c
index 05baffd..460f377 100644
--- a/toolbox/stop.c
+++ b/toolbox/stop.c
@@ -10,11 +10,10 @@
if(argc > 1) {
property_set("ctl.stop", argv[1]);
} else{
- /* default to "stop runtime" "stop zygote" */
- property_set("ctl.stop", "runtime");
+ /* defaults to stopping the common services */
property_set("ctl.stop", "zygote");
+ property_set("ctl.stop", "surfaceflinger");
}
return 0;
}
-
diff --git a/toolbox/touch.c b/toolbox/touch.c
new file mode 100644
index 0000000..b8ab310
--- /dev/null
+++ b/toolbox/touch.c
@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+static void usage(void)
+{
+ fprintf(stderr, "touch: usage: touch [-alm] [-t time_t] <file>\n");
+ exit(1);
+}
+
+int touch_main(int argc, char *argv[])
+{
+ int i, fd, aflag = 0, mflag = 0, debug = 0, flags = 0;
+ struct timespec specified_time, times[2];
+ char *file = 0;
+
+ specified_time.tv_nsec = UTIME_NOW;
+
+ for (i = 1; i < argc; i++) {
+ if (argv[i][0] == '-') {
+ /* an option */
+ const char *arg = argv[i]+1;
+ while (arg[0]) {
+ switch (arg[0]) {
+ case 'a': aflag = 1; break;
+ case 'm': mflag = 1; break;
+ case 't':
+ if ((i+1) >= argc)
+ usage();
+ specified_time.tv_sec = atol(argv[++i]);
+ if (specified_time.tv_sec == 0) {
+ fprintf(stderr, "touch: invalid time_t\n");
+ exit(1);
+ }
+ specified_time.tv_nsec = 0;
+ break;
+ case 'l': flags |= AT_SYMLINK_NOFOLLOW; break;
+ case 'd': debug = 1; break;
+ default:
+ usage();
+ }
+ arg++;
+ }
+ } else {
+ /* not an option, and only accept one filename */
+ if (i+1 != argc)
+ usage();
+ file = argv[i];
+ }
+ }
+
+ if (! file) {
+ fprintf(stderr, "touch: no file specified\n");
+ exit(1);
+ }
+
+ if (access(file, F_OK))
+ if ((fd=creat(file, 0666)) != -1)
+ close(fd);
+
+ if ((mflag == 0) && (aflag == 0))
+ aflag = mflag = 1;
+
+ if (aflag)
+ times[0] = specified_time;
+ else
+ times[0].tv_nsec = UTIME_OMIT;
+
+ if (mflag)
+ times[1] = specified_time;
+ else
+ times[1].tv_nsec = UTIME_OMIT;
+
+ if (debug) {
+ fprintf(stderr, "file = %s\n", file);
+ fprintf(stderr, "times[0].tv_sec = %ld, times[0].tv_nsec = %ld\n", times[0].tv_sec, times[0].tv_nsec);
+ fprintf(stderr, "times[1].tv_sec = %ld, times[1].tv_nsec = %ld\n", times[1].tv_sec, times[1].tv_nsec);
+ fprintf(stderr, "flags = 0x%8.8x\n", flags);
+ }
+
+ return utimensat(AT_FDCWD, file, times, flags);
+}
+
diff --git a/toolbox/umount.c b/toolbox/umount.c
index 92c6076..890e870 100644
--- a/toolbox/umount.c
+++ b/toolbox/umount.c
@@ -6,11 +6,26 @@
#include <string.h>
#include <unistd.h>
#include <linux/loop.h>
+#include <errno.h>
-// FIXME - only one loop mount is supported at a time
-#define LOOP_DEVICE "/dev/block/loop0"
+#define LOOPDEV_MAXLEN 64
+#define LOOP_MAJOR 7
-static int is_loop_mount(const char* path)
+static int is_loop(char *dev)
+{
+ struct stat st;
+ int ret = 0;
+
+ if (stat(dev, &st) == 0) {
+ if (S_ISBLK(st.st_mode) && (major(st.st_rdev) == LOOP_MAJOR)) {
+ ret = 1;
+ }
+ }
+
+ return ret;
+}
+
+static int is_loop_mount(const char* path, char *loopdev)
{
FILE* f;
int count;
@@ -22,14 +37,15 @@
f = fopen("/proc/mounts", "r");
if (!f) {
- fprintf(stdout, "could not open /proc/mounts\n");
+ fprintf(stdout, "could not open /proc/mounts: %s\n", strerror(errno));
return -1;
}
do {
count = fscanf(f, "%255s %255s %255s\n", device, mount_path, rest);
if (count == 3) {
- if (strcmp(LOOP_DEVICE, device) == 0 && strcmp(path, mount_path) == 0) {
+ if (is_loop(device) && strcmp(path, mount_path) == 0) {
+ strlcpy(loopdev, device, LOOPDEV_MAXLEN);
result = 1;
break;
}
@@ -43,27 +59,28 @@
int umount_main(int argc, char *argv[])
{
int loop, loop_fd;
-
+ char loopdev[LOOPDEV_MAXLEN];
+
if(argc != 2) {
fprintf(stderr,"umount <path>\n");
return 1;
}
- loop = is_loop_mount(argv[1]);
- if(umount(argv[1])){
- fprintf(stderr,"failed.\n");
+ loop = is_loop_mount(argv[1], loopdev);
+ if (umount(argv[1])) {
+ fprintf(stderr, "failed: %s\n", strerror(errno));
return 1;
}
if (loop) {
// free the loop device
- loop_fd = open(LOOP_DEVICE, O_RDONLY);
- if (loop_fd < -1) {
- perror("open loop device failed");
+ loop_fd = open(loopdev, O_RDONLY);
+ if (loop_fd < 0) {
+ fprintf(stderr, "open loop device failed: %s\n", strerror(errno));
return 1;
}
if (ioctl(loop_fd, LOOP_CLR_FD, 0) < 0) {
- perror("ioctl LOOP_CLR_FD failed");
+ fprintf(stderr, "ioctl LOOP_CLR_FD failed: %s\n", strerror(errno));
return 1;
}