int main (int argc, char **argv)
{
  gsk_init_without_threads (&argc, &argv);

  g_printerr ("TCP/IP server/client... ");
  addr = gsk_socket_address_ipv4_localhost (10306);
  create_server (addr);
  client_count = 0;
  create_client (addr);
  while (!done_test)
    gsk_main_loop_run (gsk_main_loop_default(), -1, NULL);
  g_object_unref (listener);
  listener = NULL;
  g_object_unref (addr);
  addr = NULL;
  g_printerr (" done.\n");

  client_count = 0;
  done_test = FALSE;

  g_printerr ("Local-socket server/client... ");
#define TEST_LOCAL_SOCKET_FNAME	"./test-socket-sc"
  addr = gsk_socket_address_local_new (TEST_LOCAL_SOCKET_FNAME);
  create_server (addr);
  client_count = 0;
  create_client (addr);
  while (!done_test)
    gsk_main_loop_run (gsk_main_loop_default(), -1, NULL);
  g_object_unref (listener);
  g_object_unref (addr);
  g_printerr (" done.\n");

  return 0;
}

static void
scan_wins(void) {
	int i;
	uint num;
	XWindow *wins;
	XWindowAttributes wa;
	XWindow d1, d2;

	if(XQueryTree(display, scr.root.w, &d1, &d2, &wins, &num)) {
		for(i = 0; i < num; i++) {
			if(!XGetWindowAttributes(display, wins[i], &wa))
				continue;
			if(wa.override_redirect || XGetTransientForHint(display, wins[i], &d1))
				continue;
			if(wa.map_state == IsViewable)
				create_client(wins[i], &wa);
		}
		for(i = 0; i < num; i++) {
			if(!XGetWindowAttributes(display, wins[i], &wa))
				continue;
			if((XGetTransientForHint(display, wins[i], &d1))
			&& (wa.map_state == IsViewable))
				create_client(wins[i], &wa);
		}
	}
	if(wins)
		XFree(wins);
}

/* work starts here */
int main (int argc, char **argv) {
    int rc;

    /*
     * allocate options structure
     * and parse command line
     */
    if(parse_arguments(argc, argv) != GM_OK) {
        print_usage();
        exit( STATE_UNKNOWN );
    }

    /* set logging */
    mod_gm_opt->debug_level = GM_LOG_INFO;
    mod_gm_opt->logmode     = GM_LOG_MODE_TOOLS;

    /* init crypto functions */
    if(mod_gm_opt->encryption == GM_ENABLED) {
        mod_gm_crypt_init(mod_gm_opt->crypt_key);
    } else {
        mod_gm_opt->transportmode = GM_ENCODE_ONLY;
    }

    /* create client */
    if ( create_client( mod_gm_opt->server_list, &client ) != GM_OK ) {
        printf( "send_gearman UNKNOWN: cannot start client\n" );
        exit( STATE_UNKNOWN );
    }
    current_client = &client;

    /* create duplicate client */
    if ( mod_gm_opt->dupserver_num > 0 ) {
        if ( create_client( mod_gm_opt->dupserver_list, &client_dup ) != GM_OK ) {
            printf( "send_gearman UNKNOWN: cannot start client for duplicate server\n" );
            exit( STATE_UNKNOWN );
        }
    }
    current_client_dup = &client_dup;

    /* send result message */
    signal(SIGALRM, alarm_sighandler);
    rc = send_result();

    gearman_client_free( &client );
    if( mod_gm_opt->dupserver_num )
        gearman_client_free( &client_dup );
    mod_gm_free_opt(mod_gm_opt);

    exit( rc );
}

int main(int argc, char *argv[])
{
    client_t *c;

    c = create_client(argv[0]);

    if (c == NULL) {
        fprintf(stderr, "Failed to create client.");
        exit(1);
    }

    parse_cmdline(c, argc, &argv[0]);
    create_mainloop(c);
    setup_signals(c);
    setup_input(c);

    if (c->glib)
        print(c, "Using GMainLoop...");
    else
        print(c, "Using pa_manloop...");

    run_mainloop(c);
    cleanup_input(c);
    destroy_client(c);

    return 0;
}

