lib/eggdrop/sockbuf.c File Reference

#include <eggdrop/eggdrop.h>
#include <unistd.h>
#include <sys/socket.h>
#include "lib/compat/poll.h"
#include <errno.h>

Go to the source code of this file.

Data Structures
struct	sockbuf_t
Functions
static void	sockbuf_got_eof (int idx, int err)
static void	stats_in (sockbuf_stats_t *stats, int len)
static void	stats_out (sockbuf_stats_t *stats, int len)
static void	skip_stats (sockbuf_stats_t *stats, int curtime)
static void	update_stats (sockbuf_stats_t *stats)
int	sockbuf_init (void)
int	sockbuf_shutdown (void)
int	sockbuf_list (int **idx, int *len, int flags)
static void	sockbuf_block (int idx)
static void	sockbuf_unblock (int idx)
static int	sockbuf_real_write (int idx, const char *data, int len)
int	sockbuf_on_eof (int idx, int level, int err, const char *errmsg)
int	sockbuf_on_connect (int idx, int level, const char *peer_ip, int peer_port)
int	sockbuf_on_newclient (int idx, int level, int newidx, const char *peer_ip, int peer_port)
int	sockbuf_on_read (int idx, int level, char *data, int len)
int	sockbuf_on_write (int idx, int level, const char *data, int len)
int	sockbuf_on_written (int idx, int level, int len, int remaining)
static void	sockbuf_got_writable_client (int idx)
static void	sockbuf_got_readable_server (int idx)
static void	sockbuf_got_writable (int idx)
static void	sockbuf_got_readable (int idx)
int	sockbuf_new ()
int	sockbuf_get_sock (int idx)
int	sockbuf_set_sock (int idx, int sock, int flags)
int	sockbuf_get_peer (int idx, const char **peer_ip, int *peer_port)
int	sockbuf_get_self (int idx, const char **my_ip, int *my_port)
int	sockbuf_get_stats (int idx, sockbuf_stats_t **stats)
int	sockbuf_noread (int idx)
int	sockbuf_read (int idx)
int	sockbuf_isvalid (int idx)
int	sockbuf_close (int idx)
int	sockbuf_delete (int idx)
int	sockbuf_write (int idx, const char *data, int len)
int	sockbuf_get_handler (int idx, sockbuf_handler_t **handler, void *client_data_ptr)
int	sockbuf_set_handler (int idx, sockbuf_handler_t *handler, void *client_data, event_owner_t *owner)
int	sockbuf_attach_listener (int fd)
int	sockbuf_detach_listener (int fd)
int	sockbuf_attach_filter (int idx, sockbuf_filter_t *filter, void *client_data)
int	sockbuf_get_filter_data (int idx, sockbuf_filter_t *filter, void *client_data_ptr)
int	sockbuf_detach_filter (int idx, sockbuf_filter_t *filter, void *client_data_ptr)
int	sockbuf_update_all (int timeout)
Variables
static const char	rcsid [] = "$Id: sockbuf.c,v 1.23 2007-09-13 22:20:55 sven Exp $"
static sockbuf_t *	sockbufs = NULL
static int	nsockbufs = 0
static int	ndeleted_sockbufs = 0
static int *	idx_array = NULL
static struct pollfd *	pollfds = NULL
static int	npollfds = 0
static int	nlisteners = 0
static sockbuf_handler_t	sockbuf_idler

---

Function Documentation

static void skip_stats	(	sockbuf_stats_t *	stats,
		int	curtime
	)			[static]

Definition at line 870 of file sockbuf.c.

References sockbuf_stats_t::last_snapshot, sockbuf_stats_t::snapshot_counter, sockbuf_stats_t::snapshot_in_bytes, and sockbuf_stats_t::snapshot_out_bytes.

Referenced by stats_in(), stats_out(), and update_stats().

{
  int diff, i;

  diff = curtime - stats->last_snapshot;
  stats->last_snapshot = curtime;
  if (diff > 5) diff = 5;

  /* Reset counters for seconds that were skipped. */
  for (i = 0; i < diff; i++) {
    stats->snapshot_counter++;
    if (stats->snapshot_counter >= 5) stats->snapshot_counter = 0;
    stats->snapshot_out_bytes[stats->snapshot_counter] = 0;
    stats->snapshot_in_bytes[stats->snapshot_counter] = 0;
  }
}

int sockbuf_attach_filter	(	int	idx,
		sockbuf_filter_t *	filter,
		void *	client_data
	)

Definition at line 721 of file sockbuf.c.

References sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_filter_t::level, sockbuf_t::nfilters, and sockbuf_isvalid().

Referenced by attach(), dcc_accept_send(), dcc_start_chat(), dcc_start_send(), http_reconnect(), linemode_on(), netstring_on(), socks5_reconnect(), socktimer_on(), telnet_on_newclient(), and throttle_on().

{
  sockbuf_t *sbuf;
  int i;

  if (!sockbuf_isvalid(idx)) return(-1);
  sbuf = &sockbufs[idx];

  sbuf->filters = realloc(sbuf->filters, sizeof(filter) * (sbuf->nfilters+1));

  sbuf->filter_client_data = realloc(sbuf->filter_client_data, sizeof(void *) * (sbuf->nfilters+1));

  /* Filters are ordered according to levels. The lower the level, the
    earlier the filter comes. This allows filters to be stacked
    in different orders but still function intelligently (e.g.
    compression should always be above encryption).
  */
  for (i = 0; i < sbuf->nfilters; i++) {
    if (filter->level < sbuf->filters[i]->level) break;
  }

  /* Move up the higher-level filters. */
  memmove(sbuf->filters+i+1, sbuf->filters+i, sizeof(filter) * (sbuf->nfilters-i));
  memmove(sbuf->filter_client_data+i+1, sbuf->filter_client_data+i, sizeof(void *) * (sbuf->nfilters-i));

  /* Put this filter in the empty spot. */
  sbuf->filters[i] = filter;
  sbuf->filter_client_data[i] = client_data;

  sbuf->nfilters++;
  return(0);
}

int sockbuf_attach_listener

(

int

fd

)

Definition at line 689 of file sockbuf.c.

