Echo server: Difference between revisions

single-threaded, one client served at a time.

 

with Ada.IO_Exceptions;

with GNAT.Sockets;

GNAT.Sockets.Close_Socket (Connection);

end loop;

 

Multi-threaded, multiple clients served. On OS X 10.10.5 with gcc 4.9.1, serves a maximum of about 2000 threads (communication tasks) per process.

with Ada.Text_IO;

with Ada.IO_Exceptions;

end echo_server_multi;

 

 

=={{header|Aime}}==

readc(dispatch w, file i, file o, data b)

{

 

0;

 

=={{header|AutoHotkey}}==

<tt>echoserver.ahk</tt>, modified from

[http://www.autohotkey.com/forum/topic13829.html script] by zed gecko.

Network_Port = 12321

Network_Address = 127.0.0.1

ExitSub:

DllCall("Ws2_32\WSACleanup")

A [[/AutoHotkey Client|client]] is also available for testing this code.

 

WHILE TRUE

fd = ACCEPT(echo)

SEND data$ & CR$ & NL$ TO fd

CLOSE SERVER fd

Input from other terminal:

<pre># echo "Hello world" | netcat 127.0.0.1 12321

Incoming connection from: 127.0.0.1:36784</pre>

 

{{works with|BBC BASIC for Windows}}

PROC_initsockets

WAIT 0

UNTIL FALSE

'''Sample output:'''

<pre>

Connection on socket 1012 closed

</pre>

 

=={{header|C}}==

This is a rather standard code (details apart); the reference guide for such a code is the [http://beej.us/guide/bgnet Beej's Guide to Network programming]. The dependency from POSIX is mainly in the use of the <tt>read</tt> and <tt>write</tt> functions, (using the socket as a file descriptor sometimes make things simpler).

 

#include <stdlib.h>

#include <string.h>

take_connections_forever(sock);

return EXIT_SUCCESS;

 

=={{header|C sharp|C#}}==

using System.Threading;

 

}

}

 

=={{header|Clojure}}==

(use '[clojure.contrib.duck-streams :only (read-lines write-lines)])

 

(write-lines (java.io.PrintWriter. output true) (read-lines input)))

 

 

Note here that an auto-flushing PrintWriter needs to be created, otherwise 'output' could simply be passed to write-lines.

{{trans|JavaScript}}

{{works with|node.js}}

net = require("net")

server = net.createServer (conn) ->

 

server.listen 12321, "localhost"

 

=={{header|Common Lisp}}==

Here is a basic [http://common-lisp.net/project/usocket/ :usocket] example (it should work with any Common Lisp):

 

(defpackage :echo (:use :cl :usocket))

(in-package :echo)

 

(echo-server 12321)

 

It's single threaded, so you can't REPL around with a running server. You'll need to start a second Lisp prompt, load the above and

 

(with-client-socket (sock str "127.0.0.1" port)

(write-string message str)

 

(echo-send "Hello echo!" 12321)

 

The return value of that call should be "You said: Hello echo!".

 

The usocket library notwithstanding, sockets are not a standard part of Common Lisp, but many implementations provide them. Here is a CLISP-specific example: {{works with|CLISP}}

"This is a list of (socket :input status) which is used with

`socket:socket-status' to test for data ready on a socket.")

(setq *clients* (remove socket *clients* :key #'car)))

 

 

=={{header|D}}==

This is a very basic server that processes the buffers one character at a time. In a real-world application, the buffers would be larger. More seriously, it processes one listener at a time. If the <code>currSock.receive()</code> blocks, the loop will not process other clients. This opens the door for a trivial denial-of-service attack. A realistic echo service must multiplex clients.

 

void main() {

buff.clear();

}

 

This example will handle many connections.

 

void main() {

}

}

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lEchoServer.Free;

end;

 

=={{header|Erlang}}==

-export([start/0]).

 

{tcp_closed, Conn} ->

io:format("Connection closed: ~p~n", [Conn])

 

=={{header|Elixir}}==

 

=={{header|F Sharp|F#}}==

open System.Net

open System.Net.Sockets

let main _ =

EchoService

 

=={{header|Factor}}==

Connections get logged to <code>/place-where-factor-is/logs/echo-server</code>.

IN: rosetta.echo

 

: start-echo-server ( -- )

<echo-server> [ start-server ] in-thread start-server drop ;

 

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

 

128 constant size

again ;

 

''TODO: use tasker.fs and non-blocking semantics to handle mutliple connections''

 

=={{header|Go}}==

 

import (

go echo(s, i)

}

 

=={{header|Haskell}}==

 

import Network (withSocketsDo, accept, listenOn, sClose, PortID(PortNumber))

import Control.Monad (forever)

acc@(_, host, port) <- accept listener

putStrLn $ "Accepted connection from " ++ show (host, port)

 

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

 

The following is Unicon-specific:

 

procedure main()

critical mlck: nCons -:= 1

}

 

=={{header|Java}}==

import java.io.IOException;

import java.io.InputStreamReader;

}

}

 

=={{header|JavaScript}}==

{{works with|Node.js}}

 

function handleClient(conn) {

}

 

 

=={{header|Julia}}==

using Sockets # for version 1.0

println("Echo server on port 12321")

println("Caught exception: $y")

end

 

=={{header|Kotlin}}==

{{trans|Java}}

import java.net.Socket

 

}

}

 

{{out}}

 

Paste into the LFE REPL:

(defun start ()

(spawn (lambda ()

(`#(tcp_closed ,conn)

(lfe_io:format "Connection closed: ~p~n" (list conn)))))

 

Usage:

{{libheader|LuaSocket}}

 

 

local function has_value(tab, value)

end

end

----

The following implementation uses tiny delays rather than socket.select. It uses a table of not-quite-non-blocking socket client objects (they block for 4 milliseconds), which is iterated over to check on whether each one has either a line to echo or an error to warrant deletion. Without the millisecond delays, the whole thing would become one 'hot' loop and eat all the CPU time for one core. With them, it uses close to zero percent.

 

function checkOn (client)

print(tostring(newClient) .. " connected")

table.insert(connections, newClient)

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

This will be able to handle multiple connections and multiple echoes:

SocketListen[server, Function[{assoc},

With[{client = assoc["SourceSocket"], input = assoc["Data"]},

WriteString[client, ByteArrayToString[input]];

]

 

=={{header|Nim}}==

 

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

 

discard serve()

 

=={{header|Objeck}}==

use Net;

use Concurrency;

}

}

 

=={{header|Ol}}==

(define (timestamp) (syscall 201 "%c"))

 

 

(run 12321)

 

=={{header|Oz}}==

ServerSocket = {New Open.socket init}

 

{ClientSocket close}

end

 

Client test code:

Socket = {New class $ from Open.socket Open.text end init}

in

{Socket write(vs:"Hello\n")}

{System.showInfo "Client received: "#{Socket getS($)}}

 

Example session:

 

This is an example using the [http://search.cpan.org/perldoc?IO::Socket IO::Socket] module:

my $use_fork = 1;

 

}

 

 

This is an equivalent program using the [http://search.cpan.org/perldoc?Net::Server Net::Server] module:

use base 'Net::Server::Fork';

sub process_request {

print while <STDIN>;

}

It also prints the IP address and port number of every connection.

 

This is a more complicated example using preforking:

use base 'Net::Server::PreFork';

sub process_request {

print while <STDIN>;

}

By default it spawns 5 child processes at startup, makes sure there are always at least 2 and at most 10 spare children available for new requests, each of which will be killed after processing 1000 requests and new ones will take their place.

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">-- demo\rosetta\EchoServer.exw</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">ESCAPE</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">#1B</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">echo</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">sockd</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">{</span><span style="color: #004080;">integer</span> <span style="color: #000000;">len</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">recv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sockd</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">len</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">first</span> <span style="color: #008080;">then</span>

<span style="color: #000000;">bytes_sent</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">send</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sockd</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- partial echo, see note</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #7060A8;">WSACleanup</span><span style="color: #0000FF;">()</span>

Tested using telnet [-e q] localhost 12321<br>

Note: on windows, keying "abc" did not echo anything until the first return, so I added a partial echo: remove if not needed/wanted.

 

=={{header|PHP}}==

socket_bind($socket, '127.0.0.1', 12321);

socket_listen($socket);

}

}

 

=={{header|PicoLisp}}==

 

(loop

 

(prinl (stamp) " -- (Pid " *Pid ") Client disconnected")

 

=={{header|Python}}==

{{works with|Python|2.3 or above}}

 

HOST = "localhost"

# interrupt the program with Ctrl-C

print "server listening on %s:%s" % server.server_address

 

{{works with|Python|3.5 or above}}

#!/usr/bin/env python

# $ printf 'echo\r\n' | nc localhost 12321

loop.run_until_complete(server.wait_closed())

loop.close()

 

{{works with|Python|2 and 3}}

Using only the low-level socket and threading modules. Supports timing out inactive clients

#!usr/bin/env python

import socket

print('exiting')

pass

 

=={{header|Racket}}==

 

An example echo server from the front page of the Racket website:

#lang racket

(define listener (tcp-listen 12321))

(thread (λ() (copy-port I O) (close-output-port O)))

(echo-server))

 

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2018.03}}

:localhost<localhost>,

:localport<12321>,

$conn.close;

}

 

