cool.io 1.2.3-x86-mingw32 → 1.4.1-x86-mingw32

data/ext/http11_client/http11_parser.h

@@ -1,48 +0,0 @@
-/**
- * Copyright (c) 2005 Zed A. Shaw
- * You can redistribute it and/or modify it under the same terms as Ruby.
- */
-
-#ifndef http11_parser_h
-#define http11_parser_h
-
-#include <sys/types.h>
-
-#if defined(_WIN32)
-#include <stddef.h>
-#endif
-
-typedef void (*element_cb)(void *data, const char *at, size_t length);
-typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
-
-typedef struct httpclient_parser { 
-  int cs;
-  size_t body_start;
-  int content_len;
-  size_t nread;
-  size_t mark;
-  size_t field_start;
-  size_t field_len;
-
-  void *data;
-
-  field_cb http_field;
-  element_cb reason_phrase;
-  element_cb status_code;
-  element_cb chunk_size;
-  element_cb http_version;
-  element_cb header_done;
-  element_cb last_chunk;
-  
-  
-} httpclient_parser;
-
-int httpclient_parser_init(httpclient_parser *parser);
-int httpclient_parser_finish(httpclient_parser *parser);
-size_t httpclient_parser_execute(httpclient_parser *parser, const char *data, size_t len, size_t off);
-int httpclient_parser_has_error(httpclient_parser *parser);
-int httpclient_parser_is_finished(httpclient_parser *parser);
-
-#define httpclient_parser_nread(parser) (parser)->nread 
-
-#endif

data/ext/http11_client/http11_parser.rl

