/**
* test2:
* This check tests "coyote_simple_stop"
*
*
* This test will create a listening server and will try to establish
* a connection, creating a channel and then closing it
*
**/
gboolean test_simple_stop (void)
{
gint argc = 1;
gchar *argv[] = {"./test_client"};
GError *error = NULL;
RRConnection * connection = NULL;
CoyoteSimple * channel = NULL;
CoyoteSimpleCfg * coyote_simple_cfg = NULL;
int status = 0;
pid_t id;
gchar *port = "55501";
id = fork();
if (!id) {
launch_server(port, NULL);
exit;
}
sleep (1);
if (!coyote_init (&argc, (gchar ***) &argv, &error))
return FALSE;
connection = coyote_connection_new ("localhost", port, TYPE_COYOTE_SIMPLE);
if (!connection) {
kill (id, SIGKILL);
waitpid (id, &status, 0);
coyote_exit (&error);
return FALSE;
} else {
coyote_simple_cfg = coyote_simple_cfg_new ();
channel = coyote_simple_start (connection,
coyote_simple_cfg,
&error);
if (! channel) {
kill (id, SIGKILL);
waitpid (id, &status, 0);
coyote_exit (&error);
return FALSE;
} else {
if (coyote_simple_close (channel, &error)) {
kill (id, SIGKILL);
waitpid (id, &status, 0);
coyote_exit (&error);
return TRUE;
} else {
kill (id, SIGKILL);
waitpid (id, &status, 0);
coyote_exit (&error);
return FALSE;
}
}
}
}
int main() {
register_procedure("addtwo", 2, add);
register_procedure("minustwo", 2, subtract);
launch_server();
/* should never get here, because
launch_server(); runs forever. */
return 0;
}
int main(int argc, char ** argv) {
/* Ctrl-c way out... */
signal(SIGINT, sign_handler);
process_args(argc, argv);
if(is_server) {
launch_server();
} else {
launch_client();
}
return 0;
}
int main() {
register_procedure("nothing", 0, nothing);
register_procedure("addtwo", 2, add);
register_procedure("pickFirst", 2, pickFirst);
register_procedure("max_of_integer_array", 1, max);
register_procedure("concatenate_five_strings", 5, concatStr);
#ifdef _DEBUG_1_
printRegisteredProcedures();
#endif
launch_server();
return 0;
}
/**
* test_simple_cfg_server_init:
* This check tests "coyote_simple_cfg_set_server_init"
*
*
* This test will create a listening server and will try to establish
* a connection, creating a channel and then closing it
*
**/
gboolean test_simple_cfg_server_init (void)
{
gint argc = 1;
gchar *argv[] = {"./test_client"};
GError *error = NULL;
RRConnection * connection = NULL;
CoyoteSimple * channel = NULL;
CoyoteSimpleCfg * coyote_simple_cfg = NULL;
pid_t id;
gchar *port = "55503";
// Creating a configuration
coyote_simple_cfg = coyote_simple_cfg_new ();
coyote_simple_cfg_set_server_init (coyote_simple_cfg, test_simple_cfg_server_init_callback, NULL);
id = fork();
if (!id) {
launch_server (port, coyote_simple_cfg);
exit;
}
sleep (1);
if (!coyote_init (&argc, (gchar ***) &argv, &error))
return FALSE;
connection = coyote_connection_new ("localhost", port, TYPE_COYOTE_SIMPLE);
if (!connection) {
kill (id, SIGKILL);
return FALSE;
} else {
channel = coyote_simple_start (connection,
coyote_simple_cfg,
&error);
if (! channel) {
kill (id, SIGKILL);
return FALSE;
} else {
coyote_simple_close (channel, &error);
kill (id, SIGKILL);
return TRUE;
}
}
}
int main(int argc, char *argv[]) {
register_procedure("sMount", 2, sMount);
register_procedure("sUnmount", 2, sUnmount);
register_procedure("sOpenDir", 3, sOpenDir);
register_procedure("sCloseDir", 3, sCloseDir);
register_procedure("sReadDir", 3, sReadDir);
register_procedure("sOpen", 4, sOpen);
register_procedure("sClose", 3, sClose);
register_procedure("sRead", 4, sRead);
register_procedure("sWrite", 5, sWrite);
register_procedure("sRemove", 2, sRemove);
strcpy(serverAlias, argv[1]);
launch_server();
return 0;
}
int main(int argc, char*argv[]) {
if (argc == 2) {
registerMountFolder(argv[1]);
register_procedure("isAlive", 0, isAlive);
register_procedure("fsOpen", 2, fsOpen);
register_procedure("fsClose", 1, fsClose);
register_procedure("fsRead", 2, fsRead);
register_procedure("fsWrite", 3, fsWrite);
register_procedure("fsRemove", 1, fsRemove);
register_procedure("fsOpenDir", 1, fsOpenDir);
register_procedure("fsReadDir", 1, fsReadDir);
register_procedure("fsCloseDir", 1, fsCloseDir);
#ifdef _DEBUG_1_
printRegisteredProcedures();
#endif
launch_server();
} else {
printf("Format: ./server <folder_path>\n");
}
return 0;
}
int adb_connect(const char *service)
{
// first query the adb server's version
int fd = _adb_connect("host:version");
D("adb_connect: service %s\n", service);
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
char buf[100];
size_t n;
int version = ADB_SERVER_VERSION - 1;
// if we have a file descriptor, then parse version result
if(fd >= 0) {
if(!ReadFdExactly(fd, buf, 4)) goto error;
buf[4] = 0;
n = strtoul(buf, 0, 16);
if(n > sizeof(buf)) goto error;
if(!ReadFdExactly(fd, buf, n)) goto error;
adb_close(fd);
if (sscanf(buf, "%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 (strcmp(__adb_error, "unknown host service") != 0)
return fd;
}
if(version != ADB_SERVER_VERSION) {
printf("adb server is out of date. killing...\n");
fd = _adb_connect("host:kill");
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 (!strcmp(service, "host:start-server"))
return 0;
fd = _adb_connect(service);
if(fd == -1) {
D("_adb_connect error: %s", __adb_error);
} 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;
}
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;
}
// main
int
main(int argc, char** argv)
{
BApplication app("application/x-vnd.antares-netfs_server_prefs");
// parse first argument
int argi = 1;
const char* arg = next_arg(argc, argv, argi);
if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0)
print_usage_and_exit(false);
if (strcmp(arg, "launch") == 0) {
// launch
no_more_args(argc, argi);
launch_server();
} else if (strcmp(arg, "terminate") == 0) {
// terminate
no_more_args(argc, argi);
terminate_server();
} else if (strcmp(arg, "save") == 0) {
// save
no_more_args(argc, argi);
save_server_setttings();
} else if (strcmp(arg, "l") == 0 || strcmp(arg, "list") == 0) {
// list
no_more_args(argc, argi);
list();
} else if (strcmp(arg, "add") == 0) {
// add
arg = next_arg(argc, argv, argi);
if (strcmp(arg, "share") == 0) {
// share
const char* name = next_arg(argc, argv, argi);
const char* path = next_arg(argc, argv, argi);
no_more_args(argc, argi);
add_share(name, path);
} else if (strcmp(arg, "user") == 0) {
// user
const char* name = next_arg(argc, argv, argi);
const char* password = next_arg(argc, argv, argi, true);
no_more_args(argc, argi);
add_user(name, password);
} else
print_usage_and_exit(true);
} else if (strcmp(arg, "remove") == 0) {
// remove
arg = next_arg(argc, argv, argi);
if (strcmp(arg, "share") == 0) {
// share
const char* name = next_arg(argc, argv, argi);
no_more_args(argc, argi);
remove_share(name);
} else if (strcmp(arg, "user") == 0) {
// user
const char* name = next_arg(argc, argv, argi);
no_more_args(argc, argi);
remove_user(name);
} else
print_usage_and_exit(true);
} else if (strcmp(arg, "permissions") == 0) {
// permissions
const char* user = next_arg(argc, argv, argi);
const char* share = next_arg(argc, argv, argi);
uint32 permissions = 0;
while (argi < argc) {
uint32 perms = 0;
arg = next_arg(argc, argv, argi);
if (!get_permissions(arg, &perms))
print_usage_and_exit(true);
permissions |= perms;
}
set_user_permissions(user, share, permissions);
} else {
print_usage_and_exit(true);
}
return 0;
}
int adb_commandline(int argc, char **argv)
{
char buf[4096];
int no_daemon = 0;
int is_daemon = 0;
int persist = 0;
int r;
int quote;
transport_type ttype = kTransportAny;
char* serial = NULL;
/* If defined, this should be an absolute path to
* the directory containing all of the various system images
* for a particular product. If not defined, and the adb
* command requires this information, then the user must
* specify the path using "-p".
*/
gProductOutPath = getenv("ANDROID_PRODUCT_OUT");
if (gProductOutPath == NULL || gProductOutPath[0] == '\0') {
gProductOutPath = NULL;
}
// TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint
serial = getenv("ANDROID_SERIAL");
/* modifiers and flags */
while(argc > 0) {
if(!strcmp(argv[0],"nodaemon")) {
no_daemon = 1;
} else if (!strcmp(argv[0], "fork-server")) {
/* this is a special flag used only when the ADB client launches the ADB Server */
is_daemon = 1;
} else if(!strcmp(argv[0],"persist")) {
persist = 1;
} else if(!strncmp(argv[0], "-p", 2)) {
const char *product = NULL;
if (argv[0][2] == '\0') {
if (argc < 2) return usage();
product = argv[1];
argc--;
argv++;
} else {
product = argv[1] + 2;
}
gProductOutPath = find_product_out_path(product);
if (gProductOutPath == NULL) {
fprintf(stderr, "adb: could not resolve \"-p %s\"\n",
product);
return usage();
}
} else if (argv[0][0]=='-' && argv[0][1]=='s') {
if (isdigit(argv[0][2])) {
serial = argv[0] + 2;
} else {
if(argc < 2) return usage();
serial = argv[1];
argc--;
argv++;
}
} else if (!strcmp(argv[0],"-d")) {
ttype = kTransportUsb;
} else if (!strcmp(argv[0],"-e")) {
ttype = kTransportLocal;
} else {
/* out of recognized modifiers and flags */
break;
}
argc--;
argv++;
}
adb_set_transport(ttype, serial);
if ((argc > 0) && (!strcmp(argv[0],"server"))) {
if (no_daemon || is_daemon) {
r = adb_main(is_daemon);
} else {
r = launch_server();
}
if(r) {
fprintf(stderr,"* could not start server *\n");
}
return r;
}
top:
if(argc == 0) {
return usage();
}
/* adb_connect() commands */
if(!strcmp(argv[0], "devices")) {
char *tmp;
snprintf(buf, sizeof buf, "host:%s", argv[0]);
tmp = adb_query(buf);
if(tmp) {
printf("List of devices attached \n");
printf("%s\n", tmp);
return 0;
} else {
return 1;
}
}
if(!strcmp(argv[0], "connect") || !strcmp(argv[0], "disconnect")) {
char *tmp;
if (argc != 2) {
fprintf(stderr, "Usage: adb %s <host>:<port>\n", argv[0]);
return 1;
}
snprintf(buf, sizeof buf, "host:%s:%s", argv[0], argv[1]);
tmp = adb_query(buf);
if(tmp) {
printf("%s\n", tmp);
return 0;
} else {
return 1;
}
}
if (!strcmp(argv[0], "emu")) {
return adb_send_emulator_command(argc, argv);
}
if(!strcmp(argv[0], "shell")) {
int r;
int fd;
if(argc < 2) {
return interactive_shell();
}
snprintf(buf, sizeof buf, "shell:%s", argv[1]);
argc -= 2;
argv += 2;
while(argc-- > 0) {
strcat(buf, " ");
/* quote empty strings and strings with spaces */
quote = (**argv == 0 || strchr(*argv, ' '));
if (quote)
strcat(buf, "\"");
strcat(buf, *argv++);
if (quote)
strcat(buf, "\"");
}
for(;;) {
fd = adb_connect(buf);
if(fd >= 0) {
read_and_dump(fd);
adb_close(fd);
r = 0;
} else {
fprintf(stderr,"error: %s\n", adb_error());
r = -1;
}
if(persist) {
fprintf(stderr,"\n- waiting for device -\n");
adb_sleep_ms(1000);
do_cmd(ttype, serial, "wait-for-device", 0);
} else {
return r;
}
}
}
if(!strcmp(argv[0], "kill-server")) {
int fd;
fd = _adb_connect("host:kill");
if(fd == -1) {
fprintf(stderr,"* server not running *\n");
return 1;
}
return 0;
}
if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot")
|| !strcmp(argv[0], "reboot-bootloader")
|| !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb")
|| !strcmp(argv[0], "root")) {
char command[100];
if (!strcmp(argv[0], "reboot-bootloader"))
snprintf(command, sizeof(command), "reboot:bootloader");
else if (argc > 1)
snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]);
else
snprintf(command, sizeof(command), "%s:", argv[0]);
int fd = adb_connect(command);
if(fd >= 0) {
read_and_dump(fd);
adb_close(fd);
return 0;
}
fprintf(stderr,"error: %s\n", adb_error());
return 1;
}
if(!strcmp(argv[0], "bugreport")) {
if (argc != 1) return usage();
do_cmd(ttype, serial, "shell", "bugreport", 0);
return 0;
}
/* adb_command() wrapper commands */
if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {
char* service = argv[0];
if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) {
if (ttype == kTransportUsb) {
service = "wait-for-usb";
} else if (ttype == kTransportLocal) {
service = "wait-for-local";
} else {
service = "wait-for-any";
}
}
format_host_command(buf, sizeof buf, service, ttype, serial);
if (adb_command(buf)) {
D("failure: %s *\n",adb_error());
fprintf(stderr,"error: %s\n", adb_error());
return 1;
}
/* Allow a command to be run after wait-for-device,
* e.g. 'adb wait-for-device shell'.
*/
if(argc > 1) {
argc--;
argv++;
goto top;
}
return 0;
}
if(!strcmp(argv[0], "forward")) {
if(argc != 3) return usage();
if (serial) {
snprintf(buf, sizeof buf, "host-serial:%s:forward:%s;%s",serial, argv[1], argv[2]);
} else if (ttype == kTransportUsb) {
snprintf(buf, sizeof buf, "host-usb:forward:%s;%s", argv[1], argv[2]);
} else if (ttype == kTransportLocal) {
snprintf(buf, sizeof buf, "host-local:forward:%s;%s", argv[1], argv[2]);
} else {
snprintf(buf, sizeof buf, "host:forward:%s;%s", argv[1], argv[2]);
}
if(adb_command(buf)) {
fprintf(stderr,"error: %s\n", adb_error());
return 1;
}
return 0;
}
/* do_sync_*() commands */
if(!strcmp(argv[0], "ls")) {
if(argc != 2) return usage();
return do_sync_ls(argv[1]);
}
if(!strcmp(argv[0], "push")) {
if(argc != 3) return usage();
return do_sync_push(argv[1], argv[2], 0 /* no verify APK */);
}
if(!strcmp(argv[0], "pull")) {
if (argc == 2) {
return do_sync_pull(argv[1], ".");
} else if (argc == 3) {
return do_sync_pull(argv[1], argv[2]);
} else {
return usage();
}
}
if(!strcmp(argv[0], "install")) {
if (argc < 2) return usage();
return install_app(ttype, serial, argc, argv);
}
if(!strcmp(argv[0], "uninstall")) {
if (argc < 2) return usage();
return uninstall_app(ttype, serial, argc, argv);
}
if(!strcmp(argv[0], "sync")) {
char *srcarg, *android_srcpath, *data_srcpath;
int listonly = 0;
int ret;
if(argc < 2) {
/* No local path was specified. */
srcarg = NULL;
} else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
listonly = 1;
if (argc == 3) {
srcarg = argv[2];
} else {
srcarg = NULL;
}
} else if(argc == 2) {
/* A local path or "android"/"data" arg was specified. */
srcarg = argv[1];
} else {
return usage();
}
ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath);
if(ret != 0) return usage();
if(android_srcpath != NULL)
ret = do_sync_sync(android_srcpath, "/system", listonly);
if(ret == 0 && data_srcpath != NULL)
ret = do_sync_sync(data_srcpath, "/data", listonly);
free(android_srcpath);
free(data_srcpath);
return ret;
}
/* passthrough commands */
if(!strcmp(argv[0],"get-state") ||
!strcmp(argv[0],"get-serialno"))
{
char *tmp;
format_host_command(buf, sizeof buf, argv[0], ttype, serial);
tmp = adb_query(buf);
if(tmp) {
printf("%s\n", tmp);
return 0;
} else {
return 1;
}
}
/* other commands */
if(!strcmp(argv[0],"status-window")) {
status_window(ttype, serial);
return 0;
}
if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat")) {
return logcat(ttype, serial, argc, argv);
}
if(!strcmp(argv[0],"ppp")) {
return ppp(argc, argv);
}
if (!strcmp(argv[0], "start-server")) {
return adb_connect("host:start-server");
}
if (!strcmp(argv[0], "jdwp")) {
int fd = adb_connect("jdwp");
if (fd >= 0) {
read_and_dump(fd);
adb_close(fd);
return 0;
} else {
fprintf(stderr, "error: %s\n", adb_error());
return -1;
}
}
/* "adb /?" is a common idiom under Windows */
if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
help();
return 0;
}
if(!strcmp(argv[0], "version")) {
version(stdout);
return 0;
}
usage();
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;
}
int main(int argc, char** argv)
{
//close server and RedPitaya if CTRL+C
signal(SIGINT, signal_callback_handler);
//client TCP initialisation
unsigned int MaxClient=5;
sock=0;
init_TCP_server(&sock, PORT, &client_list, MaxClient);
launch_server(&sock, &client_list);
//RedPitaya and settings initialisation
init_RP();
uint32_t buffer_length=0;
float level0=0.80, levelf=1.0;
int delay;
float *buffer_float=NULL;
char *buffer_char=NULL;
set_acquisition(dec);
init_ramp(1, level0, x0, levelf, xf);
init_variable(x0, xf, dec, &buffer_length, &delay);
printf("length = %i\n",(int)buffer_length);
buffer_float=(float *)malloc(((int)buffer_length)*sizeof(float));
buffer_char=(char *)malloc(((int)buffer_length+1)*sizeof(char));
//stepper initialisation
init_stepper(&stepper);
set_mode(&stepper, full_16);
double angle=0.0, speed=3.0;
angle=sector/((double)Nline);
init_position(&stepper, 160.0-sector/2.0);
int i=0;
while(1)
{
for (i=0 ; i<Nline ; i++)
{
move(&stepper, &angle, &speed, sens1);
trigg(delay);
pulse();
on_trigger_acquisition(buffer_float, buffer_length);
send_via_tcp(i+1, buffer_char, buffer_float, buffer_length, &client_list);
pulse();
}
for (i=Nline ; i>0 ; i--)
{
move(&stepper, &angle, &speed, sens2);
trigg(delay);
pulse();
on_trigger_acquisition(buffer_float, buffer_length);
send_via_tcp(i, buffer_char, buffer_float, buffer_length, &client_list);
pulse();
}
}
free(buffer_float);
free(buffer_char);
end_ramp();
disable_stepper(&stepper);
printf("Process done\n");
//close TCP client
close_TCP_client(&sock);
//close RedPitaya
close_RP();
return 0;
}
void launch_server(session_manager* m, const char* ip, unsigned short port)
{
launch_server(s_poller, m, ip, port);
}
int main(void)
{
display_pid();
launch_server();
return (0);
}
