sys_unix.go

     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  //go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || netbsd || openbsd || solaris
     6  
     7  package socktest
     8  
     9  import "syscall"
    10  
    11  // Socket wraps syscall.Socket.
    12  func (sw *Switch) Socket(family, sotype, proto int) (s int, err error) {
    13  	sw.once.Do(sw.init)
    14  
    15  	so := &Status{Cookie: cookie(family, sotype, proto)}
    16  	sw.fmu.RLock()
    17  	f := sw.fltab[FilterSocket]
    18  	sw.fmu.RUnlock()
    19  
    20  	af, err := f.apply(so)
    21  	if err != nil {
    22  		return -1, err
    23  	}
    24  	s, so.Err = syscall.Socket(family, sotype, proto)
    25  	if err = af.apply(so); err != nil {
    26  		if so.Err == nil {
    27  			syscall.Close(s)
    28  		}
    29  		return -1, err
    30  	}
    31  
    32  	sw.smu.Lock()
    33  	defer sw.smu.Unlock()
    34  	if so.Err != nil {
    35  		sw.stats.getLocked(so.Cookie).OpenFailed++
    36  		return -1, so.Err
    37  	}
    38  	nso := sw.addLocked(s, family, sotype, proto)
    39  	sw.stats.getLocked(nso.Cookie).Opened++
    40  	return s, nil
    41  }
    42  
    43  // Close wraps syscall.Close.
    44  func (sw *Switch) Close(s int) (err error) {
    45  	so := sw.sockso(s)
    46  	if so == nil {
    47  		return syscall.Close(s)
    48  	}
    49  	sw.fmu.RLock()
    50  	f := sw.fltab[FilterClose]
    51  	sw.fmu.RUnlock()
    52  
    53  	af, err := f.apply(so)
    54  	if err != nil {
    55  		return err
    56  	}
    57  	so.Err = syscall.Close(s)
    58  	if err = af.apply(so); err != nil {
    59  		return err
    60  	}
    61  
    62  	sw.smu.Lock()
    63  	defer sw.smu.Unlock()
    64  	if so.Err != nil {
    65  		sw.stats.getLocked(so.Cookie).CloseFailed++
    66  		return so.Err
    67  	}
    68  	delete(sw.sotab, s)
    69  	sw.stats.getLocked(so.Cookie).Closed++
    70  	return nil
    71  }
    72  
    73  // Connect wraps syscall.Connect.
    74  func (sw *Switch) Connect(s int, sa syscall.Sockaddr) (err error) {
    75  	so := sw.sockso(s)
    76  	if so == nil {
    77  		return syscall.Connect(s, sa)
    78  	}
    79  	sw.fmu.RLock()
    80  	f := sw.fltab[FilterConnect]
    81  	sw.fmu.RUnlock()
    82  
    83  	af, err := f.apply(so)
    84  	if err != nil {
    85  		return err
    86  	}
    87  	so.Err = syscall.Connect(s, sa)
    88  	if err = af.apply(so); err != nil {
    89  		return err
    90  	}
    91  
    92  	sw.smu.Lock()
    93  	defer sw.smu.Unlock()
    94  	if so.Err != nil {
    95  		sw.stats.getLocked(so.Cookie).ConnectFailed++
    96  		return so.Err
    97  	}
    98  	sw.stats.getLocked(so.Cookie).Connected++
    99  	return nil
   100  }
   101  
   102  // Listen wraps syscall.Listen.
   103  func (sw *Switch) Listen(s, backlog int) (err error) {
   104  	so := sw.sockso(s)
   105  	if so == nil {
   106  		return syscall.Listen(s, backlog)
   107  	}
   108  	sw.fmu.RLock()
   109  	f := sw.fltab[FilterListen]
   110  	sw.fmu.RUnlock()
   111  
   112  	af, err := f.apply(so)
   113  	if err != nil {
   114  		return err
   115  	}
   116  	so.Err = syscall.Listen(s, backlog)
   117  	if err = af.apply(so); err != nil {
   118  		return err
   119  	}
   120  
   121  	sw.smu.Lock()
   122  	defer sw.smu.Unlock()
   123  	if so.Err != nil {
   124  		sw.stats.getLocked(so.Cookie).ListenFailed++
   125  		return so.Err
   126  	}
   127  	sw.stats.getLocked(so.Cookie).Listened++
   128  	return nil
   129  }
   130  
   131  // Accept wraps syscall.Accept.
   132  func (sw *Switch) Accept(s int) (ns int, sa syscall.Sockaddr, err error) {
   133  	so := sw.sockso(s)
   134  	if so == nil {
   135  		return syscall.Accept(s)
   136  	}
   137  	sw.fmu.RLock()
   138  	f := sw.fltab[FilterAccept]
   139  	sw.fmu.RUnlock()
   140  
   141  	af, err := f.apply(so)
   142  	if err != nil {
   143  		return -1, nil, err
   144  	}
   145  	ns, sa, so.Err = syscall.Accept(s)
   146  	if err = af.apply(so); err != nil {
   147  		if so.Err == nil {
   148  			syscall.Close(ns)
   149  		}
   150  		return -1, nil, err
   151  	}
   152  
   153  	sw.smu.Lock()
   154  	defer sw.smu.Unlock()
   155  	if so.Err != nil {
   156  		sw.stats.getLocked(so.Cookie).AcceptFailed++
   157  		return -1, nil, so.Err
   158  	}
   159  	nso := sw.addLocked(ns, so.Cookie.Family(), so.Cookie.Type(), so.Cookie.Protocol())
   160  	sw.stats.getLocked(nso.Cookie).Accepted++
   161  	return ns, sa, nil
   162  }
   163  
   164  // GetsockoptInt wraps syscall.GetsockoptInt.
   165  func (sw *Switch) GetsockoptInt(s, level, opt int) (soerr int, err error) {
   166  	so := sw.sockso(s)
   167  	if so == nil {
   168  		return syscall.GetsockoptInt(s, level, opt)
   169  	}
   170  	sw.fmu.RLock()
   171  	f := sw.fltab[FilterGetsockoptInt]
   172  	sw.fmu.RUnlock()
   173  
   174  	af, err := f.apply(so)
   175  	if err != nil {
   176  		return -1, err
   177  	}
   178  	soerr, so.Err = syscall.GetsockoptInt(s, level, opt)
   179  	so.SocketErr = syscall.Errno(soerr)
   180  	if err = af.apply(so); err != nil {
   181  		return -1, err
   182  	}
   183  
   184  	if so.Err != nil {
   185  		return -1, so.Err
   186  	}
   187  	if opt == syscall.SO_ERROR && (so.SocketErr == syscall.Errno(0) || so.SocketErr == syscall.EISCONN) {
   188  		sw.smu.Lock()
   189  		sw.stats.getLocked(so.Cookie).Connected++
   190  		sw.smu.Unlock()
   191  	}
   192  	return soerr, nil
   193  }
   194
View as plain text