eventmachine 1.0.0.beta.2-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 (141) hide show
  1. data/.gitignore +16 -0
  2. data/Gemfile +1 -0
  3. data/README +81 -0
  4. data/Rakefile +11 -0
  5. data/docs/COPYING +60 -0
  6. data/docs/ChangeLog +211 -0
  7. data/docs/DEFERRABLES +246 -0
  8. data/docs/EPOLL +141 -0
  9. data/docs/GNU +281 -0
  10. data/docs/INSTALL +13 -0
  11. data/docs/KEYBOARD +42 -0
  12. data/docs/LEGAL +25 -0
  13. data/docs/LIGHTWEIGHT_CONCURRENCY +130 -0
  14. data/docs/PURE_RUBY +75 -0
  15. data/docs/RELEASE_NOTES +94 -0
  16. data/docs/SMTP +4 -0
  17. data/docs/SPAWNED_PROCESSES +148 -0
  18. data/docs/TODO +8 -0
  19. data/eventmachine.gemspec +33 -0
  20. data/examples/ex_channel.rb +43 -0
  21. data/examples/ex_queue.rb +2 -0
  22. data/examples/ex_tick_loop_array.rb +15 -0
  23. data/examples/ex_tick_loop_counter.rb +32 -0
  24. data/examples/helper.rb +2 -0
  25. data/ext/binder.cpp +124 -0
  26. data/ext/binder.h +46 -0
  27. data/ext/cmain.cpp +838 -0
  28. data/ext/ed.cpp +1884 -0
  29. data/ext/ed.h +418 -0
  30. data/ext/em.cpp +2348 -0
  31. data/ext/em.h +228 -0
  32. data/ext/eventmachine.h +123 -0
  33. data/ext/extconf.rb +157 -0
  34. data/ext/fastfilereader/extconf.rb +85 -0
  35. data/ext/fastfilereader/mapper.cpp +214 -0
  36. data/ext/fastfilereader/mapper.h +59 -0
  37. data/ext/fastfilereader/rubymain.cpp +127 -0
  38. data/ext/kb.cpp +79 -0
  39. data/ext/page.cpp +107 -0
  40. data/ext/page.h +51 -0
  41. data/ext/pipe.cpp +347 -0
  42. data/ext/project.h +155 -0
  43. data/ext/rubymain.cpp +1200 -0
  44. data/ext/ssl.cpp +460 -0
  45. data/ext/ssl.h +94 -0
  46. data/java/.classpath +8 -0
  47. data/java/.project +17 -0
  48. data/java/src/com/rubyeventmachine/EmReactor.java +571 -0
  49. data/java/src/com/rubyeventmachine/EmReactorException.java +40 -0
  50. data/java/src/com/rubyeventmachine/EventableChannel.java +69 -0
  51. data/java/src/com/rubyeventmachine/EventableDatagramChannel.java +189 -0
  52. data/java/src/com/rubyeventmachine/EventableSocketChannel.java +364 -0
  53. data/lib/em/buftok.rb +138 -0
  54. data/lib/em/callback.rb +26 -0
  55. data/lib/em/channel.rb +57 -0
  56. data/lib/em/connection.rb +569 -0
  57. data/lib/em/deferrable.rb +206 -0
  58. data/lib/em/file_watch.rb +54 -0
  59. data/lib/em/future.rb +61 -0
  60. data/lib/em/iterator.rb +270 -0
  61. data/lib/em/messages.rb +66 -0
  62. data/lib/em/process_watch.rb +44 -0
  63. data/lib/em/processes.rb +119 -0
  64. data/lib/em/protocols.rb +36 -0
  65. data/lib/em/protocols/header_and_content.rb +138 -0
  66. data/lib/em/protocols/httpclient.rb +268 -0
  67. data/lib/em/protocols/httpclient2.rb +590 -0
  68. data/lib/em/protocols/line_and_text.rb +125 -0
  69. data/lib/em/protocols/line_protocol.rb +28 -0
  70. data/lib/em/protocols/linetext2.rb +161 -0
  71. data/lib/em/protocols/memcache.rb +323 -0
  72. data/lib/em/protocols/object_protocol.rb +45 -0
  73. data/lib/em/protocols/postgres3.rb +247 -0
  74. data/lib/em/protocols/saslauth.rb +175 -0
  75. data/lib/em/protocols/smtpclient.rb +357 -0
  76. data/lib/em/protocols/smtpserver.rb +640 -0
  77. data/lib/em/protocols/socks4.rb +66 -0
  78. data/lib/em/protocols/stomp.rb +200 -0
  79. data/lib/em/protocols/tcptest.rb +53 -0
  80. data/lib/em/pure_ruby.rb +1013 -0
  81. data/lib/em/queue.rb +62 -0
  82. data/lib/em/spawnable.rb +85 -0
  83. data/lib/em/streamer.rb +130 -0
  84. data/lib/em/tick_loop.rb +85 -0
  85. data/lib/em/timers.rb +57 -0
  86. data/lib/em/version.rb +3 -0
  87. data/lib/eventmachine.rb +1548 -0
  88. data/lib/jeventmachine.rb +258 -0
  89. data/lib/rubyeventmachine.rb +2 -0
  90. data/setup.rb +1585 -0
  91. data/tasks/cpp.rake_example +77 -0
  92. data/tasks/doc.rake +30 -0
  93. data/tasks/package.rake +85 -0
  94. data/tasks/test.rake +6 -0
  95. data/tests/client.crt +31 -0
  96. data/tests/client.key +51 -0
  97. data/tests/test_attach.rb +136 -0
  98. data/tests/test_basic.rb +249 -0
  99. data/tests/test_channel.rb +64 -0
  100. data/tests/test_connection_count.rb +35 -0
  101. data/tests/test_defer.rb +49 -0
  102. data/tests/test_deferrable.rb +35 -0
  103. data/tests/test_epoll.rb +160 -0
  104. data/tests/test_error_handler.rb +35 -0
  105. data/tests/test_errors.rb +82 -0
  106. data/tests/test_exc.rb +55 -0
  107. data/tests/test_file_watch.rb +49 -0
  108. data/tests/test_futures.rb +198 -0
  109. data/tests/test_get_sock_opt.rb +30 -0
  110. data/tests/test_handler_check.rb +37 -0
  111. data/tests/test_hc.rb +190 -0
  112. data/tests/test_httpclient.rb +227 -0
  113. data/tests/test_httpclient2.rb +154 -0
  114. data/tests/test_inactivity_timeout.rb +50 -0
  115. data/tests/test_kb.rb +60 -0
  116. data/tests/test_ltp.rb +190 -0
  117. data/tests/test_ltp2.rb +317 -0
  118. data/tests/test_next_tick.rb +133 -0
  119. data/tests/test_object_protocol.rb +37 -0
  120. data/tests/test_pause.rb +70 -0
  121. data/tests/test_pending_connect_timeout.rb +48 -0
  122. data/tests/test_process_watch.rb +50 -0
  123. data/tests/test_processes.rb +128 -0
  124. data/tests/test_proxy_connection.rb +144 -0
  125. data/tests/test_pure.rb +134 -0
  126. data/tests/test_queue.rb +44 -0
  127. data/tests/test_running.rb +42 -0
  128. data/tests/test_sasl.rb +72 -0
  129. data/tests/test_send_file.rb +251 -0
  130. data/tests/test_servers.rb +76 -0
  131. data/tests/test_smtpclient.rb +83 -0
  132. data/tests/test_smtpserver.rb +85 -0
  133. data/tests/test_spawn.rb +322 -0
  134. data/tests/test_ssl_args.rb +79 -0
  135. data/tests/test_ssl_methods.rb +50 -0
  136. data/tests/test_ssl_verify.rb +82 -0
  137. data/tests/test_tick_loop.rb +59 -0
  138. data/tests/test_timers.rb +160 -0
  139. data/tests/test_ud.rb +36 -0
  140. data/tests/testem.rb +31 -0
  141. metadata +240 -0
