slambb_smartbow_locations_cn/Classes/Unity/UnityWebRequest.mm

#include <sched.h>

const CFIndex streamSize = 1024;
static NSOperationQueue* webOperationQueue;
static NSURLSession* unityWebRequestSession;

@interface UnityURLRequest : NSMutableURLRequest

@property (readonly, nonatomic) void* udata;
@property (readwrite, nonatomic) NSUInteger taskIdentifier;
@property (readonly, nonatomic) long long estimatedContentLength;
@property (readonly, nonatomic) long long receivedBytes;
@property (readwrite, nonatomic) bool wantCertificateCallback;
@property (readwrite, nonatomic) bool redirecting;
@property (readwrite) bool isDone;

- (id)init:(void*)udata;

@end

static NSMutableArray<UnityURLRequest*>* currentRequests;
static NSLock* currentRequestsLock;

@implementation UnityURLRequest
{
    void* _udata;
    NSUInteger _taskIdentifier;
    long long _estimatedContentLength;
    long long _receivedBytes;
    bool _wantCertificateCallback;
    bool _redirecting;
    bool _isDone;
}

@synthesize udata = _udata;
@synthesize taskIdentifier = _taskIdentifier;
@synthesize estimatedContentLength = _estimatedContentLength;
@synthesize receivedBytes = _receivedBytes;
@synthesize wantCertificateCallback = _wantCertificateCallback;
@synthesize redirecting = _redirecting;
@synthesize isDone = _isDone;

+ (void)storeRequest:(UnityURLRequest *)request taskID:(NSUInteger)taskId
{
    request.taskIdentifier = taskId;
    [currentRequestsLock lock];
    [currentRequests addObject: request];
    [currentRequestsLock unlock];
}

+ (UnityURLRequest*)requestForTask:(NSURLSessionTask*)task
{
    UnityURLRequest* request = nil;
    [currentRequestsLock lock];
    for (unsigned i = 0; i < currentRequests.count; ++i)
        if (currentRequests[i].taskIdentifier == task.taskIdentifier)
        {
            request = currentRequests[i];
            break;
        }
    [currentRequestsLock unlock];
    return request;
}

+ (void)removeRequest:(UnityURLRequest*)request
{
    // removeObject would remove all identical request, taskIdentifier is unique
    [currentRequestsLock lock];
    for (unsigned i = 0; i < currentRequests.count; ++i)
        if (currentRequests[i].taskIdentifier == request.taskIdentifier)
        {
            [currentRequests removeObjectAtIndex: i];
            break;
        }
    [currentRequestsLock unlock];
}

+ (void)writeBody:(NSOutputStream*)outputStream task:(NSURLSessionTask*)task udata:(void*)udata
{
    unsigned dataSize = streamSize;
    BOOL uploadComplete = FALSE;
    while (!uploadComplete)
    {
        dataSize = streamSize;
        const UInt8* data = (const UInt8*)UnityWebRequestGetUploadData(udata, &dataSize);
        if (dataSize == 0)
            break;

        if (outputStream.hasSpaceAvailable)
        {
            NSInteger transmitted = [outputStream write: data maxLength: dataSize];
            if (transmitted > 0)
                UnityWebRequestConsumeUploadData(udata, (unsigned)transmitted);
            else if (transmitted < 0)
                break;
        }
        else
        {
            sched_yield();
        }

        switch (task.state)
        {
            case NSURLSessionTaskStateCanceling:
            case NSURLSessionTaskStateCompleted:
                uploadComplete = TRUE;
                break;
            default:
                uploadComplete = FALSE;
        }
    }
    [outputStream close];
    UnityWebRequestRelease(udata);
}

- (id)init:(void*)udata
{
    self = [super init];
    _udata = udata;
    _taskIdentifier = 0;
    _estimatedContentLength = 0;
    _receivedBytes = 0;
    _wantCertificateCallback = false;
    _redirecting = false;
    _isDone = false;
    return self;
}

- (void)updateEstimatedContentLength:(long long)contentLength
{
    if (contentLength > _estimatedContentLength)
        _estimatedContentLength = contentLength;
}

- (void)updateReceivedBytes:(long long)receivedBytes
{
    _receivedBytes += receivedBytes;
    if (_receivedBytes > _estimatedContentLength)
        _estimatedContentLength = _receivedBytes;
}

@end


@interface UnityWebRequestDelegate : NSObject<NSURLSessionDataDelegate, NSURLSessionTaskDelegate>
@end


@implementation UnityWebRequestDelegate

- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveResponse:(nonnull NSURLResponse *)response completionHandler:(nonnull void (^)(NSURLSessionResponseDisposition))completionHandler
{
    [self handleResponse: response task: dataTask];
    completionHandler(NSURLSessionResponseAllow);
}

