@devicelab/maestro-runner-darwin-arm64 1.1.25 → 1.1.28

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBTCPSocket.h

@@ -6,39 +6,65 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#import "GCDAsyncSocket.h"
+@import Foundation;
+// A textual import, not `@import Network;` - older Xcode/watchOS SDK combinations (verified:
+// Xcode 15.4/watchOS 10.5) fail to expose nw_listener_t/nw_connection_t and friends through the
+// Network module map on watchOS, even though the underlying API has existed since watchOS 5.0.
+// Kept unconditional (rather than gated to watchOS) since it also builds cleanly on iOS/tvOS.
+#import <Network/Network.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-@protocol FBTCPSocketDelegate
+// Backed by Network.framework rather than BSD sockets on every platform, since watchOS forbids
+// BSD sockets outright and there is no reason to keep a second, socket-based implementation
+// around just for iOS/tvOS.
+@protocol FBTCPSocketDelegate <NSObject>
 
 /**
  The callback which is fired on new TCP client connection
 
- @param newClient The newly connected socket
+ @param newClient The newly connected client
  */
-- (void)didClientConnect:(GCDAsyncSocket *)newClient;
+- (void)didClientConnect:(nw_connection_t)newClient;
 
 /**
- The callback which is fired when the TCP server receives a data from a connected client
+ The callback which is fired when the TCP server receives data from a connected client
 
  @param client The client, which sent the data
+ @param data The received data
 */
-- (void)didClientSendData:(GCDAsyncSocket *)client;
+- (void)client:(nw_connection_t)client didReceiveData:(NSData *)data;
 
 /**
  The callback which is fired when TCP client disconnects
 
- @param client The actual diconnected client
+ @param client The actual disconnected client
  */
-- (void)didClientDisconnect:(GCDAsyncSocket *)client;
+- (void)didClientDisconnect:(nw_connection_t)client;
 
 @end
 
 
 @interface FBTCPSocket : NSObject
 
-@property (nullable, nonatomic) id<FBTCPSocketDelegate> delegate;
+#if __has_feature(objc_arc_weak)
+@property (nullable, nonatomic, weak) id<FBTCPSocketDelegate> delegate;
+#else
+@property (nullable, nonatomic, assign) id<FBTCPSocketDelegate> delegate;
+#endif
+
+/**
+ The port this socket is listening on. Equal to the port passed to -initWithPort: unless that was
+ 0 ("let the system assign a port"), in which case this reflects the actually assigned port once
+ -startWithError: has returned successfully.
+ */
+@property (nonatomic, readonly) uint16_t port;
+
+/**
+ The local IP address to bind the listener to, or nil to listen on all interfaces. Must be set
+ before -startWithError: is called.
+ */
+@property (nonatomic, copy, nullable) NSString *interface;
 
 /**
  Creates TCP socket isntance which is going to be started on the specified port
@@ -60,6 +86,28 @@ NS_ASSUME_NONNULL_BEGIN
  Stops the socket if it is running
  */
 - (void)stop;
+
+/**
+ Writes data to the given connected client
+
+ @param data The data to send
+ @param client The destination client, as received via -didClientConnect: or -client:didReceiveData:
+ */
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client;
+
+/**
+ Like -writeData:toClient:, but invokes completion once the send actually goes out. Use this
+ before cancelling the connection - nw_connection_send is async, so cancelling right away can
+ drop the write before it's sent.
+
+ @param data The data to send
+ @param client The destination client
+ @param completion Called once the send attempt finishes. `didSucceed` is NO if the send failed
+        (e.g. the peer went away mid-write), in which case nothing was delivered and the caller
+        must not treat the connection as usable.
+ */
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client completion:(nullable void (^)(BOOL didSucceed))completion;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBTCPSocket.m

@@ -8,17 +8,10 @@
 
 #import "FBTCPSocket.h"
 
-
 @interface FBTCPSocket()
 @property (readonly, nonatomic) dispatch_queue_t socketQueue;