@@ -1,173 +0,0 @@
-/**
- * Copyright (c) 2005 Zed A. Shaw
- * You can redistribute it and/or modify it under the same terms as Ruby.
- */
-
-#include "http11_parser.h"
-#include <stdio.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <string.h>
-
-#define LEN(AT, FPC) (FPC - buffer - parser->AT)
-#define MARK(M,FPC) (parser->M = (FPC) - buffer)
-#define PTR_TO(F) (buffer + parser->F)
-#define L(M) fprintf(stderr, "" # M "\n");
-
-
-/** machine **/
-%%{
-  machine httpclient_parser;
-
-  action mark {MARK(mark, fpc); }
-
-  action start_field { MARK(field_start, fpc); }
-
-  action write_field { 
-    parser->field_len = LEN(field_start, fpc);
-  }
-
-  action start_value { MARK(mark, fpc); }
-
-  action write_value { 
-    parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
-  }
-
-  action reason_phrase { 
-    parser->reason_phrase(parser->data, PTR_TO(mark), LEN(mark, fpc));
-  }
-
-  action status_code { 
-    parser->status_code(parser->data, PTR_TO(mark), LEN(mark, fpc));
-  }
-
-  action http_version {	
-    parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
-  }
-
-  action chunk_size {
-    parser->chunk_size(parser->data, PTR_TO(mark), LEN(mark, fpc));
-  }
-
-  action last_chunk {
-    parser->last_chunk(parser->data, NULL, 0);
-  }
-
-  action done { 
-    parser->body_start = fpc - buffer + 1; 
-    if(parser->header_done != NULL)
-      parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
-    fbreak;
-  }
-
-# line endings
-  CRLF = "\r\n";
-
-# character types
-  CTL = (cntrl | 127);
-  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
-
-# elements
-  token = (ascii -- (CTL | tspecials));
-
-  Reason_Phrase = (any -- CRLF)* >mark %reason_phrase;
-  Status_Code = digit{3} >mark %status_code;
-  http_number = (digit+ "." digit+) ;
-  HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
-  Status_Line = HTTP_Version " " Status_Code " "? Reason_Phrase :> CRLF;
-
-  field_name = token+ >start_field %write_field;
-  field_value = any* >start_value %write_value;
-  message_header = field_name ":" " "* field_value :> CRLF;
-
-  Response = 	Status_Line (message_header)* (CRLF @done);
-
-  chunk_ext_val = token+;
-  chunk_ext_name = token+;
-  chunk_extension = (";" chunk_ext_name >start_field %write_field %start_value ("=" chunk_ext_val >start_value)? %write_value )*;
-  last_chunk = "0"? chunk_extension :> (CRLF @last_chunk @done);
-  chunk_size = xdigit+;
-  chunk = chunk_size >mark %chunk_size chunk_extension space* :> (CRLF @done);
-  Chunked_Header = (chunk | last_chunk);
-
-  main := Response | Chunked_Header;
-}%%
-
-/** Data **/
-%% write data;
-
-int httpclient_parser_init(httpclient_parser *parser)  {
-  int cs = 0;
-  %% write init;
-  parser->cs = cs;
-  parser->body_start = 0;
-  parser->content_len = 0;
-  parser->mark = 0;
-  parser->nread = 0;
-  parser->field_len = 0;
-  parser->field_start = 0;    
-
-  return(1);
-}
-
-
-/** exec **/
-size_t httpclient_parser_execute(httpclient_parser *parser, const char *buffer, size_t len, size_t off)  {
-  const char *p, *pe;
-  int cs = parser->cs;
-
-  assert(off <= len && "offset past end of buffer");
-
-  p = buffer+off;
-  pe = buffer+len;
-
-  assert(*pe == '\0' && "pointer does not end on NUL");
-  assert(pe - p == len - off && "pointers aren't same distance");
-
-
-  %% write exec;
-
-  parser->cs = cs;
-  parser->nread += p - (buffer + off);
-
-  assert(p <= pe && "buffer overflow after parsing execute");
-  assert(parser->nread <= len && "nread longer than length");
-  assert(parser->body_start <= len && "body starts after buffer end");
-  assert(parser->mark < len && "mark is after buffer end");
-  assert(parser->field_len <= len && "field has length longer than whole buffer");
-  assert(parser->field_start < len && "field starts after buffer end");
-
-  if(parser->body_start) {
-    /* final \r\n combo encountered so stop right here */
-    %%write eof;
-    parser->nread++;
-  }
-
-  return(parser->nread);
-}
-
-int httpclient_parser_finish(httpclient_parser *parser)
-{
-  int cs = parser->cs;
-
-  %%write eof;
-
-  parser->cs = cs;
-
-  if (httpclient_parser_has_error(parser) ) {
-    return -1;
-  } else if (httpclient_parser_is_finished(parser) ) {
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-int httpclient_parser_has_error(httpclient_parser *parser) {
-  return parser->cs == httpclient_parser_error;
-}
-
-int httpclient_parser_is_finished(httpclient_parser *parser) {
-  return parser->cs == httpclient_parser_first_final;
-}

data/lib/cool.io/eventmachine.rb

@@ -1,234 +0,0 @@
-#--
-# Copyright (C)2007-10 Tony Arcieri, Roger Pack
-# You can redistribute this under the terms of the Ruby license
-# See file LICENSE for details
-#++
-
-require 'cool.io'
-
-# EventMachine emulation for Cool.io:
-#
-#   require 'coolio/eventmachine'
-#
-# Drawbacks: slightly slower than EM.
-# Benefits: timers are more accurate using libev than using EM
-# TODO: some things like connection timeouts aren't implemented yet
-# DONE: timers and normal socket functions are implemented.
-module EventMachine
-  class << self
-    # Start the Reactor loop
-    def run
-      yield if block_given?
-      Coolio::Loop.default.run
-    end
-
-    # Stop the Reactor loop
-    def stop_event_loop
-      Coolio::Loop.default.stop
-    end
-
-    class OneShotEMTimer < Coolio::TimerWatcher
-      def setup(proc)
-        @proc = proc
-      end
-
-      def on_timer
-       @proc.call
-      end
-    end
-
-    # ltodo: use Coolio's PeriodicTimer to wrap EM's two similar to it
-    # todo: close all connections on 'stop', I believe
-
-    def add_timer(interval, proc = nil, &block)
-      block ||= proc
-      t = OneShotEMTimer.new(interval, false) # non repeating
-      t.setup(block)
-
-      # fire 'er off ltodo: do we keep track of these timers in memory?
-      t.attach(Coolio::Loop.default)
-      t
-    end
-
-    def cancel_timer(t)
-      # guess there's a case where EM you can say 'cancel' but it's already fired?
-      # kind of odd but it happens
-     t.detach if t.attached?
-    end
-
-    def set_comm_inactivity_timeout(*args); end # TODO
-
-    # Make an outgoing connection
-    def connect(addr, port, handler = Connection, *args, &block)
-      block = args.pop if Proc === args[-1]
-
-      # make sure we're a 'real' class here
-      klass = if (handler and handler.is_a?(Class))
-        handler
-      else
-        Class.new( Connection ) {handler and include handler}
-      end
-
-      wrapped_child = CallsBackToEM.connect(addr, port, *args) # ltodo: args? what? they're used? also TODOC TODO FIX
-      conn = klass.new(wrapped_child) # ltodo [?] addr, port, *args)
-      wrapped_child.attach(Coolio::Loop.default) # necessary
-      conn.heres_your_socket(wrapped_child)
-      wrapped_child.call_back_to_this(conn) # calls post_init for us
-      yield conn if block_given?
-    end
-
-    # Start a TCP server on the given address and port
-    def start_server(addr, port, handler = Connection, *args, &block)
-      # make sure we're a 'real' class here
-      klass = if (handler and handler.is_a?(Class))
-        handler
-      else
-        Class.new( Connection ) {handler and include handler}
-      end
-
-      server = Coolio::TCPServer.new(addr, port, CallsBackToEM, *args) do |wrapped_child|
-        conn = klass.new(wrapped_child)
-        conn.heres_your_socket(wrapped_child) # ideally NOT have this :)
-        wrapped_child.call_back_to_this(conn)
-        block.call(conn) if block
-      end
-
-      server.attach(Coolio::Loop.default)
-    end
-
-    def stop_server(server)
-      server.close
-    end
-
-    # Set the maximum number of descriptors available to this process
-    def set_descriptor_table_size(nfds)
-      Coolio::Utils.maxfds = nfds
-    end
-
-    # Compatibility noop.  Handled automatically by libev
-    def epoll; end
-
-    # Compatibility noop.  Handled automatically by libev
-    def kqueue; end
-  end
-
-  class CallsBackToEM < Coolio::TCPSocket
-    class ConnectTimer < Coolio::TimerWatcher
-      attr_accessor :parent
-      def on_timer
-       @parent.connection_has_timed_out
-      end
-    end
-
-    def call_back_to_this parent
-      @call_back_to_this = parent
-      parent.post_init
-    end
-
-    def on_connect
-      # @connection_timer.detach if @connection_timer
-      # won't need that anymore :) -- with server connecteds we don't have it, anyway
-
-      # TODO should server accepted's call this? They don't currently
-      # [and can't, since on_connect gets called basically in the initializer--needs some code love for that to happen :)
-      @call_back_to_this.connection_completed if @call_back_to_this
-    end
-
-    def connection_has_timed_out
-      return if closed?
-
-      # wonder if this works when you're within a half-connected phase.
-      # I think it does.  What about TCP state?
-      close unless closed?
-      @call_back_to_this.unbind
-    end
-
-    def on_write_complete
-      close if @should_close_after_writing
-    end
-
-    def should_close_after_writing
-      @should_close_after_writing = true;
-    end
-
-    def on_close
-      @call_back_to_this.unbind # about the same ltodo check if they ARE the same here
-    end
-
-    def on_resolve_failed
-      fail
-    end
-
-    def on_connect_failed
-      fail
-    end
-
-    def on_read(data)
-      @call_back_to_this.receive_data data
-    end
-
-    def fail
-      #@connection_timer.detch if @connection_timer
-      @call_back_to_this.unbind
-    end
-
-    def self.connect(*args)
-      a = super *args
-      # the connect timer currently kills TCPServer classes.  I'm not sure why.
-      #@connection_timer = ConnectTimer.new(14) # needs to be at least higher than 12 :)
-      #@connection_timer.parent = a
-      #@connection_timer.attach(Coolio::Loop.default)
-      a
-    end
-  end
-
-  class Connection
-    def self.new(*args)
-      allocate#.instance_eval do
-      #  initialize *args
-      #end
-    end
-
-    # we will need to call 'their functions' appropriately -- the commented out ones, here
-    #
-    # Callback fired when connection is created
-    def post_init
-      # I thought we were 'overriding' EM's existing methods, here.
-      # Huh? Why do we have to define these then?
-    end
-
-    # Callback fired when connection is closed
-    def unbind; end
-
-    # Callback fired when data is received
-    # def receive_data(data); end
-    def heres_your_socket(instantiated_coolio_socket)
-      instantiated_coolio_socket.call_back_to_this self
-      @wrapped_coolio = instantiated_coolio_socket
-    end
-
-    # Send data to the current connection -- called by them
-    def send_data(data)
-      @wrapped_coolio.write data
-    end
-
-    # Close the connection, optionally after writing
-    def close_connection(after_writing = false)
-      return close_connection_after_writing if after_writing
-      @wrapped_coolio.close
-    end
-
-    # Close the connection after all data has been written
-    def close_connection_after_writing
-      @wrapped_coolio.output_buffer_size.zero? ? @wrapped_coolio.close : @wrapped_coolio.should_close_after_writing
-    end
-
-    def get_peername
-      family, port, host_name, host_ip = @wrapped_coolio.peeraddr
-      Socket.pack_sockaddr_in(port, host_ip) # pack it up :)
-    end
-  end
-end
-
-# Shortcut constant
-EM = EventMachine