"

 COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

NonPositionableExternalStream subclass:#Socket

       instanceVariableNames:'domain socketType protocol port serviceName

			      peerName'

       classVariableNames:''

       poolDictionaries:''

       category:'Streams-External'

!

Socket comment:'

COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

'!

!Socket class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

version

"

"

!

documentation

"

    This class provides access to (unix-)sockets for interprocess communication.

    The message protocol is preliminary, until someone tells me how

    other smalltalk's socket interfaces look like.

    Also, currently there is almost no support for other than IP 

    sockets - this will be added in the future.

    Due to historic reasons (I started this class, before I got hold of some

    code using ST-80 Sockets i.e. RemoteInvocation), there is some old interface

    still provided. 

    This will vanish; use the family:type: or newTCPxxx and newUDPxxx interface,

    together with the bind/listen and accept calls,

    which are meant to be compatible to ST-80's UnixSocketAccessor interface.

    ST/X does not use IPSocketAddress, UDSocketAddress erc; all addressing

    is done by passing appropriate string- or byteArray objects containing

    the addresses. This may change, too.

    TODO: cleanup historic leftovers, implement other than inet domain stuff.

"

!

examples

"

    example (get help info from an nntp server):

	|sock|

	sock := Socket 

		    newTCPclientToHost:(OperatingSystem 

					    getEnvironment:'NNTPSERVER') 

				  port:'nntp'.

	Transcript showCr:sock nextLine.

	sock buffered:false.

	sock nextPutAll:'HELP'; cr.

	[:exit |

	    |line|

	    line := sock nextLine.

	    line = '.' ifTrue:[exit value:nil].

	    Transcript showCr:line.

	] loopWithExit.

	sock close

    example (connect to an ftp server):

	|sock|

	sock := Socket 

		    newTCPclientToHost:(OperatingSystem getHostName) 

				  port:'ftp'.

	sock buffered:false.

	Transcript showCr:sock nextLine.

	sock nextPutAll:('USER ' , OperatingSystem getLoginName); cr.

	Transcript showCr:sock nextLine.

	sock nextPutAll:('PASS ' , 'your password here'); cr.

	Transcript showCr:sock nextLine.

	sock nextPutAll:'LIST'; cr.

	Transcript showCr:sock nextLine.

	'dont know enough of the ftp protocol to continue here ...'

    example (connect to an snmp server):

	|sock port|

	sock := Socket newUDP.

	port := Socket portOfService:'snmp'.

	sock connectTo:(OperatingSystem getHostName) port:port.

	sock buffered:false.

	Transcript showCr:'got it'.

    example (await connection from a client and read some data):

	|connectSock sock|

	connectSock := Socket provide:9996.  

	Transcript showCr:'listen ..'.

	connectSock listenFor:5.

	Transcript showCr:'wait'.

	connectSock readWait.  

	Transcript showCr:'accept'.

	sock := Socket new acceptOn:self.

	Transcript showCr:'close'.

	connectSock close.

	sock buffered:false.

	Transcript showCr:'server: got it'.

	'can now do transfer via sock'.

	Transcript showCr:'read'.

	Transcript showCr:('got: ' , sock nextLine).

	sock close

    example (connect to above server and send some data):

	|sock|

	sock := Socket connectTo:9996 on:'porty'.

	sock buffered:false.

	Transcript showCr:'client: got it'.

	'can now do transfer via sock'.

	Transcript showCr:'sending <hello>'.

	sock nextPutLine:'hello'.

	sock close

"

! !

!Socket primitiveDefinitions!

%{

#include <stdio.h>

#include <errno.h>

#ifdef LINUX

/* kludge to avoid some redefines ... */

# define _ARPA_NAMESER_H

# define _NETINET_TCP_H

#endif

#ifndef transputer

# include <fcntl.h>

# include <sys/types.h>

# ifdef IRIS

   /* no socket.h on 4.0.5h ?!?!? */

#  define AF_UNIX 1

#  define AF_INET 2

#  define SOCK_STREAM 1

#  define SOCK_DGRAM  2

#  define SOCK_RAW    3

# else

#  include <sys/socket.h>

# endif

# include <netdb.h>

# include <netinet/in.h>

# if ! (defined(SYSV3) && defined(mc88k))

#  include <netinet/tcp.h>

# endif

#endif

/*

 * on some systems errno is a macro ... check for it here

 */

#ifndef errno

 extern errno;

#endif

static int __debugging__ = 0;

#ifdef DEBUG

# define DBGPRINTF(x)    printf x

#else

# define DBGPRINTF(x)    /* as nothing */

#endif

%}

! !

!Socket class methodsFor:'Signal constants'!

