private static void doUpdate(object paramArray)
{
object[] parameters = paramArray as object[];
long ownerCID = 0;
try
{
string newDisplayName = parameters[0].ToString();
ownerCID = (long)parameters[1];
string authToken = parameters[2].ToString();
ConnectivitySettings connectivitySettings = (ConnectivitySettings)parameters[3];
EventHandler <AtomRequestSucceedEventArgs> onSuccessHandler = parameters[4] as EventHandler <AtomRequestSucceedEventArgs>;
entryType returnEntry = LiveAtomAPILight.UpdatePersonalStatus(newDisplayName, ownerCID, authToken, connectivitySettings);
if (onSuccessHandler != null)
{
onSuccessHandler(ownerCID, new AtomRequestSucceedEventArgs(returnEntry));
}
}
catch (Exception ex)
{
EventHandler <ExceptionEventArgs> onErrorHandler = parameters[5] as EventHandler <ExceptionEventArgs>;
if (onErrorHandler != null)
{
onErrorHandler(ownerCID, new ExceptionEventArgs(ex));
}
}
}
public static SftpClient GenerateBasicSftpClient()
{
ConnectivitySettings connectivitySettingsFromConfig = CreateConnectivitySettingsFromConfig();
SftpClient testSftpClient = new SftpClient(connectivitySettingsFromConfig.Host, connectivitySettingsFromConfig.Port, connectivitySettingsFromConfig.UserName, connectivitySettingsFromConfig.Password);
return(testSftpClient);
}
private static TCPv1Bridge ListenForDirectConnection(
Contact remote,
Guid remoteGuid,
NSMessageHandler nsMessageHandler,
P2PVersion ver,
P2PSession startupSession,
IPAddress host, int port, Guid replyGuid, Guid remoteNonce, bool hashed)
{
ConnectivitySettings cs = new ConnectivitySettings();
if (nsMessageHandler.ConnectivitySettings.LocalHost == string.Empty)
{
cs.LocalHost = host.ToString();
cs.LocalPort = port;
}
else
{
cs.LocalHost = nsMessageHandler.ConnectivitySettings.LocalHost;
cs.LocalPort = nsMessageHandler.ConnectivitySettings.LocalPort;
}
TCPv1Bridge tcpBridge = new TCPv1Bridge(cs, ver, replyGuid, remoteNonce, hashed, startupSession, nsMessageHandler, remote, remoteGuid);
tcpBridge.Listen(IPAddress.Parse(cs.LocalHost), cs.LocalPort);
Trace.WriteLineIf(Settings.TraceSwitch.TraceInfo, "Listening on " + cs.LocalHost + ":" + cs.LocalPort.ToString(CultureInfo.InvariantCulture));
return(tcpBridge);
}
public void UploadFileTest_privateKeyConnection_canUploadFile()
{
// arrange
ConnectivitySettings connectivitySettings = SftpTestsHelperRoutines.CreateConnectivitySettingsFromConfig();
string physicalPathToPrivateKeyFile = SftpTestsHelperRoutines.GetTestFilesPath() + connectivitySettings.PrivateKeyPath;
connectivitySettings.PrivateKeyPath = physicalPathToPrivateKeyFile;
DotNetSftpClient dotNetSftpClient = new DotNetSftpClient(connectivitySettings, testLogger);
dotNetSftpClient.CreateConnection();
// act/assert - 'assert' as in no exceptions are thrown
string newTempFilePath = Path.GetTempFileName();
TransferSettings transferSettings = new TransferSettings()
{
TransferType = 'u',
DestinationPath = string.Empty,
SourcePath = newTempFilePath
};
// act/assert - 'assert' as in no exceptions are thrown
using (dotNetSftpClient)
{
dotNetSftpClient.Upload(transferSettings);
}
}
public HttpSocketMessageProcessor(ConnectivitySettings connectivitySettings, MessagePool messagePool)
: base(connectivitySettings, messagePool)
{
gatewayIP = connectivitySettings.Host;
host = gatewayIP;
pollTimer.Elapsed += pollTimer_Elapsed;
pollTimer.AutoReset = true;
}
internal static void UpdatePersonalStatusAsync(string newDisplayName, long ownerCID, string authToken,
ConnectivitySettings connectivitySettings,
EventHandler <AtomRequestSucceedEventArgs> onSucceed,
EventHandler <ExceptionEventArgs> onError)
{
Thread workingThread = new Thread(new ParameterizedThreadStart(doUpdate));
workingThread.Start(new object[] { newDisplayName, ownerCID, authToken, connectivitySettings, onSucceed, onError });
}
public override void Send(byte[] outgoingData, object userState)
{
if (opened || (null != (outgoingData = GetOpenOrClosePacket(outgoingData))))
{
if (isWebRequestInProcess)
{
lock (SyncObject)
{
sendingQueue.Enqueue(new QueueState(outgoingData, userState));
action = HttpPollAction.None;
}
}
else
{
isWebRequestInProcess = true;
HttpPollAction oldAction = action;
lock (SyncObject)
{
action = HttpPollAction.None;
if (pollTimer.Enabled)
{
pollTimer.Stop();
}
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(GenerateURI(oldAction));
ConnectivitySettings.SetupWebRequest(request);
request.Accept = "*/*";
request.Method = "POST";
request.KeepAlive = true;
request.AllowAutoRedirect = false;
request.AllowWriteStreamBuffering = false;
request.ContentLength = outgoingData.Length;
request.Headers.Add("Pragma", "no-cache");
// Set timeouts (10+40=50) = PNG average interval
request.Timeout = 10000; // 10 seconds for GetRequestStream(). Timeout error occurs when the server is busy.
request.ReadWriteTimeout = 40000; // 40 seconds for Read()/Write(). PNG interval is 45-60, so timeout must be <= 40.
// Bypass msnp blockers
request.ContentType = "text/html; charset=UTF-8";
request.UserAgent = @"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.65 Safari/535.11";
request.Headers.Add("X-Requested-Session-Content-Type", "text/html");
// Enable GZIP
request.AutomaticDecompression = Settings.EnableGzipCompressionForWebServices ? DecompressionMethods.GZip : DecompressionMethods.None;
// Don't block current thread.
HttpState httpState = new HttpState(request, outgoingData, userState, oldAction);
request.BeginGetRequestStream(EndGetRequestStreamCallback, httpState);
}
}
}
public void CreateConnectionTest_tooFewConnectionSettings()
{
// arrange
ConnectivitySettings connectivitySettings = new ConnectivitySettings();
connectivitySettings.Host = "foobar";
DotNetSftpClient dotNetSftpClient = new DotNetSftpClient(connectivitySettings, NullLogger.Instance);
// act/assert
dotNetSftpClient.CreateConnection();
}
public void OnlineConnectivityTest_canConnect_usernameAndPassword()
{
// arrange
ConnectivitySettings connectivitySettings = SftpTestsHelperRoutines.CreateConnectivitySettingsFromConfig();
connectivitySettings.PrivateKeyPath = string.Empty;
DotNetSftpClient dotNetSftpClient = new DotNetSftpClient(connectivitySettings, testLogger);
// act/assert - 'assert' as in no exceptions are thrown
using (dotNetSftpClient)
{
dotNetSftpClient.CreateConnection();
}
}
private static void DoDownload(object param)
{
object[] paramlist = param as object[];
string usertileURL = paramlist[0].ToString();
EventHandler <ObjectEventArgs> callBack = paramlist[1] as EventHandler <ObjectEventArgs>;
ConnectivitySettings connectivitySettings = paramlist[2] as ConnectivitySettings;
try
{
Uri uri = new Uri(usertileURL);
HttpWebRequest fwr = (HttpWebRequest)WebRequest.Create(uri);
if (connectivitySettings != null)
{
connectivitySettings.SetupWebRequest(fwr);
}
fwr.Timeout = 10000;
fwr.BeginGetResponse(delegate(IAsyncResult result)
{
try
{
Stream stream = ((WebRequest)result.AsyncState).EndGetResponse(result).GetResponseStream();
MemoryStream ms = new MemoryStream();
byte[] data = new byte[8192];
int read;
while ((read = stream.Read(data, 0, data.Length)) > 0)
{
ms.Write(data, 0, read);
}
stream.Close();
if (callBack != null)
{
callBack(fwr, new ObjectEventArgs(ms.ToArray()));
}
}
catch (Exception ex)
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceError, "[HttpDataDownloader] Error: " + ex.Message);
}
}, fwr);
}
catch (Exception ex)
{
Trace.WriteLine("[HttpDataDownloader] Error: " + ex.Message);
}
}
public void OnlineConnectivityTest_ThrowsConnectionError()
{
// arrange
ConnectivitySettings connectivitySettings = SftpTestsHelperRoutines.CreateConnectivitySettingsFromConfig();
connectivitySettings.Host = "ImPrettySureThisHostDoesntExistInAnyShapeOrForm";
connectivitySettings.PrivateKeyPath = string.Empty;
DotNetSftpClient dotNetSftpClient = new DotNetSftpClient(connectivitySettings, testLogger);
// act/assert - 'assert' as in no exceptions are thrown
using (dotNetSftpClient)
{
dotNetSftpClient.CreateConnection();
}
}
public void OnlineConnectivityTest_privateKeyConnection_canConnect()
{
// arrange
ConnectivitySettings connectivitySettings = SftpTestsHelperRoutines.CreateConnectivitySettingsFromConfig();
string physicalPathToPrivateKeyFile = SftpTestsHelperRoutines.GetTestFilesPath() + connectivitySettings.PrivateKeyPath;
connectivitySettings.PrivateKeyPath = physicalPathToPrivateKeyFile;
// act/assert - 'assert' as in no exceptions are thrown
DotNetSftpClient dotNetSftpClient = new DotNetSftpClient(connectivitySettings, testLogger);
using (dotNetSftpClient)
{
dotNetSftpClient.CreateConnection();
}
}
/// <summary>
/// Constructor.
/// </summary>
public P2PDirectProcessor(
ConnectivitySettings connectivitySettings,
P2PVersion p2pVersion,
Guid reply, Guid authNonce, bool isNeedHash,
P2PSession p2pMessageSession,
NSMessageHandler nsMessageHandler)
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceInfo, "Constructing object - " + p2pVersion, GetType().Name);
Processor = new TcpSocketMessageProcessor(connectivitySettings, new P2PDCPool());
this.version = p2pVersion;
this.nonce = authNonce;
this.reply = reply;
this.needHash = isNeedHash;
this.startupSession = p2pMessageSession;
this.nsMessageHandler = nsMessageHandler;
}
/// <summary>
/// Get the connection-info for the sftp-server from the config.
/// If no sftp-server is available for integration-tests within the organization, one option for local testing is the free 'tinysftpserver' from Rebex.
/// </summary>
/// <returns>A fully loaded ConnectivitySettings-object.</returns>
public static ConnectivitySettings CreateConnectivitySettingsFromConfig()
{
string host = ConfigurationManager.AppSettings["sftpServerHostAddress"];
string port = ConfigurationManager.AppSettings["sftpServerPortNo"];
string userName = ConfigurationManager.AppSettings["userName"];
string password = ConfigurationManager.AppSettings["password"];
string privateKeyPath = ConfigurationManager.AppSettings["privateKeyPath"];
ConnectivitySettings connectivitySettings = new ConnectivitySettings()
{
Host = host,
Port = Convert.ToInt32(port),
UserName = userName,
Password = password,
PrivateKeyPath = privateKeyPath
};
return(connectivitySettings);
}
internal static entryType UpdatePersonalStatus(string newDisplayName, long ownerCID, string authToken, ConnectivitySettings connectivitySettings)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(liveAPIBaseURL + "/Users({0})/Status".Replace("{0}", ownerCID.ToString()));
if (connectivitySettings != null)
{
connectivitySettings.SetupWebRequest(request);
}
request.Method = "POST";
request.Accept = @"application/atom+xml; type=entry";
request.ContentType = @"application/atom+xml";
request.Headers.Add(HttpRequestHeader.Authorization, "WLID1.0 " + authToken);
request.Headers.Add("AppId", appID);
entryType entry = new entryType();
if (!string.IsNullOrEmpty(newDisplayName))
{
entry.title = new entryTypeTitle();
entry.title.Value = newDisplayName;
}
XmlSerializer ser = new XmlSerializer(typeof(entryType));
MemoryStream memStream = new MemoryStream();
ser.Serialize(memStream, entry);
string xmlString = Encoding.UTF8.GetString(memStream.ToArray());
int xmlLength = Encoding.UTF8.GetByteCount(xmlString);
request.ContentLength = xmlLength;
request.GetRequestStream().Write(Encoding.UTF8.GetBytes(xmlString), 0, xmlLength);
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.CloseInput = true;
using (XmlReader xmlReader = XmlReader.Create(request.GetResponse().GetResponseStream(), readerSettings))
{
return (entryType)ser.Deserialize(xmlReader);
}
}
public TCPv1Bridge(
ConnectivitySettings connectivitySettings,
P2PVersion p2pVersion,
Guid replyNonce, Guid remoteNonce, bool isNeedHash,
P2PSession p2pSession,
NSMessageHandler ns,
Contact remote, Guid remoteEpId)
: base(0, ns)
{
this.startupSession = p2pSession;
this.remote = remote;
this.remoteEpId = remoteEpId;
directConnection = new P2PDirectProcessor(connectivitySettings, p2pVersion, replyNonce, remoteNonce, isNeedHash, p2pSession, ns);
directConnection.HandshakeCompleted += new EventHandler <EventArgs>(directConnection_HandshakeCompleted);
directConnection.P2PMessageReceived += new EventHandler <P2PMessageEventArgs>(directConnection_P2PMessageReceived);
directConnection.SendCompleted += new EventHandler <MSNPSharp.Core.ObjectEventArgs>(directConnection_SendCompleted);
directConnection.DirectNegotiationTimedOut += new EventHandler <EventArgs>(directConnection_DirectNegotiationTimedOut);
directConnection.ConnectionClosed += new EventHandler <EventArgs>(directConnection_ConnectionClosed);
directConnection.ConnectingException += new EventHandler <ExceptionEventArgs>(directConnection_ConnectingException);
directConnection.ConnectionException += new EventHandler <ExceptionEventArgs>(directConnection_ConnectionException);
}
public void UploadFileTest_usernamePasswordConnection_canUploadFile()
{
// arrange
ConnectivitySettings connectivitySettings = SftpTestsHelperRoutines.CreateConnectivitySettingsFromConfig();
connectivitySettings.PrivateKeyPath = String.Empty; // clear private key path, so we only connect via username/password
DotNetSftpClient dotNetSftpClient = new DotNetSftpClient(connectivitySettings, testLogger);
dotNetSftpClient.CreateConnection();
string newTempFilePath = Path.GetTempFileName();
TransferSettings transferSettings = new TransferSettings()
{
TransferType = 'u',
DestinationPath = " ",
SourcePath = newTempFilePath
};
// act/assert - 'assert' as in no exceptions are thrown
using (dotNetSftpClient)
{
dotNetSftpClient.Upload(transferSettings);
}
}
internal static entryType UpdatePersonalStatus(string newDisplayName, long ownerCID, string authToken, ConnectivitySettings connectivitySettings)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(liveAPIBaseURL + "/Users({0})/Status".Replace("{0}", ownerCID.ToString()));
if (connectivitySettings != null)
{
connectivitySettings.SetupWebRequest(request);
}
request.Method = "POST";
request.Accept = @"application/atom+xml; type=entry";
request.ContentType = @"application/atom+xml";
request.Headers.Add(HttpRequestHeader.Authorization, "WLID1.0 " + authToken);
request.Headers.Add("AppId", appID);
entryType entry = new entryType();
if (!string.IsNullOrEmpty(newDisplayName))
{
entry.title = new entryTypeTitle();
entry.title.Value = newDisplayName;
}
XmlSerializer ser = new XmlSerializer(typeof(entryType));
MemoryStream memStream = new MemoryStream();
ser.Serialize(memStream, entry);
string xmlString = Encoding.UTF8.GetString(memStream.ToArray());
int xmlLength = Encoding.UTF8.GetByteCount(xmlString);
request.ContentLength = xmlLength;
request.GetRequestStream().Write(Encoding.UTF8.GetBytes(xmlString), 0, xmlLength);
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.CloseInput = true;
using (XmlReader xmlReader = XmlReader.Create(request.GetResponse().GetResponseStream(), readerSettings))
{
return((entryType)ser.Deserialize(xmlReader));
}
}
internal static void UpdatePersonalStatusAsync(string newDisplayName, long ownerCID, string authToken,
ConnectivitySettings connectivitySettings,
EventHandler<AtomRequestSucceedEventArgs> onSucceed,
EventHandler<ExceptionEventArgs> onError)
{
Thread workingThread = new Thread(new ParameterizedThreadStart(doUpdate));
workingThread.Start(new object[] { newDisplayName, ownerCID, authToken, connectivitySettings, onSucceed, onError });
}
public TCPv1Bridge(
ConnectivitySettings connectivitySettings,
P2PVersion p2pVersion,
Guid replyNonce, Guid remoteNonce, bool isNeedHash,
P2PSession p2pSession,
NSMessageHandler ns,
Contact remote, Guid remoteEpId)
: base(0, ns)
{
this.startupSession = p2pSession;
this.remote = remote;
this.remoteEpId = remoteEpId;
directConnection = new P2PDirectProcessor(connectivitySettings, p2pVersion, replyNonce, remoteNonce, isNeedHash, p2pSession, ns);
directConnection.HandshakeCompleted += new EventHandler<EventArgs>(directConnection_HandshakeCompleted);
directConnection.P2PMessageReceived += new EventHandler<P2PMessageEventArgs>(directConnection_P2PMessageReceived);
directConnection.SendCompleted += new EventHandler<MSNPSharp.Core.ObjectEventArgs>(directConnection_SendCompleted);
directConnection.DirectNegotiationTimedOut += new EventHandler<EventArgs>(directConnection_DirectNegotiationTimedOut);
directConnection.ConnectionClosed += new EventHandler<EventArgs>(directConnection_ConnectionClosed);
directConnection.ConnectingException += new EventHandler<ExceptionEventArgs>(directConnection_ConnectingException);
directConnection.ConnectionException += new EventHandler<ExceptionEventArgs>(directConnection_ConnectionException);
}
protected SocketMessageProcessor(ConnectivitySettings connectivitySettings, MessagePool messagePool)
{
ConnectivitySettings = connectivitySettings;
MessagePool = messagePool;
}
public static void BeginDownload(string URL, EventHandler <ObjectEventArgs> completeCallback, ConnectivitySettings connectivitySettings)
{
Thread httpRequestThread = new Thread(new ParameterizedThreadStart(DoDownload));
httpRequestThread.Start(new object[] { URL, completeCallback, connectivitySettings });
}
private static TCPv1Bridge CreateDirectConnection(Contact remote, Guid remoteGuid, P2PVersion ver, ConnectivitySettings cs, Guid replyGuid, Guid remoteNonce, bool hashed, NSMessageHandler nsMessageHandler, P2PSession startupSession)
{
string[] points = new string[cs.EndPoints.Length];
for (int i = 0; i < points.Length; i++)
{
points[i] = cs.EndPoints[i].ToString();
}
TCPv1Bridge tcpBridge = new TCPv1Bridge(cs, ver, replyGuid, remoteNonce, hashed, startupSession, nsMessageHandler, remote, remoteGuid);
Trace.WriteLineIf(Settings.TraceSwitch.TraceInfo, "Trying to setup direct connection with remote hosts " + string.Join(",", points));
tcpBridge.Connect();
return(tcpBridge);
}
public TcpSocketMessageProcessor(ConnectivitySettings connectivitySettings, MessagePool messagePool)
: base(connectivitySettings, messagePool)
{
}
public DotNetSftpClient(ConnectivitySettings connectivitySettings, ILogger logger)
{
this._connectivitySettings = connectivitySettings;
_fileAvailabilityChecker = new FileAvailabilityChecker();
_logger = logger;
}
/// <summary>
/// Constructor.
/// </summary>
public P2PDirectProcessor(
ConnectivitySettings connectivitySettings,
P2PVersion p2pVersion,
Guid reply, Guid authNonce, bool isNeedHash,
P2PSession p2pMessageSession,
NSMessageHandler nsMessageHandler)
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceInfo, "Constructing object - " + p2pVersion, GetType().Name);
Processor = new TcpSocketMessageProcessor(connectivitySettings, new P2PDCPool());
this.version = p2pVersion;
this.nonce = authNonce;
this.reply = reply;
this.needHash = isNeedHash;
this.startupSession = p2pMessageSession;
this.nsMessageHandler = nsMessageHandler;
}
private static void ProcessDCRespInvite(SLPMessage message, NSMessageHandler ns, P2PSession startupSession)
{
MimeDictionary bodyValues = message.BodyValues;
// Check the protocol
if (bodyValues.ContainsKey("Bridge") &&
bodyValues["Bridge"].ToString() == "TCPv1" &&
bodyValues.ContainsKey("Listening") &&
bodyValues["Listening"].ToString().ToLowerInvariant().IndexOf("true") >= 0)
{
Contact remote = ns.ContactList.GetContactWithCreate(message.FromEmailAccount, IMAddressInfoType.WindowsLive);
Guid remoteGuid = message.FromEndPoint;
DCNonceType dcNonceType;
Guid remoteNonce = ParseDCNonce(message.BodyValues, out dcNonceType);
bool hashed = (dcNonceType == DCNonceType.Sha1);
Guid replyGuid = hashed ? remote.dcPlainKey : remoteNonce;
IPEndPoint[] selectedPoint = SelectIPEndPoint(bodyValues, ns);
if (selectedPoint != null && selectedPoint.Length > 0)
{
P2PVersion ver = message.P2PVersion;
// We must connect to the remote client
ConnectivitySettings settings = new ConnectivitySettings();
settings.EndPoints = selectedPoint;
remote.DirectBridge = CreateDirectConnection(remote, remoteGuid, ver, settings, replyGuid, remoteNonce, hashed, ns, startupSession);
bool needConnectingEndpointInfo;
if (bodyValues.ContainsKey("NeedConnectingEndpointInfo") &&
bool.TryParse(bodyValues["NeedConnectingEndpointInfo"], out needConnectingEndpointInfo) &&
needConnectingEndpointInfo == true)
{
IPEndPoint ipep = ((TCPv1Bridge)remote.DirectBridge).LocalEndPoint;
string desc = "stroPdnAsrddAlanretnI4vPI";
char[] rev = ipep.ToString().ToCharArray();
Array.Reverse(rev);
string ipandport = new string(rev);
SLPRequestMessage slpResponseMessage = new SLPRequestMessage(message.Source, MSNSLPRequestMethod.ACK);
slpResponseMessage.Source = message.Target;
slpResponseMessage.Via = message.Via;
slpResponseMessage.CSeq = 0;
slpResponseMessage.CallId = Guid.Empty;
slpResponseMessage.MaxForwards = 0;
slpResponseMessage.ContentType = @"application/x-msnmsgr-transdestaddrupdate";
slpResponseMessage.BodyValues[desc] = ipandport;
slpResponseMessage.BodyValues["Nat-Trav-Msg-Type"] = "WLX-Nat-Trav-Msg-Updated-Connecting-Port";
P2PMessage msg = new P2PMessage(ver);
msg.InnerMessage = slpResponseMessage;
ns.SDGBridge.Send(null, remote, remoteGuid, msg);
}
return;
}
}
if (startupSession != null)
{
startupSession.DirectNegotiationFailed();
}
}
public void InitializeTests()
{
connectivitySettings = SftpTestsHelperRoutines.CreateConnectivitySettingsFromConfig();
}
public static void BeginDownload(string URL, EventHandler<ObjectEventArgs> completeCallback, ConnectivitySettings connectivitySettings)
{
Thread httpRequestThread = new Thread(new ParameterizedThreadStart(DoDownload));
httpRequestThread.Start(new object[] { URL, completeCallback, connectivitySettings });
}
