Org.Lwes/UdpEndpoint.cs

   1 //
   2 // This file is part of the LWES .NET Binding (LWES.net)
   3 //
   4 // COPYRIGHT© 2009, Phillip Clark (phillip[at*flitbit[dot*org)
   5 //       original .NET implementation
   6 //
   7 // LWES.net is free software: you can redistribute it and/or modify
   8 // it under the terms of the Lesser GNU General Public License as published by
   9 // the Free Software Foundation, either version 3 of the License, or
  10 // (at your option) any later version.
  11 //
  12 // LWES.net is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // Lesser GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the Lesser GNU General Public License
  18 // along with LWES.net.  If not, see <http://www.gnu.org/licenses/>.
  19 //
  20 namespace Org.Lwes
  21 {
  22         using System;
  23         using System.IO;
  24         using System.Net;
  25         using System.Net.Sockets;
  26
  27         /// <summary>
  28         /// Encapsulates the state of an operation that occurred
  29         /// in parallel on an EndPoint.
  30         /// </summary>
  31         internal struct EndPointOpState
  32         {
  33                 #region Fields
  34
  35                 internal Func<EndPointOpState, bool> Callback;
  36                 internal SocketAsyncEventArgs SocketArgs;
  37
  38                 object _handback;
  39
  40                 #endregion Fields
  41
  42                 #region Constructors
  43
  44                 internal EndPointOpState(SocketAsyncEventArgs args, Func<EndPointOpState, bool> cb, object hb)
  45                 {
  46                         SocketArgs = args;
  47                         Callback = cb;
  48                         _handback = hb;
  49                 }
  50
  51                 #endregion Constructors
  52
  53                 #region Properties
  54
  55                 /// <summary>
  56                 /// Accesses the raw byte buffer containing data. For SendXXX operations this
  57                 /// is the data sent; for ReceiveXXX operations this is the data received.
  58                 /// </summary>
  59                 public byte[] Buffer
  60                 {
  61                         get { return SocketArgs.Buffer; }
  62                 }
  63
  64                 /// <summary>
  65                 /// Number of bytes used in the operation.
  66                 /// </summary>
  67                 public int BytesTransferred
  68                 {
  69                         get { return SocketArgs.BytesTransferred; }
  70                 }
  71
  72                 /// <summary>
  73                 /// Handback object given by the initiator of the operation.
  74                 /// </summary>
  75                 public object Handback
  76                 {
  77                         get { return _handback; }
  78                 }
  79
  80                 /// <summary>
  81                 /// Offset within the buffer where valid data begins. WARNING: May not be the beginning of the buffer.
  82                 /// </summary>
  83                 public int Offset
  84                 {
  85                         get { return SocketArgs.Offset; }
  86                 }
  87
  88                 /// <summary>
  89                 /// Identifies the operation that was performed.
  90                 /// </summary>
  91                 /// <see cref="System.Net.Sockets.SocketAsyncOperation"/>
  92                 public SocketAsyncOperation Operation
  93                 {
  94                         get { return SocketArgs.LastOperation; }
  95                 }
  96
  97                 /// <summary>
  98                 /// Identifies the remote side of the communication.
  99                 /// </summary>
 100                 public EndPoint RemoteEndPoint
 101                 {
 102                         get { return SocketArgs.RemoteEndPoint; }
 103                 }
 104
 105                 /// <summary>
 106                 /// Identifies the socket error. NOTE: SocketError.Success indicates no error occurred!
 107                 /// </summary>
 108                 public SocketError SocketError
 109                 {
 110                         get { return SocketArgs.SocketError; }
 111                 }
 112
 113                 #endregion Properties
 114         }
 115
 116         /// <summary>
 117         /// Socket endpoint adapter for working with UDP.
 118         /// </summary>
 119         internal class UdpEndpoint : IDisposable
 120         {
 121                 #region Fields
 122
 123                 IPEndPoint _endpoint;
 124                 Socket _socket;
 125
 126                 #endregion Fields
 127
 128                 #region Constructors
 129
 130                 /// <summary>
 131                 /// Creates a new instance.
 132                 /// </summary>
 133                 /// <param name="endpoint">endpoint to be adapted</param>
 134                 public UdpEndpoint(IPEndPoint endpoint)
 135                 {
 136                         if (endpoint == null) throw new ArgumentNullException("endpoint");
 137
 138                         _endpoint = endpoint;
 139                 }
 140
 141                 ~UdpEndpoint()
 142                 {
 143                         Dispose(false);
 144                 }
 145
 146                 #endregion Constructors
 147
 148                 #region Properties
 149
 150                 public EndPoint EndPoint
 151                 {
 152                         get { return _endpoint; }
 153                 }
 154
 155                 #endregion Properties
 156
 157                 #region Methods
 158
 159                 public void ContinueReceiveFromAsync(EndPointOpState state, int offset, int count)
 160                 {
 161                         state.SocketArgs.SetBuffer(state.SocketArgs.Buffer, offset, count);
 162                         if (!_socket.ReceiveFromAsync(state.SocketArgs))
 163                         {
 164                                 // If the callback reuses the args (indicated by return value of true)
 165                                 // then we return without queuing the args.
 166                                 if (state.Callback != null
 167                                                 && state.Callback(new EndPointOpState(state.SocketArgs
 168                                                         , state.Callback
 169                                                         , state.Handback
 170                                                         )))
 171                                         return;
 172                         }
 173                 }
 174
 175                 public void ContinueReceiveFromAsync(EndPointOpState state, byte[] buffer)
 176                 {
 177                         state.SocketArgs.SetBuffer(buffer, 0, buffer.Length);
 178                         if (!_socket.ReceiveFromAsync(state.SocketArgs))
 179                         {
 180                                 // If the callback reuses the args (indicated by return value of true)
 181                                 // then we return without queuing the args.
 182                                 if (state.Callback != null
 183                                                 && state.Callback(new EndPointOpState(state.SocketArgs
 184                                                         , state.Callback
 185                                                         , state.Handback
 186                                                         )))
 187                                         return;
 188                         }
 189                 }
 190
 191                 public void ContinueSendToAsync(EndPointOpState state, int offset, int count)
 192                 {
 193                         state.SocketArgs.SetBuffer(state.SocketArgs.Buffer, offset, count);
 194                         if (!_socket.SendToAsync(state.SocketArgs))
 195                         {
 196                                 // If the callback reuses the args (indicated by return value of true)
 197                                 // then we return without queuing the args.
 198                                 if (state.Callback != null
 199                                                 && state.Callback(new EndPointOpState(state.SocketArgs
 200                                                         , state.Callback
 201                                                         , state.Handback
 202                                                         )))
 203                                         return;
 204                         }
 205                 }
 206
 207                 public void Dispose()
 208                 {
 209                         Dispose(true);
 210                         GC.SuppressFinalize(this);
 211                 }
 212
 213                 public UdpEndpoint Initialize(Action<Socket, IPEndPoint> finishSocket)
 214                 {
 215                         if (finishSocket == null) throw new ArgumentNullException("finishSocket");
 216
 217                         _socket = new Socket(_endpoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
 218                         finishSocket(_socket, _endpoint);
 219                         return this;
 220                 }
 221
 222                 public int ReceiveFrom(ref EndPoint endpoint, byte[] data, int offset, int count)
 223                 {
 224                         return _socket.ReceiveFrom(data, offset, count, SocketFlags.None, ref endpoint);
 225                 }
 226
 227                 public void ReceiveFromAsync(EndPoint endpoint, byte[] data, int offset, int count, Func<EndPointOpState, bool> callback, object handback)
 228                 {
 229                         SocketAsyncEventArgs args = InitArgs();
 230                         args.RemoteEndPoint = endpoint;
 231                         args.SetBuffer(data, offset, count);
 232                         args.UserToken = new Completion(callback, handback);
 233                         if (!_socket.ReceiveFromAsync(args))
 234                         {
 235                                 // If the callback reuses the args (indicated by return value of true)
 236                                 // then we return without queuing the args.
 237                                 if (callback != null
 238                                         && callback(new EndPointOpState(args
 239                                                 , callback
 240                                                 , handback
 241                                                 ))) return;
 242
 243                         }
 244                 }
 245
 246                 public void SendTo(EndPoint endpoint, byte[] data)
 247                 {
 248                         _socket.SendTo(data, endpoint);
 249                 }
 250
 251                 public void SendTo(EndPoint endpoint, byte[] data, int count)
 252                 {
 253                         _socket.SendTo(data, count, SocketFlags.None, endpoint);
 254                 }
 255
 256                 public void SendTo(EndPoint endpoint, byte[] data, int offset, int count, SocketFlags flags)
 257                 {
 258                         _socket.SendTo(data, offset, count, flags, endpoint);
 259                 }
 260
 261                 public void SendToAsync(EndPoint endpoint, byte[] data, int count, Func<EndPointOpState, bool> callback)
 262                 {
 263                         SendToAsync(endpoint, data, 0, count, callback, null);
 264                 }
 265
 266                 public void SendToAsync(EndPoint endpoint, byte[] data, int count, Func<EndPointOpState, bool> callback, object handback)
 267                 {
 268                         SendToAsync(endpoint, data, 0, count, callback, handback);
 269                 }
 270
 271                 public void SendToAsync(EndPoint endpoint, byte[] data, int offset, int count, Func<EndPointOpState, bool> callback, object handback)
 272                 {
 273                         SocketAsyncEventArgs args = InitArgs();
 274                         args.RemoteEndPoint = endpoint;
 275                         args.SetBuffer(data, offset, count);
 276                         args.UserToken = new Completion(callback, handback);
 277                         if (!_socket.SendToAsync(args))
 278                         {
 279                                 // If the callback reuses the args (indicated by return value of true)
 280                                 // then we return without queuing the args.
 281                                 if (callback != null
 282                                         && callback(new EndPointOpState(args
 283                                                 , callback
 284                                                 , handback
 285                                                 ))) return;
 286
 287                         }
 288                 }
 289
 290                 void BackgroundCompletedCallback(object sender, SocketAsyncEventArgs e)
 291                 {
 292                         Completion c = (Completion)e.UserToken;
 293                         if (c.Callback != null)
 294                         {
 295                                 // If the callback reuses the args (indicated by return value of true)
 296                                 // then we return without queuing the args.
 297                                 if (!c.Callback(new EndPointOpState(e, c.Callback, c.Handback)))
 298                                         return;
 299                         }
 300                 }
 301
 302                 private void Dispose(bool disposing)
 303                 {
 304                         if (_socket != null)
 305                         {
 306                                 if (_socket.Connected)
 307                                 {
 308                                         try
 309                                         {
 310                                                 _socket.Close();
 311                                         }
 312                                         catch (IOException) { /* error eaten on purpose; may be called from the GC */ }
 313                                 }
 314
 315                                 Util.Dispose(ref _socket);
 316                         }
 317                 }
 318
 319                 private SocketAsyncEventArgs InitArgs()
 320                 {
 321                         SocketAsyncEventArgs args = new SocketAsyncEventArgs();
 322                         args.Completed += new EventHandler<SocketAsyncEventArgs>(BackgroundCompletedCallback);
 323                         return args;
 324                 }
 325
 326                 #endregion Methods
 327
 328                 #region Nested Types
 329
 330                 class Completion
 331                 {
 332                         #region Fields
 333
 334                         public Func<EndPointOpState, bool> Callback;
 335                         public Object Handback;
 336
 337                         #endregion Fields
 338
 339                         #region Constructors
 340
 341                         internal Completion(Func<EndPointOpState, bool> cb, Object hb)
 342                         {
 343                                 Callback = cb;
 344                                 Handback = hb;
 345                         }
 346
 347                         #endregion Constructors
 348                 }
 349
 350                 #endregion Nested Types
 351         }
 352 }