This document builds on the User Manual
and expects some practical experience with Airio tracker from user's perspective.
It first shows limad (see below for the meaning of this strange word) and
admin commands, then moves on to explaining configuration and some internal
workings of the application. It also tells what files Airio uses and what
are the requirements of the application.

Admin is a person that has connected to a LFS server with server
admin password or is working on a dedicated server console. Admin has absolute
control over the server and Airio offers him/her special management and
control commands. Limad stands for limited admin (rights).
Limads connect to server as normal players (without server password) but
Airio assigns them special status based on their username so that they have
some server commands available – they may e.g. spectate or kick people,
depending on other settings.

Limad usernames are stored in Airio.cfg.nc.txt file and can be
easily updated. Limad status can thus be at any time granted or revoked.
FREE version of Airio supports 2 levels of limad rights. People with Level
0 can only use any of the defined prohibited names and this arrangement
is great for team members, once team tag is defined as (part of) a prohibited
name. Level 2 limads have actually special commands available allowing them
to a certain extent manage the server and the races, of which the most important
is the ability to ban and kick anyone currently connected. Airio FULL version
supports two additional limad levels, numbered 1 and 3. The commands available
to every limad level can be fine-tuned in Airio.cfg.lc.txt file.

Once a player is recognized as a limad of sufficient level, he is presented
with a message specifying how to get list of newly available commands –
by typing !lhelp1 resp. !lhelp2 or just !l1 resp.
!l2 (note that the letter is lowercase L). From the list, which respects
limad level of the caller and shows only the items he can really use, it
is clear that most of the commands also have shorter versions available.
Limad commands are just like normal Airio commands – always starting with
exclamation point (!) and hidden from view so that no one else sees
actions of limad (anonymity guaranteed). Only users with limad or admin
status can execute these commands, for other users they are ignored. Some
of these commands just mimic those by default available to admins but others
can be helpful even to people with full control over the server because
they are shorter or a bit advanced versions of the general server (/)
commands.

Limads of different levels can also have special privileges on the server,
again according to adjustable settings inside Airio.cfg.lc.txt file.
Final note before jumping to usable commands: Higher limads rule over the
lower ones, meaning they may e.g. kick them. A limad cannot rule over people
of the same class or higher, with the effect he can never kick e.g. admins
nor himself. Such commands are simply ignored. Limad and admin commands
and messages are not adjustable nor localizable; they are hard coded and
always in Airio original language, English.

Note concerning nicknames: Nicknames and usernames in the
following commands must be (for safety reasons) full (colour codes not necessary),
or Airio will report no such person connected. Because some nicknames are
hard to retype, here are two tricks how to make it easy: 1) Press Ctrl+Shift
which shows usernames in all tables (race results, connection list, above
cars). Read the username and retype it, this is usually easy. 2) Right-click
on the person's nickname (or username, while holding Ctrl+Shift) in the
connection table (displayed by pressing N, maybe twice). Text box
appears with the name. Just jump before the name by pressing Home on keyboard
and type "!ban " (including space) or other command, press Enter and you
are done.

!ban name

This entry calls the /ban command, passing required parameters,
and in effect bans anyone currently connected for the default value of 12
hours. The name is either full nickname or full username of someone
currently connected.

!ban thenuisance – if that player is connected, it will convert
his nickname to username and ban him for 12 hours. If no one with that
nickname or username is connected, error info is shown and the command
does nothing.

!kick name

Only one parameter is required representing full nickname or username
of the player to be kicked from server. Nickname is internally converted
to username which is then used for the actual kick. In case the specified
nickname or username is not found, it is reported as error and no action
is taken. For safety the nickname must be full and not just partial, even
though that would also be possible. This command may be used by limads to
get rid of people spoiling the races or otherwise behaving inappropriately.
Admins may use it if they don't want to search for player's username when
issuing /kick command remotely.

!kick thecrasher – kicks person with that username or nickname
from the server.

Alternative version: !kk.

!spec name

This command has the same format as the previous one, only just spectates
the player by his full nickname using server /spec command. It could
be used as an indirect warning or in case the player is blocking the road
and automated spectating (by default after 30 seconds) by Airio in race
is just too slow. It may also be handy for people ignoring blue flags.

!spec theobstacle – spectates person with that username or
nickname.

If you see a "Parameter not valid" message after issuing the !spec
command, it means the player is not currently on track (already spectating).
In case the specified nickname is not found, it is reported as error and
no action is taken.

Alternative version: !se.

!pit name

As a variation of the above commands, this one returns specified player
to pitlane using server /pitlane command. It again could be used
as an indirect warning or in case the player is blocking the road.

!pit thedisrespectful – sends person with that username or
nickname to pitlane.

!pen 30|45|dt|sg|cl name

Last of the control or restrictive command allows giving/clearing
penalties. You must always specify penalty type and the nickname or
username. 30 and 45 are seconds, DT is drive-through,
SG is stop-and-go, and CL means clearing any currently active
penalty of that player.

Limads must be able to control the races, though in a limited fashion.
They also have other commands at their disposal showing details about players.

!restart, !qualify, !end

Very useful commands allowing limads to restart the race at any time,
start qualification session and end current race. By default Airio blocks
race restart voting once the race first lap is completed (with some exceptions,
like when there are only a few people racing or the race takes too long).
The !restart command will overcome the limitation and immediately
restart the race. It just calls /restart. Note again that the mentioned
default race restart voting restriction (only in lap 1) is freely configurable.
The other commands just call /qualify resp. /end LFS server
commands.

Alternative versions: !re, !qu.

!ax [i|o|e|a] [layout]

When used with i switch it will list layouts for current track
available on the server. Any of them can then be loaded using o switch.
Loaded layout is cleared with e switch. You may set autocross lap
count using the a switch.

!players

