Free jscape inet software for linux

Eiffel INET provides an Eiffel classes for writing IPV4 (TCP/UDP) servers and clients.

Eiffel INET is a set of Eiffel classes (written to be used with SmallEiffel) which allow writing TCP and UDP clients & servers. Programs written with Eiffel INET run in a single thread-less process that multiplexes several connections without blocking.

Supported compilers

The library has been widely used with SmallEiffel -0.77, SmartEiffel 1.0 y 1.1. It compiles (giving spurious warnings) with SmartEiffel 2.0, but it hasnt been tested in production. However, the demos run fine.

CB3ROB Identd is an identd implementing the auth (RFC1413) protocol for use on public Unix machines. Unlike with other ident daemons, the AUTH protocol replies from this daemon cannot be spoofed by users.

CB3ROB Identd project has been optimized to handle as many requests as possible, and has been tested to work on most Linux distributions without modification.

Installation:

- become root
- unpack the files ("tar -xvzf cb3rob-identd-1.2.tgz")
- chdir to the cb3rob-identd directory ("cd cb3rob-identd")
- type "make install"
- add the service to your inet daemon (inetd or xinetd) config file
- restart inetd or xinetd

CGI::Portable is a framework for server-generic web apps.

SYNOPSIS

Content of thin shell "startup_cgi.pl" for CGI or Apache::Registry env:

#!/usr/bin/perl
use strict;
use warnings;

require CGI::Portable;
my $globals = CGI::Portable->new();

use Cwd;
$globals->file_path_root( cwd() ); # let us default to current working directory
$globals->file_path_delimiter( $^O=~/Mac/i ? ":" : $^O=~/Win/i ? "" : "/" );

$globals->set_prefs( config.pl );
$globals->current_user_path_level( 1 );

require CGI::Portable::AdapterCGI;
my $io = CGI::Portable::AdapterCGI->new();

$io->fetch_user_input( $globals );
$globals->call_component( DemoAardvark );
$io->send_user_output( $globals );

1;

Content of thin shell "startup_socket.pl" for IO::Socket::INET:

#!/usr/bin/perl
use strict;
use warnings;

print "[Server $0 starting up]n";

require CGI::Portable;
my $globals = CGI::Portable->new();

use Cwd;
$globals->file_path_root( cwd() ); # let us default to current working directory
$globals->file_path_delimiter( $^O=~/Mac/i ? ":" : $^O=~/Win/i ? "" : "/" );

$globals->set_prefs( config.pl );
$globals->current_user_path_level( 1 );

require CGI::Portable::AdapterSocket;
my $io = CGI::Portable::AdapterSocket->new();

use IO::Socket;
my $server = IO::Socket::INET->new(
Listen => SOMAXCONN,
LocalAddr => 127.0.0.1,
LocalPort => 1984,
Proto => tcp
);
die "[Error: cant setup server $0]" unless $server;

print "[Server $0 accepting clients]n";

while( my $client = $server->accept() ) {
printf "%s: [Connect from %s]n", scalar localtime, $client->peerhost;

my $content = $globals->make_new_context();

$io->fetch_user_input( $content, $client );
$content->call_component( DemoAardvark );
$io->send_user_output( $content, $client );

close $client;

printf "%s http://%s:%s%s %sn", $content->request_method,
$content->server_domain, $content->server_port,
$content->user_path_string, $content->http_status_code;
}

1;

^The CGI::Portable class is a framework intended to support complex web applications that are easily portable across servers because common environment-specific details are abstracted away, including the file system type, the web server type, and your projects location in the file system or uri hierarchy.

Also abstracted away are details related to how users of your applications arrange instance config/preferences data across single or multiple files, so they get more flexability in how to use your application without you writing the code to support it. So your apps are easier to make data-controlled.

Application cores would use CGI::Portable as an interface to the server they are running under, where they receive user input through it and they return a response (HTML page or other data type) to the user through it. Since CGI::Portable should be able to express all of their user input or output needs, your application cores should run well under CGI or mod_perl or IIS or a Perl-based server or a command line without having code that supports each types individual needs.

That said, CGI::Portable doesnt contain any user input/output code of its own, but allows you to use whatever platform-specific code or modules you wish between it and the actual server. By using my module as an abstraction layer, your own program core doesnt need to know which platform-specific code it is talking to.

As a logical extension to the interfacing functionality, CGI::Portable makes it easier for you to divide your application into autonomous components, each of which acts like it is its own application core with user input and instance config data provided to it and a recepticle for its user output provided. This module would be an interface between the components.

This class has 5 main types of functionality, or sets of properties that exist in parallel but are fully/mostly independant from each other. As such, it could conceptually be split into 5 physical modules, some of which could be used on their own, but they are actually contained in this one module for simplicity of use (just one object for user code to keep track of). The 5 functionality sets could be called: Errors, Files, Request, Response, Misc.