References nlisteners, npollfds, and pollfds.

Referenced by add_tcl_chan().

{
  pollfds = realloc(pollfds, sizeof(*pollfds) * (npollfds + nlisteners + 1));
  pollfds[npollfds+nlisteners].fd = fd;
  pollfds[npollfds+nlisteners].events = POLLIN;
  pollfds[npollfds+nlisteners].revents = 0;
  nlisteners++;
  return(0);
}

static void sockbuf_block

(

int

idx

)

[static]

Definition at line 146 of file sockbuf.c.

References sockbuf_t::flags, idx_array, npollfds, pollfds, and SOCKBUF_BLOCK.

Referenced by sockbuf_real_write().

{
  int i;
  sockbufs[idx].flags |= SOCKBUF_BLOCK;
  for (i = 0; i < npollfds; i++) {
    if (idx_array[i] == idx) {
      pollfds[i].events |= POLLOUT;
      break;
    }
  }
}

int sockbuf_close

(

int

idx

)

Definition at line 588 of file sockbuf.c.

References sockbuf_t::sock, sockbuf_isvalid(), sockbuf_set_sock(), and socket_close().

Referenced by sockbuf_got_eof().

{
  sockbuf_t *sbuf;

  if (!sockbuf_isvalid(idx)) return(-1);
  sbuf = &sockbufs[idx];
  if (sbuf->sock >= 0) {
    socket_close(sbuf->sock);
    sockbuf_set_sock(idx, -1, 0);
  }
  return(0);
}

int sockbuf_delete

(

int

idx

)

Definition at line 601 of file sockbuf.c.

References sockbuf_t::client_data, sockbuf_t::data, sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::flags, sockbuf_t::handler, idx_array, sockbuf_t::my_ip, ndeleted_sockbufs, sockbuf_t::nfilters, nlisteners, npollfds, event_owner_b::on_delete, sockbuf_filter_t::on_delete, sockbuf_t::owner, sockbuf_t::peer_ip, pollfds, sockbuf_t::sock, SOCKBUF_DELETED, sockbuf_isvalid(), socket_close(), and sockbuf_t::stats.

Referenced by bot_close(), bot_on_delete(), dcc_chat_delete(), dcc_listen_newclient(), dcc_listen_timeout(), dcc_on_eof(), dcc_on_read(), dcc_pm_delete(), dcc_recv_eof(), dcc_send_delete(), dcc_send_done(), dcc_send_eof(), disconnect_server(), dns_on_eof(), egg_ident_cancel(), egg_ident_cancel_by_owner(), got_passreq(), got_quit(), got_version(), http_err(), http_on_read(), http_on_their_delete(), ident_result(), idx_on_eof(), idx_on_read(), irc_on_eof(), irc_on_read(), irc_pm_delete(), ircparty_close(), oldbotnet_on_eof(), oldbotnet_on_read(), on_eof(), on_quit(), process_results(), recving_login(), script_event_cleanup(), script_net_close(), sending_login(), sockbuf_shutdown(), socks5_connect_reply(), socks5_err(), socks5_on_their_delete(), socks5_on_their_eof(), telnet_on_eof(), telnet_on_read(), telnet_pm_delete(), telnetparty_close(), terminal_shutdown(), and timer_callback().

{
  sockbuf_t *sbuf;
  int i;

  if (!sockbuf_isvalid(idx)) return(-1);
  sbuf = &sockbufs[idx];

  sbuf->flags |= SOCKBUF_DELETED;
  /* Call the on_delete handler for all filters. */
  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i]->on_delete) {
      sbuf->filters[i]->on_delete(sbuf->filter_client_data[i], idx);
    }
  }

  if (sbuf->owner && sbuf->owner->on_delete) sbuf->owner->on_delete(sbuf->owner, sbuf->client_data);

  /* Close the file descriptor. */
  if (sbuf->sock >= 0) socket_close(sbuf->sock);

  /* Free ip data. */
  if (sbuf->peer_ip) free(sbuf->peer_ip);
  if (sbuf->my_ip) free(sbuf->my_ip);

  /* Free its output buffer. */
  if (sbuf->data) free(sbuf->data);

  /* Free the stats struct. */
  if (sbuf->stats) free(sbuf->stats);

  /* Free filters */
  if (sbuf->filters) free(sbuf->filters);

  /* Free filter client data */
  if (sbuf->filter_client_data) free(sbuf->filter_client_data);

  /* Mark it as deleted. */
  memset(sbuf, 0, sizeof(*sbuf));
  sbuf->sock = -1;
  sbuf->flags = SOCKBUF_DELETED;
  sbuf->handler = &sockbuf_idler;
  ndeleted_sockbufs++;

  /* Find it in the pollfds/idx_array and delete it. */
  for (i = 0; i < npollfds; i++) if (idx_array[i] == idx) break;
  if (i == npollfds) return(0);

  memmove(pollfds+i, pollfds+i+1, sizeof(*pollfds) * (npollfds+nlisteners-i-1));
  memmove(idx_array+i, idx_array+i+1, sizeof(int) * (npollfds-i-1));
  npollfds--;

  return(0);
}

int sockbuf_detach_filter	(	int	idx,
		sockbuf_filter_t *	filter,
		void *	client_data_ptr
	)

Definition at line 772 of file sockbuf.c.

References sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::nfilters, NULL, and sockbuf_isvalid().

Referenced by dcc_chat_connect(), dcc_chat_eof(), detach(), http_on_delete(), http_on_read(), linemode_off(), netstring_off(), socks5_connect_reply(), socks5_err(), socks5_on_delete(), socktimer_off(), and throttle_off().

{
  int i;
  sockbuf_t *sbuf;

  if (!sockbuf_isvalid(idx)) return(-1);
  sbuf = &sockbufs[idx];

  for (i = 0; i < sbuf->nfilters; i++) if (sbuf->filters[i] == filter) break;
  if (i == sbuf->nfilters) {
    if (client_data_ptr) *(void **)client_data_ptr = NULL;
    return(-1);
  }

  if (client_data_ptr) *(void **)client_data_ptr = sbuf->filter_client_data[i];
  memmove(sbuf->filter_client_data+i, sbuf->filter_client_data+i+1, sizeof(void *) * (sbuf->nfilters-i-1));
  memmove(sbuf->filters+i, sbuf->filters+i+1, sizeof(void *) * (sbuf->nfilters-i-1));
  sbuf->nfilters--;
  return(0);
}

