Implement an FFI to fetch API IP addresses using mullvad-api

ios/MullvadMockData/MullvadREST/APIProxy+Stubs.swift

@@ -12,6 +12,13 @@ import MullvadTypes
 import WireGuardKitTypes
 
 struct APIProxyStub: APIQuerying {
+    func mullvadApiGetAddressList(
+        retryStrategy: REST.RetryStrategy,
+        completionHandler: @escaping ProxyCompletionHandler<[AnyIPEndpoint]>
+    ) -> Cancellable {
+        AnyCancellable()
+    }
+
     func getAddressList(
         retryStrategy: REST.RetryStrategy,
         completionHandler: @escaping ProxyCompletionHandler<[AnyIPEndpoint]>

ios/MullvadMockData/MullvadREST/MockProxyFactory.swift

@@ -8,6 +8,7 @@
 
 import Foundation
 import MullvadREST
+import MullvadRustRuntime
 import MullvadTypes
 import WireGuardKitTypes
 
@@ -28,11 +29,13 @@ public struct MockProxyFactory: ProxyFactoryProtocol {
 
     public static func makeProxyFactory(
         transportProvider: any RESTTransportProvider,
-        addressCache: REST.AddressCache
+        addressCache: REST.AddressCache,
+        apiContext: MullvadApiContext
     ) -> any ProxyFactoryProtocol {
         let basicConfiguration = REST.ProxyConfiguration(
             transportProvider: transportProvider,
-            addressCacheStore: addressCache
+            addressCacheStore: addressCache,
+            apiContext: apiContext
         )
 
         let authenticationProxy = REST.AuthenticationProxy(
@@ -44,7 +47,8 @@ public struct MockProxyFactory: ProxyFactoryProtocol {
 
         let authConfiguration = REST.AuthProxyConfiguration(
             proxyConfiguration: basicConfiguration,
-            accessTokenManager: accessTokenManager
+            accessTokenManager: accessTokenManager,
+            apiContext: apiContext
         )
 
         return MockProxyFactory(configuration: authConfiguration)

ios/MullvadREST/ApiHandlers/MullvadApiRequestFactory.swift

@@ -0,0 +1,37 @@
+//
+//  MullvadApiRequestFactory.swift
+//  MullvadVPN
+//
+//  Created by Jon Petersson on 2025-02-07.
+//  Copyright © 2025 Mullvad VPN AB. All rights reserved.
+//
+
+import MullvadRustRuntime
+import MullvadTypes
+
+enum MullvadApiRequest {
+    case getAddressList
+}
+
+struct MullvadApiRequestFactory {
+    let apiContext: MullvadApiContext
+
+    func makeRequest(_ request: MullvadApiRequest) -> REST.MullvadApiRequestHandler  {
+        { completion in
+            let pointerClass = MullvadApiCompletion { apiResponse in
+                try? completion?(apiResponse)
+            }
+
+            let rawPointer = Unmanaged.passRetained(pointerClass).toOpaque()
+
+            return switch request {
+            case .getAddressList:
+                MullvadApiCancellable(handle: mullvad_api_get_addresses(apiContext.context, rawPointer))
+            }
+        }
+    }
+}
+
+extension REST {
+    typealias MullvadApiRequestHandler = (((MullvadApiResponse) throws -> Void)?) -> MullvadApiCancellable
+}

ios/MullvadREST/ApiHandlers/RESTAPIProxy.swift

@@ -7,10 +7,17 @@
 //
 
 import Foundation
+import MullvadRustRuntime
 import MullvadTypes
+import Operations
 import WireGuardKitTypes
 
 public protocol APIQuerying: Sendable {
+    func mullvadApiGetAddressList(
+        retryStrategy: REST.RetryStrategy,
+        completionHandler: @escaping @Sendable ProxyCompletionHandler<[AnyIPEndpoint]>
+    ) -> Cancellable
+
     func getAddressList(
         retryStrategy: REST.RetryStrategy,
         completionHandler: @escaping @Sendable ProxyCompletionHandler<[AnyIPEndpoint]>
@@ -55,6 +62,32 @@ extension REST {
             )
         }
 
+        public func mullvadApiGetAddressList(
+            retryStrategy: REST.RetryStrategy,
+            completionHandler: @escaping @Sendable ProxyCompletionHandler<[AnyIPEndpoint]>
+        ) -> Cancellable {
+            let requestHandler = mullvadApiRequestFactory.makeRequest(.getAddressList)
+
+            let responseHandler = rustResponseHandler(
+                decoding: [AnyIPEndpoint].self,
+                with: responseDecoder
+            )
+
+            let networkOperation = MullvadApiNetworkOperation(
+                name: "get-api-addrs",
+                dispatchQueue: dispatchQueue,
+                retryStrategy: retryStrategy,
+                requestHandler: requestHandler,
+                responseDecoder: responseDecoder,
+                responseHandler: responseHandler,
+                completionHandler: completionHandler
+            )
+
+            operationQueue.addOperation(networkOperation)
+
+            return networkOperation
+        }
+
         public func getAddressList(
             retryStrategy: REST.RetryStrategy,
             completionHandler: @escaping @Sendable ProxyCompletionHandler<[AnyIPEndpoint]>

ios/MullvadREST/ApiHandlers/RESTDefaults.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import MullvadRustRuntime
 import MullvadTypes
 
 // swiftlint:disable force_cast
@@ -28,6 +29,13 @@ extension REST {
 
     /// Default network timeout for API requests.
     public static let defaultAPINetworkTimeout: Duration = .seconds(10)
+
+    /// API context used for API requests via Rust runtime.
+    // swiftlint:disable:next force_try
+    public static let apiContext = try! MullvadApiContext(
+        host: defaultAPIHostname,
+        address: defaultAPIEndpoint.description
+    )
 }
 
 // swiftlint:enable force_cast

ios/MullvadREST/ApiHandlers/RESTProxy.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import MullvadRustRuntime
 import MullvadTypes
 import Operations
 
@@ -26,6 +27,8 @@ extension REST {
         /// URL request factory.
         let requestFactory: REST.RequestFactory
 
+        let mullvadApiRequestFactory: MullvadApiRequestFactory
+
         /// URL response decoder.
         let responseDecoder: JSONDecoder
 
@@ -40,6 +43,7 @@ extension REST {
 
             self.configuration = configuration
             self.requestFactory = requestFactory
+            self.mullvadApiRequestFactory = MullvadApiRequestFactory(apiContext: configuration.apiContext)
             self.responseDecoder = responseDecoder
         }
 
@@ -132,13 +136,16 @@ extension REST {
     public class ProxyConfiguration: @unchecked Sendable {
         public let transportProvider: RESTTransportProvider
         public let addressCacheStore: AddressCache
+        public let apiContext: MullvadApiContext
 
         public init(
             transportProvider: RESTTransportProvider,
-            addressCacheStore: AddressCache
+            addressCacheStore: AddressCache,
+            apiContext: MullvadApiContext
         ) {
             self.transportProvider = transportProvider
             self.addressCacheStore = addressCacheStore
+            self.apiContext = apiContext
         }
     }
 
@@ -147,13 +154,15 @@ extension REST {
 
         public init(
             proxyConfiguration: ProxyConfiguration,
-            accessTokenManager: RESTAccessTokenManagement
+            accessTokenManager: RESTAccessTokenManagement,
+            apiContext: MullvadApiContext
         ) {
             self.accessTokenManager = accessTokenManager
 
             super.init(
                 transportProvider: proxyConfiguration.transportProvider,
-                addressCacheStore: proxyConfiguration.addressCacheStore
+                addressCacheStore: proxyConfiguration.addressCacheStore,
+                apiContext: apiContext
             )
         }
     }

ios/MullvadREST/ApiHandlers/RESTProxyFactory.swift

@@ -7,6 +7,8 @@
 //
 
 import Foundation
+import MullvadRustRuntime
+
 public protocol ProxyFactoryProtocol {
     var configuration: REST.AuthProxyConfiguration { get }
 
@@ -16,7 +18,8 @@ public protocol ProxyFactoryProtocol {
 
     static func makeProxyFactory(
         transportProvider: RESTTransportProvider,
-        addressCache: REST.AddressCache
+        addressCache: REST.AddressCache,
+        apiContext: MullvadApiContext
     ) -> ProxyFactoryProtocol
 }
 
@@ -26,11 +29,13 @@ extension REST {
 
         public static func makeProxyFactory(
             transportProvider: any RESTTransportProvider,
-            addressCache: REST.AddressCache
+            addressCache: REST.AddressCache,
+            apiContext: MullvadApiContext
         ) -> any ProxyFactoryProtocol {
             let basicConfiguration = REST.ProxyConfiguration(
                 transportProvider: transportProvider,
-                addressCacheStore: addressCache
+                addressCacheStore: addressCache,
+                apiContext: apiContext
             )
 
             let authenticationProxy = REST.AuthenticationProxy(
@@ -42,7 +47,8 @@ extension REST {
 
             let authConfiguration = REST.AuthProxyConfiguration(
                 proxyConfiguration: basicConfiguration,
-                accessTokenManager: accessTokenManager
+                accessTokenManager: accessTokenManager,
+                apiContext: apiContext
             )
 
             return ProxyFactory(configuration: authConfiguration)

ios/MullvadREST/ApiHandlers/RESTResponseHandler.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import MullvadRustRuntime
 import MullvadTypes
 
 protocol RESTResponseHandler<Success> {
@@ -15,7 +16,14 @@ protocol RESTResponseHandler<Success> {
     func handleURLResponse(_ response: HTTPURLResponse, data: Data) -> REST.ResponseHandlerResult<Success>
 }
 
+protocol RESTRustResponseHandler<Success> {
+    associatedtype Success
+
+    func handleResponse(_ response: MullvadApiResponse) -> REST.ResponseHandlerResult<Success>
+}
+
 extension REST {
+    // TODO: We could probably remove the `decoding` case when network requests are fully merged to Mullvad API.
     /// Responser handler result type.
     enum ResponseHandlerResult<Success> {
         /// Response handler succeeded and produced a value.
@@ -66,4 +74,53 @@ extension REST {
             }
         }
     }
+
+    final class RustResponseHandler<Success>: RESTRustResponseHandler {
+        typealias HandlerBlock = (MullvadApiResponse) -> REST.ResponseHandlerResult<Success>
+
+        private let handlerBlock: HandlerBlock
+
+        init(_ block: @escaping HandlerBlock) {
+            handlerBlock = block
+        }
+
+        func handleResponse(_ response: MullvadApiResponse) -> REST.ResponseHandlerResult<Success> {
+            handlerBlock(response)
+        }
+    }
+
+    /// Returns default response handler that parses JSON response into the
+    /// given `Decodable` type if possible, otherwise attempts to decode
+    /// the server error.
+    static func rustResponseHandler<T: Decodable>(
+        decoding type: T.Type,
+        with decoder: JSONDecoder
+    ) -> RustResponseHandler<T> {
+        RustResponseHandler { response in
+            guard let body = response.body else {
+                return .unhandledResponse(nil)
+            }
+
+            do {
+                let decoded = try decoder.decode(type, from: body)
+                return .decoding { decoded }
+            } catch {
+                return .unhandledResponse(
+                    try? decoder.decode(
+                        ServerErrorResponse.self,
+                        from: body
+                    )
+                )
+            }
+        }
+    }
+
+    /// Returns default response handler that parses JSON response into the
+    /// given `Decodable` type if possible, otherwise attempts to decode
+    /// the server error.
+    static func rustEmptyResponseHandler() -> RustResponseHandler<Void> {
+        RustResponseHandler { _ in
+            .success(())
+        }
+    }
 }