int			main(int ac, char **av)
{
  if (ac == 1 || ac > 3)
    {
      printf("USAGE : ./client machine [port]\n");
      exit(0);
    }
  if (ac == 2)
    {
      printf("You try to connect on default port 4242\n");
      create_client(av[1], "4242");
    }
  else
    create_client(av[1], av[2]);
  return (0);
}

int main(int argc, char *argv[])
{
    if (argc < 3) {
        usage();
    }
    if (getenv("NOPOLL_TEST_DEBUG"))
        debug_local = 1;
    if (getenv("NOPOLL_TEST_DEBUG_NOPOLL"))
        debug_nopoll = 1;

    if (strcmp(argv[1], "server") == 0) {
        return create_listener(argv[2]);
    }
    else if (strcmp(argv[1], "client") == 0) {
        if (argc < 6)
            usage();
        instanceID = strdup(argv[2]);
        const char * host = argv[3];
        const char * port = argv[4];
        int duration = atoi(argv[5]);
        if (duration <= 0) {
            printf("Duration should be greater than 0 seconds.\n");
            usage();
        }
        return create_client(host, port, duration);
    }
    else {
        printf("First argument should be  \"server\" or \"client\"\n");
        exit(1);
    }
}

int		main(int argc, char **argv)
{
	int		port;
	int		sock;
	char	*input;
	char	*buf;
	int		r;

	if (argc != 3)
	{
		printf("Usage: %s <addr> <port>\n", argv[0]);
		return (-1);
	}
	port = atoi(argv[2]);
	sock = create_client(argv[1], port);
	while (42)
	{
		ft_putstr("$> ");
		if (get_next_line(1, &input))
			exec_input(input, sock);
		while ((r = recv(sock, buf, 1023, 0)) > 0)
		{
			buf[r] = '\0';
			ft_putstr_fd(buf, 2);
		}
	}
	close(sock);
	return (0);
}

/**launch handler for each incoming connection. */
static void start_child(ICI *d, int fd, char *rh, unsigned short rp) {
  pthread_mutex_lock(&d->lock);
  d->num_clients++;
  if (d->num_clients > d->max_clients) d->max_clients = d->num_clients;
  pthread_mutex_unlock(&d->lock);

  CONN *c = calloc(1, sizeof(CONN));
  c->run = 1;
  c->fd = fd;
  c->d = d;
  c->client_address = strdup(rh);
  c->client_port = rp;
#ifdef SOCKET_WRITE
  c->cq = NULL;
#endif
  c->userdata = NULL;

  if(create_client(&socket_handler, c)) {
    if(fd >= 0)
#ifndef HAVE_WINDOWS
      close(fd);
#else
      closesocket(fd);
#endif
    dlog(DLOG_ERR, "SRV: Protocol handler child fork failed\n");
    pthread_mutex_lock(&d->lock);
    d->num_clients--;
    pthread_mutex_unlock(&d->lock);
    free(c);
    debugmsg(DEBUG_SRV, "SRV: Connection terminated: now %i connections active\n", d->num_clients);
    return;
  }
  debugmsg(DEBUG_SRV, "SRV: Connection started: now %i connections active\n", d->num_clients);
}

void serve(int serverfd) {
    int maxfd = 0;
    struct sockaddr_in addr;
    socklen_t addrlen = sizeof(struct sockaddr_in);
    struct timeval timeout;

    memset(&addr, 0, sizeof(struct sockaddr_in));

    while(1) {
        fd_set fds;

        FD_ZERO(&fds);
        FD_SET(serverfd, &fds);

        if(serverfd >= maxfd)
            maxfd = serverfd + 1;

        timeout.tv_sec = 5;
        timeout.tv_usec = 0;

        /* listen for new clients */
        if(select(maxfd, &fds, NULL, NULL, &timeout) > 0 && FD_ISSET(serverfd, &fds)) {
            int clientfd = accept(serverfd, (struct sockaddr *) &addr, &addrlen);
            if(clientfd == -1) {
                perror("accept()");
                continue;
            }

            create_client(clientfd, &addr, &addrlen);
        }

        reap_messages();
    }
}