This command shows connected players' status describing admin/limad,
licence and some car settings plus lagging. There's nickname and username
together with his limad/admin status (if any). Then follows guessed demo/licensed
status of that player based on number of items in his personal LFSW data.
Note that it is not directly possible to get information about licences
(Demo, S1, S2) of individual connected players and their licence status
may not be always shown correctly, as in case of person that is new to S1/2
and did not make any laps (or deleted that data) on more combinations than
available in demo. Once LFSW PubStats offer this information (feature request
already posted), the code will be updated.

What follows are info about car settings he is using like brake help,
automatic clutch, mouse/wheel, ABS and similar data. The line ends with
a number representing lagging percentage, which should be as close to zero
as possible. Lagging is observed only during races, not in practice or qualification.
Experience shows that lagging close to 1 percent is very inconvenient for
other people, because that car is disappearing or jumping wildly around
the track. People close to 1 percent of missing car position packets (which
is lagging) are likely to be often spectated or later kicked under default
lagging filter setting.

Alternative versions: !pl.

!recent

Very useful command showing the list of 12 recently disconnected (for
any reason – kick, security, disconnect) people, their nicknames and usernames.
This is very handy if someone causes a big crash and then quickly disconnects.
If you did not catch the crasher's registered username but still need to
ban him, just call this command and use the displayed data. But also note
that only limads level 3 (available in FULL Airio version) and admins may
ban unconnected people.

Race control messages displayed with simpler commands and disappearing
automatically after a set time may also be useful for both limads and admins.

!rc [message]

RC stands for Race Control (message) and it allows limads and
admins to set and show the messages that appear in big letters in the middle
of the screen. Actions of this command depend on what parameters are specified.
Calling !rc without parameters just clears all earlier sent messages
that are currently displayed. If some text follows the !rc, this
command takes the message and stores it for later display. The message is
not shown to anyone immediately – for that other forms of the !rc
command are necessary.

!rc All crashers leave! – stores the message to be shown
later.

!rc – clears any displayed messages, if the timer (see next)
did not clear them earlier.

Just note that the messagemust not start with a number
that could be misinterpreted as display time (see below). Setting the message
as "5 minutes break now" would not do what you expect – it would try to
display some previously stored message to person called "minutes break now"
for 5 seconds, and this act will fail miserably. The parameter "Now 5 minutes
break" is correctly interpreted as new message to be shown by the next command.

!rc time [name]

When an integer (delimited by spaces) is seen after the !rc command,
it is interpreted as the time span in seconds for which the previously stored
message should be shown. When no name is specified the message is
displayed to everyone connected. If you want the message to be shown for
some not yet specified time, enter !rc 999 or use even higher number.
You can clear that message any time by issuing simple !rc command
without parameters.

If you want the message to be sent to some particular player, specify
both time and full nickname. You cannot send RC messages to spectating players,
only to players on track. If the entered nickname does not exist (or the
player is not on track), you'll see "Parameter is not valid" system message.
Note that if you just want to change some already displayed message, you
must first define a new one and then send it again.

Another group of limad/admin commands controls Airio state with substantial
impact in many areas. They should be available only to highest limads (level
3 in FULL version) and admins, because of the potential damage they may
cause.

!checks [on|off]

This command turns on (default state) and off all active additional
Airio checks like idling, cursing, wrong way driving, repeated joining
etc. If these checks are turned off Airio just tracks and displays statistics
(split/sector/lap times) of every player and race as a whole. This mode
is useful for some special occasions like having a closed race for invited
people only when it is clear that everyone is interested in nice racing
and the checks could have negative impact – e.g. spectating a player that
just needs long time to get off the gravel. Turning off checks is also necessary
for some layout configurations and stunt racing. If neither on nor
off is specified, this command shows current Airio state. Using the
!cfg command and knowing configuration keys it is also possible to
turn on and off individual checks (see user manual for their list) as well
as other externally defined settings.

Alternative versions: !ch.

!lock [per]|[on|off|auto]

By this command it is possible to lock or unlock the server for newcomers,
players that did not yet score some definable reasonable time, either on
your server or on any server if LFSW stats are available. The !lock
command does not make the server private, it just does not allow anyone
without reasonable PB data to join the race. Such a player is required to
leave while newly connecting players with recorded good lap times (by default
1.05 x WR for current track and selected car) may freely join. The command
without parameters displays current server time lock state.

The command may be used to ensure nice racing without "moving obstacles"
on track once the user base is large enough. It complements special Airio
settings allowing to define "prime time" when the server will lock and unlock
automatically. These setting allow you to define required lap time, start
and end of the prime server usage period and also number of players when
the lock is activated and deactivated. For more information see the server
configuration file (SRV). A few examples now will hopefully make clear what
the options are.

!lock on – just turns on the lock under current settings
and displays lap time of default car needed to join the race. The lock
will stay active regardless of other circumstances.

!lock off – turns the lock off and the time lock remains
off regardless of detailed prime time settings in server configuration
file.

!lock auto – switches the time lock function into automatic
mode, running according to detailed configuration data, switching it
on and off as required.

!lock 450 – sets the time required for joining race to 4.50
percent above current WR in the car the player intends to use. Real
time for default car is displayed for your information. Note that for
the sake of flexibility the time will be not rounded to some nice value.
If you want exact number, try using different percentage values. The
lock mode on/off/auto is not changed by this version of the command,
only the percentage value changes.

Alternative versions: !lk.

!grp [num]

This is a command for grouping races into series (5 races are
1 serie, by default). If used without parameter, it clears the current serie
data, starting a new round. When a number is specified, current serie is
cleared and new one with the set number of races started.

!grp – clears current serie, starts a new one without changing
the number of races.

!grp 2 – clears current serie, starts a new one for two races.

!len [–96÷+96]

This command accepts values from –96 to +96. It is used for setting
up race length. Positive values are simply laps to be done. Using zero
turns the server into practice mode. Using negative values sets race length
in minutes. The race is then for set number of minutes plus one lap. This
nice feature uses a little trick: By specifying negative value you in fact
set racing for that number of hours, but Airio is checking the elapsed time
whenever leader enters new lap and once the total time in minutes is larger
than race length in hours, one more lap is added and race is turned into
normal one for set number of laps.

