diff --git a/src/csharp/GrpcCore/GrpcEnvironment.cs b/src/csharp/GrpcCore/GrpcEnvironment.cs
index 201320828bde96db19e68cbbd8e87db0c08b8cc0..7a7ff391790863a7cdf1afe09de1ad1c2a1ca8c4 100644
--- a/src/csharp/GrpcCore/GrpcEnvironment.cs
+++ b/src/csharp/GrpcCore/GrpcEnvironment.cs
@@ -13,11 +13,11 @@ namespace Google.GRPC.Core
{
const int THREAD_POOL_SIZE = 1;
- [DllImport("grpc.dll")]
- static extern void grpc_init();
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_init();
- [DllImport("grpc.dll")]
- static extern void grpc_shutdown();
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_shutdown();
static object staticLock = new object();
static bool initCalled = false;
@@ -61,7 +61,7 @@ namespace Google.GRPC.Core
/// </summary>
private static void GrpcInit()
{
- grpc_init();
+ grpcsharp_init();
threadPool.Start();
// TODO: use proper logging here
Console.WriteLine("GRPC initialized.");
@@ -73,7 +73,7 @@ namespace Google.GRPC.Core
private static void GrpcShutdown()
{
threadPool.Stop();
- grpc_shutdown();
+ grpcsharp_shutdown();
// TODO: use proper logging here
Console.WriteLine("GRPC shutdown.");
diff --git a/src/csharp/GrpcCore/Internal/CallSafeHandle.cs b/src/csharp/GrpcCore/Internal/CallSafeHandle.cs
index bbb830b3552c24a29237be4898a3f99bf00606fe..f5973e2709f4276431db7acea9304e1a5e0fc014 100644
--- a/src/csharp/GrpcCore/Internal/CallSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/CallSafeHandle.cs
@@ -15,67 +15,67 @@ namespace Google.GRPC.Core.Internal
{
const UInt32 GRPC_WRITE_BUFFER_HINT = 1;
- [DllImport("grpc.dll")]
- static extern CallSafeHandle grpc_channel_create_call_old(ChannelSafeHandle channel, string method, string host, Timespec deadline);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern CallSafeHandle grpcsharp_channel_create_call_old(ChannelSafeHandle channel, string method, string host, Timespec deadline);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_add_metadata(CallSafeHandle call, IntPtr metadata, UInt32 flags);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_add_metadata(CallSafeHandle call, IntPtr metadata, UInt32 flags);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_invoke_old(CallSafeHandle call, CompletionQueueSafeHandle cq, IntPtr metadataReadTag, IntPtr finishedTag, UInt32 flags);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_invoke_old(CallSafeHandle call, CompletionQueueSafeHandle cq, IntPtr metadataReadTag, IntPtr finishedTag, UInt32 flags);
- [DllImport("grpc.dll", EntryPoint = "grpc_call_invoke_old")]
- static extern GRPCCallError grpc_call_invoke_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle cq,
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_invoke_old")]
+ static extern GRPCCallError grpcsharp_call_invoke_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle cq,
[MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate metadataReadCallback,
[MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate finishedCallback,
UInt32 flags);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_server_accept_old(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, IntPtr finishedTag);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_server_accept_old(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, IntPtr finishedTag);
- [DllImport("grpc.dll", EntryPoint = "grpc_call_server_accept_old")]
- static extern GRPCCallError grpc_call_server_accept_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate finishedCallback);
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_server_accept_old")]
+ static extern GRPCCallError grpcsharp_call_server_accept_old_CALLBACK(CallSafeHandle call, CompletionQueueSafeHandle completionQueue, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate finishedCallback);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_server_end_initial_metadata_old(CallSafeHandle call, UInt32 flags);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_server_end_initial_metadata_old(CallSafeHandle call, UInt32 flags);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_cancel(CallSafeHandle call);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_cancel(CallSafeHandle call);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_cancel_with_status(CallSafeHandle call, StatusCode status, string description);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_cancel_with_status(CallSafeHandle call, StatusCode status, string description);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_start_write_status_old(CallSafeHandle call, StatusCode statusCode, string statusMessage, IntPtr tag);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_start_write_status_old(CallSafeHandle call, StatusCode statusCode, string statusMessage, IntPtr tag);
- [DllImport("grpc.dll", EntryPoint = "grpc_call_start_write_status_old")]
- static extern GRPCCallError grpc_call_start_write_status_old_CALLBACK(CallSafeHandle call, StatusCode statusCode, string statusMessage, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_start_write_status_old")]
+ static extern GRPCCallError grpcsharp_call_start_write_status_old_CALLBACK(CallSafeHandle call, StatusCode statusCode, string statusMessage, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_writes_done_old(CallSafeHandle call, IntPtr tag);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_writes_done_old(CallSafeHandle call, IntPtr tag);
- [DllImport("grpc.dll", EntryPoint = "grpc_call_writes_done_old")]
- static extern GRPCCallError grpc_call_writes_done_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_writes_done_old")]
+ static extern GRPCCallError grpcsharp_call_writes_done_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
- [DllImport("grpc.dll")]
- static extern GRPCCallError grpc_call_start_read_old(CallSafeHandle call, IntPtr tag);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern GRPCCallError grpcsharp_call_start_read_old(CallSafeHandle call, IntPtr tag);
- [DllImport("grpc.dll", EntryPoint = "grpc_call_start_read_old")]
- static extern GRPCCallError grpc_call_start_read_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_start_read_old")]
+ static extern GRPCCallError grpcsharp_call_start_read_old_CALLBACK(CallSafeHandle call, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
[DllImport("grpc_csharp_ext.dll")]
- static extern void grpc_call_start_write_from_copied_buffer(CallSafeHandle call,
+ static extern void grpcsharp_call_start_write_from_copied_buffer(CallSafeHandle call,
byte[] buffer, UIntPtr length,
IntPtr tag, UInt32 flags);
- [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpc_call_start_write_from_copied_buffer")]
- static extern void grpc_call_start_write_from_copied_buffer_CALLBACK(CallSafeHandle call,
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_call_start_write_from_copied_buffer")]
+ static extern void grpcsharp_call_start_write_from_copied_buffer_CALLBACK(CallSafeHandle call,
byte[] buffer, UIntPtr length,
[MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback,
UInt32 flags);
- [DllImport("grpc.dll")]
- static extern void grpc_call_destroy(IntPtr call);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_call_destroy(IntPtr call);
private CallSafeHandle()
{
@@ -86,87 +86,87 @@ namespace Google.GRPC.Core.Internal
/// </summary>
public static CallSafeHandle Create(ChannelSafeHandle channel, string method, string host, Timespec deadline)
{
- return grpc_channel_create_call_old(channel, method, host, deadline);
+ return grpcsharp_channel_create_call_old(channel, method, host, deadline);
}
public void Invoke(CompletionQueueSafeHandle cq, IntPtr metadataReadTag, IntPtr finishedTag, bool buffered)
{
- AssertCallOk(grpc_call_invoke_old(this, cq, metadataReadTag, finishedTag, GetFlags(buffered)));
+ AssertCallOk(grpcsharp_call_invoke_old(this, cq, metadataReadTag, finishedTag, GetFlags(buffered)));
}
public void Invoke(CompletionQueueSafeHandle cq, bool buffered, EventCallbackDelegate metadataReadCallback, EventCallbackDelegate finishedCallback)
{
- AssertCallOk(grpc_call_invoke_old_CALLBACK(this, cq, metadataReadCallback, finishedCallback, GetFlags(buffered)));
+ AssertCallOk(grpcsharp_call_invoke_old_CALLBACK(this, cq, metadataReadCallback, finishedCallback, GetFlags(buffered)));
}
public void ServerAccept(CompletionQueueSafeHandle cq, IntPtr finishedTag)
{
- AssertCallOk(grpc_call_server_accept_old(this, cq, finishedTag));
+ AssertCallOk(grpcsharp_call_server_accept_old(this, cq, finishedTag));
}
public void ServerAccept(CompletionQueueSafeHandle cq, EventCallbackDelegate callback)
{
- AssertCallOk(grpc_call_server_accept_old_CALLBACK(this, cq, callback));
+ AssertCallOk(grpcsharp_call_server_accept_old_CALLBACK(this, cq, callback));
}
public void ServerEndInitialMetadata(UInt32 flags)
{
- AssertCallOk(grpc_call_server_end_initial_metadata_old(this, flags));
+ AssertCallOk(grpcsharp_call_server_end_initial_metadata_old(this, flags));
}
public void StartWrite(byte[] payload, IntPtr tag, bool buffered)
{
- grpc_call_start_write_from_copied_buffer(this, payload, new UIntPtr((ulong) payload.Length), tag, GetFlags(buffered));
+ grpcsharp_call_start_write_from_copied_buffer(this, payload, new UIntPtr((ulong) payload.Length), tag, GetFlags(buffered));
}
public void StartWrite(byte[] payload, bool buffered, EventCallbackDelegate callback)
{
- grpc_call_start_write_from_copied_buffer_CALLBACK(this, payload, new UIntPtr((ulong) payload.Length), callback, GetFlags(buffered));
+ grpcsharp_call_start_write_from_copied_buffer_CALLBACK(this, payload, new UIntPtr((ulong) payload.Length), callback, GetFlags(buffered));
}
public void StartWriteStatus(Status status, IntPtr tag)
{
- AssertCallOk(grpc_call_start_write_status_old(this, status.StatusCode, status.Detail, tag));
+ AssertCallOk(grpcsharp_call_start_write_status_old(this, status.StatusCode, status.Detail, tag));
}
public void StartWriteStatus(Status status, EventCallbackDelegate callback)
{
- AssertCallOk(grpc_call_start_write_status_old_CALLBACK(this, status.StatusCode, status.Detail, callback));
+ AssertCallOk(grpcsharp_call_start_write_status_old_CALLBACK(this, status.StatusCode, status.Detail, callback));
}
public void WritesDone(IntPtr tag)
{
- AssertCallOk(grpc_call_writes_done_old(this, tag));
+ AssertCallOk(grpcsharp_call_writes_done_old(this, tag));
}
public void WritesDone(EventCallbackDelegate callback)
{
- AssertCallOk(grpc_call_writes_done_old_CALLBACK(this, callback));
+ AssertCallOk(grpcsharp_call_writes_done_old_CALLBACK(this, callback));
}
public void StartRead(IntPtr tag)
{
- AssertCallOk(grpc_call_start_read_old(this, tag));
+ AssertCallOk(grpcsharp_call_start_read_old(this, tag));
}
public void StartRead(EventCallbackDelegate callback)
{
- AssertCallOk(grpc_call_start_read_old_CALLBACK(this, callback));
+ AssertCallOk(grpcsharp_call_start_read_old_CALLBACK(this, callback));
}
public void Cancel()
{
- AssertCallOk(grpc_call_cancel(this));
+ AssertCallOk(grpcsharp_call_cancel(this));
}
public void CancelWithStatus(Status status)
{
- AssertCallOk(grpc_call_cancel_with_status(this, status.StatusCode, status.Detail));
+ AssertCallOk(grpcsharp_call_cancel_with_status(this, status.StatusCode, status.Detail));
}
protected override bool ReleaseHandle()
{
- grpc_call_destroy(handle);
+ grpcsharp_call_destroy(handle);
return true;
}
diff --git a/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs b/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs
index 0f38d63f98ccc77c22b4ccb6ece4462a61517d99..6436f2bb310ab820c83ca621b85a1d2227896c01 100644
--- a/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/ChannelSafeHandle.cs
@@ -10,11 +10,11 @@ namespace Google.GRPC.Core.Internal
/// </summary>
internal class ChannelSafeHandle : SafeHandleZeroIsInvalid
{
- [DllImport("grpc.dll")]
- static extern ChannelSafeHandle grpc_channel_create(string target, IntPtr channelArgs);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern ChannelSafeHandle grpcsharp_channel_create(string target, IntPtr channelArgs);
- [DllImport("grpc.dll")]
- static extern void grpc_channel_destroy(IntPtr channel);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_channel_destroy(IntPtr channel);
private ChannelSafeHandle()
{
@@ -22,12 +22,12 @@ namespace Google.GRPC.Core.Internal
public static ChannelSafeHandle Create(string target, IntPtr channelArgs)
{
- return grpc_channel_create(target, channelArgs);
+ return grpcsharp_channel_create(target, channelArgs);
}
protected override bool ReleaseHandle()
{
- grpc_channel_destroy(handle);
+ grpcsharp_channel_destroy(handle);
return true;
}
}
diff --git a/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs b/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs
index f098de682052fa8a69ba82e7b34057df97a02678..77d8bde3756d94c0603c6e7edbe73ee5a0a42712 100644
--- a/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/CompletionQueueSafeHandle.cs
@@ -9,23 +9,23 @@ namespace Google.GRPC.Core.Internal
/// </summary>
internal class CompletionQueueSafeHandle : SafeHandleZeroIsInvalid
{
- [DllImport("grpc.dll")]
- static extern CompletionQueueSafeHandle grpc_completion_queue_create();
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern CompletionQueueSafeHandle grpcsharp_completion_queue_create();
- [DllImport("grpc.dll")]
- static extern EventSafeHandle grpc_completion_queue_pluck(CompletionQueueSafeHandle cq, IntPtr tag, Timespec deadline);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern EventSafeHandle grpcsharp_completion_queue_pluck(CompletionQueueSafeHandle cq, IntPtr tag, Timespec deadline);
- [DllImport("grpc.dll")]
- static extern EventSafeHandle grpc_completion_queue_next(CompletionQueueSafeHandle cq, Timespec deadline);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern EventSafeHandle grpcsharp_completion_queue_next(CompletionQueueSafeHandle cq, Timespec deadline);
- [DllImport("grpc.dll")]
- static extern void grpc_completion_queue_shutdown(CompletionQueueSafeHandle cq);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_completion_queue_shutdown(CompletionQueueSafeHandle cq);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCCompletionType grpc_completion_queue_next_with_callback(CompletionQueueSafeHandle cq);
+ static extern GRPCCompletionType grpcsharp_completion_queue_next_with_callback(CompletionQueueSafeHandle cq);
- [DllImport("grpc.dll")]
- static extern void grpc_completion_queue_destroy(IntPtr cq);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_completion_queue_destroy(IntPtr cq);
private CompletionQueueSafeHandle()
{
@@ -33,32 +33,32 @@ namespace Google.GRPC.Core.Internal
public static CompletionQueueSafeHandle Create()
{
- return grpc_completion_queue_create();
+ return grpcsharp_completion_queue_create();
}
public EventSafeHandle Next(Timespec deadline)
{
- return grpc_completion_queue_next(this, deadline);
+ return grpcsharp_completion_queue_next(this, deadline);
}
public GRPCCompletionType NextWithCallback()
{
- return grpc_completion_queue_next_with_callback(this);
+ return grpcsharp_completion_queue_next_with_callback(this);
}
public EventSafeHandle Pluck(IntPtr tag, Timespec deadline)
{
- return grpc_completion_queue_pluck(this, tag, deadline);
+ return grpcsharp_completion_queue_pluck(this, tag, deadline);
}
public void Shutdown()
{
- grpc_completion_queue_shutdown(this);
+ grpcsharp_completion_queue_shutdown(this);
}
protected override bool ReleaseHandle()
{
- grpc_completion_queue_destroy(handle);
+ grpcsharp_completion_queue_destroy(handle);
return true;
}
}
diff --git a/src/csharp/GrpcCore/Internal/Event.cs b/src/csharp/GrpcCore/Internal/Event.cs
index 5853ddd5704ec0e5ad1efa5a180ea51ef56e4b9e..cefe8cfbb2767b1cccd088a0f681b6ae4ef76760 100644
--- a/src/csharp/GrpcCore/Internal/Event.cs
+++ b/src/csharp/GrpcCore/Internal/Event.cs
@@ -9,84 +9,84 @@ namespace Google.GRPC.Core.Internal
/// </summary>
internal class EventSafeHandle : SafeHandleZeroIsInvalid
{
- [DllImport("grpc.dll")]
- static extern void grpc_event_finish(IntPtr ev);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_event_finish(IntPtr ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCCompletionType grpc_event_type(EventSafeHandle ev);
+ static extern GRPCCompletionType grpcsharp_event_type(EventSafeHandle ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern CallSafeHandle grpc_event_call(EventSafeHandle ev);
+ static extern CallSafeHandle grpcsharp_event_call(EventSafeHandle ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCOpError grpc_event_write_accepted(EventSafeHandle ev);
+ static extern GRPCOpError grpcsharp_event_write_accepted(EventSafeHandle ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCOpError grpc_event_finish_accepted(EventSafeHandle ev);
+ static extern GRPCOpError grpcsharp_event_finish_accepted(EventSafeHandle ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern StatusCode grpc_event_finished_status(EventSafeHandle ev);
+ static extern StatusCode grpcsharp_event_finished_status(EventSafeHandle ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern IntPtr grpc_event_finished_details(EventSafeHandle ev); // returns const char*
+ static extern IntPtr grpcsharp_event_finished_details(EventSafeHandle ev); // returns const char*
[DllImport("grpc_csharp_ext.dll")]
- static extern IntPtr grpc_event_read_length(EventSafeHandle ev);
+ static extern IntPtr grpcsharp_event_read_length(EventSafeHandle ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern void grpc_event_read_copy_to_buffer(EventSafeHandle ev, byte[] buffer, UIntPtr bufferLen);
+ static extern void grpcsharp_event_read_copy_to_buffer(EventSafeHandle ev, byte[] buffer, UIntPtr bufferLen);
[DllImport("grpc_csharp_ext.dll")]
- static extern IntPtr grpc_event_server_rpc_new_method(EventSafeHandle ev); // returns const char*
+ static extern IntPtr grpcsharp_event_server_rpc_new_method(EventSafeHandle ev); // returns const char*
public GRPCCompletionType GetCompletionType()
{
- return grpc_event_type(this);
+ return grpcsharp_event_type(this);
}
public GRPCOpError GetWriteAccepted()
{
- return grpc_event_write_accepted(this);
+ return grpcsharp_event_write_accepted(this);
}
public GRPCOpError GetFinishAccepted()
{
- return grpc_event_finish_accepted(this);
+ return grpcsharp_event_finish_accepted(this);
}
public Status GetFinished()
{
// TODO: can the native method return string directly?
- string details = Marshal.PtrToStringAnsi(grpc_event_finished_details(this));
- return new Status(grpc_event_finished_status(this), details);
+ string details = Marshal.PtrToStringAnsi(grpcsharp_event_finished_details(this));
+ return new Status(grpcsharp_event_finished_status(this), details);
}
public byte[] GetReadData()
{
- IntPtr len = grpc_event_read_length(this);
+ IntPtr len = grpcsharp_event_read_length(this);
if (len == new IntPtr(-1))
{
return null;
}
byte[] data = new byte[(int) len];
- grpc_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
+ grpcsharp_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
return data;
}
public CallSafeHandle GetCall() {
- return grpc_event_call(this);
+ return grpcsharp_event_call(this);
}
public string GetServerRpcNewMethod() {
// TODO: can the native method return string directly?
- return Marshal.PtrToStringAnsi(grpc_event_server_rpc_new_method(this));
+ return Marshal.PtrToStringAnsi(grpcsharp_event_server_rpc_new_method(this));
}
//TODO: client_metadata_read event type
protected override bool ReleaseHandle()
{
- grpc_event_finish(handle);
+ grpcsharp_event_finish(handle);
return true;
}
}
@@ -98,35 +98,35 @@ namespace Google.GRPC.Core.Internal
/// </summary>
internal class EventSafeHandleNotOwned : SafeHandleZeroIsInvalid
{
- [DllImport("grpc.dll")]
- static extern void grpc_event_finish(IntPtr ev);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_event_finish(IntPtr ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCCompletionType grpc_event_type(EventSafeHandleNotOwned ev);
+ static extern GRPCCompletionType grpcsharp_event_type(EventSafeHandleNotOwned ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern CallSafeHandle grpc_event_call(EventSafeHandleNotOwned ev);
+ static extern CallSafeHandle grpcsharp_event_call(EventSafeHandleNotOwned ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCOpError grpc_event_write_accepted(EventSafeHandleNotOwned ev);
+ static extern GRPCOpError grpcsharp_event_write_accepted(EventSafeHandleNotOwned ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern GRPCOpError grpc_event_finish_accepted(EventSafeHandleNotOwned ev);
+ static extern GRPCOpError grpcsharp_event_finish_accepted(EventSafeHandleNotOwned ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern StatusCode grpc_event_finished_status(EventSafeHandleNotOwned ev);
+ static extern StatusCode grpcsharp_event_finished_status(EventSafeHandleNotOwned ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern IntPtr grpc_event_finished_details(EventSafeHandleNotOwned ev); // returns const char*
+ static extern IntPtr grpcsharp_event_finished_details(EventSafeHandleNotOwned ev); // returns const char*
[DllImport("grpc_csharp_ext.dll")]
- static extern IntPtr grpc_event_read_length(EventSafeHandleNotOwned ev);
+ static extern IntPtr grpcsharp_event_read_length(EventSafeHandleNotOwned ev);
[DllImport("grpc_csharp_ext.dll")]
- static extern void grpc_event_read_copy_to_buffer(EventSafeHandleNotOwned ev, byte[] buffer, UIntPtr bufferLen);
+ static extern void grpcsharp_event_read_copy_to_buffer(EventSafeHandleNotOwned ev, byte[] buffer, UIntPtr bufferLen);
[DllImport("grpc_csharp_ext.dll")]
- static extern IntPtr grpc_event_server_rpc_new_method(EventSafeHandleNotOwned ev); // returns const char*
+ static extern IntPtr grpcsharp_event_server_rpc_new_method(EventSafeHandleNotOwned ev); // returns const char*
public EventSafeHandleNotOwned() : base(false)
{
@@ -139,52 +139,52 @@ namespace Google.GRPC.Core.Internal
public GRPCCompletionType GetCompletionType()
{
- return grpc_event_type(this);
+ return grpcsharp_event_type(this);
}
public GRPCOpError GetWriteAccepted()
{
- return grpc_event_write_accepted(this);
+ return grpcsharp_event_write_accepted(this);
}
public GRPCOpError GetFinishAccepted()
{
- return grpc_event_finish_accepted(this);
+ return grpcsharp_event_finish_accepted(this);
}
public Status GetFinished()
{
// TODO: can the native method return string directly?
- string details = Marshal.PtrToStringAnsi(grpc_event_finished_details(this));
- return new Status(grpc_event_finished_status(this), details);
+ string details = Marshal.PtrToStringAnsi(grpcsharp_event_finished_details(this));
+ return new Status(grpcsharp_event_finished_status(this), details);
}
public byte[] GetReadData()
{
- IntPtr len = grpc_event_read_length(this);
+ IntPtr len = grpcsharp_event_read_length(this);
if (len == new IntPtr(-1))
{
return null;
}
byte[] data = new byte[(int) len];
- grpc_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
+ grpcsharp_event_read_copy_to_buffer(this, data, new UIntPtr((ulong)data.Length));
return data;
}
public CallSafeHandle GetCall() {
- return grpc_event_call(this);
+ return grpcsharp_event_call(this);
}
public string GetServerRpcNewMethod() {
// TODO: can the native method return string directly?
- return Marshal.PtrToStringAnsi(grpc_event_server_rpc_new_method(this));
+ return Marshal.PtrToStringAnsi(grpcsharp_event_server_rpc_new_method(this));
}
//TODO: client_metadata_read event type
protected override bool ReleaseHandle()
{
- grpc_event_finish(handle);
+ grpcsharp_event_finish(handle);
return true;
}
}
diff --git a/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs b/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs
index d363b34f0b94f4055744ce0ab10bd1ee98aaa98d..391a1acd01f0263d299d1f9933501419ba5f155d 100644
--- a/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs
+++ b/src/csharp/GrpcCore/Internal/ServerSafeHandle.cs
@@ -10,31 +10,31 @@ namespace Google.GRPC.Core.Internal
/// </summary>
internal sealed class ServerSafeHandle : SafeHandleZeroIsInvalid
{
- [DllImport("grpc.dll", EntryPoint = "grpc_server_request_call_old")]
- static extern GRPCCallError grpc_server_request_call_old_CALLBACK(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_server_request_call_old")]
+ static extern GRPCCallError grpcsharp_server_request_call_old_CALLBACK(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
- [DllImport("grpc.dll")]
- static extern ServerSafeHandle grpc_server_create(CompletionQueueSafeHandle cq, IntPtr args);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern ServerSafeHandle grpcsharp_server_create(CompletionQueueSafeHandle cq, IntPtr args);
// TODO: check int representation size
- [DllImport("grpc.dll")]
- static extern int grpc_server_add_http2_port(ServerSafeHandle server, string addr);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern int grpcsharp_server_add_http2_port(ServerSafeHandle server, string addr);
// TODO: check int representation size
- [DllImport("grpc.dll")]
- static extern int grpc_server_add_secure_http2_port(ServerSafeHandle server, string addr);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern int grpcsharp_server_add_secure_http2_port(ServerSafeHandle server, string addr);
- [DllImport("grpc.dll")]
- static extern void grpc_server_start(ServerSafeHandle server);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_server_start(ServerSafeHandle server);
- [DllImport("grpc.dll")]
- static extern void grpc_server_shutdown(ServerSafeHandle server);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_server_shutdown(ServerSafeHandle server);
- [DllImport("grpc.dll", EntryPoint = "grpc_server_shutdown_and_notify")]
- static extern void grpc_server_shutdown_and_notify_CALLBACK(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
+ [DllImport("grpc_csharp_ext.dll", EntryPoint = "grpcsharp_server_shutdown_and_notify")]
+ static extern void grpcsharp_server_shutdown_and_notify_CALLBACK(ServerSafeHandle server, [MarshalAs(UnmanagedType.FunctionPtr)] EventCallbackDelegate callback);
- [DllImport("grpc.dll")]
- static extern void grpc_server_destroy(IntPtr server);
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern void grpcsharp_server_destroy(IntPtr server);
private ServerSafeHandle()
{
@@ -43,38 +43,38 @@ namespace Google.GRPC.Core.Internal
public static ServerSafeHandle NewServer(CompletionQueueSafeHandle cq, IntPtr args)
{
// TODO: also grpc_secure_server_create...
- return grpc_server_create(cq, args);
+ return grpcsharp_server_create(cq, args);
}
public int AddPort(string addr)
{
// TODO: also grpc_server_add_secure_http2_port...
- return grpc_server_add_http2_port(this, addr);
+ return grpcsharp_server_add_http2_port(this, addr);
}
public void Start()
{
- grpc_server_start(this);
+ grpcsharp_server_start(this);
}
public void Shutdown()
{
- grpc_server_shutdown(this);
+ grpcsharp_server_shutdown(this);
}
public void ShutdownAndNotify(EventCallbackDelegate callback)
{
- grpc_server_shutdown_and_notify_CALLBACK(this, callback);
+ grpcsharp_server_shutdown_and_notify_CALLBACK(this, callback);
}
public GRPCCallError RequestCall(EventCallbackDelegate callback)
{
- return grpc_server_request_call_old_CALLBACK(this, callback);
+ return grpcsharp_server_request_call_old_CALLBACK(this, callback);
}
protected override bool ReleaseHandle()
{
- grpc_server_destroy(handle);
+ grpcsharp_server_destroy(handle);
return true;
}
}
diff --git a/src/csharp/GrpcCore/Internal/Timespec.cs b/src/csharp/GrpcCore/Internal/Timespec.cs
index 5a197e121c9c24bb9ba57c13e2520173c8b22e6e..c45926707f3006572fe6900ab80eb555b8ea6a60 100644
--- a/src/csharp/GrpcCore/Internal/Timespec.cs
+++ b/src/csharp/GrpcCore/Internal/Timespec.cs
@@ -13,13 +13,20 @@ namespace Google.GRPC.Core.Internal
const int nanosPerSecond = 1000 * 1000 * 1000;
const int nanosPerTick = 100;
- [DllImport("gpr.dll")]
- static extern Timespec gpr_now();
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern Timespec gprsharp_now();
- // TODO: this only works on 64bit linux, can we autoselect the right size of ints?
- // perhaps using IntPtr would work.
- public System.Int64 tv_sec;
- public System.Int64 tv_nsec;
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern Timespec gprsharp_inf_future();
+
+ [DllImport("grpc_csharp_ext.dll")]
+ static extern int gprsharp_sizeof_timespec();
+
+ // TODO: revisit this.
+ // NOTE: on linux 64bit sizeof(gpr_timespec) = 16, on windows 32bit sizeof(gpr_timespec) = 8
+ // so IntPtr seems to have the right size to work on both.
+ public System.IntPtr tv_sec;
+ public System.IntPtr tv_nsec;
/// <summary>
/// Timespec a long time in the future.
@@ -28,8 +35,7 @@ namespace Google.GRPC.Core.Internal
{
get
{
- // TODO: set correct value based on the length of the struct
- return new Timespec { tv_sec = Int32.MaxValue, tv_nsec = 0 };
+ return gprsharp_inf_future();
}
}
@@ -37,7 +43,15 @@ namespace Google.GRPC.Core.Internal
{
get
{
- return gpr_now();
+ return gprsharp_now();
+ }
+ }
+
+ internal static int NativeSize
+ {
+ get
+ {
+ return gprsharp_sizeof_timespec();
}
}
@@ -54,12 +68,12 @@ namespace Google.GRPC.Core.Internal
}
public Timespec Add(TimeSpan timeSpan) {
- long nanos = tv_nsec + (timeSpan.Ticks % TimeSpan.TicksPerSecond) * nanosPerTick;
+ long nanos = tv_nsec.ToInt64() + (timeSpan.Ticks % TimeSpan.TicksPerSecond) * nanosPerTick;
long overflow_sec = (nanos > nanosPerSecond) ? 1 : 0;
Timespec result;
- result.tv_nsec = nanos % nanosPerSecond;
- result.tv_sec = tv_sec + (timeSpan.Ticks / TimeSpan.TicksPerSecond) + overflow_sec;
+ result.tv_nsec = new IntPtr(nanos % nanosPerSecond);
+ result.tv_sec = new IntPtr(tv_sec.ToInt64() + (timeSpan.Ticks / TimeSpan.TicksPerSecond) + overflow_sec);
return result;
}
}
diff --git a/src/csharp/GrpcCoreTests/TimespecTest.cs b/src/csharp/GrpcCoreTests/TimespecTest.cs
index 484bad7ca19a4b3953ada37e706f76d798187556..cab59fa5b39678d6ab1fdbdc6a65b5ecc5393740 100644
--- a/src/csharp/GrpcCoreTests/TimespecTest.cs
+++ b/src/csharp/GrpcCoreTests/TimespecTest.cs
@@ -1,5 +1,6 @@
using System;
using NUnit.Framework;
+using System.Runtime.InteropServices;
using Google.GRPC.Core.Internal;
namespace Google.GRPC.Core.Internal.Tests
@@ -12,31 +13,43 @@ namespace Google.GRPC.Core.Internal.Tests
var timespec = Timespec.Now;
}
+ [Test]
+ public void InfFuture()
+ {
+ var timespec = Timespec.InfFuture;
+ }
+
+ [Test]
+ public void TimespecSizeIsNativeSize()
+ {
+ Assert.AreEqual(Timespec.NativeSize, Marshal.SizeOf(typeof(Timespec)));
+ }
+
[Test]
public void Add()
{
- var t = new Timespec { tv_sec = 12345, tv_nsec = 123456789 };
+ var t = new Timespec { tv_sec = new IntPtr(12345), tv_nsec = new IntPtr(123456789) };
var result = t.Add(TimeSpan.FromTicks(TimeSpan.TicksPerSecond * 10));
- Assert.AreEqual(result.tv_sec, 12355);
- Assert.AreEqual(result.tv_nsec, 123456789);
+ Assert.AreEqual(result.tv_sec, new IntPtr(12355));
+ Assert.AreEqual(result.tv_nsec, new IntPtr(123456789));
}
[Test]
public void Add_Nanos()
{
- var t = new Timespec { tv_sec = 12345, tv_nsec = 123456789 };
+ var t = new Timespec { tv_sec = new IntPtr(12345), tv_nsec = new IntPtr(123456789) };
var result = t.Add(TimeSpan.FromTicks(10));
- Assert.AreEqual(result.tv_sec, 12345);
- Assert.AreEqual(result.tv_nsec, 123456789 + 1000);
+ Assert.AreEqual(result.tv_sec, new IntPtr(12345));
+ Assert.AreEqual(result.tv_nsec, new IntPtr(123456789 + 1000));
}
[Test]
public void Add_NanosOverflow()
{
- var t = new Timespec { tv_sec = 12345, tv_nsec = 999999999 };
+ var t = new Timespec { tv_sec = new IntPtr(12345), tv_nsec = new IntPtr(999999999) };
var result = t.Add(TimeSpan.FromTicks(TimeSpan.TicksPerSecond * 10 + 10));
- Assert.AreEqual(result.tv_sec, 12356);
- Assert.AreEqual(result.tv_nsec, 999);
+ Assert.AreEqual(result.tv_sec, new IntPtr(12356));
+ Assert.AreEqual(result.tv_nsec, new IntPtr(999));
}
}
}
diff --git a/src/csharp/ext/grpc_csharp_ext.c b/src/csharp/ext/grpc_csharp_ext.c
index 74d11c655b66e31c09ce0b7d83ecd72998ab5dce..2c4cdfa0b6f5f84592787f19feab40e39cf45060 100644
--- a/src/csharp/ext/grpc_csharp_ext.c
+++ b/src/csharp/ext/grpc_csharp_ext.c
@@ -1,9 +1,23 @@
+#include <grpc/support/port_platform.h>
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/slice.h>
#include <string.h>
+#ifdef GPR_WIN32
+#define GPR_EXPORT __declspec(dllexport)
+#define GPR_CALLTYPE __stdcall
+#endif
+
+#ifndef GPR_EXPORT
+#define GPR_EXPORT
+#endif
+
+#ifndef GPR_CALLTYPE
+#define GPR_CALLTYPE
+#endif
+
grpc_byte_buffer *string_to_byte_buffer(const char *buffer, size_t len) {
gpr_slice slice = gpr_slice_from_copied_buffer(buffer, len);
grpc_byte_buffer *bb = grpc_byte_buffer_create(&slice, 1);
@@ -11,40 +25,119 @@ grpc_byte_buffer *string_to_byte_buffer(const char *buffer, size_t len) {
return bb;
}
-void grpc_call_start_write_from_copied_buffer(grpc_call *call,
- const char *buffer, size_t len,
- void *tag, gpr_uint32 flags) {
- grpc_byte_buffer *byte_buffer = string_to_byte_buffer(buffer, len);
- GPR_ASSERT(grpc_call_start_write_old(call, byte_buffer, tag, flags) ==
- GRPC_CALL_OK);
- grpc_byte_buffer_destroy(byte_buffer);
+/* Init & shutdown */
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_init(void) { grpc_init(); }
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_shutdown(void) { grpc_shutdown(); }
+
+/* Completion queue */
+
+GPR_EXPORT grpc_completion_queue *GPR_CALLTYPE
+grpcsharp_completion_queue_create(void) {
+ return grpc_completion_queue_create();
+}
+
+GPR_EXPORT grpc_event *GPR_CALLTYPE
+grpcsharp_completion_queue_next(grpc_completion_queue *cq,
+ gpr_timespec deadline) {
+ return grpc_completion_queue_next(cq, deadline);
}
-grpc_completion_type grpc_event_type(const grpc_event *event) {
+GPR_EXPORT grpc_event *GPR_CALLTYPE
+grpcsharp_completion_queue_pluck(grpc_completion_queue *cq, void *tag,
+ gpr_timespec deadline) {
+ return grpc_completion_queue_pluck(cq, tag, deadline);
+}
+
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_completion_queue_shutdown(grpc_completion_queue *cq) {
+ grpc_completion_queue_shutdown(cq);
+}
+
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_completion_queue_destroy(grpc_completion_queue *cq) {
+ grpc_completion_queue_destroy(cq);
+}
+
+GPR_EXPORT grpc_completion_type GPR_CALLTYPE
+grpcsharp_completion_queue_next_with_callback(grpc_completion_queue *cq) {
+ grpc_event *ev;
+ grpc_completion_type t;
+ void(GPR_CALLTYPE * callback)(grpc_event *);
+
+ ev = grpc_completion_queue_next(cq, gpr_inf_future);
+ t = ev->type;
+ if (ev->tag) {
+ /* call the callback in ev->tag */
+ /* C forbids to cast object pointers to function pointers, so
+ * we cast to intptr first.
+ */
+ callback = (void(GPR_CALLTYPE *)(grpc_event *))(gpr_intptr)ev->tag;
+ (*callback)(ev);
+ }
+ grpc_event_finish(ev);
+
+ /* return completion type to allow some handling for events that have no
+ * tag - such as GRPC_QUEUE_SHUTDOWN
+ */
+ return t;
+}
+
+/* Channel */
+
+GPR_EXPORT grpc_channel *GPR_CALLTYPE
+grpcsharp_channel_create(const char *target, const grpc_channel_args *args) {
+ return grpc_channel_create(target, args);
+}
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_channel_destroy(grpc_channel *channel) {
+ grpc_channel_destroy(channel);
+}
+
+GPR_EXPORT grpc_call *GPR_CALLTYPE
+grpcsharp_channel_create_call_old(grpc_channel *channel, const char *method,
+ const char *host, gpr_timespec deadline) {
+ return grpc_channel_create_call_old(channel, method, host, deadline);
+}
+
+/* Event */
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_event_finish(grpc_event *event) {
+ grpc_event_finish(event);
+}
+
+GPR_EXPORT grpc_completion_type GPR_CALLTYPE
+grpcsharp_event_type(const grpc_event *event) {
return event->type;
}
-grpc_op_error grpc_event_write_accepted(const grpc_event *event) {
+GPR_EXPORT grpc_op_error GPR_CALLTYPE
+grpcsharp_event_write_accepted(const grpc_event *event) {
GPR_ASSERT(event->type == GRPC_WRITE_ACCEPTED);
return event->data.invoke_accepted;
}
-grpc_op_error grpc_event_finish_accepted(const grpc_event *event) {
+GPR_EXPORT grpc_op_error GPR_CALLTYPE
+grpcsharp_event_finish_accepted(const grpc_event *event) {
GPR_ASSERT(event->type == GRPC_FINISH_ACCEPTED);
return event->data.finish_accepted;
}
-grpc_status_code grpc_event_finished_status(const grpc_event *event) {
+GPR_EXPORT grpc_status_code GPR_CALLTYPE
+grpcsharp_event_finished_status(const grpc_event *event) {
GPR_ASSERT(event->type == GRPC_FINISHED);
return event->data.finished.status;
}
-const char *grpc_event_finished_details(const grpc_event *event) {
+GPR_EXPORT const char *GPR_CALLTYPE
+grpcsharp_event_finished_details(const grpc_event *event) {
GPR_ASSERT(event->type == GRPC_FINISHED);
return event->data.finished.details;
}
-gpr_intptr grpc_event_read_length(const grpc_event *event) {
+GPR_EXPORT gpr_intptr GPR_CALLTYPE
+grpcsharp_event_read_length(const grpc_event *event) {
GPR_ASSERT(event->type == GRPC_READ);
if (!event->data.read) {
return -1;
@@ -56,7 +149,8 @@ gpr_intptr grpc_event_read_length(const grpc_event *event) {
* Copies data from read event to a buffer. Fatal error occurs if
* buffer is too small.
*/
-void grpc_event_read_copy_to_buffer(const grpc_event *event, char *buffer,
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_event_read_copy_to_buffer(const grpc_event *event, char *buffer,
size_t buffer_len) {
grpc_byte_buffer_reader *reader;
gpr_slice slice;
@@ -77,37 +171,142 @@ void grpc_event_read_copy_to_buffer(const grpc_event *event, char *buffer,
grpc_byte_buffer_reader_destroy(reader);
}
-grpc_call *grpc_event_call(const grpc_event *event) {
+GPR_EXPORT grpc_call *GPR_CALLTYPE
+grpcsharp_event_call(const grpc_event *event) {
/* we only allow this for newly incoming server calls. */
GPR_ASSERT(event->type == GRPC_SERVER_RPC_NEW);
return event->call;
}
-const char *grpc_event_server_rpc_new_method(const grpc_event *event) {
+GPR_EXPORT const char *GPR_CALLTYPE
+grpcsharp_event_server_rpc_new_method(const grpc_event *event) {
GPR_ASSERT(event->type == GRPC_SERVER_RPC_NEW);
return event->data.server_rpc_new.method;
}
-grpc_completion_type grpc_completion_queue_next_with_callback(
- grpc_completion_queue *cq) {
- grpc_event *ev;
- grpc_completion_type t;
- void (*callback)(grpc_event *);
+/* Timespec */
- ev = grpc_completion_queue_next(cq, gpr_inf_future);
- t = ev->type;
- if (ev->tag) {
- /* call the callback in ev->tag */
- /* C forbids to cast object pointers to function pointers, so
- * we cast to intptr first.
- */
- callback = (void (*)(grpc_event *))(gpr_intptr)ev->tag;
- (*callback)(ev);
- }
- grpc_event_finish(ev);
+GPR_EXPORT gpr_timespec GPR_CALLTYPE gprsharp_now(void) { return gpr_now(); }
- /* return completion type to allow some handling for events that have no
- * tag - such as GRPC_QUEUE_SHUTDOWN
- */
- return t;
+GPR_EXPORT gpr_timespec GPR_CALLTYPE gprsharp_inf_future(void) {
+ return gpr_inf_future;
+}
+
+GPR_EXPORT gpr_int32 GPR_CALLTYPE gprsharp_sizeof_timespec(void) {
+ return sizeof(gpr_timespec);
+}
+
+/* Call */
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_add_metadata_old(grpc_call *call, grpc_metadata *metadata,
+ gpr_uint32 flags) {
+ return grpc_call_add_metadata_old(call, metadata, flags);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_invoke_old(grpc_call *call, grpc_completion_queue *cq,
+ void *metadata_read_tag, void *finished_tag,
+ gpr_uint32 flags) {
+ return grpc_call_invoke_old(call, cq, metadata_read_tag, finished_tag, flags);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_server_accept_old(grpc_call *call, grpc_completion_queue *cq,
+ void *finished_tag) {
+ return grpc_call_server_accept_old(call, cq, finished_tag);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_server_end_initial_metadata_old(grpc_call *call,
+ gpr_uint32 flags) {
+ return grpc_call_server_end_initial_metadata_old(call, flags);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE grpcsharp_call_cancel(grpc_call *call) {
+ return grpc_call_cancel(call);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_cancel_with_status(grpc_call *call, grpc_status_code status,
+ const char *description) {
+ return grpc_call_cancel_with_status(call, status, description);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_start_write_old(grpc_call *call, grpc_byte_buffer *byte_buffer,
+ void *tag, gpr_uint32 flags) {
+ return grpc_call_start_write_old(call, byte_buffer, tag, flags);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_start_write_status_old(grpc_call *call,
+ grpc_status_code status_code,
+ const char *status_message, void *tag) {
+ return grpc_call_start_write_status_old(call, status_code, status_message,
+ tag);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_writes_done_old(grpc_call *call, void *tag) {
+ return grpc_call_writes_done_old(call, tag);
+}
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_call_start_read_old(grpc_call *call, void *tag) {
+ return grpc_call_start_read_old(call, tag);
+}
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_call_destroy(grpc_call *call) {
+ grpc_call_destroy(call);
+}
+
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_call_start_write_from_copied_buffer(grpc_call *call,
+ const char *buffer, size_t len,
+ void *tag, gpr_uint32 flags) {
+ grpc_byte_buffer *byte_buffer = string_to_byte_buffer(buffer, len);
+ GPR_ASSERT(grpc_call_start_write_old(call, byte_buffer, tag, flags) ==
+ GRPC_CALL_OK);
+ grpc_byte_buffer_destroy(byte_buffer);
+}
+
+/* Server */
+
+GPR_EXPORT grpc_call_error GPR_CALLTYPE
+grpcsharp_server_request_call_old(grpc_server *server, void *tag_new) {
+ return grpc_server_request_call_old(server, tag_new);
+}
+
+GPR_EXPORT grpc_server *GPR_CALLTYPE
+grpcsharp_server_create(grpc_completion_queue *cq,
+ const grpc_channel_args *args) {
+ return grpc_server_create(cq, args);
+}
+
+GPR_EXPORT int GPR_CALLTYPE
+grpcsharp_server_add_http2_port(grpc_server *server, const char *addr) {
+ return grpc_server_add_http2_port(server, addr);
+}
+
+GPR_EXPORT int GPR_CALLTYPE
+grpcsharp_server_add_secure_http2_port(grpc_server *server, const char *addr) {
+ return grpc_server_add_secure_http2_port(server, addr);
+}
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_start(grpc_server *server) {
+ grpc_server_start(server);
+}
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_shutdown(grpc_server *server) {
+ grpc_server_shutdown(server);
+}
+
+GPR_EXPORT void GPR_CALLTYPE
+grpcsharp_server_shutdown_and_notify(grpc_server *server, void *tag) {
+ grpc_server_shutdown_and_notify(server, tag);
+}
+
+GPR_EXPORT void GPR_CALLTYPE grpcsharp_server_destroy(grpc_server *server) {
+ grpc_server_destroy(server);
}
diff --git a/templates/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj.template b/templates/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj.template
index 45f37a8c47bee1cd3f796e03eb2ef4a87e59a241..193a2cd13fdad989fa3e97900827f05538a25d54 100644
--- a/templates/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj.template
+++ b/templates/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj.template
@@ -1,2 +1,2 @@
<%namespace file="vcxproj_defs.include" import="gen_project"/>\
-${gen_project('grpc_csharp_ext', libs, targets, configuration_type = 'DynamicLibrary', project_guid = '{C26D04A8-37C6-44C7-B458-906C9FCE928C}', additional_props = ['winsock'])}
+${gen_project('grpc_csharp_ext', libs, targets, configuration_type = 'DynamicLibrary', project_guid = '{C26D04A8-37C6-44C7-B458-906C9FCE928C}', additional_props = ['winsock', 'ssl'])}
diff --git a/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj b/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj
index 3c55e608c18360a68e9fea4426f038a307ed9a28..70a43f46244d59032e0d6fe82c5fe045f82ec996 100644
--- a/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj
+++ b/vsprojects/vs2013/grpc_csharp_ext_shared.vcxproj
@@ -36,11 +36,13 @@
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="global.props" />
<Import Project="winsock.props" />
+ <Import Project="ssl.props" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="global.props" />
<Import Project="winsock.props" />
+ <Import Project="ssl.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">