Sockets: Difference between revisions

57,046 bytes added ,  3 months ago
m
→‎{{header|Frink}}: Fixed port number
m (omit JavaScript)
m (→‎{{header|Frink}}: Fixed port number)
 
(149 intermediate revisions by 94 users not shown)
Line 1:
{{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.
 
Catching any exceptions or errors is not required.
<br><br>
 
=={{header|Ada}}==
{{libheader|GNAT RTL}}
<langsyntaxhighlight lang="ada">with GNAT.Sockets; use GNAT.Sockets;
 
procedure SocketSendSocket_Send is
Client : Socket_Type;
procedure sendData (IP : String; Msg : String) is
Client : Socket_Type;
Address : Sock_Addr_Type;
Channel : Stream_Access;
begin
Create_Socket (Client);
Address.Addr := Inet_Addr(ip);
Address.Port := 256;
Connect_Socket (Client, Address);
Channel := Stream (Client);
String'Write (Channel, Msg);
Close_Socket (Client);
end;
begin
Initialize;
Create_Socket (Socket => Client);
sendData ("127.0.0.1","hello socket world");
Connect_Socket (Socket => Client,
end;</lang>
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;</syntaxhighlight>
 
=={{header|Aime}}==
<syntaxhighlight lang="aime">file i, o;
tcpip_connect(i, o, "127.0.0.1", 256, 0);
i.text("hello socket world");</syntaxhighlight>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">socket: connect.to:"localhost" 256
send socket "Hello Socket World"
unplug socket</syntaxhighlight>
 
=={{header|AutoHotkey}}==
modified from
[http://www.autohotkey.com/forum/topic13829.html script] by zed gecko.
<langsyntaxhighlight lang="autohotkey">Network_Port = 256
Network_Address = 127.0.0.1
NewData := false
Line 152 ⟶ 159:
ExitSub:
DllCall("Ws2_32\WSACleanup")
ExitApp</langsyntaxhighlight>
 
=={{header|AutoIt}}==
 
<syntaxhighlight lang="autoit">Func _HelloWorldSocket()
TCPStartup()
$Socket = TCPConnect("127.0.0.1", 256)
TCPSend($Socket, "Hello World")
TCPCloseSocket($Socket)
TCPShutdown()
EndFunc</syntaxhighlight>
 
=={{header|AWK}}==
{{works with|GAWK}}
Note: <code>|&</code> is gawk's two way pipe operator.
 
Server:
<syntaxhighlight lang="awk">BEGIN {
s="/inet/tcp/256/0/0"
print strftime() |& s
close(s)
}
</syntaxhighlight>
 
Test client:
<syntaxhighlight lang="awk">BEGIN {
s="/inet/tcp/0/localhost/256"
s |& getline
print $0
close(s)
}</syntaxhighlight>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> 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</syntaxhighlight>
 
=={{header|C}}==
Line 159 ⟶ 211:
{{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 the <ttcode>netcatnc -l -p 256</ttcode>.
 
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
 
const char *msg[] = "hello socket world";
 
int main()
Line 185 ⟶ 238:
if ( connect(sock, addrs->ai_addr, addrs->ai_addrlen) >= 0 )
{
const char *pm = msg;
do
{
Line 197 ⟶ 250:
freeaddrinfo(addrs);
}
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
 
<langsyntaxhighlight lang="csharp">using System;
using System.IO;
using System.Net.Sockets;
Line 215 ⟶ 268:
tcp.Close();
}
}</langsyntaxhighlight>
 
Clean Socket alternative:
 
<syntaxhighlight lang="csharp">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();
}
}
}</syntaxhighlight>
 
=={{header|C++}}==
I have tested it using <code>nc -vlp 4321</code>.
 
<syntaxhighlight lang="cpp">//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;
}</syntaxhighlight>
 
=={{header|Cind}}==
 
<syntaxhighlight lang="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);
</syntaxhighlight>
 
=={{header|Clojure}}==
<syntaxhighlight lang="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")</syntaxhighlight>
 
=={{header|Common Lisp}}==
Line 221 ⟶ 342:
{{libheader|usocket}}
 
<langsyntaxhighlight lang="lisp">CL-USER> (usocket:with-client-socket (socket stream "localhost" 256)
(write-line "hello socket world" stream)
(values))
; No value</langsyntaxhighlight>
 
<langsyntaxhighlight lang="lisp">aurora ~% sudo nc -l -p 256
hello socket world</langsyntaxhighlight>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">module socket ;
import std.stdio ;
import std.socket ;
Line 238 ⟶ 359:
}
void main() {
long res;
auto socket = new Socket(AddressFamily.INET, SocketType.STREAM) ;
socket.connect(new InternetAddress("localhost",256)) ;
writefln(res = socket.send(cast(void[])"hello socket world"), " bytes sent.") ;
writefln("Socket %d bytes sent.", res) ;
socket.close() ;
}</langsyntaxhighlight>
 
=={{header|Delphi}}==
<syntaxhighlight lang="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.</syntaxhighlight>
 
=={{header|Elena}}==
ELENA 4.1 :
<syntaxhighlight lang="elena">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()
}</syntaxhighlight>
 
=={{header|Elixir}}==
<syntaxhighlight lang="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")
</syntaxhighlight>
 
=={{header|Emacs Lisp}}==
 
Emacs treats network connections as sub-processes. <code>make-network-process</code> is the low-level socket creation,
 
<syntaxhighlight lang="lisp">(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))</syntaxhighlight>
 
=={{header|Erlang}}==
<syntaxhighlight lang="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).
</syntaxhighlight>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">"localhost" 256 <inet> utf8 [ "hello socket world" print ] with-client</langsyntaxhighlight>
 
=={{header|Fantom}}==
 