Emcast project is a generic multicast toolkit.
Emcast is a multicast toolkit for distributed/peer-to- peer applications that require multicast communication.
It includes the program "emcast", a generic multicast utility (like netcat), and the library "libemcast", a generic multicast library.
Emcast supports IPv4 multicast (IM) and can easily support almost any end-host multicast (EM) protocol.
The EM protocols supported are Banana Tree Protocol (BTP) and Internet Relay Chat (IRC).
Enhancements:
- Copy from inet address, not string. Interesting that mcast was still working before in Linux.

iNet Admin Daemon interacts with services such as an Apache2 load balanced environment, a MySQL 5 clustered environment, PureFTPD, PowerDNS, Cacti, Nagios.
iNet Admin Daemon has various other services to create central ease of management and integration with these services for hosting companies.
Enhancements:
- Functional modules were added for existing services connecting to DBmail, PowerDNS, Apache2, and MySQL 5.

Script for NAT and more is an iptables firewall script.

Sample:

# Location of IPTables
FW="`whereis -b iptables | cut -d " " -f 2`"
# Interface Configuration
IF0="eth0"
IP0="`ifconfig $IF0 | grep inet | cut -d : -f 2 | cut -d -f 1`"
MASK0="`ifconfig $IF0 | grep Mask | cut -d : -f 4`"
LOCALNET="$IP0"
echo "IP: $LOCALNET/$MASK0"
# Inside Interface (Can be either eth1 or none)
IF1="eth1"
IP1="`ifconfig $IF1 | grep inet | cut -d : -f 2 | cut -d -f 1`"
MASK1="`ifconfig $IF1 | grep Mask | cut -d : -f 4`"
GWIP="$IP1"
echo "LAN Gateway: $GWIP/$MASK1"
if [ $IF1 != none ]; then
LAN="10.0.1.0/24"
HOST0="10.0.1.2"
HOST1="10.0.1.3"
fi
# Everyone
WORLD="0/0"

# Options
TOS=no
ICMP=yes

# Flush
$FW -F INPUT
$FW -F OUTPUT
$FW -F FORWARD
$FW -F -t nat
$FW -F -t mangle
$FW -F LOGDROP
# Policy
$FW -P INPUT DROP
$FW -P OUTPUT ACCEPT
$FW -P FORWARD ACCEPT

# Create Event Logging
if [ -z "`iptables -L | grep LOGDROP`" ]; then
$FW -N LOGDROP 2>/dev/null
fi
$FW -A LOGDROP -p TCP -j LOG --log-level info --log-prefix "TCP Drop "
$FW -A LOGDROP -p UDP -j LOG --log-level info --log-prefix "UDP Drop "
$FW -A LOGDROP -p ICMP -j LOG --log-level info --log-prefix "ICMP Drop "
$FW -A LOGDROP -f -j LOG --log-level emerg --log-prefix "FRAG Drop "
$FW -A LOGDROP -j DROP
echo "Event logging added"
# $FW -A INPUT -i eth0 -j LOG
# Avoid these from being logged (gets annoying)
# $FW -A INPUT -s $WORLD -p TCP --sport 6666:7000 -d $LOCALNET -j ACCEPT
# $FW -A INPUT -s 24.0.0.0/8 -p ALL -d $LOCALNET -j DROP

# LAN Configuration
# Dynamic IP
$FW -t nat -A POSTROUTING -o eth0 -j MASQUERADE
# Static IP
# $FW -t nat -A POSTROUTING -o $IF0 -s $LAN -j SNAT --to $LOCALNET
$FW -A FORWARD -o eth0 -j ACCEPT
$FW -A FORWARD -i eth0 -m state --state ESTABLISHED -j ACCEPT
$FW -A FORWARD -p TCP -s $WORLD --dport 137:139 -j DROP
$FW -A FORWARD -p UDP -s $WORLD --sport 137:139 -j DROP
# $FW -A FORWARD -p TCP --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1
$FW -A INPUT -m state --state ESTABLISHED -j ACCEPT
# $FW -A OUTPUT -p TCP -s $LAN --syn -j ACCEPT
$FW -A INPUT -p TCP --tcp-flags ALL SYN,ACK -j ACCEPT
$FW -P FORWARD DROP
# Port Forwarding

##### Traffic via LAN
# $FW -t nat -A POSTROUTING -p TCP -o eth0 -s $LAN --sport 6667:7000 -j SNAT
# --to $LOCALNET:6666-7000
# FTP
$FW -t nat -A PREROUTING -d $LOCALNET -p TCP --dport 20 -j DNAT
--to $HOST0:20
$FW -t nat -A PREROUTING -d $LOCALNET -p TCP --dport 21 -j DNAT
--to $HOST0:21
# SSH
$FW -t nat -A PREROUTING -d $LOCALNET -p TCP --dport 22 -j DNAT
--to $HOST0:22
# Telnet (seperate system)
$FW -t nat -A PREROUTING -d $LOCALNET -p TCP --dport 23 -j DNAT
--to $HOST1:23
# WWW
$FW -t nat -A PREROUTING -d $LOCALNET -p TCP --dport 80 -j DNAT
--to $HOST0:80

