Pastable version of AJAX Chat Socket Server

<div style="overflow:auto;border:solid 1px #ccc;background:#000;color:#F8F8F8">
 <div class="section">
 
 <pre style="float:left;margin:0 10px;border-right:0;color:#666;">1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400</pre>
 <pre class="sunburst">#!/usr/bin/env ruby
 
# Simple Ruby XML Socket Server
#
# This is a a simple socket server implementation in ruby
# to communicate with flash clients via Flash XML Sockets.
# 
# The socket code is based on the tutorial
# &quot;Sockets programming in Ruby&quot;
# by M. Tim Jones (mtj@mtjones.com).
#
# Date:: Tue, 05 Mar 2008
# Author:: Sebastian Tschan, https://blueimp.net
# License:: GNU Affero General Public License

# Include socket library:
require 'socket'
# Include XML libraries:
require 'rexml/document'
require 'rexml/streamlistener'

# XML Stream Handler class used to parse chat messages:
class XMLStreamHandler
 attr_reader :type,:chat_id,:user_id,:reg_id,:channel_id,:channel_ids
 # Called when an opening tag (including attributes) is parsed:
 def tag_start name, attrs
 case name
 when 'root'
 # root messages are broadcast messages:
 @type = :message
 @chat_id = attrs['chatID']
 @channel_id = attrs['channelID']
 throw :break
 when 'register'
 # register messages are sent by chat clients:
 @type = :register
 @chat_id = attrs['chatID']
 @user_id = attrs['userID']
 @reg_id = attrs['regID']
 throw :break
 when 'authenticate'
 # authenticate messages are sent by the chat server client:
 @type = :authenticate
 @chat_id = attrs['chatID']
 @user_id = attrs['userID']
 @reg_id = attrs['regID']
 @channel_ids = Array::new
 when 'channel'
 # authenticate messages contain channel tags:
 if @channel_ids
 @channel_ids.push(attrs['id'])
 else
 throw :break
 end
 when 'policy-file-request'
 # policy-file-requests are sent by flash clients for cross-domain authentication:
 @type = :policy_file_request
 throw :break
 else
 throw :break
 end
 end
 # Called when a closing tag is parsed:
 def tag_end name
 if name == 'authenticate'
 throw :break
 end
 end
 def text text
 # Called on text between tags
 end
 # Called when cdata is parsed:
 alias cdata text
end

# Socket Server class:
class SocketServer

def initialize(config_file)
 # List of configuration settings:
 @config = Hash::new
 # Initialize default settings:
 initialize_default_properties
 if config_file
 # Load settings from configuration file:
 load_properties_from_file(config_file)
 end
 # Sockets list:
 @sockets = Array::new
 # Clients list:
 @clients = Hash::new
 # Chats list, used to distinguish between different chat installations (contains channels list):
 @chats = Hash::new
 # Initialize server socket:
 initialize_server_socket
 if @server_socket
 # Log server start (STDOUT.flush prevents output buffering):
 puts &quot;#{Time.now}\tServer started on Port #{@config[:server_port].to_s} ...&quot;; STDOUT.flush
 begin
 # Start the server:
 run
 rescue SignalException
 # Controlled stop:
 ensure
 for socket in @sockets
 if socket != @server_socket
 # Disconnect all clients:
 handle_client_disconnection(socket, false)
 end
 end
 @sockets = nil
 @clients = nil
 # Log server stop:
 puts &quot;#{Time.now}\tServer stopped.&quot;; STDOUT.flush
 end
 end
 end

def run
 	# Endless loop:
 while 1
 		# Blocking select call. The first three parameters are arrays of IO objects or nil.
 # The last parameter is to set a timeout in seconds to force select to return
 # if no event has occurred on any of the given IO object arrays.
 res = select(@sockets, nil, nil, nil)
 		if res != nil then
 # Iterate through the tagged read descriptors:
 			for socket in res[0]
 # Received a connect to the server socket:
 				if socket == @server_socket then
 					accept_new_connection
 else
 # Received something on a client socket:
 					if socket.eof? then
 # Handle client disconnection:
 handle_client_disconnection(socket)
 					else
 # Handle client input data:
 handle_client_input(socket, socket.gets(@config[:eol]))
 					end
 				end
 			end
 		end
 	end
 end

private

def initialize_default_properties
 # Server address (empty = bind to all available interfaces):
 @config[:server_address] = ''
 # Server port:
 @config[:server_port] = 1935
 # Comma-separated list of clients allowed to broadcast (allows all if empty):
 @config[:broadcast_clients] = ''
 # Defines if broadcast is sent to broadcasting client:
 @config[:broadcast_self] = false
 # Maximum number of clients (0 allows an unlimited number of clients):
 @config[:max_clients] = 0
 # Comma-separated list of domains from which downloaded Flash clients are allowed to connect (* allows all domains):
 @config[:allow_access_from] = '*'
 # Defines the cross-domain-policy string sent to Flash clients as response to a policy-file-request:
 @config[:cross_domain_policy] = '&lt;cross-domain-policy&gt;&lt;allow-access-from domain=&quot;'+@config[:allow_access_from]+'&quot; to-ports=&quot;'+@config[:server_port].to_s+'&quot;/&gt;&lt;/cross-domain-policy&gt;'
 # EOL (End Of Line) character used by Flash XML Socket communication (a null-byte):
 @config[:eol] = &quot;\0&quot;
 # Log level (0 logs only errors and server start/stop, 1 logs client connections, 2 logs all messages but no broadcast content, 3 logs everything):
 @config[:log_level] = 0
 end

