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])
        {
          //sa->sin_family = he->h_addrtype;
          memcpy (&host, he->h_addr_list[0], 4);
        }
      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.29
Committed:	Tue Dec 4 13:49:16 2012 UTC (11 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.28:	+16 -3 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			{
76			host = in.s_addr;
77			}
78			else if ((he = gethostbyname (hostname))
79			&& he->h_addrtype == AF_INET
80			&& he->h_length == 4
81			&& he->h_addr_list[0])
82	pcg	1.1	{
83			//sa->sin_family = he->h_addrtype;
84			memcpy (&host, he->h_addr_list[0], 4);
85			}
86			else
87	pcg	1.8	slog (L_NOTICE, _("unable to resolve host '%s'"), hostname);
88	pcg	1.1	}
89			}
90
91	pcg	1.8	void
92			sockinfo::set (const conf_node *conf, u8 prot_)
93			{
94	pcg	1.14	if (prot_ == PROT_DNSv4)
95	pcg	1.16	{
96	pcg	1.18	host = htonl (conf->id); port = 0; prot = prot_;
97	pcg	1.16	}
98	pcg	1.14	else
99			set (conf->hostname,
100			prot_ == PROT_UDPv4 ? conf->udp_port
101			: prot_ == PROT_TCPv4 ? conf->tcp_port
102			: prot_ == PROT_DNSv4 ? conf->dns_port
103			: 0,
104			prot_);
105	pcg	1.8	}
106	pcg	1.1
107			const sockaddr *
108			sockinfo::sav4() const
109			{
110			static sockaddr_in sa;
111
112			sa.sin_family = AF_INET;
113			sa.sin_port = port;
114			sa.sin_addr.s_addr = host;
115
116			return (const sockaddr *)&sa;
117			}
118
119	pcg	1.8	static char hostport[10 + 15 + 1 + 5 + 1]; // proto / IPv4 : port
120	pcg	1.1
121			const char *
122			sockinfo::ntoa () const
123			{
124			in_addr ia = { host };
125
126			sprintf (hostport, "%.15s", inet_ntoa (ia));
127
128			return hostport;
129			}
130
131	root	1.27	bool
132			sockinfo::valid () const
133			{
134			return (prot & THISNODE->protocols) && host;
135			}
136
137	pcg	1.1	sockinfo::operator const char *() const
138			{
139			in_addr ia = { host };
140
141	pcg	1.4	sprintf (hostport, "%s/%.15s:%d", strprotocol (prot), inet_ntoa (ia), ntohs (port) & 0xffff);
142	pcg	1.1
143			return hostport;
144	pcg	1.4	}
145
146	pcg	1.5	u8
147			sockinfo::supported_protocols (conf_node *conf)
148			{
149			u8 protocols = prot;
150
151	root	1.28	if (prot & (PROT_IPv4 \| PROT_ICMPv4 \| PROT_UDPv4 \| PROT_TCPv4))
152			protocols \|= PROT_IPv4 \| PROT_ICMPv4;
153	pcg	1.5
154	root	1.25	if (conf && prot & PROTv4)
155			{
156			if (conf->protocols & PROT_UDPv4 && conf->udp_port)
157			protocols \|= PROT_UDPv4;
158
159			if (conf->protocols & PROT_TCPv4 && conf->tcp_port)
160			protocols \|= PROT_TCPv4;
161
162			if (conf->protocols & PROT_DNSv4 && conf->dns_port)
163			protocols \|= PROT_DNSv4;
164			}
165	pcg	1.5
166			return protocols;
167			}
168
169			bool
170			sockinfo::upgrade_protocol (u8 prot_, conf_node *conf)
171			{
172			if (prot_ == prot)
173			return true;
174
175	pcg	1.9	if (prot & PROTv4
176			&& prot_ & PROTv4)
177	pcg	1.5	{
178	root	1.28	if (prot_ & (PROT_IPv4 \| PROT_ICMPv4))
179	pcg	1.5	{
180			prot = prot_;
181			port = 0;
182			return true;
183			}
184
185			if (conf
186			&& prot_ & PROT_UDPv4
187			&& conf->protocols & PROT_UDPv4
188			&& conf->udp_port)
189			{
190			prot = prot_;
191	pcg	1.6	port = htons (conf->udp_port);
192	pcg	1.5	return true;
193			}
194
195			if (conf
196			&& prot_ & PROT_TCPv4
197			&& conf->protocols & PROT_TCPv4
198			&& conf->tcp_port)
199			{
200			prot = prot_;
201	pcg	1.6	port = htons (conf->tcp_port);
202	pcg	1.5	return true;
203			}
204			}
205
206			return false;
207			}
208
209	pcg	1.4	bool
210			operator == (const sockinfo &a, const sockinfo &b)
211			{
212			return a.host == b.host && a.port == b.port && a.prot == b.prot;
213			}
214
215			bool
216			operator < (const sockinfo &a, const sockinfo &b)
217			{
218			return a.host < b.host
219			\|\| (a.host == b.host && (a.port < b.port
220			\|\| (a.port == b.port && a.prot < b.prot)));
221	pcg	1.1	}
222