void
Avahi::PresencePublisher::client_callback (AvahiClient* client_,
					   AvahiClientState state)
{
  if (client_ == NULL)
    return;

  client = client_;

  switch (state) {

  case AVAHI_CLIENT_FAILURE:

    if (avahi_client_errno (client) == AVAHI_ERR_DISCONNECTED) {

      free_client ();
      create_client ();
    }
    break;
  case AVAHI_CLIENT_S_RUNNING:

    register_services ();
    break;

  case AVAHI_CLIENT_S_REGISTERING:
  case AVAHI_CLIENT_S_COLLISION:
  case AVAHI_CLIENT_CONNECTING:
  default:
    break; // nothing
  }
}

                    /**
                     * Allows to start the translation process
                     */
                    inline void start() {
                        //Define and initialize the attempt counter
                        size_t attempt = 0;

                        //Make several re-connection attempts 
                        while (true) {
                            //Create a new client
                            create_client();
                            LOG_INFO1 << "Attempting to connect to the server!" << END_LOG;
                            if (m_client->connect()) {
                                LOG_INFO << "Starting creating and sending out " << m_name << " jobs!" << END_LOG;

                                //Run the translation job sending thread
                                m_sending_thread_ptr = new thread(bind(&client_manager::send_requests, this));

                                //Stop the loop as we did connect.
                                break;
                            } else {
                                if (attempt >= MAX_NUM_CONNECTION_ATTEMPTS) {
                                    THROW_EXCEPTION(string("Tried ") + to_string(attempt) +
                                            string(" times but could not open the connection to: ") + m_uri);
                                } else {
                                    LOG_INFO2 << "Could not connect, attempt: " << attempt << "/"
                                            << MAX_NUM_CONNECTION_ATTEMPTS << ", timeout: "
                                            << RE_CONNECTION_TIME_OUT_MILLISEC << " milliseconds" << END_LOG;
                                    //Increment the attempts counter
                                    ++attempt;
                                    //Sleep some time before trying to re-connect
                                    std::this_thread::sleep_for(std::chrono::milliseconds(RE_CONNECTION_TIME_OUT_MILLISEC));
                                }
                            }
                        }
                    }

static bool_t IDCCallback_Bound_m (
	IDCCallback_cl	       *self,
	IDCOffer_clp	        offer	/* IN */,
	IDCServerBinding_clp	binding /* IN */,
	Domain_ID	        dom	/* IN */,
	ProtectionDomain_ID	pdid	/* IN */,
	const Binder_Cookies   *clt_cks	/* IN */,
	Type_Any	       *server  /* INOUT */ )
{
    ext2fs_st *st = self->st;
    Client_st *c;

    /* A client has finished binding. We need to invent a server. */
    TRC(printf("ext2fs: accepted connection from dom %qx\n",dom));

    c=Heap$Malloc(st->heap, sizeof(*c));
    if (!c) {
	printf("ext2fs: out of memory while accepting connection from %qx\n",
	       dom);
	return False;
    }

    if (!create_client(st,c,binding)) {
	printf("ext2fs: aargh, client create failed. Rejecting connection.\n");
	FREE(c);
	return False;
    }

    /* XXX: concurrency? */
    LINK_ADD_TO_HEAD(&st->client.clients, c);

    ANY_INIT(server, Ext2_clp, &c->cl);

    return True;
}

