void DropFile(string path, int useID)
 {
     try
     {
         string   filename = path.Replace("/GetFile ", "");
         FileInfo fi       = new FileInfo(filename);
         using (FileStream fs = new FileStream(filename, FileMode.Open))
         { }
         EmigrationFileInfo efi = new EmigrationFileInfo()
         {
             FileName = fi.Name, Size = fi.Length
         };
         EmigrationObject getfile = new EmigrationObject()
         {
             type = "file", message = efi
         };
         byte[] infofilebytes = ObjectToByteArray(getfile);
         Clients[useID].stream.Write(infofilebytes, 0, infofilebytes.Length);
         AddConsoleMessage($"{Clients[useID].name} begin to download {fi.Name}");
         using (FileStream fs = new FileStream(filename, FileMode.Open))
         {
             byte[] PieceOfFile = new byte[fs.Length];
             fs.Read(PieceOfFile, 0, PieceOfFile.Length);
             Clients[useID].stream.Write(PieceOfFile, 0, PieceOfFile.Length);
         }
     }
     catch (Exception ex)
     {
         //Если не можем открыть файл
     }
 }
Esempio n. 2
0
        void DropFile(List <string> files)
        {
            SendMessage("/DropFile");                          // отправляем команду серверу на получение информации об транзакции
            Thread.Sleep(50);
            EmigrationFileInfo efi = new EmigrationFileInfo(); //формируем информацию об транзакции

            efi.Size     = files.Count;
            efi.FileName = currentFTPpath;
            SendMessage(ObjectToByteArray(efi)); // отправляем информацию серверу про количество файлов и пути для сохранения
            Thread.Sleep(50);
            foreach (string filepath in files)
            {
                try
                {
                    using (FileStream fs = new FileStream(filepath, FileMode.Open)) //проверяем все файлы на то можем ли мы их открыть, если нет выходим из функции
                    {
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Exception with drop file", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
            }
            // поочерёдная передача файлов
            foreach (string filepath in files)
            {
                FileInfo fi = new FileInfo(filepath);
                efi = new EmigrationFileInfo()
                {
                    FileName = fi.Name, Size = fi.Length
                };
                SendMessage(ObjectToByteArray(efi));//отправляем информацию про файл
                Thread.Sleep(50);
                using (FileStream fs = new FileStream(filepath, FileMode.Open))
                {
                    byte[] File = new byte[fs.Length];
                    fs.Read(File, 0, File.Length);
                    SendMessage(File);
                    Thread.Sleep(50);
                }
            }
            Button_Click_1(null, null);
        }
 static void DownloadFile(EmigrationFileInfo efi)
 {
     try
     {
         using (FileStream fs = new FileStream(System.Environment.CurrentDirectory + "\\App" + "\\" + efi.FileName, FileMode.Create))
         {
             long   currentBytes = 0;
             byte[] data;
             while (currentBytes < efi.Size)
             {
                 data = new byte[1];
                 stream.Read(data, 0, data.Length);
                 fs.WriteByte(data[0]);
                 currentBytes++;
             }
         }
     }
     catch (Exception ex) { }
 }
        void TakeFile(int userID)
        {
            NetworkStream currStrm = Clients[userID].stream;

            byte[] buf = new byte[11000];
            currStrm.Read(buf, 0, buf.Length);
            EmigrationFileInfo efi  = (EmigrationFileInfo)ByteArrayToObject(buf);
            string             path = efi.FileName;
            int cntFiles            = (int)efi.Size;

            for (int i = 0; i < cntFiles; i++)
            {
                buf = new byte[11000];
                currStrm.Read(buf, 0, buf.Length);
                efi = (EmigrationFileInfo)ByteArrayToObject(buf);
                using (FileStream fs = new FileStream(path + "\\" + efi.FileName, FileMode.Create))
                {
                    long   currentBytes = 0;
                    byte[] data;
                    while (currentBytes < efi.Size)
                    {
                        data = new byte[1];
                        currStrm.Read(data, 0, data.Length);
                        fs.WriteByte(data[0]);
                        currentBytes++;
                    }
                }
            }
            //DownloadComplete
            EmigrationObject em = new EmigrationObject()
            {
                type = "DownloadComplete"
            };

            buf = ObjectToByteArray(em);
            Clients[userID].stream.Write(buf, 0, buf.Length);
            Clients[userID].IsBusy = false;
        }
Esempio n. 5
0
 void DownloadFile(EmigrationFileInfo efi)
 {
     //CancelDown.Set(() => CancelDown.IsEnabled = true);
     try
     {
         isFileDownload = true;
         using (FileStream fs = new FileStream(DownloadPath + "\\" + efi.FileName, FileMode.Create))
         {
             //PgDownloadFile.Set(() =>
             //{
             //    PgDownloadFile.Maximum = efi.Size;
             //    PgDownloadFile.Minimum = 0;
             //});
             long   currentBytes = 0;
             byte[] data;
             while (currentBytes < efi.Size)
             {
                 data = new byte[1];
                 stream.Read(data, 0, data.Length);
                 fs.WriteByte(data[0]);
                 currentBytes++;
                 //if (currentBytes % 1000000 == 0)
                 //{
                 //    PgDownloadFile.Set(() =>
                 //    {
                 //        PgDownloadFile.Value = currentBytes;
                 //    });
                 //}
             }
             //PgDownloadFile.Set(() =>
             //{
             //    PgDownloadFile.Value = 0;
             //});
         }
         isFileDownload = false;
     }
     catch (Exception ex) { Title = ex.Message; }
 }
        static void Main()
        {
            try
            {
                _Client.Connect("77.93.61.5", 21025);
                stream = _Client.GetStream();
                Console.WriteLine("Connection status: Online.");

                string message = Environment.MachineName;
                byte[] data    = Encoding.UTF8.GetBytes(message);
                stream.Write(data, 0, data.Length);

                int bytes = 0;
                data    = new byte[1024];
                bytes   = stream.Read(data, 0, data.Length);
                message = Encoding.UTF8.GetString(data, 0, bytes);
                Console.WriteLine(message);

                data = Encoding.UTF8.GetBytes("/GetVersion");
                stream.Write(data, 0, data.Length);

                bytes = 0;
                data  = new byte[1024];
                bytes = stream.Read(data, 0, data.Length);
                string clientVersion = Encoding.UTF8.GetString(data, 0, bytes);
                string currentVersion;
                using (FileStream fs = new FileStream("version.cfg", FileMode.Open))
                {
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        currentVersion = sr.ReadToEnd();
                    }
                }
                currentVersion = currentVersion.Replace("version: ", "");
                if (clientVersion == currentVersion)
                {
                    string path = System.Environment.CurrentDirectory + "\\App\\WpfConnectClient.exe";
                    System.Diagnostics.Process.Start(path);
                }
                else
                {
                    DirectoryInfo di = new DirectoryInfo("App");
                    di.GetFiles().ToList().ForEach(a => a.Delete());

                    //Шлём запрос на получение фалов программы
                    for (int i = 0; i < 9; i++)
                    {
                        message = $"/GetApp {i}";
                        data    = Encoding.UTF8.GetBytes(message);
                        stream.Write(data, 0, data.Length);

                        data  = new byte[500000];
                        bytes = stream.Read(data, 0, data.Length);
                        EmigrationObject eo = ByteArrayToObject(data) as EmigrationObject;
                        if (eo.type == "file")
                        {
                            EmigrationFileInfo efi = (EmigrationFileInfo)eo.message;
                            DownloadFile(efi);
                        }
                    }
                    Console.WriteLine("Update download complete...");
                    using (FileStream fs = new FileStream("version.cfg", FileMode.Create))
                    {
                        using (StreamWriter sw = new StreamWriter(fs))
                        {
                            sw.Write("version: " + clientVersion);
                        }
                    }
                    string path = System.Environment.CurrentDirectory + "\\App\\WpfConnectClient.exe";
                    System.Diagnostics.Process.Start(path);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("I can`t connect....");
            }
        }
Esempio n. 7
0
        // получение сообщений
        void ReceiveMessage()
        {
            while (true)
            {
                try
                {
                    EmigrationObject message;
                    int bytes = 0;
                    do
                    {
                        byte[] data = new byte[500000];
                        bytes   = stream.Read(data, 0, data.Length);
                        message = ByteArrayToObject(data) as EmigrationObject;
                        if (message.type == "file")
                        {
                            EmigrationFileInfo efi = (EmigrationFileInfo)message.message;
                            Tabs.Set(() => Tabs.Visibility = Visibility.Hidden);
                            DownloadFile(efi);
                            Tabs.Set(() => Tabs.Visibility = Visibility.Visible);
                        }
                    }while (stream.DataAvailable);

                    switch (message.type)
                    {
                    case "string":

                        break;

                    case "List<EmigrationPathInfo>":
                        List <EmigrationPathInfo> list = (List <EmigrationPathInfo>)message.message;
                        currentFTPpath = list[0].Name;
                        LabelPathFolder.Set(() => LabelPathFolder.Content = currentFTPpath);
                        list.RemoveAt(0);
                        FolderTreeView.Set(() => FolderTreeView.Items.Clear());
                        FolderTreeView.Set(() => {
                            list.ForEach(a => {
                                TemplateFileElement tfe = new TemplateFileElement();
                                tfe.isFile = a.isFile;
                                tfe.path   = a.Name;
                                tfe.icon   = ToImageSource(BytesToIcon(a.ImagePath));
                                FolderTreeView.Items.Add(tfe);
                            });
                        });
                        break;

                    case "DownloadComplete":
                        Tabs.Set(() => Tabs.Visibility = Visibility.Visible);
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Tabs.Set(() => {
                        Tabs.Set(() => Tabs.SelectedIndex = 0);
                        Title = "Client: Disconnect.";
                        this.ShowMessageAsync("Error", ex.Message);
                    });
                    return;
                }
            }
        }