Free echo software for linux

Tk::CmdLine contains process standard X11 command line options and set initial resources.

SYNOPSIS

Tk::CmdLine::SetArguments([@argument]);

my $value = Tk::CmdLine::cget([$option]);

Tk::CmdLine::SetResources((@resource | $resource) [, $priority]);

Tk::CmdLine::LoadResources(
[ -symbol => $symbol ]
[ -file => $fileSpec ]
[ -priority => $priority ]
[ -echo => $fileHandle ] );

Process standard X11 command line options and set initial resources.

The X11R5 man page for X11 says: "Most X programs attempt to use the same names for command line options and arguments. All applications written with the X Toolkit Intrinsics automatically accept the following options: ...". This module processes these command line options for perl/Tk applications using the SetArguments function.

This module can optionally be used to load initial resources explicitly via function SetResources, or from specified files (default: the standard X11 application-specific resource files) via function LoadResources.

jZeno is a meta-project that integrates a collection of java open source libraries, to form a ready-to-use web development environment. jZeno is made to allow people to create web applications by using pure java development as much as possible. The main architectural goal of Largely reducing the need to know technologies like javascript, HTML, CSS, database specific SQL, and tons of different APIs.
Limiting the amount of APIs, technologies and programming styles allows developers to learn a smaller set of skills much deeper. We think this set of skills should be : a thorough understanding of java, OO development and design patterns.
We decided to create jZeno after growing more and more frustrated with JSP and Struts over the years. We hoped JSF would improve things but have come to the conclusion that it is mainly a commercially-driven API that does not really make development life any easier. So we started looking further and came across Echo, a toolkit for developing web applications in pure java. In a nutshell Echo provides you with an implementation of the Swing API for developing web applications. We have created an optimized version of the Echo toolkit to allow partial, and highly compressed updates of web pages, providing AJAX like performance (available in the upcoming 0.9 release).
While Echo provides an easy way of creating the presentation layer of a web application, some glue was still missing to turn it into a rapid development platform. So we decided to add a set of easy to use dynamic components, that provide an easy way to do data-binding, validation, event handling and such. Many useful components are also provided by the EchoPoint library, a collection of rich Echo components.
Besides the presentation layer jZeno also provides a number of services for facilitating the creation of business facades. This environment is similar to stateless session beans in the EJB specification, but witout the overhead of EJBs. These services include transaction management, dead-lock detection and retrying, performance monitoring, security checking, etc...
jZeno also uses Hibernate for O/R mapping inside you business facades. Besides these major functions jZeno contains out-of-the-box solutions for a host of other features any real-life web application needs. This inluces things like genrating reports in a pdf,xls,rtf and other formats (through JasperReports). It also includes live performance monitoring (JAMon) and heap monitoring of your application in its production environment, among other features...
jZeno applications have a traditional layered architecture. The tradidional 3 tiers are seperated : the presentation tier, the business tier and the domain model. The first tier is created by using the jZeno dynamic components and the lower level Echo and EchoPoint components. The business tier contains support for running your business logic, decorated with a stack of aspects that together create an environment very similar to stateless session beans (but with less requirements and configuration overhead). The domain model tier is basically the O/R mapping provided by Hibernate. jZeno provides a tightly integrated environment for all these tiers. In the future support for deploying on an EJB container may be added if required.
Enhancements:
- A bug in errormessagescomponent (warnings) has been fixed.
- Validation has been fixed to pre-render/rebind invisible pages on DynaTables before validation.
- The TTL for DNS caching has been set to a maximum of 5 minutes.
- SessionSyncFilter will always serialize unless using an image/script service.
- A McKoi startup bug when using hibernate annotations has been fixed.
- Processing of radio buttons with action listeners has been fixed.
- BigDecimalViewer and ComponentUI have been added for consistency.
- A bug in the NewsTicker component has been fixed.

Cryptkeeper project is a FreeDesktop.org (KDE, Gnome, XFce, etc.) system tray applet that manages EncFS encrypted folders.
On ubuntu you can install encfs like this:
- sudo aptitude install encfs
- sudo echo "fuse" >> /etc/modules
- sudo modprobe fuse
- sudo addgroup fuse
Then you must log off and back on again.

UidBind is a simple module allows call to bind() function only to uid/gid defined in a configfs tree.

Example:

Admin joe has loaded the uidbind module, then User sam (with uid 1017) tries bind() on port 8081:


sam@hell:~$ nc -l -p 8081
Cant grab 0.0.0.0:8081 with bind : Operation not permitted

Now, Admin joe goes to /config/uidbind and...


root@hell:/config/uidbind: mkdir 8081
root@hell:/config/uidbind: cat 8081/uid
0
root@hell:/config/uidbind: echo 1017 >8081/uid
root@hell:/config/uidbind: cat 8081/uid
1017


...then User sam retries binding:
sam@hell:~$ nc -l -p 8081


...now it works and sam is happy

Admin joe has 2 ipv4 addresses configured on his server (192.168.1.2 and 192.168.1.3) and he wants to assign port 8082 to 2 different users:

tom (uid 1017) and rob (uid 1026)

root@hell:/config/uidbind: mkdir 8082
root@hell:/config/uidbind: mkdir 8082/192.168.1.2
root@hell:/config/uidbind: mkdir 8082/192.168.1.3
root@hell:/config/uidbind: echo 1017 > 8082/192.168.1.2/uid
root@hell:/config/uidbind: echo 1026 > 8082/192.168.1.3/uid


...now tom can bind port 8082 on address 192.168.1.2 and rob on address 192.168.1.3.

But Admin joe is paranoid and knows that rob needs only port 8082 on udp:

root@hell:/config/uidbind: echo 0 > 8082/192.168.1.3/uid
root@hell:/config/uidbind: echo 1026 > 8082/192.168.1.3/udp_uid



Admin joe now wants to allow bind() on port 8083 to all members of group "binders" (gid 1717):

root@hell:/config/uidbind: mkdir 8083
root@hell:/config/uidbind: echo 1717 >8083/gid



...but User dom (uid 1030) needs to bind() on all udp ports still unconfigured by Admin joe:

root@hell:/config/uidbind: mkdir all
root@hell:/config/uidbind: echo 1030 >all/udp_uid


Admin joe now wants that only python scripts owned by User dom can bind() on port 8017:

root@hell:/config/uidbind: mkdir 8017
root@hell:/config/uidbind: echo 1030 >8017/uid
root@hell:/config/uidbind: echo python >8017/comm

GCC::TranslationUnit is a Perl module that can parse the output of gcc -fdump-translation-unit.

SYNPOSIS

use GCC::TranslationUnit;

# echo #include > stdio.c
# gcc -fdump-translation-unit -c stdio.c
$node = GCC::TranslationUnit::Parser->parsefile(stdio.c.tu)->root;

# list every function/variable name
while($node) {
if($node->isa(GCC::Node::function_decl) or
$node->isa(GCC::Node::var_decl)) {
printf "%s declared in %sn",
$node->name->identifier, $node->source;
}
} continue {
$node = $node->chain;
}

ABSTRACT

Provides a module for reading in the -fdump-translation-unit file from GCC and access methods for the data available from within GCC.

Once you read in the file using the Parser, you can traverse the entire structure of the parse tree using methods defined in the GCC::Node::* modules. Look there for information. Each node is blessed into a GCC::Node::* class with that name.

Host enumeration is the act of determining the IP address of potential targets on a network. This can be done in both layer 2 and layer 3. Icmpenum project can send ICMP traffic for such enumeration.

The ICMP packets supported are: Echo, Timestamp, Information and Netmask. Furthermore, it supports spoofing and promiscuous listening for reply packets. Icmpenum is great for enumerating networks which allow ICMP traffic.

TheBOT provides an IRC bot written in bash.

TheBot is a simple IRC bot written in the bash scripting language. It is based on a modular design.

to get this thing online use the `run script (in this directory)
but please edit the configuration file first - `config.

for information about available commands see doc/commands.html
to learn how to write commands (or just try) read doc/writting-commands.html

to be able to identify youll need to crypt your password first, then add
it into the passwd file.
Ive included the source and the binary of the `crypt utlilty.
if you want to recompile just type make in the bin directory.

now, lets say that youre `SuperDude and wanna use the pass `ircforlife
first crypt your password:

SuperDude:thebot/bin$ crypt ircforlife
^Y7T08nTQpiz6

the next step is to add yourself into the passwd file:

SuperDude:thebot$ echo "SuperDude:^Y7T08nTQpiz6" >> passwd

to identif just use: /msg thebot +id ircforlife

everything else is the same.even when adding new user
with the add command.thebot crypts the password and writes it to the file.