int main(int argc, char **argv) 
{
	CLIENT client_struct, *c;
        FLICK_SERVER_LOCATION s;
	int sel, done;
	
	c = &client_struct;
	
	if (argc != 2) {
		fprintf(stderr, "Usage: %s <host>\n", argv[0]);
		exit(1);
	}
	
	s.server_name = argv[1];
	s.prog_num = netphone;
	s.vers_num = firstphone;
	create_client(c, s);
	
	done = 0;
	while (!done) {
		read_integer(("\n(1) Add an entry (2) Remove an entry "
			      "(3) Find a phone number (4) Exit: "),
			     &sel);
		switch(sel) {
		case 1:  add_entry(c); break;
		case 2:  remove_entry(c); break;
		case 3:  find_entry(c); break;
		case 4:  done = 1; break;
		default: printf("Please enter 1, 2, 3, or 4.\n");
		}
	}
	return 0;
}

void virtual_stream_create(const char * type, const char * context_id, size_t buf_len, unsigned access,
        VirtualStreamCallBack * callback, void * callback_args, VirtualStream ** res) {
    LINK * l;
    VirtualStream * stream = loc_alloc_zero(sizeof(VirtualStream));

    buf_len++;
    list_init(&stream->clients);
    strncpy(stream->type, type, sizeof(stream->type) - 1);
    stream->magic = STREAM_MAGIC;
    stream->id = id_cnt++;
    stream->access = access;
    stream->callback = callback;
    stream->callback_args = callback_args;
    stream->ref_cnt = 1;
    stream->buf = loc_alloc(buf_len);
    stream->buf_len = buf_len;
    for (l = subscriptions.next; l != &subscriptions; l = l->next) {
        Subscription * h = all2subscription(l);
        if (strcmp(type, h->type) == 0) {
            Trap trap;
            create_client(stream, h->channel);
            if (set_trap(&trap)) {
                send_event_stream_created(&h->channel->out, stream, context_id);
                clear_trap(&trap);
            }
            else {
                trace(LOG_ALWAYS, "Exception sending stream created event: %d %s",
                      trap.error, errno_to_str(trap.error));
            }
        }
    }
    list_add_first(&stream->link_all, &streams);
    *res = stream;
}

static void test_pending_calls(size_t concurrent_calls) {
  size_t i;
  grpc_call **calls;
  grpc_channel *client;
  request_data rdata;
  servers_fixture *f;
  test_spec *spec = test_spec_create(0, 4);
  rdata.call_details =
      gpr_malloc(sizeof(grpc_call_details) * spec->num_servers);
  f = setup_servers("127.0.0.1", &rdata, spec->num_servers);

  client = create_client(f);
  calls = perform_multirequest(f, client, concurrent_calls);
  grpc_call_cancel(
      calls[0],
      NULL); /* exercise the cancel pick path whilst there are pending picks */

  gpr_free(rdata.call_details);

  grpc_channel_destroy(client); /* calls the LB's shutdown func */
  /* destroy the calls after the channel so that they are still around for the
   * LB's shutdown func to process */
  for (i = 0; i < concurrent_calls; i++) {
    grpc_call_destroy(calls[i]);
  }
  gpr_free(calls);
  teardown_servers(f);
  test_spec_destroy(spec);
}

int		main(int ac, char **av)
{
	t_client		all_c;
	struct hostent	*hp;
	struct in_addr	**addr_list;

	if (ac != 3)
		ft_error_client(USG, av[0]);
	if ((hp = gethostbyname(av[1])) == NULL)
	{
		ft_putendl("\033[1;31m-- Connect to the server ERROR --\033[00m");
		exit(2);
	}
	addr_list = (struct in_addr **)hp->h_addr_list;
	ft_init_client(&all_c, av, inet_ntoa(*addr_list[0]));
	create_client(inet_ntoa(*addr_list[0]), &all_c);
	while (all_c.quit == 0 && ft_put_prompt(&all_c))
	{
		if (get_next_line(0, &(all_c).line) > 0)
		{
			brain_client(&all_c);
			free(all_c.line);
		}
	}
	close(all_c.sock);
	return (0);
}

