yChat 0.7.9.5 review

yChat is an experimental, XML-configurable, fast, very portable, multi-platform Web-based chat server written in C++ and a little sub

License: GPL (GNU General Public License) File size: 0K Developer: yChat team

0

yChat is an experimental, XML-configurable, fast, very portable, multi-platform Web-based chat server written in C++ and a little subset of C which supports secure SSL sockets using OpenSSL, MySQL databases and is compatible with almost all browsers that support frames and JavaScript.

yChat runs on all servers which are POSIX.4a compatible and use the GNU GCC C++ compiler from 3.1 and up with pthreads enabled. Its developed under the GNU General Public License.

yhttpd is a very light webserver based on yChat socket and thread engines.

Here are some key features of "yChat":
Its free & portable

yChat is developed under the GNU general public license and is based on GNU
tools (gcc, gmake), other open source library stuff (such as libncurses etc.)
and should run on any POSIX capable operating system (such as all Linux based
systems, FreeBSD, NetBSD, OpenBSD and other BSD-Systems and on UNICES like
IRIX, HP-UX, Solaris etc.).

There is no need for special chat clients

yChat is web based, that means clients may only connect to the chat server
with an normal web browser such as Microsoft Internet Explorer or any Gecko-
Engine powerd browsers like Mozilla, Firefox, Camino etc.

It has features of a real HTTP webserver

yChat runs completely stand alone and does not need another webserver to build
on like Apache and does not need to be run via any kind of CGI. yChat creates
its own socket on a customized port (standard port: 2000) and seems to be a full
featured HTTP web server to the clients (web browsers).

The yChat code base can be converted to an yhttpd code base automaticaly. yhttpd
is the webserver subset of yChat which runs completely stand alone and provides
normal websites to the net. It also supports Common Gateway Interface (CGI)
scripting.

Its fast and secure

yChat is written in C++ which is faster than any Java based Chat-Server or any
server written in a scripting language like PHP, Python or Perl. As the
internal data structures hash maps are used to garuantee searching certain
values in O(1) amount of time. If a hash maps gets full, it will be rehashed.
Currently, yChat has been measured providing over 1000 hits/requests per second
on a FreeBSD based server box while using less than 2% of CPU usage
on a Athlon XP 1900+. Performance seems to be limited by your bandwith only.
Also, each user gets its own session id (random string) with a standard length
of 50 chars to authenticate each logged in user. The length of the session id
can be redefined as well. Also, the session id will get md5-hashed optionally
so thats even harder to reverse engineering the session ids of other users.
Also, yChat supports secure hypertext transfer protocol (HTTPS) connections
using the OpenSSL library. Then, all chat messages will be encrypted in a
secure manner. HTTPS is optional to HTTP (unsecured connections).

Its HTML template based and easy to customize via XML based configuration

All HTML sites are predefined as HTML-Template files and can be easily modified
to use with an customized web design. Also, a lot of yChat preferences can be
set in the main configuration file (ychat.conf). ychat.conf is completely written
in XML 1.0 which makes it easier to use the configuration options in programs of
3rd persons which may want to write some usefull tools for yChat.
yChat caches all HTML and web images to improve overall performance. If needed, the
cache can be cleared to recache new versions of the template files.

Its language template based

The administrator can easily create a new language in which all system messages
appear to the Chat-User. The predefined languages is english but others can be
added easily. The language can be edited in the XML based configuration file.

MySQL based database

Registered users are stored in a MySQL database. C++ Programmers may feel free
to replace the database wrapper class (data.h) with another database routines
to use other databases such as PostgreSQL, SQLite or a text based database etc.
If wished, you can disable database support in the pre-compile options.

It has an administration interface

yChat includes an ncurses based administration interface which tracks some
interesting statistics and system messages and enables you to do certain
administrative tasks. In addition, you can switch to the CLI (command line
interface) mode of the administration interface in order to be provided with
more available functions (like keeping track of the current system usage etc.).
If you dont like ncurses and/or the CLI you can disable both options in the pre-
compile options.

It has logging capabilities

The logging manager keeps track to all yChat system messages (such as users
wich log in and out, modules which are loaded, MySQL queries etc.). Also, an
Apache-Style combined log file format is created by yChat (you can parse this
logfile with any Apache logfile parser like awstats etc.). And last but not
least, all public messages of all available rooms will be logged to disk as
well . To improve performance, you can define the logging puffer (standardly
new logs will be written to disk after each 20 lines). If you want to log
everything immediately, you can reset this option to 1 in ychat.conf.

Its modular through own command and dynamic HTML engine

All chat commands are realized through dynamic loadable module files which can
be recompiled and reloaded without restarting the whole yChat server. Also
HTML-Sites with certain tasks can be compiled as a module like
mods/html/yc_register.so, mods/html/yc_options.so and mods/html/yc_colors.so
etc. so you can also program your dynamic yChat websites in C++.

Its multi threaded (POSIX threads)

There is only one main process which spawns several threads, each for its own
unique task. For example one thread is used to handle the socket manager which
waits for incoming TCP/IP requests, another thread schedules the system timer
which proves if clients are still active or frees not needed memory in certain
time intervals (see also "Garbage collector"). Also, each Chat-User gets it own
thread. There is no need of memory wastage by creating for each task a new
process. All User-Threads are managed by a thread pool to avoid CPU wastage
creating every time a new thread by reusing thread objects which have done its
jobs already and have been readded into the queue of the thread pool. The
standard sizes of the queue and the total pool size can be set in ychat.conf.

Its using a smart garbage collection engine

All users and rooms which dont have to be kept in the main memory (because the
user has logged out or the room has been destroyed because it was empty) will
not be deleted immediately but be placed for about 10 minutes in the yChat
garbage collector. Each time a new room is created the systems checks the
garbage to reuse an inactive room object. If a certain user wants to log in, the
system checks if he is already present in the garbage collector. If yes, he will
be reactivated without wasting expensive database queries to fetch the user's
options. This improves overall performance on heavily loaded yChat servers if a
lot of user and room objects are created and destroyed frequently.

What's New in 0.8.2 Release:
Fixed some typos
Added the - Versioning - paragraph into the README file
Removed the yc_template command module source file
scripts/config.pl now also accepts q and quit as a command
Minor bugfix in scripts/config.pl
Some improvements in src/configure
Changed some default values in the src/glob.h

What's New in 0.7.9.5 Release:
This release adds .pm detection to scripts/stats.pl.
It modifies the README (new CVS pserver address).
All .cpp, .h, and .tmpl files now have a new source header using docs/header.txt as header skeleton.
Some minor bugfixes were made.