int local_name_to_fd(const char *name) { int port; if(!strncmp("tcp:", name, 4)){ int ret; port = atoi(name + 4); ret = socket_loopback_server(port, SOCK_STREAM); return ret; } #ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */ // It's non-sensical to support the "reserved" space on the adb host side if(!strncmp(name, "local:", 6)) { return socket_local_server(name + 6, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); } else if(!strncmp(name, "localabstract:", 14)) { return socket_local_server(name + 14, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); } else if(!strncmp(name, "localfilesystem:", 16)) { return socket_local_server(name + 16, ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM); } #endif printf("unknown local portname '%s'\n", name); return -1; }
static int do_server() { int s; 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(SIGPIPE, SIG_DFL); #ifdef SIGSTKFLT signal(SIGSTKFLT, SIG_DFL); #endif logsocket = socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM); if(logsocket < 0) { logsocket = -1; } else { fcntl(logsocket, F_SETFD, FD_CLOEXEC); } act.sa_handler = SIG_DFL; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask,SIGCHLD); act.sa_flags = SA_NOCLDWAIT; sigaction(SIGCHLD, &act, 0); s = socket_local_server(DEBUGGER_SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); if(s < 0) return 1; fcntl(s, F_SETFD, FD_CLOEXEC); LOG("debuggerd: " __DATE__ " " __TIME__ "\n"); for(;;) { struct sockaddr addr; socklen_t alen; int fd; alen = sizeof(addr); XLOG("waiting for connection\n"); fd = accept(s, &addr, &alen); if(fd < 0) { XLOG("accept failed: %s\n", strerror(errno)); continue; } fcntl(fd, F_SETFD, FD_CLOEXEC); handle_request(fd); } return 0; }
static int do_server() { // debuggerd crashes can't be reported to debuggerd. // Reset all of the crash handlers. signal(SIGABRT, SIG_DFL); signal(SIGBUS, SIG_DFL); signal(SIGFPE, SIG_DFL); signal(SIGILL, SIG_DFL); signal(SIGSEGV, SIG_DFL); #ifdef SIGSTKFLT signal(SIGSTKFLT, SIG_DFL); #endif signal(SIGTRAP, SIG_DFL); // Ignore failed writes to closed sockets signal(SIGPIPE, SIG_IGN); int logsocket = socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM); if (logsocket < 0) { logsocket = -1; } else { fcntl(logsocket, F_SETFD, FD_CLOEXEC); } struct sigaction act; act.sa_handler = SIG_DFL; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask,SIGCHLD); act.sa_flags = SA_NOCLDWAIT; sigaction(SIGCHLD, &act, 0); int s = socket_local_server(SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); if (s < 0) return 1; fcntl(s, F_SETFD, FD_CLOEXEC); ALOGI("debuggerd: starting\n"); for (;;) { sockaddr_storage ss; sockaddr* addrp = reinterpret_cast<sockaddr*>(&ss); socklen_t alen = sizeof(ss); ALOGV("waiting for connection\n"); int fd = accept(s, addrp, &alen); if (fd < 0) { ALOGV("accept failed: %s\n", strerror(errno)); continue; } fcntl(fd, F_SETFD, FD_CLOEXEC); handle_request(fd); } return 0; }
int CommandListener::getLogSocket() { static const char socketName[] = "logd"; int sock = android_get_control_socket(socketName); if (sock < 0) { sock = socket_local_server(socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM); } return sock; }
int LogReader::getLogSocket() { static const char socketName[] = "logdr"; int sock = android_get_control_socket(socketName); if (sock < 0) { sock = socket_local_server(socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET); } return sock; }
static int do_server() { // debuggerd crashes can't be reported to debuggerd. // Reset all of the crash handlers. signal(SIGABRT, SIG_DFL); signal(SIGBUS, SIG_DFL); signal(SIGFPE, SIG_DFL); signal(SIGILL, SIG_DFL); signal(SIGSEGV, SIG_DFL); #ifdef SIGSTKFLT signal(SIGSTKFLT, SIG_DFL); #endif signal(SIGTRAP, SIG_DFL); // Ignore failed writes to closed sockets signal(SIGPIPE, SIG_IGN); // Block SIGCHLD so we can sigtimedwait for it. sigset_t sigchld; sigemptyset(&sigchld); sigaddset(&sigchld, SIGCHLD); sigprocmask(SIG_SETMASK, &sigchld, nullptr); int s = socket_local_server(SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM | SOCK_CLOEXEC); if (s == -1) return 1; // Fork a process that stays root, and listens on a pipe to pause and resume the target. if (!start_signal_sender()) { ALOGE("debuggerd: failed to fork signal sender"); return 1; } ALOGI("debuggerd: starting\n"); for (;;) { sockaddr_storage ss; sockaddr* addrp = reinterpret_cast<sockaddr*>(&ss); socklen_t alen = sizeof(ss); ALOGV("waiting for connection\n"); int fd = accept4(s, addrp, &alen, SOCK_CLOEXEC); if (fd == -1) { ALOGE("accept failed: %s\n", strerror(errno)); continue; } handle_request(fd); } return 0; }
int LogListener::getLogSocket() { static const char socketName[] = "logdw"; int sock = android_get_control_socket(socketName); if (sock < 0) { sock = socket_local_server(socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_DGRAM); } int on = 1; if (setsockopt(sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)) < 0) { return -1; } return sock; }
int main(int argc, char **argv) { int s; struct sigaction act; process_name_ptr = argv; logsocket = socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM); if(logsocket < 0) { logsocket = -1; } else { fcntl(logsocket, F_SETFD, FD_CLOEXEC); } act.sa_handler = SIG_DFL; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask,SIGCHLD); act.sa_flags = SA_NOCLDWAIT; sigaction(SIGCHLD, &act, 0); s = socket_local_server("android:debuggerd", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); if(s < 0) return -1; fcntl(s, F_SETFD, FD_CLOEXEC); LOG("debuggerd: " __DATE__ " " __TIME__ "\n"); for(;;) { struct sockaddr addr; socklen_t alen; int fd; alen = sizeof(addr); fd = accept(s, &addr, &alen); if(fd < 0) continue; fcntl(fd, F_SETFD, FD_CLOEXEC); handle_crashing_process(fd); } return 0; }
int main(void) { int fd; int cfd; int rc; int clen; char buf[50]; char status[] = { 0x08, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; struct sockaddr_un caddr; fd = socket_local_server("gps", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET); listen(fd, 1); printf("socket_local_server passed: %d\n", fd); cfd = accept(fd, 0, &clen); printf("accept passed: %d\n", cfd); fd_set fds; FD_ZERO(&fds); FD_SET(cfd, &fds); while(1) { memset(buf, 0, sizeof(buf)); select(cfd+1, &fds, NULL, NULL, NULL); rc = read(cfd, buf, 50); printf("read %d bytes!\n", rc); if(rc == 50) { write(cfd, status, sizeof(status)); printf("wrote %d bytes!\n", sizeof(status)); } } return 0; }
static jboolean initServiceNative(JNIEnv* env, jobject object) { native_data_t* nat = NULL; HID_LOG("initServiceNative Enter"); // jvm env->GetJavaVM(&g_jvm); /* Find class structure */ jclass clazz = env->FindClass("com/mediatek/bluetooth/hid/BluetoothHidService"); if (clazz == NULL) { HID_ERR("FindClass failed"); goto init_fail; } g_object = env->NewGlobalRef(object); g_service_object = (jobject*) calloc(1, sizeof(jobject)); if (g_service_object == NULL) { HID_ERR("Allocate g_service_object: out of memory"); goto init_fail; } //memset(g_service_object, 0, sizeof(jobject)); memcpy(g_service_object, &object, sizeof(jobject)); /* Retrieve the method id and field id */ sendServiceMsg = env->GetMethodID(clazz, "sendServiceMsg", "(ILjava/lang/String;)V"); m_native_data = env->GetFieldID(clazz, "mNativeData", "I"); /* Allocate nat and store its address in object field */ nat = (native_data_t*) calloc(1, sizeof(native_data_t)); if (nat == NULL) { HID_ERR("Allocate nat: out of memory"); goto init_fail; } memset(nat, 0, sizeof(native_data_t)); env->SetIntField(object, m_native_data, (jint) nat); /* Create the socket */ nat->servsock = socket_local_server(BT_SOCK_NAME_EXT_ADP_HID, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM); if (nat->servsock < 0) { HID_ERR("Create receiving socket failed : %s, errno=%d", strerror(errno), errno); goto init_fail; } if(bt_hid_init_socket()==0){ HID_ERR("Create sending socket failed"); goto init_fail; } HID_LOG("initServiceNative Succeeded"); return JNI_TRUE; init_fail: if (nat) { free(nat); env->SetIntField(object, m_native_data, 0); } HID_ERR("Failed"); return JNI_FALSE; }