Free human readable software for linux

Humanzip is a compression program that operates on text files. Unlike most compression algorithms, its output is human readable. Indeed, it is explictly meant to be read by humans and might even be easier to read than the original.

This application compresses files by looking for common strings of words and replacing them with single symbols. The idea is to reduce the screen and print size of documents. humanzip does not explictly try to reduce the size of the file as measured in bytes, although this usually happens incidentally.

Installation:

There is no configure script. I assume that you have a modern GNU/Linux (or similar) system that has the usual libraries and so forth. Nothing unusual is required, just a C++ complier (g++, probably). If you want to change the install location, edit the very simple Makefile.

To compile, say "make".

To install, say "make install".

To uninstall, say "make uninstall".

Are You Human? is a script that uses a graphical test to insure that a human is being dealt with rather than a script.

This is useful to avoid automated Web signups or automated attempts to crack passwords.

There are many equivalent libraries for other languages but this is the first one for Python. The Python Imaging Library (PIL) is required.

LutelWall (formerly known as Lutel Firewall) is high-level linux firewall configuration tool. It uses human-readable and easy to understand configuration to set up Netfilter in most secure way. Its flexibility allows firewall admins build from very simple, single-homed firewalls, to most complex ones - with multiple subnets, DMZs and traffic redirections. It can be used on a dedicated firewall system, a multi-function gateway/router/server or on a standalone system. Configuration method of this firewall is made to be as simple as possible without loosing Netfilter flexibility and its security facilities.
Main features:
- flexible control over traffic using rule set
- user-defined protocols support
- support for any kind multiple external and internal interaces (and aliases)
- automated MASQUERADE / SNAT support
- easy to set up DNAT (transparent proxy, redirections to LAN/DMZ etc.)
- rate limit extensions
- packet marking for 3rd party shapers
- TOS (Type of Service) traffic optimizer
- both passive and active FTP support
- DHCP support
- can work as "workstation" firewa
- stateful TCP connection tracking with restrictive TCP chain
- blocking all stealth mode scans (FIN, Xmas Tree, Null, Windows scan or ACK scan modes (nmap -sF -sX -sN -sW -sA)
- blocking IP protocol scans (nmap -sO)
- blocking UDP scans (nmap -sU)
- blocking identification via TCP/IP fingerprinting (nmap -O)
- anti-spoof protection, including protection for aliases
- anti-smurf protection
- TCP SYN Flood protection
- UDP / ICMP Flood protection
- IANA reserved addresses checking
- SYSCTL parameters set for increased strength
- logging stealth scans (FIN, Xmas Tree, Null), ACK scan modes (nmap -sF -sX -sN), IP protocol scans (nmap -sO), UDP scans (nmap -sU), nmap fingerprinting attempts.
- autodetect of connection type (static/dynamic, external/internal)
- auto update of firewall tool
- auto update IANA reserved list
- display firewall statistics in iptables native, csv or html format
- easy deployment on all distributions
Enhancements:
- fixed iptables version checking

Number::Bytes::Human is a Perl module that can convert byte count to human readable format.

SYNOPSIS

use Number::Bytes::Human qw(format_bytes);
$size = format_bytes(0); # 0
$size = format_bytes(2*1024); # 2.0K

$size = format_bytes(1_234_890, bs => 1000); # 1.3M
$size = format_bytes(1E9, bs => 1000); # 1.0G

# the OO way
$human = Number::Bytes::Human->new(bs => 1000, si => 1);
$size = $human->format(1E7); # 10MB
$human->set_options(zero => -);
$size = $human->format(0); # -

THIS IS ALPHA SOFTWARE: THE DOCUMENTATION AND THE CODE WILL SUFFER CHANGES SOME DAY (THANKS, GOD!).

This module provides a formatter which turns byte counts to usual readable format, like 2.0K, 3.1G, 100B. It was inspired in the -h option of Unix utilities like du, df and ls for "human-readable" output.

From the FreeBSD man page of df: http://www.freebsd.org/cgi/man.cgi?query=df

"Human-readable" output. Use unit suffixes: Byte, Kilobyte,
Megabyte, Gigabyte, Terabyte and Petabyte in order to reduce the
number of digits to four or fewer using base 2 for sizes.

byte B
kilobyte K = 2**10 B = 1024 B
megabyte M = 2**20 B = 1024 * 1024 B
gigabyte G = 2**30 B = 1024 * 1024 * 1024 B
terabyte T = 2**40 B = 1024 * 1024 * 1024 * 1024 B

petabyte P = 2**50 B = 1024 * 1024 * 1024 * 1024 * 1024 B
exabyte E = 2**60 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B
zettabyte Z = 2**70 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B
yottabyte Y = 2**80 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B

I have found this link to be quite useful:

http://www.t1shopper.com/tools/calculate/

If you feel like a hard-drive manufacturer, you can start counting bytes by powers of 1000 (instead of the generous 1024). Just use bs => 1000.

But if you are a floppy disk manufacturer and want to start counting in units of 1024000 (for your "1.44 MB" disks)? Then use bs => 1_024_000.

If you feel like a purist academic, you can force the use of metric prefixes according to the Dec 1998 standard by the IEC. Never mind the units for base 1000 are (B, kB, MB, GB, TB, PB, EB, ZB, YB) and, even worse, the ones for base 1024 are (B, KiB, MiB, GiB, TiB, PiB, EiB, ZiB, YiB) with the horrible names: bytes, kibibytes, mebibytes, etc. All you have to do is to use si => 1. Aint that beautiful the SI system? Read about it:

http://physics.nist.gov/cuu/Units/binary.html

You can try a pure Perl "ls -lh"-inspired command with the one-liner, er, two-liner:

$ perl -MNumber::Bytes::Human=format_bytes
-e printf "%5s %sn", format_bytes(-s), $_ for @ARGV *

Why to write such a module? Because if people can write such things in C, it can be written much easier in Perl and then reused, refactored, abused. And then, when it is much improved, some brave soul can port it back to C (if only for the warm feeling of painful programming).

Roadnav is an in-car navigation system that can run on a variety of operating systems like Linux, Windows, and Mac OS X.
Roadnav can obtain a cars present location from a GPS unit, plot street maps of the area, and provide verbal turn by turn directions to any location in the USA.
Roadnav uses the free TIGER/Line files from the US Census Bureau to build the maps, along with the GNIS state and topical gazetteer data from the USGS to identify locations.
Main features:
- Generates street level maps for the US
- Interfaces with GPS units to display your position in real time
- Verbal turn by turn directions to any place in the US. Automatically recomputes directions if you miss a turn.
- On screen keyboard
- 3D (drivers perspective) view mode
- Daytime and nighttime color schemes
- Automatic day/night mode switching
- Plots nearby landmarks and points of interest
- Can operate offline (without an Internet connection)
- Antialiased output
- Supports multiple operating systems including Windows, Linux, and Mac OS X
- Uses freely available data from the US Census Bureau and the USGS
- Appearance can be customized with skins
- Can output status information to LCD devices through LCDproc
Enhancements:
Enhancements:
- Adds option to Preferences to enable gpsd buffering (reduces jitter).
- Adds experimental GPX import support.
- Disk usage reduced by ~30%.
- Adds GPS serial initialization string option to Preferences.
- Adds preference to override default map directory.
- Adds option for username/password proxy authentication.
- Adds "Use System Proxy Settings" preference, which reads proxy settings from the HTTP_PROXY environmental variable.
Bug Fixes:
- Fixes Delete button in Waypoints dialog when no waypoints exist.
- Workaround for buggy serial implementations.
- Fixes Windows 2000 compatibility.
- Fixes i18n issue in OSM code.
- Improved address look up.
- Eliminates IPP error messages when printer is not configured.
- Improved compatibility with DeLorme Tripmate and Earthmate GPS units.
- Win32 floating point model changed from fast to precise. Should resolve problems calculating routes.
- Fixes focusing issue in keyboard dialog.
Developer Visible Changes:
- MapControlData_Tiles index files eliminated.
- Direct access to Point::m_fLong and Point::m_fLat eliminated. Use the Point::Set* and Point::Get* functions instead.
Misc:
- Compiled maps now organized in a more human readable format.
- Eliminates TIGER/Line 2006 First Edition from search path.
- Proxy settings now on their own preferences page.
- When maps have to be upgraded, adds option to not upgrade map files and immediately terminate Roadnav instead.
- Small map labels now have a solid background instead of a cross hatch.

nstreams is a program that analyzes the networks streams occuring on a network and prints them in a human readable form. This is useful when you want to set up a firewall but do not know your needs/the needs of your customers.
Nstreams can parse the tcpdump output, or the files generated with the -w option of tcpdump. It can also directly sniff the data that appears in the network.
Enhancements:
- Applied patch from Guillaume Morin which solved some sigsegv issues

Userfriendly Iptables Frontend provides a tool for generating optimized packet filter rules.

The Userfriendly Iptables Frontend is used to generate optimized iptables packet filter rules, using a simple description file specified by the user.

Generated rules are provided in iptables- save style.

UIF can be used to read or write rulesets to or from LDAP servers in your network, which provides a global storing mechanism.

Its aim is to be an easy to configure, human readable packet filter.