Free added value software for linux

Add to Noatun playlist is a service menu that can add files to the Noatun players playlist.

raddump interprets captured RADIUS packets to print a timestamp, packet length, RADIUS packet type, source and destination hosts and ports, and included attribute names and values for each packet.
Enhancements:
- Added support for IEEE 802.1q tagged VLAN frames.

Devel::StealthDebug is a simple non-intrusive debug module.

SYNOPSIS

# in users code:
use Devel::StealthDebug;
... #!assert(< cond >)!
will die at this line if < cond > is not verified...
... #!watch(< var_name >)!
will carp each access to < var_name >
(Idea from Srinivasans monitor module)
... #!emit(< double_quoted_string_to_be_printed >)!
will emit the string Depending on emit_type
it will print, carp, croak or add to a file

carp is the default value for emit_type
... #!dump(< ref to a variable to be dumped >,< another ref >,...)!
will emit the variables structure
... #!when(< var_name >,< op >,< value >)!
will emit when < var_name > will pass the condition described by
< op >< value >. Currently, only works for watched scalar...
... #!emit_type(carp|croak|print)!
Define the emits behaviour

Can also be set on the use line :
use Devel::StealthDebug emit_type => croak;

Note that if you set it this way you gain an additional feature,
you can now emit to a file :

use Devel::StealthDebug emit_type => /path/to/file;
carp being the default value

You can also pass other optionq on the use line :

use Devel::StealthDebug ENABLE=>/path/to/file;
or
use Devel::StealthDebug ENABLE=>$ENV{WHATEVER};
or
use Devel::StealthDebug DUMPER=>1;

The third form will make the dump function use Data::Dumper.

The second form enable debugging only if the var passed as value is true (i.e. different from undef,,zero, or empty list)

The first form will enable the debug instructions if /path/to/file dont exist or exist AND contain a line (regex) which match the current file name.

This behaviour may sound odd, but as theres no way to know it you pass a value or a filename, a first test is made to check if the file exists, if it isnt the case then a value is assumed (so /path/to/missing/file is treated as a value which is true and so debugging is enabled). If the file exists, debugging is disabled unless this file contains a line whith a regex which matchs the current file name.

yatesParse is a C++ library for parsing and handling command line arguments. It can handle normal arguments (foo --help, foo -h, etc) and arguments with values (foo --file evilplans.txt, foo -f evilplans.txt, etc).

A small example program using yatesParse is available in SVN. Complete Doxygen docs are available in both the Docs section of the yatesParse website, and in SVN.

A brief explanation of how yatesParse works:

Command line arguments are added by calling the add_option function, the user must specify the option to add and the address of the function to call when that argument has been detected.

When the parsing function detects an argument, a function of the users choice is called and, if the argument takes a value, the value is passed to the function.

yatesParse can also generate output for --help from the options added and program information that the user specifies.

MySQL Global User Variables UDF is a MySQL extension to store persistent variables.

This shared library adds simple user functions to MySQL in order to keep persistent shared variables in memory. These variables and their values are available to all clients. Any data can be stored into these persistent variables, including BLOBs. Since updates are atomic and way faster than MEMORY tables, this is an easy and efficient way to handle counters and sequences.

Usage:

Storing a value

An unlimited number of user variables can be created, as long as memory is available.
The GLOBAL_STORE(, ) stores a new shared global variable.

Examples:

mysql> DO GLOBAL_STORE("online_users", 42);
mysql> DO GLOBAL_STORE("secret_key", "pajfUyfnd");

The GLOBAL_STORE() function always returns 1 unless an error occurred.

Fetching a value

Reading the value of a variable is the job of the GLOBAL_GET() function.
The value is returned, or NULL is the variable is undefined.

Example:

