Apart from the site-specific information you provide during setup, DBabble is set to work "straight out of the box". You can install it and virtually forget it. Despite this simplicity DBabble is highly configurable and offers the administrator an advanced and powerful range of options and features, allowing the server to be easily configured or tuned to meet specific needs. This manual page provides an overview to managing DBabble and its many features and options. A quick list of all configuration settings can be found on the configuration page. A more detailed description of when to use these features is given below.

Your DBabble server can be accessed at e.g.
Your DBabble server can be accessed securely (in version 2.3a and later) at e.g.

Administrator Users

The first user created is given administrator rights. You can give additional users administrator rights by checking the "Manager Rights" checkbox in their user details. You can also grant administrator rights to users in versions 1.5b and later by typing dbabblesvr -admin username (where you replace username with their user name) from the command line. If you delete the first user administrator account, the new first account will be granted administrator rights unless you disable the first_user_admin setting.

If you are using version 2.3i or later, you can also access the administrator interface by going directly to e.g.
or securely at e.g.

If you are using a version prior to 1.5b, you can give a user administrator permissions by adding the line
username f_root=true permissions=0 to the file add_users.txt in your DBabble server directory, and from the command line type dbabblesvr -setusers See Adding Lots of Users for more details on how this works.

The Configuration Window

DBabble provides easy administration of your DBabble server from within the DBabble interface. To do so, you must first login as an administrator user. (The first user to login/create an account on your DBabble server is an administrator user) From a web browser, click on the DBabble Server Config link to take you to the Server Administration page. From the windows client, select DBabble Server Configuration from the Edit menu.

  1. Configuration Settings This section of the Configuration Window lets you specify any settings in the configuration file. For more details see DBabble Configuration Settings
  2. Slave Settings This section of the Configuration Window lets you specify any slave servers if you are running a master server.
  3. Manager Commands This section provides a list of commands you can perform from within DBabble interface. These are mainly intended for correcting the server if something has gone wrong, but also provides the ability to view log files, and to stop or restart the server.

  4. The following options are only available from the web browser interface:
  5. Basic Configuration This page provides a list of only some common settings. (rather than all settings listed on the Configuration page)
  6. Permission Groups This lets you modify permissions of groups of users. (such as disk quota)
  7. Default Preferences This page lets you modify what the default preferences any new users will have. Although this page is only available through a web browser, it also provides a list of preferences only available in the Windows client. You can also optionally set the values of preferences for all existing users.

Starting, Stopping, and Restarting DBabble on Windows NT/2000

DBabble is installed as a service, which is started upon completion of installation. The service is set to start DBabble again when the system restarts.
  • To stop the service you can either
    1. Click on the "Stop Server" command in the manager commands page
    2. Type "net stop dbabblesvr" from the command prompt
    3. Stop it from the services applet in the control panel
    4. Type "dbabblesvr -stop" from within the DBabble directory
  • To start the service you can either
    1. Type "net start dbabblesvr" from the command prompt
    2. Stop it from the services applet in the control panel
  • To start DBabble without running it as a service,
    1. Type "dbabblesvr -go" from within the DBabble directory
  • To restart the service you can either
    1. From within the DBabble Manager Commands, choose "Restart Server"
    2. Type "net stop dbabblesvr" then "net start dbabblesvr" from the command prompt
    3. Type "dbabblesvr -restart" from the DBabble directory
  • To stop DBabble from starting every time the system reboots you can either
    1. Type "dbabblesvr -delsvc" from the command prompt when in the DBabble directory
    2. Disable the startup option in services applet in the control panel
  • To enable DBabble to startup every time the system reboots you can either
    1. Type "dbabblesvr -addsvc" from the command prompt when in the DBabble directory
    2. Enable the startup option in services applet in the control panel

Starting, Stopping and Restarting DBabble on UNIX

DBabble appends a line to your startup script during installation so that it is automatically started when the system restarts. It is also immediately started on completion of installation.
  • To stop DBabble, either
    1. Click on the "Stop Server" command in the manager commands page
    2. From within the DBabble directory, type "./dbabblesvr -stop"
  • To start DBabble
    1. From within the DBabble directory, type "./dbabblesvr"
  • To restart DBabble, either
    1. From within the DBabble Manager Commands, choose "Restart Server"
    2. From within the DBabble directory, type "./dbabblesvr -restart"
  • To stop DBabble from starting every time the system reboots either
    1. From within the DBabble directory, type "./dbabblesvr -delstartup"
    2. Edit your startup script, and remove the dbabblesvr line.
  • To enable DBabble to startup every time the system reboots
    1. From within the DBabble directory, type "./dbabblesvr -addstartup"
    2. Edit your startup script, and add the line "/usr/local/dbabble/dbabblesvr_start" where you specify the appropriate directory.

Reloading Configuration Files without restarting DBabble

DBabble has a number of configuration files that you might want it to reload if you have changed them. These are dbabblesvr.ini, user_fields.dat, slaves.dat, and the web template and help files. There are a 2 ways to get DBabble to reload them. Either the "Reload Ini File" button on the server administration page, or just type "dbabblesvr -reload" from within your DBabble server directory.

