private void SendRequest(int index)
        {
            RequestMessage message = new RequestMessage
            {
                Id = index,
                Request = string.Format("This is request {0}", index)
            };

            byte[] messageBody = message.ToByteArray();

            IBasicProperties requestProperties = channel.CreateBasicProperties();
            requestProperties.CorrelationId = Guid.NewGuid().ToString();
            requestProperties.ReplyTo = replyQueueName;

            this.channel.BasicPublish(string.Empty, ConnectionConstants.QueueName, requestProperties, messageBody);
            Console.WriteLine("Sent message #{0}", index);
            ReadReply();
        }
        // Получение списка.
        public static void List_Recieving(object income)
        {
            // Буффер входящих сообщений.
            Byte[] bytes = new Byte[1024];
            // Выделение потока для обмена информацией с клиентом.
            NetworkStream stream = (NetworkStream)income;
            // Запрос файлов.
            RequestMessage req = new RequestMessage("Send me");
            // Ответ.
            ResponseMessage res = new ResponseMessage("Response");
            // Сообщение полученное от клиента.
            Message LM;

            try
            {
                // Оправка уведомления о готовности.
                NW.Send(req, stream);

                // Получение списка файлов.
                do
                {
                    // Прочесть ответ хаба.
                    LM = NW.Recieve(stream);

                    // Проверить является ли ответ именем файла.
                    if (!(LM is EndMessage))
                    {
                        // Добавление файла в список.
                        Files.Add(LM.Get_Data(), stream);

                        // Отослать назад уведомление.
                        NW.Send(res, stream);
                    }
                } while (!(LM is EndMessage));

            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
        }
        // Отправка файла.
        public void Send_File(string s)
        {
            // Сообщение содержащее часть файла.
            Messages.Message mes;
            // Сообщение содержащее имя файла.
            RequestMessage name = new RequestMessage(s);
            // Сообщение содержащее подтверждение получения.
            Messages.Message resp;
            // Размер буффера считываемых данных.
            const int buffersz = 1022;
            // Буффер для частей файла.
            byte[] buffer = new byte[buffersz];
            // Размер считанных данных.
            int btscpd = 0;

            // Выделение пути к запрашиваемому файлу.
            string path = Path.Combine(cl_path, s);

            // Проверка существования файла.
            if (File.Exists(path))
            {
                // Выделение потоков для отправки файла.
                using (FileStream inFile = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                using (NetworkStream stream = clnt.GetStream())
                {
                    // Отправка имени файла.
                    NW.Send(name, stream);

                    // Ожидание ответа.
                    do
                    {
                        resp = NW.Recieve(stream);
                    }
                    while (resp.Get_Data() == string.Empty);

                    do
                    {
                        // Считывание данных с файла.
                        btscpd = inFile.Read(buffer, 0, buffersz);
                        // Проверка на пустоту считанных данных.
                        if (btscpd > 0)
                        {
                            mes = new FilePartMessage(Encoding.ASCII.GetString(buffer));
                            // Отправка пакета.
                            NW.Send(mes, stream);

                            // Получение подтверждения.
                            while (true)
                            {
                                resp = NW.Recieve(stream);

                                if (resp.Get_Data() != "")
                                {
                                    resp = new ResponseMessage(string.Empty);
                                    break;
                                }
                            }
                        }
                    } while (btscpd > 0);

                    // Для устранения ошибки преждевременного обрывания.
                    Thread.Sleep(50);

                    // Отправка уведомления о конце файла.
                    mes = new EndMessage("End of file");
                    NW.Send(mes, stream);
                }

            }
            else
            {
                using (NetworkStream stream = clnt.GetStream())
                {
                    mes = new ErrorMessage("File is not exsiting");
                    NW.Send(mes, stream);
                }
            }
        }
        // Протокол получения файла.
        public void Receiving(string s)
        {
            // Обработанное входящее сообщение.
            Messages.Message mess = new FilePartMessage(string.Empty);
            // Сообщение содержащее имя.
            RequestMessage name;
            // Уведомительное сообщение.
            ResponseMessage response = new ResponseMessage("Response");
            // Буффер для получения ответа.
            byte[] pack = new byte[1024];

            // Выделение пути к файлу.
            string path = Path.Combine(cl_path, s);
            // Выделение потоков для получения файла.
            using (FileStream outFile = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
            using (NetworkStream stream = clnt.GetStream())
            {
                name = new RequestMessage(s);
                // Отправка имени.
                NW.Send(name, stream);
                do
                {
                    // Получение части файла.
                    mess = NW.Recieve(stream);

                    // Проверка на завершение скачивания.
                    if (!(mess is EndMessage))
                    {
                        // Запись в файл.
                        outFile.Write(mess.Get_Info(), 0, mess.Get_Info().Length);
                        // Отправка уведомления.
                        NW.Send(response, stream);
                    }

                } while (!(mess is EndMessage));

                // Отчет об успешном скачивании.
                MessageBox.Show("Downloading is complete!", "Complete", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
 // Раскрыть пакет.
 public Message Decrypt(byte[] b)
 {
     // Возвращаемое значение.
     Message mes;
     // Строка, полученная из полученного массива байт.
     string str = Encoding.ASCII.GetString(b);
     // Тип сообщений.
     if (str[0] != '\0')
     {
         int type = int.Parse(str[0].ToString());
         int border = str.IndexOf('\0');
         if (border==(-1))
         {
             border = str.Length;
         }
         if (type != -1)
         {
             // Строка данных.
             string assis = str.Substring(1, border - 1);
             // Определение типа сообщения.
             switch (type)
             {
                 case 0:
                     mes = new Inform_of_Down_Message(assis);
                     break;
                 case 1:
                     mes = new Inform_of_Rec_Message(assis);
                     break;
                 case 2:
                     mes = new ListMessage(assis);
                     break;
                 case 3:
                     mes = new RequestMessage(assis);
                     break;
                 case 4:
                     mes = new FilePartMessage(assis);
                     break;
                 case 5:
                     mes = new EndMessage(assis);
                     break;
                 case 6:
                     mes = new ResponseMessage(assis);
                     break;
                 case 7:
                     mes = new ErrorMessage(assis);
                     break;
                 case 8:
                     mes = new HubInformMessage(assis);
                     break;
                 default:
                     mes = new Message(assis);
                     break;
             }
         }
         else
             mes = new Message(string.Empty);
         return mes;
     }
     else
         return new Message(string.Empty);
 }
Example #6
0
        protected virtual void HandleRequestMessage(PeerId id, RequestMessage message)
        {
            // If we are not on the last piece and the user requested a stupidly big/small amount of data
            // we will close the connection
            if (_manager.Torrent.Pieces.Count != (message.PieceIndex + 1))
                if (message.RequestLength > RequestMessage.MaxSize || message.RequestLength < RequestMessage.MinSize)
                    throw new MessageException("Illegal piece request received. Peer requested " +
                                               message.RequestLength.ToString() + " byte");

            var m = new PieceMessage(message.PieceIndex, message.StartOffset, message.RequestLength);

            // If we're not choking the peer, enqueue the message right away
            if (!id.AmChoking)
            {
                id.IsRequestingPiecesCount++;
                id.PieceReads.Add(m);
                id.TryProcessAsyncReads();
            }

                // If the peer supports fast peer and the requested piece is one of the allowed pieces, enqueue it
                // otherwise send back a reject request message
            else if (id.SupportsFastPeer && ClientEngine.SupportsFastPeer)
            {
                if (id.AmAllowedFastPieces.Contains(message.PieceIndex))
                {
                    id.IsRequestingPiecesCount++;
                    id.PieceReads.Add(m);
                    id.TryProcessAsyncReads();
                }
                else
                    id.Enqueue(new RejectRequestMessage(m));
            }
        }
 protected override void HandleRequestMessage(PeerId id, RequestMessage message)
 {
     base.HandleRequestMessage(id, message);
     _unchoker.SentBlock(id, message.PieceIndex);
 }
 private ReplyMessage MakeReply(RequestMessage message)
 {
     return new ReplyMessage
     {
         Id = message.Id,
         Reply = "Reply to " + message.Request
     };
 }