public BeginAcceptSocket ( AsyncCallback callback, object state ) : IAsyncResult | ||
callback | AsyncCallback | |
state | object | |
return | IAsyncResult |
static void Main(string[] args) { GMSKeys.Initialize(); { // Quick test ITEMS = new Dictionary<short, ItemEquip>(); ITEMS.Add(1, new ItemEquip(1113017) { StatusFlags = 0x0714, Potential1 = 40356, Potential2 = 30041, Potential3 = 30044, Potential4 = 12011, Potential5 = 2014, Potential6 = 2014, SocketState = 0x00FF, Nebulite2 = 1001, Nebulite1 = 2001, Nebulite3 = 3400, }); //File.WriteAllText("import.xml", ITEMS.Serialize()); if (File.Exists("import.xml")) { ITEMS = File.ReadAllText("import.xml").Deserialize<Dictionary<short, ItemEquip>>(); } } if (ITEMS == null) ITEMS = new Dictionary<short, ItemEquip>(); { TcpListener listener = new TcpListener(System.Net.IPAddress.Any, 8484); listener.Start(); AsyncCallback EndAccept = null; EndAccept = (a) => { new Client(listener.EndAcceptSocket(a)); Console.WriteLine("accepted"); listener.BeginAcceptSocket(EndAccept, null); }; listener.BeginAcceptSocket(EndAccept, null); } Console.ReadLine(); }
/// <summary> /// Constructor used to initialize a new BoggleServer. This will initialize the GameLength /// and it will build a dictionary of all of the valid words from the DictionaryPath. If an /// optional string was passed to this application, then it will build a BoggleBoard from /// the supplied string. Otherwise it will build a BoggleBoard randomly. /// </summary> /// <param name="GameLength">The length that the Boggle game should take.</param> /// <param name="DictionaryPath">The filepath to the dictionary that should be used to /// compare words against.</param> /// <param name="OptionalString">An optional string to construct a BoggleBoard with.</param> public BoggleServer(int GameLength, string DictionaryPath, string OptionalString) { try { this.UnderlyingServer = new TcpListener(IPAddress.Any, 2000); this.GameLength = GameLength; this.DictionaryWords = new HashSet<string>(File.ReadAllLines(DictionaryPath)); this.WaitingPlayer = null; this.CommandReceived = new Object(); this.ConnectionReceivedLock = new Object(); if (OptionalString != null) this.OptionalString = OptionalString; Console.WriteLine("The Server has Started on Port 2000"); // Start the server and begin accepting clients. UnderlyingServer.Start(); UnderlyingServer.BeginAcceptSocket(ConnectionReceived, null); } // If any exception occured when starting the sever or connecting clients, // print out an error message and the stacktrace where the error occured. catch (Exception e) { Console.WriteLine("An Exception Occured When Building the BoggleServer:"); Console.WriteLine(e.ToString()); } }
public Mainwin() { InitializeComponent(); cms = this.contextMenuStrip1; // providing a cms for rows for (int i = 0; i < 21; i++) { this.grid1.addRow(); } Host = SettingsWin.host.Text; ports = int.Parse(SettingsWin.Port.Text ) ; SettingsWin.resetSocketB.Click += resetSocketB_Click; IPAddress ipAd = IPAddress.Parse("127.0.0.1"); // use local m/c IP address, and // use the same in the client /* Initializes the Listener */ var tempList = new TcpListener(IPAddress.Any, 5202); myList.AddLast(tempList); tempList.Start(); tempList.BeginAcceptSocket(this.AcceptClient,tempList); timer1.Start(); }
void resetSocketB_Click(object sender, EventArgs e) { foreach (var item in myList) { item.Stop(); } myList.Clear(); IPAddress ipAd = IPAddress.Parse(SettingsWin.host.Text); // use local m/c IP address, and // use the same in the client /* Initializes the Listener */ //TODO : make handle multi listeners !! String [] a = SettingsWin.Port.Text.Split(','); foreach (String portt in a ) { try { var tempList = new TcpListener(IPAddress.Any, int.Parse(portt)); tempList.Start(); tempList.BeginAcceptSocket(this.AcceptClient, tempList); myList.AddLast(tempList); } catch { } } }
public void StartListener(string ip,int port) { socket = new Socket(SocketType.Stream,ProtocolType.Tcp); listener = new TcpListener(new IPEndPoint(IPAddress.Parse(ip), port)); listener.Start(); listener.BeginAcceptSocket(clientConnect, listener); }
/// <summary> /// Constructor to create the list of connects and create /// a new thread to wait/accept new connections /// </summary> public ConnectionManager(String host, String p) { Log.WriteMessage("WhitStream Server Started.", Log.eMessageType.Normal); m_ipAddress = IPAddress.Parse(host); m_listenPort = int.Parse(p); //Initialize the list to hold no connections and default capacity m_connectionList = new List<Connection>(); //Initialize the list to hold all ports from 4001 to 4010 m_availablePorts = new Queue<int>(10); for (int i = 4001; i <= 4010; i++) { m_availablePorts.Enqueue(i); } Log.WriteMessage("Waiting for connections....", Log.eMessageType.Debug); //Register a new TcpListener m_incomingListener = new TcpListener(m_ipAddress, m_listenPort); m_incomingListener.Start(); m_incomingListener.BeginAcceptSocket(new AsyncCallback(Accept_Socket), null); m_checkThread = new Thread(CheckConnections); m_checkThread.Start(); }
/// <summary> /// Creates a new NPCServer /// </summary> internal Framework(string OptionsFile = "settings.ini") { // Default PM this.NCMsg = CString.tokenize ("I am the npcserver for\nthis game server. Almost\nall npc actions are controled\nby me."); // Create Compiler Compiler = new GameCompiler (this); // Create Player Manager PlayerManager = new Players.PlayerList (this, GSConn); AppSettings settings = AppSettings.GetInstance (); settings.Load (OptionsFile); // Connect to GServer GSConn = new GServerConnection (this); this.ConnectToGServer(); // Setup NPC-Control Listener cNCAccept = new AsyncCallback (NCControl_Accept); this.UPnPOpenPort(); NCListen = new TcpListener (IPAddress.Parse (this.LocalIPAddress ()), settings.NCPort); NCListen.Start (); NCListen.BeginAcceptSocket (cNCAccept, NCListen); settings.Save (); // Setup Timer //timeBeginPeriod(50); //TimerHandle = new TimerEventHandler(RunServer); //TimerId = timeSetEvent(50, 0, TimerHandle, IntPtr.Zero, EVENT_TYPE); }
/// <summary> /// Creates a BoggleServer that listens for connections on port 2000. /// </summary> public BoggleServer(int gameTime, HashSet<string> dictionary, string boardConfiguration) { // Initialize fields. _PORT = 2000; _server = new TcpListener(IPAddress.Any, _PORT); _waitingPlayer = null; _allMatches = new HashSet<Match>(); _lock = new object(); _gameTime = gameTime; _dictionary = dictionary; _boardConfiguration = boardConfiguration; // Start the server. _server.Start(); // Start listening for a client to connect. _server.BeginAcceptSocket(ConnectionReceived, null); // Create a timer with a one second interval. timer = new System.Timers.Timer(1000); // Hook up the Elapsed event for the timer. timer.Elapsed += OneSecondHasPassed; timer.Enabled = true; // Keep this program alive Thread t = new Thread(stayAlive); t.Start(); }
private Connect4ClientConnection waiting; //Player 1 - put into a game as soon as Player 2 is identified. Set to null once the game starts #endregion Fields #region Constructors /// <summary> /// Constructs a new Connect4Service object. Takes values to set the port it listens on, /// as well as a time limit for games held on this server. /// Throws InvalidOperationException if timelimit < 1, or the port number is out of range /// or already being listened on. /// </summary> /// <param name="portNumber">Port for the server to listen on</param> /// <param name="timeLimit">Time limit for users in games on this server</param> public Connect4Service(int portNumber, int _timeLimit, WhoGoesFirst _choosingMethod) { if (_timeLimit <= 0) { throw new InvalidOperationException("time limit must be positive"); } if (portNumber > IPEndPoint.MaxPort || portNumber < IPEndPoint.MinPort) { throw new InvalidOperationException("invalid port number"); } choosingMethod = _choosingMethod; games = new List<Connect4Game>(); needToIdentify = new List<Connect4ClientConnection>(); waiting = null; timeLimit = _timeLimit; server = new TcpListener(IPAddress.Any, portNumber); try { server.Start(); } catch (SocketException) { throw new InvalidOperationException("port already taken (or something like that)"); } server.BeginAcceptSocket(ConnectionRequested, null); isShuttingDown = false; }
//---------------------------------------------------------------------- //Construction, Destruction //---------------------------------------------------------------------- /// <summary> /// Creating server socket /// </summary> /// <param name="port">Server port number</param> public StandardTcpServer(int port) { connectedSockets = new Dictionary<IPEndPoint, Socket>(); tcpServer = new TcpListener(IPAddress.Any, port); tcpServer.Start(); tcpServer.BeginAcceptSocket(EndAcceptSocket, tcpServer); }
public void Start() { _stop = false; _listener = new TcpListener(IPAddress.Any, _port); _listener.Start(); _listener.BeginAcceptSocket(OnAcceptSocket, null); }
public void Start(int port) { if (RequestHandler == null) throw new InvalidOperationException("You must hook the RequestHandler delegate first."); _listener = new TcpListener(IPAddress.Any, port); _listener.Start(500); _listener.BeginAcceptSocket(OnAccept, null); }
public netservice() { listen = new TcpListener(IPAddress.Parse("0.0.0.0"), 1234); listen.Start(); listen.BeginAcceptSocket(new AsyncCallback(this.onAccept), listen); }
internal bool Start(ushort port) { if (Running) { throw new Exception("Listener is already running."); } listen = new TcpListener(IPAddress.Any,port); try { listen.Start(); } catch { Stop(); return false; } listen.BeginAcceptSocket(new AsyncCallback(Accept),null); return true; }
/// <summary> /// #ctor /// makes server with new client lis /// </summary> /// <param name="port"></param> public BoggleServer(int port) { server = new TcpListener(IPAddress.Any,port); clients = new Queue<Tuple<StringSocket, string>>(); currentGames = new HashSet<game>(); server.Start(); server.BeginAcceptSocket(ConnectionAccept, null); }
public override void StartProcessing() { _options.Validate(); _listener = new TcpListener(_options.Endpoint); _listener.Start(); _listener.BeginAcceptSocket(AcceptCallback, _listener); }
public MainWindow() { InitializeComponent(); FS = new FileStream("C:\\Users\\CORE\\Desktop\\vidTEST",FileMode.Create,FileAccess.Write); receiveBytes = new byte[1000000]; listener = new TcpListener(IPAddress.Any, serverPort); listener.Start(); listener.BeginAcceptSocket(acceptClient, null); }
/// <summary> /// Starts listening for incoming connections at ::1 on a random port. /// </summary> public void Listen() { _server = new TcpListener(IPAddress.IPv6Loopback, 0); _server.Start(); _server.BeginAcceptSocket(AcceptClient, null); _timeout = new Thread(Timeout); _timeout.Start(); }
public GlowListener(int port, int maxPackageLength) { Port = port; MaxPackageLength = maxPackageLength; _listener = new TcpListener(IPAddress.Any, port); _listener.Start(); _listener.BeginAcceptSocket(Callback_Accept, _listener); }
public TcpServer(int port) { Contract.Requires(0 <= port && port <= ushort.MaxValue); socketsDictionary = new Dictionary<IPEndPoint, Socket>(); tcpServer = new TcpListener(IPAddress.Any, port); tcpServer.Start(); tcpServer.BeginAcceptSocket(EndAcceptSocket, tcpServer); }
public Listener(IPAddress address, int port) { listener = new TcpListener (address, port); uri = new Uri (string.Format ("http://{0}:{1}/", address, port)); handlers = new Dictionary<string, Handler> (); listener.Start (); listener.BeginAcceptSocket (AcceptSocketCB, null); }
public acceptnetworkservice(String ip, short port, juggle.process _process) { process_ = _process; listen = new TcpListener(IPAddress.Parse(ip), port); listen.Start(); listen.BeginAcceptSocket(new AsyncCallback(this.onAccept), listen); }
public static TestConnection CreateConnection() { var listener = new TcpListener(IPAddress.Loopback, 0); listener.Start(); var ar = listener.BeginAcceptSocket(null, null); var s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); s.Connect(IPAddress.Loopback, ((IPEndPoint) listener.LocalEndpoint).Port); var server = listener.EndAcceptSocket(ar); return new TestConnection {Client = s, Server = server}; }
static Tuple<int, IDisposable> ListenTcp(AsyncCallback accept) { var socket = new TcpListener (IPAddress.Loopback, 0); socket.Start (); socket.BeginAcceptSocket (accept, socket); var endpoint = socket.LocalEndpoint as IPEndPoint; if (endpoint == null) Assert.Fail ("LocalEndPoint wasn't an IPEndPoint"); return new Tuple<int,IDisposable>(endpoint.Port, socket.Server); }
/// <summary> /// Constructs a new web server. /// </summary> public WebServer() { Console.WriteLine("Web Server started."); // Start the server, and listen for incoming connections. server = new TcpListener(IPAddress.Any, 2500); server.Start(); server.BeginAcceptSocket(ConnectionReceived, null); sendString.Append("<html>"); }
public GwTcpListener(Gateway gateway, ChainSide side, IPEndPoint ipSource) { this.gateway = gateway; this.ipSource = ipSource; this.side = side; tcpListener = new TcpListener(ipSource); tcpListener.Start(10); tcpListener.BeginAcceptSocket(ReceiveConn, tcpListener); if (Log.WillDisplay(System.Diagnostics.TraceEventType.Start)) Log.TraceEvent(System.Diagnostics.TraceEventType.Start, -1, "TCP Listener " + side.ToString() + " on " + ipSource); }
private void Run(string[] args) { int port = Int32.Parse(args[0]); Console.WriteLine("Started listening on port: {0}", port); var server = new TcpListener(IPAddress.Any, port); server.Start(); server.BeginAcceptSocket(new AsyncCallback(server_onAccept), server); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); }
public Socket GetConnectedSocket() { var listener = new TcpListener(IPAddress.Loopback, 0); listener.Start(); IAsyncResult res = listener.BeginAcceptSocket(null, null); _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _socket.Connect(IPAddress.Loopback, listener.LocalEndpoint.As<IPEndPoint>().Port); Socket clientSocket = listener.EndAcceptSocket(res); StartRead(); return clientSocket; }
static void Main(string[] args) { TcpListener listen = new TcpListener( IPAddress.Any, 8023); listen.Start(); while (true) { clientConnected.Reset(); listen.BeginAcceptSocket(OnAccept, listen); clientConnected.WaitOne(); } }
/// <summary> /// Constructs a new boggle server. /// </summary> public Server(int port) { server = new TcpListener(IPAddress.Any, port); server.Start(); server.BeginAcceptSocket(ConnectionReceived, null); // Initialize the new Queue. User = new Queue<User>(); //Initialize the new Lobby lobby = new Lobby(); }
void AcceptCallback(IAsyncResult ar) { try { if (!IsTerminating) { Socket clientSocket = serverSocket.EndAcceptSocket(ar); clientSocketList.Add(clientSocket.GetHashCode().ToString(), clientSocket); clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), clientSocket); serverSocket.BeginAcceptSocket(new AsyncCallback(AcceptCallback), null); } } catch (Exception ex) { } }
public bool Initialize(IHost hostApplication) { My = hostApplication; FeuerwehrCloud.Helper.Logger.WriteLine("| *** BosMon-Compatibility loaded: listening on Port 3334"); try { serverSocket = new TcpListener(IPAddress.Any, 3334); serverSocket.Start(); serverSocket.BeginAcceptSocket(new AsyncCallback(AcceptCallback), null); } catch (Exception ex) { } return(true); }
public void Start() { if (CreateLogs) { logFile = new System.IO.StreamWriter(LogsPath, true); logFile.AutoFlush = true; } if (CreateLogs) { logFile.WriteLine("S\t" + DateTime.Now.ToString()); logFile.Flush(); } listener.Start(int.MaxValue); if (RootAddress == null || RootAddress == "") { throw new ArgumentNullException("rootAddress", "Null value"); } if (!(new System.IO.DirectoryInfo(RootAddress)).Exists) { throw new ArgumentNullException("rootAddress", "Invalid value"); } listener.BeginAcceptSocket(ConnectionHandler, listener); }
/// <summary> /// Starts the TCP server and begin to listen incomming connections /// </summary> public void Start() { if (running) { throw new Exception("Tcp Server already running"); } if (port <= 0) { throw new Exception("Port is not configured"); } //listener = new TcpListener(IPAddress.Parse("127.0.0.1"), port); listener = new TcpListener(IPAddress.Any, port); //listener.ExclusiveAddressUse listener.Server.ReceiveBufferSize = this.bufferSize; listener.Server.SendBufferSize = this.bufferSize; listener.Start(); listener.BeginAcceptSocket(dlgSocketAccepted, listener); running = true; }
private void SocketAccepted(IAsyncResult result) { Socket s; AsyncStateObject aso; try { s = listener.EndAcceptSocket(result); } catch { return; } if (s.Connected) { clients.Add(s); aso = new AsyncStateObject(s, bufferSize); BeginReceive(aso); if (ClientConnected != null) { ClientConnected(s); } } listener.BeginAcceptSocket(dlgSocketAccepted, listener); }