Free null modem cable software for linux

NullableTypes for .NET are a very reliable and efficient version of built-in value-types that can be Null. NullableTypes pass more than 800 differents test cases and have close-to-optimal efficiency as built-in value-types. They may be used every time you need to store a Null value in a .NET built-in value-type.

Types implemented by NullableTypes are: NullableBoolean, NullableByte, NullableInt16, NullableInt32, NullableInt64, NullableSingle, NullableDouble, NullableDecimal, NullableString and NullableDateTime.

Helper functions provide seamless integration with Windows and ASP.NET user controls and with ADO.NET.

NullableTypes will let you write code like this:

public sealed class Order{
public int OrderID {get {/*...*/}}
public int CustomerID {get {/*...*/}}
public NullableDateTime RequestedDeliveryDate {get {/*...*/}}
// remaining members elided for clarity
}

where RequestedDeliveryDate can be either NullableDateTime.Null or a valid DateTime value.

The property RequestedDeliveryDate.IsNull tests if the date is Null, and when it is not Null the property RequestedDeliveryDate.Value returns a valid DateTime value.

Modem.pl is a small script that scrapes the web interface of a Motorola SURFboard cable modem for various status conditions like signal strength and signal to noise.
The results are sent to STDOUT where they can be easily piped into a log file. The modem values are also checked for reasonable operating ranges.
If the modem values are outside of reasonable operating ranges, results are also sent to STDERR. When run from a cron job, modem.pl can be used to monitor the condition of the cable service and notify someone before conditions cause service interruptions.
Main features:
- Captures operating conditions of a Motorola SURFboard cable modem.
- Runs interactively or from a scheduled job (cron)
- Output is formatted with a standard log time stamp when scheduled.
- Checks modem values for reasonable operating ranges.
- Errors and warnings are duplicated to STDERR.

Null IBBS is an Internet Bulletin Board System derived from an old snapshot of NullLogic Groupware.

Null iBBS uses cleartext password transmission. If security is a concern, use https!

This program is derived from an earlier version of Sentinel Groupware. This program also shares code with Null Webmail.

Installation

Null iBBS installation is a bit of a do-it-yourself process for the time being.

1) Move all the files and directories to a directory of your choice. /usr/local/ibbs might be a good default.

2) Edit the Makefile and check the mysql and pgsql dependencies.

3) Type make mysql or make pgsql to build the binary.

4) Create your database and use ibbsdb.mysql or ibbsdb.pgsql to create the database schema.

5) Edit etc/ibbs.cfg to match your configuration.

6) Make sure the files/ directory is writable by the user Null iBBS will be run as.

7) Run ./ibbs from bin/ (NOT AS ROOT!).

8) Curse the crappy install process, and give up in disgust (optional).

With luck, you now have Null iBBS running as a standalone server. It can also be run as a cgi by copying the binary and ibbs.cfg to your cgi-bin directory (works for me).

The Wonder Shaper is a very special network shaper script with a lot of features. Works on Linux 2.4 & higher.

Goals

I attempted to create the holy grail:

* Maintain low latency for interfactive traffic at all times.

This means that downloading or uploading files should not disturb SSH or even telnet. These are the most important things, even 200ms latency is sluggish to work over.

* Allow surfing at reasonable speeds while up or downloading

Even though http is bulk traffic, other traffic should not drown it out too much.

* Make sure uploads dont harm downloads, and the other way around

This is a much observed phenomenon where upstream traffic simply destroys download speed. It turns out that all this is possible, at the cost of a tiny bit of bandwidth. The reason that uploads, downloads and ssh hurt eachother is the presence of large queues in many domestic access devices like cable or DSL modems.

Why it doesnt work well by default

ISPs know that they are benchmarked solely on how fast people can download. Besides available bandwidth, download speed is influenced heavily by packet loss, which seriously hampers TCP/IP performance. Large queues can help prevent packetloss, and speed up downloads. So ISPs configure large queues.

These large queues however damage interactivity. A keystroke must first travel the upstream queue, which may be seconds (!) long and go to your remote host. It is then displayed, which leads to a packet coming back, which must then traverse the downstream queue, located at your ISP, before it appears on your screen.

This HOWTO teaches you how to mangle and process the queue in many ways, but sadly, not all queues are accessible to us. The queue over at the ISP is completely off-limits, whereas the upstream queue probably lives inside your cable modem or DSL device. You may or may not be able to configure it. Most probably not.

So, what next? As we cant control either of those queues, they must be eliminated, and moved to your Linux router. Luckily this is possible.

