public SmtpServer(int port, Action<MailMessage> messageHandler)
{
_processor = new SMTPProcessor(
Environment.MachineName,
new AllRecipientFilter(),
new MessageSpoolProxy(messageHandler));
_server = new SimpleServer(port, _processor.ProcessConnection);
}
public void Initialise()
{
_server = new SimpleServer(ListenPort);
_server.OnDataReceivedEvent += new SimpleServer.OnDataReceivedDelegate(_server_OnDataReceivedEvent);
_server.OnClientConnectedEvent += new SimpleServer.OnClientConnectedDelegate(_server_OnClientConnectedEvent);
_server.OnClientDisconnectEvent += new SimpleServer.OnClientDisconnectDelegate(_server_OnClientDisconnectEvent);
_server.Start();
}
static int Main (string [] args)
{
if (args.Length != 1)
return 1;
switch (args [0]) {
case "client":
SimpleClient client = new SimpleClient ();
return client.Run ();
case "server":
SimpleServer server = new SimpleServer ();
server.Run ();
return 0;
default:
return 2;
}
}
public void Writes_Response_To_Stream()
{
const string baseUrl = "http://localhost:8080/";
using (SimpleServer.Create(baseUrl, Handlers.FileHandler))
{
string tempFile = Path.GetTempFileName();
using (var writer = File.OpenWrite(tempFile))
{
var client = new RestClient(baseUrl);
var request = new RestRequest("Assets/Koala.jpg");
request.ResponseWriter = (responseStream) => responseStream.CopyTo(writer);
var response = client.DownloadData(request);
Assert.Null(response);
}
var fromTemp = File.ReadAllBytes(tempFile);
var expected = File.ReadAllBytes(Environment.CurrentDirectory + "\\Assets\\Koala.jpg");
Assert.Equal(expected, fromTemp);
}
}
public void WhenDownloadProductExtractToStreamFromExtension_ThenCheckResponse()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, ProductRequestHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
client.AuthorizeAsync("test", "password").Wait();
var request = client.CreateProductRequest();
// Act
// Assert
using (var stream = new MemoryStream())
{
request.DownloadExtractToStreamAsync(43, 1, stream, new Progress <DownloadBytesProgress>()).Wait();
Assert.Equal(57210, stream.Length);
}
}
}
public void ListInterfaceAttachmentsTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
IEnumerable <InterfaceAttachment> interfaces = osm.ListInterfaceAttachments(ss.Id);
Assert.IsNotNull(interfaces);
Trace.WriteLine(string.Format("InterfaceAttachments count : {0}", interfaces.Count()));
if (interfaces.Count() == 0)
{
osm.AddInterfaceAttachment(ss.Id, GetInterfaceAttachmentIdByTesterName());
}
foreach (var i in interfaces)
{
Trace.WriteLine(string.Format("PortId : {0}, NetId : {1}, MacAddress : {2}, PortState : {3}", i.PortId, i.NetId, i.MacAddr, i.PortState));
}
}
public void Does_Not_Pass_Default_Credentials_When_UseDefaultCredentials_Is_False()
{
const Method httpMethod = Method.GET;
using (SimpleServer.Create(BASE_URL, Handlers.Generic <RequestHeadCapturer>(), AuthenticationSchemes.Negotiate))
{
RestClient client = new RestClient(BASE_URL);
RestRequest request = new RestRequest(RequestHeadCapturer.RESOURCE, httpMethod)
{
// UseDefaultCredentials is currently false by default,
// but to make the test more robust in case that ever
// changes, it's better to explicitly set it here.
UseDefaultCredentials = false
};
IRestResponse response = client.Execute(request);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.Null(RequestHeadCapturer.CapturedHeaders);
}
}
public void WhenUnSubscribeToEventWithUnathorizedUser_ThenCheckResponse()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, EventHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
var request = client.CreateAccountEventRequest();
// Act
bool ok = request.UnSubscribeToEventAsync(new Models.Accounts.AccountEventModel {
Id = 6
}).Result;
// Assert
Assert.False(ok);
Assert.NotEmpty(request.Error.Messages);
Assert.Contains("Not connected", request.Error.Messages.First());
}
}
public void Can_Perform_GET_Async_Without_Async_Handle()
{
const string baseUrl = "http://localhost:8080/";
const string val = "Basic async test";
var resetEvent = new ManualResetEvent(false);
using (SimpleServer.Create(baseUrl, Handlers.EchoValue(val)))
{
var client = new RestClient(baseUrl);
var request = new RestRequest("");
client.ExecuteAsync(request, response =>
{
Assert.NotNull(response.Content);
Assert.Equal(val, response.Content);
resetEvent.Set();
});
resetEvent.WaitOne();
}
}
public void Can_Be_Added_To_PUT_Request()
{
const Method httpMethod = Method.PUT;
using (SimpleServer.Create(BASE_URL, Handlers.Generic <RequestBodyCapturer>()))
{
var client = new RestClient(BASE_URL);
var request = new RestRequest(RequestBodyCapturer.RESOURCE, httpMethod);
const string contentType = "text/plain";
const string bodyData = "abc123 foo bar baz BING!";
request.AddParameter(contentType, bodyData, ParameterType.RequestBody);
var resetEvent = new ManualResetEvent(false);
client.ExecuteAsync(request, response => resetEvent.Set());
resetEvent.WaitOne();
AssertHasRequestBody(contentType, bodyData);
}
}
public void CreateLBMemberTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
// get server
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
// get ipv4
ServerAddresses addresses = ss.GetDetails().ListAddresses();
Assert.IsNotNull(addresses["default_global"]);
Assert.IsTrue(addresses["default_global"].Count() > 0);
var ip = addresses["default_global"].
Where(a => a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
.First <System.Net.IPAddress>();
// create pool
string pool_name = GetTesterNameByEnv();
string TokyoLBaas_subnetId = GetSubnetIdByRegion(region: null);
int weight = 1;
string[] lbMethods = { "ROUND_ROBIN", "LEAST_CONNECTIONS" };
string protocol = "TCP";
foreach (var lbMethod in lbMethods)
{
var p = osm.CreatePool(pool_name, TokyoLBaas_subnetId, lbMethod, protocol);
try
{
string address = ip.ToString(); // ip address virtual machine is having. ?
string protocolPort = "80"; // a valid value is from 0 to 65535.
var member = osm.CreateLBMember(p.Id, address, protocolPort, weight);
Assert.IsNotNull(member);
}
finally
{
// Assert.IsTrue(os.DeletePool(p.Id));
}
}
}
public void WhenCreateAccount_ThenCheckResponse()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, AccountHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
var request = client.CreateAccountRequest();
// Act
var account = request.CreateAsync(new Models.Accounts.AccountModel {
UserName = "******", Password = "******"
}).Result;
// Assert
Assert.NotNull(account);
Assert.Equal("test", account.UserName);
Assert.Equal("CAAGp95NMpY8BAOtOD7F4gxpkrMnmUZCpPBWHyZAOcX723Pfez7VEQvrjZAtrDZCXPRC0wPZCxrC", account.YsAuthToken);
Assert.Equal("{\"Id\":0,\"UserName\":\"test\",\"Password\":\"password\",\"Email\":null,\"FirstName\":null,\"LastName\":null,\"Gender\":null,\"Civility\":null,\"BirthDate\":null,\"CountryCode\":null,\"BlogUrl\":null,\"WebSiteUrl\":null,\"FacebookPage\":null,\"TwitterPage\":null,\"City\":null,\"Biography\":null,\"PhoneNumber\":null,\"EmailIsPublic\":false,\"EmailStatus\":null,\"DomainLanguageIsoCode\":null,\"TrackingId\":\"00000000-0000-0000-0000-000000000000\",\"YsAuthToken\":null}",
requestContent);
}
}
public void WhenUploadPictureFromLocalFile_ThenCheckResponse()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, AccountHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
client.AuthorizeAsync("test", "password").Wait();
var request = client.CreateAccountRequest();
// Act
bool ok = request.UploadPictureAsync(new Models.FileModel {
Content = new MemoryStream(), ContentType = "image/png", FileName = "test.png"
}).Result;
// Assert
Assert.Contains("Content-Disposition: form-data; name=file; filename=test.png; filename*=utf-8''test.png", requestContent);
Assert.True(ok);
}
}
public void WhenGettingProductsUrls_ThenCheckResponse()
{
using (SimpleServer.Create(TestHelpers.BaseUrl, ProductRequestHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
var request = client.CreateProductRequest();
// Act
var response = request.GetProductUrlsAsync(new List <int>()
{
410820, 410821
}).Result;
Assert.Equal(410820, response.First().Id);
Assert.Equal(true, response.First().Url.Contains("410820"));
Assert.Equal(410821, response.Last().Id);
Assert.Equal(true, response.Last().Url.Contains("410821"));
}
}
public void MultipartFormDataAsync()
{
const string baseUrl = "http://localhost:8888/";
using (SimpleServer.Create(baseUrl, EchoHandler))
{
RestClient client = new RestClient(baseUrl);
RestRequest request = new RestRequest("/", Method.POST)
{
AlwaysMultipartFormData = true
};
AddParameters(request);
client.ExecuteAsync(request, (restResponse, handle) =>
{
Console.WriteLine(restResponse.Content);
Assert.AreEqual(this.expected, restResponse.Content);
});
}
}
public void AlwaysMultipartFormData_WithParameter_ExecuteTaskAsync()
{
const string baseUrl = "http://localhost:8888/";
using (SimpleServer.Create(baseUrl, EchoHandler))
{
RestClient client = new RestClient(baseUrl);
RestRequest request = new RestRequest("?json_route=/posts")
{
AlwaysMultipartFormData = true,
Method = Method.POST,
};
request.AddParameter("title", "test", ParameterType.RequestBody);
Task task = client.ExecuteTaskAsync(request)
.ContinueWith(x => { Assert.Null(x.Result.ErrorException); });
task.Wait();
}
}
public void Set_Invalid_Proxy_Fails_RAW()
{
const Method httpMethod = Method.GET;
using (SimpleServer.Create(BASE_URL_SERVER, Handlers.Generic <RequestBodyCapturer>()))
{
const string contentType = "text/plain";
const string bodyData = "abc123 foo bar baz BING!";
var requestUri = new Uri(new Uri(BASE_URL_CLIENT), RequestBodyCapturer.RESOURCE);
var webRequest = (HttpWebRequest)WebRequest.Create(requestUri);
webRequest.Proxy = new WebProxy("non_existent_proxy", false);
//webRequest.Proxy = new WebProxy("non_existing", false);
// webRequest.Proxy = HttpWebRequest.DefaultWebProxy;
Assert.Throws <WebException>(() => webRequest.GetResponse());
// Assert.False(response.IsSuccessful);
// Assert.IsInstanceOf<WebException>(response.ErrorException);
// Assert.AreEqual("The proxy name could not be resolved: 'non_existent_proxy'", response.ErrorMessage);
}
}
public void Ensure_headers_correctly_set_in_the_hook()
{
const string headerName = "HeaderName";
const string headerValue = "HeaderValue";
using var server = SimpleServer.Create(Handlers.Generic <RequestHeadCapturer>());
// Prepare
var client = new RestClient(server.Url);
var request = new RestRequest(RequestHeadCapturer.Resource)
{
OnBeforeRequest = http => http.Headers.Add(new HttpHeader(headerName, headerValue))
};
// Run
client.Execute(request);
// Assert
RequestHeadCapturer.CapturedHeaders[headerName].Should().Be(headerValue);
}
public void Can_Timeout_PUT_TaskAsync()
{
const string baseUrl = "http://localhost:8888/";
using (SimpleServer.Create(baseUrl, Handlers.Generic <ResponseHandler>()))
{
RestClient client = new RestClient(baseUrl);
IRestRequest request = new RestRequest("timeout", Method.PUT).AddBody("Body_Content");
// Half the value of ResponseHandler.Timeout
request.Timeout = 500;
Task <IRestResponse> task = client.ExecuteTaskAsync(request);
task.Wait();
IRestResponse response = task.Result;
Assert.AreEqual(ResponseStatus.TimedOut, response.ResponseStatus);
}
}
void OnGUI()
{
if (!showButton)
{
return;
}
if (GUI.Button(new Rect(100, 100, 100, 50), "Start sever"))
{
Application.targetFrameRate = 20;
SimpleServer.Start("myAppId");
showButton = false;
}
if (GUI.Button(new Rect(100, 200, 100, 50), "Start client"))
{
Application.targetFrameRate = 60;
SimpleClient.Connect("myAppId");
showButton = false;
}
}
public void ConfirmServerResizedTest_Revert_Without_Resize()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.ShutOff);
if (ss != null)
{
Server s = osm.GetServer(ss.Id);
if (s.Status == ServerState.VerifyResize)
{
osm.RevertResizeServer(s.Id);
Trace.WriteLine(String.Format("server reverted a resizing : {0}", DateTime.Now));
// wait for activate
s = osm.ServersProvider.WaitForServerActive(s.Id);
Trace.WriteLine(String.Format("server activated : {0}", DateTime.Now));
}
// expect ServiceConflictException
bool b = osm.RevertResizeServer(s.Id);
}
}
public void WhenSetUserType_ThenCheckResponse()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, AccountUserTypeHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
client.AuthorizeAsync("test", "password").Wait();
var request = client.CreateAccountUserTypeRequest();
// Act
bool ok = request.SetUserTypeAsync(new Models.Accounts.UserTypeModel {
Id = 25
}).Result;
// Assert
Assert.True(ok);
Assert.Equal("{\"Id\":25,\"Name\":null,\"Label\":null}", requestContent);
}
}
public void MultipartFormData()
{
//const string baseUrl = "http://localhost:8888/";
const string baseUrl = "http://localhost:8888/";
using (SimpleServer.Create(baseUrl, EchoHandler))
{
var client = new RestClient(baseUrl);
var request = new RestRequest("/");
request.Method = Method.POST;
request.AlwaysMultipartFormData = true;
AddParameters(request);
var response = client.Execute(request);
Console.WriteLine(response.Content);
Assert.True(response.Content == Expected);
}
}
public static IEnumerable <SimpleServer> ListAllServers(IComputeProvider provider, int?blockSize = null, string imageId = null, string flavorId = null, string name = null, ServerState status = null, DateTimeOffset?changesSince = null, string region = null, CloudIdentity identity = null)
{
if (blockSize <= 0)
{
throw new ArgumentOutOfRangeException("blockSize");
}
SimpleServer lastServer = null;
do
{
string marker = lastServer != null ? lastServer.Id : null;
IEnumerable <SimpleServer> servers = provider.ListServers(imageId, flavorId, name, status, marker, blockSize, changesSince, region, identity);
lastServer = null;
foreach (SimpleServer server in servers)
{
lastServer = server;
yield return(server);
}
} while (lastServer != null);
}
public void Should_allow_wildcard_content_types_to_be_defined()
{
Uri baseUrl = new Uri("http://localhost:8080/");
using (SimpleServer.Create(baseUrl.AbsoluteUri, QueryStringBasedContentAndContentTypeHandler))
{
var client = new RestClient(baseUrl);
// In spite of the content type, handle ALL structured syntax suffixes of "+xml" as JSON
client.AddHandler("*+xml", new JsonDeserializer());
var request = new RestRequest();
request.AddParameter("ct", "application/vnd.somebody.something+xml");
request.AddParameter("c", JsonContent);
var response = client.Execute <Person>(request);
Assert.Equal("Bob", response.Data.Name);
Assert.Equal(50, response.Data.Age);
}
}
public void Content_type_that_matches_the_structured_syntax_suffix_format_but_was_given_an_explicit_handler_should_use_supplied_deserializer()
{
Uri baseUrl = new Uri("http://localhost:8080/");
using (SimpleServer.Create(baseUrl.AbsoluteUri, QueryStringBasedContentAndContentTypeHandler))
{
var client = new RestClient(baseUrl);
// In spite of the content type (+xml), treat this specific content type as JSON
client.AddHandler("application/vnd.somebody.something+xml", new JsonDeserializer());
var request = new RestRequest();
request.AddParameter("ct", "application/vnd.somebody.something+xml");
request.AddParameter("c", JsonContent);
var response = client.Execute <Person>(request);
Assert.Equal("Bob", response.Data.Name);
Assert.Equal(50, response.Data.Age);
}
}
public void Handles_Server_Timeout_Error_Async()
{
const string baseUrl = "http://localhost:8888/";
var resetEvent = new ManualResetEvent(false);
using (SimpleServer.Create(baseUrl, TimeoutHandler))
{
var client = new RestClient(baseUrl);
var request = new RestRequest("404");
client.ExecuteAsync(request, response =>
{
Assert.NotNull(response.ErrorException);
Assert.IsAssignableFrom(typeof(WebException), response.ErrorException);
Assert.Equal(response.ErrorException.Message, "The operation has timed out");
resetEvent.Set();
});
resetEvent.WaitOne();
}
}
public void StartActiveConnection()
{
if (this.fDataConnection != null)
{
if (this.fDataConnection.Connected)
{
this.fDataConnection.Close();
}
this.fDataConnection = null;
}
if (this.fDataServer == null)
{
this.fDataServer = new SimpleServer();
this.fDataServer.Binding.Address = ((IPEndPoint)CurrentConnection.LocalEndPoint).Address;
this.fDataServer.Open();
}
Byte[] lAddress;
#if FULLFRAMEWORK
lAddress = ((IPEndPoint)this.fDataServer.Binding.ListeningSocket.LocalEndPoint).Address.GetAddressBytes();
#endif
#if COMPACTFRAMEWORK
IPAddress lIPAddress = ((IPEndPoint)this.fDataServer.Binding.ListeningSocket.LocalEndPoint).Address;
String[] lIPAddressstr = lIPAddress.ToString().Split(new Char[] { '.' });
lAddress = new Byte[lIPAddressstr.Length];
for (Int32 i = 0; i < lIPAddressstr.Length; i++)
{
lAddress[i] = Byte.Parse(lIPAddressstr[i]);
}
#endif
Int32 lPort = ((IPEndPoint)this.fDataServer.Binding.ListeningSocket.LocalEndPoint).Port;
String lPortCommand = String.Format("PORT {0},{1},{2},{3},{4},{5}", lAddress[0], lAddress[1], lAddress[2], lAddress[3], unchecked ((Byte)(lPort >> 8)), unchecked ((Byte)lPort));
if (!SendAndWaitForResponse(lPortCommand, 200))
{
throw new CmdResponseException("Error in PORT command", LastResponseNo, LastResponseText);
}
}
public void Can_Perform_GET_Async()
{
Uri baseUrl = new Uri("http://localhost:8888/");
const string val = "Basic async test";
ManualResetEvent resetEvent = new ManualResetEvent(false);
using (SimpleServer.Create(baseUrl.AbsoluteUri, Handlers.EchoValue(val)))
{
RestClient client = new RestClient(baseUrl);
RestRequest request = new RestRequest("");
client.ExecuteAsync(request, (response, asyncHandle) =>
{
Assert.NotNull(response.Content);
Assert.AreEqual(val, response.Content);
resetEvent.Set();
});
resetEvent.WaitOne();
}
}
public void WhenUpdateAccount_ThenCheckResponse()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, AccountHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
client.AuthorizeAsync("test", "password").Wait();
var request = client.CreateAccountRequest();
// Act
bool ok = request.UpdateAsync(new Models.Accounts.AccountModel {
Id = 42, FirstName = "kikou"
}).Result;
// Assert
Assert.True(ok);
Assert.Equal("{\"Id\":42,\"UserName\":null,\"Password\":null,\"Email\":null,\"FirstName\":\"kikou\",\"LastName\":null,\"Gender\":null,\"Civility\":null,\"BirthDate\":null,\"CountryCode\":null,\"BlogUrl\":null,\"WebSiteUrl\":null,\"FacebookPage\":null,\"TwitterPage\":null,\"City\":null,\"Biography\":null,\"PhoneNumber\":null,\"EmailIsPublic\":false,\"EmailStatus\":null,\"DomainLanguageIsoCode\":null,\"TrackingId\":\"00000000-0000-0000-0000-000000000000\",\"YsAuthToken\":null}",
requestContent);
}
}
static void Main(string[] args)
{
ConsoleUtils.ChangeTitle("Janus 1.1.0");
SimpleServer.DrawAscii();
Console.WriteLine(" ");
ConsoleUtils.WriteMessageInfo("Initializing all stuffs !");
SimpleServer.Initialize();
Console.WriteLine(" ");
SimpleServer authServer = new SimpleServer(ServerEnum.AuthServer);
authServer.Start(SimpleServer.AuthHost, SimpleServer.AuthPort);
SimpleServer worldServer = new SimpleServer(ServerEnum.WorldServer);
worldServer.Start(SimpleServer.WorldHost, SimpleServer.WorldPort);
SimpleServer msgServer = new SimpleServer(ServerEnum.MsgServer);
msgServer.Start(SimpleServer.MsgHost, SimpleServer.MsgPort);
SimpleServer lobbyServer = new SimpleServer(ServerEnum.LobbyServer);
lobbyServer.Start(SimpleServer.LobbyHost, SimpleServer.LobbyPort);
SimpleServer relayServer = new SimpleServer(ServerEnum.RelayServer);
relayServer.Start(SimpleServer.RelayHost, SimpleServer.RelayPort);
SimpleServer p2pServer = new SimpleServer(ServerEnum.P2PServer);
p2pServer.Start(SimpleServer.P2PHost, SimpleServer.P2PPort);
Console.ReadLine();
}
public void Can_Handle_Exception_Thrown_By_OnBeforeDeserialization_Handler()
{
const string baseUrl = "http://localhost:8888/";
const string ExceptionMessage = "Thrown from OnBeforeDeserialization";
using (SimpleServer.Create(baseUrl, Handlers.Generic <ResponseHandler>()))
{
var client = new RestClient(baseUrl);
var request = new RestRequest("success");
request.OnBeforeDeserialization += r =>
{
throw new Exception(ExceptionMessage);
};
var task = client.ExecuteTaskAsync <Response>(request);
task.Wait();
var response = task.Result;
Assert.Equal(ExceptionMessage, response.ErrorMessage);
Assert.Equal(ResponseStatus.Error, response.ResponseStatus);
}
}
public void WhenGeneratePrivateEmbedIframeTagWithFeatures_ThenCheckCode()
{
// Arrange
using (SimpleServer.Create(TestHelpers.BaseUrl, GenerateEmbledHandler))
{
var client = new YouScribeClient(TestHelpers.BaseUrl);
client.AuthorizeAsync("test", "password").Wait();
var request = client.CreateEmbedRequest();
int productId = 1;
// Act
var tag = request.GeneratePrivateIframeTagAsync(productId, new Models.Products.PrivateEmbedGenerateModel {
Width = 600, Height = 300, AccessPeriod = "1d"
}).Result;
// Assert
Assert.NotEmpty(tag);
Assert.Equal("embed4", tag);
}
}
public void StartActiveConnection()
{
if (this.fDataConnection != null)
{
if (this.fDataConnection.Connected)
this.fDataConnection.Close();
this.fDataConnection = null;
}
if (this.fDataServer == null)
{
this.fDataServer = new SimpleServer();
this.fDataServer.Binding.Address = ((IPEndPoint)CurrentConnection.LocalEndPoint).Address;
this.fDataServer.Open();
}
Byte[] lAddress;
#if FULLFRAMEWORK
lAddress = ((IPEndPoint)this.fDataServer.Binding.ListeningSocket.LocalEndPoint).Address.GetAddressBytes();
#endif
#if COMPACTFRAMEWORK
IPAddress lIPAddress = ((IPEndPoint)this.fDataServer.Binding.ListeningSocket.LocalEndPoint).Address;
String[] lIPAddressstr = lIPAddress.ToString().Split(new Char[] {'.'});
lAddress = new Byte[lIPAddressstr.Length];
for (Int32 i = 0; i < lIPAddressstr.Length; i++)
lAddress[i] = Byte.Parse(lIPAddressstr[i]);
#endif
Int32 lPort = ((IPEndPoint)this.fDataServer.Binding.ListeningSocket.LocalEndPoint).Port;
String lPortCommand = String.Format("PORT {0},{1},{2},{3},{4},{5}", lAddress[0], lAddress[1], lAddress[2], lAddress[3], unchecked((Byte)(lPort >> 8)), unchecked((Byte)lPort));
if (!SendAndWaitForResponse(lPortCommand, 200))
throw new CmdResponseException("Error in PORT command", LastResponseNo, LastResponseText);
}
private void RetrieveDataConnection()
{
if (!this.Passive)
{
if (this.fDataServer == null)
throw new Exception("DataServer is not assigned");
Connection lConnection = this.fDataServer.WaitForConnection();
this.fDataServer.Close();
this.fDataServer = null;
this.fDataConnection = lConnection;
this.fDataConnection.Encoding = this.Encoding;
}
}
