Free 2 2 2.1a eng setup.exe software for linux

Freya is a script that creates a bot inside an OpenDCHub server to aid Operators do various tasks.

Commands are as follows:

--- All commands can have a + instead of a - infront of them ---

-huggle (user) you huggle someone
-glomp (user) you glomp someone
-me (message) the irc command
-hrr you hrr softly
-purr you purr like a cute lil kitten =^.^=
-makekitties (user) you and the user make kittens together
-sockcount Displays the number of Socks $botname has lost
-kittycount Displays the number of kitties running around
-status Displays Status Information
-uptime Displays How long the hub has been up.
-rules or +rules Displays the Rules in a PM
-version Displays the Script Version.
-time Displays the Current Hub time.
-showops Displays the online ops
-givesock $botname Gives a sock back to the bot
-sock Displays everyone who has got a sock in their mouth
-jumpcmds Displays a List of Hub Jumping commands (if hub jumping is enabled)
-get (variable) if you dont know .. dont worry about it
-releases returns the releases if set by the hub owner
-help or +help help..

Op Commands are as follows:

-info (username) Returns information about the user
-ipuser (Ip) Returns the users name that belongs to the IP given
-kick (Ip or Username) Kicks the user with the username or IP given
-getip (username) Returns the users IP
-ban or -pbanip (ip or hostname) Perminately bans the ip or hostname
-unban (ip or hostname) Unbans a ip or hostname
-nickban (username) Perminately bans the username
-unnickban (username) Unbans the username
-getbanlist Returns the ban list
-hush$botname Triggers will not cause the bot to talk
-talk$botname Triggers will make the bot talk
-dis (username) Disconnects the user
-pban (username) Kicks and bans the user.
-mm (message) Sends a Mass Message.
-clonecheck Tries to find clones in the hub based on IP.
-fakecheck Attempts to locate fakers based on Share value.
-- Opens up a PM with $botname

*** NOTE: These commands

-chpass (new password) Changes your password.
-reg (username) (password) (value) Registers a user

-setverbosity (1 or 0) notifies you if the script kicks/redirects a user
-setratio (value) Sets the Hub:Slot ratio
-setversion (value) Sets the Min DC++ Version Allowed
-setguiversion (value) Sets the Min DCGui Version Allowed
-setlimit (value) Sets the min a user can limit his upload to
-setbmlimit (value) Sets the min a user can limit his BW to
-setredirect (host) Sets the redirect host
-setloginverbose (1 or 0) Notifies you on a user logging in
-setaction (1 or 2) Sets the Default Action, 1 is kick and 2 is redirect
-resetuserinfo Resets the information about the # of users (plz do not use)
-set (variable) (value) WARNING****be careful what you set****

For the Commands that have (1 or 0) 1 is TRUE and 0 is FALSE

Smartmenu is a menuing application for Lirc. Its purpose is to make use of an infra-red remote controller with a Linux box as easy and smart as possible.
It handles displaying and browsing menus in a way that is usable for typical user of a remote controller.
Such a user must be able to use the menus when he is a few meters away from the monitor or even with monitor turned off.
Enhancements:
- This release provided better control of lirc key repeating.

Locale::KeyedText is a Perl module that refers to user messages in programs by keys.

It also describes the same-number versions of Locale::KeyedText::Message ("Message") and Locale::KeyedText::Translator ("Translator").

Note that the "Locale::KeyedText" package serves only as the name-sake representative for this whole file, which can be referenced as a unit by documentation or use statements or Perl archive indexes. Aside from use statements, you should never refer directly to "Locale::KeyedText" in your code; instead refer to other above-named packages in this file.

SYNOPSIS

use Locale::KeyedText;

main();

sub main {
# Create a translator.
my $translator = Locale::KeyedText::Translator->new({
set_names => [MyLib::Lang::, MyApp::Lang::],
# set package prefixes for localized app components
member_names => [Eng, Fr, De, Esp],
# set list of available languages in order of preference
});

# This will print Enter 2 Numbers in the first of the four
# languages that has a matching template available.
print $translator->translate_message(
Locale::KeyedText::Message->new({
msg_key => MYAPP_PROMPT }) );

# Read two numbers from the user.
my ($first, $second) = ;

# Print a statement giving the operands and their sum.
MyLib->add_two( $first, $second, $translator );
}

package MyLib; # module

