ermyth/src/connection.C

/*
 * connection.C: Connection and I/O management
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)           
 */

static char const rcsid[] = "$Id$";

#include "atheme.h"
#include "internal.h"
#include "datastream.h"

#if 0
static BlockHeap *sa_heap;
static BlockHeap *connection_heap;
#endif

list_t connection_list;

void
init_netio (void)
{
#if 0
  connection_heap = BlockHeapCreate (sizeof (connection_t), 16);
  sa_heap = BlockHeapCreate (sizeof (struct sockaddr_in), 16);

  if (!connection_heap || !sa_heap)
    {
      slog (LG_INFO, "init_netio(): blockheap failure");
      exit (EXIT_FAILURE);
    }
#endif
}

static int
socket_setnonblocking (int sck)
{
  int flags;

  flags = fcntl (sck, F_GETFL, 0);
  flags |= O_NONBLOCK;

  if (fcntl (sck, F_SETFL, flags))
    return -1;

  return 0;
}

/*
 * connection_add()
 *
 * inputs:
 *       connection name, file descriptor, flag bitmask,
 *       read handler, write handler.
 *
 * outputs:
 *       a connection object for the connection information given.
 *
 * side effects:
 *       a connection is added to the socket queue.
 */
connection_t *
connection_add (const char *name, int fd, unsigned int flags, void (*read_handler) (connection_t *), void (*write_handler) (connection_t *))
{
  connection_t *cptr;

  if ((cptr = connection_find (fd)))
    {
      slog (LG_DEBUG, "connection_add(): connection %d is already registered as %s", fd, cptr->name);
      return NULL;
    }

  slog (LG_DEBUG, "connection_add(): adding connection '%s', fd=%d", name, fd);

  cptr = new connection_t;

  cptr->fd = fd;
  cptr->pollslot = -1;
  cptr->flags = flags;
  cptr->first_recv = NOW;
  cptr->last_recv = NOW;

  cptr->read_handler = read_handler;
  cptr->write_handler = write_handler;

  /* set connection name */
  strlcpy (cptr->name, name, HOSTLEN);

  /* XXX */
  cptr->saddr_size = sizeof (cptr->saddr);
  getpeername (cptr->fd, &cptr->saddr, &cptr->saddr_size);
  cptr->sa = (struct sockaddr_in *) &cptr->saddr;

  inet_ntop (AF_INET, &cptr->sa->sin_addr, cptr->hbuf, BUFSIZE);

  node_add (cptr, node_create (), &connection_list);

  return cptr;
}

/*
 * connection_find()
 *
 * inputs:
 *       the file descriptor to search by
 *
 * outputs:
 *       the connection_t object associated with that fd
 *
 * side effects:
 *       none
 */
connection_t *
connection_find (int fd)
{
  connection_t *cptr;
  node_t *nptr;

  LIST_FOREACH (nptr, connection_list.head)
  {
    cptr = static_cast<connection_t *> (nptr->data);

    if (cptr->fd == fd)
      return cptr;
  }

  return NULL;
}

/*
 * connection_count()
 *
 * inputs:
 *       none
 *
 * outputs:
 *       number of connections tracked
 *
 * side effects:
 *       none
 */
int
connection_count (void)
{
  return LIST_LENGTH (&connection_list);
}

/*
 * connection_close()
 *
 * inputs:
 *       the connection being closed.
 *
 * outputs:
 *       none
 *
 * side effects:
 *       the connection is closed.
 */
void
connection_close (connection_t *cptr)
{
  node_t *nptr;
  int errno1, errno2;
#ifdef SO_ERROR
  socklen_t len = sizeof (errno2);
#endif

  if (!cptr)
    {
      slog (LG_DEBUG, "connection_close(): no connection to close!");
      return;
    }

  nptr = node_find (cptr, &connection_list);
  if (!nptr)
    {
      slog (LG_DEBUG, "connection_close(): connection %p is not registered!", cptr);
      return;
    }

  errno1 = errno;
#ifdef SO_ERROR
  if (!getsockopt (cptr->fd, SOL_SOCKET, SO_ERROR, (char *) &errno2, (socklen_t *) & len))
    {
      if (errno2 != 0)
        errno1 = errno2;
    }
#endif

  if (errno1)
    slog (cptr->flags & CF_UPLINK ? LG_ERROR : LG_INFO, "connection_close(): connection %s[%d] closed due to error %d (%s)", cptr->name, cptr->fd, errno1, strerror (errno1));

  if (cptr->close_handler)
    cptr->close_handler (cptr);

  /* close the fd */
  close (cptr->fd);

  node_del (nptr, &connection_list);
  node_free (nptr);

  sendqrecvq_free (cptr);

  delete cptr;
}

