I suggest you read the start of my Java article for detail on PHP sessions but I’ll summarise it here. PHP session handling is a way of having persistent or stateful data across HTTP requests. PHP manages this by using a session ID stored in a cookie. PHP’s session_start() call will parse the value of the “Cookie:” HTTP request header field looking for a value similar to PHPSESSID=b330c9b604d371e5c88cd0919990f41c. It will use the session ID value to retrieve the appropriate session data and deserialise any stored values and store them in the $_SESSION global array variable. If the PHPSESSID does not exist session_start() will create a new empty session (and $_SESSION) and use “Set-Cookie:” in the HTTP response to pass the session ID cookie to the browser so it can be returned on the next request. The session cookie is valid for the lifetime of the browser.

The Core Framework has a class, NSURLConnection, that is very similar to Java’s HttpURLConnection. NSURLConnection provides two class methods one which provides an asynchronous connection and one that will synchronously load the data from a remote server.

connectionWithRequest:delegate: is a factory method that returns an instance of NSURLConnection that represents the current connection. It takes two arguments, a pointer to an NSURLRequest object and a pointer to a delegate object that is called back when certain events happen such as an error, data being received, connection completed and so on.

sendSynchronousRequest:returningResponse:error is the other method provided by the class for connections. As before it takes a pointer to a NSURLRequest object. It also takes a pointer to a variable in which to return a pointer to an NSError object. This will be nil if no error occurs. The return argument is a pointer to an NSData object containing the data in the body of the document returned by the server. Unfortunately it provides no way of obtaining any header information returned by the server so I will be using connectionWithRequest:delegate: for the rest of the post.

Below is the interface definition for a class that uses NSURLConnection to connect to a remote server. There are three instance variables, the connection object, the data object (that will contain the body of the response from the server), and an array of cookies. The five new methods (other than those inherited from NSObject) is one that makes a connection to the server and four delegate methods. The delegate methods will be called by the connection object when an event happens. There are other delegate methods that can be implemented but this is the minimal set required for a connection.

@interface MyConnection : NSObject {
	// A pointer to the connection.
	NSURLConnection *_connection;
 
	// A pointer to the received data object.
	NSMutableData *_data;
 
	// The stored cookies.
	NSArray *_cookies;
}
 
// Initialise the cookies property.
@property (noatomic,retain) NSArray *_cookies;
 
// Makes the connection to the remote server and GETs data.
- (void)sendRequest:(NSString*)URLString;
 
// Delegate method called if an error occurred during the connection.
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error;
 
// Degate method called when a response has been received from the server.  All of the headers
// will have been received but not the body data yet.
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response;
 
// Delegate method called when body data has been received.  This will be called one or more times.
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data;
 
// Delegate method called when the entire transaction has completed.
- (void)connectionDidFinishLoading:(NSURLConnection *)connection;
 
@end

The implementation of the class follows. It implements the methods in the interface and the cookies property. Unlike the Java HttpURLConnection class, which has methods for setting internal data, the body data, header fields, HTTP method and so on are defined in either an NSURLRequest object or returned in an NSURLResponse object as appropriate.

@implementation MyConnection
 
// Create the cookies property
@synthesize _cookies;
 
// Makes the connection to the remote server and GETs data.
- (void)sendRequest:(NSString*)URLString {
	// Create a URL to the server
	NSURL *URL = [NSURL URLWithString: URLString];
 
	// Make a request (By default this is a GET request with no body).  It is mutable as we need to
	// Add the cookies to the request.
	NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:URL];
 
	// If we have cookies, iterate though them and add them to the request.
	if (_cookies) {
		NSEnumerator *enumerator = [_cookies objectEnumerator];
		id cookie;
 
		while (cookie = [enumerator nextObject]) {
			[urlRequest addValue:[cookie value] forHTTPHeaderField:@"Cookies"];
		}
	}
 
	// Make the connection.  The connection will start immediately.  The connection is
	// asynchronous and the data will be returned via the delegate methods.  nil will be 
	// returned on error.
	_connection = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES];
	if (_connection) {
		// Create the data object
		_data = [[NSMutableData data] retain];
	}
}
 