mysql> SELECT GLOBAL_GET("online_users;);
42

mysql> SELECT id FROM pxs WHERE secret_key = GLOBAL_GET("secret_key");
1

Atomic increments

A single function call can read the previous value, add an integer (that can be negative), and store the new value into the variable.

The function is GLOBAL_ADD(, ) and the return value is the new value of the variable.
Updates are always atomic, if the old value is 18 and you add 1, you will always get back 19.

Example:

mysql> DO GLOBAL_ADD("online_users", 1);
mysql> SELECT GLOBAL_ADD("online_users", -4);
39

If the value of a variable was a string, the new value is the increment:

mysql> SELECT GLOBAL_ADD("secret_key", 12);
12

Adding a value to an undefined variable returns NULL.
A handy variant is GLOBAL_ADDP(, ). GLOBAL_ADDP() is similar to GLOBAL_ADD() but returns the PREVIOUS value of the variable instead of the new one.

Example:

mysql> DO GLOBAL_SET("xxx", 10);
mysql> SELECT GLOBAL_ADDP("xxx", 1);
10
mysql> SELECT GLOBAL_ADDP("xxx", 1);
11

Installation:

On most systems, compiling and installing the library should be as simple as typing (as root):

make install

The shared library is installed as /usr/local/lib/udf_global_user_variables.so

If the base directory of your MySQL installation is not in /usr/local, just type:

make

and then copy udf_global_user_variables.so to the right location for UDFs on your system (maybe /usr/lib/).

The name of a variable is limited to 256 bytes. If that limit is too low for your specific application, just edit the MAX_NAME_LENGTH variable on top of the .c file and reinstall. Variable names can contain binary characters.

Values are limited to 65536 bytes. If that limit is too low for you, edit the MAX_VALUE_LENGTH variable and reinstall.

Array::Unique is a tie-able array that allows only unique values.

SYNOPSIS

use Array::Unique;
tie @a, Array::Unique;

Now use @a as a regular array.

This package lets you create an array which will allow only one occurrence of any value.

In other words no matter how many times you put in 42 it will keep only the first occurrence and the rest will be dropped.

You use the module via tie and once you tied your array to this module it will behave correctly.

Uniqueness is checked with the eq operator so among other things it is case sensitive.

As a side effect the module does not allow undef as a value in the array.

EXAMPLES

use Array::Unique;
tie @a, Array::Unique;

@a = qw(a b c a d e f);
push @a, qw(x b z);
print "@an"; # a b c d e f x z

When you are collecting a list of items and you want to make sure there is only one occurrence of each item, you have several option:

1) using an array and extracting the unique elements later. You might use a regular array to hold this unique set of values and either remove duplicates on each update by that keeping the array always unique or remove duplicates just before you want to use the uniqueness feature of the array. In either case you might run a function you call @a = unique_value(@a);

The problem with this approach is that you have to implement the unique_value function (see later) AND you have to make sure you dont forget to call it. I would say dont rely on remembering this.

There is good discussion about it in the 1st edition of the Perl Cookbook of OReilly. I have copied the solutions here, you can see further discussion in the book.

----------------------------------------
Extracting Unique Elements from a List (Section 4.6 in the Perl Cookbook 1st ed.)

# Straightforward

%seen = ();
@uniq = ();
foreach $item (@list) [
unless ($seen{$item}) {
# if we get here we have not seen it before
$seen{$item} = 1;
push (@uniq, $item);
}
}

# Faster
%seen = ();
foreach $item (@list) {
push(@uniq, $item) unless $seen{$item}++;
}

# Faster but different
%seen;
foreach $item (@list) {
$seen{$item}++;
}
@uniq = keys %seen;

# Faster and even more different
%seen;
@uniq = grep {! $seen{$_}++} @list;

----------------------------------------
2) using a hash
Some people use the keys of a hash to keep the items and
put an arbitrary value as the values of the hash:

To build such a list:
%unique = map { $_ => 1 } qw( one two one two three four! );

To print it:
print join ", ", sort keys %unique;

To add values to it:
$unique{$_}=1 foreach qw( one after the nine oh nine );

To remove values:
delete @unique{ qw(oh nine) };

To check if a value is there:
$unique{ $value }; # which is why I like to use "1" as my value

(thanks to Gaal Yahas for the above examples)

There are three drawbacks I see:

1) You type more.
2) Your reader might not understand at first why did you use hash and what will be the values.
3) You lose the order.

Usually non of them is critical but when I saw this the 10th time in a code I had to understand with 0 documentation I got frustrated.

3) using Array::Unique

So I decided to write this module because I got frustrated by my lack of understanding whats going on in that code I mentioned. In addition I thought it might be interesting to write this and then benchmark it. Additionally it is nice to have your name displayed in bright lights all over CPAN ... or at least in a module.

Array::Unique lets you tie an aray to hmmm, itself (?) and makes sure the values of the array are always unique.

Since writing this I am not sure if I really recommend its usage. I would say stick with the hash version and document that the variable is aggregating a unique list of values.

4) Using real SET

There are modules on CPAN that let you create and maintain SETs. I have not checked any of those but I guess they just as much of an overkill for this functionality as Unique::Array.

Dents is a from-scratch implementation of the server side of the DNS protocol, sharing no code with any other project. Among its several features are compatibility with named, a modular driver system and an extensible control facility which allows the administrator to control the running server.
You should have installed glib from the GNOME project (ftp.gtk.org/pub/gtk). It should contain support for POSIX-threads to be thread-safe. Our "./configure" will disable threads if glib doesnt use pthreads. If you would like to use the control facility, you will also need
ORBit (also from the GNOME project) and support for POSIX-threads. The versions being used by some of the developers are:
glib-1.2.4
ORBit-0.4.3 (optional)
but prior versions will also likely work.
Enhancements:
- clients/gdents-admin/mockup.pl (on_zone_info_clicked): Added fake values so you can watch it sort. Havent decided how to display the value of an SOA record. Right now, comma delineated.
- clients/gdents-admin/ctlfac.glade: (zone_info window) added a menubar, statusbars and progressbar, put the old zone_info window in a notebook, put the old zone_info clist in a scrolled window. Added sort routines for the columns.