/* This one is only safe for use by connection_close_soon(),
 * it will cause infinite loops otherwise
 */
static void
empty_handler (connection_t *cptr)
{
}

/*
 * connection_close_soon()
 *
 * inputs:
 *       the connection being closed.
 *
 * outputs:
 *       none
 *
 * side effects:
 *       the connection is marked to be closed soon
 *       handlers reset
 *       close_handler called
 */
void
connection_close_soon (connection_t *cptr)
{
  if (cptr == NULL)
    return;
  cptr->flags |= CF_DEAD;
  /* these two cannot be NULL */
  cptr->read_handler = empty_handler;
  cptr->write_handler = empty_handler;
  cptr->recvq_handler = NULL;
  if (cptr->close_handler)
    cptr->close_handler (cptr);
  cptr->close_handler = NULL;
  cptr->listener = NULL;
}

/*
 * connection_close_soon_children()
 *
 * inputs:
 *       a listener.
 *
 * outputs:
 *       none
 *
 * side effects:
 *       connection_close_soon() called on the connection itself and
 *       for all connections accepted on this listener
 */
void
connection_close_soon_children (connection_t *cptr)
{
  node_t *n;
  connection_t *cptr2;

  if (cptr == NULL)
    return;

  if (CF_IS_LISTENING (cptr))
    {
      LIST_FOREACH (n, connection_list.head)
      {
        cptr2 = static_cast<connection_t *> (n->data);
        if (cptr2->listener == cptr)
          connection_close_soon (cptr2);
      }
    }
  connection_close_soon (cptr);
}

/*
 * connection_close_all()
 *
 * inputs:
 *       none
 *
 * outputs:
 *       none
 *
 * side effects:
 *       connection_close() called on all registered connections
 */
void
connection_close_all (void)
{
  node_t *n, *tn;
  connection_t *cptr;

  LIST_FOREACH_SAFE (n, tn, connection_list.head)
  {
    cptr = static_cast<connection_t *> (n->data);
    connection_close (cptr);
  }
}

/*
 * connection_open_tcp()
 *
 * inputs:
 *       hostname to connect to, vhost to use, port,
 *       read handler, write handler
 *
 * outputs:
 *       the connection_t on success, NULL on failure.
 *
 * side effects:
 *       a TCP/IP connection is opened to the host,
 *       and interest is registered in read/write events.
 */
