Free 006 software for linux

FlowScan is a network analysis and reporting tool.[ COPYRIGHT=1]
Enhancements:
- The CampusIO and SubNetIO reports were enhanced with a new optional configuration directive: TopN. When defined, this directive causes ``Top Talker reports to be produced. These HTML reports contain the most active (i.e. ``top) source and destination addresses.
- The CampusIO and SubNetIO reports were enhanced to record the number of local IP addresses that where active for each network and subnet into the RRD files. This enables users to estimate the number of active hosts hosts over time, detect ``scans which systematically sweep across network address space, and to calculate the average bytes, packets, and flows per host.
- The template Makefile used to produce the graphs was enhanced to allow the inclusion of ``events in the graphs, similarly to what can be done with Cricket. This allows you to label events such as configuration changes and outages to discover correlations with traffic measurement.
- Two new utilities suitable for stand-alone use, are included. ip2hostname converts IP addresses to their respective hostnames. event2vrule adds ``events to rrdtool graphs.
- Added support for LFAP (Lightweight Flow Accouting Protocol) used by Riverstone and Enterasys (formerly Cabletron) routers. This currently requires slate (from http://www.nmops.org) and lfapd by Steven Premeau . lfapd produces time-stamped raw flow files in the same cflowd-defined format that is processed by FlowScan.
- Added the ability for the CampusIO report to identify outbound flows based solely on the flows destination IP address. While this is less trustworthy than using NextHops or OutputIfIndexes, it is now the default and will be useful for environments where the flow nexthop or output ifIndex values are not meaningful.
- The CampusIO report contains a new experimental feature which reads a BGP routing table, and therefore can determine which Autonomous systems source, transit, or sink most of your institutions traffic. The CampusIO report was enhanced with new optional configuration directives: BGPDumpFile, TopN, ReportPrefixFormat. When properly defined, these directives cause CampusIO to create tabular HTML reports named {origin|path}_{in|out}.html under OutputDir after analyzing each raw flow file. These reports show the ``top Autonomous Systems with which your site exchanges traffic.
- A WebProxyIfIndex directive was added to the CampusIO report. This allows one to specify the index of the interface to which HTTP traffic is being transparently redirected. This enables FlowScan to properly count HTTP flows even though NetFlow v5 does not accurately report the nexthop value for flows which are transparently redirected via a Cisco route-map.
- CampusIO now contains a fix for a bug introduced in FlowScan-1.005 which would sometimes cause perl to abort with this message: patricia.c:645: patricia_lookup: Assertion `prefix failed.

Tk::Multi::Manager is a Tk composite widget managing Tk::Multi slaves.

SYNOPSIS

use Tk::Multi::Manager ;
use Tk::Multi::Text ; # if you use MultiText as a slave

my $manager = yourWindow -> MultiManager
(
menu => $menu_ref , # optionnal
title => "windows", # optionnal
help => "Explain what your set of widget do" #optionnal
) -> pack ();

# Dont pack it, the managet will do it
my $w1 = $manager -> newSlave
(
type => MultiText,
title => a_label,
help => "Explain what your slave widget does" #optionnal
);

The manager is a composite widget made of a menu cascade of check buttons and slaves which can be Tk::Multi::Text.

The user can add windows to the manager. Each window visibility is controled by a check button in the menu cascade. The check button actually tells the packer to forget the window. note that the window object is not destroyed.

The main menu bar will feature a Help menu on the right. If the main help which explain the purpose of the Multi::Manager and its slaves is provided when creating the widget, the Help sub-menu will feature a global label.

Each slave widget which is created with a help will have its own label in the help menu.

Mail::Box::Parser::C is a Perl module that can parse folders for MailBox with C routines.

This is an optional module for MailBox, and will (once installed) automatically be used by MailBox to parse e-mail message content when the message is supplied as file-handle. In all other cases, MailBox will use Mail::Box::Parser::Perl.

Mail::Box::Parser::C - reading messages from file using C (XS)

SYNOPSIS

The Mail::Box::Parser::C implements parsing of messages in ANSI C, using Perls XS extension facility.

Template::Alloy::VMethod is a Perl module with VMethod role.

The Template::Alloy::VMethod role provides all of the extra vmethods, filters, and virtual objects that add to the base featureset of Template::Alloy. Most of the vmethods listed here are similar to those provided by Template::Toolkit. We will try to keep Template::Alloys in sync. Template::Alloy also provides several extra methods that are needed for HTML::Template::Expr support.

ROLE METHODS

define_vmethod

Defines a vmethod. See Template::Alloy for more details.

vmethod_*

Methods by these names implement virtual methods that are more complex than oneliners. These methods are not exposed via the role.
filter_*

Methods by these names implement filters that are more complex than one liners. These methods are not exposed via the role.

VIRTUAL METHOD LIST

The following is the list of builtin virtual methods and filters that can be called on each type of data.

In Template::Alloy, the "|" operator can be used to call virtual methods just the same way that the "." operator can. The main difference between the two is that on access to hashrefs or objects, the "|" means to always call the virtual method or filter rather than looking in the hashref for a key by that name, or trying to call that method on the object. This is similar to how TT3 will function.

Virtual methods are also made available via Virtual Objects which are discussed in a later section.

THC-Shagg is a modular application to bruteforce check digit algorithms. THC-Shagg project can be used to gain information about serial numbers that use check digit algorithms.

Once THC-Shagg has analysed a set of serial numbers and found matching check digit algorithms, it is able to generate complete new serial numbers using a saved file containg the matched states.

This page demonstrates the use of THC-Shagg in "daily" life and lists some serial numbers, that have been successfully analysed using Shagg.

Development & Contributions

Youve found some serial numbers and were able to analyse the check digit algorithms using Shagg. Youve some new ideas, you know something about fresh or still un-implemented check digit algorithms. Contribute! And help us making THC Shagg more powerful. Feel free to drop an email to Plasmoid, plasmoid@thc.org.

If you are interested in joining THC, why not write some new classes for THC-Shagg or extend the current version to analyse Web session IDs or other serial numbers? The documented programming API to all classes and interfaces is available online. The source code for THC-Shagg is bundled with the current release, so that you can compile it yourself, if you want to.

How it works:

A check digit algorithm uses the digits of a serial number to construct a check digit, it is not necessary that the digits are numeric values, they can be extended to alpha-numeric values. THC-Shagg currently implements the following algorithms:

Full name Internal name
-------------------------------- ----------------
binary Modulus 7 DR Modulus 7
binary Modulus 9 DR Modulus 9
weighted Modulus 10 DR Modulus 10 Basic
weighted Modulus 10 Luhn Modulus 10 Luhn
weighted Modulus 10 IBM Modulus 10 CC
weighted Modulus 11 DSR Modulus 11

Future releases will implement more algorithms. To get a list of all available algorithms use the -A. For simplicity this version mixes binary and weighted algorithms, DR and DSR algorithms, future version of THC-Shagg may include separate options for binary, weighted, DR and DSR algorithms. As this is the first release, only the most common algorithms have been implemented.

For details on the concept of each algorithms consult the source code of THC-Shagg or browse the web, there are some good information covering these algorithms.

Most of the algorithms above operate using so called weights. Weights are just a sequence of numbers that are multiplied with the individual digits of the serial number to be checked. THC-Shagg generates all weights up to a specified length and checks the serial numbers against all of these weight using all algorithms.

Example: All weights up to length 3

1,2,3,4,5,6,7,8,9,
01,02,03,04,05,06,07,08,09,10,...99
001,002,003,004,005,006,007,...999

THC-Shagg ignores all weights that only consist of zeros because they result in fault-positives and are not used in check digit algorithms.

In order to find the position of a check digit, THC-Shagg splits the serial numbers into partitions. A partition has a head and a tail, these parts are ignored during analysis of the serial numbers. THC-Shagg generates all partitions up to a specified minimum length where length is the length of the part to be analyzed. The programs checks the serial number against these partitions using weights and algorithms.

Class::Declare::Attributes is a Perl module with Class::Declare method types using Perl attributes.

SYNOPSIS

package My::Class;

use 5.006;
use strict;
use warnings;

use base qw( Class::Declare::Attributes );

# declare the class/instance attributes
__PACKAGE__->declare( ... );

#
# declare class/static/restricted/etc methods of this package
#

sub my_abstract : abstract { ... }
sub my_class : class { ... }
sub my_static : static { ... }
sub my_restricted : restricted { ... }
sub my_public : public { ... }
sub my_private : private { ... }
sub my_protected : protected { ... }

Class::Declare::Attributes extends Class::Declare by adding support for Perl attributes for specifying class method types. This extension was inspired by Damian Conways Attribute::Handlers module, and Tatsuhiko Miyagawas Attribute::Protected module. The original implementation used Attribute::Handlers, but now simply refers to attributes.

The addition of Perl attribute support (not to be confused with object attributes, which are entirely different, and also supported by Class::Declare) greatly simplifies the specification of Class::Declare-derived class and instance methods. This should aid in the porting of existing code (Perl, Java and C++) to a Class::Declare framework, as well as simplify the development of new modules.

With the addition of Perl attributes, Class::Declare methods can now be written as

sub method : public
{
my $self = shift;
...
}
instead of
sub method
{
my $self = __PACKAGE__->public( shift );
...
}