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

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;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

 

public class EchoServer {

 

 

 

=={{header|JavaScript}}==

{{works with|Node.js}}

 

 

}

 

 

=={{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

 

 

 

}

}

 

while (true) {

}

}

 

{{out}}

Hello

Hello

Goodbye

Goodbye

 

=={{header|LFE}}==

 

Paste into the LFE REPL:

(defun start ()

(spawn (lambda ()

(`#(tcp_closed ,conn)

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

 

Usage:

 

=={{header|Lua}}==

{{libheader|LuaSocket}}

 

function checkOn (client)

print(tostring(client) .. " " .. err)

client:close()

end

end

 

local server = assert(socket.bind("*", 12321))

server:settimeout(delay)

repeat

newClient = server:accept()

end

until newClient

newClient:settimeout(delay)

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

 

=={{header|Nim}}==

 

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

while true:

let client = await server.accept()

discard processClient(client)

 

discard serve()

 

=={{header|Objeck}}==

use Net;

use Concurrency;

}

}

 

=={{header|Ol}}==

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

 

(let ((fd (syscall 43 socket))) ; accept

(fork (on-accept (syscall 51 fd) fd))))

(loop))))

 

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