Try Arial first for NS4/Win

[privoxy.git] / doc / text / developer-manual.txt

Privoxy Developer Manual

By: Privoxy Developers

$Id: developer-manual.sgml,v 1.27 2002/04/08 15:31:18 hal9 Exp $

The developer manual gives the users information on how to help the developer
team. It provides guidance on coding, testing, documentation and other issues.

Privoxy is a web proxy with advanced filtering capabilities for protecting
privacy, filtering web page content, managing cookies, controlling access, and
removing ads, banners, pop-ups and other obnoxious Internet junk. Privoxy has a
very flexible configuration and can be customized to suit individual needs and
tastes. Privoxy has application for both stand-alone systems and multi-user
networks.

Privoxy is based on the code of the Internet Junkbuster (tm). Junkbuster was
originally written by Junkbusters Corporation, and was released as free
open-source software under the GNU GPL. Stefan Waldherr made many improvements,
and started the SourceForge project to continue development.

Privoxy continues the Junkbuster tradition, but adds many refinements,
enhancements and new features.

You can find the latest version of the this manual at http://www.privoxy.org/
developer-manual/. Please see the Contact section on how to contact the
developers.

-------------------------------------------------------------------------------

Table of Contents
 
1. Introduction
3. Quickstart to Privoxy Development
4. Documentation Guidelines
   
    4.1. Quickstart to Docbook and SGML
    4.2. Privoxy Documentation Style
    4.3. Privoxy Custom Entities
   
