int RedisClient::Connect(std::string host, long port) { try { if(this->socket != NULL) { this->socket->close(); this->socket = NULL; } std::string port_str(boost::lexical_cast<std::string>(port)); this->resolver = new boost::asio::ip::tcp::resolver(this->io_service); boost::asio::ip::tcp::resolver::query query(host, port_str); this->endpoint = this->resolver->resolve(query); this->socket = new boost::asio::ip::tcp::socket(this->io_service); boost::asio::connect(*(this->socket), this->endpoint); } catch(std::exception &e) { std::cerr << "Client connect error." << std::endl; std::cerr << e.what() << std::endl; if(this->socket) { this->socket->close(); } this->socket = NULL; return -1; } return 0; }
CNetScheduleKeyGenerator::CNetScheduleKeyGenerator( const string& host, unsigned port, const string& queue_name) { SNetScheduleAPIImpl::VerifyQueueNameAlphabet(queue_name); m_UseIPv4Addr = CSocketAPI::isip(host, true); if (m_UseIPv4Addr) m_HostIPv4Addr = CSocketAPI::gethostbyname(host); else m_HostName = host; m_Port = (unsigned short) port; m_QueueName = queue_name; string port_str(NStr::IntToString(port)); unsigned queue_prefix_len = g_NumberOfUnderscoresPlusOne(queue_name); m_V1HostPortQueue.reserve(1 + host.size() + 1 + port_str.size() + queue_prefix_len + queue_name.size()); m_V1HostPortQueue.push_back('_'); m_V1HostPortQueue.append(host); m_V1HostPortQueue.push_back('_'); m_V1HostPortQueue.append(port_str); m_V1HostPortQueue.append(queue_prefix_len, '_'); m_V1HostPortQueue.append(queue_name); }
int zmq::udp_address_t::resolve (const char *name_) { // Find the ':' at end that separates address from the port number. const char *delimiter = strrchr (name_, ':'); if (!delimiter) { errno = EINVAL; return -1; } // Separate the address/port. std::string addr_str (name_, delimiter - name_); std::string port_str (delimiter + 1); // Remove square brackets around the address, if any, as used in IPv6 if (addr_str.size () >= 2 && addr_str [0] == '[' && addr_str [addr_str.size () - 1] == ']') addr_str = addr_str.substr (1, addr_str.size () - 2); // Parse the port number (0 is not a valid port). uint16_t port = (uint16_t) atoi (port_str.c_str ()); if (port == 0) { errno = EINVAL; return -1; } dest_address.sin_family = AF_INET; dest_address.sin_port = htons (port); dest_address.sin_addr.s_addr = inet_addr (addr_str.c_str ()); if (dest_address.sin_addr.s_addr == INADDR_NONE) { errno = EINVAL; return -1; } // we will check only first byte of IP // and if it from 224 to 239, then it can // represent multicast IP. int i = dest_address.sin_addr.s_addr & 0xFF; if(i >= 224 && i <= 239) { multicast = dest_address.sin_addr; is_mutlicast = true; } else is_mutlicast = false; interface.s_addr = htons (INADDR_ANY); if (interface.s_addr == INADDR_NONE) { errno = EINVAL; return -1; } bind_address.sin_family = AF_INET; bind_address.sin_port = htons (port); bind_address.sin_addr.s_addr = htons (INADDR_ANY); address = name_; return 0; }
boost::tuple<std::string, std::string, std::string, std::string> HttpRequest::ParseUrl(const std::string & url) { //for remove regex lib size_t pos_protocol = url.find("://"); std::string protocol("http"); if (pos_protocol != std::string::npos) { protocol = url.substr(0, pos_protocol); } size_t pos_host_beg = (pos_protocol == std::string::npos ? 0 : pos_protocol +3); size_t pos_path_beg = -1; std::string host_str(""); std::string port_str("80"); size_t pos_host = url.find_first_of(':', pos_host_beg); size_t pos_slash = url.find_first_of('/', pos_host_beg); if (pos_host != std::string::npos && pos_host < pos_slash) { host_str = url.substr(pos_host_beg, pos_host - pos_host_beg); size_t pos_port_beg = pos_host + 1; size_t pos_port = url.find_first_of('/', pos_port_beg); if (pos_port != std::string ::npos) { port_str = url.substr(pos_port_beg, pos_port - pos_port_beg); pos_path_beg = pos_port; } } else { pos_host = url.find_first_of('/', pos_host_beg); if (pos_host != std::string::npos) { host_str = url.substr(pos_host_beg, pos_host - pos_host_beg); pos_path_beg = pos_host; } } std::string path_str(""); if (pos_path_beg > 0) path_str = url.substr(pos_path_beg); //boost::regex reg("^(([A-Za-z]+)://)?([^:/]+)(:([0-9]+))?(.*)"); //boost::smatch sm; //if (false == boost::regex_match(url, sm, reg)) //{ // return boost::make_tuple("", "", "", ""); //} //std::string protocol(sm[2].matched ? std::string(sm[2].first, sm[2].second) : "http"); //std::string host_str(sm[3].first, sm[3].second); //std::string port_str(sm[5].matched ? std::string(sm[5].first, sm[5].second) : ""); //std::string path_str(sm[6].matched ? std::string(sm[6].first, sm[6].second) : "/"); if (path_str.empty()) path_str = "/"; return boost::make_tuple(protocol, host_str, port_str, path_str); }
// split server:port string, doesn't always set the port static void splitServerPort(const std::string& server,std::string& address,int *port) { unsigned int colon=server.find(':',0); if(colon==std::string::npos) { address=server; } else { address=server.substr(0,colon); colon++; std::string port_str(server.substr(colon,server.length()-colon)); port[0]=atoi(port_str.c_str()); } }
int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv4only_) { // Find the ':' at end that separates address from the port number. const char *delimiter = strrchr (name_, ':'); if (!delimiter) { errno = EINVAL; return -1; } // Separate the address/port. std::string addr_str (name_, delimiter - name_); std::string port_str (delimiter + 1); // Remove square brackets around the address, if any. if (addr_str.size () >= 2 && addr_str [0] == '[' && addr_str [addr_str.size () - 1] == ']') addr_str = addr_str.substr (1, addr_str.size () - 2); uint16_t port; // Allow 0 specifically, to detect invalid port error in atoi if not if (port_str == "*" || port_str == "0") // Resolve wildcard to 0 to allow autoselection of port port = 0; else { // Parse the port number (0 is not a valid port). port = (uint16_t) atoi (port_str.c_str ()); if (port == 0) { errno = EINVAL; return -1; } } // Resolve the IP address. int rc; if (local_) rc = resolve_interface (addr_str.c_str (), ipv4only_); else rc = resolve_hostname (addr_str.c_str (), ipv4only_); if (rc != 0) return -1; // Set the port into the address structure. if (address.generic.sa_family == AF_INET6) address.ipv6.sin6_port = htons (port); else address.ipv4.sin_port = htons (port); return 0; }
LLHost::LLHost(const std::string& ip_and_port) { std::string::size_type colon_index = ip_and_port.find(":"); if (colon_index == std::string::npos) { mIP = ip_string_to_u32(ip_and_port.c_str()); mPort = 0; } else { std::string ip_str(ip_and_port, 0, colon_index); std::string port_str(ip_and_port, colon_index+1); mIP = ip_string_to_u32(ip_str.c_str()); mPort = atol(port_str.c_str()); } }
int zmq::udp_engine_t::resolve_raw_address (char *name_, size_t length_) { memset (&raw_address, 0, sizeof raw_address); const char *delimiter = NULL; // Find delimiter, cannot use memrchr as it is not supported on windows if (length_ != 0) { int chars_left = (int) length_; char *current_char = name_ + length_; do { if (*(--current_char) == ':') { delimiter = current_char; break; } } while (--chars_left != 0); } if (!delimiter) { errno = EINVAL; return -1; } std::string addr_str (name_, delimiter - name_); std::string port_str (delimiter + 1, name_ + length_ - delimiter - 1); // Parse the port number (0 is not a valid port). uint16_t port = (uint16_t) atoi (port_str.c_str ()); if (port == 0) { errno = EINVAL; return -1; } raw_address.sin_family = AF_INET; raw_address.sin_port = htons (port); raw_address.sin_addr.s_addr = inet_addr (addr_str.c_str ()); if (raw_address.sin_addr.s_addr == INADDR_NONE) { errno = EINVAL; return -1; } return 0; }
int zmq::tcp_address_t::resolve (const char *name_, bool local_, bool ipv6_, bool is_src_) { if (!is_src_) { // Test the ';' to know if we have a source address in name_ const char *src_delimiter = strrchr (name_, ';'); if (src_delimiter) { std::string src_name (name_, src_delimiter - name_); const int rc = resolve (src_name.c_str (), local_, ipv6_, true); if (rc != 0) return -1; name_ = src_delimiter + 1; _has_src_addr = true; } } // Find the ':' at end that separates address from the port number. const char *delimiter = strrchr (name_, ':'); if (!delimiter) { errno = EINVAL; return -1; } // Separate the address/port. std::string addr_str (name_, delimiter - name_); std::string port_str (delimiter + 1); // Remove square brackets around the address, if any, as used in IPv6 if (addr_str.size () >= 2 && addr_str [0] == '[' && addr_str [addr_str.size () - 1] == ']') addr_str = addr_str.substr (1, addr_str.size () - 2); // Test the '%' to know if we have an interface name / zone_id in the address // Reference: https://tools.ietf.org/html/rfc4007 std::size_t pos = addr_str.rfind("%"); uint32_t zone_id = 0; if (pos != std::string::npos) { std::string if_str = addr_str.substr(pos + 1); addr_str = addr_str.substr(0, pos); if (isalpha (if_str.at (0))) zone_id = if_nametoindex(if_str.c_str()); else zone_id = (uint32_t) atoi (if_str.c_str ()); if (zone_id == 0) { errno = EINVAL; return -1; } } // Allow 0 specifically, to detect invalid port error in atoi if not uint16_t port; if (port_str == "*" || port_str == "0") // Resolve wildcard to 0 to allow autoselection of port port = 0; else { // Parse the port number (0 is not a valid port). port = (uint16_t) atoi (port_str.c_str ()); if (port == 0) { errno = EINVAL; return -1; } } // Resolve the IP address. int rc; if (local_ || is_src_) rc = resolve_interface (addr_str.c_str (), ipv6_, is_src_); else rc = resolve_hostname (addr_str.c_str (), ipv6_, is_src_); if (rc != 0) return -1; // Set the port into the address structure. if (is_src_) { if (source_address.generic.sa_family == AF_INET6) { source_address.ipv6.sin6_port = htons (port); source_address.ipv6.sin6_scope_id = zone_id; } else source_address.ipv4.sin_port = htons (port); } else { if (address.generic.sa_family == AF_INET6) { address.ipv6.sin6_port = htons (port); address.ipv6.sin6_scope_id = zone_id; } else address.ipv4.sin_port = htons (port); } return 0; }
int zmq::udp_address_t::resolve (const char *name_, bool bind_) { // Find the ':' at end that separates address from the port number. const char *delimiter = strrchr (name_, ':'); if (!delimiter) { errno = EINVAL; return -1; } // Separate the address/port. std::string addr_str (name_, delimiter - name_); std::string port_str (delimiter + 1); // Parse the port number (0 is not a valid port). uint16_t port = (uint16_t) atoi (port_str.c_str ()); if (port == 0) { errno = EINVAL; return -1; } dest_address.sin_family = AF_INET; dest_address.sin_port = htons (port); // Only when the udp should bind we allow * as the address if (addr_str == "*" && bind_) dest_address.sin_addr.s_addr = htonl (INADDR_ANY); else dest_address.sin_addr.s_addr = inet_addr (addr_str.c_str ()); if (dest_address.sin_addr.s_addr == INADDR_NONE) { errno = EINVAL; return -1; } // we will check only first byte of IP // and if it from 224 to 239, then it can // represent multicast IP. int i = dest_address.sin_addr.s_addr & 0xFF; if(i >= 224 && i <= 239) { multicast = dest_address.sin_addr; is_multicast = true; } else is_multicast = false; iface.s_addr = htonl (INADDR_ANY); if (iface.s_addr == INADDR_NONE) { errno = EINVAL; return -1; } // If a should bind and not a multicast, the dest address // is actually the bind address if (bind_ && !is_multicast) bind_address = dest_address; else { bind_address.sin_family = AF_INET; bind_address.sin_port = htons (port); bind_address.sin_addr.s_addr = htonl (INADDR_ANY); } address = name_; return 0; }
//--------------------------------------------------------------------------- void InitUDP(CConceptClient *owner, int port) { char buffer[0xFF]; int sockfd; struct addrinfo hints; struct addrinfo *res = 0; struct sockaddr_storage cliaddr; if (!owner) return; if (owner->RTSOCKET) { closesocket(owner->RTSOCKET); owner->RTSOCKET = INVALID_SOCKET; } if (port < 0) return; memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; AnsiString port_str((long)port); int gerr = getaddrinfo(owner->Called_HOST, port_str.c_str(), &hints, &res); if ((gerr != 0) || (!res)) { AnsiString err((char *)"Error in getaddrinfo(): "); err += owner->Called_HOST; err += (char *)":"; err += port_str; err += (char *)" "; err += (char *)gai_strerror(gerr); return; } if ((res->ai_family != AF_INET) && (res->ai_family != AF_INET6)) { freeaddrinfo(res); return; } sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (sockfd < 0) { freeaddrinfo(res); return; } int flag2 = 0x10; setsockopt(sockfd, IPPROTO_IP, IP_TOS, (char *)&flag2, sizeof(int)); flag2 = 0xFFFF; setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char *)&flag2, sizeof(int)); memcpy(&serveraddr, res->ai_addr, res->ai_addrlen); server_len = res->ai_addrlen; socklen_t cllen = sizeof(cliaddr); if (sendto(sockfd, "1", 1, 0, (struct sockaddr *)&serveraddr, server_len) == 1) { if (sock_eof_timeout(sockfd, 500) == 0) { if (recvfrom(sockfd, buffer, 1, 0, (struct sockaddr *)&cliaddr, &cllen) == 1) { sendto(sockfd, "2", 1, 0, (struct sockaddr *)&serveraddr, server_len); owner->RTSOCKET = sockfd; } } } freeaddrinfo(res); }