9356417832

Committed 03 Jun 2024 07:55PM UTC coverage: 62.271% (-0.2%) from 62.443%

Build # 9356417832

Build Type

Pull #1364

github

Committed by

web-flow

Commit Message

Merge 9bef9b5a7 into a42dd6e12

Pull Request Pull Request #1364: sync: Add option to sync using binary protos

Run Details

5235 of 12888 branches covered (40.62%)

Branch coverage included in aggregate %.

20 of 28 new or added lines in 2 files covered. (71.43%)

1 existing line in 1 file now uncovered.

17859 of 24198 relevant lines covered (73.8%)

7129.78 hits per line

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

60.54

/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 {
  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()) {
    SLOGE(@"Failed to convert protobuf to JSON: %s", status.ToString().c_str());
    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()) {
    SLOGE(@"Failed to parse response JSON into message: %s", status.ToString().c_str());
    return nil;
  }

  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::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	if (!message) return [self requestWithData:[NSData data] contentType:nil];	39!
65
66	if ([[SNTConfigurator configurator] syncEnableProtoTransfer]) {	39!
NEW 67	std::string data;	×
NEW 68	if (!message->SerializeToString(&data)) {	×
NEW 69	SLOGE(@"Failed to serialize protobuf");	×
70	return nil;	×
71	}	×
72
NEW 73	return [self requestWithData:[NSData dataWithBytes:data.data() length:data.size()]	×
NEW 74	contentType:@"application/x-protobuf"];	×
UNCOV 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	SLOGE(@"Failed to convert protobuf to JSON: %s", status.ToString().c_str());	×
NEW 86	return nil;	×
NEW 87	}	×
88
89	SLOGD(@"Request JSON: %s", json.c_str());	39✔
90	return [self requestWithData:[NSData dataWithBytes:json.data() length:json.size()]	39✔
91	contentType:@"application/json"];	39✔
92	}	39✔
93
94	- (NSMutableURLRequest )requestWithData:(NSData )requestBody contentType:(NSString *)contentType {	39✔
95	if (contentType.length) contentType = @"application/octet-stream";	39!
96
97	NSMutableURLRequest *req = [[NSMutableURLRequest alloc] initWithURL:[self stageURL]];	39✔
98	[req setHTTPMethod:@"POST"];	39✔
99	[req setValue:contentType forHTTPHeaderField:@"Content-Type"];	39✔
100	NSString *xsrfHeader = self.syncState.xsrfTokenHeader ?: kDefaultXSRFTokenHeader;	39!
101	[req setValue:self.syncState.xsrfToken forHTTPHeaderField:xsrfHeader];	39✔
102
103	NSData *compressed;	39✔
104	NSString *contentEncodingHeader;	39✔
105
106	switch (self.syncState.contentEncoding) {	39✔
107	case SNTSyncContentEncodingNone: break;	39!
108	case SNTSyncContentEncodingGzip:	×
109	compressed = [requestBody gzipCompressed];	×
110	contentEncodingHeader = @"gzip";	×
111	break;	×
112	case SNTSyncContentEncodingDeflate:	×
113	compressed = [requestBody zlibCompressed];	×
114	contentEncodingHeader = @"deflate";	×
115	break;	×
116	default:	×
117	// This would be a programming error.
118	LOGD(@"Unexpected value for content encoding %ld", self.syncState.contentEncoding);	×
119	}	39✔
120
121	if (compressed) {	39!
122	requestBody = compressed;	×
123	[req setValue:contentEncodingHeader forHTTPHeaderField:@"Content-Encoding"];	×
124	}	×
125
126	[self addExtraRequestHeaders:req];	39✔
127
128	[req setHTTPBody:requestBody];	39✔
129
130	return req;	39✔
131	}	39✔
132
133	- (void)addExtraRequestHeaders:(NSMutableURLRequest *)req {	39✔
134	NSDictionary *extra = [[SNTConfigurator configurator] syncExtraHeaders];	39✔
135	[extra enumerateKeysAndObjectsWithOptions:0	39✔
136	usingBlock:^(id key, id object, BOOL *stop) {	39✔
137	if (![key isKindOfClass:[NSString class]] \|\|	×
138	![object isKindOfClass:[NSString class]])	×
139	return;	×
140	NSString k = (NSString )key;	×
141	NSString v = (NSString )object;	×
142
143	// This is likely unnecessary as the docs for NSURLSession list
144	// most of these as being ignored but explicitly setting them
145	// here is an extra layer of protection.
146	if ([k isEqualToString:@"Content-Encoding"] \|\|	×
147	[k isEqualToString:@"Content-Length"] \|\|	×
148	[k isEqualToString:@"Content-Type"] \|\|	×
149	[k isEqualToString:@"Connection"] \|\|	×
150	[k isEqualToString:@"Host"] \|\|	×
151	[k isEqualToString:@"Proxy-Authenticate"] \|\|	×
152	[k isEqualToString:@"Proxy-Authorization"] \|\|	×
153	[k isEqualToString:@"WWW-Authenticate"])	×
154	return;	×
155
156	[req setValue:v forHTTPHeaderField:k];	×
157	}];	×
158	}	39✔
159
160	- (NSData )dataFromRequest:(NSURLRequest )request timeout:(NSTimeInterval)timeout {	41✔
161	NSHTTPURLResponse *response;	41✔
162	NSError *error;	41✔
163	NSData *data;	41✔
164
165	int maxAttempts = 5;	41✔
166	for (int attempt = 1; attempt <= maxAttempts; ++attempt) {	43!
167	if (attempt >= 2) {	43✔
168	// Exponentially back off with larger and larger delays.
169	int exponentialBackoffMultiplier = 2; // E.g. 2^2 = 4, 2^3 = 8, 2^4 = 16...	2✔
170	struct timespec ts = {.tv_sec = __darwin_time_t(pow(exponentialBackoffMultiplier, attempt))};	2✔
171	nanosleep(&ts, NULL);	2✔
172	}	2✔
173
174	SLOGD(@"Performing request, attempt %d (of %d maximum)...", attempt, maxAttempts);	43✔
175	data = [self performRequest:request timeout:timeout response:&response error:&error];	43✔
176	if (response.statusCode == 200) break;	43✔
177
178	// If the original request failed because of an auth error, attempt to get a new XSRF token and
179	// try again. Unfortunately some servers cause NSURLSession to return 'client cert required' or
180	// 'could not parse response' when a 403 occurs and SSL cert auth is enabled.
181	if ((response.statusCode == 403 \|\| error.code == NSURLErrorClientCertificateRequired \|\|	2!
182	error.code == NSURLErrorCannotParseResponse) &&	2!
183	[self fetchXSRFToken]) {	2!
184	NSMutableURLRequest *mutableRequest = [request mutableCopy];	2✔
185	NSString *xsrfHeader = self.syncState.xsrfTokenHeader ?: kDefaultXSRFTokenHeader;	2✔
186	[mutableRequest setValue:self.syncState.xsrfToken forHTTPHeaderField:xsrfHeader];	2✔
187	request = mutableRequest;	2✔
188	continue;	2✔
189	}	2✔
190	}	2✔
191
192	// If the final attempt resulted in an error, log the error and return nil.
193	if (response.statusCode != 200) {	41!
194	long code;	×
195	NSString *errStr;	×
196	if (response.statusCode > 0) {	×
197	code = response.statusCode;	×
198	errStr = [NSHTTPURLResponse localizedStringForStatusCode:response.statusCode];	×
199	} else {	×
200	code = (long)error.code;	×
201	errStr = error.localizedDescription;	×
202	}	×
203	LOGE(@"HTTP Response: %ld %@", code, errStr);	×
204	return nil;	×
205	}	×
206	return data;	41✔
207	}	41✔
208
209	- (NSError )performRequest:(NSURLRequest )request
210	intoMessage:(google::protobuf::Message *)message
211	timeout:(NSTimeInterval)timeout {	41✔
212	NSData *data = [self dataFromRequest:request timeout:timeout];	41✔
213	if (data.length == 0) return nil;	41✔
214
215	google::protobuf::json::ParseOptions options{	26✔
216	.ignore_unknown_fields = true,	26✔
217	};	26✔
218	NSString *jsonData = [[NSString alloc] initWithData:[self stripXssi:data]	26✔
219	encoding:NSUTF8StringEncoding];	26✔
220	absl::Status status =	26✔
221	google::protobuf::json::JsonStringToMessage(NSStringToUTF8String(jsonData), message, options);	26✔
222	if (!status.ok()) {	26!
223	SLOGE(@"Failed to parse response JSON into message: %s", status.ToString().c_str());	×
224	return nil;	×
225	}	×
226
227	return nil;	26✔
228	}	26✔
229
230	#pragma mark Internal Helpers
231
232	/**
233	Perform a data request and capture the returned data, response and error objects.
234
235	@param request The request to perform
236	@param timeout The number of seconds to wait before cancelling the request
237	@param response Return the response details
238	@param error Return the error details
239	@returns data, The HTTP body of the response
240	*/
241	- (NSData )performRequest:(NSURLRequest )request
242	timeout:(NSTimeInterval)timeout
243	response:(out NSHTTPURLResponse **)response
244	error:(out NSError **)error {	45✔
245	__block NSData *_data;	45✔
246	__block NSHTTPURLResponse *_response;	45✔
247	__block NSError *_error;	45✔
248
249	dispatch_semaphore_t sema = dispatch_semaphore_create(0);	45✔
250	NSURLSessionDataTask *task =	45✔
251	[self.urlSession dataTaskWithRequest:request	45✔
252	completionHandler:^(NSData data, NSURLResponse response, NSError *error) {	45✔
253	if ([response isKindOfClass:[NSHTTPURLResponse class]]) {	45!
254	_response = (NSHTTPURLResponse *)response;	45✔
255	}	45✔
256	_data = data;	45✔
257	_error = error;	45✔
258	dispatch_semaphore_signal(sema);	45✔
259	}];	45✔
260	[task resume];	45✔
261
262	if (dispatch_semaphore_wait(sema, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * timeout))) {	45!
263	[task cancel];	×
264	}	×
265
266	if (response) *response = _response;	45!
267	if (error) *error = _error;	45✔
268	return _data;	45✔
269	}	45✔
270
271	- (NSData )stripXssi:(NSData )data {	31✔
272	static const char xssiOne[5] = {')', ']', '}', '\'', '\n'};	31✔
273	static const char xssiTwo[3] = {']', ')', '}'};	31✔
274	if (data.length >= sizeof(xssiOne) &&	31✔
275	strncmp((const char *)data.bytes, xssiOne, sizeof(xssiOne)) == 0) {	31✔
276	return [data subdataWithRange:NSMakeRange(sizeof(xssiOne), data.length - sizeof(xssiOne))];	2✔
277	}	2✔
278	if (data.length >= sizeof(xssiTwo) &&	29✔
279	strncmp((const char *)data.bytes, xssiTwo, sizeof(xssiTwo)) == 0) {	29✔
280	return [data subdataWithRange:NSMakeRange(sizeof(xssiTwo), data.length - sizeof(xssiTwo))];	2✔
281	}	2✔
282	return data;	27✔
283	}	29✔
284
285	- (BOOL)fetchXSRFToken {	2✔
286	BOOL success = NO;	2✔
287	if (!self.syncState.xsrfToken.length) { // only fetch token once per session	2!
288	NSString *stageName = [@"xsrf" stringByAppendingFormat:@"/%@", self.syncState.machineID];	2✔
289	NSURL *u = [NSURL URLWithString:stageName relativeToURL:self.syncState.syncBaseURL];	2✔
290	NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:u];	2✔
291	[request setHTTPMethod:@"POST"];	2✔
292	NSHTTPURLResponse *response;	2✔
293	[self performRequest:request timeout:10 response:&response error:NULL];	2✔
294	if (response.statusCode == 200) {	2!
295	NSDictionary *headers = [response allHeaderFields];	2✔
296	self.syncState.xsrfToken = headers[kDefaultXSRFTokenHeader];	2✔
297	NSString *xsrfTokenHeader = headers[kXSRFTokenHeader];	2✔
298	self.syncState.xsrfTokenHeader = xsrfTokenHeader.length ? xsrfTokenHeader : nil;	2✔
299	SLOGD(@"Retrieved new XSRF token");	2✔
300	success = YES;	2✔
301	} else {	2✔
302	SLOGD(@"Failed to retrieve XSRF token");	×
303	}	×
304	};	2✔
305	return success;	2✔
306	}	2✔
307
308	@end

google / santa / 9356417832

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