← Back to branch summary

~ubuntu-branches/ubuntu/natty/lighttpd/natty

« back to all changes in this revision

Viewing changes to src/fdevent_poll.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2006-12-08 14:40:42 UTC
  • mto: (6.1.1 lenny)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20061208144042-ehr7h8c6xmijqipw
Tags: upstream-1.4.13
Import upstream version 1.4.13

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/fdevent_poll.c
20
20
 
21
21
static int fdevent_poll_event_del(fdevents *ev, int fde_ndx, int fd) {
22
22
        if (fde_ndx < 0) return -1;
23
 
        
 
23
 
24
24
        if ((size_t)fde_ndx >= ev->used) {
25
25
                fprintf(stderr, "%s.%d: del! out of range %d %zd\n", __FILE__, __LINE__, fde_ndx, ev->used);
26
26
                SEGFAULT();
27
27
        }
28
 
        
 
28
 
29
29
        if (ev->pollfds[fde_ndx].fd == fd) {
30
30
                size_t k = fde_ndx;
31
 
                
 
31
 
32
32
                ev->pollfds[k].fd = -1;
33
33
                /* ev->pollfds[k].events = 0; */
34
34
                /* ev->pollfds[k].revents = 0; */
35
 
                
 
35
 
36
36
                if (ev->unused.size == 0) {
37
37
                        ev->unused.size = 16;
38
38
                        ev->unused.ptr = malloc(sizeof(*(ev->unused.ptr)) * ev->unused.size);
40
40
                        ev->unused.size += 16;
41
41
                        ev->unused.ptr = realloc(ev->unused.ptr, sizeof(*(ev->unused.ptr)) * ev->unused.size);
42
42
                }
43
 
                
 
43
 
44
44
                ev->unused.ptr[ev->unused.used++] = k;
45
45
        } else {
46
46
                SEGFAULT();
47
47
        }
48
 
        
 
48
 
49
49
        return -1;
50
50
}
51
51
 
52
52
#if 0
53
53
static int fdevent_poll_event_compress(fdevents *ev) {
54
54
        size_t j;
55
 
        
 
55
 
56
56
        if (ev->used == 0) return 0;
57
57
        if (ev->unused.used != 0) return 0;
58
 
        
 
58
 
59
59
        for (j = ev->used - 1; j + 1 > 0 && ev->pollfds[j].fd == -1; j--) ev->used--;
60
 
        
 
60
 
61
61
        return 0;
62
62
}
63
63
#endif
64
64
 
65
65
static int fdevent_poll_event_add(fdevents *ev, int fde_ndx, int fd, int events) {
66
66
        /* known index */
67
 
        
 
67
 
68
68
        if (fde_ndx != -1) {
69
69
                if (ev->pollfds[fde_ndx].fd == fd) {
70
70
                        ev->pollfds[fde_ndx].events = events;
71
 
                        
 
71
 
72
72
                        return fde_ndx;
73
73
                }
74
74
                fprintf(stderr, "%s.%d: add: (%d, %d)\n", __FILE__, __LINE__, fde_ndx, ev->pollfds[fde_ndx].fd);
75
75
                SEGFAULT();
76
76
        }
77
 
        
 
77
 
78
78
        if (ev->unused.used > 0) {
79
79
                int k = ev->unused.ptr[--ev->unused.used];
80
 
                
 
80
 
81
81
                ev->pollfds[k].fd = fd;
82
82
                ev->pollfds[k].events = events;
83
 
                
 
83
 
84
84
                return k;
85
85
        } else {
86
86
                if (ev->size == 0) {
90
90
                        ev->size += 16;
91
91
                        ev->pollfds = realloc(ev->pollfds, sizeof(*ev->pollfds) * ev->size);
92
92
                }
93
 
                
 
93
 
94
94
                ev->pollfds[ev->used].fd = fd;
95
95
                ev->pollfds[ev->used].events = events;
96
 
                
 
96
 
97
97
                return ev->used++;
98
98
        }
99
99
}
109
109
        int r, poll_r;
110
110
        if (ndx >= ev->used) {
111
111
                fprintf(stderr, "%s.%d: dying because: event: %zd >= %zd\n", __FILE__, __LINE__, ndx, ev->used);
112
 
                
 
112
 
113
113
                SEGFAULT();
114
 
                
 
114
 
115
115
                return 0;
116
116
        }
117
 
        
 
117
 
118
118
        if (ev->pollfds[ndx].revents & POLLNVAL) {
119
119
                /* should never happen */
120
120
                SEGFAULT();
131
131
        if (poll_r & POLLHUP) r |= FDEVENT_HUP;
132
132
        if (poll_r & POLLNVAL) r |= FDEVENT_NVAL;
133
133
        if (poll_r & POLLPRI) r |= FDEVENT_PRI;
134
 
        
 
134
 
135
135
        return ev->pollfds[ndx].revents;
136
136
}
137
137
 
141
141
 
142
142
static int fdevent_poll_event_next_fdndx(fdevents *ev, int ndx) {
143
143
        size_t i;
144
 
        
 
144
 
145
145
        i = (ndx < 0) ? 0 : ndx + 1;
146
146
        for (; i < ev->used; i++) {
147
147
                if (ev->pollfds[i].revents) break;
148
148
        }
149
 
        
 
149
 
150
150
        return i;
151
151
}
152
152
 
154
154
        ev->type = FDEVENT_HANDLER_POLL;
155
155
#define SET(x) \
156
156
        ev->x = fdevent_poll_##x;
157
 
        
 
157
 
158
158
        SET(free);
159
159
        SET(poll);
160
 
        
 
160
 
161
161
        SET(event_del);
162
162
        SET(event_add);
163
 
        
 
163
 
164
164
        SET(event_next_fdndx);
165
165
        SET(event_get_fd);
166
166
        SET(event_get_revent);
167
 
        
 
167
 
168
168
        return 0;
169
169
}
170
170