@@ -0,0 +1,357 @@
1
+ #--
2
+ #
3
+ # Author:: Francis Cianfrocca (gmail: blackhedd)
4
+ # Homepage:: http://rubyeventmachine.com
5
+ # Date:: 16 July 2006
6
+ #
7
+ # See EventMachine and EventMachine::Connection for documentation and
8
+ # usage examples.
9
+ #
10
+ #----------------------------------------------------------------------------
11
+ #
12
+ # Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
13
+ # Gmail: blackhedd
14
+ #
15
+ # This program is free software; you can redistribute it and/or modify
16
+ # it under the terms of either: 1) the GNU General Public License
17
+ # as published by the Free Software Foundation; either version 2 of the
18
+ # License, or (at your option) any later version; or 2) Ruby's License.
19
+ #
20
+ # See the file COPYING for complete licensing information.
21
+ #
22
+ #---------------------------------------------------------------------------
23
+ #
24
+ #
25
+
26
+ require 'ostruct'
27
+
28
+ module EventMachine
29
+ module Protocols
30
+
31
+ # Simple SMTP client
32
+ #
33
+ # email = EM::Protocols::SmtpClient.send(
34
+ # :domain=>"example.com",
35
+ # :host=>'localhost',
36
+ # :port=>25, # optional, defaults 25
37
+ # :starttls=>true, # use ssl
38
+ # :from=>"sender@example.com",
39
+ # :to=> ["to_1@example.com", "to_2@example.com"],
40
+ # :header=> {"Subject" => "This is a subject line"},
41
+ # :body=> "This is the body of the email"
42
+ # )
43
+ # email.callback{
44
+ # puts 'Email sent!'
45
+ # }
46
+ # email.errback{ |e|
47
+ # puts 'Email failed!'
48
+ # }
49
+ #
50
+ # Sending generated emails (using mailfactory)
51
+ #
52
+ # mail = MailFactory.new
53
+ # mail.to = 'someone@site.co'
54
+ # mail.from = 'me@site.com'
55
+ # mail.subject = 'hi!'
56
+ # mail.text = 'hello world'
57
+ # mail.html = '<h1>hello world</h1>'
58
+ #
59
+ # email = EM::P::SmtpClient.send(
60
+ # :domain=>'site.com',
61
+ # :from=>mail.from,
62
+ # :to=>mail.to,
63
+ # :content=>"#{mail.to_s}\r\n.\r\n"
64
+ # )
65
+ #
66
+ class SmtpClient < Connection
67
+ include EventMachine::Deferrable
68
+ include EventMachine::Protocols::LineText2
69
+
70
+ def initialize
71
+ @succeeded = nil
72
+ @responder = nil
73
+ @code = nil
74
+ @msg = nil
75
+ end
76
+
77
+ # :host => required String
78
+ # a string containing the IP address or host name of the SMTP server to connect to.
79
+ # :port => optional
80
+ # defaults to 25.
81
+ # :domain => required String
82
+ # This is passed as the argument to the EHLO command.
83
+ # :starttls => optional Boolean
84
+ # If it evaluates true, then the client will initiate STARTTLS with
85
+ # the server, and abort the connection if the negotiation doesn't succeed.
86
+ # TODO, need to be able to pass certificate parameters with this option.
87
+ # :auth => optional Hash of auth parameters
88
+ # If not given, then no auth will be attempted.
89
+ # (In that case, the connection will be aborted if the server requires auth.)
90
+ # Specify the hash value :type to determine the auth type, along with additional parameters
91
+ # depending on the type.
92
+ # Currently only :type => :plain is supported. Pass additional parameters :username (String),
93
+ # and :password (either a String or a Proc that will be called at auth-time).
94
+ # Example: :auth => {:type=>:plain, :username=>"mickey@disney.com", :password=>"mouse"}
95
+ # :from => required String
96
+ # Specifies the sender of the message. Will be passed as the argument
97
+ # to the MAIL FROM. Do NOT enclose the argument in angle-bracket (<>) characters.
98
+ # The connection will abort if the server rejects the value.
99
+ # :to => required String or Array of Strings
100
+ # The recipient(s) of the message. Do NOT enclose
101
+ # any of the values in angle-brackets (<>) characters. It's NOT a fatal error if one or more
102
+ # recipients are rejected by the server. (Of course, if ALL of them are, the server will most
103
+ # likely trigger an error when we try to send data.) An array of codes containing the status
104
+ # of each requested recipient is available after the call completes. TODO, we should define
105
+ # an overridable stub that will be called on rejection of a recipient or a sender, giving
106
+ # user code the chance to try again or abort the connection.
107
+ # :header => Required hash of values to be transmitted in the header of the message.
108
+ # The hash keys are the names of the headers (do NOT append a trailing colon), and the values are strings
109
+ # containing the header values. TODO, support Arrays of header values, which would cause us to
110
+ # send that specific header line more than once.
111
+ #
112
+ # Example: :header => {"Subject" => "Bogus", "CC" => "myboss@example.com"}
113
+ # :body => Optional string, defaults blank.
114
+ # This will be passed as the body of the email message.
115
+ # TODO, this needs to be significantly beefed up. As currently written, this requires the caller
116
+ # to properly format the input into CRLF-delimited lines of 7-bit characters in the standard
117
+ # SMTP transmission format. We need to be able to automatically convert binary data, and add
118
+ # correct line-breaks to text data. I think the :body parameter should remain as it is, and we
119
+ # should add a :content parameter that contains autoconversions and/or conversion parameters.
120
+ # Then we can check if either :body or :content is present and do the right thing.
121
+ # :content => Optional array or string
122
+ # Alternative to providing header and body, an array or string of raw data which MUST be in
123
+ # correct SMTP body format, including a trailing dot line
124
+ # :verbose => Optional.
125
+ # If true, will cause a lot of information (including the server-side of the
126
+ # conversation) to be dumped to $>.
127
+ #
128
+ def self.send args={}
129
+ args[:port] ||= 25
130
+ args[:body] ||= ""
131
+
132
+ =begin
133
+ (I don't think it's possible for EM#connect to throw an exception under normal
134
+ circumstances, so this original code is stubbed out. A connect-failure will result
135
+ in the #unbind method being called without calling #connection_completed.)
136
+ begin
137
+ EventMachine.connect( args[:host], args[:port], self) {|c|
138
+ # According to the EM docs, we will get here AFTER post_init is called.
139
+ c.args = args
140
+ c.set_comm_inactivity_timeout 60
141
+ }
142
+ rescue
143
+ # We'll get here on a connect error. This code mimics the effect
144
+ # of a call to invoke_internal_error. Would be great to DRY this up.
145
+ # (Actually, it may be that we never get here, if EM#connect catches
146
+ # its errors internally.)
147
+ d = EM::DefaultDeferrable.new
148
+ d.set_deferred_status(:failed, {:error=>[:connect, 500, "unable to connect to server"]})
149
+ d
150
+ end
151
+ =end
152
+ EventMachine.connect( args[:host], args[:port], self) {|c|
153
+ # According to the EM docs, we will get here AFTER post_init is called.
154
+ c.args = args
155
+ c.set_comm_inactivity_timeout 60
156
+ }
157
+ end
158
+
159
+ # :stopdoc:
160
+
161
+ attr_writer :args
162
+
163
+ def post_init
164
+ @return_values = OpenStruct.new
165
+ @return_values.start_time = Time.now
166
+ end
167
+
168
+ def connection_completed
169
+ @responder = :receive_signon
170
+ @msg = []
171
+ end
172
+
173
+ # We can get here in a variety of ways, all of them being failures unless
174
+ # the @succeeded flag is set. If a protocol success was recorded, then don't
175
+ # set a deferred success because the caller will already have done it
176
+ # (no need to wait until the connection closes to invoke the callbacks).
177
+ #
178
+ def unbind
179
+ unless @succeeded
180
+ @return_values.elapsed_time = Time.now - @return_values.start_time
181
+ @return_values.responder = @responder
182
+ @return_values.code = @code
183
+ @return_values.message = @msg
184
+ set_deferred_status(:failed, @return_values)
185
+ end
186
+ end
187
+
188
+ def receive_line ln
189
+ $>.puts ln if @args[:verbose]
190
+ @range = ln[0...1].to_i
191
+ @code = ln[0...3].to_i
192
+ @msg << ln[4..-1]
193
+ unless ln[3...4] == '-'
194
+ $>.puts @responder if @args[:verbose]
195
+ send @responder
196
+ @msg.clear
197
+ end
198
+ end
199
+
200
+ # We encountered an error from the server and will close the connection.
201
+ # Use the error and message the server returned.
202
+ #
203
+ def invoke_error
204
+ @return_values.elapsed_time = Time.now - @return_values.start_time
205
+ @return_values.responder = @responder
206
+ @return_values.code = @code
207
+ @return_values.message = @msg
208
+ set_deferred_status :failed, @return_values
209
+ send_data "QUIT\r\n"
210
+ close_connection_after_writing
211
+ end
212
+
213
+ # We encountered an error on our side of the protocol and will close the connection.
214
+ # Use an extra-protocol error code (900) and use the message from the caller.
215
+ #
216
+ def invoke_internal_error msg = "???"
217
+ @return_values.elapsed_time = Time.now - @return_values.start_time
218
+ @return_values.responder = @responder
219
+ @return_values.code = 900
220
+ @return_values.message = msg
221
+ set_deferred_status :failed, @return_values
222
+ send_data "QUIT\r\n"
223
+ close_connection_after_writing
224
+ end
225
+
226
+ def receive_signon
227
+ return invoke_error unless @range == 2
228
+ send_data "EHLO #{@args[:domain]}\r\n"
229
+ @responder = :receive_ehlo_response
230
+ end
231
+
232
+ def receive_ehlo_response
233
+ return invoke_error unless @range == 2
234
+ @server_caps = @msg
235
+ invoke_starttls
236
+ end
237
+
238
+ def invoke_starttls
239
+ if @args[:starttls]
240
+ # It would be more sociable to first ask if @server_caps contains
241
+ # the string "STARTTLS" before we invoke it, but hey, life's too short.
242
+ send_data "STARTTLS\r\n"
243
+ @responder = :receive_starttls_response
244
+ else
245
+ invoke_auth
246
+ end
247
+ end
248
+ def receive_starttls_response
249
+ return invoke_error unless @range == 2
250
+ start_tls
251
+ invoke_auth
252
+ end
253
+
254
+ # Perform an authentication. If the caller didn't request one, then fall through
255
+ # to the mail-from state.
256
+ def invoke_auth
257
+ if @args[:auth]
258
+ if @args[:auth][:type] == :plain
259
+ psw = @args[:auth][:password]
260
+ if psw.respond_to?(:call)
261
+ psw = psw.call
262
+ end
263
+ #str = Base64::encode64("\0#{@args[:auth][:username]}\0#{psw}").chomp
264
+ str = ["\0#{@args[:auth][:username]}\0#{psw}"].pack("m").chomp
265
+ send_data "AUTH PLAIN #{str}\r\n"
266
+ @responder = :receive_auth_response
267
+ else
268
+ return invoke_internal_error("unsupported auth type")
269
+ end
270
+ else
271
+ invoke_mail_from
272
+ end
273
+ end
274
+ def receive_auth_response
275
+ return invoke_error unless @range == 2
276
+ invoke_mail_from
277
+ end
278
+
279
+ def invoke_mail_from
280
+ send_data "MAIL FROM: <#{@args[:from]}>\r\n"
281
+ @responder = :receive_mail_from_response
282
+ end
283
+ def receive_mail_from_response
284
+ return invoke_error unless @range == 2
285
+ invoke_rcpt_to
286
+ end
287
+
288
+ def invoke_rcpt_to
289
+ @rcpt_responses ||= []
290
+ l = @rcpt_responses.length
291
+ to = @args[:to].is_a?(Array) ? @args[:to] : [@args[:to].to_s]
292
+ if l < to.length
293
+ send_data "RCPT TO: <#{to[l]}>\r\n"
294
+ @responder = :receive_rcpt_to_response
295
+ else
296
+ e = @rcpt_responses.select {|rr| rr.last == 2}
297
+ if e and e.length > 0
298
+ invoke_data
299
+ else
300
+ invoke_error
301
+ end
302
+ end
303
+ end
304
+ def receive_rcpt_to_response
305
+ @rcpt_responses << [@code, @msg, @range]
306
+ invoke_rcpt_to
307
+ end
308
+
309
+ def invoke_data
310
+ send_data "DATA\r\n"
311
+ @responder = :receive_data_response
312
+ end
313
+ def receive_data_response
314
+ return invoke_error unless @range == 3
315
+
316
+ # The data to send can be given either in @args[:content] (an array or string of raw data
317
+ # which MUST be in correct SMTP body format, including a trailing dot line), or a header and
318
+ # body given in @args[:header] and @args[:body].
319
+ #
320
+ if @args[:content]
321
+ send_data @args[:content].to_s
322
+ else
323
+ # The header can be a hash or an array.
324
+ if @args[:header].is_a?(Hash)
325
+ (@args[:header] || {}).each {|k,v| send_data "#{k}: #{v}\r\n" }
326
+ else
327
+ send_data @args[:header].to_s
328
+ end
329
+ send_data "\r\n"
330
+
331
+ if @args[:body].is_a?(Array)
332
+ @args[:body].each {|e| send_data e}
333
+ else
334
+ send_data @args[:body].to_s
335
+ end
336
+
337
+ send_data "\r\n.\r\n"
338
+ end
339
+
340
+ @responder = :receive_message_response
341
+ end
342
+ def receive_message_response
343
+ return invoke_error unless @range == 2
344
+ send_data "QUIT\r\n"
345
+ close_connection_after_writing
346
+ @succeeded = true
347
+ @return_values.elapsed_time = Time.now - @return_values.start_time
348
+ @return_values.responder = @responder
349
+ @return_values.code = @code
350
+ @return_values.message = @msg
351
+ set_deferred_status :succeeded, @return_values
352
+ end
353
+
354
+ # :startdoc:
355
+ end
356
+ end
357
+ end
@@ -0,0 +1,640 @@
1
+ #--
2
+ #
3
+ # Author:: Francis Cianfrocca (gmail: blackhedd)
4
+ # Homepage:: http://rubyeventmachine.com
5
+ # Date:: 16 July 2006
6
+ #
7
+ # See EventMachine and EventMachine::Connection for documentation and
8
+ # usage examples.
9
+ #
10
+ #----------------------------------------------------------------------------
11
+ #
12
+ # Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
13
+ # Gmail: blackhedd
14
+ #
15
+ # This program is free software; you can redistribute it and/or modify
16
+ # it under the terms of either: 1) the GNU General Public License
17
+ # as published by the Free Software Foundation; either version 2 of the
18
+ # License, or (at your option) any later version; or 2) Ruby's License.
19
+ #
20
+ # See the file COPYING for complete licensing information.
21
+ #
22
+ #---------------------------------------------------------------------------
23
+ #
24
+ #
25
+
26
+ module EventMachine
27
+ module Protocols
28
+
29
+ # This is a protocol handler for the server side of SMTP.
30
+ # It's NOT a complete SMTP server obeying all the semantics of servers conforming to
31
+ # RFC2821. Rather, it uses overridable method stubs to communicate protocol states
32
+ # and data to user code. User code is responsible for doing the right things with the
33
+ # data in order to get complete and correct SMTP server behavior.
34
+ #
35
+ # Simple SMTP server example:
36
+ #
37
+ # class EmailServer < EM::P::SmtpServer
38
+ # def receive_plain_auth(user, pass)
39
+ # true
40
+ # end
41
+ #
42
+ # def get_server_domain
43
+ # "mock.smtp.server.local"
44
+ # end
45
+ #
46
+ # def get_server_greeting
47
+ # "mock smtp server greets you with impunity"
48
+ # end
49
+ #
50
+ # def receive_sender(sender)
51
+ # current.sender = sender
52
+ # true
53
+ # end
54
+ #
55
+ # def receive_recipient(recipient)
56
+ # current.recipient = recipient
57
+ # true
58
+ # end
59
+ #
60
+ # def receive_message
61
+ # current.received = true
62
+ # current.completed_at = Time.now
63
+ #
64
+ # p [:received_email, current]
65
+ # @current = OpenStruct.new
66
+ # true
67
+ # end
68
+ #
69
+ # def receive_ehlo_domain(domain)
70
+ # @ehlo_domain = domain
71
+ # true
72
+ # end
73
+ #
74
+ # def receive_data_command
75
+ # current.data = ""
76
+ # true
77
+ # end
78
+ #
79
+ # def receive_data_chunk(data)
80
+ # current.data << data.join("\n")
81
+ # true
82
+ # end
83
+ #
84
+ # def receive_transaction
85
+ # if @ehlo_domain
86
+ # current.ehlo_domain = @ehlo_domain
87
+ # @ehlo_domain = nil
88
+ # end
89
+ # true
90
+ # end
91
+ #
92
+ # def current
93
+ # @current ||= OpenStruct.new
94
+ # end
95
+ #
96
+ # def self.start(host = 'localhost', port = 1025)
97
+ # require 'ostruct'
98
+ # @server = EM.start_server host, port, self
99
+ # end
100
+ #
101
+ # def self.stop
102
+ # if @server
103
+ # EM.stop_server @server
104
+ # @server = nil
105
+ # end
106
+ # end
107
+ #
108
+ # def self.running?
109
+ # !!@server
110
+ # end
111
+ # end
112
+ #
113
+ # EM.run{ EmailServer.start }
114
+ #
115
+ #--
116
+ # Useful paragraphs in RFC-2821:
117
+ # 4.3.2: Concise list of command-reply sequences, in essence a text representation
118
+ # of the command state-machine.
119
+ #
120
+ # STARTTLS is defined in RFC2487.
121
+ # Observe that there are important rules governing whether a publicly-referenced server
122
+ # (meaning one whose Internet address appears in public MX records) may require the
123
+ # non-optional use of TLS.
124
+ # Non-optional TLS does not apply to EHLO, NOOP, QUIT or STARTTLS.
125
+ class SmtpServer < EventMachine::Connection
126
+ include Protocols::LineText2
127
+
128
+ HeloRegex = /\AHELO\s*/i
129
+ EhloRegex = /\AEHLO\s*/i
130
+ QuitRegex = /\AQUIT/i
131
+ MailFromRegex = /\AMAIL FROM:\s*/i
132
+ RcptToRegex = /\ARCPT TO:\s*/i
133
+ DataRegex = /\ADATA/i
134
+ NoopRegex = /\ANOOP/i
135
+ RsetRegex = /\ARSET/i
136
+ VrfyRegex = /\AVRFY\s+/i
137
+ ExpnRegex = /\AEXPN\s+/i
138
+ HelpRegex = /\AHELP/i
139
+ StarttlsRegex = /\ASTARTTLS/i
140
+ AuthRegex = /\AAUTH\s+/i
141
+
142
+
143
+ # Class variable containing default parameters that can be overridden
144
+ # in application code.
145
+ # Individual objects of this class will make an instance-local copy of
146
+ # the class variable, so that they can be reconfigured on a per-instance
147
+ # basis.
148
+ #
149
+ # Chunksize is the number of data lines we'll buffer before
150
+ # sending them to the application. TODO, make this user-configurable.
151
+ #
152
+ @@parms = {
153
+ :chunksize => 4000,
154
+ :verbose => false
155
+ }
156
+ def self.parms= parms={}
157
+ @@parms.merge!(parms)
158
+ end
159
+
160
+
161
+
162
+ def initialize *args
163
+ super
164
+ @parms = @@parms
165
+ init_protocol_state
166
+ end
167
+
168
+ def parms= parms={}
169
+ @parms.merge!(parms)
170
+ end
171
+
172
+ # In SMTP, the server talks first. But by a (perhaps flawed) axiom in EM,
173
+ # #post_init will execute BEFORE the block passed to #start_server, for any
174
+ # given accepted connection. Since in this class we'll probably be getting
175
+ # a lot of initialization parameters, we want the guts of post_init to
176
+ # run AFTER the application has initialized the connection object. So we
177
+ # use a spawn to schedule the post_init to run later.
178
+ # It's a little weird, I admit. A reasonable alternative would be to set
179
+ # parameters as a class variable and to do that before accepting any connections.
180
+ #
181
+ # OBSOLETE, now we have @@parms. But the spawn is nice to keep as an illustration.
182
+ #
183
+ def post_init
184
+ #send_data "220 #{get_server_greeting}\r\n" (ORIGINAL)
185
+ #(EM.spawn {|x| x.send_data "220 #{x.get_server_greeting}\r\n"}).notify(self)
186
+ (EM.spawn {|x| x.send_server_greeting}).notify(self)
187
+ end
188
+
189
+ def send_server_greeting
190
+ send_data "220 #{get_server_greeting}\r\n"
191
+ end
192
+
193
+ def receive_line ln
194
+ @@parms[:verbose] and $>.puts ">>> #{ln}"
195
+
196
+ return process_data_line(ln) if @state.include?(:data)
197
+ return process_auth_line(ln) if @state.include?(:auth_incomplete)
198
+
199
+ case ln
200
+ when EhloRegex
201
+ process_ehlo $'.dup
202
+ when HeloRegex
203
+ process_helo $'.dup
204
+ when MailFromRegex
205
+ process_mail_from $'.dup
206
+ when RcptToRegex
207
+ process_rcpt_to $'.dup
208
+ when DataRegex
209
+ process_data
210
+ when RsetRegex
211
+ process_rset
212
+ when VrfyRegex
213
+ process_vrfy
214
+ when ExpnRegex
215
+ process_expn
216
+ when HelpRegex
217
+ process_help
218
+ when NoopRegex
219
+ process_noop
220
+ when QuitRegex
221
+ process_quit
222
+ when StarttlsRegex
223
+ process_starttls
224
+ when AuthRegex
225
+ process_auth $'.dup
226
+ else
227
+ process_unknown
228
+ end
229
+ end
230
+
231
+ # TODO - implement this properly, the implementation is a stub!
232
+ def process_vrfy
233
+ send_data "250 Ok, but unimplemented\r\n"
234
+ end
235
+ # TODO - implement this properly, the implementation is a stub!
236
+ def process_help
237
+ send_data "250 Ok, but unimplemented\r\n"
238
+ end
239
+ # TODO - implement this properly, the implementation is a stub!
240
+ def process_expn
241
+ send_data "250 Ok, but unimplemented\r\n"
242
+ end
243
+
244
+ #--
245
+ # This is called at several points to restore the protocol state
246
+ # to a pre-transaction state. In essence, we "forget" having seen
247
+ # any valid command except EHLO and STARTTLS.
248
+ # We also have to callback user code, in case they're keeping track
249
+ # of senders, recipients, and whatnot.
250
+ #
251
+ # We try to follow the convention of avoiding the verb "receive" for
252
+ # internal method names except receive_line (which we inherit), and
253
+ # using only receive_xxx for user-overridable stubs.
254
+ #
255
+ # init_protocol_state is called when we initialize the connection as
256
+ # well as during reset_protocol_state. It does NOT call the user
257
+ # override method. This enables us to promise the users that they
258
+ # won't see the overridable fire except after EHLO and RSET, and
259
+ # after a message has been received. Although the latter may be wrong.
260
+ # The standard may allow multiple DATA segments with the same set of
261
+ # senders and recipients.
262
+ #
263
+ def reset_protocol_state
264
+ init_protocol_state
265
+ s,@state = @state,[]
266
+ @state << :starttls if s.include?(:starttls)
267
+ @state << :ehlo if s.include?(:ehlo)
268
+ receive_transaction
269
+ end
270
+ def init_protocol_state
271
+ @state ||= []
272
+ end
273
+
274
+
275
+ #--
276
+ # EHLO/HELO is always legal, per the standard. On success
277
+ # it always clears buffers and initiates a mail "transaction."
278
+ # Which means that a MAIL FROM must follow.
279
+ #
280
+ # Per the standard, an EHLO/HELO or a RSET "initiates" an email
281
+ # transaction. Thereafter, MAIL FROM must be received before
282
+ # RCPT TO, before DATA. Not sure what this specific ordering
283
+ # achieves semantically, but it does make it easier to
284
+ # implement. We also support user-specified requirements for
285
+ # STARTTLS and AUTH. We make it impossible to proceed to MAIL FROM
286
+ # without fulfilling tls and/or auth, if the user specified either
287
+ # or both as required. We need to check the extension standard
288
+ # for auth to see if a credential is discarded after a RSET along
289
+ # with all the rest of the state. We'll behave as if it is.
290
+ # Now clearly, we can't discard tls after its been negotiated
291
+ # without dropping the connection, so that flag doesn't get cleared.
292
+ #
293
+ def process_ehlo domain
294
+ if receive_ehlo_domain domain
295
+ send_data "250-#{get_server_domain}\r\n"
296
+ if @@parms[:starttls]
297
+ send_data "250-STARTTLS\r\n"
298
+ end
299
+ if @@parms[:auth]
300
+ send_data "250-AUTH PLAIN\r\n"
301
+ end
302
+ send_data "250-NO-SOLICITING\r\n"
303
+ # TODO, size needs to be configurable.
304
+ send_data "250 SIZE 20000000\r\n"
305
+ reset_protocol_state
306
+ @state << :ehlo
307
+ else
308
+ send_data "550 Requested action not taken\r\n"
309
+ end
310
+ end
311
+
312
+ def process_helo domain
313
+ if receive_ehlo_domain domain.dup
314
+ send_data "250 #{get_server_domain}\r\n"
315
+ reset_protocol_state
316
+ @state << :ehlo
317
+ else
318
+ send_data "550 Requested action not taken\r\n"
319
+ end
320
+ end
321
+
322
+ def process_quit
323
+ send_data "221 Ok\r\n"
324
+ close_connection_after_writing
325
+ end
326
+
327
+ def process_noop
328
+ send_data "250 Ok\r\n"
329
+ end
330
+
331
+ def process_unknown
332
+ send_data "500 Unknown command\r\n"
333
+ end
334
+
335
+ #--
336
+ # So far, only AUTH PLAIN is supported but we should do at least LOGIN as well.
337
+ # TODO, support clients that send AUTH PLAIN with no parameter, expecting a 3xx
338
+ # response and a continuation of the auth conversation.
339
+ #
340
+ def process_auth str
341
+ if @state.include?(:auth)
342
+ send_data "503 auth already issued\r\n"
343
+ elsif str =~ /\APLAIN\s?/i
344
+ if $'.length == 0
345
+ # we got a partial response, so let the client know to send the rest
346
+ @state << :auth_incomplete
347
+ send_data("334 \r\n")
348
+ else
349
+ # we got the initial response, so go ahead & process it
350
+ process_auth_line($')
351
+ end
352
+ #elsif str =~ /\ALOGIN\s+/i
353
+ else
354
+ send_data "504 auth mechanism not available\r\n"
355
+ end
356
+ end
357
+
358
+ def process_auth_line(line)
359
+ plain = line.unpack("m").first
360
+ discard,user,psw = plain.split("\000")
361
+ if receive_plain_auth user,psw
362
+ send_data "235 authentication ok\r\n"
363
+ @state << :auth
364
+ else
365
+ send_data "535 invalid authentication\r\n"
366
+ end
367
+ @state.delete :auth_incomplete
368
+ end
369
+
370
+ #--
371
+ # Unusually, we can deal with a Deferrable returned from the user application.
372
+ # This was added to deal with a special case in a particular application, but
373
+ # it would be a nice idea to add it to the other user-code callbacks.
374
+ #
375
+ def process_data
376
+ unless @state.include?(:rcpt)
377
+ send_data "503 Operation sequence error\r\n"
378
+ else
379
+ succeeded = proc {
380
+ send_data "354 Send it\r\n"
381
+ @state << :data
382
+ @databuffer = []
383
+ }
384
+ failed = proc {
385
+ send_data "550 Operation failed\r\n"
386
+ }
387
+
388
+ d = receive_data_command
389
+
390
+ if d.respond_to?(:callback)
391
+ d.callback(&succeeded)
392
+ d.errback(&failed)
393
+ else
394
+ (d ? succeeded : failed).call
395
+ end
396
+ end
397
+ end
398
+
399
+ def process_rset
400
+ reset_protocol_state
401
+ receive_reset
402
+ send_data "250 Ok\r\n"
403
+ end
404
+
405
+ def unbind
406
+ connection_ended
407
+ end
408
+
409
+ #--
410
+ # STARTTLS may not be issued before EHLO, or unless the user has chosen
411
+ # to support it.
412
+ # TODO, must support user-supplied certificates.
413
+ #
414
+ def process_starttls
415
+ if @@parms[:starttls]
416
+ if @state.include?(:starttls)
417
+ send_data "503 TLS Already negotiated\r\n"
418
+ elsif ! @state.include?(:ehlo)
419
+ send_data "503 EHLO required before STARTTLS\r\n"
420
+ else
421
+ send_data "220 Start TLS negotiation\r\n"
422
+ start_tls
423
+ @state << :starttls
424
+ end
425
+ else
426
+ process_unknown
427
+ end
428
+ end
429
+
430
+
431
+ #--
432
+ # Requiring TLS is touchy, cf RFC2784.
433
+ # Requiring AUTH seems to be much more reasonable.
434
+ # We don't currently support any notion of deriving an authentication from the TLS
435
+ # negotiation, although that would certainly be reasonable.
436
+ # We DON'T allow MAIL FROM to be given twice.
437
+ # We DON'T enforce all the various rules for validating the sender or
438
+ # the reverse-path (like whether it should be null), and notifying the reverse
439
+ # path in case of delivery problems. All of that is left to the calling application.
440
+ #
441
+ def process_mail_from sender
442
+ if (@@parms[:starttls]==:required and !@state.include?(:starttls))
443
+ send_data "550 This server requires STARTTLS before MAIL FROM\r\n"
444
+ elsif (@@parms[:auth]==:required and !@state.include?(:auth))
445
+ send_data "550 This server requires authentication before MAIL FROM\r\n"
446
+ elsif @state.include?(:mail_from)
447
+ send_data "503 MAIL already given\r\n"
448
+ else
449
+ unless receive_sender sender
450
+ send_data "550 sender is unacceptable\r\n"
451
+ else
452
+ send_data "250 Ok\r\n"
453
+ @state << :mail_from
454
+ end
455
+ end
456
+ end
457
+
458
+ #--
459
+ # Since we require :mail_from to have been seen before we process RCPT TO,
460
+ # we don't need to repeat the tests for TLS and AUTH.
461
+ # Note that we don't remember or do anything else with the recipients.
462
+ # All of that is on the user code.
463
+ # TODO: we should enforce user-definable limits on the total number of
464
+ # recipients per transaction.
465
+ # We might want to make sure that a given recipient is only seen once, but
466
+ # for now we'll let that be the user's problem.
467
+ #
468
+ # User-written code can return a deferrable from receive_recipient.
469
+ #
470
+ def process_rcpt_to rcpt
471
+ unless @state.include?(:mail_from)
472
+ send_data "503 MAIL is required before RCPT\r\n"
473
+ else
474
+ succeeded = proc {
475
+ send_data "250 Ok\r\n"
476
+ @state << :rcpt unless @state.include?(:rcpt)
477
+ }
478
+ failed = proc {
479
+ send_data "550 recipient is unacceptable\r\n"
480
+ }
481
+
482
+ d = receive_recipient rcpt
483
+
484
+ if d.respond_to?(:set_deferred_status)
485
+ d.callback(&succeeded)
486
+ d.errback(&failed)
487
+ else
488
+ (d ? succeeded : failed).call
489
+ end
490
+
491
+ =begin
492
+ unless receive_recipient rcpt
493
+ send_data "550 recipient is unacceptable\r\n"
494
+ else
495
+ send_data "250 Ok\r\n"
496
+ @state << :rcpt unless @state.include?(:rcpt)
497
+ end
498
+ =end
499
+ end
500
+ end
501
+
502
+
503
+ # Send the incoming data to the application one chunk at a time, rather than
504
+ # one line at a time. That lets the application be a little more flexible about
505
+ # storing to disk, etc.
506
+ # Since we clear the chunk array every time we submit it, the caller needs to be
507
+ # aware to do things like dup it if he wants to keep it around across calls.
508
+ #
509
+ # DON'T reset the transaction upon disposition of the incoming message.
510
+ # This means another DATA command can be accepted with the same sender and recipients.
511
+ # If the client wants to reset, he can call RSET.
512
+ # Not sure whether the standard requires a transaction-reset at this point, but it
513
+ # appears not to.
514
+ #
515
+ # User-written code can return a Deferrable as a response from receive_message.
516
+ #
517
+ def process_data_line ln
518
+ if ln == "."
519
+ if @databuffer.length > 0
520
+ receive_data_chunk @databuffer
521
+ @databuffer.clear
522
+ end
523
+
524
+
525
+ succeeded = proc {
526
+ send_data "250 Message accepted\r\n"
527
+ }
528
+ failed = proc {
529
+ send_data "550 Message rejected\r\n"
530
+ }
531
+
532
+ d = receive_message
533
+
534
+ if d.respond_to?(:set_deferred_status)
535
+ d.callback(&succeeded)
536
+ d.errback(&failed)
537
+ else
538
+ (d ? succeeded : failed).call
539
+ end
540
+
541
+ @state.delete :data
542
+ else
543
+ # slice off leading . if any
544
+ ln.slice!(0...1) if ln[0] == 46
545
+ @databuffer << ln
546
+ if @databuffer.length > @@parms[:chunksize]
547
+ receive_data_chunk @databuffer
548
+ @databuffer.clear
549
+ end
550
+ end
551
+ end
552
+
553
+
554
+ #------------------------------------------
555
+ # Everything from here on can be overridden in user code.
556
+
557
+ # The greeting returned in the initial connection message to the client.
558
+ def get_server_greeting
559
+ "EventMachine SMTP Server"
560
+ end
561
+ # The domain name returned in the first line of the response to a
562
+ # successful EHLO or HELO command.
563
+ def get_server_domain
564
+ "Ok EventMachine SMTP Server"
565
+ end
566
+
567
+ # A false response from this user-overridable method will cause a
568
+ # 550 error to be returned to the remote client.
569
+ #
570
+ def receive_ehlo_domain domain
571
+ true
572
+ end
573
+
574
+ # Return true or false to indicate that the authentication is acceptable.
575
+ def receive_plain_auth user, password
576
+ true
577
+ end
578
+
579
+ # Receives the argument of the MAIL FROM command. Return false to
580
+ # indicate to the remote client that the sender is not accepted.
581
+ # This can only be successfully called once per transaction.
582
+ #
583
+ def receive_sender sender
584
+ true
585
+ end
586
+
587
+ # Receives the argument of a RCPT TO command. Can be given multiple
588
+ # times per transaction. Return false to reject the recipient.
589
+ #
590
+ def receive_recipient rcpt
591
+ true
592
+ end
593
+
594
+ # Sent when the remote peer issues the RSET command.
595
+ # Since RSET is not allowed to fail (according to the protocol),
596
+ # we ignore any return value from user overrides of this method.
597
+ #
598
+ def receive_reset
599
+ end
600
+
601
+ # Sent when the remote peer has ended the connection.
602
+ #
603
+ def connection_ended
604
+ end
605
+
606
+ # Called when the remote peer sends the DATA command.
607
+ # Returning false will cause us to send a 550 error to the peer.
608
+ # This can be useful for dealing with problems that arise from processing
609
+ # the whole set of sender and recipients.
610
+ #
611
+ def receive_data_command
612
+ true
613
+ end
614
+
615
+ # Sent when data from the remote peer is available. The size can be controlled
616
+ # by setting the :chunksize parameter. This call can be made multiple times.
617
+ # The goal is to strike a balance between sending the data to the application one
618
+ # line at a time, and holding all of a very large message in memory.
619
+ #
620
+ def receive_data_chunk data
621
+ @smtps_msg_size ||= 0
622
+ @smtps_msg_size += data.join.length
623
+ STDERR.write "<#{@smtps_msg_size}>"
624
+ end
625
+
626
+ # Sent after a message has been completely received. User code
627
+ # must return true or false to indicate whether the message has
628
+ # been accepted for delivery.
629
+ def receive_message
630
+ @@parms[:verbose] and $>.puts "Received complete message"
631
+ true
632
+ end
633
+
634
+ # This is called when the protocol state is reset. It happens
635
+ # when the remote client calls EHLO/HELO or RSET.
636
+ def receive_transaction
637
+ end
638
+ end
639
+ end
640
+ end