<syntaxhighlight lang="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
}
}
</syntaxhighlight>
 
=={{header|Forth}}==
{{works with|GNU Forth|0.7.0}}
<langsyntaxhighlight lang="forth">include unix/socket.fs
 
s" localhost" 256 open-socket
Line 255 ⟶ 469:
dup s" hello socket world" rot write-socket
 
close-socket</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
{{libheader|winsock}}
{{works with|Windows FreeBASIC}}
<syntaxhighlight lang="vbnet">' We import the windows sockets library
#Include Once "windows.bi"
#Include Once "win/winsock.bi"
 
#include "fbgfx.bi"
 
#define NET_BUFLEN 1024
 
'--- SENDER ---
 
Dim As WSADATA wsaData
 
Dim As SOCKET sendSocket
Dim As sockaddr_in recvAddr
Dim As Integer port = 256
Dim As Ubyte sendBuf(NET_BUFLEN-1)
Dim As Integer bufLen = NET_BUFLEN
Dim As Integer iResult
Dim As String message = "hello socket world"
 
' We copy the message to the buffer
For i As Ubyte = 1 To Len(message)
sendBuf(i-1) = Cbyte(Asc(Mid(message, i, 1)))
Next
 
' We update bufLen to be the length of the message
bufLen = Len(message)
 
' We initialize Winsock
If (WSAStartup(MAKEWORD(2,2), @wsaData) <> 0) Then
Beep: Print "Error: Winsock init"
Sleep
End
End If
 
' We create the socket
sendSocket = socket_(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
If sendSocket = INVALID_SOCKET Then
Beep: Print "Error: Net socket"
WSACleanup()
Sleep
End
End If
 
' We configure the server structure
recvAddr.sin_family = AF_INET
recvAddr.sin_port = htons(256)
recvAddr.sin_addr.s_addr = inet_addr("127.0.0.1")
 
' We send the message
Print "Trying: Net send"
iResult = sendto(sendSocket, @sendBuf(0), bufLen, 0, Cptr(sockaddr Ptr, @recvAddr), Sizeof(recvAddr))
If (iResult = SOCKET_ERROR) Then
Beep: Print "Error: Net send"
closesocket(sendSocket)
WSACleanup()
Sleep
End
Else
Print "number of bytes send:"; iResult
End If
 
iResult = closeSocket(sendSocket)
If (iResult < 0) Then
Beep: Print "Error: Close socket"
End If
 
'closesocket(sock)
WSACleanup()</syntaxhighlight>
 
=={{header|Frink}}==
<syntaxhighlight lang="frink">s = newJava["java.net.Socket", ["localhost", 256]]
w = new Writer[s.getOutputStream[]]
w.println["hello socket world"]
w.close[]</syntaxhighlight>
 
=={{header|Go}}==
<syntaxhighlight lang="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)
}
}</syntaxhighlight>
{{out | Test with nc}}
<pre>
$ sudo nc -l 256 & go run sock.go
[2] 19754
hello socket world[2]+ Done sudo nc -l 256
$
</pre>
 
=={{header|Groovy}}==
<syntaxhighlight lang="groovy">s = new java.net.Socket("localhost", 256)
s << "hello socket world"
s.close()</syntaxhighlight>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Network
 
main = withSocketsDo $ sendTo "localhost" (PortNumber $ toEnum 256) "hello socket world"</langsyntaxhighlight>
 
=={{header| Icon}} and Unicon ==
==={{header|Icon}}===
<lang icon>link cfunc
<syntaxhighlight lang="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</langsyntaxhighlight>
Note: Socket support in native Icon is limited and requires the external helper function cfunc.
==={{header|Unicon}}===
Unicon integrated TCP/IP networking and messaging.
<syntaxhighlight lang="unicon">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</syntaxhighlight>
 
=={{header|IDL}}==
 
<syntaxhighlight lang="idl">socket, unit, 'localhost',256,/get_lun
<tt>
<lang idl>socket, unit, 'localhost',256,/get_lun
printf,unit,"hello socket world"
close, unit</langsyntaxhighlight>
</tt>
 
"Well-known" port numbers (under 1024 -- such as 256) can also be specified by name (in this case 'RAP').
Line 284 ⟶ 629:
 
=={{header|J}}==
The <code>sdcheck</code>s raiseraises assertions if anything goes wrong:
 
<langsyntaxhighlight lang="j"> 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</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.io.IOException;
import java.net.*;
public class SocketSend {
Line 306 ⟶ 651:
sock.close();
}
}</langsyntaxhighlight>
Encapsulating the <code>Socket</code>'s <code>OutputStream</code> in a <code>PrintStream</code> (for data) or <code>PrintWriter</code> (for text) may be easier in more complex programs for their auto-flush abilities, encoding management, and their overloaded <code>print</code> and <code>println</code> methods. The <code>write</code> method from the original <code>OutputStream</code> will still be available.
 
=={{header|Jsish}}==
<syntaxhighlight lang="javascript">#!/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!=
*/</syntaxhighlight>
 
{{out}}
<pre>prompt$ jsish -u sockets.jsi
[PASS] sockets.jsi</pre>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">
socket = connect("localhost",256)
write(socket, "hello socket world")
close(socket)
</syntaxhighlight>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// 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())
}
}</syntaxhighlight>
 
=={{header|Lasso}}==
 
<syntaxhighlight lang="lasso">local(net) = net_tcp
#net->connect('127.0.0.1',256)
#net->dowithclose => {
#net->writestring('Hello World')
}</syntaxhighlight>
 
=={{header|Lua}}==
{{libheader|LuaSocket}}
<syntaxhighlight lang="lua">socket = require "socket"
host, port = "127.0.0.1", 256
 
