⚠️ Warning: This is a draft ⚠️
This means it might contain formatting issues, incorrect code, conceptual problems, or other severe issues.
If you want to help to improve and eventually enable this page, please fork RosettaGit's repository and open a merge request on GitHub.
{{task|Networking and Web Interaction}} For this exercise a program is open a socket to localhost on port 256 and send the message "hello socket world" before closing the socket.
Catching any exceptions or errors is not required.
Ada
{{libheader|GNAT RTL}}
with GNAT.Sockets; use GNAT.Sockets;
procedure Socket_Send is
Client : Socket_Type;
begin
Initialize;
Create_Socket (Socket => Client);
Connect_Socket (Socket => Client,
Server => (Family => Family_Inet,
Addr => Inet_Addr ("127.0.0.1"),
Port => 256));
String'Write (Stream (Client), "hello socket world");
Close_Socket (Client);
end Socket_Send;
Aime
file i, o;
tcpip_connect(i, o, "127.0.0.1", 256, 0);
i.text("hello socket world");
AutoHotkey
modified from [http://www.autohotkey.com/forum/topic13829.html script] by zed gecko.
Network_Port = 256
Network_Address = 127.0.0.1
NewData := false
DataReceived =
GoSub, Connection_Init
SendData(socket,"hello socket world")
return
Connection_Init:
OnExit, ExitSub
socket := ConnectToAddress(Network_Address, Network_Port)
if socket = -1
ExitApp
Process, Exist
DetectHiddenWindows On
ScriptMainWindowId := WinExist("ahk_class AutoHotkey ahk_pid " . ErrorLevel)
DetectHiddenWindows Off
NotificationMsg = 0x5556
OnMessage(NotificationMsg, "ReceiveData")
FD_READ = 1
FD_CLOSE = 32
if DllCall("Ws2_32\WSAAsyncSelect", "UInt", socket, "UInt", ScriptMainWindowId, "UInt", NotificationMsg, "Int", FD_READ|FD_CLOSE)
{
MsgBox % "WSAAsyncSelect() indicated Winsock error " . DllCall("Ws2_32\WSAGetLastError")
ExitApp
}
return
ConnectToAddress(IPAddress, Port)
{
VarSetCapacity(wsaData, 32)
result := DllCall("Ws2_32\WSAStartup", "UShort", 0x0002, "UInt", &wsaData)
if ErrorLevel
{
MsgBox WSAStartup() could not be called due to error %ErrorLevel%. Winsock 2.0 or higher is required.
return -1
}
if result
{
MsgBox % "WSAStartup() indicated Winsock error " . DllCall("Ws2_32\WSAGetLastError")
return -1
}
AF_INET = 2
SOCK_STREAM = 1
IPPROTO_TCP = 6
socket := DllCall("Ws2_32\socket", "Int", AF_INET, "Int", SOCK_STREAM, "Int", IPPROTO_TCP)
if socket = -1
{
MsgBox % "socket() indicated Winsock error " . DllCall("Ws2_32\WSAGetLastError")
return -1
}
SizeOfSocketAddress = 16
VarSetCapacity(SocketAddress, SizeOfSocketAddress)
InsertInteger(2, SocketAddress, 0, AF_INET)
InsertInteger(DllCall("Ws2_32\htons", "UShort", Port), SocketAddress, 2, 2)
InsertInteger(DllCall("Ws2_32\inet_addr", "Str", IPAddress), SocketAddress, 4, 4)
if DllCall("Ws2_32\connect", "UInt", socket, "UInt", &SocketAddress, "Int", SizeOfSocketAddress)
{
MsgBox % "connect() indicated Winsock error " . DllCall("Ws2_32\WSAGetLastError") . "?"
return -1
}
return socket
}
ReceiveData(wParam, lParam)
{
global DataReceived
global NewData
socket := wParam
ReceivedDataSize = 4096
Loop
{
VarSetCapacity(ReceivedData, ReceivedDataSize, 0)
ReceivedDataLength := DllCall("Ws2_32\recv", "UInt", socket, "Str", ReceivedData, "Int", ReceivedDataSize, "Int", 0)
if ReceivedDataLength = 0
ExitApp
if ReceivedDataLength = -1
{
WinsockError := DllCall("Ws2_32\WSAGetLastError")
if WinsockError = 10035
{
DataReceived = %TempDataReceived%
NewData := true
return 1
}
if WinsockError <> 10054
MsgBox % "recv() indicated Winsock error " . WinsockError
ExitApp
}
if (A_Index = 1)
TempDataReceived =
TempDataReceived = %TempDataReceived%%ReceivedData%
}
return 1
}
SendData(wParam,SendData)
{
socket := wParam
SendDataSize := VarSetCapacity(SendData)
SendDataSize += 1
sendret := DllCall("Ws2_32\send", "UInt", socket, "Str", SendData, "Int", SendDatasize, "Int", 0)
}
InsertInteger(pInteger, ByRef pDest, pOffset = 0, pSize = 4)
{
Loop %pSize%
DllCall("RtlFillMemory", "UInt", &pDest + pOffset + A_Index-1, "UInt", 1, "UChar", pInteger >> 8*(A_Index-1) & 0xFF)
}
ReceiveProcedure:
if NewData
GuiControl, , ReceivedText, %DataReceived%
NewData := false
Return
ExitSub:
DllCall("Ws2_32\WSACleanup")
ExitApp
AutoIt
Func _HelloWorldSocket()
TCPStartup()
$Socket = TCPConnect("127.0.0.1", 256)
TCPSend($Socket, "Hello World")
TCPCloseSocket($Socket)
TCPShutdown()
EndFunc
BBC BASIC
{{works with|BBC BASIC for Windows}}
INSTALL @lib$+"SOCKLIB"
PROC_initsockets
socket% = FN_tcpconnect("localhost", "256")
IF socket% <=0 ERROR 100, "Failed to open socket"
REM Don't use FN_writesocket since an error is expected
msg$ = "hello socket world"
SYS `send`, socket%, !^msg$, LEN(msg$), 0 TO result%
PROC_closesocket(socket%)
PROC_exitsockets
C
{{works with|POSIX|.1-2001}}
{{works with|gcc|4.2.2}}
With little changes it could work on MS Windows (without Cygwin) too. But I don't know exactly how. I have tested it using nc -l -p 256
.
#include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netdb.h> const char *msg = "hello socket world"; int main() { int i, sock, len, slen; struct addrinfo hints, *addrs; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; if (0 == getaddrinfo("localhost", "256", &hints, &addrs)) { sock = socket(addrs->ai_family, addrs->ai_socktype, addrs->ai_protocol); if ( sock >= 0 ) { if ( connect(sock, addrs->ai_addr, addrs->ai_addrlen) >= 0 ) { const char *pm = msg; do { len = strlen(pm); slen = send(sock, pm, len, 0); pm += slen; } while ((0 <= slen) && (slen < len)); } close(sock); } freeaddrinfo(addrs); } }
C++
I have tested it using nc -vlp 4321
.
//compile with g++ main.cpp -lboost_system -pthread #include <boost/asio.hpp> int main() { boost::asio::io_context io_context; boost::asio::ip::tcp::socket sock(io_context); boost::asio::ip::tcp::resolver resolver(io_context); boost::asio::ip::tcp::resolver::query query("localhost", "4321"); boost::asio::connect(sock, resolver.resolve(query)); boost::asio::write(sock, boost::asio::buffer("Hello world socket\r\n")); return 0; }
C#
using System; using System.IO; using System.Net.Sockets; class Program { static void Main(string[] args) { TcpClient tcp = new TcpClient("localhost", 256); StreamWriter writer = new StreamWriter(tcp.GetStream()); writer.Write("hello socket world"); writer.Flush(); tcp.Close(); } }
Clean Socket alternative:
using System.Text; using System.Net.Sockets; namespace SocketClient { class Program { static void Main(string[] args) { var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); sock.Connect("127.0.0.1", 1000); sock.Send(Encoding.ASCII.GetBytes("Hell, world!")); sock.Close(); } } }
Cind
var libsocket = @("lib","socket");
// connect
int socket = libsocket.connect("localhost",256);
// send data
{
sheet data = (sheet)"hello socket world";
int datalen = data.size();
int was = libsocket.send(socket,data,0,datalen);
// assuming here that all data has been sent (if not, send them in some loop)
}
// close socket
libsocket.close(socket);
Clojure
(ns socket-example (:import (java.net Socket) (java.io PrintWriter))) (defn send-data [host msg] (with-open [sock (Socket. host 256) printer (PrintWriter. (.getOutputStream sock))] (.println printer msg))) (send-data "localhost" "hello socket world")
Common Lisp
{{libheader|usocket}}
CL-USER> (usocket:with-client-socket (socket stream "localhost" 256) (write-line "hello socket world" stream) (values)) ; No value
aurora ~% sudo nc -l -p 256
hello socket world
D
module socket ; import std.stdio ; import std.socket ; version(Win32) { // For Win32 systems, need to link with ws2_32.lib. pragma(lib, "ws2_32.lib") ; } void main() { long res; auto socket = new Socket(AddressFamily.INET, SocketType.STREAM) ; socket.connect(new InternetAddress("localhost",256)) ; res = socket.send(cast(void[])"hello socket world") ; writefln("Socket %d bytes sent.", res) ; socket.close() ; }
Delphi
program Sockets;
{$APPTYPE CONSOLE}
uses IdTCPClient;
var
lTCPClient: TIdTCPClient;
begin
lTCPClient := TIdTCPClient.Create(nil);
try
lTCPClient.Host := '127.0.0.1';
lTCPClient.Port := 256;
lTCPClient.Connect;
lTCPClient.IOHandler.WriteLn('hello socket world');
finally
lTCPClient.Free;
end;
end.
Elena
ELENA 4.1 :
import system'net;
import system'text;
import extensions'text;
import system'io;
public program()
{
var socket := new Socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
socket.connect("127.0.0.1",256);
var s := "hello socket world";
socket.write(AnsiEncoder.toByteArray(0, s.Length, s));
socket.close()
}
Elixir
defmodule Sockets do require Logger def send_message(port, message) do {:ok, socket} = :gen_tcp.connect('localhost', port, []) :gen_tcp.send(socket, message) end end Sockets.send_message(256, "hello socket world")
Emacs Lisp
Emacs treats network connections as sub-processes. make-network-process
is the low-level socket creation,
(let ((proc (make-network-process :name "my sock" :host 'local ;; or hostname string :service 256))) (process-send-string proc "hello socket world") (delete-process proc))
Erlang
-module(socket). -export([start/0]). start() -> {ok, Sock} = gen_tcp:connect("localhost", 256, [binary, {packet, 0}]), ok = gen_tcp:send(Sock, "hello socket world"), ok = gen_tcp:close(Sock).
Factor
"localhost" 256 <inet> utf8 [ "hello socket world" print ] with-client
Fantom
using inet
class Socket
{
public static Void main ()
{
sock := TcpSocket()
sock.connect(IpAddr("localhost"), 256)
sock.out.printLine("hello socket world")
sock.out.flush
sock.close
}
}
Forth
{{works with|GNU Forth|0.7.0}}
include unix/socket.fs
s" localhost" 256 open-socket
dup s" hello socket world" rot write-socket
close-socket
Go
package main import ( "fmt" "net" ) func main() { conn, err := net.Dial("tcp", "localhost:256") if err != nil { fmt.Println(err) return } defer conn.Close() _, err = conn.Write([]byte("hello socket world")) if err != nil { fmt.Println(err) } }
{{out | Test with nc}}
$ sudo nc -l 256 & go run sock.go
[2] 19754
hello socket world[2]+ Done sudo nc -l 256
$
Groovy
s = new java.net.Socket("localhost", 256) s << "hello socket world" s.close()
Haskell
import Network main = withSocketsDo $ sendTo "localhost" (PortNumber $ toEnum 256) "hello socket world"
== Icon and Unicon ==
Icon
=
link cfunc
procedure main ()
hello("localhost", 1024)
end
procedure hello (host, port)
write(tconnect(host, port) | stop("unable to connect to", host, ":", port) , "hello socket world")
end
Note: Socket support in native Icon is limited and requires the external helper function cfunc.
Unicon
= Unicon integrated TCP/IP networking and messaging.
procedure main(arglist) #: usage socket port hostname or socket port
hello(arglist[2]|"",arglist[1])
end
procedure hello(host,port)
local s
/host := ""
host ||:= ":"
host ||:= 0 < 65536 > port | runerr(103,port)
if s := open(host,"n") then {
write(s, "hello socket world.")
close(s)
}
else stop("Unable to connect to ",host,":",port)
return
end
IDL
socket, unit, 'localhost',256,/get_lun
printf,unit,"hello socket world"
close, unit
"Well-known" port numbers (under 1024 -- such as 256) can also be specified by name (in this case 'RAP').
If there is no listener on this port, this will hang for a while before timing out.
J
sdcheck
raises assertions if anything goes wrong:
coinsert'jsocket' [ require 'socket' NB. Sockets library
socket =. >{.sdcheck sdsocket'' NB. Open a socket
host =. sdcheck sdgethostbyname 'localhost' NB. Resolve host
sdcheck sdconnect socket ; host ,< 256 NB. Create connection to port 256
sdcheck 'hello socket world' sdsend socket , 0 NB. Send msg
Java
import java.io.IOException; import java.net.*; public class SocketSend { public static void main(String args[]) throws IOException { sendData("localhost", "hello socket world"); } public static void sendData(String host, String msg) throws IOException { Socket sock = new Socket( host, 256 ); sock.getOutputStream().write(msg.getBytes()); sock.getOutputStream().flush(); sock.close(); } }
Encapsulating the Socket
's OutputStream
in a PrintStream
(for data) or PrintWriter
(for text) may be easier in more complex programs for their auto-flush abilities, encoding management, and their overloaded print
and println
methods. The write
method from the original OutputStream
will still be available.
Jsish
#!/usr/bin/env jsish function sockets() { var sock = new Socket({client:true, port:256, noAsync:true, udp:true}); sock.send(-1, 'hello socket world'); sock.close(); } ;sockets(); /* =!EXPECTSTART!= sockets() ==> undefined =!EXPECTEND!= */
{{out}}
prompt$ jsish -u sockets.jsi
[PASS] sockets.jsi
Julia
socket = connect("localhost",256) write(socket, "hello socket world") close(socket)
Kotlin
// version 1.2.21 import java.net.Socket fun main(args: Array<String>) { val sock = Socket("localhost", 256) sock.use { it.outputStream.write("hello socket world".toByteArray()) } }
Lasso
local(net) = net_tcp
#net->connect('127.0.0.1',256)
#net->dowithclose => {
#net->writestring('Hello World')
}
Lua
{{libheader|LuaSocket}}
socket = require "socket" host, port = "127.0.0.1", 256 sid = socket.udp() sid:sendto( "hello socket world", host, port ) sid:close()
Myrddin
use std
const main = {
match std.dial("tcp!localhost!256")
| `std.Ok fd:
std.write(fd, "hello socket world")
std.close(fd)
| `std.Err err:
std.fatal("could not open fd: {}\n", err)
;;
}
Neko
/** Sockets in Neko Tectonics: nekoc sockets.neko sudo nc -vulp 256 & sudo neko sockets */ var socket_init = $loader.loadprim("std@socket_init", 0); var socket_new = $loader.loadprim("std@socket_new", 1); var host_resolve = $loader.loadprim("std@host_resolve", 1); var socket_connect = $loader.loadprim("std@socket_connect", 3); var socket_write = $loader.loadprim("std@socket_write", 2); var socket_close = $loader.loadprim("std@socket_close", 1); /* Initialize Neko socket API */ socket_init(); /* true; UDP, false; TCP */ var socket = socket_new(true); var c = socket_connect(socket, host_resolve("localhost"), 256); socket_write(socket, "hello socket world"); socket_close(socket);
For testing on port 256, root powers required {{out}}
prompt$ nekoc sockets.neko
prompt$ sudo nc -vulp 256 & sudo neko sockets
[1] 4475
Ncat: Version 7.60 ( https://nmap.org/ncat )
Ncat: Listening on :::256
Ncat: Listening on 0.0.0.0:256
hello socket world
prompt$ [1]+ Stopped sudo nc -vulp 256
Nemerle
using System.Text;
using System.Net.Sockets;
module Program
{
Main() : void
{
def sock = Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect("127.0.0.1", 1000);
_ = sock.Send(Encoding.ASCII.GetBytes("Hell, world!"));
sock.Close();
}
}
NetRexx
{{trans|Java}} <
/* NetRexx */
options replace format comments java crossref symbols nobinary
import java.net.
runSample(arg)
return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
parse arg host':'port':'message
if host = '' then host = 'localhost'
if port = '' then port = 256
if message = '' then message = 'hello socket world'
sendToSocket(host, port, message)
return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method sendToSocket(host, port, message) public static
do
sokt = Socket(host, port)
soks = sokt.getOutputStream()
soks.write((String message).getBytes())
soks.flush()
sokt.close()
catch ix = IOException
ix.printStackTrace()
end
return
NewLISP
(set 'socket (net-connect "localhost" 256))
(net-send socket "hello socket world")
(net-close socket)
(exit)
Nim
import net var s = newSocket() s.connect("localhost", Port(256)) s.send("Hello Socket World") s.close()
Objeck
use Net;
bundle Default {
class Socket {
function : Main(args : String[]) ~ Nil {
socket := TCPSocket->New("localhost", 256);
if(socket->IsOpen()) {
socket->WriteString("hello socket world");
socket->Close();
}
}
}
}
=={{header|Objective-C}}== (untested)
// declare the class to conform to NSStreamDelegate protocol
// in some method
NSOutputStream *oStream;
[NSStream getStreamsToHost:[NSHost hostWithName:@"localhost"] port:256 inputStream:NULL outputStream:&oStream];
[oStream setDelegate:self];
[oStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
[oStream open];
// later, in the same class:
- (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)streamEvent {
NSOutputStream *oStream = (NSOutputStream *)aStream;
if (streamEvent == NSStreamEventHasBytesAvailable) {
NSString *str = @"hello socket world";
const char *rawstring = [str UTF8String];
[oStream write:rawstring maxLength:strlen(rawstring)];
[oStream close];
}
}
OCaml
open Unix let init_socket addr port = let inet_addr = (gethostbyname addr).h_addr_list.(0) in let sockaddr = ADDR_INET (inet_addr, port) in let sock = socket PF_INET SOCK_STREAM 0 in connect sock sockaddr; (* convert the file descriptor into high-level channels: *) let outchan = out_channel_of_descr sock in let inchan = in_channel_of_descr sock in (inchan, outchan)
let () = let ic, oc = init_socket "localhost" 256 in output_string oc "hello socket world"; ;;
Oz
declare
Socket = {New Open.socket init}
in
{Socket connect(port:256)}
{Socket write(vs:"hello socket world")}
{Socket close}
Pascal
See [[Sockets#Delphi | Delphi]]
Perl
use Socket; $host = gethostbyname('localhost'); $in = sockaddr_in(256, $host); $proto = getprotobyname('tcp'); socket(Socket_Handle, AF_INET, SOCK_STREAM, $proto); connect(Socket_Handle, $in); send(Socket_Handle, 'hello socket world', 0, $in); close(Socket_Handle);
Object oriented version.
use Socket::Class; $sock = Socket::Class->new( 'remote_port' => 256, ) || die Socket::Class->error; $sock->send('hello socket world'); $sock->free;
Perl 6
{{Works with|rakudo|2016.03}} Will fail with a connect error if there is not a socket server of some kind available on the specified host and port.
my $host = '127.0.0.1';
my $port = 256;
my $client = IO::Socket::INET.new(:$host, :$port);
$client.print( 'hello socket world' );
$client.close;
PHP
$socket = fsockopen('localhost', 256);
fputs($socket, 'hello socket world');
fclose($socket);
PicoLisp
(when (connect "localhost" 256)
(out @ (prinl "hello socket world"))
(close @) )
Pike
import Stdio;
int main(){
object con = File();
con->connect("127.0.0.1",256);
con->write("hello socket world");
con->close();
}
Prolog
This works with Gnu Prolog. Other implementations will have different predicates.
start(Port) :- socket('AF_INET',Socket),
socket_connect(Socket, 'AF_INET'(localhost,Port), Input, Output),
write(Output, 'hello socket world'),
flush_output(Output),
close(Output),
close(Input).
PureBasic
InitNetwork()
ConnectionID = OpenNetworkConnection("localhost", 256)
SendNetworkString(ConnectionID, "hello socket world")
CloseNetworkConnection(ConnectionID)
Python
import socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(("localhost", 256)) sock.sendall("hello socket world") sock.close()
R
s <- make.socket(port = 256)
write.socket(s, "hello socket world")
close.socket(s)
Racket
#lang racket
(let-values ([(in out) (tcp-connect "localhost" 256)])
(display "hello socket world\n" out)
(close-output-port out))
Rhope
{{works with|Rhope|alpha 1}}
Socket Send(0,0)
|:
[New@Net Client["localhost",256]]Put String["hello socket world"]
:|
The connection is automatically closed when the object is freed.
Ring
Load "guilib.ring"
new qApp {
oClient = new Client { client() }
exec()
}
Class Client
win1 oTcpSocket
func client
win1 = new qwidget()
new qpushbutton(win1) {
setgeometry(50,50,100,30)
settext("connect")
setclickevent("oClient.Connect()")
}
win1 {
setwindowtitle("client")
setgeometry(10,100,400,400)
show()
}
func connect
oTcpSocket = new qTcpSocket(win1) {
setconnectedevent("oClient.pConnected()")
connecttohost("127.0.0.1",256,3,0)
waitforconnected(5000)
}
func pConnected
cStr = "hello socket world"
write(cStr,len(cStr))
flush()
waitforbyteswritten(300000)
close()
Ruby
require 'socket' sock = TCPSocket.open("localhost", 256) sock.write("hello socket world") sock.close
Rust
{{works with|Rust 1.0 stable}}
use std::io::prelude::*; use std::net::TcpStream; fn main() { // Open a tcp socket connecting to 127.0.0.1:256, no error handling (unwrap) let mut my_stream = TcpStream::connect("127.0.0.1:256").unwrap(); // Write 'hello socket world' to the stream, ignoring the result of write let _ = my_stream.write(b"hello socket world"); } // <- my_stream's drop function gets called, which closes the socket
Scala
{{libheader|Scala}}
import java.net.Socket object sendSocketData { def sendData(host: String, msg: String) { val sock = new Socket(host, 256) sock.getOutputStream().write(msg.getBytes()) sock.getOutputStream().flush() sock.close() } sendData("localhost", "hello socket world") }
Scheme
{{works with|Guile|1.8.8}}{{works with|Chicken Scheme|4.6.0}}
(let ((s (socket PF_INET SOCK_STREAM 0)))
(connect s AF_INET (inet-pton AF_INET "127.0.0.1") 256)
(display "hello socket world" s))
Seed7
The library [http://seed7.sourceforge.net/libraries/socket.htm socket.s7i] defines the function [http://seed7.sourceforge.net/libraries/socket.htm#openInetSocket%28in_integer%29 openInetSocket], which returns a connected internet socket file at a port at localhost.
$ include "seed7_05.s7i";
include "socket.s7i";
const proc: main is func
local
var file: sock is STD_NULL;
begin
sock := openInetSocket(256);
writeln(sock, "hello socket world");
close(sock);
end func;
Sidef
var host = Socket.gethostbyname('localhost'); var in = Socket.sockaddr_in(256, host); var proto = Socket.getprotobyname('tcp'); var sock = Socket.open(Socket.AF_INET, Socket.SOCK_STREAM, proto); sock.connect(in); sock.send('hello socket world', 0, in); sock.close;
Slate
This uses fairly verbose and low level messages. This will probably be simplified in the future.
[ | socket |
[ | addr stream |
addr: (Net SocketAddress newOn: '127.0.0.1:256').
socket: (Net Socket newFor: addr domain type: Net Socket Types Stream protocol: Net Socket Protocols Default).
socket connectTo: addr.
stream: (Net SocketStream newOn: socket).
stream nextPutAll: ('hello socket world' as: ByteArray).
stream flush
] ensure: [socket close]
] do.
Smalltalk
{{works with|GNU Smalltalk}}
This is taken from [http://sblinn.jottit.com/GNU_Smalltalk_SimpleEcho_TCP_Server here] with few modification to fit the task better.
PackageLoader fileInPackage: 'TCP'!
Object subclass: #HelloSocket
instanceVariableNames: 'ss'
classVariableNames: ''
poolDictionaries: ''
category: 'SimpleEcho'!
!HelloSocket class methodsFor: 'instance creation'!
port: anInteger
| ses |
ses := super new.
ses init: anInteger.
^ses
!!
!HelloSocket methodsFor: 'instance initialization'!
init: anInteger
ss := (TCP.ServerSocket port: anInteger).
^self
!!
!HelloSocket methodsFor: 'running'!
run
| s |
[
ss waitForConnection.
s := (ss accept).
[self handleSocket: s] fork
] repeat
!!
!HelloSocket methodsFor: 'handling'!
handleSocket: s
| msg |/**
Sockets in Neko
Tectonics:
nekoc sockets.neko
sudo nc -vulp 256 & sudo neko sockets
*/
var socket_init = $loader.loadprim("std@socket_init", 0);
var socket_new = $loader.loadprim("std@socket_new", 1);
var host_resolve = $loader.loadprim("std@host_resolve", 1);
var socket_connect = $loader.loadprim("std@socket_connect", 3);
var socket_write = $loader.loadprim("std@socket_write", 2);
var socket_close = $loader.loadprim("std@socket_close", 1);
/* Initialize Neko socket API */
socket_init();
/* true; UDP, false; TCP */
var socket = socket_new(true);
var c = socket_connect(socket, host_resolve("localhost"), 1256);
socket_write(socket, "hello socket world");
socket_close(socket);
msg := 'hello socket world'.
msg displayOn: s.
(String with: (Character value: 10)) displayOn: s.
s flush
!!
Smalltalk at: #helloServer put: (HelloSocket port: 2560).
helloServer run.
Symsyn
'127.0.0.1' $addr
connect $addr 256 sok
'hello socket world' [sok]
close sok
Tcl
set io [socket localhost 256] puts -nonewline $io "hello socket world" close $io
Toka
needs sockets
#! A simple abstraction layer that makes writing trivial servers easy
value| server.socket server.connection server.action |
[ ( n- ) pBind to server.socket ] is server.setSocket
[ ( - ) server.socket pAccept to server.connection ] is server.acceptConnection
[ ( - ) server.connection pClose drop ] is server.closeConnection
[ ( $- ) >r server.connection r> string.getLength pWrite drop ] is server.send
[ ( an- ) server.connection -rot pRead drop ] is server.recieve
[ ( qn- ) swap to server.action server.setSocket
[ server.acceptConnection server.action invoke server.closeConnection TRUE ] whileTrue ] is server.start
#! The actual server
[ " hello socket world" server.send ] 256 server.start
TXR
(let* ((server (first (getaddrinfo "localhost" 256)))
(sock (open-socket server.family sock-stream)))
(sock-connect sock server)
(put-string "hello socket world"))
UNIX Shell
Using netcat:
{{libheader|nc}}
echo "hello socket world" | nc localhost 256
When the connection fails, nc
exits 1. To see an error message, use nc -v localhost 256
.
Ursa
decl port p
p.connect "localhost" 256
out "hello socket world" endl p
p.close
Visual Basic .NET
Imports System
Imports System.IO
Imports System.Net.Sockets
Public Class Program
Public Shared Sub Main(ByVal args As String[])
Dim tcp As New TcpClient("localhost", 256)
Dim writer As New StreamWriter(tcp.GetStream())
writer.Write("hello socket world")
writer.Flush()
tcp.Close()
End Sub
End Class
X86 Assembly
{{works with|nasm|Linux}}
;using sockets on linux with the 0x80 inturrprets. ; ;assemble ; nasm -o socket.o -f elf32 -g socket.asm ;link ; ld -o socket socket.o ; ; ;Just some assigns for better readability %assign SOCK_STREAM 1 %assign AF_INET 2 %assign SYS_socketcall 102 %assign SYS_SOCKET 1 %assign SYS_CONNECT 3 %assign SYS_SEND 9 %assign SYS_RECV 10 section .text global _start ;-------------------------------------------------- ;Functions to make things easier. :] ;-------------------------------------------------- _socket: mov [cArray+0], dword AF_INET mov [cArray+4], dword SOCK_STREAM mov [cArray+8], dword 0 mov eax, SYS_socketcall mov ebx, SYS_SOCKET mov ecx, cArray int 0x80 ret _connect: call _socket mov dword [sock], eax mov dx, si mov byte [edi+3], dl mov byte [edi+2], dh mov [cArray+0], eax ;sock; mov [cArray+4], edi ;&sockaddr_in; mov edx, 16 mov [cArray+8], edx ;sizeof(sockaddr_in); mov eax, SYS_socketcall mov ebx, SYS_CONNECT mov ecx, cArray int 0x80 ret _send: mov edx, [sock] mov [sArray+0],edx mov [sArray+4],eax mov [sArray+8],ecx mov [sArray+12], dword 0 mov eax, SYS_socketcall mov ebx, SYS_SEND mov ecx, sArray int 0x80 ret _exit: push 0x1 mov eax, 1 push eax int 0x80 _print: mov ebx, 1 mov eax, 4 int 0x80 ret ;-------------------------------------------------- ;Main code body ;-------------------------------------------------- _start: mov esi, szIp mov edi, sockaddr_in xor eax,eax xor ecx,ecx xor edx,edx .cc: xor ebx,ebx .c: lodsb inc edx sub al,'0' jb .next imul ebx,byte 10 add ebx,eax jmp short .c .next: mov [edi+ecx+4],bl inc ecx cmp ecx,byte 4 jne .cc mov word [edi], AF_INET mov esi, szPort xor eax,eax xor ebx,ebx .nextstr1: lodsb test al,al jz .ret1 sub al,'0' imul ebx,10 add ebx,eax jmp .nextstr1 .ret1: xchg ebx,eax mov [sport], eax mov si, [sport] call _connect cmp eax, 0 jnz short _fail mov eax, msg mov ecx, msglen call _send call _exit _fail: mov edx, cerrlen mov ecx, cerrmsg call _print call _exit _recverr: call _exit _dced: call _exit section .data cerrmsg db 'failed to connect :(',0xa cerrlen equ $-cerrmsg msg db 'Hello socket world!',0xa msglen equ $-msg szIp db '127.0.0.1',0 szPort db '256',0 section .bss sock resd 1 ;general 'array' for syscall_socketcall argument arg. cArray resd 1 resd 1 resd 1 resd 1 ;send 'array'. sArray resd 1 resd 1 resd 1 resd 1 ;duh? sockaddr_in resb 16 ;.. sport resb 2 buff resb 1024
{{works with|MASM}}
Operates in non-blocking mode.
.586 .model flat,stdcall option casemap:none include /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc include /masm32/include/ws2_32.inc includelib /masm32/lib/user32.lib includelib /masm32/lib/kernel32.lib includelib /masm32/lib/ws2_32.lib WinMain proto :DWORD,:DWORD,:DWORD,:DWORD .data ClassName db "MainWinClass",0 AppName db "Async Sockets",0 szSockStr db "Hello socket world!",13,10,0 szIp db "127.0.0.1",0 port dd 256 wsa WSADATA <> sa sockaddr_in <> .data? hInstance dd ? CommandLine dd ? sock dd ? .const WM_SOCK equ WM_USER+100 .code start: invoke WSAStartup, 200h, addr wsa .if eax!=NULL invoke ExitProcess, eax .else invoke GetModuleHandle, NULL mov hInstance,eax invoke GetCommandLine mov CommandLine,eax invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT invoke ExitProcess,eax .endif WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD LOCAL wc:WNDCLASSEX LOCAL msg:MSG LOCAL hwnd:HWND mov wc.cbSize,SIZEOF WNDCLASSEX mov wc.style, CS_HREDRAW or CS_VREDRAW mov wc.lpfnWndProc, OFFSET WndProc mov wc.cbClsExtra,NULL mov wc.cbWndExtra,NULL push hInstance pop wc.hInstance mov wc.hbrBackground,COLOR_BTNFACE+1 mov wc.lpszMenuName,NULL mov wc.lpszClassName,OFFSET ClassName invoke LoadIcon,NULL,IDI_APPLICATION mov wc.hIcon,eax mov wc.hIconSm,eax invoke LoadCursor,NULL,IDC_ARROW mov wc.hCursor,eax invoke RegisterClassEx, addr wc INVOKE CreateWindowEx,NULL,ADDR ClassName,ADDR AppName,\ WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\ CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,NULL,NULL,\ hInst,NULL mov hwnd,eax invoke ShowWindow, hwnd,SW_SHOWNORMAL invoke UpdateWindow, hwnd .WHILE TRUE invoke GetMessage, ADDR msg,NULL,0,0 .BREAK .IF (!eax) invoke TranslateMessage, ADDR msg invoke DispatchMessage, ADDR msg .ENDW mov eax,msg.wParam ret WinMain endp WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM .IF uMsg==WM_DESTROY invoke PostQuitMessage,NULL .ELSEIF uMsg==WM_CREATE invoke socket, AF_INET,SOCK_STREAM, 0 .if eax==INVALID_SOCKET ;error .endif mov sock, eax invoke WSAAsyncSelect, sock, hWnd, WM_SOCK, FD_CONNECT or FD_CLOSE .if eax==INVALID_SOCKET ;error! .endif mov sa.sin_family, AF_INET invoke inet_addr, addr szIp mov sa.sin_addr, eax invoke htons, port mov sa.sin_port, ax invoke connect, sock, addr sa, sizeof sa .if eax==SOCKET_ERROR invoke WSAGetLastError .if eax!=WSAEWOULDBLOCK ;real error. .endif .endif .elseif uMsg==WM_SOCK mov edx, lParam .if dx==FD_CONNECT shr edx, 16 .if dx==NULL invoke lstrlen, addr szSockStr invoke send, sock, addr szSockStr, eax, 0 .else ;error .endif .elseif dx==FD_CLOSE shr edx, 16 .if dx==NULL invoke SendMessage, hWnd, WM_DESTROY, 0, 0 .endif .endif .ELSE invoke DefWindowProc,hWnd,uMsg,wParam,lParam ret .ENDIF xor eax,eax ret WndProc endp end start
{{works with|MASM}}
This example works in blocking mode.
.586 .model flat,stdcall option casemap:none include /masm32/include/windows.inc include /masm32/include/user32.inc include /masm32/include/kernel32.inc include /masm32/include/ws2_32.inc includelib /masm32/lib/user32.lib includelib /masm32/lib/kernel32.lib includelib /masm32/lib/ws2_32.lib WinMain proto :DWORD,:DWORD,:DWORD,:DWORD .data ClassName db "MainWinClass",0 AppName db "Blocking Sockets",0 szSockStr db "Hello socket world!",13,10,0 szIp db "127.0.0.1",0 port dd 256 wsa WSADATA <> sa sockaddr_in <> .data? hInstance dd ? CommandLine dd ? sock dd ? .code start: invoke WSAStartup, 200h, addr wsa .if eax!=NULL invoke ExitProcess, eax .else invoke GetModuleHandle, NULL mov hInstance,eax invoke GetCommandLine mov CommandLine,eax invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT invoke ExitProcess,eax .endif WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD LOCAL wc:WNDCLASSEX LOCAL msg:MSG LOCAL hwnd:HWND mov wc.cbSize,SIZEOF WNDCLASSEX mov wc.style, CS_HREDRAW or CS_VREDRAW mov wc.lpfnWndProc, OFFSET WndProc mov wc.cbClsExtra,NULL mov wc.cbWndExtra,NULL push hInstance pop wc.hInstance mov wc.hbrBackground,COLOR_BTNFACE+1 mov wc.lpszMenuName,NULL mov wc.lpszClassName,OFFSET ClassName invoke LoadIcon,NULL,IDI_APPLICATION mov wc.hIcon,eax mov wc.hIconSm,eax invoke LoadCursor,NULL,IDC_ARROW mov wc.hCursor,eax invoke RegisterClassEx, addr wc INVOKE CreateWindowEx,NULL,ADDR ClassName,ADDR AppName,\ WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,\ CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,NULL,NULL,\ hInst,NULL mov hwnd,eax invoke ShowWindow, hwnd,SW_SHOWNORMAL invoke UpdateWindow, hwnd .WHILE TRUE invoke GetMessage, ADDR msg,NULL,0,0 .BREAK .IF (!eax) invoke TranslateMessage, ADDR msg invoke DispatchMessage, ADDR msg .ENDW mov eax,msg.wParam ret WinMain endp WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM .IF uMsg==WM_DESTROY invoke PostQuitMessage,NULL .ELSEIF uMsg==WM_CREATE invoke socket, AF_INET,SOCK_STREAM, 0 .if eax==INVALID_SOCKET ;error .endif mov sock, eax mov sa.sin_family, AF_INET invoke inet_addr, addr szIp mov sa.sin_addr, eax invoke htons, port mov sa.sin_port, ax invoke connect, sock, addr sa, sizeof sa invoke lstrlen, addr szSockStr invoke send, sock, addr szSockStr, eax, 0 .ELSE invoke DefWindowProc,hWnd,uMsg,wParam,lParam ret .ENDIF xor eax,eax ret WndProc endp end start
zkl
var s=Network.TCPClientSocket.connectTo("localhost",256);
s.write("hello socket world"); //-->18
s.close();
Zsh
zmodload zsh/net/tcp ztcp localhost 256 print hello socket world >&$REPLY
{{omit from|ACL2}} {{omit from|Applesoft BASIC|No TCP/IP support on Apple II}} {{omit from|Batch File|Does not have network access.}} {{omit from|GUISS}} {{omit from|Integer BASIC|No TCP/IP support on Apple II}} {{omit from|Lotus 123 Macro Scripting}} {{omit from|Locomotive Basic|Does not have network access.}} {{omit from|Mathematica}} {{omit from|Maxima}} {{omit from|ML/I}} {{omit from|PARI/GP}} {{omit from|Retro|No socket support}} {{omit from|TI-83 BASIC|Does not have network access.}} {{omit from|TI-89 BASIC|Does not have network access.}} {{omit from|Yorick|Does not have network access.}} {{omit from|ZX Spectrum Basic|Does not have network access.}}