Free borderline personality disorder software for linux

Hydranode Core is a modular, plugin-driven peer-to-peer client framework which is designed with true multi-network downloads in mind.
Hydranode Project can be used directly via the built-in shell functionality, or via external user interfaces.
To achieve the large number of features described in the previous section, HydraNode core needs to be extendible without causing feature bloat and increase in system requirements resulting from that. The only way to accomplish that is make the application completely modular - only a minimum set of features are provided by the core application; the rest of the features are implemented by optional loadable modules. Each file-sharing network should be in a separate module, as should be other additional features like e-mail notifications. With this design, the features are de-coupled from each other, thus greatly simplifying the debugging process, and allowing end user to select only the features he or she needs instead of what a programmer thought was best for him or her.
Second most important pre-requisite for a modern peer-to-peer application is platform-independence. The biggest differences in platforms are the graphical user interfaces, while the underlying structure of operating systems is rather similar. To achieve maximum portability, the core application should be decoupled from graphical user interfaces, which then could be written platform-dependently for each target platform; native user interfaces always perform better than interfaces designed for running on large number of platforms. To achieve this, the core application should not have any interactive graphical user interface of its own at all - it should only provide a protocol through which native graphical user interfaces and other application could communicate with it and control it. The protocol itself should be in human-readable format, but also be easily parse-able for client software; the reason for this would be to allow the possibility of interacting with the protocol directly through simple software like telnet, which would greatly simplify debugging process, but could also be useful even for end users as a crude remote control mechanism.
Related to the above comes the question of programming language to use for writing the core application. At this, C++ would be the most sensible choice, because it is widely used across all platforms and provides fastest code (which is required to achieve low system requirements); it allows (and even enforces) object-oriented design, and is easier to understand than C code. Additionally, since HydraNode strongly relies on module-writers, C++ coders are far easier to find than, say, Java coders.
As mentioned in previous section, quickest way to rapid development process is to give the users free access to the source code of the application; it increases possible developer/debugger-base significantly. Out of the myriad of open source licenses out there, GNU General Public License is most respected among users and developers, so HydraNode source code should follow the trend and be licensed under GNU GPL. Having the source code licensed under GNU GPL also allows us to use the almost infinite amount of existing code freely available through the internet, which could prove as a very useful option.
With the fore-seeable future of large number of co-developer base, it is necessary to clearly define the coding standards for the core application. Coding style is very personal; having large number of developers modifying the code will quickly lead to a mix of different styles and personalities, which in turn makes the code less readable, and thus less maintainable. There are several widely accepted coding standards floating around, and for this project we have chosen to use Linux Kernel coding standard; while originally written for C, the concepts still mostly hold for C++. Source code, however, is worth nothing without correct documentation which would give the future co-developers hints on what the original developers had in mind while writing/designing the application. Again, there several widely accepted documentation standards, out of which perhaps the most common is Doxygen-style. The reason behind this is that Doxygen is capable of extracting documentation from source files and generating web pages out of it, which can give a very quick and extensive overview of the entire application at a glance - something future developers will greatly appreciate.
The privacy of the user should be a serious concern for any modern peer-to-peer application developer; there are several institutions which tend to have a habit of spying upon the users and invading their privacy. The simplest solution would be to block the IP addresses of those groups; even better solution would be to simply stay off their radar. The first part can be implemented within the core application since it controls the low-level networking functionality; second part can be implemented by networking plugins depending on the specific networks.
Since the core application will eventually have a large number of very different networking plugins, we have the problem of bandwidth management. The end user shouldnt be bothered with each specific plugins bandwidth limiting settings, so the bandwidth limits should be managed by the main application, which in turn could either allow or deny requests for bandwidth to modules. This setting should be fully configurable, allowing end user to either have the bandwidth shared equally among the plugins, or in favor of one or several specific plugins.
Various file-sharing networks use very different files identifying methods - most often this is a checksum of the file, sometimes accompanied by file size; additionally, there is files meta-data, which can help the end-user identify the file. Since this feature is common to all file-sharing networks, while only differing in the actual checksum used, it should also be handled by the core application. Several points must be considered here - the core application should be able to generate a large number of checksums and store them. It should also be capable of extracting meta-data of files, as well as do cross-references with checksums - given a checksum from one network, it should be able to find the same file on second network (provided the file is known). However, no single client can know the checksums of all files of all networks, which means that the cross-referencing functionality will be of little use locally - this needs a central database which could store the checksums of all files from all networks, and provide cross-referencing functionality. Heres where Myradin comes in - it does exactly that. While support for Myradin shouldnt be completely integrated since it isnt really a part of the application, it could be an optional plugin that retrieves and submits checksums to the central database.
The last feature is far more important than is obvious on first impression; this is the feature that will eventually allow real multi-network simultaneous downloads of same file. The problem is - since each network uses different checksums for files, it is impossible to identify the same file on two separate networks - you dont know the file is the same until you have downloaded the entire file and generated a checksum out of it. However, with a central database which stores checksums of different files from multiple networks, it would be possible to retrieve the checksums of a file on all other networks provided you have the checksum of a file from one network, thus allowing downloading the same file from two or more networks simultaneously. Upon completition, files actual checksum could again be tested against all known checksums to provide even higher corruption protection than single-network downloads. The central database would also contain files meta-data, which would allow end-users to more clearly identify fake files, thus improving the overall quality of files on all file-sharing networks.
Enhancements:
Graphical User Interface (NEW) (madcat)
- Supports search, download and shared files lists
- Lists loaded modules
- Shows networking statistics
- Lists eDonkey2000 server list
Core/GUI communication (NEW) (madcat)
- Supports networking, files, modules and custom data syncronization with user interface(s).
Hydranode Base (madcat)
- No longer writes ANSI color codes to logfile
- Portability to platforms without stdint.h header
- Portability to unix variants without execinfo.h header
- Full support windows XP Service Pack 2 (half-open connections limiting)
- Using hand-crafted event multiplexing system in sockets to bypass the slow Boost.Signals
- Fixed issues with >2GB files on Windows
- Fixed issues with UDP packets handling when multiple packets arrive with short interval (previously this caused the socket to become dead)
- Support for more than 64 concurrent open connections on Windows
- Handles some race conditions in networking, where events come from backend when frontend has been destroyed more gracefully
- Now remembering total downloaded/uploaded/uptime across sessions (global)
Hydranode Core (madcat)
- No longer allocates disk space when shutting down
- Cleans up filename of invalid characters when starting downloads
- Fixed uploading issues while moving completed download to incoming
- Uploaded amount (for shared files) is now properly stored across sessions
- Avoids duplicate scanning of already-scanned directories
- Fixed crash when download is canceled while chunk hash job is in progress
- Added dynamic module-based upload-speed scaling based on modules overall upload/download data ratio, thus upload-capable modules that have downloaded 70% of data get 70% of upload slots. Note that these are not hard limits, so actual results may vary depending on various conditions.
- Faster and non-blocking disk space allocation for downloads
- Fixes crashes when search result handlers get destroyed
- Properly updates file modification date after movework finishes
- --disable-colors and --transform-colors command-line options
- --module-dir command-line option
- Now correctly handles temp/shared dirs with .. in path names
- No longer shares desktop.ini, thumbs.db and similar files
- No longer loses custom metadata after file rehash
Bittorrent Module (madcat)
- Fixed links command for single-file torrents after restart
- Reduced outgoing client connection timeout from 30s to 5s
- Fixed an issue with URI delimineters not being encoded in tracker GET request (ticket #225).
- Handles tracker responses sent with
newline instead of
- Properly seeds downloaded torrents after completition
- Cleans up cache folder on download completition or canceling
- Properly urlencodes HEAD / GET request arguments (ticket #235)
- Listening ports are now restarted instantly after runtime configuration changes
- Fixed some crashes during torrent completition
- Multi-tracker support
- Fixed uploaded/downloaded ratio calculation
eDonkey2000 Module (madcat)
- Reduced outgoing client connection timeout from 30s to 5s
- Fixed parsing QueueRanking packets from MLDonkey clients
- Fixed a bug where client would be dropped after download session end, when the remote client contacted us and sent AcceptUploadReq, and we didnt send ReqFile.
- Now properly destroys remote LowID clients if we are also LowID.
- More default (hardcoded) servers
- Support for global searching
- Miscellaneous protocol performance improvements and fine-tuning
- Properly switches sources to other files on download completition now
- GlobGetSources v2 packet is sent with different opcode. This raises UDP source queries effectiveness by ~5 times (from 4% to 20+%)
- Better A4AF handling
- Listening ports are now restarted instantly after runtime configuration changes
- Setting ed2k/FindServers can be set to 0 now to disable receiving servers from clients and servers
Email notifications (madcat)
- Fixes unhandled exceptions from connect() call (ticket #217)
HLink application (madcat)
- Its now possible to pass full paths (to .torrent files etc)

Net::FTPServer is a secure, extensible and configurable Perl FTP server.
SYNOPSIS
ftpd [--help] [-d] [-v] [-p port] [-s] [-S] [-V] [-C conf_file]
[-P pidfile] [-o option=value]
Net::FTPServer is a secure, extensible and configurable FTP server written in Perl.
Current features:
- Authenticated FTP access.
- Anonymous FTP access.
- Complete implementation of current RFCs.
- ASCII or binary type file transfers.
- Active or passive mode file transfers.
- Run standalone or from inetd(8).
- Security features: chroot, resource limits, tainting, protection against buffer overflows.
- IP-based and/or IP-less virtual hosts.
- Complete access control system.
- Anonymous read-only FTP personality.
- Virtual filesystem allows files to be served from a database.
- Directory aliases and CDPATH support.
- Extensible command set.
- Generate archives on the fly.
Installation:
A standard ftpd.conf file is supplied with the distribution. Full documentation for all the possible options which you may use in this file is contained in this manual page. See the section CONFIGURATION below.
After doing make install, the standard ftpd.conf file should have been installed in /etc/ftpd.conf. You will probably need to edit this file to suit your local configuration.
Also after doing make install, several start-up scripts will have been installed in /usr/sbin/*ftpd.pl. (On Debian in /usr/bin or /usr/local/bin). Each start-up script starts the server in a different configuration: either as a full FTP server, or as an anonymous-only read-only FTP server, etc.
The commonly used scripts are:
- /usr/sbin/ftpd.pl
- /usr/sbin/ro-ftpd.pl
The first script is for the full FTP server.
These scripts assume that the perl interpreter can be found on the current $PATH. In the rare situation when this is not the case, you may need to edit these scripts.

Net::Server is an extensible, general Perl server engine.
SYNOPSIS
#!/usr/bin/perl -w -T
package MyPackage;
use Net::Server;
@ISA = qw(Net::Server);
sub process_request {
#...code...
}
MyPackage->run(port => 160);
exit;
Main features:
- Single Server Mode
- Inetd Server Mode
- Preforking Simple Mode (PreForkSimple)
- Preforking Managed Mode (PreFork)
- Forking Mode
- Multiplexing Mode using a single process
- Multi port accepts on Single, Preforking, and Forking modes
- Simultaneous accept/recv on tcp, udp, and unix sockets
- Safe signal handling in Fork/PreFork avoids perl signal trouble
- User customizable hooks
- Chroot ability after bind
- Change of user and group after bind
- Basic allow/deny access control
- Customized logging (choose Syslog, log_file, or STDERR)
- HUP able server (clean restarts via sig HUP)
- Dequeue ability in all Fork and PreFork modes.
- Taint clean
- Written in Perl
- Protection against buffer overflow
- Clean process flow
- Extensibility
Net::Server is an extensible, generic Perl server engine. Net::Server combines the good properties from Net::Daemon (0.34), NetServer::Generic (1.03), and Net::FTPServer (1.0), and also from various concepts in the Apache Webserver.
Net::Server attempts to be a generic server as in Net::Daemon and NetServer::Generic. It includes with it the ability to run as an inetd process (Net::Server::INET), a single connection server (Net::Server or Net::Server::Single), a forking server (Net::Server::Fork), a preforking server which maintains a constant number of preforked children (Net::Server::PreForkSimple), or as a managed preforking server which maintains the number of children based on server load (Net::Server::PreFork). In all but the inetd type, the server provides the ability to connect to one or to multiple server ports.
Net::Server uses ideologies of Net::FTPServer in order to provide extensibility. The additional server types are made possible via "personalities" or sub classes of the Net::Server. By moving the multiple types of servers out of the main Net::Server class, the Net::Server concept is easily extended to other types (in the near future, we would like to add a "Thread" personality).
Net::Server borrows several concepts from the Apache Webserver. Net::Server uses "hooks" to allow custom servers such as SMTP, HTTP, POP3, etc. to be layered over the base Net::Server class. In addition the Net::Server::PreFork class borrows concepts of min_start_servers, max_servers, and min_waiting servers.
Net::Server::PreFork also uses the concept of an flock serialized accept when accepting on multiple ports (PreFork can choose between flock, IPC::Semaphore, and pipe to control serialization).

Wormux project is free software clone of this game concept. Though currently under heavy development, it is already very playable, with lots of weapons (Dynamite, Baseball Bat, Teleportation, etc.).

There are also lots of maps available for your battling pleasure! Wormux takes the genre to the next level, with great customisation options leading to great gameplay.

There is a wide selection of teams, from the Aliens to the Chickens. Also, new battlefields can be downloaded from the Internet, making strategy an important part of each battle.

Though two human players are currently needed to play (unless you have a split personality) the creation of artificial players and network play are future goals. So, start downloading today, and fight to become king of the garden!

AutoZen is a software brain machine for Linux. It generates sounds that are meant to cause the brain to temporarily shift to a different dominant frequency and cause the user to experience an altered state of consciousness. It is similar to the devices seen in the Sharper Image catalog and in magazine ads, but the price is a lot more attractive!

To our knowledge, the medical community has done very little research into these devices, and they may very well do nothing at all. The author has used AutoZen with good results, perhaps because he meditates regularly, employs wishful thinking, or is just strange. We give no warranty of any kind.

All the same, if you are under treatment for any psychiatric or neurological disorder, you might want to approach this with caution. We have never heard of any problems caused by any software or device of this nature other than some epileptics having problems with the ones that include flashing lights (but then, Pokemon causes the same problem).

Virt-Factory project manages virtualized infrastructure:
Virt-Factory focuses on interacting with large numbers of virtual systems and on addressing some of the interaction problems that brings with it
Virt-Factory is primarily aimed at a fairly formal setting (data center), though we hope it is also useful on smaller scales
While Virt-Factory has some uses for bare-metal systems, it is first and foremost a tool for managing virtual systems. Future development will be much more focused on virtual systems management than bare-metal.
Virt-Factory provides both a web UI, for ease of use, and an XMLRPC API, for scripting of admin actions.
Virt-Factory is built on open-source projects including Cobbler, libvirt, and Puppet.
Today, Virt-Factory provisions and manages hosts and guests. It also addresses some of the problems specific to virtual systems. It creates complete host and guest images from metadata descriptions and centrally manages existing images.
Future work will make it possible to abstract away individual hosts and place guests into a pool of equivalent hosts, simplifying the administrators view of the data center for many tasks.
Whats It Run On?
It is being developed on FC-6. Well add support for FC-7 and RHEL-5 shortly.
How Stable Is It?
At this point, virt-factory an alpha level project that will probably eat your brane. However its getting better every day.
Whats the architecture look like?
Virt-factory provides a central server for managing virtual hosts and guests. The server exposes an XMLRPC API that is used by the Web UI, and can also be used by custom scripts. On Managed systems, a special "node daemon" is installed, which the central server communicates with over secure XMLRPC.
Who is the target user?
Developers who want to be involved in new systems management technology. Users wishing to run a large number of virtual systems that have a key interest in virtualization and system recipes / appliance concepts.
How is Virtualization used?
Virtualization plays a core role in virt-factory and is heavily integrated. The software takes care of the nuts and bolts and can entirely manage your virtualization, though logging into virtualization via xm and virsh is still supported. Virt-factory is about enablement of virtualization as a core systems-management strategy.
How do you treat appliances?
Appliances can be defined purely as metadata ("profiles") rather than binary blobs. The metadata describes the required virtual machines attributes (number of processors, memory etc), the base system installation (as a template data for the kickstart file), and the appliances "personality" as a puppet manifest. This makes it possible to distribute appliances easily, and allows end-users to adapt appliances to their needs while still being able to consume appliance updates.
Enhancements:
- This release concentrates on making the code more stable and easier to install/deploy.

The hosts can be configured to run arbitrary services, and their personality can be adapted so that they appear to be running certain operating systems. Honeyd enables a single host to claim multiple addresses - I have tested up to 65536 - on a LAN for network simulation.

Honeyd improves cyber security by providing mechanisms for threat detection and assessment. It also deters adversaries by hiding real systems in the middle of virtual systems.
It is possible to ping the virtual machines, or to traceroute them. Any type of service on the virtual machine can be simulated according to a simple configuration file. Instead of simulating a service, it is also possible to proxy it to another machine.

annotate "AIX 4.0 - 4.2" fragment old
# Example of a simple host template and its binding create template
set template personality "AIX 4.0 - 4.2"
add template tcp port 80 "sh scripts/web.sh"
add template tcp port 22 "sh scripts/test.sh $ipsrc $dport"
add template tcp port 23 proxy 10.23.1.2:23
set template default tcp action reset

bind 10.21.19.102 template

The different TCP personalities are learned from reading a nmap fingerprint file. The configured personality is the operating system that nmap or xprobe will return. Personalities can be annotated to determine if they allow FIN-scans for open ports or to select the preference in which they reassemble fragmented IP packets.

Honeyd can be used to create a virtual honey net or for general network monitoring. It supports the creation of a virtual network topology including dedicated routes and routers. The routes can be attributed with latency and packet loss to make the topology seem more realistic.
Because Honeyd interacts with potentially malicious adversaries, you should sandbox it with Systrace. Systrace prevents an adversary from exploiting bugs in your Honeyd scripts.

Subsystem Virtualization

Honeyd supports service virtualization by executing Unix applications as subsystems running in the virtual IP address space of a configured honeypot. This allows any network application to dynamically bind ports, create TCP and UDP connections using a virtual IP address.
Subsystems are virtualized by intercepting their network requests and redirecting them to Honeyd. Every configuration template may contain subsystems that are started as separated processes when the template is bound to a virtual IP address. An additional benefit of this approach is the ability of honeypots to create sporadic background traffic like requesting web pages and reading email, etc.

Network Simulation/Internet-In-The-Box

Honeyd supports assymetric routes and the integration of physical machines into the virtual network topology. As a result, it is possible to use Honeyd for simple network simulations: Physical hosts can be exposed to high latency or packet loss, arbitrary routing infrastructures, etc.

route entry 10.0.0.1 network 10.0.0.0/8
route 10.0.0.1 link 10.0.0.0/24
route 10.0.0.1 add net 10.4.0.0/14 tunnel "thishost" "honeyd-b"
route 10.0.0.1 add net 10.1.0.0/16 10.1.0.1 latency 55ms loss 0.1
route 10.0.0.1 add net 10.2.0.0/16 10.2.0.1 latency 20ms loss 0.1
route 10.0.0.1 add net 10.3.0.0/16 10.2.0.1 latency 20ms loss 0.1
route 10.1.0.1 link 10.1.0.0/24
route 10.2.0.1 link 10.2.0.0/24
[...]
route 10.2.0.1 add net 10.3.0.0/16 10.3.0.1 latency 10ms loss 0.1
route 10.3.0.1 link 10.3.0.0/24
route 10.3.0.1 add net 10.3.1.1/24 10.3.1.1 latency 10ms
route 10.3.0.1 add net 10.3.240.0/20 10.3.240.1 latency 5ms
route 10.3.1.1 link 10.3.1.1/24
route 10.3.240.1 link 10.3.240.0/20
route 10.3.240.1 add net 0.0.0.0/0 10.3.0.1 latency 40ms loss 0.5
[...]
bind 10.2.0.243 to fxp0
bind 10.3.1.15 to fxp0

Using GRE tunneling allows the creation of distributed setups that allow Honeyd to scale to larger networks. It also allows virtual machines to be spread across separate address spaces as GRE tunnel selection can be based on the source addresses.