Skip to content

Commit d9bdd4e

Browse files
EDBCREPOEDBCREPO
committed
📌 Nodepp | Stable Version | V1.4.1 📌
1 parent d98432c commit d9bdd4e

8 files changed

Lines changed: 220 additions & 152 deletions

File tree

‎include/nodepp/posix/dns.h‎

Lines changed: 54 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,11 @@
1414

1515
/*────────────────────────────────────────────────────────────────────────────*/
1616

17+
namespace nodepp { struct dns_t { string_t address, hostname; int family; }; }
1718
namespace nodepp { namespace dns {
1819

1920
inline bool is_ipv6( const string_t& URL ){
20-
thread_local static regex_t reg ( "([0-9a-fA-F]+\\:)+[0-9a-fA-F]+" );
21+
thread_local static regex_t reg ( "([0-9a-fA-F]+\\:)+", true );
2122
reg.clear_memory(); return reg.test( URL ) ? 1 : 0;
2223
}
2324

@@ -29,29 +30,58 @@ namespace nodepp { namespace dns {
2930
/*─······································································─*/
3031

3132
inline bool is_ip( const string_t& URL ){
32-
if( URL.empty() )/*-*/{ return 0; }
33-
if( is_ipv4(URL) > 0 ){ return 1; }
34-
if( is_ipv6(URL) > 0 ){ return 1; } return 0;
33+
if( URL.empty( ) ){ return 0; }
34+
if( is_ipv4(URL) ){ return 1; }
35+
if( is_ipv6(URL) ){ return 1; } return 0;
3536
}
3637

3738
/*─······································································─*/
3839

39-
inline string_t lookup( string_t host, int family = AF_UNSPEC ) {
40+
inline ptr_t<dns_t> lookup( string_t host, int family = AF_UNSPEC ) {
4041
_socket_::start_device();
4142

42-
if( family == AF_INET6 ) {
43-
if ( host == "broadcast" || host == "::2" ){ return "::2"; }
44-
elif ( host == "localhost" || host == "::1" ){ return "::1"; }
45-
elif ( host == "global" || host == "::0" ){ return "::0"; }
46-
elif ( host == "loopback" || host == "::3" ){ return "::3"; }
47-
} else {
48-
if ( host == "broadcast" || host == "255.255.255.255" ){ return "255.255.255.255"; }
49-
elif ( host == "localhost" || host == "127.0.0.1" ){ return "127.0.0.1"; }
50-
elif ( host == "global" || host == "0.0.0.0" ){ return "0.0.0.0"; }
51-
elif ( host == "loopback" || host == "1.1.1.1" ){ return "1.1.1.1"; }
52-
} if ( url::is_valid(host) ){ host = url::hostname(host); }
53-
54-
addrinfo hints, *res, *ptr; memset( &hints, 0, sizeof(hints) );
43+
if( family == AF_INET ) {
44+
45+
if( host == "broadcast" || host == "255.255.255.255" ){
46+
dns_t tmp ({ "255.255.255.255", host, AF_INET });
47+
return ptr_t<dns_t>( 0UL, tmp );
48+
}
49+
elif( host == "localhost" || host == "127.0.0.1" ){
50+
dns_t tmp ({ "127.0.0.1", host, AF_INET });
51+
return ptr_t<dns_t>( 0UL, tmp );
52+
}
53+
elif( host == "global" || host == "0.0.0.0" ){
54+
dns_t tmp ({ "0.0.0.0", host, AF_INET });
55+
return ptr_t<dns_t>( 0UL, tmp );
56+
}
57+
elif( host == "loopback" || host == "1.1.1.1" ){
58+
dns_t tmp ({ "1.1.1.1", host, AF_INET });
59+
return ptr_t<dns_t>( 0UL, tmp );
60+
}
61+
62+
} elif( family == AF_INET6 ) {
63+
64+
if( host == "broadcast" || host == "::2" ){
65+
dns_t tmp ({ "::2", host, AF_INET6 });
66+
return ptr_t<dns_t>( 0UL, tmp );
67+
}
68+
elif( host == "localhost" || host == "::1" ){
69+
dns_t tmp ({ "::1", host, AF_INET6 });
70+
return ptr_t<dns_t>( 0UL, tmp );
71+
}
72+
elif( host == "global" || host == "::0" ){
73+
dns_t tmp ({ "::0", host, AF_INET6 });
74+
return ptr_t<dns_t>( 0UL, tmp );
75+
}
76+
elif( host == "loopback" || host == "::3" ){
77+
dns_t tmp ({ "::3", host, AF_INET6 });
78+
return ptr_t<dns_t>( 0UL, tmp );
79+
}
80+
81+
}
82+
83+
addrinfo hints, *res, *ptr; memset( &hints, 0, sizeof(hints) );
84+
if( url::is_valid(host) ){ host = url::hostname(host); }
5585

5686
hints.ai_socktype = SOCK_STREAM;
5787
hints.ai_family = family ;
@@ -60,7 +90,8 @@ namespace nodepp { namespace dns {
6090
if( getaddrinfo( host.get(), nullptr, &hints, &res ) != 0 )
6191
{ return nullptr; }
6292

63-
char ipstr[INET6_ADDRSTRLEN]; string_t ipAddress;
93+
string_t ipAddress ; char ipstr[INET6_ADDRSTRLEN];
94+
queue_t<dns_t> list;
6495

6596
for( ptr = res; ptr != nullptr; ptr = ptr->ai_next ) {
6697
void *addr = nullptr;
@@ -73,20 +104,21 @@ namespace nodepp { namespace dns {
73104

74105
if( addr ) {
75106
inet_ntop( ptr->ai_family, addr, ipstr, sizeof(ipstr) );
76-
ipAddress = ipstr; if ( family != AF_UNSPEC ){ break; }
107+
list.push( dns_t({ ipstr, host, ptr->ai_family }) );
108+
if ( family != AF_UNSPEC ){ break; }
77109
}
78110

79111
}
80112

81-
freeaddrinfo(res); return ipAddress;
113+
freeaddrinfo(res); return list.data();
82114
}
83115

84116
/*─······································································─*/
85117

86118
inline expected_t<ip_t,except_t> get_host_data(){
87119
auto socket = socket_t();
88120

89-
socket.SOCK = SOCK_DGRAM;
121+
socket.SOCK = SOCK_DGRAM ;
90122
socket.IPPROTO = IPPROTO_UDP;
91123
socket.socket ( "loopback", 0 );
92124
socket.connect();

‎include/nodepp/posix/socket.h‎

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@ struct agent_t {
5151
bool reuse_port = 1;
5252
bool keep_alive = 0;
5353
bool broadcast = 0;
54+
int socket_family = AF_INET;
5455
};
5556

5657
class socket_t {
@@ -455,6 +456,7 @@ class socket_t {
455456
#endif
456457
opt.keep_alive = get_keep_alive();
457458
opt.broadcast = get_broadcast();
459+
opt.socket_family = AF;
458460
return opt;
459461
}
460462

@@ -488,14 +490,12 @@ class socket_t {
488490

489491
virtual int socket( const string_t& host, int port ) const noexcept {
490492
if( host.empty() ){ onError.emit("invalid IP address"); return -1; }
491-
obj->addrlen = sizeof( obj->server_addr );
492493

493494
if((obj->fd=::socket( AF, SOCK, IPPROTO )) == INVALID_SOCKET )
494495
{ onError.emit("can't initializate socket fd"); return -1; }
495496

496497
set_buffer_size( CHUNK_SIZE );
497498
set_nonbloking_mode();
498-
set_ipv6_only_mode(0);
499499
set_reuse_address (1);
500500

501501
#ifdef SO_REUSEPORT
@@ -505,19 +505,25 @@ class socket_t {
505505
SOCKADDR_ST server_st; memset(&server_st, 0, sizeof(SOCKADDR_ST));
506506
SOCKADDR_ST client_st; memset(&client_st, 0, sizeof(SOCKADDR_ST));
507507

508-
if( AF == AF_INET6 ) {
508+
if( AF == AF_INET6 ) { set_ipv6_only_mode(0);
509509

510+
obj->addrlen = sizeof( SOCKADDR_IN6 );
510511
SOCKADDR_IN6* s = (SOCKADDR_IN6*)&server_st;
512+
memset( s,0,sizeof(SOCKADDR_IN6));
513+
511514
s->sin6_family = AF_INET6; if( port>0 ){ s->sin6_port = htons(port); }
512515

513516
if ( host == "::" || host == "global" ){ s->sin6_addr = in6addr_any; }
514517
elif( host == "::1" || host == "loopback" ){ s->sin6_addr = in6addr_loopback; }
515518
elif( host == "localhost" || host == "localhost" ){ inet_pton(AF_INET6, "::1", &s->sin6_addr); }
516519
else { inet_pton(AF_INET6, host.c_str(), &s->sin6_addr); }
517-
520+
518521
} else {
519522

523+
obj->addrlen = sizeof(SOCKADDR_IN);
520524
SOCKADDR_IN* s = (SOCKADDR_IN*)&server_st;
525+
memset(s,0,sizeof(SOCKADDR_IN));
526+
521527
s->sin_family = AF_INET; if( port>0 ){ s->sin_port = htons(port); }
522528

523529
if ( host == "0.0.0.0" || host == "global" ){ s->sin_addr.s_addr = INADDR_ANY; }

‎include/nodepp/tcp.h‎

Lines changed: 23 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -69,18 +69,19 @@ class tcp_t {
6969

7070
/*─······································································─*/
7171

72-
void listen( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
72+
void listen( const dns_t& addr, int port, NODE_CLB cb=nullptr ) const noexcept {
7373

7474
if( obj->state & STATE::TCP_STATE_CLOSED )
7575
{ onError.emit("tcp listener is closed"); return; }
7676
if( obj->state & STATE::TCP_STATE_USED )
7777
{ onError.emit("tcp listener is used"); return; }
7878

7979
socket_t sk; obj->state= STATE::TCP_STATE_USED;
80-
sk.SOCK = SOCK_STREAM ;
81-
sk.IPPROTO = IPPROTO_TCP ;
80+
sk.AF = addr.family;
81+
sk.SOCK = SOCK_STREAM;
82+
sk.IPPROTO = IPPROTO_TCP;
8283

83-
if( sk.socket( dns::lookup( host, sk.AF ), port )==-1 ){
84+
if( sk.socket( addr.address, port )==-1 ){
8485
onError.emit("Error while creating TCP");
8586
close(); sk.free(); return;
8687
} sk.set_sockopt( obj->agent );
@@ -124,25 +125,31 @@ class tcp_t {
124125

125126
}
126127

128+
void listen( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
129+
auto addr = dns::lookup( host, obj->agent.socket_family );
130+
if( addr.empty() ){ onError.emit( "dns address not found" ); return; }
131+
listen( addr[0], port, cb );
132+
}
133+
127134
/*─······································································─*/
128135

129-
void connect( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
136+
void connect( const dns_t& addr, int port, NODE_CLB cb=nullptr ) const noexcept {
130137

131138
if( obj->state & STATE::TCP_STATE_CLOSED )
132139
{ onError.emit("tcp listener is closed"); return; }
133140
if( obj->state & STATE::TCP_STATE_USED )
134141
{ onError.emit("tcp listener is used"); return; }
135142

136143
socket_t sk; obj->state= STATE::TCP_STATE_USED;
137-
sk.SOCK = SOCK_STREAM ;
138-
sk.IPPROTO = IPPROTO_TCP ;
144+
sk.AF = addr.family;
145+
sk.SOCK = SOCK_STREAM;
146+
sk.IPPROTO = IPPROTO_TCP;
139147

140-
if( sk.socket( dns::lookup( host, sk.AF ), port )==-1 ){
148+
if( sk.socket( addr.address, port )==-1 ){
141149
onError.emit("Error while creating TCP");
142150
close(); sk.free(); return;
143-
}
151+
} sk.set_sockopt( obj->agent );
144152

145-
sk.set_sockopt( obj->agent );
146153
auto self = type::bind( this );
147154
sk.onDrain.once([=](){ self->close(); });
148155

@@ -165,6 +172,12 @@ class tcp_t {
165172

166173
}
167174

175+
void connect( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
176+
auto addr = dns::lookup( host, obj->agent.socket_family );
177+
if( addr.empty() ){ onError.emit( "dns address not found" ); return; }
178+
connect( addr[0], port, cb );
179+
}
180+
168181
/*─······································································─*/
169182

170183
void free() const noexcept {

‎include/nodepp/tls.h‎

Lines changed: 24 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,7 @@ class tls_t {
7373

7474
/*─······································································─*/
7575

76-
void listen( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
76+
void listen( const dns_t& addr, int port, NODE_CLB cb=nullptr ) const noexcept {
7777

7878
if( obj->state & STATE::TLS_STATE_CLOSED )
7979
{ onError.emit("tls listener is closed"); return; }
@@ -84,10 +84,11 @@ class tls_t {
8484
{ onError.emit("Error Initializing SSL context"); return; }
8585

8686
ssocket_t sk; obj->state= STATE::TLS_STATE_USED;
87-
sk.SOCK = SOCK_STREAM ;
88-
sk.IPPROTO = IPPROTO_TCP ;
87+
sk.AF = addr.family ;
88+
sk.SOCK = SOCK_STREAM ;
89+
sk.IPPROTO = IPPROTO_TCP ;
8990

90-
if( sk.socket( dns::lookup( host, sk.AF ), port )==-1 ){
91+
if( sk.socket( addr.address, port )==-1 ){
9192
onError.emit("Error while creating TLS");
9293
close(); sk.free(); return;
9394
} sk.set_sockopt( obj->agent );
@@ -131,9 +132,15 @@ class tls_t {
131132

132133
}
133134

135+
void listen( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
136+
auto addr = dns::lookup( host, obj->agent.socket_family );
137+
if( addr.empty() ){ onError.emit( "dns address not found" ); return; }
138+
listen( addr[0], port, cb );
139+
}
140+
134141
/*─······································································─*/
135142

136-
void connect( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
143+
void connect( const dns_t& addr, int port, NODE_CLB cb=nullptr ) const noexcept {
137144

138145
if( obj->state & STATE::TLS_STATE_CLOSED )
139146
{ onError.emit("tls listener is closed"); return; }
@@ -144,18 +151,18 @@ class tls_t {
144151
{ onError.emit("Error Initializing SSL context"); return; }
145152

146153
ssocket_t sk; obj->state= STATE::TLS_STATE_USED;
147-
sk.SOCK = SOCK_STREAM ;
148-
sk.IPPROTO = IPPROTO_TCP ;
154+
sk.AF = addr.family ;
155+
sk.SOCK = SOCK_STREAM ;
156+
sk.IPPROTO = IPPROTO_TCP ;
149157

150-
if( sk.socket( dns::lookup( host, sk.AF ), port )==-1 ){
158+
if( sk.socket( addr.address, port )==-1 ){
151159
onError.emit("Error while creating TLS");
152160
close(); sk.free(); return;
153-
}
161+
} sk.set_sockopt( obj->agent );
154162

155163
sk.ssl = new ssl_t( obj->ctx, sk.get_fd() );
156-
sk.ssl->set_hostname( host );
164+
sk.ssl->set_hostname( addr.hostname );
157165

158-
sk.set_sockopt( obj->agent );
159166
auto self = type::bind( this );
160167
sk.onDrain.once([=](){ self->close(); });
161168

@@ -178,6 +185,12 @@ class tls_t {
178185

179186
}
180187

188+
void connect( const string_t& host, int port, NODE_CLB cb=nullptr ) const noexcept {
189+
auto addr = dns::lookup( host, obj->agent.socket_family );
190+
if( addr.empty() ){ onError.emit( "dns address not found" ); return; }
191+
connect( addr[0], port, cb );
192+
}
193+
181194
/*─······································································─*/
182195

183196
void free() const noexcept {

0 commit comments

Comments
 (0)