Left: | ||
Right: |
OLD | NEW |
---|---|
1 // Copyright 2009 The Go Authors. All rights reserved. | 1 // Copyright 2009 The Go Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style | 2 // Use of this source code is governed by a BSD-style |
3 // license that can be found in the LICENSE file. | 3 // license that can be found in the LICENSE file. |
4 | 4 |
5 // +build darwin freebsd linux netbsd openbsd | 5 // +build darwin freebsd linux netbsd openbsd |
6 | 6 |
7 package net | 7 package net |
8 | 8 |
9 import ( | 9 import ( |
10 "io" | 10 "io" |
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
174 if mode == 'r' { | 174 if mode == 'r' { |
175 t = fd.rdeadline | 175 t = fd.rdeadline |
176 } else { | 176 } else { |
177 t = fd.wdeadline | 177 t = fd.wdeadline |
178 } | 178 } |
179 if t > 0 { | 179 if t > 0 { |
180 if t <= now { | 180 if t <= now { |
181 delete(s.pending, key) | 181 delete(s.pending, key) |
182 if mode == 'r' { | 182 if mode == 'r' { |
183 s.poll.DelFD(fd.sysfd, mode) | 183 s.poll.DelFD(fd.sysfd, mode) |
184 fd.rdeadline = -1 | |
185 } else { | 184 } else { |
186 s.poll.DelFD(fd.sysfd, mode) | 185 s.poll.DelFD(fd.sysfd, mode) |
187 fd.wdeadline = -1 | |
188 } | 186 } |
189 » » » » s.WakeFD(fd, mode, nil) | 187 » » » » s.WakeFD(fd, mode, errTimeout) |
190 } else if nextDeadline == 0 || t < nextDeadline { | 188 } else if nextDeadline == 0 || t < nextDeadline { |
191 nextDeadline = t | 189 nextDeadline = t |
192 } | 190 } |
193 } | 191 } |
194 } | 192 } |
195 s.deadline = nextDeadline | 193 s.deadline = nextDeadline |
196 } | 194 } |
197 | 195 |
198 func (s *pollServer) Run() { | 196 func (s *pollServer) Run() { |
199 var scratch [100]byte | 197 var scratch [100]byte |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
322 ls = fd.laddr.String() | 320 ls = fd.laddr.String() |
323 } | 321 } |
324 if fd.raddr != nil { | 322 if fd.raddr != nil { |
325 rs = fd.raddr.String() | 323 rs = fd.raddr.String() |
326 } | 324 } |
327 return fd.net + ":" + ls + "->" + rs | 325 return fd.net + ":" + ls + "->" + rs |
328 } | 326 } |
329 | 327 |
330 func (fd *netFD) connect(ra syscall.Sockaddr) error { | 328 func (fd *netFD) connect(ra syscall.Sockaddr) error { |
331 err := syscall.Connect(fd.sysfd, ra) | 329 err := syscall.Connect(fd.sysfd, ra) |
332 hadTimeout := fd.wdeadline > 0 | |
333 if err == syscall.EINPROGRESS { | 330 if err == syscall.EINPROGRESS { |
334 if err = fd.pollServer.WaitWrite(fd); err != nil { | 331 if err = fd.pollServer.WaitWrite(fd); err != nil { |
335 return err | 332 return err |
336 } | 333 } |
337 if hadTimeout && fd.wdeadline < 0 { | |
338 return errTimeout | |
339 } | |
340 var e int | 334 var e int |
341 e, err = syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, sys call.SO_ERROR) | 335 e, err = syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, sys call.SO_ERROR) |
342 if err != nil { | 336 if err != nil { |
343 return os.NewSyscallError("getsockopt", err) | 337 return os.NewSyscallError("getsockopt", err) |
344 } | 338 } |
345 if e != 0 { | 339 if e != 0 { |
346 err = syscall.Errno(e) | 340 err = syscall.Errno(e) |
347 } | 341 } |
348 } | 342 } |
349 return err | 343 return err |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
423 } | 417 } |
424 defer fd.decref() | 418 defer fd.decref() |
425 for { | 419 for { |
426 if fd.rdeadline > 0 { | 420 if fd.rdeadline > 0 { |
427 if time.Now().UnixNano() >= fd.rdeadline { | 421 if time.Now().UnixNano() >= fd.rdeadline { |
428 err = errTimeout | 422 err = errTimeout |
429 break | 423 break |
430 } | 424 } |
431 } | 425 } |
432 n, err = syscall.Read(int(fd.sysfd), p) | 426 n, err = syscall.Read(int(fd.sysfd), p) |
433 » » if err == syscall.EAGAIN { | 427 » » if err != nil { |
434 n = 0 | 428 n = 0 |
435 » » » err = errTimeout | 429 » » » if err == syscall.EAGAIN { |
436 » » » if fd.rdeadline >= 0 { | |
437 if err = fd.pollServer.WaitRead(fd); err == nil { | 430 if err = fd.pollServer.WaitRead(fd); err == nil { |
438 continue | 431 continue |
439 } | 432 } |
440 } | 433 } |
441 } | 434 } |
442 » » if err != nil { | 435 » » if n == 0 && err == nil && fd.sotype == syscall.SOCK_STREAM { |
rsc
2012/11/27 15:26:58
Please change this back to != SOCK_DGRAM.
This is
dfc
2012/11/27 21:35:16
Done.
| |
443 » » » n = 0 | |
444 » » } else if n == 0 && err == nil && fd.sotype != syscall.SOCK_DGRA M { | |
445 err = io.EOF | 436 err = io.EOF |
446 } | 437 } |
447 break | 438 break |
448 } | 439 } |
449 if err != nil && err != io.EOF { | 440 if err != nil && err != io.EOF { |
450 err = &OpError{"read", fd.net, fd.raddr, err} | 441 err = &OpError{"read", fd.net, fd.raddr, err} |
451 } | 442 } |
452 return | 443 return |
453 } | 444 } |
454 | 445 |
455 func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err error) { | 446 func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err error) { |
456 fd.rio.Lock() | 447 fd.rio.Lock() |
457 defer fd.rio.Unlock() | 448 defer fd.rio.Unlock() |
458 if err := fd.incref(false); err != nil { | 449 if err := fd.incref(false); err != nil { |
459 return 0, nil, err | 450 return 0, nil, err |
460 } | 451 } |
461 defer fd.decref() | 452 defer fd.decref() |
462 for { | 453 for { |
463 if fd.rdeadline > 0 { | 454 if fd.rdeadline > 0 { |
464 if time.Now().UnixNano() >= fd.rdeadline { | 455 if time.Now().UnixNano() >= fd.rdeadline { |
465 err = errTimeout | 456 err = errTimeout |
466 break | 457 break |
467 } | 458 } |
468 } | 459 } |
469 n, sa, err = syscall.Recvfrom(fd.sysfd, p, 0) | 460 n, sa, err = syscall.Recvfrom(fd.sysfd, p, 0) |
470 » » if err == syscall.EAGAIN { | 461 » » if err != nil { |
471 n = 0 | 462 n = 0 |
472 » » » err = errTimeout | 463 » » » if err == syscall.EAGAIN { |
473 » » » if fd.rdeadline >= 0 { | |
474 if err = fd.pollServer.WaitRead(fd); err == nil { | 464 if err = fd.pollServer.WaitRead(fd); err == nil { |
475 continue | 465 continue |
476 } | 466 } |
477 } | 467 } |
478 } | 468 } |
479 » » if err != nil { | 469 » » if n == 0 && err == nil && fd.sotype == syscall.SOCK_STREAM { |
rsc
2012/11/27 15:26:58
Same.
dfc
2012/11/27 21:35:16
Done.
| |
480 » » » n = 0 | 470 » » » err = io.EOF |
481 } | 471 } |
482 break | 472 break |
483 } | 473 } |
484 if err != nil && err != io.EOF { | 474 if err != nil && err != io.EOF { |
485 err = &OpError{"read", fd.net, fd.laddr, err} | 475 err = &OpError{"read", fd.net, fd.laddr, err} |
486 } | 476 } |
487 return | 477 return |
488 } | 478 } |
489 | 479 |
490 func (fd *netFD) ReadMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.S ockaddr, err error) { | 480 func (fd *netFD) ReadMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.S ockaddr, err error) { |
491 fd.rio.Lock() | 481 fd.rio.Lock() |
492 defer fd.rio.Unlock() | 482 defer fd.rio.Unlock() |
493 if err := fd.incref(false); err != nil { | 483 if err := fd.incref(false); err != nil { |
494 return 0, 0, 0, nil, err | 484 return 0, 0, 0, nil, err |
495 } | 485 } |
496 defer fd.decref() | 486 defer fd.decref() |
497 for { | 487 for { |
498 if fd.rdeadline > 0 { | 488 if fd.rdeadline > 0 { |
499 if time.Now().UnixNano() >= fd.rdeadline { | 489 if time.Now().UnixNano() >= fd.rdeadline { |
500 err = errTimeout | 490 err = errTimeout |
501 break | 491 break |
502 } | 492 } |
503 } | 493 } |
504 n, oobn, flags, sa, err = syscall.Recvmsg(fd.sysfd, p, oob, 0) | 494 n, oobn, flags, sa, err = syscall.Recvmsg(fd.sysfd, p, oob, 0) |
505 » » if err == syscall.EAGAIN { | 495 » » if err != nil { |
506 » » » n = 0 | 496 » » » // TODO(dfc) should n and oobn be set to nil |
507 » » » err = errTimeout | 497 » » » if err == syscall.EAGAIN { |
508 » » » if fd.rdeadline >= 0 { | |
509 if err = fd.pollServer.WaitRead(fd); err == nil { | 498 if err = fd.pollServer.WaitRead(fd); err == nil { |
510 continue | 499 continue |
511 } | 500 } |
512 } | 501 } |
513 } | 502 } |
514 » » if err == nil && n == 0 { | 503 » » if n == 0 && err == nil && fd.sotype == syscall.SOCK_STREAM { |
rsc
2012/11/27 15:26:58
Same.
dfc
2012/11/27 21:35:16
Done.
| |
515 err = io.EOF | 504 err = io.EOF |
516 } | 505 } |
517 break | 506 break |
518 } | 507 } |
519 if err != nil && err != io.EOF { | 508 if err != nil && err != io.EOF { |
520 err = &OpError{"read", fd.net, fd.laddr, err} | 509 err = &OpError{"read", fd.net, fd.laddr, err} |
521 return | |
522 } | 510 } |
523 return | 511 return |
524 } | 512 } |
525 | 513 |
526 func (fd *netFD) Write(p []byte) (int, error) { | 514 func (fd *netFD) Write(p []byte) (int, error) { |
527 fd.wio.Lock() | 515 fd.wio.Lock() |
528 defer fd.wio.Unlock() | 516 defer fd.wio.Unlock() |
529 if err := fd.incref(false); err != nil { | 517 if err := fd.incref(false); err != nil { |
530 return 0, err | 518 return 0, err |
531 } | 519 } |
532 defer fd.decref() | 520 defer fd.decref() |
533 var err error | 521 var err error |
534 nn := 0 | 522 nn := 0 |
535 for { | 523 for { |
536 if fd.wdeadline > 0 { | 524 if fd.wdeadline > 0 { |
537 if time.Now().UnixNano() >= fd.wdeadline { | 525 if time.Now().UnixNano() >= fd.wdeadline { |
538 err = errTimeout | 526 err = errTimeout |
539 break | 527 break |
540 } | 528 } |
541 } | 529 } |
542 var n int | 530 var n int |
543 n, err = syscall.Write(int(fd.sysfd), p[nn:]) | 531 n, err = syscall.Write(int(fd.sysfd), p[nn:]) |
544 if n > 0 { | 532 if n > 0 { |
545 nn += n | 533 nn += n |
546 } | 534 } |
547 if nn == len(p) { | 535 if nn == len(p) { |
548 break | 536 break |
549 } | 537 } |
550 if err == syscall.EAGAIN { | 538 if err == syscall.EAGAIN { |
551 » » » err = errTimeout | 539 » » » if err = fd.pollServer.WaitWrite(fd); err == nil { |
552 » » » if fd.wdeadline >= 0 { | 540 » » » » continue |
553 » » » » if err = fd.pollServer.WaitWrite(fd); err == nil { | |
554 » » » » » continue | |
555 » » » » } | |
556 } | 541 } |
557 } | 542 } |
558 if err != nil { | 543 if err != nil { |
559 n = 0 | 544 n = 0 |
560 break | 545 break |
561 } | 546 } |
562 if n == 0 { | 547 if n == 0 { |
563 err = io.ErrUnexpectedEOF | 548 err = io.ErrUnexpectedEOF |
564 break | 549 break |
565 } | 550 } |
(...skipping 13 matching lines...) Expand all Loading... | |
579 defer fd.decref() | 564 defer fd.decref() |
580 for { | 565 for { |
581 if fd.wdeadline > 0 { | 566 if fd.wdeadline > 0 { |
582 if time.Now().UnixNano() >= fd.wdeadline { | 567 if time.Now().UnixNano() >= fd.wdeadline { |
583 err = errTimeout | 568 err = errTimeout |
584 break | 569 break |
585 } | 570 } |
586 } | 571 } |
587 err = syscall.Sendto(fd.sysfd, p, 0, sa) | 572 err = syscall.Sendto(fd.sysfd, p, 0, sa) |
588 if err == syscall.EAGAIN { | 573 if err == syscall.EAGAIN { |
589 » » » err = errTimeout | 574 » » » if err = fd.pollServer.WaitWrite(fd); err == nil { |
590 » » » if fd.wdeadline >= 0 { | 575 » » » » continue |
591 » » » » if err = fd.pollServer.WaitWrite(fd); err == nil { | |
592 » » » » » continue | |
593 » » » » } | |
594 } | 576 } |
595 } | 577 } |
596 break | 578 break |
597 } | 579 } |
598 if err == nil { | 580 if err == nil { |
599 n = len(p) | 581 n = len(p) |
600 } else { | 582 } else { |
601 err = &OpError{"write", fd.net, fd.raddr, err} | 583 err = &OpError{"write", fd.net, fd.raddr, err} |
602 } | 584 } |
603 return | 585 return |
604 } | 586 } |
605 | 587 |
606 func (fd *netFD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oob n int, err error) { | 588 func (fd *netFD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oob n int, err error) { |
607 fd.wio.Lock() | 589 fd.wio.Lock() |
608 defer fd.wio.Unlock() | 590 defer fd.wio.Unlock() |
609 if err := fd.incref(false); err != nil { | 591 if err := fd.incref(false); err != nil { |
610 return 0, 0, err | 592 return 0, 0, err |
611 } | 593 } |
612 defer fd.decref() | 594 defer fd.decref() |
613 for { | 595 for { |
614 if fd.wdeadline > 0 { | 596 if fd.wdeadline > 0 { |
615 if time.Now().UnixNano() >= fd.wdeadline { | 597 if time.Now().UnixNano() >= fd.wdeadline { |
616 err = errTimeout | 598 err = errTimeout |
617 break | 599 break |
618 } | 600 } |
619 } | 601 } |
620 err = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0) | 602 err = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0) |
621 if err == syscall.EAGAIN { | 603 if err == syscall.EAGAIN { |
622 » » » err = errTimeout | 604 » » » if err = fd.pollServer.WaitWrite(fd); err == nil { |
623 » » » if fd.wdeadline >= 0 { | 605 » » » » continue |
624 » » » » if err = fd.pollServer.WaitWrite(fd); err == nil { | |
625 » » » » » continue | |
626 » » » » } | |
627 } | 606 } |
628 } | 607 } |
629 break | 608 break |
630 } | 609 } |
631 if err == nil { | 610 if err == nil { |
632 n = len(p) | 611 n = len(p) |
633 oobn = len(oob) | 612 oobn = len(oob) |
634 } else { | 613 } else { |
635 err = &OpError{"write", fd.net, fd.raddr, err} | 614 err = &OpError{"write", fd.net, fd.raddr, err} |
636 } | 615 } |
(...skipping 10 matching lines...) Expand all Loading... | |
647 // It is okay to hold the lock across syscall.Accept | 626 // It is okay to hold the lock across syscall.Accept |
648 // because we have put fd.sysfd into non-blocking mode. | 627 // because we have put fd.sysfd into non-blocking mode. |
649 var s int | 628 var s int |
650 var rsa syscall.Sockaddr | 629 var rsa syscall.Sockaddr |
651 for { | 630 for { |
652 syscall.ForkLock.RLock() | 631 syscall.ForkLock.RLock() |
653 s, rsa, err = syscall.Accept(fd.sysfd) | 632 s, rsa, err = syscall.Accept(fd.sysfd) |
654 if err != nil { | 633 if err != nil { |
655 syscall.ForkLock.RUnlock() | 634 syscall.ForkLock.RUnlock() |
656 if err == syscall.EAGAIN { | 635 if err == syscall.EAGAIN { |
657 » » » » err = errTimeout | 636 » » » » if err = fd.pollServer.WaitRead(fd); err == nil { |
658 » » » » if fd.rdeadline >= 0 { | 637 » » » » » continue |
659 » » » » » if err = fd.pollServer.WaitRead(fd); err == nil { | |
660 » » » » » » continue | |
661 » » » » » } | |
662 } | 638 } |
663 } else if err == syscall.ECONNABORTED { | 639 } else if err == syscall.ECONNABORTED { |
664 // This means that a socket on the listen queue was closed | 640 // This means that a socket on the listen queue was closed |
665 // before we Accept()ed it; it's a silly error, so try again. | 641 // before we Accept()ed it; it's a silly error, so try again. |
666 continue | 642 continue |
667 } | 643 } |
668 return nil, &OpError{"accept", fd.net, fd.laddr, err} | 644 return nil, &OpError{"accept", fd.net, fd.laddr, err} |
669 } | 645 } |
670 break | 646 break |
671 } | 647 } |
(...skipping 23 matching lines...) Expand all Loading... | |
695 if err = syscall.SetNonblock(ns, false); err != nil { | 671 if err = syscall.SetNonblock(ns, false); err != nil { |
696 return nil, &OpError{"setnonblock", fd.net, fd.laddr, err} | 672 return nil, &OpError{"setnonblock", fd.net, fd.laddr, err} |
697 } | 673 } |
698 | 674 |
699 return os.NewFile(uintptr(ns), fd.name()), nil | 675 return os.NewFile(uintptr(ns), fd.name()), nil |
700 } | 676 } |
701 | 677 |
702 func closesocket(s int) error { | 678 func closesocket(s int) error { |
703 return syscall.Close(s) | 679 return syscall.Close(s) |
704 } | 680 } |
OLD | NEW |