9262560814

Committed 28 May 2024 02:20AM UTC coverage: 62.493% (-0.2%) from 62.648%

Build # 9262560814

Build Type

Pull #1359

github

Committed by

web-flow

Commit Message

Merge cb7277bb0 into 7502bc247

Pull Request Pull Request #1359: sync: Add a protobuf for the existing sync protocol

Run Details

5275 of 12790 branches covered (41.24%)

Branch coverage included in aggregate %.

241 of 288 new or added lines in 5 files covered. (83.68%)

13 existing lines in 2 files now uncovered.

17800 of 24134 relevant lines covered (73.75%)

7143.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.41

/Source/santasyncservice/SNTSyncStage.mm

/// Copyright 2016 Google Inc. All rights reserved.
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///    http://www.apache.org/licenses/LICENSE-2.0
///
///    Unless required by applicable law or agreed to in writing, software
///    distributed under the License is distributed on an "AS IS" BASIS,
///    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
///    See the License for the specific language governing permissions and
///    limitations under the License.

#import "Source/santasyncservice/SNTSyncStage.h"

#import <MOLXPCConnection/MOLXPCConnection.h>

#import "Source/common/SNTCommonEnums.h"
#import "Source/common/SNTConfigurator.h"
#import "Source/common/SNTLogging.h"
#import "Source/common/SNTSyncConstants.h"
#import "Source/common/SNTXPCControlInterface.h"
#import "Source/common/String.h"
#import "Source/santasyncservice/NSData+Zlib.h"
#import "Source/santasyncservice/SNTSyncLogging.h"
#import "Source/santasyncservice/SNTSyncState.h"

#include <google/protobuf/json/json.h>

using santa::common::NSStringToUTF8String;

@interface SNTSyncStage ()

@property(readwrite) NSURLSession *urlSession;
@property(readwrite) SNTSyncState *syncState;
@property(readwrite) MOLXPCConnection *daemonConn;

@end

@implementation SNTSyncStage

- (nullable instancetype)initWithState:(nonnull SNTSyncState *)syncState {
  self = [super init];
  if (self) {
    _syncState = syncState;
    _urlSession = syncState.session;
    _daemonConn = syncState.daemonConn;
  }
  return self;
}

- (BOOL)sync {
  [self doesNotRecognizeSelector:_cmd];
  __builtin_unreachable();
}

- (NSString *)stageURL {
  [self doesNotRecognizeSelector:_cmd];
  __builtin_unreachable();
}

- (NSMutableURLRequest *)requestWithMessage:(google::protobuf::Message *)message {
  NSData *requestBody = [NSData data];
  if (message) {
    google::protobuf::json::PrintOptions options{
      .always_print_enums_as_ints = false,
      .preserve_proto_field_names = true,
    };
    std::string json;
    absl::Status status = google::protobuf::json::MessageToJsonString(*message, &json, options);

    if (!status.ok()) {
      SLOGE(@"Failed to convert protobuf to JSON: %s", status.ToString().c_str());
      return nil;
    }

    SLOGD(@"Request JSON: %s", json.c_str());

    requestBody = [NSData dataWithBytes:json.data() length:json.size()];
  }
  return [self requestWithData:requestBody];
}

- (NSMutableURLRequest *)requestWithDictionary:(NSDictionary *)dictionary {
  NSData *requestBody = [NSData data];
  if (dictionary) {
    NSError *error;
    requestBody = [NSJSONSerialization dataWithJSONObject:dictionary options:0 error:&error];
    if (error) {
      SLOGD(@"Failed to encode JSON request: %@", error);
      return nil;
    }
  }
  return [self requestWithData:requestBody];
}

