atp.h

Go to the documentation of this file.

/*
 * Copyright (c) 1990,1991 Regents of The University of Michigan.
 * All Rights Reserved.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation, and that the name of The University
 * of Michigan not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior
 * permission. This software is supplied as is without expressed or
 * implied warranties of any kind.
 *
 *  Research Systems Unix Group
 *  The University of Michigan
 *  c/o Mike Clark
 *  535 W. William Street
 *  Ann Arbor, Michigan
 *  +1-313-763-0525
 *  netatalk@itd.umich.edu
 */
 
#ifndef _ATALK_ATP_H
#define _ATALK_ATP_H 1
 
#ifndef NO_DDP
 
#include <stdint.h>
#include <sys/types.h>
#include <sys/time.h>
#include <netatalk/at.h>

 
struct atphdr {
    uint8_t atphd_ctrlinfo; 
    uint8_t atphd_bitmap;   
    uint16_t    atphd_tid;  
};
 
/* ATP protocol parameters
*/
#define ATP_MAXDATA (578+4)     
#define ATP_BUFSIZ  587     
#define ATP_HDRSIZE 5       
 
#define ATP_TRELMASK    0x07        
#define ATP_RELTIME 30      
 
#define ATP_TREL30  0x0     
#define ATP_TREL1M  0x1     
#define ATP_TREL2M  0x2     
#define ATP_TREL4M  0x3     
#define ATP_TREL8M  0x4
 
#define ATP_TRIES_INFINITE  -1  
 
#define ATP_MAXQUEUE    8   
#define ATP_MAXRESP 8   
 
struct atpxobuf {
    uint16_t        atpxo_tid;
    struct timeval  atpxo_tv;
    int         atpxo_reltime;
    struct atpbuf   *atpxo_packet[8];
};
 
struct atpbuf {
    struct atpbuf   *atpbuf_next;       
    size_t      atpbuf_dlen;        
    struct sockaddr_at  atpbuf_addr;        
    union {
        char        atpbuf_data[ATP_BUFSIZ];    
        struct atpxobuf atpbuf_xo;          
    } atpbuf_info;
};
 
struct atp_handle {
    int         atph_socket;        
    struct sockaddr_at  atph_saddr;     
    uint16_t        atph_tid;       
    uint16_t        atph_rtid;      
    uint8_t     atph_rxo;       
    int         atph_rreltime;      
    struct atpbuf   *atph_sent;     
    struct atpbuf   *atph_queue;        
    int         atph_reqtries;      
    int         atph_reqto;     
    int         atph_rrespcount;    
    uint8_t     atph_rbitmap;       
    struct atpbuf   *atph_reqpkt;       
    struct timeval  atph_reqtv;     
    struct atpbuf   *atph_resppkt[ATP_MAXRESP]; 
};
 
typedef struct atp_handle *ATP;
 
#define atp_sockaddr( h )   (&(h)->atph_saddr)
#define atp_fileno(x)       ((x)->atph_socket)
 
struct sreq_st {
    char        *atpd_data;     
    int         atpd_dlen;
    int         atpd_tries;     
    int         atpd_to;        
};
 
struct rres_st {
    struct iovec    *atpd_iov;      
    int         atpd_iovcnt;
};
 
struct rreq_st {
    char        *atpd_data;     
    int         atpd_dlen;
};
 
struct sres_st {
    struct iovec    *atpd_iov;      
    int         atpd_iovcnt;
};
 
struct atp_block {
    struct sockaddr_at  *atp_saddr;     
    union {
        struct sreq_st  sreqdata;
#define atp_sreqdata    atp_data.sreqdata.atpd_data
#define atp_sreqdlen    atp_data.sreqdata.atpd_dlen
#define atp_sreqtries   atp_data.sreqdata.atpd_tries
#define atp_sreqto  atp_data.sreqdata.atpd_to
 
        struct rres_st  rresdata;
#define atp_rresiov atp_data.rresdata.atpd_iov
#define atp_rresiovcnt  atp_data.rresdata.atpd_iovcnt
 
        struct rreq_st  rreqdata;
#define atp_rreqdata    atp_data.rreqdata.atpd_data
#define atp_rreqdlen    atp_data.rreqdata.atpd_dlen
 
        struct sres_st  sresdata;
#define atp_sresiov atp_data.sresdata.atpd_iov
#define atp_sresiovcnt  atp_data.sresdata.atpd_iovcnt
    } atp_data;
    uint8_t     atp_bitmap; 
};
 
 
/* flags for ATP options (and control byte)
*/
#define ATP_STS     (1<<3)      
#define ATP_EOM     (1<<4)      
#define ATP_XO      (1<<5)      
 
/* function codes
*/
#define ATP_FUNCMASK    (3<<6)      
 
#define ATP_TREQ    (1<<6)      
#define ATP_TRESP   (2<<6)      
#define ATP_TREL    (3<<6)      
 
extern ATP      atp_open(uint8_t, const struct at_addr *);
extern int      atp_close(ATP);
extern int      atp_sreq(ATP, struct atp_block *, int, uint8_t);
extern int      atp_rresp(ATP, struct atp_block *);
extern int      atp_rsel(ATP, struct sockaddr_at *, int);
extern int      atp_rreq(ATP, struct atp_block *);
extern int      atp_rreq_try(ATP,
                          struct atp_block *);  
extern int      atp_sresp(ATP, struct atp_block *);
 
#endif  /* NO_DDP */
#endif