brokenConnectionSignal

    "return the signal used to tell broken connections.

     Since in unix, this is the same as the broken pipe signal,

     return that one.

     (for other Operatingsystems, this may change ..)"

    ^ PipeStream brokenPipeSignal

! !

!Socket class methodsFor:'debugging'!

debug:aBoolean

    "turn on/off internal debugprints.

     This method is for ST/X debugging only and

     may  be removed in later versions"

%{  /* NOCONTEXT */

    __debugging__ = (aBoolean == true);

%}

! !

!Socket class methodsFor:'queries'!

ipAddressOfHost:aHostName

    "return the IP (internet-) number for a hostname"

    |b1 b2 b3 b4|

%{

    struct sockaddr_in sa ;

    struct hostent *hp ;

    long addr;

    if (__isString(aHostName)) {

	bzero(&sa, sizeof(sa)) ;

	if ((addr = inet_addr((char *) _stringVal(aHostName))) != -1) {

	    /* is Internet addr in octet notation */

	    bcopy(&addr, (char *) &sa.sin_addr, sizeof(addr)); 

	    sa.sin_family = AF_INET;

	} else {

	    /* do we know the host's address? */

	    if ((hp = gethostbyname((char *) _stringVal(aHostName))) == NULL) {

		DBGPRINTF(("unknown host\n"));

		RETURN ( nil );

	    }

	    bcopy(hp->h_addr, (char *) &sa.sin_addr, hp->h_length) ;

	    sa.sin_family = hp->h_addrtype;

	}

    }

    /* if the addressing family is not AF_INET, return nil */

    if (sa.sin_family != AF_INET) {

	RETURN ( nil );

    }

    b1 = _MKSMALLINT((sa.sin_addr.s_addr >> 24) & 0xFF);

    b2 = _MKSMALLINT((sa.sin_addr.s_addr >> 16) & 0xFF);

    b3 = _MKSMALLINT((sa.sin_addr.s_addr >> 8) & 0xFF);

    b4 = _MKSMALLINT((sa.sin_addr.s_addr >> 0) & 0xFF);

%}

.

    ^ ByteArray with:b1 with:b2 with:b3 with:b4

    "

     Socket ipAddressOfHost:'clam'

     Socket ipAddressOfHost:'porty'

     Socket ipAddressOfHost:'josef'

     Socket ipAddressOfHost:'styx.com'

    "

!

hostWithIpAddress:anAddress

    "return the hostname for an IP (internet-) address"

    |b1 b2 b3 b4|

    b1 := anAddress at:1.

    b2 := anAddress at:2.

    b3 := anAddress at:3.

    b4 := anAddress at:4.

%{

    struct sockaddr_in sa ;

    struct hostent *hp ;

    if (__bothSmallInteger(b1, b2) && __bothSmallInteger(b3, b4)) {

	bzero(&sa, sizeof(sa)) ;

	sa.sin_addr.s_addr = _intVal(b1) & 0xFF;

	sa.sin_addr.s_addr = (sa.sin_addr.s_addr << 8) | (_intVal(b2) & 0xFF);

	sa.sin_addr.s_addr = (sa.sin_addr.s_addr << 8) | (_intVal(b3) & 0xFF);

	sa.sin_addr.s_addr = (sa.sin_addr.s_addr << 8) | (_intVal(b4) & 0xFF);

	sa.sin_family = AF_INET;

	/* do we know the host's address? */

	hp = gethostbyaddr((char *) &sa.sin_addr.s_addr, sizeof(sa.sin_addr.s_addr), AF_INET);

	if (hp == NULL) {

	    DBGPRINTF(("unknown address: %d.%d.%d.%d\n", 

		       _intVal(b1), _intVal(b2), _intVal(b3), _intVal(b4)));

	} else {

	    sa.sin_family = hp->h_addrtype;

	}

    }

    /* if the addressing family is not AF_INET, return nil */

    if (sa.sin_family != AF_INET) {

	RETURN ( nil );

    }

    if (hp != NULL)

	RETURN (_MKSTRING(hp->h_name COMMA_CON));

    RETURN (_MKSTRING(inet_ntoa(sa.sin_addr) COMMA_CON));

%}

    "

     Socket ipAddressOfHost:'clam'

     Socket hostWithIpAddress:(Socket ipAddressOfHost:'clam') 

     Socket ipAddressOfHost:'porty'

     Socket hostWithIpAddress:(Socket ipAddressOfHost:'porty') 

     Socket hostWithIpAddress:#[1 2 3 4]

    "

!

portOfService:aNameOrNumber

    "returns the port-number for a given service

     or nil if no such service exists;

     - used to convert service names to portNumbers"