5. Coding Guidelines
   
    5.1. Introduction
    5.2. Using Comments
       
        5.2.1. Comment, Comment, Comment
        5.2.2. Use blocks for comments
        5.2.3. Keep Comments on their own line
        5.2.4. Comment each logical step
        5.2.5. Comment All Functions Thoroughly
        5.2.6. Comment at the end of braces if the content is more than one
            screen length
       
    5.3. Naming Conventions
       
        5.3.1. Variable Names
        5.3.2. Function Names
        5.3.3. Header file prototypes
        5.3.4. Enumerations, and #defines
        5.3.5. Constants
       
    5.4. Using Space
       
        5.4.1. Put braces on a line by themselves.
        5.4.2. ALL control statements should have a block
        5.4.3. Do not belabor/blow-up boolean expressions
        5.4.4. Use white space freely because it is free
        5.4.5. Don't use white space around structure operators
        5.4.6. Make the last brace of a function stand out
        5.4.7. Use 3 character indentions
       
    5.5. Initializing
       
        5.5.1. Initialize all variables
       
    5.6. Functions
       
        5.6.1. Name functions that return a boolean as a question.
        5.6.2. Always specify a return type for a function.
        5.6.3. Minimize function calls when iterating by using variables
        5.6.4. Pass and Return by Const Reference
        5.6.5. Pass and Return by Value
        5.6.6. Names of include files
        5.6.7. Provide multiple inclusion protection
        5.6.8. Use `extern "C"` when appropriate
        5.6.9. Where Possible, Use Forward Struct Declaration Instead of
            Includes
       
    5.7. General Coding Practices
       
        5.7.1. Turn on warnings
        5.7.2. Provide a default case for all switch statements
        5.7.3. Try to avoid falling through cases in a switch statement.
        5.7.4. Use 'long' or 'short' Instead of 'int'
        5.7.5. Don't mix size_t and other types
        5.7.6. Declare each variable and struct on its own line.
        5.7.7. Use malloc/zalloc sparingly
        5.7.8. The Programmer Who Uses 'malloc' is Responsible for Ensuring
            'free'
        5.7.9. Add loaders to the `file_list' structure and in order
        5.7.10. "Uncertain" new code and/or changes to exitinst code, use FIXME
       
    5.8. Addendum: Template for files and function comment blocks:
   
6. Version Control Guidelines
7. Testing Guidelines
   
    7.1. Testplan for releases
    7.2. Test reports
   
8. Releasing a new version
   
    8.1. Before the Release
    8.2. Update the webserver
    8.3. SuSE or Red Hat
    8.4. OS/2
    8.5. Solaris
    8.6. Windows
    8.7. Debian
    8.8. Mac OSX
    8.9. FreeBSD
    8.10. Tarball
    8.11. HP-UX 11
    8.12. Amiga OS
    8.13. AIX
   
9. Contacting the developers, Bug Reporting and Feature Requests
10. Copyright and History
   
    10.1. Copyright
    10.2. History
   
11. See also

-------------------------------------------------------------------------------

1. Introduction

Privoxy, as an heir to Junkbuster, is an Open Source project and licensed under
the GPL. As such, Privoxy development is potentially open to anyone who has the
time, knowledge, and desire to contribute in any capacity. Our goals are simply
to continue the mission, to improve Privoxy, and to make it available to as
wide an audience as possible.

One does not have to be a programmer to contribute. Packaging, testing, and
porting, are all important jobs as well.

-------------------------------------------------------------------------------

3. Quickstart to Privoxy Development

You'll need an account on Sourceforge to support our development. Mail your ID
to the list and wait until a project manager has added you.

For the time being (read, this section is under construction), please note the
following guidelines for changing stuff in the code. If it is

 1. A bugfix / clean-up / cosmetic thing: shoot
   
 2. A new feature that can be turned off: shoot
   
 3. A clear improvement w/o side effects on other parts of the code: shoot
   
 4. A matter of taste: ask the list
   
 5. A major redesign of some part of the code: ask the list
   
-------------------------------------------------------------------------------

4. Documentation Guidelines

All formal documents are maintained in docbook SGML and located in the doc/
source/* directory. You will need Docbook, the Docbook DTD's and the Docbook
modular stylesheets (or comparable alternatives), and either jade or openjade
(recommended) installed in order to build docs from source. Currently there is 
user-manual, FAQ, and, of course this, the developer-manual in this format. The
README, AUTHORS privoxy.1 (man page) files are also now maintained as Docbook
SGML. The finished files are all in the top-level source directory are
generated files! Also, index.html, the Privoxy home page, is maintained as
SGML. DO NOT edit these directly. Edit the SGML source, or contact someone
involved in the documentation (at present Stefan and Hal).

Other, less formal documents (e.g. LICENSE, INSTALL) are maintained as plain
text files in the toplevel source directory. At least for the time being.

Packagers are encouraged to include this documentation. For those without the
ability to build the docs locally, text versions of each are kept in CVS. HTML
versions are also now being kept in CVS under doc/webserver/*.

Formal documents are built with the Makefile targets of make dok, or
alternately make redhat-dok. If you have problems, try both. The build process
uses the document SGML sources in doc/source/*/* to update all text files in
doc/text/ and to update all HTML documents in doc/webserver/.

Documentation writers should please make sure documents build successfully
before committing to CVS.

How do you update the webserver (i.e. the pages on privoxy.org)?

 1. First, build the docs by running make dok (or alternately make redhat-dok).
   
 2. Run make webserver which copies all files from doc/webserver to the
    sourceforge webserver via scp.
   
-------------------------------------------------------------------------------

4.1. Quickstart to Docbook and SGML

If you are not familiar with SGML, it is a markup language similar to HTML.
Actually, not a mark up language per se, but a language used to define markup
languages. In fact, HTML is an SGML application. Both will use "tags" to format
text and other content. SGML tags can be much more varied, and flexible, but do
much of the same kinds of things. The tags, or "elements", are definable in
SGML. There is no set "standards". Since we are using Docbook, our tags are
those that are defined by Docbook. Much of how the finish document is rendered
is determined by the "stylesheets". The stylesheets determine how each tag gets
translated to HTML, or other formats.

Tags in Docbook SGML need to be always "closed". If not, you will likely
generate errors. Example: <title>My Title</title>. They are also
case-insensitive, but we strongly suggest using all lower case. This keeps
compatibility with [Docbook] XML.

Our documents use "sections" for the most part. Sections will be processed into
HTML headers (e.g. h1 for sect1). The Docbook stylesheets will use these to
also generate the Table of Contents for each doc. Our TOC's are set to a depth
of three. Meaning sect1, sect2, and sect3 will have TOC entries, but sect4 will
not. Each section requires a <title> element, and at least one <para>. There is
a limit of five section levels in Docbook, but generally three should be
sufficient for our purposes.

Some common elements that you likely will use:

<para></para>, paragraph delimiter. Most text needs to be within paragraph     
elements (there are some exceptions).                                          
<emphasis></emphasis>, the stylesheets make this italics.                      
<filename></filename>, files and directories.                                  
<command></command>, command examples.                                         
<literallayout></literllayout>, like <pre>, more or less.                      
<itemizedlist></itemizdelist>, list with bullets.                              
<listitem></listitem>, member of the above.                                    
<screen></screen>, screen output, implies <literallayout>.                     
<ulink url="example.com"></ulink>, like HTML <a> tag.                          
<quote></quote>, for, doh, quoting text.                                       

Look at any of the existing docs for examples of all these and more.

-------------------------------------------------------------------------------

4.2. Privoxy Documentation Style

It will be easier if everyone follows a similar writing style. This just makes
it easier to read what someone else has written if it is all done in a similar
fashion.

Here it is:

  * All tags should be lower case.
   
  * Tags delimiting a block of text (even small blocks) should be on their own
    line. Like:
   
     <para>
      Some text goes here.
     </para>
           
   
    Tags marking individual words, or few words, should be in-line:
   
      Just to <emphasis>emphasize</emphasis>, some text goes here.
           
   
  * Tags should be nested and step indented for block text like: (except
    in-line tags)
   
     <para>
      <itemizedlist>
       <para>
        <listitem>
          Some text goes here in our list example.
         </listitem>
       </para>
      </itemizedlist>
     </para>
           
   
    This makes it easier to find the text amongst the tags ;-)
   
  * Use white space to separate logical divisions within a document, like
    between sections. Running everything together consistently makes it harder
    to read and work on.
   
  * Do not hesitate to make comments. Comments can either use the <comment>
    element, or the <!-- --> style comment familiar from HTML. (Note in Docbook
    v4.x <comment> is replaced by <remark>.)
   
  * We have an international audience. Refrain from slang, or English
    idiosyncrasies (too many to list :).
   
  * Try to keep overall line lengths in source files to 80 characters or less
    for obvious reasons. This is not always possible, with lenghty URLs for
    instance.
   
  * Our documents are available in differing formats. Right now, they are just
    plain text, and HTML, but PDF, and others is always a future possibility.
    Be careful with URLs (<ulink>), and avoid this mistake:
   
    My favorite site is <ulink url="http://example.com">here</ulink>.
   
    This will render as "My favorite site is here", which is not real helpful
    in a text doc. Better like this:
   
    My favorite site is <ulink url="http://example.com">example.com</ulink>.
   
  * All documents should be spell checked occasionally. aspell can check SGML
    with the -H option. (ispell I think too.)
   
-------------------------------------------------------------------------------

4.3. Privoxy Custom Entities

Privoxy documentation is using a number of customized "entities" to facilitate
documentation maintenance.

We are using a set of "boilerplate" files with generic text, that is used by
multiple docs. This way we can write something once, and use it repeatedly
without having to re-write the same content over and over again. If editing
such a file, keep in mind that it should be generic. That is the purpose; so it
can be used in varying contexts without additional modifications.

We are also using what Docbook calls "internal entities". These are like
variables in programming. Well, sort of. For instance, we have the p-version
entity that contains the current Privoxy version string. You are strongly
encouraged to use these where possible. Some of these obviously require
re-setting with each release (done by the Makefile). A sampling of custom
entities are listed below. See any of the main docs for examples.

  * Re-cyclable "boilerplate" text entities are defined like:
   
    <!entity supported SYSTEM "supported.sgml">
   
    In this example, the contents of the file, supported.sgml is available for
    inclusion anywhere in the doc. To make this happen, just reference the now
    defined entity: &supported; (starts with an ampersand and ends with a
    semi-colon), and the contents will be dumped into the finished doc at that
    point.
   
  * Commonly used "internal entities":
   
    p-version: the Privoxy version string, e.g. "2.9.13".                      
    p-status: the project status, either "ALPHA", "BETA", or "STABLE".         
    p-not-stable: use to conditionally include text in "not stable" releases   
    (e.g. "BETA").                                                             
    p-stable: just the opposite.                                               
    p-text: this doc is only generated as text.                                
   
There are others in various places that are defined for a specific purpose.
Read the source!

-------------------------------------------------------------------------------

5. Coding Guidelines

5.1. Introduction

This set of standards is designed to make our lives easier. It is developed
with the simple goal of helping us keep the "new and improved Privoxy"
consistent and reliable. Thus making maintenance easier and increasing chances
of success of the project.

And that of course comes back to us as individuals. If we can increase our
development and product efficiencies then we can solve more of the request for
changes/improvements and in general feel good about ourselves. ;->

-------------------------------------------------------------------------------

5.2. Using Comments

5.2.1. Comment, Comment, Comment

Explanation:

Comment as much as possible without commenting the obvious. For example do not
comment "aVariable is equal to bVariable". Instead explain why aVariable should
be equal to the bVariable. Just because a person can read code does not mean
they will understand why or what is being done. A reader may spend a lot more
time figuring out what is going on when a simple comment or explanation would
have prevented the extra research. Please help your brother IJB'ers out!

The comments will also help justify the intent of the code. If the comment
describes something different than what the code is doing then maybe a
programming error is occurring.

Example:

/* if page size greater than 1k ... */                                         
if ( PageLength() > 1024 )                                                     
{                                                                              
    ... "block" the page up ...                                                
}                                                                              
                                                                               
/* if page size is small, send it in blocks */                                 
if ( PageLength() > 1024 )                                                     
{                                                                              
    ... "block" the page up ...                                                
}                                                                              
                                                                               
This demonstrates 2 cases of "what not to do".  The first is a                 
"syntax comment".  The second is a comment that does not fit what              
is actually being done.                                                        

-------------------------------------------------------------------------------

5.2.2. Use blocks for comments

Explanation:

Comments can help or they can clutter. They help when they are differentiated
from the code they describe. One line comments do not offer effective
separation between the comment and the code. Block identifiers do, by
surrounding the code with a clear, definable pattern.

Example:

/*********************************************************************         
 * This will stand out clearly in your code!                                   
 *********************************************************************/        
if ( thisVariable == thatVariable )                                            
{                                                                              
   DoSomethingVeryImportant();                                                 
}                                                                              
                                                                               
                                                                               
/* unfortunately, this may not */                                              
if ( thisVariable == thatVariable )                                            
{                                                                              
   DoSomethingVeryImportant();                                                 
}                                                                              
                                                                               
                                                                               
if ( thisVariable == thatVariable ) /* this may not either */                  
{                                                                              
   DoSomethingVeryImportant();                                                 
}                                                                              

Exception:

If you are trying to add a small logic comment and do not wish to "disrubt" the
flow of the code, feel free to use a 1 line comment which is NOT on the same
line as the code.

-------------------------------------------------------------------------------

5.2.3. Keep Comments on their own line

Explanation:

It goes back to the question of readability. If the comment is on the same line
as the code it will be harder to read than the comment that is on its own line.

There are three exceptions to this rule, which should be violated freely and
often: during the definition of variables, at the end of closing braces, when
used to comment parameters.

Example:

/*********************************************************************         
 * This will stand out clearly in your code,                                   
 * But the second example won't.                                               
 *********************************************************************/        
if ( thisVariable == thatVariable )                                            
{                                                                              
   DoSomethingVeryImportant();                                                 
}                                                                              
                                                                               
if ( thisVariable == thatVariable ) /*can you see me?*/                        
{                                                                              
   DoSomethingVeryImportant(); /*not easily*/                                  
}                                                                              
                                                                               
                                                                               
/*********************************************************************         
 * But, the encouraged exceptions:                                             
 *********************************************************************/        
int urls_read     = 0;     /* # of urls read + rejected */                     
int urls_rejected = 0;     /* # of urls rejected */                            
                                                                               
if ( 1 == X )                                                                  
{                                                                              
   DoSomethingVeryImportant();                                                 
}                                                                              
                                                                               
                                                                               
short DoSomethingVeryImportant(                                                
   short firstparam,   /* represents something */                              
   short nextparam     /* represents something else */ )                       
{                                                                              
   ...code here...                                                             
                                                                               
}   /* -END- DoSomethingVeryImportant */                                       

-------------------------------------------------------------------------------

5.2.4. Comment each logical step

Explanation:

Logical steps should be commented to help others follow the intent of the
written code and comments will make the code more readable.

If you have 25 lines of code without a comment, you should probably go back
into it to see where you forgot to put one.

Most "for", "while", "do", etc... loops _probably_ need a comment. After all,
these are usually major logic containers.

-------------------------------------------------------------------------------

5.2.5. Comment All Functions Thoroughly

Explanation:

A reader of the code should be able to look at the comments just prior to the
beginning of a function and discern the reason for its existence and the
consequences of using it. The reader should not have to read through the code
to determine if a given function is safe for a desired use. The proper
information thoroughly presented at the introduction of a function not only
saves time for subsequent maintenance or debugging, it more importantly aids in
code reuse by allowing a user to determine the safety and applicability of any
function for the problem at hand. As a result of such benefits, all functions
should contain the information presented in the addendum section of this
document.

-------------------------------------------------------------------------------

5.2.6. Comment at the end of braces if the content is more than one screen
length

Explanation:

Each closing brace should be followed on the same line by a comment that
describes the origination of the brace if the original brace is off of the
screen, or otherwise far away from the closing brace. This will simplify the
debugging, maintenance, and readability of the code.

As a suggestion , use the following flags to make the comment and its brace
more readable:

use following a closing brace: } /* -END- if() or while () or etc... */

Example:

if ( 1 == X )                                                                  
{                                                                              
   DoSomethingVeryImportant();                                                 
   ...some long list of commands...                                            
} /* -END- if x is 1 */                                                        
                                                                               
or:                                                                            
                                                                               
if ( 1 == X )                                                                  
{                                                                              
   DoSomethingVeryImportant();                                                 
   ...some long list of commands...                                            
} /* -END- if ( 1 == X ) */                                                    

-------------------------------------------------------------------------------

5.3. Naming Conventions

5.3.1. Variable Names

Explanation:

Use all lowercase, and seperate words via an underscore ('_'). Do not start an
identifier with an underscore. (ANSI C reserves these for use by the compiler
and system headers.) Do not use identifiers which are reserved in ANSI C++.
(E.g. template, class, true, false, ...). This is in case we ever decide to
port Privoxy to C++.

Example:

int ms_iis5_hack = 0;                                                          

Instead of:

int msiis5hack = 0; int msIis5Hack = 0;                                        

-------------------------------------------------------------------------------

5.3.2. Function Names

Explanation:

Use all lowercase, and seperate words via an underscore ('_'). Do not start an
identifier with an underscore. (ANSI C reserves these for use by the compiler
and system headers.) Do not use identifiers which are reserved in ANSI C++.
(E.g. template, class, true, false, ...). This is in case we ever decide to
port Privoxy to C++.

Example:

int load_some_file( struct client_state *csp )                                 

Instead of:

int loadsomefile( struct client_state *csp )                                   
int loadSomeFile( struct client_state *csp )                                   

-------------------------------------------------------------------------------

5.3.3. Header file prototypes

Explanation:

Use a descriptive parameter name in the function prototype in header files. Use
the same parameter name in the header file that you use in the c file.

Example:

(.h) extern int load_aclfile( struct client_state *csp );                      
(.c) int load_aclfile( struct client_state *csp )                              

Instead of:

(.h) extern int load_aclfile( struct client_state * ); or                      
(.h) extern int load_aclfile();                                                
(.c) int load_aclfile( struct client_state *csp )                              

-------------------------------------------------------------------------------

5.3.4. Enumerations, and #defines

Explanation:

Use all capital letters, with underscores between words. Do not start an
identifier with an underscore. (ANSI C reserves these for use by the compiler
and system headers.)

Example:

(enumeration) : enum Boolean { FALSE, TRUE };                                  
(#define) : #define DEFAULT_SIZE 100;                                          

Note: We have a standard naming scheme for #defines that toggle a feature in
the preprocessor: FEATURE_>, where > is a short (preferably 1 or 2 word)
description.

Example:

#define FEATURE_FORCE 1                                                        
                                                                               
#ifdef FEATURE_FORCE                                                           
#define FORCE_PREFIX blah                                                      
#endif /* def FEATURE_FORCE */                                                 

-------------------------------------------------------------------------------

5.3.5. Constants

Explanation:

Spell common words out entirely (do not remove vowels).

Use only widely-known domain acronyms and abbreviations. Capitalize all letters
of an acronym.

Use underscore (_) to separate adjacent acronyms and abbreviations. Never
terminate a name with an underscore.

Example:

#define USE_IMAGE_LIST 1                                                       

Instead of:

#define USE_IMG_LST 1 or                                                       
#define _USE_IMAGE_LIST 1 or                                                   
#define USE_IMAGE_LIST_ 1 or                                                   
#define use_image_list 1 or                                                    
#define UseImageList 1                                                         

-------------------------------------------------------------------------------

5.4. Using Space

5.4.1. Put braces on a line by themselves.

Explanation:

The brace needs to be on a line all by itself, not at the end of the statement.
Curly braces should line up with the construct that they're associated with.
This practice makes it easier to identify the opening and closing braces for a
block.

Example:

if ( this == that )                                                            
{                                                                              
   ...                                                                         
}                                                                              

Instead of:

if ( this == that ) { ... }

or

if ( this == that ) { ... }

Note: In the special case that the if-statement is inside a loop, and it is
trivial, i.e. it tests for a condidtion that is obvious from the purpose of the
block, one-liners as above may optically preserve the loop structure and make
it easier to read.

Status: developer-discrection.

Example exception:

while ( more lines are read )                                                  
{                                                                              
   /* Please document what is/is not a comment line here */                    
   if ( it's a comment ) continue;                                             
                                                                               
   do_something( line );                                                       
}                                                                              

-------------------------------------------------------------------------------

5.4.2. ALL control statements should have a block

Explanation:

Using braces to make a block will make your code more readable and less prone
to error. All control statements should have a block defined.

Example:

if ( this == that )                                                            
{                                                                              
   DoSomething();                                                              
   DoSomethingElse();                                                          
}                                                                              

Instead of:

if ( this == that ) DoSomething(); DoSomethingElse();

or

if ( this == that ) DoSomething();

Note: The first example in "Instead of" will execute in a manner other than
that which the developer desired (per indentation). Using code braces would
have prevented this "feature". The "explanation" and "exception" from the point
above also applies.

-------------------------------------------------------------------------------

5.4.3. Do not belabor/blow-up boolean expressions

Example:

structure->flag = ( condition );                                               

Instead of:

if ( condition ) { structure->flag = 1; } else { structure->flag = 0; }

Note: The former is readable and consice. The later is wordy and inefficient.
Please assume that any developer new to the project has at least a "good"
knowledge of C/C++. (Hope I do not offend by that last comment ... 8-)

-------------------------------------------------------------------------------

5.4.4. Use white space freely because it is free

Explanation:

Make it readable. The notable exception to using white space freely is listed
in the next guideline.

Example:

int firstValue   = 0;                                                          
int someValue    = 0;                                                          
int anotherValue = 0;                                                          
int thisVariable = 0;                                                          
                                                                               
if ( thisVariable == thatVariable )                                            
                                                                               
firstValue = oldValue + ( ( someValue - anotherValue ) - whatever )            

-------------------------------------------------------------------------------

5.4.5. Don't use white space around structure operators

Explanation:

- structure pointer operator ( "->" ) - member operator ( "." ) - functions and
parentheses

It is a general coding practice to put pointers, references, and function
parentheses next to names. With spaces, the connection between the object and
variable/function name is not as clear.

Example:

aStruct->aMember;                                                              
aStruct.aMember;                                                               
FunctionName();                                                                

Instead of: aStruct -> aMember; aStruct . aMember; FunctionName ();

-------------------------------------------------------------------------------

5.4.6. Make the last brace of a function stand out

Example:

int function1( ... )                                                           
{                                                                              
   ...code...                                                                  
   return( retCode );                                                          
                                                                               
}   /* -END- function1 */                                                      
                                                                               
                                                                               
int function2( ... )                                                           
{                                                                              
}   /* -END- function2 */                                                      

Instead of:

int function1( ... ) { ...code... return( retCode ); } int function2( ... ) { }

Note: Use 1 blank line before the closing brace and 2 lines afterwards. This
makes the end of function standout to the most casual viewer. Although function
comments help seperate functions, this is still a good coding practice. In
fact, I follow these rules when using blocks in "for", "while", "do" loops, and
long if {} statements too. After all whitespace is free!

Status: developer-discrection on the number of blank lines. Enforced is the end
of function comments.

-------------------------------------------------------------------------------

5.4.7. Use 3 character indentions

Explanation:

If some use 8 character TABs and some use 3 character TABs, the code can look *
very* ragged. So use 3 character indentions only. If you like to use TABs, pass
your code through a filter such as "expand -t3" before checking in your code.

Example:

static const char * const url_code_map[256] =                                  
{                                                                              
   NULL, ...                                                                   
};                                                                             
                                                                               
                                                                               
int function1( ... )                                                           
{                                                                              
   if ( 1 )                                                                    
   {                                                                           
      return( ALWAYS_TRUE );                                                   
   }                                                                           
   else                                                                        
   {                                                                           
      return( HOW_DID_YOU_GET_HERE );                                          
   }                                                                           
                                                                               
   return( NEVER_GETS_HERE );                                                  
                                                                               
}                                                                              

-------------------------------------------------------------------------------

5.5. Initializing

5.5.1. Initialize all variables

Explanation:

Do not assume that the variables declared will not be used until after they
have been assigned a value somewhere else in the code. Remove the chance of
accidentally using an unassigned variable.

Example:

short anShort = 0;                                                             
float aFloat  = 0;                                                             
struct *ptr = NULL;                                                            

Note: It is much easier to debug a SIGSEGV if the message says you are trying
to access memory address 00000000 and not 129FA012; or arrayPtr[20] causes a
SIGSEV vs. arrayPtr[0].

Status: developer-discrection if and only if the variable is assigned a value
"shortly after" declaration.

-------------------------------------------------------------------------------

5.6. Functions

5.6.1. Name functions that return a boolean as a question.

Explanation:

Value should be phrased as a question that would logically be answered as a
true or false statement

Example:

ShouldWeBlockThis();                                                           
ContainsAnImage();                                                             
IsWebPageBlank();                                                              

-------------------------------------------------------------------------------

5.6.2. Always specify a return type for a function.

Explanation:

The default return for a function is an int. To avoid ambiguity, create a
return for a function when the return has a purpose, and create a void return
type if the function does not need to return anything.

-------------------------------------------------------------------------------

5.6.3. Minimize function calls when iterating by using variables

Explanation:

It is easy to write the following code, and a clear argument can be made that
the code is easy to understand:

Example:

for ( size_t cnt = 0; cnt < blockListLength(); cnt ++ )                        
{                                                                              
   ....                                                                        
}                                                                              

Note: Unfortunately, this makes a function call for each and every iteration.
This increases the overhead in the program, because the compiler has to look up
the function each time, call it, and return a value. Depending on what occurs
in the blockListLength() call, it might even be creating and destroying
structures with each iteration, even though in each case it is comparing "cnt"
to the same value, over and over. Remember too - even a call to blockListLength
() is a function call, with the same overhead.

Instead of using a function call during the iterations, assign the value to a
variable, and evaluate using the variable.

Example:

size_t len = blockListLength();                                                
                                                                               
for ( size_t cnt = 0; cnt < len; cnt ++ )                                      
{                                                                              
   ....                                                                        
}                                                                              

Exceptions: if the value of blockListLength() *may* change or could *
potentially* change, then you must code the function call in the for/while
loop.

-------------------------------------------------------------------------------

5.6.4. Pass and Return by Const Reference

Explanation:

This allows a developer to define a const pointer and call your function. If
your function does not have the const keyword, we may not be able to use your
function. Consider strcmp, if it were defined as: extern int strcmp( char *s1,
char *s2 );

I could then not use it to compare argv's in main: int main( int argc, const
char *argv[] ) { strcmp( argv[0], "privoxy" ); }

Both these pointers are *const*! If the c runtime library maintainers do it, we
should too.

-------------------------------------------------------------------------------

5.6.5. Pass and Return by Value

Explanation:

Most structures cannot fit onto a normal stack entry (i.e. they are not 4 bytes
or less). Aka, a function declaration like: int load_aclfile( struct
client_state csp )

would not work. So, to be consistent, we should declare all prototypes with
"pass by value": int load_aclfile( struct client_state *csp )

-------------------------------------------------------------------------------

5.6.6. Names of include files

Explanation:

Your include statements should contain the file name without a path. The path
should be listed in the Makefile, using -I as processor directive to search the
indicated paths. An exception to this would be for some proprietary software
that utilizes a partial path to distinguish their header files from system or
other header files.

Example:

#include <iostream.h>     /* This is not a local include */                    
#include "config.h"       /* This IS a local include */                        

Exception:

/* This is not a local include, but requires a path element. */                
#include <sys/fileName.h>                                                      

Note: Please! do not add "-I." to the Makefile without a _very_ good reason.
This duplicates the #include "file.h" behaviour.

-------------------------------------------------------------------------------

5.6.7. Provide multiple inclusion protection

Explanation:

Prevents compiler and linker errors resulting from redefinition of items.

Wrap each header file with the following syntax to prevent multiple inclusions
of the file. Of course, replace PROJECT_H with your file name, with "." Changed
to "_", and make it uppercase.

Example:

#ifndef PROJECT_H_INCLUDED                                                     
#define PROJECT_H_INCLUDED                                                     
 ...                                                                           
#endif /* ndef PROJECT_H_INCLUDED */                                           

-------------------------------------------------------------------------------

5.6.8. Use `extern "C"` when appropriate

Explanation:

If our headers are included from C++, they must declare our functions as
`extern "C"`. This has no cost in C, but increases the potential re-usability
of our code.

Example:

#ifdef __cplusplus                                                             
extern "C"                                                                     
{                                                                              
#endif /* def __cplusplus */                                                   
                                                                               
... function definitions here ...                                              
                                                                               
#ifdef __cplusplus                                                             
}                                                                              
#endif /* def __cplusplus */                                                   

-------------------------------------------------------------------------------

5.6.9. Where Possible, Use Forward Struct Declaration Instead of Includes

Explanation:

Useful in headers that include pointers to other struct's. Modifications to
excess header files may cause needless compiles.

Example:

/*********************************************************************         
 * We're avoiding an include statement here!                                   
 *********************************************************************/        
struct file_list;                                                              
extern file_list *xyz;                                                         

Note: If you declare "file_list xyz;" (without the pointer), then including the
proper header file is necessary. If you only want to prototype a pointer,
however, the header file is unneccessary.

Status: Use with discrection.

-------------------------------------------------------------------------------

5.7. General Coding Practices

5.7.1. Turn on warnings

Explanation

Compiler warnings are meant to help you find bugs. You should turn on as many
as possible. With GCC, the switch is "-Wall". Try and fix as many warnings as
possible.

-------------------------------------------------------------------------------

5.7.2. Provide a default case for all switch statements

Explanation:

What you think is guaranteed is never really guaranteed. The value that you
don't think you need to check is the one that someday will be passed. So, to
protect yourself from the unknown, always have a default step in a switch
statement.

Example:

switch( hash_string( cmd ) )                                                   
{                                                                              
   case hash_actions_file :                                                    
      ... code ...                                                             
      break;                                                                   
                                                                               
   case hash_confdir :                                                         
      ... code ...                                                             
      break;                                                                   
                                                                               
   default :                                                                   
      log_error( ... );                                                        
      ... anomly code goes here ...                                            
      continue; / break; / exit( 1 ); / etc ...                                
                                                                               
} /* end switch( hash_string( cmd ) ) */                                       

Note: If you already have a default condition, you are obviously exempt from
this point. Of note, most of the WIN32 code calls `DefWindowProc' after the
switch statement. This API call *should* be included in a default statement.