int sockbuf_detach_listener

(

int

fd

)

Definition at line 699 of file sockbuf.c.

References nlisteners, npollfds, and pollfds.

Referenced by rem_tcl_chan().

{
  int i;

  /* Search for it so we can clear its event field. */
  for (i = 0; i < nlisteners; i++) {
    if (pollfds[npollfds+i].fd == fd) break;
  }
  if (i < nlisteners) {
    memmove(pollfds+npollfds+i, pollfds+npollfds+i+1, sizeof(*pollfds) * (nlisteners-i-1));
    nlisteners--;
  }
  return(0);
}

int sockbuf_get_filter_data	(	int	idx,
		sockbuf_filter_t *	filter,
		void *	client_data_ptr
	)

Definition at line 754 of file sockbuf.c.

References sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::nfilters, and sockbuf_isvalid().

Referenced by dcc_send_info(), linemode_check(), netstring_check(), socktimer_check(), and socktimer_on().

{
  int i;
  sockbuf_t *sbuf;

  if (!sockbuf_isvalid(idx)) return(-1);
  sbuf = &sockbufs[idx];
  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i] == filter) {
      if (client_data_ptr) *(void **)client_data_ptr = sbuf->filter_client_data[i];
      return(0);
    }
  }
  return(-1);
}

int sockbuf_get_handler	(	int	idx,
		sockbuf_handler_t **	handler,
		void *	client_data_ptr
	)

Definition at line 664 of file sockbuf.c.

References sockbuf_t::handler, and sockbuf_isvalid().

Referenced by print_net().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  if (handler) *handler = sockbufs[idx].handler;
  if (client_data_ptr) *(void **)client_data_ptr = sockbufs[idx].client_data;

  return(0);
}

int sockbuf_get_peer	(	int	idx,
		const char **	peer_ip,
		int *	peer_port
	)

Definition at line 522 of file sockbuf.c.

References sockbuf_t::peer_ip, sockbuf_t::peer_port, and sockbuf_isvalid().

Referenced by print_net().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  if (peer_ip) *peer_ip = sockbufs[idx].peer_ip;
  if (peer_port) *peer_port = sockbufs[idx].peer_port;
  return(0);
}

int sockbuf_get_self	(	int	idx,
		const char **	my_ip,
		int *	my_port
	)

Definition at line 530 of file sockbuf.c.

References sockbuf_t::my_ip, sockbuf_t::my_port, and sockbuf_isvalid().

Referenced by print_net().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  if (my_ip) *my_ip = sockbufs[idx].my_ip;
  if (my_port) *my_port = sockbufs[idx].my_port;
  return(0);
}

int sockbuf_get_sock

(

int

idx

)

Definition at line 463 of file sockbuf.c.

References sockbuf_isvalid().

Referenced by dcc_listen_newclient(), dcc_on_connect(), http_on_read(), server_on_connect(), and socks5_connect_reply().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  return(sockbufs[idx].sock);
}

int sockbuf_get_stats	(	int	idx,
		sockbuf_stats_t **	stats
	)

Definition at line 538 of file sockbuf.c.

References sockbuf_isvalid(), sockbuf_t::stats, and update_stats().

Referenced by script_net_info(), and server_status().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  if (stats) {
    *stats = sockbufs[idx].stats;
    update_stats(*stats);
  }
  return(0);
}

static void sockbuf_got_eof	(	int	idx,
		int	err
	)			[static]

Definition at line 323 of file sockbuf.c.

References sockbuf_t::sock, sockbuf_close(), SOCKBUF_LEVEL_INTERNAL, sockbuf_on_eof(), and socket_get_error().

Referenced by sockbuf_got_readable(), sockbuf_got_writable(), sockbuf_got_writable_client(), sockbuf_real_write(), and sockbuf_update_all().

{
  char *errmsg;
  sockbuf_t *sbuf = &sockbufs[idx];

  /* If there's no error given, check for a socket-level error. */
  if (!err) err = socket_get_error(sbuf->sock);

  /* Get the associated error message. */
  errmsg = strerror(err);

  sockbuf_close(idx);
  sockbuf_on_eof(idx, SOCKBUF_LEVEL_INTERNAL, err, errmsg);
}

static void sockbuf_got_readable

(

int

idx

)

[static]

Definition at line 414 of file sockbuf.c.

References sockbuf_t::sock, sockbuf_got_eof(), SOCKBUF_LEVEL_INTERNAL, sockbuf_on_read(), sockbuf_t::stats, and stats_in().

Referenced by sockbuf_update_all().

{
  sockbuf_t *sbuf = &sockbufs[idx];
  char buf[4097];
  int nbytes;

  if (sbuf->sock < 0) return;
  errno = 0;
  nbytes = read(sbuf->sock, buf, sizeof(buf)-1);
  if (nbytes > 0) {
    stats_in(sbuf->stats, nbytes);
    buf[nbytes] = 0;
    sockbuf_on_read(idx, SOCKBUF_LEVEL_INTERNAL, buf, nbytes);
  }
  else {
    sockbuf_got_eof(idx, errno);
  }
}

static void sockbuf_got_readable_server

(

int

idx

)

[static]

Definition at line 364 of file sockbuf.c.

References NULL, sockbuf_t::sock, SOCKBUF_INBOUND, SOCKBUF_LEVEL_INTERNAL, sockbuf_new(), sockbuf_on_newclient(), sockbuf_set_sock(), socket_accept(), socket_set_nonblock(), and timer_get_now().

Referenced by sockbuf_update_all().

