gvpe/src/sockinfo.C

/*
    sockinfo.C -- socket address management
    Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
    
    This file is part of GVPE.

    GVPE is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 3 of the License, or (at your
    option) any later version.
   
    This program is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
    Public License for more details.
   
    You should have received a copy of the GNU General Public License along
    with this program; if not, see <http://www.gnu.org/licenses/>.
   
    Additional permission under GNU GPL version 3 section 7
   
    If you modify this Program, or any covered work, by linking or
    combining it with the OpenSSL project's OpenSSL library (or a modified
    version of that library), containing parts covered by the terms of the
    OpenSSL or SSLeay licenses, the licensors of this Program grant you
    additional permission to convey the resulting work.  Corresponding
    Source for a non-source form of such a combination shall include the
    source code for the parts of OpenSSL used as well as that of the
    covered work.
*/

#include "config.h"

// for gethostbyname
#include <netdb.h>

// for inet_aton
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "gettext.h"

#include "sockinfo.h"
#include "slog.h"

#include <cstring>
#include <cstdio>

// all ipv4-based protocols
#define PROTv4 (PROT_UDPv4 | PROT_TCPv4 | PROT_ICMPv4 | PROT_IPv4 | PROT_DNSv4)

void
sockinfo::set (const sockaddr_in *sa, u8 prot_)
{
  host = sa->sin_addr.s_addr;
  port = prot_ & (PROT_IPv4 | PROT_ICMPv4) ? 0 : sa->sin_port;
  prot = prot_;
}

void
sockinfo::set (const char *hostname, u16 port_, u8 prot_)
{
  prot = prot_;
  host = 0;
  port = htons (port_);

  if (prot & PROTv4
      && hostname)
    {
      struct in_addr in;
      struct hostent *he;

      if (inet_aton (hostname, &in))
        host = in.s_addr;
      else if ((he = gethostbyname (hostname))
               && he->h_addrtype == AF_INET
               && he->h_length == 4
               && he->h_addr_list[0])
        memcpy (&host, he->h_addr_list[0], 4); //sa->sin_family = he->h_addrtype;
      else
        slog (L_NOTICE, _("unable to resolve host '%s'"), hostname);
    }
}

void
sockinfo::set (const conf_node *conf, u8 prot_)
{
  if (prot_ == PROT_DNSv4)
    {
      host = htonl (conf->id); port = 0; prot = prot_;
    }
  else
    set (conf->hostname,
         prot_ == PROT_UDPv4   ? conf->udp_port
         : prot_ == PROT_TCPv4 ? conf->tcp_port
         : prot_ == PROT_DNSv4 ? conf->dns_port
         : 0,
         prot_);
}

const sockaddr *
sockinfo::sav4() const
{
  static sockaddr_in sa;

  sa.sin_family      = AF_INET;
  sa.sin_port        = port;
  sa.sin_addr.s_addr = host;

  return (const sockaddr *)&sa;
}

static char hostport[10 + 15 + 1 + 5 + 1]; // proto / IPv4 : port

const char *
sockinfo::ntoa () const
{
  in_addr ia = { host };

  sprintf (hostport, "%.15s", inet_ntoa (ia));

  return hostport;
}

bool
sockinfo::valid () const
{
  return (prot & THISNODE->protocols) && host;
}

sockinfo::operator const char *() const
{
  in_addr ia = { host };

  sprintf (hostport, "%s/%.15s:%d", strprotocol (prot), inet_ntoa (ia), ntohs (port) & 0xffff);

  return hostport;
}

u8
sockinfo::supported_protocols (conf_node *conf)
{
  u8 protocols = prot;

  if (prot & (PROT_IPv4 | PROT_ICMPv4 | PROT_UDPv4 | PROT_TCPv4))
    protocols |= PROT_IPv4 | PROT_ICMPv4;

  if (conf && prot & PROTv4)
    {
      if (conf->protocols & PROT_UDPv4 && conf->udp_port)
        protocols |= PROT_UDPv4;

      if (conf->protocols & PROT_TCPv4 && conf->tcp_port)
        protocols |= PROT_TCPv4;

      if (conf->protocols & PROT_DNSv4 && conf->dns_port)
        protocols |= PROT_DNSv4;
    }

  return protocols;
}