sid = socket.udp()
sid:sendto( "hello socket world", host, port )
sid:close()</syntaxhighlight>
 
=={{header|MACRO-10}}==
<syntaxhighlight lang="macro-10">
 
TITLE SOCKET
 
COMMENT !
 
Socket Example ** PDP-10 Assembly Language (KJX 2022)
Assembler: MACRO-10 Operating System: TOPS-20 V7
 
On TOPS-20, TCP-connections are made by opening a special
file on the "TCP:" device (in this case "TCP:256"). Apart
from the funky filename, there is virtually no difference
between opening files on disk and creating TCP-connections
or endpoints, so we go through the usual sequence of GTJFN
(= get file-handle), OPENF (open file), finally followed
by CLOSF (close file).
 
!
 
SEARCH MONSYM,MACSYM ;Load symbolic names for syscalls.
.REQUIRE SYS:MACREL
 
STDAC. ;Define standard register names.
 
JFN: BLOCK 1 ;File handle for TCP connection.
TCPFN: ASCIZ /TCP:256/ ;TCP "filename"
STR: ASCIZ /Hello World!/ ;String to send.
STRLEN= <.-STR>*5 ;Length of string.
 
GO:: RESET% ;Initialize process.
 
;; Get a file-handle (JFN) for the TCP-connection:
MOVX T1,GJ%SHT ;Do "short" GTJFN% call.
HRROI T2,TCPFN ;TCP "filename" into T2.
GTJFN% ;Get file-handle.
ERJMPS ERROR ; Handle errors.
MOVEM T1,JFN ;Store JFN we got.
 
;; Open the "file":
 
HRRZ T1,JFN ;File-handle without flags into T1.
MOVX T2,FLD(8,OF%BSZ)!OF%RD!OF%WR ;8bit bytes, read+write.
OPENF% ;Open file.
ERJMPS ERROR ; Handle errors.
 
;; Write the string.
 
MOVE T1,JFN ;File-handle into T1.
HRROI T2,STR ;String-pointer into T2.
MOVEI T3,STRLEN ;Length of string into T3.
SOUT% ;Write string.
ERJMPS ERROR ; Handle errors.
 
;; Close file.
 
HRRZ T1,JFN ;Get file-handle into T1.
CLOSF% ;Close file.
ERJMPS ERROR ; Handle errors.
 
;; End program.
 
RESET% ;Reset, to release JFN.
HALTF% ;Halt program.
JRST GO ;Allow for continue-command.
 
;;
;; ERROR: Print standardized error-message by means of ERSTR.
;; This is similar to perror() in C.
;;
 
ERROR: MOVEI T1,.PRIOU ;Print on standard output.
MOVE T2,[.FHSLF,,-1] ;Own process, last error.
SETZ T3 ;No length-limit on error msg.
ERSTR% ;Print error-message.
JFCL ; Ignore errors from ERSTR%.
JFCL ; Dito.
RESET% ;Reset, to release JFN.
HALTF% ;Halt program.
JRST GO ;Allow for continue-command.
 
END GO
</syntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">socket = SocketConnect["localhost:256", "TCP"];
WriteString[socket, "hello socket world"];
Close[socket];</syntaxhighlight>
 
=={{header|Myrddin}}==
<syntaxhighlight lang="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)
;;
}</syntaxhighlight>
 
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">import Nanoquery.Net
 
p = new(Port)
p.connect("localhost", 256)
p.write("hello socket world")
p.close()</syntaxhighlight>
 
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
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);</syntaxhighlight>
 
For testing on port 256, root powers required
{{out}}
<pre>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</pre>
 
=={{header|Nemerle}}==
<syntaxhighlight lang="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();
}
}</syntaxhighlight>
 
