src/common/fdwatch_poll.c

/*
  * Abstraction API/layer for the various ways PvPGN can inspect sockets state
  * 2003 (C) dizzy@roedu.net
  *
  * Code is based on the ideas found in thttpd project.
  *
  * poll(2) based backend
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */

#include "common/setup_before.h"
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#ifdef HAVE_POLL_H
# include <poll.h>
#else
# ifdef HAVE_SYS_POLL_H
#  include <sys/poll.h>
# endif
#endif
#include "fdwatch.h"
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/setup_after.h"

#ifdef HAVE_POLL
static int sr;
static struct pollfd *fds = NULL; /* working set */
static int *_rridx = NULL;
static int *_ridx = NULL;
static unsigned nofds;

static int fdw_poll_init(int nfds);
static int fdw_poll_close(void);
static int fdw_poll_add_fd(int idx, t_fdwatch_type rw);
static int fdw_poll_del_fd(int idx);
static int fdw_poll_watch(long timeout_msecs);
static void fdw_poll_handle(void);

t_fdw_backend fdw_poll = {
    fdw_poll_init,
    fdw_poll_close,
    fdw_poll_add_fd,
    fdw_poll_del_fd,
    fdw_poll_watch,
    fdw_poll_handle
};

static int fdw_poll_init(int nfds)
{
    int i;

    _ridx = xmalloc(sizeof(int) * nfds);
    fds = xmalloc(sizeof(struct pollfd) * nfds);
    _rridx = xmalloc(sizeof(int) * nfds);

    memset(fds, 0, sizeof(struct pollfd) * nfds);
    memset(_rridx, 0, sizeof(int) * nfds);
/* I would use a memset with 255 but that is dirty and doesnt gain us anything */
    for(i = 0; i < nfds; i++) _ridx[i] = -1;
    nofds = sr = 0;

    eventlog(eventlog_level_info, __FUNCTION__, "fdwatch poll() based layer initialized (max %d sockets)", nfds);
    return 0;
}

static int fdw_poll_close(void)
{
    if (fds) { xfree((void *)fds); fds = NULL; }
    if (_ridx) { xfree((void *)_ridx); _ridx = NULL; }
    if (_rridx) { xfree((void *)_rridx); _rridx = NULL; }
    nofds = sr = 0;

    return 0;
}

static int fdw_poll_add_fd(int idx, t_fdwatch_type rw)
{
    static int ridx;

//    eventlog(eventlog_level_trace, __FUNCTION__, "called fd: %d rw: %d", fd, rw);
    if (_ridx[idx] < 0) {
        ridx = nofds++;
        fds[ridx].fd = fdw_fd(fdw_fds + idx);
        _ridx[idx] = ridx;
        _rridx[ridx] = idx;
//      eventlog(eventlog_level_trace, __FUNCTION__, "adding new fd on %d", ridx);
    } else {
        if (fds[_ridx[idx]].fd != fdw_fd(fdw_fds + idx)) {
            eventlog(eventlog_level_error,__FUNCTION__,"BUG: found existent poll_fd entry for same idx with different fd");
            return -1;
        }
        ridx = _ridx[idx];
//      eventlog(eventlog_level_trace, __FUNCTION__, "updating fd on %d", ridx);
    }

    fds[ridx].events = 0;
    if (rw & fdwatch_type_read) fds[ridx].events |= POLLIN;
    if (rw & fdwatch_type_write) fds[ridx].events |= POLLOUT;

    return 0;
}

static int fdw_poll_del_fd(int idx)
{
//    eventlog(eventlog_level_trace, __FUNCTION__, "called fd: %d", fd);
    if (_ridx[idx] < 0 || !nofds) return -1;
    if (sr > 0) 
        eventlog(eventlog_level_error, __FUNCTION__, "BUG: called while still handling sockets");

    /* move the last entry to the deleted one and decrement nofds count */
    nofds--;
    if (_ridx[idx] < nofds) {
//      eventlog(eventlog_level_trace, __FUNCTION__, "not last, moving %d", tfds[nofds].fd);
        _ridx[_rridx[nofds]] = _ridx[idx];
        _rridx[_ridx[idx]] = _rridx[nofds];
        memcpy(fds + _ridx[idx], fds + nofds, sizeof(struct pollfd));
    }
    _ridx[idx] = -1;

    return 0;
}