bool
sockinfo::upgrade_protocol (u8 prot_, conf_node *conf)
{
  if (prot_ == prot)
    return true;

  if (prot & PROTv4
      && prot_ & PROTv4)
    {
      if (prot_ & (PROT_IPv4 | PROT_ICMPv4))
        {
          prot = prot_;
          port = 0;
          return true;
        }

      if (conf
          && prot_ & PROT_UDPv4
          && conf->protocols & PROT_UDPv4
          && conf->udp_port)
        {
          prot = prot_;
          port = htons (conf->udp_port);
          return true;
        }

      if (conf
          && prot_ & PROT_TCPv4
          && conf->protocols & PROT_TCPv4
          && conf->tcp_port)
        {
          prot = prot_;
          port = htons (conf->tcp_port);
          return true;
        }
    }

  return false;
}

bool
operator == (const sockinfo &a, const sockinfo &b)
{
  return a.host == b.host && a.port == b.port && a.prot == b.prot;
}

bool
operator < (const sockinfo &a, const sockinfo &b)
{
  return a.host < b.host
         || (a.host == b.host && (a.port < b.port
                                  || (a.port == b.port && a.prot < b.prot)));
}

Revision:	1.30
Committed:	Tue Dec 4 13:51:45 2012 UTC (11 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-3_0, rel-2_25, HEAD
Changes since 1.29:	+2 -7 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/*
2	pcg	1.4	sockinfo.C -- socket address management
3	pcg	1.23	Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4	pcg	1.1
5	pcg	1.15	This file is part of GVPE.
6
7	pcg	1.23	GVPE is free software; you can redistribute it and/or modify it
8			under the terms of the GNU General Public License as published by the
9			Free Software Foundation; either version 3 of the License, or (at your
10			option) any later version.
11
12			This program is distributed in the hope that it will be useful, but
13			WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15			Public License for more details.
16
17			You should have received a copy of the GNU General Public License along
18			with this program; if not, see <http://www.gnu.org/licenses/>.
19
20			Additional permission under GNU GPL version 3 section 7
21
22			If you modify this Program, or any covered work, by linking or
23			combining it with the OpenSSL project's OpenSSL library (or a modified
24			version of that library), containing parts covered by the terms of the
25			OpenSSL or SSLeay licenses, the licensors of this Program grant you
26			additional permission to convey the resulting work. Corresponding
27			Source for a non-source form of such a combination shall include the
28			source code for the parts of OpenSSL used as well as that of the
29			covered work.
30	pcg	1.1	*/
31
32			#include "config.h"
33
34	root	1.29	// for gethostbyname
35	pcg	1.2	#include <netdb.h>
36	pcg	1.1
37	root	1.29	// for inet_aton
38			#include <sys/socket.h>
39			#include <netinet/in.h>
40			#include <arpa/inet.h>
41
42	pcg	1.20	#include "gettext.h"
43
44	pcg	1.1	#include "sockinfo.h"
45			#include "slog.h"
46
47	pcg	1.22	#include <cstring>
48			#include <cstdio>
49
50	pcg	1.9	// all ipv4-based protocols
51	root	1.28	#define PROTv4 (PROT_UDPv4 \| PROT_TCPv4 \| PROT_ICMPv4 \| PROT_IPv4 \| PROT_DNSv4)
52	pcg	1.9
53	root	1.24	void
54			sockinfo::set (const sockaddr_in *sa, u8 prot_)
55	pcg	1.1	{
56			host = sa->sin_addr.s_addr;
57	root	1.28	port = prot_ & (PROT_IPv4 \| PROT_ICMPv4) ? 0 : sa->sin_port;
58	pcg	1.1	prot = prot_;
59			}
60
61	root	1.24	void
62			sockinfo::set (const char *hostname, u16 port_, u8 prot_)
63	pcg	1.1	{
64	pcg	1.3	prot = prot_;
65	pcg	1.1	host = 0;
66	pcg	1.8	port = htons (port_);
67	pcg	1.1
68	pcg	1.9	if (prot & PROTv4
69	pcg	1.8	&& hostname)
70	pcg	1.1	{
71	root	1.29	struct in_addr in;
72			struct hostent *he;
73	pcg	1.1
74	root	1.29	if (inet_aton (hostname, &in))
75	root	1.30	host = in.s_addr;
76	root	1.29	else if ((he = gethostbyname (hostname))
77			&& he->h_addrtype == AF_INET
78			&& he->h_length == 4
79			&& he->h_addr_list[0])
80	root	1.30	memcpy (&host, he->h_addr_list[0], 4); //sa->sin_family = he->h_addrtype;
81	pcg	1.1	else
82	pcg	1.8	slog (L_NOTICE, _("unable to resolve host '%s'"), hostname);
83	pcg	1.1	}
84			}
85
86	pcg	1.8	void
87			sockinfo::set (const conf_node *conf, u8 prot_)
88			{
89	pcg	1.14	if (prot_ == PROT_DNSv4)
90	pcg	1.16	{
91	pcg	1.18	host = htonl (conf->id); port = 0; prot = prot_;
92	pcg	1.16	}
93	pcg	1.14	else
94			set (conf->hostname,
95			prot_ == PROT_UDPv4 ? conf->udp_port
96			: prot_ == PROT_TCPv4 ? conf->tcp_port
97			: prot_ == PROT_DNSv4 ? conf->dns_port
98			: 0,
99			prot_);
100	pcg	1.8	}
101	pcg	1.1
102			const sockaddr *
103			sockinfo::sav4() const
104			{
105			static sockaddr_in sa;
106
107			sa.sin_family = AF_INET;
108			sa.sin_port = port;
109			sa.sin_addr.s_addr = host;
110
111			return (const sockaddr *)&sa;
112			}
113
114	pcg	1.8	static char hostport[10 + 15 + 1 + 5 + 1]; // proto / IPv4 : port
115	pcg	1.1
116			const char *
117			sockinfo::ntoa () const
118			{
119			in_addr ia = { host };
120
121			sprintf (hostport, "%.15s", inet_ntoa (ia));
122
123			return hostport;
124			}
125
126	root	1.27	bool
127			sockinfo::valid () const
128			{
129			return (prot & THISNODE->protocols) && host;
130			}
131
132	pcg	1.1	sockinfo::operator const char *() const
133			{
134			in_addr ia = { host };
135
136	pcg	1.4	sprintf (hostport, "%s/%.15s:%d", strprotocol (prot), inet_ntoa (ia), ntohs (port) & 0xffff);
137	pcg	1.1
138			return hostport;
139	pcg	1.4	}
140
141	pcg	1.5	u8
142			sockinfo::supported_protocols (conf_node *conf)
143			{
144			u8 protocols = prot;
145
146	root	1.28	if (prot & (PROT_IPv4 \| PROT_ICMPv4 \| PROT_UDPv4 \| PROT_TCPv4))
147			protocols \|= PROT_IPv4 \| PROT_ICMPv4;
148	pcg	1.5
149	root	1.25	if (conf && prot & PROTv4)
150			{
151			if (conf->protocols & PROT_UDPv4 && conf->udp_port)
152			protocols \|= PROT_UDPv4;
153
154			if (conf->protocols & PROT_TCPv4 && conf->tcp_port)
155			protocols \|= PROT_TCPv4;
156
157			if (conf->protocols & PROT_DNSv4 && conf->dns_port)
158			protocols \|= PROT_DNSv4;
159			}
160	pcg	1.5
161			return protocols;
162			}
163
164			bool
165			sockinfo::upgrade_protocol (u8 prot_, conf_node *conf)
166			{
167			if (prot_ == prot)
168			return true;
169
170	pcg	1.9	if (prot & PROTv4
171			&& prot_ & PROTv4)
172	pcg	1.5	{
173	root	1.28	if (prot_ & (PROT_IPv4 \| PROT_ICMPv4))
174	pcg	1.5	{
175			prot = prot_;
176			port = 0;
177			return true;
178			}
179
180			if (conf
181			&& prot_ & PROT_UDPv4
182			&& conf->protocols & PROT_UDPv4
183			&& conf->udp_port)
184			{
185			prot = prot_;
186	pcg	1.6	port = htons (conf->udp_port);
187	pcg	1.5	return true;
188			}
189
190			if (conf
191			&& prot_ & PROT_TCPv4
192			&& conf->protocols & PROT_TCPv4
193			&& conf->tcp_port)
194			{
195			prot = prot_;
196	pcg	1.6	port = htons (conf->tcp_port);
197	pcg	1.5	return true;
198			}
199			}
200
201			return false;
202			}
203
204	pcg	1.4	bool
205			operator == (const sockinfo &a, const sockinfo &b)
206			{
207			return a.host == b.host && a.port == b.port && a.prot == b.prot;
208			}
209
210			bool
211			operator < (const sockinfo &a, const sockinfo &b)
212			{
213			return a.host < b.host
214			\|\| (a.host == b.host && (a.port < b.port
215			\|\| (a.port == b.port && a.prot < b.prot)));
216	pcg	1.1	}
217