narayana/another.im-ios
narayana/another.im-ios
7
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
another.im-ios/Monal/Classes/MLCall.m

1798 lines
82 KiB
Mathematica
Raw Permalink Normal View History

copy monal src
2024-11-18 14:53:52 +00:00
//
// MLCall.m
// monalxmpp
//
// Created by admin on 30.12.22.
// Copyright © 2022 monal-im.org. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "MLConstants.h"
#import "Monal-Swift.h"
#import "HelperTools.h"
#import "XMPPIQ.h"
#import "XMPPMessage.h"
#import "xmpp.h"
#import "MLXMPPManager.h"
#import "MLVoIPProcessor.h"
#import "MLCall.h"
#import "MonalAppDelegate.h"
#import "MLOMEMO.h"
@import CallKit;
@import WebRTC;
//this is our private interface only shared with MLVoIPProcessor
@interface MLCall() <WebRTCClientDelegate>
{
//these are not synthesized automatically because we have getters and setters
MLXMLNode* _jmiProceed;
CXAnswerCallAction* _providerAnswerAction;
WebRTCClient* _webRTCClient;
BOOL _muted;
BOOL _speaker;
BOOL _isConnected;
AVAudioSession* _audioSession;
}
@property (nonatomic, strong) NSUUID* uuid;
@property (nonatomic, strong) NSString* jmiid;
@property (nonatomic, strong) MLContact* contact;
@property (nonatomic) MLCallType callType;
@property (nonatomic) MLCallDirection direction;
@property (nonatomic) MLCallEncryptionState encryptionState;
@property (nonatomic, strong) MLXMLNode* _Nullable jmiPropose;
@property (nonatomic, strong) MLXMLNode* _Nullable jmiProceed;
@property (nonatomic, strong) NSString* _Nullable fullRemoteJid;
@property (nonatomic, strong) WebRTCClient* _Nullable webRTCClient;
@property (nonatomic, strong) CXAnswerCallAction* _Nullable providerAnswerAction;
@property (nonatomic, assign) BOOL isConnected;
@property (nonatomic, assign) BOOL wasConnectedOnce;
@property (nonatomic, assign) BOOL isReconnecting;
@property (nonatomic, assign) BOOL isFinished;
@property (nonatomic, assign) BOOL tieBreak;
@property (nonatomic, strong) AVAudioSession* _Nullable audioSession;
@property (nonatomic, assign) MLCallFinishReason finishReason;
@property (nonatomic, assign) uint32_t durationTime;
@property (nonatomic, strong) NSTimer* _Nullable callDurationTimer;
@property (nonatomic, strong) monal_void_block_t _Nullable cancelDiscoveringTimeout;
@property (nonatomic, strong) monal_void_block_t _Nullable cancelRingingTimeout;
@property (nonatomic, strong) monal_void_block_t _Nullable cancelConnectingTimeout;
@property (nonatomic, strong) monal_void_block_t _Nullable cancelWaitUntilIceRestart;
@property (nonatomic, strong) MLXMLNode* localSDP;
@property (nonatomic, strong) MLXMLNode* remoteSDP;
@property (nonatomic, strong) NSNumber* remoteOmemoDeviceId;
@property (nonatomic, strong) NSObject* candidateQueueLock;
@property (nonatomic, strong) NSMutableArray<XMPPIQ*>* incomingCandidateQueue;
@property (nonatomic, strong) NSMutableArray<XMPPIQ*>* outgoingCandidateQueue;
@property (nonatomic, readonly) xmpp* account;
@property (nonatomic, strong) MLVoIPProcessor* voipProcessor;
@end
//this is private and only shared to this class
@interface MLVoIPProcessor()
@property (nonatomic, strong) CXCallController* _Nullable callController;
@property (nonatomic, strong) CXProvider* _Nullable cxProvider;
-(void) removeCall:(MLCall*) call;
-(void) initWebRTCForPendingCall:(MLCall*) call;
-(void) handleIncomingJMIStanza:(MLXMLNode*) messageNode onAccount:(xmpp*) account;
@end
@implementation MLCall
+(instancetype) makeDummyCall:(int) type
{
NSUUID* uuid = [NSUUID UUID];
return [[self alloc] initWithUUID:uuid jmiid:uuid.UUIDString contact:[MLContact makeDummyContact:type] callType:MLCallTypeAudio andDirection:MLCallDirectionOutgoing];
}
-(instancetype) initWithUUID:(NSUUID*) uuid jmiid:(NSString*) jmiid contact:(MLContact*) contact callType:(MLCallType) callType andDirection:(MLCallDirection) direction
{
self = [super init];
MLAssert(uuid != nil, @"Call UUIDs must not be nil!");
MLAssert(jmiid != nil, @"Call jmiids must not be nil!");
self.uuid = uuid;
self.jmiid = jmiid;
self.contact = contact;
self.callType = callType;
self.direction = direction;
self.encryptionState = MLCallEncryptionStateUnknown;
self.isConnected = NO;
self.wasConnectedOnce = NO;
self.isReconnecting = NO;
self.durationTime = 0;
self.isFinished = NO;
self.finishReason = MLCallFinishReasonUnknown;
self.cancelDiscoveringTimeout = nil;
self.cancelRingingTimeout = nil;
self.cancelConnectingTimeout = nil;
self.localSDP = nil;
self.remoteSDP = nil;
self.remoteOmemoDeviceId = nil;
self.candidateQueueLock = [NSObject new];
self.incomingCandidateQueue = [NSMutableArray new];
self.outgoingCandidateQueue = [NSMutableArray new];
[HelperTools dispatchAsync:NO reentrantOnQueue:dispatch_get_main_queue() withBlock:^{
MonalAppDelegate* appDelegate = (MonalAppDelegate*)[[UIApplication sharedApplication] delegate];
MLAssert(appDelegate.voipProcessor != nil, @"appDelegate.voipProcessor should never be nil!");
self.voipProcessor = appDelegate.voipProcessor;
}];
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(processIncomingSDP:) name:kMonalIncomingSDP object:nil];
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(processIncomingICECandidate:) name:kMonalIncomingICECandidate object:nil];
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleAudioRouteChangeNotification:) name:AVAudioSessionRouteChangeNotification object:nil];
//[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleConnectivityChange:) name:kMonalConnectivityChange object:nil];
return self;
}
-(void) dealloc
{
DDLogInfo(@"Called dealloc: %@", self);
[self.callDurationTimer invalidate];
[[NSNotificationCenter defaultCenter] removeObserver:self];
}
#pragma mark - public interface
-(void) startCaptureLocalVideoWithRenderer:(id<RTCVideoRenderer>) renderer andCameraPosition:(AVCaptureDevicePosition) position
{
MLAssert(self.callType == MLCallTypeVideo, @"startCaptureLocalVideoWithRenderer:andCameraPosition: can only be called for video calls!");
[self.webRTCClient startCaptureLocalVideoWithRenderer:renderer andCameraPosition:position];
}
-(void) stopCaptureLocalVideo
{
MLAssert(self.callType == MLCallTypeVideo, @"stopCaptureLocalVideo: can only be called for video calls!");
[self.webRTCClient stopCaptureLocalVideo];
}
-(void) renderRemoteVideoWithRenderer:(id<RTCVideoRenderer>) renderer
{
MLAssert(self.callType == MLCallTypeVideo, @"renderRemoteVideoWithRenderer: can only be called for video calls!");
[self.webRTCClient renderRemoteVideoTo:renderer];
}
-(void) hideVideo
{
MLAssert(self.callType == MLCallTypeVideo, @"hideVideo: can only be called for video calls!");
[self.webRTCClient hideVideo];
}
-(void) showVideo
{
MLAssert(self.callType == MLCallTypeVideo, @"showVideo: can only be called for video calls!");
[self.webRTCClient showVideo];
}
-(void) end
{
if(self.isFinished)
{
DDLogInfo(@"Not requesting end call action: call already in finished state...");
return;
}
DDLogVerbose(@"Requesting end call transaction for %@", [self short]);
CXEndCallAction* endCallAction = [[CXEndCallAction alloc] initWithCallUUID:self.uuid];
CXTransaction* transaction = [[CXTransaction alloc] initWithAction:endCallAction];
[self.voipProcessor.callController requestTransaction:transaction completion:^(NSError* error) {
if(error != nil)
{
//try to do this "manually" without looping through callkit
DDLogError(@"Error requesting end call transaction: %@", error);
[self internalHandleEndCallActionWithReason:MLCallFinishReasonUnknown];
return;
}
else
DDLogInfo(@"Successfully created end call transaction for CallKit..");
}];
}
-(void) delayedEnd:(double) delay withDisconnectedState:(BOOL) disconnected
{
createTimer(delay, (^{
//isConnected = NO will result in MLCallFinishReasonConnectivityError if wasConnectedOnce == YES
if(disconnected)
self.isConnected = NO;
[self end];
}));
}
-(void) setMuted:(BOOL) muted
{
@synchronized(self) {
if(self.webRTCClient == nil || self.audioSession == nil)
return;
_muted = muted;
if(_muted)
[self.webRTCClient muteAudio];
else
[self.webRTCClient unmuteAudio];
}
}
-(BOOL) muted
{
@synchronized(self) {
return _muted;
}
}
-(void) setSpeaker:(BOOL) speaker
{
@synchronized(self) {
if(self.webRTCClient == nil || self.audioSession == nil)
return;
if(_speaker == speaker)
return;
_speaker = speaker;
if(_speaker)
[self.webRTCClient speakerOn];
else
[self.webRTCClient speakerOff];
}
}
-(BOOL) speaker
{
@synchronized(self) {
return _speaker;
}
}
-(MLCallState) state
{
@synchronized(self) {
if(self.direction == MLCallDirectionOutgoing)
{
if(self.isFinished)
return MLCallStateFinished;
if(self.isConnected && self.webRTCClient != nil && self.audioSession != nil)
return MLCallStateConnected;
if(self.jmiProceed != nil && self.isReconnecting)
return MLCallStateReconnecting;
if(self.jmiProceed != nil)
return MLCallStateConnecting;
if(self.jmiProceed == nil && self.cancelRingingTimeout != nil)
return MLCallStateRinging;
if(self.jmiProceed == nil && self.cancelDiscoveringTimeout != nil)
return MLCallStateDiscovering;
return MLCallStateUnknown;
}
else
{
if(self.isFinished)
return MLCallStateFinished;
if(self.isConnected && self.webRTCClient != nil && self.audioSession != nil)
return MLCallStateConnected;
if(self.providerAnswerAction != nil && self.isReconnecting)
return MLCallStateReconnecting;
if(self.providerAnswerAction != nil)
return MLCallStateConnecting;
if(self.providerAnswerAction == nil)
return MLCallStateRinging;
return MLCallStateUnknown;
}
}
}
+(NSSet*) keyPathsForValuesAffectingState
{
return [NSSet setWithObjects:@"direction", @"isConnected", @"jmiProceed", @"webRTCClient", @"providerAnswerAction", @"audioSession", @"isFinished", @"cancelDiscoveringTimeout", @"cancelRingingTimeout", @"cancelConnectingTimeout", @"isReconnecting", nil];
}
#pragma mark - internals
-(xmpp*) account
{
@synchronized(self) {
xmpp* account = self.contact.account;
MLAssert(account != nil, @"Account of call must be listed in MLXMPPManager connected accounts!", (@{
@"contact": nilWrapper(self.contact),
@"call": nilWrapper(self),
}));
return account;
}
}
-(void) startCallDuartionTimer
{
//the timer needs a thread with runloop, see https://stackoverflow.com/a/18098396/3528174
dispatch_async(dispatch_get_main_queue(), ^{
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
if(self.cancelRingingTimeout != nil)
self.cancelRingingTimeout();
self.cancelRingingTimeout = nil;
if(self.cancelConnectingTimeout != nil)
self.cancelConnectingTimeout();
self.cancelConnectingTimeout = nil;
//don't restart our timer if we just reconnected
if(self.isReconnecting)
return;
if(self.callDurationTimer != nil)
[self.callDurationTimer invalidate];
DDLogInfo(@"%@: Starting call duration timer...", [self short]);
self.callDurationTimer = [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer* timer) {
DDLogVerbose(@"%@:Call duration timer triggered: %d", [self short], self.durationTime);
if(self.state == MLCallStateFinished)
{
DDLogInfo(@"%@: Stopping call duration timer...", [self short]);
[timer invalidate];
self.callDurationTimer = nil;
}
else
self.durationTime++;
}];
});
}
-(void) setJmiProceed:(MLXMLNode*) jmiProceed
{
@synchronized(self) {
_jmiProceed = jmiProceed;
if(self.direction == MLCallDirectionOutgoing)
{
//see https://gist.github.com/iNPUTmice/aa4fc0aeea6ce5fb0e0fe04baca842cd
self.remoteOmemoDeviceId = [jmiProceed findFirst:@"{urn:xmpp:jingle-message:0}proceed/{http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification}device@id|uint"];
DDLogInfo(@"Proceed set remote omemo deviceid to: %@", self.remoteOmemoDeviceId);
}
if(self.direction == MLCallDirectionOutgoing && self.webRTCClient != nil)
[self establishOutgoingConnection];
}
}
-(MLXMLNode*) jmiProceed
{
@synchronized(self) {
return _jmiProceed;
}
}
-(void) setProviderAnswerAction:(CXAnswerCallAction*) action
{
@synchronized(self) {
_providerAnswerAction = action;
if(self.direction == MLCallDirectionIncoming && self.webRTCClient != nil)
[self establishIncomingConnection];
}
}
-(CXAnswerCallAction*) providerAnswerAction
{
@synchronized(self) {
return _providerAnswerAction;
}
}
-(void) setWebRTCClient:(WebRTCClient*) webRTCClient
{
@synchronized(self) {
_webRTCClient = webRTCClient;
if(self.webRTCClient != nil && self.direction == MLCallDirectionIncoming && self.providerAnswerAction != nil)
[self establishIncomingConnection];
if(self.webRTCClient != nil && self.direction == MLCallDirectionOutgoing && self.jmiProceed != nil)
[self establishOutgoingConnection];
}
}
-(WebRTCClient*) webRTCClient
{
@synchronized(self) {
return _webRTCClient;
}
}
-(void) setIsConnected:(BOOL) isConnected
{
@synchronized(self) {
BOOL oldValue = _isConnected;
_isConnected = isConnected;
if(isConnected)
self.wasConnectedOnce = YES;
//if switching to connected state: check if we need to activate the already reported audio session now
if(oldValue == NO && self.isConnected == YES && self.audioSession != nil)
[self didActivateAudioSession:self.audioSession];
//start timer once we are fully connected
if(self.isConnected && self.audioSession != nil)
[self startCallDuartionTimer];
}
#ifdef IS_ALPHA
#if TARGET_OS_MACCATALYST
//set audio session to default one
self.audioSession = [AVAudioSession sharedInstance];
#endif
#endif
}
-(BOOL) isConnected
{
@synchronized(self) {
return _isConnected;
}
}
-(void) setAudioSession:(AVAudioSession*) audioSession
{
@synchronized(self) {
if(audioSession == _audioSession)
{
DDLogWarn(@"Trying to activate same audio session a second time, ignoring...");
return;
}
BOOL assertActivated = YES;
#ifdef IS_ALPHA
#if TARGET_OS_MACCATALYST
assertActivated = NO;
#endif
#endif
if(assertActivated && audioSession != nil)
MLAssert(_audioSession == nil, @"Audio session should never be activated without deactivating old audio session first!", (@{
@"oldAudioSession": nilWrapper(_audioSession),
@"newAudioSession": nilWrapper(audioSession),
@"call": self,
}));
AVAudioSession* oldSession = _audioSession;
_audioSession = audioSession;
//do nothing if not yet connected
if(self.isConnected == YES && oldSession == nil && self.audioSession != nil)
[self didActivateAudioSession:self.audioSession];
if(self.audioSession == nil && oldSession != nil)
[self didDeactivateAudioSession:oldSession];
//start timer once we are fully connected
if(self.isConnected && self.audioSession != nil)
[self startCallDuartionTimer];
}
}
-(AVAudioSession*) audioSession
{
@synchronized(self) {
return _audioSession;
}
}
-(void) didActivateAudioSession:(AVAudioSession*) audioSession
{
NSError* error = nil;
DDLogInfo(@"Activating audio session now: %@", audioSession);
[[RTCAudioSession sharedInstance] lockForConfiguration];
NSUInteger options = 0;
options |= AVAudioSessionCategoryOptionAllowBluetooth;
options |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
options |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
options |= AVAudioSessionCategoryOptionAllowAirPlay;
[[RTCAudioSession sharedInstance] setCategory:AVAudioSessionCategoryPlayAndRecord withOptions:options error:&error];
if(error != nil)
DDLogError(@"Failed to configure AVAudioSession category: %@", error);
[[RTCAudioSession sharedInstance] setMode:AVAudioSessionModeVoiceChat error:&error];
if(error != nil)
DDLogError(@"Failed to configure AVAudioSession mode: %@", error);
[[RTCAudioSession sharedInstance] audioSessionDidActivate:audioSession];
[[RTCAudioSession sharedInstance] setIsAudioEnabled:YES];
[[RTCAudioSession sharedInstance] unlockForConfiguration];
}
-(void) didDeactivateAudioSession:(AVAudioSession*) audioSession
{
DDLogInfo(@"Deactivating audio session now: %@", audioSession);
[[RTCAudioSession sharedInstance] lockForConfiguration];
[[RTCAudioSession sharedInstance] audioSessionDidDeactivate:audioSession];
[[RTCAudioSession sharedInstance] setIsAudioEnabled:NO];
[[RTCAudioSession sharedInstance] unlockForConfiguration];
}
-(void) reportRinging
{
DDLogDebug(@"%@ was reported as ringing...", [self short]);
[self createRingingTimeoutTimer];
}
-(void) migrateTo:(MLCall*) otherCall
{
//send jmi finish with migration before chaning all ids etc.
DDLogDebug(@"Migrating call using JMI finish: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.fullRemoteJid];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"finish" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"expired"]
] andData:nil],
[[MLXMLNode alloc] initWithElement:@"migrated" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{
@"to": otherCall.jmiid,
} andChildren:@[] andData:nil]
] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
@synchronized(self) {
DDLogDebug(@"%@: Preparing this call for new webrtc connection...", [self short]);
self.jmiid = otherCall.jmiid;
self.fullRemoteJid = otherCall.fullRemoteJid;
self.callType = otherCall.callType;
self.isConnected = NO;
self.isReconnecting = YES;
self.finishReason = MLCallFinishReasonUnknown;
self.direction = otherCall.direction;
self.jmiPropose = otherCall.jmiPropose;
self.jmiProceed = nil;
[self.callDurationTimer invalidate];
self.callDurationTimer = nil;
self.localSDP = otherCall.localSDP; //should be nil
self.remoteSDP = otherCall.remoteSDP; //should be nil
self.incomingCandidateQueue = otherCall.incomingCandidateQueue; //should be empty
self.outgoingCandidateQueue = otherCall.outgoingCandidateQueue; //should be empty
self.remoteOmemoDeviceId = otherCall.remoteOmemoDeviceId; //depends on jmiProceed and should be empty
self.encryptionState = MLCallEncryptionStateUnknown; //depends on callstate >= connecting
otherCall = nil;
DDLogDebug(@"%@: Stopping all running timers...", [self short]);
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
if(self.cancelRingingTimeout != nil)
self.cancelRingingTimeout();
self.cancelRingingTimeout = nil;
if(self.cancelConnectingTimeout != nil)
self.cancelConnectingTimeout();
self.cancelConnectingTimeout = nil;
if(self.webRTCClient != nil)
{
DDLogDebug(@"%@: Closing old webrtc connection...", [self short]);
__block WebRTCClient* client = self.webRTCClient;
self.webRTCClient = nil;
//do this async to not run into a deadlock with the signalling thread
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[client.peerConnection close];
client = nil;
//report this migrated call as ringing
[self sendJmiRinging];
//now fake a cxprovider answer action (we do auto-answer this call, but ios does not even know we switched the underlying webrtc connection)
DDLogVerbose(@"%@: Faking CXAnswerCallAction...", [self short]);
self.providerAnswerAction = [[CXAnswerCallAction alloc] initWithCallUUID:self.uuid];
DDLogVerbose(@"%@: Initializing webrtc for our migrated call...", [self short]);
[self.voipProcessor initWebRTCForPendingCall:self];
DDLogDebug(@"%@: Migration done, waiting for new webrtc connection...", [self short]);
});
}
else
DDLogDebug(@"%@: No old webrtc connection to close...", [self short]);
}
}
-(void) handleEndCallActionWithReason:(MLCallFinishReason) reason
{
@synchronized(self) {
[self internalHandleEndCallActionWithReason:reason];
[self internalUpdateCallKitState];
}
}
-(void) internalHandleEndCallActionWithReason:(MLCallFinishReason) reason
{
@synchronized(self) {
//stop all running timers
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
if(self.cancelRingingTimeout != nil)
self.cancelRingingTimeout();
self.cancelRingingTimeout = nil;
if(self.cancelConnectingTimeout != nil)
self.cancelConnectingTimeout();
self.cancelConnectingTimeout = nil;
//end webrtc call if already established or in the process of establishing
if(self.webRTCClient != nil)
{
WebRTCClient* client = self.webRTCClient;
self.webRTCClient = nil; //this will prevent the new webrtc state from being handled
//do this async to not run into a deadlock with the signalling thread
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[client.peerConnection close];
});
}
//update state (this will automatically stop the call duration timer)
self.finishReason = reason;
self.isConnected = NO;
self.isFinished = YES;
//remove this call from pending calls
[self.voipProcessor removeCall:self];
}
}
-(void) internalUpdateCallKitState
{
@synchronized(self) {
//the CXEndCallAction means either the call was rejected (if not yet answered) or it was terminated normally (if the call was accepted)
//see https://developer.apple.com/documentation/callkit/cxcallendedreason?language=objc for end reasons
if(self.direction == MLCallDirectionIncoming)
{
[self.providerAnswerAction fail]; //fail will do nothing if already fulfilled or nil
if(self.jmiProceed == nil)
{
if(self.finishReason == MLCallFinishReasonAnsweredElsewhere)
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonAnsweredElsewhere];
else if(self.finishReason == MLCallFinishReasonUnanswered)
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonRemoteEnded];
else if(self.finishReason == MLCallFinishReasonRejected)
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonDeclinedElsewhere];
else if(self.finishReason == MLCallFinishReasonDeclined)
{
if(self.tieBreak)
[self sendJmiRejectWithTieBreak];
else
[self sendJmiReject];
}
else if(self.finishReason == MLCallFinishReasonError)
{
[self sendJmiFinishWithReason:@"application-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else
{
DDLogError(@"Unexpected finish reason: %@", (@{@"call": self, @"finishReason": @(self.finishReason)}));
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
}
else
{
if(self.finishReason == MLCallFinishReasonNormal)
{
[self sendJmiFinishWithReason:@"success"];
//this is not needed because this case is always looped through cxprovider endCallAction
//[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonRemoteEnded];
}
else if(self.finishReason == MLCallFinishReasonConnectivityError)
{
[self sendJmiFinishWithReason:@"connectivity-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else if(self.finishReason == MLCallFinishReasonSecurityError)
{
[self sendJmiFinishWithReason:@"security-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else if(self.finishReason == MLCallFinishReasonError)
{
[self sendJmiFinishWithReason:@"application-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else
{
DDLogError(@"Unexpected finish reason: %@", (@{@"call": self, @"finishReason": @(self.finishReason)}));
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
}
}
else
{
if(self.jmiPropose != nil)
{
if(self.jmiProceed == nil)
{
if(self.finishReason == MLCallFinishReasonRejected)
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonRemoteEnded];
else if(self.finishReason == MLCallFinishReasonAnsweredElsewhere)
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonAnsweredElsewhere];
else if(self.finishReason == MLCallFinishReasonRetracted)
{
if(self.tieBreak)
[self sendJmiRetractWithTieBreak];
else
[self sendJmiRetract];
}
else if(self.finishReason == MLCallFinishReasonError)
{
[self sendJmiFinishWithReason:@"application-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else
{
DDLogError(@"Unexpected finish reason: %@", (@{@"call": self, @"finishReason": @(self.finishReason)}));
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
}
else
{
if(self.finishReason == MLCallFinishReasonNormal)
{
[self sendJmiFinishWithReason:@"success"];
//this is not needed because this case is always looped through cxprovider endCallAction
//[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonRemoteEnded];
}
else if(self.finishReason == MLCallFinishReasonConnectivityError)
{
[self sendJmiFinishWithReason:@"connectivity-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else if(self.finishReason == MLCallFinishReasonSecurityError)
{
[self sendJmiFinishWithReason:@"security-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else if(self.finishReason == MLCallFinishReasonError)
{
[self sendJmiFinishWithReason:@"application-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
else
{
DDLogError(@"Unexpected finish reason: %@", (@{@"call": self, @"finishReason": @(self.finishReason)}));
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonFailed];
}
}
}
else
{
//this case probably does never happen
//(the outgoing call transaction was started, but start call action not yet executed, and then the end call action arrives)
[self sendJmiFinishWithReason:@"connectivity-error"];
[self.voipProcessor.cxProvider reportCallWithUUID:self.uuid endedAtDate:nil reason:CXCallEndedReasonUnanswered];
self.finishReason = MLCallFinishReasonConnectivityError;
}
}
}
}
-(void) createConnectingTimeoutTimer
{
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
if(self.cancelRingingTimeout != nil)
self.cancelRingingTimeout();
self.cancelRingingTimeout = nil;
if(self.cancelConnectingTimeout != nil)
self.cancelConnectingTimeout();
self.cancelConnectingTimeout = nil;
self.cancelConnectingTimeout = createTimer(15.0, (^{
DDLogError(@"Failed to connect call, aborting!");
[self end];
}));
}
-(void) createReconnectingTimeoutTimer
{
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
if(self.cancelRingingTimeout != nil)
self.cancelRingingTimeout();
self.cancelRingingTimeout = nil;
if(self.cancelConnectingTimeout != nil)
self.cancelConnectingTimeout();
self.cancelConnectingTimeout = nil;
self.cancelConnectingTimeout = createTimer(45.0, (^{
DDLogError(@"Failed to connect call, aborting!");
[self end];
}));
}
-(void) createRingingTimeoutTimer
{
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
if(self.cancelRingingTimeout != nil)
self.cancelRingingTimeout();
self.cancelRingingTimeout = nil;
self.cancelRingingTimeout = createTimer(45.0, (^{
DDLogError(@"Call not answered in time, aborting!");
[self end];
}));
}
-(void) createDiscoveringTimeoutTimer
{
if(self.cancelDiscoveringTimeout != nil)
self.cancelDiscoveringTimeout();
self.cancelDiscoveringTimeout = nil;
self.cancelDiscoveringTimeout = createTimer(30.0, (^{
DDLogError(@"Discovery not answered in time, aborting!");
[self end];
}));
}
-(void) establishIncomingConnection
{
DDLogInfo(@"Now connecting incoming VoIP call: %@", self);
[self.webRTCClient configureAudioSession];
[self createConnectingTimeoutTimer];
//the remote (e.g. "initiator") will send a jingle "session-initiate" as soon as it receives our jmi proceed
[self sendJmiProceed];
}
-(void) establishOutgoingConnection
{
DDLogInfo(@"Now connecting outgoing VoIP call: %@", self);
[self.webRTCClient configureAudioSession];
[self.voipProcessor.cxProvider reportOutgoingCallWithUUID:self.uuid startedConnectingAtDate:nil];
[self createConnectingTimeoutTimer];
[self offerSDP];
}
/*
-(void) restartIce
{
if(self.isReconnecting)
{
DDLogWarn(@"Not restarting ICE, already reconnecting!");
return;
}
DDLogInfo(@"Restarting ICE...");
@synchronized(self) {
self.isConnected = NO;
self.isReconnecting = YES;
[self.webRTCClient.peerConnection restartIce];
//we have to decide for a prefered direction because otherwise we'd get a webrtc error on incoming sdp:
//Failed to set remote offer sdp: Called in wrong state: have-local-offer
if(self.direction == MLCallDirectionOutgoing)
[self offerSDP];
//start connecting timeout if not already running (but leave it running if so, because we don't want to create endless reconnect loops
if(self.cancelConnectingTimeout == nil)
[self createReconnectingTimeoutTimer];
}
}
-(void) handleConnectivityChange:(NSNotification*) notification
{
//only handle connectivity change if we switched to unreachable
if(self.wasConnectedOnce && self.isConnected && !self.isReconnecting && [notification.userInfo[@"reachable"] boolValue] == NO)
{
DDLogDebug(@"Connectivity changed, restarting ICE...");
//this will reconnect and use the (possibly still working) old connection until
//the new connection is usable, then transparently switch over to the new one
[self restartIce];
}
else
DDLogDebug(@"Not restarting ICE because of connectivity change: was never connected");
}
*/
-(void) offerSDP
{
//see https://webrtc.googlesource.com/src/+/refs/heads/main/sdk/objc/api/peerconnection/RTCSessionDescription.h
[self.webRTCClient offerWithCompletion:^(RTCSessionDescription* sdp) {
DDLogDebug(@"WebRTC reported local SDP '%@', sending to '%@': %@", [RTCSessionDescription stringForType:sdp.type], self.fullRemoteJid, sdp.sdp);
NSArray<MLXMLNode*>* children = [HelperTools sdp2xml:sdp.sdp withInitiator:YES];
if(children.count == 0)
{
DDLogError(@"Could not serialize local SDP to XML!");
[self handleEndCallActionWithReason:MLCallFinishReasonError];
return;
}
//we don't encrypt anything if encryption is not enabled for this contact or if the remote did not send us their deviceid
if(self.contact.isEncrypted && self.remoteOmemoDeviceId != nil && [self encryptFingerprintsInChildren:children])
{
//we are encrypted now (if the remote can't decrypt this or answers with a cleartext fingerprint, we throw a security error later on)
self.encryptionState = [self encryptionTypeForDeviceid:self.remoteOmemoDeviceId];
}
else
self.encryptionState = MLCallEncryptionStateClear;
XMPPIQ* sdpIQ = [[XMPPIQ alloc] initWithType:kiqSetType to:self.fullRemoteJid];
[sdpIQ addChildNode:[[MLXMLNode alloc] initWithElement:@"jingle" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{
@"action": @"session-initiate",
@"sid": self.jmiid,
} andChildren:children andData:nil]];
@synchronized(self.candidateQueueLock) {
self.localSDP = sdpIQ;
}
[self.account sendIq:sdpIQ withResponseHandler:^(XMPPIQ* result) {
DDLogDebug(@"Received SDP response for offer: %@", result);
} andErrorHandler:^(XMPPIQ* error) {
DDLogError(@"Got error for SDP offer: %@", error);
}];
}];
}
-(void) sendJmiPropose
{
DDLogDebug(@"Proposing new call via JMI: %@", self);
NSMutableArray* descriptions = [NSMutableArray new];
[descriptions addObject:[[MLXMLNode alloc] initWithElement:@"description" andNamespace:@"urn:xmpp:jingle:apps:rtp:1" withAttributes:@{@"media": @"audio"} andChildren:@[] andData:nil]];
if(self.callType == MLCallTypeVideo)
[descriptions addObject:[[MLXMLNode alloc] initWithElement:@"description" andNamespace:@"urn:xmpp:jingle:apps:rtp:1" withAttributes:@{@"media": @"video"} andChildren:@[] andData:nil]];
XMPPMessage* jmiNode = [[XMPPMessage alloc] initToContact:self.contact];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"propose" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:descriptions andData:nil]];
[jmiNode setStoreHint];
self.jmiPropose = jmiNode;
[self.account send:jmiNode];
//abort if no device responds with "ringing" in time
[self createDiscoveringTimeoutTimer];
}
-(void) sendJmiReject
{
DDLogDebug(@"Rejecting via JMI: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.fullRemoteJid];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"reject" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"busy"]
] andData:nil]
] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
}
-(void) sendJmiRejectWithTieBreak
{
DDLogDebug(@"Rejecting with tie-break via JMI: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.fullRemoteJid];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"reject" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"expired"]
] andData:nil],
[[MLXMLNode alloc] initWithElement:@"tie-break"]
] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
}
-(void) sendJmiRinging
{
DDLogDebug(@"Ringing via JMI: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.fullRemoteJid];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"ringing" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
}
-(void) sendJmiProceed
{
DDLogDebug(@"Accepting via JMI: %@", self);
//xep 0353 mandates bare jid, but daniel will update it to mandate full jid
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.fullRemoteJid];
MLXMLNode* proceedElement = [[MLXMLNode alloc] initWithElement:@"proceed" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[] andData:nil];
//only offer omemo deviceid for encryption if encryption is enabled for this contact
if(self.contact.isEncrypted)
{
//see https://gist.github.com/iNPUTmice/aa4fc0aeea6ce5fb0e0fe04baca842cd
[proceedElement addChildNode:[[MLXMLNode alloc] initWithElement:@"device" andNamespace:@"http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification" withAttributes:@{
@"id": [self.account.omemo getDeviceId],
} andChildren:@[] andData:nil]];
}
[jmiNode addChildNode:proceedElement];
[jmiNode setStoreHint];
self.jmiProceed = jmiNode;
[self.account send:jmiNode];
}
-(void) sendJmiFinishWithReason:(NSString*) reason
{
DDLogVerbose(@"Finishing via jingle: %@", self);
XMPPIQ* jingleIQ = [[XMPPIQ alloc] initWithType:kiqSetType to:self.fullRemoteJid];
[jingleIQ addChildNode:[[MLXMLNode alloc] initWithElement:@"jingle" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{
@"action": @"session-terminate",
@"sid": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:reason]
] andData:nil]
] andData:nil]];
[self.account send:jingleIQ];
DDLogDebug(@"Finishing via JMI: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.fullRemoteJid];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"finish" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:reason]
] andData:nil]
] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
}
-(void) sendJmiRetract
{
DDLogDebug(@"Retracting via JMI: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initToContact:self.contact];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"retract" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"cancel"]
] andData:nil]
] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
}
-(void) sendJmiRetractWithTieBreak
{
DDLogDebug(@"Retracting via JMI: %@", self);
XMPPMessage* jmiNode = [[XMPPMessage alloc] initToContact:self.contact];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"retract" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"reason" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"cancel"]
] andData:nil]
] andData:nil]];
[jmiNode setStoreHint];
[self.account send:jmiNode];
}
-(NSString*) description
{
NSString* state;
switch(self.state)
{
case MLCallStateDiscovering: state = @"discovering"; break;
case MLCallStateRinging: state = @"ringing"; break;
case MLCallStateConnecting: state = @"connecting"; break;
case MLCallStateReconnecting: state = @"reconnecting"; break;
case MLCallStateConnected: state = @"connected"; break;
case MLCallStateFinished: state = @"finished"; break;
case MLCallStateUnknown: state = @"unknown"; break;
default: state = @"undefined"; break;
}
return [NSString stringWithFormat:@"%@Call:%@",
self.direction == MLCallDirectionIncoming ? @"Incoming" : @"Outgoing",
@{
@"uuid": self.uuid,
@"jmiid": self.jmiid,
@"state": state,
@"finishReason": @(self.finishReason),
@"durationTime": @(self.durationTime),
@"contact": nilWrapper(self.contact),
@"fullRemoteJid": nilWrapper(self.fullRemoteJid),
@"jmiPropose": nilWrapper(self.jmiPropose),
@"jmiProceed": nilWrapper(self.jmiProceed),
@"webRTCClient": nilWrapper(self.webRTCClient),
@"providerAnswerAction": nilWrapper(self.providerAnswerAction),
@"wasConnectedOnce": bool2str(self.wasConnectedOnce),
@"isConnected": bool2str(self.isConnected),
@"isReconnecting": bool2str(self.isReconnecting),
@"hasLocalSDP": bool2str(self.localSDP != nil),
@"hasRemoteSDP": bool2str(self.remoteSDP != nil),
@"remoteOmemoDeviceId": nilWrapper(self.remoteOmemoDeviceId),
@"encryptionState": @(self.encryptionState),
}
];
}
-(NSString*) short
{
return [NSString stringWithFormat:@"%@Call:%@{%@}", self.direction == MLCallDirectionIncoming ? @"Incoming" : @"Outgoing", self.uuid, self.jmiid];
}
-(BOOL) isEqualToContact:(MLContact*) contact
{
return [self.contact isEqualToContact:contact];
}
-(BOOL) isEqualToCall:(MLCall*) call
{
return [self.uuid isEqual:call.uuid];
}
-(BOOL) isEqual:(id _Nullable) object
{
if(object == nil || self == object)
return YES;
else if([object isKindOfClass:[MLContact class]])
return [self isEqualToContact:(MLContact*)object];
else if([object isKindOfClass:[MLCall class]])
return [self isEqualToCall:(MLCall*)object];
else
return NO;
}
-(NSUInteger) hash
{
return [self.uuid hash];
}
#pragma mark - WebRTCClientDelegate
-(void) webRTCClient:(WebRTCClient*) webRTCClient didDiscoverLocalCandidate:(RTCIceCandidate*) candidate
{
@synchronized(self) {
if(webRTCClient != self.webRTCClient)
{
DDLogDebug(@"%@: Ignoring discovered local ICE candidate: %@ (call migrated)", [self short], candidate);
return;
}
DDLogDebug(@"%@: Discovered local ICE candidate destined for '%@': %@", [self short], self.fullRemoteJid, candidate);
//set ufrag to nil, it will be automatically filled via candidate.sdp
//extract the pwd from our outgoing offer using the sdpMid to identify the correct <content/> element
NSString* localPwd = [self.localSDP findFirst:@"{urn:xmpp:jingle:1}jingle/content<name=%@>/{urn:xmpp:jingle:transports:ice-udp:1}transport@pwd", candidate.sdpMid];
MLXMLNode* contentNode = [HelperTools candidate2xml:candidate.sdp withMid:candidate.sdpMid pwd:localPwd ufrag:nil andInitiator:self.direction==MLCallDirectionOutgoing];
if(contentNode == nil)
{
DDLogError(@"Failed to convert raw sdp candidate to jingle, ignoring this candidate: %@", candidate);
return;
}
#ifdef IS_ALPHA
if([contentNode check:@"{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate<protocol=tcp>"])
{
//add tcptype because that attribute is apparently not supported by our mozilla sdp lib
MLXMLNode* candidateNode = [contentNode findFirst:@"{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate"];
if([candidate.sdp containsString:@"typ host tcptype active"])
candidateNode.attributes[@"tcptype"] = @"active";
else if([candidate.sdp containsString:@"typ host tcptype passive"])
candidateNode.attributes[@"tcptype"] = @"passive";
else
DDLogWarn(@"Unknown type-tcptype combination!");
}
#else
if([contentNode check:@"{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate<protocol=tcp>"])
{
DDLogError(@"Ignoring raw sdp candidate, because it's using tcp instead of udp: %@", candidate);
return;
}
#endif
//see https://webrtc.googlesource.com/src/+/refs/heads/main/sdk/objc/api/peerconnection/RTCIceCandidate.h
XMPPIQ* candidateIq = [[XMPPIQ alloc] initWithType:kiqSetType to:self.fullRemoteJid];
[candidateIq addChildNode:[[MLXMLNode alloc] initWithElement:@"jingle" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{
@"action": @"transport-info",
@"sid": self.jmiid,
} andChildren:@[contentNode] andData:nil]];
@synchronized(self.candidateQueueLock) {
//queue candidate if sdp offer or answer have not been processed yet
if(self.remoteSDP == nil || self.localSDP == nil)
{
DDLogDebug(@"Adding outgoing ICE candidate iq to candidate queue: %@", candidateIq);
[self.outgoingCandidateQueue addObject:candidateIq];
return;
}
}
[self.account sendIq:candidateIq withResponseHandler:^(XMPPIQ* result) {
DDLogDebug(@"%@: Received outgoing ICE candidate result: %@", [self short], result);
} andErrorHandler:^(XMPPIQ* error) {
DDLogError(@"%@: Got error for outgoing ICE candidate: %@", [self short], error);
}];
}
}
-(void) webRTCClient:(WebRTCClient*) webRTCClient didChangeConnectionState:(RTCIceConnectionState) state
{
@synchronized(self) {
if(webRTCClient != self.webRTCClient)
{
DDLogInfo(@"Ignoring new RTCIceConnectionState %ld for webRTCClient: %@ (call migrated)", (long)state, webRTCClient);
return;
}
if(self.isFinished)
{
DDLogInfo(@"Ignoring new RTCIceConnectionState %ld for webRTCClient: %@ (call already finished)", (long)state, webRTCClient);
return;
}
//state enums can be found over here: https://chromium.googlesource.com/external/webrtc/+/9eeb6240c93efe2219d4d6f4cf706030e00f64d7/webrtc/sdk/objc/Framework/Headers/WebRTC/RTCPeerConnection.h
DDLogDebug(@"New RTCIceConnectionState %ld for webRTCClient: %@", (long)state, webRTCClient);
//we *always* want to cancel the running iceRestart timer once the state changes
if(self.cancelWaitUntilIceRestart != nil)
{
self.cancelWaitUntilIceRestart();
self.cancelWaitUntilIceRestart = nil;
}
switch(state)
{
case RTCIceConnectionStateConnected:
DDLogInfo(@"New WebRTC ICE state: connected, falling through to completed...");
case RTCIceConnectionStateCompleted:
DDLogInfo(@"New WebRTC ICE state: completed: %@", self);
self.isConnected = YES;
self.isReconnecting = NO;
//at this stage this means the call is incoming (--> fulfill callkit answer action to update ui to reflect connected call)
if(self.direction == MLCallDirectionIncoming)
{
DDLogInfo(@"Informing CallKit of successful connection of incoming call...");
[self.providerAnswerAction fulfill];
}
//otherwise the call was outgoing (--> initialize callkit ui for outgoing call, we are connected now)
else
{
DDLogInfo(@"Informing CallKit of successful connection of outgoing call...");
[self.voipProcessor.cxProvider reportOutgoingCallWithUUID:self.uuid connectedAtDate:nil];
}
break;
case RTCIceConnectionStateDisconnected:
DDLogInfo(@"New WebRTC ICE state: disconnected: %@", self);
/*if(self.wasConnectedOnce)
{
//wait some time before restarting ice (maybe the connection can be reestablished without a new candidate exchange)
//see: https://groups.google.com/g/discuss-webrtc/c/I4K8NwN4Huw
//see: https://webrtccourse.com/course/webrtc-codelab/module/fiddle-of-the-month/lesson/ice-restarts/
//see: https://medium.com/@fippo/ice-restarts-5d759caceda6
self.cancelWaitUntilIceRestart = createTimer(2.0, (^{
[self restartIce];
}));
}
else
[self end];*/
//wait some time for other jmi and jingle stanzas to arrive (these may contain call end reasons we want to process)
[self delayedEnd:2.0 withDisconnectedState:YES];
break;
case RTCIceConnectionStateFailed:
DDLogInfo(@"New WebRTC ICE state: failed: %@", self);
/*if(self.wasConnectedOnce)
[self restartIce];
else
[self end];*/
self.isConnected = NO; //will result in MLCallFinishReasonConnectivityError if wasConnectedOnce == YES
[self end];
break;
//all following states can be ignored
case RTCIceConnectionStateClosed:
DDLogInfo(@"New WebRTC ICE state: closed: %@", self);
break;
case RTCIceConnectionStateNew:
DDLogInfo(@"New WebRTC ICE state: new: %@", self);
break;
case RTCIceConnectionStateChecking:
DDLogInfo(@"New WebRTC ICE state: checking: %@", self);
break;
case RTCIceConnectionStateCount:
DDLogInfo(@"New WebRTC ICE state: count: %@", self);
break;
default:
DDLogInfo(@"New WebRTC ICE state: UNKNOWN: %@", self);
break;
}
}
}
-(void) webRTCClient:(WebRTCClient*) webRTCClient didReceiveData:(NSData*) data
{
if(webRTCClient != self.webRTCClient)
{
DDLogDebug(@"Ignoring received WebRTC data: %@ (call migrated)", data);
return;
}
DDLogDebug(@"Received WebRTC data: %@", data);
}
#pragma mark - ICE handling
-(void) processIncomingICECandidate:(NSNotification*) notification
{
DDLogInfo(@"Got new incoming ICE candidate...");
xmpp* account = notification.object;
NSDictionary* userInfo = notification.userInfo;
//ignore sdp for disabled accounts
if(account != [[MLXMPPManager sharedInstance] getEnabledAccountForID:account.accountID])
return;
//don't use self.account because that asserts on nil
if(self.contact.account == nil)
return;
XMPPIQ* iqNode = userInfo[@"iqNode"];
NSString* jmiid = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle@sid"];
if(![account.accountID isEqualToNumber:self.account.accountID] || ![self.jmiid isEqual:jmiid])
{
DDLogInfo(@"Incoming ICE candidate not matching %@, ignoring...", [self short]);
return;
}
@synchronized(self.candidateQueueLock) {
//queue candidate if sdp offer or answer have not been processed yet
if(self.remoteSDP == nil || self.localSDP == nil)
{
DDLogDebug(@"Adding incoming ICE candidate iq to candidate queue: %@", iqNode);
[self.incomingCandidateQueue addObject:iqNode];
return;
}
}
[self processRemoteICECandidate:iqNode];
}
-(void) processRemoteICECandidate:(XMPPIQ*) iqNode
{
RTCIceCandidate* incomingCandidate = nil;
NSString* rawSdp = [HelperTools xml2candidate:[iqNode findFirst:@"{urn:xmpp:jingle:1}jingle"] withInitiator:self.direction==MLCallDirectionIncoming];
#ifdef IS_ALPHA
if([iqNode check:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate<protocol=tcp>"])
{
NSString* type = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate@type"];
NSString* tcptype = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate@tcptype"];
DDLogDebug(@"Patching raw sdp type=%@ to contain tcptype: %@", type, tcptype);
rawSdp = [rawSdp stringByReplacingOccurrencesOfString:[NSString stringWithFormat:@"typ %@", type] withString:[NSString stringWithFormat:@"typ %@ tcptype %@", type, tcptype]];
}
#else
if([iqNode check:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate<protocol=tcp>"])
{
DDLogWarn(@"Got tcp candidate, ignoring: %@", [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:transports:ice-udp:1}transport/candidate"]);
rawSdp = nil;
}
#endif
DDLogVerbose(@"Got raw remote sdp: %@", rawSdp);
if(rawSdp == nil)
{
DDLogError(@"Failed to convert jingle candidate to raw sdp!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"bad-request" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
//don't be too harsh and not end the call here
//[self handleEndCallActionWithReason:MLCallFinishReasonError];
return;
}
//calculate correct mLineIndex by searching for the corresponding mid (e.g. content@name) in the list of contents advertised in our offer
NSString* sdpMid = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle/content@name"];
NSArray<MLXMLNode*>* offeredMedia = [self.remoteSDP find:@"{urn:xmpp:jingle:1}jingle/content"];
NSUInteger mLineIndex = 0;
for(; mLineIndex < [offeredMedia count]; mLineIndex++)
if([sdpMid isEqualToString:offeredMedia[mLineIndex].attributes[@"name"]])
{
incomingCandidate = [[RTCIceCandidate alloc] initWithSdp:rawSdp sdpMLineIndex:(int)mLineIndex sdpMid:sdpMid];
break;
}
if(mLineIndex == [offeredMedia count])
DDLogError(@"Could not find content element with mid='%@' in remoteSDP!", sdpMid);
if(incomingCandidate == nil)
{
DDLogError(@"incomingCandidate is unexpectedly nil, ignoring!");
[self.account send:[[XMPPIQ alloc] initAsResponseTo:iqNode]];
return;
// XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
// [errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
// [[MLXMLNode alloc] initWithElement:@"bad-request" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
// ] andData:nil]];
// [self.account send:errorIq];
//
// //don't be too harsh and not end the call here
// //[self handleEndCallActionWithReason:MLCallFinishReasonError];
// return;
}
DDLogInfo(@"%@: Got remote ICE candidate for call: %@", self, incomingCandidate);
NSString* remoteUfrag = [self.remoteSDP findFirst:@"{urn:xmpp:jingle:1}jingle/content<name=%@>/{urn:xmpp:jingle:transports:ice-udp:1}transport@ufrag", incomingCandidate.sdpMid];
NSString* remotePwd = [self.remoteSDP findFirst:@"{urn:xmpp:jingle:1}jingle/content<name=%@>/{urn:xmpp:jingle:transports:ice-udp:1}transport@pwd", incomingCandidate.sdpMid];
NSString* candidateUfrag = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle/content<name=%@>/{urn:xmpp:jingle:transports:ice-udp:1}transport@ufrag", incomingCandidate.sdpMid];
NSString* candidatePwd = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle/content<name=%@>/{urn:xmpp:jingle:transports:ice-udp:1}transport@pwd", incomingCandidate.sdpMid];
if(remotePwd == nil || remoteUfrag == nil || ![remoteUfrag isEqualToString:candidateUfrag] || ![remotePwd isEqualToString:candidatePwd])
{
DDLogError(@"Jingle incoming candidate has wrong pwd or ufrag: incomingCandidate.ufrag='%@', incomingCandidate.pwd='%@', remoteSDP.ufrag='%@', remoteSDP.pwd='%@'", candidateUfrag, candidatePwd, remoteUfrag, remotePwd);
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"auth"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-authorized" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
//don't be too harsh and not end the call here
//[self handleEndCallActionWithReason:MLCallFinishReasonError];
return;
}
weakify(self);
[self.webRTCClient setRemoteCandidate:incomingCandidate completion:^(id error) {
strongify(self);
DDLogDebug(@"Got setRemoteCandidate callback...");
if(error)
{
DDLogError(@"Got error while passing new remote ICE candidate to webRTCClient: %@", error);
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-acceptable" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
//don't be too harsh and not end the call here
//[self handleEndCallActionWithReason:MLCallFinishReasonError];
}
else
{
DDLogDebug(@"Successfully passed new remote ICE candidate to webRTCClient...");
[self.account send:[[XMPPIQ alloc] initAsResponseTo:iqNode]];
}
}];
DDLogDebug(@"Leaving method...");
}
-(void) processIncomingSDP:(NSNotification*) notification
{
DDLogInfo(@"Got new incoming SDP...");
xmpp* account = notification.object;
NSDictionary* userInfo = notification.userInfo;
//ignore sdp for disabled accounts
if(account != [[MLXMPPManager sharedInstance] getEnabledAccountForID:account.accountID])
return;
//don't use self.account because that asserts on nil
if(self.contact.account == nil)
return;
XMPPIQ* iqNode = userInfo[@"iqNode"];
NSString* jmiid = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle@sid"];
if(![account.accountID isEqualToNumber:self.account.accountID] || ![self.jmiid isEqual:jmiid])
{
DDLogInfo(@"Ignoring incoming SDP not matching: %@", self);
return;
}
//make sure we don't handle incoming sdp twice
if(self.remoteSDP != nil && [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action~^session-(initiate|accept)$>"])
{
DDLogWarn(@"Got new remote sdp but we already got one, ignoring! MITM/DDOS??");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"cancel"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"conflict" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
return;
}
NSString* rawSDP;
NSString* type;
if([iqNode check:@"{urn:xmpp:jingle:1}jingle<action~^session-(initiate|accept)$>"])
{
if(
([iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action=session-accept>"] && self.direction != MLCallDirectionOutgoing) ||
([iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action=session-initiate>"] && self.direction != MLCallDirectionIncoming)
) {
DDLogWarn(@"Unexpected incoming jingle data direction, ignoring: %@", iqNode);
return;
}
//don't change iqNode directly to not influence code outside of this method
iqNode = [iqNode copy];
//handle candidates in initial sdp (our webrtc lib does not like them --> fake transport-info iqs for these)
//(candidates in initial jingle are allowed by xep!)
@synchronized(self.candidateQueueLock) {
for(MLXMLNode* content in [iqNode find:@"{urn:xmpp:jingle:1}jingle/content"])
{
MLXMLNode* transport = [content findFirst:@"{urn:xmpp:jingle:transports:ice-udp:1}transport"];
for(MLXMLNode* candidate in [transport find:@"{urn:xmpp:jingle:transports:ice-udp:1}candidate"])
{
XMPPIQ* fakeCandidateIQ = [[XMPPIQ alloc] initWithType:kiqSetType];
fakeCandidateIQ.from = self.fullRemoteJid;
fakeCandidateIQ.to = self.account.connectionProperties.identity.fullJid;
MLXMLNode* shallowTransport = [transport shallowCopyWithData:YES];
[shallowTransport addChildNode:[transport removeChildNode:candidate]];
MLXMLNode* shallowContent = [content shallowCopyWithData:YES];
[shallowContent addChildNode:shallowTransport];
[fakeCandidateIQ addChildNode:[[MLXMLNode alloc] initWithElement:@"jingle" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{
@"action": @"transport-info",
@"sid": self.jmiid,
} andChildren:@[shallowContent] andData:nil]];
DDLogDebug(@"Adding fake candidate iq to candidate queue: %@", fakeCandidateIQ);
[self.incomingCandidateQueue addObject:fakeCandidateIQ];
}
}
}
//decrypt fingerprint, if needed (use iqNode copy created above to not influence code outside of this method)
//only decrypt if encryption is enabled for this contact
if(self.contact.isEncrypted)
{
//if this is a session-initiate and we can decrypt the fingerprint using the given deviceid, this call is encrypted now
//if we can NOT decrypt anything, but have a remote deviceid (e.g. the iq contains an omemo envelope), this is a security error
if([iqNode check:@"{urn:xmpp:jingle:1}jingle<action=session-initiate>"])
{
//save omemo deviceid if we got a session-initiate for this (incoming) call
self.remoteOmemoDeviceId = [iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action=session-initiate>/{urn:xmpp:jingle:1}content/{urn:xmpp:jingle:transports:ice-udp:1}transport/{http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification}fingerprint/{eu.siacs.conversations.axolotl}encrypted/header@sid|uint"];
if(self.remoteOmemoDeviceId != nil)
{
if([self decryptFingerprintsInIqNode:iqNode])
self.encryptionState = [self encryptionTypeForDeviceid:self.remoteOmemoDeviceId];
else
{
DDLogError(@"Could not decrypt remote SDP session-initiate fingerprint with OMEMO!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-acceptable" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
[[MLXMLNode alloc] initWithElement:@"text" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas" andData:@"Could not decrypt call with OMEMO!"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonSecurityError];
return;
}
}
else
self.encryptionState = MLCallEncryptionStateClear;
}
//if this is a session-accept after sending an encrypted session-initiate and we can NOT decrypt the fingerprint,
//this call is a security error (if we can decrypt it, everything is fine and the call is secured)
if([iqNode check:@"{urn:xmpp:jingle:1}jingle<action=session-accept>"])
{
//we don't need to check self.remoteOmemoDeviceId, because self.encryptionState will only be different to
//MLCallEncryptionStateClear if the deviceid is not nil
if(self.encryptionState != MLCallEncryptionStateClear && ![self decryptFingerprintsInIqNode:iqNode])
{
DDLogError(@"Could not decrypt remote SDP session-accept fingerprint with OMEMO!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-acceptable" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
[[MLXMLNode alloc] initWithElement:@"text" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas" andData:@"Could not decrypt call with OMEMO!"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonSecurityError];
return;
}
}
}
else
self.encryptionState = MLCallEncryptionStateClear;
//check if the jingle offer/response contains only the media that got advertised in jmi and throw a security error otherwise
if(self.callType == MLCallTypeAudio && [iqNode check:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:apps:rtp:1}description<media=video>"])
{
DDLogError(@"Security: jingle advertises video while jmi only contained audio, aborting call!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-acceptable" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
[[MLXMLNode alloc] initWithElement:@"text" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas" andData:@"Sent video in jingle, but only advertised audio in jmi!"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonSecurityError];
return;
}
//now handle the jingle offer/response nodes and convert jingle xml to sdp
if([iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action=session-accept>"])
{
type = @"answer";
rawSDP = [HelperTools xml2sdp:[iqNode findFirst:@"{urn:xmpp:jingle:1}jingle"] withInitiator:NO];
}
else if([iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action=session-initiate>"])
{
type = @"offer";
rawSDP = [HelperTools xml2sdp:[iqNode findFirst:@"{urn:xmpp:jingle:1}jingle"] withInitiator:YES];
}
}
//handle session-terminate: fake jmi finish message and handle it
else if([iqNode findFirst:@"{urn:xmpp:jingle:1}jingle<action=session-terminate>"])
{
DDLogDebug(@"Got jingle session-terminate, faking incoming jmi:finish for Conversations compatibility...");
XMPPMessage* jmiNode = [[XMPPMessage alloc] initWithType:kMessageChatType to:self.account.connectionProperties.identity.jid];
[jmiNode addChildNode:[[MLXMLNode alloc] initWithElement:@"finish" andNamespace:@"urn:xmpp:jingle-message:0" withAttributes:@{
@"id": self.jmiid,
} andChildren:[iqNode find:@"{urn:xmpp:jingle:1}jingle<action=session-terminate>/reason"] andData:nil]];
[jmiNode setStoreHint];
[self.voipProcessor handleIncomingJMIStanza:jmiNode onAccount:self.account];
return;
}
else
{
DDLogWarn(@"Unexpected incoming jingle type, ignoring: %@", iqNode);
return;
}
DDLogVerbose(@"rawSDP(%@)=%@", type, rawSDP);
if(rawSDP == nil)
{
DDLogError(@"Failed to convert jingle to raw sdp!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"bad-request" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonError];
return;
}
//convert raw sdp string to RTCSessionDescription object
RTCSessionDescription* resultSDP = [[RTCSessionDescription alloc] initWithType:[RTCSessionDescription typeForString:type] sdp:rawSDP];
if(resultSDP == nil)
{
DDLogError(@"resultSDP is unexpectedly nil!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"bad-request" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonError];
return;
}
DDLogInfo(@"%@: Got remote SDP for call: %@", self, resultSDP);
@synchronized(self.candidateQueueLock) {
self.remoteSDP = iqNode;
}
//this is blocking (e.g. no need for an inner @synchronized)
weakify(self);
[self.webRTCClient setRemoteSdp:resultSDP completion:^(id error) {
strongify(self);
if(error)
{
DDLogError(@"Got error while passing remote SDP to webRTCClient: %@", error);
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-acceptable" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonError];
return;
}
else
{
DDLogDebug(@"Successfully passed SDP to webRTCClient...");
//only send a "session-accept" if the remote is the initiator (e.g. this is an incoming call)
if(self.direction == MLCallDirectionIncoming)
{
[self.webRTCClient answerWithCompletion:^(RTCSessionDescription* localSdp) {
DDLogDebug(@"Sending SDP answer back...");
NSArray<MLXMLNode*>* children = [HelperTools sdp2xml:localSdp.sdp withInitiator:NO];
//we got a session-initiate jingle iq
//--> self.encryptionState will NOT be MLCallEncryptionStateClear, if that iq contained an encrypted fingerprint,
//--> self.encryptionState WILL be MLCallEncryptionStateClear, if it did not contain such an encrypted fingerprint
//(in this case we just don't try to decrypt anything, the call will simply be unencrypted but continue)
//we don't need to check self.remoteOmemoDeviceId, because self.encryptionState will only be different to
//MLCallEncryptionStateClear if the deviceid is not nil
if(self.encryptionState != MLCallEncryptionStateClear && ![self encryptFingerprintsInChildren:children])
{
DDLogError(@"Could not encrypt local SDP response fingerprint with OMEMO!");
XMPPIQ* errorIq = [[XMPPIQ alloc] initAsErrorTo:iqNode];
[errorIq addChildNode:[[MLXMLNode alloc] initWithElement:@"error" withAttributes:@{@"type": @"modify"} andChildren:@[
[[MLXMLNode alloc] initWithElement:@"not-acceptable" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas"],
[[MLXMLNode alloc] initWithElement:@"text" andNamespace:@"urn:ietf:params:xml:ns:xmpp-stanzas" andData:@"Could not encrypt call with OMEMO!"],
] andData:nil]];
[self.account send:errorIq];
[self handleEndCallActionWithReason:MLCallFinishReasonSecurityError];
return;
}
[self.account send:[[XMPPIQ alloc] initAsResponseTo:iqNode]];
XMPPIQ* sdpIQ = [[XMPPIQ alloc] initWithType:kiqSetType to:self.fullRemoteJid];
[sdpIQ addChildNode:[[MLXMLNode alloc] initWithElement:@"jingle" andNamespace:@"urn:xmpp:jingle:1" withAttributes:@{
@"action": @"session-accept",
@"sid": self.jmiid,
} andChildren:children andData:nil]];
[self.account send:sdpIQ];
@synchronized(self.candidateQueueLock) {
self.localSDP = sdpIQ;
DDLogDebug(@"Now handling queued incoming candidate iqs: %lu", (unsigned long)self.incomingCandidateQueue.count);
for(XMPPIQ* candidateIq in self.incomingCandidateQueue)
[self processRemoteICECandidate:candidateIq];
}
}];
}
else
{
[self.account send:[[XMPPIQ alloc] initAsResponseTo:iqNode]];
@synchronized(self.candidateQueueLock) {
DDLogDebug(@"Now handling queued incoming candidate iqs: %lu", (unsigned long)self.incomingCandidateQueue.count);
for(XMPPIQ* candidateIq in self.incomingCandidateQueue)
[self processRemoteICECandidate:candidateIq];
}
}
@synchronized(self.candidateQueueLock) {
DDLogDebug(@"Now sending queued outgoing candidate iqs: %lu", (unsigned long)self.outgoingCandidateQueue.count);
for(XMPPIQ* candidateIq in self.outgoingCandidateQueue)
[self.account sendIq:candidateIq withResponseHandler:^(XMPPIQ* result) {
DDLogDebug(@"%@: Received outgoing ICE candidate result: %@", [self short], result);
} andErrorHandler:^(XMPPIQ* error) {
DDLogError(@"%@: Got error for outgoing ICE candidate: %@", [self short], error);
}];
}
}
}];
DDLogDebug(@"Leaving method...");
}
-(void) handleAudioRouteChangeNotification:(NSNotification*) notification
{
DDLogVerbose(@"Audio route changed: %@", notification);
DDLogVerbose(@"Current audio route: %@", self.audioSession.currentRoute);
BOOL speaker = NO;
for(AVAudioSessionPortDescription* port in self.audioSession.currentRoute.outputs)
if(port.portType == AVAudioSessionPortBuiltInSpeaker)
speaker = YES;
if(speaker)
self.speaker = YES;
else
self.speaker = NO;
}
-(MLCallEncryptionState) encryptionTypeForDeviceid:(NSNumber* _Nonnull) deviceid
{
NSNumber* trustLevel = [self.account.omemo getTrustLevelForJid:self.contact.contactJid andDeviceId:deviceid];
if(trustLevel == nil)
return MLCallEncryptionStateClear;
switch(trustLevel.intValue)
{
case MLOmemoTrusted: return MLCallEncryptionStateTrusted;
case MLOmemoToFU: return MLCallEncryptionStateToFU;
default: return MLCallEncryptionStateClear;
}
}
-(BOOL) encryptFingerprintsInChildren:(NSArray<MLXMLNode*>*) children
{
//don't try to encrypt if the remote deviceid is not trusted
if([self encryptionTypeForDeviceid:self.remoteOmemoDeviceId] == MLCallEncryptionStateClear)
return NO;
//see https://gist.github.com/iNPUTmice/aa4fc0aeea6ce5fb0e0fe04baca842cd
BOOL retval = NO;
for(MLXMLNode* child in children)
for(MLXMLNode* fingerprint in [child find:@"/{urn:xmpp:jingle:1}content/{urn:xmpp:jingle:transports:ice-udp:1}transport/{urn:xmpp:jingle:apps:dtls:0}fingerprint"])
{
MLXMLNode* envelope = [self.account.omemo encryptString:fingerprint.data toDeviceids:@{
self.contact.contactJid: [NSSet setWithArray:@[self.remoteOmemoDeviceId]],
}];
if(envelope == nil)
{
DDLogWarn(@"Could not encrypt fingerprint with OMEMO!");
return NO;
}
[fingerprint addChildNode:envelope];
[fingerprint setXMLNS:@"http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification"];
fingerprint.data = nil;
retval = YES;
}
//this is only true if at least one fingerprint could be found and encrypted (this is normally true)
return retval;
}
-(BOOL) decryptFingerprintsInIqNode:(XMPPIQ*) iqNode
{
//don't try to decrypt if the remote deviceid is not trusted
if([self encryptionTypeForDeviceid:self.remoteOmemoDeviceId] == MLCallEncryptionStateClear)
return NO;
//see https://gist.github.com/iNPUTmice/aa4fc0aeea6ce5fb0e0fe04baca842cd
BOOL retval = NO;
for(MLXMLNode* fingerprintNode in [iqNode find:@"{urn:xmpp:jingle:1}jingle/content/{urn:xmpp:jingle:transports:ice-udp:1}transport/{http://gultsch.de/xmpp/drafts/omemo/dlts-srtp-verification}fingerprint"])
{
//more than one omemo envelope means we are under attack
if([[fingerprintNode find:@"{eu.siacs.conversations.axolotl}encrypted"] count] > 1)
{
DDLogWarn(@"More than one OMEMO envelope found!");
return NO;
}
NSString* decryptedFingerprint = [self.account.omemo decryptOmemoEnvelope:[fingerprintNode findFirst:@"{eu.siacs.conversations.axolotl}encrypted"] forSenderJid:self.contact.contactJid andReturnErrorString:NO];
if(decryptedFingerprint == nil)
{
DDLogWarn(@"Could not decrypt OMEMO encrypted fingerprint!");
return NO;
}
//remove omemo envelope, correct xmlns and add our decrypted fingerprint back in as text content
[fingerprintNode removeChildNode:[fingerprintNode findFirst:@"{eu.siacs.conversations.axolotl}encrypted"]];
[fingerprintNode setXMLNS:@"urn:xmpp:jingle:apps:dtls:0"];
fingerprintNode.data = decryptedFingerprint;
retval = YES;
}
//this is only true if at least one fingerprint could be found and decrypted
//(that could be false, if the remote did something weird or a MITM changed something)
return retval;
}
@end
Reference in a new issue Copy permalink