cool.io 1.2.0-x86-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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
+ }