public void ContentEncoding_Disposed ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
((IDisposable) resp).Dispose ();
try {
string enc = resp.ContentEncoding;
Assert.Fail ("#1:" + enc);
} catch (ObjectDisposedException ex) {
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
}
}
}
static void Main ()
{
IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 5000);
using (SocketResponder sr = new SocketResponder (localEP, new SocketRequestHandler (Response_Bug80944))) {
sr.Start ();
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (
"http://" + sr.LocalEndPoint.Address.ToString () + ":5000/");
req.KeepAlive = false;
req.Method = "GET";
req.ReadWriteTimeout = 2000;
#if NET_2_0
req.Proxy = null;
#endif
req.Timeout = 2000;
#if NET_2_0
Assert.IsNull (req.Proxy, "#1");
#else
Assert.IsNotNull (req.Proxy, "#1");
#endif
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
using (StreamReader r = new StreamReader (resp.GetResponseStream (), Encoding.UTF8)) {
Assert.AreEqual ("FINE", r.ReadToEnd (), "#2");
}
resp.Close ();
}
}
[Test] // bug #81105
public void CloseTest ()
{
IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8765);
using (SocketResponder sr = new SocketResponder (localEP, new SocketRequestHandler (CloseRequestHandler))) {
sr.Start ();
TcpClient tcpClient = new TcpClient (IPAddress.Loopback.ToString (), 8765);
NetworkStream ns = tcpClient.GetStream ();
Assert.IsNotNull (ns, "#A1");
Assert.AreEqual (0, tcpClient.Available, "#A2");
Assert.IsTrue (tcpClient.Connected, "#A3");
// Assert.IsFalse (tcpClient.ExclusiveAddressUse, "#A4");
tcpClient.Close ();
Assert.IsNotNull (tcpClient.Client, "#A5");
try {
int available = tcpClient.Available;
Assert.Fail ("#A6: " + available);
} catch (ObjectDisposedException) {
}
Assert.IsFalse (tcpClient.Connected, "#A7");
// not supported on linux
/*
try {
bool exclusive = tcpClient.ExclusiveAddressUse;
Assert.Fail ("#A8: " + exclusive);
} catch (ObjectDisposedException) {
}
*/
}
using (SocketResponder sr = new SocketResponder (localEP, new SocketRequestHandler (CloseRequestHandler))) {
sr.Start ();
TcpClient tcpClient = new TcpClient (IPAddress.Loopback.ToString (), 8765);
Assert.AreEqual (0, tcpClient.Available, "#B1");
Assert.IsTrue (tcpClient.Connected, "#B2");
// Assert.IsFalse (tcpClient.ExclusiveAddressUse, "#B3");
tcpClient.Close ();
Assert.IsNull (tcpClient.Client, "#B4");
try {
int available = tcpClient.Available;
Assert.Fail ("#B5: " + available);
} catch (NullReferenceException) {
}
try {
bool connected = tcpClient.Connected;
Assert.Fail ("#B6: " + connected);
} catch (NullReferenceException) {
}
// not supported on linux
/*
try {
bool exclusive = tcpClient.ExclusiveAddressUse;
Assert.Fail ("#B7: " + exclusive);
} catch (NullReferenceException) {
}
*/
}
}
[Test] // bug #81886
public void FaultTest ()
{
IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 5000);
using (SocketResponder sr = new SocketResponder (localEP, s => FaultResponse_Qualified (s))) {
FooService service = new FooService ();
service.Url = "http://" + IPAddress.Loopback.ToString () + ":5000/";
try {
service.Run ();
Assert.Fail ("#A1");
} catch (SoapException ex) {
Assert.AreEqual ("Mono Web Service", ex.Actor, "#A2");
Assert.AreEqual (SoapException.ServerFaultCode, ex.Code, "#A3");
Assert.IsNotNull (ex.Detail, "#A4");
Assert.AreEqual ("detail", ex.Detail.LocalName, "#A5");
Assert.AreEqual ("http://schemas.xmlsoap.org/soap/envelope/", ex.Detail.NamespaceURI, "#A6");
XmlNamespaceManager nsMgr = new XmlNamespaceManager (ex.Detail.OwnerDocument.NameTable);
nsMgr.AddNamespace ("se", "http://www.mono-project/System");
XmlElement systemError = (XmlElement) ex.Detail.SelectSingleNode (
"se:systemerror", nsMgr);
Assert.IsNotNull (systemError, "#A7");
Assert.IsNull (ex.InnerException, "#A8");
Assert.AreEqual ("Failure processing request.", ex.Message, "#A9");
}
service.Dispose ();
}
using (SocketResponder sr = new SocketResponder (localEP, s => FaultResponse_Unqualified (s))) {
FooService service = new FooService ();
service.Url = "http://" + IPAddress.Loopback.ToString () + ":5000/";
try {
service.Run ();
Assert.Fail ("#B1");
} catch (SoapException ex) {
Assert.AreEqual ("Mono Web Service", ex.Actor, "#B2");
Assert.AreEqual (SoapException.ServerFaultCode, ex.Code, "#B3");
Assert.IsNotNull (ex.Detail, "#B4");
Assert.AreEqual ("detail", ex.Detail.LocalName, "#B5");
Assert.AreEqual (string.Empty, ex.Detail.NamespaceURI, "#B6");
XmlNamespaceManager nsMgr = new XmlNamespaceManager (ex.Detail.OwnerDocument.NameTable);
nsMgr.AddNamespace ("se", "http://www.mono-project/System");
XmlElement systemError = (XmlElement) ex.Detail.SelectSingleNode (
"se:systemerror", nsMgr);
Assert.IsNotNull (systemError, "#B7");
Assert.IsNull (ex.InnerException, "#B8");
Assert.AreEqual ("Failure processing request.", ex.Message, "#B9");
}
service.Dispose ();
}
}
private SocketIdentity GetIdentity(SocketResponder responder)
{
lock (ClientIdentitiesLock)
{
try
{
return(ClientIdentities[responder]);
}
catch (Exception)
{
return(SocketIdentity.None);
}
}
}
/// <summary>
/// 应在 ReceiveData() 最开始调用
/// 接收 KeyBytes, 调用 CheckIdentity();
/// 向 Dictionary 添加 SocketResponder 权限;
/// 并向 Client 端返回 SocketIdentity
/// </summary>
/// <param name="responder"></param>
private void ResponseIdentity(SocketResponder responder)
{
responder.ReceiveBytes(out HB32Header header, out byte[] bytes);
SocketIdentityCheckEventArgs e = new SocketIdentityCheckEventArgs(header, bytes);
CheckIdentity(this, e);
SocketIdentity identity = e.CheckedIndentity;
lock (ClientIdentitiesLock)
{
ClientIdentities.Add(responder, identity);
}
responder.SendHeader(SocketPacketFlag.AuthenticationResponse, i1: (int)identity);
}
[Test] // bug #79988
public void OutParametersTest ()
{
IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 5000);
using (SocketResponder sr = new SocketResponder (localEP, s => OutParametersResponse (s))) {
FooService service = new FooService ();
service.Url = "http://" + IPAddress.Loopback.ToString () + ":5000/";
int a;
bool b;
Elem [] e = service.Req ("x", out a, out b);
Assert.IsNull (e, "#A1");
Assert.AreEqual (0, a, "#A2");
Assert.IsFalse (b, "#A3");
service.Dispose ();
}
}
public void Close_Disposed ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
((IDisposable) resp).Dispose ();
resp.Close ();
}
}
/// <summary>
/// 相应 client 端的 fsid 请求
/// 文件占用 (文件活跃时间超时被自动清除) 时返回对应 fsid , 否则生成新fsid并返回
/// 记录在 ServerFileSet 中
/// </summary>
/// <param name="client"></param>
/// <param name="header">依据header判断上传/下载</param>
/// <param name="bytes"></param>
private void ResponseFileStreamId(SocketResponder responder, HB32Header header, byte[] bytes)
{
string err_msg = "";
SocketPacketFlag mask = header.Flag & (SocketPacketFlag)(1 << 8);
int fsid = -1;
try
{
SocketIdentity required_identity = (mask > 0) ? SocketIdentity.WriteFile : SocketIdentity.ReadFile;
if ((GetIdentity(responder) & required_identity) == 0)
{
throw new Exception("Socket not authenticated.");
}
string path = Encoding.UTF8.GetString(bytes);
if (IsFileOccupying(path, out fsid))
{
;
}
else
{
FileInfo fif = new FileInfo(path);
FileStream fs = new FileStream(path, FileMode.OpenOrCreate, (mask > 0) ? FileAccess.Write : FileAccess.Read);
SocketServerFileStreamInfo record = new SocketServerFileStreamInfo
{
FStream = fs,
ServerPath = path,
Length = fif.Length,
};
fsid = GenerateRandomFileStreamId(1 << 16);
ServerFileSet.Add(fsid, record);
}
}
catch (Exception ex)
{
err_msg = ex.Message;
}
if (string.IsNullOrEmpty(err_msg))
{
responder.SendBytes(SocketPacketFlag.DownloadAllowed | mask, fsid.ToString());
}
else
{
responder.SendBytes(SocketPacketFlag.DownloadDenied | mask, err_msg);
}
}
static void Main ()
{
IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 5000);
using (SocketResponder sr = new SocketResponder (localEP, new SocketRequestHandler (Response_Bug79988))) {
sr.Start ();
FooService service = new FooService ();
service.Url = "http://" + IPAddress.Loopback.ToString () + ":5000/";
int a;
bool b;
Elem [] e = service.Req ("x", out a, out b);
Assert.IsNull (e, "#A1");
Assert.AreEqual (0, a, "#A2");
Assert.IsFalse (b, "#A3");
}
}
static int Run (IPEndPoint ep)
{
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
HttpWebRequest req;
Stream rs;
req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "POST";
req.ContentLength = 2;
rs = req.GetRequestStream ();
rs.WriteByte (0x0d);
try {
rs.Close ();
return 1;
} catch (WebException) {
}
req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "POST";
req.ContentLength = 2;
rs = req.GetRequestStream ();
rs.WriteByte (0x0d);
try {
rs.Close ();
return 2;
} catch (WebException) {
}
req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "POST";
req.ContentLength = 2;
rs = req.GetRequestStream ();
rs.WriteByte (0x0d);
rs.WriteByte (0x0d);
rs.Close ();
req.Abort ();
responder.Stop ();
}
return 0;
}
public void ReversedServerListen()
{
maintainer.StartLongConnection();
try
{
while (flag_listen)
{
SocketResponder responder = maintainer.Accept();
Thread th_receive = new Thread(ReceiveData);
th_receive.IsBackground = true;
th_receive.Start(responder);
Thread.Sleep(20);
}
}
catch (Exception ex)
{
Log("ReversedServerListen() exception: " + ex.Message, LogLevel.Error);
}
}
public void ServerListen()
{
try
{
while (flag_listen)
{
Socket client = server.Accept();
SocketResponder responder = new SocketResponder(client);
Thread th_receive = new Thread(ReceiveData);
th_receive.IsBackground = true;
th_receive.Start(responder);
Thread.Sleep(20);
}
}
catch (Exception ex)
{
Log("ServerListen() exception: " + ex.Message, LogLevel.Error);
}
}
static void Main ()
{
IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 5000);
using (SocketResponder sr = new SocketResponder (localEP, new SocketRequestHandler (Response_Bug80131))) {
sr.Start ();
FooService service = new FooService ();
service.Url = "http://" + sr.LocalEndPoint.Address.ToString () + ":5000/";
int a;
bool b;
Elem [] e = service.Req ("x", out a, out b);
Assert.IsNotNull (e, "#B1");
Assert.AreEqual (1, e.Length, "#B2");
Assert.AreEqual ("whatever", e [0].attr, "#B2");
Assert.AreEqual (5, a, "#B3");
Assert.IsTrue (b, "#B4");
}
}
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
public void UploadValues1 ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => EchoRequestHandler (s))) {
WebClient wc = new WebClient ();
wc.Encoding = Encoding.ASCII;
NameValueCollection nvc = new NameValueCollection ();
nvc.Add ("Name", "\u0041\u2262\u0391\u002E");
nvc.Add ("Address", "\u002E\u2262\u0041\u0391");
byte [] buffer = wc.UploadValues (url, nvc);
string response = Encoding.UTF8.GetString (buffer);
Assert.AreEqual ("Name=A%e2%89%a2%ce%91.&Address=.%e2%89%a2A%ce%91\r\n", response);
}
}
public void BeginWrite ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => HttpWebResponseTest.FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
byte [] buffer = new byte [5];
try {
rs.BeginWrite (buffer, 0, buffer.Length, null, null);
Assert.Fail ("#1");
} catch (NotSupportedException ex) {
// The stream does not support writing
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
} finally {
rs.Close ();
req.Abort ();
}
}
}
}
public void Read_Offset_Overflow ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => HttpWebResponseTest.FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
byte [] buffer = new byte [5];
try {
try {
rs.Read (buffer, buffer.Length + 1, 0);
Assert.Fail ("#A1");
} catch (ArgumentOutOfRangeException ex) {
// Specified argument was out of the range of valid values
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
Assert.AreEqual ("offset", ex.ParamName, "#A5");
}
// read full response
buffer = new byte [24];
Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
try {
rs.Read (buffer, buffer.Length + 1, 0);
Assert.Fail ("#B1");
} catch (ArgumentOutOfRangeException ex) {
// Specified argument was out of the range of valid values
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
Assert.AreEqual ("offset", ex.ParamName, "#B5");
}
} finally {
rs.Close ();
req.Abort ();
}
}
}
}
private void ResponseDownloadPacket(SocketResponder responder, HB32Header header)
{
byte[] responseBytes = new byte[1];
string err_msg = "";
int i1 = 0;
try
{
if ((GetIdentity(responder) & SocketIdentity.ReadFile) == 0)
{
throw new Exception("Socket not authenticated.");
}
if (!ServerFileSet.ContainsKey(header.I1))
{
i1 = 1;
throw new Exception("No fsid key in available server filestream");
}
SocketServerFileStreamInfo fs_info = ServerFileSet[header.I1];
FileStream fs = fs_info.FStream;
/// I2 == -1 则关闭 FileStream
if (header.I2 == -1)
{
fs.Close();
ServerFileSet.Remove(header.I1);
Log("Released file id : " + header.I1.ToString(), LogLevel.Info);
return;
}
/// 确定 Server 端 FileStream 读起点和 byte 长度
long begin = (long)header.I2 * HB32Encoding.DataSize;
int length = HB32Encoding.DataSize; /// <- 读/写 byte长度
if (begin + HB32Encoding.DataSize > fs_info.Length)
{
length = (int)(fs_info.Length - begin);
}
responseBytes = new byte[length];
/// 读取 FileStream bytes
lock (fs)
{
fs.Seek(begin, SeekOrigin.Begin);
fs.Read(responseBytes, 0, length);
}
fs_info.LastTime = DateTime.Now;
}
catch (Exception ex)
{
err_msg = ex.Message;
Log("ResponseDownloadPacket exception : " + err_msg, LogLevel.Warn);
}
if (string.IsNullOrEmpty(err_msg))
{
responder.SendBytes(SocketPacketFlag.DownloadPacketResponse, responseBytes);
}
else
{
responder.SendBytes(SocketPacketFlag.DownloadDenied, err_msg, i1: i1);
}
}
public void Read ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => HttpWebResponseTest.FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
byte [] buffer = new byte [5];
try {
Assert.AreEqual (1, rs.Read (buffer, 4, 1), "#A1");
Assert.AreEqual (new byte [] { 0x00, 0x00, 0x00, 0x00, 0x3c }, buffer, "#A2");
Assert.AreEqual (2, rs.Read (buffer, 0, 2), "#B1");
Assert.AreEqual (new byte [] { 0x64, 0x75, 0x00, 0x00, 0x3c }, buffer, "#B2");
Assert.AreEqual (4, rs.Read (buffer, 1, 4), "#C1");
Assert.AreEqual (new byte [] { 0x64, 0x6d, 0x6d, 0x79, 0x20 }, buffer, "#C2");
Assert.AreEqual (2, rs.Read (buffer, 0, 3), "#D1");
Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#D2");
Assert.AreEqual (0, rs.Read (buffer, 1, 3), "#E1");
Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#E2");
Assert.AreEqual (0, rs.Read (buffer, buffer.Length, 0), "#G1");
Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#G2");
} finally {
rs.Close ();
req.Abort ();
}
}
}
}
public void Headers_Disposed ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
((IDisposable) resp).Dispose ();
WebHeaderCollection headers = resp.Headers;
Assert.AreEqual (6, headers.Count, "#1");
Assert.AreEqual ("9", headers ["Content-Length"], "#2");
Assert.AreEqual ("utf-8", headers ["Content-Encoding"], "#3");
Assert.AreEqual ("text/xml; charset=UTF-8", headers ["Content-Type"], "#4");
Assert.AreEqual ("Wed, 08 Jan 2003 23:11:55 GMT", headers ["Last-Modified"], "#5");
Assert.AreEqual ("UserID=Miguel,StoreProfile=true", headers ["Set-Cookie"], "#6");
Assert.AreEqual ("Mono/Test", headers ["Server"], "#7");
}
}
public void Cookies_Disposed ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
responder.Start ();
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
((IDisposable) resp).Dispose ();
try {
CookieCollection cookies = resp.Cookies;
Assert.Fail ("#A1:" + cookies);
} catch (ObjectDisposedException ex) {
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#A5");
}
try {
resp.Cookies = new CookieCollection ();
Assert.Fail ("#B1");
} catch (ObjectDisposedException ex) {
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#B5");
}
}
}
public void Read_Stream_Closed ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => HttpWebResponseTest.FullResponseHandler (s))) {
HttpWebRequest req;
req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
rs.Close ();
try {
rs.Read (new byte [0], 0, 0);
Assert.Fail ("#A1");
} catch (WebException ex) {
// The request was aborted: The connection was closed unexpectedly
Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
Assert.IsNull (ex.Response, "#A5");
Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#A6");
} finally {
rs.Close ();
req.Abort ();
}
}
req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
byte [] buffer = new byte [24];
Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
rs.Close ();
try {
rs.Read (new byte [0], 0, 0);
Assert.Fail ("#B1");
} catch (WebException ex) {
// The request was aborted: The connection was closed unexpectedly
Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
Assert.IsNull (ex.Response, "#B5");
Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#B6");
} finally {
rs.Close ();
req.Abort ();
}
}
}
}
public void UploadAsyncCancelEventTest (int port, Action<WebClient, Uri, EventWaitHandle> uploadAction)
{
var ep = NetworkHelpers.LocalEphemeralEndPoint ();
string url = "http://" + ep.ToString() + "/test/";
using (var responder = new SocketResponder (ep, s => EchoRequestHandler (s)))
{
var webClient = new WebClient ();
var cancellationTokenSource = new CancellationTokenSource ();
cancellationTokenSource.Token.Register (webClient.CancelAsync);
var cancelEvent = new ManualResetEvent (false);
uploadAction.Invoke (webClient, new Uri (url), cancelEvent);
cancellationTokenSource.Cancel ();
Assert.IsTrue (cancelEvent.WaitOne (1000));
}
}
/// <summary>
/// 在 Socket.accept() 获取到的 client 在这里处理
/// 这个函数为 client 的整个生存周期
/// </summary>
/// <param name="responderObject">client socket</param>
protected override void ReceiveData(object responderObject)
{
SocketResponder responder = responderObject as SocketResponder;
responder.SetTimeout(Config.SocketSendTimeOut, Config.SocketReceiveTimeOut);
try
{
ResponseIdentity(responder);
int error_count = 0;
while (flag_receive & error_count < 5)
{
try
{
responder.ReceiveBytes(out HB32Header header, out byte[] bytes);
switch (header.Flag)
{
case SocketPacketFlag.DirectoryRequest:
ResponseDirectory(responder, bytes);
break;
case SocketPacketFlag.DirectorySizeRequest:
ResponseDirectorySize(responder, bytes);
break;
case SocketPacketFlag.CreateDirectoryRequest:
ResponseCreateDirectory(responder, bytes);
break;
#region download
case SocketPacketFlag.DownloadRequest:
ResponseDownloadSmallFile(responder, bytes);
break;
case SocketPacketFlag.DownloadFileStreamIdRequest:
ResponseFileStreamId(responder, header, bytes);
break;
case SocketPacketFlag.DownloadPacketRequest:
ResponseTransferPacket(responder, header, bytes);
break;
#endregion
#region upload
case SocketPacketFlag.UploadRequest:
ResponseUploadSmallFile(responder, bytes);
break;
case SocketPacketFlag.UploadFileStreamIdRequest:
ResponseFileStreamId(responder, header, bytes);
break;
case SocketPacketFlag.UploadPacketRequest:
ResponseTransferPacket(responder, header, bytes);
break;
#endregion
case SocketPacketFlag.DisconnectRequest:
DisposeClient(responder);
return;
default:
throw new Exception("Invalid socket header in receiving: " + header.Flag.ToString());
}
error_count = 0;
}
catch (SocketException ex)
{
error_count++;
switch (ex.ErrorCode)
{
// 远程 client 主机关闭连接
case 10054:
DisposeClient(responder);
Log("Connection closed (client closed). " + ex.Message, LogLevel.Info);
return;
// Socket 超时
case 10060:
Thread.Sleep(200);
Log("Socket timeout. " + ex.Message, LogLevel.Trace);
continue;
default:
Log("Server receive data :" + ex.Message, LogLevel.Warn);
continue;
}
}
catch (Exception ex)
{
error_count++;
if (ex.Message.Contains("Buffer receive error: cannot receive package"))
{
DisposeClient(responder);
Log(ex.Message, LogLevel.Trace);
return;
}
if (ex.Message.Contains("Invalid socket header"))
{
DisposeClient(responder);
Log("Connection closed : " + ex.Message, LogLevel.Warn);
return;
}
Log("Server exception :" + ex.Message, LogLevel.Warn);
Thread.Sleep(200);
continue;
}
}
Log("Connection closed.", LogLevel.Warn);
}
catch (Exception ex)
{
Log("Identity authentication exception :" + ex.Message, LogLevel.Error);
ClientIdentities.Remove(responder);
}
}
public void CloseTest()
{
IPEndPoint localEP = new IPEndPoint(IPAddress.Loopback, 8765);
using (SocketResponder sr = new SocketResponder(localEP, new SocketRequestHandler(CloseRequestHandler))) {
sr.Start();
TcpClient tcpClient = new TcpClient(IPAddress.Loopback.ToString(), 8765);
NetworkStream ns = tcpClient.GetStream();
Assert.IsNotNull(ns, "#A1");
#if NET_2_0
Assert.AreEqual(0, tcpClient.Available, "#A2");
Assert.IsTrue(tcpClient.Connected, "#A3");
// Assert.IsFalse (tcpClient.ExclusiveAddressUse, "#A4");
#endif
tcpClient.Close();
#if NET_2_0
Assert.IsNotNull(tcpClient.Client, "#A5");
try {
int available = tcpClient.Available;
Assert.Fail("#A6: " + available);
} catch (ObjectDisposedException) {
}
Assert.IsFalse(tcpClient.Connected, "#A7");
// not supported on linux
/*
* try {
* bool exclusive = tcpClient.ExclusiveAddressUse;
* Assert.Fail ("#A8: " + exclusive);
* } catch (ObjectDisposedException) {
* }
*/
#endif
}
using (SocketResponder sr = new SocketResponder(localEP, new SocketRequestHandler(CloseRequestHandler))) {
sr.Start();
TcpClient tcpClient = new TcpClient(IPAddress.Loopback.ToString(), 8765);
#if NET_2_0
Assert.AreEqual(0, tcpClient.Available, "#B1");
Assert.IsTrue(tcpClient.Connected, "#B2");
// Assert.IsFalse (tcpClient.ExclusiveAddressUse, "#B3");
#endif
tcpClient.Close();
#if NET_2_0
Assert.IsNull(tcpClient.Client, "#B4");
try {
int available = tcpClient.Available;
Assert.Fail("#B5: " + available);
} catch (NullReferenceException) {
}
try {
bool connected = tcpClient.Connected;
Assert.Fail("#B6: " + connected);
} catch (NullReferenceException) {
}
// not supported on linux
/*
* try {
* bool exclusive = tcpClient.ExclusiveAddressUse;
* Assert.Fail ("#B7: " + exclusive);
* } catch (NullReferenceException) {
* }
*/
#endif
}
}
public void CanWrite ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, s => HttpWebResponseTest.FullResponseHandler (s))) {
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
try {
Assert.IsFalse (rs.CanWrite, "#1");
rs.Close ();
Assert.IsFalse (rs.CanWrite, "#2");
} finally {
rs.Close ();
req.Abort ();
}
}
}
}
public void Read_Buffer_Null ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
responder.Start ();
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
Stream rs = resp.GetResponseStream ();
byte [] buffer = null;
try {
try {
rs.Read (buffer, 0, 0);
Assert.Fail ("#A1");
} catch (ArgumentNullException ex) {
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
Assert.AreEqual ("buffer", ex.ParamName, "#A5");
}
// read full response
buffer = new byte [24];
Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
buffer = null;
try {
rs.Read (buffer, 0, 0);
Assert.Fail ("#B1");
} catch (ArgumentNullException ex) {
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
Assert.AreEqual ("buffer", ex.ParamName, "#B5");
}
} finally {
rs.Close ();
req.Abort ();
}
}
}
}
public void StatusCode_Disposed ()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
responder.Start ();
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
((IDisposable) resp).Dispose ();
Assert.AreEqual (HttpStatusCode.OK, resp.StatusCode);
}
}
