"

 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 portNr serviceName'

       classVariableNames:''

       poolDictionaries:''

       category:'Streams-External'

!

Socket comment:'

COPYRIGHT (c) 1992 by Claus Gittinger

              All Rights Reserved

I provide access to sockets for interprocess communication.

The message protocol is preliminary, until someone tells me how

other smalltalks socket interface looks.

'!

%{

#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>

# include <sys/socket.h>

# include <netdb.h>

# include <netinet/in.h>

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

#  include <netinet/tcp.h>

# endif

#endif

%}

connectTo:service on:host

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

    "Socket connectTo:9995 on:'clam'"

    "Socket connectTo:'finger' on:'clam'"

    "Socket connectTo:'nntp' on:'nntphost'"

!

provide:service

    "Socket provide:9995"

!

acceptFrom:aSocket

     socket"

    ^ self new acceptOn:aSocket

    "Socket acceptFrom:(Socket provide:9995)"

!

! !

!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 ;

    int a, sock ;

    long addr;

    FILE *fp;

    extern int _immediateInterrupt;

    int savInt;

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

                printf("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

!

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

    }

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

        if (servent != NULL) {

            RETURN ( _MKSMALLINT(servent->s_port) );

        }

        RETURN ( nil );

    }

    RETURN ( nil );

%}

    "Socket portOfService:'finger'"

    "Socket portOfService:'nntp'"

!

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 {

            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 methodsFor:'socket setup'!

    "set up socket with domain, type and protocol"

%{

    FILE *fp;

    int dom, typ, proto, sock;

    struct protoent *protoEntry;

    extern struct protoent *getprotobyname();

    extern errno;

    extern OBJ ErrorNumber;

    /*

     * get address-family

     */

#ifdef AF_UNIX

        dom = AF_UNIX;

    else

#endif

#ifdef AF_INET

        dom = AF_INET;

    else

#endif

#ifdef AF_NS

        dom = AF_NS;

    else

#endif

#ifdef AF_APPLETALK

        dom = AF_APPLETALK;

    else

#endif

#ifdef AF_X25

        dom = AF_X25;

    else

#endif

    {

        RETURN ( nil );

    }

#ifdef SOCK_STREAM

        typ = SOCK_STREAM;

    else

#endif

#ifdef SOCK_DGRAM

        typ = SOCK_DGRAM;

    else 

#endif

#ifdef SOCK_RAW

        typ = SOCK_RAW;

    else

#endif

#ifdef SOCK_SEQPACKET

        typ = SOCK_SEQPACKET;

    else

#endif

    {

        RETURN ( nil );

    }

        protoEntry = getprotobyname((char *) _stringVal(aStringOrNumberOrNil));

        if (protoEntry == NULL) {

            RETURN ( nil );

        }

        proto = protoEntry->p_proto;

        endprotoent();

    } else if (_isSmallInteger(aStringOrNumberOrNil)) {

        proto = _intVal(aStringOrNumberOrNil);

    } else {

        proto = 0;

    }

    do {

        sock = socket(dom, typ, proto);

    } while ((sock < 0) && (errno == EINTR));

    if (sock >= 0) {

        /* make it a FILE * */

        fp = fdopen(sock, "r+");

        if (fp) {

            _INST(filePointer) = MKOBJ(fp);

        }

%}

    "Socket domain:#inet type:#stream protocol:nil"

!

    "setup for a server socket"

!

    "setup for a server socket"

!

    "setup for a server socket"

!

    "setup for a server socket"

%{

    struct sockaddr_in sa ;

    int sock = -1;

    FILE *fp;

    int backLog;

    extern OBJ _stream, _datagram, ErrorNumber;

    extern int _immediateInterrupt;

    extern errno;

    extern OBJ ErrorNumber;

    int savInt;

    int socktype = 0;

    int ret;

    if (! _isSmallInteger(portNr)) {

        RETURN ( nil );

    }

#ifdef SOCK_STREAM 

        socktype = SOCK_STREAM;

#endif

#ifdef SOCK_DGRAM 

        socktype = SOCK_DGRAM;

    }

    do {

        sock = socket(AF_INET, socktype, 0);

    } while ((sock < 0) && (errno == EINTR));

    if (sock < 0 ) {

        ErrorNumber = _MKSMALLINT(errno);

        RETURN (nil);

    }

    bzero((char *) &sa, sizeof(sa)) ;

    sa.sin_family = AF_INET ;

    sa.sin_addr.s_addr = htonl(INADDR_ANY) ;

    sa.sin_port = htons(_intVal(portNr)) ;

    do {

        ret = bind(sock, (struct sockaddr *) &sa, sizeof(sa));

    } while ((ret < 0) && (errno == EINTR));

    if (ret < 0) {

        printf("bind failed\n");

        ErrorNumber = _MKSMALLINT(errno);

        close(sock);

        RETURN ( nil );

    }

    if (_isSmallInteger(aNumber)) {

        backLog = _intVal(aNumber);

    } else

        backLog = 1;

#ifdef SOCK_STREAM

        savInt = _immediateInterrupt;

        _immediateInterrupt = 1;

        do {

           ret = listen(sock, backLog);

        } while ((ret < 0) && (errno == EINTR));

        if (ret < 0) {

            printf("listen failed\n");

            ErrorNumber = _MKSMALLINT(errno);

            close(sock);

            _immediateInterrupt = savInt;

            RETURN ( nil );

        }

        _immediateInterrupt = savInt;

    }

#endif

    /* make it a FILE * */

    fp = fdopen(sock, "r+");

    if (! fp) {

        close(sock);

        RETURN ( nil );

    }

/*

    setbuf(fp, NULL);

*/

    _INST(filePointer) = MKOBJ(fp);

%}

.