Free hiperarc 1.03 software for linux

edanator is an intuitive graphical binary and hex calculator. Each nibble is displayed in hex and binary. Clicking on the button (hex nibble or binary bit) changes the value. Bit and nibble shifting is supported via dedicated buttons. The project supports variable widths per word (up to 64- bits), three words (each on a different row), and mathematical operations between words.
Enhancements:
- An endian-ness button for swapping bit labels was added along with a bit reverse function.

Cutter is an TCP/IP Connection cutting on Linux Firewalls and Routers.

Cutter is an open source program that uses the FIN-ACK-RST packet technique described above to abort TCP/IP connections routed over the firewall or router on which it is run. It can be called using one of the following four syntaxes.

cutter ip-address

Example: "cutter 10.10.0.45"

Cuts all connections passing through the firewall between any ports on the specified ip-address (either a "private" or "public" address) and any other hosts. This can be used to close down all incoming connections to a particular server, all outgoing connections from a particular client or all outgoing connections to a server.

cutter ip-address port

Example: "cutter 200.1.2.3 80"

Cuts all connections to or from the specified ip-address/port pair. This allows the user to be a little more specific than the previous example and allows targetting of specific services on specific hosts.

cutter ip-address-1 port-1 ip-address-2

Example "cutter 200.1.2.3 22 10.10.0.45"

Cuts all connections between ip-address-2 and ip-address-1/port-1. This allows the user to cut connections between a specified "client" and a particular service on a specified host. Our example closes host 10.10.0.45s SSH connection to server 200.1.2.3.

cutter ip-address-1 port-1 ip-address-2 port-2

Example: "cutter 200.1.2.3 22 10.10.0.45 32451"

Cuts the specific connection between the two ip/port number pairs given.

IMPORTANT WARNING

Cutter has been designed for use as a administrators tool for Linux firewalls. Its use (as is, or modified) for any other purpose is not sanctioned by the author. So - do not use this tool as a parachute, or to dry your cat, chill meat, answer your phone, drive you car, teach your kids to read or attack other peoples computer systems or networks.

This software has been designed for "legal" and "appropriate" use by network security administrators and the like. It has been written as part of a larger Linux firewall project, targetting at controlling traffic from peer-to-peer software such as Kazaa, iMesh and others into and out of a private network. It is not designed as a tool for malicious use and the author in no way sanctions such use.

Users of the software should be aware that its actions are easily detectable using a number of readily available network monitoring tools, and it makes no attempt to disguise its actions. Malicious use of "cutter" could result in a jail sentance in a number of countries around the world.

IOG is a network I/O byte grapher made to track KB/MB/GB totals for hours, days, and months. The project is intended to be simple and fast (to support thousands of hosts), and to integrate well with MRTG.
Data for each host is updated hourly and HTML graphs are created. It uses a data consolidation algorithm which allows for a small, non-growing database file for each host.
Enhancements:
- Fixed bug which causes router/switch reboots to potentially cause large negative values for that particular hour.

AntTweakBar allows programmers to quickly add a light and intuitive graphical user interface into graphic programs to interactively tweak them. AntTweakBar is a small and easy to use library that can be readily integrated into OpenGL and DirectX applications.
Program variables can be linked to a graphical control that allows users to modify them. Thus, parameters exposed by programmers can be easily modified. They are displayed into the graphical application through one or more embeded windows called tweak bars.
Design and integration:
The library is designed to minimize programmer work while offering a fast, clean, intuitive and non-invasive graphical interface. For instance, numerical values are automatically mapped to a RotoSlider control for rapid editing.
It is composed of few functions. Common variables like booleans, integers, floats and enums can be directly mapped to a graphic control through pointers or callback functions. Additionnal editing informations like min and max values can be provided. Keyboard shortcuts can also be associated to controls and an help window which summurizes these shortcuts can be displayed. Programmers are not required to design the graphical interface by providing coordinates or by using a visual UI editor. Controls are automatically organized following an optional given hierarchy. In most cases, only one line of code is needed to add a new variable to a tweak bar.
The AntTweakBar library mainly targets graphical programs that need an easy way to tweak parameters and see the result in real-time like 3D demos, light inline game editors, small 3D applications, prototypes, debug facilities of weighter graphical programs, etc.
While the library itself is written in C++, its programming interface is a C interface, and then it can be directly integrated in any C++ or C program.
It has been designed with performance in mind. Embeded in a typical 3D application, its rendering time is almost insignificant. Bars can also be iconified to fully minimize their rendering time.
Enhancements:
- The medium font is antialiased.
- The code now compiles on 64-bit x86 platforms.
- A problem which occurred if the library was initialized or uninitialized more than once was fixed.
- Some other minor fixes were done.

Convert::Scalar is a Perl module that can convert between different representations of perl scalars.

SYNOPSIS

use Convert::Scalar;

This module exports various internal perl methods that change the internal representation or state of a perl scalar. All of these work in-place, that is, they modify their scalar argument. No functions are exported by default.

The following export tags exist:

:utf8 all functions with utf8 in their name
:taint all functions with taint in their name
:refcnt all functions with refcnt in their name
:ok all *ok-functions.
utf8 scalar[, mode]

Returns true when the given scalar is marked as utf8, false otherwise. If the optional mode argument is given, also forces the interpretation of the string to utf8 (mode true) or plain bytes (mode false). The actual (byte-) content is not changed. The return value always reflects the state before any modification is done.

