Changes in / [e7f5970:a01ed7c]
- Files:
-
- 13 edited
Legend:
- Unmodified
- Added
- Removed
-
global.c
r23fddad r6fc40a7 112 112 113 113 owl_message_init_fmtext_cache(); 114 owl_list_create(&(g-> dispatchlist));114 owl_list_create(&(g->io_dispatch_list)); 115 115 owl_list_create(&(g->psa_list)); 116 116 g->timerlist = NULL; … … 940 940 } 941 941 942 owl_list *owl_global_get_ dispatchlist(owl_global *g)943 { 944 return &(g-> dispatchlist);942 owl_list *owl_global_get_io_dispatch_list(owl_global *g) 943 { 944 return &(g->io_dispatch_list); 945 945 } 946 946 -
owl.c
r23fddad r18fdd5f9 315 315 } 316 316 317 void owl_process_input( owl_dispatch *d)317 void owl_process_input(const owl_io_dispatch *d, void *data) 318 318 { 319 319 owl_input j; … … 444 444 445 445 /* Sends stderr (read from rfd) messages to the error console */ 446 void stderr_redirect_handler( owl_dispatch *d)446 void stderr_redirect_handler(const owl_io_dispatch *d, void *data) 447 447 { 448 448 int navail, bread; … … 521 521 owl_global_set_haveaim(&g); 522 522 523 /* prepare stdin dispatch */ 524 { 525 owl_dispatch *d = owl_malloc(sizeof(owl_dispatch)); 526 d->fd = STDIN; 527 d->cfunc = &owl_process_input; 528 d->destroy = NULL; 529 owl_select_add_dispatch(d); 530 } 531 523 /* register STDIN dispatch; throw away return, we won't need it */ 524 owl_select_add_io_dispatch(STDIN, OWL_IO_READ, &owl_process_input, NULL, NULL); 532 525 owl_zephyr_initialize(); 533 526 534 527 #if OWL_STDERR_REDIR 535 528 /* Do this only after we've started curses up... */ 536 { 537 owl_dispatch *d = owl_malloc(sizeof(owl_dispatch)); 538 owl_function_debugmsg("startup: doing stderr redirection"); 539 d->fd = stderr_replace(); 540 d->cfunc = stderr_redirect_handler; 541 d->destroy = NULL; 542 owl_select_add_dispatch(d); 543 } 529 owl_function_debugmsg("startup: doing stderr redirection"); 530 owl_select_add_io_dispatch(stderr_replace(), OWL_IO_READ, &stderr_redirect_handler, NULL, NULL); 544 531 #endif 545 532 -
owl.h
r68c572a r6fc40a7 107 107 #define OWL_MESSAGE_DIRECTION_OUT 2 108 108 109 #define OWL_ MUX_READ 1110 #define OWL_ MUX_WRITE 2111 #define OWL_ MUX_EXCEPT 4109 #define OWL_IO_READ 1 110 #define OWL_IO_WRITE 2 111 #define OWL_IO_EXCEPT 4 112 112 113 113 #define OWL_DIRECTION_NONE 0 … … 503 503 } owl_obarray; 504 504 505 typedef struct _owl_dispatch { 506 int fd; /* FD to watch for dispatch. */ 505 typedef struct _owl_io_dispatch { 506 int fd; /* FD to watch for dispatch. */ 507 int mode; 507 508 int needs_gc; 508 void (*c func)(struct _owl_dispatch*);/* C function to dispatch to. */509 void (*destroy)( struct _owl_dispatch*);/* Destructor */509 void (*callback)(const struct _owl_io_dispatch *, void *); /* C function to dispatch to. */ 510 void (*destroy)(const struct _owl_io_dispatch *); /* Destructor */ 510 511 void *data; 511 } owl_ dispatch;512 } owl_io_dispatch; 512 513 513 514 typedef struct _owl_ps_action { … … 523 524 int winactive; 524 525 pid_t pid; /* or 0 if it has terminated */ 525 owl_dispatchdispatch;526 const owl_io_dispatch *dispatch; 526 527 } owl_popexec; 527 528 … … 596 597 struct termios startup_tio; 597 598 owl_obarray obarray; 598 owl_list dispatchlist;599 owl_list io_dispatch_list; 599 600 owl_list psa_list; 600 601 GList *timerlist; -
perl/lib/BarnOwl.pm
r3c428d4 rffc4df6 13 13 error debug 14 14 create_style getnumcolors wordwrap 15 add_dispath remove_dispatch 15 add_dispatch remove_dispatch 16 add_io_dispatch remove_io_dispatch 16 17 new_command 17 18 new_variable_int new_variable_bool new_variable_string … … 62 63 Returns the current message as a C<BarnOwl::Message> subclass, or 63 64 undef if there is no message selected 64 65 65 =head2 getnumcols 66 66 … … 160 160 read from C<FD>. 161 161 162 C<add_dispatch> has been deprecated in favor of C<add_io_dispatch>, 163 and is now a wrapper for it called with C<mode> set to C<'r'>. 164 165 =cut 166 167 sub add_dispatch { 168 my $fd = shift; 169 my $cb = shift; 170 add_io_dispatch($fd, 'r', $cb); 171 } 172 162 173 =head2 remove_dispatch FD 163 174 164 175 Remove a file descriptor previously registered via C<add_dispatch> 176 177 C<remove_dispatch> has been deprecated in favor of 178 C<remove_io_dispatch>. 179 180 =cut 181 182 *remove_dispatch = \&remove_io_dispatch; 183 184 =head2 add_io_dispatch FD MODE CB 185 186 Adds a file descriptor to C<BarnOwl>'s internal C<select()> 187 loop. <MODE> can be 'r', 'w', or 'rw'. C<CALLBACK> will be invoked 188 whenever C<FD> becomes ready, as specified by <MODE>. 189 190 Only one callback can be registered per FD. If a new callback is 191 registered, the old one is removed. 192 193 =cut 194 195 sub add_io_dispatch { 196 my $fd = shift; 197 my $modeStr = shift; 198 my $cb = shift; 199 my $mode = 0; 200 201 $mode |= 0x1 if ($modeStr =~ /r/i); # Read 202 $mode |= 0x2 if ($modeStr =~ /w/i); # Write 203 if ($mode) { 204 $mode |= 0x4; # Exceptional 205 BarnOwl::Internal::add_io_dispatch($fd, $mode, $cb); 206 } else { 207 die("Invalid I/O Dispatch mode: $modeStr"); 208 } 209 } 210 211 =head2 remove_io_dispatch FD 212 213 Remove a file descriptor previously registered via C<add_io_dispatch> 165 214 166 215 =head2 create_style NAME OBJECT -
perl/modules/IRC/lib/BarnOwl/Module/IRC.pm
rda554da rf1a2736 381 381 $ircnets{$alias} = $conn; 382 382 my $fd = $conn->getSocket()->fileno(); 383 BarnOwl::add_ dispatch($fd, \&OwlProcess);383 BarnOwl::add_io_dispatch($fd, 'r', \&OwlProcess); 384 384 $conn->{FD} = $fd; 385 385 } else { -
perl/modules/IRC/lib/BarnOwl/Module/IRC/Connection.pm
r7cfb1df rf1a2736 210 210 } 211 211 } 212 BarnOwl::remove_ dispatch($self->{FD});212 BarnOwl::remove_io_dispatch($self->{FD}); 213 213 BarnOwl::admin_message('IRC', 214 214 "[" . $self->alias . "] Disconnected from server"); -
perl/modules/Jabber/lib/BarnOwl/Module/Jabber.pm
rf3678c3 rf1a2736 471 471 $conn->renameConnection($jidStr, $fullJid); 472 472 queue_admin_msg("Connected to jabber as $fullJid"); 473 # The remove_ dispatch() method is called from the473 # The remove_io_dispatch() method is called from the 474 474 # ConnectionManager's removeConnection() method. 475 475 $client->{fileno} = $client->getSocket()->fileno(); 476 476 #queue_admin_msg("Connected to jabber as $fullJid ($client->{fileno})"); 477 BarnOwl::add_ dispatch($client->{fileno}, sub { $client->OwlProcess($fullJid) });477 BarnOwl::add_io_dispatch($client->{fileno}, 'r', sub { $client->OwlProcess($fullJid) }); 478 478 479 479 # populate completion from roster. -
perl/modules/Jabber/lib/BarnOwl/Module/Jabber/ConnectionManager.pm
r8590774 rf1a2736 37 37 return 0 unless exists $self->{$jidStr}; 38 38 39 BarnOwl::remove_ dispatch($self->{$jidStr}->{Client}->{fileno}) if $self->{$jidStr}->{Client}->{fileno};39 BarnOwl::remove_io_dispatch($self->{$jidStr}->{Client}->{fileno}) if $self->{$jidStr}->{Client}->{fileno}; 40 40 $self->{$jidStr}->{Client}->Disconnect() 41 41 if $self->{$jidStr}->{Client}; … … 55 55 } 56 56 57 BarnOwl::remove_ dispatch($self->{$jidStr}->{Client}->{fileno}) if $self->{$jidStr}->{Client}->{fileno};57 BarnOwl::remove_io_dispatch($self->{$jidStr}->{Client}->{fileno}) if $self->{$jidStr}->{Client}->{fileno}; 58 58 $self->{$jidStr}->{Client}->Disconnect() 59 59 if $self->{$jidStr}->{Client}; -
perlconfig.c
re7f5970 rffc4df6 542 542 } 543 543 544 void owl_perlconfig_ dispatch_free(owl_dispatch *d)544 void owl_perlconfig_io_dispatch_destroy(const owl_io_dispatch *d) 545 545 { 546 546 SvREFCNT_dec(d->data); 547 owl_free(d);548 547 } 549 548 … … 593 592 } 594 593 595 void owl_perlconfig_ dispatch(owl_dispatch *d)596 { 597 SV *cb = d ->data;594 void owl_perlconfig_io_dispatch(const owl_io_dispatch *d, void *data) 595 { 596 SV *cb = data; 598 597 dSP; 599 598 if(cb == NULL) { … … 607 606 PUSHMARK(SP); 608 607 PUTBACK; 609 608 610 609 call_sv(cb, G_DISCARD|G_KEEPERR|G_EVAL); 611 610 -
perlglue.xs
rfe7616e rffc4df6 318 318 319 319 void 320 add_dispatch(fd, cb)320 remove_io_dispatch(fd) 321 321 int fd 322 SV * cb 323 CODE: 324 owl_select_add_perl_dispatch(fd, SvREFCNT_inc(cb)); 325 326 void 327 remove_dispatch(fd) 328 int fd 329 CODE: 330 owl_select_remove_perl_dispatch(fd); 331 322 CODE: 323 owl_select_remove_perl_io_dispatch(fd); 332 324 333 325 AV* … … 504 496 ival); 505 497 498 void 499 add_io_dispatch(fd, mode, cb) 500 int fd 501 int mode 502 SV * cb 503 CODE: 504 owl_select_add_perl_io_dispatch(fd, mode, SvREFCNT_inc(cb)); 505 506 506 IV 507 507 add_timer(after, interval, cb) -
popexec.c
r0e5afa2 r18fdd5f9 53 53 pe->pid=pid; 54 54 pe->winactive=1; 55 pe->dispatch.fd = parent_read_fd; 56 pe->dispatch.cfunc = owl_popexec_inputhandler; 57 pe->dispatch.destroy = owl_popexec_free_dispatch; 58 pe->dispatch.data = pe; 59 owl_select_add_dispatch(&pe->dispatch); 55 pe->dispatch = owl_select_add_io_dispatch(parent_read_fd, OWL_IO_READ|OWL_IO_EXCEPT, &owl_popexec_inputhandler, &owl_popexec_delete_dispatch, pe); 60 56 pe->refcount++; 61 57 } else { … … 78 74 } 79 75 80 void owl_popexec_inputhandler( owl_dispatch *d)76 void owl_popexec_inputhandler(const owl_io_dispatch *d, void *data) 81 77 { 82 owl_popexec *pe = d ->data;78 owl_popexec *pe = data; 83 79 int navail, bread, rv_navail; 84 80 char *buf; … … 99 95 /* the viewwin has closed */ 100 96 if (!pe->pid && !pe->winactive) { 101 owl_select_remove_ dispatch(d->fd);97 owl_select_remove_io_dispatch(d); 102 98 return; 103 99 } … … 116 112 owl_viewwin_redisplay(pe->vwin, 1); 117 113 } 118 owl_select_remove_ dispatch(d->fd);114 owl_select_remove_io_dispatch(d); 119 115 return; 120 116 } … … 146 142 } 147 143 148 void owl_popexec_ free_dispatch(owl_dispatch *d)144 void owl_popexec_delete_dispatch(const owl_io_dispatch *d) 149 145 { 150 146 owl_popexec *pe = d->data; … … 159 155 160 156 pe->winactive = 0; 161 if (pe->dispatch .fd>0) {162 owl_select_remove_ dispatch(pe->dispatch.fd);157 if (pe->dispatch->fd > 0) { 158 owl_select_remove_io_dispatch(pe->dispatch); 163 159 } 164 160 if (pe->pid) { -
select.c
r4f2166b r6fc40a7 81 81 } 82 82 83 /* Returns the index of the dispatch for the file descriptor. */ 84 int owl_select_find_dispatch(int fd) 83 static const owl_io_dispatch *owl_select_find_io_dispatch_by_fd(const int fd) 85 84 { 86 85 int i, len; 87 86 const owl_list *dl; 88 const owl_dispatch *d; 89 90 dl = owl_global_get_dispatchlist(&g); 87 owl_io_dispatch *d; 88 dl = owl_global_get_io_dispatch_list(&g); 91 89 len = owl_list_get_size(dl); 92 90 for(i = 0; i < len; i++) { 93 91 d = owl_list_get_element(dl, i); 94 if (d->fd == fd) return i; 92 if (d->fd == fd) return d; 93 } 94 return NULL; 95 } 96 97 static int owl_select_find_io_dispatch(const owl_io_dispatch *in) 98 { 99 int i, len; 100 const owl_list *dl; 101 102 if (in != NULL) { 103 dl = owl_global_get_io_dispatch_list(&g); 104 len = owl_list_get_size(dl); 105 for(i = 0; i < len; i++) { 106 const owl_io_dispatch *d = owl_list_get_element(dl, i); 107 if (d == in) return i; 108 } 95 109 } 96 110 return -1; 97 111 } 98 112 99 void owl_select_remove_dispatch_at(int elt) /* noproto */ 100 { 101 owl_list *dl; 102 owl_dispatch *d; 103 104 dl = owl_global_get_dispatchlist(&g); 105 d = owl_list_get_element(dl, elt); 106 owl_list_remove_element(dl, elt); 107 if (d->destroy) { 108 d->destroy(d); 109 } 110 } 111 112 /* Adds a new owl_dispatch to the list, replacing existing ones if needed. */ 113 void owl_select_add_dispatch(owl_dispatch *d) 113 void owl_select_remove_io_dispatch(const owl_io_dispatch *in) 114 114 { 115 115 int elt; 116 owl_list *dl; 117 118 d->needs_gc = 0; 119 120 elt = owl_select_find_dispatch(d->fd); 121 dl = owl_global_get_dispatchlist(&g); 122 123 if (elt != -1) { /* If we have a dispatch for this FD */ 124 owl_dispatch *d_old; 125 d_old = owl_list_get_element(dl, elt); 126 /* Ignore if we're adding the same dispatch again. Otherwise 127 replace the old dispatch. */ 128 if (d_old != d) { 129 owl_select_remove_dispatch_at(elt); 130 } 131 } 132 owl_list_append_element(dl, d); 133 } 134 135 /* Removes an owl_dispatch to the list, based on it's file descriptor. */ 136 void owl_select_remove_dispatch(int fd) 137 { 138 int elt; 139 owl_list *dl; 140 owl_dispatch *d; 141 142 elt = owl_select_find_dispatch(fd); 143 if(elt == -1) { 144 return; 145 } else if(dispatch_active) { 146 /* Defer the removal until dispatch is done walking the list */ 147 dl = owl_global_get_dispatchlist(&g); 148 d = owl_list_get_element(dl, elt); 149 d->needs_gc = 1; 150 } else { 151 owl_select_remove_dispatch_at(elt); 152 } 153 } 154 155 int owl_select_dispatch_count(void) 156 { 157 return owl_list_get_size(owl_global_get_dispatchlist(&g)); 158 } 159 160 int owl_select_add_perl_dispatch(int fd, SV *cb) 161 { 162 int elt; 163 owl_dispatch *d; 164 elt = owl_select_find_dispatch(fd); 165 if (elt != -1) { 166 d = owl_list_get_element(owl_global_get_dispatchlist(&g), elt); 167 if (d->cfunc != owl_perlconfig_dispatch) { 168 /* don't mess with non-perl dispatch functions from here. */ 169 return 1; 170 } 171 } 172 173 d = owl_malloc(sizeof(owl_dispatch)); 174 d->fd = fd; 175 d->cfunc = owl_perlconfig_dispatch; 176 d->destroy = owl_perlconfig_dispatch_free; 177 d->data = cb; 178 owl_select_add_dispatch(d); 179 return 0; 180 } 181 182 int owl_select_remove_perl_dispatch(int fd) 183 { 184 int elt; 185 owl_dispatch *d; 186 187 elt = owl_select_find_dispatch(fd); 188 if (elt != -1) { 189 d = owl_list_get_element(owl_global_get_dispatchlist(&g), elt); 190 if (d->cfunc == owl_perlconfig_dispatch) { 191 owl_select_remove_dispatch_at(elt); 192 return 0; 193 } 194 } 195 return 1; 196 } 197 198 int owl_select_dispatch_prepare_fd_sets(fd_set *r, fd_set *e) 199 { 200 int i, len, max_fd; 201 owl_dispatch *d; 202 const owl_list *dl; 203 204 dl = owl_global_get_dispatchlist(&g); 205 FD_ZERO(r); 206 FD_ZERO(e); 207 max_fd = 0; 208 len = owl_select_dispatch_count(); 209 for(i = 0; i < len; i++) { 210 d = owl_list_get_element(dl, i); 211 FD_SET(d->fd, r); 212 FD_SET(d->fd, e); 213 if (max_fd < d->fd) max_fd = d->fd; 214 } 215 return max_fd + 1; 216 } 217 218 void owl_select_gc(void) 116 if (in != NULL) { 117 elt = owl_select_find_io_dispatch(in); 118 if (elt != -1) { 119 owl_list *dl = owl_global_get_io_dispatch_list(&g); 120 owl_io_dispatch *d = owl_list_get_element(dl, elt); 121 if (dispatch_active) 122 d->needs_gc = 1; 123 else { 124 owl_list_remove_element(dl, elt); 125 if (d->destroy) 126 d->destroy(d); 127 owl_free(d); 128 } 129 } 130 } 131 } 132 133 void owl_select_io_dispatch_gc(void) 219 134 { 220 135 int i; 221 136 owl_list *dl; 222 137 223 dl = owl_global_get_ dispatchlist(&g);138 dl = owl_global_get_io_dispatch_list(&g); 224 139 /* 225 140 * Count down so we aren't set off by removing items from the list … … 227 142 */ 228 143 for(i = owl_list_get_size(dl) - 1; i >= 0; i--) { 229 const owl_dispatch *d = owl_list_get_element(dl, i);144 owl_io_dispatch *d = owl_list_get_element(dl, i); 230 145 if(d->needs_gc) { 231 owl_select_remove_dispatch_at(i); 232 } 233 } 234 } 235 236 void owl_select_dispatch(fd_set *fds, int max_fd) 146 owl_select_remove_io_dispatch(d); 147 } 148 } 149 } 150 151 /* Each FD may have at most one dispatcher. 152 * If a new dispatch is added for an FD, the old one is removed. 153 * mode determines what types of events are watched for, and may be any combination of: 154 * OWL_IO_READ, OWL_IO_WRITE, OWL_IO_EXCEPT 155 */ 156 const owl_io_dispatch *owl_select_add_io_dispatch(int fd, int mode, void (*cb)(const owl_io_dispatch *, void *), void (*destroy)(const owl_io_dispatch *), void *data) 157 { 158 owl_io_dispatch *d = owl_malloc(sizeof(owl_io_dispatch)); 159 owl_list *dl = owl_global_get_io_dispatch_list(&g); 160 161 d->fd = fd; 162 d->needs_gc = 0; 163 d->mode = mode; 164 d->callback = cb; 165 d->destroy = destroy; 166 d->data = data; 167 168 owl_select_remove_io_dispatch(owl_select_find_io_dispatch_by_fd(fd)); 169 owl_list_append_element(dl, d); 170 171 return d; 172 } 173 174 int owl_select_prepare_io_dispatch_fd_sets(fd_set *rfds, fd_set *wfds, fd_set *efds) { 175 int i, len, max_fd; 176 owl_io_dispatch *d; 177 owl_list *dl = owl_global_get_io_dispatch_list(&g); 178 179 max_fd = 0; 180 len = owl_list_get_size(dl); 181 for (i = 0; i < len; i++) { 182 d = owl_list_get_element(dl, i); 183 if (d->mode & (OWL_IO_READ | OWL_IO_WRITE | OWL_IO_EXCEPT)) { 184 if (max_fd < d->fd) max_fd = d->fd; 185 if (d->mode & OWL_IO_READ) FD_SET(d->fd, rfds); 186 if (d->mode & OWL_IO_WRITE) FD_SET(d->fd, wfds); 187 if (d->mode & OWL_IO_EXCEPT) FD_SET(d->fd, efds); 188 } 189 } 190 return max_fd + 1; 191 } 192 193 void owl_select_io_dispatch(const fd_set *rfds, const fd_set *wfds, const fd_set *efds, const int max_fd) 237 194 { 238 195 int i, len; 239 owl_dispatch *d; 240 const owl_list *dl; 241 242 dl = owl_global_get_dispatchlist(&g); 243 len = owl_select_dispatch_count(); 196 owl_io_dispatch *d; 197 owl_list *dl = owl_global_get_io_dispatch_list(&g); 244 198 245 199 dispatch_active = 1; 246 247 for (i = 0; i < len; i++) {200 len = owl_list_get_size(dl); 201 for (i = 0; i < len; i++) { 248 202 d = owl_list_get_element(dl, i); 249 /* While d shouldn't normally be null, the list may be altered by 250 * functions we dispatch to. */ 251 if (d != NULL && !d->needs_gc && FD_ISSET(d->fd, fds)) { 252 if (d->cfunc != NULL) { 253 d->cfunc(d); 254 } 255 } 256 } 257 203 if (d->fd < max_fd && d->callback != NULL && 204 ((d->mode & OWL_IO_READ && FD_ISSET(d->fd, rfds)) || 205 (d->mode & OWL_IO_WRITE && FD_ISSET(d->fd, wfds)) || 206 (d->mode & OWL_IO_EXCEPT && FD_ISSET(d->fd, efds)))) { 207 d->callback(d, d->data); 208 } 209 } 258 210 dispatch_active = 0; 259 owl_select_gc(); 211 owl_select_io_dispatch_gc(); 212 } 213 214 int owl_select_add_perl_io_dispatch(int fd, int mode, SV *cb) 215 { 216 const owl_io_dispatch *d = owl_select_find_io_dispatch_by_fd(fd); 217 if (d != NULL && d->callback != owl_perlconfig_io_dispatch) { 218 /* Don't mess with non-perl dispatch functions from here. */ 219 return 1; 220 } 221 owl_select_add_io_dispatch(fd, mode, owl_perlconfig_io_dispatch, owl_perlconfig_io_dispatch_destroy, cb); 222 return 0; 223 } 224 225 int owl_select_remove_perl_io_dispatch(int fd) 226 { 227 const owl_io_dispatch *d = owl_select_find_io_dispatch_by_fd(fd); 228 if (d != NULL && d->callback == owl_perlconfig_io_dispatch) { 229 /* Only remove perl io dispatchers from here. */ 230 owl_select_remove_io_dispatch(d); 231 return 0; 232 } 233 return 1; 260 234 } 261 235 … … 266 240 int max_fd; 267 241 268 FD_ZERO(rfds);269 FD_ZERO(wfds);270 242 max_fd = 0; 271 243 sess = owl_global_get_aimsess(&g); … … 414 386 void owl_select(void) 415 387 { 416 int i, max_fd, aim_max_fd, aim_done, ret;388 int i, max_fd, max_fd2, aim_done, ret; 417 389 fd_set r; 390 fd_set w; 418 391 fd_set e; 419 392 fd_set aim_rfds, aim_wfds; … … 430 403 return; 431 404 } 432 433 max_fd = owl_select_dispatch_prepare_fd_sets(&r, &e); 405 FD_ZERO(&r); 406 FD_ZERO(&w); 407 FD_ZERO(&e); 408 409 max_fd = owl_select_prepare_io_dispatch_fd_sets(&r, &w, &e); 434 410 435 411 /* AIM HACK: … … 448 424 if (owl_global_is_doaimevents(&g)) { 449 425 aim_done = 0; 450 aim_max_fd= owl_select_aim_hack(&aim_rfds, &aim_wfds);451 if (max_fd < aim_max_fd) max_fd = aim_max_fd;452 for(i = 0; i <= aim_max_fd; i++) {426 max_fd2 = owl_select_aim_hack(&aim_rfds, &aim_wfds); 427 if (max_fd < max_fd2) max_fd = max_fd2; 428 for(i = 0; i <= max_fd2; i++) { 453 429 if (FD_ISSET(i, &aim_rfds)) { 454 430 FD_SET(i, &r); 455 431 FD_SET(i, &e); 456 432 } 433 if (FD_ISSET(i, &aim_wfds)) { 434 FD_SET(i, &w); 435 FD_SET(i, &e); 436 } 457 437 } 458 438 } … … 464 444 } 465 445 466 ret = pselect(max_fd+1, &r, & aim_wfds, &e, &timeout, &mask);446 ret = pselect(max_fd+1, &r, &w, &e, &timeout, &mask); 467 447 468 448 if(ret < 0 && errno == EINTR) { … … 482 462 /* Merge all interesting FDs into one set, since we have a 483 463 single dispatch per FD. */ 484 if (FD_ISSET(i, &r) || FD_ISSET(i, & aim_wfds) || FD_ISSET(i, &e)) {464 if (FD_ISSET(i, &r) || FD_ISSET(i, &w) || FD_ISSET(i, &e)) { 485 465 /* AIM HACK: no separate dispatch, just process here if 486 466 needed, and only once per run through. */ … … 496 476 /* NOTE: the same dispatch function is called for both exceptional 497 477 and read ready FDs. */ 498 owl_select_ dispatch(&r, max_fd);499 } 500 } 478 owl_select_io_dispatch(&r, &w, &e, max_fd); 479 } 480 } -
zephyr.c
r12e291a r18fdd5f9 36 36 ZNotice_t req; 37 37 Code_t code; 38 owl_dispatch *dispatch;39 38 40 39 /* … … 80 79 } 81 80 82 dispatch = owl_malloc(sizeof(*dispatch)); 83 dispatch->fd = ZGetFD(); 84 dispatch->cfunc = owl_zephyr_finish_initialization; 85 dispatch->destroy = (void(*)(owl_dispatch*))owl_free; 86 87 owl_select_add_dispatch(dispatch); 88 } 89 90 void owl_zephyr_finish_initialization(owl_dispatch *d) { 81 owl_select_add_io_dispatch(ZGetFD(), OWL_IO_READ|OWL_IO_EXCEPT, &owl_zephyr_finish_initialization, NULL, NULL); 82 } 83 84 void owl_zephyr_finish_initialization(const owl_io_dispatch *d, void *data) { 91 85 Code_t code; 92 86 char *perl; 93 87 94 owl_select_remove_ dispatch(d->fd);88 owl_select_remove_io_dispatch(d); 95 89 96 90 ZClosePort(); … … 106 100 } 107 101 108 d = owl_malloc(sizeof(owl_dispatch)); 109 d->fd = ZGetFD(); 110 d->cfunc = &owl_zephyr_process_events; 111 d->destroy = NULL; 112 owl_select_add_dispatch(d); 102 owl_select_add_io_dispatch(ZGetFD(), OWL_IO_READ|OWL_IO_EXCEPT, &owl_zephyr_process_events, NULL, NULL); 103 113 104 owl_global_set_havezephyr(&g); 114 105 … … 1350 1341 } 1351 1342 1352 void owl_zephyr_process_events( owl_dispatch *d)1343 void owl_zephyr_process_events(const owl_io_dispatch *d, void *data) 1353 1344 { 1354 1345 _owl_zephyr_process_events();
Note: See TracChangeset
for help on using the changeset viewer.