URLCache.c File Reference

#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include "String.h"
#include "URLCache.h"

Go to the source code of this file.

Macros
#define	_Class   _URLCache
#define	URLCACHE_DEFAULT_MAX_SIZE   (1024 * 1024)

Functions
Class *	_URLCache (void)
static bool	cacheControlDisablesCaching (const char *value)
	Returns true if the provided Cache-Control value disables caching.
static URLCachedResponse *	cachedResponseForRequest (URLCache *self, const URLRequest *request)
static void	dealloc (Object *self)
static void	evictIfNeeded (URLCache *self)
	Removes the oldest cached response while this cache exceeds its maximum size.
static const String *	headerValueForField (const Dictionary *headers, const char *field)
	Returns the value for the specified HTTP header field, case-insensitively.
static URLCache *	init (URLCache *self)
static void	initialize (Class *clazz)
static void	removeAllCachedResponses (URLCache *self)
static void	removeCachedResponseForRequest (URLCache *self, const URLRequest *request)
static bool	requestIsCacheable (const URLRequest *request)
	Returns true if this request is cacheable.
static bool	responseIsCacheable (const URLResponse *response)
	Returns true if this response is cacheable.
static void	setMaxSize (URLCache *self, size_t maxSize)
static void	storeCachedResponseForRequest (URLCache *self, const URLRequest *request, const URLResponse *response, const Data *data)
static bool	stringEqualsIgnoreCase (const char *a, const char *b)
	Tests two C strings for case-insensitive equality.
static bool	stringEqualsIgnoreCaseN (const char *a, const char *b, size_t length)
	Tests the first length characters of two C strings for case-insensitive equality.

Macro Definition Documentation

_Class

#define _Class   _URLCache

Definition at line 31 of file URLCache.c.

URLCACHE_DEFAULT_MAX_SIZE

#define URLCACHE_DEFAULT_MAX_SIZE   (1024 * 1024)

Definition at line 33 of file URLCache.c.

Function Documentation

_URLCache()

Class * _URLCache

(

void

)