This function is useful when you "import" utf8-data into perl, or when some external function (e.g. storing/retrieving from a database) removes the utf8-flag.

utf8_on scalar

Similar to utf8 scalar, 1, but additionally returns the scalar (the argument is still modified in-place).

utf8_off scalar

Similar to utf8 scalar, 0, but additionally returns the scalar (the argument is still modified in-place).

utf8_valid scalar [Perl 5.7]

Returns true if the bytes inside the scalar form a valid utf8 string, false otherwise (the check is independent of the actual encoding perl thinks the string is in).

utf8_upgrade scalar

Convert the string content of the scalar in-place to its UTF8-encoded form (and also returns it).

utf8_downgrade scalar[, fail_ok=0]

Attempt to convert the string content of the scalar from UTF8-encoded to ISO-8859-1. This may not be possible if the string contains characters that cannot be represented in a single byte; if this is the case, it leaves the scalar unchanged and either returns false or, if fail_ok is not true (the default), croaks.

utf8_encode scalar

Convert the string value of the scalar to UTF8-encoded, but then turn off the SvUTF8 flag so that it looks like bytes to perl again. (Might be removed in future versions).

utf8_length scalar

Returns the number of characters in the string, counting wide UTF8 characters as a single character, independent of wether the scalar is marked as containing bytes or mulitbyte characters.

unmagic scalar, type

Remove the specified magic from the scalar (DANGEROUS!).

weaken scalar

Weaken a reference. (See also WeakRef).

taint scalar

Taint the scalar.

tainted scalar

returns true when the scalar is tainted, false otherwise.

untaint scalar

Remove the tainted flag from the specified scalar.

grow scalar, newlen

Sets the memory area used for the scalar to the given length, if the current length is less than the new value. This does not affect the contents of the scalar, but is only useful to "pre-allocate" memory space if you know the scalar will grow. The return value is the modified scalar (the scalar is modified in-place).

refcnt scalar[, newrefcnt]

Returns the current reference count of the given scalar and optionally sets it to the given reference count.

refcnt_inc scalar

Increments the reference count of the given scalar inplace.

refcnt_dec scalar

Decrements the reference count of the given scalar inplace. Use weaken instead if you understand what this function is fore. Better yet: dont use this module in this case.

refcnt_rv scalar[, newrefcnt]

Works like refcnt, but dereferences the given reference first. This is useful to find the reference count of arrays or hashes, which cnanot be passed directly. Remember that taking a reference of some object increases its reference count, so the reference count used by the *_rv-functions tend to be one higher.

refcnt_inc_rv scalar

Works like refcnt_inc, but dereferences the given reference first.

refcnt_dec_rv scalar

Works like refcnt_dec, but dereferences the given reference first.

ok scalar

uok scalar

rok scalar

pok scalar

nok scalar

niok scalar

Calls SvOK, SvUOK, SvROK, SvPOK, SvNOK or SvNIOK on the given scalar, respectively.

Readonly is a Perl module that offers the facility for creating read-only scalars, arrays, hashes.

SYNOPSIS

use Readonly;

# Read-only scalar
Readonly::Scalar $sca => $initial_value;
Readonly::Scalar my $sca => $initial_value;

# Read-only array
Readonly::Array @arr => @values;
Readonly::Array my @arr => @values;

# Read-only hash
Readonly::Hash %has => (key => value, key => value, ...);
Readonly::Hash my %has => (key => value, key => value, ...);
# or:
Readonly::Hash %has => {key => value, key => value, ...};

# You can use the read-only variables like any regular variables:
print $sca;
$something = $sca + $arr[2];
next if $has{$some_key};

# But if you try to modify a value, your program will die:
$sca = 7;
push @arr, seven;
delete $has{key};
# The error message is "Modification of a read-only value
attempted"

# Alternate form (Perl 5.8 and later)
Readonly $sca => $initial_value;
Readonly my $sca => $initial_value;
Readonly @arr => @values;
Readonly my @arr => @values;
Readonly %has => (key => value, key => value, ...);
Readonly my %has => (key => value, key => value, ...);
# Alternate form (for Perls earlier than v5.8)
Readonly $sca => $initial_value;
Readonly my $sca => $initial_value;
Readonly @arr => @values;
Readonly my @arr => @values;
Readonly %has => (key => value, key => value, ...);
Readonly my %has => (key => value, key => value, ...);

This is a facility for creating non-modifiable variables. This is useful for configuration files, headers, etc. It can also be useful as a development and debugging tool, for catching updates to variables that should not be changed.
If any of the values you pass to Scalar, Array, or Hash are references, then those functions recurse over the data structures, marking everything as Readonly. Usually, this is what you want: the entire structure nonmodifiable. If you want only the top level to be Readonly, use the alternate Scalar1, Array1 and Hash1 functions.

Please note that most users of Readonly will also want to install a companion module Readonly::XS. See the "CONS" section below for more details.

Term::Prompt is a Perl extension for prompting a user for information.

SYNOPSIS

use Term::Prompt;
$value = &prompt(...);

use Term::Prompt qw(termwrap);
print &termwrap(...);

$Term::Prompt::MULTILINE_INDENT = ;

PREREQUISITES

You must have Text::Wrap and Term::ReadKey available on your system.

This main function of this module is to accept interactive input. You specify the type of inputs allowed, a prompt, help text and defaults and it will deal with the user interface, (and the user!), by displaying the prompt, showing the default, and checking to be sure that the response is one of the legal choices. Additional "types" that could be added would be a phone type, a social security type, a generic numeric pattern type...