~SyncConnection() { if (!IsValid()) return; if (SendQuit()) { // We sent a quit command, so the server should be doing orderly // shutdown soon. But if we encountered an error while we were using // the connection, the server might still be sending data (before // doing orderly shutdown), in which case we won't wait for all of // the data nor the coming orderly shutdown. In the common success // case, this will wait for the server to do orderly shutdown. ReadOrderlyShutdown(fd); } line_printer_.KeepInfoLine(); }
bool adb_query(const std::string& service, std::string* result, std::string* error) { D("adb_query: %s", service.c_str()); int fd = adb_connect(service, error); if (fd < 0) { return false; } result->clear(); if (!ReadProtocolString(fd, result, error)) { adb_close(fd); return false; } ReadOrderlyShutdown(fd); adb_close(fd); return true; }
bool adb_command(const std::string& service) { std::string error; int fd = adb_connect(service, &error); if (fd < 0) { fprintf(stderr, "error: %s\n", error.c_str()); return false; } if (!adb_status(fd, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); adb_close(fd); return false; } ReadOrderlyShutdown(fd); adb_close(fd); return true; }
bool adb_kill_server() { D("adb_kill_server"); std::string reason; int fd = socket_spec_connect(__adb_server_socket_spec, &reason); if (fd < 0) { fprintf(stderr, "cannot connect to daemon at %s: %s\n", __adb_server_socket_spec, reason.c_str()); return true; } if (!SendProtocolString(fd, "host:kill")) { fprintf(stderr, "error: write failure during connection: %s\n", strerror(errno)); return false; } // The server might send OKAY, so consume that. char buf[4]; ReadFdExactly(fd, buf, 4); // Now that no more data is expected, wait for socket orderly shutdown or error, indicating // server death. ReadOrderlyShutdown(fd); return true; }
int adb_connect(const std::string& service, std::string* error) { // first query the adb server's version int fd = _adb_connect("host:version", error); D("adb_connect: service %s", service.c_str()); if (fd == -2 && __adb_server_name) { fprintf(stderr,"** Cannot start server on remote host\n"); // error is the original network connection error return fd; } else if (fd == -2) { fprintf(stdout,"* daemon not running. starting it now on port %d *\n", __adb_server_port); start_server: if (launch_server(__adb_server_port)) { fprintf(stderr,"* failed to start daemon *\n"); // launch_server() has already printed detailed error info, so just // return a generic error string about the overall adb_connect() // that the caller requested. *error = "cannot connect to daemon"; return -1; } else { fprintf(stdout,"* daemon started successfully *\n"); } /* give the server some time to start properly and detect devices */ adb_sleep_ms(3000); // fall through to _adb_connect } else { // If a server is already running, check its version matches. int version = ADB_SERVER_VERSION - 1; // If we have a file descriptor, then parse version result. if (fd >= 0) { std::string version_string; if (!ReadProtocolString(fd, &version_string, error)) { adb_close(fd); return -1; } ReadOrderlyShutdown(fd); adb_close(fd); if (sscanf(&version_string[0], "%04x", &version) != 1) { *error = android::base::StringPrintf("cannot parse version string: %s", version_string.c_str()); return -1; } } else { // If fd is -1 check for "unknown host service" which would // indicate a version of adb that does not support the // version command, in which case we should fall-through to kill it. if (*error != "unknown host service") { return fd; } } if (version != ADB_SERVER_VERSION) { printf("adb server version (%d) doesn't match this client (%d); killing...\n", version, ADB_SERVER_VERSION); fd = _adb_connect("host:kill", error); if (fd >= 0) { ReadOrderlyShutdown(fd); adb_close(fd); } else { // If we couldn't connect to the server or had some other error, // report it, but still try to start the server. fprintf(stderr, "error: %s\n", error->c_str()); } /* XXX can we better detect its death? */ adb_sleep_ms(2000); goto start_server; } } // if the command is start-server, we are done. if (service == "host:start-server") { return 0; } fd = _adb_connect(service, error); if (fd == -1) { D("_adb_connect error: %s", error->c_str()); } else if(fd == -2) { fprintf(stderr,"** daemon still not running\n"); } D("adb_connect: return fd %d", fd); return fd; }
int adb_connect(const std::string& service, std::string* error) { // first query the adb server's version int fd = _adb_connect("host:version", error); D("adb_connect: service %s", service.c_str()); if (fd == -2 && !is_local_socket_spec(__adb_server_socket_spec)) { fprintf(stderr, "* cannot start server on remote host\n"); // error is the original network connection error return fd; } else if (fd == -2) { fprintf(stderr, "* daemon not running; starting now at %s\n", __adb_server_socket_spec); start_server: if (launch_server(__adb_server_socket_spec)) { fprintf(stderr, "* failed to start daemon\n"); // launch_server() has already printed detailed error info, so just // return a generic error string about the overall adb_connect() // that the caller requested. *error = "cannot connect to daemon"; return -1; } else { fprintf(stderr, "* daemon started successfully\n"); } // The server will wait until it detects all of its connected devices before acking. // Fall through to _adb_connect. } else { // If a server is already running, check its version matches. int version = ADB_SERVER_VERSION - 1; // If we have a file descriptor, then parse version result. if (fd >= 0) { std::string version_string; if (!ReadProtocolString(fd, &version_string, error)) { adb_close(fd); return -1; } ReadOrderlyShutdown(fd); adb_close(fd); if (sscanf(&version_string[0], "%04x", &version) != 1) { *error = android::base::StringPrintf("cannot parse version string: %s", version_string.c_str()); return -1; } } else { // If fd is -1 check for "unknown host service" which would // indicate a version of adb that does not support the // version command, in which case we should fall-through to kill it. if (*error != "unknown host service") { return fd; } } if (version != ADB_SERVER_VERSION) { fprintf(stderr, "adb server version (%d) doesn't match this client (%d); killing...\n", version, ADB_SERVER_VERSION); adb_kill_server(); goto start_server; } } // if the command is start-server, we are done. if (service == "host:start-server") { return 0; } fd = _adb_connect(service, error); if (fd == -1) { D("_adb_connect error: %s", error->c_str()); } else if(fd == -2) { fprintf(stderr, "* daemon still not running\n"); } D("adb_connect: return fd %d", fd); return fd; }