Limit upload speed somewhat

By limiting our upload speed to slightly less than the truly available rate, no queues are built up in our modem. The queue is now moved to Linux.

Limit download speed

This is slightly trickier as we cant really influence how fast the internet ships us data. We can however drop packets that are coming in too fast, which causes TCP/IP to slow down to just the rate we want. Because we dont want to drop traffic unnecessarily, we configure a burst size we allow at higher speed.

Now, once we have done this, we have eliminated the downstream queue totally (except for short bursts), and gain the ability to manage the upstream queue with all the power Linux offers.

Let interactive traffic skip the queue

What remains to be done is to make sure interactive traffic jumps to the front of the upstream queue. To make sure that uploads dont hurt downloads, we also move ACK packets to the front of the queue. This is what normally causes the huge slowdown observed when generating bulk traffic both ways. The ACKnowledgements for downstream traffic must compete with upstream traffic, and get delayed in the process.

We also move other small packets to the front of the queue - this helps operating systems which do not set TOS bits, like everything from Microsoft.

Allow the user to specify low priority traffic (new in 1.1!)

Sometimes you may notice low priority OUTGOING traffic slowing down important traffic. In that case, the following options may help you:

NOPRIOHOSTSRC
Set this to hosts or netmasks in your network that should have low priority

NOPRIOHOSTDST
Set this to hosts or netmasks on the internet that should have low priority

NOPRIOPORTSRC
Set this to source ports that should have low priority. If you have an unimportant webserver on your traffic, set this to 80

NOPRIOPORTDST
Set this to destination ports that should have low priority.

See the start of wshaper and wshaper.htb

Results

If we do all this we get the following measurements using an excellent ADSL connection from xs4all in the Netherlands:

Baseline latency:
round-trip min/avg/max = 14.4/17.1/21.7 ms

Without traffic conditioner, while downloading:
round-trip min/avg/max = 560.9/573.6/586.4 ms

Without traffic conditioner, while uploading:
round-trip min/avg/max = 2041.4/2332.1/2427.6 ms

With conditioner, during 220kbit/s upload:
round-trip min/avg/max = 15.7/51.8/79.9 ms

With conditioner, during 850kbit/s download:
round-trip min/avg/max = 20.4/46.9/74.0 ms

When uploading, downloads proceed at ~80% of the available speed. Uploads at around 90%. Latency then jumps to 850 ms, still figuring out why.

What you can expect from this script depends a lot on your actual uplink speed. When uploading at full speed, there will always be a single packet ahead of your keystroke. That is the lower limit to the latency you can achieve - divide your MTU by your upstream speed to calculate. Typical values will be somewhat higher than that. Lower your MTU for better effects!

A small table:

Uplink speed | Expected latency due to upload
--------------------------------------------------
32 | 234ms
64 | 117ms
128 | 58ms
256 | 29ms

So to calculate your effective latency, take a baseline measurement (ping on an unloaded link), and look up the number in the table, and add it. That is about the best you can expect. This number comes from a calculation that assumes that your upstream keystroke will have at most half a full sized packet ahead of it.

This boils down to:

mtu * 0.5 * 10
-------------- + baseline_latency
kbit

The factor 10 is not quite correct but works well in practice.

Your kernel

If you run a recent distribution, everything should be ok. You need 2.4 with QoS options turned on.

If you compile your own kernel, it must have some options enabled. Most notably, in the Networking Options menu, QoS and/or Fair Queueing, turn at least CBQ, PRIO, SFQ, Ingress, Traffic Policing, QoS support, Rate Estimator, QoS classifier, U32 classifier, fwmark classifier.

In practice, I (and most distributions) just turn on everything.

The scripts

The script comes in two versions, one which works on standard kernels and is implemented using CBQ. The other one uses the excellent HTB qdisc which is not in the default kernel. The CBQ version is more tested than the HTB one!

See wshaper and wshaper.htb.

Tuning

These scripts need to know the real rate of your ISP connection. This is hard to determine upfront as different ISPs use different kinds of bits it appears. People report success using the following technique:

Estimate both your upstream and downstream at half the rate your ISP specifies. Now verify if the script is functioning - check interactivity while uploading and while downloading. This should deliver the latency as calculated above. If not, check if the script executed without errors.

Now slowly increase the upstream & downstream numbers in the script until the latency comes back. This way you can find optimum values for your connection. If you are happy, please report to me so I can make a list of numbers that work well. Please let me know which ISP you use and the name of your subscription, and its reputed specifications, so I can list you here and save others the trouble.

Installation

