1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
namespace IceInternal
{
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
sealed class TcpTransceiver : Transceiver, WSTransceiverDelegate
{
public Socket fd()
{
return _stream.fd();
}
public int initialize(Buffer readBuffer, Buffer writeBuffer, ref bool hasMoreData)
{
return _stream.connect(readBuffer, writeBuffer, ref hasMoreData);
}
public int closing(bool initiator, Ice.LocalException ex)
{
// If we are initiating the connection closure, wait for the peer
// to close the TCP/IP connection. Otherwise, close immediately.
return initiator ? SocketOperation.Read : SocketOperation.None;
}
public void close()
{
_stream.close();
}
public EndpointI bind()
{
Debug.Assert(false);
return null;
}
public void destroy()
{
_stream.destroy();
}
public int write(Buffer buf)
{
return _stream.write(buf);
}
public int read(Buffer buf, ref bool hasMoreData)
{
return _stream.read(buf);
}
public bool startRead(Buffer buf, AsyncCallback callback, object state)
{
return _stream.startRead(buf, callback, state);
}
public void finishRead(Buffer buf)
{
_stream.finishRead(buf);
}
public bool startWrite(Buffer buf, AsyncCallback callback, object state, out bool completed)
{
return _stream.startWrite(buf, callback, state, out completed);
}
public void finishWrite(Buffer buf)
{
_stream.finishWrite(buf);
}
public string protocol()
{
return _instance.protocol();
}
public Ice.ConnectionInfo getInfo()
{
Ice.TCPConnectionInfo info = new Ice.TCPConnectionInfo();
fillConnectionInfo(info);
return info;
}
public Ice.ConnectionInfo getWSInfo(Dictionary<string, string> headers)
{
Ice.WSConnectionInfo info = new Ice.WSConnectionInfo();
fillConnectionInfo(info);
info.headers = headers;
return info;
}
public void checkSendSize(Buffer buf)
{
}
public void setBufferSize(int rcvSize, int sndSize)
{
_stream.setBufferSize(rcvSize, sndSize);
}
public override string ToString()
{
return _stream.ToString();
}
public string toDetailedString()
{
return ToString();
}
//
// Only for use by TcpConnector, TcpAcceptor
//
internal TcpTransceiver(ProtocolInstance instance, StreamSocket stream)
{
_instance = instance;
_stream = stream;
}
private void fillConnectionInfo(Ice.TCPConnectionInfo info)
{
if(_stream.fd() != null)
{
EndPoint localEndpoint = Network.getLocalAddress(_stream.fd());
info.localAddress = Network.endpointAddressToString(localEndpoint);
info.localPort = Network.endpointPort(localEndpoint);
EndPoint remoteEndpoint = Network.getRemoteAddress(_stream.fd());
info.remoteAddress = Network.endpointAddressToString(remoteEndpoint);
info.remotePort = Network.endpointPort(remoteEndpoint);
info.rcvSize = Network.getRecvBufferSize(_stream.fd());
info.sndSize = Network.getSendBufferSize(_stream.fd());
}
}
private readonly ProtocolInstance _instance;
private readonly StreamSocket _stream;
}
}
|
