Information for Netatalk Developers
===================================

For basic installation instructions, see the Installation chapter
in the manual.

Netatalk is an implementation of AFP, with built in support for
AFP over TCP (also known as AppleShare IP, or ASIP for short.)
Netatalk also supports the AppleTalk Protocol Suite for legacy Macs
and Apple IIs via the "atalkd" daemon.
The current release contains support for EtherTalk Phase I and II, 
DDP, RTMP, NBP, ZIP, AEP, ATP, PAP, ASP, AFP and DSI.
The complete stack looks like this on a BSD-derived system:

    AFP                          AFP
     |                            |
    ASP    PAP                   DSI
      \   /                       |
       ATP RTMP NBP ZIP AEP       |
        |    |   |   |   |        |
   -+---------------------------------------------------+- (kernel boundary)
    |                    Socket                         |
    +-----------------------+------------+--------------+
    |                       |     TCP    |    UDP       |
    |          DDP          +------------+--------------+
    |                       |           IP              |
    +-----------------------+---------------------------+
    |                Network-Interface                  |
    +---------------------------------------------------+

* DSI is a session layer used to carry AFP over TCP.
* DDP is in the kernel, presently.
* "atalkd" implements RTMP, NBP, ZIP, and AEP.  It
  is the AppleTalk equivalent of Unix "routed".  There is also a
  client-stub library for NBP that exists as a client-stub library.
* ATP and ASP are implemented as libraries.
* "papd" allows Macs to spool to "lpd", and "pap" allows Unix
  machines to print to AppleTalk connected printers.
* "psf" is a PostScript printer filter for "lpd", designed to use "pap".
* "psorder" is a PostScript reverser, called by "psf" to reverse pages
  printed to face-up stacking printers.
* "afpd" provides Macs with an interface to the Unix file system.
  Refer to the appropriate man pages for operational information.


Compilation
===========
   The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation.  It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions.  Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, a file
`config.cache' that saves the results of its tests to speed up
reconfiguring, and a file `config.log' containing compiler output
(useful mainly for debugging `configure').

   If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release.  If at some point `config.cache'
contains results you don't want to keep, you may remove or edit it.

   The file `bootstrap' is used to create `configure' by a program
called `autoconf'.  You only need `bootstrap' if you want to change
it or regenerate `configure' using a newer version of `autoconf'.


Tools for Developers
====================
1. Libtool
Libtool encapsulates the platform specific dependencies for the
creation of libraries. It determines if the local platform can support
shared libraries or if it only supports static libraries.

Netatalk currently requires libtool 1.4 or higher (1.4b for OpenBSD).

Documentation: http://www.gnu.org/software/libtool/

2. GNU m4
GNU m4 is an implementation of the Unix macro processor. It reads
stdin and copies to stdout expanding defined macros as it processes
the text.

Documentation: http://www.gnu.org/software/m4/

3. Autoconf
Autoconf is a package of m4 macros that produce shell scripts to
configure source code packages.

Documentation: http://www.gnu.org/software/autoconf/

4. Automake
Automake is a tool that generates  'Makefile.in' files.

Documentation: http://www.gnu.org/software/automake/

Optional
========
5. OpenSSL and/or Libgcrypt
The OpenSSL Project is a collaborative effort to develop a robust,
commercial-grade, full-featured, and Open Source toolkit implementing
the Secure Sockets Layer (SSL v2/v3) and Transport Layer Security (TLS
v1) protocols as well as a full-strength general purpose cryptography
library.
This is required to enable DHX login support.
Note that OpenSSL 3.0 or later are no longer compatible with DHX.

Get everything at http://www.openssl.org/ 

The Libgcrypt is a general purpose cryptographic library based on
the code from GnuPG.
This is required to enable DHX2 login support.

Get everything at https://gnupg.org/software/libgcrypt/

6. TCP Wrappers
Wietse Venema's network logger, also known as TCPD or LOG_TCP. These
programs log the client host name of incoming telnet, ftp, rsh,
rlogin, finger etc. requests. Security options are: access control per
host, domain and/or service; detection of host name spoofing or host
address spoofing; booby traps to implement an early-warning system.
Netatalk uses TCP Wrappers to authorize host access when using
afpovertcp. It should be noted that if DDP is in use, the connection
will still be allowed as TCP Wrappers do not impact DDP connections.

7. PAM (Pluggable Authentication Modules) 
PAM provides a flexible mechanism for authenticating
users. PAM was invented by SUN Microsystems.

Author: Andrew Morgan <morgan@linux.kernel.org>

Linux-PAM is a suite of shared libraries that enable the local system
administrator to choose how applications authenticate users.
You can get the Linux PAM documentation and sources from
http://www.kernel.org/pub/linux/libs/pam/
Netatalk also supports other standard PAM implementations such as OpenPAM.

8. Berkeley DB
Berkeley DB is a programmatic toolkit that provides fast, reliable,
scalable, and mission-critical database support to software
developers.
Netatalk's CNID database uses the library and header files from BDB.
Currently, Netatalk supports BDB 4.6 and later; 5.3 is recommended.

Error checking and logging
==========================
We want rigid error checking and concise log messages. This often leads
to significant code bloat where the relevant function call is buried in error
checking and logging statements.
In order to alleviate error checking and code readability, we provide a set
of error checking macros in <atalk/errchk.h>. These macros compare the return
value of statements againt 0, NULL, -1 (and maybe more, check it out).
Every macro comes in four flavours: EC_CHECK, EC_CHECK_LOG, EC_CHECK_LOG_ERR
and EC_CHECK_CUSTOM:
- EC_CHECK just checks the CHECK
- EC_CHECK_LOG additionally logs the stringified function call.
- EC_CHECK_LOG_ERR allows specifying the return value
- EC_CHECK_CUSTOM allows custom actions
The macros EC_CHECK* unconditionally jump to a cleanup label where the
neccessary cleanup can be done alongside controlling the return value.
EC_CHECK_CUSTOM doesn't do that, so an extra "goto EC_CLEANUP" may be
performed as appropriate.

Example:
- stat() without EC macro:
  static int func(const char *name) {
    int ret = 0;
    ...
    if ((ret = stat(name, &some_struct_stat)) != 0) {
      LOG(...);
      ret = -1; /* often needed to explicitly set the error indicating return value */
      goto cleanup;
    }

    return ret;

  cleanup:
    ...
    return ret;
  }

- stat() with EC macro:
  static int func(const char *name) {
    EC_INIT; /* expands to int ret = 0; */

    char *uppername = NULL
    EC_NULL(uppername = strdup(name));
    EC_ZERO(strtoupper(uppername));

    EC_ZERO(stat(uppername, &some_struct_stat)); /* expands to complete if block from above */

    EC_STATUS(0);

EC_CLEANUP:
    if (uppername) free(uppername);
    EC_EXIT;
  }

A boileplate function template is:

int func(void)
{
    EC_INIT;

    ...your code here...

    EC_STATUS(0);

EC_CLEANUP:
    EC_EXIT;
}
