shoes 3.0.1

data/shoes/effects.h

@@ -0,0 +1,7 @@
+//
+// shoes/effects.h
+// The presently meager effects API.
+//
+void shoes_gaussian_blur_filter(cairo_t *, VALUE, shoes_place *);
+void shoes_shadow_filter(cairo_t *, VALUE, shoes_place *);
+void shoes_glow_filter(cairo_t *, VALUE, shoes_place *);

data/shoes/http.h

@@ -0,0 +1,44 @@
+//
+// shoes/http.h
+// the shoes downloader, which uses platform code and threads
+// to achieve much faster and brain-dead http access.
+//
+#ifndef SHOES_HTTP_H
+#define SHOES_HTTP_H
+
+#include "shoes/http/common.h"
+
+typedef struct {
+  char *url;
+  char *scheme;
+  char *host;
+  int port;
+  char *path;
+
+  char *method, *body;
+  unsigned long bodylen;
+  SHOES_DOWNLOAD_HEADERS headers;
+
+  char *mem;
+  unsigned long memlen;
+  char *filepath;
+  unsigned LONG_LONG size;
+  shoes_http_handler handler;
+  void *data;
+  unsigned char flags;
+} shoes_http_request;
+
+void shoes_download(shoes_http_request *req);
+void shoes_queue_download(shoes_http_request *req);
+VALUE shoes_http_err(SHOES_DOWNLOAD_ERROR error);
+SHOES_DOWNLOAD_HEADERS shoes_http_headers(VALUE hsh);
+void shoes_http_request_free(shoes_http_request *);
+void shoes_http_headers_free(SHOES_DOWNLOAD_HEADERS);
+
+#ifdef SHOES_WIN32
+#include "shoes/http/winhttp.h"
+#else
+#define HTTP_HANDLER(x)
+#endif
+
+#endif

data/shoes/http/common.h

@@ -0,0 +1,86 @@
+//
+// shoes/http/common.h
+// cross-platform structures common to Shoes and its stubs
+//
+#ifndef SHOES_HTTP_COMMON_H
+#define SHOES_HTTP_COMMON_H
+
+#define SHOES_CHUNKSIZE 16384
+
+#define SHOES_DL_REDIRECTS 1
+#define SHOES_DL_DEFAULTS  (SHOES_DL_REDIRECTS)
+
+#define SHOES_DOWNLOAD_CONTINUE 0
+#define SHOES_DOWNLOAD_HALT 1
+
+#define SHOES_HTTP_STATUS    3
+#define SHOES_HTTP_HEADER    4
+#define SHOES_HTTP_CONNECTED 5
+#define SHOES_HTTP_TRANSFER  10
+#define SHOES_HTTP_COMPLETED 15
+#define SHOES_HTTP_ERROR     20
+
+#define HTTP_HEADER(ptr, realsize, handler, data) \
+  { \
+    char *colon, *val, *end; \
+    for (colon = ptr; colon < ptr + realsize; colon++) \
+      if (colon[0] == ':') \
+        break; \
+    for (val = colon + 1; val < ptr + realsize; val++) \
+      if (val[0] != ' ') \
+        break; \
+    for (end = (ptr + realsize) - 1; end > ptr; end--) \
+      if (end[0] != '\r' && end[0] != '\n' && end[0] != ' ') \
+        break; \
+    if (colon < ptr + realsize) \
+    { \
+      shoes_http_event *event = SHOE_ALLOC(shoes_http_event); \
+      event->stage = SHOES_HTTP_HEADER; \
+      event->hkey = ptr; \
+      event->hkeylen = colon - ptr; \
+      event->hval = val; \
+      event->hvallen = (end - val) + 1; \
+      if (handler != NULL) handler(event, data); \
+      SHOE_FREE(event); \
+    } \
+  }
+
+#define HTTP_EVENT(handler, s, last, perc, trans, tot, dat, bd, abort) \
+{ SHOES_TIME ts; \
+  shoes_get_time(&ts); \
+  unsigned long elapsed = shoes_diff_time(&(last), &ts); \
+  if (s != SHOES_HTTP_TRANSFER || elapsed > 600 ) { \
+    shoes_http_event *event = SHOE_ALLOC(shoes_http_event); \
+    event->stage = s; \
+    if (s == SHOES_HTTP_COMPLETED) event->stage = SHOES_HTTP_TRANSFER; \
+    event->percent = perc; \
+    event->transferred = trans;\
+    event->total = tot; \
+    last = ts; \
+    if (handler != NULL && (handler(event, dat) & SHOES_DOWNLOAD_HALT)) \
+    { SHOE_FREE(event); event = NULL; abort; } \
+    if (event != NULL && s == SHOES_HTTP_COMPLETED) { event->stage = s; \
+      event->body = bd; \
+      if (handler != NULL && (handler(event, dat) & SHOES_DOWNLOAD_HALT)) \
+      { SHOE_FREE(event); event = NULL; abort; } \
+    } \
+    if (event != NULL) SHOE_FREE(event); \
+  } }
+
+typedef struct {
+  unsigned char stage;
+  unsigned long status;
+  char *hkey, *hval, *body;
+  unsigned long hkeylen, hvallen, bodylen;
+  unsigned LONG_LONG total;
+  unsigned LONG_LONG transferred;
+  unsigned long percent;
+  SHOES_DOWNLOAD_ERROR error;
+} shoes_http_event;
+
+typedef int (*shoes_http_handler)(shoes_http_event *, void *);
+
+void shoes_get_time(SHOES_TIME *);
+unsigned long shoes_diff_time(SHOES_TIME *, SHOES_TIME *);
+
+#endif