- (void)handleResponse:(NSURLResponse*)response task:(NSURLSessionTask*)task
{
    UnityURLRequest* urequest = [UnityURLRequest requestForTask: task];
    if (urequest == nil)
        return;
    if ([response isKindOfClass: [NSHTTPURLResponse class]])
        [self handleHTTPResponse: (NSHTTPURLResponse*)response urequest: urequest];
    else
        [self handleResponse: response urequest: urequest];
}

- (void)handleHTTPResponse:(NSHTTPURLResponse*)response task:(NSURLSessionTask*)task
{
    UnityURLRequest* urequest = [UnityURLRequest requestForTask: task];
    if (urequest == nil)
        return;
    [self handleHTTPResponse: response urequest: urequest];
}

- (void)handleHTTPResponse:(NSHTTPURLResponse*)response urequest:(UnityURLRequest*)urequest
{
    UnityReportWebRequestStatus(urequest.udata, (int)[response statusCode]);
    NSDictionary* respHeader = [response allHeaderFields];
    NSEnumerator* headerEnum = [respHeader keyEnumerator];
    for (id headerKey = [headerEnum nextObject]; headerKey; headerKey = [headerEnum nextObject])
        UnityReportWebRequestResponseHeader(urequest.udata, [headerKey UTF8String], [[respHeader objectForKey: headerKey] UTF8String]);
    [self handleResponse: response urequest: urequest];
}

- (void)handleResponse:(NSURLResponse*)response urequest:(UnityURLRequest*)urequest
{
    [urequest updateEstimatedContentLength: response.expectedContentLength];
    UnityReportWebRequestReceivedResponse(urequest.udata, (unsigned int)urequest.estimatedContentLength);
}

- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
{
    UnityURLRequest* urequest = [UnityURLRequest requestForTask: dataTask];
    if (urequest == nil)
        return;
    [urequest updateEstimatedContentLength: [dataTask countOfBytesExpectedToReceive]];
    [data enumerateByteRangesUsingBlock:^(const void* bytes, NSRange range, BOOL* stop) {
        UnityReportWebRequestReceivedData(urequest.udata, bytes, (unsigned int)range.length, (unsigned int)urequest.estimatedContentLength);
    }];
}

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
{
    UnityURLRequest* urequest = [UnityURLRequest requestForTask: task];
    if (urequest == nil)
        return;
    urequest.redirecting = true;
    [self handleHTTPResponse: response task: task];
    completionHandler(nil);
    [task cancel];
}

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential* credential))completionHandler
{
    if ([[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodServerTrust)
    {
        UnityURLRequest* urequest = [UnityURLRequest requestForTask: task];
        if (urequest == nil || !urequest.wantCertificateCallback)
        {
            completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil);
            return;
        }

#if !defined(DISABLE_WEBREQUEST_CERTIFICATE_CALLBACK)
        SecTrustResultType systemResult;
        SecTrustRef serverTrust = [[challenge protectionSpace] serverTrust];
        if (serverTrust == nil || errSecSuccess != SecTrustEvaluate(serverTrust, &systemResult))
        {
            systemResult = kSecTrustResultOtherError;
        }

        switch (systemResult)
        {
            case kSecTrustResultUnspecified:
            case kSecTrustResultProceed:
            case kSecTrustResultRecoverableTrustFailure:
                break;
            default:
                completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil);
                return;
        }

        SecCertificateRef serverCertificate = SecTrustGetCertificateAtIndex(serverTrust, 0);
        if (serverCertificate != nil)
        {
            CFDataRef serverCertificateData = SecCertificateCopyData(serverCertificate);
            const UInt8* const data = CFDataGetBytePtr(serverCertificateData);
            const CFIndex size = CFDataGetLength(serverCertificateData);
            bool trust = UnityReportWebRequestValidateCertificate(urequest.udata, (const char*)data, (unsigned)size);
            CFRelease(serverCertificateData);
            if (trust)
            {
                NSURLCredential *credential = [NSURLCredential credentialForTrust: challenge.protectionSpace.serverTrust];
                completionHandler(NSURLSessionAuthChallengeUseCredential, credential);
                return;
            }
        }
#endif
        completionHandler(NSURLSessionAuthChallengeCancelAuthenticationChallenge, nil);
        return;
    }
    else
        completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil);
}

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
{
    UnityURLRequest* urequest = [UnityURLRequest requestForTask: task];
    if (urequest == nil)
        return;
    urequest.isDone = true;
    if (urequest.redirecting)
        return;
    if (error != nil)
        UnityReportWebRequestNetworkError(urequest.udata, (int)[error code]);
    UnityReportWebRequestFinishedLoadingData(urequest.udata);
    UnityWebRequestRelease(urequest.udata);
}