Another Note: This is not so much a readability issue as a robust programming
issue. The "anomly code goes here" may be no more than a print to the STDERR
stream (as in load_config). Or it may really be an ABEND condition.

Status: Programmer discretion is advised.

-------------------------------------------------------------------------------

5.7.3. Try to avoid falling through cases in a switch statement.

Explanation:

In general, you will want to have a 'break' statement within each 'case' of a
switch statement. This allows for the code to be more readable and
understandable, and furthermore can prevent unwanted surprises if someone else
later gets creative and moves the code around.

The language allows you to plan the fall through from one case statement to
another simply by omitting the break statement within the case statement. This
feature does have benefits, but should only be used in rare cases. In general,
use a break statement for each case statement.

If you choose to allow fall through, you should comment both the fact of the
fall through and reason why you felt it was necessary.

-------------------------------------------------------------------------------

5.7.4. Use 'long' or 'short' Instead of 'int'

Explanation:

On 32-bit platforms, int usually has the range of long. On 16-bit platforms,
int has the range of short.

Status: open-to-debate. In the case of most FSF projects (including X/
GNU-Emacs), there are typedefs to int4, int8, int16, (or equivalence ... I
forget the exact typedefs now). Should we add these to IJB now that we have a
"configure" script?

-------------------------------------------------------------------------------

