mirror of
https://github.com/Ylianst/MeshCentralRouter
synced 2025-12-06 00:13:33 +00:00
1856 lines
82 KiB
C#
1856 lines
82 KiB
C#
/*
|
|
Copyright 2009-2021 Intel Corporation
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Drawing;
|
|
using System.Collections;
|
|
using System.Windows.Forms;
|
|
using System.Collections.Generic;
|
|
using System.Security.Cryptography;
|
|
using System.Web.Script.Serialization;
|
|
|
|
namespace MeshCentralRouter
|
|
{
|
|
public partial class FileViewer : Form
|
|
{
|
|
private MeshCentralServer server = null;
|
|
private NodeClass node = null;
|
|
private int state = 0;
|
|
private RandomNumberGenerator rand = RandomNumberGenerator.Create();
|
|
private string randomIdHex = null;
|
|
public webSocketClient wc = null;
|
|
public Dictionary<string, int> userSessions = null;
|
|
public bool sessionIsRecorded = false;
|
|
public DirectoryInfo localFolder = null;
|
|
public string remoteFolder = null;
|
|
public ArrayList remoteFolderList = null;
|
|
private static string rndString = getRandomString(12);
|
|
private bool skipExistingFiles = false;
|
|
private FileDialogMsgForm msgForm = null;
|
|
|
|
// Stats
|
|
public long bytesIn = 0;
|
|
public long bytesInCompressed = 0;
|
|
public long bytesOut = 0;
|
|
public long bytesOutCompressed = 0;
|
|
|
|
// Upload state
|
|
public FileTransferStatusForm transferStatusForm = null;
|
|
public bool uploadActive = false;
|
|
public bool uploadStop = false;
|
|
public int uploadFileArrayPtr = -1;
|
|
public ArrayList uploadFileArray;
|
|
public Hashtable uploadFileDuplicateArray; // Name --> Size
|
|
public DirectoryInfo uploadLocalPath;
|
|
public string uploadRemotePath;
|
|
public FileStream uploadFileStream = null;
|
|
public long uploadFilePtr = 0;
|
|
public long uploadFileStartPtr = 0;
|
|
public long uploadFileSize = 0;
|
|
public DateTime uploadFileStartTime = DateTime.MinValue;
|
|
public string uploadFileName = null;
|
|
|
|
// Download state
|
|
public bool downloadActive = false;
|
|
public bool downloadStop = false;
|
|
public int downloadFileArrayPtr = -1;
|
|
public ArrayList downloadFileArray;
|
|
public ArrayList downloadFileSizeArray;
|
|
public DirectoryInfo downloadLocalPath;
|
|
public string downloadRemotePath;
|
|
public FileStream downloadFileStream = null;
|
|
public long downloadFilePtr = 0;
|
|
public long downloadFileSize = 0;
|
|
public DateTime downloadFileStartTime = DateTime.MinValue;
|
|
|
|
public FileViewer(MeshCentralServer server, NodeClass node)
|
|
{
|
|
InitializeComponent();
|
|
Translate.TranslateControl(this);
|
|
if (node != null) { this.Text += " - " + node.name; }
|
|
this.node = node;
|
|
this.server = server;
|
|
UpdateStatus();
|
|
|
|
rightListView.Columns[0].Width = rightListView.Width - rightListView.Columns[1].Width - 22;
|
|
|
|
// Load the local path from the registry
|
|
string lp = Settings.GetRegValue("LocalPath", "");
|
|
if ((lp != "") && (Directory.Exists(lp))) { localFolder = new DirectoryInfo(lp); }
|
|
}
|
|
|
|
public bool updateLocalFileView()
|
|
{
|
|
// Save the list of selected items
|
|
List<String> selectedItems = new List<String>();
|
|
foreach (ListViewItem l in leftListView.SelectedItems) { selectedItems.Add(l.Text); }
|
|
|
|
// Refresh the list
|
|
leftListView.Items.Clear();
|
|
if (localFolder == null)
|
|
{
|
|
localRootButton.Enabled = false;
|
|
localNewFolderButton.Enabled = false;
|
|
localDeleteButton.Enabled = false;
|
|
try
|
|
{
|
|
DriveInfo[] drives = DriveInfo.GetDrives();
|
|
foreach (DriveInfo drive in drives)
|
|
{
|
|
ListViewItem x = new ListViewItem(drive.Name, 0);
|
|
x.Tag = drive;
|
|
leftListView.Items.Add(x);
|
|
}
|
|
localUpButton.Enabled = false;
|
|
localLabel.Text = Translate.T(Properties.Resources.Local);
|
|
mainToolTip.SetToolTip(localLabel, Translate.T(Properties.Resources.Local));
|
|
}
|
|
catch (Exception) { return false; }
|
|
}
|
|
else
|
|
{
|
|
localRootButton.Enabled = true;
|
|
localNewFolderButton.Enabled = true;
|
|
localDeleteButton.Enabled = false;
|
|
try
|
|
{
|
|
DirectoryInfo[] directories = localFolder.GetDirectories();
|
|
foreach (DirectoryInfo directory in directories)
|
|
{
|
|
ListViewItem x = new ListViewItem(directory.Name, 1);
|
|
x.Tag = directory;
|
|
leftListView.Items.Add(x);
|
|
}
|
|
FileInfo[] files = localFolder.GetFiles();
|
|
foreach (FileInfo file in files)
|
|
{
|
|
if (file.Attributes.HasFlag(FileAttributes.Hidden)) continue;
|
|
string[] si = new string[2];
|
|
si[0] = file.Name;
|
|
si[1] = "" + file.Length;
|
|
ListViewItem x = new ListViewItem(si, 2);
|
|
x.Tag = file;
|
|
leftListView.Items.Add(x);
|
|
}
|
|
localUpButton.Enabled = true;
|
|
localLabel.Text = string.Format(Translate.T(Properties.Resources.LocalPlus), localFolder.FullName);
|
|
mainToolTip.SetToolTip(localLabel, string.Format(Translate.T(Properties.Resources.LocalPlus), localFolder.FullName));
|
|
}
|
|
catch (Exception) { return false; }
|
|
}
|
|
updateTransferButtons();
|
|
|
|
// Reselect items
|
|
foreach (ListViewItem l in leftListView.Items) { l.Selected = selectedItems.Contains(l.Text); }
|
|
|
|
return true;
|
|
}
|
|
|
|
public class ListViewItemSortClass : IComparer
|
|
{
|
|
int IComparer.Compare(Object x, Object y)
|
|
{
|
|
return ((new CaseInsensitiveComparer()).Compare(((ListViewItem)x).SubItems[0].Text, ((ListViewItem)y).SubItems[0].Text));
|
|
}
|
|
}
|
|
|
|
private delegate void updateRemoteFileViewHandler();
|
|
public void updateRemoteFileView()
|
|
{
|
|
if (this.InvokeRequired) { this.Invoke(new updateRemoteFileViewHandler(updateRemoteFileView)); return; }
|
|
|
|
// Save the list of selected items
|
|
List<String> selectedItems = new List<String>();
|
|
foreach (ListViewItem l in rightListView.SelectedItems) { selectedItems.Add(l.Text); }
|
|
|
|
rightListView.Items.Clear();
|
|
|
|
if ((remoteFolder == null) || (remoteFolder == "")) {
|
|
remoteLabel.Text = Translate.T(Properties.Resources.Remote);
|
|
mainToolTip.SetToolTip(remoteLabel, Translate.T(Properties.Resources.Remote));
|
|
} else {
|
|
if (node.agentid < 5)
|
|
{
|
|
remoteLabel.Text = string.Format(Translate.T(Properties.Resources.RemotePlus), remoteFolder.Replace("/", "\\"));
|
|
mainToolTip.SetToolTip(remoteLabel, string.Format(Translate.T(Properties.Resources.RemotePlus), remoteFolder.Replace("/", "\\")));
|
|
}
|
|
else
|
|
{
|
|
remoteLabel.Text = string.Format(Translate.T(Properties.Resources.RemotePlus), remoteFolder);
|
|
mainToolTip.SetToolTip(remoteLabel, string.Format(Translate.T(Properties.Resources.RemotePlus), remoteFolder));
|
|
}
|
|
}
|
|
|
|
remoteRefreshButton.Enabled = true;
|
|
remoteRootButton.Enabled = !((remoteFolder == null) || (remoteFolder == ""));
|
|
remoteUpButton.Enabled = !((remoteFolder == null) || (remoteFolder == ""));
|
|
if (node.agentid < 5) {
|
|
remoteNewFolderButton.Enabled = !((remoteFolder == null) || (remoteFolder == ""));
|
|
remoteDeleteButton.Enabled = remoteZipButton.Enabled = (!((remoteFolder == null) || (remoteFolder == ""))) && (rightListView.SelectedItems.Count > 0);
|
|
} else {
|
|
remoteNewFolderButton.Enabled = true;
|
|
remoteDeleteButton.Enabled = remoteZipButton.Enabled = (rightListView.SelectedItems.Count > 0);
|
|
}
|
|
|
|
if (remoteFolderList != null)
|
|
{
|
|
ArrayList sortlist = new ArrayList();
|
|
|
|
// Display all folders
|
|
for (int i = 0; i < remoteFolderList.Count; i++)
|
|
{
|
|
Dictionary<string, object> fileItem = (Dictionary<string, object>)remoteFolderList[i];
|
|
int fileIcon = 0;
|
|
string fileName = null;
|
|
string fileDate = null;
|
|
long fileSize = -1;
|
|
if (fileItem.ContainsKey("t")) { fileIcon = (int)fileItem["t"]; }
|
|
if (fileItem.ContainsKey("n")) { fileName = (string)fileItem["n"]; }
|
|
if (fileItem.ContainsKey("d")) { fileDate = (string)fileItem["d"]; }
|
|
if (fileItem.ContainsKey("s")) {
|
|
if (fileItem["s"].GetType() == typeof(System.Int32)) { fileSize = (int)fileItem["s"]; }
|
|
if (fileItem["s"].GetType() == typeof(System.Int64)) { fileSize = (long)fileItem["s"]; }
|
|
}
|
|
if (fileIcon == 1) {
|
|
sortlist.Add(new ListViewItem(fileName, 0)); // Drive
|
|
} else if (fileIcon == 2) {
|
|
sortlist.Add(new ListViewItem(fileName, 1)); // Folder
|
|
}
|
|
}
|
|
sortlist.Sort(new ListViewItemSortClass());
|
|
foreach (ListViewItem l in sortlist) { rightListView.Items.Add(l); }
|
|
sortlist.Clear();
|
|
|
|
// Display all files
|
|
for (int i = 0; i < remoteFolderList.Count; i++)
|
|
{
|
|
Dictionary<string, object> fileItem = (Dictionary<string, object>)remoteFolderList[i];
|
|
int fileIcon = 0;
|
|
string fileName = null;
|
|
string fileDate = null;
|
|
long fileSize = -1;
|
|
if (fileItem.ContainsKey("t")) { fileIcon = (int)fileItem["t"]; }
|
|
if (fileItem.ContainsKey("n")) { fileName = (string)fileItem["n"]; }
|
|
if (fileItem.ContainsKey("d")) { fileDate = (string)fileItem["d"]; }
|
|
if (fileItem.ContainsKey("s"))
|
|
{
|
|
if (fileItem["s"].GetType() == typeof(System.Int32)) { fileSize = (int)fileItem["s"]; }
|
|
if (fileItem["s"].GetType() == typeof(System.Int64)) { fileSize = (long)fileItem["s"]; }
|
|
}
|
|
if (fileIcon == 3)
|
|
{
|
|
// File
|
|
string[] si = new string[2];
|
|
si[0] = fileName;
|
|
si[1] = "" + fileSize;
|
|
sortlist.Add(new ListViewItem(si, 2)); // File
|
|
}
|
|
}
|
|
sortlist.Sort(new ListViewItemSortClass());
|
|
foreach (ListViewItem l in sortlist) { rightListView.Items.Add(l); }
|
|
}
|
|
updateTransferButtons();
|
|
|
|
// Reselect items
|
|
foreach (ListViewItem l in rightListView.Items) { l.Selected = selectedItems.Contains(l.Text); }
|
|
}
|
|
|
|
private void Server_onStateChanged(int state)
|
|
{
|
|
UpdateStatus();
|
|
}
|
|
|
|
private void MainForm_Load(object sender, EventArgs e)
|
|
{
|
|
updateLocalFileView();
|
|
|
|
// Restore Window Location
|
|
string locationStr = Settings.GetRegValue("filelocation", "");
|
|
if (locationStr != null)
|
|
{
|
|
string[] locationSplit = locationStr.Split(',');
|
|
if (locationSplit.Length == 4)
|
|
{
|
|
try
|
|
{
|
|
var x = int.Parse(locationSplit[0]);
|
|
var y = int.Parse(locationSplit[1]);
|
|
var w = int.Parse(locationSplit[2]);
|
|
var h = int.Parse(locationSplit[3]);
|
|
Point p = new Point(x, y);
|
|
if (isPointVisibleOnAScreen(p))
|
|
{
|
|
Location = p;
|
|
if ((w > 50) && (h > 50)) { Size = new Size(w, h); }
|
|
}
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MenuItemExit_Click(object sender, EventArgs e)
|
|
{
|
|
Close();
|
|
}
|
|
|
|
public void MenuItemConnect_Click(object sender, EventArgs e)
|
|
{
|
|
if ((wc != null) || (node == null)) return;
|
|
byte[] randomid = new byte[10];
|
|
rand.GetBytes(randomid);
|
|
randomIdHex = BitConverter.ToString(randomid).Replace("-", string.Empty);
|
|
|
|
state = 1;
|
|
string ux = server.wsurl.ToString().Replace("/control.ashx", "/");
|
|
int i = ux.IndexOf("?");
|
|
if (i >= 0) { ux = ux.Substring(0, i); }
|
|
Uri u = new Uri(ux + "meshrelay.ashx?browser=1&p=5&nodeid=" + node.nodeid + "&id=" + randomIdHex + "&auth=" + server.authCookie);
|
|
wc = new webSocketClient();
|
|
wc.debug = server.debug;
|
|
wc.onStateChanged += Wc_onStateChanged;
|
|
wc.onBinaryData += Wc_onBinaryData;
|
|
wc.onStringData += Wc_onStringData;
|
|
wc.TLSCertCheck = webSocketClient.TLSCertificateCheck.Fingerprint;
|
|
wc.Start(u, server.wshash, null);
|
|
}
|
|
|
|
private void Wc_onStateChanged(webSocketClient sender, webSocketClient.ConnectionStates wsstate)
|
|
{
|
|
switch (wsstate)
|
|
{
|
|
case webSocketClient.ConnectionStates.Disconnected:
|
|
{
|
|
// Disconnect
|
|
state = 0;
|
|
wc.Dispose();
|
|
wc = null;
|
|
break;
|
|
}
|
|
case webSocketClient.ConnectionStates.Connecting:
|
|
{
|
|
state = 1;
|
|
displayMessage(null);
|
|
break;
|
|
}
|
|
case webSocketClient.ConnectionStates.Connected:
|
|
{
|
|
// Reset stats
|
|
bytesIn = 0;
|
|
bytesInCompressed = 0;
|
|
bytesOut = 0;
|
|
bytesOutCompressed = 0;
|
|
|
|
state = 2;
|
|
|
|
string u = "*" + server.wsurl.AbsolutePath.Replace("control.ashx", "meshrelay.ashx") + "?p=5&nodeid=" + node.nodeid + "&id=" + randomIdHex + "&rauth=" + server.rauthCookie;
|
|
server.sendCommand("{ \"action\": \"msg\", \"type\": \"tunnel\", \"nodeid\": \"" + node.nodeid + "\", \"value\": \"" + u.ToString() + "\", \"usage\": 5 }");
|
|
displayMessage(null);
|
|
break;
|
|
}
|
|
}
|
|
UpdateStatus();
|
|
updateTransferButtons();
|
|
}
|
|
|
|
private void requestRemoteFolder(string path)
|
|
{
|
|
// Send LS command
|
|
string cmd = "{\"action\":\"ls\",\"reqid\":1,\"path\":\"" + path.Replace("\\","/") + "\"}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
|
|
private void requestCreateFolder(string path)
|
|
{
|
|
// Send MKDIR command
|
|
string cmd = "{\"action\":\"mkdir\",\"reqid\":2,\"path\":\"" + path.Replace("\\", "/") + "\"}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
|
|
public void requestCancel()
|
|
{
|
|
string cmd = "{\"action\":\"cancel\"}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
updateMsgForm(null, null, 0);
|
|
}
|
|
|
|
private void requestCreateZipFileFolder(string path, string zip, string[] files)
|
|
{
|
|
// Send ZIP command
|
|
string cmd = "{\"action\":\"zip\",\"reqid\":5,\"path\":\"" + path.Replace("\\", "/") + "\",\"output\":\"" + zip.Replace("\\", "/") + "\",\"files\":[";
|
|
bool first = true;
|
|
foreach (string file in files)
|
|
{
|
|
if (first) { first = false; } else { cmd += ","; }
|
|
cmd += "\"" + file + "\"";
|
|
}
|
|
cmd += "]}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
|
|
private void requestRename(string path, string oldname, string newname)
|
|
{
|
|
// Send RENAME command
|
|
string cmd = "{\"action\":\"rename\",\"reqid\":3,\"path\":\"" + path.Replace("\\", "/") + "\",\"oldname\":\"" + oldname + "\",\"newname\":\"" + newname + "\"}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
|
|
private void requestDelete(string path, string[] files, bool recursive)
|
|
{
|
|
// Send RM command
|
|
string delfiles = "";
|
|
foreach (string file in files) { if (delfiles.Length != 0) { delfiles += ","; } delfiles += "\"" + file + "\""; }
|
|
string cmd = "{\"action\":\"rm\",\"reqid\":4,\"path\":\"" + path.Replace("\\", "/") + "\",\"rec\":" + recursive.ToString().ToLower() + ",\"delfiles\":[" + delfiles + "]}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
|
|
private void Wc_onStringData(webSocketClient sender, string data, int orglen)
|
|
{
|
|
bytesIn += data.Length;
|
|
bytesInCompressed += orglen;
|
|
|
|
if ((state == 2) && ((data == "c") || (data == "cr")))
|
|
{
|
|
if (data == "cr") { sessionIsRecorded = true; }
|
|
state = 3;
|
|
UpdateStatus();
|
|
displayMessage(null);
|
|
|
|
// Send protocol
|
|
string cmd = "5";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
|
|
// Ask for root level
|
|
requestRemoteFolder("");
|
|
return;
|
|
}
|
|
if (state != 3) return;
|
|
|
|
// Parse the received JSON
|
|
Dictionary<string, object> jsonAction = new Dictionary<string, object>();
|
|
jsonAction = new JavaScriptSerializer().Deserialize<Dictionary<string, object>>(data);
|
|
if (jsonAction == null) return;
|
|
|
|
if (jsonAction.ContainsKey("action") && (jsonAction["action"].GetType() == typeof(string)))
|
|
{
|
|
string action = jsonAction["action"].ToString();
|
|
switch (action)
|
|
{
|
|
case "download":
|
|
{
|
|
if (downloadStop) { downloadCancel(); return; }
|
|
|
|
string sub = null;
|
|
if (jsonAction.ContainsKey("sub")) { sub = (string)jsonAction["sub"]; }
|
|
if (sub == "start")
|
|
{
|
|
// Send DOWNLOAD startack command
|
|
string cmd = "{\"action\":\"download\",\"sub\":\"startack\",\"id\":" + (downloadFileArrayPtr + 1000) + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
else if (sub == "cancel")
|
|
{
|
|
// Unable to download this file
|
|
if (transferStatusForm != null) { transferStatusForm.addErrorMessage(String.Format(Translate.T(Properties.Resources.ErrorDownloadingFileX), downloadFileArray[downloadFileArrayPtr].ToString())); }
|
|
|
|
// Send DOWNLOAD command
|
|
string cmd = "{\"action\":\"download\",\"sub\":\"stop\",\"id\":" + (downloadFileArrayPtr + 1000) + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
if (downloadFileStream != null) { downloadFileStream.Close(); downloadFileStream = null; } // Close the file
|
|
try { File.Delete(Path.Combine(downloadLocalPath.FullName, downloadFileArray[downloadFileArrayPtr].ToString())); } catch (Exception) { }
|
|
|
|
// Go to next file
|
|
if (downloadFileArray.Count > downloadFileArrayPtr + 1)
|
|
{
|
|
// Download the next file
|
|
downloadFileArrayPtr++;
|
|
downloadNextFile();
|
|
}
|
|
else
|
|
{
|
|
// Done with all files
|
|
downloadActive = false;
|
|
downloadStop = false;
|
|
downloadFileArrayPtr = -1;
|
|
downloadFileArray = null;
|
|
downloadLocalPath = null;
|
|
downloadRemotePath = null;
|
|
closeTransferDialog();
|
|
localRefresh();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (jsonAction.ContainsKey("type") && (jsonAction["type"].GetType() == typeof(string))) {
|
|
string action = jsonAction["type"].ToString();
|
|
switch (action)
|
|
{
|
|
case "metadata":
|
|
{
|
|
if ((jsonAction.ContainsKey("users") == false) || (jsonAction["users"] == null)) return;
|
|
Dictionary<string, object> usersex = (Dictionary<string, object>)jsonAction["users"];
|
|
userSessions = new Dictionary<string, int>();
|
|
foreach (string user in usersex.Keys) { userSessions.Add(user, (int)usersex[user]); }
|
|
UpdateStatus();
|
|
break;
|
|
}
|
|
case "console":
|
|
{
|
|
string msg = null;
|
|
int msgid = -1;
|
|
if ((jsonAction.ContainsKey("msg")) && (jsonAction["msg"] != null)) { msg = jsonAction["msg"].ToString(); }
|
|
if (jsonAction.ContainsKey("msgid")) { msgid = (int)jsonAction["msgid"]; }
|
|
if (msgid == 1) { msg = Translate.T(Properties.Resources.WaitingForUserToGrantAccess); }
|
|
if (msgid == 2) { msg = Translate.T(Properties.Resources.Denied); }
|
|
if (msgid == 3) { msg = Translate.T(Properties.Resources.FailedToStartRemoteTerminalSession); }
|
|
if (msgid == 4) { msg = Translate.T(Properties.Resources.Timeout); }
|
|
if (msgid == 5) { msg = Translate.T(Properties.Resources.ReceivedInvalidNetworkData); }
|
|
displayMessage(msg);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Wc_onBinaryData(webSocketClient sender, byte[] data, int offset, int length, int orglen)
|
|
{
|
|
bytesIn += length;
|
|
bytesInCompressed += orglen;
|
|
|
|
if (state != 3) return;
|
|
|
|
if (data[offset] == 123) {
|
|
// Parse the received JSON
|
|
Dictionary<string, object> jsonAction = new Dictionary<string, object>();
|
|
jsonAction = new JavaScriptSerializer().Deserialize<Dictionary<string, object>>(UTF8Encoding.UTF8.GetString(data, offset, length));
|
|
if (jsonAction == null) return;
|
|
int reqid = 0;
|
|
if (jsonAction.ContainsKey("reqid")) { reqid = (int)jsonAction["reqid"]; }
|
|
string action = null;
|
|
if (jsonAction.ContainsKey("action")) { action = (string)jsonAction["action"]; }
|
|
|
|
if (action == "uploadstart")
|
|
{
|
|
if (uploadStop) { uploadCancel(); return; }
|
|
uploadNextPart(false);
|
|
for (var i = 0; i < 8; i++) { uploadNextPart(true); }
|
|
}
|
|
else if (action == "uploadack")
|
|
{
|
|
if (uploadStop) { uploadCancel(); return; }
|
|
uploadNextPart(false);
|
|
}
|
|
else if ((action == "uploaddone") || (action == "uploaderror"))
|
|
{
|
|
// Clean up current upload
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileSize = 0;
|
|
if (uploadFileStream != null) { uploadFileStream.Close(); uploadFileStream = null; }
|
|
|
|
// If this is an error, show it in the dialog
|
|
if ((action == "uploaderror") && (transferStatusForm != null)) { transferStatusForm.addErrorMessage(String.Format(Translate.T(Properties.Resources.ErrorUploadingFileX), uploadFileName)); }
|
|
|
|
// Check if another file needs to be uploaded
|
|
if (uploadFileArray.Count > (uploadFileArrayPtr + 1))
|
|
{
|
|
// Upload the next file
|
|
uploadFileArrayPtr++;
|
|
uploadNextFile();
|
|
}
|
|
else
|
|
{
|
|
// Done with all files
|
|
uploadActive = false;
|
|
uploadStop = false;
|
|
uploadFileArrayPtr = -1;
|
|
uploadFileArray = null;
|
|
uploadFileDuplicateArray = null;
|
|
uploadLocalPath = null;
|
|
uploadRemotePath = null;
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileSize = 0;
|
|
uploadFileName = null;
|
|
closeTransferDialog();
|
|
remoteRefresh();
|
|
}
|
|
}
|
|
else if (action == "uploadhash")
|
|
{
|
|
if (uploadStop) { uploadCancel(); return; }
|
|
string name = null;
|
|
if (jsonAction.ContainsKey("name")) { name = (string)jsonAction["name"]; }
|
|
string path = null;
|
|
if (jsonAction.ContainsKey("path")) { path = (string)jsonAction["path"]; }
|
|
string remoteHashHex = null;
|
|
if (jsonAction.ContainsKey("hash")) { remoteHashHex = (string)jsonAction["hash"]; }
|
|
long remoteFileSize = 0;
|
|
if (jsonAction.ContainsKey("tag")) {
|
|
if (jsonAction["tag"].GetType() == typeof(int)) { remoteFileSize = (int)jsonAction["tag"]; }
|
|
if (jsonAction["tag"].GetType() == typeof(long)) { remoteFileSize = (long)jsonAction["tag"]; }
|
|
}
|
|
if ((uploadRemotePath != path) || (uploadFileName != name)) { uploadCancel(); return; }
|
|
|
|
// Hash the local file
|
|
string localHashHex = null;
|
|
try
|
|
{
|
|
string filePath = Path.Combine(localFolder.FullName, uploadFileName);
|
|
using (SHA384 SHA384 = SHA384Managed.Create())
|
|
{
|
|
uploadFileStream.Seek(0, SeekOrigin.Begin);
|
|
byte[] buf = new byte[65536];
|
|
long ptr = 0;
|
|
int len = 1;
|
|
while (len != 0)
|
|
{
|
|
int l = buf.Length;
|
|
if (l > (remoteFileSize - ptr)) { l = (int)(remoteFileSize - ptr); }
|
|
if (l == 0) { len = 0; } else { len = uploadFileStream.Read(buf, 0, l); }
|
|
if (len > 0) { SHA384.TransformBlock(buf, 0, len, buf, 0); }
|
|
ptr += len;
|
|
}
|
|
SHA384.TransformFinalBlock(buf, 0, 0);
|
|
localHashHex = BitConverter.ToString(SHA384.Hash).Replace("-", string.Empty);
|
|
uploadFileStream.Seek(0, SeekOrigin.Begin);
|
|
}
|
|
}
|
|
catch (Exception) { }
|
|
|
|
if ((localHashHex != null) && (localHashHex.Equals(remoteHashHex)))
|
|
{
|
|
if (remoteFileSize == uploadFileStream.Length)
|
|
{
|
|
// Files are the same length, skip the file.
|
|
// Check if another file needs to be uploaded
|
|
if (uploadFileArray.Count > (uploadFileArrayPtr + 1))
|
|
{
|
|
// Upload the next file
|
|
uploadFileArrayPtr++;
|
|
uploadNextFile();
|
|
}
|
|
else
|
|
{
|
|
// Done with all files
|
|
uploadActive = false;
|
|
uploadStop = false;
|
|
uploadFileArrayPtr = -1;
|
|
uploadFileArray = null;
|
|
uploadFileDuplicateArray = null;
|
|
uploadLocalPath = null;
|
|
uploadRemotePath = null;
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileSize = 0;
|
|
uploadFileName = null;
|
|
closeTransferDialog();
|
|
remoteRefresh();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Files are not the same length, append the rest
|
|
uploadFileStream.Seek(remoteFileSize, SeekOrigin.Begin);
|
|
uploadFilePtr = uploadFileStartPtr = remoteFileSize;
|
|
|
|
// Send UPLOAD command with append turned on
|
|
string cmd = "{\"action\":\"upload\",\"reqid\":" + (uploadFileArrayPtr + 1000) + ",\"path\":\"" + uploadRemotePath + "\",\"name\":\"" + name + "\",\"size\":" + uploadFileSize + ",\"append\":true}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Send UPLOAD command
|
|
string cmd = "{\"action\":\"upload\",\"reqid\":" + (uploadFileArrayPtr + 1000) + ",\"path\":\"" + uploadRemotePath + "\",\"name\":\"" + name + "\",\"size\":" + uploadFileSize + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
}
|
|
else if ((action == "dialogmessage"))
|
|
{
|
|
// Dialog box message
|
|
string msg = null;
|
|
string file = null;
|
|
int progress = 0;
|
|
if (jsonAction.ContainsKey("msg") && (jsonAction["msg"] == null)) { msg = ""; }
|
|
else if (jsonAction.ContainsKey("msg") && (jsonAction["msg"].GetType() == typeof(string))) { msg = (string)jsonAction["msg"]; }
|
|
if (jsonAction.ContainsKey("file") && (jsonAction["file"].GetType() == typeof(string))) { file = (string)jsonAction["file"]; }
|
|
if (jsonAction.ContainsKey("progress") && (jsonAction["progress"].GetType() == typeof(System.Int32))) { progress = (int)jsonAction["progress"]; }
|
|
updateMsgForm(msg, file, progress);
|
|
}
|
|
else if (reqid == 1)
|
|
{
|
|
// Result of a LS command
|
|
if (jsonAction.ContainsKey("path")) { remoteFolder = (string)jsonAction["path"]; }
|
|
if (jsonAction.ContainsKey("dir")) { remoteFolderList = (ArrayList)jsonAction["dir"]; }
|
|
updateRemoteFileView();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (downloadActive) {
|
|
if (downloadStop) { downloadCancel(); return; }
|
|
downloadGotBinaryData(data, offset, length);
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate void updateMsgFormHandler(string msg, string file, int progress);
|
|
|
|
private void updateMsgForm(string msg, string file, int progress)
|
|
{
|
|
if (this.InvokeRequired) { this.Invoke(new updateMsgFormHandler(updateMsgForm), msg, file, progress); return; }
|
|
if ((msg == null) || (msg == ""))
|
|
{
|
|
// Close the dialog box
|
|
if (msgForm != null) { msgForm.Close(); msgForm = null; remoteRefresh(); }
|
|
}
|
|
else
|
|
{
|
|
// Open or update the dialog box
|
|
if (msgForm == null)
|
|
{
|
|
msgForm = new FileDialogMsgForm(this);
|
|
msgForm.Show(this);
|
|
msgForm.UpdateStatus(msg, file, progress);
|
|
if (msgForm.StartPosition == FormStartPosition.CenterParent)
|
|
{
|
|
var x = Location.X + (Width - msgForm.Width) / 2;
|
|
var y = Location.Y + (Height - msgForm.Height) / 2;
|
|
msgForm.Location = new Point(Math.Max(x, 0), Math.Max(y, 0));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
msgForm.UpdateStatus(msg, file, progress);
|
|
}
|
|
}
|
|
}
|
|
|
|
private delegate void remoteRefreshHandler();
|
|
|
|
private void remoteRefresh()
|
|
{
|
|
if (this.InvokeRequired) { this.Invoke(new remoteRefreshHandler(remoteRefresh)); return; }
|
|
updateTimer.Enabled = true;
|
|
}
|
|
|
|
private delegate void localRefreshHandler();
|
|
|
|
private void localRefresh()
|
|
{
|
|
if (this.InvokeRequired) { this.Invoke(new localRefreshHandler(localRefresh)); return; }
|
|
updateLocalFileView();
|
|
}
|
|
|
|
private void MenuItemDisconnect_Click(object sender, EventArgs e)
|
|
{
|
|
if (wc != null)
|
|
{
|
|
// Disconnect
|
|
state = 0;
|
|
wc.Dispose();
|
|
wc = null;
|
|
UpdateStatus();
|
|
}
|
|
else
|
|
{
|
|
// Connect
|
|
MenuItemConnect_Click(null, null);
|
|
}
|
|
displayMessage(null);
|
|
}
|
|
|
|
|
|
public delegate void UpdateStatusHandler();
|
|
|
|
private void UpdateStatus()
|
|
{
|
|
if (this.IsDisposed) return;
|
|
if (this.InvokeRequired) { this.Invoke(new UpdateStatusHandler(UpdateStatus)); return; }
|
|
|
|
//if (kvmControl == null) return;
|
|
switch (state)
|
|
{
|
|
case 0: // Disconnected
|
|
mainToolStripStatusLabel.Text = Translate.T(Properties.Resources.Disconnected);
|
|
connectButton.Text = Translate.T(Properties.Resources.Connect);
|
|
remoteRefreshButton.Enabled = false;
|
|
remoteUpButton.Enabled = false;
|
|
remoteRootButton.Enabled = false;
|
|
remoteNewFolderButton.Enabled = false;
|
|
remoteDeleteButton.Enabled = false;
|
|
remoteZipButton.Enabled = false;
|
|
remoteFolder = null;
|
|
break;
|
|
case 1: // Connecting
|
|
mainToolStripStatusLabel.Text = Translate.T(Properties.Resources.Connecting);
|
|
connectButton.Text = Translate.T(Properties.Resources.Disconnect);
|
|
break;
|
|
case 2: // Setup
|
|
mainToolStripStatusLabel.Text = Translate.T(Properties.Resources.Setup);
|
|
connectButton.Text = Translate.T(Properties.Resources.Disconnect);
|
|
break;
|
|
case 3: // Connected
|
|
string label = Translate.T(Properties.Resources.Connected);
|
|
if (sessionIsRecorded) { label += Translate.T(Properties.Resources.RecordedSession); }
|
|
if ((userSessions != null) && (userSessions.Count > 1)) { label += string.Format(Translate.T(Properties.Resources.AddXUsers), userSessions.Count); }
|
|
label += ".";
|
|
mainToolStripStatusLabel.Text = label;
|
|
connectButton.Text = Translate.T(Properties.Resources.Disconnect);
|
|
break;
|
|
}
|
|
|
|
rightListView.Enabled = (state == 3);
|
|
if (state != 3) { rightListView.Items.Clear(); }
|
|
}
|
|
|
|
private void Main_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
if (wc != null)
|
|
{
|
|
// Disconnect
|
|
state = 0;
|
|
wc.Dispose();
|
|
wc = null;
|
|
UpdateStatus();
|
|
}
|
|
node.fileViewer = null;
|
|
|
|
// Clean up any downloads
|
|
if (downloadFileStream != null) { downloadFileStream.Close(); downloadFileStream = null; }
|
|
downloadFilePtr = 0;
|
|
downloadFileSize = 0;
|
|
downloadActive = false;
|
|
downloadStop = false;
|
|
downloadFileArrayPtr = -1;
|
|
downloadFileArray = null;
|
|
downloadLocalPath = null;
|
|
downloadRemotePath = null;
|
|
|
|
// Clean up any uploads
|
|
uploadActive = false;
|
|
uploadStop = false;
|
|
uploadFileArrayPtr = -1;
|
|
uploadFileArray = null;
|
|
uploadFileDuplicateArray = null;
|
|
uploadLocalPath = null;
|
|
uploadRemotePath = null;
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileSize = 0;
|
|
if (uploadFileStream != null) { uploadFileStream.Close(); uploadFileStream = null; }
|
|
|
|
// Save window location
|
|
Settings.SetRegValue("filelocation", Location.X + "," + Location.Y + "," + Size.Width + "," + Size.Height);
|
|
}
|
|
|
|
public delegate void displayMessageHandler(string msg);
|
|
public void displayMessage(string msg)
|
|
{
|
|
if (this.InvokeRequired) { this.Invoke(new displayMessageHandler(displayMessage), msg); return; }
|
|
if (msg == null)
|
|
{
|
|
consoleMessage.Visible = false;
|
|
consoleTimer.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
consoleMessage.Text = msg;
|
|
consoleMessage.Visible = true;
|
|
consoleTimer.Enabled = true;
|
|
}
|
|
}
|
|
private void consoleTimer_Tick(object sender, EventArgs e)
|
|
{
|
|
consoleMessage.Visible = false;
|
|
consoleTimer.Enabled = false;
|
|
}
|
|
|
|
private void connectButton_Click(object sender, EventArgs e)
|
|
{
|
|
if (wc != null)
|
|
{
|
|
// Disconnect
|
|
state = 0;
|
|
wc.Dispose();
|
|
wc = null;
|
|
UpdateStatus();
|
|
}
|
|
else
|
|
{
|
|
// Connect
|
|
MenuItemConnect_Click(null, null);
|
|
}
|
|
displayMessage(null);
|
|
}
|
|
|
|
private void leftListView_MouseDoubleClick(object sender, MouseEventArgs e)
|
|
{
|
|
ListViewItem item = leftListView.GetItemAt(e.X, e.Y);
|
|
if (item != null)
|
|
{
|
|
if (item.Tag.GetType() == typeof(DriveInfo)) {
|
|
DirectoryInfo old = localFolder;
|
|
localFolder = ((DriveInfo)item.Tag).RootDirectory;
|
|
if (updateLocalFileView() == false) { localFolder = old; updateLocalFileView(); }
|
|
Settings.SetRegValue("LocalPath", (localFolder == null) ? "" : localFolder.FullName);
|
|
}
|
|
else if (item.Tag.GetType() == typeof(DirectoryInfo))
|
|
{
|
|
DirectoryInfo old = localFolder;
|
|
localFolder = (DirectoryInfo)item.Tag;
|
|
if (updateLocalFileView() == false) { localFolder = old; updateLocalFileView(); }
|
|
Settings.SetRegValue("LocalPath", (localFolder == null) ? "" : localFolder.FullName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void localUpButton_Click(object sender, EventArgs e)
|
|
{
|
|
localFolder = localFolder.Parent;
|
|
Settings.SetRegValue("LocalPath", (localFolder == null)?"":localFolder.FullName);
|
|
updateLocalFileView();
|
|
}
|
|
|
|
private void rightListView_MouseDoubleClick(object sender, MouseEventArgs e)
|
|
{
|
|
ListViewItem item = rightListView.GetItemAt(e.X, e.Y);
|
|
if (item != null)
|
|
{
|
|
string r = remoteFolder;
|
|
if ((item.ImageIndex == 0) || (item.ImageIndex == 1)) {
|
|
if ((r == null) || (r == "")) {
|
|
r = item.Text;
|
|
} else {
|
|
if (remoteFolder.EndsWith("/")) { r = remoteFolder + item.Text; } else { r = remoteFolder + "/" + item.Text; }
|
|
}
|
|
requestRemoteFolder(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void remoteUpButton_Click(object sender, EventArgs e)
|
|
{
|
|
string r = remoteFolder;
|
|
if (r.EndsWith("/")) { r = r.Substring(0, r.Length - 1); }
|
|
int i = r.LastIndexOf("/");
|
|
if (i >= 0) { r = r.Substring(0, i + 1); } else { r = ""; }
|
|
requestRemoteFolder(r);
|
|
}
|
|
|
|
private void leftRefreshButton_Click(object sender, EventArgs e)
|
|
{
|
|
updateLocalFileView();
|
|
}
|
|
|
|
private void rightRefreshButton_Click(object sender, EventArgs e)
|
|
{
|
|
requestRemoteFolder(remoteFolder);
|
|
}
|
|
|
|
private void remoteNewFolderButton_Click(object sender, EventArgs e)
|
|
{
|
|
if (remoteFolder == null) return;
|
|
FilenamePromptForm f = new FilenamePromptForm(Translate.T(Properties.Resources.CreateFolder), "");
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
string r;
|
|
if (remoteFolder.EndsWith("/")) { r = remoteFolder + f.filename; } else { r = remoteFolder + "/" + f.filename; }
|
|
requestCreateFolder(r);
|
|
remoteRefresh();
|
|
}
|
|
}
|
|
|
|
private void remoteZipButton_Click(object sender, EventArgs e)
|
|
{
|
|
if (remoteFolder == null) return;
|
|
FilenamePromptForm f = new FilenamePromptForm(Translate.T(Properties.Resources.ZipSelectedFiles), "");
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
string r = f.filename;
|
|
if (!r.ToLower().EndsWith(".zip")) { r += ".zip"; }
|
|
ArrayList filesArray = new ArrayList();
|
|
foreach (ListViewItem l in rightListView.SelectedItems) { filesArray.Add(l.Text); }
|
|
string[] files = (string[])filesArray.ToArray(typeof(string));
|
|
requestCreateZipFileFolder(remoteFolder, r, files);
|
|
}
|
|
}
|
|
|
|
private void localRootButton_Click(object sender, EventArgs e)
|
|
{
|
|
localFolder = null;
|
|
Settings.SetRegValue("LocalPath", "");
|
|
updateLocalFileView();
|
|
}
|
|
|
|
private void remoteRootButton_Click(object sender, EventArgs e)
|
|
{
|
|
requestRemoteFolder("");
|
|
}
|
|
|
|
private void rightListView_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (node.agentid < 5)
|
|
{
|
|
remoteDeleteButton.Enabled = remoteZipButton.Enabled = (!((remoteFolder == null) || (remoteFolder == ""))) && (rightListView.SelectedItems.Count > 0);
|
|
}
|
|
else
|
|
{
|
|
remoteDeleteButton.Enabled = remoteZipButton.Enabled = (rightListView.SelectedItems.Count > 0);
|
|
}
|
|
updateTransferButtons();
|
|
}
|
|
|
|
private void rightListView_Resize(object sender, EventArgs e)
|
|
{
|
|
if (rightListView.Columns[0].Width != (rightListView.Width - rightListView.Columns[1].Width - 22))
|
|
{
|
|
rightListView.Columns[0].Width = rightListView.Width - rightListView.Columns[1].Width - 22;
|
|
}
|
|
}
|
|
|
|
private void rightListView_ColumnWidthChanged(object sender, ColumnWidthChangedEventArgs e)
|
|
{
|
|
if (rightListView.Columns[0].Width != (rightListView.Width - rightListView.Columns[1].Width - 22))
|
|
{
|
|
rightListView.Columns[0].Width = rightListView.Width - rightListView.Columns[1].Width - 22;
|
|
}
|
|
}
|
|
|
|
private void leftListView_Resize(object sender, EventArgs e)
|
|
{
|
|
if (leftListView.Columns[0].Width != (leftListView.Width - leftListView.Columns[1].Width - 22))
|
|
{
|
|
leftListView.Columns[0].Width = leftListView.Width - leftListView.Columns[1].Width - 22;
|
|
}
|
|
}
|
|
|
|
private void leftListView_ColumnWidthChanged(object sender, ColumnWidthChangedEventArgs e)
|
|
{
|
|
if (leftListView.Columns[0].Width != (leftListView.Width - leftListView.Columns[1].Width - 22))
|
|
{
|
|
leftListView.Columns[0].Width = leftListView.Width - leftListView.Columns[1].Width - 22;
|
|
}
|
|
}
|
|
|
|
private void updateTimer_Tick(object sender, EventArgs e)
|
|
{
|
|
updateTimer.Enabled = false;
|
|
if (remoteFolder != null) { requestRemoteFolder(remoteFolder); }
|
|
}
|
|
|
|
private void remoteDeleteButton_Click(object sender, EventArgs e)
|
|
{
|
|
bool rec = false;
|
|
ArrayList filesArray = new ArrayList();
|
|
foreach (ListViewItem l in rightListView.SelectedItems) { filesArray.Add(l.Text); if (l.ImageIndex == 1) { rec = true; } }
|
|
string[] files = (string[])filesArray.ToArray(typeof(string));
|
|
string msg = string.Format(Translate.T(Properties.Resources.RemoveXItems), files.Length);
|
|
if (files.Length == 1) { msg = Translate.T(Properties.Resources.Remove1Item); }
|
|
FileDeletePromptForm f = new FileDeletePromptForm(msg, rec);
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
requestDelete(remoteFolder, files, f.recursive);
|
|
remoteRefresh();
|
|
}
|
|
}
|
|
|
|
private void remoteContextMenuStrip_Opening(object sender, System.ComponentModel.CancelEventArgs e)
|
|
{
|
|
if ((rightListView.SelectedItems.Count == 0) || ((node.agentid < 5) && ((remoteFolder == null) || (remoteFolder == ""))))
|
|
{
|
|
deleteToolStripMenuItem.Visible = toolStripMenuItem1.Visible = renameToolStripMenuItem.Visible = compressToolStripMenuItem.Visible = false;
|
|
}
|
|
else if (rightListView.SelectedItems.Count == 1)
|
|
{
|
|
deleteToolStripMenuItem.Visible = toolStripMenuItem1.Visible = renameToolStripMenuItem.Visible = compressToolStripMenuItem.Visible = true;
|
|
}
|
|
else if (rightListView.SelectedItems.Count > 1)
|
|
{
|
|
renameToolStripMenuItem.Visible = false;
|
|
deleteToolStripMenuItem.Visible = toolStripMenuItem1.Visible = compressToolStripMenuItem.Visible = true;
|
|
}
|
|
}
|
|
|
|
private void renameToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
string oldname = rightListView.SelectedItems[0].Text;
|
|
if ((rightListView.SelectedItems.Count != 1) || (remoteFolder == null)) return;
|
|
FilenamePromptForm f = new FilenamePromptForm(Translate.T(Properties.Resources.Rename), oldname);
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
if (oldname == f.filename) return;
|
|
//string r;
|
|
//if (remoteFolder.EndsWith("/")) { r = remoteFolder + f.filename; } else { r = remoteFolder + "/" + f.filename; }
|
|
requestRename(remoteFolder, oldname, f.filename);
|
|
remoteRefresh();
|
|
}
|
|
}
|
|
|
|
private delegate void updateTransferButtonsHandler();
|
|
|
|
private void updateTransferButtons()
|
|
{
|
|
if (this.InvokeRequired) { this.Invoke(new updateTransferButtonsHandler(updateTransferButtons)); return; }
|
|
if ((wc == null) || (wc.State != webSocketClient.ConnectionStates.Connected))
|
|
{
|
|
uploadButton.Enabled = false;
|
|
downloadButton.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
// Set upload button
|
|
bool uploadAllowed = true;
|
|
if (localFolder == null) { uploadAllowed = false; }
|
|
if (leftListView.SelectedItems.Count == 0) { uploadAllowed = false; }
|
|
foreach (ListViewItem l in leftListView.SelectedItems) { if (l.ImageIndex != 2) { uploadAllowed = false; } }
|
|
if ((node.agentid < 5) && ((remoteFolder == null) || (remoteFolder == ""))) { uploadAllowed = false; }
|
|
uploadButton.Enabled = uploadAllowed;
|
|
|
|
// Set download button
|
|
bool downloadAllowed = true;
|
|
if (localFolder == null) { downloadAllowed = false; }
|
|
if (rightListView.SelectedItems.Count == 0) { downloadAllowed = false; }
|
|
foreach (ListViewItem l in rightListView.SelectedItems) { if (l.ImageIndex != 2) { downloadAllowed = false; } }
|
|
if ((node.agentid < 5) && ((remoteFolder == null) || (remoteFolder == ""))) { downloadAllowed = false; }
|
|
downloadButton.Enabled = downloadAllowed;
|
|
}
|
|
}
|
|
|
|
private void leftListView_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
updateTransferButtons();
|
|
localDeleteButton.Enabled = ((localFolder != null) && (leftListView.SelectedItems.Count > 0));
|
|
}
|
|
|
|
private void uploadButton_Click(object sender, EventArgs e)
|
|
{
|
|
// If a transfer is currently active, ignore this.
|
|
if (uploadActive || downloadActive || (transferStatusForm != null)) return;
|
|
|
|
// If any files are going to be overwritten
|
|
int overWriteCount = 0;
|
|
foreach (ListViewItem l in leftListView.SelectedItems) {
|
|
if (l.ImageIndex == 2) {
|
|
string filename = l.Text;
|
|
|
|
foreach (ListViewItem l2 in rightListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) { overWriteCount++; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
skipExistingFiles = true;
|
|
if (overWriteCount > 0)
|
|
{
|
|
FileConfirmOverwriteForm f = new FileConfirmOverwriteForm();
|
|
if (overWriteCount == 1) { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteOneFile), overWriteCount); } else { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteXfiles), overWriteCount); }
|
|
if (f.ShowDialog(this) != DialogResult.OK) return;
|
|
skipExistingFiles = f.skipExistingFiles;
|
|
}
|
|
|
|
uploadFileArrayPtr = 0;
|
|
uploadFileArray = new ArrayList();
|
|
uploadFileDuplicateArray = new Hashtable();
|
|
|
|
foreach (ListViewItem l in leftListView.SelectedItems)
|
|
{
|
|
if (l.ImageIndex == 2)
|
|
{
|
|
bool overwrite = false;
|
|
bool overwriteNotLarger = false;
|
|
long remoteLength = 0;
|
|
string filename = l.Text;
|
|
foreach (ListViewItem l2 in rightListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) {
|
|
overwrite = true;
|
|
if (skipExistingFiles == false)
|
|
{
|
|
long localLength = new FileInfo(Path.Combine(localFolder.FullName, l.Text)).Length;
|
|
remoteLength = long.Parse(l2.SubItems[1].Text);
|
|
if (localLength >= remoteLength) { overwriteNotLarger = true; }
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ((skipExistingFiles == false) || (overwrite == false))
|
|
{
|
|
uploadFileArray.Add(l.Text);
|
|
if (overwriteNotLarger) { uploadFileDuplicateArray.Add(Path.Combine(localFolder.FullName, l.Text), remoteLength); }
|
|
}
|
|
}
|
|
}
|
|
|
|
if (uploadFileArray.Count == 0) return;
|
|
uploadLocalPath = localFolder;
|
|
uploadRemotePath = remoteFolder;
|
|
uploadActive = true;
|
|
uploadStop = false;
|
|
|
|
// Show transfer status dialog
|
|
transferStatusForm = new FileTransferStatusForm(this);
|
|
transferStatusForm.Show(this);
|
|
|
|
uploadNextFile();
|
|
}
|
|
|
|
private void uploadNextFile()
|
|
{
|
|
if ((uploadFileArray == null) || (uploadFileArray.Count == 0)) return;
|
|
|
|
string localFilePath, localFileName;
|
|
if (uploadLocalPath != null)
|
|
{
|
|
localFilePath = Path.Combine(uploadLocalPath.FullName, (string)uploadFileArray[uploadFileArrayPtr]);
|
|
localFileName = (string)uploadFileArray[uploadFileArrayPtr];
|
|
}
|
|
else
|
|
{
|
|
localFilePath = (string)uploadFileArray[uploadFileArrayPtr];
|
|
localFileName = Path.GetFileName(localFilePath);
|
|
}
|
|
try { uploadFileStream = File.OpenRead(localFilePath); } catch (Exception)
|
|
{
|
|
// Display the error
|
|
if (transferStatusForm != null) { transferStatusForm.addErrorMessage(String.Format(Translate.T(Properties.Resources.UnableToOpenFileX), localFileName)); }
|
|
|
|
// Skip to the next file
|
|
// Check if another file needs to be uploaded
|
|
if (uploadFileArray.Count > (uploadFileArrayPtr + 1))
|
|
{
|
|
// Upload the next file
|
|
uploadFileArrayPtr++;
|
|
uploadNextFile();
|
|
}
|
|
else
|
|
{
|
|
// Done with all files
|
|
uploadActive = false;
|
|
uploadStop = false;
|
|
uploadFileArrayPtr = -1;
|
|
uploadFileArray = null;
|
|
uploadFileDuplicateArray = null;
|
|
uploadLocalPath = null;
|
|
uploadRemotePath = null;
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileSize = 0;
|
|
uploadFileName = null;
|
|
closeTransferDialog();
|
|
remoteRefresh();
|
|
}
|
|
return;
|
|
}
|
|
uploadFileSize = new FileInfo(localFilePath).Length;
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileStartTime = DateTime.Now;
|
|
uploadFileName = localFileName;
|
|
|
|
// Check if the files already exist on the remote side
|
|
if (uploadFileDuplicateArray[localFilePath] != null)
|
|
{
|
|
// Send UPLOADHASH command
|
|
string cmd = "{\"action\":\"uploadhash\",\"reqid\":" + (uploadFileArrayPtr + 1000) + ",\"path\":\"" + uploadRemotePath + "\",\"name\":\"" + localFileName + "\",\"tag\":" + uploadFileDuplicateArray[localFilePath] + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
else
|
|
{
|
|
// Send UPLOAD command
|
|
string cmd = "{\"action\":\"upload\",\"reqid\":" + (uploadFileArrayPtr + 1000) + ",\"path\":\"" + uploadRemotePath + "\",\"name\":\"" + localFileName + "\",\"size\":" + uploadFileSize + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
}
|
|
|
|
public void uploadCancel()
|
|
{
|
|
if (uploadActive == false) return;
|
|
|
|
// Send UPLOADCANCEL command
|
|
string cmd = "{\"action\":\"uploadcancel\",\"reqid\":" + (uploadFileArrayPtr + 1000) + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
|
|
// Clear state
|
|
uploadActive = false;
|
|
uploadStop = false;
|
|
uploadFileArrayPtr = -1;
|
|
uploadFileArray = null;
|
|
uploadFileDuplicateArray = null;
|
|
uploadLocalPath = null;
|
|
uploadRemotePath = null;
|
|
uploadFilePtr = 0;
|
|
uploadFileStartPtr = 0;
|
|
uploadFileSize = 0;
|
|
if (uploadFileStream != null) { uploadFileStream.Close(); uploadFileStream = null; }
|
|
closeTransferDialog();
|
|
remoteRefresh();
|
|
}
|
|
|
|
private void uploadNextPart(bool dataPriming)
|
|
{
|
|
if (uploadActive == false) return;
|
|
byte[] buffer = new byte[16385];
|
|
int len = uploadFileStream.Read(buffer, 1, buffer.Length - 1);
|
|
if (dataPriming && (len == 0)) return;
|
|
uploadFilePtr += len;
|
|
|
|
if (len == 0) {
|
|
// Send UPLOADDONE command
|
|
string cmd = "{\"action\":\"uploaddone\",\"reqid\":" + (uploadFileArrayPtr + 1000) + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
} else {
|
|
// Send part of the file
|
|
// If starts with 0 or {, add a zero char at the start of the send, this will indicate that it's not a JSON command.
|
|
if ((buffer[1] == 123) || (buffer[1] == 0)) { wc.SendBinary(buffer, 0, len + 1); } else { wc.SendBinary(buffer, 1, len); }
|
|
}
|
|
}
|
|
|
|
private delegate void closeTransferDialogHandler();
|
|
|
|
private void closeTransferDialog()
|
|
{
|
|
if (transferStatusForm == null) return;
|
|
if (this.InvokeRequired) { this.Invoke(new closeTransferDialogHandler(closeTransferDialog)); return; }
|
|
if (transferStatusForm.showingError == false)
|
|
{
|
|
// Everything was succesful, close the form
|
|
transferStatusForm.Close();
|
|
transferStatusForm = null;
|
|
} else {
|
|
// Error are displayed, keep the form open
|
|
transferStatusForm.transferCompleted();
|
|
}
|
|
}
|
|
|
|
private void downloadButton_Click(object sender, EventArgs e)
|
|
{
|
|
// If a transfer is currently active, ignore this.
|
|
if (uploadActive || downloadActive || (transferStatusForm != null)) return;
|
|
|
|
// If any files are going to be overwritten
|
|
int overWriteCount = 0;
|
|
foreach (ListViewItem l in rightListView.SelectedItems)
|
|
{
|
|
if (l.ImageIndex == 2)
|
|
{
|
|
string filename = l.Text;
|
|
|
|
foreach (ListViewItem l2 in leftListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) { overWriteCount++; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
skipExistingFiles = true;
|
|
if (overWriteCount > 0)
|
|
{
|
|
FileConfirmOverwriteForm f = new FileConfirmOverwriteForm();
|
|
if (overWriteCount == 1) { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteOneFile), overWriteCount); } else { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteXfiles), overWriteCount); }
|
|
if (f.ShowDialog(this) != DialogResult.OK) return;
|
|
skipExistingFiles = f.skipExistingFiles;
|
|
}
|
|
|
|
// Perform the download
|
|
downloadFileArrayPtr = 0;
|
|
downloadFileArray = new ArrayList();
|
|
downloadFileSizeArray = new ArrayList();
|
|
foreach (ListViewItem l in rightListView.SelectedItems)
|
|
{
|
|
if (l.ImageIndex == 2)
|
|
{
|
|
if (skipExistingFiles == false)
|
|
{
|
|
downloadFileArray.Add(l.Text);
|
|
downloadFileSizeArray.Add(int.Parse(l.SubItems[1].Text));
|
|
}
|
|
else
|
|
{
|
|
bool overwrite = false;
|
|
string filename = l.Text;
|
|
foreach (ListViewItem l2 in leftListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) { overwrite = true; }
|
|
}
|
|
}
|
|
if (overwrite == false)
|
|
{
|
|
downloadFileArray.Add(l.Text);
|
|
downloadFileSizeArray.Add(int.Parse(l.SubItems[1].Text));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (downloadFileArray.Count == 0) return;
|
|
downloadLocalPath = localFolder;
|
|
downloadRemotePath = remoteFolder;
|
|
downloadActive = true;
|
|
downloadStop = false;
|
|
|
|
// Show transfer status dialog
|
|
transferStatusForm = new FileTransferStatusForm(this);
|
|
transferStatusForm.Show(this);
|
|
|
|
downloadNextFile();
|
|
}
|
|
|
|
private void downloadNextFile()
|
|
{
|
|
if ((downloadFileArray == null) || (downloadFileArray.Count == 0)) return;
|
|
|
|
string localFilePath;
|
|
localFilePath = Path.Combine(downloadLocalPath.FullName, (string)downloadFileArray[downloadFileArrayPtr]);
|
|
try { downloadFileStream = File.OpenWrite(localFilePath); } catch (Exception) {
|
|
// Download error, show it in the dialog
|
|
FileInfo f = new FileInfo(localFilePath);
|
|
if (transferStatusForm != null) { transferStatusForm.addErrorMessage(String.Format(Translate.T(Properties.Resources.UnableToWriteFileX), f.Name)); }
|
|
|
|
// Unable to download the file, skip it.
|
|
if (downloadFileArray.Count > downloadFileArrayPtr + 1)
|
|
{
|
|
// Download the next file
|
|
downloadFileArrayPtr++;
|
|
downloadNextFile();
|
|
}
|
|
else
|
|
{
|
|
// Done with all files
|
|
downloadActive = false;
|
|
downloadStop = false;
|
|
downloadFileArrayPtr = -1;
|
|
downloadFileArray = null;
|
|
downloadLocalPath = null;
|
|
downloadRemotePath = null;
|
|
closeTransferDialog();
|
|
localRefresh();
|
|
}
|
|
return;
|
|
}
|
|
downloadFileSize = (int)downloadFileSizeArray[downloadFileArrayPtr];
|
|
downloadFilePtr = 0;
|
|
downloadFileStartTime = DateTime.Now;
|
|
|
|
string r;
|
|
if (downloadRemotePath.EndsWith("/")) { r = downloadRemotePath + downloadFileArray[downloadFileArrayPtr]; } else { r = downloadRemotePath + "/" + downloadFileArray[downloadFileArrayPtr]; }
|
|
|
|
// Send DOWNLOAD command
|
|
string cmd = "{\"action\":\"download\",\"sub\":\"start\",\"id\":" + (downloadFileArrayPtr + 1000) + ",\"path\":\"" + r + "\"}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
|
|
private void downloadGotBinaryData(byte[] data, int offset, int length)
|
|
{
|
|
if ((length < 4) || (downloadFileStream == null)) return;
|
|
if (length > 4)
|
|
{
|
|
// Save part to disk
|
|
downloadFileStream.Write(data, offset + 4, length - 4);
|
|
downloadFilePtr += (length - 4);
|
|
}
|
|
int controlBits = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
|
|
if ((controlBits & 1) != 0)
|
|
{
|
|
if (downloadFileStream != null) { downloadFileStream.Close(); downloadFileStream = null; }
|
|
downloadFilePtr = 0;
|
|
downloadFileSize = 0;
|
|
|
|
if (downloadFileArray.Count > downloadFileArrayPtr + 1)
|
|
{
|
|
// Download the next file
|
|
downloadFileArrayPtr++;
|
|
downloadNextFile();
|
|
}
|
|
else
|
|
{
|
|
// Done with all files
|
|
downloadActive = false;
|
|
downloadStop = false;
|
|
downloadFileArrayPtr = -1;
|
|
downloadFileArray = null;
|
|
downloadLocalPath = null;
|
|
downloadRemotePath = null;
|
|
closeTransferDialog();
|
|
localRefresh();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Send DOWNLOAD command
|
|
string cmd = "{\"action\":\"download\",\"sub\":\"ack\",\"id\":" + (downloadFileArrayPtr + 1000) + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
}
|
|
}
|
|
|
|
public void downloadCancel()
|
|
{
|
|
if (downloadActive == false) return;
|
|
|
|
// Send DOWNLOAD command
|
|
string cmd = "{\"action\":\"download\",\"sub\":\"stop\",\"id\":" + (downloadFileArrayPtr + 1000) + "}";
|
|
byte[] bincmd = UTF8Encoding.UTF8.GetBytes(cmd);
|
|
wc.SendBinary(bincmd, 0, bincmd.Length);
|
|
|
|
// Done with all files
|
|
if (downloadFileStream != null) { downloadFileStream.Close(); downloadFileStream = null; }
|
|
downloadFilePtr = 0;
|
|
downloadFileSize = 0;
|
|
downloadActive = false;
|
|
downloadStop = false;
|
|
downloadFileArrayPtr = -1;
|
|
downloadFileArray = null;
|
|
downloadLocalPath = null;
|
|
downloadRemotePath = null;
|
|
closeTransferDialog();
|
|
localRefresh();
|
|
}
|
|
|
|
private void localNewFolderButton_Click(object sender, EventArgs e)
|
|
{
|
|
if (localFolder == null) return;
|
|
FilenamePromptForm f = new FilenamePromptForm(Translate.T(Properties.Resources.CreateFolder), "");
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
Directory.CreateDirectory(Path.Combine(localFolder.FullName, f.filename));
|
|
updateLocalFileView();
|
|
}
|
|
}
|
|
|
|
private void localDeleteButton_Click(object sender, EventArgs e)
|
|
{
|
|
bool rec = false;
|
|
ArrayList filesArray = new ArrayList();
|
|
foreach (ListViewItem l in leftListView.SelectedItems) { filesArray.Add(l.Text); if (l.ImageIndex == 1) { rec = true; } }
|
|
string[] files = (string[])filesArray.ToArray(typeof(string));
|
|
string msg = string.Format(Translate.T(Properties.Resources.RemoveXItems), files.Length);
|
|
if (files.Length == 1) { msg = Translate.T(Properties.Resources.Remove1Item); }
|
|
FileDeletePromptForm f = new FileDeletePromptForm(msg, rec);
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
foreach (string file in filesArray)
|
|
{
|
|
try {
|
|
string fullpath = Path.Combine(localFolder.FullName, file);
|
|
FileAttributes attr = File.GetAttributes(fullpath);
|
|
if ((attr & FileAttributes.Directory) == FileAttributes.Directory) { Directory.Delete(fullpath, f.recursive); } else { File.Delete(fullpath); }
|
|
} catch (Exception) { }
|
|
}
|
|
updateLocalFileView();
|
|
}
|
|
}
|
|
|
|
private void rightListView_DragEnter(object sender, DragEventArgs e)
|
|
{
|
|
if (uploadActive || downloadActive || (transferStatusForm != null)) return;
|
|
if ((node.agentid < 5) && ((remoteFolder == null) || (remoteFolder == ""))) { return; }
|
|
if (e.Data.GetDataPresent(DataFormats.FileDrop)) e.Effect = DragDropEffects.Copy;
|
|
}
|
|
|
|
private void rightListView_DragDrop(object sender, DragEventArgs e)
|
|
{
|
|
if (uploadActive || downloadActive || (transferStatusForm != null)) return;
|
|
if ((node.agentid < 5) && ((remoteFolder == null) || (remoteFolder == ""))) { return; }
|
|
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
|
|
|
|
// If any files are going to be overwritten
|
|
int overWriteCount = 0;
|
|
foreach (string file in files)
|
|
{
|
|
FileInfo f = new FileInfo(file);
|
|
string filename = f.Name;
|
|
foreach (ListViewItem l2 in rightListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) { overWriteCount++; }
|
|
}
|
|
}
|
|
}
|
|
skipExistingFiles = true;
|
|
if (overWriteCount > 0)
|
|
{
|
|
FileConfirmOverwriteForm f = new FileConfirmOverwriteForm();
|
|
if (overWriteCount == 1) { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteOneFile), overWriteCount); } else { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteXfiles), overWriteCount); }
|
|
if (f.ShowDialog(this) != DialogResult.OK) return;
|
|
skipExistingFiles = f.skipExistingFiles;
|
|
}
|
|
|
|
// Perform the upload
|
|
uploadFileArrayPtr = 0;
|
|
uploadFileArray = new ArrayList();
|
|
uploadFileDuplicateArray = new Hashtable();
|
|
|
|
foreach (string file in files)
|
|
{
|
|
bool overwrite = false;
|
|
bool overwriteNotLarger = false;
|
|
long remoteLength = 0;
|
|
string filename = Path.GetFileName(file);
|
|
foreach (ListViewItem l2 in rightListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) {
|
|
overwrite = true;
|
|
if (skipExistingFiles == false)
|
|
{
|
|
long localLength = new FileInfo(file).Length;
|
|
remoteLength = long.Parse(l2.SubItems[1].Text);
|
|
if (localLength >= remoteLength) { overwriteNotLarger = true; }
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ((skipExistingFiles == false) || (overwrite == false)) {
|
|
uploadFileArray.Add(file);
|
|
if (overwriteNotLarger) { uploadFileDuplicateArray.Add(file, remoteLength); }
|
|
}
|
|
}
|
|
|
|
if (uploadFileArray.Count == 0) return;
|
|
uploadLocalPath = null;
|
|
uploadRemotePath = remoteFolder;
|
|
uploadActive = true;
|
|
uploadStop = false;
|
|
|
|
// Show transfer status dialog
|
|
transferStatusForm = new FileTransferStatusForm(this);
|
|
transferStatusForm.Show(this);
|
|
|
|
uploadNextFile();
|
|
}
|
|
|
|
private void leftListView_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button == MouseButtons.Left)
|
|
{
|
|
ArrayList files = new ArrayList();
|
|
foreach (ListViewItem l in leftListView.SelectedItems) { if (l.ImageIndex == 2) { files.Add(Path.Combine(localFolder.FullName, l.Text)); } }
|
|
if (files.Count > 0)
|
|
{
|
|
leftListView.DoDragDrop(new DataObject(DataFormats.FileDrop, (string[])files.ToArray(typeof(string))), DragDropEffects.Copy);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void rightListView_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button == MouseButtons.Left)
|
|
{
|
|
ArrayList XdownloadFileArray = new ArrayList();
|
|
ArrayList XdownloadFileSizeArray = new ArrayList();
|
|
foreach (ListViewItem l in rightListView.SelectedItems)
|
|
{
|
|
if (l.ImageIndex == 2)
|
|
{
|
|
XdownloadFileArray.Add(l.Text);
|
|
XdownloadFileSizeArray.Add(int.Parse(l.SubItems[1].Text));
|
|
}
|
|
}
|
|
if (XdownloadFileArray.Count > 0)
|
|
{
|
|
DataObject dataObj = new DataObject();
|
|
dataObj.SetData("Type", "MeshCentralRouterRemoteFiles-" + rndString);
|
|
dataObj.SetData("RemoteFiles", XdownloadFileArray);
|
|
dataObj.SetData("RemoteSizes", XdownloadFileSizeArray);
|
|
dataObj.SetData("RemoteFolder", remoteFolder);
|
|
rightListView.DoDragDrop(dataObj, DragDropEffects.Copy);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void leftListView_DragEnter(object sender, DragEventArgs e)
|
|
{
|
|
if (uploadActive || downloadActive || (localFolder == null) || (transferStatusForm != null)) return;
|
|
if ((e.Data.GetDataPresent("Type") == true) && ((string)e.Data.GetData("Type") == ("MeshCentralRouterRemoteFiles-" + rndString))) { e.Effect = DragDropEffects.Copy; }
|
|
}
|
|
|
|
private void leftListView_DragDrop(object sender, DragEventArgs e)
|
|
{
|
|
if (uploadActive || downloadActive || (transferStatusForm != null)) return;
|
|
if ((e.Data.GetDataPresent("Type") == false) || ((string)e.Data.GetData("Type") != ("MeshCentralRouterRemoteFiles-" + rndString))) return;
|
|
|
|
ArrayList files = (ArrayList)e.Data.GetData("RemoteFiles");
|
|
|
|
// If any files are going to be overwritten
|
|
int overWriteCount = 0;
|
|
foreach (string file in files)
|
|
{
|
|
string filename = file;
|
|
foreach (ListViewItem l2 in leftListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) { overWriteCount++; }
|
|
}
|
|
}
|
|
}
|
|
skipExistingFiles = true;
|
|
if (overWriteCount > 0)
|
|
{
|
|
FileConfirmOverwriteForm f = new FileConfirmOverwriteForm();
|
|
if (overWriteCount == 1) { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteOneFile), overWriteCount); } else { f.mainTextLabel = String.Format(Translate.T(Properties.Resources.OverwriteXfiles), overWriteCount); }
|
|
if (f.ShowDialog(this) != DialogResult.OK) return;
|
|
skipExistingFiles = f.skipExistingFiles;
|
|
}
|
|
|
|
// Perform downloads
|
|
downloadFileArrayPtr = 0;
|
|
downloadFileArray = (ArrayList)e.Data.GetData("RemoteFiles");
|
|
downloadFileSizeArray = (ArrayList)e.Data.GetData("RemoteSizes");
|
|
|
|
if (skipExistingFiles == true)
|
|
{
|
|
ArrayList downloadFileArray2 = new ArrayList();
|
|
ArrayList downloadFileSizeArray2 = new ArrayList();
|
|
|
|
for (int i = 0; i < downloadFileArray.Count; i++)
|
|
{
|
|
bool overwrite = false;
|
|
string filename = (string)downloadFileArray[i];
|
|
foreach (ListViewItem l2 in leftListView.Items)
|
|
{
|
|
if (l2.ImageIndex == 2)
|
|
{
|
|
string filename2 = l2.Text;
|
|
if (node.agentid < 5) { filename = filename.ToLower(); filename2 = filename2.ToLower(); }
|
|
if (filename.Equals(filename2)) { overwrite = true; }
|
|
}
|
|
}
|
|
if (overwrite == false)
|
|
{
|
|
downloadFileArray2.Add(downloadFileArray[i]);
|
|
downloadFileSizeArray2.Add(downloadFileSizeArray[i]);
|
|
}
|
|
}
|
|
|
|
downloadFileArray = downloadFileArray2;
|
|
downloadFileSizeArray = downloadFileSizeArray2;
|
|
}
|
|
|
|
if (downloadFileArray.Count == 0) return;
|
|
|
|
downloadLocalPath = localFolder;
|
|
downloadRemotePath = (string)e.Data.GetData("RemoteFolder");
|
|
downloadActive = true;
|
|
downloadStop = false;
|
|
|
|
// Show transfer status dialog
|
|
transferStatusForm = new FileTransferStatusForm(this);
|
|
transferStatusForm.Show(this);
|
|
|
|
downloadNextFile();
|
|
}
|
|
private static string getRandomString(int length)
|
|
{
|
|
using (var rng = new RNGCryptoServiceProvider())
|
|
{
|
|
var bytes = new byte[(((length * 6) + 7) / 8)];
|
|
rng.GetBytes(bytes);
|
|
return Convert.ToBase64String(bytes);
|
|
}
|
|
}
|
|
|
|
bool isPointVisibleOnAScreen(Point p)
|
|
{
|
|
foreach (Screen s in Screen.AllScreens) { if ((p.X < s.Bounds.Right) && (p.X > s.Bounds.Left) && (p.Y > s.Bounds.Top) && (p.Y < s.Bounds.Bottom)) return true; }
|
|
return false;
|
|
}
|
|
|
|
private void localContextMenuStrip_Opening(object sender, System.ComponentModel.CancelEventArgs e)
|
|
{
|
|
if ((leftListView.SelectedItems.Count == 0) || (localFolder == null))
|
|
{
|
|
deleteToolStripMenuItem1.Visible = toolStripMenuItem2.Visible = renameToolStripMenuItem1.Visible = false;
|
|
}
|
|
else if (leftListView.SelectedItems.Count == 1)
|
|
{
|
|
deleteToolStripMenuItem1.Visible = toolStripMenuItem2.Visible = renameToolStripMenuItem1.Visible = true;
|
|
}
|
|
else if (leftListView.SelectedItems.Count > 1)
|
|
{
|
|
renameToolStripMenuItem1.Visible = false;
|
|
deleteToolStripMenuItem1.Visible = toolStripMenuItem2.Visible = true;
|
|
}
|
|
}
|
|
|
|
private void renameToolStripMenuItem1_Click(object sender, EventArgs e)
|
|
{
|
|
if ((leftListView.SelectedItems.Count != 1) || (localFolder == null)) return;
|
|
string oldname = leftListView.SelectedItems[0].Text;
|
|
FilenamePromptForm f = new FilenamePromptForm(Translate.T(Properties.Resources.Rename), oldname);
|
|
if (f.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
if (oldname == f.filename) return;
|
|
FileInfo fileinfo = new FileInfo(Path.Combine(localFolder.FullName, oldname));
|
|
if (fileinfo.Exists == false) return;
|
|
try { fileinfo.MoveTo(Path.Combine(localFolder.FullName, f.filename)); } catch (Exception) { }
|
|
localRefresh();
|
|
}
|
|
}
|
|
}
|
|
}
|