protected override void SendResponse()
 {
     // resend blocks in the window
     for (int t = 0; t < m_Window.Count; t++)
     {
         TFTPServer.Send(m_Socket, m_RemoteEndPoint, m_Window[t].Segment);
     }
     StartTimer();
 }
        private void SendOptionsAck()
        {
            var seg = TFTPServer.GetOptionsAckPacket(m_AcceptedOptions);

            m_Window.Add(new WindowEntry()
            {
                IsData = false, Length = 0, Segment = seg
            });
            TFTPServer.Send(m_Socket, m_RemoteEndPoint, seg);
            m_BlockRetry = 0;
            StartTimer();
        }
 private void SendData()
 {
     // fill the window up to the window size & send all the new packets
     while (m_Window.Count < m_WindowSize && !m_LastBlock)
     {
         byte[] buffer   = new byte[m_CurrentBlockSize];
         int    dataSize = m_Stream.Read(buffer, 0, m_CurrentBlockSize);
         var    seg      = TFTPServer.GetDataPacket((ushort)(m_BlockNumber + m_Window.Count), buffer, dataSize);
         m_Window.Add(new WindowEntry()
         {
             IsData = true, Length = dataSize, Segment = seg
         });
         m_LastBlock = (dataSize < m_CurrentBlockSize);
         TFTPServer.Send(m_Socket, m_RemoteEndPoint, seg);
         m_BlockRetry = 0;
         StartTimer();
     }
 }
        public override void ProcessData(ushort blockNr, ArraySegment <byte> data)
        {
            bool isComplete = false;

            lock (m_Lock)
            {
                if (blockNr == ((ushort)(m_BlockNumber + 1)))
                {
                    m_BlockNumber = blockNr;
                    m_LastBlock   = data.Count < m_CurrentBlockSize;
                    isComplete    = m_LastBlock;
                    m_Stream.Write(data.Array, data.Offset, data.Count);

                    m_Position += data.Count;
                    m_SessionLog.Progress(m_Position);

                    // send ack for current block, client will respond with next block
                    m_Window = TFTPServer.GetDataAckPacket(m_BlockNumber);
                    TFTPServer.Send(m_Socket, m_RemoteEndPoint, m_Window);
                    m_BlockRetry = 0;

                    if (m_LastBlock)
                    {
                        StopTimer();
                        m_SessionLog.Complete();
                    }
                    else
                    {
                        StartTimer();
                    }
                }
            }

            if (isComplete)
            {
                Stop(true, null);
            }
        }
        public override void Start()
        {
            var sessionLogConfiguration = new SessionLogEntry.TConfiguration()
            {
                FileLength     = -1,
                Filename       = m_Filename,
                IsUpload       = true,
                LocalEndPoint  = m_LocalEndPoint,
                RemoteEndPoint = m_RemoteEndPoint,
                StartTime      = DateTime.Now,
                WindowSize     = 1
            };

            try
            {
                lock (m_Lock)
                {
                    try
                    {
                        m_Length = m_RequestedOptions.ContainsKey(TFTPServer.Option_TransferSize) ? Int64.Parse(m_RequestedOptions[TFTPServer.Option_TransferSize]) : -1;
                        sessionLogConfiguration.FileLength = m_Length;
                        m_Stream   = m_Parent.GetWriteStream(m_Filename, m_Length);
                        m_Position = 0;
                    }
                    catch (Exception e)
                    {
                        TFTPServer.SendError(m_Socket, m_RemoteEndPoint, TFTPServer.ErrorCode.FileNotFound, e.Message);
                        throw;
                    }
                    finally
                    {
                        // always create a SessionLog (even if the file couldn't be opened), so Stop() will have somewhere to store its errors
                        m_SessionLog = m_Parent.SessionLog.CreateSession(sessionLogConfiguration);
                    }

                    // handle tsize option
                    if (m_RequestedOptions.ContainsKey(TFTPServer.Option_TransferSize))
                    {
                        // rfc2349: in Write Request packets, the size of the file, in octets, is specified in the
                        // request and echoed back in the OACK
                        m_AcceptedOptions.Add(TFTPServer.Option_TransferSize, m_RequestedOptions[TFTPServer.Option_TransferSize]);
                    }

                    if (m_AcceptedOptions.Count > 0)
                    {
                        // send options ack, client will respond with block number 1
                        m_Window = TFTPServer.GetOptionsAckPacket(m_AcceptedOptions);
                    }
                    else
                    {
                        // send ack for current block, client will respond with next block
                        m_Window = TFTPServer.GetDataAckPacket(m_BlockNumber);
                    }

                    TFTPServer.Send(m_Socket, m_RemoteEndPoint, m_Window);
                    m_BlockRetry = 0;
                    StartTimer();
                }
            }
            catch (Exception e)
            {
                Stop(true, e);
            }
        }
 protected override void SendResponse()
 {
     TFTPServer.Send(m_Socket, m_RemoteEndPoint, m_Window);
     StartTimer();
 }