ProtocolStack/IPMapper.cs

using System;
using System.Collections;
using System.Net;
using Microsoft.Win32;

namespace ProtocolStack
{
        public class IPMapper : System.Collections.DictionaryBase
        {
                public IPMapper(StackInterface thisStack) : base() {
                        // add server IP address
                        IPAddress hostIP = thisStack.settings.ServerIP;
                        Console.Write("Server IP Address (ENTER Selects [{0}]): ", hostIP.ToString());
                        string serverIPString = Console.ReadLine();
                        if (serverIPString == "") { serverIPString = hostIP.ToString(); }
                        IPAddress myServerIP = IPAddress.Parse(serverIPString);
                        this.AddMapping(0, myServerIP);

                        // add client IP address
                        IPAddress defaultAddress = thisStack.settings.ClientIP;
                        Console.Write("GPRS Phone (Client) Address (Enter Selects [{0}]): ", defaultAddress.ToString());
                        string gprsIPstring = Console.ReadLine();
                        if (gprsIPstring == "") { gprsIPstring = defaultAddress.ToString(); }
                        this.AddMapping(1, IPAddress.Parse(gprsIPstring)); // GPRS Testing
                } 

                public IPAddress Lookup(ushort deviceID) {
                        if (Dictionary.Contains(deviceID)) {
                                return (IPAddress)Dictionary[deviceID];
                        } else {
                                throw new IPMappingNotFoundException(String.Format("IP Mapping for Device {0} not found", deviceID));
                        }
                }

                public void AddMapping(ushort deviceID, IPAddress ipAddress) {
                        try {
                                Dictionary[deviceID] = ipAddress; // this way we update any old mappings
                        } catch (Exception ex) {
                                throw new IPMappingException("Unable to Add mappting to IP Mapper", ex);
                        }
                }
        }

        public class IPMappingException : ApplicationException {
                public IPMappingException() : base() {}
                public IPMappingException(string message) : base(message) {}
                public IPMappingException(string message, Exception innerException) : base(message, innerException) {}
        }

        public class IPMappingNotFoundException : IPMappingException {
                public IPMappingNotFoundException() : base() {}
                public IPMappingNotFoundException(string message) : base(message) {}
                public IPMappingNotFoundException(string message, Exception innerException) : base(message, innerException) {}
        };


        /*************************************************************************/
        public class StackSettings {
                public StackSettings() {
                        LoadFromReg();
                        //throw new NotImplementedException("Stack Settings not implemented");
                }

                private int myDeviceID = -1 ;

                public ushort MyDeviceID {
                        get { if (myDeviceID >= 0) {
                                          return (ushort)myDeviceID; 
                                  } else {
                                          throw new ApplicationException("Unable to fetch Device ID for stack - no device ID set");
                                  }
                        } 
                        set { myDeviceID = value;}
                }

                public int ClientReceivePortNumber {
                        get { return 30481; }
                }
                private int clientRxPortNum; 

                public int ClientSendFromPortNumber {
                        get { return 12346; }
                }

                public int ServerSendFromPortNumber {
                        get { return 12345; }
                }

                public int ServerReceivePortNumber {
                        get { return 30481; }
                }
                private int serverRxPortNum;

                private void LoadFromReg() {
                        // Opens registry 
                        RegistryKey regKey = Registry.CurrentUser.OpenSubKey("Software\\University of Cambridge\\GPRSWeb", true);
                        myDeviceID = (int)regKey.GetValue("DeviceID", -1); 
                        defaultBDP = (int)regKey.GetValue("DefaultBDP", -1);
                        interAckableTime = (int)regKey.GetValue("InterAckableTime", -1);
                        firstAckableTime = (int)regKey.GetValue("FirstAckableTime", -1);
                        ackArrivalTimeout = (int)regKey.GetValue("AckArrivalTimeout", -1);
                        serverIP = (string)regKey.GetValue("ServerIP", "");
                        clientIP = (string)regKey.GetValue("ClientIP", "");
                        clientRxPortNum = (int)regKey.GetValue("ClientRxPort", -1);
                        serverRxPortNum = (int)regKey.GetValue("ServerRxPort", -1);
                }

                private int defaultBDP;
                public int DefaultBandwidthDelayProdut {
                        get { 
                                if (defaultBDP >= 0) {
                                        return defaultBDP; 
                                } else {
                                        throw new ApplicationException("Unable to fetch Default Bandwidth Deplay Product - not set");
                                }
                        }
                }

                private int interAckableTime;
                public int InterAckableTime {
                        get { 
                                if (interAckableTime >= 0) {
                                        return interAckableTime; 
                                } else {
                                        throw new ApplicationException("Unable to fetch InterAckableTime - not set");
                                }
                        }
                }

                private int firstAckableTime;
                public int FirstAckableTime {
                        get { 
                                if (firstAckableTime >= 0) {
                                        return firstAckableTime; 
                                } else {
                                        throw new ApplicationException("Unable to fetch FirstAckableTime - not set");
                                }
                        }
                }

                private int ackArrivalTimeout;
                public int AckArrivalTimeout {
                        get { 
                                if (ackArrivalTimeout >= 0) {
                                        return ackArrivalTimeout; 
                                } else {
                                        throw new ApplicationException("Unable to fetch AckArrivalTimeout- not set");
                                }
                        }
                }

                private string serverIP;
                public IPAddress ServerIP {
                        get {
                                try {
                                        return IPAddress.Parse(serverIP);
                                } catch (Exception ex) {
                                        throw new ApplicationException("Unable to fetch Server IP", ex);
                                }
                        }
                }

                private string clientIP;
                public IPAddress ClientIP {
                        get {
                                try {
                                        return IPAddress.Parse(clientIP);
                                } catch (Exception ex) {
                                        throw new ApplicationException("Unable to fetch Client IP", ex);
                                }
                        }
                }

                public ushort SERVER_DEVICE_ID {
                        get { return 0; }
                }

        }
}

---