Dev Docs Network Protocols

Network Protocol Stack

Audited against Netatalk d63155e13 on 2026-10-10. This describes the current source checkout; older releases may differ.

Netatalk supports two network protocol stacks for AFP (Apple Filing Protocol) file sharing. The primary stack, DSI (Data Stream Interface), carries AFP over TCP/IP and is used by all modern clients. The legacy stack, ASP (AppleTalk Session Protocol), carries AFP over DDP and serves vintage Macintosh systems that predate TCP/IP networking.

This page documents both stacks—from wire format and session management through AFP command dispatch—based on the actual implementation in the Netatalk source tree.

Protocol Stack Overview

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '14px', 'primaryColor': '#4a90d9', 'primaryTextColor': '#fff', 'lineColor': '#5c6370', 'secondaryColor': '#7c4dff', 'tertiaryColor': '#e8f5e9'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 30}}}%%
graph TB
    subgraph "AFP over TCP/IP — Modern"
        A["AFP Commands<br/><i>include/atalk/afp.h</i>"]
        B["DSI Session Layer<br/><i>libatalk/dsi/</i>"]
        C["TCP/IP Transport<br/>Port 548"]
    end
    subgraph "AFP over AppleTalk — Legacy"
        D["AFP Commands<br/><i>include/atalk/afp.h</i>"]
        E["ASP Session Layer<br/><i>libatalk/asp/</i>"]
        F["ATP Transaction Layer<br/><i>libatalk/atp/</i>"]
        G["DDP Network Layer<br/><i>host kernel</i>"]
    end
    A --> B --> C
    D --> E --> F --> G
    style A fill:#4a90d9,color:#fff
    style B fill:#7c4dff,color:#fff
    style C fill:#43a047,color:#fff
    style D fill:#4a90d9,color:#fff
    style E fill:#7c4dff,color:#fff
    style F fill:#e65100,color:#fff
    style G fill:#c62828,color:#fff

The protocol identifier constants are defined in include/atalk/afp.h:

#define AFPPROTO_ASP           1
#define AFPPROTO_DSI           2

DSI Protocol (AFP over TCP)

DSI is the session layer that frames AFP commands for transport over TCP/IP. It handles connection establishment, request/response message boundaries, keep-alive tickles, server attention notifications, and flow control through quantum negotiation. The DSI implementation lives in libatalk/dsi/ and is built independently of optional AppleTalk support.

Source Files

Wire Format — struct dsi_block

Every DSI message starts with a 16-byte header defined in include/atalk/dsi.h:

#define DSI_BLOCKSIZ 16
struct dsi_block {
    uint8_t dsi_flags;       /* packet type: request or reply */
    uint8_t dsi_command;     /* command */
    uint16_t dsi_requestID;  /* request ID */
    union {
        uint32_t dsi_code;   /* error code */
        uint32_t dsi_doff;   /* data offset */
    } dsi_data;
    uint32_t dsi_len;        /* total data length */
    uint32_t dsi_reserved;   /* reserved field */
};

Reply headers are packed by dsi_header_pack_reply() and decoded by dsi_stream_receive(), both in libatalk/dsi/dsi_stream.c. Multi-byte fields are encoded in network byte order on the wire. Some fields are converted for host-order calculations during parsing; do not infer every in-memory value’s byte order solely from the original header comment:

CONVENTION: anything with a dsi_ prefix is kept in network byte order.

Byte:  0     1     2-3          4-7                  8-11            12-15
     +-----+-----+------------+--------------------+-----------------+---------+
     |Flags| Cmd | Request ID | Code / Data Offset | Total Data Len | Reserved|
     +-----+-----+------------+--------------------+-----------------+---------+

DSI Flags

Defined in include/atalk/dsi.h:

DSI Commands

Defined in include/atalk/dsi.h:

Value 7 is deliberately skipped (it was ASPFUNC_WRTCONT in the AppleTalk equivalent). DSIFUNC_MAX is defined as 8 for bounds checking during connection setup.

DSI Error Codes

Defined in include/atalk/dsi.h:

DSI Session Options

Negotiated during DSIFUNC_OPEN in dsi_opensession() (dsi_opensess.c). Defined in include/atalk/dsi.h:

Quantum Constants from include/atalk/dsi.h:

DSI Session Structure

The main session handle, defined in include/atalk/dsi.h:

#define DSI_DATASIZ       65536

typedef struct DSI {
    struct DSI *next;             /* multiple listening addresses */
    AFPObj   *AFPobj;
    int      statuslen;
    char     status[1400];        /* server status block */
    const void *signature;
    struct dsi_block        header;
    struct sockaddr_storage server, client;
    struct itimerval        timer;
    int      tickle;              /* tickle count */
    int      in_write;            /* signal blocking during writes */
    int      msg_request;         /* pending message to client */
    int      down_request;        /* pending SIGUSR1 shutdown */

    uint32_t attn_quantum, datasize, server_quantum;
    uint16_t serverID, clientID;
    uint8_t  *commands;           /* DSI receive buffer (server_quantum bytes) */
    uint8_t  data[DSI_DATASIZ];   /* DSI reply buffer (64 KB) */
    size_t   datalen, cmdlen;
    off_t    read_count, write_count;
    uint32_t flags;               /* DSI state flags */
    int      socket;              /* AFP session socket */
    int      serversock;          /* listening socket */
    int      splice_pipe[2];      /* recvfile pipe, created lazily */
    int      splice_size;         /* capacity actually granted by kernel */

    /* readahead buffer for dsi_peek */
    size_t   dsireadbuf;          /* allocation multiplier copied from configuration */
    char     *buffer;             /* buffer start */
    char     *start;              /* current read head */
    char     *eof;                /* end of buffered data */
    char     *end;                /* buffer end */

    /* protocol-specific function pointers */
    pid_t (*proto_open)(struct DSI *);
    void (*proto_close)(struct DSI *);
} DSI;

The commands buffer is allocated in dsi_init_buffer() (dsi_tcp.c) to server_quantum bytes. The readahead buffer is dsireadbuf * server_quantum bytes.

DSI State Flags

Defined in include/atalk/dsi.h. These are bitmask values set on dsi->flags:

The flags are tracked and logged in main-loop handle_alarm() (afp_dsi.c).

DSI Session State Machine

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '14px', 'primaryColor': '#4a90d9', 'primaryTextColor': '#fff', 'lineColor': '#5c6370', 'secondaryColor': '#7c4dff', 'tertiaryColor': '#e8f5e9'}, 'flowchart': {'nodeSpacing': 25, 'rankSpacing': 25}}}%%
stateDiagram-v2
    [*] --> TCPListen: dsi_tcp_init()
    TCPListen --> ChildForked: accept() + fork()\nin dsi_tcp_open()
    ChildForked --> OpenSession: DSIFUNC_OPEN\n→ dsi_opensession()
    ChildForked --> StatusReply: DSIFUNC_STAT\n→ dsi_getstatus() → exit
    OpenSession --> Running: DSI_RUNNING set\nper command
    Running --> Running: DSIFUNC_CMD\nDSIFUNC_WRITE
    Running --> Sleeping: FPZzz\n→ DSI_SLEEPING
    Running --> ExtSleep: Extended\n→ DSI_EXTSLEEP
    Running --> Dying: SIGUSR1\n→ DSI_DIE
    Running --> Disconnected: socket error\n→ dsi_disconnect()
    Running --> LoggedOut: FPLogout\n→ DSI_AFP_LOGGED_OUT
    Running --> Reconnecting: SIGURG\n→ DSI_RECONSOCKET
    Sleeping --> Running: client data\n→ clear DSI_SLEEPING
    Sleeping --> Disconnected: tickle timeout
    ExtSleep --> Running: wakeup
    Disconnected --> Running: primary reconnect\nsucceeds
    Disconnected --> [*]: reconnect timer\nexpires → exit
    Dying --> [*]: SIGALRM after 5 min\n→ afp_dsi_die()
    LoggedOut --> [*]: next EOF → exit
    Reconnecting --> Running: DSI_RECONSOCKET\nhandled
    Running --> [*]: DSIFUNC_CLOSE\n→ dsi_close()

Tickle Mechanism

The keep-alive system uses SIGALRM with a periodic interval timer. The signal handler records the timer request and wakes the self-pipe. Main-loop handle_alarm() in etc/afpd/afp_dsi.c runs through this decision chain:

1. If DSI_DATA is set, the client recently sent traffic. Clear the flag and return—no tickle needed.
2. Increment the dsi->tickle counter (counts consecutive idle intervals).
3. If DSI_SLEEPING: compare tickle against options.sleep. Terminate the session if the sleep limit is exceeded.
4. If DSI_DISCONNECTED: compare tickle against options.disconnected. Terminate if the reconnect window has expired.
5. If tickle >= options.timeout: the client has gone silent too long. Enter the disconnected state via dsi_disconnect() in dsi_stream.c.
6. Otherwise: send a keep-alive tickle via dsi_tickle() in dsi_tickle.c.

dsi_tickle() constructs a bare 16-byte DSI header (flags=DSIFL_REQUEST, command=DSIFUNC_TICKLE, no data payload) and writes it with DSI_NOWAIT so it does not block. The function is a no-op when DSI_SLEEPING is set or dsi->in_write is non-zero, preventing corruption of an in-progress multi-packet transfer.

Stream Operations

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '14px', 'primaryColor': '#4a90d9', 'primaryTextColor': '#fff', 'lineColor': '#5c6370', 'secondaryColor': '#7c4dff', 'tertiaryColor': '#e8f5e9'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 30}}}%%
graph TB
    subgraph "Receive Path"
        A["dsi_stream_receive()"] --> B["dsi_buffered_stream_read()<br/>Read 16-byte header"]
        B --> C["from_buf()<br/>Check readahead buffer"]
        C --> D{Data in buffer?}
        D -->|Yes| E["Return buffered bytes"]
        D -->|No| F["recv() from socket"]
        B --> G["dsi_stream_read()<br/>Read command payload"]
        G --> H["buf_read() loop"]
    end
    subgraph "Send Path"
        I["dsi_stream_send()"] --> J["dsi_header_pack_reply()<br/>Pack 16-byte header"]
        J --> K["writev()<br/>Header + data in one syscall"]
        K --> L{EAGAIN?}
        L -->|Yes| M["dsi_peek()<br/>Read to unblock client"]
        M --> K
        L -->|No| N["Write complete"]
    end
    style A fill:#4a90d9,color:#fff
    style I fill:#43a047,color:#fff
    style C fill:#7c4dff,color:#fff
    style M fill:#e65100,color:#fff
    style E fill:#81c784,color:#000
    style N fill:#81c784,color:#000
    style F fill:#ffb74d,color:#000
    style H fill:#ffb74d,color:#000

Receive path — dsi_stream_receive() in libatalk/dsi/dsi_stream.c reads/decodes a 16-byte header and validates frame bounds. DSIWrite permits AFP request blocks of 12 bytes (FPWrite) or 20 bytes (FPWriteExt), checks offset against payload length, and bounds write data independently by the negotiated quantum. Oversized ordinary requests and command frames without an AFP function byte are rejected; lengths are not silently truncated. Write data is consumed by the AFP write handler after its request block is read.

Send path — dsi_stream_send() serializes the 16-byte header into a stack buffer, then uses writev() to transmit the header and reply data as a single scatter/gather I/O operation, avoiding an extra copy. During the write, block_sig() increments dsi->in_write to prevent dsi_tickle() and dsi_attention() from interleaving packets on the socket.

Deadlock avoidance — When send() returns EAGAIN (socket buffer full), dsi_peek() uses select() to simultaneously monitor the socket for write-readiness and read-readiness. If the client has pending data (e.g., a tickle), dsi_peek() reads it into the readahead buffer. This breaks a potential deadlock where both client and server have full send buffers and neither can make progress.

Readahead Buffer

Allocated in dsi_init_buffer() in libatalk/dsi/dsi_tcp.c:

dsi->commands = malloc(dsi->server_quantum);
dsi->buffer = malloc(dsi->dsireadbuf * dsi->server_quantum);
dsi->start = dsi->buffer;
dsi->eof = dsi->buffer;
dsi->end = dsi->buffer + (dsi->dsireadbuf * dsi->server_quantum);

With the configured default quantum of 1 MiB and dsireadbuf of 32, the baseline is 32 MiB of incoming readahead. Session quantum alignment can change the allocation. The buffer-product limit is 1 GiB, and the multiplier is re-clamped after alignment. dsi_peek() logs a warning when the buffer is full:

dsi_peek: readahead buffer is full, possibly increase -dsireadbuf option

Streaming Data Transfer (Read/Write)

Server→Client reads (AFP FPRead):

1. dsi_readinit() — sets DSI_NOREPLY, sends DSI header + initial buffer via dsi_stream_send()
2. dsi_read() — sends subsequent chunks via dsi_stream_write(), decrements dsi->datasize
3. dsi_readdone() — decrements in_write counter
4. With sendfile: dsi_stream_read_file() — zero-copy from file descriptor, platform-specific (sendfile/sendfilev)

All in libatalk/dsi/dsi_read.c and libatalk/dsi/dsi_stream.c.

Client→Server writes (AFP FPWrite):

1. dsi_writeinit() — calculates datasize from dsi_len - dsi_doff, drains readahead buffer first
2. dsi_write() — reads chunks from socket via dsi_stream_read(), decrements datasize
3. dsi_writeflush() — discards any unread remaining data

All in libatalk/dsi/dsi_write.c.

Replay Cache

Defined in etc/afpd/afp_dsi.c:

typedef struct {
    uint16_t DSIreqID;
    uint8_t  AFPcommand;
    uint32_t result;
} rc_elem_t;

static rc_elem_t replaycache[REPLAYCACHE_SIZE];

REPLAYCACHE_SIZE is 128 (from include/atalk/afp.h). Indexed by dsi->clientID % REPLAYCACHE_SIZE. In the DSIWrite path, when a request ID and command match a cache entry, the cached result is returned without re-executing the write. It is not a full-reply replay cache for all AFP commands. The cache size is communicated to the client as DSIOPT_REPLCSIZE during dsi_opensession().

AFP Protocol Layer

AFP defines the application-level file sharing commands that are transported over DSI (or ASP for legacy AppleTalk). In every DSI request, the first byte of dsi->commands identifies the AFP command to execute.

Source Files

AFP Command Dispatch

The AFPCmd type is defined in include/atalk/globals.h:

typedef int (*AFPCmd)(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen);

Two 256-entry dispatch tables in etc/afpd/switch.c:

• preauth_switch[] — only afp_login (18), afp_logincont (19), afp_logout (20), and afp_login_ext (63) are non-NULL
• postauth_switch[] — full set of AFP commands after authentication

The global pointer afp_switch initially references preauth_switch, restricting unauthenticated clients to login commands only. After successful authentication, it is redirected to postauth_switch to unlock the full command set. UAM modules can also modify individual dispatch entries through uam_afpserver_action().

AFP Command Codes

All defined in include/atalk/afp.h. Key commands by category:

Session & Authentication:

Volume Operations:

File/Directory Operations:

Fork (Read/Write) Operations:

AFP 3.0 Extensions:

AFP 3.1+ Extensions:

AFP 3.2 Extensions (Extended Attributes / ACLs):

AFP Error Codes

Defined in include/atalk/afp.h:

AFP Server Flags

Defined in include/atalk/afp.h, these are advertised in the server status block:

AFP Attention Codes

Defined in include/atalk/afp.h, sent via DSIFUNC_ATTN:

AFP Command Processing Loop and Signals

The DSI worker polls the client socket, parent hint pipe, and signal self-pipe. It grants idle cleanup only while blocked, then calls iw_revoke() before any cache access, including after EINTR. Buffered DSI requests bypass poll. Sleeping sessions continue to poll so reconnect signals can wake them.

Signal handlers record requests; process_deferred_signals() performs their actions in the main loop. In particular, afp_dsi_transfer_handler() records SIGURG for handle_transfer_session(), and alarm_handler() records SIGALRM for handle_alarm(). There is no siglongjmp() reconnect path. See AFP Daemon: Signal Handling for the current handler table.

