Sockets: Difference between revisions

=={{header|Ada}}==

{{libheader|GNAT RTL}}

 

procedure Socket_Send is

String'Write (Stream (Client), "hello socket world");

Close_Socket (Client);

 

=={{header|Aime}}==

tcpip_connect(i, o, "127.0.0.1", 256, 0);

 

=={{header|AutoHotkey}}==

modified from

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

Network_Address = 127.0.0.1

NewData := false

ExitSub:

DllCall("Ws2_32\WSACleanup")

 

=={{header|AutoIt}}==

 

TCPStartup()

$Socket = TCPConnect("127.0.0.1", 256)

TCPCloseSocket($Socket)

TCPShutdown()

 

=={{header|AWK}}==

 

Server:

s="/inet/tcp/256/0/0"

print strftime() |& s

close(s)

}

 

Test client:

s="/inet/tcp/0/localhost/256"

s |& getline

print $0

close(s)

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PROC_initsockets

PROC_closesocket(socket%)

 

=={{header|C}}==

With little changes it could work on MS Windows (without Cygwin) too. But I don't know exactly how. I have tested it using <code>nc -l -p 256</code>.

 

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

 

const char *msg = "hello socket world";

freeaddrinfo(addrs);

}

 

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

 

using System.IO;

using System.Net.Sockets;

tcp.Close();

}

 

Clean Socket alternative:

 

using System.Net.Sockets;

 

}

}

 

=={{header|C++}}==

I have tested it using <code>nc -vlp 4321</code>.

 

 

#include <boost/asio.hpp>

 

return 0;

 

=={{header|Cind}}==

 

var libsocket = @("lib","socket");

// connect

// close socket

libsocket.close(socket);

 

=={{header|Clojure}}==

(:import (java.net Socket)

(java.io PrintWriter)))

(.println printer msg)))

 

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

{{libheader|usocket}}

 

(write-line "hello socket world" stream)

(values))

 

 

=={{header|D}}==

import std.stdio ;

import std.socket ;

writefln("Socket %d bytes sent.", res) ;

socket.close() ;

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lTCPClient.Free;

end;

 

=={{header|Elena}}==

ELENA 4.1 :

import system'text;

import extensions'text;

socket.write(AnsiEncoder.toByteArray(0, s.Length, s));

socket.close()

 

=={{header|Elixir}}==

defmodule Sockets do

require Logger

 

Sockets.send_message(256, "hello socket world")

 

=={{header|Emacs Lisp}}==

Emacs treats network connections as sub-processes. <code>make-network-process</code> is the low-level socket creation,

 

:host 'local ;; or hostname string

:service 256)))

(process-send-string proc "hello socket world")

 

=={{header|Erlang}}==

-export([start/0]).

 

ok = gen_tcp:send(Sock, "hello socket world"),

ok = gen_tcp:close(Sock).

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

 

using inet

 

}

}

 

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

 

s" localhost" 256 open-socket

dup s" hello socket world" rot write-socket

 

 

=={{header|Go}}==

import (

fmt.Println(err)

}

{{out | Test with nc}}

<pre>

 

=={{header|Groovy}}==

s << "hello socket world"

 

=={{header|Haskell}}==

 

 

== Icon and Unicon ==

==={{header|Icon}}===

procedure main ()

hello("localhost", 1024)

procedure hello (host, port)

write(tconnect(host, port) | stop("unable to connect to", host, ":", port) , "hello socket world")

Note: Socket support in native Icon is limited and requires the external helper function cfunc.

==={{header|Unicon}}===

Unicon integrated TCP/IP networking and messaging.

hello(arglist[2]|"",arglist[1])

end

else stop("Unable to connect to ",host,":",port)

return

 

=={{header|IDL}}==

 

printf,unit,"hello socket world"

 

"Well-known" port numbers (under 1024 -- such as 256) can also be specified by name (in this case 'RAP').

<code>sdcheck</code> raises assertions if anything goes wrong:

 

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

 

=={{header|Java}}==

import java.net.*;

public class SocketSend {

sock.close();

}

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

