rsc.io/go@v0.0.0-20150416155037-e040fd465409/src/net/internal/socktest/sys_windows.go (about)

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package socktest
     6  
     7  import "syscall"
     8  
     9  // Socket wraps syscall.Socket.
    10  func (sw *Switch) Socket(family, sotype, proto int) (s syscall.Handle, err error) {
    11  	so := &Status{Cookie: cookie(family, sotype, proto)}
    12  	sw.fmu.RLock()
    13  	f, _ := sw.fltab[FilterSocket]
    14  	sw.fmu.RUnlock()
    15  
    16  	af, err := f.apply(so)
    17  	if err != nil {
    18  		return syscall.InvalidHandle, err
    19  	}
    20  	s, so.Err = syscall.Socket(family, sotype, proto)
    21  	if err = af.apply(so); err != nil {
    22  		if so.Err == nil {
    23  			syscall.Closesocket(s)
    24  		}
    25  		return syscall.InvalidHandle, err
    26  	}
    27  
    28  	sw.smu.Lock()
    29  	defer sw.smu.Unlock()
    30  	if so.Err != nil {
    31  		sw.stats.getLocked(so.Cookie).OpenFailed++
    32  		return syscall.InvalidHandle, so.Err
    33  	}
    34  	nso := sw.addLocked(s, family, sotype, proto)
    35  	sw.stats.getLocked(nso.Cookie).Opened++
    36  	return s, nil
    37  }
    38  
    39  // Closesocket wraps syscall.Closesocket.
    40  func (sw *Switch) Closesocket(s syscall.Handle) (err error) {
    41  	so := sw.sockso(s)
    42  	if so == nil {
    43  		return syscall.Closesocket(s)
    44  	}
    45  	sw.fmu.RLock()
    46  	f, _ := sw.fltab[FilterClose]
    47  	sw.fmu.RUnlock()
    48  
    49  	af, err := f.apply(so)
    50  	if err != nil {
    51  		return err
    52  	}
    53  	so.Err = syscall.Closesocket(s)
    54  	if err = af.apply(so); err != nil {
    55  		return err
    56  	}
    57  
    58  	sw.smu.Lock()
    59  	defer sw.smu.Unlock()
    60  	if so.Err != nil {
    61  		sw.stats.getLocked(so.Cookie).CloseFailed++
    62  		return so.Err
    63  	}
    64  	delete(sw.sotab, s)
    65  	sw.stats.getLocked(so.Cookie).Closed++
    66  	return nil
    67  }
    68  
    69  // Conenct wraps syscall.Connect.
    70  func (sw *Switch) Connect(s syscall.Handle, sa syscall.Sockaddr) (err error) {
    71  	so := sw.sockso(s)
    72  	if so == nil {
    73  		return syscall.Connect(s, sa)
    74  	}
    75  	sw.fmu.RLock()
    76  	f, _ := sw.fltab[FilterConnect]
    77  	sw.fmu.RUnlock()
    78  
    79  	af, err := f.apply(so)
    80  	if err != nil {
    81  		return err
    82  	}
    83  	so.Err = syscall.Connect(s, sa)
    84  	if err = af.apply(so); err != nil {
    85  		return err
    86  	}
    87  
    88  	sw.smu.Lock()
    89  	defer sw.smu.Unlock()
    90  	if so.Err != nil {
    91  		sw.stats.getLocked(so.Cookie).ConnectFailed++
    92  		return so.Err
    93  	}
    94  	sw.stats.getLocked(so.Cookie).Connected++
    95  	return nil
    96  }
    97  
    98  // ConenctEx wraps syscall.ConnectEx.
    99  func (sw *Switch) ConnectEx(s syscall.Handle, sa syscall.Sockaddr, b *byte, n uint32, nwr *uint32, o *syscall.Overlapped) (err error) {
   100  	so := sw.sockso(s)
   101  	if so == nil {
   102  		return syscall.ConnectEx(s, sa, b, n, nwr, o)
   103  	}
   104  	sw.fmu.RLock()
   105  	f, _ := sw.fltab[FilterConnect]
   106  	sw.fmu.RUnlock()
   107  
   108  	af, err := f.apply(so)
   109  	if err != nil {
   110  		return err
   111  	}
   112  	so.Err = syscall.ConnectEx(s, sa, b, n, nwr, o)
   113  	if err = af.apply(so); err != nil {
   114  		return err
   115  	}
   116  
   117  	sw.smu.Lock()
   118  	defer sw.smu.Unlock()
   119  	if so.Err != nil {
   120  		sw.stats.getLocked(so.Cookie).ConnectFailed++
   121  		return so.Err
   122  	}
   123  	sw.stats.getLocked(so.Cookie).Connected++
   124  	return nil
   125  }
   126  
   127  // Listen wraps syscall.Listen.
   128  func (sw *Switch) Listen(s syscall.Handle, backlog int) (err error) {
   129  	so := sw.sockso(s)
   130  	if so == nil {
   131  		return syscall.Listen(s, backlog)
   132  	}
   133  	sw.fmu.RLock()
   134  	f, _ := sw.fltab[FilterListen]
   135  	sw.fmu.RUnlock()
   136  
   137  	af, err := f.apply(so)
   138  	if err != nil {
   139  		return err
   140  	}
   141  	so.Err = syscall.Listen(s, backlog)
   142  	if err = af.apply(so); err != nil {
   143  		return err
   144  	}
   145  
   146  	sw.smu.Lock()
   147  	defer sw.smu.Unlock()
   148  	if so.Err != nil {
   149  		sw.stats.getLocked(so.Cookie).ListenFailed++
   150  		return so.Err
   151  	}
   152  	sw.stats.getLocked(so.Cookie).Listened++
   153  	return nil
   154  }