Free neostats irc software for linux

NeoStats is a powerful and extendable set of *services* for IRC. By Services, we do not mean NickServ/Chanserv etc but additional services.
These additional services include things like StatServ which gives you statistics on the number of users/operators/channels/servers, and MoraleServ, which is a *fun* module, to send funny messages to users, and utility modules.
Some modules have a useful function on your network, other modules are developed for fun, and to make your IRC network more attractive to users.
Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.
NeoStats uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.
Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up
reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).
If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.
If at some point `config.cache contains results you dont want to keep, you may remove or edit it.
The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Enhancements:
- Lots of bugfixes and code cleanups were done.
- Several new modules were added, including quoteserv, textserv, and limitserv.
- This version introduces the ability to write modules in Perl rather than C, as well as the ability to extend the existing modules with Perl code.
- Internally, the code was fixed up to not be as resource intensive as previous versions.
- The module API was enhanced to make it easier for module coders to take advantage of the advanced features of NeoStats.

Rhapsody is an IRC client for Unix operating systems intended to be displayed on a text console or terminal. It is small, fast, portable and easy to use, yet it is full featured.
The thing that separates it from the crowd is its intuitive menu driven user interface. Check out the screenshot area for more information.
It is written entirely from scratch in C and uses the ncurses library. It compiles and has been tested on Linux, FreeBSD, OpenBSD, NetBSD, Solaris, IRIX, Mac OS X, BeOS, Hurd, Syllable and Cygwin.
Most importantly, Rhapsody is a FREE software. Grab it from the download section!
Main features:
- Multi server support.
- Clean, easy to use menu driven user interface.
- Favorite server, channel and user lists.
- Ignore lists.
- Configurable interface color themes.
- Large file (over 2GB) support.
Protocols that are supported:
- IRC (obviously)
- DCC chat
- DCC file transfers
- CTCP
Enhancements:
- This release fixes a bug that causes client lockups when initiating a DCC chat.
- Some minor feature enchancements have been included as well.

InspIRCd is a modular C++ IRC Daemon for Linux, BSD and Windows systems created to provide a stable, modern, lightweight ircd (irc server) from scratch and provide a vast number of features in a modularised form using an advanced module API.

By keeping the functionality of the main core to a minimum we hope to increase the stability and speed of our project and make it customisable to the needs of many users. InspIRCd is designed primarily to be a custom irc server for the chatspike irc network (irc.chatspike.net) but we are releasing it into the public domain under GPL so that you may benifit yourself from our work.

InspIRCd is written from scratch, avoiding the inherent instability under large loads which can be seen in many other irc server distributions which have the same featureset.

NoxBot project is an IRC bot totally written in PHP 5.
Main features:
- Cross platform.
- Modular
- Easy to use.
- Feature full.
- Easy plugin development.
- Being mostly RFC compliant.

inetlib is a small and optimized library for writing IRC bots and clients for Linux in C.
A small IRC bot that uses all the features of the library is included with the source.
Enhancements:
- New end-user funcions: irc_connect(), irc_disconnect(), irc_receive() and irc_check_ping.
- For raw input/output, the funcions _irc_raw_send() and _irc_raw_receive() have been updated.
- There arent global vars now.

Sensible IRC Handler aims to provide an interface for Gaim that handles irc:// links in Firefox Browser. This will provide the same xchat-gnome functionality to handle irc:// links, but for Gaim.
Recent changes in inclusion of packages for future Ubuntu release will not include xchat-gnome because of recursive duplication with Gaims IRC capabilities, so IRC will be entirely handled in Gaim.
This will use Gaim as an IRC client, but will not alter the main Gaim configurations, this would create a temporary configurations for the current sessions. A functionality to add the IRC channels defined in InternetRelayChat in Gaim buddy list, will be easy, but will not add them by default. Adding them for a user requires further discussions.
Enhancements:
- GTK+ version 2.2.x

POE::Component::IRC is a fully event-driven IRC client module.

SYNOPSIS

# A simple Rot13 encryption bot

use strict;
use warnings;
use POE qw(Component::IRC);

my $nickname = Flibble . $$;
my $ircname = Flibble the Sailor Bot;
my $ircserver = irc.blahblahblah.irc;
my $port = 6667;

my @channels = ( #Blah, #Foo, #Bar );

# We create a new PoCo-IRC object and component.
my $irc = POE::Component::IRC->spawn(
nick => $nickname,
server => $ircserver,
port => $port,
ircname => $ircname,
) or die "Oh noooo! $!";

POE::Session->create(
package_states => [
main => [ qw(_default _start irc_001 irc_public) ],
],
heap => { irc => $irc },
);

$poe_kernel->run();
exit 0;

sub _start {
my ($kernel,$heap) = @_[KERNEL,HEAP];

# We get the session ID of the component from the object
# and register and connect to the specified server.
my $irc_session = $heap->{irc}->session_id();
$kernel->post( $irc_session => register => all );
$kernel->post( $irc_session => connect => { } );
undef;
}

sub irc_001 {
my ($kernel,$sender) = @_[KERNEL,SENDER];

# Get the components object at any time by accessing the heap of
# the SENDER
my $poco_object = $sender->get_heap();
print "Connected to ", $poco_object->server_name(), "n";

# In any irc_* events SENDER will be the PoCo-IRC session
$kernel->post( $sender => join => $_ ) for @channels;
undef;
}

sub irc_public {
my ($kernel,$sender,$who,$where,$what) = @_[KERNEL,SENDER,ARG0,ARG1,ARG2];
my $nick = ( split /!/, $who )[0];
my $channel = $where->[0];

if ( my ($rot13) = $what =~ /^rot13 (.+)/ ) {
$rot13 =~ tr[a-zA-Z][n-za-mN-ZA-M];
$kernel->post( $sender => privmsg => $channel => "$nick: $rot13" );
}
undef;
}

# We registered for all events, this will produce some debug info.
sub _default {
my ($event, $args) = @_[ARG0 .. $#_];
my @output = ( "$event: " );

foreach my $arg ( @$args ) {
if ( ref($arg) eq ARRAY ) {
push( @output, "[" . join(" ,", @$arg ) . "]" );
} else {
push ( @output, "$arg" );
}
}
print STDOUT join , @output, "n";
return 0;
}

POE::Component::IRC is a POE component (whod have guessed?) which acts as an easily controllable IRC client for your other POE components and sessions. You create an IRC component and tell it what events your session cares about and where to connect to, and it sends back interesting IRC events when they happen. You make the client do things by sending it events. Thats all there is to it. Cool, no?

[Note that using this module requires some familiarity with the details of the IRC protocol. Id advise you to read up on the gory details of RFC 1459 before you get started. Keep the list of server numeric codes handy while you program. Needless to say, youll also need a good working knowledge of POE, or this document will be of very little use to you.]
The POE::Component::IRC distribution has a docs/ folder with a collection of salient documentation including the pertinent RFCs.

POE::Component::IRC consists of a POE::Session that manages the IRC connection and dispatches irc_ prefixed events to interested sessions and an object that can be used to access additional information using methods.

Sessions register their interest in receiving irc_ events by sending register to the component. One would usually do this in your _start handler. Your session will continue to receive events until you unregister. The component will continue to stay around until you tell it not to with shutdown.

The SYNOPSIS demonstrates a fairly basic bot.

IoChatto is a chat client which you can use in the JXTA platform.

Its interface is similar to many IRC chat clients, but you can have presence information for every channel, and its design is fully decentralized.