# Type Of Services (iptables -m tos -h for information)
if [ $TOS = yes ]; then
$FW -t mangle -A OUTPUT -p TCP --dport 20 -j TOS --set-tos 8
$FW -t mangle -A OUTPUT -p TCP --dport 21 -j TOS --set-tos 16
$FW -t mangle -A OUTPUT -p TCP --dport 22 -j TOS --set-tos 16
$FW -t mangle -A OUTPUT -p TCP --dport 23 -j TOS --set-tos 16
$FW -t mangle -A OUTPUT -p TCP --dport 25 -j TOS --set-tos 16
$FW -t mangle -A OUTPUT -p TCP --dport 53 -j TOS --set-tos 16
$FW -t mangle -A OUTPUT -p TCP --dport 53 -j TOS --set-tos 16
$FW -t mangle -A OUTPUT -p TCP --dport 80 -j TOS --set-tos 8
##
$FW -t mangle -A PREROUTING -p TCP --dport 20 -j TOS --set-tos 8
$FW -t mangle -A PREROUTING -p TCP --dport 21 -j TOS --set-tos 16
$FW -t mangle -A PREROUTING -p TCP --dport 22 -j TOS --set-tos 16
$FW -t mangle -A PREROUTING -p TCP --dport 23 -j TOS --set-tos 16
$FW -t mangle -A PREROUTING -p UDP --dport 25 -j TOS --set-tos 16
$FW -t mangle -A PREROUTING -p UDP --dport 53 -j TOS --set-tos 16
$FW -t mangle -A PREROUTING -p UDP --dport 53 -j TOS --set-tos 16
$FW -t mangle -A PREROUTING -p TCP --dport 80 -j TOS --set-tos 8
fi

# Permit full access from LAN
$FW -A INPUT -s $LAN -p TCP -d $LOCALNET --dport 20: -j ACCEPT
$FW -A INPUT -s $LAN -p UDP -d $LOCALNET --sport 20: -j ACCEPT
$FW -A INPUT -s $LAN -p TCP -d $GWIP --dport 20: -j ACCEPT
$FW -A INPUT -s $LAN -p UDP -d $GWIP --sport 20: -j ACCEPT

##### Traffic via local system
# Permit Identd (Local machine)
$FW -A INPUT -s $WORLD -d $LOCALNET -p TCP --dport 113 -j ACCEPT
# Permit ICMP response
if [ $ICMP = yes ]; then
$FW -A OUTPUT -s $LOCALNET -d $WORLD -o $IF0 -p ICMP -j ACCEPT
$FW -A INPUT -s $WORLD -d $LOCALNET -i $IF0 -p ICMP -j ACCEPT
fi

Net::Server is an extensible, general Perl server engine.
SYNOPSIS
#!/usr/bin/perl -w -T
package MyPackage;
use Net::Server;
@ISA = qw(Net::Server);
sub process_request {
#...code...
}
MyPackage->run(port => 160);
exit;
Main features:
- Single Server Mode
- Inetd Server Mode
- Preforking Simple Mode (PreForkSimple)
- Preforking Managed Mode (PreFork)
- Forking Mode
- Multiplexing Mode using a single process
- Multi port accepts on Single, Preforking, and Forking modes
- Simultaneous accept/recv on tcp, udp, and unix sockets
- Safe signal handling in Fork/PreFork avoids perl signal trouble
- User customizable hooks
- Chroot ability after bind
- Change of user and group after bind
- Basic allow/deny access control
- Customized logging (choose Syslog, log_file, or STDERR)
- HUP able server (clean restarts via sig HUP)
- Dequeue ability in all Fork and PreFork modes.
- Taint clean
- Written in Perl
- Protection against buffer overflow
- Clean process flow
- Extensibility
Net::Server is an extensible, generic Perl server engine. Net::Server combines the good properties from Net::Daemon (0.34), NetServer::Generic (1.03), and Net::FTPServer (1.0), and also from various concepts in the Apache Webserver.
Net::Server attempts to be a generic server as in Net::Daemon and NetServer::Generic. It includes with it the ability to run as an inetd process (Net::Server::INET), a single connection server (Net::Server or Net::Server::Single), a forking server (Net::Server::Fork), a preforking server which maintains a constant number of preforked children (Net::Server::PreForkSimple), or as a managed preforking server which maintains the number of children based on server load (Net::Server::PreFork). In all but the inetd type, the server provides the ability to connect to one or to multiple server ports.
Net::Server uses ideologies of Net::FTPServer in order to provide extensibility. The additional server types are made possible via "personalities" or sub classes of the Net::Server. By moving the multiple types of servers out of the main Net::Server class, the Net::Server concept is easily extended to other types (in the near future, we would like to add a "Thread" personality).
Net::Server borrows several concepts from the Apache Webserver. Net::Server uses "hooks" to allow custom servers such as SMTP, HTTP, POP3, etc. to be layered over the base Net::Server class. In addition the Net::Server::PreFork class borrows concepts of min_start_servers, max_servers, and min_waiting servers.
Net::Server::PreFork also uses the concept of an flock serialized accept when accepting on multiple ports (PreFork can choose between flock, IPC::Semaphore, and pipe to control serialization).