-@property (readonly, nonatomic) GCDAsyncSocket *listeningSocket;
-@property (readonly, nonatomic) NSMutableArray *connectedClients;
-@property (readonly, nonatomic) uint16_t port;
-@end
-
-
-@interface FBTCPSocket(AsyncSocket) <GCDAsyncSocketDelegate>
-
+@property (nullable, nonatomic) nw_listener_t listener;
+@property (readonly, nonatomic) NSMutableArray<nw_connection_t> *connectedClients;
 @end
 
 
@@ -28,7 +21,6 @@
 {
   if ((self = [super init])) {
     _socketQueue = dispatch_queue_create("socketQueue", NULL);
-    _listeningSocket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:_socketQueue];
     _connectedClients = [[NSMutableArray alloc] initWithCapacity:1];
     _port = port;
     _delegate = nil;
@@ -38,48 +30,206 @@
 
 - (BOOL)startWithError:(NSError **)error
 {
-  if (![self.listeningSocket acceptOnPort:self.port error:error]) {
-    return NO;;
+  nw_parameters_t parameters = nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL,
+                                                                NW_PARAMETERS_DEFAULT_CONFIGURATION);
+  NSString *portString = [NSString stringWithFormat:@"%u", (unsigned int)self.port];
+  // portString is always valid UTF8; -UTF8String is just declared nullable in general.
+  const char * _Nonnull portCString = (const char * _Nonnull)portString.UTF8String;
+
+  nw_listener_t listener;
+  if (nil != self.interface) {
+    const char * _Nonnull interfaceCString = (const char * _Nonnull)((NSString * _Nonnull)self.interface).UTF8String;
+    nw_endpoint_t localEndpoint = nw_endpoint_create_host(interfaceCString, portCString);
+    nw_parameters_set_local_endpoint(parameters, localEndpoint);
+    // The port is already encoded in localEndpoint above - do not also pass it to
+    // nw_listener_create_with_port, which would be ambiguous.
+    listener = nw_listener_create(parameters);
+  } else {
+    listener = nw_listener_create_with_port(portCString, parameters);
+  }
+  if (nil == listener) {
+    if (error) {
+      *error = [NSError errorWithDomain:@"FBTCPSocket"
+                                    code:1
+                                userInfo:@{NSLocalizedDescriptionKey: @"Failed to create the TCP listener"}];
+    }
+    return NO;
+  }
+  self.listener = listener;
+
+  __weak typeof(self) weakSelf = self;
+  nw_listener_set_queue(listener, self.socketQueue);
+  nw_listener_set_new_connection_handler(listener, ^(nw_connection_t connection) {
+    [weakSelf acceptConnection:connection];
+  });
+
+  dispatch_semaphore_t startupSemaphore = dispatch_semaphore_create(0);
+  __block NSError *startupError = nil;
+  nw_listener_set_state_changed_handler(listener, ^(nw_listener_state_t state, nw_error_t nwError) {
+    // if/else, not switch: -Wswitch-enum, -Wswitch-default, and -Wcovered-switch-default can't
+    // all be satisfied by one switch statement at once.
+    if (nw_listener_state_ready == state) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      if (strongSelf) {
+        strongSelf->_port = nw_listener_get_port(listener);
+      }
+      dispatch_semaphore_signal(startupSemaphore);
+    } else if (nw_listener_state_failed == state || nw_listener_state_cancelled == state) {
+      // NSLocalizedDescriptionKey must be a string, not the underlying NSError itself, or
+      // -[NSError localizedDescription] crashes trying to treat it as one.
+      NSError *underlyingError = nwError ? (NSError *)CFBridgingRelease(nw_error_copy_cf_error(nwError)) : nil;
+      if ([underlyingError.domain isEqualToString:NSPOSIXErrorDomain]) {
+        // Surface POSIX errors (e.g. EADDRINUSE) directly, since callers like FBWebServer check
+        // for them by domain/code on the top-level error to decide whether to retry another port.
+        startupError = underlyingError;
+      } else {
+        NSMutableDictionary<NSString *, id> *userInfo = [NSMutableDictionary dictionary];
+        userInfo[NSLocalizedDescriptionKey] = underlyingError.localizedDescription ?: @"The TCP listener failed to start";
+        if (underlyingError) {
+          userInfo[NSUnderlyingErrorKey] = underlyingError;
+        }
+        startupError = [NSError errorWithDomain:@"FBTCPSocket" code:2 userInfo:userInfo];
+      }
+      dispatch_semaphore_signal(startupSemaphore);
+    }
+  });
+  nw_listener_start(listener);
+  BOOL didStartInTime = 0 == dispatch_semaphore_wait(startupSemaphore, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)));
+  if (!didStartInTime) {
+    startupError = [NSError errorWithDomain:@"FBTCPSocket"
+                                        code:3
+                                    userInfo:@{NSLocalizedDescriptionKey: @"Timed out while starting the TCP listener"}];
+  }
+  if (nil != startupError) {
+    if (error) {
+      *error = startupError;
+    }
+    // Cancel rather than just dropping our reference - otherwise a late ready/failed callback
+    // can still fire and the port stays bound at the OS level even though the caller was told
+    // startup failed.
+    nw_listener_cancel(listener);
+    self.listener = nil;
+    return NO;
   }