5.7.5. Don't mix size_t and other types

Explanation:

The type of size_t varies across platforms. Do not make assumptions about
whether it is signed or unsigned, or about how long it is. Do not compare a
size_t against another variable of a different type (or even against a
constant) without casting one of the values. Try to avoid using size_t if you
can.

-------------------------------------------------------------------------------

5.7.6. Declare each variable and struct on its own line.

Explanation:

It can be tempting to declare a series of variables all on one line. Don't.

Example:

long a = 0;                                                                    
long b = 0;                                                                    
long c = 0;                                                                    

Instead of:

long a, b, c;

Explanation: - there is more room for comments on the individual variables -
easier to add new variables without messing up the original ones - when
searching on a variable to find its type, there is less clutter to "visually"
eliminate

Exceptions: when you want to declare a bunch of loop variables or other trivial
variables; feel free to declare them on 1 line. You should, although, provide a
good comment on their functions.

Status: developer-discrection.

-------------------------------------------------------------------------------

5.7.7. Use malloc/zalloc sparingly

Explanation:

Create a local stuct (on the stack) if the variable will live and die within
the context of one function call.

Only "malloc" a struct (on the heap) if the variable's life will extend beyond
the context of one function call.

Example:

If a function creates a struct and stores a pointer to it in a                 
list, then it should definately be allocated via `malloc'.                     

-------------------------------------------------------------------------------

5.7.8. The Programmer Who Uses 'malloc' is Responsible for Ensuring 'free'

Explanation:

If you have to "malloc" an instance, you are responsible for insuring that the
instance is `free'd, even if the deallocation event falls within some other
programmer's code. You are also responsible for ensuring that deletion is
timely (i.e. not too soon, not too late). This is known as "low-coupling" and
is a "good thing (tm)". You may need to offer a free/unload/destuctor type
function to accomodate this.

