Free 4 shared software for linux

GShare project allows users to easily share files between computers.

Shared files are published on the network and display automaticaly in Nautilus Network Servers browser.

An internal FTP server is used to share the files with other users.

IPC::SharedCache is a Perl module to manage a cache in SysV IPC shared memory.

SYNOPSIS

use IPC::SharedCache;

# the cache is accessed using a tied hash.
tie %cache, IPC::SharedCache, ipc_key => AKEY,
load_callback => &load,
validate_callback => &validate;

# get an item from the cache
$config_file = $cache{/some/path/to/some.config};

This module provides a shared memory cache accessed as a tied hash.
Shared memory is an area of memory that is available to all processes. It is accessed by choosing a key, the ipc_key arguement to tie. Every process that accesses shared memory with the same key gets access to the same region of memory. In some ways it resembles a file system, but it is not hierarchical and it is resident in memory. This makes it harder to use than a filesystem but much faster. The data in shared memory persists until the machine is rebooted or it is explicitely deleted.

This module attempts to make shared memory easy to use for one specific application - a shared memory cache. For other uses of shared memory see the documentation to the excelent module I use, IPC::ShareLite (IPC::ShareLite).
A cache is a place where processes can store the results of their computations for use at a later time, possibly by other instances of the application. A good example of the use of a cache is a web server.

When a web server receieves a request for an html page it goes to the file system to read it. This is pretty slow, so the web server will probably save the file in memory and use the in memory copy the next time a request for that file comes in, as long as the file hasnt changed on disk.

This certainly speeds things up but web servers have to serve multiple clients at once, and that means multiple copies of the in-memory data. If the web server uses a shared memory cache, like the one this module provides, then all the servers can use the same cache and much less memory is consumed.

This module handles all shared memory interaction using the IPC::ShareLite module (version 0.06 and higher) and all data serialization using Storable. See IPC::ShareLite and Storable for details.

Web Sharing is a small tray applet for sharing files on the web.

Publish anything on the Internet or your local area network at home, office or school from a folder on your hard disk with just a few clicks of a mouse!

konqueror-share is a small util like nautilus-share.

1, the "smbshared" is come from nautilus-share. it works as a daemon and a dbus service.

Some changes had been done,you can diff it with orig source.

2, the "kshare" is a UI tool to communicate with smbshared.

3, the "patches" contains two patches for kdebase-3.5.1 or 3.5.2, it convert the URL to real Local URL.

You should apply this two patches, otherwise, you can not use kshare in some kio_slave.

Parallel::Workers::Shared is a simple Perl module.

Parallel::Workers::Shared requires no configuration files or environment variables.

gnome-user-share is a small package that binds together various free software projects to bring easy to use user-level file sharing to the masses.

gnome-user-share is meant to run in the background when the user is logged in, and when file sharing is enabled a webdav server is started that shares the $HOME/Public folder. The share is then published to all computers on the local network using mDNS/rendezvous, so that it shows up in the Network location in Gnome.

The dav server used is apache, so you need that installed. Howl is used for mDNS support, so you need to have that installed and mDNSResolver running.

Hyperic SIGAR (System Information Gatherer and Reporter) is a cross-platform, cross-language library and command-line tool for accessing operating system and hardware level information in Java, Perl and .NET.
Hyperic developed SIGAR to overcome the lack of portable access to low-level hardware and operating system metrics found in the Java platform. Its now a key component of the Hyperic HQ management platform since it provides HQ with visibility into things that are otherwise impossible to get to through the standard Java API.
Over the last four years of development, weve enhanced SIGAR to support multiple language bindings and operate on more than 10 OS/hardware combinations.
We think other applications would benefit from the type of information SIGAR provides. We also want to create and foster a community of users who will help us push this technology forward and incorporate it into both open source and commercial applications. So we decided to make this technology open source to give others the ability to enhance their applications.
Main features:
- System memory statistics - total, free, shared
- CPU statistics - load averages, user cpu, system cpu
- Process level statistics - process arguments, memory consumption, cpu consumption, credential info, state, environment, open file descriptors
- File system level statistics - local and remote mounted file systems (NTFS, ext, SMB, NFS, etc), capacity, utilization
- Network interface level statistics - all available network interfaces detected and monitored for bytes received/transmitted, packets received/transmitted, collisions, errors, dropped packets
Enhancements:
- Improved performance and efficiency.
- A bug with User Mode Linux VMs where SIGAR acquired incorrect CPU info has been fixed.

ShmFIFO library provides an easy-to-use interface to shared memory for programs where one process needs to send blocks of data to other processes.

It was developed because pipe(2) and mkfifo(3) have a very small buffer size (4k) and are unsuitable for many applications. Shmfifo allows you to put a block of data in shared memory, get the oldest block of data from shared memory.

ShmFIFO library also has the feature to share one instance of a private data structure among all processes which use the library.

How to use shmfifo

Before using, shared memory should be created. After creating shared memory, process which wants to use it, should attach to memory. Then it can put and get blocks to FIFO. After process is finished working with FIFO, it calls shfifo_detach. When no processes will use FIFO, shared memory should be deallocated.

Usally, lifecycle of shmfifo-based program is following:

[parent] shmfifo_create
[parent] fork(2)
[both] shmfifo_attach
[both] shmfifo_put, shmfifo_get (many times)
[both] shmfifo_detach
[parent] wait(2) or waitpid(2)
[child] exit
[parent] shmfifo_dealloc

shmfifo comes with test.c program, which is good sample of how to write programs with shmfifo. It forks into 2 processes, parent generated variable-length blocks, writes checksum into each block and put it into FIFO. Child gets blocks from fifo, check if checksum is valid (its always valid if there is no bug in program) and prints debug info. after large number of blocks gets transferred, both processes are exit.

Additionally, shmfifo allows processes to share one private structure. test.c uses this structure to store counter, which is increased each time when parent cannot put block to FIFO because its already full and has to wait until child will get block. If small amount of memory allocated for FIFO, then parent will wait more often.

Installation:

make
make test
su -
make install

test.c is sample test program which is builts into test binary. You can run it to test if library is working