-
   return YES;
 }
 
-- (void)stop
+- (void)acceptConnection:(nw_connection_t)connection
 {
-  @synchronized(self.connectedClients) {
-    for (NSUInteger i = 0; i < [self.connectedClients count]; i++) {
-      [[self.connectedClients objectAtIndex:i] disconnect];
-    }
+  @synchronized (self.connectedClients) {
+    [self.connectedClients addObject:connection];
   }
 
-  [self.listeningSocket disconnect];
+  __weak typeof(self) weakSelf = self;
+  nw_connection_set_queue(connection, self.socketQueue);
+  nw_connection_set_state_changed_handler(connection, ^(nw_connection_state_t state, nw_error_t connectionError) {
+    // Same reasoning as the listener state handler above.
+    if (nw_connection_state_ready == state) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      if (nil == strongSelf) {
+        return;
+      }
+      id<FBTCPSocketDelegate> delegate = strongSelf.delegate;
+      if (nil != delegate) {
+        [delegate didClientConnect:connection];
+      }
+      [strongSelf scheduleReceiveForConnection:connection];
+    } else if (nw_connection_state_failed == state || nw_connection_state_cancelled == state) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      [strongSelf handleDisconnectForConnection:connection];
+    }
+  });
+  nw_connection_start(connection);
 }
 
-@end
-
-
-@implementation FBTCPSocket(AsyncSocket)
+- (void)scheduleReceiveForConnection:(nw_connection_t)connection
+{
+  __weak typeof(self) weakSelf = self;
+  nw_connection_receive(connection, 1, UINT32_MAX, ^(dispatch_data_t  _Nullable content,
+                                                       nw_content_context_t  _Nullable context,
+                                                       bool isComplete,
+                                                       nw_error_t  _Nullable receiveError) {
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (nil == strongSelf) {
+      return;
+    }
+    if (nil != content) {
+      dispatch_data_t nonnullContent = (dispatch_data_t _Nonnull)content;
+      NSMutableData *data = [NSMutableData data];
+      dispatch_data_apply(nonnullContent, ^bool(dispatch_data_t  _Nonnull region, size_t offset, const void * _Nonnull buffer, size_t size) {
+        [data appendBytes:buffer length:size];
+        return true;
+      });
+      if (data.length > 0) {
+        id<FBTCPSocketDelegate> delegate = strongSelf.delegate;
+        if (nil != delegate) {
+          [delegate client:connection didReceiveData:data];
+        }
+      }
+    }
+    if (nil != receiveError || (isComplete && nil == content)) {
+      [strongSelf handleDisconnectForConnection:connection];
+      return;
+    }
+    [strongSelf scheduleReceiveForConnection:connection];
+  });
+}
 
