Esempio n. 1
0
        protected void LifeTimeSink(LifeTimeMonitor sender, object Obj)
        {
            lock (this)
            {
                if (PendingEvents > 1)
                {
                    base.Value = PendingObject;
                }
                PendingObject = Accumulator.Reset();
                PendingEvents = 0;
            }

            /*
             *
             *                  if (PendingObject != null)
             *                  {
             *                          base.Value = PendingObject;
             *                          PendingObject = Accumulator.Reset();
             *                          PendingEvents = 1;
             *                          t.Add(this,Seconds);
             *                  }
             *                  else
             *                  {
             *                          StateObject = Accumulator.Reset();
             *                          PendingEvents = 0;
             *                  }
             *          }*/
        }
        /// <summary>
        /// Triggered when a device lifetime has expired
        /// </summary>
        /// <param name="Obj"></param>
        private void DeviceLifeTimeClockSink(LifeTimeMonitor sender, object obj)
        {
            DeviceInfo deviceInfo;

            lock (deviceTableLock)
            {
                if (deviceTable.ContainsKey(obj) == false)
                {
                    return;
                }
                deviceInfo = (DeviceInfo)deviceTable[obj];
                deviceTable.Remove(obj);
                deviceUpdateClock.Remove(obj);  // Cancel any source change
                if (activeDeviceList.Contains(deviceInfo.Device))
                {
                    activeDeviceList.Remove(deviceInfo.Device);
                }
                else
                {
                    deviceInfo.Device = null;   // Don't warn user about this, user does not know about device
                }
            }
            if (deviceInfo.Device != null)
            {
                deviceInfo.Device.Removed();
            }
            if (deviceInfo.Device != null)
            {
                deviceInfo.Device.Removed();
                OnDeviceExpiredEvent.Fire(this, deviceInfo.Device);
            }
        }
        /// <summary>
        /// Triggered when a device must be updated to a new source IP address
        /// </summary>
        /// <param name="Obj"></param>
        private void DeviceUpdateClockSink(LifeTimeMonitor sender, object obj)
        {
            // Make the source switch
            lock (deviceTableLock)
            {
                if (deviceTable.ContainsKey(obj) == false)
                {
                    return;
                }
                DeviceInfo deviceInfo = (DeviceInfo)deviceTable[obj];
                if (deviceInfo.PendingBaseURL == null)
                {
                    return;     // Cancel the switch
                }

                deviceInfo.BaseURL    = deviceInfo.PendingBaseURL;
                deviceInfo.MaxAge     = deviceInfo.PendingMaxAge;
                deviceInfo.SourceEP   = deviceInfo.PendingSourceEP;
                deviceInfo.LocalEP    = deviceInfo.PendingLocalEP;
                deviceInfo.NotifyTime = DateTime.Now;
                deviceInfo.Device.UpdateDevice(deviceInfo.BaseURL, deviceInfo.LocalEP.Address);
                deviceTable[obj] = deviceInfo;

                deviceLifeTimeClock.Add(deviceInfo.UDN, deviceInfo.MaxAge);
            }
            //if (OnUpdatedDevice != null) OnUpdatedDevice(this,deviceInfo.Device);
        }
        private void KeepAliveSink(LifeTimeMonitor sender, object obj)
        {
            if (IdleTimeout == false)
            {
                return;
            }
            ArrayList RemoveList = new ArrayList();

            lock (SessionTable)
            {
                IDictionaryEnumerator en = SessionTable.GetEnumerator();
                while (en.MoveNext())
                {
                    if (((HTTPSession)en.Value).Monitor.IsTimeout())
                    {
                        RemoveList.Add(en.Value);
                    }
                }
            }
            foreach (HTTPSession HS in RemoveList)
            {
                HS.Close();
            }
            KeepAliveTimer.Add(false, 7);
        }
 private void HandleExpired(LifeTimeMonitor sender, object Obj)
 {
     if (Obj.GetType().FullName == "OpenSource.UPnP.UPnPDeviceFactory")
     {
         ((UPnPDeviceFactory)Obj).Shutdown();
         CreateTable.Remove(Obj);
     }
 }
Esempio n. 6
0
        private void SearchTimerSink(LifeTimeMonitor sender, object obj)
        {
            SearchStruct SS = (SearchStruct)obj;

            if (OnSearch != null)
            {
                OnSearch(SS.ST, SS.Source, SS.Local);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Calledn every second to check for interface changes.
        /// </summary>
        private void PollInterface(LifeTimeMonitor sender, Object obj)
        {
            try
            {
                ArrayList          CurrentAddressTable = new ArrayList();
                NetworkInterface[] interfaces          = NetworkInterface.GetAllNetworkInterfaces();
                foreach (NetworkInterface i in interfaces)
                {
                    if (i.IsReceiveOnly == false && i.OperationalStatus == OperationalStatus.Up && i.SupportsMulticast == true)
                    {
                        IPInterfaceProperties i2 = i.GetIPProperties();
                        foreach (UnicastIPAddressInformation i3 in i2.UnicastAddresses)
                        {
                            if (!CurrentAddressTable.Contains(i3.Address) && !i3.Address.Equals(IPAddress.IPv6Loopback))
                            {
                                CurrentAddressTable.Add(i3.Address);
                            }
                        }
                    }
                }

                /*
                 * IPHostEntry HostInfo = Dns.GetHostEntry(HostName);
                 * ArrayList CurrentAddressTable = new ArrayList(HostInfo.AddressList);
                 */

                ArrayList OldAddressTable = AddressTable;
                AddressTable = CurrentAddressTable;
                if (!AddressTable.Contains(IPAddress.Loopback))
                {
                    AddressTable.Add(IPAddress.Loopback);
                }

                foreach (IPAddress addr in CurrentAddressTable)
                {
                    if (OldAddressTable.Contains(addr) == false)
                    {
                        OnNewInterfaceEvent.Fire(this, addr);
                    }
                }

                foreach (IPAddress addr in OldAddressTable)
                {
                    if (CurrentAddressTable.Contains(addr) == false)
                    {
                        OnInterfaceDisabledEvent.Fire(this, addr);
                    }
                }
            }
            catch (Exception ex)
            {
                OpenSource.Utilities.EventLogger.Log(ex);
                //System.Windows.Forms.MessageBox.Show(ex.ToString(),"NetworkInfo");
            }
            InterfacePoller.Add(this, NetworkInfo.NetworkPollSeconds);
        }
        public UPnPControlPoint(NetworkInfo ni)
        {
            CreateTable         = Hashtable.Synchronized(new Hashtable());
            NetInfo             = ni;
            SyncData            = ArrayList.Synchronized(new ArrayList());
            SSDPSessions        = Hashtable.Synchronized(new Hashtable());
            Lifetime            = new LifeTimeMonitor();
            Lifetime.OnExpired += new LifeTimeMonitor.LifeTimeHandler(HandleExpired);

            SSDPServer           = new SSDP(65535);
            SSDPServer.OnNotify += new SSDP.NotifyHandler(HandleNotify);
        }
Esempio n. 9
0
 private void KeepAliveSink(LifeTimeMonitor sender, object obj)
 {
     if (IdleTimeout == false || (int)obj != this.GetHashCode())
     {
         return;
     }
     this.ForceCloseSession();
     if (this.OnInactiveClosed != null)
     {
         this.OnInactiveClosed(this);
     }
 }
Esempio n. 10
0
        /// <summary>
        /// Constructs a new Control Point, and waits for your commands and receives events
        /// </summary>
        public UPnPControlPoint()
        {
            CreateTable = Hashtable.Synchronized(new Hashtable());
            NetInfo = new NetworkInfo(new NetworkInfo.InterfaceHandler(NewInterface));
            SyncData = ArrayList.Synchronized(new ArrayList());
            SSDPSessions = Hashtable.Synchronized(new Hashtable());
            Lifetime = new LifeTimeMonitor();
            Lifetime.OnExpired += new LifeTimeMonitor.LifeTimeHandler(HandleExpired);

            SSDPServer = new SSDP(65535);
            SSDPServer.OnNotify += new SSDP.NotifyHandler(HandleNotify);
        }
        public UPnPControlPoint(NetworkInfo ni)
        {
            CreateTable         = Hashtable.Synchronized(new Hashtable());
            NetInfo             = (null != ni) ? ni : new NetworkInfo(new NetworkInfo.InterfaceHandler(NewInterface));
            SyncData            = ArrayList.Synchronized(new ArrayList());
            SSDPSessions        = Hashtable.Synchronized(new Hashtable());
            Lifetime            = new LifeTimeMonitor();
            Lifetime.OnExpired += new LifeTimeMonitor.LifeTimeHandler(HandleExpired);

            SSDPServer                = new SSDP(65535);
            SSDPServer.OnNotify      += new SSDP.NotifyHandler(HandleNotify);
            SSDPServer.OnSniffPacket += new SSDP.SnifferHandler(HandleSniffer);
        }
        /// <summary>
        /// Constructs a new Control Point, and waits for your commands and receives events
        /// </summary>
        public UPnPControlPoint()
        {
            CreateTable = Hashtable.Synchronized(new Hashtable());
            NetInfo = new NetworkInfo(new NetworkInfo.InterfaceHandler(NewInterface));
            SyncData = ArrayList.Synchronized(new ArrayList());
            SSDPSessions = Hashtable.Synchronized(new Hashtable());
            Lifetime = new LifeTimeMonitor();
            Lifetime.OnExpired += new LifeTimeMonitor.LifeTimeHandler(HandleExpired);

            SSDPServer = new SSDP(65535);
            SSDPServer.OnNotify += new SSDP.NotifyHandler(HandleNotify);

            OpenSource.Utilities.EventLogger.Log(this, System.Diagnostics.EventLogEntryType.Information,"UPnP Object Created");
        }
        protected void LifeTimeSink(LifeTimeMonitor sender, object Obj)
        {
            lock (this)
            {
                if (PendingEvents > 1)
                {
                    base.Value = PendingObject;
                }
                PendingObject = Accumulator.Reset();
                PendingEvents = 0;
            }
            /*

                if (PendingObject != null)
                {
                    base.Value = PendingObject;
                    PendingObject = Accumulator.Reset();
                    PendingEvents = 1;
                    t.Add(this,Seconds);
                }
                else
                {
                    StateObject = Accumulator.Reset();
                    PendingEvents = 0;
                }
            }*/
        }
Esempio n. 14
0
 private void KeepAliveSink(LifeTimeMonitor sender, object obj)
 {
     if (IdleTimeout == false || (int)obj != this.GetHashCode()) return;
     this.ForceCloseSession();
     if (this.OnInactiveClosed != null) this.OnInactiveClosed(this);
 }
 private void RescanSink(LifeTimeMonitor sender, object obj)
 {
     if (this.InvokeRequired) { Invoke(new LifeTimeMonitor.LifeTimeHandler(RescanSink), sender, obj); return; }
     statusBar.Text = "";
 }
Esempio n. 16
0
 private void HandleExpired(LifeTimeMonitor sender, object Obj)
 {
     if (Obj.GetType().FullName == "OpenSource.UPnP.UPnPDeviceFactory")
     {
         ((UPnPDeviceFactory)Obj).Shutdown();
         CreateTable.Remove(Obj);
     }
 }
 /// <summary>
 /// Triggered when a device lifetime has expired
 /// </summary>
 /// <param name="Obj"></param>
 private void DeviceLifeTimeClockSink(LifeTimeMonitor sender, object obj)
 {
     DeviceInfo deviceInfo;
     lock (deviceTableLock)
     {
         if (deviceTable.ContainsKey(obj) == false)
         {
             return;
         }
         deviceInfo = (DeviceInfo)deviceTable[obj];
         deviceTable.Remove(obj);
         deviceUpdateClock.Remove(obj);	// Cancel any source change
         if (activeDeviceList.Contains(deviceInfo.Device))
         {
             activeDeviceList.Remove(deviceInfo.Device);
         }
         else
         {
             deviceInfo.Device = null;	// Don't warn user about this, user does not know about device
         }
     }
     if (deviceInfo.Device != null)
     {
         deviceInfo.Device.Removed();
     }
     if (deviceInfo.Device != null)
     {
         deviceInfo.Device.Removed();
         OnDeviceExpiredEvent.Fire(this, deviceInfo.Device);
     }
 }
Esempio n. 18
0
        /// <summary>
        /// Calledn every second to check for interface changes.
        /// </summary>
        private void PollInterface(LifeTimeMonitor sender, Object obj)
        {
            try
            {
                ArrayList CurrentAddressTable = new ArrayList();
                NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces();
                foreach (NetworkInterface i in interfaces)
                {
                    if (i.IsReceiveOnly == false && i.OperationalStatus == OperationalStatus.Up && i.SupportsMulticast == true)
                    {
                        IPInterfaceProperties i2 = i.GetIPProperties();
                        foreach (UnicastIPAddressInformation i3 in i2.UnicastAddresses)
                        {
                            if (!CurrentAddressTable.Contains(i3.Address) && !i3.Address.Equals(IPAddress.IPv6Loopback))
                            {
                                CurrentAddressTable.Add(i3.Address);
                            }
                        }
                    }
                }

                /*
                IPHostEntry HostInfo = Dns.GetHostEntry(HostName);
                ArrayList CurrentAddressTable = new ArrayList(HostInfo.AddressList);
                */

                ArrayList OldAddressTable = AddressTable;
                AddressTable = CurrentAddressTable;
                if (!AddressTable.Contains(IPAddress.Loopback))
                {
                    AddressTable.Add(IPAddress.Loopback);
                }

                foreach (IPAddress addr in CurrentAddressTable)
                {
                    if (OldAddressTable.Contains(addr) == false)
                        OnNewInterfaceEvent.Fire(this, addr);
                }

                foreach (IPAddress addr in OldAddressTable)
                {
                    if (CurrentAddressTable.Contains(addr) == false)
                        OnInterfaceDisabledEvent.Fire(this, addr);
                }

            }
            catch (Exception ex)
            {
                OpenSource.Utilities.EventLogger.Log(ex);
                //System.Windows.Forms.MessageBox.Show(ex.ToString(),"NetworkInfo");
            }
            InterfacePoller.Add(this, NetworkInfo.NetworkPollSeconds);
        }
        private void KeepAliveSink(LifeTimeMonitor sender, object obj)
        {
            if (IdleTimeout == false) return;
            ArrayList RemoveList = new ArrayList();
            lock (SessionTable)
            {

                IDictionaryEnumerator en = SessionTable.GetEnumerator();
                while (en.MoveNext())
                {
                    if (((HTTPSession)en.Value).Monitor.IsTimeout())
                    {
                        RemoveList.Add(en.Value);
                    }
                }
            }
            foreach (HTTPSession HS in RemoveList)
            {
                HS.Close();
            }
            KeepAliveTimer.Add(false, 7);
        }
Esempio n. 20
0
		/// <summary>
		/// This method can be triggered 30 seconds after an event was received
		/// notifying us what ConnectionIDs are valid. There could be a 30 seconds delay, because
		/// if there are pending connection attempts, this event may not contain the complete ID list,
		/// so we need to wait for PrepareForConnection to return. Or vice versa. If PrepareForConnection
		/// returns with its ID, we need to make sure the event arrived, because otherwise we
		/// could receive an event without that connection id, and the CP may think that the ID we just added
		/// was deleted, which is bad... Very bad race conditions here :)
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="obj"></param>
		private void ConnectionMonitorSink(LifeTimeMonitor sender, object obj)
		{
			// Lets fetch information about the connection id specicifed in obj
			ConnectionManager.GetCurrentConnectionInfo((int)obj,null,new CpConnectionManager.Delegate_OnResult_GetCurrentConnectionInfo(ConnectionInfoSink));				
		}
        /// <summary>
        /// Triggered when a device must be updated to a new source IP address
        /// </summary>
        /// <param name="Obj"></param>
        private void DeviceUpdateClockSink(LifeTimeMonitor sender, object obj)
        {
            // Make the source switch
            lock (deviceTableLock)
            {
                if (deviceTable.ContainsKey(obj) == false)
                {
                    return;
                }
                DeviceInfo deviceInfo = (DeviceInfo)deviceTable[obj];
                if (deviceInfo.PendingBaseURL == null)
                {
                    return;	// Cancel the switch
                }

                deviceInfo.BaseURL = deviceInfo.PendingBaseURL;
                deviceInfo.MaxAge = deviceInfo.PendingMaxAge;
                deviceInfo.SourceEP = deviceInfo.PendingSourceEP;
                deviceInfo.LocalEP = deviceInfo.PendingLocalEP;
                deviceInfo.NotifyTime = DateTime.Now;
                deviceInfo.Device.UpdateDevice(deviceInfo.BaseURL, deviceInfo.LocalEP.Address);
                deviceTable[obj] = deviceInfo;

                deviceLifeTimeClock.Add(deviceInfo.UDN, deviceInfo.MaxAge);
            }
            //if (OnUpdatedDevice != null) OnUpdatedDevice(this,deviceInfo.Device);
        }
        private void SessionTimerSink(LifeTimeMonitor sender, object obj)
        {
            HTTPSession s = (HTTPSession)obj;

            s.Close();
        }
 /// <summary>
 /// This method executes when the LifeTimeMonitor has indicated
 /// that the 30 second prerequisite time has passed, so that
 /// <see cref="HttpTransfer"/> objects can be removed from the
 /// MediaServer device's list of active transfers.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="obj"><see cref="HttpTransfer"/> object that can be removed from the server's list</param>
 private void Sink_OnExpired(LifeTimeMonitor sender, object obj)
 {
     if (obj.GetType() == typeof(HttpTransfer))
     {
         this.RemoveTransfer ((HttpTransfer) obj);
     }
     else
     {
         throw new Error_TransferProblem(0, null);
     }
 }
 private void SearchTimerSink(LifeTimeMonitor sender, object obj)
 {
     SearchStruct SS = (SearchStruct)obj;
     if (OnSearch != null) OnSearch(SS.ST, SS.Source, SS.Local);
 }
Esempio n. 25
0
 private void DeviceLifeTimeClockSink(LifeTimeMonitor sender, object obj)
 {
     DeviceInfo info;
     lock (this.deviceTableLock)
     {
         if (!this.deviceTable.ContainsKey(obj))
         {
             return;
         }
         info = (DeviceInfo)this.deviceTable[obj];
         this.deviceTable.Remove(obj);
         this.deviceUpdateClock.Remove(obj);
         if (this.activeDeviceList.Contains(info.Device))
         {
             this.activeDeviceList.Remove(info.Device);
         }
         else
         {
             info.Device = null;
         }
     }
     if (info.Device != null)
     {
         //info.Device.Removed();
     }
     if (info.Device != null)
     {
         //info.Device.Removed();
         this.OnDeviceExpiredEvent.Fire(this, info.Device);
     }
 }
 private void SubscribeCycleSink(LifeTimeMonitor sender, object obj)
 {
     if ((int)obj == this.GetHashCode()) Renew();
 }
Esempio n. 27
0
 private void DeviceUpdateClockSink(LifeTimeMonitor sender, object obj)
 {
     lock (this.deviceTableLock)
     {
         if (this.deviceTable.ContainsKey(obj))
         {
             DeviceInfo info = (DeviceInfo)this.deviceTable[obj];
             if (info.PendingBaseURL != null)
             {
                 info.BaseURL = info.PendingBaseURL;
                 info.MaxAge = info.PendingMaxAge;
                 info.SourceEP = info.PendingSourceEP;
                 info.LocalEP = info.PendingLocalEP;
                 info.NotifyTime = DateTime.Now;
                 info.Device.UpdateDevice(info.BaseURL, info.LocalEP.Address);
                 this.deviceTable[obj] = info;
                 this.deviceLifeTimeClock.Add(info.UDN, info.MaxAge);
             }
         }
     }
 }
        private void SessionTimerSink(LifeTimeMonitor sender, object obj)
        {
            HTTPSession s = (HTTPSession)obj;

            s.Close();
        }