Example:

int load_re_filterfile( struct client_state *csp ) { ... }                     
static void unload_re_filterfile( void *f ) { ... }                            

Exceptions:

The developer cannot be expected to provide `free'ing functions for C run-time
library functions ... such as `strdup'.

Status: developer-discrection. The "main" use of this standard is for
allocating and freeing data structures (complex or nested).

-------------------------------------------------------------------------------

5.7.9. Add loaders to the `file_list' structure and in order

Explanation:

I have ordered all of the "blocker" file code to be in alpha order. It is
easier to add/read new blockers when you expect a certain order.

Note: It may appear that the alpha order is broken in places by POPUP tests
coming before PCRS tests. But since POPUPs can also be referred to as
KILLPOPUPs, it is clear that it should come first.

-------------------------------------------------------------------------------

5.7.10. "Uncertain" new code and/or changes to exitinst code, use FIXME

Explanation:

If you have enough confidence in new code or confidence in your changes, but
are not *quite* sure of the reprocussions, add this:

/* FIXME: this code has a logic error on platform XYZ, * attempthing to fix */
#ifdef PLATFORM ...changed code here... #endif

or:

/* FIXME: I think the original author really meant this... */ ...changed code
here...

or:

/* FIXME: new code that *may* break something else... */ ...new code here...

Note: If you make it clear that this may or may not be a "good thing (tm)", it
will be easier to identify and include in the project (or conversly exclude
from the project).

-------------------------------------------------------------------------------

5.8. Addendum: Template for files and function comment blocks:

Example for file comments:

const char FILENAME_rcs[] = "$Id: developer-manual.sgml,v 1.27 2002/04/08 15:31:18 hal9 Exp $"; 
/*********************************************************************                          
 *                                                                                              
 * File        :  $Source$                                                                      
 *                                                                                              
 * Purpose     :  (Fill me in with a good description!)                                         
 *                                                                                              
 * Copyright   :  Written by and Copyright (C) 2001 the SourceForge                             
 *                Privoxy team. http://www.privoxy.org/                                         
 *                                                                                              
 *                Based on the Internet Junkbuster originally written                           
 *                by and Copyright (C) 1997 Anonymous Coders and                                
 *                Junkbusters Corporation.  http://www.junkbusters.com                          
 *                                                                                              
 *                This program is free software; you can redistribute it                        
 *                and/or modify it under the terms of the GNU General                           
 *                Public License as published by the Free Software                              
 *                Foundation; either version 2 of the License, or (at                           
 *                your option) any later version.                                               
 *                                                                                              
 *                This program is distributed in the hope that it will                          
 *                be useful, but WITHOUT ANY WARRANTY; without even the                         
 *                implied warranty of MERCHANTABILITY or FITNESS FOR A                          
 *                PARTICULAR PURPOSE.  See the GNU General Public                               
 *                License for more details.                                                     
 *                                                                                              
 *                The GNU General Public License should be included with                        
 *                this file.  If not, you can view it at                                        
 *                http://www.gnu.org/copyleft/gpl.html                                          
 *                or write to the Free Software Foundation, Inc., 59                            
 *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.                        
 *                                                                                              
 * Revisions   :                                                                                
 *    $Log$                                                                                     
 *                                                                                              
 *********************************************************************/                         
                                                                                                
                                                                                                
#include "config.h"                                                                             
                                                                                                
   ...necessary include files for us to do our work...                                          
                                                                                                
const char FILENAME_h_rcs[] = FILENAME_H_VERSION;                                               

Note: This declares the rcs variables that should be added to the
"show-proxy-args" page. If this is a brand new creation by you, you are free to
change the "Copyright" section to represent the rights you wish to maintain.

Note: The formfeed character that is present right after the comment flower box
is handy for (X|GNU)Emacs users to skip the verbige and get to the heart of the
code (via `forward-page' and `backward-page'). Please include it if you can.