Async version:

whenever IO::Socket::Async.listen('0.0.0.0', 12321) -> $conn {

whenever $conn.Supply.lines -> $line {

}

}

 

=={{header|REBOL}}==

forever [

connection-port: first server-port

close connection-port

]

 

=={{header|Ruby}}==

server = TCPServer.new(12321)

 

end

end

 

Ruby 1.9.2 introduced an alternate method to create TCP server sockets. The <code>Socket.tcp_server_loop</code> method encapsulates the guts of the server into a block.

{{works with|Ruby|1.9.2}}

 

Socket.tcp_server_loop(12321) do |conn, addr|

end

end

 

=={{header|Rust}}==

use std::net::{TcpListener, TcpStream};

use std::io::{BufReader, BufRead, Write};

}

}

 

=={{header|Scala}}==

import java.net.{ServerSocket, Socket}

 

 

while (true) new Thread(new ClientHandler(serverSocket.accept())).start()

 

=={{header|Scheme}}==

{{works with|Guile}}

Based on the [[Guile]] [http://www.gnu.org/software/guile/manual/html_node/Internet-Socket-Examples.html Internet Socket Server Example].

(use-modules (ice-9 rdelim))

 

(primitive-exit))

; Parent waits for child to finish spawning grandchild

 

=={{header|Seed7}}==

