9273321169

Committed 28 May 2024 04:51PM UTC coverage: 62.521% (-0.1%) from 62.648%

Build # 9273321169

Build Type

Pull #1359

github

Committed by

web-flow

Commit Message

Merge 909e8fd75 into 7502bc247

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

Run Details

5233 of 12716 branches covered (41.15%)

Branch coverage included in aggregate %.

243 of 294 new or added lines in 6 files covered. (82.65%)

17 existing lines in 1 file now uncovered.

17798 of 24121 relevant lines covered (73.79%)

7080.23 hits per line

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

62.72

/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;
    }

    requestBody = [NSData dataWithBytes:json.data() length:json.size()];
  }
  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;
}

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

google / santa / 9273321169

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