connection_t *
connection_open_tcp (char *host, char *vhost, unsigned int port, void (*read_handler) (connection_t *), void (*write_handler) (connection_t *))
{
  connection_t *cptr;
  char buf[BUFSIZE];
  struct hostent *hp;
  struct sockaddr_in sa;
  struct in_addr *in;
  unsigned s;
  unsigned int optval;

  if (!(s = socket (AF_INET, SOCK_STREAM, 0)))
    {
      slog (LG_ERROR, "connection_open_tcp(): unable to create socket.");
      return NULL;
    }

  /* Has the highest fd gotten any higher yet? */
  if (s > claro_state.maxfd)
    claro_state.maxfd = s;

  snprintf (buf, BUFSIZE, "tcp connection: %s", host);

  if (vhost)
    {
      memset (&sa, 0, sizeof (sa));
      sa.sin_family = AF_INET;

      if ((hp = gethostbyname (vhost)) == NULL)
        {
          slog (LG_ERROR, "connection_open_tcp(): cant resolve vhost %s", vhost);
          close (s);
          return NULL;
        }

      in = (struct in_addr *) (hp->h_addr_list[0]);
      sa.sin_addr.s_addr = in->s_addr;
      sa.sin_port = 0;

      optval = 1;
      setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *) &optval, sizeof (optval));

      if (bind (s, (struct sockaddr *) &sa, sizeof (sa)) < 0)
        {
          close (s);
          slog (LG_ERROR, "connection_open_tcp(): unable to bind to vhost %s", vhost);
          return NULL;
        }
    }

  /* resolve it */
  if ((hp = gethostbyname (host)) == NULL)
    {
      slog (LG_ERROR, "connection_open_tcp(): unable to resolve %s", host);
      close (s);
      return NULL;
    }

  memset (&sa, '\0', sizeof (sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons (port);
  memcpy (&sa.sin_addr, hp->h_addr, hp->h_length);

  socket_setnonblocking (s);

  if (connect (s, (struct sockaddr *) &sa, sizeof (sa)) == -1 && errno != EINPROGRESS && errno != EINTR)
    {
      slog (LG_ERROR, "connection_open_tcp(): failed to connect to %s: %s", host, strerror (errno));
      close (s);
      return NULL;
    }

  cptr = connection_add (buf, s, CF_CONNECTING, read_handler, write_handler);

  return cptr;
}

/*
 * connection_open_listener_tcp()
 *
 * inputs:
 *       host and port to listen on,
 *       accept handler
 *
 * outputs:
 *       the connection_t on success, NULL on failure.
 *
 * side effects:
 *       a TCP/IP connection is opened to the host,
 *       and interest is registered in read/write events.
 */
connection_t *
connection_open_listener_tcp (char *host, unsigned int port, void (*read_handler) (connection_t *))
{
  connection_t *cptr;
  char buf[BUFSIZE];
  struct hostent *hp;
  struct sockaddr_in sa;
  struct in_addr *in;
  unsigned s;
  unsigned int optval;

  if (!(s = socket (AF_INET, SOCK_STREAM, 0)))
    {
      slog (LG_ERROR, "connection_open_listener_tcp(): unable to create socket.");
      return NULL;
    }

  /* Has the highest fd gotten any higher yet? */
  if (s > claro_state.maxfd)
    claro_state.maxfd = s;

  snprintf (buf, BUFSIZE, "listener: %s[%d]", host, port);

  memset (&sa, 0, sizeof (sa));
  sa.sin_family = AF_INET;

  if ((hp = gethostbyname (host)) == NULL)
    {
      slog (LG_ERROR, "connection_open_listener_tcp(): cant resolve host %s", host);
      close (s);
      return NULL;
    }

  in = (struct in_addr *) (hp->h_addr_list[0]);
  sa.sin_family = AF_INET;
  sa.sin_addr.s_addr = in->s_addr;
  sa.sin_port = htons (port);

  optval = 1;
  setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *) &optval, sizeof (optval));

  if (bind (s, (struct sockaddr *) &sa, sizeof (sa)) < 0)
    {
      close (s);
      slog (LG_ERROR, "connection_open_listener_tcp(): unable to bind listener %s[%d], errno [%d]", host, port, errno);
      return NULL;
    }

  socket_setnonblocking (s);

  /* XXX we need to have some sort of handling for SOMAXCONN */
  if (listen (s, 5) < 0)
    {
      close (s);
      slog (LG_ERROR, "connection_open_listener_tcp(): error: %s", strerror (errno));
      return NULL;
    }

  cptr = connection_add (buf, s, CF_LISTENING, read_handler, NULL);

  return cptr;
}

/*
 * connection_accept_tcp()
 *
 * inputs:
 *       listener to accept from, read handler, write handler
 *
 * outputs:
 *       the connection_t on success, NULL on failure.
 *
 * side effects:
 *       a TCP/IP connection is accepted from the host,
 *       and interest is registered in read/write events.
 */
connection_t *
connection_accept_tcp (connection_t *cptr, void (*read_handler) (connection_t *), void (*write_handler) (connection_t *))
{
  char buf[BUFSIZE];
  connection_t *newptr;
  unsigned s;

  if (!(s = accept (cptr->fd, NULL, NULL)))
    {
      slog (LG_INFO, "connection_accept_tcp(): accept failed");
      return NULL;
    }

  /* Has the highest fd gotten any higher yet? */
  if (s > claro_state.maxfd)
    claro_state.maxfd = s;

  socket_setnonblocking (s);

  strlcpy (buf, "incoming connection", BUFSIZE);
  newptr = connection_add (buf, s, 0, read_handler, write_handler);
  newptr->listener = cptr;
  return newptr;
}

/*
 * connection_setselect()
 *
 * inputs:
 *       connection_t to register/deregister interest on,
 *       replacement handlers (NULL = no interest)
 *
 * outputs:
 *       none
 *
 * side effects:
 *       the handlers are changed for the connection_t.
 */
