shoes 3.0.1

data/shoes/http/windownload.c

@@ -0,0 +1,114 @@
+//
+// shoes/http/windownload.c
+// the downloader routines using windows' winhttp lib.
+//
+#include "shoes/app.h"
+#include "shoes/ruby.h"
+#include "shoes/internal.h"
+#include "shoes/config.h"
+#include "shoes/http.h"
+#include "shoes/version.h"
+#include "shoes/world.h"
+#include "shoes/native.h"
+#include <shellapi.h>
+#include <wchar.h>
+#include <time.h>
+
+void
+shoes_download(shoes_http_request *req)
+{
+  HANDLE file = INVALID_HANDLE_VALUE;
+  INTERNET_PORT _port = req->port;
+  LPWSTR _method = NULL, _body = NULL;
+  LPWSTR _scheme = SHOE_ALLOC_N(WCHAR, MAX_PATH);
+  LPWSTR _host = SHOE_ALLOC_N(WCHAR, MAX_PATH);
+  LPWSTR _path = SHOE_ALLOC_N(WCHAR, MAX_PATH);
+  DWORD _size;
+  MultiByteToWideChar(CP_UTF8, 0, req->scheme, -1, _scheme, MAX_PATH);
+  MultiByteToWideChar(CP_UTF8, 0, req->host, -1, _host, MAX_PATH);
+  MultiByteToWideChar(CP_UTF8, 0, req->path, -1, _path, MAX_PATH);
+  if (req->method != NULL)
+  {
+    _method = SHOE_ALLOC_N(WCHAR, MAX_PATH);
+    MultiByteToWideChar(CP_UTF8, 0, req->method, -1, _method, MAX_PATH);
+  }
+
+  if (req->mem == NULL && req->filepath != NULL)
+    file = CreateFile(req->filepath, GENERIC_READ | GENERIC_WRITE,
+      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+  shoes_winhttp(_scheme, _host, _port, _path, _method, req->headers, (LPVOID)req->body, req->bodylen,
+               &req->mem, req->memlen, file, &_size, req->flags, req->handler, req->data);
+  req->size = _size;
+  SHOE_FREE(_scheme);
+  SHOE_FREE(_host);
+  SHOE_FREE(_path);
+  if (_method != NULL) SHOE_FREE(_method);
+}
+
+DWORD WINAPI
+shoes_download2(LPVOID data)
+{
+  shoes_http_request *req = (shoes_http_request *)data;
+  shoes_download(req);
+  shoes_http_request_free(req);
+  free(req);
+  return TRUE;
+}
+
+void
+shoes_queue_download(shoes_http_request *req)
+{
+  DWORD tid;
+  CreateThread(0, 0, (LPTHREAD_START_ROUTINE)shoes_download2, (void *)req, 0, &tid);
+}
+
+VALUE
+shoes_http_err(SHOES_DOWNLOAD_ERROR code)
+{
+  TCHAR msg[1024];
+  DWORD msglen;
+  if (code > 12000 && code <= 12174)
+  {
+    msglen = FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+      GetModuleHandle("WINHTTP.DLL"), code, 0, msg, sizeof(msg), NULL);
+  }
+  else
+  {
+    msglen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+      NULL, code, 0, msg, sizeof(msg), NULL);
+  }
+  msg[msglen] = '\0';
+  return rb_str_new2(msg);
+}
+
+SHOES_DOWNLOAD_HEADERS
+shoes_http_headers(VALUE hsh)
+{
+  long i;
+  LPWSTR hdrs = NULL;
+  VALUE keys = rb_funcall(hsh, s_keys, 0);
+  if (RARRAY_LEN(keys) > 0)
+  {
+    VALUE headers = rb_str_new2("");
+    //for (i = 0; i < RARRAY(keys)->as.heap.len; i++ )
+    for (i = 0; i < RARRAY_LEN(keys); i++ )
+    {
+      VALUE key = rb_ary_entry(keys, i);
+      rb_str_append(headers, key);
+      rb_str_cat2(headers, ": ");
+      rb_str_append(headers, rb_hash_aref(hsh, key));
+      rb_str_cat2(headers, "\n");
+    }
+
+    hdrs = SHOE_ALLOC_N(WCHAR, RSTRING_LEN(headers) + 1);
+    SHOE_MEMZERO(hdrs, WCHAR, RSTRING_LEN(headers) + 1);
+    MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(headers), -1, hdrs, RSTRING_LEN(headers) + 1);
+  }
+  return hdrs;
+}
+
+void
+shoes_http_headers_free(SHOES_DOWNLOAD_HEADERS headers)
+{
+  SHOE_FREE(headers);
+}

data/shoes/http/winhttp.c

