Add openvpn and openconnect

daemon/started_service.go

@@ -2,6 +2,7 @@ package daemon
 
 import (
 	"context"
+	"net/netip"
 	"os"
 	"runtime"
 	runtimeDebug "runtime/debug"
@@ -32,7 +33,7 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
-const APIVersion = 2
+const APIVersion = 3
 
 var _ StartedServiceServer = (*StartedService)(nil)
 
@@ -1197,6 +1198,68 @@ func NewSTUNTestResult(result *stun.Result) *STUNTestProgress {
 	}
 }
 
+func resolveEndpoint[T adapter.Endpoint](instance *Instance, tag string, endpointType string, endpointName string) (T, error) {
+	var zero T
+	endpointManager := service.FromContext[adapter.EndpointManager](instance.ctx)
+	endpoint, loaded := endpointManager.Get(tag)
+	if !loaded {
+		return zero, status.Error(codes.NotFound, "endpoint not found: "+tag)
+	}
+	if endpoint.Type() != endpointType {
+		return zero, status.Error(codes.InvalidArgument, "endpoint is not "+endpointName+": "+tag)
+	}
+	return endpoint.(T), nil
+}
+
+type endpointStatusProvider interface {
+	adapter.Endpoint
+	StatusUpdated() <-chan struct{}
+}
+
+func subscribeEndpointStatus[T endpointStatusProvider](ctx context.Context, endpointManager adapter.EndpointManager, endpointType string, endpointName string, send func([]T) error) error {
+	var endpoints []T
+	for _, endpoint := range endpointManager.Endpoints() {
+		if endpoint.Type() == endpointType {
+			endpoints = append(endpoints, endpoint.(T))
+		}
+	}
+	if len(endpoints) == 0 {
+		return status.Error(codes.NotFound, "no "+endpointName+" endpoint found")
+	}
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	updated := make(chan struct{}, 1)
+	for _, endpoint := range endpoints {
+		go func(provider T) {
+			for {
+				statusUpdated := provider.StatusUpdated()
+				select {
+				case updated <- struct{}{}:
+				default:
+				}
+				select {
+				case <-statusUpdated:
+				case <-ctx.Done():
+					return
+				}
+			}
+		}(endpoint)
+	}
+
+	for {
+		select {
+		case <-updated:
+		case <-ctx.Done():
+			return nil
+		}
+		err := send(endpoints)
+		if err != nil {
+			return err
+		}
+	}
+}
+
 func (s *StartedService) StartNetworkQualityTest(
 	request *NetworkQualityTestRequest,
 	server grpc.ServerStreamingServer[NetworkQualityTestProgress],
@@ -1523,6 +1586,233 @@ func (s *StartedService) TailscaleLogout(ctx context.Context, request *Tailscale
 	return &emptypb.Empty{}, nil
 }
 
+func (s *StartedService) SubscribeOpenConnectStatus(
+	_ *emptypb.Empty,
+	server grpc.ServerStreamingServer[OpenConnectStatusUpdate],
+) error {
+	err := s.waitForStarted(server.Context())
+	if err != nil {
+		return err
+	}
+	s.serviceAccess.RLock()
+	boxService := s.instance
+	s.serviceAccess.RUnlock()
+
+	endpointManager := service.FromContext[adapter.EndpointManager](boxService.ctx)
+	return subscribeEndpointStatus(server.Context(), endpointManager, C.TypeOpenConnect, "OpenConnect client", func(endpoints []adapter.OpenConnectEndpoint) error {
+		return server.Send(&OpenConnectStatusUpdate{
+			Endpoints: common.Map(endpoints, func(endpoint adapter.OpenConnectEndpoint) *OpenConnectEndpointStatus {
+				return openConnectEndpointStatusToProto(endpoint.Tag(), endpoint.OpenConnectStatus())
+			}),
+		})
+	})
+}
+
+func openConnectEndpointStatusToProto(tag string, endpointStatus adapter.OpenConnectStatus) *OpenConnectEndpointStatus {
+	result := &OpenConnectEndpointStatus{
+		EndpointTag: tag,
+		State:       endpointStatus.State,
+		Error:       endpointStatus.Error,
+		TunnelInfo:  openConnectTunnelInfoToProto(endpointStatus.TunnelInfo),
+	}
+	if endpointStatus.AuthForm != nil {
+		fields := common.Map(endpointStatus.AuthForm.Fields, func(field adapter.OpenConnectAuthFormField) *OpenConnectAuthFormField {
+			return &OpenConnectAuthFormField{
+				SubmissionKey: field.SubmissionKey,
+				Name:          field.Name,
+				Label:         field.Label,
+				Kind:          field.Kind,
+				Value:         field.Value,
+				Options: common.Map(field.Options, func(option adapter.OpenConnectAuthFormChoice) *OpenConnectAuthFormChoice {
+					return &OpenConnectAuthFormChoice{
+						Value: option.Value,
+						Label: option.Label,
+					}
+				}),
+			}
+		})
+		result.AuthForm = &OpenConnectAuthForm{
+			Id:      endpointStatus.AuthForm.ID,
+			Banner:  endpointStatus.AuthForm.Banner,
+			Message: endpointStatus.AuthForm.Message,
+			Error:   endpointStatus.AuthForm.Error,
+			Url:     endpointStatus.AuthForm.URL,
+			Fields:  fields,
+		}
+	}
+	return result
+}
+
+func (s *StartedService) SubmitOpenConnectAuthForm(ctx context.Context, request *OpenConnectAuthFormSubmission) (*emptypb.Empty, error) {
+	err := s.waitForStarted(ctx)
+	if err != nil {
+		return nil, err
+	}
+	s.serviceAccess.RLock()
+	boxService := s.instance
+	s.serviceAccess.RUnlock()
+
+	endpoint, err := resolveEndpoint[adapter.OpenConnectEndpoint](boxService, request.EndpointTag, C.TypeOpenConnect, "OpenConnect client")
+	if err != nil {
+		return nil, err
+	}
+	err = endpoint.CompleteAuthForm(request.FormID, request.Values)
+	if err != nil {
+		return nil, err
+	}
+	return &emptypb.Empty{}, nil
+}
+
+func (s *StartedService) CancelOpenConnectAuthForm(ctx context.Context, request *OpenConnectAuthFormCancel) (*emptypb.Empty, error) {
+	err := s.waitForStarted(ctx)
+	if err != nil {
+		return nil, err
+	}
+	s.serviceAccess.RLock()
+	boxService := s.instance
+	s.serviceAccess.RUnlock()
+
+	endpoint, err := resolveEndpoint[adapter.OpenConnectEndpoint](boxService, request.EndpointTag, C.TypeOpenConnect, "OpenConnect client")
+	if err != nil {
+		return nil, err
+	}
+	err = endpoint.CancelAuthForm(request.FormID)
+	if err != nil {
+		return nil, err
+	}
+	return &emptypb.Empty{}, nil
+}
+
+func (s *StartedService) SubscribeOpenVPNStatus(
+	_ *emptypb.Empty,
+	server grpc.ServerStreamingServer[OpenVPNStatusUpdate],
+) error {
+	err := s.waitForStarted(server.Context())
+	if err != nil {
+		return err
+	}
+	s.serviceAccess.RLock()
+	boxService := s.instance
+	s.serviceAccess.RUnlock()
+
+	endpointManager := service.FromContext[adapter.EndpointManager](boxService.ctx)
+	return subscribeEndpointStatus(server.Context(), endpointManager, C.TypeOpenVPNClient, "OpenVPN client", func(endpoints []adapter.OpenVPNEndpoint) error {
+		return server.Send(&OpenVPNStatusUpdate{
+			Endpoints: common.Map(endpoints, func(endpoint adapter.OpenVPNEndpoint) *OpenVPNEndpointStatus {
+				return openVPNEndpointStatusToProto(endpoint.Tag(), endpoint.OpenVPNStatus())
+			}),
+		})
+	})
+}
+
+func openVPNEndpointStatusToProto(tag string, endpointStatus adapter.OpenVPNStatus) *OpenVPNEndpointStatus {
+	result := &OpenVPNEndpointStatus{
+		EndpointTag: tag,
+		State:       endpointStatus.State,
+		Error:       endpointStatus.Error,
+		TunnelInfo:  openVPNTunnelInfoToProto(endpointStatus.TunnelInfo),
+	}
+	if endpointStatus.Challenge != nil {
+		challenge := &OpenVPNChallenge{
+			Id:            endpointStatus.Challenge.ID,
+			Kind:          endpointStatus.Challenge.Kind,
+			Username:      endpointStatus.Challenge.Username,
+			Message:       endpointStatus.Challenge.Message,
+			Url:           endpointStatus.Challenge.URL,
+			SecretMessage: endpointStatus.Challenge.SecretMessage,
+			Echo:          endpointStatus.Challenge.Echo,
+			PreviousError: endpointStatus.Challenge.PreviousError,
+		}
+		if !endpointStatus.Challenge.Deadline.IsZero() {
+			challenge.Deadline = endpointStatus.Challenge.Deadline.Unix()
+		}
+		result.Challenge = challenge
+	}
+	return result
+}
+
+func openConnectTunnelInfoToProto(tunnelInfo *adapter.OpenConnectTunnelInfo) *OpenConnectTunnelInfo {
+	if tunnelInfo == nil {
+		return nil
+	}
+	result := &OpenConnectTunnelInfo{
+		Server:    tunnelInfo.Server,
+		Flavor:    tunnelInfo.Flavor,
+		Transport: tunnelInfo.Transport,
+		Mtu:       tunnelInfo.MTU,
+	}
+	if !tunnelInfo.ConnectedSince.IsZero() {
+		result.ConnectedSince = tunnelInfo.ConnectedSince.Unix()
+	}
+	result.Ipv4 = common.Map(tunnelInfo.IPv4, netip.Prefix.String)
+	result.Ipv6 = common.Map(tunnelInfo.IPv6, netip.Prefix.String)
+	result.Dns = common.Map(tunnelInfo.DNS, netip.Addr.String)
+	return result
+}
+
+func openVPNTunnelInfoToProto(tunnelInfo *adapter.OpenVPNTunnelInfo) *OpenVPNTunnelInfo {
+	if tunnelInfo == nil {
+		return nil
+	}
+	result := &OpenVPNTunnelInfo{
+		Server:  tunnelInfo.Server,
+		Network: tunnelInfo.Network,
+		Cipher:  tunnelInfo.Cipher,
+		Mtu:     tunnelInfo.MTU,
+	}
+	if !tunnelInfo.ConnectedSince.IsZero() {
+		result.ConnectedSince = tunnelInfo.ConnectedSince.Unix()
+	}
+	result.Ipv4 = common.Map(tunnelInfo.IPv4, netip.Prefix.String)
+	result.Ipv6 = common.Map(tunnelInfo.IPv6, netip.Prefix.String)
+	result.Dns = common.Map(tunnelInfo.DNS, netip.Addr.String)
+	return result
+}
+
+func (s *StartedService) SubmitOpenVPNChallengeResponse(ctx context.Context, request *OpenVPNChallengeSubmission) (*emptypb.Empty, error) {
+	err := s.waitForStarted(ctx)
+	if err != nil {
+		return nil, err
+	}
+	s.serviceAccess.RLock()
+	boxService := s.instance
+	s.serviceAccess.RUnlock()
+
+	endpoint, err := resolveEndpoint[adapter.OpenVPNEndpoint](boxService, request.EndpointTag, C.TypeOpenVPNClient, "OpenVPN client")
+	if err != nil {
+		return nil, err
+	}
+	err = endpoint.CompleteChallenge(request.ChallengeID, adapter.OpenVPNChallengeResponse{
+		Username: request.Username,
+		Password: request.Password,
+		Secret:   request.Secret,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &emptypb.Empty{}, nil
+}
+
+func (s *StartedService) CancelOpenVPNChallenge(ctx context.Context, request *OpenVPNChallengeCancel) (*emptypb.Empty, error) {
+	err := s.waitForStarted(ctx)
+	if err != nil {
+		return nil, err
+	}
+	s.serviceAccess.RLock()
+	boxService := s.instance
+	s.serviceAccess.RUnlock()
+
+	endpoint, err := resolveEndpoint[adapter.OpenVPNEndpoint](boxService, request.EndpointTag, C.TypeOpenVPNClient, "OpenVPN client")
+	if err != nil {
+		return nil, err
+	}
+	err = endpoint.CancelChallenge(request.ChallengeID)
+	if err != nil {
+		return nil, err
+	}
+	return &emptypb.Empty{}, nil
+}
+
 func (s *StartedService) mustEmbedUnimplementedStartedServiceServer() {
 }
 

daemon/started_service.proto

@@ -38,6 +38,12 @@ service StartedService {
   rpc StartTailscaleSSHSession(stream TailscaleSSHClientMessage) returns (stream TailscaleSSHServerMessage) {}
   rpc ProvideUSBDevices(stream USBProviderMessage) returns (stream USBServerMessage) {}
   rpc SubscribeUSBIPServerStatus(google.protobuf.Empty) returns (stream USBIPServerStatusUpdate) {}
+  rpc SubscribeOpenConnectStatus(google.protobuf.Empty) returns (stream OpenConnectStatusUpdate) {}
+  rpc SubmitOpenConnectAuthForm(OpenConnectAuthFormSubmission) returns (google.protobuf.Empty) {}
+  rpc CancelOpenConnectAuthForm(OpenConnectAuthFormCancel) returns (google.protobuf.Empty) {}
+  rpc SubscribeOpenVPNStatus(google.protobuf.Empty) returns (stream OpenVPNStatusUpdate) {}
+  rpc SubmitOpenVPNChallengeResponse(OpenVPNChallengeSubmission) returns (google.protobuf.Empty) {}
+  rpc CancelOpenVPNChallenge(OpenVPNChallengeCancel) returns (google.protobuf.Empty) {}
 }
 
 message Version {
@@ -516,3 +522,109 @@ enum USBBackend {
   USB_BACKEND_DARWIN_IOKIT = 3;
   USB_BACKEND_WINDOWS_VBOXUSB = 4;
 }
+
+message OpenConnectStatusUpdate {
+  repeated OpenConnectEndpointStatus endpoints = 1;
+}
+
+message OpenConnectEndpointStatus {
+  string endpointTag = 1;
+  string state = 2;
+  OpenConnectAuthForm authForm = 3;
+  string error = 4;
+  OpenConnectTunnelInfo tunnelInfo = 5;
+}
+
+message OpenConnectTunnelInfo {
+  string server = 1;
+  string flavor = 2;
+  string transport = 3;
+  repeated string ipv4 = 4;
+  repeated string ipv6 = 5;
+  repeated string dns = 6;
+  uint32 mtu = 7;
+  int64 connectedSince = 8;
+}
+
+message OpenConnectAuthForm {
+  string id = 1;
+  string banner = 2;
+  string message = 3;
+  string error = 4;
+  string url = 5;
+  repeated OpenConnectAuthFormField fields = 6;
+}
+
+message OpenConnectAuthFormField {
+  string submissionKey = 1;
+  string name = 2;
+  string label = 3;
+  string kind = 4;
+  string value = 5;
+  repeated OpenConnectAuthFormChoice options = 6;
+}
+
+message OpenConnectAuthFormChoice {
+  string value = 1;
+  string label = 2;
+}
+
+message OpenConnectAuthFormSubmission {
+  string endpointTag = 1;
+  string formID = 2;
+  map<string, string> values = 3;
+}
+
+message OpenConnectAuthFormCancel {
+  string endpointTag = 1;
+  string formID = 2;
+}
+
+message OpenVPNStatusUpdate {
+  repeated OpenVPNEndpointStatus endpoints = 1;
+}
+
+message OpenVPNEndpointStatus {
+  string endpointTag = 1;
+  string state = 2;
+  OpenVPNChallenge challenge = 3;
+  string error = 4;
+  OpenVPNTunnelInfo tunnelInfo = 5;
+}
+
+message OpenVPNTunnelInfo {
+  string server = 1;
+  reserved 2;
+  string network = 3;
+  repeated string ipv4 = 4;
+  repeated string ipv6 = 5;
+  repeated string dns = 6;
+  uint32 mtu = 7;
+  int64 connectedSince = 8;
+  string cipher = 9;
+}
+
+message OpenVPNChallenge {
+  string id = 1;
+  string kind = 2;
+  string username = 3;
+  string message = 4;
+  string url = 5;
+  string secretMessage = 6;
+  bool echo = 7;
+  string previousError = 8;
+  int64 deadline = 9;
+}
+
+message OpenVPNChallengeSubmission {
+  string endpointTag = 1;
+  string challengeID = 2;
+  string username = 3;
+  string password = 4;
+  string secret = 5;
+}
+
+message OpenVPNChallengeCancel {
+  string endpointTag = 1;
+  string challengeID = 2;
+}

daemon/started_service_grpc.pb.go

@@ -15,34 +15,40 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	StartedService_GetVersion_FullMethodName                 = "/daemon.StartedService/GetVersion"
-	StartedService_SubscribeServiceStatus_FullMethodName     = "/daemon.StartedService/SubscribeServiceStatus"
-	StartedService_SubscribeLog_FullMethodName               = "/daemon.StartedService/SubscribeLog"
-	StartedService_GetDefaultLogLevel_FullMethodName         = "/daemon.StartedService/GetDefaultLogLevel"
-	StartedService_ClearLogs_FullMethodName                  = "/daemon.StartedService/ClearLogs"
-	StartedService_SubscribeStatus_FullMethodName            = "/daemon.StartedService/SubscribeStatus"
-	StartedService_SubscribeGroups_FullMethodName            = "/daemon.StartedService/SubscribeGroups"
-	StartedService_GetClashModeStatus_FullMethodName         = "/daemon.StartedService/GetClashModeStatus"
-	StartedService_SubscribeClashMode_FullMethodName         = "/daemon.StartedService/SubscribeClashMode"
-	StartedService_SetClashMode_FullMethodName               = "/daemon.StartedService/SetClashMode"
-	StartedService_URLTest_FullMethodName                    = "/daemon.StartedService/URLTest"
-	StartedService_SelectOutbound_FullMethodName             = "/daemon.StartedService/SelectOutbound"
-	StartedService_SetGroupExpand_FullMethodName             = "/daemon.StartedService/SetGroupExpand"
-	StartedService_SubscribeConnections_FullMethodName       = "/daemon.StartedService/SubscribeConnections"
-	StartedService_CloseConnection_FullMethodName            = "/daemon.StartedService/CloseConnection"
-	StartedService_CloseAllConnections_FullMethodName        = "/daemon.StartedService/CloseAllConnections"
-	StartedService_GetDeprecatedWarnings_FullMethodName      = "/daemon.StartedService/GetDeprecatedWarnings"
-	StartedService_GetStartedAt_FullMethodName               = "/daemon.StartedService/GetStartedAt"
-	StartedService_SubscribeOutbounds_FullMethodName         = "/daemon.StartedService/SubscribeOutbounds"
-	StartedService_StartNetworkQualityTest_FullMethodName    = "/daemon.StartedService/StartNetworkQualityTest"
-	StartedService_StartSTUNTest_FullMethodName              = "/daemon.StartedService/StartSTUNTest"
-	StartedService_SubscribeTailscaleStatus_FullMethodName   = "/daemon.StartedService/SubscribeTailscaleStatus"
-	StartedService_StartTailscalePing_FullMethodName         = "/daemon.StartedService/StartTailscalePing"
-	StartedService_SetTailscaleExitNode_FullMethodName       = "/daemon.StartedService/SetTailscaleExitNode"
-	StartedService_TailscaleLogout_FullMethodName            = "/daemon.StartedService/TailscaleLogout"
-	StartedService_StartTailscaleSSHSession_FullMethodName   = "/daemon.StartedService/StartTailscaleSSHSession"
-	StartedService_ProvideUSBDevices_FullMethodName          = "/daemon.StartedService/ProvideUSBDevices"
-	StartedService_SubscribeUSBIPServerStatus_FullMethodName = "/daemon.StartedService/SubscribeUSBIPServerStatus"
+	StartedService_GetVersion_FullMethodName                     = "/daemon.StartedService/GetVersion"
+	StartedService_SubscribeServiceStatus_FullMethodName         = "/daemon.StartedService/SubscribeServiceStatus"
+	StartedService_SubscribeLog_FullMethodName                   = "/daemon.StartedService/SubscribeLog"
+	StartedService_GetDefaultLogLevel_FullMethodName             = "/daemon.StartedService/GetDefaultLogLevel"
+	StartedService_ClearLogs_FullMethodName                      = "/daemon.StartedService/ClearLogs"
+	StartedService_SubscribeStatus_FullMethodName                = "/daemon.StartedService/SubscribeStatus"
+	StartedService_SubscribeGroups_FullMethodName                = "/daemon.StartedService/SubscribeGroups"
+	StartedService_GetClashModeStatus_FullMethodName             = "/daemon.StartedService/GetClashModeStatus"
+	StartedService_SubscribeClashMode_FullMethodName             = "/daemon.StartedService/SubscribeClashMode"
+	StartedService_SetClashMode_FullMethodName                   = "/daemon.StartedService/SetClashMode"
+	StartedService_URLTest_FullMethodName                        = "/daemon.StartedService/URLTest"
+	StartedService_SelectOutbound_FullMethodName                 = "/daemon.StartedService/SelectOutbound"
+	StartedService_SetGroupExpand_FullMethodName                 = "/daemon.StartedService/SetGroupExpand"
+	StartedService_SubscribeConnections_FullMethodName           = "/daemon.StartedService/SubscribeConnections"
+	StartedService_CloseConnection_FullMethodName                = "/daemon.StartedService/CloseConnection"
+	StartedService_CloseAllConnections_FullMethodName            = "/daemon.StartedService/CloseAllConnections"
+	StartedService_GetDeprecatedWarnings_FullMethodName          = "/daemon.StartedService/GetDeprecatedWarnings"
+	StartedService_GetStartedAt_FullMethodName                   = "/daemon.StartedService/GetStartedAt"
+	StartedService_SubscribeOutbounds_FullMethodName             = "/daemon.StartedService/SubscribeOutbounds"
+	StartedService_StartNetworkQualityTest_FullMethodName        = "/daemon.StartedService/StartNetworkQualityTest"
+	StartedService_StartSTUNTest_FullMethodName                  = "/daemon.StartedService/StartSTUNTest"
+	StartedService_SubscribeTailscaleStatus_FullMethodName       = "/daemon.StartedService/SubscribeTailscaleStatus"
+	StartedService_StartTailscalePing_FullMethodName             = "/daemon.StartedService/StartTailscalePing"
+	StartedService_SetTailscaleExitNode_FullMethodName           = "/daemon.StartedService/SetTailscaleExitNode"
+	StartedService_TailscaleLogout_FullMethodName                = "/daemon.StartedService/TailscaleLogout"
+	StartedService_StartTailscaleSSHSession_FullMethodName       = "/daemon.StartedService/StartTailscaleSSHSession"
+	StartedService_ProvideUSBDevices_FullMethodName              = "/daemon.StartedService/ProvideUSBDevices"
+	StartedService_SubscribeUSBIPServerStatus_FullMethodName     = "/daemon.StartedService/SubscribeUSBIPServerStatus"
+	StartedService_SubscribeOpenConnectStatus_FullMethodName     = "/daemon.StartedService/SubscribeOpenConnectStatus"
+	StartedService_SubmitOpenConnectAuthForm_FullMethodName      = "/daemon.StartedService/SubmitOpenConnectAuthForm"
+	StartedService_CancelOpenConnectAuthForm_FullMethodName      = "/daemon.StartedService/CancelOpenConnectAuthForm"
+	StartedService_SubscribeOpenVPNStatus_FullMethodName         = "/daemon.StartedService/SubscribeOpenVPNStatus"
+	StartedService_SubmitOpenVPNChallengeResponse_FullMethodName = "/daemon.StartedService/SubmitOpenVPNChallengeResponse"
+	StartedService_CancelOpenVPNChallenge_FullMethodName         = "/daemon.StartedService/CancelOpenVPNChallenge"
 )
 
 // StartedServiceClient is the client API for StartedService service.
@@ -77,6 +83,12 @@ type StartedServiceClient interface {
 	StartTailscaleSSHSession(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[TailscaleSSHClientMessage, TailscaleSSHServerMessage], error)
 	ProvideUSBDevices(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[USBProviderMessage, USBServerMessage], error)
 	SubscribeUSBIPServerStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[USBIPServerStatusUpdate], error)
+	SubscribeOpenConnectStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[OpenConnectStatusUpdate], error)
+	SubmitOpenConnectAuthForm(ctx context.Context, in *OpenConnectAuthFormSubmission, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	CancelOpenConnectAuthForm(ctx context.Context, in *OpenConnectAuthFormCancel, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	SubscribeOpenVPNStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[OpenVPNStatusUpdate], error)
+	SubmitOpenVPNChallengeResponse(ctx context.Context, in *OpenVPNChallengeSubmission, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	CancelOpenVPNChallenge(ctx context.Context, in *OpenVPNChallengeCancel, opts ...grpc.CallOption) (*emptypb.Empty, error)
 }
 
 type startedServiceClient struct {
@@ -481,6 +493,84 @@ func (c *startedServiceClient) SubscribeUSBIPServerStatus(ctx context.Context, i
 // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
 type StartedService_SubscribeUSBIPServerStatusClient = grpc.ServerStreamingClient[USBIPServerStatusUpdate]
 
+func (c *startedServiceClient) SubscribeOpenConnectStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[OpenConnectStatusUpdate], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &StartedService_ServiceDesc.Streams[14], StartedService_SubscribeOpenConnectStatus_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[emptypb.Empty, OpenConnectStatusUpdate]{ClientStream: stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type StartedService_SubscribeOpenConnectStatusClient = grpc.ServerStreamingClient[OpenConnectStatusUpdate]
+
+func (c *startedServiceClient) SubmitOpenConnectAuthForm(ctx context.Context, in *OpenConnectAuthFormSubmission, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, StartedService_SubmitOpenConnectAuthForm_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *startedServiceClient) CancelOpenConnectAuthForm(ctx context.Context, in *OpenConnectAuthFormCancel, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, StartedService_CancelOpenConnectAuthForm_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *startedServiceClient) SubscribeOpenVPNStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[OpenVPNStatusUpdate], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &StartedService_ServiceDesc.Streams[15], StartedService_SubscribeOpenVPNStatus_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[emptypb.Empty, OpenVPNStatusUpdate]{ClientStream: stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type StartedService_SubscribeOpenVPNStatusClient = grpc.ServerStreamingClient[OpenVPNStatusUpdate]
+
+func (c *startedServiceClient) SubmitOpenVPNChallengeResponse(ctx context.Context, in *OpenVPNChallengeSubmission, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, StartedService_SubmitOpenVPNChallengeResponse_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *startedServiceClient) CancelOpenVPNChallenge(ctx context.Context, in *OpenVPNChallengeCancel, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, StartedService_CancelOpenVPNChallenge_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // StartedServiceServer is the server API for StartedService service.
 // All implementations must embed UnimplementedStartedServiceServer
 // for forward compatibility.
@@ -513,6 +603,12 @@ type StartedServiceServer interface {
 	StartTailscaleSSHSession(grpc.BidiStreamingServer[TailscaleSSHClientMessage, TailscaleSSHServerMessage]) error
 	ProvideUSBDevices(grpc.BidiStreamingServer[USBProviderMessage, USBServerMessage]) error
 	SubscribeUSBIPServerStatus(*emptypb.Empty, grpc.ServerStreamingServer[USBIPServerStatusUpdate]) error
+	SubscribeOpenConnectStatus(*emptypb.Empty, grpc.ServerStreamingServer[OpenConnectStatusUpdate]) error
+	SubmitOpenConnectAuthForm(context.Context, *OpenConnectAuthFormSubmission) (*emptypb.Empty, error)
+	CancelOpenConnectAuthForm(context.Context, *OpenConnectAuthFormCancel) (*emptypb.Empty, error)
+	SubscribeOpenVPNStatus(*emptypb.Empty, grpc.ServerStreamingServer[OpenVPNStatusUpdate]) error
+	SubmitOpenVPNChallengeResponse(context.Context, *OpenVPNChallengeSubmission) (*emptypb.Empty, error)
+	CancelOpenVPNChallenge(context.Context, *OpenVPNChallengeCancel) (*emptypb.Empty, error)
 	mustEmbedUnimplementedStartedServiceServer()
 }
 
@@ -634,6 +730,30 @@ func (UnimplementedStartedServiceServer) ProvideUSBDevices(grpc.BidiStreamingSer
 func (UnimplementedStartedServiceServer) SubscribeUSBIPServerStatus(*emptypb.Empty, grpc.ServerStreamingServer[USBIPServerStatusUpdate]) error {
 	return status.Error(codes.Unimplemented, "method SubscribeUSBIPServerStatus not implemented")
 }
+
+func (UnimplementedStartedServiceServer) SubscribeOpenConnectStatus(*emptypb.Empty, grpc.ServerStreamingServer[OpenConnectStatusUpdate]) error {
+	return status.Error(codes.Unimplemented, "method SubscribeOpenConnectStatus not implemented")
+}
+
+func (UnimplementedStartedServiceServer) SubmitOpenConnectAuthForm(context.Context, *OpenConnectAuthFormSubmission) (*emptypb.Empty, error) {
+	return nil, status.Error(codes.Unimplemented, "method SubmitOpenConnectAuthForm not implemented")
+}
+
+func (UnimplementedStartedServiceServer) CancelOpenConnectAuthForm(context.Context, *OpenConnectAuthFormCancel) (*emptypb.Empty, error) {
+	return nil, status.Error(codes.Unimplemented, "method CancelOpenConnectAuthForm not implemented")
+}
+
+func (UnimplementedStartedServiceServer) SubscribeOpenVPNStatus(*emptypb.Empty, grpc.ServerStreamingServer[OpenVPNStatusUpdate]) error {
+	return status.Error(codes.Unimplemented, "method SubscribeOpenVPNStatus not implemented")
+}
+
+func (UnimplementedStartedServiceServer) SubmitOpenVPNChallengeResponse(context.Context, *OpenVPNChallengeSubmission) (*emptypb.Empty, error) {
+	return nil, status.Error(codes.Unimplemented, "method SubmitOpenVPNChallengeResponse not implemented")
+}
+
+func (UnimplementedStartedServiceServer) CancelOpenVPNChallenge(context.Context, *OpenVPNChallengeCancel) (*emptypb.Empty, error) {
+	return nil, status.Error(codes.Unimplemented, "method CancelOpenVPNChallenge not implemented")
+}
 func (UnimplementedStartedServiceServer) mustEmbedUnimplementedStartedServiceServer() {}
 func (UnimplementedStartedServiceServer) testEmbeddedByValue()                        {}
 
@@ -1053,6 +1173,100 @@ func _StartedService_SubscribeUSBIPServerStatus_Handler(srv interface{}, stream
 // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
 type StartedService_SubscribeUSBIPServerStatusServer = grpc.ServerStreamingServer[USBIPServerStatusUpdate]
 
+func _StartedService_SubscribeOpenConnectStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(emptypb.Empty)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(StartedServiceServer).SubscribeOpenConnectStatus(m, &grpc.GenericServerStream[emptypb.Empty, OpenConnectStatusUpdate]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type StartedService_SubscribeOpenConnectStatusServer = grpc.ServerStreamingServer[OpenConnectStatusUpdate]
+
+func _StartedService_SubmitOpenConnectAuthForm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(OpenConnectAuthFormSubmission)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StartedServiceServer).SubmitOpenConnectAuthForm(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: StartedService_SubmitOpenConnectAuthForm_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StartedServiceServer).SubmitOpenConnectAuthForm(ctx, req.(*OpenConnectAuthFormSubmission))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StartedService_CancelOpenConnectAuthForm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(OpenConnectAuthFormCancel)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StartedServiceServer).CancelOpenConnectAuthForm(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: StartedService_CancelOpenConnectAuthForm_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StartedServiceServer).CancelOpenConnectAuthForm(ctx, req.(*OpenConnectAuthFormCancel))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StartedService_SubscribeOpenVPNStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(emptypb.Empty)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(StartedServiceServer).SubscribeOpenVPNStatus(m, &grpc.GenericServerStream[emptypb.Empty, OpenVPNStatusUpdate]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type StartedService_SubscribeOpenVPNStatusServer = grpc.ServerStreamingServer[OpenVPNStatusUpdate]
+
+func _StartedService_SubmitOpenVPNChallengeResponse_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(OpenVPNChallengeSubmission)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StartedServiceServer).SubmitOpenVPNChallengeResponse(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: StartedService_SubmitOpenVPNChallengeResponse_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StartedServiceServer).SubmitOpenVPNChallengeResponse(ctx, req.(*OpenVPNChallengeSubmission))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StartedService_CancelOpenVPNChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(OpenVPNChallengeCancel)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StartedServiceServer).CancelOpenVPNChallenge(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: StartedService_CancelOpenVPNChallenge_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StartedServiceServer).CancelOpenVPNChallenge(ctx, req.(*OpenVPNChallengeCancel))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // StartedService_ServiceDesc is the grpc.ServiceDesc for StartedService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -1116,6 +1330,22 @@ var StartedService_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "TailscaleLogout",
 			Handler:    _StartedService_TailscaleLogout_Handler,
 		},
+		{
+			MethodName: "SubmitOpenConnectAuthForm",
+			Handler:    _StartedService_SubmitOpenConnectAuthForm_Handler,
+		},
+		{
+			MethodName: "CancelOpenConnectAuthForm",
+			Handler:    _StartedService_CancelOpenConnectAuthForm_Handler,
+		},
+		{
+			MethodName: "SubmitOpenVPNChallengeResponse",
+			Handler:    _StartedService_SubmitOpenVPNChallengeResponse_Handler,
+		},
+		{
+			MethodName: "CancelOpenVPNChallenge",
+			Handler:    _StartedService_CancelOpenVPNChallenge_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1190,6 +1420,16 @@ var StartedService_ServiceDesc = grpc.ServiceDesc{
 			Handler:       _StartedService_SubscribeUSBIPServerStatus_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "SubscribeOpenConnectStatus",
+			Handler:       _StartedService_SubscribeOpenConnectStatus_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "SubscribeOpenVPNStatus",
+			Handler:       _StartedService_SubscribeOpenVPNStatus_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "daemon/started_service.proto",
 }