Rosetta Code

Sockets

Revision as of 03:31, 11 April 2010 by rosettacode>Dgamey (→‎{{header|Unicon}})

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.

Task
Sockets
You are encouraged to solve this task according to the task description, using any language you may know.

Ada

Library: GNAT RTL

<lang ada>with GNAT.Sockets; use GNAT.Sockets;

procedure SocketSend is 

  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;
  sendData ("127.0.0.1","hello socket world");

end;</lang>

AutoHotkey

modified from script by zed gecko. <lang autohotkey>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</lang>

C

Works with: POSIX version .1-2001
Works with: gcc version 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 256.

<lang c>#include <stdio.h>

  1. include <string.h>
  2. include <sys/types.h>
  3. include <sys/socket.h>
  4. 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);
  }

}</lang>

C#

<lang csharp>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();
   }

}</lang>

Clojure

<lang clojure>(ns socket-example 

 (:import (java.net Socket)
          (java.io PrintWriter)))

(defn send-data [host msg] 

 (let [sock (Socket. host 256)
       printer (PrintWriter. (.getOutputStream sock))]
   (.println printer msg)
   (.close printer)
   (.close sock)))

(send-data "localhost" "hello socket world")</lang>

Common Lisp

Library: usocket

<lang lisp>CL-USER> (usocket:with-client-socket (socket stream "localhost" 256) 

          (write-line "hello socket world" stream)
          (values))
No value</lang>

<lang lisp>aurora ~% sudo nc -l -p 256 hello socket world</lang>

D

<lang 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() { 

 auto socket = new Socket(AddressFamily.INET, SocketType.STREAM) ;
 socket.connect(new InternetAddress("localhost",256)) ;
 writefln(socket.send(cast(void[])"hello socket world"), " bytes sent.") ;
 socket.close() ;

}</lang>

Factor

<lang factor>"localhost" 256 <inet> utf8 [ "hello socket world" print ] with-client</lang>

Forth

Works with: GNU Forth version 0.7.0

<lang forth>include unix/socket.fs

s" localhost" 256 open-socket

dup s" hello socket world" rot write-socket

close-socket</lang>

Haskell

<lang haskell>import Network

main = withSocketsDo $ sendTo "localhost" (PortNumber $ toEnum 256) "hello socket world"</lang>

Icon

<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</lang>

IDL

<lang idl>socket, unit, 'localhost',256,/get_lun printf,unit,"hello socket world" close, unit</lang>

"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

The sdchecks raise assertions if anything goes wrong:

<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</lang>

Java

<lang 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();
 }

}</lang> 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.

OCaml

<lang 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)</lang>

<lang ocaml>let () = 

 let ic, oc = init_socket "localhost" 256 in
 output_string oc "hello socket world";
</lang>

Oz

<lang oz>declare 

 Socket = {New Open.socket init}

in 

 {Socket connect(port:256)}
 {Socket write(vs:"hello socket world")}
 {Socket close}</lang>

Perl

<lang 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);</lang>

Object oriented version. <lang perl>use Socket::Class;

$sock = Socket::Class->new( 

 'remote_port' => 256,

) || die Socket::Class->error; $sock->send('hello socket world'); $sock->free;</lang>

PHP

<lang PHP>$socket = fsockopen('localhost', 256); fputs($socket, 'hello socket world'); fclose($socket);</lang>

PicoLisp

<lang PicoLisp>(when (connect "localhost" 256) 

  (out @ (prinl "hello socket world"))
  (close @) )</lang>

Pike

<lang pike>import Stdio;

int main(){ 

  object con = File();
  con->connect("127.0.0.1",256);
  con->write("hello socket world");
  con->close();

}</lang>

PureBasic

<lang Purebasic> InitNetwork() ConnectionID = OpenNetworkConnection("localhost", 256) SendNetworkString(ConnectionID, "hello socket world") CloseNetworkConnection(ConnectionID) </lang>

Python

<lang python>import socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(("localhost", 256)) sock.sendall("hello socket world") sock.close()</lang>

Rhope

Works with: Rhope version alpha 1

<lang rhope>Socket Send(0,0) |: 

   [New@Net Client["localhost",256]]Put String["hello socket world"]
|</lang>

The connection is automatically closed when the object is freed.

Ruby

<lang ruby>require 'socket' sock = TCPSocket.open("localhost", 256) sock.write("hello socket world") sock.close</lang>

Seed7

<lang seed7>$ 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;</lang>


Slate

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

<lang slate>[ | 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.</lang>

Smalltalk

Works with: GNU Smalltalk

This is taken from here with few modification to fit the task better.

<lang smalltalk>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 |
   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.</lang>

Tcl

<lang tcl>set io [socket localhost 256] puts -nonewline $io "hello socket world" close $io</lang>

Toka

<lang toka>needs sockets

  1. ! 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
  1. ! The actual server

[ " hello socket world" server.send ] 256 server.start</lang>

Unicon

Unicon integrated TCP/IP networking and messaging. <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</lang>

UnixPipes

<lang bash>(echo "hello socket world" | nc localhost 256 | exit 0)</lang>

UNIX Shell

Using the program netcat (nc)

<lang bash>echo "hello socket world" | netcat localhost 256</lang>

Retrieved from "https://rosettacode.org/wiki/Sockets?oldid=46820"