Example for file header comments:

#ifndef _FILENAME_H                                                                           
#define _FILENAME_H                                                                           
#define FILENAME_H_VERSION "$Id: developer-manual.sgml,v 1.27 2002/04/08 15:31:18 hal9 Exp $" 
/*********************************************************************                        
 *                                                                                            
 * File        :  $Source$                                                                    
 *                                                                                            
 * Purpose     :  (Fill me in with a good description!)                                       
 *                                                                                            
 * Copyright   :  Written by and Copyright (C) 2001 the SourceForge                           
 *                Privoxy team. http://www.privoxy.org/                                       
 *                                                                                            
 *                Based on the Internet Junkbuster originally written                         
 *                by and Copyright (C) 1997 Anonymous Coders and                              
 *                Junkbusters Corporation.  http://www.junkbusters.com                        
 *                                                                                            
 *                This program is free software; you can redistribute it                      
 *                and/or modify it under the terms of the GNU General                         
 *                Public License as published by the Free Software                            
 *                Foundation; either version 2 of the License, or (at                         
 *                your option) any later version.                                             
 *                                                                                            
 *                This program is distributed in the hope that it will                        
 *                be useful, but WITHOUT ANY WARRANTY; without even the                       
 *                implied warranty of MERCHANTABILITY or FITNESS FOR A                        
 *                PARTICULAR PURPOSE.  See the GNU General Public                             
 *                License for more details.                                                   
 *                                                                                            
 *                The GNU General Public License should be included with                      
 *                this file.  If not, you can view it at                                      
 *                http://www.gnu.org/copyleft/gpl.html                                        
 *                or write to the Free Software Foundation, Inc., 59                          
 *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.                      
 *                                                                                            
 * Revisions   :                                                                              
 *    $Log$                                                                                   
 *                                                                                            
 *********************************************************************/                       
                                                                                              
                                                                                              
