C++ create_connection函数代码示例

static void
gst_dtls_dec_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstDtlsDec *self = GST_DTLS_DEC (object);

  switch (prop_id) {
    case PROP_CONNECTION_ID:
      g_free (self->connection_id);
      self->connection_id = g_value_dup_string (value);
      g_return_if_fail (self->agent);
      create_connection (self, self->connection_id);
      break;
    case PROP_PEM:
      if (self->agent) {
        g_object_unref (self->agent);
      }
      self->agent = get_agent_by_pem (g_value_get_string (value));
      if (self->connection_id) {
        create_connection (self, self->connection_id);
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (self, prop_id, pspec);
  }
}

void create_client(unsigned int part_size, char *message)
{
	int write_length;

	size_t text_length;
	char text[MAX_MESSAGE_SIZE];

	if (message) {
		text_length = strlen(message);
		
		if (!simulate_sending) {
			create_connection();
			LOG(DEBUG, "Connection created");
		}

		strncpy(text, message, MAX_MESSAGE_SIZE);

		part_size = prepare_connection(text_length, part_size);
		if (part_size == 0)
			die("preparing connection");

		LOG(DEBUG, "{ Message from command line to send: '%s' (%u)", text, text_length);
		write_length = send_message(/*connection, */text, text_length, part_size);
		LOG(DEBUG, "} Message written; packet size: %i", write_length);

		if (!simulate_sending)
			close_connection();

		LOG(INFO, "Nothing more to do. Exiting.");
	} else {

		LOG(INFO, "Type message and press enter");

		for (;;) {
			printf(CLIENT_PROMPT);

			text_length = read_line(text, MAX_MESSAGE_SIZE);

			if (!simulate_sending) {
				create_connection();
				LOG(DEBUG, "Connection created");
			}

			part_size = prepare_connection(text_length, part_size);
			if (part_size == 0)
				die("preparing connection");

			LOG(DEBUG, "Message to send: '%s' (%u)", text, text_length);

			write_length = send_message(/*connection, */text, text_length, part_size);
			//sleep(1); // Prevent client from spamming

			if (!simulate_sending)
				close_connection();
		}

		LOG(INFO, "Server closed connection?");
	}
}

connection_pool::connection_pool(int _size,
                                 const std::string& _host,
                                 const int _port,
                                 const std::string& _username,
                                 const std::string& _zone,
                                 const int _refresh_time)
    : host_{_host}
    , port_{_port}
    , username_{_username}
    , zone_{_zone}
    , refresh_time_(_refresh_time)
    , conn_ctxs_(_size)
{
    if (_size < 1) {
        throw std::runtime_error{"invalid connection pool size"};
    }

    // Always initialize the first connection to guarantee that the
    // network plugin is loaded. This guarantees that asynchronous calls
    // to rcConnect do not cause a segfault.
    create_connection(0,
                      [] { throw std::runtime_error{"connect error"}; },
                      [] { throw std::runtime_error{"client login error"}; });

    // If the size of the pool is one, then return immediately.
    if (_size == 1) {
        return;
    }

    // Initialize the rest of the connection pool asynchronously.

    irods::thread_pool thread_pool{std::min<int>(_size, std::thread::hardware_concurrency())};

    std::atomic<bool> connect_error{};
    std::atomic<bool> login_error{};

    for (int i = 1; i < _size; ++i) {
        irods::thread_pool::post(thread_pool, [this, i, &connect_error, &login_error] {
            if (connect_error.load() || login_error.load()) {
                return;
            }

            create_connection(i,
                              [&connect_error] { connect_error.store(true); },
                              [&login_error] { login_error.store(true); });
        });
    }

    thread_pool.join();

    if (connect_error.load()) {
        throw std::runtime_error{"connect error"};
    }

    if (login_error.load()) {
        throw std::runtime_error{"client login error"};
    }
}

/* Search and connect
 * Returns:
 *   -1 - critical error (exit persist mode)
 *   1  - non critical error
 *   0  - success
 */
static int do_connect(void)
{
	inquiry_info *ii;
	int reconnect = 0;
	int i, n, r = 0;

	do {
		if (reconnect)
			sleep(persist);
		reconnect = 1;

		if (cache.valid > 0) {
			/* Use cached bdaddr */
			r = create_connection(cache.dst, &cache.bdaddr);
			if (r < 0) {
				terminate = 1;
				break;
			}
			continue;
		}

		syslog(LOG_INFO, "Inquiring");

		/* FIXME: Should we use non general LAP here ? */

		ii = NULL;
		n  = hci_inquiry(src_dev, search_duration, 10, NULL, &ii, 0);
		if (n < 0) {
			syslog(LOG_ERR, "Inquiry failed. %s(%d)", strerror(errno), errno);
			continue;
		}

		for (i = 0; i < n; i++) {
			char dst[40];
			ba2str(&ii[i].bdaddr, dst);

			if (use_sdp) {
				syslog(LOG_INFO, "Searching for %s on %s", 
						bnep_svc2str(service), dst);

				if (bnep_sdp_search(&src_addr, &ii[i].bdaddr, service) <= 0)
					continue;
			}

			r = create_connection(dst, &ii[i].bdaddr);
			if (r < 0) {
				terminate = 1;
				break;
			}
		}
		free(ii);
	} while (!terminate && persist);

	return r;
}

