int main(void) { find_bcd_device(); struct sock_func *sf; ALOGI("Xmosd started"); hub_func.hubfd = preprocess(); if (hub_func.hubfd < 0) { ALOGE("preprocess failed"); return -1; } sf = &sock_funcs; while (sf->socket) { sf->fd = android_get_control_socket(sf->socket); if (listen(sf->fd, 4) < 0) { perror("listen"); return -1; } sf++; } event_handler((struct sock_func *)&sock_funcs); return 0; }
int SocketListener::startListener() { if (!mSocketName && mSock == -1) { SLOGE("Failed to start unbound listener"); errno = EINVAL; return -1; } else if (mSocketName) { if ((mSock = android_get_control_socket(mSocketName)) < 0) { SLOGE("Obtaining file descriptor socket '%s' failed: %s", mSocketName, strerror(errno)); return -1; } } if (mListen && listen(mSock, 4) < 0) { SLOGE("Unable to listen on socket (%s)", strerror(errno)); return -1; } else if (!mListen) mClients->push_back(new SocketClient(mSock)); if (pipe(mCtrlPipe)) { SLOGE("pipe failed (%s)", strerror(errno)); return -1; } if (pthread_create(&mThread, NULL, SocketListener::threadStart, this)) { SLOGE("pthread_create (%s)", strerror(errno)); return -1; } return 0; }
int SocketListener::startListener(int backlog) { if (!mSocketName && mSock == -1) { SLOGE("Failed to start unbound listener"); errno = EINVAL; return -1; } else if (mSocketName) { if ((mSock = android_get_control_socket(mSocketName)) < 0) { SLOGE("Obtaining file descriptor socket '%s' failed: %s", mSocketName, strerror(errno)); return -1; } SLOGV("got mSock = %d for %s", mSock, mSocketName); fcntl(mSock, F_SETFD, FD_CLOEXEC); } if (mListen && listen(mSock, backlog) < 0) { SLOGE("Unable to listen on socket (%s)", strerror(errno)); return -1; } else if (!mListen) mClients->push_back(new SocketClient(mSock, false, mUseCmdNum)); if (pipe(mCtrlPipe)) { SLOGE("pipe failed (%s)", strerror(errno)); return -1; } if (pthread_create(&mThread, NULL, SocketListener::threadStart, this)) { SLOGE("pthread_create (%s)", strerror(errno)); return -1; } return 0; }
int main(const int argc, const char *argv[]) { char buf[BUFFER_MAX]; struct sockaddr addr; socklen_t alen; int lsocket, s, count; if (initialize_globals() < 0) { LOGE("Could not initialize globals; exiting.\n"); exit(1); } if (initialize_directories() < 0) { LOGE("Could not create directories; exiting.\n"); exit(1); } lsocket = android_get_control_socket(SOCKET_PATH); if (lsocket < 0) { LOGE("Failed to get socket from environment: %s\n", strerror(errno)); exit(1); } if (listen(lsocket, 5)) { LOGE("Listen on socket failed: %s\n", strerror(errno)); exit(1); } fcntl(lsocket, F_SETFD, FD_CLOEXEC); for (;;) { alen = sizeof(addr); s = accept(lsocket, &addr, &alen); if (s < 0) { LOGE("Accept failed: %s\n", strerror(errno)); continue; } fcntl(s, F_SETFD, FD_CLOEXEC); LOGI("new connection\n"); for (;;) { unsigned short count; if (readx(s, &count, sizeof(count))) { LOGE("failed to read size\n"); break; } if ((count < 1) || (count >= BUFFER_MAX)) { LOGE("invalid size %d\n", count); break; } if (readx(s, buf, count)) { LOGE("failed to read command\n"); break; } buf[count] = 0; if (execute(s, buf)) break; } LOGI("closing connection\n"); close(s); } return 0; }
void adbd_cloexec_auth_socket() { int fd = android_get_control_socket("adbd"); if (fd == -1) { PLOG(ERROR) << "Failed to get adbd socket"; return; } fcntl(fd, F_SETFD, FD_CLOEXEC); }
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 android_get_control_and_arguments(int *argc, char ***argv) { static char *args[32]; int control; int i; atexit(notify_death); if ((i = android_get_control_socket("racoon")) == -1) { return -1; } do_plog(LLV_DEBUG, "Waiting for control socket"); if (listen(i, 1) == -1 || (control = accept(i, NULL, 0)) == -1) { do_plog(LLV_ERROR, "Cannot get control socket"); exit(1); } close(i); fcntl(control, F_SETFD, FD_CLOEXEC); args[0] = (*argv)[0]; for (i = 1; i < 32; ++i) { unsigned char bytes[2]; if (recv(control, &bytes[0], 1, 0) != 1 || recv(control, &bytes[1], 1, 0) != 1) { do_plog(LLV_ERROR, "Cannot get argument length"); exit(1); } else { int length = bytes[0] << 8 | bytes[1]; int offset = 0; if (length == 0xFFFF) { break; } args[i] = malloc(length + 1); while (offset < length) { int n = recv(control, &args[i][offset], length - offset, 0); if (n > 0) { offset += n; } else { do_plog(LLV_ERROR, "Cannot get argument value"); exit(1); } } args[i][length] = 0; } } do_plog(LLV_DEBUG, "Received %d arguments", i - 1); *argc = i; *argv = args; return control; }
void adbd_auth_init(void) { int fd = android_get_control_socket("adbd"); if (fd == -1) { PLOG(ERROR) << "Failed to get adbd socket"; return; } if (listen(fd, 4) == -1) { PLOG(ERROR) << "Failed to listen on '" << fd << "'"; return; } listener_fde = fdevent_create(fd, adbd_auth_listener, nullptr); fdevent_add(listener_fde, FDE_READ); }
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 open_control(void) { int i; if ((i = android_get_control_socket("openconnect")) == -1) { android_log(PRG_ERR, "No control socket"); return -1; } android_log(PRG_DEBUG, "Waiting for control socket"); if (listen(i, 1) == -1 || (control = accept(i, NULL, 0)) == -1) { android_log(PRG_ERR, "Cannot get control socket"); exit(-1); } close(i); return control; }
static int srv_create_sk() { int lsocket; info_sys("Get socket from Android env!"); lsocket = android_get_control_socket(SOCKET_PATH); if (lsocket < 0){ debug_sys("Failed to get socket from environment"); return -1; } if (listen(lsocket, QBACKLOG)) { debug_sys("Listen on socket failed"); return -1; } fcntl(lsocket, F_SETFD, FD_CLOEXEC); return lsocket; }
status_t HDMIDaemon::readyToRun() { if ((mFrameworkSock = android_get_control_socket(HDMI_SOCKET_NAME)) < 0) { LOGE("Obtaining file descriptor socket '%s' failed: %s", HDMI_SOCKET_NAME, strerror(errno)); return -1; } if (listen(mFrameworkSock, 4) < 0) { LOGE("Unable to listen on fd '%d' for socket '%s': %s", mFrameworkSock, HDMI_SOCKET_NAME, strerror(errno)); return -1; } struct sockaddr_nl nladdr; memset(&nladdr, 0, sizeof(nladdr)); nladdr.nl_family = AF_NETLINK; nladdr.nl_pid = getpid(); nladdr.nl_groups = 0xffffffff; if ((mUeventSock = socket(PF_NETLINK, SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) { LOGE("Unable to create uevent socket: %s", strerror(errno)); return -1; } int uevent_sz = 64 * 1024; if (setsockopt(mUeventSock, SOL_SOCKET, SO_RCVBUFFORCE, &uevent_sz, sizeof(uevent_sz)) < 0) { LOGE("Unable to set uevent socket options: %s", strerror(errno)); return -1; } if (bind(mUeventSock, (struct sockaddr *) &nladdr, sizeof(nladdr)) < 0) { LOGE("Unable to bind uevent socket: %s", strerror(errno)); return -1; } LOGD("readyToRun: success"); return NO_ERROR; }
status_t HDMIDaemon::readyToRun() { if ((mFrameworkSock = android_get_control_socket(HDMI_SOCKET_NAME)) < 0) { ALOGE("Obtaining file descriptor socket '%s' failed: %s", HDMI_SOCKET_NAME, strerror(errno)); return -1; } if (listen(mFrameworkSock, 4) < 0) { ALOGE("Unable to listen on fd '%d' for socket '%s': %s", mFrameworkSock, HDMI_SOCKET_NAME, strerror(errno)); return -1; } mUeventSock = hdmi_init(0); hdmi_enable(); ALOGD("readyToRun: success"); return NO_ERROR; }
/* redirect output to a service control socket */ void redirect_to_socket(FILE *redirect, const char *service) { int s = android_get_control_socket(service); if (s < 0) { fprintf(stderr, "android_get_control_socket(%s): %s\n", service, strerror(errno)); exit(1); } if (listen(s, 4) < 0) { fprintf(stderr, "listen(control socket): %s\n", strerror(errno)); exit(1); } struct sockaddr addr; socklen_t alen = sizeof(addr); int fd = accept(s, &addr, &alen); if (fd < 0) { fprintf(stderr, "accept(control socket): %s\n", strerror(errno)); exit(1); } fflush(redirect); dup2(fd, fileno(redirect)); close(fd); }
int main(int argc, char **argv) { int door_sock = -1; int uevent_sock = -1; struct sockaddr_nl nladdr; int uevent_sz = 64 * 1024; LOGI("Android Display Daemon version %d.%d", ver_major, ver_minor); /* * Create all the various sockets we'll need */ // Socket to listen on for incomming framework connections if ((door_sock = android_get_control_socket(DISPD_SOCKET)) < 0) { LOGE("Obtaining file descriptor socket '%s' failed: %s", DISPD_SOCKET, strerror(errno)); exit(1); } if (listen(door_sock, 4) < 0) { LOGE("Unable to listen on fd '%d' for socket '%s': %s", door_sock, DISPD_SOCKET, strerror(errno)); exit(1); } mkdir("/dev/block/dispd", 0755); // Socket to listen on for uevent changes memset(&nladdr, 0, sizeof(nladdr)); nladdr.nl_family = AF_NETLINK; nladdr.nl_pid = getpid(); nladdr.nl_groups = 0xffffffff; if ((uevent_sock = socket(PF_NETLINK, SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) { LOGE("Unable to create uevent socket: %s", strerror(errno)); exit(1); } if (setsockopt(uevent_sock, SOL_SOCKET, SO_RCVBUFFORCE, &uevent_sz, sizeof(uevent_sz)) < 0) { LOGE("Unable to set uevent socket options: %s", strerror(errno)); exit(1); } if (bind(uevent_sock, (struct sockaddr *) &nladdr, sizeof(nladdr)) < 0) { LOGE("Unable to bind uevent socket: %s", strerror(errno)); exit(1); } /* * Bootstrap */ bootstrap = 1; // Switch switch_bootstrap(); dvi_detection_bootstrap(); hdmi_detection_bootstrap(); bootstrap = 0; /* * Main loop */ LOG_DISP("Bootstrapping complete"); while(1) { fd_set read_fds; struct timeval to; int max = 0; int rc = 0; to.tv_sec = (60 * 60); to.tv_usec = 0; FD_ZERO(&read_fds); FD_SET(door_sock, &read_fds); if (door_sock > max) max = door_sock; FD_SET(uevent_sock, &read_fds); if (uevent_sock > max) max = uevent_sock; if (fw_sock != -1) { FD_SET(fw_sock, &read_fds); if (fw_sock > max) max = fw_sock; } if ((rc = select(max + 1, &read_fds, NULL, NULL, &to)) < 0) { LOGE("select() failed (%s)", strerror(errno)); sleep(1); continue; } if (!rc) { continue; } if (FD_ISSET(door_sock, &read_fds)) { struct sockaddr addr; socklen_t alen; alen = sizeof(addr); if (fw_sock != -1) { LOGE("Dropping duplicate framework connection"); int tmp = accept(door_sock, &addr, &alen); close(tmp); continue; } if ((fw_sock = accept(door_sock, &addr, &alen)) < 0) { LOGE("Unable to accept framework connection (%s)", strerror(errno)); } LOG_DISP("Accepted connection from framework"); //Send the states whether the disp already been connected through fw_sock if ((rc = dispmgr_send_status()) < 0) { LOGE("Unable to send dispmgr status to framework (%d)", rc); } } if (FD_ISSET(fw_sock, &read_fds)) { LOG_DISP("process cmd from framework"); if ((rc = process_framework_command(fw_sock)) < 0) { if (rc == -ECONNRESET) { LOGE("Framework disconnected"); close(fw_sock); fw_sock = -1; } else { LOGE("Error processing framework command (%s)", strerror(errno)); } } } if (FD_ISSET(uevent_sock, &read_fds)) { //LOG_DISP("process uevent from kernel"); if ((rc = process_uevent_message(uevent_sock)) < 0) { LOGE("Error processing uevent msg (%s)", strerror(errno)); } } } // while }
void initSocket(){ int ret = 0; //Initalize the ATCI socket for native ATCI service s_fdAtci_generic_listen = android_get_control_socket(SOCKET_NAME_ATCI); if (s_fdAtci_generic_listen < 0) { LOGE("Failed to get socket '" SOCKET_NAME_ATCI "' erron:%d", errno); }else{ ret = listen(s_fdAtci_generic_listen, 4); if (ret < 0) { LOGE("Failed to listen on control socket '%d': %s", s_fdAtci_generic_listen, strerror(errno)); } } //Initialize the ATCI framework for framework ATCI service s_fdAtci_mmi_listen = android_get_control_socket(SOCKET_NAME_ATCI_FRAMEWORK); if (s_fdAtci_generic_listen < 0) { LOGE("Failed to get socket '" SOCKET_NAME_ATCI_FRAMEWORK "' erron:%d", errno); }else{ ret = listen(s_fdAtci_mmi_listen, 4); if (ret < 0) { LOGE("Failed to listen on control socket on framework '%d': %s", s_fdAtci_generic_listen, strerror(errno)); } } while(1){ if(pthread_cond_init(&start_atci_mmi_thread_cond, NULL)){ if (errno == EAGAIN){ LOGE("mmi cond init fail for EAGAIN"); continue; } else{ LOGE("mmi cond init fail, have to exit"); exit(-1); } } break; } while(1){ if(pthread_cond_init(&start_atci_thread_cond, NULL)){ if (errno == EAGAIN){ LOGE("atci cond init fail for EAGAIN"); continue; } else{ LOGE("atci cond init fail, have to exit"); exit(-1); } } break; } while(1){ if(pthread_mutex_init(&start_atci_data_thread_mutex, NULL)){ if (errno == EAGAIN){ LOGE("atci mutex init fail for EAGAIN"); continue; } else{ LOGE("atci mutex init fail, have to exit"); exit(-1); } } break; } while(1){ if(pthread_mutex_init(&start_atci_mmi_data_thread_mutex, NULL)){ if (errno == EAGAIN){ LOGE("atci mmi mutex init fail for EAGAIN"); continue; } else{ LOGE("atci mmi mutex init fail, have to exit"); exit(-1); } } break; } }
struct ctrl_iface_priv * wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s) { struct ctrl_iface_priv *priv; struct sockaddr_un addr; char *fname = NULL; gid_t gid = 0; int gid_set = 0; char *buf, *dir = NULL, *gid_str = NULL; struct group *grp; char *endp; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) return NULL; priv->wpa_s = wpa_s; priv->sock = -1; if (wpa_s->conf->ctrl_interface == NULL) return priv; buf = os_strdup(wpa_s->conf->ctrl_interface); if (buf == NULL) goto fail; #ifdef ANDROID os_snprintf(addr.sun_path, sizeof(addr.sun_path), "wpa_%s", wpa_s->conf->ctrl_interface); priv->sock = android_get_control_socket(addr.sun_path); if (priv->sock >= 0) goto havesock; #endif if (os_strncmp(buf, "DIR=", 4) == 0) { dir = buf + 4; gid_str = os_strstr(dir, " GROUP="); if (gid_str) { *gid_str = '\0'; gid_str += 7; } } else { dir = buf; gid_str = wpa_s->conf->ctrl_interface_group; } if (mkdir(dir, S_IRWXU | S_IRWXG) < 0) { if (errno == EEXIST) { wpa_printf(MSG_DEBUG, "Using existing control " "interface directory."); } else { perror("mkdir[ctrl_interface]"); goto fail; } } if (gid_str) { grp = getgrnam(gid_str); if (grp) { gid = grp->gr_gid; gid_set = 1; wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d" " (from group name '%s')", (int) gid, gid_str); } else { /* Group name not found - try to parse this as gid */ gid = strtol(gid_str, &endp, 10); if (*gid_str == '\0' || *endp != '\0') { wpa_printf(MSG_ERROR, "CTRL: Invalid group " "'%s'", gid_str); goto fail; } gid_set = 1; wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d", (int) gid); } } if (gid_set && chown(dir, -1, gid) < 0) { perror("chown[ctrl_interface]"); goto fail; } if (os_strlen(dir) + 1 + os_strlen(wpa_s->ifname) >= sizeof(addr.sun_path)) goto fail; priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0); if (priv->sock < 0) { perror("socket(PF_UNIX)"); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; fname = wpa_supplicant_ctrl_iface_path(wpa_s); if (fname == NULL) goto fail; os_strncpy(addr.sun_path, fname, sizeof(addr.sun_path)); if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s", strerror(errno)); if (connect(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not" " allow connections - assuming it was left" "over from forced program termination"); if (unlink(fname) < 0) { perror("unlink[ctrl_iface]"); wpa_printf(MSG_ERROR, "Could not unlink " "existing ctrl_iface socket '%s'", fname); goto fail; } if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind(PF_UNIX)"); goto fail; } wpa_printf(MSG_DEBUG, "Successfully replaced leftover " "ctrl_iface socket '%s'", fname); } else { wpa_printf(MSG_INFO, "ctrl_iface exists and seems to " "be in use - cannot override it"); wpa_printf(MSG_INFO, "Delete '%s' manually if it is " "not used anymore", fname); os_free(fname); fname = NULL; goto fail; } } if (gid_set && chown(fname, -1, gid) < 0) { perror("chown[ctrl_interface/ifname]"); goto fail; } if (chmod(fname, S_IRWXU | S_IRWXG) < 0) { perror("chmod[ctrl_interface/ifname]"); goto fail; } os_free(fname); havesock: eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive, wpa_s, priv); wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb); os_free(buf); return priv; fail: if (priv->sock >= 0) close(priv->sock); os_free(priv); if (fname) { unlink(fname); os_free(fname); } os_free(buf); return NULL; }
struct ctrl_iface_global_priv * wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global) { struct ctrl_iface_global_priv *priv; struct sockaddr_un addr; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) return NULL; priv->global = global; priv->sock = -1; if (global->params.ctrl_interface == NULL) return priv; #ifdef ANDROID priv->sock = android_get_control_socket(global->params.ctrl_interface); if (priv->sock >= 0) goto havesock; #endif wpa_printf(MSG_DEBUG, "Global control interface '%s'", global->params.ctrl_interface); priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0); if (priv->sock < 0) { perror("socket(PF_UNIX)"); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; os_strncpy(addr.sun_path, global->params.ctrl_interface, sizeof(addr.sun_path)); if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind(PF_UNIX)"); if (connect(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not" " allow connections - assuming it was left" "over from forced program termination"); if (unlink(global->params.ctrl_interface) < 0) { perror("unlink[ctrl_iface]"); wpa_printf(MSG_ERROR, "Could not unlink " "existing ctrl_iface socket '%s'", global->params.ctrl_interface); goto fail; } if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind(PF_UNIX)"); goto fail; } wpa_printf(MSG_DEBUG, "Successfully replaced leftover " "ctrl_iface socket '%s'", global->params.ctrl_interface); } else { wpa_printf(MSG_INFO, "ctrl_iface exists and seems to " "be in use - cannot override it"); wpa_printf(MSG_INFO, "Delete '%s' manually if it is " "not used anymore", global->params.ctrl_interface); goto fail; } } havesock: eloop_register_read_sock(priv->sock, wpa_supplicant_global_ctrl_iface_receive, global, NULL); return priv; fail: if (priv->sock >= 0) close(priv->sock); os_free(priv); return NULL; }
int main (void) { int err; struct sockaddr addr; socklen_t alen = sizeof(addr); int lsocket, s, count; char buf[C_CMD_BUF_SIZE]; MNLD_DATA_T *obj = &mnld_data; lsocket = android_get_control_socket(SOCKET_MNL); if (lsocket < 0) { MND_ERR("fail to get socket from environment: %s\n",strerror(errno)); exit(1); } if (listen(lsocket, 5)) { MND_ERR("listen on socket failed: %s\n", strerror(errno)); exit(1); } if (setup_signal_handler()) { MND_ERR("setup_signal_handler: %d (%s)\n", errno, strerror(errno)); exit(1); } if (mnl_init()) { MND_ERR("mnl_init: %d (%s)\n", errno, strerror(errno)); exit(1); } MND_MSG("listening..\n"); while(1) { int eof, s = accept(lsocket, &addr, &alen); if (s < 0) { MND_ERR("Accept failed!! :%s\n", strerror(errno)); continue; } obj->cur_accept_socket = s; fcntl(s, F_SETFD, FD_CLOEXEC); if (epoll_init()) { MND_ERR("epoll_init: %d (%s)\n", errno, strerror(errno)); exit(1); } MND_MSG("new connection\n"); for (;;) { err = process(); if (err == ERR_REMOTE_HANGUP) { MND_ERR("remote hangup (cleanup?), wait for new connection\n"); break; } else if (err == ERR_MNL_DIED) { MND_ERR("mnl process died, kill it\n"); kill_mnl_process(); } else if (errno == EINTR) { continue; } else if (err) { MND_ERR("process data error: %d (%s)\n", errno, strerror(errno)); } } MND_MSG("closing connection\n"); close(s); epoll_destroy(); } MND_MSG("exit mnld \n!!"); return 0; }
int main(int argc, char** argv) { enum { UNCRYPT, SETUP_BCB, CLEAR_BCB, UNCRYPT_DEBUG } action; const char* input_path = nullptr; const char* map_file = CACHE_BLOCK_MAP.c_str(); if (argc == 2 && strcmp(argv[1], "--clear-bcb") == 0) { action = CLEAR_BCB; } else if (argc == 2 && strcmp(argv[1], "--setup-bcb") == 0) { action = SETUP_BCB; } else if (argc == 1) { action = UNCRYPT; } else if (argc == 3) { input_path = argv[1]; map_file = argv[2]; action = UNCRYPT_DEBUG; } else { usage(argv[0]); return 2; } if ((fstab = read_fstab()) == nullptr) { log_uncrypt_error_code(kUncryptFstabReadError); return 1; } if (action == UNCRYPT_DEBUG) { LOG(INFO) << "uncrypt called in debug mode, skip socket communication"; bool success = uncrypt_wrapper(input_path, map_file, -1); if (success) { LOG(INFO) << "uncrypt succeeded"; } else{ LOG(INFO) << "uncrypt failed"; } return success ? 0 : 1; } // c3. The socket is created by init when starting the service. uncrypt // will use the socket to communicate with its caller. android::base::unique_fd service_socket(android_get_control_socket(UNCRYPT_SOCKET.c_str())); if (service_socket == -1) { PLOG(ERROR) << "failed to open socket \"" << UNCRYPT_SOCKET << "\""; log_uncrypt_error_code(kUncryptSocketOpenError); return 1; } fcntl(service_socket, F_SETFD, FD_CLOEXEC); if (listen(service_socket, 1) == -1) { PLOG(ERROR) << "failed to listen on socket " << service_socket.get(); log_uncrypt_error_code(kUncryptSocketListenError); return 1; } android::base::unique_fd socket_fd(accept4(service_socket, nullptr, nullptr, SOCK_CLOEXEC)); if (socket_fd == -1) { PLOG(ERROR) << "failed to accept on socket " << service_socket.get(); log_uncrypt_error_code(kUncryptSocketAcceptError); return 1; } bool success = false; switch (action) { case UNCRYPT: success = uncrypt_wrapper(input_path, map_file, socket_fd); break; case SETUP_BCB: success = setup_bcb(socket_fd); break; case CLEAR_BCB: success = clear_bcb(socket_fd); break; default: // Should never happen. LOG(ERROR) << "Invalid uncrypt action code: " << action; return 1; } // c13. Read a 4-byte code from the client before uncrypt exits. This is to // ensure the client to receive the last status code before the socket gets // destroyed. int code; if (android::base::ReadFully(socket_fd, &code, 4)) { LOG(INFO) << " received " << code << ", exiting now"; } else { PLOG(ERROR) << "failed to read the code"; } return success ? 0 : 1; }
static int wpas_ctrl_iface_open_sock(struct wpa_supplicant *wpa_s, struct ctrl_iface_priv *priv) { struct sockaddr_un addr; char *fname = NULL; gid_t gid = 0; int gid_set = 0; char *buf, *dir = NULL, *gid_str = NULL; struct group *grp; char *endp; int flags; buf = os_strdup(wpa_s->conf->ctrl_interface); if (buf == NULL) goto fail; #ifdef ANDROID os_snprintf(addr.sun_path, sizeof(addr.sun_path), "wpa_%s", wpa_s->conf->ctrl_interface); priv->sock = android_get_control_socket(addr.sun_path); if (priv->sock >= 0) { priv->android_control_socket = 1; goto havesock; } #endif /* ANDROID */ if (os_strncmp(buf, "DIR=", 4) == 0) { dir = buf + 4; gid_str = os_strstr(dir, " GROUP="); if (gid_str) { *gid_str = '\0'; gid_str += 7; } } else { dir = buf; gid_str = wpa_s->conf->ctrl_interface_group; } if (mkdir(dir, S_IRWXU | S_IRWXG) < 0) { if (errno == EEXIST) { wpa_printf(MSG_DEBUG, "Using existing control " "interface directory."); } else { wpa_printf(MSG_ERROR, "mkdir[ctrl_interface=%s]: %s", dir, strerror(errno)); goto fail; } } #ifdef ANDROID /* * wpa_supplicant is started from /init.*.rc on Android and that seems * to be using umask 0077 which would leave the control interface * directory without group access. This breaks things since Wi-Fi * framework assumes that this directory can be accessed by other * applications in the wifi group. Fix this by adding group access even * if umask value would prevent this. */ if (chmod(dir, S_IRWXU | S_IRWXG) < 0) { wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s", strerror(errno)); /* Try to continue anyway */ } #endif /* ANDROID */ if (gid_str) { grp = getgrnam(gid_str); if (grp) { gid = grp->gr_gid; gid_set = 1; wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d" " (from group name '%s')", (int) gid, gid_str); } else { /* Group name not found - try to parse this as gid */ gid = strtol(gid_str, &endp, 10); if (*gid_str == '\0' || *endp != '\0') { wpa_printf(MSG_ERROR, "CTRL: Invalid group " "'%s'", gid_str); goto fail; } gid_set = 1; wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d", (int) gid); } } if (gid_set && chown(dir, -1, gid) < 0) { wpa_printf(MSG_ERROR, "chown[ctrl_interface=%s,gid=%d]: %s", dir, (int) gid, strerror(errno)); goto fail; } /* Make sure the group can enter and read the directory */ if (gid_set && chmod(dir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP) < 0) { wpa_printf(MSG_ERROR, "CTRL: chmod[ctrl_interface]: %s", strerror(errno)); goto fail; } if (os_strlen(dir) + 1 + os_strlen(wpa_s->ifname) >= sizeof(addr.sun_path)) { wpa_printf(MSG_ERROR, "ctrl_iface path limit exceeded"); goto fail; } priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0); if (priv->sock < 0) { wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno)); goto fail; } os_memset(&addr, 0, sizeof(addr)); #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) addr.sun_len = sizeof(addr); #endif /* __FreeBSD__ */ addr.sun_family = AF_UNIX; fname = wpa_supplicant_ctrl_iface_path(wpa_s); if (fname == NULL) goto fail; os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path)); if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s", strerror(errno)); if (connect(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not" " allow connections - assuming it was left" "over from forced program termination"); if (unlink(fname) < 0) { wpa_printf(MSG_ERROR, "Could not unlink existing ctrl_iface socket '%s': %s", fname, strerror(errno)); goto fail; } if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_ERROR, "supp-ctrl-iface-init: bind(PF_UNIX): %s", strerror(errno)); goto fail; } wpa_printf(MSG_DEBUG, "Successfully replaced leftover " "ctrl_iface socket '%s'", fname); } else { wpa_printf(MSG_INFO, "ctrl_iface exists and seems to " "be in use - cannot override it"); wpa_printf(MSG_INFO, "Delete '%s' manually if it is " "not used anymore", fname); os_free(fname); fname = NULL; goto fail; } } if (gid_set && chown(fname, -1, gid) < 0) { wpa_printf(MSG_ERROR, "chown[ctrl_interface=%s,gid=%d]: %s", fname, (int) gid, strerror(errno)); goto fail; } if (chmod(fname, S_IRWXU | S_IRWXG) < 0) { wpa_printf(MSG_ERROR, "chmod[ctrl_interface=%s]: %s", fname, strerror(errno)); goto fail; } os_free(fname); #ifdef ANDROID havesock: #endif /* ANDROID */ /* * Make socket non-blocking so that we don't hang forever if * target dies unexpectedly. */ flags = fcntl(priv->sock, F_GETFL); if (flags >= 0) { flags |= O_NONBLOCK; if (fcntl(priv->sock, F_SETFL, flags) < 0) { wpa_printf(MSG_INFO, "fcntl(ctrl, O_NONBLOCK): %s", strerror(errno)); /* Not fatal, continue on.*/ } } eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive, wpa_s, priv); wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb); os_free(buf); return 0; fail: if (priv->sock >= 0) { close(priv->sock); priv->sock = -1; } if (fname) { unlink(fname); os_free(fname); } os_free(buf); return -1; }
/* * SDP server initialization on startup includes creating the * l2cap and unix sockets over which discovery and registration clients * access us respectively */ static int init_server(uint16_t mtu, int master, int compat) { struct l2cap_options opts; struct sockaddr_l2 l2addr; struct sockaddr_un unaddr; socklen_t optlen; /* Register the public browse group root */ register_public_browse_group(); /* Register the SDP server's service record */ register_server_service(); /* Create L2CAP socket */ l2cap_sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP); if (l2cap_sock < 0) { error("opening L2CAP socket: %s", strerror(errno)); return -1; } memset(&l2addr, 0, sizeof(l2addr)); l2addr.l2_family = AF_BLUETOOTH; bacpy(&l2addr.l2_bdaddr, BDADDR_ANY); l2addr.l2_psm = htobs(SDP_PSM); if (bind(l2cap_sock, (struct sockaddr *) &l2addr, sizeof(l2addr)) < 0) { error("binding L2CAP socket: %s", strerror(errno)); return -1; } if (master) { int opt = L2CAP_LM_MASTER; if (setsockopt(l2cap_sock, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) { error("setsockopt: %s", strerror(errno)); return -1; } } if (mtu > 0) { memset(&opts, 0, sizeof(opts)); optlen = sizeof(opts); if (getsockopt(l2cap_sock, SOL_L2CAP, L2CAP_OPTIONS, &opts, &optlen) < 0) { error("getsockopt: %s", strerror(errno)); return -1; } opts.omtu = mtu; opts.imtu = mtu; if (setsockopt(l2cap_sock, SOL_L2CAP, L2CAP_OPTIONS, &opts, sizeof(opts)) < 0) { error("setsockopt: %s", strerror(errno)); return -1; } } if (listen(l2cap_sock, 5) < 0) { error("listen: %s", strerror(errno)); return -1; } if (!compat) { unix_sock = -1; return 0; } #ifndef ANDROID /* Create local Unix socket */ unix_sock = socket(PF_UNIX, SOCK_STREAM, 0); if (unix_sock < 0) { error("opening UNIX socket: %s", strerror(errno)); return -1; } memset(&unaddr, 0, sizeof(unaddr)); unaddr.sun_family = AF_UNIX; strcpy(unaddr.sun_path, SDP_UNIX_PATH); unlink(unaddr.sun_path); if (bind(unix_sock, (struct sockaddr *) &unaddr, sizeof(unaddr)) < 0) { error("binding UNIX socket: %s", strerror(errno)); return -1; } listen(unix_sock, 5); chmod(SDP_UNIX_PATH, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); #else unix_sock = android_get_control_socket("bluetooth"); if (unix_sock < 0) { error("Unable to get the control socket for 'bluetooth'"); return -1; } if (listen(unix_sock, 5)) { error("Listening on local socket failed: %s", strerror(errno)); return -1; } info("Got Unix socket fd '%d' from environment", unix_sock); #endif return 0; }
int hostapd_ctrl_iface_init(struct hostapd_data *hapd) { struct sockaddr_un addr; int s = -1; char *fname = NULL; hapd->ctrl_sock = -1; if (hapd->conf->ctrl_interface == NULL) return 0; #ifdef ANDROID os_snprintf(addr.sun_path, sizeof(addr.sun_path), "hostapd_%s", hapd->conf->ctrl_interface); s = android_get_control_socket(addr.sun_path); if (s >= 0) goto havesock; #endif if (mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) { if (errno == EEXIST) { wpa_printf(MSG_DEBUG, "Using existing control " "interface directory."); #ifdef ANDROID fname = hostapd_ctrl_iface_path(hapd); if (fname) unlink(fname); free(fname); rmdir(hapd->conf->ctrl_interface); mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG); #endif /* ANDROID */ } else { perror("mkdir[ctrl_interface]"); goto fail; } } #ifdef ANDROID if (chown(hapd->conf->ctrl_interface, AID_SYSTEM, AID_WIFI) < 0) { perror("chown[ctrl_interface]"); } #endif /* ANDROID */ if (hapd->conf->ctrl_interface_gid_set && chown(hapd->conf->ctrl_interface, 0, hapd->conf->ctrl_interface_gid) < 0) { perror("chown[ctrl_interface]"); return -1; } if (os_strlen(hapd->conf->ctrl_interface) + 1 + os_strlen(hapd->conf->iface) >= sizeof(addr.sun_path)) goto fail; s = socket(PF_UNIX, SOCK_DGRAM, 0); if (s < 0) { perror("socket(PF_UNIX)"); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; fname = hostapd_ctrl_iface_path(hapd); if (fname == NULL) goto fail; os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path)); if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind(PF_UNIX)"); goto fail; } if (hapd->conf->ctrl_interface_gid_set && chown(fname, 0, hapd->conf->ctrl_interface_gid) < 0) { perror("chown[ctrl_interface/ifname]"); goto fail; } if (chmod(fname, S_IRWXU | S_IRWXG) < 0) { perror("chmod[ctrl_interface/ifname]"); goto fail; } os_free(fname); #ifdef ANDROID havesock: #endif hapd->ctrl_sock = s; eloop_register_read_sock(s, hostapd_ctrl_iface_receive, hapd, NULL); wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb); return 0; fail: if (s >= 0) close(s); if (fname) { unlink(fname); os_free(fname); } return -1; }
int main() { int l_socket_fd = -1; int c_socket_fd = -1; fd_set fds; l_socket_fd = android_get_control_socket(SOCKET_NAME); if (l_socket_fd < 0 ){ ALOGE("Unable to open inputdevinfo_socket (%s)\n", strerror(errno)); return -1; } if (make_nonblocking (l_socket_fd)) { ALOGE("Unable to modify inputdevinfo_socket flags. (%s)\n", strerror(errno)); } if (listen (l_socket_fd, 0) < 0) { ALOGE("Unable to open inputdevinfo_socket (%s)\n", strerror(errno)); return -1; } while(1){ FD_ZERO(&fds); FD_SET(l_socket_fd, &fds); if (c_socket_fd >= 0 ) { // && fcntl(c_socket_fd, F_GETFD) >= 0 ? FD_SET(c_socket_fd, &fds); } int retval = select(get_max(c_socket_fd, l_socket_fd) + 1, &fds, NULL, NULL, NULL); if(retval <= 0){ ALOGI("Error\n"); // Should I check for EBADR? break; } if(FD_ISSET(l_socket_fd, &fds)) { ALOGI("Connection attempt\n"); if(c_socket_fd < 0) { c_socket_fd = accept(l_socket_fd, NULL, NULL); } if (make_nonblocking (c_socket_fd)) { ALOGE("Unable to modify socket flags. (%s)\n", strerror(errno)); } } if(c_socket_fd >= 0 && FD_ISSET(c_socket_fd, &fds)){ int unread_bytes_count; if (ioctl(c_socket_fd, FIONREAD, &unread_bytes_count)){ ALOGE("Attempt to check if client socket is closed resulted in error.\n"); } else if(unread_bytes_count == 0) { //TODO: Check return code? close(c_socket_fd); c_socket_fd = -1; } else { process_cmds(c_socket_fd, MAX_COMMAND_LENGTH); close(c_socket_fd); c_socket_fd = -1; } } } return 0; }
void *daemonListenThread(void* ignore) { int servfd,newfd,fdmax, i,n; socklen_t servlen,clilen; fd_set master,read_fds; struct sockaddr_un cli_addr, serv_addr; fdmax=0; char buf[80]; ERROR("daemonListenThread\n"); servfd = android_get_control_socket("svmp_sensors"); if (servfd < 0 ) ERROR("error with android_get_control_socket: error %s\n",strerror(errno)); else ERROR("android_get_control_socket success fd %d\n", servfd); if(listen(servfd, 10) == -1) { //perror("Could not listen to raw daemon socket"); ERROR("listen error %s\n",strerror(errno)); pthread_exit(0); } FD_ZERO(&master); FD_ZERO(&read_fds); FD_SET(servfd,&master); fdmax = max(fdmax,servfd); ERROR("starting select loop\n"); for (;;) { read_fds=master; if(select(fdmax+1,&read_fds,NULL,NULL,NULL)==-1) ERROR("select error %s\n",strerror(errno)); for(i=0; i<=fdmax; i++){ if(FD_ISSET(i,&read_fds)) { printf("fd is set i=%d, servfd %d \n",i,servfd); if(i == servfd) { newfd = accept(servfd,NULL,NULL); //servfd,(struct sockaddr *)&cli_addr,&clilen); if (newfd >0){ ERROR("new connection accepted fd = %d\n",newfd); //fflush(dfp); FD_SET(newfd,&master); fdmax=max(fdmax,newfd); // initialize sensors //sendSensorActivations(); } else ERROR("accept error: %s\n", strerror(errno)); }else { // existing client int n=processPacket(i); if (n<=0) { ERROR("closing connection to client \n"); //fflush(dfp); close(i); FD_CLR(i, &master); } else { //fflush(dfp); pthread_cond_signal(&newpacket_cv); ERROR("new packet processed size : %d\n",n); //pthread_mutex_unlock(&newpacket_mutex); } } } } } pthread_exit(NULL); return 0; }
int main(const int argc, const char *argv[]) { char buf[BUFFER_MAX]; struct sockaddr addr; socklen_t alen; int lsocket, s, count; pthread_t worker_threads, signal_thread; pthread_attr_t pthread_custom_attr; sigset_t sigs_to_block; pthread_mutex_init(&io_mutex, NULL); pthread_cond_init(&io_wait, NULL); pthread_attr_init(&pthread_custom_attr); sigemptyset(&sigs_to_block); sigaddset(&sigs_to_block, SIGIO); pthread_sigmask(SIG_BLOCK, &sigs_to_block, NULL); pthread_create(&signal_thread, &pthread_custom_attr, io_signal_handler, NULL); ALOGI("installd firing up\n"); if (initialize_globals() < 0) { ALOGE("Could not initialize globals; exiting.\n"); exit(1); } if (initialize_directories() < 0) { ALOGE("Could not create directories; exiting.\n"); exit(1); } drop_privileges(); lsocket = android_get_control_socket(SOCKET_PATH); if (lsocket < 0) { ALOGE("Failed to get socket from environment: %s\n", strerror(errno)); exit(1); } if (listen(lsocket, 5)) { ALOGE("Listen on socket failed: %s\n", strerror(errno)); exit(1); } fcntl(lsocket, F_SETFD, FD_CLOEXEC); for (;;) { alen = sizeof(addr); s = accept(lsocket, &addr, &alen); if (s < 0) { ALOGE("Accept failed: %s\n", strerror(errno)); continue; } fcntl(s, F_SETFD, FD_CLOEXEC); fcntl(s, F_SETFL, O_ASYNC | O_NONBLOCK); fcntl(s, F_SETSIG, 0); fcntl(s, F_SETOWN, getpid()); write_error = 0; ALOGI("new connection\n"); for (;;) { unsigned short count; int id; if (readx(s, &id, sizeof(id))) { ALOGE("failed to read transaction id\n"); break; } if (readx(s, &count, sizeof(count))) { ALOGE("failed to read size\n"); break; } if ((count < 1) || (count >= BUFFER_MAX)) { ALOGE("invalid size %d\n", count); break; } if (readx(s, buf, count)) { ALOGE("failed to read command\n"); break; } buf[count] = 0; thread_parm *args = (thread_parm*) malloc(sizeof(thread_parm)); args->s = s; strncpy(args->cmd, buf, count + 1); args->id = id; pthread_create(&worker_threads, &pthread_custom_attr, executeAsync, (void*) args); } ALOGI("closing connection\n"); close(s); } pthread_kill(&signal_thread, SIGKILL); pthread_join(&signal_thread, NULL); return 0; }