Free one time software for linux

Network Time Tools (NTT) is a set of network tools designed to provide monitoring of a network and the services on that network, and provide various reports on the hosts/services and optional alerts via email, pager, and cellphones. It also has the capability to send messages on user-specified services to email, pagers and cell phones.
Main features:
- Bandwidth measurement based on time intervals
- Checks Service availibilty on specified Hosts for the following protocols:
- ftp
- ssh
- telnet
- dns
- http ( specific pages )
- www ( simple head )
- pop
- nntp
- imap
- irc
- smtp
- Ability to send alerts based on user specified services to:
- pagers
- cell phones
- email
- A frontend that displays a daily report that can be viewed by a web browser or cell phone.
- views specific servers
- views specific services
- views bandwidth measurements
- view alerts
- Data stored in a Mysql Database
- Easily configurable via an XML config file
- Runs in Daemon or one-shot mode

WMitime is yet another clock dock app (and quite overglorified at that! WMitime shows standard time, date, as well as the new internet time (see www.swatch.com)

onepad is a set of programs to encrypt files using one-time-pad encryption. This is an old but theoretically impossible to easily break way of encryption. I came across this method in Neal Stephensons Cryptonomicon.
It works by XOR-ing every byte in the cleartext message with a byte in the key. As long as every key is only used once, and the key is random, this is supposed to be unbreakable.
However, you need a secure way to exchange keys with the intended recipient. If a third party intercepts the key, it can read the messages.
NOTE: These programs work, but the genpad program relies on the /dev/random device to generate random keys. So the quality of the key and therefore the safety of this encryption method depends on the randomness of the /dev/random device on your system. So I cannot guarantee that the generated keys are totally random. Therefore, if you need really good encryption, use something like ccrypt or GNU Privacy Guard. These have been written, tested and pounded on by a lot of people, probably smarter than I am.
Enhancements:
- Changed to a BSD-style license.
- Makefile changed to build with BSD or GNU make.

The ORTE is an implementation of the RTPS communication protocol defined by Real Time Innovations.

RTPS is an application layer protocol targeted to the real-time communication area. It is built on top of a standard UDP stack.

This protocol is being submitted to the IETF as an informational RFC and has been adopted by the IDA group.

Time::Warp is a Perl module to control over the flow of time.

SYNOPSIS

use Time::Warp qw(scale to time);

to(time + 5); # 5 seconds ahead
scale(2); # make time flow twice normal

Our external experience unfolds in 3 1/2 dimensions (time has a dimensionality of 1/2). The Time::Warp module offers developers control over the measurement of time.

API

to($desired_time)

The theory of relativity asserts that all physical laws are enforced relative to the observer. Since the starting point of time is arbitrary, it is permissable to change it. This has the effect of making it appear as if time is moving forwards or backward instanteously. For example, on some types of operating systems time starts at Wed Dec 31 19:00:00 1969 (this will likely change as we approach 2030 and with the acceptance of 64-bit CPUs).

to(time + 60*60); # 1 hour ahead

scale($factor)

Changes the speed at which time is progressing.

scale(scale * 2); # double the speed of time

Note that it is not possible to stop time or cause it to reverse since this is forbidden by the second law of thermodynamics.

Time::Skew is a Perl module that computes local clock skew with respect to a remote clock.

SYNOPISI

use Time::Skew

# Init Convex Hull and timing data
my $hull=[];
my $result={};

# Iterate data point introduction
Time::Skew::convexhull($result,$datapoint,$hull);

This module supports the computation of the skew between two clocks: the (relative) skew is the speed with which two clocks diverge. For instance, if yesterday two clocks, at the same time, showed respectively 10:00 and 10:05, while today when the former shows 10:00 the latter shows 10:04, we say that their relative skew is 1 minute/24 hours, roughly 7E-4.

The module contains one single subroutine, which accepts as input a pair of timestamps, associated to a message from host A to host B: the timestamps correspond to the time when the message was sent, and to the time when message is received. Each timestamp reflects the value of the local clock where the operation takes place: the clock of host A for the send, the clock of B for the receive.

Please note that the module does _not_ contain any message exchange facility, but only the mathematics needed to perform the skew approximation, once timestamps are known.

The subroutine takes as argument:

a reference to a hash where values related to the timing of the network path from A to B;
a 2-elems array (a data point in the sequel) containing the timestamp of the receive event, and the differece between the send timestamp and the receive timestamp for one message;
a stack containing some data points, those that form the convex hull.

The usage is very simple, and is illustrated by the following example:

#!/usr/bin/perl -w
use strict;
use Time::Skew;

# Initialize data
my $hull=[];
my $result={};
while ( 1 ) {
# Exchange message and acquire a new data point
my $datapoint = acquire();
# Call the convexhull subroutine
Time::Skew::convexhull($result,$datapoint,$hull);
# After first message some results are still undefined
( defined $result->{skewjitter} ) || next;
# here you can use the results

};
}

The data returned in the "result" hash is the following:

result->{skew} the clock skew;
result->{skewjitter} the variance of the skew estimate, used to estimate convergence;
result->{jitter} difference between the current delay and the previous delay;
result->{delay} the communication delay, decremented by a constant (yet unknown) value, used to compute communication jitter;
result->{elems} the number of data points in the convex hull;
result->{select} the index of the data point in the convex hull used to compute the skew;
result->{itimestamp} the timestamp, first element in the data point just passed to the subroutine;
result->{delta} the timestamp difference, second element in the data point just passed to the subroutine;

The data returned in the "hull" stack is a series of data points, selected from those passed to successive calls of the subroutine. The number of data points in the "hull" stack usually does not exceed 20 units.

The algorithm is very fast: each call consists in scanning at most all data points in the "hull" stack, performing simple arithmetic operations for each element.

The algorithm must be fed with a sequence of data points before returning significant results. The accuracy of the estimate keeps growing while new data points are passed to the subroutine. A rough rule of thumb to evaluate estimate accuracy is to observe the skew jitter, and assume it corresponds to the skew estimate accuracy. Paths with quite regular communication delay (small jitter) converge faster.

Time::Beat is a Perl module to convert between standard time and Swatch ".beat" time.

Time::Beat is a module to convert normal time to and from .beats, of which there are a thousand in a day. It can change normal time in time() format to .beats, and .beats into either 24-hour or 12-hour normal time.

SYNOPSIS

use Time::Beat qw(beat time24 time12);

my $time_in_beats = beats($time);

my $beats_in_24hr_time = time24($beat);

my $beats_in_12hr_time = time12($beat);

METHODS

There are three methods in Time::Beat.

beats($time)

beats will give you the current time in .beats if you do not specify a time string. If you specify a string in time() format it will return that particular time in .beats. The basic algorithm for doing this is to take the time in GMT+1 hour, convert it into seconds, and divide by 86.4.

time24($beat)

time24 takes a 3-digit beat time and outputs a 24-hour time along the lines of "12:34:56". The hours will have leading noughts.

time12($beat)

time12 takes a 3-digit beat time and outputs a 12-hour time along the lines of "12:34:56 am" or "12:34:56 pm". Hours do not have leading noughts.