=={{header|NetRexx}}==
{{trans|Java}}
<<syntaxhighlight lang="netrexx">/* 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
</syntaxhighlight>
 
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">
(set 'socket (net-connect "localhost" 256))
(net-send socket "hello socket world")
(net-close socket)
(exit)
</syntaxhighlight>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">import net
 
var s = newSocket()
s.connect("localhost", Port(256))
s.send("Hello Socket World")
s.close()</syntaxhighlight>
 
=={{header|Objeck}}==
<syntaxhighlight lang="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();
}
}
}
}
</syntaxhighlight>
 
=={{header|Objective-C}}==
(untested)
<syntaxhighlight lang="objc">// 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];
}
}</syntaxhighlight>
 
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">open Unix
 
let init_socket addr port =
Line 321 ⟶ 973:
let outchan = out_channel_of_descr sock in
let inchan = in_channel_of_descr sock in
(inchan, outchan)</langsyntaxhighlight>
 
<langsyntaxhighlight lang="ocaml">let () =
let ic, oc = init_socket "localhost" 256 in
output_string oc "hello socket world";
;;</langsyntaxhighlight>
 
=={{header|Oz}}==
<syntaxhighlight lang="oz">declare
Socket = {New Open.socket init}
in
{Socket connect(port:256)}
{Socket write(vs:"hello socket world")}
{Socket close}</syntaxhighlight>
 
=={{header|Pascal}}==
Tested using <code>nc -l 256</code>, on both macOS Sierra and Windows 7, compiled using Free Pascal in the default FPC mode.
Very similar to the [https://rosettacode.org/wiki/Sockets#C example in C].
 
See also [https://rosettacode.org/wiki/Sockets#Delphi Delphi].
<syntaxhighlight lang="pascal">Program Sockets_ExampleA;
 
Uses
{ Free Pascal RTL sockets unit }
sockets;
 
Var
TCP_Sock: integer;
Remote_Addr: TSockAddr;
 
Message: string;
PMessage: Pchar;
Message_Len: integer;
 
 
Begin
{ Fill the record (struct) with the server's address information }
With Remote_Addr do
begin
Sin_family := AF_INET;
Sin_addr := StrToNetAddr('127.0.0.1');
Sin_port := HtoNs(256);
end;
 
{ Returns an IPv4 TCP socket descriptor }
TCP_Sock := fpSocket(AF_INET, SOCK_STREAM, IPPROTO_IP);
 
{ Most routines in this unit return -1 on failure }
If TCP_Sock = -1 then
begin
WriteLn('Failed to create new socket descriptor');
Halt(1);
end;
 
{ Attempt to connect to the address supplied above }
If fpConnect(TCP_Sock, @Remote_Addr, SizeOf(Remote_Addr)) = -1 then
begin
{ Specifc error codes can be retrieved by calling the SocketError function }
WriteLn('Failed to contact server');
Halt(1);
end;
 
{ Finally, send the message to the server and disconnect }
Message := 'Hello socket world';
PMessage := @Message;
Message_Len := StrLen(PMessage);
 
If fpSend(TCP_Sock, PMessage, Message_Len, 0) <> Message_Len then
begin
WriteLn('An error occurred while sending data to the server');
Halt(1);
end;
 
CloseSocket(TCP_Sock);
End.
</syntaxhighlight>
 
Variant without superfluous additions:
<syntaxhighlight lang="pascal">Program Sockets_ExampleB;
 
Uses
sockets;
 
Var
TCP_Sock: integer;
Remote_Addr: TSockAddr;
 
Message: string;
PMessage: Pchar;
Message_Len: integer;
 
Begin
Remote_Addr.Sin_family := AF_INET;
Remote_Addr.Sin_addr := StrToNetAddr('127.0.0.1');
Remote_Addr.Sin_port := HtoNs(256);
 
TCP_Sock := fpSocket(AF_INET, SOCK_STREAM, IPPROTO_IP);
 
fpConnect(TCP_Sock, @Remote_Addr, SizeOf(Remote_Addr));
 
Message := 'Hello socket world';
PMessage := @Message;
Message_Len := StrLen(PMessage);
 
fpSend(TCP_Sock, PMessage, Message_Len, 0);
End.
</syntaxhighlight>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use Socket;
 
$host = gethostbyname('localhost');
Line 337 ⟶ 1,090:
connect(Socket_Handle, $in);
send(Socket_Handle, 'hello socket world', 0, $in);
close(Socket_Handle);</langsyntaxhighlight>
 
Object oriented version.
<langsyntaxhighlight lang="perl">use Socket::Class;
 
$sock = Socket::Class->new(
Line 346 ⟶ 1,099:
) || die Socket::Class->error;
$sock->send('hello socket world');
$sock->free;</langsyntaxhighlight>
 
=={{header|Phix}}==
Note this fails for me with "connection refused", just like the Go/Python/Ruby entries.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (sockets)</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">sockets</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">msg</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"hello socket world"</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">sock</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">socket</span><span style="color: #0000FF;">(</span><span style="color: #000000;">AF_INET</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">SOCK_STREAM</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">sock</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">pSockAddr</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sockaddr_in</span><span style="color: #0000FF;">(</span><span style="color: #000000;">AF_INET</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"localhost"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">256</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">connect</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sock</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">pSockAddr</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=</span><span style="color: #000000;">SOCKET_ERROR</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"connect (%v)"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">get_socket_error</span><span style="color: #0000FF;">()})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">pm</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">msg</span>
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">len</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pm</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">slen</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">send</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sock</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">pm</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">slen</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">or</span> <span style="color: #000000;">slen</span><span style="color: #0000FF;">=</span><span style="color: #000000;">len</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: #000000;">pm</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">pm</span><span style="color: #0000FF;">[</span><span style="color: #000000;">slen</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..$]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">closesocket</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sock</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">WSACleanup</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
 
=={{header|PHP}}==
<langsyntaxhighlight PHPlang="php">$socket = fsockopen('localhost', 256);
fputs($socket, 'hello socket world');
fclose($socket);</langsyntaxhighlight>
 
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">(when (connect "localhost" 256)
(out @ (prinl "hello socket world"))
(close @) )</syntaxhighlight>
 
=={{header|Pike}}==
<langsyntaxhighlight lang="pike">import Stdio;
 
int main(){
Line 361 ⟶ 1,144:
con->write("hello socket world");
con->close();
}</langsyntaxhighlight>
 
=={{header|Prolog}}==
This works with Gnu Prolog. Other implementations will have different predicates.
<syntaxhighlight lang="prolog">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).</syntaxhighlight>
 
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">InitNetwork()
ConnectionID = OpenNetworkConnection("localhost", 256)
SendNetworkString(ConnectionID, "hello socket world")
CloseNetworkConnection(ConnectionID)</syntaxhighlight>
 
=={{header|Python}}==
<syntaxhighlight lang ="python">import socket
"""Connect to a socket. Requires Python >= 3.2."""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
import socket
sock.connect(("localhost", 256))
 
sock.sendall("hello socket world")
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.close()</lang>
sock.connect(("localhost", 256))
sock.sendall(b"hello socket world")
</syntaxhighlight>
 
{{out}}
 
This example output uses netcat (<code>nc</code>) to provide a socket to connect to. Some versions of netcat require the <code>-p</code> (port) flag to be used in combination with <code>-l</code> (listen mode), some treat the combination of <code>-l</code> and <code>-p</code> as an error, and some don't mind either way. On some systems, you can use <code>sudo netstat -tulpn | grep nc</code> to show what port netcat is actually listening on.
 
256 is a "well-known", reserved port number. Binding to well-known ports usually requires elevated permissions. Hence the use of <code>sudo</code> here.
<pre>
$ sudo nc -l -p 256 & python sock.py
[3] 10559
hello socket world[3] Done sudo nc -l -p 256
</pre>
 
=={{header|R}}==
<syntaxhighlight lang="rsplus">
s <- make.socket(port = 256)
write.socket(s, "hello socket world")
close.socket(s)
</syntaxhighlight>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">#lang racket
(let-values ([(in out) (tcp-connect "localhost" 256)])
(display "hello socket world\n" out)
(close-output-port out))</syntaxhighlight>
 
=={{header|Raku}}==
(formerly 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.
<syntaxhighlight lang="raku" line>my $host = '127.0.0.1';
my $port = 256;
 
my $client = IO::Socket::INET.new(:$host, :$port);
$client.print( 'hello socket world' );
$client.close;</syntaxhighlight>
 
=={{header|Rhope}}==
{{works with|Rhope|alpha 1}}
<langsyntaxhighlight lang="rhope">Socket Send(0,0)
|:
[New@Net Client["localhost",256]]Put String["hello socket world"]
:|</langsyntaxhighlight>
The connection is automatically closed when the object is freed.
 
=={{header|Ring}}==
<syntaxhighlight lang="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()
</syntaxhighlight>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'socket'
sock = TCPSocket.open("localhost", 256)
sock.write("hello socket world")
sock.close</langsyntaxhighlight>
 
=={{header|Rust}}==
{{works with|Rust 1.0 stable}}
<syntaxhighlight lang="rust">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</syntaxhighlight>
 
=={{header|Scala}}==
{{libheader|Scala}}
<syntaxhighlight lang="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")
}</syntaxhighlight>
 
=={{header|Scheme}}==
{{works with|Guile|1.8.8}}{{works with|Chicken Scheme|4.6.0}}
<syntaxhighlight lang="scheme">(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))</syntaxhighlight>
 
=={{header|Seed7}}==
The library [http://seed7.sourceforge.net/libraries/socket.htm socket.s7i]
<lang seed7>$ include "seed7_05.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.
 
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "socket.s7i";
 
Line 395 ⟶ 1,315:
writeln(sock, "hello socket world");
close(sock);
end func;</langsyntaxhighlight>
 
=={{header|SenseTalk}}==
<syntaxhighlight lang="sensetalk">
set SocketID to "localhost:256"
open socket SocketID
write "Hello socket world!" to socket SocketID
close socket SocketID
</syntaxhighlight>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">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;</syntaxhighlight>
 
=={{header|Slate}}==
Line 402 ⟶ 1,339:
This uses fairly verbose and low level messages. This will probably be simplified in the future.
 
<langsyntaxhighlight lang="slate">[ | socket |
[ | addr stream |
addr: (Net SocketAddress newOn: '127.0.0.1:256').
Line 408 ⟶ 1,345:
socket connectTo: addr.
stream: (Net SocketStream newOn: socket).
stream nextPutAll: ('hello socket world' as: ByteArray).
stream flush
] ensure: [socket close]
] do.</langsyntaxhighlight>
 
=={{header|Smalltalk}}==
Line 417 ⟶ 1,355:
This is taken from [http://sblinn.jottit.com/GNU_Smalltalk_SimpleEcho_TCP_Server here] with few modification to fit the task better.
 
<langsyntaxhighlight lang="smalltalk">PackageLoader fileInPackage: 'TCP'!
 
Object subclass: #HelloSocket
Line 464 ⟶ 1,402:
Smalltalk at: #helloServer put: (HelloSocket port: 2560).
 
helloServer run.</langsyntaxhighlight>
 
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
'127.0.0.1' $addr
connect $addr 256 sok
'hello socket world' [sok]
close sok
</syntaxhighlight>
 
=={{header|Standard ML}}==
<syntaxhighlight lang="text">val txt = Word8VectorSlice.full (Byte.stringToBytes "hello world" ) ;
val set = fn socket => fn ipnr => fn portnr => fn text =>
(
Socket.connect (socket, INetSock.toAddr ( Option.valOf (NetHostDB.fromString(ipnr) ) , portnr )) ;
Socket.sendVec(socket, text) before Socket.close socket
)
;
</syntaxhighlight>
call
set ( INetSock.TCP.socket () ) "127.0.0.1" 256 txt ;
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">set io [socket localhost 256]
puts -nonewline $io "hello socket world"
close $io</langsyntaxhighlight>
 
=={{header|Toka}}==
<langsyntaxhighlight lang="toka">needs sockets
 
#! A simple abstraction layer that makes writing trivial servers easy
Line 485 ⟶ 1,442:
 
#! The actual server
[ " hello socket world" server.send ] 256 server.start</langsyntaxhighlight>
 
=={{header|UnixPipesTXR}}==
 
<lang bash>(echo "hello socket world" | nc localhost 256 | exit 0)</lang>
<syntaxhighlight lang="txrlisp">(let* ((server (first (getaddrinfo "localhost" 256)))
(sock (open-socket server.family sock-stream)))
(sock-connect sock server)
(put-string "hello socket world"))</syntaxhighlight>
 
=={{header|UNIX Shell}}==
Using netcat:
 
{{libheader|nc}}
<syntaxhighlight lang="bash">echo "hello socket world" | nc localhost 256</syntaxhighlight>
 
When the connection fails, <code>nc</code> exits 1. To see an error message, use <code>nc -v localhost 256</code>.
 
=={{header|Ursa}}==
<syntaxhighlight lang="ursa">decl port p
p.connect "localhost" 256
out "hello socket world" endl p
p.close</syntaxhighlight>
 
=={{header|Visual Basic .NET}}==
 
<syntaxhighlight lang="vbnet">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</syntaxhighlight>
 
=={{header|Wren}}==
{{trans|C}}
An embedded program so we can ask the C host to call the relevant library functions for us.
 
Although this worked when originally posted, the connection is now refused. The same applies to the C, Go, Phix, Python and Ruby entries and probably others.
<syntaxhighlight lang="wren">/* Sockets.wren */
 