@@ -0,0 +1,216 @@
+//
+// shoes/http/winhttp.c
+// the central download routine
+// (isolated so it can be reused in platform/msw/stub.c)
+//
+#include "shoes/app.h"
+#include "shoes/ruby.h"
+#include "shoes/internal.h"
+#include "shoes/config.h"
+#include "shoes/version.h"
+#include "shoes/http/common.h"
+#include "shoes/http/winhttp.h"
+
+void shoes_get_time(SHOES_TIME *ts)
+{
+  *ts = GetTickCount();
+}
+
+unsigned long shoes_diff_time(SHOES_TIME *start, SHOES_TIME *end)
+{
+  return *end - *start;
+}
+
+void
+shoes_winhttp_headers(HINTERNET req, shoes_http_handler handler, void *data)
+{ 
+  DWORD size;
+  WinHttpQueryHeaders(req, WINHTTP_QUERY_RAW_HEADERS,
+    WINHTTP_HEADER_NAME_BY_INDEX, NULL, &size, WINHTTP_NO_HEADER_INDEX);
+
+  if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+  {
+    int whdrlen = 0, hdrlen = 0;
+    LPCWSTR whdr;
+    LPSTR hdr = SHOE_ALLOC_N(CHAR, MAX_PATH);
+    LPCWSTR hdrs = SHOE_ALLOC_N(WCHAR, size/sizeof(WCHAR));
+    BOOL res = WinHttpQueryHeaders(req, WINHTTP_QUERY_RAW_HEADERS,
+      WINHTTP_HEADER_NAME_BY_INDEX, (LPVOID)hdrs, &size, WINHTTP_NO_HEADER_INDEX);
+    if (res)
+    {
+      for (whdr = hdrs; whdr - hdrs < size / sizeof(WCHAR); whdr += whdrlen)
+      {
+        WideCharToMultiByte(CP_UTF8, 0, whdr, -1, hdr, MAX_PATH, NULL, NULL);
+        hdrlen = strlen(hdr);
+        HTTP_HEADER(hdr, hdrlen, handler, data);
+        whdrlen = wcslen(whdr) + 1;
+      }
+    }
+    SHOE_FREE(hdrs);
+    SHOE_FREE(hdr);
+  }
+}
+
+void
+shoes_winhttp(LPCWSTR scheme, LPCWSTR host, INTERNET_PORT port, LPCWSTR path, LPCWSTR method,
+  LPCWSTR headers, LPVOID body, DWORD bodylen, TCHAR **mem, ULONG memlen, HANDLE file,
+  LPDWORD size, UCHAR flags, shoes_http_handler handler, void *data)
+{
+  LPWSTR proxy;
+  DWORD len = 0, rlen = 0, status = 0, complete = 0, flen = 0, total = 0, written = 0;
+  LPTSTR buf = SHOE_ALLOC_N(TCHAR, SHOES_BUFSIZE);
+  LPTSTR fbuf = SHOE_ALLOC_N(TCHAR, SHOES_CHUNKSIZE);
+  LPWSTR uagent = SHOE_ALLOC_N(WCHAR, SHOES_BUFSIZE);
+  HINTERNET sess = NULL, conn = NULL, req = NULL;
+  SHOES_TIME last = 0;
+
+  if (buf == NULL || fbuf == NULL || uagent == NULL)
+    goto done;
+
+  _snwprintf(uagent, SHOES_BUFSIZE, L"Shoes/0.r%d (%S) %S/%d", SHOES_REVISION, SHOES_PLATFORM,
+    SHOES_RELEASE_NAME, SHOES_BUILD_DATE);
+  sess = WinHttpOpen(uagent, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
+    WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
+  if (sess == NULL)
+    goto done;
+
+  conn = WinHttpConnect(sess, host, port, 0);
+  if (conn == NULL)
+    goto done;
+
+  if (method == NULL) method = L"GET";
+  req = WinHttpOpenRequest(conn, method, path,
+    NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
+  if (req == NULL)
+    goto done;
+
+  proxy = _wgetenv(L"http_proxy");
+  if (proxy != NULL)
+  {
+    WINHTTP_PROXY_INFO proxy_info;
+    proxy_info.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
+    proxy_info.lpszProxy = proxy;
+    proxy_info.lpszProxyBypass = NULL;
+    WinHttpSetOption(req, WINHTTP_OPTION_PROXY, &proxy_info, sizeof(proxy_info));
+  }
+
+  if (!(flags & SHOES_DL_REDIRECTS))
+  {
+    DWORD options = WINHTTP_DISABLE_REDIRECTS;
+    WinHttpSetOption(req, WINHTTP_OPTION_DISABLE_FEATURE, &options, sizeof(options));
+  }
+
+  if (headers != NULL)
+    WinHttpAddRequestHeaders(req, headers, -1L, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE);
+
+  if (!WinHttpSendRequest(req, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
+    (LPVOID)body, bodylen, bodylen, 0))
+    goto done;
+
+  if (!WinHttpReceiveResponse(req, NULL))
+    goto done;
+
+  len = sizeof(DWORD);
+  if (!WinHttpQueryHeaders(req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
+    NULL, &status, &len, NULL))
+    goto done;
+  else if (handler != NULL)
+  {
+    shoes_http_event *event = SHOE_ALLOC(shoes_http_event);
+    SHOE_MEMZERO(event, shoes_http_event, 1);
+    event->stage = SHOES_HTTP_STATUS;
+    event->status = status;
+    handler(event, data);
+    SHOE_FREE(event);
+  }
+
+  if (handler != NULL) shoes_winhttp_headers(req, handler, data);
+
+  *size = 0;
+  len = sizeof(buf);
+  if (WinHttpQueryHeaders(req, WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER,
+    NULL, size, &len, NULL))
+  {
+    if (*mem != NULL && *size > memlen)
+    {
+      SHOE_REALLOC_N(*mem, char, (memlen = *size));
+      if (*mem == NULL) goto done;
+    }
+  }
+
+  HTTP_EVENT(handler, SHOES_HTTP_CONNECTED, last, 0, 0, *size, data, NULL, goto done);
+
+  total = *size * 100;
+  rlen = *size;
+  while (1)
+  {
+    len = 0;
+    WinHttpReadData(req, fbuf, SHOES_CHUNKSIZE, &len);
+    if (len <= 0)
+      break;
+
+    if (*mem != NULL)
+    {
+      if (written + len > memlen)
+      {
+        while (written + len > memlen)
+          memlen += SHOES_BUFSIZE;
+        SHOE_REALLOC_N(*mem, char, memlen);
+        if (*mem == NULL) goto done;
+      }
+      SHOE_MEMCPY(*mem + written, fbuf, char, len);
+    }
+    if (file != INVALID_HANDLE_VALUE)
+      WriteFile(file, (LPBYTE)fbuf, len, &flen, NULL);
+    written += len;
+
+    if (*size == 0) total = written * 100;
+    if (total > 0)
+    {
+      HTTP_EVENT(handler, SHOES_HTTP_TRANSFER, last, (int)((total - (rlen * 100)) / (total / 100)),
+                 (total / 100) - rlen, (total / 100), data, NULL, break);
+    }
+
+    if (rlen > len) rlen -= len;
+  }
+
+  *size = written;
+
+  if (file != INVALID_HANDLE_VALUE)
+  {
+    CloseHandle(file);
+    file = INVALID_HANDLE_VALUE;
+  }
+
+  HTTP_EVENT(handler, SHOES_HTTP_COMPLETED, last, 100, *size, *size, data, *mem, goto done);
+  complete = 1;
+
+done:
+  if (buf != NULL)    SHOE_FREE(buf);
+  if (fbuf != NULL)   SHOE_FREE(fbuf);
+  if (uagent != NULL) SHOE_FREE(uagent);
+
+  if (!complete)
+  {
+    shoes_http_event *event = SHOE_ALLOC(shoes_http_event);
+    SHOE_MEMZERO(event, shoes_http_event, 1);
+    event->stage = SHOES_HTTP_ERROR;
+    event->error = GetLastError();
+    int hx = handler(event, data);
+    SHOE_FREE(event);
+    if (hx & SHOES_DOWNLOAD_HALT) goto done;
+  }
+
+  if (file != INVALID_HANDLE_VALUE)
+    CloseHandle(file);
+
+  if (req)
+    WinHttpCloseHandle(req);
+
+  if (conn)
+    WinHttpCloseHandle(conn);
+
+  if (sess)
+    WinHttpCloseHandle(sess);
+}
+

data/shoes/http/winhttp.h

@@ -0,0 +1,19 @@
+//
+// shoes/http/winhttp.h
+// the shoes_winhttp function, used by platform/msw/stub.c.
+//
+#ifndef SHOES_HTTP_WINHTTP_H
+#define SHOES_HTTP_WINHTTP_H
+
+#include <stdio.h>
+#include <windows.h>
+#include <wchar.h>
+#include <winhttp.h>
+#include <shellapi.h>
+#include "shoes/http/common.h"
+
+#define HTTP_HANDLER(x) reinterpret_cast<shoes_http_handler>(x)
+
+void shoes_winhttp(LPCWSTR, LPCWSTR, INTERNET_PORT, LPCWSTR, LPCWSTR, LPCWSTR, LPVOID, DWORD, TCHAR **, ULONG, HANDLE, LPDWORD, UCHAR, shoes_http_handler, void *);
+
+#endif

data/shoes/image.c

@@ -0,0 +1,1020 @@
+//
+// shoes/image.c
+// Loading image formats in Cairo.  I've already tried gdk-pixbuf and imlib2, but 
+// the idea here is to cut down dependencies, since I only really need reading of 
+// the basics: GIF and JPEG.
+//
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/stat.h>
+#include "shoes/app.h"
+#include "shoes/canvas.h"
+#include "shoes/ruby.h"
+#include "shoes/internal.h"
+#include "shoes/world.h"
+#include "shoes/native.h"
+#include "shoes/version.h"
+#include "shoes/http.h"
+
+#undef HAVE_PROTOTYPES
+#undef HAVE_STDLIB_H
+#undef EXTERN
+#include <jpeglib.h>
+#include <jerror.h>
+
+#ifndef SHOES_GTK
+#ifdef DrawText
+#undef DrawText
+#endif
+#endif
+#define DrawText gif_DrawText
+#include <gif_lib.h>
+
+shoes_image_format shoes_image_detect(VALUE, int *, int *);
+
+#define JPEG_LINES 16
+#define SIZE_SURFACE ((cairo_surface_t *)1)
+
+typedef struct {
+  unsigned int state[5];
+  unsigned int count[2];
+  unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(unsigned int state[5], unsigned char buffer[64]);
+void SHA1Init(SHA1_CTX* context);
+void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len);
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#ifdef LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+  |(rol(block->l[i],8)&0x00FF00FF))
+#else
+#define blk0(i) block->l[i]
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+  ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+void SHA1Transform(unsigned int state[5], unsigned char buffer[64])
+{
+unsigned int a, b, c, d, e;
+typedef union {
+  unsigned char c[64];
+  unsigned int l[16];
+} CHAR64LONG16;
+CHAR64LONG16* block;
+#ifdef SHA1HANDSOFF
+static unsigned char workspace[64];
+  block = (CHAR64LONG16*)workspace;
+  memcpy(block, buffer, 64);
+#else
+  block = (CHAR64LONG16*)buffer;
+#endif
+  /* Copy context->state[] to working vars */
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  /* 4 rounds of 20 operations each. Loop unrolled. */
+  R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+  R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+  R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+  R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+  R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+  R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+  R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+  R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+  R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+  R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+  R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+  R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+  R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+  R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+  R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+  R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+  R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+  R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+  R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+  R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+  /* Add the working vars back into context.state[] */
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  /* Wipe variables */
+  a = b = c = d = e = 0;
+}
+
+/* SHA1Init - Initialize new context */
+void SHA1Init(SHA1_CTX* context)
+{
+  /* SHA1 initialization constants */
+  context->state[0] = 0x67452301;
+  context->state[1] = 0xEFCDAB89;
+  context->state[2] = 0x98BADCFE;
+  context->state[3] = 0x10325476;
+  context->state[4] = 0xC3D2E1F0;
+  context->count[0] = context->count[1] = 0;
+}
+
+/* Run your data through this. */
+void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len)
+{
+unsigned int i, j;
+
+  j = (context->count[0] >> 3) & 63;
+  if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
+  context->count[1] += (len >> 29);
+  if ((j + len) > 63) {
+    memcpy(&context->buffer[j], data, (i = 64-j));
+    SHA1Transform(context->state, context->buffer);
+    for ( ; i + 63 < len; i += 64) {
+      SHA1Transform(context->state, &data[i]);
+    }
+    j = 0;
+  }
+  else i = 0;
+  memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+/* Add padding and return the message digest. */
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
+{
+unsigned int i, j;
+unsigned char finalcount[8];
+
+  for (i = 0; i < 8; i++) {
+    finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
+     >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
+  }
+  SHA1Update(context, (unsigned char *)"\200", 1);
+  while ((context->count[0] & 504) != 448) {
+    SHA1Update(context, (unsigned char *)"\0", 1);
+  }
+  SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
+  for (i = 0; i < 20; i++) {
+    digest[i] = (unsigned char)
+     ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+  }
+  /* Wipe variables */
+  i = j = 0;
+  memset(context->buffer, 0, 64);
+  memset(context->state, 0, 20);
+  memset(context->count, 0, 8);
+  memset(&finalcount, 0, 8);
+#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
+  SHA1Transform(context->state, context->buffer);
+#endif
+}
+
+cairo_surface_t *
+shoes_surface_create_from_pixels(PIXEL *pixels, int width, int height)
+{
+  guchar *cairo_pixels;
+  cairo_surface_t *surface;
+  cairo_user_data_key_t key;
+  int j;
+ 
+  cairo_pixels = (guchar *)g_malloc(4 * width * height);
+  surface = cairo_image_surface_create_for_data((unsigned char *)cairo_pixels,
+    CAIRO_FORMAT_ARGB32,
+    width, height, 4 * width);
+  cairo_surface_set_user_data(surface, &key,
+    cairo_pixels, (cairo_destroy_func_t)g_free);
+ 
+  for (j = height; j; j--)
+  {
+    guchar *p = (guchar *)pixels;
+    guchar *q = cairo_pixels;
+   
+    guchar *end = p + 4 * width;
+    guint t1,t2,t3;
+ 
+#define MULT(d,c,a,t) G_STMT_START { t = c * a; d = ((t >> 8) + t) >> 8; } G_STMT_END
+ 
+    while (p < end)
+    {
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+      MULT(q[2], p[2], p[3], t1);
+      MULT(q[1], p[1], p[3], t2);
+      MULT(q[0], p[0], p[3], t3);
+      q[3] = p[3];
+#else
+      q[0] = p[3];
+      MULT(q[3], p[0], p[3], t1);
+      MULT(q[2], p[1], p[3], t2);
+      MULT(q[1], p[2], p[3], t3);
+#endif
+    
+      p += 4;
+      q += 4;
+    }
+   
+#undef MULT
+   
+    pixels += width;
+    cairo_pixels += 4 * width;
+  }
+ 
+  return surface;
+}
+
+#define PNG_SIG "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"
+
+cairo_surface_t *
+shoes_png_size(char *filename, int *width, int *height)
+{
+  unsigned char *sig = SHOE_ALLOC_N(unsigned char, 32);
+  cairo_surface_t *surface = NULL;
+  
+#ifdef SHOES_WIN32
+  HANDLE hFile;
+  hFile = CreateFile( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
+  if ( hFile == INVALID_HANDLE_VALUE ) return NULL;
+  DWORD readsize;
+	ReadFile( hFile, sig, 32, &readsize, NULL );
+  if (readsize < 8)
+    goto done; 
+#else
+  FILE *image = fopen(filename, "rb");
+  if (image == NULL) return NULL;
+
+  if (fread(sig, 1, 32, image) < 8)
+    goto done; 
+#endif
+  
+  if (memcmp(sig, PNG_SIG, 8) != 0)
+    goto done;
+
+  *width = *((int *)(sig + 0x10));
+  BE_CPU(*width);
+  *height = *((int *)(sig + 0x14));
+  BE_CPU(*height);
+
+  surface = SIZE_SURFACE;
+done:
+#ifdef SHOES_WIN32
+  CloseHandle( hFile );
+#else
+  fclose(image);
+#endif
+  return surface;
+}
+
+cairo_surface_t *
+shoes_surface_create_from_gif(char *filename, int *width, int *height, unsigned char load)
+{
+  cairo_surface_t *surface = NULL;
+  GifFileType *gif;
+  PIXEL *ptr = NULL, *pixels = NULL;
+  GifPixelType **rows = NULL;
+  GifRecordType rec;
+  ColorMapObject *cmap;
+  int i, j, bg, r, g, b, w = 0, h = 0, done = 0, transp = -1;
+  float per = 0.0, per_inc;
+  int intoffset[] = { 0, 4, 2, 1 };
+  int intjump[] = { 8, 8, 4, 2 };
+
+  transp = -1;
+  gif = DGifOpenFileName(filename);
+  if (gif == NULL)
+    goto done;
+
+  do
+  {
+    if (DGifGetRecordType(gif, &rec) == GIF_ERROR)
+      rec = TERMINATE_RECORD_TYPE;
+    if ((rec == IMAGE_DESC_RECORD_TYPE) && (!done))
+    {
+      if (DGifGetImageDesc(gif) == GIF_ERROR)
+        {
+           /* PrintGifError(); */
+           rec = TERMINATE_RECORD_TYPE;
+        }
+      w = gif->Image.Width;
+      if (width != NULL) *width = w;
+      h = gif->Image.Height;
+      if (height != NULL) *height = h;
+      if ((w < 1) || (h < 1) || (w > 8192) || (h > 8192))
+        goto done;
+
+      if (!load)
+      {
+        surface = SIZE_SURFACE;
+        goto done;
+      }
+
+      rows = SHOE_ALLOC_N(GifPixelType *, h);
+      if (rows == NULL)
+        goto done;
+
+      SHOE_MEMZERO(rows, GifPixelType *, h);
+
+      for (i = 0; i < h; i++)
+      {
+        rows[i] = SHOE_ALLOC_N(GifPixelType, w);
+        if (rows[i] == NULL)
+          goto done;
+      }
+
+      if (gif->Image.Interlace)
+      {
+        for (i = 0; i < 4; i++)
+        {
+          for (j = intoffset[i]; j < h; j += intjump[i])
+            DGifGetLine(gif, rows[j], w);
+        }
+      }
+      else
+      {
+        for (i = 0; i < h; i++)
+          DGifGetLine(gif, rows[i], w);
+      }
+      done = 1;
+    }
+    else if (rec == EXTENSION_RECORD_TYPE)
+    {
+      int ext_code;
+      GifByteType *ext = NULL;
+      DGifGetExtension(gif, &ext_code, &ext);
+      while (ext)
+      {
+        if ((ext_code == 0xf9) && (ext[1] & 1) && (transp < 0))
+          transp = (int)ext[4];
+        ext = NULL;
+        DGifGetExtensionNext(gif, &ext);
+      }
+    }
+  } while (rec != TERMINATE_RECORD_TYPE);
+
+  bg = gif->SBackGroundColor;
+  cmap = (gif->Image.ColorMap ? gif->Image.ColorMap : gif->SColorMap);
+  pixels = SHOE_ALLOC_N(PIXEL, w * h);
+  if (pixels == NULL)
+    goto done;
+
+  ptr = pixels;
+  per_inc = 100.0 / (((float)w) * h);
+  for (i = 0; i < h; i++)
+  {
+    for (j = 0; j < w; j++)
+    {
+      if (rows[i][j] == transp)
+      {
+        r = cmap->Colors[bg].Red;
+        g = cmap->Colors[bg].Green;
+        b = cmap->Colors[bg].Blue;
+        *ptr = 0x00ffffff & ((r << 16) | (g << 8) | b);
+        LE_CPU(*ptr);
+        ptr++;
+      }
+      else
+      {
+        r = cmap->Colors[rows[i][j]].Red;
+        g = cmap->Colors[rows[i][j]].Green;
+        b = cmap->Colors[rows[i][j]].Blue;
+        *ptr = (0xff << 24) | (r << 16) | (g << 8) | b;
+        LE_CPU(*ptr);
+        ptr++;
+      }
+      per += per_inc;
+    }
+  }
+
+  if ((w < 1) || (h < 1) || (w > 8192) || (h > 8192))
+    goto done;
+
+  surface = shoes_surface_create_from_pixels(pixels, w, h);
+
+done:
+  if (gif != NULL) DGifCloseFile(gif);
+  if (pixels != NULL) SHOE_FREE(pixels);
+  if (rows != NULL) {
+    for (i = 0; i < h; i++)
+      if (rows[i] != NULL)
+        SHOE_FREE(rows[i]);
+    SHOE_FREE(rows);
+  }
+  return surface;
+}
+
+//
+// JPEG handling code
+//
+struct shoes_jpeg_file_src {
+  struct jpeg_source_mgr pub;   /* public fields */
+  
+#ifdef SHOES_WIN32
+  HANDLE infile;        /* source stream */
+#else
+  FILE *infile;         /* source stream */
+#endif
+  
+  JOCTET *buffer;         /* start of buffer */
+  boolean start_of_file;    /* have we gotten any data yet? */
+};
+
+struct shoes_jpeg_error_mgr {
+  struct jpeg_error_mgr pub;             /* public fields */
+  jmp_buf setjmp_buffer;  /* for return to caller */
+};
+
+typedef struct shoes_jpeg_file_src *shoes_jpeg_file;
+typedef struct shoes_jpeg_error_mgr *shoes_jpeg_err;
+
+#define JPEG_INPUT_BUF_SIZE 4096
+
+void
+shoes_jpeg_term_source(j_decompress_ptr cinfo)
+{
+}
+
+void
+shoes_jpeg_init_source(j_decompress_ptr cinfo)
+{
+  shoes_jpeg_file src = (shoes_jpeg_file) cinfo->src;
+  src->start_of_file = 1;
+}
+
+
+boolean
+shoes_jpeg_fill_input_buffer(j_decompress_ptr cinfo)
+{
+  shoes_jpeg_file src = (shoes_jpeg_file)cinfo->src;
+  size_t nbytes;
+
+#ifdef SHOES_WIN32
+  DWORD readsize;
+	ReadFile( src->infile, src->buffer, JPEG_INPUT_BUF_SIZE, &readsize, NULL );
+  nbytes = readsize;
+#else
+  nbytes = fread(src->buffer, 1, JPEG_INPUT_BUF_SIZE, src->infile);
+#endif
+
+  if (nbytes <= 0) {
+    if (src->start_of_file) /* Treat empty input file as fatal error */
+      ERREXIT(cinfo, JERR_INPUT_EMPTY);
+    WARNMS(cinfo, JWRN_JPEG_EOF);
+    src->buffer[0] = (JOCTET) 0xFF;
+    src->buffer[1] = (JOCTET) JPEG_EOI;
+    nbytes = 2;
+  }
+
+  src->pub.next_input_byte = src->buffer;
+  src->pub.bytes_in_buffer = nbytes;
+  src->start_of_file = 0;
+
+  return 1;
+}
+
+void
+shoes_jpeg_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
+{
+  shoes_jpeg_file src = (shoes_jpeg_file)cinfo->src;
+
+  if (num_bytes > 0)
+  {
+    while (num_bytes > (long)src->pub.bytes_in_buffer)
+    {
+      num_bytes -= (long)src->pub.bytes_in_buffer;
+      (void)shoes_jpeg_fill_input_buffer(cinfo);
+    }
+    src->pub.next_input_byte += (size_t)num_bytes;
+    src->pub.bytes_in_buffer -= (size_t)num_bytes;
+  }
+}
+
+void
+#ifdef SHOES_WIN32
+jpeg_file_src(j_decompress_ptr cinfo, HANDLE infile)
+#else
+jpeg_file_src(j_decompress_ptr cinfo, FILE *infile)
+#endif
+{
+  shoes_jpeg_file src;
+
+  if (cinfo->src == NULL)
+  {
+    /* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small)((j_common_ptr) cinfo, JPOOL_PERMANENT,
+                    sizeof(struct shoes_jpeg_file_src));
+    src = (shoes_jpeg_file) cinfo->src;
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small)((j_common_ptr) cinfo, JPOOL_PERMANENT,
+                    JPEG_INPUT_BUF_SIZE * sizeof(JOCTET));
+  }
+
+  src = (shoes_jpeg_file)cinfo->src;
+  src->pub.init_source = shoes_jpeg_init_source;
+  src->pub.fill_input_buffer = shoes_jpeg_fill_input_buffer;
+  src->pub.skip_input_data = shoes_jpeg_skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = shoes_jpeg_term_source;
+  src->infile = infile;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
+ 
+void
+shoes_jpeg_fatal(j_common_ptr cinfo)
+{
+  shoes_jpeg_err jpgerr = (shoes_jpeg_err)cinfo->err;
+  longjmp(jpgerr->setjmp_buffer, 1);
+}
+
+cairo_surface_t *
+shoes_surface_create_from_jpeg(char *filename, int *width, int *height, unsigned char load)
+{
+  int x, y, w, h, l, i, scans, count, prevy;
+  unsigned char *ptr, *rgb = NULL, **line = NULL;
+  PIXEL *pixels = NULL, *ptr2;
+  cairo_surface_t *surface = NULL;
+  struct jpeg_decompress_struct cinfo;
+  struct shoes_jpeg_error_mgr jerr;
+  
+#ifdef SHOES_WIN32
+  HANDLE hFile;
+  hFile = CreateFile( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
+  if ( hFile == INVALID_HANDLE_VALUE ) return NULL;
+#else
+  FILE *f = fopen(filename, "rb");
+  if (!f) return NULL;
+#endif
+  
+  // TODO: error handling
+  cinfo.err = jpeg_std_error(&jerr.pub);
+  jerr.pub.error_exit = shoes_jpeg_fatal;
+  // jerr.pub.emit_message = shoes_jpeg_error;
+  // jerr.pub.output_message = shoes_jpeg_error2;
+  if (setjmp(jerr.setjmp_buffer)) {
+    // append_jpeg_message(interp, (j_common_ptr) &cinfo);
+    jpeg_destroy_decompress(&cinfo);
+    return NULL;
+  }
+
+  jpeg_create_decompress(&cinfo);
+#ifdef SHOES_WIN32
+  jpeg_file_src(&cinfo, hFile);
+#else
+  jpeg_file_src(&cinfo, f);
+#endif
+  jpeg_read_header(&cinfo, TRUE);
+  cinfo.do_fancy_upsampling = FALSE;
+  cinfo.do_block_smoothing = FALSE;
+
+  line = SHOE_ALLOC_N(unsigned char *, JPEG_LINES);
+  jpeg_start_decompress(&cinfo);
+  w = cinfo.output_width;
+  if (width != NULL) *width = w;
+  h = cinfo.output_height;
+  if (height != NULL) *height = h;
+
+  if ((w < 1) || (h < 1) || (w > 8192) || (h > 8192))
+    goto done;
+
+  if (!load)
+  {
+    surface = SIZE_SURFACE;
+    goto done;
+  }
+
+  if (cinfo.rec_outbuf_height > JPEG_LINES)
+    goto done;
+
+  rgb = SHOE_ALLOC_N(unsigned char, w * JPEG_LINES * 3);
+  ptr2 = pixels = SHOE_ALLOC_N(PIXEL, w * h);
+  if (rgb == NULL || pixels == NULL)
+    goto done;
+
+  count = 0;
+  prevy = 0;
+  if (cinfo.output_components == 3 || cinfo.output_components == 1)
+  {
+    int c = cinfo.output_components;
+    for (i = 0; i < cinfo.rec_outbuf_height; i++)
+      line[i] = rgb + (i * w * c);
+    for (l = 0; l < h; l += cinfo.rec_outbuf_height)
+    {
+      jpeg_read_scanlines(&cinfo, line, cinfo.rec_outbuf_height);
+      scans = cinfo.rec_outbuf_height;
+      if ((h - l) < scans) scans = h - l;
+      ptr = rgb;
+      for (y = 0; y < scans; y++)
+      {
+        for (x = 0; x < w; x++)
+        {
+          if (c == 3)
+            *ptr2 = (0xff000000) | ((ptr[0]) << 16) | ((ptr[1]) << 8) | (ptr[2]);
+          else if (c == 1)
+            *ptr2 = (0xff000000) | ((ptr[0]) << 16) | ((ptr[0]) << 8) | (ptr[0]);
+          LE_CPU(*ptr2);
+          ptr += c;
+          ptr2++;
+        }
+      }
+    }
+  }
+
+  surface = shoes_surface_create_from_pixels(pixels, w, h);
+  jpeg_finish_decompress(&cinfo);
+done:
+  free(line);
+  if (pixels != NULL) free(pixels);
+  if (rgb != NULL) free(rgb);
+  jpeg_destroy_decompress(&cinfo);
+#ifdef SHOES_WIN32
+  CloseHandle( hFile );
+#else
+  fclose(f);
+#endif
+  return surface;
+}
+
+char
+shoes_has_ext(char *fname, int len, const char *ext)
+{
+  return strncmp(fname + (len - strlen(ext)), ext, strlen(ext)) == 0;
+}
+
+unsigned char
+shoes_check_file_exists(VALUE path)
+{
+  if (!RTEST(rb_funcall(rb_cFile, rb_intern("exists?"), 1, path)))
+  {
+    StringValue(path);
+    shoes_error("Shoes could not find the file %s.", RSTRING_PTR(path)); 
+    return FALSE;
+  }
+  return TRUE;
+}
+
+void
+shoes_unsupported_image(VALUE path)
+{
+  VALUE ext = rb_funcall(rb_cFile, rb_intern("extname"), 1, path);
+  StringValue(path);
+  StringValue(ext);
+  shoes_error("Couldn't load %s. Shoes does not support images with the %s extension.", 
+    RSTRING_PTR(path), RSTRING_PTR(ext)); 
+}
+
+void
+shoes_failed_image(VALUE path)
+{
+  VALUE ext = rb_funcall(rb_cFile, rb_intern("extname"), 1, path);
+  StringValue(path);
+  StringValue(ext);
+  shoes_error("Couldn't load %s. Is the file a valid %s?", 
+    RSTRING_PTR(path), RSTRING_PTR(ext)); 
+}
+
+cairo_surface_t *
+shoes_surface_create_from_file(VALUE imgpath, int *width, int *height)
+{
+  cairo_surface_t *img = NULL;
+  shoes_image_format format = shoes_image_detect(imgpath, width, height);
+  if (format == SHOES_IMAGE_PNG)
+  {
+    img = cairo_image_surface_create_from_png(RSTRING_PTR(imgpath));
+    if (cairo_surface_status(img) != CAIRO_STATUS_SUCCESS)
+      img = NULL;
+  }
+  else if (format == SHOES_IMAGE_JPEG)
+    img = shoes_surface_create_from_jpeg(RSTRING_PTR(imgpath), width, height, TRUE);
+  else if (format == SHOES_IMAGE_GIF)
+    img = shoes_surface_create_from_gif(RSTRING_PTR(imgpath), width, height, TRUE);
+  else
+    return shoes_world->blank_image;
+
+  if (img == NULL)
+  {
+    shoes_failed_image(imgpath);
+    img = shoes_world->blank_image;
+  }
+
+  return img;
+}
+
+int
+shoes_file_mtime(char *path)
+{
+  int mtime = 0;
+  struct stat *s = SHOE_ALLOC(struct stat);
+  stat(path, s);
+  mtime = s->st_mtime;
+  SHOE_FREE(s);
+  return mtime;
+}
+
+shoes_cached_image *
+shoes_cached_image_new(int width, int height, cairo_surface_t *surface)
+{
+  shoes_cached_image *cached = SHOE_ALLOC(shoes_cached_image);
+  if (surface == NULL)
+    surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+  cached->surface = surface;
+  cached->pattern = NULL;
+  cached->width = width;
+  cached->height = height;
+  cached->mtime = 0;
+  return cached;
+}
+
+int
+shoes_cache_lookup(char *imgpath, shoes_cached_image **image)
+{
+  shoes_cache_entry *cached = NULL;
+  int ret = st_lookup(shoes_world->image_cache, (st_data_t)imgpath, (st_data_t *)&cached);
+  // if (ret && shoes_file_mtime(imgpath) == cached->image->mtime) {
+  //   st_delete(shoes_world->image_cache, (st_data_t *)&imgpath, 0);
+  //   // TODO: memory leak if an image's mtime changes (it's overwritten)
+  //   // need to free this struct, but only after the surface is out of play
+  //   // shoes_world_free_image_cache(imgpath, cached, NULL);
+  //   ret = 0;
+  // }
+  if (ret) *image = cached->image;
+  return ret;
+}
+
+void
+shoes_cache_insert(unsigned char type, VALUE imgpath, shoes_cached_image *image)
+{
+  char *path = strdup(RSTRING_PTR(imgpath));
+  shoes_cache_entry *cached = SHOE_ALLOC(shoes_cache_entry);
+  cached->type = type;
+  cached->image = image;
+  if (type == SHOES_CACHE_FILE) image->mtime = shoes_file_mtime(path);
+  st_insert(shoes_world->image_cache, (st_data_t)path, (st_data_t)cached);
+}
+
+shoes_image_format
+shoes_image_detect(VALUE imgpath, int *width, int *height)
+{
+  shoes_image_format format = SHOES_IMAGE_NONE;
+  shoes_cached_image *cached = NULL;
+  cairo_surface_t *img = NULL;
+  VALUE filename = rb_funcall(imgpath, s_downcase, 0);
+  char *fname = RSTRING_PTR(filename);
+  int len = RSTRING_LEN(filename);
+
+  if (shoes_cache_lookup(RSTRING_PTR(imgpath), &cached))
+  {
+    *width = cached->width;
+    *height = cached->height;
+    return cached->format;
+  }
+
+  if (!shoes_check_file_exists(imgpath))
+    return SHOES_IMAGE_NONE;
+  else if (shoes_has_ext(fname, len, ".png"))
+  {
+    img = shoes_png_size(RSTRING_PTR(imgpath), width, height);
+    format = SHOES_IMAGE_PNG;
+  }
+  else if (shoes_has_ext(fname, len, ".jpg") || shoes_has_ext(fname, len, ".jpeg"))
+  {
+    img = shoes_surface_create_from_jpeg(RSTRING_PTR(imgpath), width, height, FALSE);
+    format = SHOES_IMAGE_JPEG;
+  }
+  else if (shoes_has_ext(fname, len, ".gif"))
+  {
+    img = shoes_surface_create_from_gif(RSTRING_PTR(imgpath), width, height, FALSE);
+    format = SHOES_IMAGE_GIF;
+  }
+
+  if (img != SIZE_SURFACE)
+  {
+    if (format != SHOES_IMAGE_PNG && 
+      (img = shoes_png_size(RSTRING_PTR(imgpath), width, height)) == SIZE_SURFACE)
+      format = SHOES_IMAGE_PNG;
+    else if (format != SHOES_IMAGE_JPEG && 
+      (img = shoes_surface_create_from_jpeg(RSTRING_PTR(imgpath), width, height, FALSE)) == SIZE_SURFACE)
+      format = SHOES_IMAGE_JPEG;
+    else if (format != SHOES_IMAGE_GIF &&
+      (img = shoes_surface_create_from_gif(RSTRING_PTR(imgpath), width, height, FALSE)) == SIZE_SURFACE)
+      format = SHOES_IMAGE_GIF;
+  }
+
+  if (format == SHOES_IMAGE_NONE)
+  {
+    shoes_unsupported_image(imgpath);
+    return format;
+  }
+
+  if (img != SIZE_SURFACE)
+    shoes_failed_image(imgpath);
+
+  return format;
+}
+
+shoes_code
+shoes_load_imagesize(VALUE imgpath, int *width, int *height)
+{
+  if (shoes_image_detect(imgpath, width, height) == SHOES_IMAGE_NONE)
+    return SHOES_FAIL;
+  return SHOES_OK;
+}
+
+unsigned char
+shoes_image_downloaded(shoes_image_download_event *idat)
+{
+  int i, j, width, height;
+  SHA1_CTX context;
+  unsigned char *digest = SHOE_ALLOC_N(unsigned char, 20), 
+                *buffer = SHOE_ALLOC_N(unsigned char, 16384);
+
+  if (idat->status == 304)
+  {
+    idat->filepath = idat->cachepath;
+    idat->cachepath = NULL;
+  }
+  else if (idat->status != 200)
+  {
+    shoes_error("Shoes could not load the file at %s. [%lu]", idat->uripath, idat->status); 
+    return 0;
+  }
+
+  cairo_surface_t *img = shoes_surface_create_from_file(rb_str_new2(idat->filepath), &width, &height);
+  if (img != NULL)
+  {
+    shoes_cached_image *cached;
+    if (shoes_cache_lookup(idat->uripath, &cached) && cached->surface == shoes_world->blank_image)
+    {
+      cached->surface = img;
+      cached->width = width;
+      cached->height = height;
+      cached->mtime = shoes_file_mtime(idat->filepath);
+
+      if (idat->status != 304)
+      {
+#ifdef SHOES_WIN32
+        HANDLE hFile;
+        hFile = CreateFile( idat->filepath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
+        SHA1Init(&context);
+        DWORD readsize;
+        while (1)
+        {
+          ReadFile( hFile, buffer, 16384, &readsize, NULL );
+          if (readsize != 16384) break;
+          SHA1Update(&context, buffer, readsize);
+        }
+        SHA1Final(digest, &context);
+        CloseHandle( hFile );
+#else
+        FILE* fp = fopen(idat->filepath, "rb");
+        if (fp == NULL)
+        {
+          shoes_error("Shoes was unable to open the cached file at %s.", idat->filepath);
+          return 0;
+        }
+        SHA1Init(&context);
+        while (!feof(fp)) 
+        {
+          i = fread(buffer, 1, 16384, fp);
+          SHA1Update(&context, buffer, i);
+        }
+        SHA1Final(digest, &context);
+        fclose(fp);
+#endif
+        
+        for (i = 0; i < 5; i++)
+          for (j = 0; j < 4; j++)
+            sprintf(&idat->hexdigest[(i*8)+(j*2)], "%02x", digest[i*4+j]);
+        idat->hexdigest[41] = '\0';
+      }
+    }
+  }
+
+  SHOE_FREE(digest);
+  SHOE_FREE(buffer);
+  return 1;
+}
+
+int
+shoes_http_image_handler(shoes_http_event *de, void *data)
+{
+  shoes_image_download_event *idat = (shoes_image_download_event *)data;
+  if (de->stage == SHOES_HTTP_STATUS)
+  {
+    idat->status = de->status;
+  }
+  else if (de->stage == SHOES_HTTP_HEADER)
+  {
+    if (de->hkeylen == 4 && strncmp(de->hkey, "ETag", 4) == 0 && de->hvallen > 0)
+    {
+      idat->etag = SHOE_ALLOC_N(char, de->hvallen + 1);
+      SHOE_MEMCPY(idat->etag, de->hval, char, de->hvallen);
+      idat->etag[de->hvallen] = '\0';
+    }
+  }
+  else if (de->stage == SHOES_HTTP_COMPLETED)
+  {
+    shoes_image_download_event *side = SHOE_ALLOC(shoes_image_download_event);
+    SHOE_MEMCPY(side, idat, shoes_image_download_event, 1);
+    return shoes_throw_message(SHOES_IMAGE_DOWNLOAD, idat->slot, side);
+  }
+  return SHOES_DOWNLOAD_CONTINUE;
+}
+
+shoes_cached_image *
+shoes_load_image(VALUE slot, VALUE imgpath)
+{
+  shoes_cached_image *cached = NULL;
+  cairo_surface_t *img = NULL;
+  VALUE filename = rb_funcall(imgpath, s_downcase, 0);
+  StringValue(filename);
+  char *fname = RSTRING_PTR(filename);
+  int width = 1, height = 1;
+
+  if (shoes_cache_lookup(RSTRING_PTR(imgpath), &cached))
+    goto done;
+
+  if (strlen(fname) > 7 && (strncmp(fname, "http://", 7) == 0 || strncmp(fname, "https://", 8) == 0))
+  {
+    struct timeval tv;
+    VALUE cache, uext, hdrs, tmppath, uri, scheme, host, port, requ, path, cachepath = Qnil, hash = Qnil;
+    rb_require("shoes/data");
+    uri = rb_funcall(cShoes, rb_intern("uri"), 1, imgpath);
+    scheme = rb_funcall(uri, s_scheme, 0);
+    host = rb_funcall(uri, s_host, 0);
+    port = rb_funcall(uri, s_port, 0);
+    requ = rb_funcall(uri, s_request_uri, 0);
+    path = rb_funcall(uri, s_path, 0);
+    path = rb_funcall(path, s_downcase, 0);
+
+    cache = rb_funcall(rb_const_get(rb_cObject, rb_intern("DATABASE")), rb_intern("check_cache_for"), 1, imgpath);
+    uext = rb_funcall(rb_cFile, rb_intern("extname"), 1, path);
+    hdrs = Qnil;
+    if (!NIL_P(cache)) 
+    {
+      VALUE etag = rb_hash_aref(cache, ID2SYM(rb_intern("etag")));
+      hash = rb_hash_aref(cache, ID2SYM(rb_intern("hash")));
+      if (!NIL_P(hash)) cachepath = rb_funcall(cShoes, rb_intern("image_cache_path"), 2, hash, uext);
+      int saved = NUM2INT(rb_hash_aref(cache, ID2SYM(rb_intern("saved"))));
+      gettimeofday(&tv, 0);
+      if (tv.tv_sec - saved < SHOES_IMAGE_EXPIRE)
+      {
+        cached = shoes_load_image(slot, cachepath);
+        if (cached != NULL)
+        {
+          shoes_cache_insert(SHOES_CACHE_ALIAS, imgpath, cached);
+          goto done;
+        }
+      }
+      else if (!NIL_P(etag))
+        rb_hash_aset(hdrs = rb_hash_new(), rb_str_new2("If-None-Match"), etag);
+    }
+
+    cached = shoes_cached_image_new(1, 1, shoes_world->blank_image);
+    shoes_cache_insert(SHOES_CACHE_FILE, imgpath, cached);
+    tmppath = rb_funcall(cShoes, rb_intern("image_temp_path"), 2, uri, uext);
+
+    shoes_http_request *req = SHOE_ALLOC(shoes_http_request);
+    SHOE_MEMZERO(req, shoes_http_request, 1);
+    shoes_image_download_event *idat = SHOE_ALLOC(shoes_image_download_event);
+    SHOE_MEMZERO(idat, shoes_image_download_event, 1);
+    req->url = strdup(RSTRING_PTR(imgpath));
+    req->scheme = strdup(RSTRING_PTR(scheme));
+    req->host = strdup(RSTRING_PTR(host));
+    req->port = NUM2INT(port);
+    req->path = strdup(RSTRING_PTR(requ));
+    req->handler = shoes_http_image_handler;
+    req->filepath = strdup(RSTRING_PTR(tmppath));
+    idat->filepath = strdup(RSTRING_PTR(tmppath));
+    idat->uripath = strdup(RSTRING_PTR(imgpath));
+    idat->slot = slot;
+    if (!NIL_P(cachepath)) idat->cachepath = strdup(RSTRING_PTR(cachepath));
+    if (!NIL_P(hash)) SHOE_MEMCPY(idat->hexdigest, RSTRING_PTR(hash), char, min(42, RSTRING_LEN(hash)));
+    if (!NIL_P(hdrs)) req->headers = shoes_http_headers(hdrs);
+    req->data = idat;
+    shoes_queue_download(req);
+    goto done;
+  }
+
+  img = shoes_surface_create_from_file(imgpath, &width, &height);
+  if (img != shoes_world->blank_image)
+  {
+    cached = shoes_cached_image_new(width, height, img);
+    shoes_cache_insert(SHOES_CACHE_FILE, imgpath, cached);
+  }
+
+done:
+  if (cached == NULL)
+    cached = shoes_world->blank_cache;
+  return cached;
+}