Free true beauty software for linux

PHPTestManager project is a school test manager.
PHPTestManager is a program aimed to help teachers test their students. It is written in PHP and uses a MySQL database.
Main features:
- create, delete and edit subjects
- create, delete and edit four type of questions (Open, Multiple choice with only one correct answer, with more than one correct answer and true/false questions)
- create, delete and edit groups
- allow just some groups to take a test
- take and review tests
- sticky questions (always in) to tests
- enable/disable registration

Kurrently is a simple BASH script outputs the currently playing artist and track to ~/.playing_now in this format: Author Name - "Track Name".

Kurrently is meant to be easily modified to direct whatever output you want to whatever location you want.

Why?

Because there are several scripts that output track information to a web page, but none that simply dump it to a text file for easy parsing.

Why would I want that?

I dont know. Maybe you use a blogging client that can read plain text files, and you want it to show others what youre listening to automatically? Maybe youd like to track the order of songs youve been listening to? Maybe youd like to display the contents of this file in a web page you already have set up somewhere? Do with it as you see fit.

Can I make changes?

Certainly. Its the beauty of the GPL. In fact, I recommend it. This script is very simplistic in what it does and how it does it. If youd like to make it dance to a different tune, feel free!

List::MoreUtils is a Perl module that can provide the stuff missing in List::Util.

SYNOPSIS

use List::MoreUtils qw(any all none notall true false firstidx first_index
lastidx last_index insert_after insert_after_string
apply after after_incl before before_incl indexes
firstval first_value lastval last_value each_array
each_arrayref pairwise natatime mesh zip uniq minmax);

List::MoreUtils provides some trivial but commonly needed functionality on lists which is not going to go into List::Util.

All of the below functions are implementable in only a couple of lines of Perl code. Using the functions from this module however should give slightly better performance as everything is implemented in C. The pure-Perl implementation of these functions only serves as a fallback in case the C portions of this module couldnt be compiled on this machine.

any BLOCK LIST