Definition at line 411 of file URLCache.c.

                       {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "URLCache",
      .superclass = _Object(),
      .instanceSize = sizeof(URLCache),
      .interfaceOffset = offsetof(URLCache, interface),
      .interfaceSize = sizeof(URLCacheInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

cacheControlDisablesCaching()

static bool cacheControlDisablesCaching ( const char *  value )

static

Returns true if the provided Cache-Control value disables caching.

Definition at line 104 of file URLCache.c.

                                                           {
 
  if (value == NULL) {
    return false;
  }
 
  const char *cursor = value;
  while (*cursor) {
 
    while (*cursor == ' ' || *cursor == '\t' || *cursor == ',') {
      cursor++;
    }
 
    const char *end = cursor;
    while (*end && *end != ',') {
      end++;
    }
 
    const char *start = cursor;
    while (start < end && isspace((unsigned char) *start)) {
      start++;
    }
 
    while (end > start && isspace((unsigned char) *(end - 1))) {
      end--;
    }
 
    const size_t length = (size_t) (end - start);
    if (length > 0) {
 
      if (length == 8 && stringEqualsIgnoreCaseN(start, "no-cache", 8)) {
        return true;
      }
 
      if (length == 8 && stringEqualsIgnoreCaseN(start, "no-store", 8)) {
        return true;
      }
 
      if (length >= 8 && stringEqualsIgnoreCaseN(start, "max-age=", 8)) {
        if (strtol(start + 8, NULL, 10) <= 0) {
          return true;
        }
      }
    }
 
    cursor = end;
    if (*cursor == ',') {
      cursor++;
    }
  }
 
  return false;
}

cachedResponseForRequest()

static URLCachedResponse * cachedResponseForRequest ( URLCache *  self, const URLRequest *  request  )

static

Definition at line 268 of file URLCache.c.

                                                                                              {
 
  if (requestIsCacheable(request) == false) {
    return NULL;
  }
 
  URLCachedResponse *cachedResponse = NULL;
  const Dictionary *dictionary = (Dictionary *) self->responses;
  synchronized(self->lock, {
    cachedResponse = $(dictionary, objectForKey, (ident) request);
    if (cachedResponse) {
      retain(cachedResponse);
    }
  });
 
  return cachedResponse;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 252 of file URLCache.c.

                                  {
 
  URLCache *this = (URLCache *) self;
 
  release(this->lock);
  release(this->responses);
 
  super(Object, self, dealloc);
}

evictIfNeeded()

static void evictIfNeeded ( URLCache *  self )

static

Removes the oldest cached response while this cache exceeds its maximum size.

Definition at line 213 of file URLCache.c.

                                          {
 
  const Dictionary *dictionary = (Dictionary *) self->responses;
 
  while (self->currentSize > self->maxSize && self->responses->count > 0) {
 
    Array *keys = $(dictionary, allKeys);
 
    const URLRequest *oldestKey = NULL;
    URLCachedResponse *oldestResponse = NULL;
 
    for (size_t i = 0; i < keys->count; i++) {
 
      const URLRequest *key = $(keys, objectAtIndex, i);
      URLCachedResponse *candidate = $(dictionary, objectForKey, (ident) key);
 
      if (candidate && (oldestResponse == NULL
          || $(candidate->timestamp, compareTo, oldestResponse->timestamp) == OrderAscending)) {
        oldestKey = key;
        oldestResponse = candidate;
      }
    }
 
    release(keys);
 
    if (oldestKey == NULL || oldestResponse == NULL) {
      break;
    }
 
    self->currentSize -= oldestResponse->size;
    $(self->responses, removeObjectForKey, (ident) oldestKey);
  }
}

headerValueForField()

static const String * headerValueForField ( const Dictionary *  headers, const char *  field  )

static

Returns the value for the specified HTTP header field, case-insensitively.

Definition at line 79 of file URLCache.c.

                                                                                       {
 
  if (headers && field) {
 
    Array *keys = $(headers, allKeys);
    for (size_t i = 0; i < keys->count; i++) {
 
      const String *key = $(keys, objectAtIndex, i);
      if (stringEqualsIgnoreCase(key->chars, field)) {
 
        const String *value = $(headers, objectForKey, (ident) key);
        release(keys);
        return value;
      }
    }
 
    release(keys);
  }
 
  return NULL;
}

init()

static URLCache * init ( URLCache *  self )

static

Definition at line 290 of file URLCache.c.

                                      {
 
  self = (URLCache *) super(Object, self, init);
  if (self) {
    self->lock = $(alloc(Lock), init);
    assert(self->lock);
 
    self->responses = $(alloc(Dictionary), init);
    assert(self->responses);
 
    self->maxSize = URLCACHE_DEFAULT_MAX_SIZE;
  }
 
  return self;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 395 of file URLCache.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
  ((URLCacheInterface *) clazz->interface)->cachedResponseForRequest = cachedResponseForRequest;
  ((URLCacheInterface *) clazz->interface)->init = init;
  ((URLCacheInterface *) clazz->interface)->removeAllCachedResponses = removeAllCachedResponses;
  ((URLCacheInterface *) clazz->interface)->removeCachedResponseForRequest = removeCachedResponseForRequest;
  ((URLCacheInterface *) clazz->interface)->setMaxSize = setMaxSize;
  ((URLCacheInterface *) clazz->interface)->storeCachedResponseForRequest = storeCachedResponseForRequest;
}

removeAllCachedResponses()

static void removeAllCachedResponses ( URLCache *  self )

static

Definition at line 310 of file URLCache.c.

                                                     {
 
  synchronized(self->lock, {
    $(self->responses, removeAllObjects);
    self->currentSize = 0;
  });
}

removeCachedResponseForRequest()

static void removeCachedResponseForRequest ( URLCache *  self, const URLRequest *  request  )

static

Definition at line 322 of file URLCache.c.

                                                                                      {
 
  synchronized(self->lock, {
    const Dictionary *dictionary = (Dictionary *) self->responses;
    URLCachedResponse *cachedResponse = $(dictionary, objectForKey, (ident) request);
    if (cachedResponse) {
      self->currentSize -= cachedResponse->size;
      $(self->responses, removeObjectForKey, (ident) request);
    }
  });
}

requestIsCacheable()

static bool requestIsCacheable ( const URLRequest *  request )

static

Returns true if this request is cacheable.

Definition at line 161 of file URLCache.c.

                                                          {
 
  if (request == NULL) {
    return false;
  }
 
  switch (request->httpMethod) {
    case HTTP_NONE:
    case HTTP_GET:
      break;
    default:
      return false;
  }
 
  const String *cacheControl = headerValueForField(request->httpHeaders, "Cache-Control");
  if (cacheControl && cacheControlDisablesCaching(cacheControl->chars)) {
    return false;
  }
 
  const String *pragma = headerValueForField(request->httpHeaders, "Pragma");
  if (pragma && stringEqualsIgnoreCase(pragma->chars, "no-cache")) {
    return false;
  }
 
  return true;
}

responseIsCacheable()

static bool responseIsCacheable ( const URLResponse *  response )

static

Returns true if this response is cacheable.

Definition at line 191 of file URLCache.c.

                                                             {
 
  if (response == NULL || response->httpStatusCode != 200) {
    return false;
  }
 
  const String *cacheControl = headerValueForField(response->httpHeaders, "Cache-Control");
  if (cacheControl && cacheControlDisablesCaching(cacheControl->chars)) {
    return false;
  }
 
  const String *pragma = headerValueForField(response->httpHeaders, "Pragma");
  if (pragma && stringEqualsIgnoreCase(pragma->chars, "no-cache")) {
    return false;
  }
 
  return true;
}

setMaxSize()

static void setMaxSize ( URLCache *  self, size_t  maxSize  )

static

Definition at line 338 of file URLCache.c.

                                                       {
 
  synchronized(self->lock, {
    self->maxSize = maxSize;
 
    if (self->maxSize == 0) {
      $(self->responses, removeAllObjects);
      self->currentSize = 0;
    } else {
      evictIfNeeded(self);
    }
  });
}

storeCachedResponseForRequest()

static void storeCachedResponseForRequest ( URLCache *  self, const URLRequest *  request, const URLResponse *  response, const Data *  data  )

static

Definition at line 356 of file URLCache.c.

                                                   {
 
  if (requestIsCacheable(request) == false || responseIsCacheable(response) == false) {
    return;
  }
 
  URLCachedResponse *cachedResponse = $(alloc(URLCachedResponse), initWithResponseData, response, data);
  if (cachedResponse == NULL) {
    return;
  }
 
  synchronized(self->lock, {
    if (cachedResponse->size <= self->maxSize && self->maxSize > 0) {
 
      const Dictionary *dictionary = (Dictionary *) self->responses;
      URLCachedResponse *existing = $(dictionary, objectForKey, (ident) request);
      if (existing) {
        self->currentSize -= existing->size;
        $(self->responses, removeObjectForKey, (ident) request);
      }
 
      URLRequest *key = (URLRequest *) $((Object *) request, copy);
      $(self->responses, setObjectForKey, cachedResponse, key);
      release(key);
 
      self->currentSize += cachedResponse->size;
      evictIfNeeded(self);
    }
  });
 
  release(cachedResponse);
}

stringEqualsIgnoreCase()

static bool stringEqualsIgnoreCase ( const char *  a, const char *  b  )

static

Tests two C strings for case-insensitive equality.

Definition at line 40 of file URLCache.c.

                                                                 {
 
  if (a == NULL || b == NULL) {
    return false;
  }
 
  while (*a && *b) {
    if (tolower((unsigned char) *a) != tolower((unsigned char) *b)) {
      return false;
    }
 
    a++;
    b++;
  }
 
  return *a == 0 && *b == 0;
}

stringEqualsIgnoreCaseN()

static bool stringEqualsIgnoreCaseN ( const char *  a, const char *  b, size_t  length  )

static

Tests the first length characters of two C strings for case-insensitive equality.

Definition at line 61 of file URLCache.c.

                                                                                 {
 
  if (a == NULL || b == NULL) {
    return false;
  }
 
  for (size_t i = 0; i < length; i++) {
    if (tolower((unsigned char) a[i]) != tolower((unsigned char) b[i])) {
      return false;
    }
  }
 
  return true;
}