Index: src/OFDNSResolver.m
==================================================================
--- src/OFDNSResolver.m
+++ src/OFDNSResolver.m
@@ -84,10 +84,11 @@
  *  - Fallback to TCP
  */
 
 @interface OFDNSResolverQuery: OFObject
 {
+@public
 	OFString *_host, *_domainName;
 	of_dns_resource_record_class_t _recordClass;
 	of_dns_resource_record_type_t _recordType;
 	OFNumber *_ID;
 	OFArray OF_GENERIC(OFString *) *_nameServers, *_searchDomains;
@@ -98,25 +99,10 @@
 	id _context;
 	OFData *_queryData;
 	OFTimer *_cancelTimer;
 }
 
-@property (readonly, nonatomic) OFString *host, *domainName;
-@property (readonly, nonatomic) of_dns_resource_record_class_t recordClass;
-@property (readonly, nonatomic) of_dns_resource_record_type_t recordType;
-@property (readonly, nonatomic) OFNumber *ID;
-@property (readonly, nonatomic) OFArray OF_GENERIC(OFString *) *nameServers;
-@property (readonly, nonatomic) OFArray OF_GENERIC(OFString *) *searchDomains;
-@property (nonatomic) size_t nameServersIndex;
-@property (nonatomic) size_t searchDomainsIndex;
-@property (nonatomic) size_t attempt;
-@property (readonly, nonatomic) id target;
-@property (readonly, nonatomic) SEL selector;
-@property (readonly, nonatomic) id context;
-@property (readonly, nonatomic) OFData *queryData;
-@property (retain, nonatomic) OFTimer *cancelTimer;
-
 - (instancetype)initWithHost: (OFString *)host
 		  domainName: (OFString *)domainName
 		 recordClass: (of_dns_resource_record_class_t)recordClass
 		  recordType: (of_dns_resource_record_type_t)recordType
 			  ID: (OFNumber *)ID
@@ -535,18 +521,10 @@
 	method(target, selector, resolver, domainName, answerRecords,
 	    authorityRecords, additionalRecords, context, exception);
 }
 
 @implementation OFDNSResolverQuery
-@synthesize host = _host, domainName = _domainName, recordClass = _recordClass;
-@synthesize recordType = _recordType, ID = _ID, nameServers = _nameServers;
-@synthesize searchDomains = _searchDomains;
-@synthesize nameServersIndex = _nameServersIndex;
-@synthesize searchDomainsIndex = _searchDomainsIndex, attempt = _attempt;
-@synthesize target = _target, selector = _selector, context = _context;
-@synthesize queryData = _queryData, cancelTimer = _cancelTimer;
-
 - (instancetype)initWithHost: (OFString *)host
 		  domainName: (OFString *)domainName
 		 recordClass: (of_dns_resource_record_class_t)recordClass
 		  recordType: (of_dns_resource_record_type_t)recordType
 			  ID: (OFNumber *)ID
