C++ create_client函数代码示例

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);
}