- (NSMutableURLRequest *)requestWithData:(NSData *)requestBody {
  NSMutableURLRequest *req = [[NSMutableURLRequest alloc] initWithURL:[self stageURL]];
  [req setHTTPMethod:@"POST"];
  [req setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
  NSString *xsrfHeader = self.syncState.xsrfTokenHeader ?: kDefaultXSRFTokenHeader;
  [req setValue:self.syncState.xsrfToken forHTTPHeaderField:xsrfHeader];

  NSData *compressed;
  NSString *contentEncodingHeader;

  switch (self.syncState.contentEncoding) {
    case SNTSyncContentEncodingNone: break;
    case SNTSyncContentEncodingGzip:
      compressed = [requestBody gzipCompressed];
      contentEncodingHeader = @"gzip";
      break;
    case SNTSyncContentEncodingDeflate:
      compressed = [requestBody zlibCompressed];
      contentEncodingHeader = @"deflate";
      break;
    default:
      // This would be a programming error.
      LOGD(@"Unexpected value for content encoding %ld", self.syncState.contentEncoding);
  }

  if (compressed) {
    requestBody = compressed;
    [req setValue:contentEncodingHeader forHTTPHeaderField:@"Content-Encoding"];
  }

  [self addExtraRequestHeaders:req];

  [req setHTTPBody:requestBody];

  return req;
}

- (void)addExtraRequestHeaders:(NSMutableURLRequest *)req {
  NSDictionary *extra = [[SNTConfigurator configurator] syncExtraHeaders];
  [extra enumerateKeysAndObjectsWithOptions:0
                                 usingBlock:^(id key, id object, BOOL *stop) {
                                   if (![key isKindOfClass:[NSString class]] ||
                                       ![object isKindOfClass:[NSString class]])
                                     return;
                                   NSString *k = (NSString *)key;
                                   NSString *v = (NSString *)object;

                                   // This is likely unnecessary as the docs for NSURLSession list
                                   // most of these as being ignored but explicitly setting them
                                   // here is an extra layer of protection.
                                   if ([k isEqualToString:@"Content-Encoding"] ||
                                       [k isEqualToString:@"Content-Length"] ||
                                       [k isEqualToString:@"Content-Type"] ||
                                       [k isEqualToString:@"Connection"] ||
                                       [k isEqualToString:@"Host"] ||
                                       [k isEqualToString:@"Proxy-Authenticate"] ||
                                       [k isEqualToString:@"Proxy-Authorization"] ||
                                       [k isEqualToString:@"WWW-Authenticate"])
                                     return;

                                   [req setValue:v forHTTPHeaderField:k];
                                 }];
}

- (NSData *)dataFromRequest:(NSURLRequest *)request timeout:(NSTimeInterval)timeout {
  NSHTTPURLResponse *response;
  NSError *error;
  NSData *data;

  int maxAttempts = 5;
  for (int attempt = 1; attempt <= maxAttempts; ++attempt) {
    if (attempt >= 2) {
      // Exponentially back off with larger and larger delays.
      int exponentialBackoffMultiplier = 2;  // E.g. 2^2 = 4, 2^3 = 8, 2^4 = 16...
      struct timespec ts = {.tv_sec = __darwin_time_t(pow(exponentialBackoffMultiplier, attempt))};
      nanosleep(&ts, NULL);
    }

    SLOGD(@"Performing request, attempt %d (of %d maximum)...", attempt, maxAttempts);
    data = [self performRequest:request timeout:timeout response:&response error:&error];
    if (response.statusCode == 200) break;

    // If the original request failed because of an auth error, attempt to get a new XSRF token and
    // try again. Unfortunately some servers cause NSURLSession to return 'client cert required' or
    // 'could not parse response' when a 403 occurs and SSL cert auth is enabled.
    if ((response.statusCode == 403 || error.code == NSURLErrorClientCertificateRequired ||
         error.code == NSURLErrorCannotParseResponse) &&
        [self fetchXSRFToken]) {
      NSMutableURLRequest *mutableRequest = [request mutableCopy];
      NSString *xsrfHeader = self.syncState.xsrfTokenHeader ?: kDefaultXSRFTokenHeader;
      [mutableRequest setValue:self.syncState.xsrfToken forHTTPHeaderField:xsrfHeader];
      request = mutableRequest;
      continue;
    }
  }

  // If the final attempt resulted in an error, log the error and return nil.
  if (response.statusCode != 200) {
    long code;
    NSString *errStr;
    if (response.statusCode > 0) {
      code = response.statusCode;
      errStr = [NSHTTPURLResponse localizedStringForStatusCode:response.statusCode];
    } else {
      code = (long)error.code;
      errStr = error.localizedDescription;
    }
    LOGE(@"HTTP Response: %ld %@", code, errStr);
    return nil;
  }
  return data;
}

- (NSError *)performRequest:(NSURLRequest *)request
                intoMessage:(google::protobuf::Message *)message
                    timeout:(NSTimeInterval)timeout {
  NSData *data = [self dataFromRequest:request timeout:timeout];
  if (data.length == 0) return nil;

  google::protobuf::json::ParseOptions options{
    .ignore_unknown_fields = true,
  };
  NSString *jsonData = [[NSString alloc] initWithData:[self stripXssi:data]
                                             encoding:NSUTF8StringEncoding];
  absl::Status status =
    google::protobuf::json::JsonStringToMessage(NSStringToUTF8String(jsonData), message, options);
  if (!status.ok()) {
    SLOGE(@"Failed to parse response JSON into message: %s", status.ToString().c_str());
    return nil;
  }

  return nil;
}

// Returns nil when there is a server connection issue.  For other errors, such as
// an empty response or an unparseable response, an empty dictionary is returned.
- (NSDictionary *)performRequest:(NSURLRequest *)request timeout:(NSTimeInterval)timeout {
  NSData *data = [self dataFromRequest:request timeout:timeout];
  if (data.length == 0) return @{};

  NSError *error;
  NSDictionary *dict = [NSJSONSerialization JSONObjectWithData:[self stripXssi:data]
                                                       options:0
                                                         error:&error];
  if (error) SLOGD(@"Failed to decode JSON response: %@", error);

  return dict ?: @{};
}

- (NSDictionary *)performRequest:(NSURLRequest *)request {
  return [self performRequest:request timeout:30];
}

#pragma mark Internal Helpers

/**
  Perform a data request and capture the returned data, response and error objects.

  @param request The request to perform
  @param timeout The number of seconds to wait before cancelling the request
  @param response Return the response details
  @param error  Return the error details
  @returns data, The HTTP body of the response
*/
- (NSData *)performRequest:(NSURLRequest *)request
                   timeout:(NSTimeInterval)timeout
                  response:(out NSHTTPURLResponse **)response
                     error:(out NSError **)error {
  __block NSData *_data;
  __block NSHTTPURLResponse *_response;
  __block NSError *_error;

  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
  NSURLSessionDataTask *task =
    [self.urlSession dataTaskWithRequest:request
                       completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                         if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
                           _response = (NSHTTPURLResponse *)response;
                         }
                         _data = data;
                         _error = error;
                         dispatch_semaphore_signal(sema);
                       }];
  [task resume];

  if (dispatch_semaphore_wait(sema, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * timeout))) {
    [task cancel];
  }

  if (response) *response = _response;
  if (error) *error = _error;
  return _data;
}