Connection Lifecycle

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '14px', 'primaryColor': '#4a90d9', 'primaryTextColor': '#fff', 'lineColor': '#333333', 'secondaryColor': '#7c4dff', 'tertiaryColor': '#e8f5e9', 'actorBkg': '#4a90d9', 'actorTextColor': '#ffffff', 'actorBorder': '#2e6da4', 'actorLineColor': '#333333', 'signalColor': '#333333', 'signalTextColor': '#333333', 'noteBkgColor': '#e8f5e9', 'noteTextColor': '#333333', 'noteBorderColor': '#43a047', 'activationBkgColor': '#dce4f0', 'activationBorderColor': '#4a90d9', 'loopTextColor': '#333333', 'labelBoxBkgColor': '#f5f5f5', 'labelBoxBorderColor': '#cccccc', 'labelTextColor': '#333333'}, 'sequence': {'noteMargin': 8, 'mirrorActors': false}}}%%
sequenceDiagram
    participant C as AFP Client
    participant M as afpd Master
    participant W as afpd Worker

    C->>M: TCP SYN to port 548
    M-->>C: TCP SYN-ACK
    C->>M: TCP ACK

    Note over M: accept() in dsi_tcp_open()
    Note over M: fork() child process
    M->>W: Child inherits socket

    C->>W: DSI OpenSession (DSIFUNC_OPEN=4)<br/>with DSIOPT_ATTNQUANT
    Note over W: dsi_opensession() parses options
    W-->>C: DSI OpenSession Reply<br/>DSIOPT_SERVQUANT (1MB)<br/>DSIOPT_REPLCSIZE (128)

    C->>W: DSI Command (DSIFUNC_CMD=2)<br/>AFP FPLogin (cmd=18)
    Note over W: preauth_switch[18] = afp_login
    W-->>C: DSI Reply: AFP_OK or AFPERR_AUTHCONT
    Note over W: Switch afp_switch → postauth_switch

    loop AFP Operations
        C->>W: DSI Command (DSIFUNC_CMD=2)<br/>AFP command byte
        Note over W: postauth_switch[cmd]()
        W-->>C: DSI Reply with result
    end

    par Keep-alive
        W->>C: DSI Tickle (DSIFUNC_TICKLE=5)
        C->>W: DSI Tickle (DSIFUNC_TICKLE=5)
    end

    C->>W: DSI CloseSession (DSIFUNC_CLOSE=1)
    Note over W: afp_dsi_close() → dsi_close()
    W-->>C: DSI Close → TCP FIN

ASP Protocol (AFP over AppleTalk)

ASP is the legacy session layer for AFP over AppleTalk networks. It provides the same session semantics as DSI (open, command, write, tickle, attention, close) but runs over ATP/DDP rather than TCP. ASP requires kernel-level AppleTalk support and is only compiled when NO_DDP is not defined.

Source Files

ASP Structure

Defined in include/atalk/asp.h:

#define ASP_HDRSIZ        4
#define ASP_CMDSIZ        578
#define ASP_MAXPACKETS    8

typedef struct ASP {
    ATP          asp_atp;         /* underlying ATP handle */
    struct sockaddr_at asp_sat;   /* AppleTalk address */
    uint8_t      asp_wss;        /* workstation session socket */
    uint8_t      asp_sid;        /* session ID */
    int          asp_flags;      /* ASPFL_SLS or ASPFL_SSS */
    char         child, inited, *commands;
    char         cmdbuf[ASP_CMDMAXSIZ];   /* 582 bytes */
    char         data[ASP_DATAMAXSIZ];    /* 4624 bytes */
    size_t       cmdlen, datalen;
    off_t        read_count, write_count;
} *ASP;

The maximum data per ATP transaction is 578 bytes × 8 packets = 4,624 bytes (ASP_DATASIZ). This is orders of magnitude smaller than DSI’s default 1 MiB quantum, which is why AppleTalk file transfers are significantly slower.

ASP Commands

Defined in include/atalk/asp.h. Parallel to DSI commands:

ASP Error Codes

Defined in include/atalk/asp.h. Mirror DSI error codes exactly:

ASP Session Handling

asp_getsession() in libatalk/asp/asp_getsess.c handles three request types:

• ASPFUNC_TICKLE — resets the connection state for the session ID
• ASPFUNC_STAT — sends the server status block via ATP response packets
• ASPFUNC_OPEN — opens a new ATP socket, forks a child process, returns the session ID and port

The parent process runs a periodic tickle_handler() via SIGALRM that iterates all session slots, sending tickles and killing timed-out children.

AppleTalk Protocol Stack