/*
** Connects to a data source.
*/
static int env_connect(lua_State *L)
{
  const char *sourcename;
  sqlite3 *conn;
  const char *errmsg;
  int res;
  getenvironment(L);  /* validate environment */

  sourcename = luaL_checkstring(L, 2);

  res = sqlite3_open(sourcename, &conn);
  if (res != SQLITE_OK)
    {
      errmsg = sqlite3_errmsg(conn);
      luasql_faildirect(L, errmsg);
      sqlite3_close(conn);
      return 2;
    }

  if (lua_isnumber(L, 3)) {
  	sqlite3_busy_timeout(conn, lua_tonumber(L,3)); // TODO: remove this
  }

  return create_connection(L, 1, conn);
}

TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_processes_handle_read_as_notify)
{
  // Setup
  const int expected_command = 4673261;

  test_connection_ptr conn = create_connection();

  std::string in_data(256, 'e');

  epee::levin::bucket_head2 req_head;
  req_head.m_signature = LEVIN_SIGNATURE;
  req_head.m_cb = in_data.size();
  req_head.m_have_to_return_data = false;
  req_head.m_command = expected_command;
  req_head.m_flags = LEVIN_PACKET_REQUEST;
  req_head.m_protocol_version = LEVIN_PROTOCOL_VER_1;

  std::string buf(reinterpret_cast<const char*>(&req_head), sizeof(req_head));
  buf += in_data;

  // Test
  ASSERT_TRUE(conn->m_protocol_handler.handle_recv(buf.data(), buf.size()));

  // Check connection and levin_commands_handler states
  ASSERT_EQ(1, m_commands_handler.notify_counter());
  ASSERT_EQ(0, m_commands_handler.invoke_counter());
  ASSERT_EQ(expected_command, m_commands_handler.last_command());
  ASSERT_EQ(in_data, m_commands_handler.last_in_buf());
  ASSERT_LE(0, conn->send_counter());
  ASSERT_TRUE(conn->last_send_data().empty());
}

/* Search and connect
 * Returns:
 *   -1 - critical error (exit persist mode)
 *   1  - non critical error
 *   0  - success
 */
static int do_connect(bdaddr_t* src,bdaddr_t* dst)
{
  //	inquiry_info *ii;
	int reconnect = 0;
	//	int i, n;
	int r = 0;

	do {
		if (reconnect)
			sleep(persist);
		reconnect = 1;

		//TODO if (cache.valid > 0) {
			/* Use cached bdaddr */
			// r = create_connection(cache.dst, &cache.bdaddr);
                        r = create_connection(src,dst);
			if (r < 0) {
				terminate = 1;
				break;
			}
			continue;
		//TODO }

	} while (!terminate && persist);

	return r;
}

/* Handle client connection */
void handle_client(int client_sock, struct sockaddr_in client_addr)
{
    if ((remote_sock = create_connection()) < 0) {
        perror("Cannot connect to host");
        return;
    }

    init_clinet_ssl(remote_sock);//get ssl

    if (fork() == 0) { // a process forwarding data from client to remote socket

        forward_data_up(client_sock, remote_sock);

        exit(0);
    }

    if (fork() == 0) { // a process forwarding data from remote socket to client

        forward_data_down(remote_sock, client_sock);

        exit(0);
    }

    close(remote_sock);
    close(client_sock);

    SSL_free(ssl);
    SSL_CTX_free(ctx);
}

static void hci_link_control(uint16_t ocf, int plen, uint8_t *data)
{
	uint8_t status;

	const uint16_t ogf = OGF_LINK_CTL;

	switch (ocf) {
	case OCF_CREATE_CONN:
		command_status(ogf, ocf, 0x00);
		create_connection(data);
		break;

	case OCF_ACCEPT_CONN_REQ:
		command_status(ogf, ocf, 0x00);
		accept_connection(data);
		break;

	case OCF_DISCONNECT:
		command_status(ogf, ocf, 0x00);
		disconnect(data);
		break;

	default:
		status = 0x01;
		command_complete(ogf, ocf, 1, &status);
		break;
	}
}

