| 1 | package Asyncore; | ||
| 2 | { | ||
| 3 | $Asyncore::VERSION = '0.08'; | ||
| 4 | } | ||
| 5 | |||
| 6 | #============================================================================== | ||
| 7 | # | ||
| 8 | # FILE: Asyncore.pm | ||
| 9 | # | ||
| 10 | # DESCRIPTION: porting in Perl of asyncore.py (python 2.7) | ||
| 11 | # | ||
| 12 | # FILES: --- | ||
| 13 | # BUGS: --- | ||
| 14 | # NOTES: --- | ||
| 15 | # AUTHOR: (Sebastiano Piccoli), <sebastiano.piccoli@gmail.com> | ||
| 16 | # COMPANY: | ||
| 17 | # VERSION: 0.08 | ||
| 18 | # CREATED: 26/06/12 20:27:28 CEST | ||
| 19 | # REVISION: --- | ||
| 20 | #============================================================================== | ||
| 21 | |||
| 22 | use strict; | ||
| 23 | use warnings; | ||
| 24 | |||
| 25 | use IO::Select; | ||
| 26 | use Socket; | ||
| 27 | use Carp; | ||
| 28 | |||
| 29 | our $socket_map; | ||
| 30 | |||
| 31 | if (not $socket_map) { | ||
| 32 | $socket_map = {} | ||
| 33 | } | ||
| 34 | |||
| 35 | sub _read { | ||
| 36 | my $obj = shift; | ||
| 37 | |||
| 38 | eval { | ||
| 39 | $obj->handle_read_event(); | ||
| 40 | }; | ||
| 41 | if ($@) { | ||
| 42 | $obj->handle_error($@); | ||
| 43 | } | ||
| 44 | } | ||
| 45 | |||
| 46 | sub _write { | ||
| 47 | my $obj = shift; | ||
| 48 | |||
| 49 | eval { | ||
| 50 | $obj->handle_write_event(); | ||
| 51 | }; | ||
| 52 | if ($@) { | ||
| 53 | $obj->handle_error($@); | ||
| 54 | } | ||
| 55 | } | ||
| 56 | |||
| 57 | sub _exception { | ||
| 58 | my $obj = shift; | ||
| 59 | |||
| 60 | eval { | ||
| 61 | $obj->handle_expt_event(); | ||
| 62 | }; | ||
| 63 | if ($@) { | ||
| 64 | $obj->handle_error($@); | ||
| 65 | } | ||
| 66 | } | ||
| 67 | |||
| 68 | sub poll { | ||
| 69 | my($timeout, $map) = @_; | ||
| 70 | |||
| 71 | if (not $map) { | ||
| 72 | $map = $socket_map; | ||
| 73 | } | ||
| 74 | |||
| 75 | if ($map) { | ||
| 76 | my $r = new IO::Select; | ||
| 77 | my $w = new IO::Select; | ||
| 78 | my $e = new IO::Select; | ||
| 79 | foreach my $fd (keys %{ $map }) { | ||
| 80 | my $obj = $map->{$fd}; | ||
| 81 | my $is_r = $obj->readable(); | ||
| 82 | my $is_w = $obj->writable(); | ||
| 83 | |||
| 84 | if ($is_r) { | ||
| 85 | $r->add($obj->{_socket}); | ||
| 86 | } | ||
| 87 | if ($is_w and not $obj->{_accepting}) { | ||
| 88 | $w->add($obj->{_socket}); | ||
| 89 | |||
| 90 | } | ||
| 91 | if ($is_r or $is_w) { | ||
| 92 | $e->add($obj->{_socket}); | ||
| 93 | } | ||
| 94 | } | ||
| 95 | if (not @$r and not @$w and not @$e) { | ||
| 96 | sleep($timeout); | ||
| 97 | return | ||
| 98 | } | ||
| 99 | |||
| 100 | my($rr, $rw, $he); | ||
| 101 | eval { | ||
| 102 | # rr, wr: ready for reading/writing. he: has exception | ||
| 103 | ($rr, $rw, $he) = IO::Select->select($r, $w, $e, $timeout); | ||
| 104 | }; | ||
| 105 | if ($@) { | ||
| 106 | croak "$@"; | ||
| 107 | } | ||
| 108 | |||
| 109 | foreach my $fd (@$rr) { | ||
| 110 | next if !defined(fileno($fd)); | ||
| 111 | my $obj = $map->{fileno($fd)}; | ||
| 112 | if (not $obj) { | ||
| 113 | next; | ||
| 114 | } | ||
| 115 | _read($obj); | ||
| 116 | } | ||
| 117 | |||
| 118 | foreach my $fd (@$rw) { | ||
| 119 | next if !defined(fileno($fd)); | ||
| 120 | my $obj = $map->{fileno($fd)}; | ||
| 121 | if (not $obj) { | ||
| 122 | next; | ||
| 123 | } | ||
| 124 | _write($obj); | ||
| 125 | } | ||
| 126 | |||
| 127 | foreach my $fd (@$he) { | ||
| 128 | my $obj = $map->{$fd->fileno()}; | ||
| 129 | if (not $obj) { | ||
| 130 | next; | ||
| 131 | } | ||
| 132 | _exception($obj); | ||
| 133 | } | ||
| 134 | } | ||
| 135 | } | ||
| 136 | |||
| 137 | sub loop { | ||
| 138 | my($timeout, $use_poll, $map, $count) = @_; | ||
| 139 | |||
| 140 | if (not $timeout) { | ||
| 141 | $timeout = 30; | ||
| 142 | } | ||
| 143 | |||
| 144 | if (not $map) { | ||
| 145 | $map = $socket_map; | ||
| 146 | } | ||
| 147 | |||
| 148 | #if ($use_poll and hasattr(select, 'poll') { | ||
| 149 | #$poll_fun = $poll2 | ||
| 150 | #} | ||
| 151 | #else { | ||
| 152 | #$poll_fun = $poll | ||
| 153 | #} | ||
| 154 | |||
| 155 | if (not $count) { | ||
| 156 | while ($map) { | ||
| 157 | #$poll_fun($timeout, $map) | ||
| 158 | poll($timeout, $map) | ||
| 159 | } | ||
| 160 | } | ||
| 161 | else { | ||
| 162 | while (($map) and ($count > 0)) { | ||
| 163 | #$poll_fun($timeout, $map); | ||
| 164 | $count--; | ||
| 165 | } | ||
| 166 | } | ||
| 167 | } | ||
| 168 | |||
| 169 | |||
| 170 | |||
| 171 | package Asyncore::Dispatcher; | ||
| 172 | { | ||
| 173 | $Asyncore::Dispatcher::VERSION = '0.08'; | ||
| 174 | } | ||
| 175 | |||
| 176 | #============================================================================== | ||
| 177 | # | ||
| 178 | # FILE: Asyncore.pm | ||
| 179 | # PACKAGE: Asyncore::Dispatcher | ||
| 180 | # | ||
| 181 | # DESCRIPTION: | ||
| 182 | # | ||
| 183 | # FILES: --- | ||
| 184 | # BUGS: --- | ||
| 185 | # NOTES: --- | ||
| 186 | # AUTHOR: (Sebastiano Piccoli), <sebastiano.piccoli@gmail.com> | ||
| 187 | # COMPANY: | ||
| 188 | # VERSION: 0.8 | ||
| 189 | # CREATED: 26/06/12 20:27:28 CEST | ||
| 190 | # REVISION: --- | ||
| 191 | #============================================================================== | ||
| 192 | |||
| 193 | use strict; | ||
| 194 | use warnings; | ||
| 195 | |||
| 196 | use Socket; | ||
| 197 | use Fcntl; | ||
| 198 | use Carp; | ||
| 199 | use Errno; | ||
| 200 | |||
| 201 | sub new { | ||
| 202 | my $class = shift; | ||
| 203 | my $self = {}; | ||
| 204 | bless $self, $class; | ||
| 205 | return $self->init(@_); | ||
| 206 | } | ||
| 207 | |||
| 208 | sub init { | ||
| 209 | my($self, $sock, $map) = @_; | ||
| 210 | |||
| 211 | if (not $map) { | ||
| 212 | $self->{_map} = $socket_map; | ||
| 213 | } | ||
| 214 | else { | ||
| 215 | $self->{_map} = $map; | ||
| 216 | } | ||
| 217 | |||
| 218 | $self->{_fileno} = 0; | ||
| 219 | |||
| 220 | if ($sock) { | ||
| 221 | # Set to nonblocking just to make sure for cases where we | ||
| 222 | # get a socket from a blocking source | ||
| 223 | fcntl($sock, F_SETFL, O_NONBLOCK); | ||
| 224 | $self->set_socket($sock, $map); | ||
| 225 | $self->{_connected} = 1; | ||
| 226 | |||
| 227 | if (not getpeername($sock)) { | ||
| 228 | if ($!{ENOTCONN} || $!{EINVAL}) { | ||
| 229 | # Handle the case where we got an unconnected socket | ||
| 230 | $self->{_connected} = 0; | ||
| 231 | } | ||
| 232 | else { | ||
| 233 | # Handle the case where the socket is broken in some unknown | ||
| 234 | # way, alert the user and remove it from the map (to prevent | ||
| 235 | # polling of broken sockets) | ||
| 236 | $self->del_channel($map); | ||
| 237 | |||
| 238 | } | ||
| 239 | } | ||
| 240 | } | ||
| 241 | else { | ||
| 242 | $self->{_socket} = 0; | ||
| 243 | } | ||
| 244 | |||
| 245 | return $self; | ||
| 246 | } | ||
| 247 | |||
| 248 | sub add_channel { | ||
| 249 | my($self, $map) = @_; | ||
| 250 | |||
| 251 | if (not $map) { | ||
| 252 | $map = $self->{_map} | ||
| 253 | } | ||
| 254 | |||
| 255 | $map->{$self->{_fileno}} = $self; | ||
| 256 | } | ||
| 257 | |||
| 258 | sub del_channel { | ||
| 259 | my($self, $map) = @_; | ||
| 260 | |||
| 261 | if (not $map) { | ||
| 262 | $map = $self->{_map} | ||
| 263 | } | ||
| 264 | |||
| 265 | my $fd = $self->{_fileno}; | ||
| 266 | foreach my $mfd (keys %{ $map }) { | ||
| 267 | if ($mfd == $fd) { | ||
| 268 | delete $map->{$mfd}; | ||
| 269 | } | ||
| 270 | } | ||
| 271 | |||
| 272 | $self->{_fileno} = undef; | ||
| 273 | } | ||
| 274 | |||
| 275 | sub create_socket { | ||
| 276 | my($self, $family, $type) = @_; | ||
| 277 | |||
| 278 | if (not $family) { | ||
| 279 | $family = AF_INET; | ||
| 280 | } | ||
| 281 | if (not $type) { | ||
| 282 | $type = SOCK_STREAM; # tcp | ||
| 283 | } | ||
| 284 | # SOCK_DGRAM (udp), SOCK_RAW (icmp) | ||
| 285 | |||
| 286 | my $sock; | ||
| 287 | my $proto = getprotobyname("tcp"); # fixme | ||
| 288 | socket($sock, AF_INET, SOCK_STREAM, $proto) || croak "$!"; | ||
| 289 | fcntl($sock, F_SETFL, O_NONBLOCK); | ||
| 290 | |||
| 291 | $self->set_socket($sock); | ||
| 292 | } | ||
| 293 | |||
| 294 | sub set_socket { | ||
| 295 | my($self, $sock, $map) = @_; | ||
| 296 | |||
| 297 | $self->{_socket} = $sock; | ||
| 298 | $self->{_fileno} = fileno($sock); | ||
| 299 | $self->add_channel($map); | ||
| 300 | } | ||
| 301 | |||
| 302 | sub readable { | ||
| 303 | my $self = shift; | ||
| 304 | |||
| 305 | return 1; | ||
| 306 | } | ||
| 307 | |||
| 308 | sub writable { | ||
| 309 | my $self = shift; | ||
| 310 | |||
| 311 | return 1; | ||
| 312 | } | ||
| 313 | |||
| 314 | sub bind { | ||
| 315 | my($self, $port) = @_; | ||
| 316 | |||
| 317 | my $sock = $self->{_socket}; | ||
| 318 | my $iaddr = gethostbyname('localhost'); | ||
| 319 | bind($sock, sockaddr_in($port, $iaddr)); | ||
| 320 | } | ||
| 321 | |||
| 322 | sub listen { | ||
| 323 | my($self, $num) = @_; | ||
| 324 | |||
| 325 | $self->{_accepting} = 1; | ||
| 326 | |||
| 327 | my $sock = $self->{_socket}; | ||
| 328 | listen($sock, $num); | ||
| 329 | } | ||
| 330 | |||
| 331 | sub connect { | ||
| 332 | my($self, $addr, $port) = @_; | ||
| 333 | |||
| 334 | $self->{_connected} = 0; | ||
| 335 | $self->{_connecting} = 1; | ||
| 336 | |||
| 337 | my $sock = $self->{_socket}; | ||
| 338 | my $iaddr = inet_aton($addr); | ||
| 339 | my $paddr = sockaddr_in($port, $iaddr); | ||
| 340 | # In the case of a non-blocking socket connection cannot be completed | ||
| 341 | # immediately. connect is a form of write so select() or poll() can be | ||
| 342 | # used to determine when it's possible to write. | ||
| 343 | unless (connect($sock, $paddr)) { | ||
| 344 | if ($!{EINPROGRESS}) { | ||
| 345 | return; | ||
| 346 | } | ||
| 347 | } | ||
| 348 | |||
| 349 | $self->{_addr} = $addr; | ||
| 350 | $self->{_port} = $port; | ||
| 351 | $self->handle_connect_event(); | ||
| 352 | } | ||
| 353 | |||
| 354 | sub accept { | ||
| 355 | my $self = shift; | ||
| 356 | |||
| 357 | my $conn; | ||
| 358 | my $sock = $self->{_socket}; | ||
| 359 | |||
| 360 | if (not accept($conn, $sock)) { | ||
| 361 | if ($!{EWOULDBLOCK} || $!{ECONNABORTED} || $!{EAGAIN}) { | ||
| 362 | # Handle the case where we cannot accept connection | ||
| 363 | return; | ||
| 364 | } | ||
| 365 | else { | ||
| 366 | carp 'Unknown error in accept()'; | ||
| 367 | } | ||
| 368 | } | ||
| 369 | |||
| 370 | return $conn; | ||
| 371 | } | ||
| 372 | |||
| 373 | sub send { | ||
| 374 | my($self, $data) = @_; | ||
| 375 | |||
| 376 | my $sock = $self->{_socket}; | ||
| 377 | |||
| 378 | my $result; | ||
| 379 | eval { | ||
| 380 | send($sock, $data, 0); | ||
| 381 | }; | ||
| 382 | if ($@) { | ||
| 383 | croak "$@"; | ||
| 384 | } | ||
| 385 | |||
| 386 | return $result; | ||
| 387 | } | ||
| 388 | |||
| 389 | sub receive { | ||
| 390 | my($self, $buffer_size) = @_; | ||
| 391 | |||
| 392 | my $data; | ||
| 393 | my $sock = $self->{_socket}; | ||
| 394 | recv($sock, $data, $buffer_size, 0); | ||
| 395 | |||
| 396 | if (not $data) { | ||
| 397 | $self->handle_close(); | ||
| 398 | return ''; | ||
| 399 | } | ||
| 400 | else { | ||
| 401 | return $data; | ||
| 402 | } | ||
| 403 | |||
| 404 | # check error todo | ||
| 405 | } | ||
| 406 | |||
| 407 | sub close { | ||
| 408 | my $self = shift; | ||
| 409 | |||
| 410 | $self->{_connected} = 0; | ||
| 411 | $self->{_accepting} = 0; | ||
| 412 | $self->{_connecting} = 0; | ||
| 413 | |||
| 414 | my $sock = $self->{_socket}; | ||
| 415 | close($sock); | ||
| 416 | } | ||
| 417 | |||
| 418 | sub handle_close { | ||
| 419 | my $self = shift; | ||
| 420 | |||
| 421 | $self->close(); | ||
| 422 | } | ||
| 423 | |||
| 424 | sub handle_read_event { | ||
| 425 | my $self = shift; | ||
| 426 | |||
| 427 | if ($self->{_accepting}) { | ||
| 428 | $self->handle_accept(); | ||
| 429 | } | ||
| 430 | elsif (not $self->{_connected}) { | ||
| 431 | if ($self->{_connecting}) { | ||
| 432 | $self->handle_connect_event(); | ||
| 433 | } | ||
| 434 | $self->handle_read(); | ||
| 435 | } | ||
| 436 | else { | ||
| 437 | $self->handle_read(); | ||
| 438 | } | ||
| 439 | } | ||
| 440 | |||
| 441 | sub handle_connect_event { | ||
| 442 | my $self = shift; | ||
| 443 | |||
| 444 | # some preliminary check todo | ||
| 445 | |||
| 446 | $self->handle_connect(); | ||
| 447 | $self->{_connected} = 1; | ||
| 448 | $self->{_connecting} = 0; | ||
| 449 | } | ||
| 450 | |||
| 451 | sub handle_write_event { | ||
| 452 | my $self = shift; | ||
| 453 | |||
| 454 | if ($self->{_accepting}) { | ||
| 455 | return; | ||
| 456 | } | ||
| 457 | |||
| 458 | if (not $self->{_connected}) { | ||
| 459 | if ($self->{_connecting}) { | ||
| 460 | $self->handle_connect_event(); | ||
| 461 | } | ||
| 462 | } | ||
| 463 | $self->handle_write(); | ||
| 464 | } | ||
| 465 | |||
| 466 | sub handle_expt_event { | ||
| 467 | my $self = shift; | ||
| 468 | |||
| 469 | my $err = $self->{_socket}->getsockopt(); | ||
| 470 | if ($err != 0) { | ||
| 471 | $self->handle_close(); | ||
| 472 | } | ||
| 473 | else { | ||
| 474 | $self->handle_expt(); | ||
| 475 | } | ||
| 476 | } | ||
| 477 | |||
| 478 | sub handle_error { | ||
| 479 | my($self, $error) = @_; | ||
| 480 | |||
| 481 | warn $error; | ||
| 482 | |||
| 483 | $self->handle_close(); | ||
| 484 | } | ||
| 485 | |||
| 486 | sub handle_expt { | ||
| 487 | # overrided | ||
| 488 | } | ||
| 489 | |||
| 490 | sub handle_read { | ||
| 491 | # overrided | ||
| 492 | } | ||
| 493 | |||
| 494 | sub handle_write { | ||
| 495 | # overrided | ||
| 496 | } | ||
| 497 | |||
| 498 | sub handle_connect { | ||
| 499 | # overrided | ||
| 500 | } | ||
| 501 | |||
| 502 | sub handle_accept { | ||
| 503 | # overrided | ||
| 504 | } | ||
| 505 | |||
| 506 | |||
| 507 | 1; | ||
| 508 | |||
| 509 | __END__ |