Sockets: Difference between revisions

=={{header|Ada}}==

{{libheader|GNAT RTL}}

 

procedure Socket_Send is

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

Close_Socket (Client);

 

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

 

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

 

const main = {

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

;;

 

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

 

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

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

(display "hello socket world\n" out)

 

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

 

handleSocket: s

msg := 'hello socket world'.

msg displayOn: s.

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

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

 

=={{header|Zsh}}==

ztcp localhost 256

 

{{omit from|ACL2}}

{{omit from|Lotus 123 Macro Scripting}}

{{omit from|Locomotive Basic|Does not have network access.}}

{{omit from|Maxima}}

{{omit from|ML/I}}