data/shoes/http/curl.c

@@ -0,0 +1,259 @@
+//
+// shoes/http/curl.c
+// the downloader routines using libcurl.
+//
+#include "shoes/app.h"
+#include "shoes/ruby.h"
+#include "shoes/config.h"
+#include "shoes/http.h"
+#include "shoes/version.h"
+#include "shoes/internal.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+typedef struct {
+  char *mem;
+  unsigned long memlen;
+  FILE *fp;
+  char *body;
+  size_t size, total, readpos, bodylen;
+  unsigned long status;
+  shoes_http_handler handler;
+  SHOES_TIME last;
+  CURL *curl;
+  void *data;
+} shoes_curl_data;
+
+const char *content_len_str = "Content-Length: ";
+
+size_t
+shoes_curl_header_funk(char *ptr, size_t size, size_t nmemb, void *user)
+{
+  shoes_curl_data *data = (shoes_curl_data *)user;
+  size_t realsize = size * nmemb;
+  if (data->status == 0 && data->handler != NULL)
+  {
+    curl_easy_getinfo(data->curl, CURLINFO_RESPONSE_CODE, (long *)&data->status);
+    if (data->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 = data->status;
+      data->handler(event, data->data);
+      SHOE_FREE(event);
+    }
+  }
+
+  HTTP_HEADER(ptr, realsize, data->handler, data->data);
+  if ((data->mem != NULL || data->fp != NULL) &&
+      strncmp(ptr, content_len_str, strlen(content_len_str)) == 0)
+  {
+    data->total = strtoull(ptr + strlen(content_len_str), NULL, 10);
+    if (data->mem != NULL && data->total > data->memlen)
+    {
+      data->memlen = data->total;
+      SHOE_REALLOC_N(data->mem, char, data->memlen);
+      if (data->mem == NULL) return -1;
+    }
+  }
+  return realsize;
+}
+
+size_t
+shoes_curl_read_funk(void *ptr, size_t size, size_t nmemb, void *user)
+{
+  shoes_curl_data *data = (shoes_curl_data *)user;
+  size_t realsize = size * nmemb;
+  if (realsize > data->bodylen - data->readpos)
+    realsize = data->bodylen - data->readpos;
+  SHOE_MEMCPY(ptr, &(data->body[data->readpos]), char, realsize);
+  data->readpos += realsize;
+  return realsize;
+}
+
+size_t
+shoes_curl_write_funk(void *ptr, size_t size, size_t nmemb, void *user)
+{
+  shoes_curl_data *data = (shoes_curl_data *)user;
+  size_t realsize = size * nmemb;
+  if (data->size == 0)
+  {
+    HTTP_EVENT(data->handler, SHOES_HTTP_CONNECTED, data->last, 0, 0, data->total, data->data, NULL, return -1);
+  }
+  if (data->mem != NULL)
+  {
+    if (data->size + realsize > data->memlen)
+    {
+      while (data->size + realsize > data->memlen)
+        data->memlen += SHOES_BUFSIZE;
+      SHOE_REALLOC_N(data->mem, char, data->memlen);
+      if (data->mem == NULL) return -1;
+    }
+    SHOE_MEMCPY(&(data->mem[data->size]), ptr, char, realsize);
+  }
+  if (data->fp != NULL)
+    realsize = fwrite(ptr, size, nmemb, data->fp) * size;
+  if (realsize > 0)
+    data->size += realsize;
+  return realsize;
+}
+
+int
+shoes_curl_progress_funk(void *user, double dltotal, double dlnow, double ultotal, double ulnow)
+{
+  shoes_curl_data *data = (shoes_curl_data *)user;
+  if (dltotal > 0.)
+  {
+    HTTP_EVENT(data->handler, SHOES_HTTP_TRANSFER, data->last, dlnow * 100.0 / dltotal, dlnow,
+               dltotal, data->data, NULL, return 1);
+  }
+  return 0;
+}
+
+void
+shoes_download(shoes_http_request *req)
+{
+  char uagent[SHOES_BUFSIZE];
+  CURL *curl = curl_easy_init();
+  CURLcode res;
+  shoes_curl_data *cdata = SHOE_ALLOC(shoes_curl_data);
+  if (curl == NULL) return;
+
+  sprintf(uagent, "Shoes/0.r%d (%s) %s/%d", SHOES_REVISION, SHOES_PLATFORM,
+    SHOES_RELEASE_NAME, SHOES_BUILD_DATE);
+
+  cdata->mem = req->mem;
+  cdata->memlen = req->memlen;
+  cdata->fp = NULL;
+  cdata->size = cdata->readpos = req->size = 0;
+  cdata->total = 0;
+  cdata->handler = req->handler;
+  cdata->data = req->data;
+  cdata->last.tv_sec = 0;
+  cdata->last.tv_nsec = 0;
+  cdata->status = 0;
+  cdata->curl = curl;
+  cdata->body = NULL;
+
+  if (req->mem == NULL && req->filepath != NULL)
+  {
+    cdata->fp = fopen(req->filepath, "wb");
+    if (cdata->fp == NULL) goto done;
+  } 
+
+  curl_easy_setopt(curl, CURLOPT_NOSIGNAL, TRUE);
+  curl_easy_setopt(curl, CURLOPT_URL, req->url);
+  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, shoes_curl_header_funk);
+  curl_easy_setopt(curl, CURLOPT_WRITEHEADER, cdata);
+  if (cdata->mem != NULL || cdata->fp != NULL)
+  {
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, shoes_curl_write_funk);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, cdata);
+    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+    curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, shoes_curl_progress_funk);
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, cdata);
+  }
+  else
+  {
+    curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
+  }
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, uagent);
+  if (req->flags & SHOES_DL_REDIRECTS)
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+  if (req->method)
+    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, req->method);
+  if (req->headers)
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, req->headers);
+  if (req->body)
+  {
+    cdata->body = req->body;
+    cdata->bodylen = req->bodylen;
+    curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+    curl_easy_setopt(curl, CURLOPT_INFILE, cdata);
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, cdata->bodylen);
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, shoes_curl_read_funk);
+  }
+
+  res = curl_easy_perform(curl);
+  req->size = cdata->size;
+  req->mem = cdata->mem;
+
+  if (res != CURLE_OK)
+  {
+    if (req->handler != NULL)
+    {
+      shoes_http_event *event = SHOE_ALLOC(shoes_http_event);
+      SHOE_MEMZERO(event, shoes_http_event, 1);
+      event->stage = SHOES_HTTP_ERROR;
+      event->error = res;
+      req->handler(event, req->data);
+      SHOE_FREE(event);
+    }
+    goto done;
+  }
+
+  if (cdata->fp != NULL)
+  { 
+    fclose(cdata->fp);
+    cdata->fp = NULL;
+  }
+
+  HTTP_EVENT(cdata->handler, SHOES_HTTP_COMPLETED, cdata->last, 100, req->size, req->size, cdata->data, req->mem, goto done);
+
+done:
+  if (cdata->fp != NULL)
+    fclose(cdata->fp);
+  if (cdata != NULL)
+    SHOE_FREE(cdata);
+
+  curl_easy_cleanup(curl);
+}
+
+void *
+shoes_download2(void *data)
+{
+  shoes_http_request *req = (shoes_http_request *)data;
+  shoes_download(req);
+  shoes_http_request_free(req);
+  free(req);
+  return NULL;
+}
+
+void
+shoes_queue_download(shoes_http_request *req)
+{
+  pthread_t tid;
+  pthread_create(&tid, NULL, shoes_download2, req);
+}
+
+VALUE
+shoes_http_err(SHOES_DOWNLOAD_ERROR code)
+{
+  return rb_str_new2(curl_easy_strerror(code));
+}
+
+SHOES_DOWNLOAD_HEADERS
+shoes_http_headers(VALUE hsh)
+{
+  long i;
+  struct curl_slist *slist = NULL;
+  VALUE keys = rb_funcall(hsh, s_keys, 0);
+  for (i = 0; i < RARRAY_LEN(keys); i++ )
+  {
+    VALUE key = rb_ary_entry(keys, i);
+    VALUE header = rb_str_dup(key);
+    rb_str_cat2(header, ": ");
+    rb_str_append(header, rb_hash_aref(hsh, key));
+    slist = curl_slist_append(slist, RSTRING_PTR(header));
+  }
+  return slist;
+}
+
+void
+shoes_http_headers_free(struct curl_slist *slist)
+{
+  curl_slist_free_all(slist);
+}

