// NewSandboxModeSetting ...
343752
func NewSandboxModeSetting(enable bool, forwardSpam bool, spamCheck *SpamCheckSetting) *SandboxModeSetting {
	setEnable := enable
	setForwardSpam := forwardSpam
	return &SandboxModeSetting{
		Enable:      &setEnable,
		ForwardSpam: &setForwardSpam,
		SpamCheck:   spamCheck,
	}
}
913470
func (service *VboxPortType) IGuestMultiTouchEventgetYPositions(request *IGuestMultiTouchEventgetYPositions) (*IGuestMultiTouchEventgetYPositionsResponse, error) {
	response := new(IGuestMultiTouchEventgetYPositionsResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
119672
func (ds *dockerService) PodSandboxStatus(ctx context.Context, req *runtimeapi.PodSandboxStatusRequest) (*runtimeapi.PodSandboxStatusResponse, error) {
	podSandboxID := req.PodSandboxId

	r, metadata, err := ds.getPodSandboxDetails(podSandboxID)
	if err != nil {
		return nil, err
	}

	// Parse the timestamps.
	createdAt, _, _, err := getContainerTimestamps(r)
	if err != nil {
		return nil, fmt.Errorf("failed to parse timestamp for container %q: %v", podSandboxID, err)
	}
	ct := createdAt.UnixNano()

	// Translate container to sandbox state.
	state := runtimeapi.PodSandboxState_SANDBOX_NOTREADY
	if r.State.Running {
		state = runtimeapi.PodSandboxState_SANDBOX_READY
	}

	var IP string
	// TODO: Remove this when sandbox is available on windows
	// This is a workaround for windows, where sandbox is not in use, and pod IP is determined through containers belonging to the Pod.
	if IP = ds.determinePodIPBySandboxID(podSandboxID); IP == "" {
		IP = ds.getIP(podSandboxID, r)
	}

	labels, annotations := extractLabels(r.Config.Labels)
	status := &runtimeapi.PodSandboxStatus{
		Id:          r.ID,
		State:       state,
		CreatedAt:   ct,
		Metadata:    metadata,
		Labels:      labels,
		Annotations: annotations,
		Network: &runtimeapi.PodSandboxNetworkStatus{
			Ip: IP,
		},
		Linux: &runtimeapi.LinuxPodSandboxStatus{
			Namespaces: &runtimeapi.Namespace{
				Options: &runtimeapi.NamespaceOption{
					Network: networkNamespaceMode(r),
					Pid:     pidNamespaceMode(r),
					Ipc:     ipcNamespaceMode(r),
				},
			},
		},
	}
	return &runtimeapi.PodSandboxStatusResponse{Status: status}, nil
}
934621
func (service *VboxPortType) IBIOSSettingsgetLogoFadeIn(request *IBIOSSettingsgetLogoFadeIn) (*IBIOSSettingsgetLogoFadeInResponse, error) {
	response := new(IBIOSSettingsgetLogoFadeInResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
723759
func (service *VboxPortType) IGuestgetAdditionsRevision(request *IGuestgetAdditionsRevision) (*IGuestgetAdditionsRevisionResponse, error) {
	response := new(IGuestgetAdditionsRevisionResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
1134781
func (service *VboxPortType) IGuestMouseEventgetButtons(request *IGuestMouseEventgetButtons) (*IGuestMouseEventgetButtonsResponse, error) {
	response := new(IGuestMouseEventgetButtonsResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
485636
func (service *VboxPortType) IBIOSSettingssetTimeOffset(request *IBIOSSettingssetTimeOffset) (*IBIOSSettingssetTimeOffsetResponse, error) {
	response := new(IBIOSSettingssetTimeOffsetResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
1009863
func newSettingsAckSwallowWriter(w *bufio.Writer) *settingsAckSwallowWriter {
	return &settingsAckSwallowWriter{
		Writer:     w,
		buf:        make([]byte, 0),
		didSwallow: false,
	}
}
506196
func (service *VboxPortType) IGuestPropertyChangedEventgetFlags(request *IGuestPropertyChangedEventgetFlags) (*IGuestPropertyChangedEventgetFlagsResponse, error) {
	response := new(IGuestPropertyChangedEventgetFlagsResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
1057604
func (service *VboxPortType) IFsObjInfogetUserFlags(request *IFsObjInfogetUserFlags) (*IFsObjInfogetUserFlagsResponse, error) {
	response := new(IFsObjInfogetUserFlagsResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
465691
func (service *VboxPortType) IMachinediscardSettings(request *IMachinediscardSettings) (*IMachinediscardSettingsResponse, error) {
	response := new(IMachinediscardSettingsResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
773429
func (service *VboxPortType) IProgresssetNextOperation(request *IProgresssetNextOperation) (*IProgresssetNextOperationResponse, error) {
	response := new(IProgresssetNextOperationResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
163067
func (service *VboxPortType) IBIOSSettingssetBootMenuMode(request *IBIOSSettingssetBootMenuMode) (*IBIOSSettingssetBootMenuModeResponse, error) {
	response := new(IBIOSSettingssetBootMenuModeResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
755896
func NewSetMode(CUSTOM_MODE uint32, TARGET_SYSTEM uint8, BASE_MODE uint8) *SetMode {
	m := SetMode{}
	m.CUSTOM_MODE = CUSTOM_MODE
	m.TARGET_SYSTEM = TARGET_SYSTEM
	m.BASE_MODE = BASE_MODE
	return &m
}
31368
func NewSandbox(key string, osCreate, isRestore bool) (Sandbox, error) {
	if !isRestore {
		err := createNetworkNamespace(key, osCreate)
		if err != nil {
			return nil, err
		}
	} else {
		once.Do(createBasePath)
	}

	n := &networkNamespace{path: key, isDefault: !osCreate, nextIfIndex: make(map[string]int)}

	sboxNs, err := netns.GetFromPath(n.path)
	if err != nil {
		return nil, fmt.Errorf("failed get network namespace %q: %v", n.path, err)
	}
	defer sboxNs.Close()

	n.nlHandle, err = netlink.NewHandleAt(sboxNs, syscall.NETLINK_ROUTE)
	if err != nil {
		return nil, fmt.Errorf("failed to create a netlink handle: %v", err)
	}

	err = n.nlHandle.SetSocketTimeout(ns.NetlinkSocketsTimeout)
	if err != nil {
		logrus.Warnf("Failed to set the timeout on the sandbox netlink handle sockets: %v", err)
	}
	// In live-restore mode, IPV6 entries are getting cleaned up due to below code
	// We should retain IPV6 configurations in live-restore mode when Docker Daemon
	// comes back. It should work as it is on other cases
	// As starting point, disable IPv6 on all interfaces
	if !isRestore && !n.isDefault {
		err = setIPv6(n.path, "all", false)
		if err != nil {
			logrus.Warnf("Failed to disable IPv6 on all interfaces on network namespace %q: %v", n.path, err)
		}
	}

	if err = n.loopbackUp(); err != nil {
		n.nlHandle.Delete()
		return nil, err
	}

	return n, nil
}
347334
func (service *VboxPortType) IBIOSSettingsgetLogoFadeOut(request *IBIOSSettingsgetLogoFadeOut) (*IBIOSSettingsgetLogoFadeOutResponse, error) {
	response := new(IBIOSSettingsgetLogoFadeOutResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
845931
func (service *VboxPortType) IMachinesetDragAndDropMode(request *IMachinesetDragAndDropMode) (*IMachinesetDragAndDropModeResponse, error) {
	response := new(IMachinesetDragAndDropModeResponse)
	err := service.client.Call("", request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}