function sockets() {

var sock = new Socket({client:true, port:256, noAsync:true, udp:true});

sockets() ==> undefined

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

socket = connect("localhost",256)

write(socket, "hello socket world")

close(socket)

 

=={{header|Kotlin}}==

 

import java.net.Socket

it.outputStream.write("hello socket world".toByteArray())

}

 

=={{header|Lasso}}==

 

#net->connect('127.0.0.1',256)

#net->dowithclose => {

#net->writestring('Hello World')

 

=={{header|Lua}}==

{{libheader|LuaSocket}}

host, port = "127.0.0.1", 256

 

sid = socket.udp()

sid:sendto( "hello socket world", host, port )

 

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

WriteString[socket, "hello socket world"];

 

=={{header|Myrddin}}==

 

const main = {

std.fatal("could not open fd: {}\n", err)

;;

 

=={{header|Nanoquery}}==

 

p = new(Port)

p.connect("localhost", 256)

p.write("hello socket world")

 

=={{header|Neko}}==

Sockets in Neko

Tectonics:

socket_write(socket, "hello socket world");

 

 

For testing on port 256, root powers required

 

=={{header|Nemerle}}==

using System.Net.Sockets;

 

sock.Close();

}

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

import java.net.

end

return

 

=={{header|NewLISP}}==

(set 'socket (net-connect "localhost" 256))

(net-send socket "hello socket world")

(net-close socket)

(exit)

 

=={{header|Nim}}==

 

var s = newSocket()

s.connect("localhost", Port(256))

s.send("Hello Socket World")

 

=={{header|Objeck}}==

use Net;

 

}

}

 

=={{header|Objective-C}}==

(untested)

 

// in some method

[oStream close];

}

 

=={{header|OCaml}}==

 

 

let init_socket addr port =

let outchan = out_channel_of_descr sock in

let inchan = in_channel_of_descr sock in

 

let ic, oc = init_socket "localhost" 256 in

output_string oc "hello socket world";

 

=={{header|Oz}}==

Socket = {New Open.socket init}

in

{Socket connect(port:256)}

{Socket write(vs:"hello socket world")}

 

=={{header|Pascal}}==

 

