예제 #1
0
        private static ByteBuffer EncodeBytesRead(RtmpContext context, BytesRead bytesRead)
        {
            ByteBuffer buffer = ByteBuffer.Allocate(4);

            buffer.PutInt(bytesRead.Bytes);
            return(buffer);
        }
예제 #2
0
        static ByteBuffer EncodeBytesRead(RtmpContext context, BytesRead bytesRead)
        {
            ByteBuffer output = ByteBuffer.Allocate(4);

            output.PutInt(bytesRead.Bytes);
            return(output);
        }
예제 #3
0
        protected void UpdateBytesRead()
        {
            long readBytes = this.ReadBytes;

            if (readBytes >= this._nextBytesRead)
            {
                BytesRead message = new BytesRead((int)readBytes);
                this.GetChannel(2).Write(message);
                this._nextBytesRead += this._bytesReadInterval;
            }
        }
예제 #4
0
 /// <summary>
 ///     Called when bytes are read.
 /// </summary>
 /// <param name="bytesMoved">int with the number of bytes</param>
 protected virtual void OnBytesRead(int bytesMoved)
 {
     if (bytesMoved != 0 && BytesRead != null)
     {
         long length   = 0;
         long position = 0;
         if (_innerStream.CanSeek)
         {
             length   = _innerStream.Length;
             position = _innerStream.Position;
         }
         var args = new ProgressStreamReport(bytesMoved, length, position, true);
         BytesRead?.Invoke(this, args);
     }
 }
예제 #5
0
        internal static bool ReadFile_Hooked(
            IntPtr hFile,
            IntPtr lpBuffer,
            UInt32 nNumberOfBytesToRead,
            /*ref UInt32*/ IntPtr lpNumberOfBytesRead,
            /*ref OVERLAPPED*/ IntPtr lpOverlapped)
        {
            BytesRead br = new BytesRead(lpNumberOfBytesRead);

            return(new HookContext <bool>(
                       func => ((ReadFile_Delegate)func)(hFile, lpBuffer, nNumberOfBytesToRead,
                                                         lpNumberOfBytesRead, lpOverlapped),
                       helper => FileEncryptionLayer.ReadFile(hFile, lpBuffer, nNumberOfBytesToRead,
                                                              lpNumberOfBytesRead, lpOverlapped),
                       errorCode =>
            {
                SetLastError(unchecked ((uint)errorCode));
                return false;
            },
                       HookLogging.DefaultLogging, "[hFile]: {0} [toRead]: {1} [Read]: {2}",
                       hFile.ToString(), nNumberOfBytesToRead, br).Call());
        }
예제 #6
0
 /// <summary>
 /// This method supports the infrastructure and is not intended to be used directly from your code.
 /// </summary>
 /// <param name="connection"></param>
 /// <param name="channel"></param>
 /// <param name="source"></param>
 /// <param name="streamBytesRead"></param>
 protected void OnStreamBytesRead(RtmpConnection connection, RtmpChannel channel, RtmpHeader source, BytesRead streamBytesRead)
 {
     connection.ReceivedBytesRead(streamBytesRead.Bytes);
 }
예제 #7
0
        static void Main(string[] args)
        {
            Device device = new Device("TUNTEST");

            device.setMediaStatusAsConnected();
            device.setTunMode("10.111.111.1", "255.0.0.0");

            var mtu = device.getMTU();

            logger.Debug("MTU: {0}", mtu);

            Tap = device.getStream();

            var udpForwarder = new UDPForwarder(Tap);
            var tcpForwarder = new TCPForwarder(Tap);

            object state = new int();

            WaitObject = new EventWaitHandle(false, EventResetMode.AutoReset);
            IAsyncResult res;

            while (true)
            {
                byte[] buf = new byte[mtu];
                BytesRead = Tap.Read(buf, 0, buf.Length);
                if (BytesRead <= 0)
                {
                    break;
                }
                logger.Debug("Read " + BytesRead.ToString());
                try
                {
                    var frame = IPFrame.Create(buf.Take(BytesRead).ToArray());
                    logger.Debug("Version: " + frame.Version);
                    logger.Debug("Protocol Type: " + frame.Protocol);
                    logger.Debug("Source Address: " + frame.SourceAddress.ToString());
                    logger.Debug("Dest Address: " + frame.DestinationAddress.ToString());

                    var parser = new ProtocolParser();
                    parser.ParseCompleteFrame(frame);

                    if (frame.EncapsulatedFrame.FrameType == FrameTypes.UDP)
                    {
                        udpForwarder.forwardFrame(frame);
                    }
                    else if (frame.EncapsulatedFrame.FrameType == FrameTypes.TCP)
                    {
                        tcpForwarder.forwardFrame(frame);
                    }
                }
                catch (Exception e)
                {
                    logger.Error(e);
                }

                //
                // Reverse IPv4 addresses and send back to tun
                //
                //for (int i = 0; i< 4; ++i)
                //{
                //    byte tmp = buf[12+i]; buf[12+i] = buf[16+i]; buf[16+i] = tmp;
                //}
                //res2 = Tap.BeginWrite(buf, 0, BytesRead, ar => {
                //    Tap.EndWrite(ar);
                //    WaitObject2.Set();
                //}, state2);
                //WaitObject2.WaitOne();
            }
        }
 public void Report(int bytesRead)
 {
     BytesRead?.Invoke(bytesRead);
 }
예제 #9
0
 private void OnBytesRead(IntEventArgs e)
 {
     BytesRead?.Invoke(this, e);
 }
예제 #10
0
        public void PushMessage(IPipe pipe, IMessage message)
        {
            if (message is ResetMessage)
            {
                _timeStamper.Reset();
            }
            else if (message is StatusMessage)
            {
                StatusMessage statusMsg = message as StatusMessage;
                _data.SendStatus(statusMsg.body as StatusASO);
            }
            else if (message is RtmpMessage)
            {
                // Make sure chunk size has been sent
                if (!_chunkSizeSent)
                {
                    SendChunkSize();
                }

                RtmpMessage rtmpMsg = message as RtmpMessage;
                IRtmpEvent  msg     = rtmpMsg.body;

                int eventTime = msg.Timestamp;
#if !SILVERLIGHT
                if (log.IsDebugEnabled)
                {
                    log.Debug(string.Format("Message timestamp: {0}", eventTime));
                }
#endif
                if (eventTime < 0)
                {
#if !SILVERLIGHT
                    if (log.IsDebugEnabled)
                    {
                        log.Debug(string.Format("Message has negative timestamp: {0}", eventTime));
                    }
#endif
                    return;
                }
                byte dataType = msg.DataType;
                // Create a new header for the consumer
                RtmpHeader header = _timeStamper.GetTimeStamp(dataType, eventTime);

                switch (msg.DataType)
                {
                case Constants.TypeStreamMetadata:
                    Notify notify = new Notify((msg as Notify).Data);
                    notify.Header    = header;
                    notify.Timestamp = header.Timer;
                    _data.Write(notify);
                    break;

                case Constants.TypeFlexStreamEnd:
                    // TODO: okay to send this also to AMF0 clients?
                    FlexStreamSend send = new FlexStreamSend((msg as Notify).Data);
                    send.Header    = header;
                    send.Timestamp = header.Timer;
                    _data.Write(send);
                    break;

                case Constants.TypeVideoData:
                    VideoData videoData = new VideoData((msg as VideoData).Data);
                    videoData.Header    = header;
                    videoData.Timestamp = header.Timer;
                    _video.Write(videoData);
                    break;

                case Constants.TypeAudioData:
                    AudioData audioData = new AudioData((msg as AudioData).Data);
                    audioData.Header    = header;
                    audioData.Timestamp = header.Timer;
                    _audio.Write(audioData);
                    break;

                case Constants.TypePing:
                    Ping ping = new Ping((msg as Ping).PingType, (msg as Ping).Value2, (msg as Ping).Value3, (msg as Ping).Value4);
                    ping.Header = header;
                    _connection.Ping(ping);
                    break;

                case Constants.TypeBytesRead:
                    BytesRead bytesRead = new BytesRead((msg as BytesRead).Bytes);
                    bytesRead.Header    = header;
                    bytesRead.Timestamp = header.Timer;
                    _connection.GetChannel((byte)2).Write(bytesRead);
                    break;

                default:
                    _data.Write(msg);
                    break;
                }
            }
        }
예제 #11
0
        static void ListenTest(GpioPin pin)
        {
            PinPulse(pin, 2000);

            using (Socket soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IPv4))
            {
                IPEndPoint ep = new IPEndPoint(IPAddress.Any, 6501);

                soc.Bind(ep);

                soc.Listen(1);

                while (true)
                {
                    Socket client = null;

                    int BytesRead;
                    try
                    {
                        Console.WriteLine(DateTime.UtcNow.ToString() + "Accept client");
                        client = soc.Accept();
                        Console.WriteLine(DateTime.UtcNow.ToString() + "Accepted");

                        PinPulse(pin, 500);

                        client.ReceiveTimeout = 10000;

                        NetworkStream stream = new NetworkStream(client);

                        byte[] buffer = new byte[100];

                        // Echo back everything we receive and toggle Led
                        while ((BytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
                        {
                            stream.Write(buffer, 0, BytesRead);
                            Console.WriteLine(DateTime.UtcNow.ToString() + "Read/Write " + BytesRead.ToString());
                            pin.Toggle();
                        }

                        Console.WriteLine(DateTime.UtcNow.ToString() + "connection ending");
                    }
                    catch (Exception ex) {
                        Console.WriteLine(DateTime.UtcNow.ToString() + "Ex " + ex.Message);
                    };

                    if (client != null)
                    {
                        client.Close();
                    }
                    break;
                }
            }
        }
 private void RaiseBytesReadEvent(int byteCount)
 {
     BytesRead?.Invoke(byteCount);
 }
예제 #13
0
        public void PushMessage(IPipe pipe, IMessage message)
        {
            if (message is ResetMessage)
            {
                this._streamTracker.Reset();
            }
            else if (message is StatusMessage)
            {
                StatusMessage message2 = message as StatusMessage;
                this._data.SendStatus(message2.body as StatusASO);
            }
            else if (message is RtmpMessage)
            {
                RtmpMessage message3 = message as RtmpMessage;
                IRtmpEvent  body     = message3.body;
                RtmpHeader  header   = new RtmpHeader();
                int         num      = this._streamTracker.Add(body);
                if (num < 0)
                {
                    log.Warn("Skipping message with negative timestamp.");
                }
                else
                {
                    header.IsTimerRelative = this._streamTracker.IsRelative;
                    header.Timer           = num;
                    switch (body.DataType)
                    {
                    case 3:
                    {
                        BytesRead read = new BytesRead((body as BytesRead).Bytes);
                        header.IsTimerRelative = false;
                        header.Timer           = 0;
                        read.Header            = header;
                        read.Timestamp         = header.Timer;
                        this._connection.GetChannel(2).Write(read);
                        return;
                    }

                    case 4:
                    {
                        Ping ping = new Ping((body as Ping).Value1, (body as Ping).Value2, (body as Ping).Value3, (body as Ping).Value4);
                        header.IsTimerRelative = false;
                        header.Timer           = 0;
                        ping.Header            = header;
                        ping.Timestamp         = header.Timer;
                        this._connection.Ping(ping);
                        return;
                    }

                    case 8:
                    {
                        AudioData data2 = new AudioData((body as AudioData).Data)
                        {
                            Header    = header,
                            Timestamp = header.Timer
                        };
                        this._audio.Write(data2);
                        return;
                    }

                    case 9:
                    {
                        VideoData data = new VideoData((body as VideoData).Data)
                        {
                            Header    = header,
                            Timestamp = header.Timer
                        };
                        this._video.Write(data);
                        return;
                    }

                    case 15:
                    {
                        FlexStreamSend send = new FlexStreamSend((body as Notify).Data)
                        {
                            Header    = header,
                            Timestamp = header.Timer
                        };
                        this._data.Write(send);
                        return;
                    }

                    case 0x12:
                    {
                        Notify notify = new Notify((body as Notify).Data)
                        {
                            Header    = header,
                            Timestamp = header.Timer
                        };
                        this._data.Write(notify);
                        return;
                    }
                    }
                    this._data.Write(body);
                }
            }
        }