static void connect_handler(nsock_pool nsp, nsock_event evt, void *data)
{
enum nse_status status = nse_status(evt);
enum nse_type type = nse_type(evt);
assert(type == NSE_TYPE_CONNECT || type == NSE_TYPE_CONNECT_SSL);
if (status == NSE_STATUS_ERROR) {
loguser("%s.\n", socket_strerror(nse_errorcode(evt)));
exit(1);
} else if (status == NSE_STATUS_TIMEOUT) {
loguser("%s.\n", socket_strerror(ETIMEDOUT));
exit(1);
} else {
assert(status == NSE_STATUS_SUCCESS);
}
#ifdef HAVE_OPENSSL
if (nsi_checkssl(cs.sock_nsi)) {
/* Check the domain name. ssl_post_connect_check prints an
error message if appropriate. */
if (!ssl_post_connect_check((SSL *) nsi_getssl(cs.sock_nsi), o.target))
bye("Certificate verification error.");
}
#endif
connect_report(cs.sock_nsi);
/* Create IOD for nsp->stdin */
if ((cs.stdin_nsi = nsi_new2(nsp, 0, NULL)) == NULL)
bye("Failed to create stdin nsiod.");
post_connect(nsp, nse_iod(evt));
}
int svrapp::mgr_disconnect(app_connection *n, int reason){
server_info * s = (server_info*)n->get_context();
ipaddr & peer = n->get_peeraddr();
uint now = (uint)time(NULL);
for(int index = 0; index < max_group_count; index++){
std::map<uint, device_s> & temp = m_devmap[index];
std::map<uint, device_s>::iterator it = temp.begin();
for(; it != temp.end(); it++){
if (it->second.server_id == s->get_id()){
it->second.state = em_offline;
it->second.reason = reason_server_off;
it->second.server_id = 0;
it->second.off_tm = now;
it->second.off_times++;
}
}
}
m_svrmap.erase(s->get_id());
log_out(log_warn, "mgr_disconnect::server %s:%d reason %d\n", peer.ip, peer.port, reason);
post_connect(peer.ip, peer.port, s->get_interval(), s);
return 0;
}
int svrapp::mgr_disconnect(app_connection *n, int reason){
server_info * sif = (server_info*)n->get_context();
ipaddr & peer = n->get_peeraddr();
m_svrmap.erase(sif->get_numkey());
log_out(log_warn, "mgr_disconnect::server(%s) reason(%d)\n", peer.ip, reason);
post_connect(peer.ip, peer.port, sif->get_interval(), sif);
return 0;
}
int upgradeapp::connect_mgr_req(ipaddr * svr_list, int count){
for(int i = 0; i < count; i++){
server_info * s = new server_info(mgr_type);
ipaddr * svr_addr = &svr_list[i];
post_connect(svr_addr->ip, svr_addr->port, 2000, s);
log_out(log_debug, "connect_mgr_req::ip(%s) id(%d)\n", svr_addr->ip, s->get_id());
}
return 0;
}
int svrapp::on_connect(app_connection * n){
ipaddr & peer = n->get_peeraddr();
server_info * s = (server_info*)n->get_context();
if(n->connected()){
login_mgr_req(n);
}
else{
log_out(log_debug, "on_connect::connect server %s:%d fail\n", peer.ip, peer.port);
return post_connect(peer.ip, peer.port, s->get_interval(), s);
}
return 0;
}
int svrapp::on_connect(app_connection *n){
ipaddr & peer = n->get_peeraddr();
server_info * s = (server_info*)n->get_context();
if(n->connected()){
char cpy_list[1024] = {0};
read_companys(ulu_c2hd_cntmgr_conf, "company", cpy_list);
login_mgr_req(cpy_list, "cntmgr", n);
}
else{
log_out(log_debug, "on_connect::connect server %s:%d fail\n", peer.ip, peer.port);
return post_connect(peer.ip, peer.port, s->get_interval(), s);
}
return 0;
}
int baseapp::mgr_disconnect(app_connection *n, int reason){
server_info * s = (server_info*)n->get_context();
ipaddr & peer = n->get_peeraddr();
std::map<uint, app_connection*>::iterator it = m_devmap.begin();
while(it != m_devmap.end()){
server_info * s1 = (server_info*)it->second->get_context();
if (s1->get_id() == s->get_id()){
m_devmap.erase(it++);
}
else{
it++;
}
}
m_svrmap.erase(s->get_id());
log_out(log_warn, "mgr_disconnect::server %s:%d reason %d\n", peer.ip, peer.port, reason);
post_connect(peer.ip, peer.port, s->get_interval(), s);
return 0;
}
int upgradeapp::connect_server(const char * cfg, const char * section, int type){
char identify[128] = {0};
int count = 0;
char ** devmgr = GetIniItemTable(cfg, section, count);
for(int i = 0; i < count; i++){
memset(identify, 0, sizeof(identify));
sscanf(devmgr[i], "server %s", identify);
char * pt = strchr(identify, ':');
if(!pt){
continue;
}
char host[128] = {0};
strncpy(host, identify, pt - identify);
struct hostent * h = gethostbyname(host);
if(!h){
continue;
}
ipaddr devip = {{0}, 0};
strncpy(devip.ip, inet_ntoa(*((struct in_addr *)h->h_addr)), sizeof(devip.ip));
devip.port = atoi(pt+1);
server_info * s = new server_info(type);
post_connect(devip.ip, devip.port, 2000, s);
free(devmgr[i]);
log_out(log_debug, "connect_server::%s identify(%s) ip(%s) id(%d)\n", cfg, identify,
devip.ip, s->get_id());
}
free(devmgr);
return 0;
}
int ncat_connect(void)
{
nsock_pool mypool;
int rc;
/* Unless explicitely asked not to do so, ncat uses the
* fallback nsock engine to maximize compatibility between
* operating systems and the different use cases.
*/
if (!o.nsock_engine)
nsock_set_default_engine("select");
/* Create an nsock pool */
if ((mypool = nsp_new(NULL)) == NULL)
bye("Failed to create nsock_pool.");
if (o.debug >= 6)
nsock_set_loglevel(mypool, NSOCK_LOG_DBG_ALL);
else if (o.debug >= 3)
nsock_set_loglevel(mypool, NSOCK_LOG_DBG);
else if (o.debug >= 1)
nsock_set_loglevel(mypool, NSOCK_LOG_INFO);
else
nsock_set_loglevel(mypool, NSOCK_LOG_ERROR);
/* Allow connections to broadcast addresses. */
nsp_setbroadcast(mypool, 1);
#ifdef HAVE_OPENSSL
set_ssl_ctx_options((SSL_CTX *) nsp_ssl_init(mypool));
#endif
if (httpconnect.storage.ss_family == AF_UNSPEC
&& socksconnect.storage.ss_family == AF_UNSPEC) {
/* A non-proxy connection. Create an iod for a new socket. */
cs.sock_nsi = nsi_new(mypool, NULL);
if (cs.sock_nsi == NULL)
bye("Failed to create nsock_iod.");
if (nsi_set_hostname(cs.sock_nsi, o.target) == -1)
bye("Failed to set hostname on iod.");
#if HAVE_SYS_UN_H
/* For DGRAM UNIX socket we have to use source socket */
if (o.af == AF_UNIX && o.udp)
{
if (srcaddr.storage.ss_family != AF_UNIX) {
char *tmp_name = NULL;
/* If no source socket was specified, we have to create temporary one. */
if ((tmp_name = tempnam(NULL, "ncat.")) == NULL)
bye("Failed to create name for temporary DGRAM source Unix domain socket (tempnam).");
srcaddr.un.sun_family = AF_UNIX;
strncpy(srcaddr.un.sun_path, tmp_name, sizeof(srcaddr.un.sun_path));
free (tmp_name);
}
nsi_set_localaddr(cs.sock_nsi, &srcaddr.storage, SUN_LEN((struct sockaddr_un *)&srcaddr.storage));
if (o.verbose)
loguser("[%s] used as source DGRAM Unix domain socket.\n", srcaddr.un.sun_path);
}
else
#endif
if (srcaddr.storage.ss_family != AF_UNSPEC)
nsi_set_localaddr(cs.sock_nsi, &srcaddr.storage, sizeof(srcaddr.storage));
if (o.numsrcrtes) {
unsigned char *ipopts = NULL;
size_t ipoptslen = 0;
if (o.af != AF_INET)
bye("Sorry, -g can only currently be used with IPv4.");
ipopts = buildsrcrte(targetss.in.sin_addr, o.srcrtes, o.numsrcrtes, o.srcrteptr, &ipoptslen);
nsi_set_ipoptions(cs.sock_nsi, ipopts, ipoptslen);
free(ipopts); /* Nsock has its own copy */
}
#if HAVE_SYS_UN_H
if (o.af == AF_UNIX) {
if (o.udp) {
nsock_connect_unixsock_datagram(mypool, cs.sock_nsi, connect_handler, NULL,
&targetss.sockaddr,
SUN_LEN((struct sockaddr_un *)&targetss.sockaddr));
} else {
nsock_connect_unixsock_stream(mypool, cs.sock_nsi, connect_handler, o.conntimeout,
NULL, &targetss.sockaddr,
SUN_LEN((struct sockaddr_un *)&targetss.sockaddr));
}
} else
#endif
if (o.udp) {
nsock_connect_udp(mypool, cs.sock_nsi, connect_handler,
NULL, &targetss.sockaddr, targetsslen,
inet_port(&targetss));
}
#ifdef HAVE_OPENSSL
else if (o.sctp && o.ssl) {
nsock_connect_ssl(mypool, cs.sock_nsi, connect_handler,
o.conntimeout, NULL,
&targetss.sockaddr, targetsslen,
IPPROTO_SCTP, inet_port(&targetss),
NULL);
}
#endif
else if (o.sctp) {
nsock_connect_sctp(mypool, cs.sock_nsi, connect_handler,
o.conntimeout, NULL,
&targetss.sockaddr, targetsslen,
inet_port(&targetss));
}
#ifdef HAVE_OPENSSL
else if (o.ssl) {
nsock_connect_ssl(mypool, cs.sock_nsi, connect_handler,
o.conntimeout, NULL,
&targetss.sockaddr, targetsslen,
IPPROTO_TCP, inet_port(&targetss),
NULL);
}
#endif
else {
nsock_connect_tcp(mypool, cs.sock_nsi, connect_handler,
o.conntimeout, NULL,
&targetss.sockaddr, targetsslen,
inet_port(&targetss));
}
} else {
/* A proxy connection. */
static int connect_socket;
int len;
char *line;
size_t n;
if (httpconnect.storage.ss_family != AF_UNSPEC) {
connect_socket = do_proxy_http();
if (connect_socket == -1)
return 1;
} else if (socksconnect.storage.ss_family != AF_UNSPEC) {
struct socket_buffer stateful_buf;
struct socks4_data socks4msg;
char socksbuf[8];
connect_socket = do_connect(SOCK_STREAM);
if (connect_socket == -1) {
loguser("Proxy connection failed: %s.\n", socket_strerror(socket_errno()));
return 1;
}
socket_buffer_init(&stateful_buf, connect_socket);
if (o.verbose) {
loguser("Connected to proxy %s:%hu\n", inet_socktop(&targetss),
inet_port(&targetss));
}
/* Fill the socks4_data struct */
zmem(&socks4msg, sizeof(socks4msg));
socks4msg.version = SOCKS4_VERSION;
socks4msg.type = SOCKS_CONNECT;
socks4msg.port = socksconnect.in.sin_port;
socks4msg.address = socksconnect.in.sin_addr.s_addr;
if (o.proxy_auth)
Strncpy(socks4msg.username, (char *) o.proxy_auth, sizeof(socks4msg.username));
len = 8 + strlen(socks4msg.username) + 1;
if (send(connect_socket, (char *) &socks4msg, len, 0) < 0) {
loguser("Error sending proxy request: %s.\n", socket_strerror(socket_errno()));
return 1;
}
/* The size of the socks4 response is 8 bytes. So read exactly
8 bytes from the buffer */
if (socket_buffer_readcount(&stateful_buf, socksbuf, 8) < 0) {
loguser("Error: short reponse from proxy.\n");
return 1;
}
if (socksbuf[1] != 90) {
loguser("Proxy connection failed.\n");
return 1;
}
/* Clear out whatever is left in the socket buffer which may be
already sent by proxy server along with http response headers. */
line = socket_buffer_remainder(&stateful_buf, &n);
/* Write the leftover data to stdout. */
Write(STDOUT_FILENO, line, n);
}
/* Once the proxy negotiation is done, Nsock takes control of the
socket. */
cs.sock_nsi = nsi_new2(mypool, connect_socket, NULL);
/* Create IOD for nsp->stdin */
if ((cs.stdin_nsi = nsi_new2(mypool, 0, NULL)) == NULL)
bye("Failed to create stdin nsiod.");
post_connect(mypool, cs.sock_nsi);
}
/* connect */
rc = nsock_loop(mypool, -1);
if (o.verbose) {
struct timeval end_time;
double time;
gettimeofday(&end_time, NULL);
time = TIMEVAL_MSEC_SUBTRACT(end_time, start_time) / 1000.0;
loguser("%lu bytes sent, %lu bytes received in %.2f seconds.\n",
nsi_get_write_count(cs.sock_nsi),
nsi_get_read_count(cs.sock_nsi), time);
}
#if HAVE_SYS_UN_H
if (o.af == AF_UNIX && o.udp) {
if (o.verbose)
loguser("Deleting source DGRAM Unix domain socket. [%s]\n", srcaddr.un.sun_path);
unlink(srcaddr.un.sun_path);
}
#endif
nsp_delete(mypool);
return rc == NSOCK_LOOP_ERROR ? 1 : 0;
}
boost::system::error_code Connector::connect(
SocketType & peer1,
NetName const & netname,
boost::system::error_code & ec)
{
typedef typename SocketType::protocol_type::socket socket;
typedef typename socket::endpoint_type endpoint_type;
socket & peer(peer1); // we should use the real socket type, not the child type
if (netname.is_digit()) {
return connect(peer, netname.endpoint(), ec);
}
if (!started_) {
canceled_ = canceled_forever_;
stat_.reset();
connect_started_ = false;
boost::asio::detail::mutex::scoped_lock lock(mutex_);
if (canceled_) {
ec = boost::asio::error::operation_aborted;
canceled_ = false;
} else {
lock.unlock();
resolver_iterator_ = resolver_.resolve(netname, ec);
lock.lock();
}
stat_.resolve_time = stat_.elapse();
if (ec) {
return ec;
} else if (canceled_) {
canceled_ = false;
return ec = boost::asio::error::operation_aborted;
}
started_ = true;
}
ResolverIterator end;
for (; resolver_iterator_ != end; ++resolver_iterator_) {
if (!connect_started_) {
Endpoint const & e = *resolver_iterator_;
{
boost::asio::detail::mutex::scoped_lock lock(mutex_);
if (canceled_) {
ec = boost::asio::error::operation_aborted;
canceled_ = false;
} else {
if (peer.is_open()) {
peer.close(ec);
}
boost::asio::socket_base::non_blocking_io cmd1(non_block_);
#ifndef UNDER_CE
boost::asio::socket_base::receive_time_out cmd2(time_out_);
#endif
ec || peer.open(endpoint_type(e).protocol(), ec)
|| peer.io_control(cmd1, ec)
#ifndef UNDER_CE
|| peer.set_option(cmd2, ec)
#endif
;
}
}
if (ec) {
break;
}
LOG_TRACE("[connect] try server, ep: " << e.to_string());
start_connect(peer, e, ec);
} else {
ec = boost::asio::error::would_block;
}
if (ec == boost::asio::error::would_block) {
pool_connect(peer, ec);
}
if (ec != boost::asio::error::would_block) {
if (!ec) {
post_connect(peer, ec);
} else {
boost::system::error_code ec1;
post_connect(peer, ec1);
}
}
if (!ec || ec == boost::asio::error::would_block || canceled_) {
break;
}
LOG_DEBUG("[connect] failed, ep: " <<
resolver_iterator_->to_string() << ",ec: " << ec.message());
} // for
if ((!ec || ec == boost::asio::error::would_block) && canceled_) {
ec = boost::asio::error::operation_aborted;
}
if (ec != boost::asio::error::would_block) {
stat_.connect_time = stat_.elapse();
started_ = false;
canceled_ = false;
}
return ec;
}
boost::system::error_code Connector::connect(
SocketType & peer1,
Endpoint const & endpoint,
boost::system::error_code & ec)
{
typedef typename SocketType::protocol_type::socket socket;
typedef typename socket::endpoint_type endpoint_type;
socket & peer(peer1); // we should use the real socket type, not the child type
if (!started_) {
canceled_ = canceled_forever_;
stat_.reset();
stat_.resolve_time = 0;
if (ec) {
return ec;
}
{
boost::asio::detail::mutex::scoped_lock lock(mutex_);
if (canceled_) {
ec = boost::asio::error::operation_aborted;
canceled_ = false;
} else if (peer.is_open()) {
peer.close(ec);
}
boost::asio::socket_base::non_blocking_io cmd1(non_block_);
#ifndef UNDER_CE
boost::asio::socket_base::receive_time_out cmd2(time_out_);
#endif
ec || peer.open(endpoint_type(endpoint).protocol(), ec)
|| peer.io_control(cmd1, ec)
#ifndef UNDER_CE
|| peer.set_option(cmd2, ec)
#endif
;
started_ = true;
}
connect_started_ = false;
if (ec)
return ec;
start_connect(peer, endpoint, ec);
} else {
ec = boost::asio::error::would_block;
}
if (ec == boost::asio::error::would_block) {
pool_connect(peer, ec);
}
if (ec == boost::asio::error::would_block) {
if (time_out_ && stat_.elapse() > time_out_) {
ec = boost::asio::error::timed_out;
}
}
if (ec != boost::asio::error::would_block) {
if (!ec) {
post_connect(peer, ec);
} else {
boost::system::error_code ec1;
post_connect(peer, ec1);
}
stat_.connect_time = stat_.elapse();
started_ = false;
canceled_ = false;
}
return ec;
}