If you dial in, you can copy the script to /etc/ppp/ip-up.d and it will be run at each connect.

If you want to remove the shaper from an interface, run wshaper stop. To see status information, run wshaper status.

KNOWN PROBLEMS

If you get errors, add an -x to the first line, as follows:

#!/bin/bash -x

And retry. This will show you which line gives an error. Before contacting me, make sure that you are running a recent version of iproute!

Recent versions can be found at your Linux distributor, or if you prefer compiling, here:
ftp://ftp.inr.ac.ru/ip-routing/iproute2-current.tar.gz

Device::Modem is a Perl extension created to talk to modem devices connected via serial port.

WARNING

This is BETA software, so use it at your own risk, and without ANY warranty! Have fun.

SYNOPSIS

use Device::Modem;

my $modem = new Device::Modem( port => /dev/ttyS1 );

if( $modem->connect( baudrate => 9600 ) ) {
print "connected!n";
} else {
print "sorry, no connection with serial port!n";
}

$modem->attention(); # send `attention sequence (+++)

($ok, $answer) = $modem->dial(02270469012); # dial phone number
$ok = $modem->dial(3); # 1-digit parameter = dial number stored in memory 3

$modem->echo(1); # enable local echo (0 to disable)

$modem->offhook(); # Take off hook (ready to dial)
$modem->hangup(); # returns modem answer

$modem->is_active(); # Tests whether modem device is active or not
# So far it works for modem OFF/ modem ON condition

$modem->reset(); # hangup + attention + restore setting 0 (Z0)

$modem->restore_factory_settings(); # Handle with care!
$modem->restore_factory_settings(1); # Same with preset profile 1 (can be 0 or 1)

$modem->send_init_string(); # Send initialization string
# Now this is fixed to AT H0 Z S7=45 S0=0 Q0 V1 E0 &C0 X4

# Get/Set value of S1 register
my $S1 = $modem->S_register(1);
my $S1 = $modem->S_register(1, 55); # Dont do that if you definitely dont know!

# Get status of managed signals (CTS, DSR, RLSD, RING)
my %signal = $modem->status();
if( $signal{DSR} ) { print "Data Set Ready signal active!n"; }

# Stores this number in modem memory number 3
$modem->store_number(3, 01005552817);

$modem->repeat(); # Repeat last command

$modem->verbose(1); # Normal text responses (0=numeric codes)

# Some raw AT commands
$modem->atsend( ATH0 );
print $modem->answer();

$modem->atsend( ATDT01234567 . Device::Modem::CR );
print $modem->answer();

Device::Modem class implements basic AT (Hayes) compliant device abstraction. It can be inherited by sub classes (as Device::Gsm), which are based on serial connections.

C::Include is a package to easy operate with binary data via describing they like C/C++ structs.

CLASSES AND PACKAGES

C::Include - Header file base parser class
C::Include::Struct - Struct wraper class

USAGE

use C::Include;

POSSIBILITY

- skip comments;

- valid preprocessor commands: define, ifdef, ifndef, endif, else;

- supported bitset and enclosed structs, enums;

- The compiled data may be cached in the external file and at repeated call not compiled
any more, that will speed up operation.8);

- may be defined and redefined type substitutions via #define
(Ex: #define WORD word );

- predefined standart types:
char
unsigned char
short
unsigned short
int
unsigned int
long
unsigned long
long long
unsigned long long
float
double
pointer
null
neganull
bit
short int
long int
long long int
unsigned
unsigned long int
unsigned short int
unsigned long long int
byte
dword
string (null padded)
sstring (space padded)
zstring (null terminated, null padded)

- predefined standart type aliases:
short int => short
long int => long
long long int => long long
unsigned => unsigned long
unsigned long int => unsigned long
unsigned short int => unsigned short
unsigned long long int => unsigned long long
byte => unsigned char
word => unsigned short
dword => unsigned long

QtPhone is a cross-platform telephone emulation application designed to be used with a PC, speakers, microphone, V.92 voice modem and a standard phone line.
ISDN, ADSL and Networking/Cable ( i.e VoIP ) will also be supported. Features include Caller Identification and Voice Mail.
Main features:
- Telephone, Speakerphone Capabilities
- Voice Mail, Caller Identification
- Wireless Headset/Handset Capabilities
- Supports V.92 Full Duplex Voice Modems,
- ISDN, ADSL and Networking/Cable ( i.e. VoIP )
- Voice Activation, Security Features
- Linux, Windows, MAC Versions
- Embedded Linux Version
Enhancements:
- Integrates the comms portions of the code.