Free serial killers software for linux

Serial Over IP is a tool for the transport of serial interfaces over UDP/IP. It is very usefull for connecting distant equipment that run via a serial interfaces to a local computer.


One linux will be server and one will be client. On the server you can start the program typing the following command:

bash# serialoverip -d /dev/ttyS0 9600-8n1 -s 127.0.0.1 3000

... and on the client:

bash# serialoverip -c 127.0.0.1 3000 -d /dev/ttyS1 9600-8n1

In both commands the IP address is the server IP. Note that you have to start the server first, and it will be efectively be running only after the first packet received from the client.

slsnif is a serial line sniffer. It listens to the specified serial port and logs all data coming through it. slsnif works transparently for both the device connected to the serial port and the controlling software for this device. It operates by opening a pseudo tty (pty) and linking it to the actual serial port.
slsnif operates by opening a pty and linking it to the serial port. These are following parameters / options:
1. Serial port to open (required).
2. Name of the file to direct output to (optional, defaults to stdout).
3. Desired baudrate (optional, defaults to 9600 baud).
4. Timestamp On/Off (optional, defaults to Off).
5. Print ascii values in hex On/Off (optional, defaults to Off)
6. Print number of bytes transmitted On/Off (optional, defaults to Off).
7. Optional colors for timestamp, number of bytes transmitted and normal output.
8. Lock port On/Off (optional, defaults to On).
9. Use Unix98 ptys instead of BSD ptys (optional, defaults to BSD style).
10. Second serial port to open. If specified, this port will be used instead of a pty, thus providing an ability to log data between two serial ports.
Enhancements:
- Added ability to resynchronize ports at any time by sending a SIGUSR1 signal to slsnif. Useful for debugging applications that change port parameters mid-way, after starting the transmission. One example is pppd daemon, which sets initial parameters in the chat script, and changes them later, after chat script terminates.
- Added ability to use SYSV (Unix98) ptys instead of BSD ones (see -u and --unix98 parameters). This option can also be turned on/off from rc-file.

Tiny serial terminal is a simple and dumb tool to access serial ports. Mainly intended for use to access serial consoles of various hardware.

Usage:

Download: com.c
Version : 1.1
Size : 4607 bytes
MD5 : 73a394b6d5ad333c2bf542315e1a0b73
SHA1 : 53c8ea8a1d5450ac4237a20c843e1462acaaa96e

Building: cc -o com com.c
Usage : ./com /dev/device [speed]
Example : ./com /dev/ttyS0 [115200]
Keys : Ctrl-A - exit, Ctrl-X - display control lines status
Darcs : darcs get http://tinyserial.sf.net/
Scr.shot: screenshot.png (8862 bytes)

Contact Form Killer is a free tool you can use to generate contact forms for your site, or let your web site visitors add contact forms themselves.
Contact Form Killer script takes care of messy form validation with both JavaScript and PHP, just in case they have JavaScript disabled. The contact forms it generates are nicely formatted and can be further edited to match the look and feel of your site.
Main features:
- Easy to install. Just unzip and upload, or if youre using it on a local server, just unzip!
- Quick generation of contact forms that usually take hours to code.
- JavaScript validation of each input for ultimate usability.
- PHP validation to make sure JavaScript-disablers dont slip the radar.
- Over 10 inputs to pick and choose from.
- Form generation is really easy, just click the checkboxes next to the inputs you want, click submit and youre done!

ASK is a spam killer. This program (Active Spam Killer, or ASK for short) takes an "Active" approach in solving the problem: Everytime an email is received, a message is sent back to the sender asking for confirmation. If that sender does not confirm the message, it remains queued for delivery. If the sender confirms, the message is delivered and removed from the queue. The "confirmed" senders will be added to your "whitelist" and will never be sent another confirmation. Messages from these emails will always be delivered immediately . You can also specify an "ignorelist" for emails that should be always ignored and a "blacklist" that will cause a nastygram to be sent back to the sender everytime an email is received.

There are many traditional approaches to avoiding spam. The most common approach is based on "content-filtering": a program that attempts to classify incoming mails based on their content. This works partially, but in reality, its somewhat easy to find ways to avoid it.