var AF_UNSPEC = 0
var SOCK_STREAM = 1
 
foreign class AddrInfo {
foreign static getAddrInfo(name, service, req, pai)
 
construct new() {}
 
foreign family
 
foreign family=(f)
 
foreign sockType
 
foreign sockType=(st)
 
foreign protocol
 
foreign addr
 
foreign addrLen
}
 
foreign class AddrInfoPtr {
construct new() {}
 
foreign deref
 
foreign free()
}
 
foreign class SockAddrPtr {
construct new() {}
}
 
class Socket {
foreign static create(domain, type, protocol)
 
foreign static connect(fd, addr, len)
 
foreign static send(fd, buf, n, flags)
 
foreign static close(fd)
}
 
var msg = "hello socket world\n"
var hints = AddrInfo.new()
hints.family = AF_UNSPEC
hints.sockType = SOCK_STREAM
var addrInfoPtr = AddrInfoPtr.new()
if (AddrInfo.getAddrInfo("localhost", "256", hints, addrInfoPtr) == 0){
var addrs = addrInfoPtr.deref
var sock = Socket.create(addrs.family, addrs.sockType, addrs.protocol)
if (sock >= 0) {
var stat = Socket.connect(sock, addrs.addr, addrs.addrLen)
if (stat >= 0) {
var pm = msg
while (true) {
var len = pm.count
var slen = Socket.send(sock, pm, len, 0)
if (slen < 0 || slen >= len) break
pm = pm[slen..-1]
}
} else if (stat == -1) {
System.print("Connection refused.")
}
var status = Socket.close(sock)
if (status != 0) System.print("Failed to close socket.")
}
addrInfoPtr.free()
}</syntaxhighlight>
<br>
Now embed this script in the following C program, compile and run it.
<syntaxhighlight lang="c">/* gcc Sockets.c -o Sockets -lwren -lm */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include "wren.h"
 
