9859805182

Committed 09 Jul 2024 03:21PM UTC coverage: 63.124% (-0.005%) from 63.129%

Build # 9859805182

Build Type

Pull #1389

github

Committed by

web-flow

Commit Message

Merge f1fb97921 into 348ff8c00

Pull Request Pull Request #1389: sync: Handle parse errors, make some preflight fields optional

Run Details

5626 of 13406 branches covered (41.97%)

Branch coverage included in aggregate %.

4 of 13 new or added lines in 2 files covered. (30.77%)

1 existing line in 1 file now uncovered.

18746 of 25204 relevant lines covered (74.38%)

6437.06 hits per line

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

59.33

/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::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 {
  if (!message) return [self requestWithData:[NSData data] contentType:nil];

  if ([[SNTConfigurator configurator] syncEnableProtoTransfer]) {
    std::string data;
    if (!message->SerializeToString(&data)) {
      SLOGE(@"Failed to serialize protobuf");
      return nil;
    }

    return [self requestWithData:[NSData dataWithBytes:data.data() length:data.size()]
                     contentType:@"application/x-protobuf"];
  }

  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()) {
    NSString *errStr = [NSString
      stringWithFormat:@"Failed to convert protobuf to JSON: %s", status.ToString().c_str()];
    SLOGE(@"%@", errStr);
    return nil;
  }

  SLOGD(@"Request JSON: %s", json.c_str());
  return [self requestWithData:[NSData dataWithBytes:json.data() length:json.size()]
                   contentType:@"application/json"];
}

- (NSMutableURLRequest *)requestWithData:(NSData *)requestBody contentType:(NSString *)contentType {
  if (contentType.length) contentType = @"application/octet-stream";

  NSMutableURLRequest *req = [[NSMutableURLRequest alloc] initWithURL:[self stageURL]];
  [req setHTTPMethod:@"POST"];
  [req setValue:contentType 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()) {
    NSString *errStr = [NSString stringWithFormat:@"Failed to parse response JSON into message: %s",
                                                  status.ToString().c_str()];
    SLOGE(@"%@", errStr);
    return [NSError errorWithDomain:@"com.google.santa.syncservice"
                               code:3
                           userInfo:@{NSLocalizedDescriptionKey : errStr}];
  }

  return nil;
}

