Chat server: Difference between revisions

{{task|Networking and Web Interaction}}

 

 

=={{header|Ada}}==

{{libheader|AdaSockets}}

 

with Ada.Command_Line; use Ada.Command_Line;

with Ada.Exceptions; use Ada.Exceptions;

Dummy.Start (Incoming_Socket);

end loop;

 

=={{header|C}}==

A glitch occurs if a connection is made using the Telnet protocol - user names are preceded by garbled text.

 

#include <stdlib.h>

#include <sys/socket.h>

 

return 0;

 

 

This is ported from the JavaScript version. The tool js2coffee got me a mostly working version, and then I manually converted JS-style classes to CS "classic-style class" syntax.

 

net = require("net")

sys = require("sys")

 

server = new ChatServer()

 

=={{header|D}}==

import std.getopt;

import std.socket;

}

}

=={{header|Erlang}}==

-module(chat).

 

Response -> Response

end.

=={{header|Go}}==

This example uses the Go idiom of [http://blog.golang.org/share-memory-by-communicating ''Do not communicate by sharing memory; instead, share memory by communicating'']; there are no explicit locks used, instead Go channels are used to safely synchronize where required.

This example handles the case of one specific client "falling behind" by relying on the underlying TCP stack to do a reasonable job of buffering. Once that buffer fills, a write to the that client's connection will time out and the connection will dropped. Other minor improvements would include enabling TCP keep alives, handling temporary errors from accept, and better logging. Not ideal, but it should be good enough for this example.

 

 

import (

log.Println("Listening for connections on", addr)

defer ln.Close()

go s.handleConns()

for {

// chat client connections as well as broadcasting messages to them.

func (s *Server) handleConns() {

// We define the `conns` map here rather than within Server,

// and we use local function literals rather than methods to be

}

c.server.rem <- c.name

 

=={{header|Haskell}}==

import Network

import System.IO

T.putStrLn "Server started"

newMVar (M.empty) >>= clientLoop server

 

==Icon and {{header|Unicon}}==

 

This is Unicon-specific:

 

procedure main()

critical mlck: nCons -:= 1

}

=={{header|Java}}==

 

I think ideally, NIO would be used to select() sockets available/ready for I/O, to eliminate the possibility of a bad connection disrupting the server, but this increases the complexity.

 

import java.net.*;

import java.util.*;

}

}

=={{header|JavaScript}}==

{{works with|Node.js}}

/*******************************************************************************

* ChatServer

* Manages connections, users, and chat messages.

******************************************************************************/

 

}

 

 

 

};

 

 

};

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

}

 

=={{header|Nim}}==

 

 

proc sendOthers(client: Client, line: string) {.async.} =

for c in clients:

await c.socket.send(line & "\c\L")

 

proc processClient(socket: AsyncSocket) {.async.} =

await socket.send("Please enter your name: ")

 

 

while true:

let line = await client.socket.recvLine()

if line == "":

 

proc serve() {.async.} =

var server = newAsyncSocket()

server.bindAddr(Port(4004))

while true:

let socket = await server.accept()

 

=={{header|Objeck}}==

use System.IO.Net;

use System.Concurrency;

}

}

 

=={{header|PicoLisp}}==

 

(de chat Lst

(tell 'chat "--- " *Name " left ---")

(bye) ) ) )

After starting the above script, connect to the chat server from two terminals:

<pre> Terminal 1 | Terminal 2

| Connection closed.

| $</pre>

 

=={{header|Python}}==

 

import socket

time.sleep(.1)

except (SystemExit, KeyboardInterrupt):

 

=={{header|Racket}}==

 

This is a very basic chat server, but it does everything that is needed for this task.

 

#lang racket

 

(void (thread (λ() (chat-server (tcp-listen 12321)))))

((client (current-input-port) (current-output-port)))

 

=={{header|Ruby}}==

 

class ChatServer < GServer

#Turn on informational messages

ChatServer.new(7000, '0.0.0.0', 100, $stderr, true).start.join

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

# Write a message to everyone except the sender of the message

socket -server {coroutine c[incr count] chat} 4004

set ::cmap {}; # Dictionary mapping nicks to channels

 

=={{header|zkl}}==

{{trans|Python}}

On my Linux box, telnet seems to only want to connect to port 23.

pipe:=Thread.Pipe(); // how server tells thread to connect to user

 

server:=Network.TCPServerSocket.open(PORT);

println("Listening on %s:%s".fmt(server.hostname,server.port));

{{out}}

Start the server:

Connection closed by foreign host.

</pre>

{{omit from|AutoHotkey}}

{{omit from|Lilypond}}

{{omit from|Mathematica}}

{{omit from|Maxima}}

{{omit from|PARI/GP|No good way to access network}}

{{omit from|Retro}}