- (NSData *)stripXssi:(NSData *)data {
  static const char xssiOne[5] = {')', ']', '}', '\'', '\n'};
  static const char xssiTwo[3] = {']', ')', '}'};
  if (data.length >= sizeof(xssiOne) &&
      strncmp((const char *)data.bytes, xssiOne, sizeof(xssiOne)) == 0) {
    return [data subdataWithRange:NSMakeRange(sizeof(xssiOne), data.length - sizeof(xssiOne))];
  }
  if (data.length >= sizeof(xssiTwo) &&
      strncmp((const char *)data.bytes, xssiTwo, sizeof(xssiTwo)) == 0) {
    return [data subdataWithRange:NSMakeRange(sizeof(xssiTwo), data.length - sizeof(xssiTwo))];
  }
  return data;
}

- (BOOL)fetchXSRFToken {
  BOOL success = NO;
  if (!self.syncState.xsrfToken.length) {  // only fetch token once per session
    NSString *stageName = [@"xsrf" stringByAppendingFormat:@"/%@", self.syncState.machineID];
    NSURL *u = [NSURL URLWithString:stageName relativeToURL:self.syncState.syncBaseURL];
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:u];
    [request setHTTPMethod:@"POST"];
    NSHTTPURLResponse *response;
    [self performRequest:request timeout:10 response:&response error:NULL];
    if (response.statusCode == 200) {
      NSDictionary *headers = [response allHeaderFields];
      self.syncState.xsrfToken = headers[kDefaultXSRFTokenHeader];
      NSString *xsrfTokenHeader = headers[kXSRFTokenHeader];
      self.syncState.xsrfTokenHeader = xsrfTokenHeader.length ? xsrfTokenHeader : nil;
      SLOGD(@"Retrieved new XSRF token");
      success = YES;
    } else {
      SLOGD(@"Failed to retrieve XSRF token");
    }
  };
  return success;
}