sub add_two {
my (undef, $first, $second, $translator) = @_;
my $sum = $first + $second;

# This will print plus equals in
# the first possible language. For example, if the user
# inputs 3 and 4, it the output will be 3 plus 4 equals 7.
print $translator->translate_message(
Locale::KeyedText::Message->new({ msg_key => MYLIB_RESULT,
msg_vars => { FIRST => $first, SECOND => $second,
RESULT => $sum } }) );
}

Many times during a programs operation, the program (or a package it uses) will need to display a message to the user, or generate a message to be shown to the user. Sometimes this is an error message of some kind, but it could also be a prompt or response message for interactive systems.

If the program or any of its components are intended for widespread use then it needs to account for a variance of needs between its different users, such as their preferred language of communication, or their privileges regarding access to information details, or their technical skills. For example, a native French or Chinese speaker often prefers to communicate in those languages. Or, when viewing an error message, the applications developer should see more details than joe public would.

Alternately, sometimes a program will raise a condition or error that, while resembling a message that would be shown to a user, is in fact meant to be interpreted by the machine itself and not any human user. In some situations, a shared program component may raise such a condition, and one application may handle it internally, while another one displays it to the user instead.

Locale::KeyedText provides a simple but effective mechanism for applications and packages that empowers single binaries to support N locales or user types simultaneously, and that allows any end users to add support for new languages easily and without a recompile (such as by simply copying files), often even while the program is executing.

Locale::KeyedText gives your application the maximum amount of control as to what the user sees; it never outputs anything by itself to the user, but rather returns its results for calling code to output as it sees fit. It also does not make direct use of environment variables, which can aid in portability.

Practically speaking, Locale::KeyedText doesnt actually do a lot internally; it exists mainly to document a certain localization methodology in an easily accessable manner, such that would not be possible if its functionality was subsumed into a larger package that would otherwise use it. Hereafter, if any other package or application says that it uses Locale::KeyedText, that is a terse way of saying that it subscribes to the localization methodology that is described here, and hence provides these benefits to developers and users alike.

For some practical examples of Locale::KeyedText in use, see the /examples directory of this distribution. Or, see my dependent CPAN packages whose problem domain is databases and/or SQL.

WmG applet is a dockapp plugin for Gaim. That is, once the plugin is started a dockapp appears, which can be conviniently dragged to the windowmaker dock.
The dockapp shows the top 3 buddies from Gaim, sorted by whatever algorithm was selected in the Gaim preferences. Clicking either of the buddies causes a new conversation window to be created for that buddy (unless one already exists, in which case the existing one will be used).
Additionally, the dockapp features a scrolling message thingy, which displays events occurring, such as buddies logging on and off, becoming idle, going away or coming back.
WmG was selected as the name of this program, because WmGaim was already spoken for.
Version restrictions:
- Unloading the plugin unfortunately requires a restart of gaim.
- No protocol mini-icons are available for protocols other than msn and icq
Enhancements:
- This release fixes compilation issues with the latest Gaim betas, and introduces some graphical representation of buddy status for ICQ buddies.

Quarantine firewall is yet another firewall that has masquerade, type-of-service, and traffic shaping features.

Simply do make install. It will copy the module files, qconfig, qmodule and a sample configuration file to /etc/quarantine.d. quarantine and netrouter then goes to /etc/init.d.


The configuration file /etc/quarantine.d/rc.quarantine can be edited manually (see README file) or via the configuration utility qconfig.

The thing youll have to do is creating a symlink in /etc/rc.d/rc[whatever].d named S99netrouter and K00netrouter pointing at /etc/init.d/netrouter.

The firewall script (quarantine) is designed to get the hosts IP adress when connecting to the internet. Youll need to put a /etc/init.d/quarantine start in the /etc/ppp/ip-up file - also insert a /etc/init.d/quarantine stop in the /etc/ppp/ip-down script file.

Zengaia Space project is a multiplayer game which can be played over a central Internet server.
In the game, you have to build ships, settle new planets, build new shipyards, fight your enemy, and conquer new planets and solar systems.
Enhancements:
- A large bug has been fixed that caused the MySQL connection to crash after about a day running the server.
- Now the server should be up 24/7 again.