requests from new and existing connections.

 

include "socket.s7i";

include "listener.s7i";

end if;

end while;

 

=={{header|Tcl}}==

This code is single-threaded. It uses non-blocking I/O to perform the transfers, sitting on top of the event multiplexer system call (e.g., <code>select()</code> on Unix) to decide when to take new connections or service a particular socket. This makes this into a very lightweight echo server in terms of overall system resources.

 

proc acceptEcho {chan host port} {

puts "opened connection from $host:$port"

# Make the server socket and wait for connections

socket -server acceptEcho -myaddr localhost 12321

===Alternative version===

A more succinct version (though one harder to adapt to other kinds of services, but closer to the standard unix echo daemon since it has no line-buffering) is to use an asynchronous binary copy.

proc acceptEcho {chan host port} {

puts "opened connection from $host:$port"

# Make the server socket and wait for connections

socket -server acceptEcho -myaddr localhost 12321

 

=={{header|X86 Assembly}}==

 

; x86_64 Linux NASM

xor rdi, rdi

syscall

 

=={{header|Wren}}==

{{trans|C}}

An embedded program so we can ask the C host to call the relevant library functions for us and also handle simultaneous connections from multiple clients using a multi-process approach.

 

var MAX_ENQUEUED = 20

 

/* Serve the listening socket until killed */

<br>

which we now embed in the following C program, build and run:

 

#include <stdio.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

<pre>

/* start server on terminal 1 */

 

/* start telnet on terminal 2 and type 'hello' */

 

=={{header|zkl}}==

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}}

The next three windows overlap in time

{{omit from|M4}}

{{omit from|Maxima}}

{{omit from|ML/I}}

{{omit from|PARI/GP}}

{{omit from|Retro|No concurrency support}}

{{omit from|SNUSP|No networking.}}

{{omit from|Unlambda|Does not have network access.}}

{{omit from|Commodore BASIC}}