def load_properties_from_file(config_file)
 # Open the config file and go through each line:
 File.open(config_file, 'r') do |file|
 file.read.each_line do |line|
 # Remove trailing whitespace from the line:
 line.strip!
 # Get the position of the first &quot;=&quot;:
 i = line.index('=')
 # Check if line is not a comment and a valid property:
 if (!line.empty? &amp;&amp; line[0] != ?# &amp;&amp; i &gt; 0)
 # Add the configuration option to the config hash:
 key = line[0..i - 1].strip
 value = line[i + 1..-1].strip
 # Parse boolean values:
 if value.eql?('false')
 @config[key.to_sym] = false
 elsif value.eql?('true')
 @config[key.to_sym] = true
 # Parse integer numbers:
 elsif value.to_i.to_s.eql?(value)
 @config[key.to_sym] = value.to_i
 # Parse floating point numbers:
 elsif value.to_f.to_s.eql?(value)
 @config[key.to_sym] = value.to_f
 # Parse string values:
 else
 @config[key.to_sym] = value
 end
 end
 end 
 end
 if @config[:eol].empty?
 # Use default EOL if configuration option is empty:
 @config[:eol] = $/
 end
 end

def initialize_server_socket
 begin
 # The server socket, allowing connections from any interface and bound to the given port number:
 @server_socket = TCPServer.new(@config[:server_address], @config[:server_port].to_i)
 # Enable reuse of the server address (e.g. for rapid restarts of the server):
 @server_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
 # Add the server socket to the sockets list:
 @sockets.push(@server_socket)
 rescue Exception =&gt; error
 # Log initialization failure:
 puts &quot;#{Time.now}\tFailed to initialize Server on Port #{@config[:server_port].to_s}: #{error}.&quot;; STDOUT.flush
 end
 end

def accept_new_connection
 begin
 # Accept the client connection:
 socket = @server_socket.accept
 # Retrieve IP and Port:
 ip = socket.peeraddr[3]
 port = socket.peeraddr[1]
 # Check if we have reached the maximum number of connected clients (always accept the broadcast clients):
 if @config[:max_clients].to_i == 0 || @clients.size &lt; @config[:max_clients].to_i || !@config[:broadcast_clients].empty? &amp;&amp; @config[:broadcast_clients].include?(ip)
 # Add the accepted socket connection to the socket list:
 @sockets.push(socket)
 # Create a new Hash to store the client data:
 client = Hash::new
 client[:id] = &quot;[#{ip}]:#{port}&quot;
 # Check if the client is allowed to broadcast:
 if @config[:broadcast_clients].empty? || @config[:broadcast_clients].include?(ip)
 client[:allowed_to_broadcast] = true
 else
 client[:allowed_to_broadcast] = false
 end
 # Add the client to the clients list: 
 @clients[socket] = client
 if @config[:log_level].to_i &gt; 0
 # Log client connection and the number of connected clients:
 puts &quot;#{Time.now}\t#{client[:id]} Connects\t(#{@clients.size} connected)&quot;; STDOUT.flush
 end
 else
 # Close the socket connection:
 socket.close
 end
 rescue
 # Client disconnected before the address information (IP, Port) could be retrieved.
 end
 end

def handle_client_disconnection(client_socket, delete_socket=true)
 # Retrieve the client ID for the current socket:
 client_id = @clients[client_socket][:id]
 begin
 # Close the socket connection:
 client_socket.close
 rescue
 # Rescue if closing the socket fails
 end
 if delete_socket
 # Remove the socket from the sockets list:
 @sockets.delete(client_socket)
 end
 # Remove the client ID from the clients list:
 @clients.delete(client_socket)
 if @config[:log_level].to_i &gt; 0
 # Log client disconnection and the number of connected clients:
 puts &quot;#{Time.now}\t#{client_id} Disconnects\t(#{@clients.size} connected)&quot;; STDOUT.flush
 end
 end

def handle_client_input(client_socket, str)
 # Create a new XML stream handler:
 handler = XMLStreamHandler.new
 begin 
 # As soon as the parser has found the relevant information it throws a :break symbol:
 catch :break do
 # Parse the given input string for XML messages:
 REXML::Document.parse_stream(str, handler)
 end
 # The handler stores a type property to define the parsed XML message:
 case handler.type
 when :message
 handle_broadcast_message(client_socket, handler.chat_id, handler.channel_id, str)
 when :register
 handle_client_registration(client_socket, handler.chat_id, handler.user_id, handler.reg_id)
 when :authenticate
 handle_client_authentication(client_socket, handler.chat_id, handler.user_id, handler.reg_id, handler.channel_ids)
 when :policy_file_request
 handle_policy_file_request(client_socket)
 end 
 rescue Exception =&gt; error
 # Rescue if parsing the client input fails and log the error message:
 puts &quot;#{Time.now}\t#{@clients[client_socket][:id]} Client Input Error:#{error.to_s.dump}&quot;; STDOUT.flush
 end
 end
 
 def handle_broadcast_message(client_socket, chat_id, channel_id, str)
 # Check if the_client is allowed to broadcast:
 if @clients[client_socket][:allowed_to_broadcast]
 # Check if the chat and channel have been registered:
 if @chats[chat_id] &amp;&amp; (@chats[chat_id][channel_id] || @chats[chat_id]['ALL'])
 # Go through the sockets list:
 @sockets.each do |socket|
 # Skip the server socket and skip the the client socket if broadcast is not to be sent to self:
 if socket != @server_socket &amp;&amp; (@config[:broadcast_self] || socket != client_socket)
 # Only write to clients registered to the given channel or to the &quot;ALL&quot; channel:
 if @chats[chat_id]['ALL']
 reg_id = @chats[chat_id]['ALL'][@clients[socket][:user_id]]
 end
 if !reg_id &amp;&amp; @chats[chat_id][channel_id]
 reg_id = @chats[chat_id][channel_id][@clients[socket][:user_id]]
 end
 # Check if the reg_id stored for the given channel and user_id matches the clients reg_id:
 if reg_id &amp;&amp; reg_id.eql?(@clients[socket][:reg_id])
 begin
 # Write the broadcast message on the socket connection:
 socket.write(str)
 rescue
 # Rescue if writing to the socket fails
 end
 end
 end
 end
 end
 if @config[:log_level].to_i &gt; 2
 # Log the message sent by the broadcast client:
 puts &quot;#{Time.now}\t#{@clients[client_socket][:id]} Chat:#{chat_id.to_s.dump} Channel:#{channel_id.to_s.dump} Message:#{str.to_s.dump}&quot;; STDOUT.flush
 elsif @config[:log_level].to_i &gt; 1
 # Log the message sent by the broadcast client:
 puts &quot;#{Time.now}\t#{@clients[client_socket][:id]} Chat:#{chat_id.to_s.dump} Channel:#{channel_id.to_s.dump} Message&quot;; STDOUT.flush
 end
 end
 end
 
 def handle_client_registration(client_socket, chat_id, user_id, reg_id)
 # Save the chat_id, use_id and reg_id as client properties:
 @clients[client_socket][:chat_id] = chat_id
 @clients[client_socket][:user_id] = user_id
 @clients[client_socket][:reg_id] = reg_id
 if @config[:log_level].to_i &gt; 1
 # Log the client registration:
 puts &quot;#{Time.now}\t#{@clients[client_socket][:id]} Chat:#{chat_id.to_s.dump} User:#{user_id.to_s.dump} Reg:#{reg_id.to_s.dump}&quot;; STDOUT.flush
 end
 end
 
 def handle_client_authentication(client_socket, chat_id, user_id, reg_id, channel_ids)
 # Only the broadcast clients may send authentication messages:
 if @clients[client_socket][:allowed_to_broadcast]
 # Create a new chat item if not found for the given chat_id:
 if !@chats[chat_id]
 @chats[chat_id] = Hash.new
 end
 # Go through the list of channels for the given chat:
 @chats[chat_id].each_key do |key|
 # Delete all items for the given user on all channels of the given chat:
 @chats[chat_id][key].delete(user_id)
 # If the chat channel is empty, delete the channel item:
 if @chats[chat_id][key].size == 0
 @chats[chat_id].delete(key)
 end
 end
 # Go through the list of authenticated channel_ids:
 channel_ids.each do |channel_id|
 # Create a new channel item if not found for the current channel_id (and the given chat_id):
 if !@chats[chat_id][channel_id]
 @chats[chat_id][channel_id] = Hash.new
 end
 # Add a user item of the given user_id with the given reg_id to the current channel:
 @chats[chat_id][channel_id][user_id] = reg_id
 end
 if @config[:log_level].to_i &gt; 1
 # Log the client authentication:
 puts &quot;#{Time.now}\t#{@clients[client_socket][:id]} Chat:#{chat_id.to_s.dump} User:#{user_id.to_s.dump} Auth:#{reg_id.to_s.dump} Channels:#{channel_ids.join(',').dump}&quot;; STDOUT.flush
 end
 end
 end
 
 def handle_policy_file_request(client_socket)
 begin
 # Write the cross-domain-policy to the Flash client:
 client_socket.write(@config[:cross_domain_policy]+@config[:eol])
 rescue
 # Rescue if writing to the socket fails
 end
 if @config[:log_level].to_i &gt; 1
 # Log the policy-file-request:
 puts &quot;#{Time.now}\t#{@clients[client_socket][:id]} Policy-File-Request&quot;; STDOUT.flush
 end
 end

end

# Start the socket server with the first command line argument as configuration file:
SocketServer.new($*[0])
</pre>
 </div>
 </div>

Refactor :my => 'code'

Recent

Popular

Pastable version of AJAX Chat Socket Server