/* C <=> Wren interface functions */
 
void C_addrInfoAllocate(WrenVM* vm) {
wrenSetSlotNewForeign(vm, 0, 0, sizeof(struct addrinfo));
}
 
void C_addrInfoPtrAllocate(WrenVM* vm) {
wrenSetSlotNewForeign(vm, 0, 0, sizeof(struct addrinfo*));
}
 
void C_sockAddrPtrAllocate(WrenVM* vm) {
wrenSetSlotNewForeign(vm, 0, 0, sizeof(struct sockaddr*));
}
 
void C_getAddrInfo(WrenVM* vm) {
const char *name = wrenGetSlotString(vm, 1);
const char *service = wrenGetSlotString(vm, 2);
const struct addrinfo *req = (const struct addrinfo *)wrenGetSlotForeign(vm, 3);
struct addrinfo** ppai = (struct addrinfo**)wrenGetSlotForeign(vm, 4);
int status = getaddrinfo(name, service, req, ppai);
wrenSetSlotDouble(vm, 0, (double)status);
}
 
void C_family(WrenVM* vm) {
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
wrenSetSlotDouble(vm, 0, (double)(pai->ai_family));
}
 
void C_setFamily(WrenVM* vm) {
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
int f = (int)wrenGetSlotDouble(vm, 1);
pai->ai_family = f;
}
 
void C_sockType(WrenVM* vm) {
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
wrenSetSlotDouble(vm, 0, (double)(pai->ai_socktype));
}
 
void C_setSockType(WrenVM* vm) {
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
int type = (int)wrenGetSlotDouble(vm, 1);
pai->ai_socktype = type;
}
 
void C_protocol(WrenVM* vm) {
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
wrenSetSlotDouble(vm, 0, (double)(pai->ai_protocol));
}
 
void C_addr(WrenVM* vm) {
wrenEnsureSlots(vm, 2);
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
wrenGetVariable(vm, "main", "SockAddrPtr", 1);
struct sockaddr **ppsa = (struct sockaddr**)wrenSetSlotNewForeign(vm, 0, 1, sizeof(struct sockaddr*));
*ppsa = pai->ai_addr;
}
 
void C_addrLen(WrenVM* vm) {
struct addrinfo* pai = (struct addrinfo*)wrenGetSlotForeign(vm, 0);
wrenSetSlotDouble(vm, 0, (double)(pai->ai_addrlen));
}
 
void C_deref(WrenVM* vm) {
wrenEnsureSlots(vm, 2);
struct addrinfo** ppai = (struct addrinfo**)wrenGetSlotForeign(vm, 0);
wrenGetVariable(vm, "main", "AddrInfo", 1);
struct addrinfo *pai = (struct addrinfo*)wrenSetSlotNewForeign(vm, 0, 1, sizeof(struct addrinfo));
*pai = **ppai;
}
 
void C_free(WrenVM* vm) {
struct addrinfo* pai = *(struct addrinfo**)wrenGetSlotForeign(vm, 0);
freeaddrinfo(pai);
}
 
void C_create(WrenVM* vm) {
int domain = (int)wrenGetSlotDouble(vm, 1);
int type = (int)wrenGetSlotDouble(vm, 2);
int protocol = (int)wrenGetSlotDouble(vm, 3);
int fd = socket(domain, type, protocol);
wrenSetSlotDouble(vm, 0, (double)fd);
}
 
