Search Manual | DBabble Server Management
DBabble Links
Download Now
FAQ
Email Support
Features
Manual
Prices
Buy Now
- 2. - |  |  | Search Entire DBabble Manual - Enter Word(s) to find Introduction Server Administration Administrator Users The Configuration Window Configuration Settings Slave Settings Manager Commands Starting, Stopping, and Restarting DBabble on NT Starting, Stopping, and Restarting DBabble on UNIX Reloading Configuration Files without restarting DBabble Encryption (SSL) Backing up your server Users and Authentication User Authentication POP Authentication DBabble's Internal Authentication External Authentication (Unix, NT, LDAP, MySQL, and Custom Modules) Specifying user details and permissions Specifying user friends, user group, chat room, and discussion group membership Logging in using existing web site cookies Adding Lots of Users Deleting Users HTTP Basic Authentication Logging in to DBabble from your existing web site User Management Automatic login to other Netwin Web Products Using DBabble for online support News, Email, and Mobile Phones Linking discussions to external usenet (NNTP) groups Sending and Receiving EMail from DBabble Receiving Email when you already have an SMTP server on the same machine Sending Messages as Text Messages to Mobile Phones Customizing Customizing the Windows Client Customizing the Windows Client Fonts Customizing the Windows Client Color Scheme Customizing the Windows Client Settings Customizing the Advertisements Customizing the Web Pages Customizing the Languages Available Customizing the User Fields Customizing the Group Categories Multiple Servers Linking to remote DBabble servers Netwin's master server Running multiple servers on the same machine Upgrading multiple servers on the same machine Performance and Problems Server Performance Running DBabble with high numbers of users. Problems Uninstalling DBabble Introduction 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 http://domain.name:8132. e.g. http://free.dbabble.com:8132. Your DBabble server can be accessed securely (in version 2.3a and later) at https://domain.name:8133. e.g. https://free.dbabble.com:8133. 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 http://domain.name:8132/admin. e.g. http://free.dbabble.com:8132/admin. or securely at https://domain.name:8133/admin. e.g. https://free.dbabble.com:8133/admin. 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. Configuration Settings This section of the Configuration Window lets you specify any settings in the configuration file. For more details see DBabble Configuration Settings Slave Settings This section of the Configuration Window lets you specify any slave servers if you are running a master server. 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. The following options are only available from the web browser interface: Basic Configuration This page provides a list of only some common settings. (rather than all settings listed on the Configuration page) Permission Groups This lets you modify permissions of groups of users. (such as disk quota) 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 Click on the "Stop Server" command in the manager commands page Type "net stop dbabblesvr" from the command prompt Stop it from the services applet in the control panel Type "dbabblesvr -stop" from within the DBabble directory To start the service you can either Type "net start dbabblesvr" from the command prompt Stop it from the services applet in the control panel To start DBabble without running it as a service, Type "dbabblesvr -go" from within the DBabble directory To restart the service you can either From within the DBabble Manager Commands, choose "Restart Server" Type "net stop dbabblesvr" then "net start dbabblesvr" from the command prompt Type "dbabblesvr -restart" from the DBabble directory To stop DBabble from starting every time the system reboots you can either Type "dbabblesvr -delsvc" from the command prompt when in the DBabble directory Disable the startup option in services applet in the control panel To enable DBabble to startup every time the system reboots you can either Type "dbabblesvr -addsvc" from the command prompt when in the DBabble directory 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 Click on the "Stop Server" command in the manager commands page From within the DBabble directory, type "./dbabblesvr -stop" To start DBabble From within the DBabble directory, type "./dbabblesvr" To restart DBabble, either From within the DBabble Manager Commands, choose "Restart Server" From within the DBabble directory, type "./dbabblesvr -restart" To stop DBabble from starting every time the system reboots either From within the DBabble directory, type "./dbabblesvr -delstartup" Edit your startup script, and remove the dbabblesvr line. To enable DBabble to startup every time the system reboots From within the DBabble directory, type "./dbabblesvr -addstartup" 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) Backup the files \winnt\dbabblesvr.ini and \winnt\dbabblesvr.exe Backup the directory \dbabblesvr 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) Backup the file /etc/dbabblesvr.ini Backup the directory /usr/local/dbabble 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 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: Download PopAuth from http://www.netwinsite.com/authent/popauth.htm Extract popauth.exe from the zip file into your DBabble server directory (for example to c:\dbabblesvr\popauth.exe) Create a .ini file with the appropriate settings. For example, use notepad to create c:\dbabblesvr\popauth.ini which contains a line like: domains netwinsite.com,netwin.co.nz where the domains is a comma separated list of pop server domains to authenticate with. 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 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. 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: department=sales groups=5,6 friends=test1,test2,test3 ugroups=2 permissions=1 department=accounts 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: http://127.0.0.1:8132/dbabble?cmd_cookie_login=xx_123456789 then DBabble might send a line to the authentication process of the form: cookie_check 4522 xx_123456789 127.0.0.1 and your authentication process might reply: +OK 4522 0 test1 display="Test 1" email="test1@netwin.co.nz" 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. Examples: test100 pass=testpass (Adds or sets user test100 with password testpass) test101 pass=testpass display="test 101" email=test101@test.com permissions=1 (Adds or sets user test101 with password testpass, who belongs to permission group 1) test102 permissions=0 f_root=true (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. 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=true after any user and run dbabblesvr -setusers. For example: test103 f_deleted=true (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=true test104 f_banned=true 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 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) 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="http://free.dbabble.com/dbabble">
           <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. 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. 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 http://free.dbabble.com/cgi-bin/cwmail /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 http://free.dbabble.com:8132/dbabble /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 http://free.dbabble.com:8132/dbabble /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 http://netwinsite.com/dbabble 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 http://127.0.0.1:8132/admin 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: 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 support-dbabble@netwinsite.com 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. 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. Check you have specified a value for the email_from setting. Some email servers may reject a message that has a blank from header. 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. 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 10.0.0.26:25 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 netwin.co.nz 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_". We previously used DMail and did this: We added the following settings to dmail.conf: forward dbabble_*@netwin.co.nz %1@dbabble.netwin.co.nz gateway dbabble.netwin.co.nz 127.0.0.1:2025 no_autohost true forward_from_ip 127.0.0.1 Note that dbabble.netwin.co.nz 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 127.0.0.1:2025 is itself, and the forward_from_ip 127.0.0.1 is to allow DSMTP to accept email from itself when generating a bounce message for an invalid address sent to DBabble. 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_*@netwin.co.nz dbabble_%1@127.0.0.1:2025 We also have to be careful that we don't have any existing email accounts at netwin.co.nz that start with dbabble_, otherwise those users would loose their email. With this setup, we can send instant messages to users via email at dbabble_username@netwin.co.nz, while still receiving our normal email sent to us at username@netwin.co.nz. 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 dbabble.netwin.co.nz, then in that case, we would just have set the smtp_listen setting to "true" and DBabble will receive email sent to username@dbabble.netwin.co.nz.) 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 @phone.netwin.co.nz 6425 +6425 025 phone_gateway @phone2.netwin.co.nz 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 "64251234567@phone.netwin.co.nz". Alternatively, "(021) 345-678" or "+6421 345678" would go to "phone+6421345678@phone2.netwin.co.nz". 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 matt.netwin.co.nz running on port 8132 and another one at bob.netwin.co.nz running on port 80 and you want to link these together so that users on each server can communicate with users the other server. First choose one that will be the master server. We choose matt.netwin.co.nz as the master The other server (bob.netwin.co.nz) 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 bob.netwin.co.nz type dbabblesvr -stop in Windows or /usr/local/dbabble/dbabblesvr -stop in unix. 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 bob.netwin.co.nz 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) 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 bob.netwin.co.nz, we edit dbabblesvr.ini and change the line master to master matt.netwin.co.nz:8132 and the line slave_pass to slave_pass abcd Next we need to tell the master server about the slave server. On matt.netwin.co.nz, edit the file slaves.dat, and add the lines: hid 2 host bob.netwin.co.nz password abcd port 80 program /dbabble max_groups 5 match_ip Tell the master server to reload the new slave data from disk. On matt.netwin.co.nz type dbabblesvr -reload 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 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 http://dbabble.com:4141. 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. Copy the font source file into the DBabble /client directory. In the example, the font file is called comic.ttf 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: comic.ttf 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 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_host proxy.netwinsite.com
      proxy_port 8080
      proxy_local_bypass 0
      proxy_exceptions
      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
