cool.io 1.2.0-x86-mingw32

Sign up to get free protection for your applications and to get access to all the features.
Files changed (79) hide show
  1. data/.gitignore +26 -0
  2. data/.rspec +3 -0
  3. data/.travis.yml +4 -0
  4. data/CHANGES.md +176 -0
  5. data/Gemfile +4 -0
  6. data/LICENSE +20 -0
  7. data/README.md +172 -0
  8. data/Rakefile +81 -0
  9. data/cool.io.gemspec +28 -0
  10. data/examples/dslified_echo_client.rb +34 -0
  11. data/examples/dslified_echo_server.rb +24 -0
  12. data/examples/echo_client.rb +38 -0
  13. data/examples/echo_server.rb +27 -0
  14. data/examples/google.rb +9 -0
  15. data/examples/httpclient.rb +38 -0
  16. data/ext/cool.io/.gitignore +5 -0
  17. data/ext/cool.io/cool.io.h +58 -0
  18. data/ext/cool.io/cool.io_ext.c +25 -0
  19. data/ext/cool.io/ev_wrap.h +8 -0
  20. data/ext/cool.io/extconf.rb +73 -0
  21. data/ext/cool.io/iowatcher.c +189 -0
  22. data/ext/cool.io/libev.c +8 -0
  23. data/ext/cool.io/loop.c +301 -0
  24. data/ext/cool.io/stat_watcher.c +269 -0
  25. data/ext/cool.io/timer_watcher.c +219 -0
  26. data/ext/cool.io/utils.c +122 -0
  27. data/ext/cool.io/watcher.c +264 -0
  28. data/ext/cool.io/watcher.h +71 -0
  29. data/ext/http11_client/.gitignore +5 -0
  30. data/ext/http11_client/LICENSE +31 -0
  31. data/ext/http11_client/ext_help.h +14 -0
  32. data/ext/http11_client/extconf.rb +6 -0
  33. data/ext/http11_client/http11_client.c +300 -0
  34. data/ext/http11_client/http11_parser.c +403 -0
  35. data/ext/http11_client/http11_parser.h +48 -0
  36. data/ext/http11_client/http11_parser.rl +173 -0
  37. data/ext/iobuffer/extconf.rb +9 -0
  38. data/ext/iobuffer/iobuffer.c +765 -0
  39. data/ext/libev/Changes +388 -0
  40. data/ext/libev/LICENSE +36 -0
  41. data/ext/libev/README +58 -0
  42. data/ext/libev/README.embed +3 -0
  43. data/ext/libev/ev.c +4803 -0
  44. data/ext/libev/ev.h +845 -0
  45. data/ext/libev/ev_epoll.c +279 -0
  46. data/ext/libev/ev_kqueue.c +214 -0
  47. data/ext/libev/ev_poll.c +148 -0
  48. data/ext/libev/ev_port.c +185 -0
  49. data/ext/libev/ev_select.c +314 -0
  50. data/ext/libev/ev_vars.h +203 -0
  51. data/ext/libev/ev_win32.c +163 -0
  52. data/ext/libev/ev_wrap.h +200 -0
  53. data/ext/libev/test_libev_win32.c +123 -0
  54. data/lib/.gitignore +2 -0
  55. data/lib/cool.io.rb +32 -0
  56. data/lib/cool.io/async_watcher.rb +43 -0
  57. data/lib/cool.io/custom_require.rb +9 -0
  58. data/lib/cool.io/dns_resolver.rb +225 -0
  59. data/lib/cool.io/dsl.rb +135 -0
  60. data/lib/cool.io/eventmachine.rb +234 -0
  61. data/lib/cool.io/http_client.rb +427 -0
  62. data/lib/cool.io/io.rb +174 -0
  63. data/lib/cool.io/iowatcher.rb +17 -0
  64. data/lib/cool.io/listener.rb +93 -0
  65. data/lib/cool.io/loop.rb +130 -0
  66. data/lib/cool.io/meta.rb +49 -0
  67. data/lib/cool.io/server.rb +74 -0
  68. data/lib/cool.io/socket.rb +230 -0
  69. data/lib/cool.io/timer_watcher.rb +17 -0
  70. data/lib/cool.io/version.rb +5 -0
  71. data/lib/coolio.rb +2 -0
  72. data/spec/async_watcher_spec.rb +57 -0
  73. data/spec/dns_spec.rb +39 -0
  74. data/spec/spec_helper.rb +12 -0
  75. data/spec/stat_watcher_spec.rb +77 -0
  76. data/spec/timer_watcher_spec.rb +55 -0
  77. data/spec/unix_listener_spec.rb +25 -0
  78. data/spec/unix_server_spec.rb +25 -0
  79. metadata +200 -0