The NIST Implementation of the Ad-Hoc On Demand Distance Vector protocol is a kernel-level driver for Linux . AODV is a routing protocol for ad hoc networks designed with mobile wireless devices in mind. For a quick overview on AODVs basics, check out our Quick Guide to AODV page. If you are interested in running a simulation of AODV, NIST has developed a simulation in OPNET.
Kernel AODV is a loadable kernel module for Linux. It implements AODV routing between computers equipped with WLAN interfaces.
This software was developed at the National Institute of Standards and Technology by employees of the Federal Government in the course of their official duties. Pursuant to title 17 Section 105 of the United States Code this software is not subject to copyright protection and is in the public domain. Kernel AODV is an experimental system. NIST assumes no responsibility whatsoever for its use by other parties, and makes no guarantees, expressed or implied, about its quality, reliability, or any other characteristic. We would appreciate acknowledgement if the software is used.
This software can be redistributed and/or modified freely provided that any derivative works bear some notice that they are derived from it, and any modified versions bear some notice that they have been modified.
Enhancements:
- Corrected LINK_LIMIT #ifdefs (Fix from Peter Barron)
- aodv_neigh.c
- hello.c
- module.c
- Add Packet Queuing back in (Fix from Peter Barron)
- Send queued messages when recieving a route, aodv_route.c
- Drop packet from queue if RREQ fails, rreq.c
- Added packet_queue.c back in, packet_queue.c
- Added init and cleanup of packet_queue, module.c
- Added additional check to packet_out.c to determine if packet is going to external subnet on a gateway.
- Shouldnt be neccesary since a route should be created for the external destination anyhow. Have to look into this. (Fix from Peter Barron)
- Removed annoying message printed when signal strength can not be read. Instead only prints when can not be set. signal.c
- Fixed the undefined symbol STRCHR problem for real this time. The problem is doing strstr() with a singlecharecter results in it being converted to strchr(), but for some reason it is not properly imported. The solution it to simply use stchr() instead. module.c
- Changed it so that find_aodv_route() will return valid routes that have expired. When it didnt return expired routes two routes would sometimes be created. Also, now kernel routes are only removed when an expired route is removed. find_aodv_route() will also invalidate expired valid routes.
- Had some trouble with duplicate kernel routes. Now we are always deleting before inserting a new route. Should fix it, fingers are crossed.
- Changed delete_neighbor() so that we send out an RERR even if the route is no longer valid. Also change gen_rerr() so that is will send out a RERR even if the route is not valid. It has to be better to send out a few extra rather than not enough. Just cause you have timed a route out doesnt mean others have.
- Compared the Metrics wrong in update_route() if the seq numbers were equal.

Locale::Object::Language Perl module contains language information objects.

Locale::Object::Language allows you to create objects containing information about languages such as their ISO codes, the countries theyre used in and so on.

SYNOPSIS

use Locale::Object::Language;

my $eng = Locale::Object::Language->new( code_alpha3 => eng );

my $name = $eng->name;
my $code_alpha2 = $eng->code_alpha2;
my $code_alpha3 = $eng->code_alpha3;

my @countries = $eng->countries;

my $gb = Locale::Object::Country->new( code_alpha2 => gb );

print $eng->official($gb);

METHODS

new()

my $eng = Locale::Object::Language->new( code_alpha3 => eng );

The new method creates an object. It takes a single-item hash as an argument - valid options to pass are ISO 3166 values - code_alpha2, code_alpha3 and name (see Locale::Object::DB::Schemata for details on these).
The objects created are singletons; if you try and create a currency object when one matching your specification already exists, new() will return the original one.

name(), code_alpha2(), code_alpha3()

my $name = $country->name;

These methods retrieve the values of the attributes in the object whose name they share.

countries()

my @countries = $eng->countries;

Returns an array (in array context, otherwise a reference) of Locale::Object::Country objects with their ISO 3166 alpha2 codes as keys (see Locale::Object::DB::Schemata for more details on those) for all countries using this currency in array context, or a reference in scalar context. The objects have their own attribute methods, so you can do things like this for example:

foreach my $place (@countries)
{
print $place->name, "n";
}

Which will list you all the countries that use in that currency. See the documentation for Locale::Object::Country for a listing of country attributes. Note that you can chain methods as well.

foreach my $place (@countries)
{
print $place->continent->name, "n";
}
official()
my $gb = Locale::Object::Country->new( code_alpha2 => gb );

print $eng->official($gb); # prints true

Give this method a Locale::Object::Country object, and it will return a true or false value for whether the country the object represents has the language represented by your Locale::Object::Language object as an official language. See database.pod for a note about languages in the database.