2. - 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 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. 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. Windows: Assuming you currently have 1 server installed in c:\dbabblesvr then do the following to install a second one. Stop your DBabble server. Type the given text in a DOS/Command prompt net stop dbabblesvr Move your \winnt\dbabblesvr.ini file into your DBabble server directory move \winnt\dbabblesvr.ini \dbabblesvr\dbabblesvr.ini 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.) Make sure \winnt\dbabblesvr.ini no longer exists (it shouldn't if you did the above commands correctly) Start your original server net start dbabble1 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 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" Open the new dbabblesvr.ini file in a text editor and change the port settings to new values 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 Start your new DBabble server and go to the setup web page net start dbabble2 Go to http://127.0.0.1:8142 in your web browser Unix: Assuming you currently have 1 server installed in /usr/local/dbabble then do the following to install a second one. Stop your DBabble server. /usr/local/dbabble/dbabblesvr_stop Move your /etc/dbabblesvr.ini file into your DBabble server directory mv /etc/dbabblesvr.ini /usr/local/dbabble/dbabblesvr.ini 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 Make sure /etc/dbabblesvr.ini no longer exists (it shouldn't if you did the above commands correctly) 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 After the new server has installed move it's ini file into it's own directory like you just did for the first server /usr/local/dbabble2/dbabblesvr_stop 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 Open the new dbabblesvr.ini file in a text editor and change the port settings to new values 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 Start your new DBabble server and go to the setup web page /usr/local/dbabble2/dbabblesvr_start Go to http://127.0.0.1:8142 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 copy \winnt\dbabblesvr.ini \winnt\dbabblesvr.ini2 (backup the default ini file) copy \dbabblesvr2\dbabblesvr.ini \winnt\dbabblesvr.ini (replace the default ini file with the one for the server you want to upgrade) dbabblesvr15n.exe (run the server upgrade, which will upgrade the server installed to \dbabblesvr2) Choose no to the question about starting it automatically. 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) copy \winnt\dbabblesvr.ini2 \winnt\dbabblesvr.ini (restore the default ini file) net start dbabblesvr2 (start the upgraded server) Performance These figures are for a AMD-K6-2 350 MHz, 128 MB RAM running DBabble 1.5a or later. Newer versions 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 performance figures listed here. If you use a faster machine, you can expect better performance. Memory Required: 24 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 about 24 MB available to DBabble. 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? Does my version of DBabble support SSL/TLS ? How to generate a Certification Authority Request to get a CA signed key #### 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. http://www.verisign.com/ http://www.abaecom.com/ http://www.digsigtrust.com/ http://www.e-certify.com/ http://www.entrust.net/ http://www.equifax.com/ http://www.globalsign.com/ http://www.tc-trustcenter.com/ http://www.thawte.com/ http://www.valicert.com/ 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. certificate_netwin.co.nz.pem) 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. private_key_netwin.co.nz.pem) 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 http://www.stunnel.org) 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. Install Stunnel on your machine by following the instructions at http://www.stunnel.org/faq/install.html#ToC1 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 https://server.name instead of http://server.name:8132. If you want to force your users to use https instead of http, you can set the DBabble connections_from setting to 127.0.0.1 Our test server at http://free.dbabble.com now supports encryption using this method at https://free.dbabble.com 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: Download from http://www.stunnel.org/download/binaries.html 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 Create the following files in the client directory. client.add, which contains the lines
         stunnel.exe
         libeay32.dll
         libssl32.dll
   - client.ini, which contains the lines
         run_process stunnel.exe -d 8133 -r free.dbabble.com:443 -c
         run_process_checked true
where you replace free.dbabble.com:443 by your server name and port you will be listening on for SSL connections. Change your server win_host_port setting to 127.0.0.1:8133 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. 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 127.0.0.1:8133 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 127.0.0.1:8133 and their server host to whatever your server host and SSL port are. Problems If for some reason you are having difficulty installing or getting DBabble to work properly, you can try the following 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. 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. 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. 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 support-dbabble@netwinsite.com 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) 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. 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.