void cmd_connect_fail_message(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    gchar *args[] = { "*****@*****.**", NULL };

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_any(accounts_get_account, name);
    will_return(accounts_get_account, NULL);

    will_return(ui_ask_password, strdup("password"));

    expect_cons_show("Connecting as [email protected]");

    expect_any(jabber_connect_with_details, jid);
    expect_any(jabber_connect_with_details, passwd);
    expect_any(jabber_connect_with_details, altdomain);
    expect_any(jabber_connect_with_details, port);
    will_return(jabber_connect_with_details, JABBER_DISCONNECTED);

    expect_cons_show_error("Connection attempt for [email protected] failed.");

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
Exemple #2
0
/**
 * Handle input command.
 *
 * This function should return 0, even if the command failed.
 * Return of != 0 means the event loop will quit.
 */
static int handle_input_command(const dstring* string) {
	dstrlist* list;
	dstring** argv;
	unsigned int argc;
	int error;
	ENetPacket* packet;


	if (string->len == 0) {
		/* empty command */
		return 0;
	} else if (string->data[0] == '/') {
		/* local command */
		/* parse the command */
		list = dstrlex_parse(string, &error);
		if (list == NULL) {
			fprintf(stderr, "Failed to parse command string '%s': %s\n", string->data, dstrlex_errstr(error));
			return 0;
		}

		/* convert list to vector */
		argc = list->size;
		argv = dlist_tovector(list);
		dlist_free(list);

		/* select command to execute */
		if (dcmpcs(argv[0], "/connect") == 0) {
			error = cmd_connect(argc, argv);
		} else if (dcmpcs(argv[0], "/disconnect") == 0) {
			error = cmd_disconnect(argc, argv);
		} else if (dcmpcs(argv[0], "/quit") == 0) {
			error = cmd_quit(argc, argv);
		} else if (dcmpcs(argv[0], "/mute") == 0) {
			error = cmd_mute(argc, argv);
		} else if (dcmpcs(argv[0], "/deafen") == 0) {
			error = cmd_deafen(argc, argv);
		} else {
			fprintf(stderr, "Unknown command '%s'\n", argv[0]->data);
			error = 0;
		}

		dvec_free(argv);
		return error;
	} else if (client.state == SVCECLIENT_STATE_CONNECTED) {
		/* send to server if connected */
		mutex_lock(&client.network_lock);
		packet = enet_packet_create(string->data, string->len, ENET_PACKET_FLAG_RELIABLE);
		enet_peer_send(client.client, 0, packet);
		mutex_unlock(&client.network_lock);
	} else if (client.state == SVCECLIENT_STATE_CONNECTING) {
		/* server command but still connecting */
		fprintf(stderr, "Can't send command to server, still connecting.\n");
	} else {
		/* server command but not connected */
		fprintf(stderr, "Can't send command to server, not connected.\n");
	}


	return 0;
}
void cmd_connect_lowercases_argument(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    gchar *args[] = { "*****@*****.**", NULL };

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_string(accounts_get_account, name, "*****@*****.**");
    will_return(accounts_get_account, NULL);

    will_return(ui_ask_password, strdup("password"));

    expect_cons_show("Connecting as [email protected]");

    expect_any(jabber_connect_with_details, jid);
    expect_any(jabber_connect_with_details, passwd);
    expect_any(jabber_connect_with_details, altdomain);
    expect_any(jabber_connect_with_details, port);
    will_return(jabber_connect_with_details, JABBER_CONNECTING);

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
void cmd_connect_with_server_and_port_when_provided(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    gchar *args[] = { "*****@*****.**", "port", "5432", "server", "aserver", NULL };

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_string(accounts_get_account, name, "*****@*****.**");
    will_return(accounts_get_account, NULL);

    will_return(ui_ask_password, strdup("password"));

    expect_cons_show("Connecting as [email protected]");

    expect_string(jabber_connect_with_details, jid, "*****@*****.**");
    expect_string(jabber_connect_with_details, passwd, "password");
    expect_string(jabber_connect_with_details, altdomain, "aserver");
    expect_value(jabber_connect_with_details, port, 5432);
    will_return(jabber_connect_with_details, JABBER_CONNECTING);

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
int main(int argc, const char *argv[])
{
    if (cpn_global_init() < 0)
        return -1;

    if (cpn_opts_parse_cmd(opts, argc, argv) < 0) {
        return -1;
    }

    switch (cpn_opts_get(opts, 'v', NULL)->counter) {
        case 0:
            cpn_log_set_level(LOG_LEVEL_ERROR);
            break;
        case 1:
            cpn_log_set_level(LOG_LEVEL_WARNING);
            break;
        case 2:
            cpn_log_set_level(LOG_LEVEL_VERBOSE);
            break;
        case 3:
            cpn_log_set_level(LOG_LEVEL_TRACE);
            break;
        default:
            break;
    }

    if (cpn_cfg_parse(&cfg, cpn_opts_get(opts, 'c', NULL)->string) < 0) {
        printf("Could not parse config '%s", cpn_opts_get(opts, 'c', NULL)->string);
        return -1;
    }

    if (cpn_sign_keys_from_config(&local_keys, &cfg) < 0) {
        puts("Could not keys from config");
        return -1;
    }

    memcpy(&remote_key, &cpn_opts_get(opts, 0, "--remote-key")->sigkey, sizeof(struct cpn_sign_pk));
    remote_host = cpn_opts_get(opts, 0, "--remote-host")->string;
    remote_port = cpn_opts_get(opts, 0, "--remote-port")->uint32;

    if (cpn_opts_get(opts, 0, "query"))
        return cmd_query();
    else if (cpn_opts_get(opts, 0, "request"))
        return cmd_request(cpn_opts_get(request_opts, 0, "--service-type")->string,
                &cpn_opts_get(request_opts, 0, "--parameters")->stringlist);
    else if (cpn_opts_get(opts, 0, "connect"))
        return cmd_connect(cpn_opts_get(connect_opts, 0, "--service-type")->string,
               cpn_opts_get(connect_opts, 0, "--session-id")->uint32,
               cpn_opts_get(connect_opts, 0, "--session-cap")->string);
    else if (cpn_opts_get(opts, 0, "terminate"))
        return cmd_terminate(cpn_opts_get(terminate_opts, 0, "--session-id")->uint32,
                cpn_opts_get(terminate_opts, 0, "--session-cap")->string);
    else
        puts("No action specified");

    return 0;
}
static void test_with_connection_status(jabber_conn_status_t status)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));

    will_return(jabber_get_connection_status, status);

    expect_cons_show("You are either connected already, or a login is in process.");

    gboolean result = cmd_connect(NULL, NULL, *help);
    assert_true(result);

    free(help);
}
void cmd_connect_shows_message_when_port_contains_chars(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    gchar *args[] = { "*****@*****.**", "port", "52f66", NULL };

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_cons_show("Could not convert \"52f66\" to a number.");
    expect_cons_show("");

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
void cmd_connect_shows_message_when_port_65536(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    gchar *args[] = { "*****@*****.**", "port", "65536", NULL };

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_cons_show("Value 65536 out of range. Must be in 1..65535.");
    expect_cons_show("");

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
void cmd_connect_shows_usage_when_no_port_value(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    help->usage = "some usage";
    gchar *args[] = { "*****@*****.**", "port", NULL };

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_cons_show("Usage: some usage");
    expect_cons_show("");

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
Exemple #10
0
void cmd_connect_connects_with_account(void **state)
{
    CommandHelp *help = malloc(sizeof(CommandHelp));
    gchar *args[] = { "jabber_org", NULL };
    ProfAccount *account = account_new("jabber_org", "*****@*****.**", "password", NULL,
        TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL);

    will_return(jabber_get_connection_status, JABBER_DISCONNECTED);

    expect_any(accounts_get_account, name);
    will_return(accounts_get_account, account);

    expect_cons_show("Connecting with account jabber_org as [email protected]");

    expect_memory(jabber_connect_with_account, account, account, sizeof(account));
    will_return(jabber_connect_with_account, JABBER_CONNECTING);

    gboolean result = cmd_connect(NULL, args, *help);
    assert_true(result);

    free(help);
}
Exemple #11
0
int main(void)
{
	int cmd;
	
	/* initialize window size to defult */
	window_size = DEFAULT_WINDOW_SIZE;
	
	message_to_send = NULL;
	
	/*pthread_t pthread_id[2];
	pthread_attr_t attr;*/
	
	/* 
	 * start named pipe, this is where the host will receive user commands.
	 * it will be a producer/consumer design. pipe name should be passed as
	 * command-line argument
	 */
	create_pipe(PIPE_NAME);
	int pipe = open_pipe(PIPE_NAME, O_RDONLY);

	
	/*
	 * open a socket to do the communication. packet transaction will be 
	 * simulated above a normal connection.
	 */
	if (HOST == HOST_A)
	{
		open_socket();
		send_message_to_other("Hello Client! You can start your simulation.");
		get_message_from_other();
		printf("\n\n\n");
	}
	else 
	{
		open_connection();
		get_message_from_other();
		send_message_to_other("Hi Server.");
		printf("\n\n\n");
	}


	/*
	 * once connection is stablished we can start the SIM STATE MACHINE.
	 * our state machine will start in CLOSED 
	 */
	host_state = STATE_CLOSED;
	
	host_seq_number = rand();
	
	/*
	 * at this point we need to start our threads that will exchange 
	 * messages with the other host.
	 */
	
	/* thread to construct packets */
	pthread_t pthread_id[10];
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

	pthread_create(&pthread_id[0], 
		       &attr, 
		       (void *) &send_stuff_thread,
		       (void *) NULL);
	/*
	
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	
	pthread_create(&pthread_id[0], &attr, 
		       (void *)&receive_tcp_packet_from_other, NULL);
	*/
	

	/* loop until gets work to do */
	while (TRUE)
	{
		/* 
		 * get work from console. this is the link we have with the
		 * outside world (client)
		 */
		fflush(stdout);
		cmd = get_work(pipe);

		int  read_size;
		char buf[MAX_PIPE_DATA_SIZE];
		
		switch (cmd)
		{
			case CMD_LISTEN:
				printf("got CMD_LISTEN\n");
				cmd_listen();
				break;

			case CMD_CONNECT:
				printf("got CMD_CONNECT\n");
				cmd_connect();
				break;
				
			case CMD_SEND_PKT:
				printf("got CMD_SEND_PKT\n");
				
				sleep(1);
				
				/* get message to send over */
				while ((read_size = pipe_read(pipe, buf)) < 1);
								
				message_to_send = malloc(read_size * sizeof(char));
				strncpy(buf, message_to_send, read_size);
				
				break;
				
			case CMD_CHNG_WINDOW_SIZE:				
				printf("changed window size to %d\n", window_size);
				
				break;

			case CMD_CLOSE:
				break;

			/* ACK packet */
				
			default:
				printf("did not recognize cmd!\n");
		}
			 
	}

}
Exemple #12
0
static void mapidcom()
//Communicates with clients through IPC
{
	fd_set active_fd_set; // active file descriptor list
	fd_set read_fd_set; // temp file descriptor list for select()
	int fdmax; // maximum file descriptor number
	int yes = 1; // for setsockopt() SO_REUSEADDR, below
	struct sockaddr_un mapidaddr;
	struct sockaddr_un remoteaddr;
	struct mapiipcbuf qbuf;
	socklen_t addrlen;
	int nbytes, len, s;
	struct client *cl= NULL;
	flist_node_t *tmpnode;
	conf_category_entry_t *cat=NULL;
	char *local;
	struct group *mapi_group;
  conf_category_t *conf;

	mapidsocket=strdup(MAPIDSOCKGLOBAL);

	if ((conf = pc_load(mapid_conf)) != NULL) {
		cat = pc_get_category(conf, "");
		local=pc_get_param(cat, "local");
		if (local!=NULL && strcmp(local, "1")==0) {
			free(mapidsocket);
			mapidsocket=printf_string(MAPIDSOCKHOME, getenv("HOME") );
		}
		pc_close(conf);

	}
	//  create the listener socket
	if ((listenerfd = socket(AF_LOCAL, SOCK_STREAM, 0)) == -1) {
		DEBUG_CMD(Debug_Message("ERROR: socket: %s", strerror(errno)));
		exit(EXIT_FAILURE);
	}
	// avoid "address already in use" error message
	if (setsockopt(listenerfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int))
			== -1) {
		DEBUG_CMD(Debug_Message("ERROR: setsockopt: %s", strerror(errno)));
		exit(EXIT_FAILURE);
	}
	//  set up the address we will be binding to
	memset(&mapidaddr, 0, sizeof (mapidaddr));
	mapidaddr.sun_family = AF_LOCAL;

	memcpy(mapidaddr.sun_path, mapidsocket, strlen(mapidsocket)+1);
	unlink(mapidsocket);

	len = sizeof mapidaddr.sun_family + strlen(mapidaddr.sun_path);
	if (bind(listenerfd, (struct sockaddr *) &mapidaddr, len)) {
		DEBUG_CMD(Debug_Message("ERROR: bind: %s", strerror(errno)));
		exit(EXIT_FAILURE);
	}

	// allow any member of our own group to connect
	chmod(mapidsocket, S_IRWXU | S_IRWXG);

	// if a mapi user group exists, set group permissions accordingly,
	// otherwise the group ID will be equal to the user ID of the user that
	// invoked mapid
	mapi_group = getgrnam(MAPI_GROUP_NAME);
	if (mapi_group != NULL) {
		chown(mapidsocket, -1, mapi_group->gr_gid);
	}

	if (listen(listenerfd, BACKLOG) == -1) {
		DEBUG_CMD(Debug_Message("ERROR: listen: %s", strerror(errno)));
		exit(EXIT_FAILURE);
	}

	FD_ZERO (&active_fd_set);
	// add the listener to the active set
	FD_SET (listenerfd, &active_fd_set)
;
  // keep track of the biggest file descriptor
  		fdmax = listenerfd; // so far, it's just this one

	// wait for commands from the mapi stub, for ever...
	while (1) {
		read_fd_set = active_fd_set; // copy it
		if (select(fdmax + 1, &read_fd_set, NULL, NULL, NULL) == -1) {
			DEBUG_CMD(Debug_Message("ERROR: select: %s", strerror(errno)));
			break;
		}

		// run through the existing connections
		for (s = 0; s <= fdmax; s++) {
			if (FD_ISSET (s, &read_fd_set)) {

				// connection on the original listener socket
				if (s == listenerfd) {
					addrlen = sizeof (remoteaddr);
					if ((newfd = accept(listenerfd,
							(struct sockaddr *) &remoteaddr, &addrlen)) == -1) {
						DEBUG_CMD(Debug_Message("accept: %s", strerror(errno)));
					} else {
						FD_SET (newfd, &active_fd_set)
;						// add to active set
						if (newfd > fdmax)
						{ // keep track of the maximum
							fdmax = newfd;
						}
					}
				}
				// handle data from an existing client
				else
				{
					if ((nbytes = recv (s, &qbuf, MAX_SEND_SIZE, 0)) <= 0)
					{
						if (nbytes == 0)
						{
							// connection closed - find client's pid
							while(__sync_lock_test_and_set(&clientlist_lock,1));
							tmpnode = (flist_node_t *) flist_head (clientlist);

							cl = NULL;
							while (tmpnode != NULL)
							{
								if (((struct client *) tmpnode->data)->sock == s)
								{
									cl = (struct client *) tmpnode->data;
									break;
								}
								tmpnode = flist_next (tmpnode);
							}
							clientlist_lock = 0;

							if (cl == NULL)
							{/* This is not interesting, as it will occur upon requests from clients without flows etc.
							 WARNING_CMD (printf
							 ("WARNING: Zero bytes from socket %d [%s:%d]\n",
							 s, __FILE__, __LINE__));
							 */
								/* shouldn't really exit here? 
								 * this will cause the program to exit on errors with an empty
								 * client-list which isn't really an error (IMHO)
								 */
								//exit(EXIT_FAILURE);
							}
							else
							{
								while(__sync_lock_test_and_set(&clientlist_lock,1));
								//clean up any remaining flows
								tmpnode = (flist_node_t *) flist_head (cl->flowlist);
								while (tmpnode != NULL)
								{
									cleanup_flow ((struct flow *) tmpnode->data);
									tmpnode = flist_next (tmpnode);
								}
								tmpnode = (flist_node_t *) flist_head (cl->devicelist);
								while (tmpnode != NULL)
								{
									mapidrv_delete_device = get_drv_funct (tmpnode->data, "mapidrv_delete_device");
									mapidrv_delete_device (tmpnode->id);
									tmpnode = flist_next (tmpnode);
								}
								flist_destroy (cl->flowlist);
								flist_destroy (cl->devicelist);
								free(cl->devicelist);
								free (cl->flowlist);
								//remove this client from global client list
								free(flist_remove (clientlist, cl->pid));
								clientlist_lock = 0;
							}
						}
						else
						{
							DEBUG_CMD(Debug_Message("WARNING: recv: %s at", strerror (errno)));
						}
						close (s);
						FD_CLR (s, &active_fd_set); // remove it from active set
					}
					else
					{
						// we got some data from a client: process request
						switch (qbuf.cmd)
						{
							case GET_LIBS:
							cmd_get_libs (qbuf.pid, s);
							break;
							case GET_LIBPATH:
							cmd_get_libpath (qbuf.pid, s);
							break;
							case CREATE_FLOW:
							cmd_create_flow ((char *)qbuf.data, qbuf.pid, qbuf.uid, s);
							break;
							case CLOSE_FLOW:
							cmd_close_flow (qbuf.fd, qbuf.pid, s, 1);
							break;
							case GET_FLOW_INFO:
							cmd_get_flow_info (qbuf.fd, qbuf.pid, s);
							break;
							case GET_FUNCTION_INFO:
							cmd_get_function_info (qbuf.fd, qbuf.fid, qbuf.pid, s);
							break;
							case GET_NEXT_FUNCTION_INFO:
							cmd_get_next_function_info (qbuf.fd, qbuf.fid, qbuf.pid, s);
							break;
							case GET_NEXT_FLOW_INFO:
							cmd_get_next_flow_info (qbuf.fd, qbuf.pid, s);
							break;
							case GET_NEXT_DEVICE_INFO:
							cmd_get_next_device_info (qbuf.fd, qbuf.pid, s);
							break;
							case GET_DEVICE_INFO:
							cmd_get_device_info (qbuf.fd, qbuf.pid, s);
							break;
						case MAPI_STATS:
						  cmd_stats ((char *)qbuf.data, qbuf.pid, qbuf.uid, s);
						  break;
							case APPLY_FUNCTION:
							cmd_apply_function (&qbuf, qbuf.pid, s);
							break;
							case READ_RESULT:
							cmd_read_results (qbuf.fd, qbuf.fid, qbuf.pid, s);
							break;
							case CONNECT:
							cmd_connect (qbuf.fd, qbuf.pid, s);
							break;
							case CREATE_FLOW_ACK:
							case APPLY_FUNCTION_ACK:
							case READ_RESULT_ACK:
							case CONNECT_ACK:
							case CLOSE_FLOW_ACK:
							case SET_AUTHDATA_ACK:
							break;
							case READ_ERROR_ACK:
							break;
							case ERROR_ACK:
							break;
							case CREATE_OFFLINE_DEVICE:
							cmd_create_offline_device ((char *)qbuf.data, qbuf.fid, qbuf.pid, s);
							break;
							case CREATE_OFFLINE_DEVICE_ACK:
							break;
							case START_OFFLINE_DEVICE:
							cmd_start_offline_device ((char *)qbuf.data, qbuf.pid, s);
							break;
							case START_OFFLINE_DEVICE_ACK:
							break;
							case DELETE_OFFLINE_DEVICE:
							cmd_delete_offline_device ((char *)qbuf.data, qbuf.pid, s);
							break;
							case DELETE_OFFLINE_DEVICE_ACK:
							break;
							case CREATE_OFFLINE_FLOW_ACK:
							break;
							case LOAD_LIBRARY:
							cmd_load_library ((char *)qbuf.data, qbuf.pid, s);
							default:
							break;
						}
					}
				}
			}
		} // for
	} // while(1)
}
int main(int argc, char **argv)
{
  char addr[18];
  char *handle, *value;
  int ret, choice;

  printf("*********************************\n");
  printf("**** Nod Labs test framework ****\n");
  printf("*********************************\n");

  /* initialize a glib event loop */
  event_loop = g_main_loop_new(NULL, FALSE);

  printf("Scanning for all BTLE devices in proximity...");
  printf("Press ^C to stop scanning\n");

  if(ret = cmd_lescan(0) < 0) {
    printf("Scanning failed!! Quitting %d\n", ret);
    exit(-1);
  }

  printf("Enter the device to connect: ");
  scanf("%s", addr);

  ret = 0;
  if (ret = cmd_connect(addr, NULL) < 0) {
    printf("Connection failed %d\n", ret);
    exit(-2);
  } else {
    printf("Connected to [%s]\n", addr);
  }

  printf("SERVICES:\n");
  discover_services((gpointer)attrib);

  printf("\nCHARACTERISTICS:\n");
  discover_characteristics((gpointer)attrib, CHAR_START, CHAR_END);

  /* IMP: If the native bluez stack is running while this test runs, then the
   * keys get cached in the system(on which this is running). Next time, when this
   * test case is being run, it will fail to change the security level to
   * anything other than "low". To resolve this issue, we need to check for
   * the paired devices in bluetoothctl (using cmd 'show devices') and remove
   * the device from bluez device cache.
   *
   * HIGH security level is needed for initiating the bonding with the device. This
   * is important as HID services need the link to be encrypted.
   */
  if (cmd_set_sec_level("high") < 0) {
    printf("Failed to set the security level to HIGH\n");
    exit(-1);
  } else {
    printf("Security level set to HIGH\n");
  }

  /* Now, enable battery and nControl notifications in the ring */
  control_service(non_os_indexes, GET_SZ(non_os_indexes), ENABLE_NOTIFICATION);

  /*
   * TODO: Make sure the below mode list is up-to-date with
   * the numbers used in the f/w
   */

  ret = 0;
  printf("Which mode you want to enable?\n");
  printf("1. TTM\n");
  printf("2. Free pointer\n");
  printf("3. OpenSpatial (Pose6D & Buttons)\n");
  printf("0. Exit\n");
  printf("Enter your choice: ");
  scanf("%d", &choice);
  printf("\n");

  if (!choice) {
    exit(0);
  }
  /* update the mode accordingly */
  change_mode((gpointer)attrib, choice);

  /* We have an active connection, with the data ready to be received */
  set_state(STATE_CONNACTIVE);

  /* let the signal handler do necessary cleanup before proceeding to disconnect */
  wait_for_cleanup = 1;

  /* below loop will control the event loop for receiving the data */
  g_main_loop_run(event_loop);

  while (wait_for_cleanup);

  printf("Disconnecting from device [%s]\n", addr);

  cmd_disconnect();

  /* un-initialize glib event loop */
  g_main_loop_unref(event_loop);

  return 0;
}