Returns a true value if any item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "At least one value undefined"
if any { !defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

all BLOCK LIST

Returns a true value if all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "All items defined"
if all { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

none BLOCK LIST

Logically the negation of any. Returns a true value if no item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "No value defined"
if none { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

notall BLOCK LIST

Logically the negation of all. Returns a true value if not all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "Not all values defined"
if notall { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

true BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

printf "%i item(s) are defined", true { defined($_) } @list;

false BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is false. Sets $_ for each item in LIST in turn:

printf "%i item(s) are not defined", false { defined($_) } @list;

firstidx BLOCK LIST

first_index BLOCK LIST

Returns the index of the first element in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

my @list = (1, 4, 3, 2, 4, 6);
printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
__END__
item with index 1 in list is 4

Returns -1 if no such item could be found.

first_index is an alias for firstidx.

Struct::Compare is a recursive diff for perl structures.

SYNOPSIS

use Struct::Compare;
my $is_different = compare($ref1, $ref2);

Compares two values of any type and structure and returns true if they are the same. It does a deep comparison of the structures, so a hash of a hash of a whatever will be compared correctly.

This is especially useful for writing unit tests for your modules!

PUBLIC FUNCTIONS

$bool = compare($var1, $var2)

Recursively compares $var1 to $var2, returning false if either structure is different than the other at any point. If both are undefined, it returns true as well, because that is considered equal.

Group Shell is a tool to aggregate several remote shells into one. It is used to launch an interactive remote shell on many machines at once. Group Shell is written in Python and requires Python ≥ 2.4.

There is a control shell accessible with Ctrl-C that is used to list some information about the current remote shells. It also allows common terminal manipulations like sending a Ctrl-C, Ctrl-Z, Ctrl-D …

The prompt shows the number of listening shells and the number of active shell. A shell is said to be listening if its prompt has returned and it is accepting commands, active shells are those whose connection is still alive. Shells can be individually enabled and disabled.

Here is the transcript of a sample session:

[g ~/gsh]$ ./gsh.py machine{0-9}

[10/10]> date

machine4: ven nov 10 23:26:36 CET 2006
machine7: ven nov 10 23:26:36 CET 2006
machine3: ven nov 10 23:26:36 CET 2006
machine5: ven nov 10 23:26:36 CET 2006
machine9: ven nov 10 23:26:36 CET 2006
machine0: ven nov 10 23:26:36 CET 2006
machine2: ven nov 10 23:26:36 CET 2006
machine1: ven nov 10 23:26:37 CET 2006
machine6: ven nov 10 23:26:37 CET 2006
machine8: ven nov 10 23:26:37 CET 2006
[10/10]>
Now, Ctrl-C is pressed, it triggers the control shell.
(Cmd) help

Documented commands (type help < topic >):

EOF enable list send_eof set_print_first
continue get_print_first quit send_sigint unset_print_first
disable help reconnect send_sigtstp

(Cmd) list
machine0 fd:3 r:3 w:0 active:True enabled:True idle
machine1 fd:4 r:3 w:0 active:True enabled:True idle
machine2 fd:5 r:3 w:0 active:True enabled:True idle
machine3 fd:6 r:3 w:0 active:True enabled:True idle
machine4 fd:7 r:3 w:0 active:True enabled:True idle
machine5 fd:8 r:3 w:0 active:True enabled:True idle
machine6 fd:9 r:3 w:0 active:True enabled:True idle
machine7 fd:10 r:3 w:0 active:True enabled:True idle
machine8 fd:11 r:3 w:0 active:True enabled:True idle
machine9 fd:12 r:3 w:0 active:True enabled:True idle

10 active shells, 0 dead shells, total: 10
(Cmd) quit
[g ~/gsh]$

ustr (Micro string library) is a string API for C. A few years ago now I wrote a very extensive String API for C, called Vstr, it was designed to perform extremely well for IO like patterns as that was my planned usage (for instance And-httpd, my Web server). It works very well, for that usage.
Also due to the extensivness of the API I basically used it everywhere, even though there are some things it is somewhat "overkill" for, and I wanted other people to use it so I didnt have to resort to using string.h when creating patches for their code. However more than a few C coders I speak to have one of a few reasons why they dont want to use Vstr. The ustr API should solve all of these problems, and hopefully fill in all the gaps where Vstr is the 500lb hammer.
A Significant example of usage, with comments:
Ustr *s1 = USTR(""); /* == "", always works */
Ustr *s2 = ustr_dup(s1); /* == "", always works */
Ustr *s3 = ustr_dup_cstr(""); /* == "", always works */
ustr_cmp_eq(s1, s2); /* == TRUE */
ustr_cmp_eq(s1, s3); /* == TRUE */
if (ustr_shared(s2)) /* This is TRUE, as a constant/read-only string cannot be freed */
/* whatever */ ;
if (ustr_ro(s2)) /* This is TRUE */
/* whatever */ ;
if (!ustr_add_fmt(&s2, "%s %d %c%d", "x", 4, 0, 8))
/* error */ ;
if (ustr_owner(s1)) /* This will return FALSE, as noone owns the "" read-only string */
/* whatever */ ;
if (ustr_owner(s2)) /* This will return TRUE, as weve now got allocated memory for s2 */
/* whatever */ ;
foo_API(ustr_cstr(s1), ustr_len(s1)); /* == "", 0 */
foo_API(ustr_cstr(s2), ustr_len(s2)); /* == "x 4 008", 6 */
s3 = ustr_dup(s2); /* dont need to free s3 as its empty */
/* dont need to check for errors as s2 == s3 */
if (ustr_owner(s2)) /* This will now return FALSE, weve got two references: s2 and s3 */
/* whatever */ ;
if (ustr_shared(s2)) /* This is FALSE, its a non-shared string referenced by both s2 and s3 */
/* whatever */ ;
ustr_free(s2); /* freed one reference to the data pointed to by both s2 and s3 */
ustr_set_share(s2); /* Make s2/s3 "shared" data,
so it always has infinite references */
if (ustr_shared(s2)) /* This is TRUE */
/* whatever */ ;
if (ustr_ro(s2)) /* This is FALSE */
/* whatever */ ;
s3 = ustr_dup(s2); /* This is the same as s3 = s2; */
ustr_free(s2); /* These do nothing */
ustr_free(s2);
ustr_free(s2);
ustr_free(s2);
if (!ustr_add_cstr(&s3, "abcd"))
/* error */ ;
ustr_add_cstr(&s3, "1234");
ustr_add_cstr(&s3, "xyz");
if (ustr_enomem(s3)) /* check for errors on the last 2 ustr_add_cstr() functions at once
ustr_owner(x) has to be true for this to be reliable,
hence the explicit first check */
/* error */ ;
ustr_set_owner(s2); /* Make s2 be "non-shared" and have a single owner */
ustr_set_owner(s1); /* This fails, as you cant make a read-only string be "non-shared" */
ustr_sc_del(&s2); /* freed s2 and set s2 = USTR("") */
ustr_cmp_eq(s1, s2); /* == TRUE */
s2 = USTR1(x0b, "Hello world"); /* Constant string with data */
if (ustr_shared(s2)) /* This is TRUE */
/* whatever */ ;
if (ustr_ro(s2)) /* This is TRUE */
/* whatever */ ;
/* dont need to "free" anything else */
Enhancements:
- A lot of new functions were added, such as insert, replace, split, substitute, and io_getdelim.
- Documentation improvements were made.
- Build fixes were made for Win32.

SQLIer is a script that uses brute force to crack passwords through "true/false" SQL injection vulnerabilities. With "true/false" SQL injection vulnerabilities, you cannot actually query data out of the database, only ask a statement that is returned "true" or "false".
SQLIer takes each characters ASCII code and asks a "higher/lower" question to the database, eventually reaching the actual character code. This script also does not use quotes in the exploit to operate, meaning it will work for a wider range of sites.
An 8 character password (containing any character from decimal ASCII code 1-127) takes approximately 1 minute to crack.
Enhancements:
- This release removes the dependency on the "tempfile" command, which apparently is Debian/Debian-derivative specific.
- It should now work on most GNU/Unix platforms.