public void Spawn()
{
var options = new uv_process_options_t();
options.exit_cb = static_exit;
options.file = this.File;
var args = new IntPtr[Arguments.Count + 3];
args[0] = Marshal.StringToHGlobalAuto(this.CurrentWorkingDirectory);
args[1] = Marshal.StringToHGlobalAuto(this.File);
args[args.Length - 1] = IntPtr.Zero;
for (int i = 0; i < Arguments.Count; i++)
{
args[i + 2] = Marshal.StringToHGlobalAuto(Arguments[i]);
}
options.args = args;
var env = new IntPtr[Environment.Count + 1];
env[Environment.Count - 1] = IntPtr.Zero;
for (int i = 0; i < Environment.Count; i++)
{
env[i] = Marshal.StringToHGlobalAuto(Environment[i]);
}
options.env = env;
options.stdout_stream = _stdout;
options.stderr_stream = _stderr;
Util.CheckError(uv_spawn(_handle, options));
StdOut.ReadStart();
StdErr.ReadStart();
}
public void Listen(IPEndPoint endpoint)
{
var info = uv_ip4_addr(endpoint.Address.ToString(), endpoint.Port);
Util.CheckError(uv_tcp_bind(this._handle, info));
Util.CheckError(uv_listen(this._handle, 128, unmanaged_callback));
}
public void Connect(IPEndPoint endpoint, Action OnConnect)
{
var info = uv_ip4_addr(endpoint.Address.ToString(), endpoint.Port);
Util.CheckError(uv_tcp_connect(this.connection, this._handle, info, unmanaged_connect_cb));
this.OnConnect += OnConnect;
}
static void static_read(IntPtr stream, IntPtr nread, uv_buf_t buf)
{
int size = (int)nread;
if (size < 0)
{
if ((int)buf.data != 0)
{
Marshal.FreeHGlobal(buf.data);
}
IntPtr shutdown = Marshal.AllocHGlobal(Sizes.ShutdownT);
Util.CheckError(uv_shutdown(shutdown, stream, after_shutdown));
return;
}
if (size == 0)
{
Marshal.FreeHGlobal(buf.data);
return;
}
byte[] data = new byte[size];
Marshal.Copy(buf.data, data, 0, size);
var handle = (uv_handle_t)Marshal.PtrToStructure(stream, typeof(uv_handle_t));
var instance_gchandle = GCHandle.FromIntPtr(handle.data);
var stream_instance = (UVStream)instance_gchandle.Target;
stream_instance.HandleRead(data);
Marshal.FreeHGlobal(buf.data);
}
public static void StaticCallback(IntPtr server_ptr, int status)
{
Util.CheckError(status);
var handle = (uv_handle_t)Marshal.PtrToStructure(server_ptr, typeof(uv_handle_t));
var instance = GCHandle.FromIntPtr(handle.data);
var server = (TcpServer)instance.Target;
server.callback(new TcpSocket(server._handle));
}
static void after_write(IntPtr write_req, int status)
{
Util.CheckError(status);
var req = (uv_req_t)Marshal.PtrToStructure(write_req, typeof(uv_req_t));
//var handle = GCHandle.FromIntPtr(req.data);
//handle.Free();
Marshal.FreeHGlobal(write_req);
}
internal static void StaticCallback(IntPtr watcher, int status)
{
Util.CheckError(status);
var handle = (uv_handle_t)Marshal.PtrToStructure(watcher, typeof(uv_handle_t));
var instance = GCHandle.FromIntPtr(handle.data);
var watcher_instance = (Watcher)instance.Target;
watcher_instance.callback();
}
public TcpServer(Action <TcpSocket> callback)
{
this.callback = callback;
this._handle = Marshal.AllocHGlobal(Sizes.TcpT);
Util.CheckError(uv_tcp_init(this._handle));
var handle = (uv_handle_t)Marshal.PtrToStructure(this._handle, typeof(uv_handle_t));
this.me = GCHandle.Alloc(this);
handle.data = GCHandle.ToIntPtr(this.me);
Marshal.StructureToPtr(handle, this._handle, true);
}
static void after_shutdown(IntPtr shutdown, int status)
{
Util.CheckError(status);
var tmp = (uv_shutdown_t)Marshal.PtrToStructure(shutdown, typeof(uv_shutdown_t));
var handle = (uv_handle_t)Marshal.PtrToStructure(tmp.handle, typeof(uv_handle_t));
var instance = GCHandle.FromIntPtr(handle.data);
var watcher_instance = (UVStream)instance.Target;
watcher_instance.HandleClose();
Marshal.FreeHGlobal(shutdown);
}
public Watcher(Action callback, int size)
{
this.callback = callback;
this._handle = Marshal.AllocHGlobal(size);
Util.CheckError(this.InitImpl());
var handle = (uv_handle_t)Marshal.PtrToStructure(this._handle, typeof(uv_handle_t));
this.me = GCHandle.Alloc(this);
handle.data = GCHandle.ToIntPtr(this.me);
Marshal.StructureToPtr(handle, this._handle, true);
}
static void unmanaged_connect_cb(IntPtr connection, int status)
{
Util.CheckError(status);
var tmp = (uv_connect_t)Marshal.PtrToStructure(connection, typeof(uv_connect_t));
var handle = (uv_handle_t)Marshal.PtrToStructure(tmp.handle, typeof(uv_handle_t));
var instance = GCHandle.FromIntPtr(handle.data);
var socket_instance = (TcpSocket)instance.Target;
socket_instance.Stream = new UVStream(socket_instance._handle);
socket_instance.Stream.ReadStart();
socket_instance.HandleConnect();
}
public TcpSocket()
{
this._handle = Marshal.AllocHGlobal(Sizes.TcpT);
Util.CheckError(uv_tcp_init(this._handle));
var handle = (uv_handle_t)Marshal.PtrToStructure(this._handle, typeof(uv_handle_t));
this.me = GCHandle.Alloc(this);
handle.data = GCHandle.ToIntPtr(this.me);
Marshal.StructureToPtr(handle, this._handle, true);
this.connection = Marshal.AllocHGlobal(Sizes.ConnectT);
//can't attach anything to connect_t, it would get nulled
}
public TcpSocket(IntPtr ServerHandle)
{
this._handle = Marshal.AllocHGlobal(Sizes.TcpT);
Util.CheckError(uv_tcp_init(this._handle));
Util.CheckError(uv_accept(ServerHandle, this._handle));
var handle = (uv_handle_t)Marshal.PtrToStructure(this._handle, typeof(uv_handle_t));
this.me = GCHandle.Alloc(this);
handle.data = GCHandle.ToIntPtr(this.me);
Marshal.StructureToPtr(handle, this._handle, true);
this.Stream = new UVStream(this._handle);
}
public void Write(byte[] data, int length)
{
IntPtr write_request = Marshal.AllocHGlobal(Sizes.WriteT);
var dataptrhandle = GCHandle.Alloc(data, GCHandleType.Pinned);
// This is not being freed, which needs to be fixed
IntPtr dat = dataptrhandle.AddrOfPinnedObject();
uv_buf_t[] buf = new uv_buf_t[1];
buf[0].data = dat;
#if __MonoCS__
buf[0].len = (IntPtr)length;
#else
buf[0].len = (ulong)length;
#endif
var req = (uv_req_t)Marshal.PtrToStructure(write_request, typeof(uv_req_t));
req.data = dat;
Marshal.StructureToPtr(req, write_request, true);
Util.CheckError(uv_write(write_request, this.handle, buf, 1, after_write));
}
public void Listen(string endpoint)
{
Util.CheckError(uv_pipe_bind(this._handle, endpoint));
Util.CheckError(uv_listen(this._handle, 128, unmanaged_callback));
}
public void Start()
{
Util.CheckError(this.StartImpl());
}
public void Again()
{
Util.CheckError(uv_timer_again(this._handle));
}
public void Connect(string path, Action OnConnect)
{
Util.CheckError(uv_pipe_connect(this.connection, this._handle, path, unmanaged_connect_cb));
this.OnConnect += OnConnect;
}
public void Stop()
{
Util.CheckError(this.StopImpl());
}
// Instance Methods
public void ReadStart()
{
Util.CheckError(uv_read_start(this.handle, static_alloc, static_read));
}
public void ReadStop()
{
Util.CheckError(uv_read_stop(this.handle));
}