#include "project.h"                                                                          
                                                                                              
#ifdef __cplusplus                                                                            
extern "C" {                                                                                  
#endif                                                                                        
                                                                                              
   ... function headers here ...                                                              
                                                                                              
                                                                                              
/* Revision control strings from this header and associated .c file */                        
extern const char FILENAME_rcs[];                                                             
extern const char FILENAME_h_rcs[];                                                           
                                                                                              
                                                                                              
#ifdef __cplusplus                                                                            
} /* extern "C" */                                                                            
#endif                                                                                        
                                                                                              
#endif /* ndef _FILENAME_H */                                                                 
                                                                                              
/*                                                                                            
  Local Variables:                                                                            
  tab-width: 3                                                                                
  end:                                                                                        
*/                                                                                            

Example for function comments:

/*********************************************************************         
 *                                                                             
 * Function    :  FUNCTION_NAME                                                
 *                                                                             
 * Description :  (Fill me in with a good description!)                        
 *                                                                             
 * parameters  :                                                               
 *          1  :  param1 = pointer to an important thing                       
 *          2  :  x      = pointer to something else                           
 *                                                                             
 * Returns     :  0 => Ok, everything else is an error.                        
 *                                                                             
 *********************************************************************/        
int FUNCTION_NAME( void *param1, const char *x )                               
{                                                                              
   ...                                                                         
   return( 0 );                                                                
                                                                               
}                                                                              

Note: If we all follow this practice, we should be able to parse our code to
create a "self-documenting" web page.

-------------------------------------------------------------------------------

6. Version Control Guidelines

To be filled. note on cvs comments. Don't only comment what you did, but also
why you did it!

-------------------------------------------------------------------------------

7. Testing Guidelines

To be filled.

-------------------------------------------------------------------------------

7.1. Testplan for releases

Explain release numbers. major, minor. developer releases. etc.

 1. Remove any existing rpm with rpm -e
   
 2. Remove any file that was left over. This includes (but is not limited to)
   
      + /var/log/privoxy
       
      + /etc/privoxy
       
      + /usr/sbin/privoxy
       
      + /etc/init.d/privoxy
       
      + /usr/doc/privoxy*
       
 3. Install the rpm. Any error messages?
   
 4. start,stop,status Privoxy with the specific script (e.g. /etc/rc.d/init/
    privoxy stop). Reboot your machine. Does autostart work?
   
 5. Start browsing. Does Privoxy work? Logfile written?
   
 6. Remove the rpm. Any error messages? All files removed?
   
-------------------------------------------------------------------------------

7.2. Test reports

Please submit test reports only with the test form at sourceforge. Three simple
steps:

  * Select category: the distribution you test on.
   
  * Select group: the version of Privoxy that we are about to release.
   
  * Fill the Summary and Detailed Description with something intelligent (keep
    it short and precise).
   
Do not mail to the mailinglist (we cannot keep track on issues there).

-------------------------------------------------------------------------------

8. Releasing a new version

To minimize trouble with distribution contents, webpage errors and the like, we
strongly encourage you to follow this section if you prepare a new release of
code or new pages on the webserver.