-- (void)socket:(GCDAsyncSocket *)sock didAcceptNewSocket:(GCDAsyncSocket *)newSocket
+- (void)handleDisconnectForConnection:(nw_connection_t)connection
 {
-  @synchronized(self.connectedClients) {
-    [self.connectedClients addObject:newSocket];
+  BOOL wasConnected;
+  @synchronized (self.connectedClients) {
+    wasConnected = [self.connectedClients containsObject:connection];
+    [self.connectedClients removeObject:connection];
+  }
+  if (wasConnected) {
+    id<FBTCPSocketDelegate> delegate = self.delegate;
+    if (nil != delegate) {
+      [delegate didClientDisconnect:connection];
+    }
   }
-  [self.delegate didClientConnect:newSocket];
 }
 
-- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client
 {
-  [self.delegate didClientSendData:sock];
+  [self writeData:data toClient:client completion:nil];
 }
 
-- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client completion:(nullable void (^)(BOOL didSucceed))completion
 {
-  @synchronized(self.connectedClients) {
-    [self.connectedClients removeObject:sock];
+  dispatch_data_t dispatchData = dispatch_data_create(data.bytes, data.length, self.socketQueue, DISPATCH_DATA_DESTRUCTOR_DEFAULT);
+  nw_connection_send(client, dispatchData, NW_CONNECTION_DEFAULT_STREAM_CONTEXT, false, ^(nw_error_t  _Nullable sendError) {
+    if (completion) {
+      // The send error must reach the caller: a failed write means the response never reached
+      // the peer, and treating that as success would e.g. let the next pipelined request run
+      // against a connection that can no longer answer it.
+      completion(nil == sendError);
+    }
+  });
+}
+
+- (void)stop
+{
+  NSArray<nw_connection_t> *clients;
+  @synchronized (self.connectedClients) {
+    clients = self.connectedClients.copy;
+    [self.connectedClients removeAllObjects];
+  }
+  // Cancel on socketQueue, the same queue every connection's send/receive is bound to (see
+  // -acceptConnection:), so a write already issued just before -stop (e.g. a shutdown route's
+  // response) is processed before the cancellation rather than racing it.
+  dispatch_async(self.socketQueue, ^{
+    for (nw_connection_t client in clients) {
+      nw_connection_cancel(client);
+    }
+  });
+
+  self.delegate = nil;
+  nw_listener_t listener = self.listener;
+  if (nil != listener) {
+    nw_listener_cancel((nw_listener_t _Nonnull)listener);
+    self.listener = nil;
   }
-  [self.delegate didClientDisconnect:sock];
 }
 
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBWebServer.h

@@ -8,7 +8,7 @@
 
 #import <Foundation/Foundation.h>
 
-@class RouteResponse, RoutingHTTPServer, FBExceptionHandler;
+@class RouteResponse, FBExceptionHandler;
 @protocol FBWebServerDelegate;
 
 NS_ASSUME_NONNULL_BEGIN
@@ -24,7 +24,11 @@ NS_ASSUME_NONNULL_BEGIN
 @property (weak, nonatomic) id<FBWebServerDelegate> delegate;
 
 /**
- Starts WebDriverAgent service by booting HTTP and USB server
+ Starts WebDriverAgent service by booting HTTP and USB server.
+ If the HTTP server fails to bind (for example the whole configured port range
+ is already occupied), the failure is reported to the delegate via
+ `webServer:didFailToStartWithError:`. If the delegate does not implement that
+ method the process is aborted, as before.
  */
 - (void)startServing;
 
@@ -47,6 +51,18 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (void)webServerDidRequestShutdown:(FBWebServer *)webServer;
 
+@optional
+/**
+ Called when the server failed to start the HTTP listener, for example because
+ none of the ports in the configured binding range could be bound.
+ If this method is not implemented by the delegate then the process is aborted,
+ preserving the previous behavior.
+
+ @param webServer Server instance.
+ @param error The actual error, that caused the server startup to fail.
+ */
+- (void)webServer:(FBWebServer *)webServer didFailToStartWithError:(NSError *)error;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBWebServer.m

@@ -8,17 +8,18 @@
 
 #import "FBWebServer.h"
 
-#import "RoutingConnection.h"
-#import "RoutingHTTPServer.h"
+#import "FBHTTPServer.h"
+#import "FBMjpegServer.h"
+#import "FBTCPSocket.h"
 
 #import "FBCommandHandler.h"
+#import "FBCommandStatus.h"
 #import "FBErrorBuilder.h"
 #import "FBExceptionHandler.h"
-#import "FBMjpegServer.h"
+#import "FBResponsePayload.h"
 #import "FBRouteRequest.h"
 #import "FBRuntimeUtils.h"
 #import "FBSession.h"
-#import "FBTCPSocket.h"
 #import "FBUnknownCommands.h"
 #import "FBConfiguration.h"
 #import "FBLogger.h"
@@ -28,29 +29,21 @@
 static NSString *const FBServerURLBeginMarker = @"ServerURLHere->";
 static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
-@interface FBHTTPConnection : RoutingConnection
-@end
-
-@implementation FBHTTPConnection
-
-- (void)handleResourceNotFound
-{
-  [FBLogger logFmt:@"Received request for %@ which we do not handle", self.requestURI];
-  [super handleResourceNotFound];
-}
-
-@end
-
-
 @interface FBWebServer ()
 @property (nonatomic, strong) FBExceptionHandler *exceptionHandler;
-@property (nonatomic, strong) RoutingHTTPServer *server;
-@property (atomic, assign) BOOL keepAlive;
+@property (nonatomic, strong) FBHTTPServer *server;
 @property (nonatomic, nullable) FBTCPSocket *screenshotsBroadcaster;
+@property (nonatomic, nullable, strong) FBMjpegServer *mjpegServer;
+@property (atomic, assign) BOOL keepAlive;
 @end
 
 @implementation FBWebServer
 
+- (void)dealloc
+{
+  [self stopScreenshotsBroadcaster];
+}
+
 + (NSArray<Class<FBCommandHandler>> *)collectCommandHandlerClasses
 {
   NSArray *handlersClasses = FBClassesThatConformsToProtocol(@protocol(FBCommandHandler));
@@ -70,7 +63,9 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 {
   [FBLogger logFmt:@"Built at %s %s", __DATE__, __TIME__];
   self.exceptionHandler = [FBExceptionHandler new];
-  [self startHTTPServer];
+  if (![self startHTTPServer]) {
+    return;
+  }
   [self initScreenshotsBroadcaster];
 
   self.keepAlive = YES;
@@ -79,25 +74,29 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
          [runLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]]);
 }
 
-- (void)startHTTPServer
+- (BOOL)startHTTPServer
 {
-  self.server = [[RoutingHTTPServer alloc] init];
+  self.server = [[FBHTTPServer alloc] init];
   [self.server setRouteQueue:dispatch_get_main_queue()];
   [self.server setDefaultHeader:@"Server" value:@"WebDriverAgent/1.0"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Origin" value:@"*"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Headers" value:@"Content-Type, X-Requested-With"];
-  [self.server setConnectionClass:[FBHTTPConnection self]];
+
+  [NSNotificationCenter.defaultCenter addObserver:self
+                                          selector:@selector(sessionWasKilled:)
+                                              name:FBSessionWasKilledNotification
+                                            object:nil];
 
   [self registerRouteHandlers:[self.class collectCommandHandlerClasses]];
   [self registerServerKeyRouteHandlers];
 
-  NSRange serverPortRange = FBConfiguration.bindingPortRange;
-  NSString *bindingIP = FBConfiguration.bindingIPAddress;
+  NSRange serverPortRange = FBConfiguration.sharedInstance.bindingPortRange;
+  NSString *bindingIP = FBConfiguration.sharedInstance.bindingIPAddress;
   if (bindingIP != nil) {
     [self.server setInterface:bindingIP];
     [FBLogger logFmt:@"Using custom binding IP address: %@", bindingIP];
   }
-  
+
   NSError *error;
   BOOL serverStarted = NO;
 
@@ -115,22 +114,32 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
   if (!serverStarted) {
     [FBLogger logFmt:@"Last attempt to start web server failed with error %@", [error description]];
+    id<FBWebServerDelegate> delegate = self.delegate;
+    if ([delegate respondsToSelector:@selector(webServer:didFailToStartWithError:)]) {
+      [delegate webServer:self didFailToStartWithError:(NSError * _Nonnull)error];
+      return NO;
+    }
     abort();
   }
-  
+
   NSString *serverHost = bindingIP ?: ([XCUIDevice sharedDevice].fb_wifiIPAddress ?: @"127.0.0.1");
   [FBLogger logFmt:@"%@http://%@:%d%@", FBServerURLBeginMarker, serverHost, [self.server port], FBServerURLEndMarker];
+  return YES;
 }
 
 - (void)initScreenshotsBroadcaster
 {
   [self readMjpegSettingsFromEnv];
+  self.mjpegServer = [[FBMjpegServer alloc] init];
   self.screenshotsBroadcaster = [[FBTCPSocket alloc]
-                                 initWithPort:(uint16_t)FBConfiguration.mjpegServerPort];
-  self.screenshotsBroadcaster.delegate = [[FBMjpegServer alloc] init];
+                                 initWithPort:(uint16_t)FBConfiguration.sharedInstance.mjpegServerPort];
+  self.mjpegServer.socket = self.screenshotsBroadcaster;
+  self.screenshotsBroadcaster.delegate = self.mjpegServer;
   NSError *error;
   if (![self.screenshotsBroadcaster startWithError:&error]) {
-    [FBLogger logFmt:@"Cannot init screenshots broadcaster service on port %@. Original error: %@", @(FBConfiguration.mjpegServerPort), error.description];
+    [FBLogger logFmt:@"Cannot init screenshots broadcaster service on port %@. Original error: %@", @(FBConfiguration.sharedInstance.mjpegServerPort), error.description];
+    [self.mjpegServer stopStreaming];
+    self.mjpegServer = nil;
     self.screenshotsBroadcaster = nil;
   }
 }
