public void Resolve(string node, string service, Action <UvArgs <IPEndPoint[]> > callback = null)
{
var hints = addrinfo.CreateHints();
var hintsPtr = this.Loop.Allocs.Alloc(Marshal.SizeOf(typeof(addrinfo)));
Marshal.StructureToPtr(hints, hintsPtr, fDeleteOld: false);
try
{
_resolveReq = this.Loop.Requests.Create(uv_req_type.UV_GETADDRINFO);
CheckError(Uvi.uv_getaddrinfo(this.Loop.Handle, _resolveReq, _resolveDelegate, node, service, hintsPtr));
this.Status = HandleStatus.Resolving;
_resolveCallback = new UvEndPointsCallback(this, callback);
}
catch (Exception)
{
this.Loop.Requests.Delete(_resolveReq);
_connectCallback = null;
throw;
}
finally
{
this.Loop.Allocs.Free(hintsPtr);
}
}
internal IntPtr AllocHandle(uv_handle_type handleType)
{
var ret = Alloc(Uvi.uv_handle_size(handleType));
_allocatedHandles++;
return(ret);
}
private int FreeRequest(IntPtr req)
{
var ret = Uvi.uv_fs_req_result(req);
Uvi.uv_fs_req_cleanup(req);
this.Loop.Requests.Delete(req);
return(ret);
}
private UvStatArgs FreeStatRequest(IntPtr req)
{
var ret = Uvi.uv_fs_req_result(req);
var stat = UvStat.Create(ret == 0 ? Uvi.uv_fs_req_stat(req) : IntPtr.Zero);
Uvi.uv_fs_req_cleanup(req);
this.Loop.Requests.Delete(req);
return(new UvStatArgs(ret, stat));
}
private UvDataArgs FreeReadRequest(IntPtr req)
{
var ret = Uvi.uv_fs_req_result(req);
Uvi.uv_fs_req_cleanup(req);
var data = this.Loop.Requests.CopyAndDelete(req, (int)ret);
return(new UvDataArgs(ret, data));
}
/// <summary>
/// Closes the stream
/// </summary>
public void Close(bool dispose = false, Action <UvArgs> callback = null)
{
if (this.Status != HandleStatus.Open)
{
return;
}
_disposeAfterClose = dispose;
Uvi.uv_close(this.Handle, _closeDelegate);
this.Status = HandleStatus.Closing;
_closeCallback = new UvCallback(this, callback);
}
public void Connect(IntPtr address, Action <UvArgs> callback = null)
{
try
{
_address = address;
CheckError(Uvi.uv_tcp_connect(this.Connection, this.Handle, _address, _connectDelegate));
this.Status = HandleStatus.Opening;
_connectCallback = new UvCallback(this, callback);
}
catch (Exception)
{
_address = this.Loop.Allocs.Free(_address);
_connectCallback = null;
throw;
}
}
public void Write(byte[] data, int offset, int length, Action <UvDataArgs> callback = null)
{
IntPtr req = IntPtr.Zero;
try
{
req = this.Loop.Requests.Create(uv_req_type.UV_WRITE, data, offset, length);
CheckError((Uvi.uv_write(req, this.Handle, new[] { this.Loop.Requests[req] }, 1, _writeDelegate)));
_writeCallbacks.Add(req, new UvDataCallback(this, callback, data));
}
catch (Exception)
{
this.Loop.Requests.Delete(req);
throw;
}
}
public void RemoveDirectory(string path, Action <UvArgs> callback = null)
{
IntPtr req = IntPtr.Zero;
try
{
req = this.CreateRequest();
CheckError(Uvi.uv_fs_rmdir(this.Loop.Handle, req, path, _rmdirDelegate));
_rmdirCallback = new UvCallback(this, callback);
}
catch (Exception)
{
this.FreeRequest(req);
throw;
}
}
public void Delete(string path, Action <UvArgs> callback = null)
{
IntPtr req = IntPtr.Zero;
try
{
req = this.CreateRequest();
CheckError(Uvi.uv_fs_unlink(this.Loop.Handle, req, path, _deleteDelegate));
_deleteCallback = new UvCallback(this, callback);
}
catch (Exception)
{
this.FreeRequest(req);
throw;
}
}
public void StartListening(IPEndPoint endpoint, Action <UvArgs <TcpServerSocket> > callback = null)
{
try
{
_address = this.Loop.Allocs.Free(_address);
_address = TcpSocket.AllocSocketAddress(endpoint, this.Loop);
CheckError(Uvi.uv_tcp_bind(this.Handle, _address, 0));
CheckError(Uvi.uv_listen(this.Handle, this.BackLog, _connectionDelegate));
this.Status = HandleStatus.Open;
_connectCallback = new UvTcpServerSocketCallback(this, callback);
}
catch (Exception)
{
_address = this.Loop.Allocs.Free(_address);
}
}
protected virtual void Dispose(bool disposing)
{
if (this.IsDisposed)
{
return;
}
//we don't delete the default's loop handle
if (this.Handle != DefaultLoop.Handle)
{
if (this.Handle != IntPtr.Zero)
{
Uvi.uv_loop_delete(this.Handle);
this.Handle = IntPtr.Zero;
}
}
GC.SuppressFinalize(this);
this.IsDisposed = true;
}
internal LoopWork(Loop loop, Action run, Action after, Action <LoopWork> completed)
{
_run = new uv_work_cb(this.Run);
_after = new uv_after_work_cb(this.After);
_runAction = run;
_afterAction = after;
_completed = completed;
_loop = loop;
_work = _loop.Requests.Create(uv_req_type.UV_WORK);
try
{
_loop.CheckError(Uvi.uv_queue_work(_loop.Handle, _work, _run, _after));
}
catch (Exception)
{
_work = _loop.Requests.Delete(_work);
throw;
}
}
public void Write(byte[] data, int offset, int length, Action <UvDataArgs> callback = null)
{
if (this.Status != FileStatus.Open)
{
throw new InvalidOperationException("File handle must be open in order to write data");
}
IntPtr req = IntPtr.Zero;
try
{
req = this.CreateRequest(data, offset, length);
CheckError(Uvi.uv_fs_write(this.Loop.Handle, req, _file, new[] { this.Loop.Requests[req] }, 1, -1, _writeDelegate));
_writeCallback = new UvDataCallback(this, callback, data);
}
catch (Exception)
{
this.FreeRequest(req);
throw;
}
}
/// <summary>
/// Read from the file
/// </summary>
public void Read(uint length, Action <UvDataArgs> callback = null)
{
if (this.Status != FileStatus.Open)
{
throw new InvalidOperationException("File handle must be open in order to read data");
}
IntPtr req = IntPtr.Zero;
try
{
req = this.CreateRequest(length);
CheckError(Uvi.uv_fs_read(this.Loop.Handle, req, _file, new[] { this.Loop.Requests[req] }, 1, -1, _readDelegate));
_readCallback = new UvDataCallback(this, callback);
}
catch (Exception)
{
this.FreeRequest(req);
throw;
}
}
public void Shutdown(Action <UvArgs> callback = null)
{
IntPtr req = IntPtr.Zero;
try
{
if (_isReading)
{
this.ReadStop();
}
req = this.Loop.Requests.Create(uv_req_type.UV_SHUTDOWN);
CheckError(Uvi.uv_shutdown(req, this.Handle, _shutdownDelegate));
_shutdownCallback = new UvCallback(this, callback);
}
catch (Exception)
{
this.Loop.Requests.Delete(req);
throw;
}
}
internal static IntPtr AllocSocketAddress(IPEndPoint endpoint, Loop loop)
{
IntPtr ret;
switch (endpoint.AddressFamily)
{
case AddressFamily.InterNetwork:
ret = loop.Allocs.Alloc(Uvi.sockaddr_in_size);
loop.CheckError(Uvi.uv_ip4_addr(endpoint.Address.ToString(), endpoint.Port, ret));
break;
case AddressFamily.InterNetworkV6:
ret = loop.Allocs.Alloc(Uvi.sockaddr_in6_size);
loop.CheckError(Uvi.uv_ip6_addr(endpoint.Address.ToString(), endpoint.Port, ret));
break;
default:
throw new ArgumentException(String.Format("AddressFamily {0} not supported", endpoint.AddressFamily));
}
return(ret);
}
/// <summary>
/// Closes the stream. After this call the stream will not be valid
/// </summary>
public void Close(Action <UvArgs> callback = null)
{
if (this.Status != FileStatus.Open)
{
throw new InvalidOperationException(String.Format("Cannot close the file handle while the status is {0}", this.Status));
}
IntPtr req = IntPtr.Zero;
try
{
req = this.CreateRequest();
CheckError(Uvi.uv_fs_close(this.Loop.Handle, req, _file, _closeDelegate));
this.Status = FileStatus.Closing;
_closeCallback = new UvCallback(this, callback);
}
catch (Exception)
{
this.FreeRequest(req);
throw;
}
}
private void OnResolve(IntPtr resolver, int status, IntPtr addrinfo)
{
var callback = _resolveCallback;
_resolveCallback = null;
try
{
IPEndPoint[] value = null;
if (status == 0)
{
var info = ((addrinfo)Marshal.PtrToStructure(addrinfo, typeof(addrinfo)));
value = info.EndPoints.ToArray();
}
callback.Invoke(status, value, this.OnResolve, this.Resolved);
}
finally
{
Uvi.uv_freeaddrinfo(addrinfo);
this.Loop.Requests.Delete(_resolveReq);
}
}
/// <summary>
///
/// </summary>
/// <param name="loop"></param>
/// <remarks>Handle type is <typeparamref name="Libuv.uv_tcp_t"/> that is a subclass of <typeparamref name="Libuv.uv_stream_t"/></remarks>
protected TcpSocket(Loop loop)
: base(loop, uv_handle_type.UV_TCP)
{
CheckError(Uvi.uv_tcp_init(this.Loop.Handle, this.Handle));
}
public void Stop()
{
CheckError(Uvi.uv_timer_stop(this.Handle));
_callback = null;
}
/// <summary>
/// This function polls for new events without blocking
/// </summary>
public void RunOnce()
{
CheckError(Uvi.uv_run(this.Handle, Uvi.uv_run_mode.UV_RUN_ONCE));
}
/// <summary>
/// This function starts the event loop. It blocks until the reference count
/// of the loop drops to zero.
/// </summary>
public void Run()
{
CheckError(Uvi.uv_run(this.Handle, Uvi.uv_run_mode.UV_RUN_DEFAULT));
}
public Loop()
: this(Uvi.uv_loop_new())
{
}
public void Again()
{
CheckError(Uvi.uv_timer_again(this.Handle));
}
internal IntPtr AllocRequest(uv_req_type requestType)
{
return(Alloc(Uvi.uv_req_size(requestType)));
}
internal uv_buf_t CreateBuffer(IntPtr data, uint size)
{
return(Uvi.uv_buf_init(data, size));
}
public void ReadStop()
{
CheckError(Uvi.uv_read_stop(this.Handle));
_isReading = false;
_readCallback = null;
}
public void ReadStart(Action <UvDataArgs> callback = null)
{
CheckError(Uvi.uv_read_start(this.Handle, _allocDelegate, _readDelegate));
_isReading = true;
_readCallback = new UvDataCallback(this, callback);
}
public TcpServer(Loop loop)
: base(loop, uv_handle_type.UV_TCP)
{
this.BackLog = DefaultBackLog;
CheckError(Uvi.uv_tcp_init(this.Loop.Handle, this.Handle));
}