void
connection_setselect (connection_t *cptr, void (*read_handler) (connection_t *), void (*write_handler) (connection_t *))
{
  cptr->read_handler = read_handler;
  cptr->write_handler = write_handler;
}

/*
 * connection_stats()
 *
 * inputs:
 *       callback function, data for callback function
 *
 * outputs:
 *       none
 *
 * side effects:
 *       callback function is called with a series of lines
 */
void
connection_stats (void (*stats_cb) (const char *, void *), void *privdata)
{
  node_t *n;
  char buf[160];
  char buf2[20];

  LIST_FOREACH (n, connection_list.head)
  {
    connection_t *c = (connection_t *) n->data;

    snprintf (buf, sizeof buf, "fd %-3d desc '%s'", c->fd, c->flags & CF_UPLINK ? "uplink" : c->flags & CF_LISTENING ? "listener" : "misc");
    if (c->listener != NULL)
      {
        snprintf (buf2, sizeof buf2, " listener %d", c->listener->fd);
        strlcat (buf, buf2, sizeof buf);
      }
    if (c->flags & (CF_CONNECTING | CF_DEAD | CF_NONEWLINE | CF_SEND_EOF | CF_SEND_DEAD))
      {
        strlcat (buf, " status", sizeof buf);
        if (c->flags & CF_CONNECTING)
          strlcat (buf, " connecting", sizeof buf);
        if (c->flags & CF_DEAD)
          strlcat (buf, " dead", sizeof buf);
        if (c->flags & CF_NONEWLINE)
          strlcat (buf, " nonewline", sizeof buf);
        if (c->flags & CF_SEND_DEAD)
          strlcat (buf, " send_dead", sizeof buf);
        else if (c->flags & CF_SEND_EOF)
          strlcat (buf, " send_eof", sizeof buf);
      }
    stats_cb (buf, privdata);
  }
}

/*
 * connection_write()
 *
 * inputs:
 *       connection_t to write to, format string, parameters
 *
 * outputs:
 *       none
 *
 * side effects:
 *       data is added to the connection_t sendq cache.
 */
void
connection_write (connection_t *to, char *format, ...)
{
  char buf[BUFSIZE * 12];
  va_list args;
  unsigned int len;

  va_start (args, format);
  vsnprintf (buf, BUFSIZE * 12, format, args);
  va_end (args);

  len = strlen (buf);
  buf[len++] = '\r';
  buf[len++] = '\n';
  buf[len] = '\0';

  sendq_add (to, buf, len);
}

/*
 * connection_write_raw()
 *
 * inputs:
 *       connection_t to write to, raw string to write
 *
 * outputs:
 *       none
 *
 * side effects:
 *       data is added to the connection_t sendq cache.
 */
void
connection_write_raw (connection_t *to, char *data)
{
  sendq_add (to, data, strlen (data));
}

/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
 * vim:ts=8
 * vim:sw=8
 * vim:noexpandtab
 */