@@ -138,10 +147,18 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 - (void)stopScreenshotsBroadcaster
 {
   if (nil == self.screenshotsBroadcaster) {
+    self.mjpegServer = nil;
     return;
   }
 
+  id<FBTCPSocketDelegate> delegate = self.screenshotsBroadcaster.delegate;
+  if ([(NSObject *)delegate respondsToSelector:@selector(stopStreaming)]) {
+    [(FBMjpegServer *)delegate stopStreaming];
+  }
+  self.screenshotsBroadcaster.delegate = nil;
   [self.screenshotsBroadcaster stop];
+  self.screenshotsBroadcaster = nil;
+  self.mjpegServer = nil;
 }
 
 - (void)readMjpegSettingsFromEnv
@@ -149,25 +166,45 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   NSDictionary *env = NSProcessInfo.processInfo.environment;
   NSString *scalingFactor = [env objectForKey:@"MJPEG_SCALING_FACTOR"];
   if (scalingFactor != nil && [scalingFactor length] > 0) {
-    [FBConfiguration setMjpegScalingFactor:[scalingFactor floatValue]];
+    FBConfiguration.sharedInstance.mjpegScalingFactor = [scalingFactor floatValue];
   }
   NSString *screenshotQuality = [env objectForKey:@"MJPEG_SERVER_SCREENSHOT_QUALITY"];
   if (screenshotQuality != nil && [screenshotQuality length] > 0) {
-    [FBConfiguration setMjpegServerScreenshotQuality:[screenshotQuality integerValue]];
+    FBConfiguration.sharedInstance.mjpegServerScreenshotQuality = [screenshotQuality integerValue];
+  }
+}
+
+- (void)sessionWasKilled:(NSNotification *)notification
+{
+  FBSession *session = notification.object;
+  if (![session isKindOfClass:FBSession.class]) {
+    return;
   }
+  // Same "invalid session id" shape a still-queued request would eventually get anyway, once
+  // -routeQueue drains and FBRoute.decorateRequest: finds the session gone - just delivered now
+  // instead of after however long the request would otherwise have been stuck waiting.
+  NSString *message = [NSString stringWithFormat:@"Session %@ was deleted while this request was still pending", session.identifier];
+  id<FBResponsePayload> payload = FBResponseWithStatus([FBCommandStatus noSuchDriverErrorWithMessage:message
+                                                                                            traceback:nil]);
+  RouteResponse *response = [RouteResponse new];
+  [payload dispatchWithResponse:response];
+  [self.server abandonPendingRequestsForSessionID:session.identifier withResponse:response];
 }
 
 - (void)stopServing
 {
+  [NSNotificationCenter.defaultCenter removeObserver:self name:FBSessionWasKilledNotification object:nil];
   [FBSession.activeSession kill];
   [self stopScreenshotsBroadcaster];
   if (self.server.isRunning) {
     [self.server stop:NO];
   }
+  self.server = nil;
+  self.exceptionHandler = nil;
   self.keepAlive = NO;
 }
 
