示例#1
0
        static internal void Run(Udt.Socket conn, string file, bool bVerbose)
        {
            int ini = Environment.TickCount;

            using (Udt.NetworkStream netStream = new Udt.NetworkStream(conn))
                using (BinaryWriter writer = new BinaryWriter(netStream))
                    using (BinaryReader reader = new BinaryReader(netStream))
                        using (FileStream fileReader = new FileStream(file, FileMode.Open, FileAccess.Read))
                        {
                            long fileSize = new FileInfo(file).Length;

                            writer.Write(Path.GetFileName(file));
                            writer.Write(fileSize);

                            byte[] buffer = new byte[512 * 1024];

                            long pos = 0;

                            int i = 0;

                            ConsoleProgress.Draw(i++, pos, fileSize, ini, Console.WindowWidth / 3);

                            while (pos < fileSize)
                            {
                                int toSend = buffer.Length < (fileSize - pos)
                        ? buffer.Length
                        : (int)(fileSize - pos);

                                fileReader.Read(buffer, 0, toSend);

                                int iteration = Environment.TickCount;

                                writer.Write(toSend);
                                conn.Send(buffer, 0, toSend);

                                if (!reader.ReadBoolean())
                                {
                                    Console.WriteLine("Error in transmission");
                                    return;
                                }

                                pos += toSend;

                                ConsoleProgress.Draw(i++, pos, fileSize, ini, Console.WindowWidth / 3);

                                if (bVerbose)
                                {
                                    Console.WriteLine();

                                    Console.WriteLine("Current: {0} / s",
                                                      SizeConverter.ConvertToSizeString(toSend / (Environment.TickCount - iteration) * 1000));

                                    Console.WriteLine("BandwidthMbps {0} mbps.", conn.GetPerformanceInfo().Probe.BandwidthMbps);
                                    Console.WriteLine("RoundtripTime {0}.", conn.GetPerformanceInfo().Probe.RoundtripTime);
                                    Console.WriteLine("SendMbps {0}.", conn.GetPerformanceInfo().Local.SendMbps);
                                    Console.WriteLine("ReceiveMbps {0}.", conn.GetPerformanceInfo().Local.ReceiveMbps);
                                }
                            }
                        }
        }
示例#2
0
        static internal void Run(Udt.Socket conn)
        {
            int ini = Environment.TickCount;

            using (Udt.NetworkStream netStream = new Udt.NetworkStream(conn))
                using (BinaryWriter writer = new BinaryWriter(netStream))
                    using (BinaryReader reader = new BinaryReader(netStream))
                    {
                        string fileName = reader.ReadString();
                        long   size     = reader.ReadInt64();

                        byte[] buffer = new byte[4 * 1024 * 1024];

                        int i = 0;

                        ConsoleProgress.Draw(i++, 0, size, ini, Console.WindowWidth / 2);

                        using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
                        {
                            long read = 0;

                            while (read < size)
                            {
                                int toRecv = reader.ReadInt32();

                                ReadFragment(reader, toRecv, buffer);

                                fileStream.Write(buffer, 0, toRecv);

                                read += toRecv;

                                writer.Write(true);

                                ConsoleProgress.Draw(i++, read, size, ini, Console.WindowWidth / 2);
                            }
                        }
                    }
        }
示例#3
0
        static internal void Run(PseudoTcpSocket conn, string file, bool bVerbose)
        {
            int   ini = Environment.TickCount;
            Queue notifyClockQueue = new Queue();

            using (FileStream fileReader = new FileStream(file, FileMode.Open, FileAccess.Read))
            {
                long   fileSize  = new FileInfo(file).Length;
                byte[] ackBuffer = new byte[1];

                PLog.DEBUG("Sending filename {0}", Path.GetFileName(file));
                byte[] fileNameBytes       = Encoding.UTF8.GetBytes(Path.GetFileName(file));
                byte[] fileNameBytesLength = BitConverter.GetBytes(fileNameBytes.Length);
                PLog.DEBUG("Length of file name in bytes={0}", fileNameBytesLength);

                SyncPseudoTcpSocket.Send(conn, fileNameBytesLength, (uint)fileNameBytesLength.Length);
                SyncPseudoTcpSocket.Recv(conn, ackBuffer, 1);
                PLog.DEBUG("Sent filename length, ack={0}", ackBuffer [0]);

                SyncPseudoTcpSocket.Send(conn, fileNameBytes, (uint)fileNameBytes.Length);
                SyncPseudoTcpSocket.Recv(conn, ackBuffer, 1);
                PLog.DEBUG("Sent filename bytes {0}={1}, ack={2}",
                           fileNameBytes, BitConverter.ToString(fileNameBytes), ackBuffer[0]);

                SyncPseudoTcpSocket.Send(conn, BitConverter.GetBytes(fileSize), 8);
                SyncPseudoTcpSocket.Recv(conn, ackBuffer, 1);
                PLog.DEBUG("Sent file size, ack={0}", ackBuffer [0]);

                byte[] buffer = new byte[512 * 1024];

                long pos = 0;

                int i = 0;

                ConsoleProgress.Draw(i++, pos, fileSize, ini, Console.WindowWidth / 3);

                while (pos < fileSize)
                {
                    ProcessNotifyClockQueue(conn, notifyClockQueue);

                    int toSend = buffer.Length < (fileSize - pos)
                        ? buffer.Length
                        : (int)(fileSize - pos);

                    PLog.DEBUG("File reading: pos={0}, fileSize={1}, toSend={2}", pos, fileSize, toSend);

                    fileReader.Read(buffer, 0, toSend);

                    int iteration = Environment.TickCount;

                    int sent;
                    int totalSent    = 0;
                    int fragmentSize = toSend;
                    while (totalSent < toSend)
                    {
                        sent = SendFragment(conn, buffer, fragmentSize, notifyClockQueue);

                        totalSent += sent;
                        PLog.DEBUG("totalSent={0} sent={1} fragmentSize={2}", totalSent, sent, fragmentSize);
                        if (sent < fragmentSize)
                        {
                            byte[] buffer2 = new byte[fragmentSize - sent];
                            Buffer.BlockCopy(buffer, sent, buffer2, 0, buffer2.Length);
                            fragmentSize = buffer2.Length;
                            buffer       = buffer2;
                        }
                    }
                    PLog.DEBUG("finished sending toSend={0}", toSend);

                    pos += toSend;

                    ConsoleProgress.Draw(i++, pos, fileSize, ini, Console.WindowWidth / 3);

                    if (bVerbose)
                    {
                        Console.WriteLine();

                        Console.WriteLine("Current: {0} / s",
                                          SizeConverter.ConvertToSizeString(toSend / (Environment.TickCount - iteration) * 1000));

                        //Console.WriteLine("BandwidthMbps {0} mbps.", conn.GetPerformanceInfo().Probe.BandwidthMbps);
                        //Console.WriteLine("RoundtripTime {0}.", conn.GetPerformanceInfo().Probe.RoundtripTime);
                        //Console.WriteLine("SendMbps {0}.", conn.GetPerformanceInfo().Local.SendMbps);
                        //Console.WriteLine("ReceiveMbps {0}.", conn.GetPerformanceInfo().Local.ReceiveMbps);
                    }
                }
            }

            Console.WriteLine();
            while (conn.priv.sbuf.data_length != 0)
            {
                Console.WriteLine("Waiting for buffered data to finish sending...");
                for (int i = 0; i < 20; i++)
                {
                    conn.NotifyClock();
                    Thread.Sleep(50);
                }
            }

            Console.WriteLine();
            Console.WriteLine("Done!");
        }
示例#4
0
        static internal void Run(PseudoTcpSocket conn)
        {
            PLog.DEBUG("In Receiver.Run");
            int ini = Environment.TickCount;

            byte[] ackBuffer = new byte[1];
            ackBuffer [0] = 1;
            long got = 0;

            byte[] fnlBytes = new byte[4];
            do
            {
                got = SyncPseudoTcpSocket.Recv(conn, fnlBytes, 4);
                PLog.DEBUG("Reading filename length, got={0}", got);
                UdpCallbacks.PollingSleep(got, -1);
            } while (got == -1);
            SyncPseudoTcpSocket.Send(conn, ackBuffer, 1);
            uint fileNameLengthBytes = (uint)BitConverter.ToInt32(fnlBytes, 0);

            PLog.DEBUG("Got filename length=" + fileNameLengthBytes);

            byte[] fnBytes = new byte[fileNameLengthBytes];
            do
            {
                got = SyncPseudoTcpSocket.Recv(conn, fnBytes, fileNameLengthBytes);
                PLog.DEBUG("Reading filename, got={0}", got);
                UdpCallbacks.PollingSleep(got, -1);
            } while (got == -1);
            SyncPseudoTcpSocket.Send(conn, ackBuffer, 1);
            PLog.DEBUG("filename bytes=" + BitConverter.ToString(fnBytes));
            string fileName = System.Text.Encoding.UTF8.GetString(fnBytes);

            Console.WriteLine("Receiving file: {0}", fileName);

            byte[] fileSizeBytes = new byte[sizeof(long)];
            do
            {
                got = SyncPseudoTcpSocket.Recv(conn, fileSizeBytes, (uint)fileSizeBytes.Length);
                PLog.DEBUG("Reading file size, got={0}", got);
                UdpCallbacks.PollingSleep(got, -1);
            } while (got == -1);
            SyncPseudoTcpSocket.Send(conn, ackBuffer, 1);
            long size = (long)BitConverter.ToInt64(fileSizeBytes, 0);

            Console.WriteLine("File size={0} bytes", size);

            byte[] buffer = new byte[4 * 1024 * 1024];
            int    i      = 0;

            ConsoleProgress.Draw(i++, 0, size, ini, Console.WindowWidth / 2);

            using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
            {
                long len  = 0;
                long read = 0;

                while (read < size)
                {
                    do
                    {
                        PLog.DEBUG("{0} Reading file data... so far total read={1}", Environment.TickCount, read);
                        len = SyncPseudoTcpSocket.Recv(conn, buffer, (uint)buffer.Length);
                        UdpCallbacks.PollingSleep(len, -1);
                    } while (len == -1);

                    PLog.DEBUG("Read {0} bytes of file data", len);
                    fileStream.Write(buffer, 0, (int)len);
                    read += len;

                    ConsoleProgress.Draw(i++, read, size, ini, Console.WindowWidth / 2);
                }

                double MB     = (double)size * 8.0 / (1024.0 * 1024.0);
                double rxTime = (Environment.TickCount - ini) / 1000.0;
                Console.WriteLine();
                Console.WriteLine("Receive time=" + rxTime + " secs");
                Console.WriteLine("Av bandwidth=" + MB / rxTime + " Mbits/sec");
            }
        }