@end


extern "C" void* UnityCreateWebRequestBackend(void* udata, const char* methodString, const void* headerDict, const char* url)
{
    @autoreleasepool
    {
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            @autoreleasepool
            {
                webOperationQueue = [[NSOperationQueue alloc] init];
                webOperationQueue.name = @"com.unity3d.WebOperationQueue";
                webOperationQueue.qualityOfService = NSQualityOfServiceUtility;

                currentRequests = [[NSMutableArray<UnityURLRequest*> alloc] init];
                currentRequestsLock = [[NSLock alloc] init];

                NSURLSessionConfiguration* config = [NSURLSessionConfiguration defaultSessionConfiguration];
                UnityWebRequestDelegate* delegate = [[UnityWebRequestDelegate alloc] init];
                unityWebRequestSession = [NSURLSession sessionWithConfiguration: config delegate: delegate delegateQueue: nil];
            }
        });

        UnityURLRequest* request = [[UnityURLRequest alloc] init: udata];
        request.URL = [NSURL URLWithString: [NSString stringWithUTF8String: url]];
        request.HTTPMethod = [NSString stringWithUTF8String: methodString];
        request.allHTTPHeaderFields = (__bridge NSMutableDictionary*)headerDict;
        [request setCachePolicy: NSURLRequestReloadIgnoringLocalCacheData];
        return (__bridge_retained void*)request;
    }
}

extern "C" void UnitySendWebRequest(void* connection, unsigned length, unsigned long timeoutSec, bool wantCertificateCallback)
{
    @autoreleasepool
    {
        UnityURLRequest* request = (__bridge UnityURLRequest*)connection;
        request.timeoutInterval = timeoutSec;
        request.wantCertificateCallback = wantCertificateCallback;

        NSOutputStream* outputStream = nil;
        if (length > 0)
        {
            CFReadStreamRef readStream;
            CFWriteStreamRef writeStream;
            CFStreamCreateBoundPair(kCFAllocatorDefault, &readStream, &writeStream, streamSize);
            CFWriteStreamOpen(writeStream);
            outputStream = (__bridge_transfer NSOutputStream*)writeStream;
            request.HTTPBodyStream = (__bridge_transfer NSInputStream*)readStream;
        }
        NSURLSessionTask* task = [unityWebRequestSession dataTaskWithRequest: request];
        [UnityURLRequest storeRequest: request taskID: task.taskIdentifier];
        [task resume];
        if (length > 0)
            [webOperationQueue addOperationWithBlock:^{
                [UnityURLRequest writeBody: outputStream task: task udata: request.udata];
            }];
    }
}

extern "C" bool UnityWebRequestIsDone(void* connection)
{
    @autoreleasepool
    {
        UnityURLRequest* request = (__bridge UnityURLRequest*)connection;
        return request.isDone;
    }
}

extern "C" void UnityDestroyWebRequestBackend(void* connection)
{
    @autoreleasepool
    {
        UnityURLRequest* request = (__bridge_transfer UnityURLRequest*)connection;
        [UnityURLRequest removeRequest: request];
    }
}

extern "C" void UnityCancelWebRequest(void* connection)
{
    @autoreleasepool
    {
        UnityURLRequest* request = (__bridge UnityURLRequest*)connection;
        [unityWebRequestSession getAllTasksWithCompletionHandler:^(NSArray<NSURLSessionTask*>* _Nonnull tasks) {
            for (unsigned i = 0; i < tasks.count; ++i)
                if (tasks[i].taskIdentifier == request.taskIdentifier)
                {
                    [tasks[i] cancel];
                    break;
                }
        }];
    }
}

extern "C" void UnityWebRequestClearCookieCache(const char* domain)
{
    NSArray<NSHTTPCookie*>* cookies;
    NSHTTPCookieStorage* cookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
    if (domain == NULL)
        cookies = [cookieStorage cookies];
    else
    {
        NSURL* url = [NSURL URLWithString: [NSString stringWithUTF8String: domain]];
        if (url.path == nil || [url.path isEqualToString: [NSString string]])
        {
            NSMutableArray<NSHTTPCookie*>* hostCookies = [[NSMutableArray<NSHTTPCookie *> alloc] init];
            cookies = [cookieStorage cookies];
            NSUInteger cookieCount = [cookies count];
            for (unsigned i = 0; i < cookieCount; ++i)
                if ([cookies[i].domain isEqualToString: url.host])
                    [hostCookies addObject: cookies[i]];
            cookies = hostCookies;
        }
        else
            cookies = [cookieStorage cookiesForURL: url];
    }
    NSUInteger cookieCount = [cookies count];
    for (int i = 0; i < cookieCount; ++i)
        [cookieStorage deleteCookie: cookies[i]];
}