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"

#include <netdb.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 hostent *he = gethostbyname (hostname);

      if (he
          && 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.28
Committed:	Tue Jan 17 21:38:11 2012 UTC (12 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.27:	+5 -5 lines
Log Message:	remove rawip2
#	Content
1	/*
2	sockinfo.C -- socket address management
3	Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4
5	This file is part of GVPE.
6
7	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	*/
31
32	#include "config.h"
33
34	#include <netdb.h>
35
36	#include "gettext.h"
37
38	#include "sockinfo.h"
39	#include "slog.h"
40
41	#include <cstring>
42	#include <cstdio>
43
44	// all ipv4-based protocols
45	#define PROTv4 (PROT_UDPv4 \| PROT_TCPv4 \| PROT_ICMPv4 \| PROT_IPv4 \| PROT_DNSv4)
46
47	void
48	sockinfo::set (const sockaddr_in *sa, u8 prot_)
49	{
50	host = sa->sin_addr.s_addr;
51	port = prot_ & (PROT_IPv4 \| PROT_ICMPv4) ? 0 : sa->sin_port;
52	prot = prot_;
53	}
54
55	void
56	sockinfo::set (const char *hostname, u16 port_, u8 prot_)
57	{
58	prot = prot_;
59	host = 0;
60	port = htons (port_);
61
62	if (prot & PROTv4
63	&& hostname)
64	{
65	struct hostent *he = gethostbyname (hostname);
66
67	if (he
68	&& he->h_addrtype == AF_INET && he->h_length == 4 && he->h_addr_list[0])
69	{
70	//sa->sin_family = he->h_addrtype;
71	memcpy (&host, he->h_addr_list[0], 4);
72	}
73	else
74	slog (L_NOTICE, _("unable to resolve host '%s'"), hostname);
75	}
76	}
77
78	void
79	sockinfo::set (const conf_node *conf, u8 prot_)
80	{
81	if (prot_ == PROT_DNSv4)
82	{
83	host = htonl (conf->id); port = 0; prot = prot_;
84	}
85	else
86	set (conf->hostname,
87	prot_ == PROT_UDPv4 ? conf->udp_port
88	: prot_ == PROT_TCPv4 ? conf->tcp_port
89	: prot_ == PROT_DNSv4 ? conf->dns_port
90	: 0,
91	prot_);
92	}
93
94	const sockaddr *
95	sockinfo::sav4() const
96	{
97	static sockaddr_in sa;
98
99	sa.sin_family = AF_INET;
100	sa.sin_port = port;
101	sa.sin_addr.s_addr = host;
102
103	return (const sockaddr *)&sa;
104	}
105
106	static char hostport[10 + 15 + 1 + 5 + 1]; // proto / IPv4 : port
107
108	const char *
109	sockinfo::ntoa () const
110	{
111	in_addr ia = { host };
112
113	sprintf (hostport, "%.15s", inet_ntoa (ia));
114
115	return hostport;
116	}
117
118	bool
119	sockinfo::valid () const
120	{
121	return (prot & THISNODE->protocols) && host;
122	}
123
124	sockinfo::operator const char *() const
125	{
126	in_addr ia = { host };
127
128	sprintf (hostport, "%s/%.15s:%d", strprotocol (prot), inet_ntoa (ia), ntohs (port) & 0xffff);
129
130	return hostport;
131	}
132
133	u8
134	sockinfo::supported_protocols (conf_node *conf)
135	{
136	u8 protocols = prot;
137
138	if (prot & (PROT_IPv4 \| PROT_ICMPv4 \| PROT_UDPv4 \| PROT_TCPv4))
139	protocols \|= PROT_IPv4 \| PROT_ICMPv4;
140
141	if (conf && prot & PROTv4)
142	{
143	if (conf->protocols & PROT_UDPv4 && conf->udp_port)
144	protocols \|= PROT_UDPv4;
145
146	if (conf->protocols & PROT_TCPv4 && conf->tcp_port)
147	protocols \|= PROT_TCPv4;
148
149	if (conf->protocols & PROT_DNSv4 && conf->dns_port)
150	protocols \|= PROT_DNSv4;
151	}
152
153	return protocols;
154	}
155
156	bool
157	sockinfo::upgrade_protocol (u8 prot_, conf_node *conf)
158	{
159	if (prot_ == prot)
160	return true;
161
162	if (prot & PROTv4
163	&& prot_ & PROTv4)
164	{
165	if (prot_ & (PROT_IPv4 \| PROT_ICMPv4))
166	{
167	prot = prot_;
168	port = 0;
169	return true;
170	}
171
172	if (conf
173	&& prot_ & PROT_UDPv4
174	&& conf->protocols & PROT_UDPv4
175	&& conf->udp_port)
176	{
177	prot = prot_;
178	port = htons (conf->udp_port);
179	return true;
180	}
181
182	if (conf
183	&& prot_ & PROT_TCPv4
184	&& conf->protocols & PROT_TCPv4
185	&& conf->tcp_port)
186	{
187	prot = prot_;
188	port = htons (conf->tcp_port);
189	return true;
190	}
191	}
192
193	return false;
194	}
195
196	bool
197	operator == (const sockinfo &a, const sockinfo &b)
198	{
199	return a.host == b.host && a.port == b.port && a.prot == b.prot;
200	}
201
202	bool
203	operator < (const sockinfo &a, const sockinfo &b)
204	{
205	return a.host < b.host
206	\|\| (a.host == b.host && (a.port < b.port
207	\|\| (a.port == b.port && a.prot < b.prot)));
208	}
209