{
  int newsock, newidx, peer_port;
  char *peer_ip = NULL;
  sockbuf_t *sbuf = &sockbufs[idx];

  newsock = socket_accept(sbuf->sock, &peer_ip, &peer_port);
  if (newsock < 0) {
    if (peer_ip) free(peer_ip);
    return;
  }
  socket_set_nonblock(newsock, 1);

  newidx = sockbuf_new();
  timer_get_now(&sockbufs[newidx].stats->connected_at);
  sockbuf_set_sock(newidx, newsock, SOCKBUF_INBOUND);
  sockbuf_on_newclient(idx, SOCKBUF_LEVEL_INTERNAL, newidx, peer_ip, peer_port);
  free(peer_ip);
}

static void sockbuf_got_writable

(

int

idx

)

[static]

Definition at line 387 of file sockbuf.c.

References sockbuf_t::data, sockbuf_t::len, sockbuf_stats_t::raw_bytes_left, sockbuf_t::sock, sockbuf_got_eof(), SOCKBUF_LEVEL_INTERNAL, sockbuf_on_written(), sockbuf_unblock(), sockbuf_t::stats, and stats_out().

Referenced by sockbuf_update_all().

{
  int nbytes;
  sockbuf_t *sbuf = &sockbufs[idx];

  if (sbuf->sock < 0) return;
  /* Try to write any buffered data. */
  errno = 0;
  nbytes = write(sbuf->sock, sbuf->data, sbuf->len);
  if (nbytes > 0) {
    stats_out(sbuf->stats, nbytes);
    sbuf->len -= nbytes;
    sbuf->stats->raw_bytes_left = sbuf->len;
    if (!sbuf->len) sockbuf_unblock(idx);
    else memmove(sbuf->data, sbuf->data+nbytes, sbuf->len);
    sockbuf_on_written(idx, SOCKBUF_LEVEL_INTERNAL, nbytes, sbuf->len);
  }
  else if (nbytes < 0) {
    /* If there's an error writing to a socket that's marked as
      writable, then there's probably a socket-level error. */
    sockbuf_got_eof(idx, errno);
  }
}

static void sockbuf_got_writable_client

(

int

idx

)

[static]

Definition at line 341 of file sockbuf.c.

References sockbuf_t::flags, sockbuf_t::len, sockbuf_t::sock, SOCKBUF_CONNECTING, sockbuf_got_eof(), SOCKBUF_LEVEL_INTERNAL, sockbuf_on_connect(), sockbuf_unblock(), socket_get_error(), and socket_get_peer_name().

Referenced by sockbuf_update_all().

{
  int err, peer_port;
  char *peer_ip;
  sockbuf_t *sbuf = &sockbufs[idx];

  err = socket_get_error(sbuf->sock);
  if (err) {
    sockbuf_got_eof(idx, err);
    return;
  }

  sbuf->flags &= ~SOCKBUF_CONNECTING;
  if (!sbuf->len) sockbuf_unblock(idx);
  socket_get_peer_name(sbuf->sock, &peer_ip, &peer_port);

  sockbuf_on_connect(idx, SOCKBUF_LEVEL_INTERNAL, peer_ip, peer_port);
  if (peer_ip) free(peer_ip);
}

int sockbuf_init

(

void

)

Definition at line 92 of file sockbuf.c.

Referenced by egg_net_init().

{
  return (0); 
}

int sockbuf_isvalid

(

int

idx

)

Definition at line 582 of file sockbuf.c.

References nsockbufs, SOCKBUF_AVAIL, and SOCKBUF_DELETED.

Referenced by dcc_listen_delete(), dcc_send_bytes(), dcc_send_connect(), dcc_send_delete(), dcc_send_done(), dcc_send_written(), linemode_check(), linemode_on_read(), netstring_check(), netstring_on_read(), sockbuf_attach_filter(), sockbuf_close(), sockbuf_delete(), sockbuf_detach_filter(), sockbuf_get_filter_data(), sockbuf_get_handler(), sockbuf_get_peer(), sockbuf_get_self(), sockbuf_get_sock(), sockbuf_get_stats(), sockbuf_noread(), sockbuf_read(), sockbuf_set_handler(), sockbuf_set_sock(), sockbuf_write(), socktimer_check(), socktimer_on(), and throttle_off().

{
  if (idx >= 0 && idx < nsockbufs && !(sockbufs[idx].flags & (SOCKBUF_AVAIL | SOCKBUF_DELETED))) return(1);
  return(0);
}

int sockbuf_list	(	int **	idx,
		int *	len,
		int	flags
	)

Definition at line 131 of file sockbuf.c.

References nsockbufs, SOCKBUF_AVAIL, and SOCKBUF_DELETED.

Referenced by print_net().

{
  int i, j;

  *idx = malloc(sizeof(int) * (nsockbufs+1));
  j = 0;
  for (i = 0; i < nsockbufs; i++) {
    if (sockbufs[i].flags & (SOCKBUF_DELETED | SOCKBUF_AVAIL)) continue;
    if (sockbufs[i].flags & flags) (*idx)[j++] = i;
  }
  *len = j;
  return(0);
}

int sockbuf_new

(

void

)

Definition at line 433 of file sockbuf.c.

References sockbuf_t::flags, sockbuf_t::handler, nsockbufs, sockbuf_t::sock, SOCKBUF_AVAIL, SOCKBUF_BLOCK, and sockbuf_t::stats.

Referenced by dcc_accept_send(), dcc_start_chat(), dcc_start_send(), egg_client(), egg_connect(), egg_server(), get_dns_idx(), http_reconnect(), sockbuf_got_readable_server(), socks5_reconnect(), and terminal_init().

{
  sockbuf_t *sbuf;
  int idx;

  for (idx = 0; idx < nsockbufs; idx++) {
    if (sockbufs[idx].flags & SOCKBUF_AVAIL) break;
  }
  if (idx == nsockbufs) {
    int i;

    sockbufs = realloc(sockbufs, (nsockbufs+5) * sizeof(*sockbufs));
    memset(sockbufs+nsockbufs, 0, 5 * sizeof(*sockbufs));
    for (i = 0; i < 5; i++) {
      sockbufs[nsockbufs+i].sock = -1;
      sockbufs[nsockbufs+i].flags = SOCKBUF_AVAIL;
    }
    nsockbufs += 5;
  }

  sbuf = &sockbufs[idx];
  memset(sbuf, 0, sizeof(*sbuf));
  sbuf->flags = SOCKBUF_BLOCK;
  sbuf->sock = -1;
  sbuf->handler = &sockbuf_idler;
  sbuf->stats = calloc(1, sizeof(*sbuf->stats));

  return(idx);
}

