Free id software software for linux

Bio::Genex::Software is Perl module with methods for processing data from the GeneX DB table: Software.

SYNOPSIS

use Bio::Genex::Software;

# instantiating an instance
my $Software = Bio::Genex::Software->new(id=>47);

# retrieve data from the DB for all columns
$Software->fetch();

# creating an instance, without pre-fetching all columns
my $Software = new Bio::Genex::Software(id=>47);

# creating an instance with pre-fetched data
my $Software = new Bio::Genex::Software(id=>47, fetch_all=>1);

# retrieving multiple instances via primary keys
my @objects = Bio::Genex::Software->get_objects(23,57,98)


# retrieving all instances from a table
my @objects = Bio::Genex::Software->get_all_objects();

# retrieving the primary key for an object, generically
my $primary_key = $Software->id();

# or specifically
my $sw_pk_val = $Software->sw_pk();

# retreving other DB column attributes
my $name_val = $Software->name();
$Software->name($value);

my $version_val = $Software->version();
$Software->version($value);

my $type_val = $Software->type();
$Software->type($value);

my $con_fk_val = $Software->con_fk();
$Software->con_fk($value);

Each Genex class has a one to one correspondence with a GeneX DB table of the same name (i.e. the corresponding table for Bio::Genex::Software is Software).
Most applications will first create an instance of Bio::Genex::Software and then fetch the data for the object from the DB by invoking fetch().

However, in cases where you may only be accessing a single value from an object the built-in delayed fetch mechanism can be used. All objects are created without pre-fetching any data from the DB. Whenever an attribute of the object is accessed via a getter method, the data for that attribute will be fetched from the DB if it has not already been. Delayed fetching happens transparently without the user needing to enable or disable any features.

Since data is not be fetched from the DB until it is accessed by the calling application, it could presumably save a lot of access time for large complicated objects when only a few attribute values are needed.

snort-rep is a Snort reporting tool that can produce text or HTML output from a syslog file.
The reports contain:
Portscan summary
Alert Summary by ID
Alert summary by remote host and ID
Alert summary by local host and ID
Alert summary by local port and ID
It is designed to be used for daily e-mail reports to the system administrators (see snort-rep-mail for an example script that generates daily e-mails). The HTML code output contains direct links to the IDS descriptions of whitehats.com.
Enhancements:
- release 1.10
- fix off-by-one hour error in syslog parsing when changing from daylight saving time
- support portscan2 (Snort 1.9.0)

DBIx::OO::Tree is a Perl module to manipulate hierarchical data using the "nested sets" model.

SYNOPSYS

CREATE TABLE Categories (
id INTEGER UNSIGNED AUTO_INCREMENT PRIMARY KEY,
label VARCHAR(255),

-- these columns are required by DBIx::OO::Tree
parent INTEGER UNSIGNED,
lft INTEGER UNSIGNED NOT NULL,
rgt INTEGER UNSIGNED NOT NULL,
mvg TINYINT DEFAULT 0,

INDEX(lft),
INDEX(rgt),
INDEX(mvg),
INDEX(parent)
);

* * *

package Category;
use base DBIx::OO;
use DBIx::OO::Tree;

__PACKAGE__->table(Categories);
__PACKAGE__->columns(P => [ id ],
E => [ label, parent ]);

# note its not necessary to declare lft, rgt, mvg or parent. We
# declare parent simply because it might be useful, but
# DBIx::OO:Tree works with low-level SQL therefore it doesnt
# require that the DBIx::OO object has these fields.

# the code below creates the structure presented in [1]

my $electronics = Category->tree_append({ label => electronics });
my $tvs = $electronics->tree_append({ label => televisions });
my $tube = $tvs->tree_append({ label => tube });
my $plasma = $tvs->tree_append({ label => plasma });
my $lcd = $plasma->tree_insert_before({ label => lcd });
my $portable = $tvs->tree_insert_after({ label => portable electronics });
my $mp3 = $portable->tree_append({ label => mp3 players });
my $flash = $mp3->tree_append({ label => flash });
my $cds = $portable->tree_append({ label => cd players });
my $radios = Category->tree_append($portable->id,
{ label => 2 way radios });

# fetch and display a subtree

my $data = $electronics->tree_get_subtree({
fields => [qw( label lft rgt parent )]
});
my $levels = Category->tree_compute_levels($data);

foreach my $i (@$data) {
print x $levels->{$i->{id}}, $i->{label}, "n";
}

## or, create DBIx::OO objects from returned data:

my $array = Category->init_from_data($data);
print join("n", (map { x $levels->{$_->id} . $_->label } @$array));

# display path info

my $data = $flash->tree_get_path;
print join("n", (map { $_->{label} } @$data));

# move nodes around

$mp3->tree_reparent($lcd->id);
$tvs->tree_reparent($portable->id);
$cds->tree_reparent(undef);

$plasma->tree_move_before($tube->id);
$portable->tree_move_before($electronics->id);

# delete nodes

$lcd->tree_delete;

This module is a complement to DBIx::OO to facilitate storing trees in database using the "nested sets model", presented in [1]. Its main ambition is to be extremely fast at retrieving data (sacrificing for this the performance of UPDATE-s, INSERT-s or DELETE-s). Currently this module requires you to have these columns in the table:

- id: primary key (integer)
- parent: integer, references the parent node (NULL for root nodes)
- lft, rgt: store the node position
- mvg: used only when moving nodes

"parent" and "mvg" are not esentially required by the nested sets model as presented in [1], but they are necessary for this module to work. In particular, "mvg" is only required by functions that move nodes, such as tree_reparent(). If you dont want to move nodes around you can omit "mvg".

Retrieval functions should be very fast (one SQL executed). To further promote speed, they dont return DBIx::OO blessed objects, but an array of hashes instead. Its easy to create DBIx::OO objects from these, if required, by calling DBIx::OO->init_from_data() (see DBIx::OO for more information).

Insert/delete/move functions, however, need to ensure the tree integrity. Heres what happens currently:

- tree_append, tree_insert_before, tree_insert_after -- these execute
one SELECT and two UPDATE-s (that potentially could affect a lot of
rows).

- tree_delete: execute one SELECT, one DELETE and two UPDATE-s.

- tree_reparent -- executes 2 SELECT-s and 7 UPDATE-s. I know, this
sounds horrible--if you have better ideas Id love to hear them.

SQLitepp is a C/C++/Python wrapper to sqlite library for database management. It implements an object oriented way to manipulate the database in every supported language.

SQLitepp supports selfupdatable queries and a straight SQL code query system without using strange things for querying the database, letting you manipulate it directly in SQL but also exposing simple object oriented methods to manipulate the result of the queries and updating them.

Python EXAMPLE:

db = SQLDatabase("database.db")
q = db.query("Tablename", "SELECT Name,Id FROM %t")
if len(q):
tuple1 = q[0]
tuple1["Name"] = "Foobar"
tuple1.commit()
del db

C++ EXAMPLE:

SQLDatabase db("database.db");
SQLQuery *q = db.query("Tablename", "SELECT Name,Id FROM %t");
if(q->numberOfTuples()) {
SQLRow *tuple1 = q->getRow(0);
tuple1->set("Name", "Foobar");
tuple1->commit();
}
delete q;

C EXAMPLE:

void *db = new_SQLDatabase("database.db");
void *q = SQLDatabase_query(db, "Tablename", "SELECT Name,Id FROM %t");
if(SQLQuery_numberOfTuples(q)) {
void *tuple1 = SQLQuery_getRow(q, 0);
SQLRow_set(tuple1, "Name", "Foobar");
SQLRow_commit(tuple1);
}
delete_SQLQuery(q);
delete_SQLDatabase(db);

Noid is a Perl module that contains routines to mint and manage nice opaque identifiers.

SYNOPSIS

use Noid; # import routines into a Perl script

$dbreport = Noid::dbcreate( # create minter database & printable
$dbdir, $contact, # report on its properties; $contact
$template, $term, # is string identifying the operator
$naan, $naa, # (authentication information); the
$subnaa ); # report is printable

$noid = Noid::dbopen( $dbname, $flags ); # open a minter, optionally
$flags = 0 | DB_RDONLY; # in read only mode

Noid::mint( $noid, $contact, $pepper ); # generate an identifier

Noid::dbclose( $noid ); # close minter when done

Noid::checkchar( $id ); # if id ends in +, replace with new check
# char and return full id, else return id
# if current check char valid, else return
# undef

Noid::validate( $noid, # check that ids conform to template ("-"
$template, # means use minters template); returns
@ids ); # array of corresponding strings, errors
# beginning with "iderr:"

$n = Noid::bind( $noid, $contact, # bind data to identifier; set
$validate, $how, # $validate to 0 if id. doesnt
$id, $elem, $value ); # need to conform to a template

Noid::note( $noid, $contact, $key, $value ); # add an internal note

Noid::fetch( $noid, $verbose, # fetch bound data; set $verbose
$id, @elems ); # to 1 to return labels

print Noid::dbinfo( $noid, # get minter information; level
$level ); # brief (default), full, or dump
Noid::getnoid( $noid, $varname ); # get arbitrary named internal
# variable

Noid::hold( $noid, $contact, # place or release hold; return
$on_off, @ids ); # 1 on success, 0 on error
Noid::hold_set( $noid, $id );
Noid::hold_release( $noid, $id );

Noid::parse_template( $template, # read template for errors, returning
$prefix, $mask, # namespace size (NOLIMIT=unbounded)
$gen_type, # or 0 on error; $message, $gen_type,
$message ); # $prefix, & $mask are output params

Noid::queue( $noid, $contact, # return strings for queue attempts
$when, @ids ); # (failures start "error:")

Noid::n2xdig( $num, $mask ); # show identifier matching ord. $num

Noid::sample( $noid, $num ); # show random ident. less than $num

Noid::scope( $noid ); # show range of ids inside the minter

print Noid::errmsg( $noid, $reset ); # print message from failed call
$reset = undef | 1; # use 1 to clear error message buffer

Noid::addmsg( $noid, $message ); # add message to error message buffer

Noid::logmsg( $noid, $message ); # write message to minter log

runsuid runs a script with another user-id/group-id, when the user has the right to do so according to the configuration file.
If used in the right combination with access restrictions this can ease the life of system administrators. Additionally, it can be used for running CGI-scripts as different fixed users.
Enhancements:
- A stupid options parsing bug and a memory leak (with no security implications) were fixed.
- Spelling corrections were made.