@@ -1071,20 +1049,22 @@
 - (void)of_sendQuery: (OFDNSResolverQuery *)query
 {
 	of_socket_address_t address;
 	OFUDPSocket *sock;
 
-	[[query cancelTimer] invalidate];
-	[query setCancelTimer: [OFTimer
+	[query->_cancelTimer invalidate];
+	[query->_cancelTimer release];
+	query->_cancelTimer = nil;
+	query->_cancelTimer = [[OFTimer
 	    scheduledTimerWithTimeInterval: TIMEOUT
 				    target: self
 				  selector: @selector(of_queryWithIDTimedOut:)
 				    object: query
-				   repeats: false]];
+				   repeats: false] retain];
 
 	address = of_socket_address_parse_ip(
-	    [[query nameServers] objectAtIndex: [query nameServersIndex]], 53);
+	    [query->_nameServers objectAtIndex: query->_nameServersIndex], 53);
 
 	switch (address.family) {
 #ifdef OF_HAVE_IPV6
 	case OF_SOCKET_ADDRESS_FAMILY_IPV6:
 		if (_IPv6Socket == nil) {
@@ -1109,12 +1089,12 @@
 		break;
 	default:
 		@throw [OFInvalidArgumentException exception];
 	}
 
-	[sock asyncSendBuffer: [[query queryData] items]
-		       length: [[query queryData] count]
+	[sock asyncSendBuffer: [query->_queryData items]
+		       length: [query->_queryData count]
 		     receiver: address
 		       target: self
 		     selector: @selector(of_socket:didSendBuffer:bytesSent:
 				   receiver:context:exception:)
 		      context: query];
@@ -1125,34 +1105,34 @@
 	OFResolveHostFailedException *exception;
 
 	if (query == nil)
 		return;
 
-	if ([query nameServersIndex] + 1 < [[query nameServers] count]) {
-		[query setNameServersIndex: [query nameServersIndex] + 1];
+	if (query->_nameServersIndex + 1 < [query->_nameServers count]) {
+		query->_nameServersIndex++;
 		[self of_sendQuery: query];
 		return;
 	}
 
-	if ([query attempt] < ATTEMPTS) {
-		[query setAttempt: [query attempt] + 1];
-		[query setNameServersIndex: 0];
+	if (query->_attempt < ATTEMPTS) {
+		query->_attempt++;
+		query->_nameServersIndex = 0;
 		[self of_sendQuery: query];
 		return;
 	}
 
 	query = [[query retain] autorelease];
-	[_queries removeObjectForKey: [query ID]];
+	[_queries removeObjectForKey: query->_ID];
 
 	exception = [OFResolveHostFailedException
-	    exceptionWithHost: [query host]
-		  recordClass: [query recordClass]
-		   recordType: [query recordType]
+	    exceptionWithHost: query->_host
+		  recordClass: query->_recordClass
+		   recordType: query->_recordType
 			error: OF_DNS_RESOLVER_ERROR_TIMEOUT];
 
-	callback([query target], [query selector], self, [query domainName],
-	    nil, nil, nil, [query context], exception);
+	callback(query->_target, query->_selector, self, query->_domainName,
+	    nil, nil, nil, query->_context, exception);
 }
 
 - (size_t)of_socket: (OFUDPSocket *)sock
       didSendBuffer: (void **)buffer
 	  bytesSent: (size_t)bytesSent
@@ -1160,14 +1140,14 @@
 	    context: (OFDNSResolverQuery *)query
 	  exception: (id)exception
 {
 	if (exception != nil) {
 		query = [[query retain] autorelease];
-		[_queries removeObjectForKey: [query ID]];
+		[_queries removeObjectForKey: query->_ID];
 
-		callback([query target], [query selector], self,
-		    [query domainName], nil, nil, nil, [query context],
+		callback(query->_target, query->_selector, self,
+		    query->_domainName, nil, nil, nil, query->_context,
 		    exception);
 
 		return 0;
 	}
 
@@ -1190,11 +1170,10 @@
 {
 	OFArray *answerRecords = nil, *authorityRecords = nil;
 	OFArray *additionalRecords = nil;
 	OFNumber *ID;
 	OFDNSResolverQuery *query;
-	OFData *queryData;
 
 	if (exception != nil)
 		return false;
 
 	if (length < 2)
@@ -1205,15 +1184,15 @@
 	query = [[[_queries objectForKey: ID] retain] autorelease];
 
 	if (query == nil)
 		return false;
 
-	[[query cancelTimer] invalidate];
+	[query->_cancelTimer invalidate];
+	[query->_cancelTimer release];
+	query->_cancelTimer = nil;
 	[_queries removeObjectForKey: ID];
 
-	queryData = [query queryData];
-
 	@try {
 		const unsigned char *queryDataBuffer;
 		size_t i;
 		of_dns_resolver_error_t error;
 		uint16_t numQuestions, numAnswers, numAuthorityRecords;
@@ -1220,14 +1199,15 @@
 		uint16_t numAdditionalRecords;
 
 		if (length < 12)
 			@throw [OFTruncatedDataException exception];
 
-		if ([queryData itemSize] != 1 || [queryData count] < 12)
+		if ([query->_queryData itemSize] != 1 ||
+		    [query->_queryData count] < 12)
 			@throw [OFInvalidArgumentException exception];
 
-		queryDataBuffer = [queryData items];
+		queryDataBuffer = [query->_queryData items];
 
 		/* QR */
 		if ((buffer[2] & 0x80) == 0)
 			@throw [OFInvalidServerReplyException exception];
 
@@ -1263,13 +1243,13 @@
 			break;
 		}
 
 		if (buffer[3] & 0x0F)
 			@throw [OFResolveHostFailedException
-			    exceptionWithHost: [query host]
-				  recordClass: [query recordClass]
-				   recordType: [query recordType]
+			    exceptionWithHost: query->_host
+				  recordClass: query->_recordClass
+				   recordType: query->_recordType
 					error: error];
 
 		numQuestions = (buffer[4] << 8) | buffer[5];
 		numAnswers = (buffer[6] << 8) | buffer[7];
 		numAuthorityRecords = (buffer[8] << 8) | buffer[9];
@@ -1292,18 +1272,18 @@
 		authorityRecords = parseSection(buffer, length, &i,
 		    numAuthorityRecords);
 		additionalRecords = parseSection(buffer, length, &i,
 		    numAdditionalRecords);
 	} @catch (id e) {
-		callback([query target], [query selector], self,
-		    [query domainName], nil, nil, nil, [query context], e);
+		callback(query->_target, query->_selector, self,
+		    query->_domainName, nil, nil, nil, query->_context, e);
 		return false;
 	}
 
-	callback([query target], [query selector], self, [query domainName],
+	callback(query->_target, query->_selector, self, query->_domainName,
 	    answerRecords, authorityRecords, additionalRecords,
-	    [query context], nil);
+	    query->_context, nil);
 
 	return false;
 }
 
 - (void)close
@@ -1325,20 +1305,20 @@
 	enumerator = [_queries objectEnumerator];
 	while ((query = [enumerator nextObject]) != nil) {
 		OFResolveHostFailedException *exception;
 
 		exception = [OFResolveHostFailedException
-		    exceptionWithHost: [query host]
-			  recordClass: [query recordClass]
-			   recordType: [query recordType]
+		    exceptionWithHost: query->_host
+			  recordClass: query->_recordClass
+			   recordType: query->_recordType
 				error: OF_DNS_RESOLVER_ERROR_CANCELED];
 
-		callback([query target], [query selector], self,
-		    [query domainName], nil, nil, nil, [query context],
+		callback(query->_target, query->_selector, self,
+		    query->_domainName, nil, nil, nil, query->_context,
 		    exception);
 	}
 
 	[_queries removeAllObjects];
 
 	objc_autoreleasePoolPop(pool);
 }
 @end