A "fixed" version of Stéphane Fillod's xotd for Linux

["John Hughes" <john@Calva.COM>]

I've been playing around with xotd-0.04 for a while and have come up
with a version that I think fixes some serious bugs, notably some
problems with lost outbound calls.  (I append my earlier message
describing this problem).

It also allows configuration of multiple remote XOT devices.

---

I said: 

> I'm having a little problem making Linux xotd work with my 
> home grown implementation, but I think I've tracked it down 
> to a difference of opinion about when the TCP call should be 
> cleared. 

The way xotd works is that it clears the TCP call if it 
recieves an X.25 CLEAR CONFIRMATION: 

        void *tap_writer(void *arg) 
        { 
        ... 
            while (1) { 

                nread = readn(sockfd,(unsigned char*)&header, 
                              sizeof(struct xot_header)); 
                if (nread != sizeof(struct xot_header)) { 
        ... 
                     break;  /* abort */ 
                } 
        ... 

            } 

            if (isVerbose) 
                printd("TCP connection closed (tap writer), 
                       lci=%d.",curr_lci); 

            hash_remove(&hash_table, sockfd, lci); 

            close(sockfd);      /* TODO: add to a spare list, 
                                   for use by tap_reader */ 

This seems reasonable.  *BUT* if xotd SENDS a CLEAR CONFIRMATION, 
in the other direction it does not clear the call, it keeps it 
open and will re-use it for new connections.  (It used to clear 
the call, but as of version 0.04 this is commented out). 

Now imagine what happens when two of these xotd's are talking 
together - 

xotd#1                            xotd#2         
send clear conf >----\ 
                      \----------> Get clear conf 
                                           | 
                        /--------< Clear TCP call 
Send new call >----\   / 
                    \ / 
                     X 
                    / 
Eurgh          <---/ 

Whoops! the new call has been sent on a socket that has been 
closed by the other side.