text: /* vi: set sw=4 ts=4: */
  /*
   * Generic non-forking server infrastructure.
   * Intended to make writing telnetd-type servers easier.
   *
   * Copyright (C) 2007 Denys Vlasenko
   *
   * Licensed under GPL version 2, see file LICENSE in this tarball for details.
   */
  
  #include "libbb.h"
  #include "isrv.h"
  
  #define DEBUG 0
  
  #if DEBUG
  #define DPRINTF(args...) bb_error_msg(args)
  #else
  #define DPRINTF(args...) ((void)0)
  #endif
  
  /* Helpers */
  
  /* Opaque structure */
  
  struct isrv_state_t {
  	short  *fd2peer; /* one per registered fd */
  	void  **param_tbl; /* one per registered peer */
  	/* one per registered peer; doesn't exist if !timeout */
  	time_t *timeo_tbl;
  	int   (*new_peer)(isrv_state_t *state, int fd);
  	time_t  curtime;
  	int     timeout;
  	int     fd_count;
  	int     peer_count;
  	int     wr_count;
  	fd_set  rd;
  	fd_set  wr;
  };
  #define FD2PEER    (state->fd2peer)
  #define PARAM_TBL  (state->param_tbl)
  #define TIMEO_TBL  (state->timeo_tbl)
  #define CURTIME    (state->curtime)
  #define TIMEOUT    (state->timeout)
  #define FD_COUNT   (state->fd_count)
  #define PEER_COUNT (state->peer_count)
  #define WR_COUNT   (state->wr_count)
  
  /* callback */
  void isrv_want_rd(isrv_state_t *state, int fd)
  {
  	FD_SET(fd, &state->rd);
  }
  
  /* callback */
  void isrv_want_wr(isrv_state_t *state, int fd)
  {
  	if (!FD_ISSET(fd, &state->wr)) {
  		WR_COUNT++;
  		FD_SET(fd, &state->wr);
  	}
  }
  
  /* callback */
  void isrv_dont_want_rd(isrv_state_t *state, int fd)
  {
  	FD_CLR(fd, &state->rd);
  }
  
  /* callback */
  void isrv_dont_want_wr(isrv_state_t *state, int fd)
  {
  	if (FD_ISSET(fd, &state->wr)) {
  		WR_COUNT--;
  		FD_CLR(fd, &state->wr);
  	}
  }
  
  /* callback */
  int isrv_register_fd(isrv_state_t *state, int peer, int fd)
  {
  	int n;
  
  	DPRINTF("register_fd(peer:%d,fd:%d)", peer, fd);
  
  	if (FD_COUNT >= FD_SETSIZE) return -1;
  	if (FD_COUNT <= fd) {
  		n = FD_COUNT;
  		FD_COUNT = fd + 1;
  
  		DPRINTF("register_fd: FD_COUNT %d", FD_COUNT);
  
  		FD2PEER = xrealloc(FD2PEER, FD_COUNT * sizeof(FD2PEER[0]));
  		while (n < fd) FD2PEER[n++] = -1;
  	}
  
  	DPRINTF("register_fd: FD2PEER[%d] = %d", fd, peer);
  
  	FD2PEER[fd] = peer;
  	return 0;
  }
  
  /* callback */
  void isrv_close_fd(isrv_state_t *state, int fd)
  {
  	DPRINTF("close_fd(%d)", fd);
  
  	close(fd);
  	isrv_dont_want_rd(state, fd);
  	if (WR_COUNT) isrv_dont_want_wr(state, fd);
  
  	FD2PEER[fd] = -1;
  	if (fd == FD_COUNT-1) {
  		do fd--; while (fd >= 0 && FD2PEER[fd] == -1);
  		FD_COUNT = fd + 1;
  
  		DPRINTF("close_fd: FD_COUNT %d", FD_COUNT);
  
  		FD2PEER = xrealloc(FD2PEER, FD_COUNT * sizeof(FD2PEER[0]));
  	}
  }
  
  /* callback */
  int isrv_register_peer(isrv_state_t *state, void *param)
  {
  	int n;
  
  	if (PEER_COUNT >= FD_SETSIZE) return -1;
  	n = PEER_COUNT++;
  
  	DPRINTF("register_peer: PEER_COUNT %d", PEER_COUNT);
  
  	PARAM_TBL = xrealloc(PARAM_TBL, PEER_COUNT * sizeof(PARAM_TBL[0]));
  	PARAM_TBL[n] = param;
  	if (TIMEOUT) {
  		TIMEO_TBL = xrealloc(TIMEO_TBL, PEER_COUNT * sizeof(TIMEO_TBL[0]));
  		TIMEO_TBL[n] = CURTIME;
  	}
  	return n;
  }
  
  static void remove_peer(isrv_state_t *state, int peer)
  {
  	int movesize;
  	int fd;
  
  	DPRINTF("remove_peer(%d)", peer);
  
  	fd = FD_COUNT - 1;
  	while (fd >= 0) {
  		if (FD2PEER[fd] == peer) {
  			isrv_close_fd(state, fd);
  			fd--;
  			continue;
  		}
  		if (FD2PEER[fd] > peer)
  			FD2PEER[fd]--;
  		fd--;
  	}
  
  	PEER_COUNT--;
  	DPRINTF("remove_peer: PEER_COUNT %d", PEER_COUNT);
  
  	movesize = (PEER_COUNT - peer) * sizeof(void*);
  	if (movesize > 0) {
  		memcpy(&PARAM_TBL[peer], &PARAM_TBL[peer+1], movesize);
  		if (TIMEOUT)
  			memcpy(&TIMEO_TBL[peer], &TIMEO_TBL[peer+1], movesize);
  	}
  	PARAM_TBL = xrealloc(PARAM_TBL, PEER_COUNT * sizeof(PARAM_TBL[0]));
  	if (TIMEOUT)
  		TIMEO_TBL = xrealloc(TIMEO_TBL, PEER_COUNT * sizeof(TIMEO_TBL[0]));
  }
  
  static void handle_accept(isrv_state_t *state, int fd)
  {
  	int n, newfd;
  
  	/* suppress gcc warning "cast from ptr to int of different size" */
  	fcntl(fd, F_SETFL, (int)(ptrdiff_t)(PARAM_TBL[0]) | O_NONBLOCK);
  	newfd = accept(fd, NULL, 0);
  	fcntl(fd, F_SETFL, (int)(ptrdiff_t)(PARAM_TBL[0]));
  	if (newfd < 0) {
  		if (errno == EAGAIN) return;
  		/* Most probably someone gave us wrong fd type
  		 * (for example, non-socket). Don't want
  		 * to loop forever. */
  		bb_perror_msg_and_die("accept");
  	}
  
  	DPRINTF("new_peer(%d)", newfd);
  	n = state->new_peer(state, newfd);
  	if (n)
  		remove_peer(state, n); /* unsuccesful peer start */
  }
  
  void BUG_sizeof_fd_set_is_strange(void);
  static void handle_fd_set(isrv_state_t *state, fd_set *fds, int (*h)(int, void **))
  {
  	enum { LONG_CNT = sizeof(fd_set) / sizeof(long) };
  	int fds_pos;
  	int fd, peer;
  	/* need to know value at _the beginning_ of this routine */
  	int fd_cnt = FD_COUNT;
  
  	if (LONG_CNT * sizeof(long) != sizeof(fd_set))
  		BUG_sizeof_fd_set_is_strange();
  
  	fds_pos = 0;
  	while (1) {
  		/* Find next nonzero bit */
  		while (fds_pos < LONG_CNT) {
  			if (((long*)fds)[fds_pos] == 0) {
  				fds_pos++;
  				continue;
  			}
  			/* Found non-zero word */
  			fd = fds_pos * sizeof(long)*8; /* word# -> bit# */
  			while (1) {
  				if (FD_ISSET(fd, fds)) {
  					FD_CLR(fd, fds);
  					goto found_fd;
  				}
  				fd++;
  			}
  		}
  		break; /* all words are zero */
   found_fd:
  		if (fd >= fd_cnt) { /* paranoia */
  			DPRINTF("handle_fd_set: fd > fd_cnt?? (%d > %d)",
  					fd, fd_cnt);
  			break;
  		}
  		DPRINTF("handle_fd_set: fd %d is active", fd);
  		peer = FD2PEER[fd];
  		if (peer < 0)
  			continue; /* peer is already gone */
  		if (peer == 0) {
  			handle_accept(state, fd);
  			continue;
  		}
  		DPRINTF("h(fd:%d)", fd);
  		if (h(fd, &PARAM_TBL[peer])) {
  			/* this peer is gone */
  			remove_peer(state, peer);
  		} else if (TIMEOUT) {
  			TIMEO_TBL[peer] = monotonic_sec();
  		}
  	}
  }
  
  static void handle_timeout(isrv_state_t *state, int (*do_timeout)(void **))
  {
  	int n, peer;
  	peer = PEER_COUNT-1;
  	/* peer 0 is not checked */
  	while (peer > 0) {
  		DPRINTF("peer %d: time diff %d", peer,
  				(int)(CURTIME - TIMEO_TBL[peer]));
  		if ((CURTIME - TIMEO_TBL[peer]) >= TIMEOUT) {
  			DPRINTF("peer %d: do_timeout()", peer);
  			n = do_timeout(&PARAM_TBL[peer]);
  			if (n)
  				remove_peer(state, peer);
  		}
  		peer--;
  	}
  }
  
  /* Driver */
  void isrv_run(
  	int listen_fd,
  	int (*new_peer)(isrv_state_t *state, int fd),
  	int (*do_rd)(int fd, void **),
  	int (*do_wr)(int fd, void **),
  	int (*do_timeout)(void **),
  	int timeout,
  	int linger_timeout)
  {
  	isrv_state_t *state = xzalloc(sizeof(*state));
  	state->new_peer = new_peer;
  	state->timeout  = timeout;
  
  	/* register "peer" #0 - it will accept new connections */
  	isrv_register_peer(state, NULL);
  	isrv_register_fd(state, /*peer:*/ 0, listen_fd);
  	isrv_want_rd(state, listen_fd);
  	/* remember flags to make blocking<->nonblocking switch faster */
  	/* (suppress gcc warning "cast from ptr to int of different size") */
  	PARAM_TBL[0] = (void*)(ptrdiff_t)(fcntl(listen_fd, F_GETFL));
  
  	while (1) {
  		struct timeval tv;
  		fd_set rd;
  		fd_set wr;
  		fd_set *wrp = NULL;
  		int n;
  
  		tv.tv_sec = timeout;
  		if (PEER_COUNT <= 1)
  			tv.tv_sec = linger_timeout;
  		tv.tv_usec = 0;
  		rd = state->rd;
  		if (WR_COUNT) {
  			wr = state->wr;
  			wrp = &wr;
  		}
  
  		DPRINTF("run: select(FD_COUNT:%d,timeout:%d)...",
  				FD_COUNT, (int)tv.tv_sec);
  		n = select(FD_COUNT, &rd, wrp, NULL, tv.tv_sec ? &tv : NULL);
  		DPRINTF("run: ...select:%d", n);
  
  		if (n < 0) {
  			if (errno != EINTR)
  				bb_perror_msg("select");
  			continue;
  		}
  
  		if (n == 0 && linger_timeout && PEER_COUNT <= 1)
  			break;
  
  		if (timeout) {
  			time_t t = monotonic_sec();
  			if (t != CURTIME) {
  				CURTIME = t;
  				handle_timeout(state, do_timeout);
  			}
  		}
  		if (n > 0) {
  			handle_fd_set(state, &rd, do_rd);
  			if (wrp)
  				handle_fd_set(state, wrp, do_wr);
  		}
  	}
  	DPRINTF("run: bailout");
  	/* NB: accept socket is not closed. Caller is to decide what to do */
  }
  