ASK takes advantage of the fact that most spammers use invalid or fake "From:" address in their messages. When a new message arrives and the sender is unknown, ASK sends a "confirmation message" back, informing the sender that the original message has been queued, pending confirmation. When the sender confirms (a simple reply), ASK delivers the original message and adds the sender to a "whitelist". Further messages from this sender will be immediately delivered. It is also possible to ignore messages based on specific criteria, like senders email, subject and so on.

The goal of ASK is to block Spam mail before it is delivered to your mailbox. As we know, filtering alone is not effective since many times Spam mail contains no detectable elements.

ASK should be invoked from .forward (or .procmailrc if you are using procmail). The incoming message should be piped to ASK, which will be in charge of doing the actual delivery.

When ASK receives an email, if first checks the email address against your "ignorelist". If the address is listed there, its ignored completely. Then, the message is checked against your "blacklist". If its there, a nastygram is sent back to the sender with something like "Please stop sending me emails" in the Subject line.

The real fun happens when an email comes from an unknown user (i.e, someone not in any of your lists). In this case, ASK calculates the MD5 checksum of the message + a secret MD5 key (configured during installation time). This number is sent as part of a "confirmation message" back to the user. If the user replies to it, the confirmation number (in the subject) is recognized, the message is dequeued and delivered. If the user does not reply, the message remains queued until its removed.

The program has some intelligence to deal with specific cases. For instance, if a mail is sent to a non-existing user, the error message from mailer-daemon is ignored. This avoids seeing lots of "invalid user" messages in your inbox.

Another interesting "twist" is that messages coming from your own email address are never trusted. If the spammer knows your address he could easily fake your own address as the From: line. Messages coming from you will be identified by a "mailkey", a piece of string you always put on your message by default (maybe a piece of your own signature). Note that this has the added side-effect of allowing any messages coming in reply to a message you sent to someone (as long as that person keeps your "mailkey" in its quoted reply, a practice common these days).

The program never deletes any messages. For instance, if you send yourself a message without your mailkey (a possible Spam), it will be saved in a "Junk" mailfolder (you can specify this folder during the configuration).

The ser2net daemon allows telnet and TCP sessions to be established with a units serial ports. Note that ser2net supports RFC 2217 (remote control of serial port parameters), but you must have a complient client. The only one I know it is kermit application (http://www.columbia.edu/kermit).
Enhancements:
- dataxfer.c, devcfg.c, devcfg.h, ser2net.conf, ser2net.8: Added a s banner token for printing out the serial parameters.
- ser2net.conf: Cleaned up the ugly banner3.
- Makefile.am: Add ser2net.init to EXTRA_DIST.
- configure.in: Move to version 2.3.

serialsnoop is a command-line tool for Linux that echoes bytes to and from any two serial ports, PTYs, or network sockets , and prints all traffic to stdout in hex and ASCII.

to install (binary, debian):

get the latest x86 .deb file and dpkg -i the thing.

to install (from source):

youll need linux. the code uses non-portable linux-isms in the network socket code. this is fixable, but i havent done it yet. for now, its a penguin-only thing.

get the source and untar it.

get my utility header file and put it either in the source tree or somewhere else in your include path

type "make". hopefully it will build for you

"./sersnoop -h" will get you the help. you can specify two fds to listen to: -a and -b. either or both of these can be a network socket, a physical tty, or a virtual pty.

or, on debian systems, to build from source, you can grab the source package files and build from them.

JKhepera is a Java class library for Khepera mini robots. It includes a class which allows you to open connections from a host computer to the Khepera robot via a serial interface easily.
Communication between Khepera and a computer is also simple, using methods like "setSpeed" or "readProximitySensors".
In addition, there are GUI classes to display the whole communication for debugging purposes and to control the robot manually.
Main features:
- Open Source - JKhepera is published under the terms of GPL.
- Easy to handle communication between Khepera robots and a host computer via serial interface.
- The gui component KheperaPanel, to control Khepera manually
- The gui component KheperaMonitor, to display the complete communication between Khepera and a host computer for debugging purposes
- An Interface KheperaMotionalAlgorithm, that allows the implementation of individual control algorithms (additionally to the existing BraitenbergAlgorithm) to control Khepera automatically.
- The KheperaAgent, to control Khepera by an individual algorithm in an independent thread.