// Delegate method called if an error occurred during the connection.
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error {
	// We got an error.  Just for this example log it.
	NSLog(@"Error: %@", [error localizedDescription]);
 
	// Then tidy up
	[_connection release];
	[_data release];
}
 
// Degate method called when a response has been received from the server.  All of the headers
// will have been received but not the body data yet.
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response {
	// We're doing HTTP so we will have gotten a NSHTTPURLResponse!
	httpResponse = [(NSHTTPURLResponse*)response retain];
 
	// Check the status code and respond appropriately.
	switch ([httpResponse statusCode]) {
		case 200: {
			// Got a response so extract any cookies.  The array will be empty if there are none.
			NSDictionary *theHeaders = [httpResponse allHeaderFields];
			NSArray      *theCookies = [NSHTTPCookie cookiesWithResponseHeaderFields:theHeaders forURL:[response URL]];
 
			// Save any cookies
			if ([theCookies count] > 0) {
				self._cookies = theCookies;
			}
		    break;
		}
 
		default:
			break;
	}
 
	// Initialised the received data which will contain the body of the response and will be
	// populated via the connection:didReceiveData call below.
	[_data setLength:0];
}
 
// Delegate method called when body data has been received.  This will be called one or more times.
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
	// Append the data received to our data
	[_data appendData:data];
}
 
// Delegate method called when the entire transaction has completed.
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
	// We have got everything so no longer need the connection so release it.
	[_connection release];
 
	// Do something with the data.
	NSLog(@"Data: %@", _data);
 
	// Then release that too.
	[_data release];
}
 
@end

The sendRequest method creates a URL and then creates an NSMutableURLRequest object. If you are carrying out a GET request with default data you can use an NSURLRequest object. But in order to add cookies to the request you have to use the mutable sub-class of NSURLRequest.

Unlike in Java, the Cocoa framework is nice and provides an NSHTTPCookie class that represents cookie data. There could be more than one cookie and so an array is used to store them. If the array exists its contents are iterated over and the cookies are added to the request object. When an instance of MyConnection is first created the value of the _cookies variable is nil. So on the first connection no cookies are sent to the server. This causes PHP’s session_start() to create a session cookie which is returned in the response. Finally the method creates a connection for the specified URL with the supplied request. The connection is asked to connect immediately.

If there is an error trying to contact the server due to a network issue, bad domain or similar, the connection:didFailWithError delegate method will be called with the error object. Note that all the delegate methods are called with the connection as the first argument. This allows you to use the same delegate for multiple connections.

Once a connection has been made and the response headers have been read the connection:didReceiveResponse method is called. The response returned is typically a sub-class of NSURLResponse. The sub-class depends upon the type of request that has been made. This example is assuming that an HTTP request is made so an NSHTTPURLResponse will be returned. The response object is cast and the status code examined. If its something other than 200 i.e. OK then that can be handled at this point. The example ignores all statuses other than 200.

Unlike Java, Cocoa does a lot of the work for getting the cookies from the header. connection:didReceiveResponse calls a method that returns an NSDictionary of header name and value pairs. It then passes this to the NSHTTPCookie static method cookiesWithResponseHeaderFields:forURL to obtain an array of cookie objects. These are then stored in the cookies instance property. Finally the class initialises a data object in which to store the body of the response.

The connection object will call connection:didReceiveData one or more times with the body data. Once all the data has been read the connectionDidFinishLoading delegate method will be called to indicate this. The connection instance can now be released and the data processed.

As for the Java version of this code, if the sendRequest is called again, the cookies that were stored the first time a connection was made using sendRequest are sent back to the server. This causes PHP to re-establish the session. The life of the session will be consistent with the life of the MyConnection instance used to connect to the server. To create a new session create a new instance of MyConnection.