int		main(int argc, char **argv)
{
	t_client			clt;
	char				*line;
	char				*addr;

	if (argc != 3)
		usage_client(argv[0]);
	clt.port = atoi(argv[2]);
	printf("port : %d \n", clt.port);
	if ((addr = get_addr(argv[1])) == NULL)
		usage_client(argv[0]);
	clt.sock = create_client(addr, clt.port);
	clt.home = getcwd(NULL, 0);
	while (1)
	{
		ft_putstr("Plait-il ?>");
		get_next_line(0, &line);
		hub_client(line, clt);
		free(line);
		line = NULL;
	}
	close(clt.sock);
	return (0);
}

void device::work()
{
    load_options();
    create_client();
    delegate_all();
    initialize_device();
}

int
main(int argc, char **argv)
{
    int optidx	= 0;

    setprogname (argv[0]);

    if (getarg (args, sizeof(args) / sizeof(args[0]), argc, argv, &optidx))
	usage (1);

    if (help_flag)
	usage (0);

    if (version_flag) {
	print_version (NULL);
	return 0;
    }

    if (optidx != argc)
	usage (1);

    if (port_str) {
	char *ptr;

	port = strtol (port_str, &ptr, 10);
	if (port == 0 && ptr == port_str)
	    errx (1, "Bad port `%s'", port_str);
    }

    krb5_init_context(&context);

    {
	const char *lf = logfile_str;
	if (lf == NULL)
	    lf = "/dev/tty";

	logfile = fopen(lf, "w");
	if (logfile == NULL)
	    err(1, "error opening %s", lf);
    }

    mini_inetd(htons(port), NULL);
    fprintf(logfile, "connected\n");

    {
	struct client *c;

	c = create_client(0, port, moniker_str);
	/* close(0); */

	handleServer(c);

	free_client(c);
    }

    krb5_free_context(context);

    return 0;
}

int inetget_main(const int argc, const wchar_t *const argv[])
{
	//Print application info
	print_logo();

	//Initialize parameters
	Params params;

	//Load configuration file, if it exists
	const std::wstring config_file = Utils::exe_path(L".cfg");
	if(Utils::file_exists(config_file))
	{
		if(!params.load_conf_file(config_file))
		{
			std::wcerr << "Invalid configuration file, refer to the documentation for details!\n" << std::endl;
			return EXIT_FAILURE;
		}
	}

	//Parse command-line parameters
	if(!params.parse_cli_args(argc, argv))
	{
		std::wcerr << "Invalid command-line arguments, type \"INetGet.exe --help\" for details!\n" << std::endl;
		return EXIT_FAILURE;
	}

	//Show help screen, if it was requested
	if(params.getShowHelp())
	{
		print_help_screen();
		return EXIT_SUCCESS;
	}

	//Parse the specified source URL
	const std::wstring source = (params.getSource().compare(L"-") == 0) ? Utils::utf8_to_wide_str(stdin_get_line()) : params.getSource();
	URL url(source);
	if(!url.isComplete())
	{
		std::wcerr << "The specified URL is incomplete or unsupported:\n" << source << L'\n' << std::endl;
		return EXIT_FAILURE;
	}

	//Print request URL
	const std::wstring url_string = url.toString();
	std::wcerr << L"Request address:\n" << url.toString() << L'\n' << std::endl;
	Utils::set_console_title(std::wstring(L"INetGet - ").append(url_string));

	//Create the HTTP(S) client
	std::unique_ptr<AbstractClient> client;
	StatusListener listener;
	if(!create_client(client, listener, url.getScheme(), params))
	{
		std::wcerr << "Specified protocol is unsupported! Only HTTP(S) and FTP are allowed.\n" << std::endl;
		return EXIT_FAILURE;
	}

	//Retrieve the URL
	return retrieve_url(client.get(), url_string, params.getHttpVerb(), url, params.getPostData(), params.getReferrer(), params.getOutput(), params.getSetTimestamp(), params.getUpdateMode(), params.getEnableAlert(), params.getKeepFailed());
}