@@ -0,0 +1,48 @@
1
+ /**
2
+ * Copyright (c) 2005 Zed A. Shaw
3
+ * You can redistribute it and/or modify it under the same terms as Ruby.
4
+ */
5
+
6
+ #ifndef http11_parser_h
7
+ #define http11_parser_h
8
+
9
+ #include <sys/types.h>
10
+
11
+ #if defined(_WIN32)
12
+ #include <stddef.h>
13
+ #endif
14
+
15
+ typedef void (*element_cb)(void *data, const char *at, size_t length);
16
+ typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
17
+
18
+ typedef struct httpclient_parser {
19
+ int cs;
20
+ size_t body_start;
21
+ int content_len;
22
+ size_t nread;
23
+ size_t mark;
24
+ size_t field_start;
25
+ size_t field_len;
26
+
27
+ void *data;
28
+
29
+ field_cb http_field;
30
+ element_cb reason_phrase;
31
+ element_cb status_code;
32
+ element_cb chunk_size;
33
+ element_cb http_version;
34
+ element_cb header_done;
35
+ element_cb last_chunk;
36
+
37
+
38
+ } httpclient_parser;
39
+
40
+ int httpclient_parser_init(httpclient_parser *parser);
41
+ int httpclient_parser_finish(httpclient_parser *parser);
42
+ size_t httpclient_parser_execute(httpclient_parser *parser, const char *data, size_t len, size_t off);
43
+ int httpclient_parser_has_error(httpclient_parser *parser);
44
+ int httpclient_parser_is_finished(httpclient_parser *parser);
45
+
46
+ #define httpclient_parser_nread(parser) (parser)->nread
47
+
48
+ #endif
@@ -0,0 +1,173 @@
1
+ /**
2
+ * Copyright (c) 2005 Zed A. Shaw
3
+ * You can redistribute it and/or modify it under the same terms as Ruby.
4
+ */
5
+
6
+ #include "http11_parser.h"
7
+ #include <stdio.h>
8
+ #include <assert.h>
9
+ #include <stdlib.h>
10
+ #include <ctype.h>
11
+ #include <string.h>
12
+
13
+ #define LEN(AT, FPC) (FPC - buffer - parser->AT)
14
+ #define MARK(M,FPC) (parser->M = (FPC) - buffer)
15
+ #define PTR_TO(F) (buffer + parser->F)
16
+ #define L(M) fprintf(stderr, "" # M "\n");
17
+
18
+
19
+ /** machine **/
20
+ %%{
21
+ machine httpclient_parser;
22
+
23
+ action mark {MARK(mark, fpc); }
24
+
25
+ action start_field { MARK(field_start, fpc); }
26
+
27
+ action write_field {
28
+ parser->field_len = LEN(field_start, fpc);
29
+ }
30
+
31
+ action start_value { MARK(mark, fpc); }
32
+
33
+ action write_value {
34
+ parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
35
+ }
36
+
37
+ action reason_phrase {
38
+ parser->reason_phrase(parser->data, PTR_TO(mark), LEN(mark, fpc));
39
+ }
40
+
41
+ action status_code {
42
+ parser->status_code(parser->data, PTR_TO(mark), LEN(mark, fpc));
43
+ }
44
+
45
+ action http_version {
46
+ parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
47
+ }
48
+
49
+ action chunk_size {
50
+ parser->chunk_size(parser->data, PTR_TO(mark), LEN(mark, fpc));
51
+ }
52
+
53
+ action last_chunk {
54
+ parser->last_chunk(parser->data, NULL, 0);
55
+ }
56
+
57
+ action done {
58
+ parser->body_start = fpc - buffer + 1;
59
+ if(parser->header_done != NULL)
60
+ parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
61
+ fbreak;
62
+ }
63
+
64
+ # line endings
65
+ CRLF = "\r\n";
66
+
67
+ # character types
68
+ CTL = (cntrl | 127);
69
+ tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
70
+
71
+ # elements
72
+ token = (ascii -- (CTL | tspecials));
73
+
74
+ Reason_Phrase = (any -- CRLF)* >mark %reason_phrase;
75
+ Status_Code = digit{3} >mark %status_code;
76
+ http_number = (digit+ "." digit+) ;
77
+ HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
78
+ Status_Line = HTTP_Version " " Status_Code " "? Reason_Phrase :> CRLF;
79
+
80
+ field_name = token+ >start_field %write_field;
81
+ field_value = any* >start_value %write_value;
82
+ message_header = field_name ":" " "* field_value :> CRLF;
83
+
84
+ Response = Status_Line (message_header)* (CRLF @done);
85
+
86
+ chunk_ext_val = token+;
87
+ chunk_ext_name = token+;
88
+ chunk_extension = (";" chunk_ext_name >start_field %write_field %start_value ("=" chunk_ext_val >start_value)? %write_value )*;
89
+ last_chunk = "0"? chunk_extension :> (CRLF @last_chunk @done);
90
+ chunk_size = xdigit+;
91
+ chunk = chunk_size >mark %chunk_size chunk_extension space* :> (CRLF @done);
92
+ Chunked_Header = (chunk | last_chunk);
93
+
94
+ main := Response | Chunked_Header;
95
+ }%%
96
+
97
+ /** Data **/
98
+ %% write data;
99
+
100
+ int httpclient_parser_init(httpclient_parser *parser) {
101
+ int cs = 0;
102
+ %% write init;
103
+ parser->cs = cs;
104
+ parser->body_start = 0;
105
+ parser->content_len = 0;
106
+ parser->mark = 0;
107
+ parser->nread = 0;
108
+ parser->field_len = 0;
109
+ parser->field_start = 0;
110
+
111
+ return(1);
112
+ }
113
+
114
+
115
+ /** exec **/
116
+ size_t httpclient_parser_execute(httpclient_parser *parser, const char *buffer, size_t len, size_t off) {
117
+ const char *p, *pe;
118
+ int cs = parser->cs;
119
+
120
+ assert(off <= len && "offset past end of buffer");
121
+
122
+ p = buffer+off;
123
+ pe = buffer+len;
124
+
125
+ assert(*pe == '\0' && "pointer does not end on NUL");
126
+ assert(pe - p == len - off && "pointers aren't same distance");
127
+
128
+
129
+ %% write exec;
130
+
131
+ parser->cs = cs;
132
+ parser->nread += p - (buffer + off);
133
+
134
+ assert(p <= pe && "buffer overflow after parsing execute");
135
+ assert(parser->nread <= len && "nread longer than length");
136
+ assert(parser->body_start <= len && "body starts after buffer end");
137
+ assert(parser->mark < len && "mark is after buffer end");
138
+ assert(parser->field_len <= len && "field has length longer than whole buffer");
139
+ assert(parser->field_start < len && "field starts after buffer end");
140
+
141
+ if(parser->body_start) {
142
+ /* final \r\n combo encountered so stop right here */
143
+ %%write eof;
144
+ parser->nread++;
145
+ }
146
+
147
+ return(parser->nread);
148
+ }
149
+
150
+ int httpclient_parser_finish(httpclient_parser *parser)
151
+ {
152
+ int cs = parser->cs;
153
+
154
+ %%write eof;
155
+
156
+ parser->cs = cs;
157
+
158
+ if (httpclient_parser_has_error(parser) ) {
159
+ return -1;
160
+ } else if (httpclient_parser_is_finished(parser) ) {
161
+ return 1;
162
+ } else {
163
+ return 0;
164
+ }
165
+ }
166
+
167
+ int httpclient_parser_has_error(httpclient_parser *parser) {
168
+ return parser->cs == httpclient_parser_error;
169
+ }
170
+
171
+ int httpclient_parser_is_finished(httpclient_parser *parser) {
172
+ return parser->cs == httpclient_parser_first_final;
173
+ }
@@ -0,0 +1,9 @@
1
+ require 'mkmf'
2
+
3
+ dir_config("iobuffer")
4
+ have_library("c", "main")
5
+ if have_macro("HAVE_RB_IO_T", "rubyio.h")
6
+ have_struct_member("rb_io_t", "fd", "rubyio.h")
7
+ end
8
+
9
+ create_makefile("iobuffer_ext")
@@ -0,0 +1,765 @@
1
+ /*
2
+ * Copyright (C) 2007-12 Tony Arcieri
3
+ * You may redistribute this under the terms of the MIT license.
4
+ * See LICENSE for details
5
+ */
6
+
7
+ #include "ruby.h"
8
+ #include "ruby/io.h"
9
+
10
+ #include <assert.h>
11
+
12
+ #include <string.h>
13
+ #include <time.h>
14
+ #include <unistd.h>
15
+ #include <errno.h>
16
+
17
+ /* 1 GiB maximum buffer size */
18
+ #define MAX_BUFFER_SIZE 0x40000000
19
+
20
+ /* Macro for retrieving the file descriptor from an FPTR */
21
+ #if !HAVE_RB_IO_T_FD
22
+ #define FPTR_TO_FD(fptr) fileno(fptr->f)
23
+ #else
24
+ #define FPTR_TO_FD(fptr) fptr->fd
25
+ #endif
26
+
27
+ /* Default number of bytes in each node's buffer. Should be >= MTU */
28
+ #define DEFAULT_NODE_SIZE 16384
29
+ static unsigned default_node_size = DEFAULT_NODE_SIZE;
30
+
31
+ struct buffer {
32
+ unsigned size, node_size;
33
+ struct buffer_node *head, *tail;
34
+ struct buffer_node *pool_head, *pool_tail;
35
+
36
+ };
37
+
38
+ struct buffer_node {
39
+ unsigned start, end;
40
+ struct buffer_node *next;
41
+ unsigned char data[0];
42
+ };
43
+
44
+ static VALUE cIO_Buffer = Qnil;
45
+
46
+ static VALUE IO_Buffer_allocate(VALUE klass);
47
+ static void IO_Buffer_mark(struct buffer *);
48
+ static void IO_Buffer_free(struct buffer *);
49
+
50
+ static VALUE IO_Buffer_default_node_size(VALUE klass);
51
+ static VALUE IO_Buffer_set_default_node_size(VALUE klass, VALUE size);
52
+ static VALUE IO_Buffer_initialize(int argc, VALUE * argv, VALUE self);
53
+ static VALUE IO_Buffer_clear(VALUE self);
54
+ static VALUE IO_Buffer_size(VALUE self);
55
+ static VALUE IO_Buffer_empty(VALUE self);
56
+ static VALUE IO_Buffer_append(VALUE self, VALUE data);
57
+ static VALUE IO_Buffer_prepend(VALUE self, VALUE data);
58
+ static VALUE IO_Buffer_read(int argc, VALUE * argv, VALUE self);
59
+ static VALUE IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark);
60
+ static VALUE IO_Buffer_to_str(VALUE self);
61
+ static VALUE IO_Buffer_read_from(VALUE self, VALUE io);
62
+ static VALUE IO_Buffer_write_to(VALUE self, VALUE io);
63
+
64
+ static struct buffer *buffer_new(void);
65
+ static void buffer_clear(struct buffer * buf);
66
+ static void buffer_free(struct buffer * buf);
67
+ static void buffer_free_pool(struct buffer * buf);
68
+ static void buffer_prepend(struct buffer * buf, char *str, unsigned len);
69
+ static void buffer_append(struct buffer * buf, char *str, unsigned len);
70
+ static void buffer_read(struct buffer * buf, char *str, unsigned len);
71
+ static int buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark);
72
+ static void buffer_copy(struct buffer * buf, char *str, unsigned len);
73
+ static int buffer_read_from(struct buffer * buf, int fd);
74
+ static int buffer_write_to(struct buffer * buf, int fd);
75
+
76
+ /*
77
+ * High-performance I/O buffer intended for use in non-blocking programs
78
+ *
79
+ * Data is stored in as a memory-pooled linked list of equally sized chunks.
80
+ * Routines are provided for high speed non-blocking reads and writes from
81
+ * Ruby IO objects.
82
+ */
83
+ void
84
+ Init_iobuffer_ext()
85
+ {
86
+ cIO_Buffer = rb_define_class_under(rb_cIO, "Buffer", rb_cObject);
87
+ rb_define_alloc_func(cIO_Buffer, IO_Buffer_allocate);
88
+
89
+ rb_define_singleton_method(cIO_Buffer, "default_node_size",
90
+ IO_Buffer_default_node_size, 0);
91
+ rb_define_singleton_method(cIO_Buffer, "default_node_size=",
92
+ IO_Buffer_set_default_node_size, 1);
93
+
94
+ rb_define_method(cIO_Buffer, "initialize", IO_Buffer_initialize, -1);
95
+ rb_define_method(cIO_Buffer, "clear", IO_Buffer_clear, 0);
96
+ rb_define_method(cIO_Buffer, "size", IO_Buffer_size, 0);
97
+ rb_define_method(cIO_Buffer, "empty?", IO_Buffer_empty, 0);
98
+ rb_define_method(cIO_Buffer, "<<", IO_Buffer_append, 1);
99
+ rb_define_method(cIO_Buffer, "append", IO_Buffer_append, 1);
100
+ rb_define_method(cIO_Buffer, "write", IO_Buffer_append, 1);
101
+ rb_define_method(cIO_Buffer, "prepend", IO_Buffer_prepend, 1);
102
+ rb_define_method(cIO_Buffer, "read", IO_Buffer_read, -1);
103
+ rb_define_method(cIO_Buffer, "read_frame", IO_Buffer_read_frame, 2);
104
+ rb_define_method(cIO_Buffer, "to_str", IO_Buffer_to_str, 0);
105
+ rb_define_method(cIO_Buffer, "read_from", IO_Buffer_read_from, 1);
106
+ rb_define_method(cIO_Buffer, "write_to", IO_Buffer_write_to, 1);
107
+
108
+ rb_define_const(cIO_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE));
109
+ }
110
+
111
+ static VALUE
112
+ IO_Buffer_allocate(VALUE klass)
113
+ {
114
+ return Data_Wrap_Struct(klass, IO_Buffer_mark, IO_Buffer_free, buffer_new());
115
+ }
116
+
117
+ static void
118
+ IO_Buffer_mark(struct buffer * buf)
119
+ {
120
+ /* Naively discard the memory pool whenever Ruby garbage collects */
121
+ buffer_free_pool(buf);
122
+ }
123
+
124
+ static void
125
+ IO_Buffer_free(struct buffer * buf)
126
+ {
127
+ buffer_free(buf);
128
+ }
129
+
130
+ /**
131
+ * call-seq:
132
+ * IO_Buffer.default_node_size -> 4096
133
+ *
134
+ * Retrieves the current value of the default node size.
135
+ */
136
+ static VALUE
137
+ IO_Buffer_default_node_size(VALUE klass)
138
+ {
139
+ return UINT2NUM(default_node_size);
140
+ }
141
+
142
+ /*
143
+ * safely converts node sizes from Ruby numerics to C and raising
144
+ * ArgumentError or RangeError on invalid sizes
145
+ */
146
+ static unsigned
147
+ convert_node_size(VALUE size)
148
+ {
149
+ if (
150
+ rb_funcall(size, rb_intern("<"), 1, INT2NUM(1)) == Qtrue ||
151
+ rb_funcall(size, rb_intern(">"), 1, INT2NUM(MAX_BUFFER_SIZE)) == Qtrue
152
+ )
153
+ rb_raise(rb_eArgError, "invalid buffer size");
154
+
155
+ return (unsigned) NUM2INT(size);
156
+ }
157
+
158
+ /**
159
+ * call-seq:
160
+ * IO_Buffer.default_node_size = 16384
161
+ *
162
+ * Sets the default node size for calling IO::Buffer.new with no arguments.
163
+ */
164
+ static VALUE
165
+ IO_Buffer_set_default_node_size(VALUE klass, VALUE size)
166
+ {
167
+ default_node_size = convert_node_size(size);
168
+
169
+ return size;
170
+ }
171
+
172
+ /**
173
+ * call-seq:
174
+ * IO_Buffer.new(size = IO::Buffer.default_node_size) -> IO_Buffer
175
+ *
176
+ * Create a new IO_Buffer with linked segments of the given size
177
+ */
178
+ static VALUE
179
+ IO_Buffer_initialize(int argc, VALUE * argv, VALUE self)
180
+ {
181
+ VALUE node_size_obj;
182
+ struct buffer *buf;
183
+
184
+ if (rb_scan_args(argc, argv, "01", &node_size_obj) == 1) {
185
+ Data_Get_Struct(self, struct buffer, buf);
186
+
187
+ /*
188
+ * Make sure we're not changing the buffer size after data
189
+ * has been allocated
190
+ */
191
+ assert(!buf->head);
192
+ assert(!buf->pool_head);
193
+
194
+ buf->node_size = convert_node_size(node_size_obj);
195
+ }
196
+ return Qnil;
197
+ }
198
+
199
+ /**
200
+ * call-seq:
201
+ * IO_Buffer#clear -> nil
202
+ *
203
+ * Clear all data from the IO_Buffer
204
+ */
205
+ static VALUE
206
+ IO_Buffer_clear(VALUE self)
207
+ {
208
+ struct buffer *buf;
209
+ Data_Get_Struct(self, struct buffer, buf);
210
+
211
+ buffer_clear(buf);
212
+
213
+ return Qnil;
214
+ }
215
+
216
+ /**
217
+ * call-seq:
218
+ * IO_Buffer#size -> Integer
219
+ *
220
+ * Return the size of the buffer in bytes
221
+ */
222
+ static VALUE
223
+ IO_Buffer_size(VALUE self)
224
+ {
225
+ struct buffer *buf;
226
+ Data_Get_Struct(self, struct buffer, buf);
227
+
228
+ return INT2NUM(buf->size);
229
+ }
230
+
231
+ /**
232
+ * call-seq:
233
+ * IO_Buffer#empty? -> Boolean
234
+ *
235
+ * Is the buffer empty?
236
+ */
237
+ static VALUE
238
+ IO_Buffer_empty(VALUE self)
239
+ {
240
+ struct buffer *buf;
241
+ Data_Get_Struct(self, struct buffer, buf);
242
+
243
+ return buf->size > 0 ? Qfalse : Qtrue;
244
+ }
245
+
246
+ /**
247
+ * call-seq:
248
+ * IO_Buffer#append(data) -> String
249
+ *
250
+ * Append the given data to the end of the buffer
251
+ */
252
+ static VALUE
253
+ IO_Buffer_append(VALUE self, VALUE data)
254
+ {
255
+ struct buffer *buf;
256
+ Data_Get_Struct(self, struct buffer, buf);
257
+
258
+ /* Is this needed? Never seen anyone else do it... */
259
+ data = rb_convert_type(data, T_STRING, "String", "to_str");
260
+ buffer_append(buf, RSTRING_PTR(data), RSTRING_LEN(data));
261
+
262
+ return data;
263
+ }
264
+
265
+ /**
266
+ * call-seq:
267
+ * IO_Buffer#prepend(data) -> String
268
+ *
269
+ * Prepend the given data to the beginning of the buffer
270
+ */
271
+ static VALUE
272
+ IO_Buffer_prepend(VALUE self, VALUE data)
273
+ {
274
+ struct buffer *buf;
275
+ Data_Get_Struct(self, struct buffer, buf);
276
+
277
+ data = rb_convert_type(data, T_STRING, "String", "to_str");
278
+ buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data));
279
+
280
+ return data;
281
+ }
282
+
283
+ /**
284
+ * call-seq:
285
+ * IO_Buffer#read(length = nil) -> String
286
+ *
287
+ * Read the specified abount of data from the buffer. If no value
288
+ * is given the entire contents of the buffer are returned. Any data
289
+ * read from the buffer is cleared.
290
+ * The given length must be greater than 0 or an exception would raise.
291
+ * If the buffer size is zero then an empty string is returned (regardless
292
+ * the given length).
293
+ */
294
+ static VALUE
295
+ IO_Buffer_read(int argc, VALUE * argv, VALUE self)
296
+ {
297
+ VALUE length_obj, str;
298
+ int length;
299
+ struct buffer *buf;
300
+
301
+ Data_Get_Struct(self, struct buffer, buf);
302
+
303
+ if (rb_scan_args(argc, argv, "01", &length_obj) == 1) {
304
+ length = NUM2INT(length_obj);
305
+ if(length < 1)
306
+ rb_raise(rb_eArgError, "length must be greater than zero");
307
+ if(length > buf->size)
308
+ length = buf->size;
309
+ } else
310
+ length = buf->size;
311
+
312
+ if(buf->size == 0)
313
+ return rb_str_new2("");
314
+
315
+ str = rb_str_new(0, length);
316
+ buffer_read(buf, RSTRING_PTR(str), length);
317
+
318
+ return str;
319
+ }
320
+
321
+ /**
322
+ * call-seq:
323
+ * IO_Buffer#read_frame(str, mark) -> boolean
324
+ *
325
+ * Read up to and including the given frame marker (expressed a a
326
+ * Fixnum 0-255) byte, copying into the supplied string object. If the mark is
327
+ * not encountered before the end of the buffer, false is returned but data
328
+ * is still copied into str. True is returned if the end of a frame is reached.
329
+ *
330
+ */
331
+ static VALUE
332
+ IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
333
+ {
334
+ char mark_c = (char) NUM2INT(mark);
335
+ struct buffer *buf;
336
+
337
+ Data_Get_Struct(self, struct buffer, buf);
338
+
339
+ if (buffer_read_frame(buf, data, mark_c)) {
340
+ return Qtrue;
341
+ } else {
342
+ return Qfalse;
343
+ }
344
+ }
345
+
346
+ /**
347
+ * call-seq:
348
+ * IO_Buffer#to_str -> String
349
+ *
350
+ * Convert the Buffer to a String. The original buffer is unmodified.
351
+ */
352
+ static VALUE
353
+ IO_Buffer_to_str(VALUE self)
354
+ {
355
+ VALUE str;
356
+ struct buffer *buf;
357
+
358
+ Data_Get_Struct(self, struct buffer, buf);
359
+
360
+ str = rb_str_new(0, buf->size);
361
+ buffer_copy(buf, RSTRING_PTR(str), buf->size);
362
+
363
+ return str;
364
+ }
365
+
366
+ /**
367
+ * call-seq:
368
+ * IO_Buffer#read_from(io) -> Integer
369
+ *
370
+ * Perform a nonblocking read of the the given IO object and fill
371
+ * the buffer with any data received. The call will read as much
372
+ * data as it can until the read would block.
373
+ */
374
+ static VALUE
375
+ IO_Buffer_read_from(VALUE self, VALUE io)
376
+ {
377
+ struct buffer *buf;
378
+ int ret;
379
+ #if HAVE_RB_IO_T
380
+ rb_io_t *fptr;
381
+ #else
382
+ OpenFile *fptr;
383
+ #endif
384
+
385
+ Data_Get_Struct(self, struct buffer, buf);
386
+ GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
387
+ rb_io_set_nonblock(fptr);
388
+
389
+ ret = buffer_read_from(buf, FPTR_TO_FD(fptr));
390
+ return ret == -1 ? Qnil : INT2NUM(ret);
391
+ }
392
+
393
+ /**
394
+ * call-seq:
395
+ * IO_Buffer#write_to(io) -> Integer
396
+ *
397
+ * Perform a nonblocking write of the buffer to the given IO object.
398
+ * As much data as possible is written until the call would block.
399
+ * Any data which is written is removed from the buffer.
400
+ */
401
+ static VALUE
402
+ IO_Buffer_write_to(VALUE self, VALUE io)
403
+ {
404
+ struct buffer *buf;
405
+ #if HAVE_RB_IO_T
406
+ rb_io_t *fptr;
407
+ #else
408
+ OpenFile *fptr;
409
+ #endif
410
+
411
+ Data_Get_Struct(self, struct buffer, buf);
412
+ GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
413
+ rb_io_set_nonblock(fptr);
414
+
415
+ return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
416
+ }
417
+
418
+ /*
419
+ * Ruby bindings end here. Below is the actual implementation of
420
+ * the underlying byte queue ADT
421
+ */
422
+
423
+ /* Create a new buffer */
424
+ static struct buffer *
425
+ buffer_new(void)
426
+ {
427
+ struct buffer *buf;
428
+
429
+ buf = (struct buffer *) xmalloc(sizeof(struct buffer));
430
+ buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0;
431
+ buf->size = 0;
432
+ buf->node_size = default_node_size;
433
+
434
+ return buf;
435
+ }
436
+
437
+ /* Clear all data from a buffer */
438
+ static void
439
+ buffer_clear(struct buffer * buf)
440
+ {
441
+ /* Move everything into the buffer pool */
442
+ if (!buf->pool_tail) {
443
+ buf->pool_head = buf->pool_tail = buf->head;
444
+ } else {
445
+ buf->pool_tail->next = buf->head;
446
+ }
447
+
448
+ buf->head = buf->tail = 0;
449
+ buf->size = 0;
450
+ }
451
+
452
+ /* Free a buffer */
453
+ static void
454
+ buffer_free(struct buffer * buf)
455
+ {
456
+ buffer_clear(buf);
457
+ buffer_free_pool(buf);
458
+
459
+ free(buf);
460
+ }
461
+
462
+ /* Free the memory pool */
463
+ static void
464
+ buffer_free_pool(struct buffer * buf)
465
+ {
466
+ struct buffer_node *tmp;
467
+
468
+ while (buf->pool_head) {
469
+ tmp = buf->pool_head;
470
+ buf->pool_head = tmp->next;
471
+ free(tmp);
472
+ }
473
+
474
+ buf->pool_tail = 0;
475
+ }
476
+
477
+ /* Create a new buffer_node (or pull one from the memory pool) */
478
+ static struct buffer_node *
479
+ buffer_node_new(struct buffer * buf)
480
+ {
481
+ struct buffer_node *node;
482
+
483
+ /* Pull from the memory pool if available */
484
+ if (buf->pool_head) {
485
+ node = buf->pool_head;
486
+ buf->pool_head = node->next;
487
+
488
+ if (node->next)
489
+ node->next = 0;
490
+ else
491
+ buf->pool_tail = 0;
492
+ } else {
493
+ node = (struct buffer_node *) xmalloc(sizeof(struct buffer_node) + buf->node_size);
494
+ node->next = 0;
495
+ }
496
+
497
+ node->start = node->end = 0;
498
+ return node;
499
+ }
500
+
501
+ /* Free a buffer node (i.e. return it to the memory pool) */
502
+ static void
503
+ buffer_node_free(struct buffer * buf, struct buffer_node * node)
504
+ {
505
+ node->next = buf->pool_head;
506
+ buf->pool_head = node;
507
+
508
+ if (!buf->pool_tail) {
509
+ buf->pool_tail = node;
510
+ }
511
+ }
512
+
513
+ /* Prepend data to the front of the buffer */
514
+ static void
515
+ buffer_prepend(struct buffer * buf, char *str, unsigned len)
516
+ {
517
+ struct buffer_node *node, *tmp;
518
+ buf->size += len;
519
+
520
+ /* If it fits in the beginning of the head */
521
+ if (buf->head && buf->head->start >= len) {
522
+ buf->head->start -= len;
523
+ memcpy(buf->head->data + buf->head->start, str, len);
524
+ } else {
525
+ node = buffer_node_new(buf);
526
+ node->next = buf->head;
527
+ buf->head = node;
528
+ if (!buf->tail)
529
+ buf->tail = node;
530
+
531
+ while (len > buf->node_size) {
532
+ memcpy(node->data, str, buf->node_size);
533
+ node->end = buf->node_size;
534
+
535
+ tmp = buffer_node_new(buf);
536
+ tmp->next = node->next;
537
+ node->next = tmp;
538
+
539
+ if (buf->tail == node)
540
+ buf->tail = tmp;
541
+ node = tmp;
542
+
543
+ str += buf->node_size;
544
+ len -= buf->node_size;
545
+ }
546
+
547
+ if (len > 0) {
548
+ memcpy(node->data, str, len);
549
+ node->end = len;
550
+ }
551
+ }
552
+ }
553
+
554
+ /* Append data to the front of the buffer */
555
+ static void
556
+ buffer_append(struct buffer * buf, char *str, unsigned len)
557
+ {
558
+ unsigned nbytes;
559
+ buf->size += len;
560
+
561
+ /* If it fits in the remaining space in the tail */
562
+ if (buf->tail && len <= buf->node_size - buf->tail->end) {
563
+ memcpy(buf->tail->data + buf->tail->end, str, len);
564
+ buf->tail->end += len;
565
+ return;
566
+ }
567
+ /* Empty list needs initialized */
568
+ if (!buf->head) {
569
+ buf->head = buffer_node_new(buf);
570
+ buf->tail = buf->head;
571
+ }
572
+ /* Build links out of the data */
573
+ while (len > 0) {
574
+ nbytes = buf->node_size - buf->tail->end;
575
+ if (len < nbytes)
576
+ nbytes = len;
577
+
578
+ memcpy(buf->tail->data + buf->tail->end, str, nbytes);
579
+ str += nbytes;
580
+ len -= nbytes;
581
+
582
+ buf->tail->end += nbytes;
583
+
584
+ if (len > 0) {
585
+ buf->tail->next = buffer_node_new(buf);
586
+ buf->tail = buf->tail->next;
587
+ }
588
+ }
589
+ }
590
+
591
+ /* Read data from the buffer (and clear what we've read) */
592
+ static void
593
+ buffer_read(struct buffer * buf, char *str, unsigned len)
594
+ {
595
+ unsigned nbytes;
596
+ struct buffer_node *tmp;
597
+
598
+ while (buf->size > 0 && len > 0) {
599
+ nbytes = buf->head->end - buf->head->start;
600
+ if (len < nbytes)
601
+ nbytes = len;
602
+
603
+ memcpy(str, buf->head->data + buf->head->start, nbytes);
604
+ str += nbytes;
605
+ len -= nbytes;
606
+
607
+ buf->head->start += nbytes;
608
+ buf->size -= nbytes;
609
+
610
+ if (buf->head->start == buf->head->end) {
611
+ tmp = buf->head;
612
+ buf->head = tmp->next;
613
+ buffer_node_free(buf, tmp);
614
+
615
+ if (!buf->head)
616
+ buf->tail = 0;
617
+ }
618
+ }
619
+ }
620
+
621
+ /*
622
+ * Read data from the buffer into str until byte frame_mark or empty. Bytes
623
+ * are copied into str and removed if a complete frame is read, a true value
624
+ * is returned
625
+ */
626
+ static int
627
+ buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
628
+ {
629
+ unsigned nbytes = 0;
630
+ struct buffer_node *tmp;
631
+
632
+ while (buf->size > 0) {
633
+ struct buffer_node *head = buf->head;
634
+ char *loc, *s = head->data + head->start, *e = head->data + head->end;
635
+ nbytes = e - s;
636
+
637
+ loc = memchr(s, frame_mark, nbytes);
638
+
639
+ if (loc) {
640
+ nbytes = loc - s + 1;
641
+ }
642
+
643
+ /* Copy less than everything if we found a frame byte */
644
+ rb_str_cat(str, s, nbytes);
645
+
646
+ /* Fixup the buffer pointers to indicate the bytes were consumed */
647
+ head->start += nbytes;
648
+ buf->size -= nbytes;
649
+
650
+ if (head->start == head->end) {
651
+ buf->head = head->next;
652
+ buffer_node_free(buf, head);
653
+
654
+ if (!buf->head)
655
+ buf->tail = 0;
656
+ }
657
+
658
+ if (loc) {
659
+ return 1;
660
+ }
661
+ }
662
+
663
+ return 0;
664
+ }
665
+
666
+ /* Copy data from the buffer without clearing it */
667
+ static void
668
+ buffer_copy(struct buffer * buf, char *str, unsigned len)
669
+ {
670
+ unsigned nbytes;
671
+ struct buffer_node *node;
672
+
673
+ node = buf->head;
674
+ while (node && len > 0) {
675
+ nbytes = node->end - node->start;
676
+ if (len < nbytes)
677
+ nbytes = len;
678
+
679
+ memcpy(str, node->data + node->start, nbytes);
680
+ str += nbytes;
681
+ len -= nbytes;
682
+
683
+ if (node->start + nbytes == node->end)
684
+ node = node->next;
685
+ }
686
+ }
687
+
688
+ /* Write data from the buffer to a file descriptor */
689
+ static int
690
+ buffer_write_to(struct buffer * buf, int fd)
691
+ {
692
+ int bytes_written, total_bytes_written = 0;
693
+ struct buffer_node *tmp;
694
+
695
+ while (buf->head) {
696
+ bytes_written = write(fd, buf->head->data + buf->head->start, buf->head->end - buf->head->start);
697
+
698
+ /* If the write failed... */
699
+ if (bytes_written < 0) {
700
+ if (errno != EAGAIN)
701
+ rb_sys_fail("write");
702
+
703
+ return total_bytes_written;
704
+ }
705
+
706
+ total_bytes_written += bytes_written;
707
+ buf->size -= bytes_written;
708
+
709
+ /* If the write blocked... */
710
+ if (bytes_written < buf->head->end - buf->head->start) {
711
+ buf->head->start += bytes_written;
712
+ return total_bytes_written;
713
+ }
714
+ /* Otherwise we wrote the whole buffer */
715
+ tmp = buf->head;
716
+ buf->head = tmp->next;
717
+ buffer_node_free(buf, tmp);
718
+
719
+ if (!buf->head)
720
+ buf->tail = 0;
721
+ }
722
+
723
+ return total_bytes_written;
724
+ }
725
+
726
+ /* Read data from a file descriptor to a buffer */
727
+ /* Append data to the front of the buffer */
728
+ static int
729
+ buffer_read_from(struct buffer * buf, int fd)
730
+ {
731
+ int bytes_read, total_bytes_read = 0;
732
+ unsigned nbytes;
733
+
734
+ /* Empty list needs initialized */
735
+ if (!buf->head) {
736
+ buf->head = buffer_node_new(buf);
737
+ buf->tail = buf->head;
738
+ }
739
+
740
+ do {
741
+ nbytes = buf->node_size - buf->tail->end;
742
+ bytes_read = read(fd, buf->tail->data + buf->tail->end, nbytes);
743
+
744
+ if (bytes_read == 0) {
745
+ return -1;
746
+ //When the file reaches EOF
747
+ } else if (bytes_read < 0) {
748
+ if (errno != EAGAIN)
749
+ rb_sys_fail("read");
750
+
751
+ return total_bytes_read;
752
+ }
753
+
754
+ total_bytes_read += bytes_read;
755
+ buf->tail->end += bytes_read;
756
+ buf->size += bytes_read;
757
+
758
+ if (buf->tail->end == buf->node_size) {
759
+ buf->tail->next = buffer_node_new(buf);
760
+ buf->tail = buf->tail->next;
761
+ }
762
+ } while (bytes_read == nbytes);
763
+
764
+ return total_bytes_read;
765
+ }