rule

Slide Rule is an application that emulates (exactly) a slide rule.

It can be a very useful solution if you were looking for a simple but powerful slide rule.

Snort::Rule is a Perl extension for dynamically building snort rules.

SYNOPSIS

use Snort::Rule;
$rule = Snort::Rule->new(
-action => alert,
-proto => tcp,
-src => any,
-sport => any,
-dir => ->,
-dst => 192.188.1.1,
-dport => 44444,
);

$rule->opts(msg,Test Rule");
$rule->opts(threshold,type limit,track by_src,count 1,seconds 3600);
$rule->opts(sid,500000);

print $rule->string()."n";

OR

$rule = alert tcp $SMTP_SERVERS any -> $EXTERNAL_NET 25 (msg:"BLEEDING-EDGE POLICY SMTP US Top Secret PROPIN"; flow:to_server,established; content:"Subject|3A|"; pcre:"/(TOPsSECRET|TS)//[sw,/-]*PROPIN[sw,/-]*(?=//(25)?X[1-9])/ism"; classtype:policy-violation; sid:2002448; rev:1;);

$rule = Snort::Rule->new(-parse => $rule);
print $rule->string()."n";

This is a very simple snort rule object. It was developed to allow for scripted dynamic rule creation. Ideally you could dynamically take a list of bad hosts and build an array of snort rule objects from that list. Then write that list using the string() method to a snort rules file.

Slide Rule is an easy to use application that emulates an old-style analog slide rule.

Completly freeware for non-commercial use.

Whats New in This Release:

· Now compiled with RealBasic 5.5.5.
· Added Help menu.
· Change front/back checkboxes to radio buttons.

SYNOPSIS

use File::Find::Rule;
# find all the subdirectories of a given directory
my @subdirs = File::Find::Rule->directory->in( $directory );

# find all the .pm files in @INC
my @files = File::Find::Rule->file()
->name( *.pm )
->in( @INC );

# as above, but without method chaining
my $rule = File::Find::Rule->new;
$rule->file;
$rule->name( *.pm );
my @files = $rule->in( @INC );

Test::File::Find::Rule is a Perl module to test files and directories with File::Find::Rule.

SYNOPSIS

use Test::File::Find::Rule;

# Check that all files in $dir have sensible names
my $rule = File::Find::Rule
->file
->relative
->not_name(qr/^[w]{1,8}.[a-z]{3,4}$/);
match_rule_no_result($rule, $dir, File names ok);

# Check that all our perl scripts have use strict !
my $rule = File::Find::Rule
->file
->relative
->name(@perl_ext)
->not_grep(qr/^s*uses+strict;/m, sub { 1 });
match_rule_no_result($rule, $dir, use strict usage);

# With some help of File::Find::Rule::MMagic
# Check that there is less than 10 images in $dir
# with a size > 1Mo
my $rule = File::Find::Rule
->file
->relative
->magic(image/*)
->size(>1Mo);
match_rule_nb_result($rule, $dir, <10, Few big images);
# We can reuse our F:F:R object
match_rule_nb_result($rule, $another_dir, >100, A lot of big images);

# Check the exact result from a rule
my $dirs = [qw(web lib data tmp)];
my $rule = File::Find::Rule
->directory
->mindepth(1)
->maxdepth(1)
->relative;
match_rule_array($rule, $dir, $dirs, Directory structure ok));

Make mailing list rule is an AppleScript that enables you to make a new rule for a mailing list.

This script will create a folder for a mailing list, and create a rule to move incoming messages for that list into the folder, only if no folder or rule of the same name already exists. It makes the rule the second rule in the rule list--this is because many people have a kill file rule as the first rule.

The script makes the assumption that the To recipient is the list address. If that is not the case, do not use the script for that list. Unfortunately, there is no one characteristic common to all mailing lists that a script can use.

Rule Manager description
Rule Manager offers a complete Business Rules solution that requires no programming Rule Manager will allow the Business User to construct, animate, validate and visualize business rules that requires no programming. Our rule editors use English-friendly constructions and do not require semi-colons, quotes, or other technical constructions.

The Rule manager provides powerful search and management tools that allow your business users to maintain control of your core business rules.

Managing these business rules increases the companys flexibility by allowing tactical changes to be rapidly reflected in the operation of your enterprise applications. New business rules can be added efficiently and existing business rules can be quickly uncovered from within your code and annotated for better control.

The Rule Manager allows your business to conform to government and industry standards. Tracing your business rules ensures the consistency of your operations when migrating to a new system, and demonstrates your compliance with laws, standards, and regulations.

Here are some key features of "Rule Manager":

· Support for BizTalk 2006 & Windows Workflow Foundation
· Creation of Business Rules and Business Terms without coding
· Rule Animation through the Interactive Rule Map
· Rule Validation by goal seeking a terms value
· Rule Verification that detects contradictions and redundancies
· Completeness check (discover missing rules)
· Full text search through the rule policy
· Export to Windows Workflow Foundation
· Rule Report generation to PDF format


Requirements:

· .NET 3.0 framework or higher (included with the installation)
· Adobe Acrobat Reader
· Optional Microsoft BizTalk 2006: Import BizTalk Rule Policies from Microsoft RuleStore.


Limitations:

· 30 days trial

HIPAA Security Rule Assistant provides HIPAA covered entities a program to learn and understand the HIPAA Security Rule.

HIPAA Security Rule Assistant contains Risk Analysis worksheet, sample policy templates, sample disaster recovery plan, and a sample Incident Report form.

HIPAA Security Rule Assistant also has areas to tract actions taken and enter policies and procedures developed to meet the requirements of the rule.

You can view the entire rule or portions thereof. Enter and track actions taken, enter comments, and more.

A simple word processor is included to let you create policies in the program or you can create them with a word processor and then copy and paste them into this program so all policies are group by their specification.

Additional information about the rule is also included for your information.

Even if you purchase templates from another organization, HIPAA Security Rule Assistant will provide an easy inexpensive mean to store those policies for future follow-up and viewing, etc.

File::Find::Rule::XPath is a Perl module that contains rule to match on XPath expressions.

SYNOPSIS

use File::Find::Rule::XPath;

my @files = File::Find::Rule->file
->name(*.dkb)
->xpath( //section/title[contains(., "Crustacean")] )
->in($root);

This module extends File::Find::Rule to provide the ability to locate XML files which match a given XPath expression.

METHODS

xpath( $xpath_expression )

Matches XML files which contain one or more nodes matching the given XPath expression. Files which are not well formed XML are silently skipped.

If no XPath expression is supplied, the value / is used. This will match all files which are well formed XML.

HIPAA Security Rule Assistant provides HIPAA covered entities a program to learn and understand the HIPAA Security Rule. It contains Risk Analysis worksheet, sample policy templates, sample disaster recovery plan, and a sample Incident Report form. It also has areas to tract actions taken and enter policies and procedures developed to meet the requirements of the rule. You can view the entire rule or portions thereof. Enter and track actions taken, enter comments, and more. A simple word processor is included to let you create policies in the program or you can create them with a word processor and then copy and paste them into this program so all policies are group by their specification. Additional information about the rule is also included for your information. Even if you purchase templates from another organization, this program provides an easy inexpensive way to store those policies for viewing and future follow-up, etc. Even if you purchase templates, policies etc. from another organization, this program provides an easy and economical way to store those policies for viewing and future follow-up, etc.

You can use the Rule of Three Widget without knowing the formula: just mark the field you want to know with an X and enter the two known values of the same unit in a column and the third value in the corresponding field and the request will return the result.

The widget can also calculate the inverse proportion, e.g., for time data (more manpower = less time to work).

Rule Set Based Access Control (RSBAC) is a Free Software security extension for current Linux kernels. Rule Set Based Access Control is based on the Generalized Framework for Access Control (GFAC) by Abrams and LaPadula and provides a flexible system of access control based on several modules.

All security relevant system calls are extended by security enforcement code. This code calls the central decision component, which in turn calls all active decision modules and generates a combined decision. This decision is then enforced by the system call extensions.

Here are some key features of "Rule Set Based Access Control":

· Free Open Source (GPL) Linux kernel security solution
· Independent of governments and big companies
· Several well-known and new security models, like MAC, ACL and RC
· On-access virus scanning with the Dazuko interface
· Detailed control over individual user and program network accesses
· Fully access controlled kernel level user management
· Any combination of security models possible
· Easily extensible: write your own model for runtime registration
· Support for latest kernels and stable for production use

Whats New in This Release:

· This release relates to kernel 2.4.34.5 and 2.6.22.1.
· There are important fixes with some compilation errors and an important bug with User Management password hashing, introduced with the newer 2.6 kernel crypto API.
· Some security has been added with safety measures against null pointers.

Basic Ipchains Firewall Rule Script is an iptables firewall script.

WARNING THIS SCRIPT HAS NOT BEEN TESTED YET! USE AT YOUR OWN RISK.

TIPS:

- To test your ruleset without actually changing the firewall, you can change the IPTABLES variable below to "echo" and run the script. This will print a copy of the ruleset commands out to stdout (screen)

- To tidy it up even more, you could try this when you run the script with the "echo" setting:

/etc/rc.d/rc.firewall | grep ^- | sed s/^-/ipchains -/

- Or to create a prebuilt ruleset with your variables already set:

/etc/rc.d/rc.firewall | grep ^- | sed s/^-/ipchains -/ > newfile

Of course you will have to rerun this and create a new script whenever you change the variables in this script.

Get the Rules of Acquisition directly onto your computer terminal. You ll get all 285 Rules of Acquisition randomly displayed for your enjoyment, education, and profit! Plus a selection of six notable Ferengi, the Rules of Acqusition book, or a bar of Gold Pressed Latinum as your display.

So don t delay, download now and start down the road to greater profit!

If men could re-write the rules they are sure to include these. A funny screen saver depicting 10 rules written by men along with a cartoon for each rule.

FSA::Rules is a Perl module to build simple rules-based state machines in Perl.

Synopsis

my $fsa = FSA::Rules->new(
ping => {
do => sub {
print "ping!n";
my $state = shift;
$state->result(pong);
$state->machine->{count}++;
},
rules => [
game_over => sub { shift->machine->{count} >= 20 },
pong => sub { shift->result eq pong },
],
},

pong => {
do => sub { print "pong!n" },
rules => [ ping => 1, ], # always goes back to ping
},
game_over => { do => sub { print "Game Overn" } }
);

$fsa->start;
$fsa->switch until $fsa->at(game_over);

This class implements a simple state machine pattern, allowing you to quickly build rules-based state machines in Perl. As a simple implementation of a powerful concept, it differs slightly from an ideal DFA model in that it does not enforce a single possible switch from one state to another. Rather, it short circuits the evaluation of the rules for such switches, so that the first rule to return a true value will trigger its switch and no other switch rules will be checked. (But see the strict attribute and parameter to new().) It differs from an NFA model in that it offers no back-tracking. But in truth, you can use it to build a state machine that adheres to either model--hence the more generic FSA moniker.

FSA::Rules uses named states so that its easy to tell what state youre in and what state you want to go to. Each state may optionally define actions that are triggered upon entering the state, after entering the state, and upon exiting the state. They may also define rules for switching to other states, and these rules may specify the execution of switch-specific actions. All actions are defined in terms of anonymous subroutines that should expect an FSA::State object itself to be passed as the sole argument.

FSA::Rules objects and the FSA::State objects that make them up are all implemented as empty hash references. This design allows the action subroutines to use the FSA::State object passed as the sole argument, as well as the FSA::Rules object available via its machine() method, to stash data for other states to access, without the possibility of interfering with the state or the state machine itself.

If your struggling with business the Ferengi just may have the answer!

According to legend, Gint, the first Grand Nagus of the Ferengi Alliance, coined the first Rule, remembered as #162. (The legend further states that Gint numbered the Rule as the 162nd in order to create demand for the first 161. Some Federation cultural historians are dubious as to the validity of this claim.)

Simply click on the Insignia to change to another Rule.

All 129 rules, including rule#, rule, and source (character and episode).

Requirements:

· HanDBase v.2.7x or greater