c%2B%2B/socket%2B%2B-1.10/sockinet.C

// sockinet.C  -*- C++ -*- socket library
// Copyright (C) 1992,1993,1994 Gnanasekaran Swaminathan <gs4t@virginia.edu>
// 
// Permission is granted to use at your own risk and distribute this software
// in source and binary forms provided the above copyright
// notice and this paragraph are preserved on all copies.
// This software is provided "as is" with no express or implied warranty.
//
// Version: 17Oct95 1.10

#include <config.h>
#include <sockinet.h>

EXTERN_C_BEGIN
#include <netdb.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
EXTERN_C_END

void    herror(const char*);

sockinetaddr::sockinetaddr () 
{
  sin_family      = sockinetbuf::af_inet;
  sin_addr.s_addr = htonl(INADDR_ANY);
  sin_port        = 0;
}

sockinetaddr::sockinetaddr(unsigned long addr, int port_no)
// addr and port_no are in host byte order
{
  sin_family      = sockinetbuf::af_inet;
  sin_addr.s_addr = htonl(addr);
  sin_port      = htons(port_no);
}

sockinetaddr::sockinetaddr(unsigned long addr, const char* sn, const char* pn)
// addr is in host byte order
{
  sin_family      = sockinetbuf::af_inet;
  sin_addr.s_addr = htonl (addr); // Added by cgay@cs.uoregon.edu May 29, 1993
  setport(sn, pn);
}

sockinetaddr::sockinetaddr (const char* host_name, int port_no)
// port_no is in host byte order
{
  setaddr(host_name);
  sin_port = htons(port_no);
}

sockinetaddr::sockinetaddr(const char* hn, const char* sn, const char* pn)
{
  setaddr(hn);
  setport(sn, pn);
}

sockinetaddr::sockinetaddr (const sockinetaddr& sina)
{
  sin_family      = sockinetbuf::af_inet;
  sin_addr.s_addr = sina.sin_addr.s_addr;
  sin_port      = sina.sin_port;
}   

void sockinetaddr::setport(const char* sn, const char* pn)
{
  servent* sp = getservbyname(sn, pn);
  if (sp == 0) {
    perror(sn);
    error ("sockinetaddr: invalid service name");
    exit(1);
  }
  sin_port = sp->s_port;
}

int sockinetaddr::getport () const
{
  return ntohs (sin_port);
}

void sockinetaddr::setaddr(const char* host_name)
{
  if ( (sin_addr.s_addr = inet_addr(host_name)) == -1) {
    hostent* hp = gethostbyname(host_name);
    if (hp == 0) {
      herror("sockinetaddr::sockinetaddr");
      exit(1);
    }
    memcpy(&sin_addr, hp->h_addr, hp->h_length);
    sin_family = hp->h_addrtype;
  }else
    sin_family = sockinetbuf::af_inet;
}

const char* sockinetaddr::gethostname () const
{
  if (sin_addr.s_addr == htonl(INADDR_ANY)) {
    static char hostname[64];
    if (::gethostname(hostname, 63) == -1) {
      perror("in sockinetaddr::gethostname");
      return "";
    }
    return hostname;            
  }
  
  hostent* hp = gethostbyaddr((const char*) &sin_addr,
                              sizeof(sin_addr),
                              family());
  if (hp == 0) {
    herror("sockinetaddr::gethostname");
    return "";
  }
  if (hp->h_name) return hp->h_name;
  return "";
}

sockinetbuf::sockinetbuf(sockbuf::type ty, int proto)
  : sockbuf(af_inet, ty, proto)
{}

sockinetbuf& sockinetbuf::operator = (const sockbuf& si)
{
  this->sockbuf::operator = (si);
  return *this;
  
}

sockinetbuf& sockinetbuf::operator = (const sockinetbuf& si)
{
  this->sockbuf::operator = (si);
  return *this;
}

sockbuf* sockinetbuf::open(sockbuf::type st, int proto)
{
  *this = sockinetbuf(st, proto);
  return this;
}

sockinetaddr sockinetbuf::localaddr() const
{
  sockinetaddr sin;
  int len = sin.size();
  if (::getsockname(rep->sock, sin.addr (), &len) == -1)
    perror("sockinetbuf::localaddr()");
  return sin;
}

int sockinetbuf::localport() const
{
  sockinetaddr sin = localaddr();
  if (sin.family() != af_inet) return -1;
  return sin.getport();
}

const char* sockinetbuf::localhost() const
{
  sockinetaddr sin = localaddr();
  if (sin.family() != af_inet) return "";
  return sin.gethostname();
}


sockinetaddr sockinetbuf::peeraddr() const
{
  sockinetaddr sin;
  int len = sin.size();
  if (::getpeername(rep->sock, sin.addr (), &len) == -1)
    perror("sockinetbuf::peeraddr()");
  return sin;
}