#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::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	if (!message) return [self requestWithData:[NSData data] contentType:nil];	39!
65
66	if ([[SNTConfigurator configurator] syncEnableProtoTransfer]) {	39!
67	std::string data;	×
68	if (!message->SerializeToString(&data)) {	×
69	SLOGE(@"Failed to serialize protobuf");	×
70	return nil;	×
71	}	×
72
73	return [self requestWithData:[NSData dataWithBytes:data.data() length:data.size()]	×
74	contentType:@"application/x-protobuf"];	×
75	}	×
76
77	google::protobuf::json::PrintOptions options{	39✔
78	.always_print_enums_as_ints = false,	39✔
79	.preserve_proto_field_names = true,	39✔
80	};	39✔
81	std::string json;	39✔
82	absl::Status status = google::protobuf::json::MessageToJsonString(*message, &json, options);	39✔
83
84	if (!status.ok()) {	39!
NEW 85	NSString *errStr = [NSString	×
NEW 86	stringWithFormat:@"Failed to convert protobuf to JSON: %s", status.ToString().c_str()];	×
NEW 87	SLOGE(@"%@", errStr);	×
88	return nil;	×
89	}	×
90
91	SLOGD(@"Request JSON: %s", json.c_str());	39✔
92	return [self requestWithData:[NSData dataWithBytes:json.data() length:json.size()]	39✔
93	contentType:@"application/json"];	39✔
94	}	39✔
95
96	- (NSMutableURLRequest )requestWithData:(NSData )requestBody contentType:(NSString *)contentType {	39✔
97	if (contentType.length) contentType = @"application/octet-stream";	39!
98
99	NSMutableURLRequest *req = [[NSMutableURLRequest alloc] initWithURL:[self stageURL]];	39✔
100	[req setHTTPMethod:@"POST"];	39✔
101	[req setValue:contentType 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 {	41✔
214	NSData *data = [self dataFromRequest:request timeout:timeout];	41✔
215	if (data.length == 0) return nil;	41✔
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	NSString *errStr = [NSString stringWithFormat:@"Failed to parse response JSON into message: %s",	×
NEW 226	status.ToString().c_str()];	×
NEW 227	SLOGE(@"%@", errStr);	×
NEW 228	return [NSError errorWithDomain:@"com.google.santa.syncservice"	×
NEW 229	code:3	×
NEW 230	userInfo:@{NSLocalizedDescriptionKey : errStr}];	×
UNCOV 231	}	×
232
233	return nil;	26✔
234	}	26✔
235
236	#pragma mark Internal Helpers
237
238	/**
239	Perform a data request and capture the returned data, response and error objects.
240
241	@param request The request to perform
242	@param timeout The number of seconds to wait before cancelling the request
243	@param response Return the response details
244	@param error Return the error details
245	@returns data, The HTTP body of the response
246	*/
247	- (NSData )performRequest:(NSURLRequest )request
248	timeout:(NSTimeInterval)timeout
249	response:(out NSHTTPURLResponse **)response
250	error:(out NSError **)error {	45✔
251	__block NSData *_data;	45✔
252	__block NSHTTPURLResponse *_response;	45✔
253	__block NSError *_error;	45✔
254
255	dispatch_semaphore_t sema = dispatch_semaphore_create(0);	45✔
256	NSURLSessionDataTask *task =	45✔
257	[self.urlSession dataTaskWithRequest:request	45✔
258	completionHandler:^(NSData data, NSURLResponse response, NSError *error) {	45✔
259	if ([response isKindOfClass:[NSHTTPURLResponse class]]) {	45!
260	_response = (NSHTTPURLResponse *)response;	45✔
261	}	45✔
262	_data = data;	45✔
263	_error = error;	45✔
264	dispatch_semaphore_signal(sema);	45✔
265	}];	45✔
266	[task resume];	45✔
267
268	if (dispatch_semaphore_wait(sema, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * timeout))) {	45!
269	[task cancel];	×
270	}	×
271
272	if (response) *response = _response;	45!
273	if (error) *error = _error;	45✔
274	return _data;	45✔
275	}	45✔
276
277	- (NSData )stripXssi:(NSData )data {	31✔
278	static const char xssiOne[5] = {')', ']', '}', '\'', '\n'};	31✔
279	static const char xssiTwo[3] = {']', ')', '}'};	31✔
280	if (data.length >= sizeof(xssiOne) &&	31✔
281	strncmp((const char *)data.bytes, xssiOne, sizeof(xssiOne)) == 0) {	31✔
282	return [data subdataWithRange:NSMakeRange(sizeof(xssiOne), data.length - sizeof(xssiOne))];	2✔
283	}	2✔
284	if (data.length >= sizeof(xssiTwo) &&	29✔
285	strncmp((const char *)data.bytes, xssiTwo, sizeof(xssiTwo)) == 0) {	29✔
286	return [data subdataWithRange:NSMakeRange(sizeof(xssiTwo), data.length - sizeof(xssiTwo))];	2✔
287	}	2✔
288	return data;	27✔
289	}	29✔
290
291	- (BOOL)fetchXSRFToken {	2✔
292	BOOL success = NO;	2✔
293	if (!self.syncState.xsrfToken.length) { // only fetch token once per session	2!
294	NSString *stageName = [@"xsrf" stringByAppendingFormat:@"/%@", self.syncState.machineID];	2✔
295	NSURL *u = [NSURL URLWithString:stageName relativeToURL:self.syncState.syncBaseURL];	2✔
296	NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:u];	2✔
297	[request setHTTPMethod:@"POST"];	2✔
298	NSHTTPURLResponse *response;	2✔
299	[self performRequest:request timeout:10 response:&response error:NULL];	2✔
300	if (response.statusCode == 200) {	2!
301	NSDictionary *headers = [response allHeaderFields];	2✔
302	self.syncState.xsrfToken = headers[kDefaultXSRFTokenHeader];	2✔
303	NSString *xsrfTokenHeader = headers[kXSRFTokenHeader];	2✔
304	self.syncState.xsrfTokenHeader = xsrfTokenHeader.length ? xsrfTokenHeader : nil;	2✔
305	SLOGD(@"Retrieved new XSRF token");	2✔
306	success = YES;	2✔
307	} else {	2✔
308	SLOGD(@"Failed to retrieve XSRF token");	×
309	}	×
310	};	2✔
311	return success;	2✔
312	}	2✔
313
314	@end

google / santa / 9859805182

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