-- (BOOL)attemptToStartServer:(RoutingHTTPServer *)server onPort:(NSInteger)port withError:(NSError **)error
+- (BOOL)attemptToStartServer:(FBHTTPServer *)server onPort:(NSInteger)port withError:(NSError **)error
 {
   server.port = (UInt16)port;
   NSError *innerError = nil;
@@ -192,10 +229,15 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
 - (void)registerRouteHandlers:(NSArray *)commandHandlerClasses
 {
+  __weak typeof(self) weakSelf = self;
   for (Class<FBCommandHandler> commandHandler in commandHandlerClasses) {
     NSArray *routes = [commandHandler routes];
     for (FBRoute *route in routes) {
-      [self.server handleMethod:route.verb withPath:route.path block:^(RouteRequest *request, RouteResponse *response) {
+      [self.server handleMethod:route.verb withPath:route.path standalone:route.isStandalone block:^(RouteRequest *request, RouteResponse *response) {
+        __strong typeof(weakSelf) strongSelf = weakSelf;
+        if (nil == strongSelf) {
+          return;
+        }
         NSDictionary *arguments = [NSJSONSerialization JSONObjectWithData:request.body options:NSJSONReadingMutableContainers error:NULL];
         FBRouteRequest *routeParams = [FBRouteRequest
           routeRequestWithURL:request.url
@@ -209,7 +251,7 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
           [route mountRequest:routeParams intoResponse:response];
         }
         @catch (NSException *exception) {
-          [self handleException:exception forResponse:response];
+          [strongSelf handleException:exception forResponse:response];
         }
       }];
     }
@@ -227,6 +269,9 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
     [response respondWithString:@"<!DOCTYPE html><html><title>Health Check</title><body><p>I-AM-ALIVE</p></body></html>"];
   }];
 
+  // Deprecated: no longer needed since appium-xcuitest-driver handles calibration
+  // itself (https://github.com/appium/appium-xcuitest-driver/pull/2948). Kept for
+  // backward compatibility; will be removed in a future major release.
   NSString *calibrationPage = @"<html>"
   "<title>{\"x\":null,\"y\":null}</title>"
   "<header>"
@@ -234,12 +279,22 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   "</header>"
   "</html>";
   [self.server get:@"/calibrate" withBlock:^(RouteRequest *request, RouteResponse *response) {
+    [FBLogger logFmt:@"The /calibrate endpoint is deprecated and will be removed in a future release"];
     [response respondWithString:calibrationPage];
   }];
 
+  __weak typeof(self) weakSelf = self;
   [self.server get:@"/wda/shutdown" withBlock:^(RouteRequest *request, RouteResponse *response) {
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (nil == strongSelf) {
+      return;
+    }
     [response respondWithString:@"Shutting down"];
-    [self.delegate webServerDidRequestShutdown:self];
+    // Deferred so the "Shutting down" response is written to the client before
+    // webServerDidRequestShutdown: tears down the server's socket out from under it.
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [strongSelf.delegate webServerDidRequestShutdown:strongSelf];
+    });
   }];
 
   [self registerRouteHandlers:@[FBUnknownCommands.class]];

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBXCElementSnapshot.h

@@ -58,7 +58,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)mergeTreeWithSnapshot:(id)arg1;
 - (id)_childMatchingElement:(id)arg1;
 - (NSArray<id<FBXCElementSnapshot>> *)_allDescendants;
-- (BOOL)hasDescendantMatchingFilter:(CDUnknownBlockType)arg1;
+- (BOOL)hasDescendantMatchingFilter:(BOOL(^)(id<FBXCElementSnapshot> snapshot))arg1;
 - (NSArray<id<FBXCElementSnapshot>> *)descendantsByFilteringWithBlock:(BOOL(^)(id<FBXCElementSnapshot> snapshot))block;
 - (id)elementSnapshotMatchingAccessibilityElement:(id)arg1;
 - (void)enumerateDescendantsUsingBlock:(void(^)(id<FBXCElementSnapshot> snapshot))block;