--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tango/tango/net/DatagramConduit.d	Fri Jan 11 17:57:40 2008 +0100
@@ -0,0 +1,173 @@
+/*******************************************************************************
+
+        copyright:      Copyright (c) 2004 Kris Bell. All rights reserved
+
+        license:        BSD style: $(LICENSE)
+
+        version:        Mar 2004 : Initial release
+        version:        Dec 2006 : South Pacific release
+        
+        author:         Kris
+
+*******************************************************************************/
+
+module tango.net.DatagramConduit;
+
+public  import  tango.io.Conduit;
+
+package import  tango.net.Socket,
+                tango.net.SocketConduit;
+
+/*******************************************************************************
+        
+        Datagrams provide a low-overhead, non-reliable data transmission
+        mechanism.
+
+        Datagrams are not 'connected' in the same manner as a TCP socket; you
+        don't need to listen() or accept() to receive a datagram, and data
+        may arrive from multiple sources. A datagram socket may, however,
+        still use the connect() method like a TCP socket. When connected,
+        the read() and write() methods will be restricted to a single address
+        rather than being open instead. That is, applying connect() will make
+        the address argument to both read() and write() irrelevant. Without
+        connect(), method write() must be supplied with an address and method
+        read() should be supplied with one to identify where data originated.
+        
+        Note that when used as a listener, you must first bind the socket
+        to a local adapter. This can be achieved by binding the socket to
+        an InternetAddress constructed with a port only (ADDR_ANY), thus
+        requesting the OS to assign the address of a local network adapter
+
+*******************************************************************************/
+
+class DatagramConduit : SocketConduit
+{
+        private Address to,
+                        from;
+
+        /***********************************************************************
+        
+                Create a read/write datagram socket
+
+        ***********************************************************************/
+
+        this ()
+        {
+                super (SocketType.DGRAM, ProtocolType.IP);
+        }
+
+        /***********************************************************************
+        
+                Read bytes from an available datagram into the given array.
+                When provided, the 'from' address will be populated with the
+                origin of the incoming data. Note that we employ the timeout
+                mechanics exposed via our SocketConduit superclass. 
+
+                Returns the number of bytes read from the input, or Eof if
+                the socket cannot read
+
+        ***********************************************************************/
+
+        uint read (void[] dst, Address from=null)
+        {
+                this.from = from;
+                return input.read (dst);
+        }
+
+        /***********************************************************************
+        
+                Write an array to the specified address. If address 'to' is
+                null, it is assumed the socket has been connected instead.
+
+                Returns the number of bytes sent to the output, or Eof if
+                the socket cannot write
+
+        ***********************************************************************/
+
+        uint write (void[] src, Address to=null)
+        {
+                this.to = to;
+                return output.write (src);
+        }
+
+        /***********************************************************************
+
+                SocketConduit override:
+                
+                Read available datagram bytes into a provided array. Returns
+                the number of bytes read from the input, or Eof if the socket
+                cannot read.
+
+                Note that we're taking advantage of timout support within the
+                superclass 
+
+        ***********************************************************************/
+
+        protected override uint socketReader (void[] dst)
+        {
+                int count;
+
+                if (dst.length)
+                    count = (from) ? socket.receiveFrom (dst, from) : socket.receiveFrom (dst);
+
+                return count;
+        }
+
+        /***********************************************************************
+
+                SocketConduit override:
+
+                Write the provided content to the socket. This will stall
+                until the socket responds in some manner. If there is no
+                target address held by this class, we assume the datagram
+                has been connected instead.
+
+                Returns the number of bytes sent to the output, or Eof if
+                the socket cannot write
+
+        ***********************************************************************/
+
+        protected override uint write (void[] src)
+        {
+                int count;
+                
+                if (src.length)
+                   {
+                   count = (to) ? socket.sendTo (src, to) : socket.sendTo (src);
+                   if (count <= 0)
+                       count = Eof;
+                   }
+                return count;
+        }
+}
+
+
+
+/******************************************************************************
+
+*******************************************************************************/
+
+debug (Datagram)
+{
+        import tango.io.Console;
+
+        import tango.net.InternetAddress;
+
+        void main()
+        {
+                auto addr = new InternetAddress ("127.0.0.1", 8080);
+
+                // listen for datagrams on the local address
+                auto gram = new DatagramConduit;
+                gram.bind (addr);
+
+                // write to the local address
+                gram.write ("hello", addr);
+
+                // we are listening also ...
+                char[8] tmp;
+                auto x = new InternetAddress;
+                auto bytes = gram.read (tmp, x);
+                Cout (x) (tmp[0..bytes]).newline;
+        }
+}