int sockinetbuf::peerport() const
{
  sockinetaddr sin = peeraddr();
  if (sin.family() != af_inet) return -1;
  return sin.getport();
}

const char* sockinetbuf::peerhost() const
{
  sockinetaddr sin = peeraddr();
  if (sin.family() != af_inet) return "";
  return sin.gethostname();
}

int sockinetbuf::bind_until_success (int portno)
// a. bind to (INADDR_ANY, portno)
// b. if success return 0
// c. if failure and errno is EADDRINUSE, portno++ and go to step a.
// d. return errno.
{
  for (;;) {
    sockinetaddr sa ((unsigned long) INADDR_ANY, portno++);
    int eno = bind (sa);
    if (eno == 0)
      return 0;
    if (eno != EADDRINUSE)
      return eno;
  }
}

int sockinetbuf::bind (sockAddr& sa)
{
  return sockbuf::bind (sa);
}

int sockinetbuf::bind ()
{
  sockinetaddr sa;
  return bind (sa);
}

int sockinetbuf::bind (unsigned long addr, int port_no)
// address and portno are in host byte order
{
  sockinetaddr sa (addr, port_no);
  return bind (sa);
}

int sockinetbuf::bind (const char* host_name, int port_no)
{
  sockinetaddr sa (host_name, port_no);
  return bind (sa);
}

int sockinetbuf::bind (unsigned long addr,
                       const char* service_name,
                       const char* protocol_name)
{
  sockinetaddr sa (addr, service_name, protocol_name);
  return bind (sa);
}

int sockinetbuf::bind (const char* host_name,
                       const char* service_name,
                       const char* protocol_name)
{
  sockinetaddr sa (host_name, service_name, protocol_name);
  return bind (sa);
}

int sockinetbuf::connect (sockAddr& sa)
{
  return sockbuf::connect (sa);
}

int sockinetbuf::connect (unsigned long addr, int port_no)
// address and portno are in host byte order
{
  sockinetaddr sa (addr, port_no);
  return connect (sa);
}

int sockinetbuf::connect (const char* host_name, int port_no)
{
  sockinetaddr sa (host_name, port_no);
  return connect (sa);
}

int sockinetbuf::connect (unsigned long addr,
                          const char* service_name,
                          const char* protocol_name)
{
  sockinetaddr sa (addr, service_name, protocol_name);
  return connect (sa);
}

int sockinetbuf::connect (const char* host_name,
                          const char* service_name,
                          const char* protocol_name)
{
  sockinetaddr sa (host_name, service_name, protocol_name);
  return connect (sa);
}

isockinet::isockinet (sockbuf::type ty, int proto)
  : ios (new sockinetbuf (ty, proto))
{}

isockinet::isockinet (const sockbuf& sb)
  : ios (new sockinetbuf (sb))
{}

isockinet::~isockinet ()
{
  delete ios::rdbuf ();
  init (0);
}

osockinet::osockinet (sockbuf::type ty, int proto)
  : ios (new sockinetbuf (ty, proto))
{}

osockinet::osockinet (const sockbuf& sb)
  : ios (new sockinetbuf (sb))
{}

osockinet::~osockinet ()
{
  delete ios::rdbuf ();
  init (0);
}

iosockinet::iosockinet (sockbuf::type ty, int proto)
  : ios (new sockinetbuf (ty, proto))
{}

iosockinet::iosockinet (const sockbuf& sb)
  : ios (new sockinetbuf (sb))
{}

iosockinet::~iosockinet ()
{
  delete ios::rdbuf ();
  init (0);
}

#if !defined (__linux__)

extern "C" int h_errno;
static  char* errmsg[] = {
  ": No error\n",
  ": Host not found\n",
  ": Try again\n",
  ": No recovery\n",            
  ": No address\n"
  ": Unknown error\n"
};
void herror(const char* em)
{
  if (h_errno > 5) h_errno = 5;
  cerr << em << errmsg[h_errno];
}

