Free to capture software for linux

JCapture is an automatic Webcam image grabber & image manipulator. Control it from your crontab once a minute, or however often you want to update the image.

A working installation of ImageMagick is required for this to run properly. I also use CQCam v0.90p7 to capture the image. You will need to change the associated lines in the file where necessary to adjust for paths to the proper executables on your machine.

jack_capture is a small simple program to capture whatever sound is going out to your speakers into a file.

jack_capture is the program I always wanted to have for jack, but no one made. So here it is.

Usage:

jack_capture [ -b bitdepth ] [-c channels] [ -B bufsize ] [filename]

Filename is by default auotogenerated to something like "jack_capture_ .wav"
Bitdepth is by default FLOAT.
Channels is by default 2.
Bufsize is by default 262144.

ltraf is a simple utility to list traffic flowing through a computers network interface. It can categorize the traffic based on bpf rules. It uses libpcap to capture network traffic.
The main goal of the project is to give systems administrators a chance to visualize the traffic flow through a linux based computers network interface in real time.
There are a number of projects that can do similar things (and even more) so you might want to try IPTraf or tcpdump but they are a bit different. Ill let you decide which is best for you.
TODO:
1. Implement timing options for display refresh and measurement
2. Write some more documentation. Like a man page or something.
Version restrictions:
- When interface speed is measured for a long time and too much data flows through some variable in math.c overflows at average calculations.
- Do we need to separate simplex and duplex filters ??
- Duplex filter bpf parsing is buggy and incomplete. Redesign it.

Net::Pcap is an Interface to pcap(3) LBL packet capture library.

SYNOPSIS

use Net::Pcap;

my $err = ;
my $dev = Net::Pcap::lookupdev($err); # find a device

# open the device for live listening
my $pcap = Net::Pcap::open_live($dev, 1024, 1, 0, $err);

# loop over next 10 packets
Net::Pcap::loop($pcap, 10, &process_packet, "just for the demo");

# close the device
Net::Pcap::close($pcap);

sub process_packet {
my($user_data, $header, $packet) = @_;
# do something ...
}

Net::Pcap is a Perl binding to the LBL pcap(3) library. The README for libpcap describes itself as:

"a system-independent interface for user-level packet capture.
libpcap provides a portable framework for low-level network
monitoring. Applications include network statistics collection,
security monitoring, network debugging, etc."

RPCAP is a Remote Packet Capture system. It enables you to run a packet capture program (the server) on a target computer, which will sniff the network traffic on that system, and uplink the captured packets to another host (the client), where the captured packets can be processed, analysed and archived . The rpcap system thus consists of two separate processes, the server (or agent) which captures network traffic on a remote system, and a client, which receives and processes these packets. The server code is a standalone executable program which uses the libpcap packet capture library to capture network traffic. The client is actually a library called librpcap, which is linked to a user program and used on the client system in a manner identical to libpcap, to receive and process the packets which are captured.
The librpcap client library exposes a subset of the pcap API as defined in the pcap (3) manpage. The API is used in a manner identical to that of libpcap, so that any programs which do not use the libpcap functions not present in rpcap can directly link to rpcap in place of pcap. The API functions as a set of pcap-compatible wrapper functions over a Sun RPC interface to the remote server, which invoke the corresponding libpcap functionality on it.
At this time, rpcap has been built and tested only on Linux on Intel platforms. However, it should build on any UNIX like system that supports multithreading and has the RPC libraries and utilities available, so that it should be possible to build it on most systems. Please note however that there are a couple of bugs in the code (all my own!) that currently restrict it to little-endian systems. I will fix this ASAP.
Enhancements:
- New code release v.0.23 alpha
- added GNU autotools based build (autconf/ automake/ libtool)
- pcap_geterr rewritten
- pcap_compile fixed to accept null strings for tcpdump compatibility
- pointer issues with pcap_compile and pcap_open_live resolved
- made the code tcpdump compatible so that tcpdump now builds against librpcap
- added a port of tcpdump to rpcap

Remote Capture for Canon PowerShot cameras project is a tool for controlling Canon PowerShot cameras.
The following cameras were reported to work with Capture. Please send a report to extend the list.
Canon PowerShot S50
Canon PowerShot A60
Canon PowerShot A70
Canon PowerShot A75
Canon PowerShot A80
Canon PowerShot A85
Canon PowerShot A95
Canon PowerShot A510
Canon PowerShot A520
Canon PowerShot G6
Canon Digital IXUS 400 (aka PowerShot S400)
Canon PowerShot S410
Canon PowerShot S500
The main advantage of Capture over gPhoto is that the consecutive shots are taken without the camera lenses being closed and opened again. When taking several thousand shots in a row, this indeed lets the camera live longer.
Enhancements:
- This release adds some minor enhancements and fixes.
- The code is stable.

Parcelle project is a PyGTK application that captures and saves clipboard history.
Main features:
- Automatically captures clipboard changes.
- Saves clipboard history.
- Sort and search through entries.
- Edit and save changes to entries.
- Edit current clipboard contents.
- Dates entry additions and edits.
- Option to launch on startup to capture quietly.

Performance Co-Pilot (PCP) is a framework and services to support system-level performance monitoring and performance management.
The services offered by PCP are especially attractive for those tackling harder system-level performance problems. For example this may involve a transient performance degradation, or correlating end-user quality of service with platform activity, or diagnosing some complex interaction between resource demands on a single system, or management of performance on large systems with lots of "moving parts".
The distributed PCP architecture makes it especially useful for those seeking centralized monitoring of distributed processing (e.g. in a cluster or webserver farm environment), especially where a large number hosts are involved.
Main features:
- A single API for accessing the performance data that hides details of where the data comes from and how it was captured and imported into the PCP framework.
- A client-server architecture allows multiple clients to monitor the same host, and a single client to monitor multiple hosts (e.g. in a Beowulf cluster). This enables centralized monitoring of distributed processing.
- Integrated archive logging and replay so a client application can use the same API to process real-time data from a host or historical data from an archive.
- The framework supports APIs and configuration file formats that enable the scope of performance monitoring to be extended at all levels.
- An "plugin" framework (libraries, APIs, agents and daemon) to collect performance data from multiple sources on a single host, e.g. from the hardware, the kernel, the service layers, the application libraries, and the applications themselves.
- Libraries and sample implementations encourage the development of new "plugins" (or agents) to capture and export the performance data that matters in your application environment, along side the other generic performance data.
- An endian-safe transport layer for moving performance metrics between the collector and the monitoring applications over TCP/IP. This means an IRIX desktop with PCP can monitor one or more Linux systems with the Open Source release of PCP installed.
- A Linux agent that exports a broad range of performance data from most kernels circa 2.0.36 (RedHat 5.2) or later. This includes coverage of activity in the areas of: CPU, disk, memory, swapping, network, NFS, RPC, filesystems and all the per-process statistics.
- Other agents export performance data from:
- Web server activity logs
- arbitrary application-level tracing (via a PCP trace library)
- Cisco routers
- sendmail
- the mail queue
- the PCP infrastructure itself
- Assorted simple monitoring tools that use the PCP APIs to retrieve and display either arbitrary performance metrics, or specific groups of metrics (as in pmstat a cluster-aware vmstat lookalike).
- The PCP inference engine supports automated monitoring through a rule-based language and interpreter that performs user-defined actions when rule predicates are found to be true.