First, I assume you understand the basic idea behind P2P
(person-to-person, or peer-to-peer) sharing systems: a large community
of users agrees to "share" files on their individual computers, and
leave "client" software running on their computer which transmits
these files to anyone who asks for them.
There are two parts to P2P sharing technologies: Finding another user
that has the file you want, and then actually downloading the file.
There are simple ways of doing both and much more clever ways of doing
both. The implementation of these two components are what
differentiates the networks.
The simplest way of finding a user who has a specific file is via one
or more "master" search servers. Each user's client software reports a
list of the files it has to this master server, which keeps the lists
of everyone currently connected. When someone searches for a file, the
client software sends the search request to the master server, which
then returns a list of people who have matching files. This method,
which is used by most networks (with the notable exception of
Gnutella), has the advantage of potentially very fast and complete
searches. However, the entire network can grind to a halt if these
master servers fail or are required to be brought down -- which is
what happened to Napster.
The simplest way of actually transmitting a file over a network is to
do no more than "ask" someone who has the file to send it to you. Your
client software and the other person's client software communicate
directly via very simple file transmission protocols (similar to FTP
or HTTP) to transmit the file directly to you. Again, most networks
use this method (now with the notable exception of Kazaa), but the
disadvantage is that it can be slow if the other person has a slow
network connection, and can abort entirely if the other person
disconnects for some reason.
Gnutella handles searches in a very different manner, as it has no
central servers. A "web" of client nodes is maintained, where each
node has an active connection to a small to moderate number of other
nodes. Searches are sent out to all nodes to which your client has a
connection, who in turn send it to all nodes to which they have a
connection, etc. This results in a lot of background "search traffic"
on the network, and can cause slow and incomplete searches, because
your query will likely not make it to all nodes on the network. The
upside is that there is no central server to crash or be brought down.
Kazaa has an equally interesting way of handling the downloading part
of the equation. In addition to the central servers recording the
filename of each file on the network, they also record the file's
checksum. This enables the central server to identify identical files
on the network. When you download a file that exists on more than one
user's computer, Kazaa will attempt to connect to multiple users at
once, asking each for a different "chunk" of the file. For example,
you might get the first half of the file from one user, and the second
from an entirely different user. Because the checksums are identical,
the network knows that the appropriate combination of the different
chunks of the file will result in a viable download.
Here's a list of some of the major networks and what sets them apart:
Napster: Central servers, simple download protocol. Technically very
primitive, but works well if the central servers are reliable and
Audiogalaxy: Central server, simple download protocol, technically
very similar to Napster.
OpenNap: Uses the Napster protocols, but instead of a central server
run by Napster, Inc., uses a large number of privately-run central
servers using open-source implementations of the Napster server code.
Gnutella: Distributed searching, simple download protocol. No central
server, so there can be slow, incomplete searches. Open protocol, so
there are a LOT of different client applications (e.g. Limewire,
Bearshare, Gnucleus, etc.) that use the exact same network.
Aimster: An "overlay" to Gnutella, can access the public Gnutella
network, as well as the private collections of people on your AOL
Instant Messenger buddy lists who are also using Aimster.
Kazaa: Semi-centralized servers, "distributed" download protocol that
can download the same file from multiple sources simultaneously.
Instead of central servers run by the company, the client software
itself identifies a large number of reliable user nodes with good
bandwidth and makes them "supernodes" that act as central servers.
Kazaa technology was licensed out to a few other companies, so there
are a couple different clients that access the Kazaa network, such as
Grokster and the old Morpheus. (The Morpheus developers had their
license revoked by the Kazaa developers, and the current Morpheus uses
the Gnutella network.)
There are many other smaller networks in use and under development,
but most if not all use some variation on one or more of the basic
principles dicussed here.
Because these networks often use vastly different techniques, not to
mention protocols, there is no way to "communicate from one network to
another". There are some client programs that can access and search
more than one network, but this is nothing more than multiple clients
rolled into one.
Many P2P network protocols are closed, and have not been
reverse-engineered. Gnutella and Napster are notable exceptions to
this -- Gnutella was designed from the beginning to have an open
protocol, and Napster's was quickly reverse-engineered due to it's
popularity and simplicity.
Here's a good discussion regarding the technical operation of
And the Gnutella protocol specification:
And a Napster/OpenNap specification:
infoAnarchy has a lot of good information about P2P networks:
Terms used: napster protocol, gnutella protocol