!len 5 – race length will be set to 5 laps.

!len -25 – the race will be for 25 minutes plus one lap,
confirmed by race control message at the start.

To switch between races for minutes and laps you must use this
command. Specifying simply /laps=5 after race for minutes will not suffice,
because Airio must renew last used minute setting just before the race start
and it will ignore currently specified number of laps.

!pall, !sall

These simple commands send all cars to pits or among spectators. You
may use the global spectating after race when some changes in configuration
need to be reapplied. For example car tyres are checked only when a player
is joining race, not later. This means if you prohibit his tyre type later
and type !rld, he will stay on track with disallowed tyres. Typing
!sall spectates all people, forcing them to join again, with all
the joining checks now using updated values. The !pall command just
calls /pit_all.

It is possible to assign to limad categories other commands mimicking
those of LFS server itself. These commands have the same format as the LFS
original, only start with ! instead of /. Currently the following
commands are supported: !tracks (sent as /track for collision
reasons), !cars, !weather, !wind, !laps,
!hours, !qual, !vote, !midrace, !mustpit,
!canreset, !msg, !pass. Parameters are passed just
as received, no validity checks are done. See LFS documentation for meanings
of the mentioned commands. All these commands can be found with short explanations
and possible parameters in !l3 output.

Every player connected as an admin sees not only the user welcome message,
but also instructions how to display list of limad command (see previous
section) and admin commands – by typing !ahelp or just !a.
These commands have great power and can cause troubles, so please be very
careful and think twice before sending them to Airio for processing.

First group of commands basically allow some manipulation with PB files.

!remove [car|*] [track|*]

This command removes all stats for certain tracks and/or cars.
It allows you to delete e.g. all data for FBM on BL1, or all data for FBM
on all tracks (denoted by *), or all cars (also specified as *)
on BL1, and also all cars on all tracks. It is clear this command is very
dangerous and must be used with extreme caution. It is reversible only by
stopping Airio, rewriting STA files from latest backup and starting Airio
again.

!remove – deletes all gathered stats on your current
track and your current car.

!delete [car|*|**] name

This command deletes player's stats from PB file. The deleted
data cannot be automatically recovered, so one needs to be careful with
this command. The command always expects player's full username as
a parameter. Optionally it is possible to set also car for which
the player stats should be erased. If car is not specifies, your current
car is used. Before issuing this command it is advised to use !pb
command with the same format. Once it returns correct data that are to be
deleted, you may just replace !pb with !delete.

It is also possible to delete player's stats not only for current car,
but for all cars on current track. In that case use * as car code.
If you are really angry at someone, you may delete all his stored stats
for all tracks and all cars. Just use ** as car code, but make really
sure you are entering the correct username.

!delete thehacker – deletes the player's statistics for the
current track and the car you are in.

!delete * thehacker – deletes the player's statistics for
the current track and all cars he ever used on your server.

Output of the command summarizes what was actually deleted, but the action
is not reversible, unless you stop Airio, replace SAT files from backup
and start Airio again.

Alternative versions: !del.

!clr [t|c]

This is one more command to manipulate with statistics. It clears
temporary data stored on two levels called total and championship.
They are definable periods for which some racing data (lap times, race times,
points) are updated and then automatically deleted. Using the t switch
will delete all temporary data at total level, c switch does the
same for championship level. Routines of this command may be called automatically
by setting specific values in days in common configuration file. For more
on this see the configuration section. Output of the command says what level
of temporary data was deleted.

!state [num]

If you are interested in current server state, call this command. It
will show you not only the server name, but also race type (laps, hours),
value (number of laps or hours) and other server data like number of connections
and players, wind, weather, allowed voting, midrace join, active Airio checks
and server time lock, among others. If Airio is connected to several servers,
you may call up the state of any one of them using the internal number.
If 0 is specified, summary of all servers with short state descriptions
is displayed.

Alternative versions: !st.

!reload

This very useful command allows to update all configuration data without
restarting Airio. There are several external text files that are read
on Airio initialization. If some data need to be updated (e.g. add new word
to curse list, define new limad username, or update speedtrap position,
see below), it may be done by direct editing of these files on the server
(or overwriting them with new versions). Saved changes are not updated automatically
– but you can require immediate update of the information by issuing
!rld command. All external configuration files (except CON and STA files)
will be read once again and new settings will be valid from this moment.
Just note that for a limad status to be applied to currently connected player
he must reconnect (because it is assigned only on connecting).

Alternative versions: !rld.

!cfg key=value

In the common and server configuration files the entries are specified
using key=value pairs. The !cfg command allows you
to enter any such item and its assigned value manually. You could do the
same by opening the appropriate configuration file, updating a value there,
saving the file and using !rld command to apply the changes. However,
if you do not have time for his procedure, you can use the !cfg command
for temporary changes. They are temporary, because they are only
in memory and if you reload configuration files later, the data specified
there will be again valid. If you want to use this command, you need to
be aware of the key you need and accepted values. Once you get these two
items in the correct form, Airio will confirm accepting the new temporary
value.

Airio is run by simple opening of its main EXE file. It reads available
configuration files (see below) and tries to connect to servers according
to specified settings. After connecting successfully to a server it performs
initialization and lets everyone know it is now in charge. There are additional
commands controlling run of the application and connection to LFS servers.

!aini

This command cleanly restarts the Airio tracker. It may be used
in a situating when an internal error occurred and some commands do not
provide correct output, if any at all. The Airio tracker is stopped on all
connected servers, data saved and then a new instance for each server is
created. Airio starts gathering new data and for a minute or two it may
report slightly strange data, like very high split times as best in the
race etc. This is normal start-up behaviour.

As noted earlier (and explained in detail later) one running instance
of the Airio tracker can easily manage and control several LFS servers at
the same time. This arrangement saves resources, simplifies configuration
and allows for some advanced features like having one common communication
thread for all LFSW PubStats requests and one common data repository with
new PBs on one server immediately available on all the remaining servers.
The !init command reinitializes Airio on all configured servers,
not only on the server where it was actually issued.

