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.1
Committed:	Mon Feb 26 15:01:39 2001 UTC (23 years, 9 months ago) by ab11
Content type:	text/plain
Branch:	MAIN
CVS Tags:	PROJECT_COMPLETION
Log Message:	Networking class. Assumed to be bug free.
#	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__