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; } return true; }
bool adb_status(int fd, std::string* error) { char buf[5]; if (!ReadFdExactly(fd, buf, 4)) { *error = perror_str("protocol fault (couldn't read status)"); return false; } if (!memcmp(buf, "OKAY", 4)) { return true; } if (memcmp(buf, "FAIL", 4)) { *error = android::base::StringPrintf("protocol fault (status %02x %02x %02x %02x?!)", buf[0], buf[1], buf[2], buf[3]); return false; } ReadProtocolString(fd, error, error); return false; }
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 server was running, check its version to make sure it is not out of date 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)) { goto error; } 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, then 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 is out of date. killing...\n"); fd = _adb_connect("host:kill", error); if (fd >= 0) { 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; error: adb_close(fd); return -1; }
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(stdout, "* daemon not running. starting it 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(stdout,"* daemon started successfully *\n"); } // Give the server some time to start properly and detect devices. std::this_thread::sleep_for(3s); // 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? */ std::this_thread::sleep_for(2s); 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\n", service.c_str()); if (fd == -2 && __adb_server_name) { fprintf(stderr,"** Cannot start server on remote host\n"); 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"); 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 server was running, check its version to make sure it is not out of date 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)) { goto error; } adb_close(fd); if (sscanf(&version_string[0], "%04x", &version) != 1) { goto error; } } else { // if fd is -1, then check for "unknown host service", // which would indicate a version of adb that does not support the version command if (*error == "unknown host service") { return fd; } } if (version != ADB_SERVER_VERSION) { printf("adb server is out of date. killing...\n"); fd = _adb_connect("host:kill", error); adb_close(fd); /* 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\n", error->c_str()); } else if(fd == -2) { fprintf(stderr,"** daemon still not running\n"); } D("adb_connect: return fd %d\n", fd); return fd; error: adb_close(fd); return -1; }