@end

1	/// Copyright 2016 Google Inc. All rights reserved.
2	///
3	/// Licensed under the Apache License, Version 2.0 (the "License");
4	/// you may not use this file except in compliance with the License.
5	/// You may obtain a copy of the License at
6	///
7	/// http://www.apache.org/licenses/LICENSE-2.0
8	///
9	/// Unless required by applicable law or agreed to in writing, software
10	/// distributed under the License is distributed on an "AS IS" BASIS,
11	/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	/// See the License for the specific language governing permissions and
13	/// limitations under the License.
14
15	#import "Source/santasyncservice/SNTSyncStage.h"
16
17	#import <MOLXPCConnection/MOLXPCConnection.h>
18
19	#import "Source/common/SNTCommonEnums.h"
20	#import "Source/common/SNTConfigurator.h"
21	#import "Source/common/SNTLogging.h"
22	#import "Source/common/SNTSyncConstants.h"
23	#import "Source/common/SNTXPCControlInterface.h"
24	#import "Source/common/String.h"
25	#import "Source/santasyncservice/NSData+Zlib.h"
26	#import "Source/santasyncservice/SNTSyncLogging.h"
27	#import "Source/santasyncservice/SNTSyncState.h"
28
29	#include <google/protobuf/json/json.h>
30
31	using santa::common::NSStringToUTF8String;
32
33	@interface SNTSyncStage ()
34
35	@property(readwrite) NSURLSession *urlSession;
36	@property(readwrite) SNTSyncState *syncState;
37	@property(readwrite) MOLXPCConnection *daemonConn;
38
39	@end
40
41	@implementation SNTSyncStage
42
43	- (nullable instancetype)initWithState:(nonnull SNTSyncState *)syncState {	33✔
44	self = [super init];	33✔
45	if (self) {	33!
46	_syncState = syncState;	33✔
47	_urlSession = syncState.session;	33✔
48	_daemonConn = syncState.daemonConn;	33✔
49	}	33✔
50	return self;	33✔
51	}	33✔
52
53	- (BOOL)sync {	×
54	[self doesNotRecognizeSelector:_cmd];	×
55	__builtin_unreachable();	×
56	}	×
57
58	- (NSString *)stageURL {	×
59	[self doesNotRecognizeSelector:_cmd];	×
60	__builtin_unreachable();	×
61	}	×
62
63	- (NSMutableURLRequest )requestWithMessage:(google::protobuf::Message )message {	39✔
64	NSData *requestBody = [NSData data];	39✔
65	if (message) {	39!
66	google::protobuf::json::PrintOptions options{	39✔
67	.always_print_enums_as_ints = false,	39✔
68	.preserve_proto_field_names = true,	39✔
69	};	39✔
70	std::string json;	39✔
71	absl::Status status = google::protobuf::json::MessageToJsonString(*message, &json, options);	39✔
72
73	if (!status.ok()) {	39!
NEW 74	SLOGE(@"Failed to convert protobuf to JSON: %s", status.ToString().c_str());	×
NEW 75	return nil;	×
NEW 76	}	×
77
78	SLOGD(@"Request JSON: %s", json.c_str());	39✔
79
80	requestBody = [NSData dataWithBytes:json.data() length:json.size()];	39✔
81	}	39✔
82	return [self requestWithData:requestBody];	39✔
83	}	39✔
84
85	- (NSMutableURLRequest )requestWithDictionary:(NSDictionary )dictionary {	×
86	NSData *requestBody = [NSData data];	×
87	if (dictionary) {	×
88	NSError *error;	×
89	requestBody = [NSJSONSerialization dataWithJSONObject:dictionary options:0 error:&error];	×
90	if (error) {	×
91	SLOGD(@"Failed to encode JSON request: %@", error);	×
92	return nil;	×
93	}	×
94	}	×
NEW 95	return [self requestWithData:requestBody];	×
NEW 96	}	×
97
98	- (NSMutableURLRequest )requestWithData:(NSData )requestBody {	39✔
99	NSMutableURLRequest *req = [[NSMutableURLRequest alloc] initWithURL:[self stageURL]];	39✔
100	[req setHTTPMethod:@"POST"];	39✔
101	[req setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];	39✔
102	NSString *xsrfHeader = self.syncState.xsrfTokenHeader ?: kDefaultXSRFTokenHeader;	39!
103	[req setValue:self.syncState.xsrfToken forHTTPHeaderField:xsrfHeader];	39✔
104
105	NSData *compressed;	39✔
106	NSString *contentEncodingHeader;	39✔
107
108	switch (self.syncState.contentEncoding) {	39✔
109	case SNTSyncContentEncodingNone: break;	39!
110	case SNTSyncContentEncodingGzip:	×
111	compressed = [requestBody gzipCompressed];	×
112	contentEncodingHeader = @"gzip";	×
113	break;	×
114	case SNTSyncContentEncodingDeflate:	×
115	compressed = [requestBody zlibCompressed];	×
116	contentEncodingHeader = @"deflate";	×
117	break;	×
118	default:	×
119	// This would be a programming error.
120	LOGD(@"Unexpected value for content encoding %ld", self.syncState.contentEncoding);	×
121	}	39✔
122
123	if (compressed) {	39!
124	requestBody = compressed;	×
125	[req setValue:contentEncodingHeader forHTTPHeaderField:@"Content-Encoding"];	×
126	}	×
127
128	[self addExtraRequestHeaders:req];	39✔
129
130	[req setHTTPBody:requestBody];	39✔
131
132	return req;	39✔
133	}	39✔
134
135	- (void)addExtraRequestHeaders:(NSMutableURLRequest *)req {	39✔
136	NSDictionary *extra = [[SNTConfigurator configurator] syncExtraHeaders];	39✔
137	[extra enumerateKeysAndObjectsWithOptions:0	39✔
138	usingBlock:^(id key, id object, BOOL *stop) {	39✔
139	if (![key isKindOfClass:[NSString class]] \|\|	×
140	![object isKindOfClass:[NSString class]])	×
141	return;	×
142	NSString k = (NSString )key;	×
143	NSString v = (NSString )object;	×
144
145	// This is likely unnecessary as the docs for NSURLSession list
146	// most of these as being ignored but explicitly setting them
147	// here is an extra layer of protection.
148	if ([k isEqualToString:@"Content-Encoding"] \|\|	×
149	[k isEqualToString:@"Content-Length"] \|\|	×
150	[k isEqualToString:@"Content-Type"] \|\|	×
151	[k isEqualToString:@"Connection"] \|\|	×
152	[k isEqualToString:@"Host"] \|\|	×
153	[k isEqualToString:@"Proxy-Authenticate"] \|\|	×
154	[k isEqualToString:@"Proxy-Authorization"] \|\|	×
155	[k isEqualToString:@"WWW-Authenticate"])	×
156	return;	×
157
158	[req setValue:v forHTTPHeaderField:k];	×
159	}];	×
160	}	39✔
161
162	- (NSData )dataFromRequest:(NSURLRequest )request timeout:(NSTimeInterval)timeout {	41✔
163	NSHTTPURLResponse *response;	41✔
164	NSError *error;	41✔
165	NSData *data;	41✔
166
167	int maxAttempts = 5;	41✔
168	for (int attempt = 1; attempt <= maxAttempts; ++attempt) {	43!
169	if (attempt >= 2) {	43✔
170	// Exponentially back off with larger and larger delays.
171	int exponentialBackoffMultiplier = 2; // E.g. 2^2 = 4, 2^3 = 8, 2^4 = 16...	2✔
172	struct timespec ts = {.tv_sec = __darwin_time_t(pow(exponentialBackoffMultiplier, attempt))};	2✔
173	nanosleep(&ts, NULL);	2✔
174	}	2✔
175
176	SLOGD(@"Performing request, attempt %d (of %d maximum)...", attempt, maxAttempts);	43✔
177	data = [self performRequest:request timeout:timeout response:&response error:&error];	43✔
178	if (response.statusCode == 200) break;	43✔
179
180	// If the original request failed because of an auth error, attempt to get a new XSRF token and
181	// try again. Unfortunately some servers cause NSURLSession to return 'client cert required' or
182	// 'could not parse response' when a 403 occurs and SSL cert auth is enabled.
183	if ((response.statusCode == 403 \|\| error.code == NSURLErrorClientCertificateRequired \|\|	2!
184	error.code == NSURLErrorCannotParseResponse) &&	2!
185	[self fetchXSRFToken]) {	2!
186	NSMutableURLRequest *mutableRequest = [request mutableCopy];	2✔
187	NSString *xsrfHeader = self.syncState.xsrfTokenHeader ?: kDefaultXSRFTokenHeader;	2✔
188	[mutableRequest setValue:self.syncState.xsrfToken forHTTPHeaderField:xsrfHeader];	2✔
189	request = mutableRequest;	2✔
190	continue;	2✔
191	}	2✔
192	}	2✔
193
194	// If the final attempt resulted in an error, log the error and return nil.
195	if (response.statusCode != 200) {	41!
196	long code;	×
197	NSString *errStr;	×
198	if (response.statusCode > 0) {	×
199	code = response.statusCode;	×
200	errStr = [NSHTTPURLResponse localizedStringForStatusCode:response.statusCode];	×
201	} else {	×
202	code = (long)error.code;	×
203	errStr = error.localizedDescription;	×
204	}	×
205	LOGE(@"HTTP Response: %ld %@", code, errStr);	×
206	return nil;	×
207	}	×
208	return data;	41✔
209	}	41✔
210
211	- (NSError )performRequest:(NSURLRequest )request
212	intoMessage:(google::protobuf::Message *)message
213	timeout:(NSTimeInterval)timeout {	27✔
214	NSData *data = [self dataFromRequest:request timeout:timeout];	27✔
215	if (data.length == 0) return nil;	27✔
216
217	google::protobuf::json::ParseOptions options{	26✔
218	.ignore_unknown_fields = true,	26✔
219	};	26✔
220	NSString *jsonData = [[NSString alloc] initWithData:[self stripXssi:data]	26✔
221	encoding:NSUTF8StringEncoding];	26✔
222	absl::Status status =	26✔
223	google::protobuf::json::JsonStringToMessage(NSStringToUTF8String(jsonData), message, options);	26✔
224	if (!status.ok()) {	26!
NEW 225	SLOGE(@"Failed to parse response JSON into message: %s", status.ToString().c_str());	×
NEW 226	return nil;	×
NEW 227	}	×
228
229	return nil;	26✔
230	}	26✔
231
232	// Returns nil when there is a server connection issue. For other errors, such as
233	// an empty response or an unparseable response, an empty dictionary is returned.
234	- (NSDictionary )performRequest:(NSURLRequest )request timeout:(NSTimeInterval)timeout {	14✔
235	NSData *data = [self dataFromRequest:request timeout:timeout];	14✔
236	if (data.length == 0) return @{};	14!
237
NEW 238	NSError *error;	×
239	NSDictionary *dict = [NSJSONSerialization JSONObjectWithData:[self stripXssi:data]	×
240	options:0	×
241	error:&error];	×
242	if (error) SLOGD(@"Failed to decode JSON response: %@", error);	×
243
244	return dict ?: @{};	×
245	}	14✔
246
247	- (NSDictionary )performRequest:(NSURLRequest )request {	14✔
248	return [self performRequest:request timeout:30];	14✔
249	}	14✔
250
251	#pragma mark Internal Helpers
252
253	/**
254	Perform a data request and capture the returned data, response and error objects.
255
256	@param request The request to perform
257	@param timeout The number of seconds to wait before cancelling the request
258	@param response Return the response details
259	@param error Return the error details
260	@returns data, The HTTP body of the response
261	*/
262	- (NSData )performRequest:(NSURLRequest )request
263	timeout:(NSTimeInterval)timeout
264	response:(out NSHTTPURLResponse **)response
265	error:(out NSError **)error {	45✔
266	__block NSData *_data;	45✔
267	__block NSHTTPURLResponse *_response;	45✔
268	__block NSError *_error;	45✔
269
270	dispatch_semaphore_t sema = dispatch_semaphore_create(0);	45✔
271	NSURLSessionDataTask *task =	45✔
272	[self.urlSession dataTaskWithRequest:request	45✔
273	completionHandler:^(NSData data, NSURLResponse response, NSError *error) {	45✔
274	if ([response isKindOfClass:[NSHTTPURLResponse class]]) {	45!
275	_response = (NSHTTPURLResponse *)response;	45✔
276	}	45✔
277	_data = data;	45✔
278	_error = error;	45✔
279	dispatch_semaphore_signal(sema);	45✔
280	}];	45✔
281	[task resume];	45✔
282
283	if (dispatch_semaphore_wait(sema, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * timeout))) {	45!
284	[task cancel];	×
285	}	×
286
287	if (response) *response = _response;	45!
288	if (error) *error = _error;	45✔
289	return _data;	45✔
290	}	45✔
291
292	- (NSData )stripXssi:(NSData )data {	31✔
293	static const char xssiOne[5] = {')', ']', '}', '\'', '\n'};	31✔
294	static const char xssiTwo[3] = {']', ')', '}'};	31✔
295	if (data.length >= sizeof(xssiOne) &&	31✔
296	strncmp((const char *)data.bytes, xssiOne, sizeof(xssiOne)) == 0) {	31✔
297	return [data subdataWithRange:NSMakeRange(sizeof(xssiOne), data.length - sizeof(xssiOne))];	2✔
298	}	2✔
299	if (data.length >= sizeof(xssiTwo) &&	29✔
300	strncmp((const char *)data.bytes, xssiTwo, sizeof(xssiTwo)) == 0) {	29✔
301	return [data subdataWithRange:NSMakeRange(sizeof(xssiTwo), data.length - sizeof(xssiTwo))];	2✔
302	}	2✔
303	return data;	27✔
304	}	29✔
305
306	- (BOOL)fetchXSRFToken {	2✔
307	BOOL success = NO;	2✔
308	if (!self.syncState.xsrfToken.length) { // only fetch token once per session	2!
309	NSString *stageName = [@"xsrf" stringByAppendingFormat:@"/%@", self.syncState.machineID];	2✔
310	NSURL *u = [NSURL URLWithString:stageName relativeToURL:self.syncState.syncBaseURL];	2✔
311	NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:u];	2✔
312	[request setHTTPMethod:@"POST"];	2✔
313	NSHTTPURLResponse *response;	2✔
314	[self performRequest:request timeout:10 response:&response error:NULL];	2✔
315	if (response.statusCode == 200) {	2!
316	NSDictionary *headers = [response allHeaderFields];	2✔
317	self.syncState.xsrfToken = headers[kDefaultXSRFTokenHeader];	2✔
318	NSString *xsrfTokenHeader = headers[kXSRFTokenHeader];	2✔
319	self.syncState.xsrfTokenHeader = xsrfTokenHeader.length ? xsrfTokenHeader : nil;	2✔
320	SLOGD(@"Retrieved new XSRF token");	2✔
321	success = YES;	2✔
322	} else {	2✔
323	SLOGD(@"Failed to retrieve XSRF token");	×
324	}	×
325	};	2✔
326	return success;	2✔
327	}	2✔
328
329	@end

google / santa / 9262560814

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous