/// <summary>
/// Discovers and returns all NAT devices for the specified type. If no NAT device is found it returns an empty enumerable
/// </summary>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>All found NAT devices</returns>
public async Task<IEnumerable<NatDevice>> DiscoverDevicesAsync(PortMapper portMapper, CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper == PortMapper.Upnp || portMapper == PortMapper.Pmp, "poertMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
var devices = await DiscoverAsync(portMapper, false, cancellationTokenSource);
return devices.ToArray();
}
/// <summary>
/// Discovers and returns all NAT devices for the specified type. If no NAT device is found it returns an empty
/// enumerable
/// </summary>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>All found NAT devices</returns>
public async Task <IEnumerable <NatDevice> > DiscoverDevicesAsync(PortMapper portMapper,
CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper.HasFlag(PortMapper.Upnp) || portMapper.HasFlag(PortMapper.Pmp), "portMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
var devices = await DiscoverAsync(portMapper, false, cancellationTokenSource).ConfigureAwait(false);
return(devices.ToArray());
}
/// <summary>
/// Discovers and returns a NAT device for the specified type; otherwise a <see cref="NatDeviceNotFoundException">NatDeviceNotFoundException</see>
/// exception is thrown when it is cancelled.
/// </summary>
/// <remarks>
/// It allows to specify the NAT type to discover as well as the cancellation token in order.
/// </remarks>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>A NAT device</returns>
/// <exception cref="NatDeviceNotFoundException">when no NAT found before cancellation</exception>
public async Task<NatDevice> DiscoverDeviceAsync(PortMapper portMapper, CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper == PortMapper.Upnp || portMapper == PortMapper.Pmp, "poertMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
var devices = await DiscoverAsync(portMapper, true, cancellationTokenSource);
var device = devices.FirstOrDefault();
if(device==null)
{
throw new NatDeviceNotFoundException();
}
return device;
}
internal RpcTcpTransport GetTransport(int program, int version)
{
RpcTcpTransport transport;
if (!_transports.TryGetValue(program, out transport))
{
PortMapper pm = new PortMapper(this);
int port = pm.GetPort(program, version, PortMapperProtocol.Tcp);
transport = new RpcTcpTransport(_serverAddress, port);
_transports[program] = transport;
}
return transport;
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
PortMapper pm = PortMapper.SharedInstance;
pm.DidStartWork -= new PortMapper.PMDidStartWork(PortMapper_DidStartWork);
pm.DidFinishWork -= new PortMapper.PMDidFinishWork(PortMapper_DidFinishWork);
pm.WillStartSearchForRouter -= new PortMapper.PMWillStartSearchForRouter(PortMapper_WillStartSearchForRouter);
pm.DidFinishSearchForRouter -= new PortMapper.PMDidFinishSearchForRouter(PortMapper_DidFinishSearchForRouter);
pm.DidChangeMappingStatus -= new PortMapper.PMDidChangeMappingStatus(PortMapper_DidChangeMappingStatus);
pm.ExternalIPAddressDidChange -= new PortMapper.PMExternalIPAddressDidChange(PortMapper_ExternalIPAddressDidChange);
pm.StopBlocking();
}
private void PortMapper_DidChangeMappingStatus(PortMapper sender, PortMapping pm)
{
DebugLog.WriteLine("Form1: PortMapper_DidChangeMappingStatus");
foreach (ListViewItem lvi in mappings)
{
PortMapping lvi_pm = (PortMapping)lvi.Tag;
if (lvi_pm == pm)
{
mappingsListView.RedrawItems(lvi.Index, lvi.Index, false);
}
}
}
/// <summary>
/// Discovers and returns a NAT device for the specified type; otherwise a <see cref="NatDeviceNotFoundException">NatDeviceNotFoundException</see>
/// exception is thrown when it is cancelled.
/// </summary>
/// <remarks>
/// It allows to specify the NAT type to discover as well as the cancellation token in order.
/// </remarks>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>A NAT device</returns>
/// <exception cref="NatDeviceNotFoundException">when no NAT found before cancellation</exception>
public async Task <NatDevice> DiscoverDeviceAsync(PortMapper portMapper, CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper.HasFlag(PortMapper.Upnp) || portMapper.HasFlag(PortMapper.Pmp), "portMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
var devices = await DiscoverAsync(portMapper, true, cancellationTokenSource);
var device = devices.FirstOrDefault();
if (device == null)
{
throw new NatDeviceNotFoundException();
}
return(device);
}
private Task <IEnumerable <NatDevice> > DiscoverAsync(PortMapper portMapper, bool onlyOne, CancellationTokenSource cts)
{
TraceSource.LogInfo("Start Discovery");
var searcherTasks = new List <Task <IEnumerable <NatDevice> > >();
if (portMapper.HasFlag(PortMapper.Upnp))
{
var upnpSearcher = new UpnpSearcher(new IPAddressesProvider());
upnpSearcher.DeviceFound += (sender, args) => { if (onlyOne)
{
cts.Cancel();
}
};
searcherTasks.Add(upnpSearcher.Search(cts.Token));
}
if (portMapper.HasFlag(PortMapper.Pmp))
{
var pmpSearcher = new PmpSearcher(new IPAddressesProvider());
pmpSearcher.DeviceFound += (sender, args) => { if (onlyOne)
{
cts.Cancel();
}
};
searcherTasks.Add(pmpSearcher.Search(cts.Token));
}
return(TaskExtension.WhenAll(searcherTasks.ToArray())
.ContinueWith(t =>
{
TraceSource.LogInfo("Stop Discovery");
var devices = searcherTasks.SelectMany(x => x.Result);
foreach (var device in devices)
{
var key = device.ToString();
NatDevice nat;
if (Devices.TryGetValue(key, out nat))
{
nat.Touch();
}
else
{
Devices.Add(key, device);
}
}
return devices;
}));
}
/// <summary>
/// DEPRECATED!
/// Invoke PortMapper.GetNetStatPorts() to get occupied ports list
/// Then filter with process name and get port number
/// </summary>
/// <param name="process">Target process</param>
/// <returns>Port number of target process</returns>
private string getTargetPort(string process)
{
string result = null;
List <PortMapper.Port> portList = PortMapper.GetNetStatPorts();
foreach (var listItem in portList)
{
if (listItem.process_name == process)
{
result = listItem.port_number;
}
}
return(result);
}
/// <summary>
/// Discovers and returns a NAT device for the specified type; otherwise a <see cref="NatDeviceNotFoundException">NatDeviceNotFoundException</see>
/// exception is thrown when it is cancelled.
/// </summary>
/// <remarks>
/// It allows to specify the NAT type to discover as well as the cancellation token in order.
/// </remarks>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>A NAT device</returns>
/// <exception cref="NatDeviceNotFoundException">when no NAT found before cancellation</exception>
public async Task<NatDevice> DiscoverDeviceAsync(PortMapper portMapper, CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper.HasFlag(PortMapper.Upnp) || portMapper.HasFlag(PortMapper.Pmp), "portMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
var devices = await DiscoverAsync(portMapper, true, cancellationTokenSource);
var device = devices.FirstOrDefault();
if(device==null)
{
TraceSource.LogInfo("Device not found. Common reasons:");
TraceSource.LogInfo("\t* No device is present or,");
TraceSource.LogInfo("\t* Upnp is disabled in the router or");
TraceSource.LogInfo("\t* Antivirus software is filtering SSDP (discovery protocol).");
throw new NatDeviceNotFoundException();
}
return device;
}
private void PortMapper_DidFinishSearchForRouter(PortMapper sender)
{
DebugLog.WriteLine("Form1: PortMapper_DidFinishSearchForRouter");
progressPictureBox.Visible = false;
if (PortMapper.SharedInstance.MappingProtocolName == "UPnP")
{
allUpnpButton.Enabled = true;
}
else
{
allUpnpButton.Enabled = false;
}
UpdateTagLine();
}
protected override void DoCommandAction()
{
int slicePortIndex = 0;
foreach (LibElemInst inst in LibraryElementInstanceManager.Instance.GetAllInstantiations())
{
PortMapper portMapper = inst.PortMapper;
Slice s = FPGA.FPGA.Instance.GetSlice(inst.SliceName);
Tile clb = s.ContainingTile;
Tuple <string, string, PortMapper.MappingKind> mapping = portMapper.GetMappings().Where(m => Regex.IsMatch(m.Item2, SignalName)).FirstOrDefault();
string signalName = portMapper.GetSignalName(mapping.Item1);
int index = portMapper.GetIndex(mapping.Item1);
string netName = Prefix + signalName + "[" + index + "]";
Tuple <Port, Port> arc = clb.SwitchMatrix.GetAllArcs().FirstOrDefault(a => Regex.IsMatch(a.Item1.Name, SliceOutPorts[slicePortIndex]));
slicePortIndex++;
slicePortIndex %= SliceOutPorts.Count;
if (arc == null)
{
throw new ArgumentException("Cannot start pre route from tile " + clb.Location);
}
Location current = Navigator.GetDestinations(clb.Location, arc.Item2.Name).First();
bool startIsUserSelected = TileSelectionManager.Instance.IsUserSelected(current.Tile.TileKey, UserSelectionType);
bool continuePath = true;
string routingConstraint = @"set_property ROUTE { " + arc.Item1 + " " + arc.Item2 + " ";
do
{
Port port = current.Tile.SwitchMatrix.GetDrivenPorts(current.Pip).Where(p => Regex.IsMatch(p.Name, RoutingResources)).FirstOrDefault();
if (port == null)
{
throw new ArgumentException("Cannot continue pre route from " + current + ". Is the tile at the border of the device?");
}
routingConstraint += port.Name + " ";
current = Navigator.GetDestinations(current.Tile.Location, port.Name).FirstOrDefault();
continuePath =
(startIsUserSelected && TileSelectionManager.Instance.IsUserSelected(current.Tile.TileKey, UserSelectionType)) ||
(!startIsUserSelected && !TileSelectionManager.Instance.IsUserSelected(current.Tile.TileKey, UserSelectionType));
}while (continuePath);
routingConstraint += "} [get_nets " + netName + "]" + Environment.NewLine;;
routingConstraint += "set_property IS_ROUTE_FIXED TRUE [get_nets " + netName + "]";
OutputManager.WriteOutput(routingConstraint);
}
}
private async Task <IEnumerable <NatDevice> > DiscoverAsync(PortMapper portMapper, bool onlyOne, CancellationTokenSource cts)
{
TraceSource.LogInfo("Start Discovery");
List <Task <IEnumerable <NatDevice> > > searcherTasks = new List <Task <IEnumerable <NatDevice> > >();
if (portMapper.HasFlag(PortMapper.Upnp))
{
UpnpSearcher upnpSearcher = new UpnpSearcher(new IPAddressesProvider());
upnpSearcher.DeviceFound += (sender, args) => { if (onlyOne)
{
cts.Cancel();
}
};
searcherTasks.Add(upnpSearcher.Search(cts.Token));
}
if (portMapper.HasFlag(PortMapper.Pmp))
{
PmpSearcher pmpSearcher = new PmpSearcher(new IPAddressesProvider());
pmpSearcher.DeviceFound += (sender, args) => { if (onlyOne)
{
cts.Cancel();
}
};
searcherTasks.Add(pmpSearcher.Search(cts.Token));
}
await Task.WhenAll(searcherTasks);
TraceSource.LogInfo("Stop Discovery");
IEnumerable <NatDevice> devices = searcherTasks.SelectMany(x => x.Result);
foreach (NatDevice device in devices)
{
string key = device.ToString();
if (Devices.TryGetValue(key, out NatDevice nat))
{
nat.Touch();
}
else
{
Devices.Add(key, device);
}
}
return(devices);
}
private void ExternalIPChanged(PortMapper sender, IPAddress externalIP)
{
lock (lockObj)
{
if (externalIP == null)
{
return;
}
this.externalIP = externalIP;
logger.Info("Public IP detected: " + externalIP.ToString());
if (IsReadyToNotifyCloud())
{
TaskQueue.EnqueueMedium(this.NotifyCloudOfExternalPort);
}
}
}
private async Task <IEnumerable <NatDevice> > DiscoverAsync(PortMapper portMapper, bool onlyOne,
CancellationTokenSource cts)
{
TraceSource.LogInfo("Start Discovery");
var searcherTasks = new List <Task <IEnumerable <NatDevice> > >();
if (portMapper.HasFlag(PortMapper.Upnp))
{
var upnpSearcher = new UpnpSearcher(new IPAddressesProvider());
upnpSearcher.DeviceFound += (sender, args) => { if (onlyOne)
{
cts.Cancel();
}
};
searcherTasks.Add(upnpSearcher.Search(cts.Token));
}
if (portMapper.HasFlag(PortMapper.Pmp))
{
throw new NotImplementedException();
/*var pmpSearcher = new PmpSearcher(new IPAddressesProvider());
* pmpSearcher.DeviceFound += (sender, args) => { if (onlyOne) cts.Cancel(); };
* searcherTasks.Add(pmpSearcher.Search(cts.Token));*/
}
var devices = (await Task.WhenAll(searcherTasks).ConfigureAwait(false)).SelectMany(enumerable => enumerable.ToList()).ToList();
TraceSource.LogInfo("Stop Discovery");
foreach (var device in devices)
{
var key = device.ToString();
NatDevice nat;
if (Devices.TryGetValue(key, out nat))
{
nat.Touch();
}
else
{
Devices.Add(key, device);
}
}
return(devices);
}
/// <summary>
/// Discovers and returns a NAT device for the specified type; otherwise a <see cref="NatDeviceNotFoundException">NatDeviceNotFoundException</see>
/// exception is thrown when it is cancelled.
/// </summary>
/// <remarks>
/// It allows to specify the NAT type to discover as well as the cancellation token in order.
/// </remarks>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>A NAT device</returns>
/// <exception cref="NatDeviceNotFoundException">when no NAT found before cancellation</exception>
public async Task <NatDevice> DiscoverDeviceAsync(PortMapper portMapper, CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper.HasFlag(PortMapper.Upnp) || portMapper.HasFlag(PortMapper.Pmp), "portMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
var devices = await DiscoverAsync(portMapper, true, cancellationTokenSource);
var device = devices.FirstOrDefault();
if (device == null)
{
TraceSource.LogInfo("Device not found. Common reasons:");
TraceSource.LogInfo("\t* No device is present or,");
TraceSource.LogInfo("\t* Upnp is disabled in the router or");
TraceSource.LogInfo("\t* Antivirus software is filtering SSDP (discovery protocol).");
throw new NatDeviceNotFoundException();
}
return(device);
}
public Mini8086Emulator()
{
var components = new List <BaseComponent>();
_memMapper = new MemoryMapper(512);
_portMapper = new PortMapper();
_cpu = new Cpu8086(_memMapper, _portMapper);
_disassembler = new Disassembler(_cpu, _memMapper);
components.Add(_bios = new Rom(Config.BiosMemAddress));
_memMapper.Register(Config.BiosMemAddress, Config.BiosMemAddress + Config.BiosMemSize - 1, _bios);
components.Add(_pic = new InterruptController(Config.PicBasePort));
_portMapper.Register(Config.PicBasePort, Config.PicBasePort + 0x07, _pic);
components.Add(_timer = new Timer(Config.TimerBasePort, _pic));
_portMapper.Register(Config.TimerBasePort, Config.TimerBasePort + 0x07, _timer);
components.Add(_graphicsAdapter = new GraphicsAdapter(Config.VgaBasePort, Config.VgaMemAddress, _pic, @"..\..\..\ROMs\charrom.bin"));
_portMapper.Register(Config.VgaBasePort, Config.VgaBasePort + 0x07, _graphicsAdapter);
_memMapper.Register(Config.VgaMemAddress, Config.VgaMemAddress + Config.VgaMemSize - 1, _graphicsAdapter);
components.Add(_lcd = new Lcd44780(Config.LcdBasePort));
_portMapper.Register(Config.LcdBasePort, Config.LcdBasePort + 0x07, _lcd);
//components.Add(_ppi = new Ppi(Config.PpiBasePort));
//_portMapper.Register(Config.PpiBasePort, Config.PpiBasePort + 0x07, _ppi);
components.Add(_keybController = new KeybController(Config.KeybControllerBasePort, _pic));
_portMapper.Register(Config.KeybControllerBasePort, Config.KeybControllerBasePort + 0x07, _keybController);
components.Add(_sdController = new SdController(Config.SdControllerBasePort, Config.SdImagePath));
_portMapper.Register(Config.SdControllerBasePort, Config.SdControllerBasePort + 0x07, _sdController);
_memMapper.FinishRegistration();
components.ForEach(_ =>
{
_.EventTimer = _cpu;
_.DoCpuInterrupt = _cpu.DoInterrupt;
});
}
public async Task <int> ListDevicesAsync(bool includePMP)
{
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource(TIMEOUT);
PortMapper param = PortMapper.Upnp;
if (includePMP)
{
param |= PortMapper.Pmp;
}
logMessageContext.Create("Getting devices");
return(await nat.DiscoverDevicesAsync(param, cts).ContinueWith(t =>
{
int result = 0;
if (t.Status != TaskStatus.Faulted)
{
using (IEnumerator <NatDevice> enumerator = t.Result.GetEnumerator())
{
while (enumerator.MoveNext())
{
logMessageContext.Create("Found device: " + enumerator.Current.ToString());
result++;
}
}
}
else
{
if (!(t.Exception.InnerException is NatDeviceNotFoundException))
{
result = -1;
logMessageContext.Create("error listing devices");
}
}
return result;
}));
}
public void Awake()
{
DontDestroyOnLoad(this);
NetworkPlayers = new List <uLink.NetworkPlayer>();
ServerNotifier = new ExternalServerNotifier();
Leaderboard = new Leaderboard();
Leaderboard.Skin = Relay.Instance.BaseSkin;
StatusMessage = "?";
BannerMessages = new List <BannerMessage>();
if (networkView.isMine)
{
_CurrentMapName = Application.loadedLevelName;
IsGameActive = false;
// Set up hooks for UPnP
PortMapper = new PortMapper(Relay.Port);
}
}
public MainEmulator()
{
_memoryMapper = new MemoryMapper();
_portMapper = new PortMapper();
_cpu = new Z80 { MemProvider = _memoryMapper, PortProvider = _portMapper };
_graphics = new Graphics();
_memoryMapper.Register(0x1000, 0x1fff, _graphics, true, false);
_portMapper.Register(5, 7, _graphics);
_ram = new Ram();
_memoryMapper.Register(0, 0xffff, _ram, true, true);
_portMapper.Register(0, 0, _ram);
_tickCounter = new TickCounter(_cancellationTokenSource.Token);
_portMapper.Register(130, 133, _tickCounter);
_diskController = new DiskController(_memoryMapper, () => _cpu.Reset());
_portMapper.Register(160, 169, _diskController);
_serial = new Serial(_memoryMapper);
_portMapper.Register(170, 179, _serial);
_led = new Led();
_portMapper.Register(3, 3, _led);
_speaker = new Speaker();
_portMapper.Register(4, 4, _speaker);
_keyboard = new Keyboard();
_portMapper.Register(128, 129, _keyboard);
//FBootLoader = new BootLoader(FMemoryMapper);
_memoryMapper.FinishRegistration();
OriginalSpeed = true;
}
private void PortMappingChanged(PortMapper sender, PortMapping pm)
{
lock (lockObj)
{
if (pm != myMapping)
{
return;
}
if (pm.MappingStatus != PortMappingStatus.Mapped)
{
return;
}
externalPort = pm.ExternalPort;
logger.Info("External port is registered: " + externalPort);
if (IsReadyToNotifyCloud())
{
TaskQueue.EnqueueMedium(this.NotifyCloudOfExternalPort);
}
}
}
/// <summary>
/// Discovers and returns all NAT devices for the specified type. If no NAT device is found it returns an empty enumerable
/// </summary>
/// <param name="portMapper">Port mapper protocol; Upnp, Pmp or both</param>
/// <param name="cancellationTokenSource">Cancellation token source for cancelling the discovery process</param>
/// <returns>All found NAT devices</returns>
#if NET35
public Task<IEnumerable<NatDevice>> DiscoverDevicesAsync(PortMapper portMapper, CancellationTokenSource cancellationTokenSource)
{
Guard.IsTrue(portMapper.HasFlag(PortMapper.Upnp) || portMapper.HasFlag(PortMapper.Pmp), "portMapper");
Guard.IsNotNull(cancellationTokenSource, "cancellationTokenSource");
return DiscoverAsync(portMapper, false, cancellationTokenSource)
.ContinueWith(t => (IEnumerable<NatDevice>)t.Result.ToArray());
}
public void OnDefineNode(
Func <string, TypeHandle, PortModel.PortModelOptions, PortModel>
addDataInputPort, Func <string, TypeHandle, PortModel> addDataOutputPort,
Func <string, PortModel> addExecutionInputPort,
Func <string, PortModel> addExecutionOutputPort)
{
if (m_PortToOffsetMapping == null)
{
m_PortToOffsetMapping = new PortMapper();
}
else
{
m_PortToOffsetMapping.Clear();
}
m_Node = new GraphReference();
m_Node.Inputs.SetCount(0);
m_Node.DataInputs.SetCount(0);
m_Node.Outputs.SetCount(0);
m_Node.DataOutputs.SetCount(0);
if (!m_GraphReference)
{
return;
}
m_LastHashCode = GetGraphReferenceHashCode();
uint i = 1;
m_Node.Target.Port.Index = i++;
var vsGraphModel = (VSGraphModel)m_GraphReference.GraphModel;
// TODO: ugly. GraphBuilder.AddNodeInternal is processing ports in field declaration order, hence the need here to process variables in a very specific order.
ProcessVariablesOfGivenTypeAndDirection(vsGraphModel, ModifierFlags.ReadOnly, false, m_PortToOffsetMapping);
ProcessVariablesOfGivenTypeAndDirection(vsGraphModel, ModifierFlags.WriteOnly, false, m_PortToOffsetMapping);
ProcessVariablesOfGivenTypeAndDirection(vsGraphModel, ModifierFlags.ReadOnly, true, m_PortToOffsetMapping);
ProcessVariablesOfGivenTypeAndDirection(vsGraphModel, ModifierFlags.WriteOnly, true, m_PortToOffsetMapping);
m_Node.Inputs.Port.Index = 2;
m_Node.Outputs.Port.Index = (uint)(m_Node.Inputs.Port.Index + m_Node.Inputs.DataCount);
m_Node.DataInputs.Port.Index = (uint)(m_Node.Outputs.Port.Index + m_Node.Outputs.DataCount);
m_Node.DataOutputs.Port.Index = (uint)(m_Node.DataInputs.Port.Index + m_Node.DataInputs.DataCount);
void ProcessVariablesOfGivenTypeAndDirection(VSGraphModel graphModel, ModifierFlags expectedFlags,
bool expectedData, PortMapper mPortToOffsetMapping)
{
foreach (var variableModel in graphModel.GraphVariableModels.Where(
v => v.IsInputOrOutput()))
{
var isData = !variableModel.IsInputOrOutputTrigger();
if (variableModel.Modifiers != expectedFlags || isData != expectedData)
{
continue;
}
PortModel p;
if (variableModel.Modifiers == ModifierFlags.ReadOnly)
{
if (isData)
{
p = addDataInputPort(variableModel.Name, variableModel.DataType, PortModel.PortModelOptions.NoEmbeddedConstant);
m_Node.DataInputs.DataCount++;
}
else
{
p = addExecutionInputPort(variableModel.Name);
m_Node.Inputs.DataCount++;
}
}
else
{
if (isData)
{
p = addDataOutputPort(variableModel.Name, variableModel.DataType);
m_Node.DataOutputs.DataCount++;
}
else
{
p = addExecutionOutputPort(variableModel.Name);
m_Node.Outputs.DataCount++;
}
}
mPortToOffsetMapping.Add(p.UniqueId, p.Direction, i++);
}
}
}
private void DidStartWork(PortMapper sender)
{
}
public static void ForwardPorts(PortMapper type = PortMapper.Upnp, bool retry = false)
{
var config = Config.Load();
var webServerPort = config.WebServer.WebServerPort;
var apiPort = config.TaskServer.TaskServerPort;
var webCamPort = config.Webcams.WebcamPort;
var terminalPort = config.Terminal.TerminalPort;
var screenSharePort = config.ScreenShareService.ScreenSharePort;
var nat = new NatDiscoverer();
var cts = new CancellationTokenSource();
cts.CancelAfter(5000);
NatDevice device;
var t = nat.DiscoverDeviceAsync(type, cts);
t.ContinueWith(tt =>
{
device = tt.Result;
device.GetExternalIPAsync()
.ContinueWith(task =>
{
;
return(device.DeletePortMapAsync(
new Mapping(Protocol.Tcp, webServerPort, webServerPort, 0, "Ulterius Web Server")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.DeletePortMapAsync(
new Mapping(Protocol.Tcp, screenSharePort, screenSharePort, 0, "Ulterius Screen Share")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.DeletePortMapAsync(
new Mapping(Protocol.Tcp, apiPort, apiPort, 0, "Ulterius Api")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.DeletePortMapAsync(
new Mapping(Protocol.Tcp, webCamPort, webCamPort, 0, "Ulterius Webcams")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.DeletePortMapAsync(
new Mapping(Protocol.Tcp, terminalPort, terminalPort, 0, "Ulterius Terminal")));
})
.Unwrap()
.ContinueWith(task =>
{
;
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, webServerPort, webServerPort, 0, "Ulterius Web Server")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, screenSharePort, screenSharePort, 0, "Ulterius Screen Share")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, apiPort, apiPort, 0, "Ulterius Api")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, webCamPort, webCamPort, 0, "Ulterius Webcams")));
})
.Unwrap()
.ContinueWith(task =>
{
return(device.CreatePortMapAsync(
new Mapping(Protocol.Tcp, terminalPort, terminalPort, 0, "Ulterius Terminal")));
})
.Unwrap()
.ContinueWith(task => { Console.WriteLine("Ports forwarded!"); });
}, TaskContinuationOptions.OnlyOnRanToCompletion);
try
{
t.Wait();
}
catch (AggregateException e)
{
if (e.InnerException is NatDeviceNotFoundException)
{
if (retry)
{
return;
}
ForwardPorts(PortMapper.Pmp, true);
Console.WriteLine("No NAT Device Found");
}
}
}
public void Awake()
{
DontDestroyOnLoad(this);
NetworkPlayers = new List<uLink.NetworkPlayer>();
ServerNotifier = new ExternalServerNotifier();
Leaderboard = new Leaderboard();
Leaderboard.Skin = Relay.Instance.BaseSkin;
StatusMessage = "?";
BannerMessages = new List<BannerMessage>();
if (networkView.isMine)
{
_CurrentMapName = Application.loadedLevelName;
IsGameActive = false;
// Set up hooks for UPnP
PortMapper = new PortMapper(Relay.Port);
}
}
private async Task<IEnumerable<NatDevice>> DiscoverAsync(PortMapper portMapper, bool onlyOne, CancellationTokenSource cts)
{
TraceSource.LogInfo("Start Discovery");
var searcherTasks = new List<Task<IEnumerable<NatDevice>>>();
if(portMapper.HasFlag(PortMapper.Upnp))
{
var upnpSearcher = new UpnpSearcher(new IPAddressesProvider());
upnpSearcher.DeviceFound += (sender, args) => { if (onlyOne) cts.Cancel(); };
searcherTasks.Add(upnpSearcher.Search(cts.Token));
}
if(portMapper.HasFlag(PortMapper.Pmp))
{
var pmpSearcher = new PmpSearcher(new IPAddressesProvider());
pmpSearcher.DeviceFound += (sender, args) => { if (onlyOne) cts.Cancel(); };
searcherTasks.Add(pmpSearcher.Search(cts.Token));
}
await Task.WhenAll(searcherTasks);
TraceSource.LogInfo("Stop Discovery");
var devices = searcherTasks.SelectMany(x => x.Result);
foreach (var device in devices)
{
var key = device.ToString();
NatDevice nat;
if(Devices.TryGetValue(key, out nat))
{
nat.Touch();
}
else
{
Devices.Add(key, device);
}
}
return devices;
}
private void PortMapper_DidFinishWork(PortMapper sender)
{
DebugLog.WriteLine("Form1: PortMapper_DidFinishWork");
}
private void PortMapper_ExternalIPAddressDidChange(PortMapper sender, System.Net.IPAddress ip)
{
DebugLog.WriteLine("Form1: PortMapper_ExternalIPAddressDidChange");
UpdateTagLine();
}
private void IntergrateIntoContainer(Command callee)
{
m_instanceCode.AppendLine("-- instantiation of " + m_instantation.InstanceName);
m_instanceCode.AppendLine(m_instantation.InstanceName + " : " + m_instantation.GetLibraryElement().PrimitiveName);
if (!string.IsNullOrEmpty(m_libraryElement.VHDLGenericMap))
{
m_instanceCode.AppendLine(m_libraryElement.VHDLGenericMap);
}
m_instanceCode.AppendLine("port map (");
List <string> mappings = new List <string>();
foreach (XDLPort port in ((XDLContainer)m_libraryElement.Containter).Ports)
{
if (!m_instantation.PortMapper.HasKindMapping(port.ExternalName))
{
callee.OutputManager.WriteOutput("Warning: Could not find a signal mapping for port " + port.ExternalName + ". Misspelled mapping? Note that the mapping is case sensitive.");
continue;
}
PortMapper mapper = m_instantation.PortMapper;
PortMapper.MappingKind mappingKind = mapper.GetMapping(port.ExternalName);
string rightHandSide = mapper.GetSignalName(port.ExternalName);
// do not vectorize already indeced ports
//bool vector = Regex.IsMatch(port.ExternalName, @"\d+$") && !Regex.IsMatch(rightHandSide, @"\(\d+\)$");
if (rightHandSide.Equals("0") || rightHandSide.Equals("1"))
{
mappings.Add("\t" + port.ExternalName + " => " + "'" + rightHandSide + "',");
}
else if (rightHandSide.Equals("open"))
{
mappings.Add("\t" + port.ExternalName + " => open,");
}
else if (!rightHandSide.Equals("open"))
{
VHDLSignalList signalList = null;
switch (mappingKind)
{
case PortMapper.MappingKind.NoVector:
case PortMapper.MappingKind.External:
{
// in case of entity signals add direction
signalList = m_container.Entity;
m_container.Entity.SetDirection(rightHandSide, port.Direction);
break;
}
case PortMapper.MappingKind.Internal:
{
signalList = m_container.SignalDeclaration;
break;
}
default:
throw new ArgumentException("Found port mapped to " + mappingKind + ". This mapping is not supported. Use either public or external, see command AddPortMapping");
}
if (!signalList.HasSignal(rightHandSide))
{
if (m_instantation.PortMapper.HasKindMapping(port.ExternalName))
{
signalList.Add(rightHandSide, 1, m_instantation.PortMapper.GetMapping(port.ExternalName));
}
else
{
signalList.Add(rightHandSide, 1);
}
}
switch (mappingKind)
{
case PortMapper.MappingKind.Internal:
case PortMapper.MappingKind.External:
{
//int index = signalList.GetSignalWidth(rightHandSide) - 1;
int index = mapper.GetIndex(port.ExternalName);
mappings.Add("\t" + port.ExternalName + " => " + rightHandSide + "(" + index + "),");
if (!signalList.HasSignal(rightHandSide))
{
signalList.Add(rightHandSide, -1);
}
if (signalList.GetSignalWidth(rightHandSide) <= index)
{
signalList.SetSignalWidth(rightHandSide, index + 1);
}
// store the index generated during VHDL generation for interface checks
//this.m_instantation.GetPortMapper().SetIndex(port.ExternalName, index);
break;
}
case PortMapper.MappingKind.NoVector:
{
mappings.Add("\t" + port.ExternalName + " => " + rightHandSide + ",");
break;
}
default:
throw new ArgumentException("Found port mapped to " + mappingKind + ". This mapping is not supported. Use either public or external, see command AddPortMapping");
}
}
}
if (mappings.Count > 0)
{
mappings[mappings.Count - 1] = Regex.Replace(mappings[mappings.Count - 1], ",$", "");
}
// update tool info
//Tile t = FPGA.FPGA.Instance.GetTile(m_instantation.AnchorLocation);
//Blackboard.Instance.ClearToolTipInfo(t);
foreach (string str in mappings)
{
m_instanceCode.AppendLine(str);
// update tool info
if (!str.EndsWith(" => ,"))
{
string toolTip = str;
toolTip = Regex.Replace(toolTip, @"^\s+", "");
toolTip = Regex.Replace(toolTip, ",", "");
toolTip += Environment.NewLine;
//Blackboard.Instance.AddToolTipInfo(t, toolTip);
}
}
m_instanceCode.AppendLine(");");
}
private void WillStartSearchForRouter(PortMapper sender)
{
}