See also [https://rosettacode.org/wiki/Sockets#Delphi Delphi].

 

Uses

CloseSocket(TCP_Sock);

End.

 

Variant without superfluous additions:

 

Uses

fpSend(TCP_Sock, PMessage, Message_Len, 0);

End.

 

=={{header|Perl}}==

 

$host = gethostbyname('localhost');

connect(Socket_Handle, $in);

send(Socket_Handle, 'hello socket world', 0, $in);

 

Object oriented version.

 

$sock = Socket::Class->new(

) || die Socket::Class->error;

$sock->send('hello socket world');

 

=={{header|Phix}}==

Note this fails for me with "connection refused", just like the Go/Python/Ruby entries.

 

=={{header|PHP}}==

fputs($socket, 'hello socket world');

 

=={{header|PicoLisp}}==

(out @ (prinl "hello socket world"))

 

=={{header|Pike}}==

 

int main(){

con->write("hello socket world");

con->close();

 

=={{header|Prolog}}==

This works with Gnu Prolog. Other implementations will have different predicates.

socket_connect(Socket, 'AF_INET'(localhost,Port), Input, Output),

write(Output, 'hello socket world'),

flush_output(Output),

close(Output),

 

=={{header|PureBasic}}==

ConnectionID = OpenNetworkConnection("localhost", 256)

SendNetworkString(ConnectionID, "hello socket world")

 

=={{header|Python}}==

 

=={{header|R}}==

s <- make.socket(port = 256)

write.socket(s, "hello socket world")

close.socket(s)

 

=={{header|Racket}}==

(let-values ([(in out) (tcp-connect "localhost" 256)])

(display "hello socket world\n" out)

 

=={{header|Raku}}==

{{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 $port = 256;

 

my $client = IO::Socket::INET.new(:$host, :$port);

$client.print( 'hello socket world' );

 

=={{header|Rhope}}==

{{works with|Rhope|alpha 1}}

|:

[New@Net Client["localhost",256]]Put String["hello socket world"]

The connection is automatically closed when the object is freed.

 

=={{header|Ring}}==

Load "guilib.ring"

 

waitforbyteswritten(300000)

close()

 

=={{header|Ruby}}==

sock = TCPSocket.open("localhost", 256)

sock.write("hello socket world")

 

=={{header|Rust}}==

{{works with|Rust 1.0 stable}}

use std::net::TcpStream;

 

let _ = my_stream.write(b"hello socket world");

 

 

=={{header|Scala}}==

{{libheader|Scala}}

 

object sendSocketData {

 

sendData("localhost", "hello socket world")

 

=={{header|Scheme}}==

{{works with|Guile|1.8.8}}{{works with|Chicken Scheme|4.6.0}}

(connect s AF_INET (inet-pton AF_INET "127.0.0.1") 256)

 

=={{header|Seed7}}==

which returns a connected internet socket file at a port at localhost.

 

include "socket.s7i";

 

writeln(sock, "hello socket world");

close(sock);

 

=={{header|SenseTalk}}==

set SocketID to "localhost:256"

open socket SocketID

write "Hello socket world!" to socket SocketID

close socket SocketID

 

=={{header|Sidef}}==

var in = Socket.sockaddr_in(256, host);

var proto = Socket.getprotobyname('tcp');

sock.connect(in);

sock.send('hello socket world', 0, in);

 

=={{header|Slate}}==

This uses fairly verbose and low level messages. This will probably be simplified in the future.

 

[ | addr stream |

addr: (Net SocketAddress newOn: '127.0.0.1:256').

stream flush

] ensure: [socket close]

 

=={{header|Smalltalk}}==

This is taken from [http://sblinn.jottit.com/GNU_Smalltalk_SimpleEcho_TCP_Server here] with few modification to fit the task better.

 

 

Object subclass: #HelloSocket

Smalltalk at: #helloServer put: (HelloSocket port: 2560).

 

 

=={{header|Symsyn}}==

'127.0.0.1' $addr

connect $addr 256 sok

'hello socket world' [sok]

close sok

 

=={{header|Standard ML}}==

val set = fn socket => fn ipnr => fn portnr => fn text =>

(

)

;

call

set ( INetSock.TCP.socket () ) "127.0.0.1" 256 txt ;

=={{header|Tcl}}==

puts -nonewline $io "hello socket world"

 

=={{header|Toka}}==

 

#! A simple abstraction layer that makes writing trivial servers easy

 

#! The actual server

 

=={{header|TXR}}==

 

(sock (open-socket server.family sock-stream)))

(sock-connect sock server)

 

=={{header|UNIX Shell}}==

 

{{libheader|nc}}

 

When the connection fails, <code>nc</code> exits 1. To see an error message, use <code>nc -v localhost 256</code>.

 

=={{header|Ursa}}==

p.connect "localhost" 256

out "hello socket world" endl p

 

=={{header|Visual Basic .NET}}==

 

Imports System.IO

Imports System.Net.Sockets

tcp.Close()

End Sub

 

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

{{works with|nasm|Linux}}

;using sockets on linux with the 0x80 inturrprets.

;

sport resb 2

buff resb 1024

 

{{works with|MASM}}<br>

Operates in non-blocking mode.

.586

.model flat,stdcall

 

end start

 

{{works with|MASM}}<br>

This example works in blocking mode.

.586

.model flat,stdcall

 

end start

 

=={{header|X86-64 Assembly}}==

===UASM 2.52===

option casemap:none

option literals:on

 

option dllimport:<ws2_32>

WSAStartup proto :word, :qword

WSACleanup proto :qword

 

elseif @Platform eq linux64

malloc proto SYSTEMV :qword

free proto SYSTEMV :qword

connect proto :dword, :qword, :dword

freeaddrinfo proto :qword

CLASS socket_class

end

 

 

=={{header|zkl}}==

s.write("hello socket world"); //-->18

 

=={{header|Zsh}}==

ztcp localhost 256

 

{{omit from|ACL2}}