static int fdw_poll_watch(long timeout_msec)
{
    return (sr = poll(fds, nofds, timeout_msec));
}

static void fdw_poll_handle(void)
{
    register unsigned i;
    int changed;
    t_fdwatch_fd *cfd;

    for(i = 0; i < nofds && sr; i++) {
        changed = 0;
        cfd = fdw_fds + _rridx[i];

        if (fdw_rw(cfd) & fdwatch_type_read && 
            fds[i].revents & (POLLIN  | POLLERR | POLLHUP | POLLNVAL))
        {
            if (fdw_hnd(cfd)(fdw_data(cfd), fdwatch_type_read) == -2) {
                sr--;
                continue;
            }
            changed = 1;
        }

        if (fdw_rw(cfd) & fdwatch_type_write && 
            fds[i].revents & (POLLOUT  | POLLERR | POLLHUP | POLLNVAL))
        {
            fdw_hnd(cfd)(fdw_data(cfd), fdwatch_type_write);
            changed = 1;
        }

        if (changed) sr--;
    }
}

#endif /* HAVE_POLL */
1	sysadm	1.1	/*
2			* Abstraction API/layer for the various ways PvPGN can inspect sockets state
3			* 2003 (C) dizzy@roedu.net
4			*
5			* Code is based on the ideas found in thttpd project.
6			*
7			* poll(2) based backend
8			*
9			* This program is free software; you can redistribute it and/or
10			* modify it under the terms of the GNU General Public License
11			* as published by the Free Software Foundation; either version 2
12			* of the License, or (at your option) any later version.
13			*
14			* This program is distributed in the hope that it will be useful,
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			* GNU General Public License for more details.
18			*
19			* You should have received a copy of the GNU General Public License
20			* along with this program; if not, write to the Free Software
21			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22			*/
23
24			#include "common/setup_before.h"
25			#ifdef STDC_HEADERS
26			# include <stdlib.h>
27			#else
28			# ifdef HAVE_MALLOC_H
29			# include <malloc.h>
30			# endif
31			#endif
32			#ifdef HAVE_STRING_H
33			# include <string.h>
34			#else
35			# ifdef HAVE_STRINGS_H
36			# include <strings.h>
37			# endif
38			#endif
39			#ifdef HAVE_POLL_H
40			# include <poll.h>
41			#else
42			# ifdef HAVE_SYS_POLL_H
43			# include <sys/poll.h>
44			# endif
45			#endif
46			#include "fdwatch.h"
47			#include "common/eventlog.h"
48			#include "common/xalloc.h"
49			#include "common/setup_after.h"
50
51			#ifdef HAVE_POLL
52			static int sr;
53			static struct pollfd fds = NULL; / working set */
54			static int *_rridx = NULL;
55			static int *_ridx = NULL;
56			static unsigned nofds;
57
58			static int fdw_poll_init(int nfds);
59			static int fdw_poll_close(void);
60			static int fdw_poll_add_fd(int idx, t_fdwatch_type rw);
61			static int fdw_poll_del_fd(int idx);
62			static int fdw_poll_watch(long timeout_msecs);
63			static void fdw_poll_handle(void);
64
65			t_fdw_backend fdw_poll = {
66			fdw_poll_init,
67			fdw_poll_close,
68			fdw_poll_add_fd,
69			fdw_poll_del_fd,
70			fdw_poll_watch,
71			fdw_poll_handle
72			};
73
74			static int fdw_poll_init(int nfds)
75			{
76			int i;
77
78			_ridx = xmalloc(sizeof(int) * nfds);
79			fds = xmalloc(sizeof(struct pollfd) * nfds);
80			_rridx = xmalloc(sizeof(int) * nfds);
81
82			memset(fds, 0, sizeof(struct pollfd) * nfds);
83			memset(_rridx, 0, sizeof(int) * nfds);
84			/* I would use a memset with 255 but that is dirty and doesnt gain us anything */
85			for(i = 0; i < nfds; i++) _ridx[i] = -1;
86			nofds = sr = 0;
87
88			eventlog(eventlog_level_info, __FUNCTION__, "fdwatch poll() based layer initialized (max %d sockets)", nfds);
89			return 0;
90			}
91
92			static int fdw_poll_close(void)
93			{
94			if (fds) { xfree((void *)fds); fds = NULL; }
95			if (_ridx) { xfree((void *)_ridx); _ridx = NULL; }
96			if (_rridx) { xfree((void *)_rridx); _rridx = NULL; }
97			nofds = sr = 0;
98
99			return 0;
100			}
101
102			static int fdw_poll_add_fd(int idx, t_fdwatch_type rw)
103			{
104			static int ridx;
105
106			// eventlog(eventlog_level_trace, __FUNCTION__, "called fd: %d rw: %d", fd, rw);
107			if (_ridx[idx] < 0) {
108			ridx = nofds++;
109			fds[ridx].fd = fdw_fd(fdw_fds + idx);
110			_ridx[idx] = ridx;
111			_rridx[ridx] = idx;
112			// eventlog(eventlog_level_trace, __FUNCTION__, "adding new fd on %d", ridx);
113			} else {
114			if (fds[_ridx[idx]].fd != fdw_fd(fdw_fds + idx)) {
115			eventlog(eventlog_level_error,__FUNCTION__,"BUG: found existent poll_fd entry for same idx with different fd");
116			return -1;
117			}
118			ridx = _ridx[idx];
119			// eventlog(eventlog_level_trace, __FUNCTION__, "updating fd on %d", ridx);
120			}
121
122			fds[ridx].events = 0;
123			if (rw & fdwatch_type_read) fds[ridx].events \|= POLLIN;
124			if (rw & fdwatch_type_write) fds[ridx].events \|= POLLOUT;
125
126			return 0;
127			}
128
129			static int fdw_poll_del_fd(int idx)
130			{
131			// eventlog(eventlog_level_trace, __FUNCTION__, "called fd: %d", fd);
132			if (_ridx[idx] < 0 \|\| !nofds) return -1;
133			if (sr > 0)
134			eventlog(eventlog_level_error, __FUNCTION__, "BUG: called while still handling sockets");
135
136			/* move the last entry to the deleted one and decrement nofds count */
137			nofds--;
138			if (_ridx[idx] < nofds) {
139			// eventlog(eventlog_level_trace, __FUNCTION__, "not last, moving %d", tfds[nofds].fd);
140			_ridx[_rridx[nofds]] = _ridx[idx];
141			_rridx[_ridx[idx]] = _rridx[nofds];
142			memcpy(fds + _ridx[idx], fds + nofds, sizeof(struct pollfd));
143			}
144			_ridx[idx] = -1;
145
146			return 0;
147			}
148
149			static int fdw_poll_watch(long timeout_msec)
150			{
151			return (sr = poll(fds, nofds, timeout_msec));
152			}
153
154			static void fdw_poll_handle(void)
155			{
156			register unsigned i;
157			int changed;
158			t_fdwatch_fd *cfd;
159
160			for(i = 0; i < nofds && sr; i++) {
161			changed = 0;
162			cfd = fdw_fds + _rridx[i];
163
164			if (fdw_rw(cfd) & fdwatch_type_read &&
165			fds[i].revents & (POLLIN \| POLLERR \| POLLHUP \| POLLNVAL))
166			{
167			if (fdw_hnd(cfd)(fdw_data(cfd), fdwatch_type_read) == -2) {
168			sr--;
169			continue;
170			}
171			changed = 1;
172			}
173
174			if (fdw_rw(cfd) & fdwatch_type_write &&
175			fds[i].revents & (POLLOUT \| POLLERR \| POLLHUP \| POLLNVAL))
176			{
177			fdw_hnd(cfd)(fdw_data(cfd), fdwatch_type_write);
178			changed = 1;
179			}
180
181			if (changed) sr--;
182			}
183			}
184
185			#endif /* HAVE_POLL */
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1