aboutsummaryrefslogtreecommitdiffstats
path: root/library/ajaxchat/chat/socket
diff options
context:
space:
mode:
Diffstat (limited to 'library/ajaxchat/chat/socket')
-rw-r--r--library/ajaxchat/chat/socket/.htaccess4
-rw-r--r--library/ajaxchat/chat/socket/server71
-rw-r--r--library/ajaxchat/chat/socket/server.conf22
-rw-r--r--library/ajaxchat/chat/socket/server.rb400
4 files changed, 0 insertions, 497 deletions
diff --git a/library/ajaxchat/chat/socket/.htaccess b/library/ajaxchat/chat/socket/.htaccess
deleted file mode 100644
index 91e386dc9..000000000
--- a/library/ajaxchat/chat/socket/.htaccess
+++ /dev/null
@@ -1,4 +0,0 @@
-AuthType Basic
-AuthName "Forbidden"
-AuthUserFile /dev/null
-require user nobody \ No newline at end of file
diff --git a/library/ajaxchat/chat/socket/server b/library/ajaxchat/chat/socket/server
deleted file mode 100644
index 806b5ef74..000000000
--- a/library/ajaxchat/chat/socket/server
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/bin/bash
-
-# Simple bash script to start and stop a service
-# Works without access to /var/run/ or ps and pidof commands
-#
-# Date:: Wed, 09 Jan 2008
-# Author:: Sebastian Tschan, https://blueimp.net
-# License:: GNU Affero General Public License
-
-
-SERVICE_TITLE=Service
-SERVICE_BASENAME=${0##*/}
-SERVICE_DIR=${0%/$SERVICE_BASENAME}
-SERVICE_COMMAND=$SERVICE_DIR/$SERVICE_BASENAME.rb
-SERVICE_CONFIG=$SERVICE_DIR/$SERVICE_BASENAME.conf
-SERVICE_LOG=$SERVICE_DIR/$SERVICE_BASENAME.log
-SERVICE_PIDFILE=$SERVICE_DIR/$SERVICE_BASENAME.pid
-
-
-function start
-{
- if [ -f $SERVICE_PIDFILE ]
- then
- echo "PID file $SERVICE_PIDFILE found - $SERVICE_TITLE already running?"
- else
- $SERVICE_COMMAND $SERVICE_CONFIG >> $SERVICE_LOG & echo "Started $SERVICE_TITLE..."
- PID=$!
- echo $PID > $SERVICE_PIDFILE
- fi
- exit 0
-}
-
-function stop
-{
- if [ -f $SERVICE_PIDFILE ]
- then
- PID=`cat $SERVICE_PIDFILE`
- kill -TERM $PID
- rm -f $SERVICE_PIDFILE
- echo "Stopped $SERVICE_TITLE."
- else
- echo "PID file $SERVICE_PIDFILE not found - $SERVICE_TITLE not running?"
- fi
- exit 0
-}
-
-function main
-{
- for arg in $@
- do
- if [ $arg == "start" ]
- then
- start
- elif [ $arg == "stop" ]
- then
- stop
- else
- echo "Unknown argument:" $arg
- echo "Usage: $0 [start|stop]"
- exit 0
- fi
- done
-
- echo "Missing argument."
- echo "Usage: $0 [start|stop]"
- exit 0
-}
-
-
-# Script execution:
-main $@ \ No newline at end of file
diff --git a/library/ajaxchat/chat/socket/server.conf b/library/ajaxchat/chat/socket/server.conf
deleted file mode 100644
index 47c6849da..000000000
--- a/library/ajaxchat/chat/socket/server.conf
+++ /dev/null
@@ -1,22 +0,0 @@
-
-# Server address (leave empty to bind to all available interfaces):
-server_address=
-
-# Server port:
-server_port=1935
-
-# Comma-separated list of clients allowed to broadcast (allows all if empty):
-broadcast_clients=127.0.0.1,::1
-
-# Maximum number of clients (0 allows an unlimited number of clients):
-max_clients=0
-
-# Comma-separated list of domains from which downloaded Flash clients are allowed to connect (* allows all domains):
-allow_access_from=*
-
-# Log level:
-# 0 = log only errors and server start/stop
-# 1 = log client connections
-# 2 = log all messages but no broadcast content
-# 3 = log everything
-log_level=0
diff --git a/library/ajaxchat/chat/socket/server.rb b/library/ajaxchat/chat/socket/server.rb
deleted file mode 100644
index c2f532c84..000000000
--- a/library/ajaxchat/chat/socket/server.rb
+++ /dev/null
@@ -1,400 +0,0 @@
-#!/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
-# "Sockets programming in Ruby"
-# 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 "#{Time.now}\tServer started on Port #{@config[:server_port].to_s} ..."; 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 "#{Time.now}\tServer stopped."; 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] = '<cross-domain-policy><allow-access-from domain="'+@config[:allow_access_from]+'" to-ports="'+@config[:server_port].to_s+'"/></cross-domain-policy>'
- # EOL (End Of Line) character used by Flash XML Socket communication (a null-byte):
- @config[:eol] = "\0"
- # 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 "=":
- i = line.index('=')
- # Check if line is not a comment and a valid property:
- if (!line.empty? && line[0] != ?# && i > 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 => error
- # Log initialization failure:
- puts "#{Time.now}\tFailed to initialize Server on Port #{@config[:server_port].to_s}: #{error}."; STDOUT.flush
- end
- end
-
- def accept_new_connection
- begin
- # Accept the client connection (non-blocking):
- socket = @server_socket.accept_nonblock
- # 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 < @config[:max_clients].to_i || !@config[:broadcast_clients].empty? && @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] = "[#{ip}]:#{port}"
- # 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 > 0
- # Log client connection and the number of connected clients:
- puts "#{Time.now}\t#{client[:id]} Connects\t(#{@clients.size} connected)"; 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 > 0
- # Log client disconnection and the number of connected clients:
- puts "#{Time.now}\t#{client_id} Disconnects\t(#{@clients.size} connected)"; 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 => error
- # Rescue if parsing the client input fails and log the error message:
- puts "#{Time.now}\t#{@clients[client_socket][:id]} Client Input Error:#{error.to_s.dump}"; 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] && (@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 && (@config[:broadcast_self] || socket != client_socket)
- # Only write to clients registered to the given channel or to the "ALL" channel:
- if @chats[chat_id]['ALL']
- reg_id = @chats[chat_id]['ALL'][@clients[socket][:user_id]]
- end
- if !reg_id && @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 && 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 > 2
- # Log the message sent by the broadcast client:
- puts "#{Time.now}\t#{@clients[client_socket][:id]} Chat:#{chat_id.to_s.dump} Channel:#{channel_id.to_s.dump} Message:#{str.to_s.dump}"; STDOUT.flush
- elsif @config[:log_level].to_i > 1
- # Log the message sent by the broadcast client:
- puts "#{Time.now}\t#{@clients[client_socket][:id]} Chat:#{chat_id.to_s.dump} Channel:#{channel_id.to_s.dump} Message"; 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 > 1
- # Log the client registration:
- puts "#{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}"; 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 > 1
- # Log the client authentication:
- puts "#{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}"; 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 > 1
- # Log the policy-file-request:
- puts "#{Time.now}\t#{@clients[client_socket][:id]} Policy-File-Request"; STDOUT.flush
- end
- end
-
-end
-
-# Start the socket server with the first command line argument as configuration file:
-SocketServer.new($*[0]) \ No newline at end of file