Alternative versions: !ai.

!quit

This command cleanly closes the Airio tracker. It means that all
current data are stored, all opened connections closed and all used resources
properly freed. Always use this command to stop Airio – the same may be
done by pressing Q in the command console seen on server. Direct
killing of the process may have undesirable side effects – damaged PB files,
incomplete system log file etc. The command actually does not end Airio
process, only stops all data processing and moves it into suspended state
from which it can be safely killed. On server console killing is not necessary,
one more press of Q closes Airio completely. Note that once Airio
is in suspended mode, it may only be closed as it does not accept any commands
and does no processing. Also note that like in the previous case the
!quit command closes Airio on all connected servers, not only
on the current one.

Alternative versions: !qt.

!join num

When something goes wrong with LFS server itself, Airio disconnects from
it. Then it tries to reconnect every 5 minutes, indefinitely. If you cannot
wait this long, use the !join command for manual reconnection
with appropriate server number. Airio will inform you after a while if the
connection succeeded or not. This command may also be used when adding new
server to be managed by a running Airio instance. I may hint here on the
procedure, because it is pretty simple: Just put new Airio.con.?.txt
file containing required connection data into Airio folder (? here
represents unique server number). Again, Airio would connect and start managing
the new server automatically within 5 minutes, but you may gain a bit of
time by requiring the connection manually.

Alternative versions: !jo.

!part num

Naturally, this is the opposite of the previous command, allowing you
to disconnect Airio from any server, and only from that one. As mentioned,
Airio would under normal circumstances try to connect back within 5 minutes,
so there's a little trick to prevent that: The appropriate Airio.con.?.txt
file is renamed, so that Airio would lose necessary connection data. When
you finish the server maintenance or solve whatever reasons you had for
disconnecting Airio from that server, you may just use the !join
command which will rename the CON file back and use it for connecting. However,
you may also rename the CON file manually and wait a while for automatic
reconnect.

!log

This admin command copies to the chat console in real time entries
(pertaining to current server or Airio instance as a whole) being saved
into system log file. It is great far watching some internal Airio events
and detailed info about actions it takes (e.g. why someone was spectated
or kicked). There can be only one system log redirection for all connected
servers at one time. Issuing the command by another admin or on another
server cancels the previous target and assigns new target. Once the command
is issued from current redirection target the messages stop. The same happens
if the target is lost (disconnected), but it is always better to turn off
the log messages manually.

Lets make it clear: First !log entry turn on log display and on
any decently used server you'll be flooded with log data. Using !log
again stops displaying the log entries. Watching the lines appearing will
give you a good understanding of Airio and the LFS server internal workings
and events that are captured. To get a bit deeper understanding of the info
you see check out the system log file description below.

!imp

This command without parameters imports data from LFS Lapper's PB.txt
file and converts them into Airio format. You may use it just once when
switching from LFS Lapper to Airio to import all previously saved stats
in the extent LFS Lapper allows. The import rewrites current Airio data
and thus it is not recommended to call it later, after some data were accumulated
by Airio itself, because that operation will result in data loss. The
PB.txt file is expected to be in Airio directory.

When importing the data Airio by default checks everything. Unfortunately
LFS Lapper's file may contain wrong information, such as missing car types
or sector times close to zero. During import all unrealistic or incomplete
items will be removed, just as items exceeding set statistics limit time
(100 percent of WR by default). This all helps to start with clean and reasonable
imported stats.

!exp

As you may expect, this command does the opposite of the previous one,
exporting Airio data into LFS Lapper PB.txt file. You may use it
when switching from Airio to LFS Lapper but it also can be used if
you need the Lapper file for some other reason like publishing Web stats
using a custom-built PHP script. Naturally, you may create a new script
reading directly Airio STA files – if you want to do this (and perhaps make
the script publicly available), contact me and ask about STA files format.
Just know that STA format is more complicated with data spread hierarchically
across three of four separate files. You should also note the possibility
to require automatic export to PB.txt in set intervals. With that
arrangement you will always have reasonably up-to-date personal best data
in LFS Lapper format to work with. For more info see the common configuration
file (CFG).

Software

To use Airio your system must meet certain requirements:

Airio is written in C# and it requires .NET Framework 2.0 or
newer installed. If your PC can run this framework, then Airio will
run as well. It has been fully tested under Windows XP and Windows 2003.
Also the possibility to run it reliably under Mono in Linux is now confirmed
from several sources (you need to install mono-runtime, libmono-corlib2.0-cil,
and libmono-system2.0-cil).

Airio can correctly connect only to a dedicated LFS server.
It is a server management tool and currently it will behave strangely
if used in single-player mode or when connected directly to LFS game.
The dedicated server must also run with system messages in English for
some cool features to function, but I'm not sure if this is in fact
configurable.

Hardware

Here I'll try to summarize the Airio hardware requirements:

The application just waits most of the time for some events to process
and thus it is not much CPU-dependent. On a PM 2GHz machine it was on
average consuming at maximum 5 to 10 percent of the CPU capacity with
four servers and 40 connected users managed at the same. There may be
some peaks in the usage when long lists of several thousands users are
sorted (outputs of !sb or !pm) or repeatedly searched.
Generally any reasonable processor, say 1GHz (but slower would
suffice as well) can power Airio.

Airio memory requirements for managing users and storing their data
are not huge. Airio requires maximum 30 or 40 MB of system memory
for four concurrently managed servers – most of it for the .NET environment.

Disk space requirements are in units of megabytes and thus negligible.

All communication with the LFS server(s) is done using TCP, so you
need a computer (or connection) where that protocol runs smoothly and
reliably.

Communication

To use all available features some external communication is required:

If you want to have LFS World data available, you must create
and use a PubStats key (see configuration section). Once that key is
set, Airio will require some data from LFS World. By default it downloads
compete WR (world record) table once an hour. It also requests and downloads
complete PB (personal best) table of everyone connected to server. This
table is downloaded again when that person improves one of his LFSW
PBs.