int sockbuf_noread

(

int

idx

)

Definition at line 548 of file sockbuf.c.

References idx_array, npollfds, pollfds, and sockbuf_isvalid().

Referenced by throttle_on_read().

{
  int i;

  if (!sockbuf_isvalid(idx)) return(-1);

  /* Find the entry in the pollfds array. */
  for (i = 0; i < npollfds; i++) {
    if (idx_array[i] == idx) break;
  }

  if (i == npollfds) return(-1);

  pollfds[i].events &= (~POLLIN);
  return(0);
}

int sockbuf_on_connect	(	int	idx,
		int	level,
		const char *	peer_ip,
		int	peer_port
	)

Definition at line 224 of file sockbuf.c.

References sockbuf_t::client_data, sockbuf_stats_t::connected_at, sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::handler, sockbuf_filter_t::level, sockbuf_t::my_ip, sockbuf_t::my_port, sockbuf_t::nfilters, sockbuf_handler_t::on_connect, sockbuf_filter_t::on_connect, sockbuf_t::peer_ip, sockbuf_t::peer_port, sockbuf_t::sock, socket_get_name(), sockbuf_t::stats, str_redup(), and timer_get_now().

Referenced by dcc_chat_connect(), dcc_recv_connect(), dcc_send_connect(), egg_on_connect(), http_on_read(), sockbuf_got_writable_client(), and socks5_connect_reply().

{
  int i;
  sockbuf_t *sbuf = &sockbufs[idx];

  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i]->on_connect && sbuf->filters[i]->level > level) {
      return sbuf->filters[i]->on_connect(sbuf->filter_client_data[i], idx, peer_ip, peer_port);
    }
  }

  timer_get_now(&sbuf->stats->connected_at);
  if (peer_ip) str_redup(&sbuf->peer_ip, peer_ip);
  sbuf->peer_port = peer_port;
  socket_get_name(sbuf->sock, &sbuf->my_ip, &sbuf->my_port);

  if (sbuf->handler->on_connect) {
    sbuf->handler->on_connect(sbuf->client_data, idx, peer_ip, peer_port);
  }
  return(0);
}

int sockbuf_on_eof	(	int	idx,
		int	level,
		int	err,
		const char *	errmsg
	)

Definition at line 205 of file sockbuf.c.

References sockbuf_t::client_data, sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::handler, sockbuf_filter_t::level, sockbuf_t::nfilters, sockbuf_handler_t::on_eof, and sockbuf_filter_t::on_eof.

Referenced by connect_host_resolved(), dcc_chat_eof(), dcc_listen_delete(), dcc_recv_eof(), dcc_recv_timeout(), dcc_send_done(), dcc_send_eof(), egg_connect_timeout(), egg_on_eof(), http_err(), linemode_on_eof(), netstring_on_read(), sockbuf_got_eof(), socks5_err(), and socks5_on_delete().

{
  int i;
  sockbuf_t *sbuf = &sockbufs[idx];

  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i]->on_eof && sbuf->filters[i]->level > level) {
      return sbuf->filters[i]->on_eof(sbuf->filter_client_data[i], idx, err, errmsg);
    }
  }

  /* If we didn't branch to a filter, try the user handler. */
  if (sbuf->handler->on_eof) {
    sbuf->handler->on_eof(sbuf->client_data, idx, err, errmsg);
  }
  return(0);
}

int sockbuf_on_newclient	(	int	idx,
		int	level,
		int	newidx,
		const char *	peer_ip,
		int	peer_port
	)

Definition at line 247 of file sockbuf.c.

References sockbuf_t::client_data, sockbuf_stats_t::connected_at, sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::handler, sockbuf_filter_t::level, sockbuf_t::my_ip, sockbuf_t::my_port, sockbuf_t::nfilters, sockbuf_filter_t::on_connect, sockbuf_handler_t::on_newclient, sockbuf_filter_t::on_newclient, sockbuf_t::peer_ip, sockbuf_t::peer_port, sockbuf_t::sock, socket_get_name(), sockbuf_t::stats, str_redup(), and timer_get_now().

Referenced by sockbuf_got_readable_server().

{
  int i;
  sockbuf_t *sbuf = &sockbufs[idx];
  sockbuf_t *newsbuf = &sockbufs[newidx];

  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i]->on_connect && sbuf->filters[i]->level > level) {
      return sbuf->filters[i]->on_newclient(sbuf->filter_client_data[i], idx, newidx, peer_ip, peer_port);
    }
  }

  timer_get_now(&newsbuf->stats->connected_at);
  if (peer_ip) str_redup(&newsbuf->peer_ip, peer_ip);
  newsbuf->peer_port = peer_port;
  socket_get_name(newsbuf->sock, &newsbuf->my_ip, &newsbuf->my_port);

  if (sbuf->handler->on_newclient) {
    sbuf->handler->on_newclient(sbuf->client_data, idx, newidx, peer_ip, peer_port);
  }
  return(0);
}

int sockbuf_on_read	(	int	idx,
		int	level,
		char *	data,
		int	len
	)

Definition at line 271 of file sockbuf.c.

References sockbuf_stats_t::bytes_in, sockbuf_t::client_data, sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::handler, sockbuf_filter_t::level, sockbuf_t::nfilters, sockbuf_handler_t::on_read, sockbuf_filter_t::on_read, and sockbuf_t::stats.

Referenced by dcc_recv_read(), linemode_off(), linemode_on_eof(), linemode_on_read(), netstring_off(), netstring_on_read(), sockbuf_got_readable(), telnet_filter_read(), and throttle_on_read().

{
  int i;
  sockbuf_t *sbuf = &sockbufs[idx];

  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i]->on_read && sbuf->filters[i]->level > level) {
      return sbuf->filters[i]->on_read(sbuf->filter_client_data[i], idx, data, len);
    }
  }

  sbuf->stats->bytes_in += len;
  if (sbuf->handler->on_read) {
    sbuf->handler->on_read(sbuf->client_data, idx, data, len);
  }
  return(0);
}