The following programs are required to follow this process: ncftpput (ncftp),
scp (ssh), gmake (GNU's version of make), autoconf, cvs, ???.

-------------------------------------------------------------------------------

8.1. Before the Release

The following must be done by one of the developers prior to each new release:

  * Make sure that everybody who has worked on the code in the last couple of
    days has had a chance to yell "no!" in case they have pending changes/fixes
    in their pipelines.
   
  * Increment the version number in configure.in in CVS. Also, the RPM release
    number in configure.in. Do NOT touch version information after export from
    CVS. All packages will use the version and release data from configure.in.
    Local files should not be changed, except prior to a CVS commit!!! This way
    we are all on the same page!
   
  * If the default actionsfile has changed since last release, bump up its
    version info in this line:
   
      {+add-header{X-Actions-File-Version: A.B} -filter -no-popups}    
                                                                       
   
    Then change the version info in doc/webserver/actions/index.php, line:
    '$required_actions_file_version = "A.B";'
   
  * Tag all files in CVS with the version number with "cvs tag v_X_Y_Z" (where
    X = major, Y = minor, Z = point). Don't use vX_Y_Z, ver_X_Y_Z, v_X.Y.Z
    (won't work) etc.
   
  * The first package uploaded should be the official "tarball" release. This
    is built with the "make tarball-dist" Makefile target, and then can be
    uploaded with "make tarball-upload" (see below).
   
-------------------------------------------------------------------------------

8.2. Update the webserver

All files must be group-readable and group-writable (or no one else will be
able to change them). To update the webserver, create any pages locally in the
doc/webserver directory (or create new directories under doc/webserver), then
do

  make webserver                                                               
                                                                               

Note that "make dok" (or "make redhat-dok") creates doc/webserver/user-manual,
doc/webserver/developer-manual, doc/webserver/faq and doc/webserver/man-page
automatically.

Please do NOT use any other means of transferring files to the webserver. "make
webserver" not only uploads, but will make sure that the appropriate
permissions are preserved for shared group access.

-------------------------------------------------------------------------------

8.3. SuSE or Red Hat

Ensure that you have the latest code version. Hence run:

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

first.

  autoheader && autoconf && ./configure                                        
                                                                               

Then do

  make suse-dist or make redhat-dist                                           
                                                                               

To upload the package to Sourceforge, simply issue

  make suse-upload or make redhat-upload                                       
                                                                               

Go to the displayed URL and release the file publicly on Sourceforge.

-------------------------------------------------------------------------------

8.4. OS/2

Ensure that you have the latest code version. Hence run:

  cd current                                                                                         
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                          
  cvs -z3 -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
  cd ..                                                                                              
  cvs -z3 -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa co os2setup                
                                                                                                     

You will need a mix of development tools. The main compilation takes place with
IBM Visual Age C++. Some ancillary work takes place with GNU tools, available
from various sources like hobbes.nmsu.edu. Specificially, you will need
autoheader, autoconf and sh tools. The packaging takes place with WarpIN,
available from various sources, including its home page: xworkplace.

Change directory to the os2setup directory. Edit the os2build.cmd file to set
the final executable filename. For example,

  installExeName='privoxyos2_setup_X.Y.Z.exe'                                  
                                                                               

Next, edit the IJB.wis file so the release number matches in the PACKAGEID
section:

  PACKAGEID="Privoxy Team\Privoxy\Privoxy Package\X\Y\Z"                       
                                                                               

You're now ready to build. Run:

  os2build                                                                     
                                                                               

And in the ./files directory you will have the WarpIN-installable executable.
Upload this anonymously to uploads.sourceforge.net/incoming, create a release
for it, and you're done.

-------------------------------------------------------------------------------

8.5. Solaris

Login to Sourceforge's compilefarm via ssh

  ssh cf.sourceforge.net                                                       
                                                                               

Choose the right operating system (not the Debian one). If you have downloaded
Privoxy before,

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

If not, please checkout Privoxy via CVS first. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then run

  gmake solaris-dist                                                           
                                                                               

which creates a gzip'ed tar archive. Sadly, you cannot use make solaris-upload
on the Sourceforge machine (no ncftpput). You now have to manually upload the
archive to Sourceforge's ftp server and release the file publicly.

-------------------------------------------------------------------------------

8.6. Windows

Ensure that you have the latest code version. Hence run

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then do FIXME.

-------------------------------------------------------------------------------

8.7. Debian

Ensure that you have the latest code version. Hence run:

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

first. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then do FIXME.

-------------------------------------------------------------------------------

8.8. Mac OSX

Ensure that you have the latest code version. Hence run:

  cd current                                                                                         
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                          
  cvs -z3 -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
  cd ..                                                                                              
  cvs -z3 -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa co osxsetup                
                                                                                                     

From the osxsetup directory, run:

  build                                                                        
                                                                               

This will run autoheader, autoconf and configure as well as make. Finally, it
will copy over the necessary files to the ./osxsetup/files directory for
further processing by PackageMaker.

Bring up PackageMaker with the PrivoxyPackage.pmsp definition file, modify the
package name to match the release, and hit the "Create package" button. If you
specify ./Privoxy.pkg as the output package name, you can then create the
distributable zip file with the command:

zip -r privoxyosx_setup_x.y.z.zip Privoxy.pkg                                  
                                                                               

You can then upload privoxyosx_setup_x.y.z.zip anonymously to
uploads.sourceforge.net/incoming, create a release for it, and you're done.

-------------------------------------------------------------------------------

8.9. FreeBSD

Change the version number of Privoxy in the configure.in file. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then ...

Login to Sourceforge's compilefarm via ssh:

  ssh cf.sourceforge.net                                                       
                                                                               

Choose the right operating system. If you have downloaded Privoxy before,

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

If not, please checkout Privoxy via CVS first. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then run:

  gmake freebsd-dist                                                           
                                                                               

which creates a gzip'ed tar archive. Sadly, you cannot use make freebsd-upload
on the Sourceforge machine (no ncftpput). You now have to manually upload the
archive to Sourceforge's ftp server and release the file publicly.

-------------------------------------------------------------------------------

8.10. Tarball

Ensure that you have the latest code version. Hence run:

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

first. Run:

  make clobber                                                                 
  autoheader && autoconf && ./configure                                        
                                                                               

Then do:

  make tarball-dist                                                            
                                                                               

To upload the package to Sourceforge, simply issue

  make tarball-upload                                                          
                                                                               

Goto the displayed URL and release the file publicly on Sourceforge.

-------------------------------------------------------------------------------

8.11. HP-UX 11

Ensure that you have the latest code version. Hence run:

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

first. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then do FIXME.

-------------------------------------------------------------------------------

8.12. Amiga OS

Ensure that you have the latest code version. Hence run:

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

first. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then do FIXME.

-------------------------------------------------------------------------------

8.13. AIX

Login to Sourceforge's compilefarm via ssh:

  ssh cf.sourceforge.net                                                       
                                                                               

Choose the right operating system. If you have downloaded Privoxy before:

  cd current                                                                                          
  cvs -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa login                           
  cvs -z3  -d:pserver:anonymous@cvs.ijbswa.sourceforge.net:/cvsroot/ijbswa export -r  v_X_Y_Z current 
                                                                                                      

If not, please checkout Privoxy via CVS first. Run:

  autoheader && autoconf && ./configure                                        
                                                                               

Then run:

  make aix-dist                                                                
                                                                               

which creates a gzip'ed tar archive. Sadly, you cannot use make aix-upload on
the Sourceforge machine (no ncftpput). You now have to manually upload the
archive to Sourceforge's ftp server and release the file publicly.

-------------------------------------------------------------------------------

9. Contacting the developers, Bug Reporting and Feature Requests

We value your feedback. However, to provide you with the best support, please
note:

  *  Use the Sourceforge Support Forum to get help:
       
     http://sourceforge.net/tracker/?group_id=11118&atid=211118
       
   
  *  Submit bugs only through our Sourceforge Bug Forum:
     
     http://sourceforge.net/tracker/?group_id=11118&atid=111118. 
        
   
    Make sure that the bug has not already been submitted. Please try to verify
    that it is a Privoxy bug, and not a browser or site bug first. If you are
    using your own custom configuration, please try the stock configs to see if
    the problem is a configuration related bug. And if not using the latest
    development snapshot, please try the latest one. Or even better, CVS
    sources. Please be sure to include the Privoxy/Junkbuster version,
    platform, browser, any pertinent log data, any other relevant details
    (please be specific) and, if possible, some way to reproduce the bug.
   
  *  Submit feature requests only through our Sourceforge feature request 
     forum:
     
     http://sourceforge.net/tracker/?atid=361118&group_id=11118&func=browse.
       
   
  * We will soon have an automated way to submit advertisements, incorrectly
    blocked images, popups and the like. Check back.
       
   
  *  For any other issues, feel free to use the mailing lists:
     
     http://sourceforge.net/mail/?group_id=11118.
     
   
    Anyone interested in actively participating in development and related
    discussions can also join the appropriate mailing list. Archives are
    available too.
   
-------------------------------------------------------------------------------

10. Copyright and History

10.1. Copyright

Privoxy is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details, which
is available from the Free Software Foundation, Inc, 59 Temple Place - Suite
330, Boston, MA 02111-1307, USA.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA.

-------------------------------------------------------------------------------

10.2. History

Privoxy is evolved, and derived from, the Internet Junkbuster, with many
improvments and enhancements over the original.

Junkbuster was originally written by Anonymous Coders and Junkbuster's
Corporation, and was released as free open-source software under the GNU GPL. 
Stefan Waldherr made many improvements, and started the SourceForge project
Privoxy to rekindle development. There are now several active developers
contributing. The last stable release of Junkbuster was v2.0.2, which has now
grown whiskers ;-).

-------------------------------------------------------------------------------

11. See also

Other references and sites of interest to Privoxy users:

http://www.privoxy.org/, The Privoxy Home page.

http://sourceforge.net/projects/ijbswa, the Project Page for Privoxy on        
Sourceforge.                                                                   

http://p.p/, access Privoxy from your browser. Alternately, http://            
config.privoxy.org may work in some situations where the first does not.       

http://www.junkbusters.com/ht/en/cookies.html

http://www.waldherr.org/junkbuster/

http://privacy.net/analyze/

http://www.squid-cache.org/