void C_connect(WrenVM* vm) {
int fd = (int)wrenGetSlotDouble(vm, 1);
__CONST_SOCKADDR_ARG *psa = (__CONST_SOCKADDR_ARG *)wrenGetSlotForeign(vm, 2);
socklen_t len = (socklen_t)wrenGetSlotDouble(vm, 3);
int status = connect(fd, *psa, len);
wrenSetSlotDouble(vm, 0, (double)status);
}
 
void C_send(WrenVM* vm) {
int fd = (int)wrenGetSlotDouble(vm, 1);
const char *buf = (const char *)wrenGetSlotString(vm, 2);
size_t n = (size_t)wrenGetSlotDouble(vm, 3);
int flags = (int)wrenGetSlotDouble(vm, 4);
ssize_t size = send(fd, (const void*)buf, n, flags);
wrenSetSlotDouble(vm, 0, (double)size);
}
 
void C_close(WrenVM* vm) {
int fd = (int)wrenGetSlotDouble(vm, 1);
int status = close(fd);
wrenSetSlotDouble(vm, 0, (double)status);
}
 
WrenForeignClassMethods bindForeignClass(WrenVM* vm, const char* module, const char* className) {
WrenForeignClassMethods methods;
methods.allocate = NULL;
methods.finalize = NULL;
if (strcmp(module, "main") == 0) {
if (strcmp(className, "AddrInfo") == 0) {
methods.allocate = C_addrInfoAllocate;
} else if (strcmp(className, "AddrInfoPtr") == 0) {
methods.allocate = C_addrInfoPtrAllocate;
} else if (strcmp(className, "SockAddPtr") == 0) {
methods.allocate = C_sockAddrPtrAllocate;
}
}
return methods;
}
 
WrenForeignMethodFn bindForeignMethod(
WrenVM* vm,
const char* module,
const char* className,
bool isStatic,
const char* signature) {
if (strcmp(module, "main") == 0) {
if (strcmp(className, "AddrInfo") == 0) {
if ( isStatic && strcmp(signature, "getAddrInfo(_,_,_,_)") == 0) return C_getAddrInfo;
if (!isStatic && strcmp(signature, "family") == 0) return C_family;
if (!isStatic && strcmp(signature, "family=(_)") == 0) return C_setFamily;
if (!isStatic && strcmp(signature, "sockType") == 0) return C_sockType;
if (!isStatic && strcmp(signature, "sockType=(_)") == 0) return C_setSockType;
if (!isStatic && strcmp(signature, "protocol") == 0) return C_protocol;
if (!isStatic && strcmp(signature, "addr") == 0) return C_addr;
if (!isStatic && strcmp(signature, "addrLen") == 0) return C_addrLen;
} else if (strcmp(className, "AddrInfoPtr") == 0) {
if (!isStatic && strcmp(signature, "deref") == 0) return C_deref;
if (!isStatic && strcmp(signature, "free()") == 0) return C_free;
} else if (strcmp(className, "Socket") == 0) {
if ( isStatic && strcmp(signature, "create(_,_,_)") == 0) return C_create;
if ( isStatic && strcmp(signature, "connect(_,_,_)") == 0) return C_connect;
if ( isStatic && strcmp(signature, "send(_,_,_,_)") == 0) return C_send;
if ( isStatic && strcmp(signature, "close(_)") == 0) return C_close;
}
}
return NULL;
}
 
static void writeFn(WrenVM* vm, const char* text) {
printf("%s", text);
}
 
void errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) {
switch (errorType) {
case WREN_ERROR_COMPILE:
printf("[%s line %d] [Error] %s\n", module, line, msg);
break;
case WREN_ERROR_STACK_TRACE:
printf("[%s line %d] in %s\n", module, line, msg);
break;
case WREN_ERROR_RUNTIME:
printf("[Runtime Error] %s\n", msg);
break;
}
}
 
char *readFile(const char *fileName) {
FILE *f = fopen(fileName, "r");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
rewind(f);
char *script = malloc(fsize + 1);
fread(script, 1, fsize, f);
fclose(f);
script[fsize] = 0;
return script;
}
 
int main(int argc, char **argv) {
WrenConfiguration config;
wrenInitConfiguration(&config);
config.writeFn = &writeFn;
config.errorFn = &errorFn;
config.bindForeignClassFn = &bindForeignClass;
config.bindForeignMethodFn = &bindForeignMethod;
WrenVM* vm = wrenNewVM(&config);
const char* module = "main";
const char* fileName = "Sockets.wren";
char *script = readFile(fileName);
WrenInterpretResult result = wrenInterpret(vm, module, script);
switch (result) {
case WREN_RESULT_COMPILE_ERROR:
printf("Compile Error!\n");
break;
case WREN_RESULT_RUNTIME_ERROR:
printf("Runtime Error!\n");
break;
case WREN_RESULT_SUCCESS:
break;
}
wrenFreeVM(vm);
free(script);
return 0;
}</syntaxhighlight>
{{out}}
<pre>
$ sudo nc -l 256 & ./Sockets
[23] 6074
Connection refused.
</pre>
 
=={{header|X86 Assembly}}==
{{works with|nasm|Linux}}
<syntaxhighlight lang="asm">
;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
</syntaxhighlight>
 
{{works with|MASM}}<br>
Operates in non-blocking mode.
<syntaxhighlight lang="asm">
.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
</syntaxhighlight>
 
{{works with|MASM}}<br>
This example works in blocking mode.
<syntaxhighlight lang="asm">
.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
</syntaxhighlight>
 
=={{header|X86-64 Assembly}}==
===UASM 2.52===
<syntaxhighlight lang="asm">
option casemap:none
option literals:on
 
ifndef __SOCKET_CLASS__
__SOCKET_CLASS__ equ 1
if @Platform eq windows64
 