Backing up your server

  • Windows NT (assuming you have installed to \dbabblesvr and your Windows directory is \winnt)
    1. Backup the files \winnt\dbabblesvr.ini and \winnt\dbabblesvr.exe
    2. Backup the directory \dbabblesvr
    3. If you need to restore the from the backup, after restoring the above files, from the command line, type dbabblesvr -addsvc to add DBabble to the Windows service database
  • Unix (assuming you installed it to /usr/local/dbabble)
    1. Backup the file /etc/dbabblesvr.ini
    2. Backup the directory /usr/local/dbabble
    3. If you need to restore the from the backup, add the line /usr/local/dbabble/dbabblesvr_start to your system startup script. For example on linux /etc/rc.d/rc.local

    Ports used by DBabble

    DBabble uses only TCP.

    The DBabble server listens on the following ports:
    • 8132 (port) (web and client to server communication via http)
    • 8133 (ssl_port) (encrypted web and client to server communication https)
    • 25 (optional) (smtp_port) for accepting incoming email
    • 119 (optional) (nntp_port) for accepting incoming news (NNTP) requests
    • 5269 (optional) (jabber_server_port) for communicating with MSN, ICQ, AIM, Yahoo gateway servers
    • 80 (optional) (port/extra_ports) If you want DBabble to listen on the default web HTTP port.
    • 443 (optional) (ssl_port/extra_ssl_ports) If you want DBabble to listen on the default web HTTPS port.
    The DBabble server makes outgoing connections on the following ports:
    • 25 If you want outgoing email to work
    • 119 If you want to pull from or post to an external news (NNTP) server
    • 110 If you want the email checking feature to work.
    • 5269 If you want to use communication with MSN, ICQ, AIM, Yahoo gateway servers.
    • 8132/8133 If you want to link your server to other DBabble servers.
    • Any other port if you want to allow more than about 800 simultaneous users.
    The DBabble client makes outgoing connections on the following ports:
    • 8132 If using an unsecure connection to the server
    • 8133 If using an encrypted connection to the server
    • 80/443 if you have configured the server to listen on these ports and the client has a firewall preventing them from using the ports 8132/8133.
    The DBabble client listens on the following ports:
    • A random free port if there are more than about 800 simultaneous users on the server. This is so the client doesn't have to keep a connection to the server open and the server can connect to the client instead when there is a new message for them. Note - the server actually starts doing this with clients not behind firewalls at about 400 simultaneous users so that if some users are behind firewalls they can still use DBabble.

    User Authentication

    DBabble can authenticate your users using either a POP server, DBabble's internal authentication system, or a custom authentication process as used by Netwin's external authentication protocol Netwin has custom authentication processes for Unix password files, NT system user database, LDAP, MySQL, and others. You can also use the external authentication to fetch user details from your external database for viewing within DBabble.
    • POP Authentication - To use POP server authentication, just specify a value for the auth_pop_host setting. When using a POP server, DBabble will check whether a user name and password is valid by logging into the POP server and logging out again.
    • DBabble's Internal Authentication System - If you choose to use DBabble's internal authentication system, then each user must have an account created before they can log in. By using the user_accounts setting, you can specify whether users are able to create their own accounts, or whether administrators must create any new accounts.
    • External Authentication (versions 1.2m and later) - To use external authentication, you must first have a copy of the external authentication process you want to use installed on your system. This can be one Netwin has available from the NetWin external authentication page, or can be one you have written yourself. (see External Authentication Protocol) In either case, just set the authent_process to the full path and name of your authentication process. You can also use the authent_process_num setting to control how many authentication processes will be simultaneously running. For example, if you are running the server on Windows and if you want to use the POPAuth authentication process (which will allow you to authenticate with multiple POP servers) then you would do this:
      1. Download PopAuth from
      2. Extract popauth.exe from the zip file into your DBabble server directory (for example to c:\dbabblesvr\popauth.exe)
      3. Create a .ini file with the appropriate settings. For example, use notepad to create c:\dbabblesvr\popauth.ini which contains a line like:
        where the domains is a comma separated list of pop server domains to authenticate with.
      4. Set the DBabble server authent_process setting to point to the authentication process. For example
        authent_process c:\dbabblesvr\popauth.exe -path c:\dbabblesvr
    • If you have set up one of the above systems of authentication, and your users are already logging in to your existing web pages using the same user name and password, then you can create links on your existing web pages to login to DBabble. See Logging in to DBabble from your existing Web Site.

      Specifying user details and permissions using the external authentication process
      Using the external authentication protocol, you can fetch user details from your external database for displaying in DBabble. You can fetch the following values from your external database
      • Every user detail specified on the DBabble user details page
      • Every user permission (can create chat rooms, administrator permissions, etc) , or just the permission group that the user belongs to
      • The user groups, chat rooms, and discussion groups the user belongs to
      • A list of users that should appear in the friends list of the user
      You can also optionally write user details and permissions back to your external database if they are changed from within the DBabble interface.

      In order to fetch details from the external database, you must configure your authentication module to extract these details from the database and supply them to DBabble. The following 2 examples describe how to do this assuming you are using MySQLAuth. The procedure is very similar for any other authentication module

      1. If you want to extract the user's display name from your database, which is currently stored in a field called 'FullName' in your SQL database, then you would add this line to your MySQLAuth configuration file:
        info_fields display FullName
        What this means is that MySQLAuth will fetch the field called 'FullName' from your database, and call it 'display' when giving it to DBabble. For a list of what each field must be called when used in DBabble, see the web browser administration page on your server, and go the the 'User Fields' section and look at the 'Internal Name' given for each user field. If your authentication process returns different field names than DBabble expects, use the authent_translate_fields DBabble server setting.
      2. If the field you want to fetch from your external database should not use the exact same value when it appears in DBabble, you can use the auth_groups.txt file in the DBabble server directory to control translation of values. For example, say you have a field called department in your SQL database, that can have a value of either sales or accounts, then you could add this line to your MySQLAuth configuration file:
        info_fields department department
        and these lines to your DBabble auth_groups.txt file:
        groups=5,6 friends=test1,test2,test3 ugroups=2 permissions=1

        groups=7,8 friends=test4,test5 ugroups=4,5 permissions=2
        What this will do is assign any user in the sales department to belong to discussion groups/chat rooms with group-id 5 and 6, automatically add users test1, test2, and test3 to the friends lists of each of these users, make these users members of user group 2, and make these users belong to permission group 1.

      User details and permissions are fetched from the database each time the user logs in to DBabble.

      If a user changes any of these values within DBabble, they are NOT updated within the database unless you specify those fields in the authent_write_fields server setting. Any fields that you have chosen to not write back to the database will be replaced by the database values next time the user logs in, so you should make these fields unchangeable by modifying the 'User can change' property on the server administrator 'User Fields' web page. Most of the above information assumes you are using DBabble 2.0g or later. You may also want to refer to the Adding Lots of Users section which describes the friends, groups, and ugroups fields in more detail.

      Using the authentication process to log in using existing web site cookies
      You can also use this authentication process for allowing your users to access DBabble without having to login again if they were already visiting an authenticated site of yours, by adding support to your authentication process for confirming that a given cookie is valid. To do this, set the auth_check_cookie setting to the name of the cookie that will be given to DBabble. When the DBabble CGI (see http authentication) receives this cookie, it forwards the user to the dbabble server with the cookie value as a form value (it is done using the CGI since some web browsers won't preserve cookies over different ports on the same domain, and DBabble requires a port unique from your standard pages). When the DBabble server receives the request (cmd_cookie_login=cookie_value) , it will send a line to the authentication process of the form:
      cookie_check unique_id cookie_value from_ip_address
      and if the cookie is valid, the authentication process should return:
      +OK unique_id 0 username [fields]
      For example, if you have auth_check_cookie AUTH_TOKEN in dbabblesvr.ini
      and the DBabble CGI receives a HTTP header of the form:
      Cookie: AUTH_TOKEN=xx_123456789
      then it will forward the user to the DBabble server with a request like:
      then DBabble might send a line to the authentication process of the form:
      cookie_check 4522 xx_123456789
      and your authentication process might reply:
      +OK 4522 0 test1 display="Test 1" email=""
      DBabble will then proceed as if test1 has just logged in.

    Adding or Modifying Lots of Users

    Normally, user's create their own accounts by clicking on the 'create account' link on the login page. If you have disabled user account creation on your server then new accounts can only be created when you are logged in as an administrator user. The first user account created has administrator permissions.

    If you are using POP server, or external authentication (e.g. Windows NT user database), then users are not able to create accounts. Instead, their DBabble account is automatically created for them the first time they log into DBabble using a valid user name/password. The first user to login when using this one of these authentication systems will have administrator permissions.

    The following section describes how you can create or modify many accounts within DBabble from a list of users in a text file. This will work no matter what sort of user authentication you are using.

    In version 1.4j and later, there is support for adding a text file containing a list of users into DBabble's internal user database. To do this, edit the file add_users.txt in your DBabble server directory to contain a list of users, and type dbabblesvr -addusers to add those users to Dbabble or type dbabblesvr -setusers if you want it to update already existing users with new permissions or passwords. The format of this file is one user per line, with the following syntax:
    username [field_name=field_value [field_name=field_value]] ...
    where field_name is the name of any user field as given in user_fields.dat. If a value needs to contain a space, enclose the value in quotes ("). Each user in DBabble must have unique user name (login name). Make sure values are space separated rather than tab separated.
    1. test100 pass=testpass (Adds or sets user test100 with password testpass)
    2. test101 pass=testpass display="test 101" permissions=1 (Adds or sets user test101 with password testpass, who belongs to permission group 1)
    3. test102 permissions=0 f_root=1 (Adds or sets user test102 to belong to no permission group, and have administrator rights)
    After doing the addusers command, check log/users.log to confirm it has successfully added all the users.
    Note that if you are using POP or external authentication, any users you add to DBabble in this way must also be valid users on your POP server, or in your external authentication database.

    In version 1.5b and later, there is also support for specifying which user groups each user should belong to, and a list of friends for each user. This is done by supplying a ugroups field with a comma separated list of user group ids. Whenever a user is added to a user group using this method, they are given whatever the default permissions of new users to the user group would normally have.
    To supply a list of friends for each user, give a comma separated list of user names for the friends field. The friends specified must already exist. If you need to create those friends in the same file, run it once using -addusers, then run it a second time using -setusers.
    1. test103 ugroups=1-11,1-12 friends=test101,test102 (Adds user test103 to user groups 1-11 and 1-12, and adds users test101 and test102 to the friends list for test103)
    When adding to user groups, the specified user groups must already exist on the system, and you must supply the unique identification number for the user group. This number is listed on the user group page/window for modifying the user group. For example "ID 1-11".

    In version 2.0g and later, if the user is already a member of the user group at the time this command is run, then their current user group permissions are not updated unless you use the field name "ugroups_set" instead of "ugroups"

    Also in version 2.0g and later, there is support for specifying initial group (chat room/discussion) membership. This is done using the "groups" field name in the same way as the "ugroups" field. The unique group id for chat rooms and discussions is listed in the group modifying window for that particular group.

    In version 2.1g and later, if you are using external authentication, or adding lots of users using the add_users command, there is now support for converting specific field/value pairs into group or user group value lists. For example if your existing database contains field names like "dep=sales" or "dep=accounts" you could specify that when DBabble sees "dep=sales" this is interpreted to mean "groups=5,6 ugroups=1". See the file auth_groups.txt in your server directory for more details.

    In version 2.6j and later, you can use the "friends_clear_and_set" field instead of the "friends" field. This means that the user's existing friends list is cleared and set to exactly what is specified in the field value, rather than just adding the specified users to their existing friends list.

    To delete users using this system, you can set the field f_deleted=1 after any user and run dbabblesvr -setusers. For example:

    test103 f_deleted=1
    (Deletes user test103)

    However, when using POP or external authentication, whenever a new user logs in, an account is automatically created for them. This means that if you delete a user when using POP or external authentication, then their account will be recreated next time they try and log in. If you wish to prevent this, you must either remove their name from the POP server or external authentication database too, or first delete their account then recreate it with the ban flag set. For example you would use the following lines to delete and ban user test104:
    test104 f_deleted=1
    test104 f_banned=1

    In versions 1.5d and later, you can specify an alternative file to use rather than add_users.txt. For example dbabblesvr -addusers user_list1.txt would add the list of users in the file user_list1.txt.

    You may also want to refer to the external authentication section which has examples on how many of these fields can be used in a different context.

    Deleting Users

    To delete a single user from within the DBabble interface, you must first log on as an administrator user. Then find the user you want to delete using the "Find User" page.

    In a web browser, click on the user and click on the "Modify User Details" link. On the next screen will be a link to delete their account.

    In the windows client, in recent versions right click on the user and choose "Modify User Details". In older versions double click on the user and in the "Details and Options" tab is a "Modify User Settings" button. In the window that opens is a button to delete their account.

    To delete many users at once, you can use the instructions in the Adding lots of users section and set the flag f_deleted for each user you want to delete.

    HTTP Basic Authentication

    As of version 1.1k or later, DBabble also supports HTTP Basic Authentication. This is intended to run in addition to whatever authentication system you are already using, and is just another means of getting your user's names and passwords. HTTP Authentication is where the web-browser automatically pops up a dialog box prompting for their user name and password. The web browser also sends this same information to any other programs/CGIs running on the same system to avoid users from having to enter their name and password again. However, DBabble runs on it's own port separately from your web server, and some web browsers (eg Netscape Communicator) treat this as a different domain so won't use the same name and passwords. To get around this, DBabble comes with a CGI program that you can install on your existing web server, which acts as a gateway to logging in to DBabble. Copy this CGI (dbabble.cgi on unix or dbabblecgi.exe on Windows NT) into your existing web server CGI directory, and if using unix, make sure it has permission to write to your dbabblesvr/work directory. Set up your web server to require non-anonymous basic authentication on the DBabble CGI. You should then be able to go to the dbabble CGI from your web browser, and it should prompt you for a user name and password. Once you have entered them, the CGI will redirect your web browser to the DBabble server, and log you in. You will not have to enter your name and password information again until you restart your web browser. Note: You should only use this system when your web server user database is the same as your DBabble user database. Due to DBabble only supporting POP-authentication as a means of external authentication currently, this means that you must be using POP-authentication and your POP server user database must be the same user database as your web server uses.

    Logging in to DBabble from your existing Web Site

    If you already ask your users for a name and password elsewhere on your site, and want them to be able to login to DBabble without entering their name and password again, you must do the following
    1. Firstly, you must be using the same set of user names and passwords on both DBabble and your existing system. You have 3 options for this.
      • You could can achieve this by using POP authentication if your users are already set up on your email system with the same names and passwords.
      • Alternatively you can use an external authentication process that will return to DBabble whether or not user names and passwords are valid.
      • A third option is to use DBabble's internal authentication system, and add every one of your existing user names and passwords to DBabble (see Adding Lots of Users)
    2. Next, you must have a way of passing the fact that a user is already logged in onto DBabble.
      • If you have access to the user's name and password on your existing web page, then you could just create a link on your existing pages of the form <form name="dbabble_login" method="POST" action=""> <input type=hidden name="user" value="Guest"> <input type=hidden name="pass" value=""> <input type=hidden name="r_login" value="r_login"> <a href="javascript:document.dbabble_login.submit()">Login to Free DBabble</a> </form> which would be show to the user like:
        Login to Free DBabble
        You would replace Guest with the user's name and fill in the password field. There are other options available when using a hidden form like this. For example, you can take users directly to a particular chat room. See web login options for details.
      • Alternatively if you have an existing cookie that users receive after login, you can tell DBabble to look for this cookie, and run a custom program of yours that will return if the cookie is valid or not. See the second half of External Authentication for details on doing this.
      • A third option is to use HTTP basic authentication, but you will only be able to use this if you are already using this for authentication on your existing site pages.

    Web login options

    When allowing users to login from your existing web site, there are a number of options available. For example, if you wanted to take the user to chat room number 1, hide the rest of the interface from them, and make them return to after finishing in the chat room, you could add these fields to the hidden form fields described above. <input type=hidden name="after_login_page" value="cmd=chat_list&gid=1"> <input type="hidden" name="hide_menu_and_friends" value="true"> <input type="hidden" name="show_features" value="3"> <input type="hidden" name="after_logout_page" value=""> Here is a list of the various options available:
    • after_login_page - The page within DBabble that the user sees within the main DBabble frame immediately after logging in. You can use any valid command available on any of the normal DBabble pages. For example cmd=chat_list&gid=1 to go to chat room id 1, or cmd=group_items&gid=2 to go to forum id 2, or cmd=r_search_user to show the user search page.
    • hide_menu_and_friends - Hides the menu with links in it down the left and hides the list of contacts on the right.
    • show_features - Choose which features are available to the user.
      0="Show All Features"
      1="Instant Messages Only"
      2="Forums Only"
      3="Chat Rooms Only"
      4="Chat Rooms and Forums Only"
      5="Chat Rooms and Instant Messages Only"
      6="Forums and Instant Messages Only"
      Note - this feature can have other desired side-effects. For example, if instant messages are not allowed, then in chat rooms there will not be links on user names to send instant messages to those users.
    • after_logout_page - The URL of a web page the user is taken to after they logout from DBabble. This also applies if using a direct chat room link and hiding the menu/contacts and the user clicks on the 'leave chat room' link. If you targetted the login form to a new window, then you could give this option a value of "javascript:window.close()" to close then window when done.
    • u_day, u_hour, u_min, and u_sec - DBabble adjusts all times displayed to match the users local time. If you don't specify values for these parameters in the login window, then the user is assumed to be in the same time zone as the server. Call the following javascript function function FetchDate() { x = new Date(); document.dbabble_login.u_hour.value=x.getHours(); document.dbabble_login.u_min.value=x.getMinutes(); document.dbabble_login.u_sec.value=x.getSeconds(); document.dbabble_login.u_day.value=x.getDate(); } before submitted the hidden form to fill in these options.
    • override_dot_top, override_main_name, and override_check_main_window - If you want the DBabble window to appear within a sub-frame of the existing window you must use these options. DBabble needs to be able to find the top-level DBabble window using javascript. For example, we have code that sets these values as follows:
      if (sub_frame_name!="") { document.dbabble_login.override_dot_top.value=".top."+sub_frame_name document.dbabble_login.override_main_name.value=sub_frame_name document.dbabble_login.override_check_main_window.value="window.length>1 &&[1].name=='"+sub_frame_name+"'" }

    User Management

    Every user account has an associated set of privileges. These include permission to create discussions, chat rooms, broadcast messages, and perform administrator functions. By default, new users are created with these permissions set to true or false depending on the values of the settings user_chats, user_discussions, and user_broadcasts. The administrator privilege is always disabled by default. For any individual user, these can be modified by an administrator by selecting the user in DBabble, and choosing to modify their settings. You can also optionally impose a quota limit on users to prevent them from using excessive storage space for private messages and their attachments using the user_quota setting. Individual users can have their quota adjusted from this value by any administrator users.

    For DBabble versions 1.1i and later, each user can optionally be assigned to belong to a permission group from which all of their privileges are taken from. This means that you can change just the rights for the permission group, and all users belonging to the group have their permissions automatically changed to match the permission group. Permission groups can be administered and created from the web browser interface from the "Server Configuration->Permission Groups" section. On that page you can also set the default permission group that any newly created users will be assigned to. Note that if a user belongs to a permission group, any changes you try to make to any of their other permissions will be ignored unless unless you set their permission group back to "None". When using permission groups, the above mentioned settings (user_chats, user_discussions, user_broadcasts, and user_quota) are no longer needed.

    Automatic login to other Netwin Web Products

    As of DBabble version 1.1g, there is support for adding links to your template pages in DBabble and other Netwin products so that your users can switch between products without having to login again. DBabble will automatically create the appropriate configuration file settings and list links in the main DBabble screen shown after a user logs in. However, these links are not visible by default, and you must set the auto_login_links setting to true to show them. After enabling them, if they don't work on your system, this may be because you have them installed in non-default directories or something similar.
    The auto-login feature will only work if your users have the same username and password on all servers.
    • Logging in to other products from DBabble
      DBabble will generate lines in your dbabblesvr.ini file like:
      auto_login 5 http://$(server)/scripts/cwmail.exe $(dbabble_path)/../cwmail
      where $(server) and $(dbabble_path) get automatically replaced by your system values at run time. You may need to change this to the specific directories on your system. For example:
      auto_login 5 /usr/local/cwmail
      To reference these in web-pages, you use html source like:
      <a target="_top" href="||action||?cmd=send_auto_login&n=5&tok=||tok||">Login to CWMail</a> anywhere within your template pages. Note that the value 5 in this example is used to associate the correct configuration file line with the appropriate html link. Each auto_login line must use a unique integer value.
    • Logging in to DBabble from other products
      For other products to login to DBabble, they should have a configuration file line like:
      auto_login 6 $(server):8132/dbabble $(workarea)/../dbabblesvr/work
      Again, if you have different directories or use a different DBabble port setting you will need to change these to something like:
      auto_login 6 /usr/local/dbabble/work
      And within the other products web-pages generate links using the syntax which they specify. For example, in CWMail you would use:
      <a target="_top" href="||action||?cmd=send_auto_login&n=6&utoken=||utoken||">Login to DBabble</a>
      Make sure you include the target="_top" section as DBabble needs to be in the top frame to function correctly.

      Note that some Netwin products use a different syntax. For example in WebNews and WebIMAP your configuration file line might look like:
      netwin_autologin /usr/local/dbabble/work
      and your web references might look like <a target="_top" href="||action||?cmd=netwin_login-6&utoken=||utoken||">Login to DBabble</a>

      Note that in this case, you must replace the 6 with the index within your WebNews/WebIMAP configuration file that the DBabble netwin_autologin login line is given, starting from 0. For example if your DBabble netwin_autologin line in webimap.ini was the 3rd netwin_autologin line, then you would use the value 2.
    NOTE If using a unix system, be sure to set your permissions correctly. DBabble normally runs as root, and CGIs as nobody. Your CGIs will need to have permission to write to the DBabble server work directory, and will need to be able to read files created by DBabble in their own directories. New DBabble installations will create the dbabble and dbabble/work directories with write access by nobody. Additionally, any files created by DBabble intended for reading by the CGIs are created with ownership of the auto_login_user setting. This defaults to nobody.

    Using DBabble for online support

    You can use DBabble to insert links into your existing web pages to initiate a private conversation with a particular user (or member of a particular user group). You can also add links to take the user directly to a particular chat room. The private conversation can optionally be embedded directly in any web page if the recipient is currently online (for example see and if a member of our DBabble support team is currently online and willing to accept chat requests then the top right corner of the page will contain a private chat window). There are details and examples of how to do this on your own DBabble server administrator page web page. See and go to the 'Online Support Setup' section.

    Linking discussions to external usenet (NNTP) groups

    When a user creates a new discussion, they have the option of linking it to a usenet group so that any articles posted to either the external group, or the DBabble discussion group will appear in the other. This option is only enabled if you have specified the pull_host setting. Additionally, groups can also be made visible to the NNTP protocol if you have specified the nntp_listen setting. This means that DBabble will listen on nntp_port for requests from news-readers. In this way users can use their favorite news reader to view a DBabble discussion.

    Sending and Receiving EMail from DBabble

    DBabble supports both sending out email and receiving incoming email.

    Sending Email

    In order for DBabble to send outgoing email (so that users can receive email notification of new discussion group items and receive their initial password if your system is set up that way, and optionally forward their instant messages to an email account when they are offline), you must have specified a valid SMTP server in the smtp_host setting. If you haven't done this, then outgoing email is queued in the work/email.que file until DBabble can send it. You may also want to specify a value for the email_from setting. The From header in outgoing password and server messages is set to this value. Outgoing from headers are allowed to be blank, but if they are some email servers may treat the message as spam and not deliver it to the recipient.

    Problems with sending EMail

    If you are having trouble getting outgoing email to work, try the following:
    1. Have a look and see if the file work/email.que exists on your server. For example c:\dbabblesvr\work\email.que. This file contains outgoing email that has not yet been sent to your email server. If this file does exist it means DBabble has not been able to attempt to send the email. Make sure you have specified a valid value for the smtp_host setting. If you have, have a look in the error log file (log/error.log) for a possible problem. If you are not sure what the error means, send it to us at and we should be able to help you out. A possible error could be due to SMTP server not relaying email for you. You might have to set your SMTP server to accept relaying of email from DBabble. For example, if you are using DMail, then you would need to add DBabble to the forward_from or forward_from_ip setting in dmail.conf.
    2. if work/email.que does not exist, then either DBabble has successfully sent it to your email server, or discarded it because of permanent rejection errors from the email server. Have a look in the error log file (log/error.log). If it was rejected there will be a message there explaining the problem.
    3. Check you have specified a value for the email_from setting. Some email servers may reject a message that has a blank from header.
    4. When DBabble sends out password emails, by default it does not set a bounce return address, so if the email was undeliverable, then no bounce message will be sent back. You can change this behavior with the give_email_bounces setting. If you turn the first setting on, then bounce messages for password messages will be sent to the address specified by the email_from setting. There is also a setting called give_user_email_bounces which applies to messages sent by users and the default for this setting is on. When a user sends an email, the from address is set to their personal email address so that is where bounce messages will be sent.

    Receiving Email

    DBabble can also receive incoming email. By default this option is not enabled. It works by acting as an SMTP server itself, so do not enable this if you already have an SMTP server running on the same machine. Otherwise you may not receive your normal email. (If you do have an SMTP server running on the same machine, see the following section.) To enable this feature, set the smtp_listen setting to true. The reason DBabble can receive email is so that users can email messages straight into discussion groups, by just choosing to reply to messages they have been emailed from the discussion. However, this will not work for discussion groups that are marked as private due to DBabble performing no authentication on incoming email connections. Also, some email clients do not add a "References" header to email they send, so any email that they send to DBabble will not be correctly threaded with the message they are replying to. Users can also receive instant messages via email, by sending email to username@domain

    Receiving Email when you already have an SMTP server on the same machine

    If you already have an SMTP server running on the same machine, you have two options that can still enable you to receive incoming email.
    1. If you are running DBabble 1.4u or later, and your machine has multiple IP addresses and domain names, you can bind DBabble to only one of the IP addresses using the bind_address setting. In order to do this, your existing SMTP server must also support IP address binding and be bound to a different IP address. For example, if you are running DMail then you would use the Dmail setting bind_in. If you are running SurgeMail then on the administrator web interface, go to Common/Ports page and change the Smtp Port setting to be prefixed by the ip address. For example
    2. If you are running DBabble 1.1h or later, you can allow DBabble to receive email while there is an SMTP server running on the same machine. This relies on your SMTP server being able to support forwarding of all email for addresses beginning with a specific prefix to DBabble, which will be running on the same machine, but on a different port.

      For example, at we have our DBabble and SMTP servers running on the same machine. We set the DBabble smtp_port setting to "2025", smtp_listen setting to "true" and set the smtp_user_base setting to "dbabble_".

      1. We previously used DMail and did this:
        We added the following settings to dmail.conf:
        forward dbabble_*
        no_autohost true
        Note that is not a real domain name, even on our internal network - it is just a temporary name for DSMTP to use in the forwarding process. The no_autohost setting is to stop DSMTP from thinking is itself, and the forward_from_ip is to allow DSMTP to accept email from itself when generating a bounce message for an invalid address sent to DBabble.
      2. We now use SurgeMail so we do this:
        In the administrator web page in the section
        Common/Redirecting/Redirection Rules/Edit Rules we added this entry:
        dbabble_*      dbabble_%1@
      We also have to be careful that we don't have any existing email accounts at that start with dbabble_, otherwise those users would loose their email. With this setup, we can send instant messages to users via email at, while still receiving our normal email sent to us at Of course all of the above would be unnecessary if we had our SMTP server running on a different domain than DBabble. (For example if DBabble was at, then in that case, we would just have set the smtp_listen setting to "true" and DBabble will receive email sent to

    Sending Messages as Text Messages to Mobile Phones (SMS)

    If you have access to an email to mobile phone gateway then you can set up DBabble to know about this so that users can enter just a phone number and DBabble will send the message to the corresponding email address that will then forward it onto the mobile phone.
    Phone gateways are specified using the phone_gateway setting. This is of the form
    phone_gateway domain prefix [match [match ...]]
    where domain is the suffix of the gateway starting with @. Prefix is a prefix that each phone number must start with when sending to this gateway, followed by a list of alternative prefixes that will also be matched.
    For example if you had
    phone_gateway 6425 +6425 025
    phone_gateway phone+6421 +6421 6421 021
    phone_remove -()
    in your configuration file, then a user can send a message to any of "+64 25 1234567", "6425-1234567","(025) 1234567", and this would be sent as email to "". Alternatively, "(021) 345-678" or "+6421 345678" would go to "". If there is no matching phone gateway for a given phone number, the sender will be told that it can not be sent to that phone number.
    Note:The phone_gateway setting is a special type of setting in that there can be multiple lines in dbabblesvr.ini specifying different values. This type of setting is not currently supported by the windows client and web browser configuration interfaces, so you will have to modify these values by editing dbabblesvr.ini manually.

    Linking to remote DBabble servers

    DBabble provides the ability to link individual servers to other servers to enable users to interact with users on other servers, as well as visit chat rooms and discussions hosted on other servers. This is done through a master server which manages the database of all other servers locations. The DBabble server provided is capable of acting as either a master or slave server. To set up DBabble as a slave server, it is necessary is to specify the location of the master server using the master setting, and to specify the password to log in to it. (slave_pass). Also, each server must have a unique host identification number (hid). This is specified in the hid setting. The master server has a list of all slave servers. These can be specified from the DBabble Server Configuration page by any administrator user on the master server. To specify a new slave server, all that is needed is the Host ID, server address and password of the slave server. You can also optionally specify an alternative port , a maximum number of global groups the slave server can host, and any additional ip addresses that the server may have. The additional ip addresses may be needed because in addition to the password, slave servers are identified based on the originating IP address of the connecting slave.

    Example of how to link two servers

    If you find the above a description a bit confusing, here is an example. Assume you have two DBabble servers. One at running on port 8132 and another one at running on port 80 and you want to link these together so that users on each server can communicate with users the other server.

    1. First choose one that will be the master server. We choose as the master
    2. The other server ( is going to be the slave server, and it will need to be temporarily stopped while we make the changes. From the command line on type dbabblesvr -stop in Windows or /usr/local/dbabble/dbabblesvr -stop in unix.
    3. Each server needs to have a unique host identification number (hid). A default DBabble server installation assigns the hid to 1, so you will first need to change it on one of the servers. We change it to 2 for by editing dbabblesvr.ini and changing the line hid 1 to hid 2 (note there is a bug in versions 1.5b and 1.5c that would crash the server during startup after changing the hid setting, so you should not attempt this on those servers)
    4. Next we need to tell the slave server what it's master server location is and what password the slave server will use. So on, we edit dbabblesvr.ini and change the line master to master and the line slave_pass to slave_pass abcd
    5. Next we need to tell the master server about the slave server. On, edit the file slaves.dat, and add the lines:
      hid 2
      password abcd
      port 80
      program /dbabble
      max_groups 5
    6. Tell the master server to reload the new slave data from disk. On type dbabblesvr -reload
    7. Start the slave server now, and it should all be working. The slave server will automatically update any data files it uses to use the new hid setting and this may take a few minutes if you have a large number of messages on the server. (On Windows type net start dbabblesvr or on unix type /usr/local/dbabble/dbabblesvr_start
    8. To test if it is working, log in to one of the DBabble servers and choose "Find User" and uncheck the "Local users only" checkbox. It should list any users on the other server as long as they have not chosen to be visible to local users only in their user setup. If it doesn't seem to be working, have a look in the log/error.log on both the slave and master servers for any obvious problems.

    Linking to Netwin's master DBabble server

    To allow you to easily link your DBabble server to any other server world-wide, Netwin provide a master server running at Go to DBabble Slave Server Registration to provide the information needed to link your server to our master server.

    Customizing the Windows Client

    Although the basic layout and design of the Windows client can not be changed, a lot of it can be modified.
    • The Windows client downloaded from your server is automatically configured to connect to your server domain name.
    • You can change almost every piece of text visible to non-administrator users. See customizing the languages for details.
    • You can change the name from DBabble to anything you want using the program_name setting.
    • The image in the Help->About box can be changed using the brand_image setting.
    • You can customize the icons used throughout the Windows client in versions 1.5k and later by modifying the .ico files in the server /client directory.
    • In versions 1.6a and later you can customize the default font used
    • In versions 2.0c and later you can customize the default color scheme.
    • In versions 2.3h and later you can change or turn off the background image. This is done using the server settings called client_background_image_on, client_background_image, and client_background_image_adjust
    • In versions 2.4h and later you can remove or change the license agreement that users must agree to before installing the client. Use the show_client_license_agreement server setting.
    • In versions 2.5a and later you can set up the Windows client to install quietly without prompting the user for a response to any questions. See the 'Windows Client' section of the web browser administrator interface for details.
    • You can change or remove the advertisements. See customizing the advertisements
    • You can change the default values for preferences. See the default preferences section in the server administrator window
    • You can hide some features from the user. Features you can hide are chat rooms, instant messages (and associated features such as friends lists etc), user groups, discussion groups, and the todo list feature.

    Your DBabble server will automatically build a new Windows client download after you make any of the above changes and tell the server to reload. (e.g. dbabblesvr -reload)

    Customizing the Windows Client Fonts

    In versions 1.6a and later, you can specify what the default font and font size should be, and include custom fonts for the DBabble client to install. Normally DBabble uses whatever font and font size that user's Windows settings specify. However, you can override this, and/or install new fonts with the Windows client. This might be desirable if you are using non-English language version of DBabble where your users will be installing DBabble on a version of Windows that does not have the required font installed for your language character set. For example, assume you need to install the font "Comic Sans MS" in the English language only version of DBabble.
    1. Copy the font source file into the DBabble /client directory. In the example, the font file is called comic.ttf
    2. Add the name of the font source file into the DBabble /client/client.add file (or /client/English.add if you want it added to the English language version only) In the example, the contents of the file /client/English.add would contain just one line with the text:
    3. Tell the DBabble client to add the font to the Windows font database during installation. In the file /client/client.ini1 (or /client/English.ini1 for the example) add a line:
      install_font comic.ttf
    4. Tell the DBabble client that this should be the default font it uses. In the file /client/client.ini (or /client/English.ini for the example) add the lines:
      default_font_name Comic Sans MS
      default_font_size 12

    Your DBabble server will automatically build a new Windows client download after you make any of the above changes and tell the server to reload. (e.g. dbabblesvr -reload).

    Customizing the Windows Client Color Scheme

    In versions 2.0c and later, you can customize the default color scheme that the Windows client uses. For example you may want it to use your company colors. By default the Windows client uses the color scheme specified in the user's "Windows Control Panel"->"Display"->"Appearance" settings. Users are able to override these in DBabble. Color Scheme information is stored in the file "ColorSchemes.txt" in the user's DBabble directory. The defaults for this file are copied from the file "ColorSchemes.default" in the /client directory on your server which is automatically built into the Windows client download available on your server. To create a new default color scheme to be installed with the Windows client that users download from your server, first create the Color scheme you want using in the Windows client preferences under the "Custom" scheme. Once you have applied it, Open the file ColorsSchemes.txt and copy the 2 adjacent lines that look like
    *name Custom
    colors 12900812 14149618 16711680 8404992 1632071 255 255 32896 7850648 255 32768 255 32768 65535 -2147483640
    into the client/ColorSchemes.default file on your server. You should change the word "Custom" to whatever you want to name your color scheme. (The name may contain spaces.) (If you will be using multiple languages on your server, give this scheme an English name, and add a translation line for this phrase to each of your language.txt files.) Only one line in the color scheme file may start with "*name" instead of "name", and this indicates which scheme is the default scheme for new installations. In this way you could add multiple color schemes for new installations and let your users choose between them.

    Your DBabble server will automatically build a new Windows client download after you make the above changes and tell the server to reload. (e.g. dbabblesvr -reload).

    Customizing the Windows Client Settings

    In 2.0e and later, there is support for specifying default Windows client settings, as specified in the Configuration tab on the login window. (it is automatically configured to connect to your server host name - this section just for other settings.) Their settings are stored in the file DBabble.ini on the client machine. (in versions prior to 2.0d this file was stored in the Windows directory (e.g. \winnt\DBabble.ini) , but this and all other DBabble files are now stored in the DBabble directory (e.g. \Program Files\DBabble\DBabble.ini)) You can copy any settings from there into the file client/DBabble.ini on your server to specify defaults. Make sure the first line in the DBabble.ini file is the "version" line, which must be the same as the version line in the current version of DBabble.ini on the client (version 105) for version 2.0e of the client. For example, if your clients must access your server via a proxy server, then you might make the client/DBabble.ini file look like:
    version 105
    use_proxy 1
    proxy_use_explorer 0
    proxy_use_netscape 0
    proxy_port 8080
    proxy_local_bypass 0
    try_no_proxy_first 0
    Another example, if you want the client to not add itself to the user's startup menu by default, you would make the client/DBabble.ini file look like:
    version 105
    do_startup 0

    Your DBabble server will automatically build a new Windows client download after you make the above changes and tell the server to reload. (e.g. dbabblesvr -reload).

    Customizing the Advertisements

    DBabble optionally provides the ability to show advertisements in the main window, which are linked to specified web pages when clicked. You can disable advertisements in both the web browser and windows client by turning off the show_ads setting. You are able to specify a list of advertisements, from which a random one is selected to be displayed. The windows client automatically changes the displayed advertisement occasionally. The DBabble server keeps track of how often each advertisement is displayed and clicked on in the file ads/usage.txt. To customize the advertisements, edit the file ads/ads.txt , and follow the instructions in there. After changing it, you will need to reload the configuration file before the changes take effect. For versions 1.2j and later, if you want to insert new ads anywhere within the web pages, just place the text ||show_advert|| into a web page. The file tpl/show_ad.htm gets replaced by this text, with a random ad chosen from the list inserted into it. You can change the template page displayed for each ad individually by specifying a template page name instead of an image name in ads/ads.txt. See ads/ads.txt for further details. Also, for each individual user, the number of ads they have seen and clicked on are recorded, and these values can be seen by the administrator when they view a users details. You can also choose to use an external ad banner site for handling DBabble advertisements. See ads/ads.txt in versions 1.4a and later for details.

    Customizing the User Fields

    DBabble allows you to change what user fields (e.g. birthday, city, country etc) are available and which are optional or required. You can also change the name of them, and can also add your own user fields. There is currently no nice interface for changing these. You need to modify the file user_fields.dat in your dbabble server directory. There are more detailed instructions in there. For example, you would remove the "Birthday" field by changing the line "birthday 1 0 0 21" to "birthday 0 0 0 21". As another example, you could remove the "Display Name" field by changing the line "display 2 0 0 0" to "display 0 0 0 0". Alternatively, if you wanted to remove the email_address field entirely, but make it that a user's user-name (the name used to login) is actually their email address, then you would change the line "email 1 0 0 5" to "email 0 0 0 5", and set the email_add setting to "1". These last 2 examples will only work in DBabble versions 1.1k or later.

    Customizing the Group Categories

    DBabble allows you to change what categories are available for discussion groups (e.g. sports, computers, music etc). There is currently no nice interface for changing these. You need to modify the file group_categories.dat in your dbabble server directory. There are more detailed instructions in there.

    Running multiple servers on the same machine

    You can run more than 1 DBabble server on a single machine. You may want to do this if you have 2 groups of users who you do not want to be able to contact or know about each other. However, if you do this then you must do one of the following options
    1. Each protocol must be configured to listen on a different port (see the port, ssl_port, smtp_port, nntp_port, extra_ports and extra_ssl_ports settings). The only problem with this is only one server will be able to accept incoming email since email (smtp) must be running on port 25.
    2. Or if you have multiple ip addresses for the machine then you can bind each DBabble server to one ip address. Use the DBabble bind_address and bind_address_out server settings.
    If you want to run two separate DBabble servers on the same machine then you can do this as follows. These instructions will only work in versions 2.1n and later.

    1. Assuming you currently have 1 server installed in c:\dbabblesvr then do the following to install a second one.
    2. If you are using ip address binding, configure the bind_address and bind_address_out settings for the first server now.
    3. Stop your DBabble server. Type the given text in a DOS/Command prompt
      net stop dbabblesvr
    4. Move your \winnt\dbabblesvr.ini file into your DBabble server directory
      move \winnt\dbabblesvr.ini \dbabblesvr\dbabblesvr.ini
    5. Create a service to run your original DBabble server.
      c:\dbabblesvr\dbabblesvr -addsvc dbabble1 c:\dbabblesvr\dbabblesvr.exe "DBabble Server 1"
      (the first parameter is the service name, the second the executable to run, and the third is a more descriptive name.)
    6. Make sure \winnt\dbabblesvr.ini no longer exists (it shouldn't if you did the above commands correctly)
    7. Start your original server
      net start dbabble1
    8. Install a new server (by running the server download again) and when asked for a location to install to choose something other than c:\dbabblesvr. For example c:\dbabblesvr2
    9. After the new server has installed move it's ini file into it's own directory like you just did for the first server
      net stop dbabblesvr
      move \winnt\dbabblesvr.ini c:\dbabblesvr2\dbabblesvr.ini
      c:\dbabblesvr2\dbabblesvr -addsvc dbabble2 c:\dbabblesvr2\dbabblesvr.exe "DBabble Server 2"
    10. Open the new dbabblesvr.ini file in a text editor and either change the port settings to new values or specify a value for the bind_address and bind_address_out settings
      notepad c:\dbabblesvr2\dbabblesvr.ini
      For example, change the port, ssl_port, extra_ports, ssl_extra_ports, nntp_port lines to look like this:
      port 8142
      extra_ports 8142
      ssl_port 8143
      ssl_extra_ports 8143
      nntp_port 4119
      smtp_port 4025
      Save and close the text editor
    11. Start your new DBabble server and go to the setup web page
      net start dbabble2
      Go to in your web browser

    1. Assuming you currently have 1 server installed in /usr/local/dbabble then do the following to install a second one.
    2. If you are using ip address binding, configure the bind_address and bind_address_out settings for the first server now.
    3. Stop your DBabble server.
    4. Move your /etc/dbabblesvr.ini file into your DBabble server directory
      mv /etc/dbabblesvr.ini /usr/local/dbabble/dbabblesvr.ini
    5. Change your startup script to start DBabble using the -ini command line option.
      echo /usr/local/dbabble/dbabblesvr -ini /usr/local/dbabble/dbabblesvr.ini >/usr/local/dbabble/dbabblesvr_start
    6. Make sure /etc/dbabblesvr.ini no longer exists (it shouldn't if you did the above commands correctly)
    7. Install a new server (by running the server download again) and when it asks for a destination, type something other than /usr/local/dbabble. For example /usr/local/dbabble2
    8. After the new server has installed move it's ini file into it's own directory like you just did for the first server
      mv /etc/dbabblesvr.ini /usr/local/dbabble2/dbabblesvr.ini
      echo /usr/local/dbabble2/dbabblesvr -ini /usr/local/dbabble2/dbabblesvr.ini >/usr/local/dbabble2/dbabblesvr_start

      Add /usr/local/dbabble2/dbabblesvr_start to your system startup script
    9. Open the new dbabblesvr.ini file in a text editor and change the port settings to new values or specify a value for the bind_address and bind_address_out settings
      vi /usr/local/dbabble2/dbabblesvr.ini
      For example, change the port, ssl_port, extra_ports, ssl_extra_ports, nntp_port lines to look like this:
      port 8142
      extra_ports 8142
      ssl_port 8143
      ssl_extra_ports 8143
      nntp_port 4119
      smtp_port 4025
      Save and close the text editor
    10. Start your new DBabble server and go to the setup web page
      Go to in your web browser
    You should also edit the dbabblesvr_start, dbabblesvr_stop, dbabblesvr_reload and dbabblesvr_restart scripts in your DBabble server directory to specify the ini file. For example, in dbabblesvr_stop, it would now look like
    /usr/local/dbabble/dbabblesvr -ini /usr/local/dbabblesvr.ini -stop

    Upgrading the server when running multiple servers

    • Upgrading to versions 2.1v and later
      Run the standard DBabble server download and choose the upgrade option. Enter the full location of the dbabblesvr.ini file of the server you want to upgrade. Note: Do not choose to start the DBabble service at the end of installation as this will start the default server. (Instead choose "no" and manually start it yourself. (e.g. by typing "net start dbabble1")
    • Upgrading to versions prior to 2.1v
      The server installation procedure looks for the existence of the default dbabblesvr.ini file to decide whether it is performing a new installation or an upgrade installation, and it does not recognise that you have multiple servers installed on the same machine. So in order to upgrade each server you must temporarily rename the default dbabblesvr.ini file to something else and copy the dbabblesvr.ini file for the server you want to upgrade over it and then run the server installation. Do not choose to start the DBabble service at the end of installation as this will start the default server. (Instead choose "no" and manually start it yourself.) Repeat this for each server you want to upgrade, and at the end, restore your original dbabblesvr.ini file. For example on Windows NT assuming you have an extra server installed in \dbabblesvr2 which uses ini file \dbabblesvr2\dbabblesvr.ini and has a service name of dbabblesvr2
      1. copy \winnt\dbabblesvr.ini \winnt\dbabblesvr.ini2 (backup the default ini file)
      2. copy \dbabblesvr2\dbabblesvr.ini \winnt\dbabblesvr.ini (replace the default ini file with the one for the server you want to upgrade)
      3. dbabblesvr15n.exe (run the server upgrade, which will upgrade the server installed to \dbabblesvr2)
      4. Choose no to the question about starting it automatically.
      5. copy \winnt\dbabblesvr.ini \dbabblesvr2\dbabblesvr.ini (the upgrade with have added default values for any new settings to dbabblesvr.ini so replace your original ini file with it)
      6. copy \winnt\dbabblesvr.ini2 \winnt\dbabblesvr.ini (restore the default ini file)
      7. net start dbabblesvr2 (start the upgraded server)


    These figures are for a AMD-K6-2 350 MHz, 128 MB RAM (DBabble does not require a fast machine) running DBabble without SSL enabled. SSL encryption is quite intensive on server performance and you will need to not use it for most users to achieve the performance figures listed here. If you use a faster machine, you can expect better performance.

    Memory Required: 32 MB +
    A standard DBabble server uses about 10-15 MB (+1 MB per 3000 users in database, +1 MB per 50 connected users) under normal operation. However, if DBabble is handling large downloads or uploads, more memory may be temporarily needed. So it is recommended having at least 32 MB available to DBabble.

    Disk Space Required: 30 MB + user storage + forum/chat storage
    30 MB of disk space is sufficient for a DBabble server without any forums or chat rooms and no users. The amount of space you want to allocate to your users is up to you (DBabble has a quota system), but somewhere between 10MB and 50MB per user should be plenty. In practice users who do not send or receive instant message attachments are unlikely to use more than 1MB of disk space. Unless users are posting large attachments or you have forums with thousands of articles, then you will probably not need more than a few MB per forum or chat room.

    Number of Users in Database: 10 million
    DBabble can support user databases of up to 10 million users provided you have enough memory on the machine. (about 4GB for 10 million users.) It needs to store limited information in memory about every user, and the limiting factor is it takes about 10 minutes to start running with 10 million users. If you are prepared to wait longer whenever you need to start your server and have more memory, you can have more users.

    Number of Simultaneous Users: 500 to 5,000
    The number of simultaneous users is depends highly on how they connect and what they are doing. For 5,000 users, this is assuming they are using the Windows client and are able to connect directly to the server and are typically using DBabble for sending on average 30 instant messages a day each. Here at Netwin, we send on average about 20 instant messages a day each through our DBabble server. If your users are connecting to DBabble using a web browser or using the Windows client through a proxy connection ( where they can not keep a connection to the server open and must send http requests every few seconds to find out if they have new messages) then you will only be able to support about 500 simultaneous users. If you expect more than about 50 simultaneous users on a Windows system, make sure you are running a Windows Server rather than a Windows WorkStation.

    Chat Room Simultaneous Users: 100 to 500
    Using direct Windows client connections, a single chat room can handle about 500 simultaneous users.
    However, when using a web browser, it sends a request to the server to check for new messages every 2 seconds and refreshes the list of user's present every 10 seconds. The creates a limit of about 100 users present in a single chat room, or about 200 users spread over multiple chat rooms. If you remove the list of users present frame and/or increase the refresh interval (using the web_chat_refresh setting) you can expect better performance in chat rooms.

    DBabble does not currently support multiple servers sharing the same user database, or server redundancy (we do plan to add this in future). DBabble does support linking multiple servers each with their own user database together for the purposes of inter-server communication. See Linking to remote DBabble servers for more information on this.

    Running DBabble with high numbers of users.

    A single DBabble server can support up to about 10 million users in it's database and up to about 10,000 users online at any one time.

    If you want to have more than about 50,000 users in your database or more than 1,000 users online at a time, you will need to modify some settings. You should increase the user_hash_num setting to at least twice the number of users in your database and 20 times the number of users that will be online at any one time. This setting uses about value*10 bytes of memory, and the higher it is the better performance will be. It defaults to 100,000.

    Versions 2.3 and later of DBabble have built in SSL encryption on by default. SSL encryption is quite intensive on server performance and you will need to disable it to achieve the best performance possible.

    Normally the Windows client keeps a connection open to the server to receive notification of new messages and the server is limited to max_chans simultaneous connections (default of 800). You can raise this value as high as you want, and the server will internally restrict it to the maximum number of connections supported by your operating system. (from 1,000 on linux up 32000 on Windows NT and some unix platforms.) If you increase this on unix systems, make sure you increase the ulimit to be at least 100 higher than this. Edit the dbabblesvr_start script and change the "ulimit -n 1024" line.

    In order to be able to support more than 1,000 simultaneous users on operating systems that cannot support many connections, the Windows client can listen for incoming connections to itself, so it will not need to keep a connection to the server open. The server will automatically check if this is possible for each client by attempting to connect to the client when they login and if not (due to a firewall or proxy server) it will continue as normal. The client_listen_threshold setting (defaults to 400) specifies the number of connections the server must be using before the Windows client will not keep connections open any more. If the Windows client is operating in this mode, it will not know immediately if it's connection to the server has been lost.

    Every minute (which can be changed by the client_check_interval setting, the Windows client sends a very small request to the server to confirm that it is still connected. This normally takes only a very small amount of server processing time, but if you have thousands of users online simultaneously this can become significant and you may want to increase this to every 10 minutes.

    By default once a minute the Windows client checks with the server if any subscribed discussion groups or chat rooms have new posts, and if any discussion groups, chat rooms or user groups have changed names or properties. There is a user preference that controls whether it does this. To set the default to off, in the server administration default preferences page, turn off the preference called refresh_group_list (# 135). You may want to turn this off if you have hundreds of users online simultaneously.

    Every 5 seconds (which can be changed by the web_message_refresh setting, web browsers send a small request to the server to check for new messages. You may want to increase this if you have more than a few hundred web browser users online simultaneously.

    Encryption (SSL)

    DBabble versions 2.3a and later support SSL server to client encryption and public key client to client encrypted instant messages. For versions prior to 2.3a see Encryption in Versions prior to 2.3a.

    What is SSL/TLS and how secure is it?

    SSL/TLS is the same encryption system used by 'https' web pages. It is generally considered to be the most (if not only) secure method for sending sensitive information across the internet, and is the basis of all ECommerce security systems used today. Both the DBabble web interface and DBabble Windows client support SSL. The Windows client defaults to using SSL to communicate with the server so that no one else can view any information sent over the network or internet.

    When installed, your DBabble server automatically creates you a private key and a matching self-signed certificate. Since the certificate is self-signed, when a user visits your DBabble server using a web browser over a secure connection, they will be warned that they have not chosen to trust you. The only way you can remove this message is to get a certificate authority to sign your certificate and verify that you are who you claim to be. This will cost you money. See the How to generate a Certification Authority Request to get a CA signed key section below. The DBabble Windows client you download from your server is automatically configured to know the certificate your server generates can be trusted.

    The private key that DBabble creates for you by default is 1024 bits. This is secure enough for most users. If you really want a longer (more secure and slower) key, you can do this in versions 2.4c and later by changing the server setting ssl_private_key_bits and do the manager recreate private key command.

    In order to generate your private key, random data is required. On OS's such as Windows and Linux there is random data available from the system to do this, but on some OS's such as Solaris your private key that DBabble generates may be predictable, although DBabble does use various system event times, which are kind of random to generate a reasonable key.

    To create a more secure private key, place some random data (1K should be sufficient) in the file random_data.dat in your main DBabble server directory. Stop your server, delete the files private_key_YOUR_DOMAIN.pem and certificate_YOUR_DOMAIN.pem and start the server again. You should only do this soon after installing - if you already have existing Windows client users using secure communication with the server, they will be warned your certificate has changed

    Does my version of DBabble support SSL/TLS ?

    SSL/TLS is supported in the Windows, Linux, FreeBSD, Solaris Sparc, and Mac OSX DBabble servers 2.3a and later. The Windows client 2.3a and later includes SSL support too.

    How to generate a Certification Authority Request to get a CA signed key

    DBabble automatically generates you a private key and self signed certificate. For high level security you should consider getting a certificate signed by a CA. This means that web browser clients can be sure that they are talking to 'your' server and not just someone pretending to be your server.

    A script is provided for Windows machines. Copy the files

    • request.cnf
    • make_req.cmd
    • sslreq.exe
    to a windows machine and at a DOS prompt, type "make_req.cmd" and follow the instructions.

    This will create two files, request.pem and privkey.pem

    Paste request.pem into a CA registration form at a site that provides CA services, e.g.

    DBabble uses OpenSSL encryption / decryption libraries for SSL.

    When the certificate authority sends you your signed certificate, save it as certificate_YOUR_DOMAIN.pem (e.g. in the main DBabble directory.  Also, copy the privkey.pem file into the same directory and call it private_key_YOUR_DOMAIN.pem. (e.g.

    Then restart your DBabble server.

    dbabblesvr -restart

    Keep in mind when doing this, that any existing users who are using the Windows client will be warned that the server certificate has changed. Any new downloads of the Windows client from your server will be pre-configured to trust your new certificate.

    Encryption in Versions prior to 2.3a

    Versions prior to 2.3a do not support encryption, but you can add encryption to the server yourself and add support to the windows client in versions 1.4c and later. This is done by using an external TCP SSL program that takes un-encrypted connections and encrypts them and vice versa. However, we recommend using version 2.3a or later rather than doing this. Here is an example on how to do this using Stunnel (which is free from

    Adding encryption to the server for versions prior to 2.3a
    This is very easy - it took us only about 3 minutes on Windows and about 5 minutes on linux.
    1. Install Stunnel on your machine by following the instructions at
    2. Assuming you have DBabble running on port 8132, and want your users to be able to connect to DBabble on the default https port (443), you would start stunnel (version 3.14) using the command line:
      UNIX: stunnel -d 443 -r 8132 -f (you can omit the -f option once you have it running correctly):
      Windows:stunnel-3_14 -d 443 -r 8132
      You should then be able to access your dbabble server using instead of
    If you want to force your users to use https instead of http, you can set the DBabble connections_from setting to
    Our test server at now supports encryption using this method at
    In 1.4c and later, there is support within the server for automatically start and stop this program whenever DBabble starts, and to also log the output of the program into a DBabble log file. Use the external_process setting to do so.

    Adding encryption to the Windows Client for versions prior to 2.3a
    In version 1.4c and later there is support for including an encryption program within the windows client to allow client to server encryption. This means that you do the work setting it up and your users don't even need to be aware that there is a separate encryption program running on their computer that is started and stopped whenever DBabble is started and stopped on their machine. This is just a temporary solution until we have implemented encryption within the server and windows client. Here is a list of steps you should to do add STunnel to the windows client:
    1. Download from the following files and save them in the DBabble client subdirectory.
      • stunnel-3.14.exe and rename it to stunnel.exe
      • libssl32.dll
      • libeay32.dll
    2. Create the following files in the client directory.
      • client.add, which contains the lines
      • client.ini, which contains the lines
        run_process stunnel.exe -d 8133 -r -c
        run_process_checked true
        where you replace by your server name and port you will be listening on for SSL connections.
    3. Change your server win_host_port setting to
    4. Tell your DBabble server to reload ("dbabblesvr -reload"). The windows client downloads will be regenerated to include the new files, and to automatically run stunnel in the background on their machine to encrypt all outgoing DBabble connections.
    5. Notes: This only applies to new installations of the windows client. If a user is upgrading from a previous version of the windows client, they must manually change their server host setting to from the configuration window. Also note that this will not work properly if they must connect through a proxy server. In this case, they must change their proxy server server setting to and their server host to whatever your server host and SSL port are.


    If for some reason you are having difficulty installing or getting DBabble to work properly, you can try the following

    1. Have a look in the error log file. On Windows this is in c:\dbabblesvr\log\error.log and on unix /usr/local/dbabble/log/error.log. This file might mention a something that is wrong that you can fix yourself.
    2. Windows Only - If there is no useful information in error.log, and you can't get the server to go at all, try running DBabble from the command line instead of as a service. At a DOS prompt,
      • First make sure the DBabble service is not already running by typing net stop dbabblesvr
      • type cd c:\dbabblesvr
      • type dbabblesvr -go
      • This will start DBabble running from the command line, and it will print error messages if anything goes wrong. Press <Ctrl-c> (or type dbabblesvr -stop in an different DOS window) to stop it, or close the DOS window.
    3. UNIX only - If there is no useful information in error.log, and you can't get the server to go at all, try running DBabble without detaching it from the console.
      • type cd /usr/local/dbabble
      • type ./dbabblesvr -stop to make sure it is not already running
      • type ./dbabblesvr -nodetach
      • This will start DBabble running from the command line, and it will print error messages if anything goes wrong. Press <Ctrl-c> (or type ./dbabblesvr -stop in an different window) to stop it.
    4. If you are still not sure what is wrong, we will be happy to help you. We provide free email support during your trial period and for 12 months after purchasing. Just email us at and give a description of what exactly is not working. Please include what system you are using (e.g. "Windows NT 4.0 Service pack 2" or "Linux 6.0"), and what version of DBabble you are using (e.g 1.4f for dbabblesvr14f.exe or dbabblesvr14f_linux_libc6.tar.Z). It is very useful to us if you can send as email attachments the error log and configuration files. (On Windows c:\winnt\dbabblesvr.ini and c:\dbabblesvr\log\error.log) (On Unix /etc/dbabblesvr.ini and /usr/local/dbabble/log/error.log)
    5. If in the unlikely case you find your DBabble server crashes due to an error and must be started again, we would like to know about this so we can fix it. If you can send us the above information (version number, dbabblesvr.ini and error.log), and the following information, we should be able to have the problem fixed (and send you a fixed version) within one or two working days.
      • Windows NT/2000:Most versions of Windows come with a program called Dr Watson. This program needs to be enabled at the time of the server crash to generate the information we need. To enable it, from the command line type "drwtsn32 -i". What this does is catch any program on your machine that crashes, and writes a log file. (which might be at C:\WINNT\Profiles\AllUsers\Documents\DrWatson\drwtsn32.log or C:\Documents and Settings\All Users\Documents\DrWatson\drwtsn32.log ). If you can send us this file it is extremely useful to us in finding and fixing the problem.
      • Unix:When the server crashes, it generates a core file on most platforms. This might be called core or dbabblesvr.core. From the command line in the DBabble server directory, type "gdb dbabblesvr". When gdb has started, type "core core" (or "core dbabblesvr.core" if the core file name is dbabblesvr.core). Then type "bt" and this should generate a backtrace which is extremely useful to us in finding and fixing the problem. Copy the output from the console and send it to us.
      • If you can't provide with one of the files, then the DBabble log/debug.log file can also be very useful. To generate this, you should change the line debug false to debug true in dbabblesvr.ini and restart your server. Next time it crashes, make a copy of log/debug.log and send it to us. Make sure you turn the debug setting off again after generating a log file, as the server can run very slowly in some situations when debugging is enabled.
    6. If you are having problems with the Windows client crashing or giving a program error, please let us know. If you can provide a description of what you were doing at the time of the error that would be useful. The DBabble client can generate a log file, but by default it does not. To generate a log file, run it from the command line using "DBabble -log dbabble.log". When an error next occurs, make a copy of dbabble.log and send it to us.

    Uninstalling DBabble

    If for some reason you decide you don't want DBabble Server on your system anymore, from within your DBabble directory, type "dbabblesvr -uninstall". WARNING - This will delete all files associated with DBabble including all user data, messages, chat rooms and discussions If your users have installed the Windows client on their machines, they can remove it by selecting DBabble in the "Add/Remove Programs" section of the Control Panel.