#endif // !__linux__
Revision:	1.2
Committed:	Mon Jun 10 14:10:44 2002 UTC (22 years, 5 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Tidy up of files. These are all old things that are not only no longer used but are also probably useless to anyone other than us. This saves checking them out all the time, and makes the "cms/source" tree contain only current stuff. They'll still exist in the attic's though :)
#	Content
1	// sockinet.C -- C++ -- socket library
2	// Copyright (C) 1992,1993,1994 Gnanasekaran Swaminathan <gs4t@virginia.edu>
3	//
4	// Permission is granted to use at your own risk and distribute this software
5	// in source and binary forms provided the above copyright
6	// notice and this paragraph are preserved on all copies.
7	// This software is provided "as is" with no express or implied warranty.
8	//
9	// Version: 17Oct95 1.10
10
11	#include <config.h>
12	#include <sockinet.h>
13
14	EXTERN_C_BEGIN
15	#include <netdb.h>
16	#include <sys/time.h>
17	#include <sys/socket.h>
18	#include <stdlib.h>
19	#include <unistd.h>
20	#include <errno.h>
21	EXTERN_C_END
22
23	void herror(const char*);
24
25	sockinetaddr::sockinetaddr ()
26	{
27	sin_family = sockinetbuf::af_inet;
28	sin_addr.s_addr = htonl(INADDR_ANY);
29	sin_port = 0;
30	}
31
32	sockinetaddr::sockinetaddr(unsigned long addr, int port_no)
33	// addr and port_no are in host byte order
34	{
35	sin_family = sockinetbuf::af_inet;
36	sin_addr.s_addr = htonl(addr);
37	sin_port = htons(port_no);
38	}
39
40	sockinetaddr::sockinetaddr(unsigned long addr, const char* sn, const char* pn)
41	// addr is in host byte order
42	{
43	sin_family = sockinetbuf::af_inet;
44	sin_addr.s_addr = htonl (addr); // Added by cgay@cs.uoregon.edu May 29, 1993
45	setport(sn, pn);
46	}
47
48	sockinetaddr::sockinetaddr (const char* host_name, int port_no)
49	// port_no is in host byte order
50	{
51	setaddr(host_name);
52	sin_port = htons(port_no);
53	}
54
55	sockinetaddr::sockinetaddr(const char* hn, const char* sn, const char* pn)
56	{
57	setaddr(hn);
58	setport(sn, pn);
59	}
60
61	sockinetaddr::sockinetaddr (const sockinetaddr& sina)
62	{
63	sin_family = sockinetbuf::af_inet;
64	sin_addr.s_addr = sina.sin_addr.s_addr;
65	sin_port = sina.sin_port;
66	}
67
68	void sockinetaddr::setport(const char* sn, const char* pn)
69	{
70	servent* sp = getservbyname(sn, pn);
71	if (sp == 0) {
72	perror(sn);
73	error ("sockinetaddr: invalid service name");
74	exit(1);
75	}
76	sin_port = sp->s_port;
77	}
78
79	int sockinetaddr::getport () const
80	{
81	return ntohs (sin_port);
82	}
83
84	void sockinetaddr::setaddr(const char* host_name)
85	{
86	if ( (sin_addr.s_addr = inet_addr(host_name)) == -1) {
87	hostent* hp = gethostbyname(host_name);
88	if (hp == 0) {
89	herror("sockinetaddr::sockinetaddr");
90	exit(1);
91	}
92	memcpy(&sin_addr, hp->h_addr, hp->h_length);
93	sin_family = hp->h_addrtype;
94	}else
95	sin_family = sockinetbuf::af_inet;
96	}
97
98	const char* sockinetaddr::gethostname () const
99	{
100	if (sin_addr.s_addr == htonl(INADDR_ANY)) {
101	static char hostname[64];
102	if (::gethostname(hostname, 63) == -1) {
103	perror("in sockinetaddr::gethostname");
104	return "";
105	}
106	return hostname;
107	}
108
109	hostent* hp = gethostbyaddr((const char*) &sin_addr,
110	sizeof(sin_addr),
111	family());
112	if (hp == 0) {
113	herror("sockinetaddr::gethostname");
114	return "";
115	}
116	if (hp->h_name) return hp->h_name;
117	return "";
118	}
119
120	sockinetbuf::sockinetbuf(sockbuf::type ty, int proto)
121	: sockbuf(af_inet, ty, proto)
122	{}
123
124	sockinetbuf& sockinetbuf::operator = (const sockbuf& si)
125	{
126	this->sockbuf::operator = (si);
127	return *this;
128
129	}
130
131	sockinetbuf& sockinetbuf::operator = (const sockinetbuf& si)
132	{
133	this->sockbuf::operator = (si);
134	return *this;
135	}
136
137	sockbuf* sockinetbuf::open(sockbuf::type st, int proto)
138	{
139	*this = sockinetbuf(st, proto);
140	return this;
141	}
142
143	sockinetaddr sockinetbuf::localaddr() const
144	{
145	sockinetaddr sin;
146	int len = sin.size();
147	if (::getsockname(rep->sock, sin.addr (), &len) == -1)
148	perror("sockinetbuf::localaddr()");
149	return sin;
150	}
151
152	int sockinetbuf::localport() const
153	{
154	sockinetaddr sin = localaddr();
155	if (sin.family() != af_inet) return -1;
156	return sin.getport();
157	}
158
159	const char* sockinetbuf::localhost() const
160	{
161	sockinetaddr sin = localaddr();
162	if (sin.family() != af_inet) return "";
163	return sin.gethostname();
164	}
165
166
167	sockinetaddr sockinetbuf::peeraddr() const
168	{
169	sockinetaddr sin;
170	int len = sin.size();
171	if (::getpeername(rep->sock, sin.addr (), &len) == -1)
172	perror("sockinetbuf::peeraddr()");
173	return sin;
174	}
175
176	int sockinetbuf::peerport() const
177	{
178	sockinetaddr sin = peeraddr();
179	if (sin.family() != af_inet) return -1;
180	return sin.getport();
181	}
182
183	const char* sockinetbuf::peerhost() const
184	{
185	sockinetaddr sin = peeraddr();
186	if (sin.family() != af_inet) return "";
187	return sin.gethostname();
188	}
189
190	int sockinetbuf::bind_until_success (int portno)
191	// a. bind to (INADDR_ANY, portno)
192	// b. if success return 0
193	// c. if failure and errno is EADDRINUSE, portno++ and go to step a.
194	// d. return errno.
195	{
196	for (;;) {
197	sockinetaddr sa ((unsigned long) INADDR_ANY, portno++);
198	int eno = bind (sa);
199	if (eno == 0)
200	return 0;
201	if (eno != EADDRINUSE)
202	return eno;
203	}
204	}
205
206	int sockinetbuf::bind (sockAddr& sa)
207	{
208	return sockbuf::bind (sa);
209	}
210
211	int sockinetbuf::bind ()
212	{
213	sockinetaddr sa;
214	return bind (sa);
215	}
216
217	int sockinetbuf::bind (unsigned long addr, int port_no)
218	// address and portno are in host byte order
219	{
220	sockinetaddr sa (addr, port_no);
221	return bind (sa);
222	}
223
224	int sockinetbuf::bind (const char* host_name, int port_no)
225	{
226	sockinetaddr sa (host_name, port_no);
227	return bind (sa);
228	}
229
230	int sockinetbuf::bind (unsigned long addr,
231	const char* service_name,
232	const char* protocol_name)
233	{
234	sockinetaddr sa (addr, service_name, protocol_name);
235	return bind (sa);
236	}
237
238	int sockinetbuf::bind (const char* host_name,
239	const char* service_name,
240	const char* protocol_name)
241	{
242	sockinetaddr sa (host_name, service_name, protocol_name);
243	return bind (sa);
244	}
245
246	int sockinetbuf::connect (sockAddr& sa)
247	{
248	return sockbuf::connect (sa);
249	}
250
251	int sockinetbuf::connect (unsigned long addr, int port_no)
252	// address and portno are in host byte order
253	{
254	sockinetaddr sa (addr, port_no);
255	return connect (sa);
256	}
257
258	int sockinetbuf::connect (const char* host_name, int port_no)
259	{
260	sockinetaddr sa (host_name, port_no);
261	return connect (sa);
262	}
263
264	int sockinetbuf::connect (unsigned long addr,
265	const char* service_name,
266	const char* protocol_name)
267	{
268	sockinetaddr sa (addr, service_name, protocol_name);
269	return connect (sa);
270	}
271
272	int sockinetbuf::connect (const char* host_name,
273	const char* service_name,
274	const char* protocol_name)
275	{
276	sockinetaddr sa (host_name, service_name, protocol_name);
277	return connect (sa);
278	}
279
280	isockinet::isockinet (sockbuf::type ty, int proto)
281	: ios (new sockinetbuf (ty, proto))
282	{}
283
284	isockinet::isockinet (const sockbuf& sb)
285	: ios (new sockinetbuf (sb))
286	{}
287
288	isockinet::~isockinet ()
289	{
290	delete ios::rdbuf ();
291	init (0);
292	}
293
294	osockinet::osockinet (sockbuf::type ty, int proto)
295	: ios (new sockinetbuf (ty, proto))
296	{}
297
298	osockinet::osockinet (const sockbuf& sb)
299	: ios (new sockinetbuf (sb))
300	{}
301
302	osockinet::~osockinet ()
303	{
304	delete ios::rdbuf ();
305	init (0);
306	}
307
308	iosockinet::iosockinet (sockbuf::type ty, int proto)
309	: ios (new sockinetbuf (ty, proto))
310	{}
311
312	iosockinet::iosockinet (const sockbuf& sb)
313	: ios (new sockinetbuf (sb))
314	{}
315
316	iosockinet::~iosockinet ()
317	{
318	delete ios::rdbuf ();
319	init (0);
320	}
321
322	#if !defined (__linux__)
323
324	extern "C" int h_errno;
325	static char* errmsg[] = {
326	": No error\n",
327	": Host not found\n",
328	": Try again\n",
329	": No recovery\n",
330	": No address\n"
331	": Unknown error\n"
332	};
333	void herror(const char* em)
334	{
335	if (h_errno > 5) h_errno = 5;
336	cerr << em << errmsg[h_errno];
337	}
338
339	#endif // !__linux__