data/shoes/http/nsurl.m

@@ -0,0 +1,274 @@
+//
+// shoes/http/nsurl.m
+// the downloader routines using nsurl classes.
+//
+#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"
+
+#import <Cocoa/Cocoa.h>
+
+@interface ShoesHttp : NSObject
+{
+  char *dest;
+  unsigned long destlen;
+  NSURLConnection *conn;
+  NSURLDownload *down;
+  NSURLResponse *resp;
+  NSFileManager *fm;
+  long long size;
+  long long total;
+  unsigned char flags;
+  shoes_http_handler handler;
+  SHOES_TIME last;
+  NSMutableData *bytes;
+  void *data;
+}
+@end
+
+@implementation ShoesHttp
+- (id)init
+{
+  if ((self = [super init]))
+  {
+    bytes = [[NSMutableData data] retain];
+    fm = [NSFileManager defaultManager];
+    destlen = 0;
+  }
+  return self;
+}
+- (void)releaseData
+{
+  if (dest != NULL) free(dest);
+  if (data != NULL) free(data);
+}
+- (void)download: (shoes_http_request *)req
+{
+  NSString *url = [NSString stringWithFormat: @"%s", req->url];
+  NSString *uagent = [NSString stringWithFormat: @"Shoes/0.r%d (%s) %s/%d", 
+    SHOES_REVISION, SHOES_PLATFORM, SHOES_RELEASE_NAME, SHOES_BUILD_DATE];
+  NSMutableURLRequest *nsreq = [NSMutableURLRequest requestWithURL: 
+    [NSURL URLWithString: url]
+    cachePolicy: NSURLRequestUseProtocolCachePolicy
+    timeoutInterval: 60.0];
+  [nsreq setValue: uagent forHTTPHeaderField: @"User-Agent"];
+  [nsreq setHTTPShouldHandleCookies: FALSE];
+
+  flags = req->flags;
+  handler = req->handler;
+  data = req->data;
+  if (req->headers != NULL)
+    [nsreq setAllHTTPHeaderFields: req->headers];
+  if (req->body != NULL && req->bodylen > 0)
+    [nsreq setHTTPBody: [NSData dataWithBytes: req->body length: req->bodylen]];
+  if (req->method != NULL)
+    [nsreq setHTTPMethod: [NSString stringWithUTF8String: req->method]];
+  last.tv_sec = 0;
+  last.tv_usec = 0;
+  size = total = 0;
+  if (req->filepath != NULL)
+  {
+    dest = req->filepath;
+    down = [[NSURLDownload alloc] initWithRequest: nsreq delegate: self];
+    req->filepath = NULL;
+  }
+  else
+  {
+    dest = req->mem;
+    destlen = req->memlen;
+    conn = [[NSURLConnection alloc] initWithRequest: nsreq
+      delegate: self];
+    req->mem = NULL;
+  }
+}
+- (void)readHeaders: (NSURLResponse *)response
+{
+  if ([response respondsToSelector:@selector(allHeaderFields)] && handler != NULL)
+  {
+    shoes_http_event *event = SHOE_ALLOC(shoes_http_event);
+    NSHTTPURLResponse* httpresp = (NSHTTPURLResponse *)response;
+    if ([httpresp statusCode])
+    {
+      SHOE_MEMZERO(event, shoes_http_event, 1);
+      event->stage = SHOES_HTTP_STATUS;
+      event->status = [httpresp statusCode];
+      handler(event, data);
+    }
+
+    NSDictionary *hdrs = [httpresp allHeaderFields];
+    if (hdrs)
+    {
+      NSString *key;
+      NSEnumerator *keys = [hdrs keyEnumerator];
+      while (key = [keys nextObject])
+      {
+        NSString *val = [hdrs objectForKey: key];
+        SHOE_MEMZERO(event, shoes_http_event, 1);
+        event->stage = SHOES_HTTP_HEADER;
+        event->hkey = [key UTF8String];
+        event->hkeylen = strlen(event->hkey);
+        event->hval = [val UTF8String];
+        event->hvallen = strlen(event->hval);
+        handler(event, data);
+      }
+    }
+
+    SHOE_FREE(event);
+  }
+}
+- (void)handleError: (NSError *)error
+{
+  if (handler != NULL)
+  {
+    shoes_http_event *event = SHOE_ALLOC(shoes_http_event);
+    SHOE_MEMZERO(event, shoes_http_event, 1);
+    event->stage = SHOES_HTTP_ERROR;
+    event->error = error;
+    handler(event, data);
+    SHOE_FREE(event);
+  }
+}
+- (NSURLRequest *)connection: (NSURLConnection *)connection
+  willSendRequest: (NSURLRequest *)request
+  redirectResponse: (NSURLResponse *)redirectResponse
+{
+  NSURLRequest *newRequest = request;
+  if (redirectResponse && !(flags & SHOES_DL_REDIRECTS))
+    newRequest = nil;
+  return newRequest;
+}
+- (void)connection: (NSURLConnection *)c didReceiveResponse: (NSURLResponse *)response
+{
+  [self readHeaders: response];
+  size = total = 0;
+  if ([response expectedContentLength] != NSURLResponseUnknownLength)
+    total = [response expectedContentLength];
+  HTTP_EVENT(handler, SHOES_HTTP_CONNECTED, last, 0, 0, total, data, NULL, [c cancel]);
+  [bytes setLength: 0];
+}
+- (void)connection: (NSURLConnection *)c didFailWithError:(NSError *)error
+{
+  [c release];
+  [self handleError: error];
+}
+- (void)connection: (NSURLConnection *)c didReceiveData: (NSData *)chunk
+{
+  [bytes appendData: chunk];
+  size += [chunk length];
+  HTTP_EVENT(handler, SHOES_HTTP_TRANSFER, last, size * 100.0 / total, size,
+             total, data, NULL, [c cancel]);
+}
+- (void)connectionDidFinishLoading: (NSURLConnection *)c
+{
+  total = [bytes length];
+  if (dest != NULL)
+  {
+    if ([bytes length] > destlen)
+      SHOE_REALLOC_N(dest, char, [bytes length]);
+    [bytes getBytes: dest];
+  }
+  HTTP_EVENT(handler, SHOES_HTTP_COMPLETED, last, 100, total, total, data, [bytes mutableBytes], 1);
+  [c release];
+  [self releaseData];
+}
+- (NSURLRequest *)download: (NSURLDownload *)download
+  willSendRequest: (NSURLRequest *)request
+  redirectResponse: (NSURLResponse *)redirectResponse
+{
+  NSURLRequest *newRequest = request;
+  if (redirectResponse && !(flags & SHOES_DL_REDIRECTS))
+    newRequest = nil;
+  return newRequest;
+}
+- (void)download: (NSURLDownload *)download decideDestinationWithSuggestedFilename: (NSString *)filename
+{
+  NSString *path = [NSString stringWithUTF8String: dest];
+  [download setDestination: path allowOverwrite: YES];
+}
+- (void)setDownloadResponse: (NSURLResponse *)aDownloadResponse
+{
+  [aDownloadResponse retain];
+  [resp release];
+  resp = aDownloadResponse;
+}
+- (void)download: (NSURLDownload *)download didReceiveResponse: (NSURLResponse *)response
+{
+  [self readHeaders: response];
+  size = total = 0;
+  if ([response expectedContentLength] != NSURLResponseUnknownLength)
+    total = [response expectedContentLength];
+  HTTP_EVENT(handler, SHOES_HTTP_CONNECTED, last, 0, 0, total, data, NULL, [download cancel]);
+  [self setDownloadResponse: response];
+}
+- (void)download: (NSURLDownload *)download didFailWithError:(NSError *)error
+{
+  [download release];
+  [self handleError: error];
+}
+- (void)download: (NSURLDownload *)download didReceiveDataOfLength: (unsigned)length
+{
+  size += length;
+  HTTP_EVENT(handler, SHOES_HTTP_TRANSFER, last, size * 100.0 / total, size,
+             total, data, NULL, [download cancel]);
+}
+- (void)downloadDidFinish: (NSURLDownload *)download
+{
+  HTTP_EVENT(handler, SHOES_HTTP_COMPLETED, last, 100, total, total, data, NULL, 1);
+  [download release];
+  [self releaseData];
+}
+@end
+
+void
+shoes_download(shoes_http_request *req)
+{
+  ShoesHttp *http = [[ShoesHttp alloc] init];
+  [http download: req];
+  shoes_http_request_free(req);
+  free(req);
+}
+
+void
+shoes_queue_download(shoes_http_request *req)
+{
+  shoes_download(req);
+}
+
+VALUE
+shoes_http_err(SHOES_DOWNLOAD_ERROR code)
+{
+  char *errorString = [[code localizedDescription] UTF8String];
+  return rb_str_new2(errorString);
+}
+
+SHOES_DOWNLOAD_HEADERS
+shoes_http_headers(VALUE hsh)
+{
+  long i;
+  NSDictionary *d = NULL;
+  VALUE keys = rb_funcall(hsh, s_keys, 0);
+  if (RARRAY_LEN(keys) > 0)
+  {
+    d = [[NSMutableDictionary dictionaryWithCapacity: RARRAY_LEN(keys)] retain];
+    for (i = 0; i < RARRAY_LEN(keys); i++)
+    {
+      VALUE key = rb_ary_entry(keys, i);
+      VALUE val = rb_hash_aref(hsh, key);
+      if(!NIL_P(val))
+        [d setValue: [NSString stringWithUTF8String: RSTRING_PTR(val)]
+           forKey:   [NSString stringWithUTF8String: RSTRING_PTR(key)]];
+    }
+  }
+  return d;
+}
+
+void
+shoes_http_headers_free(SHOES_DOWNLOAD_HEADERS headers)
+{
+  [headers release];
+}