Source file src/github.com/Microsoft/hcsshim/hcn/zsyscall_windows.go

Documentation: github.com/Microsoft/hcsshim/hcn

     1  //go:build windows
     2  
     3  // Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
     4  
     5  package hcn
     6  
     7  import (
     8  	"syscall"
     9  	"unsafe"
    10  
    11  	"golang.org/x/sys/windows"
    12  )
    13  
    14  var _ unsafe.Pointer
    15  
    16  // Do the interface allocations only once for common
    17  // Errno values.
    18  const (
    19  	errnoERROR_IO_PENDING = 997
    20  )
    21  
    22  var (
    23  	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
    24  	errERROR_EINVAL     error = syscall.EINVAL
    25  )
    26  
    27  // errnoErr returns common boxed Errno values, to prevent
    28  // allocations at runtime.
    29  func errnoErr(e syscall.Errno) error {
    30  	switch e {
    31  	case 0:
    32  		return errERROR_EINVAL
    33  	case errnoERROR_IO_PENDING:
    34  		return errERROR_IO_PENDING
    35  	}
    36  	// TODO: add more here, after collecting data on the common
    37  	// error values see on Windows. (perhaps when running
    38  	// all.bat?)
    39  	return e
    40  }
    41  
    42  var (
    43  	modcomputenetwork = windows.NewLazySystemDLL("computenetwork.dll")
    44  	modiphlpapi       = windows.NewLazySystemDLL("iphlpapi.dll")
    45  	modvmcompute      = windows.NewLazySystemDLL("vmcompute.dll")
    46  
    47  	procHcnCloseEndpoint               = modcomputenetwork.NewProc("HcnCloseEndpoint")
    48  	procHcnCloseLoadBalancer           = modcomputenetwork.NewProc("HcnCloseLoadBalancer")
    49  	procHcnCloseNamespace              = modcomputenetwork.NewProc("HcnCloseNamespace")
    50  	procHcnCloseNetwork                = modcomputenetwork.NewProc("HcnCloseNetwork")
    51  	procHcnCloseSdnRoute               = modcomputenetwork.NewProc("HcnCloseSdnRoute")
    52  	procHcnCreateEndpoint              = modcomputenetwork.NewProc("HcnCreateEndpoint")
    53  	procHcnCreateLoadBalancer          = modcomputenetwork.NewProc("HcnCreateLoadBalancer")
    54  	procHcnCreateNamespace             = modcomputenetwork.NewProc("HcnCreateNamespace")
    55  	procHcnCreateNetwork               = modcomputenetwork.NewProc("HcnCreateNetwork")
    56  	procHcnCreateSdnRoute              = modcomputenetwork.NewProc("HcnCreateSdnRoute")
    57  	procHcnDeleteEndpoint              = modcomputenetwork.NewProc("HcnDeleteEndpoint")
    58  	procHcnDeleteLoadBalancer          = modcomputenetwork.NewProc("HcnDeleteLoadBalancer")
    59  	procHcnDeleteNamespace             = modcomputenetwork.NewProc("HcnDeleteNamespace")
    60  	procHcnDeleteNetwork               = modcomputenetwork.NewProc("HcnDeleteNetwork")
    61  	procHcnDeleteSdnRoute              = modcomputenetwork.NewProc("HcnDeleteSdnRoute")
    62  	procHcnEnumerateEndpoints          = modcomputenetwork.NewProc("HcnEnumerateEndpoints")
    63  	procHcnEnumerateLoadBalancers      = modcomputenetwork.NewProc("HcnEnumerateLoadBalancers")
    64  	procHcnEnumerateNamespaces         = modcomputenetwork.NewProc("HcnEnumerateNamespaces")
    65  	procHcnEnumerateNetworks           = modcomputenetwork.NewProc("HcnEnumerateNetworks")
    66  	procHcnEnumerateSdnRoutes          = modcomputenetwork.NewProc("HcnEnumerateSdnRoutes")
    67  	procHcnModifyEndpoint              = modcomputenetwork.NewProc("HcnModifyEndpoint")
    68  	procHcnModifyLoadBalancer          = modcomputenetwork.NewProc("HcnModifyLoadBalancer")
    69  	procHcnModifyNamespace             = modcomputenetwork.NewProc("HcnModifyNamespace")
    70  	procHcnModifyNetwork               = modcomputenetwork.NewProc("HcnModifyNetwork")
    71  	procHcnModifySdnRoute              = modcomputenetwork.NewProc("HcnModifySdnRoute")
    72  	procHcnOpenEndpoint                = modcomputenetwork.NewProc("HcnOpenEndpoint")
    73  	procHcnOpenLoadBalancer            = modcomputenetwork.NewProc("HcnOpenLoadBalancer")
    74  	procHcnOpenNamespace               = modcomputenetwork.NewProc("HcnOpenNamespace")
    75  	procHcnOpenNetwork                 = modcomputenetwork.NewProc("HcnOpenNetwork")
    76  	procHcnOpenSdnRoute                = modcomputenetwork.NewProc("HcnOpenSdnRoute")
    77  	procHcnQueryEndpointProperties     = modcomputenetwork.NewProc("HcnQueryEndpointProperties")
    78  	procHcnQueryLoadBalancerProperties = modcomputenetwork.NewProc("HcnQueryLoadBalancerProperties")
    79  	procHcnQueryNamespaceProperties    = modcomputenetwork.NewProc("HcnQueryNamespaceProperties")
    80  	procHcnQueryNetworkProperties      = modcomputenetwork.NewProc("HcnQueryNetworkProperties")
    81  	procHcnQuerySdnRouteProperties     = modcomputenetwork.NewProc("HcnQuerySdnRouteProperties")
    82  	procSetCurrentThreadCompartmentId  = modiphlpapi.NewProc("SetCurrentThreadCompartmentId")
    83  	procHNSCall                        = modvmcompute.NewProc("HNSCall")
    84  )
    85  
    86  func hcnCloseEndpoint(endpoint hcnEndpoint) (hr error) {
    87  	hr = procHcnCloseEndpoint.Find()
    88  	if hr != nil {
    89  		return
    90  	}
    91  	r0, _, _ := syscall.Syscall(procHcnCloseEndpoint.Addr(), 1, uintptr(endpoint), 0, 0)
    92  	if int32(r0) < 0 {
    93  		if r0&0x1fff0000 == 0x00070000 {
    94  			r0 &= 0xffff
    95  		}
    96  		hr = syscall.Errno(r0)
    97  	}
    98  	return
    99  }
   100  
   101  func hcnCloseLoadBalancer(loadBalancer hcnLoadBalancer) (hr error) {
   102  	hr = procHcnCloseLoadBalancer.Find()
   103  	if hr != nil {
   104  		return
   105  	}
   106  	r0, _, _ := syscall.Syscall(procHcnCloseLoadBalancer.Addr(), 1, uintptr(loadBalancer), 0, 0)
   107  	if int32(r0) < 0 {
   108  		if r0&0x1fff0000 == 0x00070000 {
   109  			r0 &= 0xffff
   110  		}
   111  		hr = syscall.Errno(r0)
   112  	}
   113  	return
   114  }
   115  
   116  func hcnCloseNamespace(namespace hcnNamespace) (hr error) {
   117  	hr = procHcnCloseNamespace.Find()
   118  	if hr != nil {
   119  		return
   120  	}
   121  	r0, _, _ := syscall.Syscall(procHcnCloseNamespace.Addr(), 1, uintptr(namespace), 0, 0)
   122  	if int32(r0) < 0 {
   123  		if r0&0x1fff0000 == 0x00070000 {
   124  			r0 &= 0xffff
   125  		}
   126  		hr = syscall.Errno(r0)
   127  	}
   128  	return
   129  }
   130  
   131  func hcnCloseNetwork(network hcnNetwork) (hr error) {
   132  	hr = procHcnCloseNetwork.Find()
   133  	if hr != nil {
   134  		return
   135  	}
   136  	r0, _, _ := syscall.Syscall(procHcnCloseNetwork.Addr(), 1, uintptr(network), 0, 0)
   137  	if int32(r0) < 0 {
   138  		if r0&0x1fff0000 == 0x00070000 {
   139  			r0 &= 0xffff
   140  		}
   141  		hr = syscall.Errno(r0)
   142  	}
   143  	return
   144  }
   145  
   146  func hcnCloseRoute(route hcnRoute) (hr error) {
   147  	hr = procHcnCloseSdnRoute.Find()
   148  	if hr != nil {
   149  		return
   150  	}
   151  	r0, _, _ := syscall.Syscall(procHcnCloseSdnRoute.Addr(), 1, uintptr(route), 0, 0)
   152  	if int32(r0) < 0 {
   153  		if r0&0x1fff0000 == 0x00070000 {
   154  			r0 &= 0xffff
   155  		}
   156  		hr = syscall.Errno(r0)
   157  	}
   158  	return
   159  }
   160  
   161  func hcnCreateEndpoint(network hcnNetwork, id *_guid, settings string, endpoint *hcnEndpoint, result **uint16) (hr error) {
   162  	var _p0 *uint16
   163  	_p0, hr = syscall.UTF16PtrFromString(settings)
   164  	if hr != nil {
   165  		return
   166  	}
   167  	return _hcnCreateEndpoint(network, id, _p0, endpoint, result)
   168  }
   169  
   170  func _hcnCreateEndpoint(network hcnNetwork, id *_guid, settings *uint16, endpoint *hcnEndpoint, result **uint16) (hr error) {
   171  	hr = procHcnCreateEndpoint.Find()
   172  	if hr != nil {
   173  		return
   174  	}
   175  	r0, _, _ := syscall.Syscall6(procHcnCreateEndpoint.Addr(), 5, uintptr(network), uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(endpoint)), uintptr(unsafe.Pointer(result)), 0)
   176  	if int32(r0) < 0 {
   177  		if r0&0x1fff0000 == 0x00070000 {
   178  			r0 &= 0xffff
   179  		}
   180  		hr = syscall.Errno(r0)
   181  	}
   182  	return
   183  }
   184  
   185  func hcnCreateLoadBalancer(id *_guid, settings string, loadBalancer *hcnLoadBalancer, result **uint16) (hr error) {
   186  	var _p0 *uint16
   187  	_p0, hr = syscall.UTF16PtrFromString(settings)
   188  	if hr != nil {
   189  		return
   190  	}
   191  	return _hcnCreateLoadBalancer(id, _p0, loadBalancer, result)
   192  }
   193  
   194  func _hcnCreateLoadBalancer(id *_guid, settings *uint16, loadBalancer *hcnLoadBalancer, result **uint16) (hr error) {
   195  	hr = procHcnCreateLoadBalancer.Find()
   196  	if hr != nil {
   197  		return
   198  	}
   199  	r0, _, _ := syscall.Syscall6(procHcnCreateLoadBalancer.Addr(), 4, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(loadBalancer)), uintptr(unsafe.Pointer(result)), 0, 0)
   200  	if int32(r0) < 0 {
   201  		if r0&0x1fff0000 == 0x00070000 {
   202  			r0 &= 0xffff
   203  		}
   204  		hr = syscall.Errno(r0)
   205  	}
   206  	return
   207  }
   208  
   209  func hcnCreateNamespace(id *_guid, settings string, namespace *hcnNamespace, result **uint16) (hr error) {
   210  	var _p0 *uint16
   211  	_p0, hr = syscall.UTF16PtrFromString(settings)
   212  	if hr != nil {
   213  		return
   214  	}
   215  	return _hcnCreateNamespace(id, _p0, namespace, result)
   216  }
   217  
   218  func _hcnCreateNamespace(id *_guid, settings *uint16, namespace *hcnNamespace, result **uint16) (hr error) {
   219  	hr = procHcnCreateNamespace.Find()
   220  	if hr != nil {
   221  		return
   222  	}
   223  	r0, _, _ := syscall.Syscall6(procHcnCreateNamespace.Addr(), 4, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(namespace)), uintptr(unsafe.Pointer(result)), 0, 0)
   224  	if int32(r0) < 0 {
   225  		if r0&0x1fff0000 == 0x00070000 {
   226  			r0 &= 0xffff
   227  		}
   228  		hr = syscall.Errno(r0)
   229  	}
   230  	return
   231  }
   232  
   233  func hcnCreateNetwork(id *_guid, settings string, network *hcnNetwork, result **uint16) (hr error) {
   234  	var _p0 *uint16
   235  	_p0, hr = syscall.UTF16PtrFromString(settings)
   236  	if hr != nil {
   237  		return
   238  	}
   239  	return _hcnCreateNetwork(id, _p0, network, result)
   240  }
   241  
   242  func _hcnCreateNetwork(id *_guid, settings *uint16, network *hcnNetwork, result **uint16) (hr error) {
   243  	hr = procHcnCreateNetwork.Find()
   244  	if hr != nil {
   245  		return
   246  	}
   247  	r0, _, _ := syscall.Syscall6(procHcnCreateNetwork.Addr(), 4, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(network)), uintptr(unsafe.Pointer(result)), 0, 0)
   248  	if int32(r0) < 0 {
   249  		if r0&0x1fff0000 == 0x00070000 {
   250  			r0 &= 0xffff
   251  		}
   252  		hr = syscall.Errno(r0)
   253  	}
   254  	return
   255  }
   256  
   257  func hcnCreateRoute(id *_guid, settings string, route *hcnRoute, result **uint16) (hr error) {
   258  	var _p0 *uint16
   259  	_p0, hr = syscall.UTF16PtrFromString(settings)
   260  	if hr != nil {
   261  		return
   262  	}
   263  	return _hcnCreateRoute(id, _p0, route, result)
   264  }
   265  
   266  func _hcnCreateRoute(id *_guid, settings *uint16, route *hcnRoute, result **uint16) (hr error) {
   267  	hr = procHcnCreateSdnRoute.Find()
   268  	if hr != nil {
   269  		return
   270  	}
   271  	r0, _, _ := syscall.Syscall6(procHcnCreateSdnRoute.Addr(), 4, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(route)), uintptr(unsafe.Pointer(result)), 0, 0)
   272  	if int32(r0) < 0 {
   273  		if r0&0x1fff0000 == 0x00070000 {
   274  			r0 &= 0xffff
   275  		}
   276  		hr = syscall.Errno(r0)
   277  	}
   278  	return
   279  }
   280  
   281  func hcnDeleteEndpoint(id *_guid, result **uint16) (hr error) {
   282  	hr = procHcnDeleteEndpoint.Find()
   283  	if hr != nil {
   284  		return
   285  	}
   286  	r0, _, _ := syscall.Syscall(procHcnDeleteEndpoint.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(result)), 0)
   287  	if int32(r0) < 0 {
   288  		if r0&0x1fff0000 == 0x00070000 {
   289  			r0 &= 0xffff
   290  		}
   291  		hr = syscall.Errno(r0)
   292  	}
   293  	return
   294  }
   295  
   296  func hcnDeleteLoadBalancer(id *_guid, result **uint16) (hr error) {
   297  	hr = procHcnDeleteLoadBalancer.Find()
   298  	if hr != nil {
   299  		return
   300  	}
   301  	r0, _, _ := syscall.Syscall(procHcnDeleteLoadBalancer.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(result)), 0)
   302  	if int32(r0) < 0 {
   303  		if r0&0x1fff0000 == 0x00070000 {
   304  			r0 &= 0xffff
   305  		}
   306  		hr = syscall.Errno(r0)
   307  	}
   308  	return
   309  }
   310  
   311  func hcnDeleteNamespace(id *_guid, result **uint16) (hr error) {
   312  	hr = procHcnDeleteNamespace.Find()
   313  	if hr != nil {
   314  		return
   315  	}
   316  	r0, _, _ := syscall.Syscall(procHcnDeleteNamespace.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(result)), 0)
   317  	if int32(r0) < 0 {
   318  		if r0&0x1fff0000 == 0x00070000 {
   319  			r0 &= 0xffff
   320  		}
   321  		hr = syscall.Errno(r0)
   322  	}
   323  	return
   324  }
   325  
   326  func hcnDeleteNetwork(id *_guid, result **uint16) (hr error) {
   327  	hr = procHcnDeleteNetwork.Find()
   328  	if hr != nil {
   329  		return
   330  	}
   331  	r0, _, _ := syscall.Syscall(procHcnDeleteNetwork.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(result)), 0)
   332  	if int32(r0) < 0 {
   333  		if r0&0x1fff0000 == 0x00070000 {
   334  			r0 &= 0xffff
   335  		}
   336  		hr = syscall.Errno(r0)
   337  	}
   338  	return
   339  }
   340  
   341  func hcnDeleteRoute(id *_guid, result **uint16) (hr error) {
   342  	hr = procHcnDeleteSdnRoute.Find()
   343  	if hr != nil {
   344  		return
   345  	}
   346  	r0, _, _ := syscall.Syscall(procHcnDeleteSdnRoute.Addr(), 2, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(result)), 0)
   347  	if int32(r0) < 0 {
   348  		if r0&0x1fff0000 == 0x00070000 {
   349  			r0 &= 0xffff
   350  		}
   351  		hr = syscall.Errno(r0)
   352  	}
   353  	return
   354  }
   355  
   356  func hcnEnumerateEndpoints(query string, endpoints **uint16, result **uint16) (hr error) {
   357  	var _p0 *uint16
   358  	_p0, hr = syscall.UTF16PtrFromString(query)
   359  	if hr != nil {
   360  		return
   361  	}
   362  	return _hcnEnumerateEndpoints(_p0, endpoints, result)
   363  }
   364  
   365  func _hcnEnumerateEndpoints(query *uint16, endpoints **uint16, result **uint16) (hr error) {
   366  	hr = procHcnEnumerateEndpoints.Find()
   367  	if hr != nil {
   368  		return
   369  	}
   370  	r0, _, _ := syscall.Syscall(procHcnEnumerateEndpoints.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(endpoints)), uintptr(unsafe.Pointer(result)))
   371  	if int32(r0) < 0 {
   372  		if r0&0x1fff0000 == 0x00070000 {
   373  			r0 &= 0xffff
   374  		}
   375  		hr = syscall.Errno(r0)
   376  	}
   377  	return
   378  }
   379  
   380  func hcnEnumerateLoadBalancers(query string, loadBalancers **uint16, result **uint16) (hr error) {
   381  	var _p0 *uint16
   382  	_p0, hr = syscall.UTF16PtrFromString(query)
   383  	if hr != nil {
   384  		return
   385  	}
   386  	return _hcnEnumerateLoadBalancers(_p0, loadBalancers, result)
   387  }
   388  
   389  func _hcnEnumerateLoadBalancers(query *uint16, loadBalancers **uint16, result **uint16) (hr error) {
   390  	hr = procHcnEnumerateLoadBalancers.Find()
   391  	if hr != nil {
   392  		return
   393  	}
   394  	r0, _, _ := syscall.Syscall(procHcnEnumerateLoadBalancers.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(loadBalancers)), uintptr(unsafe.Pointer(result)))
   395  	if int32(r0) < 0 {
   396  		if r0&0x1fff0000 == 0x00070000 {
   397  			r0 &= 0xffff
   398  		}
   399  		hr = syscall.Errno(r0)
   400  	}
   401  	return
   402  }
   403  
   404  func hcnEnumerateNamespaces(query string, namespaces **uint16, result **uint16) (hr error) {
   405  	var _p0 *uint16
   406  	_p0, hr = syscall.UTF16PtrFromString(query)
   407  	if hr != nil {
   408  		return
   409  	}
   410  	return _hcnEnumerateNamespaces(_p0, namespaces, result)
   411  }
   412  
   413  func _hcnEnumerateNamespaces(query *uint16, namespaces **uint16, result **uint16) (hr error) {
   414  	hr = procHcnEnumerateNamespaces.Find()
   415  	if hr != nil {
   416  		return
   417  	}
   418  	r0, _, _ := syscall.Syscall(procHcnEnumerateNamespaces.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(namespaces)), uintptr(unsafe.Pointer(result)))
   419  	if int32(r0) < 0 {
   420  		if r0&0x1fff0000 == 0x00070000 {
   421  			r0 &= 0xffff
   422  		}
   423  		hr = syscall.Errno(r0)
   424  	}
   425  	return
   426  }
   427  
   428  func hcnEnumerateNetworks(query string, networks **uint16, result **uint16) (hr error) {
   429  	var _p0 *uint16
   430  	_p0, hr = syscall.UTF16PtrFromString(query)
   431  	if hr != nil {
   432  		return
   433  	}
   434  	return _hcnEnumerateNetworks(_p0, networks, result)
   435  }
   436  
   437  func _hcnEnumerateNetworks(query *uint16, networks **uint16, result **uint16) (hr error) {
   438  	hr = procHcnEnumerateNetworks.Find()
   439  	if hr != nil {
   440  		return
   441  	}
   442  	r0, _, _ := syscall.Syscall(procHcnEnumerateNetworks.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(networks)), uintptr(unsafe.Pointer(result)))
   443  	if int32(r0) < 0 {
   444  		if r0&0x1fff0000 == 0x00070000 {
   445  			r0 &= 0xffff
   446  		}
   447  		hr = syscall.Errno(r0)
   448  	}
   449  	return
   450  }
   451  
   452  func hcnEnumerateRoutes(query string, routes **uint16, result **uint16) (hr error) {
   453  	var _p0 *uint16
   454  	_p0, hr = syscall.UTF16PtrFromString(query)
   455  	if hr != nil {
   456  		return
   457  	}
   458  	return _hcnEnumerateRoutes(_p0, routes, result)
   459  }
   460  
   461  func _hcnEnumerateRoutes(query *uint16, routes **uint16, result **uint16) (hr error) {
   462  	hr = procHcnEnumerateSdnRoutes.Find()
   463  	if hr != nil {
   464  		return
   465  	}
   466  	r0, _, _ := syscall.Syscall(procHcnEnumerateSdnRoutes.Addr(), 3, uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(routes)), uintptr(unsafe.Pointer(result)))
   467  	if int32(r0) < 0 {
   468  		if r0&0x1fff0000 == 0x00070000 {
   469  			r0 &= 0xffff
   470  		}
   471  		hr = syscall.Errno(r0)
   472  	}
   473  	return
   474  }
   475  
   476  func hcnModifyEndpoint(endpoint hcnEndpoint, settings string, result **uint16) (hr error) {
   477  	var _p0 *uint16
   478  	_p0, hr = syscall.UTF16PtrFromString(settings)
   479  	if hr != nil {
   480  		return
   481  	}
   482  	return _hcnModifyEndpoint(endpoint, _p0, result)
   483  }
   484  
   485  func _hcnModifyEndpoint(endpoint hcnEndpoint, settings *uint16, result **uint16) (hr error) {
   486  	hr = procHcnModifyEndpoint.Find()
   487  	if hr != nil {
   488  		return
   489  	}
   490  	r0, _, _ := syscall.Syscall(procHcnModifyEndpoint.Addr(), 3, uintptr(endpoint), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result)))
   491  	if int32(r0) < 0 {
   492  		if r0&0x1fff0000 == 0x00070000 {
   493  			r0 &= 0xffff
   494  		}
   495  		hr = syscall.Errno(r0)
   496  	}
   497  	return
   498  }
   499  
   500  func hcnModifyLoadBalancer(loadBalancer hcnLoadBalancer, settings string, result **uint16) (hr error) {
   501  	var _p0 *uint16
   502  	_p0, hr = syscall.UTF16PtrFromString(settings)
   503  	if hr != nil {
   504  		return
   505  	}
   506  	return _hcnModifyLoadBalancer(loadBalancer, _p0, result)
   507  }
   508  
   509  func _hcnModifyLoadBalancer(loadBalancer hcnLoadBalancer, settings *uint16, result **uint16) (hr error) {
   510  	hr = procHcnModifyLoadBalancer.Find()
   511  	if hr != nil {
   512  		return
   513  	}
   514  	r0, _, _ := syscall.Syscall(procHcnModifyLoadBalancer.Addr(), 3, uintptr(loadBalancer), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result)))
   515  	if int32(r0) < 0 {
   516  		if r0&0x1fff0000 == 0x00070000 {
   517  			r0 &= 0xffff
   518  		}
   519  		hr = syscall.Errno(r0)
   520  	}
   521  	return
   522  }
   523  
   524  func hcnModifyNamespace(namespace hcnNamespace, settings string, result **uint16) (hr error) {
   525  	var _p0 *uint16
   526  	_p0, hr = syscall.UTF16PtrFromString(settings)
   527  	if hr != nil {
   528  		return
   529  	}
   530  	return _hcnModifyNamespace(namespace, _p0, result)
   531  }
   532  
   533  func _hcnModifyNamespace(namespace hcnNamespace, settings *uint16, result **uint16) (hr error) {
   534  	hr = procHcnModifyNamespace.Find()
   535  	if hr != nil {
   536  		return
   537  	}
   538  	r0, _, _ := syscall.Syscall(procHcnModifyNamespace.Addr(), 3, uintptr(namespace), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result)))
   539  	if int32(r0) < 0 {
   540  		if r0&0x1fff0000 == 0x00070000 {
   541  			r0 &= 0xffff
   542  		}
   543  		hr = syscall.Errno(r0)
   544  	}
   545  	return
   546  }
   547  
   548  func hcnModifyNetwork(network hcnNetwork, settings string, result **uint16) (hr error) {
   549  	var _p0 *uint16
   550  	_p0, hr = syscall.UTF16PtrFromString(settings)
   551  	if hr != nil {
   552  		return
   553  	}
   554  	return _hcnModifyNetwork(network, _p0, result)
   555  }
   556  
   557  func _hcnModifyNetwork(network hcnNetwork, settings *uint16, result **uint16) (hr error) {
   558  	hr = procHcnModifyNetwork.Find()
   559  	if hr != nil {
   560  		return
   561  	}
   562  	r0, _, _ := syscall.Syscall(procHcnModifyNetwork.Addr(), 3, uintptr(network), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result)))
   563  	if int32(r0) < 0 {
   564  		if r0&0x1fff0000 == 0x00070000 {
   565  			r0 &= 0xffff
   566  		}
   567  		hr = syscall.Errno(r0)
   568  	}
   569  	return
   570  }
   571  
   572  func hcnModifyRoute(route hcnRoute, settings string, result **uint16) (hr error) {
   573  	var _p0 *uint16
   574  	_p0, hr = syscall.UTF16PtrFromString(settings)
   575  	if hr != nil {
   576  		return
   577  	}
   578  	return _hcnModifyRoute(route, _p0, result)
   579  }
   580  
   581  func _hcnModifyRoute(route hcnRoute, settings *uint16, result **uint16) (hr error) {
   582  	hr = procHcnModifySdnRoute.Find()
   583  	if hr != nil {
   584  		return
   585  	}
   586  	r0, _, _ := syscall.Syscall(procHcnModifySdnRoute.Addr(), 3, uintptr(route), uintptr(unsafe.Pointer(settings)), uintptr(unsafe.Pointer(result)))
   587  	if int32(r0) < 0 {
   588  		if r0&0x1fff0000 == 0x00070000 {
   589  			r0 &= 0xffff
   590  		}
   591  		hr = syscall.Errno(r0)
   592  	}
   593  	return
   594  }
   595  
   596  func hcnOpenEndpoint(id *_guid, endpoint *hcnEndpoint, result **uint16) (hr error) {
   597  	hr = procHcnOpenEndpoint.Find()
   598  	if hr != nil {
   599  		return
   600  	}
   601  	r0, _, _ := syscall.Syscall(procHcnOpenEndpoint.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(endpoint)), uintptr(unsafe.Pointer(result)))
   602  	if int32(r0) < 0 {
   603  		if r0&0x1fff0000 == 0x00070000 {
   604  			r0 &= 0xffff
   605  		}
   606  		hr = syscall.Errno(r0)
   607  	}
   608  	return
   609  }
   610  
   611  func hcnOpenLoadBalancer(id *_guid, loadBalancer *hcnLoadBalancer, result **uint16) (hr error) {
   612  	hr = procHcnOpenLoadBalancer.Find()
   613  	if hr != nil {
   614  		return
   615  	}
   616  	r0, _, _ := syscall.Syscall(procHcnOpenLoadBalancer.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(loadBalancer)), uintptr(unsafe.Pointer(result)))
   617  	if int32(r0) < 0 {
   618  		if r0&0x1fff0000 == 0x00070000 {
   619  			r0 &= 0xffff
   620  		}
   621  		hr = syscall.Errno(r0)
   622  	}
   623  	return
   624  }
   625  
   626  func hcnOpenNamespace(id *_guid, namespace *hcnNamespace, result **uint16) (hr error) {
   627  	hr = procHcnOpenNamespace.Find()
   628  	if hr != nil {
   629  		return
   630  	}
   631  	r0, _, _ := syscall.Syscall(procHcnOpenNamespace.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(namespace)), uintptr(unsafe.Pointer(result)))
   632  	if int32(r0) < 0 {
   633  		if r0&0x1fff0000 == 0x00070000 {
   634  			r0 &= 0xffff
   635  		}
   636  		hr = syscall.Errno(r0)
   637  	}
   638  	return
   639  }
   640  
   641  func hcnOpenNetwork(id *_guid, network *hcnNetwork, result **uint16) (hr error) {
   642  	hr = procHcnOpenNetwork.Find()
   643  	if hr != nil {
   644  		return
   645  	}
   646  	r0, _, _ := syscall.Syscall(procHcnOpenNetwork.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(network)), uintptr(unsafe.Pointer(result)))
   647  	if int32(r0) < 0 {
   648  		if r0&0x1fff0000 == 0x00070000 {
   649  			r0 &= 0xffff
   650  		}
   651  		hr = syscall.Errno(r0)
   652  	}
   653  	return
   654  }
   655  
   656  func hcnOpenRoute(id *_guid, route *hcnRoute, result **uint16) (hr error) {
   657  	hr = procHcnOpenSdnRoute.Find()
   658  	if hr != nil {
   659  		return
   660  	}
   661  	r0, _, _ := syscall.Syscall(procHcnOpenSdnRoute.Addr(), 3, uintptr(unsafe.Pointer(id)), uintptr(unsafe.Pointer(route)), uintptr(unsafe.Pointer(result)))
   662  	if int32(r0) < 0 {
   663  		if r0&0x1fff0000 == 0x00070000 {
   664  			r0 &= 0xffff
   665  		}
   666  		hr = syscall.Errno(r0)
   667  	}
   668  	return
   669  }
   670  
   671  func hcnQueryEndpointProperties(endpoint hcnEndpoint, query string, properties **uint16, result **uint16) (hr error) {
   672  	var _p0 *uint16
   673  	_p0, hr = syscall.UTF16PtrFromString(query)
   674  	if hr != nil {
   675  		return
   676  	}
   677  	return _hcnQueryEndpointProperties(endpoint, _p0, properties, result)
   678  }
   679  
   680  func _hcnQueryEndpointProperties(endpoint hcnEndpoint, query *uint16, properties **uint16, result **uint16) (hr error) {
   681  	hr = procHcnQueryEndpointProperties.Find()
   682  	if hr != nil {
   683  		return
   684  	}
   685  	r0, _, _ := syscall.Syscall6(procHcnQueryEndpointProperties.Addr(), 4, uintptr(endpoint), uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result)), 0, 0)
   686  	if int32(r0) < 0 {
   687  		if r0&0x1fff0000 == 0x00070000 {
   688  			r0 &= 0xffff
   689  		}
   690  		hr = syscall.Errno(r0)
   691  	}
   692  	return
   693  }
   694  
   695  func hcnQueryLoadBalancerProperties(loadBalancer hcnLoadBalancer, query string, properties **uint16, result **uint16) (hr error) {
   696  	var _p0 *uint16
   697  	_p0, hr = syscall.UTF16PtrFromString(query)
   698  	if hr != nil {
   699  		return
   700  	}
   701  	return _hcnQueryLoadBalancerProperties(loadBalancer, _p0, properties, result)
   702  }
   703  
   704  func _hcnQueryLoadBalancerProperties(loadBalancer hcnLoadBalancer, query *uint16, properties **uint16, result **uint16) (hr error) {
   705  	hr = procHcnQueryLoadBalancerProperties.Find()
   706  	if hr != nil {
   707  		return
   708  	}
   709  	r0, _, _ := syscall.Syscall6(procHcnQueryLoadBalancerProperties.Addr(), 4, uintptr(loadBalancer), uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result)), 0, 0)
   710  	if int32(r0) < 0 {
   711  		if r0&0x1fff0000 == 0x00070000 {
   712  			r0 &= 0xffff
   713  		}
   714  		hr = syscall.Errno(r0)
   715  	}
   716  	return
   717  }
   718  
   719  func hcnQueryNamespaceProperties(namespace hcnNamespace, query string, properties **uint16, result **uint16) (hr error) {
   720  	var _p0 *uint16
   721  	_p0, hr = syscall.UTF16PtrFromString(query)
   722  	if hr != nil {
   723  		return
   724  	}
   725  	return _hcnQueryNamespaceProperties(namespace, _p0, properties, result)
   726  }
   727  
   728  func _hcnQueryNamespaceProperties(namespace hcnNamespace, query *uint16, properties **uint16, result **uint16) (hr error) {
   729  	hr = procHcnQueryNamespaceProperties.Find()
   730  	if hr != nil {
   731  		return
   732  	}
   733  	r0, _, _ := syscall.Syscall6(procHcnQueryNamespaceProperties.Addr(), 4, uintptr(namespace), uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result)), 0, 0)
   734  	if int32(r0) < 0 {
   735  		if r0&0x1fff0000 == 0x00070000 {
   736  			r0 &= 0xffff
   737  		}
   738  		hr = syscall.Errno(r0)
   739  	}
   740  	return
   741  }
   742  
   743  func hcnQueryNetworkProperties(network hcnNetwork, query string, properties **uint16, result **uint16) (hr error) {
   744  	var _p0 *uint16
   745  	_p0, hr = syscall.UTF16PtrFromString(query)
   746  	if hr != nil {
   747  		return
   748  	}
   749  	return _hcnQueryNetworkProperties(network, _p0, properties, result)
   750  }
   751  
   752  func _hcnQueryNetworkProperties(network hcnNetwork, query *uint16, properties **uint16, result **uint16) (hr error) {
   753  	hr = procHcnQueryNetworkProperties.Find()
   754  	if hr != nil {
   755  		return
   756  	}
   757  	r0, _, _ := syscall.Syscall6(procHcnQueryNetworkProperties.Addr(), 4, uintptr(network), uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result)), 0, 0)
   758  	if int32(r0) < 0 {
   759  		if r0&0x1fff0000 == 0x00070000 {
   760  			r0 &= 0xffff
   761  		}
   762  		hr = syscall.Errno(r0)
   763  	}
   764  	return
   765  }
   766  
   767  func hcnQueryRouteProperties(route hcnRoute, query string, properties **uint16, result **uint16) (hr error) {
   768  	var _p0 *uint16
   769  	_p0, hr = syscall.UTF16PtrFromString(query)
   770  	if hr != nil {
   771  		return
   772  	}
   773  	return _hcnQueryRouteProperties(route, _p0, properties, result)
   774  }
   775  
   776  func _hcnQueryRouteProperties(route hcnRoute, query *uint16, properties **uint16, result **uint16) (hr error) {
   777  	hr = procHcnQuerySdnRouteProperties.Find()
   778  	if hr != nil {
   779  		return
   780  	}
   781  	r0, _, _ := syscall.Syscall6(procHcnQuerySdnRouteProperties.Addr(), 4, uintptr(route), uintptr(unsafe.Pointer(query)), uintptr(unsafe.Pointer(properties)), uintptr(unsafe.Pointer(result)), 0, 0)
   782  	if int32(r0) < 0 {
   783  		if r0&0x1fff0000 == 0x00070000 {
   784  			r0 &= 0xffff
   785  		}
   786  		hr = syscall.Errno(r0)
   787  	}
   788  	return
   789  }
   790  
   791  func SetCurrentThreadCompartmentId(compartmentId uint32) (hr error) {
   792  	r0, _, _ := syscall.Syscall(procSetCurrentThreadCompartmentId.Addr(), 1, uintptr(compartmentId), 0, 0)
   793  	if int32(r0) < 0 {
   794  		if r0&0x1fff0000 == 0x00070000 {
   795  			r0 &= 0xffff
   796  		}
   797  		hr = syscall.Errno(r0)
   798  	}
   799  	return
   800  }
   801  
   802  func _hnsCall(method string, path string, object string, response **uint16) (hr error) {
   803  	var _p0 *uint16
   804  	_p0, hr = syscall.UTF16PtrFromString(method)
   805  	if hr != nil {
   806  		return
   807  	}
   808  	var _p1 *uint16
   809  	_p1, hr = syscall.UTF16PtrFromString(path)
   810  	if hr != nil {
   811  		return
   812  	}
   813  	var _p2 *uint16
   814  	_p2, hr = syscall.UTF16PtrFromString(object)
   815  	if hr != nil {
   816  		return
   817  	}
   818  	return __hnsCall(_p0, _p1, _p2, response)
   819  }
   820  
   821  func __hnsCall(method *uint16, path *uint16, object *uint16, response **uint16) (hr error) {
   822  	hr = procHNSCall.Find()
   823  	if hr != nil {
   824  		return
   825  	}
   826  	r0, _, _ := syscall.Syscall6(procHNSCall.Addr(), 4, uintptr(unsafe.Pointer(method)), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(object)), uintptr(unsafe.Pointer(response)), 0, 0)
   827  	if int32(r0) < 0 {
   828  		if r0&0x1fff0000 == 0x00070000 {
   829  			r0 &= 0xffff
   830  		}
   831  		hr = syscall.Errno(r0)
   832  	}
   833  	return
   834  }
   835  

View as plain text