int sockbuf_on_write	(	int	idx,
		int	level,
		const char *	data,
		int	len
	)

Definition at line 290 of file sockbuf.c.

References sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_filter_t::level, sockbuf_t::nfilters, sockbuf_filter_t::on_write, and sockbuf_real_write().

Referenced by dcc_recv_read(), netstring_on_write(), sockbuf_write(), telnet_code(), telnet_filter_read(), telnet_filter_write(), throttle_off(), throttle_on_write(), throttle_secondly(), and throttle_set().

{
  int i;
  sockbuf_t *sbuf = &sockbufs[idx];

  for (i = sbuf->nfilters-1; i >= 0; i--) {
    if (sbuf->filters[i]->on_write && sbuf->filters[i]->level < level) {
      return sbuf->filters[i]->on_write(sbuf->filter_client_data[i], idx, data, len);
    }
  }
  /* There's no user handler for on_write (they wrote it). */
  return sockbuf_real_write(idx, data, len);
}

int sockbuf_on_written	(	int	idx,
		int	level,
		int	len,
		int	remaining
	)

Definition at line 305 of file sockbuf.c.

References sockbuf_t::client_data, sockbuf_t::filter_client_data, sockbuf_t::filters, sockbuf_t::handler, sockbuf_filter_t::level, sockbuf_t::nfilters, sockbuf_handler_t::on_written, and sockbuf_filter_t::on_written.

Referenced by dcc_send_bytes(), dcc_send_written(), sockbuf_got_writable(), throttle_on_written(), throttle_secondly(), and throttle_set().

{
  int i;
  sockbuf_t *sbuf = &sockbufs[idx];

  for (i = 0; i < sbuf->nfilters; i++) {
    if (sbuf->filters[i]->on_written && sbuf->filters[i]->level > level) {
      return sbuf->filters[i]->on_written(sbuf->filter_client_data[i], idx, len, remaining);
    }
  }

  if (sbuf->handler->on_written) {
    sbuf->handler->on_written(sbuf->client_data, idx, len, remaining);
  }
  return(0);
}

int sockbuf_read

(

int

idx

)

Definition at line 565 of file sockbuf.c.

References idx_array, npollfds, pollfds, and sockbuf_isvalid().

Referenced by throttle_secondly().

{
  int i;

  if (!sockbuf_isvalid(idx)) return(-1);

  /* Find the entry in the pollfds array. */
  for (i = 0; i < npollfds; i++) {
    if (idx_array[i] == idx) break;
  }

  if (i == npollfds) return(-1);

  pollfds[i].events |= POLLIN;
  return(0);
}

static int sockbuf_real_write	(	int	idx,
		const char *	data,
		int	len
	)			[static]

Definition at line 173 of file sockbuf.c.

References sockbuf_t::data, sockbuf_t::flags, sockbuf_t::len, sockbuf_t::sock, sockbuf_block(), SOCKBUF_BLOCK, sockbuf_got_eof(), sockbuf_t::stats, and stats_out().

Referenced by sockbuf_on_write().

{
  int nbytes = 0;
  sockbuf_t *sbuf = &sockbufs[idx];

  if (sbuf->sock < 0) return 0;
  /* If it's not blocked already, write as much as we can. */
  if (!(sbuf->flags & SOCKBUF_BLOCK)) {   
    nbytes = write (sbuf->sock, data, len);
    if (nbytes < 0) {
      if (errno != EAGAIN) {
        sockbuf_got_eof(idx, errno);
        return(nbytes);
      }
      nbytes = 0;
    }

    if (nbytes > 0) stats_out(sbuf->stats, nbytes);
    if (nbytes == len) return(nbytes);
    sockbuf_block(idx);
    data += nbytes;
    len -= nbytes;
  }

  /* Add the remaining data to the buffer. */
  sbuf->data = realloc(sbuf->data, sbuf->len + len);
  memcpy(sbuf->data + sbuf->len, data, len);
  sbuf->len += len;
  return(nbytes);
}

int sockbuf_set_handler	(	int	idx,
		sockbuf_handler_t *	handler,
		void *	client_data,
		event_owner_t *	owner
	)

Definition at line 673 of file sockbuf.c.

References sockbuf_t::client_data, sockbuf_t::handler, sockbuf_t::owner, and sockbuf_isvalid().

Referenced by bot_init(), connect_to_next_server(), dcc_listen(), do_link(), egg_ident_lookup(), get_dns_idx(), got_chat_request(), http_reconnect(), idx_on_newclient(), irc_init(), irc_on_newclient(), script_net_takeover(), socks5_reconnect(), telnet_init(), telnet_on_newclient(), and terminal_init().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  sockbufs[idx].handler = handler;
  sockbufs[idx].client_data = client_data;
  sockbufs[idx].owner = owner;

  return(0);
}

int sockbuf_set_sock	(	int	idx,
		int	sock,
		int	flags
	)

Definition at line 469 of file sockbuf.c.

References sockbuf_t::flags, idx_array, nlisteners, npollfds, pollfds, sockbuf_t::sock, SOCKBUF_BLOCK, SOCKBUF_CLIENT, SOCKBUF_CONNECTING, sockbuf_isvalid(), SOCKBUF_NOREAD, SOCKBUF_SERVER, and socket_get_name().

Referenced by connect_host_resolved(), dcc_listen_newclient(), egg_server(), get_dns_idx(), http_on_read(), sockbuf_close(), sockbuf_got_readable_server(), socks5_connect_reply(), terminal_init(), and terminal_shutdown().