By default Airio sends each minute summarized data from servers
it is connected to, the so-called local stats. They are primarily
version string, names of the servers, total number of servers, connections,
and number of players of that one Airio instance. These data are used
in global stats calculations with results sent back to Airio.
You can see the data returned in !ver (or !info) command
output. Anyone thus may see how many Airio instances are running and
how many servers and people they currently manage. The sent local stats
are handled by an ASP.NET script/page allowing anyone to see all currently
running Airio instances and managed servers. Just browse to
Airio Servers page.

The above are the only external communications taking place in FREE version
of Airio. The protocol used is TCP and you may need to make sure such requests
from Airio and responses are supported in your computer connection configuration
(firewalls, communication shields).

Transferred LFSW data volume depends on the server(s) usage. The more
people are connecting, the more data are downloaded. For example WR table
represents approximately 40 KB (kilobytes) of data. People's PB tables may
have size from 1 KB to 50 KB. Generally speaking, these bandwidth requirements
are not high, especially in comparison with data sent and received by LFS
server itself about people's cars and other events.

Local/global stats are sent and received once every minute. Depending
on number of servers each request (local stats) will represent 30 to 100
B (bytes) of data. The response is approximately 30 B. It is obvious that
communication requirements of this feature are rather negligible – unless
you have a compelling reason to do so, please do not turn off sending Airio
local stats (but note that you have the option). This will make sure the
displayed data are meaningful to you and all other Airio users.

The Airio archive available for download contains a number of files.
Some of them are required for the application to run, some allow you to
change configuration options, some are created automatically, and yet other
you may create yourself. All the Airio files are in one folder (directory),
there are no subdirectories. Unzip the files to a new folder on your computer,
ideally on the machine where your LFS server(s) run. Lets look now at the
files and their purpose.

Required

These files are necessary for running the application. If some of them
is missing, then Airio will not start, it will shut itself down or report
errors soon.

Airio.exe – Naturally, this is the main application file,
the one you run when you did some basic configuration and are trying
to connect the system to your server(s). Airio is a console application
and the best way to start it is by double-clicking on Airio.exe
file. Hint: Try pressing spacebar in the Airio console
window. You'll see a list of commands called by pressing other specific
keys – showing state of server(s), connected people or players, all
this in nice textual tables.

Airio.pdb – This is a debug file of the main application.
If there is some bug in the code, extensive error data are saved into
Airio log file allowing for easy debugging.

Airio.wrs.txt – Current world records table. The data stored
there are important for many internal Airio calculations and without
this file Airio refuses to start. It is best if the file is updated
automatically every hour; it is admin responsibility to configure Airio
in such a way (see the configuration section).

Connection

The most important of configuration file(s) are the connection data,
CON. Each server has its own CON file with all necessary data. The CON file
also specifies in its name the server number as used internally by Airio.

Airio.con.?.txt – Connection file specifying LFS server
to connect to. IP address of the server (may be local, 127.0.0.1), InSim
port (as defined in server configuration file or by /insim command,
usually around 30000), and server password must always be set inside
the file. The ? in filename represents unique server number used
internally by Airio and must be from 1 to 4, numbering the servers somehow
logically to you. There are other files and commands using this server
number, so you should know which server has what number. Once again,
because this is very important: You set server number by the filename,
inside the CON file you then specify connection to the server.

When Airio starts it reads in sequence all existing CON files with numbers
from 0 (reserved for local testing) to 4 (but this may be anything higher
in FULL version), if they exist. Based on the data it tries to create connection
according to stored configuration data. If it succeeds, new handler is created,
initialized and starts gathering the information and acting upon it. If
connection for some reason fails then that server is simply skipped and
next one is processed. This allows for any combination of servers to be
active. These configuration files are read only when Airio starts, is restarting
after !aini command or reconnecting to some server automatically
or manually by !join. This is the time when any changes to Airio.con.?.txt
files are reflected.

In the following files you configure various settings applied generally
or to individual servers.

Common Configuration

Besides CON file(s) the other configuration files are not necessary for
the application to run but they allow you to change Airio default values
in many aspects. Lets look now at the common configuration, CFG, files.

Airio.cfg.txt – Common general configuration file. Inside
you'll find setting used by all managed LFS servers. There are non-server
specific data like IdentKey for LFS World downloads, logging, defining
cars and tracks and such. Open the file, read the extensive comments
there concerning individual items, change or update what is necessary.
Find out more info about values you should change before running Airio
for the first time below in the configuration section of this document.

Airio.cfg.tc.txt – Common (to all connected servers) track
and car configuration file. Here you can define default cars (which
are assigned to every new connection before the player joins the race)
for specific tracks, times considered and optionally reported as good,
prohibited tyres, prohibited passengers, restricted zones and similar
items. The file has hierarchic structure and contains some default demo
tracks/cars settings and explanation of all usable items.

Airio.cfg.nc.txt – Common name/language filter configuration
file. Inside you can define two categories of names: 1) usernames of
limads that get special rights after connecting and 2) prohibited (parts
of) names, for which players are kicked. Read above what limad is. This
file also contains definitions of language filter consisting of three
parts: 1) character replacements applied first, 2) the bad words themselves,
and 3) exceptions to bad words. Again see the comments inside the file
to get more detailed information.

Airio.cfg.lc.txt – Common limad/commands configuration file.
While limads themselves and their categories are set in Airio.cfg.nc.txt,
items in this file allow you to fine-tune commands actually available
to limads by their levels. You may also choose the level of protection
limads gain and set the system so that they are never kicked (which
looks bad) or are able to breach certain rules.

Server Configuration

Common configuration is applied unchangeably to all servers in the site
(managed by one running Airio instance). Server configuration files, SRV
and FIL, contain items that can be adjusted on individual servers. These
servers are set by numbers corresponding to numbers used in names of CON
files