WSADATA struct
wVersion dw ?
wHighVersion dw ?
iMaxSockets dw ?
iMaxUdpDg dw ?
szDescription db 256 dup (?)
szSystemStatus db 128 dup (?)
lpVendorInfo dq ?
WSADATA ends
 
option dllimport:<kernel32>
ExitProcess proto :word
HeapAlloc proto :qword, :dword, :qword
HeapFree proto :qword, :dword, :qword
GetProcessHeap proto
 
option dllimport:<ws2_32>
WSAStartup proto :word, :qword
WSACleanup proto :qword
closesocket proto :dword
 
option dllimport:none
exit equ ExitProcess
close equ closesocket
 
elseif @Platform eq linux64
malloc proto SYSTEMV :qword
free proto SYSTEMV :qword
close proto SYSTEMV :dword
exit proto SYSTEMV :dword
 
endif
 
memset proto :qword, :dword, :dword
printf proto :qword, :vararg
strlen proto :qword
getaddrinfo proto :qword, :qword, :qword, :qword
gai_strerror proto :dword
send proto :dword, :qword, :qword, :dword
socket proto :dword, :dword, :dword
connect proto :dword, :qword, :dword
freeaddrinfo proto :qword
CLASS socket_class
CMETHOD conn
CMETHOD write
ENDMETHODS
if @Platform eq windows64
wsa WSADATA <?>
endif
sock dd 0
pai dq 0
hostname dq ?
port dq ?
ENDCLASS
 
METHOD socket_class, Init, <VOIDARG>, <>, h:qword, p:qword
mov rbx, thisPtr
assume rbx:ptr socket_class
mov rax, h
mov [rbx].hostname, rax
mov rax, p
mov [rbx].port, rax
mov rax, rbx
assume rbx:nothing
ret
ENDMETHOD
 
METHOD socket_class, conn, <dword>, <>
local ht:qword
 
mov rbx, thisPtr
assume rbx:ptr socket_class
invoke printf, CSTR("--> Attempting connection to %s on %s",10), [rbx].hostname ,[rbx].port
if @Platform eq windows64
invoke WSAStartup, 202h, addr [rbx].wsa
endif
invoke memset, ht, 0, 0x30 ;; sizeof(struct addrinfo)
mov rax, ht
mov dword ptr [rax], 0 ;; ai_flags
mov dword ptr [rax+4], AF_INET
mov dword ptr [rax+8], SOCK_STREAM
invoke getaddrinfo, [rbx].hostname, [rbx].port, ht, addr [rbx].pai
.if rax != 0
invoke gai_strerror, eax
invoke printf, CSTR("--> Gai_strerror returned: %s",10), rax
mov rax, -1
jmp _exit
.endif
mov rax, [rbx].pai
mov edx, dword ptr [rax + 0XC] ;; pai.ai_protocol
mov ecx, dword ptr [rax + 8] ;; pai.ai_socktype
mov eax, dword ptr [rax + 4] ;; pai.ai_family
invoke socket, eax, ecx, edx
.if rax == -1
mov rax, -1
jmp _exit
.endif
mov [rbx].sock, eax
invoke printf, CSTR("--> Socket created as: %d",10), [rbx].sock
mov rax, [rbx].pai
mov edx, dword ptr [rax + 0x10] ;; pai.ai_addrlen
mov rcx, qword ptr [rax + 0x18] ;; pai.ai_addr
invoke connect, [rbx].sock, rcx, edx
.if rax == -1
invoke printf, CSTR("--> connect failed.. %i",10), rax
mov rax, -1
jmp _exit
.endif
mov rax, 0
 
_exit:
assume rbx:nothing
ret
ENDMETHOD
 
METHOD socket_class, write, <dword>, <>, b:qword
local tmp:qword
 
mov rbx, thisPtr
assume rbx:ptr socket_class
mov rax, b
mov tmp, rax
invoke strlen, tmp
invoke send, [rbx].sock, tmp, rax, 0
.if eax == -1
invoke printf, CSTR("--> Error in send..%d",10), rax
ret
.endif
assume rbx:nothing
ret
ENDMETHOD
 
METHOD socket_class, Destroy, <VOIDARG>, <>
mov rbx, thisPtr
assume rbx:ptr socket_class
invoke close, [rbx].sock
if @Platform eq windows64
invoke WSACleanup, addr [rbx].wsa
endif
.if [rbx].pai != 0
invoke freeaddrinfo, [rbx].pai
.endif
assume rbx:nothing
ret
ENDMETHOD
endif ;; __SOCKET_CLASS__
 
.code
main proc
local lpSocket:ptr socket_class
 
mov lpSocket, _NEW(socket_class, CSTR("localhost"), CSTR("256"))
lpSocket->conn()
.if rax == -1
invoke exit, 0
ret
.endif
invoke printf, CSTR("-> Connected, sending data.",10)
lpSocket->write(CSTR("Goodbye, socket world!",10))
_DELETE(lpSocket)
invoke exit, 0
ret
main endp
 
end
 
</syntaxhighlight>
 
=={{header|zkl}}==
Using the program <tt>netcat</tt> (<tt>nc</tt>)
<syntaxhighlight lang="zkl">var s=Network.TCPClientSocket.connectTo("localhost",256);
s.write("hello socket world"); //-->18
s.close();</syntaxhighlight>
 
=={{header|Zsh}}==
<lang bash>echo "hello socket world" | netcat localhost 256</lang>
<syntaxhighlight lang="zsh">zmodload zsh/net/tcp
ztcp localhost 256
print hello socket world >&$REPLY</syntaxhighlight>
 
{{omit from|JavaScriptACL2}}
{{omit from|TI-83Applesoft BASIC}} {{omit from|TI-89No BASIC}}TCP/IP <!--support Doeson notApple have network access. -->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|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.}}
494

edits