An anonymizing proxy server removes identifying information from the clients' requests, for the purpose of anonymity. They may also be used to break through filtered contents on the internet.
A proxy server is called an "open proxy" if everyone can connect to it and use it. Usually, open proxies are proxy servers which are badly configured. Open proxies may be abused easily; for example, a bad user may send a corrupting request to a remote server, but hide himself behind an open proxy, so the administrators of the remote server cannot stop him. Open proxies can also be used for spamming. For this reason, some websites do not allow connections to their web servers or to edit content on them through known open proxies.
A "forced proxy" server is a proxy server which handles all of the traffic from the client to the internet. The client will not know that the proxy exists, but all of the information passes through the proxy server. They are sometimes called "transparent" proxy servers, because the user does not know a proxy server is between the client and remote server.
A Transparent SMTP Proxy is a SMTP proxy server that is inserted in between a sending mail server and a receiving mail server. The main purpose of the SMTP proxy is to filter outbound spam. The proxy masquerades itself in such a way that the client and server believe that they are talking to each other even though there is a proxy in between.
There is a lot of software which can be used for running a proxy server. Some software can only work as a proxy server, while other software can also work as a firewall or caching server. Squid, Varnish and Microsoft Internet Security and Acceleration Server (ISA Server) are among the best known pieces of proxy server software. Some proxy software uses the SOCKS protocol. An example is the Java SOCKS Proxy Server.
Client
In net jargon (words people use about the Internet) a client is a computer used by a user to connect to a network and make requests to servers. For example, a web browser is a client software.
Cache (computing)
Caching is a term used in computer science. The idea behind a cache (pronounced "cash" ) is very simple: Very often, obtaining a result for a calculation is very time-consuming, so storing the result is generally a good idea. Two kinds of storage media are used: One is usually quite big, but accessing it is "slow"; the other one can be accessed much faster, but generally it is small. The very basic idea behind caching is to use the medium that is fast to access to have copies of data. There is no difference between the copy, and the original. Accessing the original data may take a long time, or it may be expensive to do (for example: the results of a difficult problem that take a long time to solve). For this reason, it is much "cheaper" to simply use the copy of the data from the cache. Put differently, a cache is a temporary storage area that has copies of data that is used often. When a copy of the data is in this cache, it is faster to use this copy rather than re-fetching or re-calculating the original data. This will make the average time needed to access the data shorter. Putting a new value into a cache often means that an older value needs to be replaced. There are different ideas (usually called "strategies") on how to select the value to replace.
A buffer is very similar to a cache. It is different in that the client accessing the data in a buffer knows there is a buffer; the buffer is managed by the application. With a cache, the client accessing the data need not be aware there is a cache.
Typical computer applications access data in very similar ways. Suppose the data is structured into "blocks", which can be accessed individually. When an application accesses a block it is also very likely to access (or reference) a block that is "close" to the original block. This is known as locality of reference. There are different kinds of such "locality". Locality of reference is one of the reasons why caches work well in many areas of computing.
In order to work well, caches are small, compared to the whole amount of data. The bigger the cache, the longer it takes to lookup an entry. Bigger caches are also more expensive to build.
A cache is a block of memory for storing data which is likely used again. The CPU and hard drive often use a cache, as do web browsers and web servers.
A cache is made up of many entries, called a "pool". Each entry holds a datum (a bit of data) which is a copy of a datum in another place. Caches usually use what is called a "backing store". Backing stores are slow or expensive to access, compared to the cache. A disk cache uses a hard disk as a backing store, for example.
Each entry also has a little information attached, called a "tag". This tag is used to find the location where the original data is stored.
A client (a CPU, web browser, operating system) wants to access a bit of data, it believes to be in the backing store, it first checks to see if the datum can be found in the cache. If the data can be found in the cache, the client can use it and does not need to use the main memory. This is known as a cache hit. So, for example, a web browser program might check its local cache on disk to see if it has a local copy of the contents of a web page at a particular URL. In this example, the URL is the tag, and the contents of the web page is the datum.
The other situation that can occur is that the datum with the tag cannot be found in the cache. This is known as cache miss. The datum needs to be fetched from the backing store. Usually, it is copied into the cache, so that the next time, it no longer needs to be fetched from the backing store.
The cache only has a limited size. To make room for the previously uncached entry, another cached entry may need to be deleted from the cache. Special rules are used to find the entry that should best be deleted. These rules are usually called Heuristics. Heuristics used to find the entry are called replacement policy. A very simple rule used is called "Least recently used" (or LRU). It simply takes the entry that was used the longest time ago. Other heuristics are listed at cache algorithm..
Caches can also be used for writing data; the benefit of this is that the client can continue its operation once the entry has been written to the cache; it does not have to wait until the entry is written to the backing store.
However, the entry must be written to the backing store at some point in time. The timing when this happens is controlled by the write policy.
In a write-through cache, each entry is written to the backing store immediately, as well as being stored in cache.
The other option is to only write to cache, and write to the backing store later. This is known as write-back (or write-behind) cache. The cache marks the entries that have not yet been written to the backing store; the mark that is used is often referred to as dirty flag. Before the entries are deleted from the cache, they are written to the backing store. This is known as lazy write. A miss in a write-back cache (which requires a block to be replaced by another) will often need two memory accesses: one to get the needed datum, and another to write replaced data from the cache to the store.
The caching policy may also say that a certain datum must be written to cache. The client may have made many changes to the datum in the cache. After it is done, it may explicitly tell the cache to write back the datum.
No-write allocation is a cache policy where only reads are cached. This avoids the need for write-back or write-through caching. Writes are done to the backing store all the time.