Airio.srv.txt – This is the general server configuration
file. The settings inside are by default applied to all servers in the
site, but any value can be changed on any server. This file offers many
options, with every one explained in detail using comments (starting
with #). Inside you'll find optional message definitions, vote
management data, server locking, points and other items.

Airio.fil.txt - Inside are various filter settings. They
may be also in SRV files and this special filter configuration file
was created only because it helps to separate items logically and to
have two smaller files instead of one large file.

Airio.srv.?.txt – This file configures only server
?, which is the number corresponding to particular CON filename
and real server defined inside. In this file you may use any key from
Airio.srv.txt and assign it a different value, overwriting (and in case
of messages extending) the general configuration with more specific
data.

Airio.fil.?.txt - Definitions of filters for individual
servers, if they should differ from values in the main FIL file. You
may also include these items in Airio.srv.?.txt file, if there are just
a few changes.

Once you understand the principle of server configuration, you will realize
it is versatile, live, and hierarchic. By versatile I mean it gives
you many options. It will also be easy to add new options later, because
it just means creating new key=value pairs. By live I mean
anything can be updated (by editing the CFG or SRV file) while Airio is
running and applied without restart (by calling !rld). This reloads
all external configuration files and updates internal settings accordingly,
without players realizing this was done. By hierarchic I mean the
config data are on three levels: There is common configuration CFG, there
is general server configuration SRV/FIL and there is specific server configuration.

Worth mentioning again is the !cfg command. Using !cfg key=value
you may temporarily change any item from the config files. The exception
are items from CFG.TC and CFG.NC files which cannot be updated in his fashion.
Final note: Server configuration files are read in the above shown order
with the last defined value applied. This means that when you have the same
key but different value in Airio.fil.txt and Airio.srv.1.txt file, the one
from server-specific file will be used.

Language Files

One of the coolest Airio features is the ability to fully customize and
localize all user messages. Lets take a look at what you can have and what
can be done.

Airio.msg.en.txt – This file contains definitions of all
Airio user messages. These are lines of textual information that can
be seen by normal users. You can change the text of any message you
do not like, but please make sure it is still understandable. Note that
limad and admin messages cannot be changed, they are hard coded into
the application and are always in English (well, as far as I'm able
to write in that language).

Airio.msg.cz.txt – Localized user messages file. This file
shows how easy it is to support more user languages in Airio with everyone
able to select at any time a different language in which he wants to
see the messages. The file contains complete Czech localization. Once
you put the file into Airio folder (and type !rld, if the application
is already running), a new language option will appear in user preferences
and the language can be changed by a simple click.

Airio.msg.??.txt – In Airio distribution there may
be other localized message files. These may also be available in the
form of language pack available with latest additions/corrections on
the Airio site. In any case, to have such translations available, just
put the files into Airio folder and type !rld.

If you want to create other localizations, just copy the EN file, rename
it e.g. to Airio.msg.fr.txt and translate all the values of key=value
pairs. When you are done (which will take some time, because there are some
300 user messages defined), save the file into Airio folder, type !rld
and immediately you'll see FR language as a new option.

You are not limited to translations when dealing with user messages.
You may e.g. create an Airio.msg.ns.txt file and specify inside (one
of the keys at the top) that this version is NASTY. It may still be English,
but you'll adjust the messages in some "nasty" fashion. Just note there
may be only 2 letters in the file name specifying (language, whatever) version.

Also note that it would be nice of you not to change the default English
messages, because people may be used to them from other servers running
Airio. Also there may appear new messages in future Airio version requiring
you to overwrite the original file. Rather create a new language version
in the manner I just mentioned. If some item is not specified, default message
equal to official EN version will be used, so you may redefine just part
of the file and delete the rest.

Statistic Files

Many data gathered by Airio are made persistent, that is saved to disk
in regular intervals. They are the statistics of individual players, their
personal settings, tracks/cars they used, lap/race times they achieved and
many, many more. All the available stats are explained or mentioned in Airio
User Manual. The stored data are in four STA files, again hierarchically
arranged. Note that Airio distribution may come without STA files, in which
case they are created as empty.

Airio.sta.un.txt – This file stores username, nickname, and
personal settings of every player. If a player changes his nickname,
it will be reflected in this file only. Username (registered at www.lfs.net)
represents highest entity in Airio, everything revolves around usernames.

Airio.sta.tr.txt – This is a file of track statistics. It
stores track-level data for each user, such as points and other total/champ
level information. Track is the second level of the Airio internal hierarchy
(remember that username is the first).

Airio.sta.cr.txt – Here is the 3rd level of the hierarchy,
file of car statistics. Inside are car-level data for each user and
track. These data are primarily best sector and split times, the core
of !pb listings. There is also a date the PB was made and number
of laps done by that player on this track and in this car.

Airio.sta.ac.txt – This file is on the same level as car
stats, but it stores separately data from autocross layouts. Airio recognizes
autocross layouts by their names and shows separate statistics for each
of them, just like they were different tracks. Note that if you change
layout name on server, Airio sees the layout as a new track and will
start to gather new stats. If you on the other hand use different layout
with the same name, Airio cannot see the difference and will start to
update existing data.

Text Files

There are a few more text files allowing for some more customization
and communication with users.

Airio.txt.fq.txt – You may optionally put into this file
lines of text shown when a user clicks the Server FAQ button
on the personal settings screen. Each line will be shown as one button,
so you need to use lines of correct suitable length. Just save the file
and click FAQ, no !rld is necessary here.

Airio.txt.nt.txt – Same as above but the text entered should
contain Server Notes, if you can come up with any.

Airio.txt.rl.txt – Same as above but the text entered should
contain Server Rules and you certainly should come up with some.

Airio.rep.txt – This file is created by !rep command
and contains reports or comments sent to you by users. It is a good
idea to check for presence of this file regularly and delete it once
its items are dealt with.

System Log

The system log was already mentioned as a very interesting feature in
the !log command. Basically it is a text file storing continuously
all important events on all servers managed by Airio.

Airio.log – This is the record file used for all connected
servers. When being backed-up (on server midnight, every day) this file
is flushed and closed, copied as Airio.log.txt, and zipped together
with other configuration files. The file is then rewritten and starts
to store new day's system log data.

Airio.log.txt – As apparent from previous description, this
file stores complete yesterday's system log. It is also included in
back-up of the previous day.

Each line in the syslog file starts with server date and time. Then follows
XXY where XX is short site identification and Y
the server number (as set by connection files) where the action occurred.
In case of some global action (like downloading WR table, common to all)
there is no XXY tag. Then may follow a message exactly as seen in
the LFS chat area (including system messages and players' commands). In
case there is some Airio action, it start with CxxPyy
where xx is connection ID and yy is player ID
of a specific man. These are very important LFS data used extensively inside
Airio. Then it is clear what action Airio took and why, like who was warned,
spectated and kicked and for what (e.g. what word in his message was seen
as cursing or how many times he was seen as driving wrong way). The log
may be used for detailed analysis of events and their sequence. It notes
when certain events happened and may give answers to many questions of "why
this happened" type.

By now you should have a general idea concerning configuring and running
Airio. Let me just repeat that all configuration is done using external
text files and that anything configured may always be changed "live", without
restarting Airio, just by issuing !rld command. This section looks
in more detail at the settings you must, should and may configure before
running Airio. Note that the configuration files contain lots of other settings
not mentioned here, but each one with several lines of comment that makes
its purpose clear.

Open the Airio.con.1.txt file and define inside the connection
to your LFS server number 1. IP address, InSim port and server password
are the necessary data. The IP address may be local (default)
or any other static address. Airio can connect to remote servers, but
in that case there may be other configurations required on the target
system, such as opening TCP ports or defining firewall exceptions. The
InSim port number is specified inside LFS server configuration
or by /insim command. Each server must have unique InSim port
number, usually around 30000. The password is admin password
set at LFS server. Airio is always connected with admin privileges to
do its stuff.

If you want to connect one running instance of Airio to second server,
copy the Airio.con.1.txt file and rename it to Airio.con.2.txt.
Open the file and define there connection to your second server. FREE
Airio version supports four connections (meaning you can also create
files Airio.con.3.txt and Airio.con.4.txt), in the FULL
version the number of servers is fully configurable and changeable parameter
with upper limit set only by your computer's abilities.

Once you have connections defined, you may run Airio (by double clicking
Airio.exe). It should start and connect in a short while sequentially
to all defined servers. You can see in the application console to which
servers it connected. If a connection cannot be established, check the data
in the appropriate CON file, especially the InSim port and password. If
you find out there was a mistake, correct it, save the file and then press
R in the console window. This will restart Airio, read the CON files
again and try to establish connections according to updated settings. If
you want to stop Airio, press Q in the console. To see the available
commands there press spacebar.

While not absolutely necessary, it would be good to do a few more changes
before you start Airio.

Inside the Airio.cfg.txt find a key labelled ServersID.
As the comment there mentions, you set here a very short name of your
server(s), say two or three capital letters. It may be a tag of your
team or anything else but for the global statistic purposes (as shown
with !ver command) use something unique. For example on AirAttack
servers we use ServersID=AA. This tag is then used to shortly
describe your servers in system log.

Still inside Airio.cfg.txt look for an item named IdentKey.
This represents LFS World identification key you may generate for yourself.
Go to www.lfsworld.net, open
My LFSW Settings panel, click on Pubstat Access tab and
generate an IdentKey value. Copy the value into the IdentKey
item. If you do this, Airio may access LFSW data of individual players
and it may also download WR table every hour. If using this service
free of change, then LFSW requests are limited to one per 5 seconds.
Airio will ensure this rule is observed. Note that you also have the
option to pay for the service, which will give you all LFSW data instantaneously.

Now open the Airio.srv.txt file and find TextLogo
key. This one represents text of your team/server as shown on every
race start and in players' personal preferences screen. It would be
a good idea to identify your site by defining this text. You may use
standard LFS colour tags in the text (that is from ^0 for black
to ^8 for gray). Once defined, this text will be shown on all
your servers (together with standard Airio Powered tag in small
letters).

If you want to have different TextLogo text shown on individual
servers, you need to overwrite this general setting in server specific
file. For example for your server 2 you need to open Airio.srv.2.txt
file. (If that file does not exist, just create it by copying and renaming
Airio.srv.1.txt.) Open the server 2 file and put inside TextLogo=
together with new required server logo text. This setting will be applied
only to the 2nd server, that is once you save/close the file and reload
all configurations by typing !rld (or restart Airio, but that
is really not necessary and not recommended).

If you complete all the above mentioned steps and run Airio, you will
have somehow customized installation/setup providing all the core functionality
and using most of the default settings.

Now it is time to go through the configuration files, read the comments
and adjust any of the items if you think that is necessary. Here are just
a few picks at the items you may update to suit your purposes:

Common Configuration

In Airio.cfg.txt you may define additional car groups (approximately
equal cars for point system) under CarGroups. You may set
MaxTime specifying in percents what lap time is needed in any track/car
combination to get into server stored statistics. This setting helps
ignore high lap times that would just clutter the system and are of
no real value. By DaysChamp and DaysTotal you may define
short-term and long-term temporary stats data (e.g. points).

If you need PB.txt file to work with using custom PHP scripts
(for Web statistics), set up automatic generation and updating of such
a file. In Airio.cfg.txt set ExportLapperData to true
and use ExportLapperTime to specify update interval in minutes.

Put inside Airio.cfg.nc.txt the usernames of all people that
should have higher rights and some level of protection on your servers.
These people are set as Limad2 (have special commands available)
or Limad0 (can use prohibited nickname, good for team members)
with username following.

Check out Airio.cfg.lc.txt file contents and choose the commands
that should be available to limads (starting with Enable). See
also items starting with Allow and set actions for which limads
and admins will not be spectated or kicked. Note that the default settings
are reasonable so you may update the file only when really necessary,
once you do not like the default options/behaviour.

Define absolute or relative good/great/top lap times for any track/car
combination using items of the Airio.cfg.tc.txt file. Note that
it is not possible to define absolute good/great/top split/sector times.
These are always calculated from defined lap time using current WR as
a distribution base. This principle ensures proper relations of split
and sector times are always observed. It also shows why WR table is
important for Airio and why it will refuse to start if the table is
not available.

Server Configuration

The settings inside Airio.fil.txt are very sensitive because
many of them have direct impact on users. You may create very strict
racing environment, you can also give players almost complete freedom.
Turn on/off individual filters using items as CheckFlooding,
CheckTyres, CheckDriving or CheckInactivity. These
keys accept only true (the filter is used) or false (the
filter is ignored, not used) values.

Define specific track rotation scheme using RotateTracks
in Airio.srv.txt. An example entry could be BL2|4|XFG+XRG
> BL1|4, switching track between BL2 and BL1 each RotateRaces
races. Set points for finish places by PointSystem. Define points
requirements e.g. by LapsPoints specifying what percentage of
completed laps is required to score.

Additional Info

Create and offer your own language version of user messages by copying
Airio.msg.en.txt file, renaming it to Airio.msg.??.txt
and translating or adjusting the text values of the defined keys (it
may be just partial).

Again, look inside all the configuration files (CFG and SRV/FIL),
get general understanding of what is possible, see how a thing you do
not particularly like might be changed or adjusted. Watch the server
run, try racing, see what other features you do not like, return to
config files, etc. In several days you may have a nice racing environment
corresponding with your ideas and requirements.

Internally Airio keeps statistics in hierarchical order on three levels:
user (with nickname and personal settings), track (with track-related
custom data) and car (with data valid for particular track/car combination).
This internal hierarchy is reflected also in STA files being saved and storing
all statistical data.

The data are written in plain text so knowing the structure as described
below makes is possible to create custom (PHP) Web scripts reading the files,
picking the required data, sorting and displaying an output on a Web page.
Airio itself currently does not contain any such scripts, but there may
be some available soon.

Airio.sta.un.txt

This file contains user data on the highest level. It starts with 5 lines
of comments describing the file and then follow basic data about all users
that have ever connected to one of the managed servers. Individual data
items are written on separate lines, users are separated by one empty line
which makes it possible to change the structure in the future if there's
a need for this. A user entry consists of 10 items in the following order:

username (registered on LFS, it is the main entity in Airio,
sort of a database primary key, all lowercase)

experience index (only in FULL and tab-separated file, integer,
last known LFSEI * 1000)

Airio.sta.tr.txt

In this file track-specific data for each user are stored. The file again
starts by 5 commentary lines, then follows 14 items for each user on separate
lines. Users are again separated by an empty line.

username (necessary to bind the item to other user data)

track name (simple short track code saying what track the
following data relate to)

soft split 1 (used only in FULL version, custom-defined node
on track sector 1 where additional timing data are shown)

soft split 2 (used only in FULL version, as above, only for
sector 2)

soft split 3 (used only in FULL version, as above, only for
sector 3)

soft split 4 (used only in FULL version, as above, only for
sector 4)

not used (always zero)

not used (always zero)

not used (always zero)

not used (always zero)

not used (always zero)

not used (always zero)

not used (always zero)

not used (always zero)

Airio.sta.cr.txt

This file stores user/track/car specific data and is the most important
for external display of statistics. Basic structure is the same as with
previous files, that is 5 starting commentary lines, then individual items,
users again separated by an empty line. One user/track/car combination consists
currently of 33 items as described below:

username (necessary to bind the item to other user data)

track name (simple short track code saying what track the
following data relate to)

car name (simple short car code saying what car type the
following data relate to)

total laps (integer, made in this track/car combination)

PB split 1 time (integer, in centiseconds, that is milliseconds
* 10, of 1st split time made during PB lap)

PB split 2 time (as above, only 2nd split time made during
PB lap, if the track has 1 split only, this is also PB lap time)

PB split 3 time (as above, only 3rd split time made during
PB lap, if the track has 2 splits only, this is also PB lap time)

PB split 4 time (as above, only 4th split time made during
PB lap, always also total PB lap time)

date/time of the PB (Unix timestamp)

TB sector 1 time (integer, in centiseconds, that is milliseconds
* 10, of best 1st sector time ever made)

TB sector 2 time (as above, only best 2nd sector time ever
made)

TB sector 3 time (as above, only best 3rd sector time ever
made, if the track contains such)

TB sector 4 time (as above, only best 4th sector time ever
made, if the track contains such)

total points (integer, total points scored on this track/car
combination, shown by !ptt, deleted by !clrt)

target time (integer, FULL only, centiseconds, set/shown
by !target command as an optional comparison base)

last update (of this particular record, Unix timestamp)

Airio.sta.ac.txt

This is an additional file used for storing named layouts (autocross)
data. Its format is exactly the same as of the Airio.sta.cr.txt file,
only track names always include layout names (after underscore).

Displaying Statistics

The files are created so that there's as low redundancy as possible.
This means that for the most common scenario of displaying best lap times
of people on certain track/car combination you have to use two of the above
described files. You will filter/sort the Airio.sta.cr.txt file,
getting only the required items. But to get nicknames of players, you need
to use also Airio.sta.un.txt, with username as the key. Anyway, I
hope this description will help you make some nice scripts for your own
use and maybe also available to public. One reminder: The STA files are
updated every 10 minutes and also on Airio closing/restart.

This is the end of Airio Admin's Manual. I hope the information presented
here was sufficiently clear for you to be able to create your customized
setup and run Airio successfully. I'll just repeat, that if you do not understand
some feature, contact me through LFS Forum and I'll try to make the document
better. Do the same if you spot some errors, factual or syntactic.

Both in User Manual and in this Admin Manual
were hints about FULL version of the Airio tracker. If you'd like to know
what that release offers for both users and admins, take a look inside the
Full Version Manual.