{
  int i;

  if (!sockbuf_isvalid(idx)) return(-1);

  sockbufs[idx].sock = sock;
  sockbufs[idx].flags &= ~(SOCKBUF_CONNECTING|SOCKBUF_CLIENT|SOCKBUF_SERVER|SOCKBUF_BLOCK|SOCKBUF_NOREAD);
  sockbufs[idx].flags |= flags;
  if (sockbufs[idx].flags & SOCKBUF_SERVER) {
    socket_get_name(sockbufs[idx].sock, &sockbufs[idx].my_ip, &sockbufs[idx].my_port);
  }

  /* pollfds   = [socks][socks][socks][listeners][listeners][end] */
  /* idx_array = [ idx ][ idx ][ idx ][end]*/
  /* So when we grow pollfds, we shift the listeners at the end. */

  /* Find the entry in the pollfds array. */
  for (i = 0; i < npollfds; i++) {
    if (idx_array[i] == idx) break;
  }

  if (sock == -1) {
    if (i == npollfds) return(1);

    /* If they set the sock to -1, then we remove the entry. */
    memmove(idx_array+i, idx_array+i+1, sizeof(int) * (npollfds-i-1));
    memmove(pollfds+i, pollfds+i+1, sizeof(*pollfds) * (nlisteners + npollfds-i-1));
    npollfds--;
    return(0);
  }

  /* Add it to the end if it's not found. */
  if (i == npollfds) {
    /* Add the new idx to the idx_array. */
    idx_array = realloc(idx_array, sizeof(int) * (i+1));
    idx_array[i] = idx;

    /* Add corresponding pollfd to pollfds. */
    pollfds = realloc(pollfds, sizeof(*pollfds) * (i+nlisteners+1));
    memmove(pollfds+i+1, pollfds+i, sizeof(*pollfds) * nlisteners);

    npollfds++;
  }

  pollfds[i].fd = sock;
  pollfds[i].events = 0;
  if (flags & (SOCKBUF_BLOCK|SOCKBUF_CONNECTING)) pollfds[i].events |= POLLOUT;
  if (!(flags & SOCKBUF_NOREAD)) pollfds[i].events |= POLLIN;

  return(idx);
}

int sockbuf_shutdown

(

void

)

Definition at line 97 of file sockbuf.c.

References idx_array, LOG_DEBUG, sockbuf_t::my_ip, sockbuf_t::my_port, npollfds, nsockbufs, NULL, sockbuf_t::peer_ip, sockbuf_t::peer_port, pollfds, putlog(), and sockbuf_delete().

Referenced by egg_net_shutdown().

{
  int i;

  for (i = npollfds - 1; i >= 0; i--) {
          sockbuf_t *sbuf = &sockbufs[idx_array[i]];

    putlog(LOG_DEBUG, "*", "Socket %i %s:%i shouldn't be opened at this stage, closing.", idx_array[i],
      (sbuf->peer_ip) ? sbuf->peer_ip : sbuf->my_ip,
      (sbuf->peer_ip) ? sbuf->peer_port : sbuf->my_port);
      
    sockbuf_delete(idx_array[i]);
  }

  if (idx_array) {
    free(idx_array);
    idx_array = NULL;
  }

  if (pollfds) {
    free(pollfds);
    pollfds = NULL;
  }
  npollfds = 0;

  if (sockbufs) {
    free(sockbufs);
    sockbufs = NULL;
  }
  nsockbufs = 0;

  return (0);
}

static void sockbuf_unblock

(

int

idx

)

[static]

Definition at line 159 of file sockbuf.c.

References sockbuf_t::flags, idx_array, npollfds, pollfds, and SOCKBUF_BLOCK.

Referenced by sockbuf_got_writable(), and sockbuf_got_writable_client().

{
  int i;
  sockbufs[idx].flags &= (~SOCKBUF_BLOCK);
  for (i = 0; i < npollfds; i++) {
    if (idx_array[i] == idx) {
      pollfds[i].events &= (~POLLOUT);
      break;
    }
  }
}

int sockbuf_update_all

(

int

timeout

)

Definition at line 798 of file sockbuf.c.

References sockbuf_t::flags, idx_array, ndeleted_sockbufs, npollfds, nsockbufs, pollfds, SOCKBUF_AVAIL, SOCKBUF_CONNECTING, SOCKBUF_DELETED, sockbuf_got_eof(), sockbuf_got_readable(), sockbuf_got_readable_server(), sockbuf_got_writable(), sockbuf_got_writable_client(), and SOCKBUF_SERVER.

Referenced by main().

{
  int i, n, flags, revents, idx;
  static int depth = 0;

  /* Increment the depth counter when we enter the proc. */
  depth++;

  n = poll(pollfds, npollfds, timeout);
  if (n < 0) n = npollfds;

  /* If a sockbuf gets deleted during its event handler, the pollfds array
    gets shifted down and we will miss the events of the next
    socket. That's ok, because we'll pick up those events next
    time.
  */
  for (i = 0; n && i < npollfds; i++) {
    /* Common case: no activity. */
    revents = pollfds[i].revents;
    if (!revents) continue;

    idx = idx_array[i];
    flags = sockbufs[idx].flags;
    if (revents & POLLOUT) {
      if (flags & SOCKBUF_CONNECTING) sockbuf_got_writable_client(idx);
      else sockbuf_got_writable(idx);
    }
    if (revents & POLLIN) {
      if (flags & SOCKBUF_SERVER) sockbuf_got_readable_server(idx);
      else sockbuf_got_readable(idx);
    }
    if (revents & (POLLHUP|POLLNVAL|POLLERR)) sockbuf_got_eof(idx, 0);
    n--;
  }

  /* Now that we're done manipulating stuff, back out of the depth. */
  depth--;

  /* If this is the topmost level, check for deleted sockbufs. */
  if (ndeleted_sockbufs && !depth) {
    for (i = 0; ndeleted_sockbufs && i < nsockbufs; i++) {
      if (sockbufs[i].flags & SOCKBUF_DELETED) {
        sockbufs[i].flags = SOCKBUF_AVAIL;
        ndeleted_sockbufs--;
      }
    }
    /* If ndeleted_sockbufs isn't 0, then we somehow lost track of
      an idx. That can't happen, but we might as well be
      safe. */
    ndeleted_sockbufs = 0;
  }

  return(0);
}

int sockbuf_write	(	int	idx,
		const char *	data,
		int	len
	)

Definition at line 656 of file sockbuf.c.

References sockbuf_stats_t::bytes_out, sockbuf_isvalid(), SOCKBUF_LEVEL_WRITE_INTERNAL, sockbuf_on_write(), and sockbuf_t::stats.