The lower-layer AppleTalk protocols that ASP depends on. All are conditionally compiled behind #ifndef NO_DDP.

DDP (Datagram Delivery Protocol)

Header: include/atalk/ddp.h. Defines the DDP socket type constants:

ATP (AppleTalk Transaction Protocol)

Header: include/atalk/atp.h. Implementation: libatalk/atp/.

ATP provides reliable request-response transactions over DDP datagrams. It supports exactly-once (XO) delivery, multi-packet responses (up to 8 segments), and configurable retransmission timers. The core header structure is struct atphdr:

struct atphdr {
    uint8_t   atphd_ctrlinfo;  /* control: function(2) + XO + EOM + STS + TREL(3) */
    uint8_t   atphd_bitmap;    /* bitmap or sequence number */
    uint16_t  atphd_tid;       /* transaction ID */
};

Constants:

API functions: atp_open(), atp_close(), atp_sreq() (send request), atp_rresp() (receive response), atp_rreq() (receive request), atp_sresp() (send response).

NBP (Name Binding Protocol)

Header: include/atalk/nbp.h. Implementation: etc/atalkd/nbp.c.

NBP provides name-to-address resolution for AppleTalk networks, analogous to DNS for IP. Services register themselves as named entities in the format object:type@zone (e.g., MyServer:AFPServer@Engineering), and clients discover them through broadcast lookups.

struct nbptuple — the address portion of an NBP entity:

struct nbptuple {
    uint16_t   nt_net;     /* network number */
    uint8_t    nt_node;    /* node number */
    uint8_t    nt_port;    /* socket (port) number */
    uint8_t    nt_enum;    /* enumerator */
};

struct nbpnve — a Network Visible Entity (full name + address):

struct nbpnve {
    struct sockaddr_at nn_sat;
    uint8_t  nn_objlen;
    char     nn_obj[NBPSTRLEN];    /* 32 chars max */
    uint8_t  nn_typelen;
    char     nn_type[NBPSTRLEN];
    uint8_t  nn_zonelen;
    char     nn_zone[NBPSTRLEN];
};

NBP operations:

API: nbp_lookup(), nbp_rgstr(), nbp_unrgstr(), nbp_name(). Command-line tools: bin/nbp/nbplkup.c, bin/nbp/nbprgstr.c, bin/nbp/nbpunrgstr.c.

RTMP (Routing Table Maintenance Protocol)

Header: include/atalk/rtmp.h. Implementation: etc/atalkd/rtmp.c.

struct rtmpent {
    uint16_t   re_net;    /* network number */
    uint8_t    re_hops;   /* hop count */
};

Constants: RTMPHOPS_MAX = 15, RTMPHOPS_POISON = 31, RTMPROP_REQUEST = 1.

ZIP (Zone Information Protocol)

Header: include/atalk/zip.h. Implementation: etc/atalkd/zip.c.

struct ziphdr {
    uint8_t    zh_op;     /* operation */
    uint8_t    zh_cnt;    /* count / zero / flags */
};

ZIP operations:

Maximum zone name: MAX_ZONE_LENGTH = 32.

AppleTalk Protocol Stack Diagram

Application Layer:     AFP (Apple Filing Protocol)
                       ─────────────────────────────
Session Layer:         ASP (AppleTalk Session Protocol)
                       ─────────────────────────────
Transport Layer:       ATP (AppleTalk Transaction Protocol)
                       ─────────────────────────────
Network Services:      RTMP    NBP     ZIP     AEP
                       ─────────────────────────────
Network Layer:         DDP (Datagram Delivery Protocol)
                       ─────────────────────────────
Link Layer:            EtherTalk / LocalTalk / TokenTalk

Performance Characteristics

DSI server quantum bounds incoming write data; it is not a filesystem record size or the maximum streamed read reply. dsi_align_quantum() in libatalk/dsi/dsi_tcp.c adjusts it to bounded page/MSS alignment, and dsi_opensession() advertises the session value. Receive-side buffering can grow with both quantum and dsireadbuf.

See Performance Tuning for current defaults, memory accounting, and measurement. No fixed buffer requirement can be inferred from link speed alone.

Footnotes

Generated from the Netatalk GitHub Wiki

Last updated 2026-10-21