Revision:	1.3
Committed:	Sat Jul 21 13:23:21 2007 UTC (16 years, 10 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+1 -1 lines
Log Message:	- added rcsid to some files - more documentation tweaks - made most protocol commands local to phandler.C - added ircd metadata (inspircd only for now) - added inspircd swhois support
#	User	Rev	Content
1	pippijn	1.1	/*
2			* connection.C: Connection and I/O management
3	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
4	pippijn	1.1	*
5			* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
6			*/
7
8	pippijn	1.3	static char const rcsid[] = "$Id$";
9	pippijn	1.1
10			#include "atheme.h"
11			#include "internal.h"
12			#include "datastream.h"
13
14			#if 0
15			static BlockHeap *sa_heap;
16			static BlockHeap *connection_heap;
17			#endif
18
19			list_t connection_list;
20
21			void
22			init_netio (void)
23			{
24			#if 0
25			connection_heap = BlockHeapCreate (sizeof (connection_t), 16);
26			sa_heap = BlockHeapCreate (sizeof (struct sockaddr_in), 16);
27
28			if (!connection_heap \|\| !sa_heap)
29			{
30			slog (LG_INFO, "init_netio(): blockheap failure");
31			exit (EXIT_FAILURE);
32			}
33			#endif
34			}
35
36			static int
37			socket_setnonblocking (int sck)
38			{
39			int flags;
40
41			flags = fcntl (sck, F_GETFL, 0);
42			flags \|= O_NONBLOCK;
43
44			if (fcntl (sck, F_SETFL, flags))
45			return -1;
46
47			return 0;
48			}
49
50			/*
51			* connection_add()
52			*
53			* inputs:
54			* connection name, file descriptor, flag bitmask,
55			* read handler, write handler.
56			*
57			* outputs:
58			* a connection object for the connection information given.
59			*
60			* side effects:
61			* a connection is added to the socket queue.
62			*/
63			connection_t *
64			connection_add (const char name, int fd, unsigned int flags, void (read_handler) (connection_t ), void (write_handler) (connection_t *))
65			{
66			connection_t *cptr;
67
68			if ((cptr = connection_find (fd)))
69			{
70			slog (LG_DEBUG, "connection_add(): connection %d is already registered as %s", fd, cptr->name);
71			return NULL;
72			}
73
74			slog (LG_DEBUG, "connection_add(): adding connection '%s', fd=%d", name, fd);
75
76			cptr = new connection_t;
77
78			cptr->fd = fd;
79			cptr->pollslot = -1;
80			cptr->flags = flags;
81			cptr->first_recv = NOW;
82			cptr->last_recv = NOW;
83
84			cptr->read_handler = read_handler;
85			cptr->write_handler = write_handler;
86
87			/* set connection name */
88			strlcpy (cptr->name, name, HOSTLEN);
89
90			/* XXX */
91			cptr->saddr_size = sizeof (cptr->saddr);
92			getpeername (cptr->fd, &cptr->saddr, &cptr->saddr_size);
93			cptr->sa = (struct sockaddr_in *) &cptr->saddr;
94
95			inet_ntop (AF_INET, &cptr->sa->sin_addr, cptr->hbuf, BUFSIZE);
96
97			node_add (cptr, node_create (), &connection_list);
98
99			return cptr;
100			}
101
102			/*
103			* connection_find()
104			*
105			* inputs:
106			* the file descriptor to search by
107			*
108			* outputs:
109			* the connection_t object associated with that fd
110			*
111			* side effects:
112			* none
113			*/
114			connection_t *
115			connection_find (int fd)
116			{
117			connection_t *cptr;
118			node_t *nptr;
119
120			LIST_FOREACH (nptr, connection_list.head)
121			{
122			cptr = static_cast<connection_t *> (nptr->data);
123
124			if (cptr->fd == fd)
125			return cptr;
126			}
127
128			return NULL;
129			}
130
131			/*
132			* connection_count()
133			*
134			* inputs:
135			* none
136			*
137			* outputs:
138			* number of connections tracked
139			*
140			* side effects:
141			* none
142			*/
143			int
144			connection_count (void)
145			{
146			return LIST_LENGTH (&connection_list);
147			}
148
149			/*
150			* connection_close()
151			*
152			* inputs:
153			* the connection being closed.
154			*
155			* outputs:
156			* none
157			*
158			* side effects:
159			* the connection is closed.
160			*/
161			void
162			connection_close (connection_t *cptr)
163			{
164			node_t *nptr;
165			int errno1, errno2;
166			#ifdef SO_ERROR
167			socklen_t len = sizeof (errno2);
168			#endif
169
170			if (!cptr)
171			{
172			slog (LG_DEBUG, "connection_close(): no connection to close!");
173			return;
174			}
175
176			nptr = node_find (cptr, &connection_list);
177			if (!nptr)
178			{
179			slog (LG_DEBUG, "connection_close(): connection %p is not registered!", cptr);
180			return;
181			}
182
183			errno1 = errno;
184			#ifdef SO_ERROR
185			if (!getsockopt (cptr->fd, SOL_SOCKET, SO_ERROR, (char ) &errno2, (socklen_t ) & len))
186			{
187			if (errno2 != 0)
188			errno1 = errno2;
189			}
190			#endif
191
192			if (errno1)
193			slog (cptr->flags & CF_UPLINK ? LG_ERROR : LG_INFO, "connection_close(): connection %s[%d] closed due to error %d (%s)", cptr->name, cptr->fd, errno1, strerror (errno1));
194
195			if (cptr->close_handler)
196			cptr->close_handler (cptr);
197
198			/* close the fd */
199			close (cptr->fd);
200
201			node_del (nptr, &connection_list);
202			node_free (nptr);
203
204			sendqrecvq_free (cptr);
205
206			delete cptr;
207			}
208
209			/* This one is only safe for use by connection_close_soon(),
210			* it will cause infinite loops otherwise
211			*/
212			static void
213			empty_handler (connection_t *cptr)
214			{
215			}
216
217			/*
218			* connection_close_soon()
219			*
220			* inputs:
221			* the connection being closed.
222			*
223			* outputs:
224			* none
225			*
226			* side effects:
227			* the connection is marked to be closed soon
228			* handlers reset
229			* close_handler called
230			*/
231			void
232			connection_close_soon (connection_t *cptr)
233			{
234			if (cptr == NULL)
235			return;
236			cptr->flags \|= CF_DEAD;
237			/* these two cannot be NULL */
238			cptr->read_handler = empty_handler;
239			cptr->write_handler = empty_handler;
240			cptr->recvq_handler = NULL;
241			if (cptr->close_handler)
242			cptr->close_handler (cptr);
243			cptr->close_handler = NULL;
244			cptr->listener = NULL;
245			}
246
247			/*
248			* connection_close_soon_children()
249			*
250			* inputs:
251			* a listener.
252			*
253			* outputs:
254			* none
255			*
256			* side effects:
257			* connection_close_soon() called on the connection itself and
258			* for all connections accepted on this listener
259			*/
260			void
261			connection_close_soon_children (connection_t *cptr)
262			{
263			node_t *n;
264			connection_t *cptr2;
265
266			if (cptr == NULL)
267			return;
268
269			if (CF_IS_LISTENING (cptr))
270			{
271			LIST_FOREACH (n, connection_list.head)
272			{
273			cptr2 = static_cast<connection_t *> (n->data);
274			if (cptr2->listener == cptr)
275			connection_close_soon (cptr2);
276			}
277			}
278			connection_close_soon (cptr);
279			}
280
281			/*
282			* connection_close_all()
283			*
284			* inputs:
285			* none
286			*
287			* outputs:
288			* none
289			*
290			* side effects:
291			* connection_close() called on all registered connections
292			*/
293			void
294			connection_close_all (void)
295			{
296			node_t n, tn;
297			connection_t *cptr;
298
299			LIST_FOREACH_SAFE (n, tn, connection_list.head)
300			{
301			cptr = static_cast<connection_t *> (n->data);
302			connection_close (cptr);
303			}
304			}
305
306			/*
307			* connection_open_tcp()
308			*
309			* inputs:
310			* hostname to connect to, vhost to use, port,
311			* read handler, write handler
312			*
313			* outputs:
314			* the connection_t on success, NULL on failure.
315			*
316			* side effects:
317			* a TCP/IP connection is opened to the host,
318			* and interest is registered in read/write events.
319			*/
320			connection_t *
321			connection_open_tcp (char host, char vhost, unsigned int port, void (read_handler) (connection_t ), void (write_handler) (connection_t ))
322			{
323			connection_t *cptr;
324			char buf[BUFSIZE];
325			struct hostent *hp;
326			struct sockaddr_in sa;
327			struct in_addr *in;
328			unsigned s;
329			unsigned int optval;
330
331			if (!(s = socket (AF_INET, SOCK_STREAM, 0)))
332			{
333			slog (LG_ERROR, "connection_open_tcp(): unable to create socket.");
334			return NULL;
335			}
336
337			/* Has the highest fd gotten any higher yet? */
338			if (s > claro_state.maxfd)
339			claro_state.maxfd = s;
340
341			snprintf (buf, BUFSIZE, "tcp connection: %s", host);
342
343			if (vhost)
344			{
345			memset (&sa, 0, sizeof (sa));
346			sa.sin_family = AF_INET;
347
348			if ((hp = gethostbyname (vhost)) == NULL)
349			{
350			slog (LG_ERROR, "connection_open_tcp(): cant resolve vhost %s", vhost);
351			close (s);
352			return NULL;
353			}
354
355			in = (struct in_addr *) (hp->h_addr_list[0]);
356			sa.sin_addr.s_addr = in->s_addr;
357			sa.sin_port = 0;
358
359			optval = 1;
360			setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *) &optval, sizeof (optval));
361
362			if (bind (s, (struct sockaddr *) &sa, sizeof (sa)) < 0)
363			{
364			close (s);
365			slog (LG_ERROR, "connection_open_tcp(): unable to bind to vhost %s", vhost);
366			return NULL;
367			}
368			}
369
370			/* resolve it */
371			if ((hp = gethostbyname (host)) == NULL)
372			{
373			slog (LG_ERROR, "connection_open_tcp(): unable to resolve %s", host);
374			close (s);
375			return NULL;
376			}
377
378			memset (&sa, '\0', sizeof (sa));
379			sa.sin_family = AF_INET;
380			sa.sin_port = htons (port);
381			memcpy (&sa.sin_addr, hp->h_addr, hp->h_length);
382
383			socket_setnonblocking (s);
384
385			if (connect (s, (struct sockaddr *) &sa, sizeof (sa)) == -1 && errno != EINPROGRESS && errno != EINTR)
386			{
387			slog (LG_ERROR, "connection_open_tcp(): failed to connect to %s: %s", host, strerror (errno));
388			close (s);
389			return NULL;
390			}
391
392			cptr = connection_add (buf, s, CF_CONNECTING, read_handler, write_handler);
393
394			return cptr;
395			}
396
397			/*
398			* connection_open_listener_tcp()
399			*
400			* inputs:
401			* host and port to listen on,
402			* accept handler
403			*
404			* outputs:
405			* the connection_t on success, NULL on failure.
406			*
407			* side effects:
408			* a TCP/IP connection is opened to the host,
409			* and interest is registered in read/write events.
410			*/
411			connection_t *
412			connection_open_listener_tcp (char host, unsigned int port, void (read_handler) (connection_t *))
413			{
414			connection_t *cptr;
415			char buf[BUFSIZE];
416			struct hostent *hp;
417			struct sockaddr_in sa;
418			struct in_addr *in;
419			unsigned s;
420			unsigned int optval;
421
422			if (!(s = socket (AF_INET, SOCK_STREAM, 0)))
423			{
424			slog (LG_ERROR, "connection_open_listener_tcp(): unable to create socket.");
425			return NULL;
426			}
427
428			/* Has the highest fd gotten any higher yet? */
429			if (s > claro_state.maxfd)
430			claro_state.maxfd = s;
431
432			snprintf (buf, BUFSIZE, "listener: %s[%d]", host, port);
433
434			memset (&sa, 0, sizeof (sa));
435			sa.sin_family = AF_INET;
436
437			if ((hp = gethostbyname (host)) == NULL)
438			{
439			slog (LG_ERROR, "connection_open_listener_tcp(): cant resolve host %s", host);
440			close (s);
441			return NULL;
442			}
443
444			in = (struct in_addr *) (hp->h_addr_list[0]);
445			sa.sin_family = AF_INET;
446			sa.sin_addr.s_addr = in->s_addr;
447			sa.sin_port = htons (port);
448
449			optval = 1;
450			setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char *) &optval, sizeof (optval));
451
452			if (bind (s, (struct sockaddr *) &sa, sizeof (sa)) < 0)
453			{
454			close (s);
455			slog (LG_ERROR, "connection_open_listener_tcp(): unable to bind listener %s[%d], errno [%d]", host, port, errno);
456			return NULL;
457			}
458
459			socket_setnonblocking (s);
460
461			/* XXX we need to have some sort of handling for SOMAXCONN */
462			if (listen (s, 5) < 0)
463			{
464			close (s);
465			slog (LG_ERROR, "connection_open_listener_tcp(): error: %s", strerror (errno));
466			return NULL;
467			}
468
469			cptr = connection_add (buf, s, CF_LISTENING, read_handler, NULL);
470
471			return cptr;
472			}
473
474			/*
475			* connection_accept_tcp()
476			*
477			* inputs:
478			* listener to accept from, read handler, write handler
479			*
480			* outputs:
481			* the connection_t on success, NULL on failure.
482			*
483			* side effects:
484			* a TCP/IP connection is accepted from the host,
485			* and interest is registered in read/write events.
486			*/
487			connection_t *
488			connection_accept_tcp (connection_t cptr, void (read_handler) (connection_t ), void (write_handler) (connection_t *))
489			{
490			char buf[BUFSIZE];
491			connection_t *newptr;
492			unsigned s;
493
494			if (!(s = accept (cptr->fd, NULL, NULL)))
495			{
496			slog (LG_INFO, "connection_accept_tcp(): accept failed");
497			return NULL;
498			}
499
500			/* Has the highest fd gotten any higher yet? */
501			if (s > claro_state.maxfd)
502			claro_state.maxfd = s;
503
504			socket_setnonblocking (s);
505
506			strlcpy (buf, "incoming connection", BUFSIZE);
507			newptr = connection_add (buf, s, 0, read_handler, write_handler);
508			newptr->listener = cptr;
509			return newptr;
510			}
511
512			/*
513			* connection_setselect()
514			*
515			* inputs:
516			* connection_t to register/deregister interest on,
517			* replacement handlers (NULL = no interest)
518			*
519			* outputs:
520			* none
521			*
522			* side effects:
523			* the handlers are changed for the connection_t.
524			*/
525			void
526			connection_setselect (connection_t cptr, void (read_handler) (connection_t ), void (write_handler) (connection_t *))
527			{
528			cptr->read_handler = read_handler;
529			cptr->write_handler = write_handler;
530			}
531
532			/*
533			* connection_stats()
534			*
535			* inputs:
536			* callback function, data for callback function
537			*
538			* outputs:
539			* none
540			*
541			* side effects:
542			* callback function is called with a series of lines
543			*/
544			void
545			connection_stats (void (stats_cb) (const char , void ), void privdata)
546			{
547			node_t *n;
548			char buf[160];
549			char buf2[20];
550
551			LIST_FOREACH (n, connection_list.head)
552			{
553			connection_t c = (connection_t ) n->data;
554
555			snprintf (buf, sizeof buf, "fd %-3d desc '%s'", c->fd, c->flags & CF_UPLINK ? "uplink" : c->flags & CF_LISTENING ? "listener" : "misc");
556			if (c->listener != NULL)
557			{
558			snprintf (buf2, sizeof buf2, " listener %d", c->listener->fd);
559			strlcat (buf, buf2, sizeof buf);
560			}
561			if (c->flags & (CF_CONNECTING \| CF_DEAD \| CF_NONEWLINE \| CF_SEND_EOF \| CF_SEND_DEAD))
562			{
563			strlcat (buf, " status", sizeof buf);
564			if (c->flags & CF_CONNECTING)
565			strlcat (buf, " connecting", sizeof buf);
566			if (c->flags & CF_DEAD)
567			strlcat (buf, " dead", sizeof buf);
568			if (c->flags & CF_NONEWLINE)
569			strlcat (buf, " nonewline", sizeof buf);
570			if (c->flags & CF_SEND_DEAD)
571			strlcat (buf, " send_dead", sizeof buf);
572			else if (c->flags & CF_SEND_EOF)
573			strlcat (buf, " send_eof", sizeof buf);
574			}
575			stats_cb (buf, privdata);
576			}
577			}
578
579			/*
580			* connection_write()
581			*
582			* inputs:
583			* connection_t to write to, format string, parameters
584			*
585			* outputs:
586			* none
587			*
588			* side effects:
589			* data is added to the connection_t sendq cache.
590			*/
591			void
592			connection_write (connection_t to, char format, ...)
593			{
594			char buf[BUFSIZE * 12];
595			va_list args;
596			unsigned int len;
597
598			va_start (args, format);
599			vsnprintf (buf, BUFSIZE * 12, format, args);
600			va_end (args);
601
602			len = strlen (buf);
603			buf[len++] = '\r';
604			buf[len++] = '\n';
605			buf[len] = '\0';
606
607			sendq_add (to, buf, len);
608			}
609
610			/*
611			* connection_write_raw()
612			*
613			* inputs:
614			* connection_t to write to, raw string to write
615			*
616			* outputs:
617			* none
618			*
619			* side effects:
620			* data is added to the connection_t sendq cache.
621			*/
622			void
623			connection_write_raw (connection_t to, char data)
624			{
625			sendq_add (to, data, strlen (data));
626			}
627
628			/* vim:cinoptions=>s,e0,n0,f0,{0,}0,^0,=s,ps,t0,c3,+s,(2s,us,)20,*30,gs,hs
629			* vim:ts=8
630			* vim:sw=8
631			* vim:noexpandtab
632			*/