%{

    struct servent *servent = NULL;

    if (__isSmallInteger(aNameOrNumber)) {

	servent = getservbyport(htons(_intVal(aNameOrNumber)), "tcp") ;

	if (servent != NULL) {

	    RETURN ( aNameOrNumber );

	}

	RETURN ( aNameOrNumber );

    }

    if (__isString(aNameOrNumber)) {

	servent = getservbyname((char *) _stringVal(aNameOrNumber), "tcp");

	if (servent != NULL) {

	    RETURN ( _MKSMALLINT(ntohs(servent->s_port)) );

	}

	RETURN ( nil );

    }

    RETURN ( nil );

%}

    "

     Socket portOfService:'finger'

     Socket portOfService:'nntp'  

     Socket portOfService:'echo' 

     Socket portOfService:'snmp' 

    "

!

protocolOfService:aNameOrNumber

    "returns the protocol (as string) for a given service

     or nil if no such service exists."

%{

    struct servent *servent = NULL;

    if (__isSmallInteger(aNameOrNumber)) {

	servent = getservbyport(htons(_intVal(aNameOrNumber)), "tcp") ;

	if (servent == NULL) {

	    servent = getservbyport(htons(_intVal(aNameOrNumber)), "udp") ;

	    if (servent == NULL) {

		RETURN ( nil );

	    }

	}

    } else {

	if (__isString(aNameOrNumber)) {

	    servent = getservbyname((char *) _stringVal(aNameOrNumber), "tcp");

	    if (servent == NULL) {

		servent = getservbyname((char *) _stringVal(aNameOrNumber), "udp");

		if (servent == NULL) {

		    RETURN ( nil );

		}

	    }

	}

    }

    if (servent) {

	RETURN ( _MKSTRING(servent->s_proto COMMA_CON) );

    }

    RETURN ( nil );

%}

    "

     Socket protocolOfService:'finger' 

     Socket protocolOfService:'nntp'  

     Socket protocolOfService:'xxx'

     Socket protocolOfService:79

     Socket protocolOfService:'snmp' 

    "

!

domainOfProtocol:aProtocol

    "given a protocols name (i.e. tcp, udp etc) return the domain.

     This method needs more ... - or is there a way to get this from the system ?"

    "

     tcp/ip stuff

    "

    (aProtocol = 'tcp') ifTrue:[^ #inet].

    (aProtocol = 'udp') ifTrue:[^ #inet].

    (aProtocol = 'ip')  ifTrue:[^ #inet].

    "

     unix domain

    "

    (aProtocol = 'ud')  ifTrue:[^ #unix].

    "

     x25 stuff (if any)

     appletalk stuff (if any)

     other stuff (if any)

    "

    ^ nil

    "

     Socket domainOfProtocol:'tcp'

     Socket domainOfProtocol:'ucp'

     Socket domainOfProtocol:(Socket protocolOfService:'nntp')

     Socket domainOfProtocol:(Socket protocolOfService:'echo')

    "

!

typeOfProtocol:aProtocol

    "given a protocols name (i.e. tcp, udp etc) return the connection type.

     This method needs more ... - or is there a way to get this from the system ?"

    (aProtocol = 'tcp') ifTrue:[^ #stream].

    (aProtocol = 'udp') ifTrue:[^ #datagram].

    (aProtocol = 'ip')  ifTrue:[^ #raw].

    "

     unix domain

    "

    (aProtocol = 'ud')  ifTrue:[^ #stream].

    "

     x25 stuff (if any)

     appletalk stuff (if any)

     other stuff (if any)

    "

    ^ nil

    "

     Socket typeOfProtocol:'tcp'

     Socket typeOfProtocol:'ucp'

     Socket typeOfProtocol:(Socket protocolOfService:'nntp')

     Socket typeOfProtocol:(Socket protocolOfService:'echo')

    "

! !

!Socket class methodsFor:'easy tcp/ip instance creation'!

connectTo:service on:host

    "standard & easy client setup: 

	create new client tcp socket, bind and connect; 

	return the socket.

     The system will block (interruptable), until the connection is 

     established."

    ^ (self new) for:host port:(self portOfService:service).

    "

     Socket connectTo:9995 on:'clam'

     Socket connectTo:'finger' on:'clam'

     Socket connectTo:'ftp' on:'clam'

     Socket connectTo:'nntp' on:(OperatingSystem getEnvironment:'NNTPSERVER')

    "

!

provide:service

    "standard & easy server setup: 

	create a new TCP server socket providing a service."

    |newSock|

    newSock := (self new) for:nil port:(self portOfService:service).

    newSock notNil ifTrue:[

	newSock listenFor:5.

    ].

    ^ newSock

    "

     Socket provide:9995