Referenced by dcc_on_read(), dcc_send_bytes(), do_output(), egg_dns_send(), egg_iprintf(), irc_on_newclient(), irc_on_read(), on_botbroadcast(), on_botmsg(), on_extension(), process_results(), script_net_write(), send_connect_request(), socks5_auth_method(), socks5_on_connect(), telnet_filter_read(), telnet_on_newclient(), and telnet_on_read().

{
  if (!sockbuf_isvalid(idx)) return(-1);
  if (len < 0) len = strlen(data);
  sockbufs[idx].stats->bytes_out += len;
  return sockbuf_on_write(idx, SOCKBUF_LEVEL_WRITE_INTERNAL, data, len);
}

static void stats_in	(	sockbuf_stats_t *	stats,
		int	len
	)			[static]

Definition at line 862 of file sockbuf.c.

References sockbuf_stats_t::last_input_at, sockbuf_stats_t::raw_bytes_in, egg_timeval::sec, skip_stats(), sockbuf_stats_t::snapshot_counter, sockbuf_stats_t::snapshot_in_bytes, and timer_get_now().

Referenced by sockbuf_got_readable().

{
  timer_get_now(&stats->last_input_at);
  skip_stats(stats, stats->last_input_at.sec);
  stats->raw_bytes_in += len;
  stats->snapshot_in_bytes[stats->snapshot_counter] += len;
}

static void stats_out	(	sockbuf_stats_t *	stats,
		int	len
	)			[static]

Definition at line 854 of file sockbuf.c.

References sockbuf_stats_t::last_output_at, sockbuf_stats_t::raw_bytes_out, egg_timeval::sec, skip_stats(), sockbuf_stats_t::snapshot_counter, sockbuf_stats_t::snapshot_out_bytes, and timer_get_now().

Referenced by sockbuf_got_writable(), and sockbuf_real_write().

{
  timer_get_now(&stats->last_output_at);
  skip_stats(stats, stats->last_output_at.sec);
  stats->raw_bytes_out += len;
  stats->snapshot_out_bytes[stats->snapshot_counter] += len;
}

static void update_stats

(

sockbuf_stats_t *

stats

)

[static]

Definition at line 888 of file sockbuf.c.

References sockbuf_stats_t::connected_at, NULL, sockbuf_stats_t::raw_bytes_in, sockbuf_stats_t::raw_bytes_out, egg_timeval::sec, skip_stats(), sockbuf_stats_t::snapshot_counter, sockbuf_stats_t::snapshot_in_bytes, sockbuf_stats_t::snapshot_in_cps, sockbuf_stats_t::snapshot_out_bytes, sockbuf_stats_t::snapshot_out_cps, timer_get_now_sec(), sockbuf_stats_t::total_in_cps, and sockbuf_stats_t::total_out_cps.

Referenced by sockbuf_get_stats().

{
  int curtime = timer_get_now_sec(NULL);
  int nsecs;
  int snap_in = 0, snap_out = 0;
  int i;

  /* Compute total input cps. */
  nsecs = curtime - stats->connected_at.sec + 1;

  stats->total_in_cps = stats->raw_bytes_in / nsecs;
  stats->total_out_cps = stats->raw_bytes_out / nsecs;

  /* Compute cps. */

  /* Zero out any skipped seconds. */
  skip_stats(stats, curtime);

  /* When we calculate the totals, we do not include the current second
   * because more data might be sent during this second and our report
   * will be pretty inaccurate. */
  for (i = 0; i < 5; i++) {
    if (i != stats->snapshot_counter) {
      snap_in += stats->snapshot_in_bytes[i];
      snap_out += stats->snapshot_out_bytes[i];
    }
  }
  if (nsecs > 4) nsecs = 4;
  else if (nsecs > 1) nsecs--;
  else nsecs = 1;
  stats->snapshot_in_cps = snap_in / nsecs;
  stats->snapshot_out_cps = snap_out / nsecs;
}

---

Variable Documentation

int* idx_array = NULL [static]

Definition at line 69 of file sockbuf.c.

Referenced by sockbuf_block(), sockbuf_delete(), sockbuf_noread(), sockbuf_read(), sockbuf_set_sock(), sockbuf_shutdown(), sockbuf_unblock(), and sockbuf_update_all().

int ndeleted_sockbufs = 0 [static]

Definition at line 66 of file sockbuf.c.

Referenced by sockbuf_delete(), and sockbuf_update_all().

int nlisteners = 0 [static]

Definition at line 75 of file sockbuf.c.

Referenced by sockbuf_attach_listener(), sockbuf_delete(), sockbuf_detach_listener(), and sockbuf_set_sock().

int npollfds = 0 [static]

Definition at line 71 of file sockbuf.c.

Referenced by sockbuf_attach_listener(), sockbuf_block(), sockbuf_delete(), sockbuf_detach_listener(), sockbuf_noread(), sockbuf_read(), sockbuf_set_sock(), sockbuf_shutdown(), sockbuf_unblock(), and sockbuf_update_all().

int nsockbufs = 0 [static]

Definition at line 65 of file sockbuf.c.

Referenced by sockbuf_isvalid(), sockbuf_list(), sockbuf_new(), sockbuf_shutdown(), and sockbuf_update_all().

struct pollfd* pollfds = NULL [static]

Definition at line 70 of file sockbuf.c.

Referenced by sockbuf_attach_listener(), sockbuf_block(), sockbuf_delete(), sockbuf_detach_listener(), sockbuf_noread(), sockbuf_read(), sockbuf_set_sock(), sockbuf_shutdown(), sockbuf_unblock(), and sockbuf_update_all().

const char rcsid[] = "$Id: sockbuf.c,v 1.23 2007-09-13 22:20:55 sven Exp $" [static]

Definition at line 21 of file sockbuf.c.

sockbuf_handler_t sockbuf_idler [static]

Initial value:

 {
  "idle",
  NULL, NULL, NULL,
  NULL, NULL
}

Definition at line 78 of file sockbuf.c.

sockbuf_t* sockbufs = NULL [static]

Definition at line 64 of file sockbuf.c.