/*
** Creates and returns a connection object
** Lua Input: source [, user [, pass]]
**   source: data source
**   user, pass: data source authentication information
** Lua Returns:
**   connection object if successfull
**   nil and error message otherwise.
*/
static int env_connect (lua_State *L) {
	env_data *env = (env_data *) getenvironment (L);
	const char *sourcename = luaL_checkstring (L, 2);
	const char *username = luaL_optstring (L, 3, NULL);
	const char *password = luaL_optstring (L, 4, NULL);
	SQLHDBC hdbc;
	SQLRETURN ret;

	/* tries to allocate connection handle */
	ret = SQLAllocHandle (hDBC, env->henv, &hdbc);
	if (error(ret))
		return luasql_faildirect (L, "connection allocation error.");

	/* tries to connect handle */
	ret = SQLConnect (hdbc, (char *) sourcename, SQL_NTS, 
		(char *) username, SQL_NTS, (char *) password, SQL_NTS);
	if (error(ret)) {
		ret = fail(L, hDBC, hdbc);
		SQLFreeHandle(hDBC, hdbc);
		return ret;
	}

	/* success, return connection object */
	return create_connection (L, 1, env, hdbc);
}

static void
service_added_cb (DMAPMdnsBrowser *browser,
                  DMAPMdnsBrowserService *service,
                  gpointer user_data)
{
	char answer, newline;

	if (NULL == service_name) {
		fprintf (stdout,
		    "service added %s:%s:%s:%d (%s)\n",
		     service->service_name,
		     service->name,
		     service->host,
		     service->port,
		     service->password_protected ? "protected" : "not protected");
		fprintf (stdout, "Stress test this service [Y|N]? ");
		fscanf (stdin, "%c%c", &answer, &newline);
	} else {
		answer = strcmp (service->service_name, service_name) ? 'N' : 'Y';
	}

	if (answer == 'Y') {
		create_connection (dmap_mdns_browser_get_service_type (browser),
				   service->name,
				   service->host,
				   service->port);
	}
}

static void server_loop(void) {
    int rc;

    chip_unipro_init();

    switch_set_local_dev_id(NULL, SWITCH_PORT_ID, LOCAL_DEV_ID);

    dbgprint("Wait for peer...\n");
    chip_reset_before_ready();

    rc = svc_wait_for_peer_ready();
    if (rc) {
        return;
    }

#if _SPECIAL_TEST == SPECIAL_GEAR_CHANGE_TEST
    switch_gear_change(GEAR_HS_G1,
                       TERMINATION_ON,
                       HS_MODE_A,
                       2,
                       POWERMODE_FAST);
#endif

    switch_if_dev_id_set(NULL, PEER_PORT_ID, PEER_DEV_ID);

    create_connection(&conn[0]);
    dbgprint("Control port connected\n");

    gb_control();
    gbboot_process();
#if _SPECIAL_TEST == SPECIAL_GBBOOT_SERVER_STANDBY
    if (stage_to_load == FFFF_ELEMENT_STAGE_2_FW)
        chip_enter_hibern8_server();
#endif
}

    void accept() override {
      auto session = std::make_shared<Session>(create_connection(*io_service, context));

      acceptor->async_accept(session->connection->socket->lowest_layer(), [this, session](const error_code &ec) {
        auto lock = session->connection->handler_runner->continue_lock();
        if(!lock)
          return;

        if(ec != asio::error::operation_aborted)
          this->accept();

        if(!ec) {
          asio::ip::tcp::no_delay option(true);
          error_code ec;
          session->connection->socket->lowest_layer().set_option(option, ec);

          session->connection->set_timeout(config.timeout_request);
          session->connection->socket->async_handshake(asio::ssl::stream_base::server, [this, session](const error_code &ec) {
            session->connection->cancel_timeout();
            auto lock = session->connection->handler_runner->continue_lock();
            if(!lock)
              return;
            if(!ec)
              this->read_request_and_content(session);
            else if(this->on_error)
              this->on_error(session->request, ec);
          });
        }
        else if(this->on_error)
          this->on_error(session->request, ec);
      });
    }

static void server_loop(void) {
    int rc;

    chip_unipro_init();

    switch_set_local_dev_id(NULL, SWITCH_PORT_ID, LOCAL_DEV_ID);

    dbgprint("Wait for peer...\n");
    chip_reset_before_ready();

    rc = svc_wait_for_peer_ready();
    if (rc) {
        return;
    }

    switch_if_dev_id_set(NULL, PEER_PORT_ID, PEER_DEV_ID);

    create_connection(&conn[0]);
    dbgprint("Control port connected\n");

    gb_control();
    gbboot_process();
#ifdef _SIMULATION
    if (stage_to_load == FFFF_ELEMENT_STAGE_2_FW)
        chip_enter_hibern8_server();
#endif
}

static connection_t *_accept_connection(void)
{
    int sock;
    connection_t *con;
    char *ip;
    int serversock; 

    serversock = wait_for_serversock(100);
    if(serversock < 0)
        return NULL;

    /* malloc enough room for a full IP address (including ipv6) */
    ip = (char *)malloc(MAX_ADDR_LEN);

    sock = sock_accept(serversock, ip, MAX_ADDR_LEN);
    if (sock >= 0) {
        con = create_connection(sock, serversock, ip);

        return con;
    }

    if (!sock_recoverable(sock_error()))
        WARN2("accept() failed with error %d: %s", sock_error(), strerror(sock_error()));
    
    free(ip);

    return NULL;
}