1520     self listenWithBacklog:aNumber

  1520     self listenFor:aNumber

  1533     ^ port

  1533     ^ self port

  1591 !Socket methodsFor:'closing'!

  1591 !Socket methodsFor:'accepting connections'!

  1592 

  1592 

  1593 shutDown

  1593 accept

  1594     "shutDown and close the socket"

  1594     "create a new TCP socket from accepting on the receiver.

  1595 

  1595      This method will suspend the current process if no connection is waiting.

  1596     self shutdown:2.

  1596      For ST-80 compatibility"

  1597     self close

  1597 

  1598 !

  1598     |newSock|

  1599 

  1599 

  1600 shutDownInput

  1600     self readWait.

  1601     "shutDown the input side of the socket.

  1601     newSock := self class new.

  1602      Any read on the socket will signal end-of-file from now on.

  1602     (newSock primAcceptOn:self blocking:false) ifFalse:[

  1603      The other side MAY be informed, that no more data will be accepted

  1603         "should raise an error here"

  1604      (e.g. setting the TCP-Windowsize to 0)"

  1604         ^ nil

  1605 

  1605     ].

  1606     self shutdown:0.

  1606     ^ newSock

  1607 !

  1607 

  1608 

  1608     "

  1609 shutDownOutput

  1609      |sock newSock|

  1610     "shutDown the output side of the socket.

  1610 

  1611      Any write to the socket will signal end-of-file from now on.

  1611      sock := Socket provide:8004.

  1612      The other side will get a end-of-file condition,

  1612      sock listenFor:5.

  1613      after the last buffered data has been read"

  1613      newSock := sock accept.

  1614 

  1614     "

  1615     self shutdown:1.

  1615 !

  1616 

  1617 blockingAccept

  1618     "create a new TCP socket from accepting on the receiver.

  1619      This method will suspend the smalltalk image with all smalltalk processes if no connection is waiting.

  1620      For ST-80 compatibility"

  1621 

  1622     |newSock|

  1623 

  1624     newSock := self class new.

  1625     (newSock primAcceptOn:self blocking:true) ifFalse:[

  1626         "should raise an error here"

  1627         ^ nil

  1628     ].

  1629     ^ newSock

  1618 !Socket methodsFor:'datagram transmission'!

  1632 !Socket methodsFor:'binding'!

  1619 

  1620 receiveBuffer:aDataBuffer start:startIndex for:nBytes

  1621     "receive data

  1622      Return the number of bytes received, or a negative number on error.

  1623      On error, the unix error code is left in the lastErrorNumber

  1624      instance variable.

  1625      The thread blocks until data arrives - you may want to wait before

  1626      receiving, using #readWait or #readWaitWithTimeout:."

  1627 

  1628     |nReceived|

  1629 

  1630 %{

  1631 #ifndef NO_SOCKET

  1632     OBJ fp = __INST(filePointer);

  1633 

  1634     if (fp != nil) {

  1635 	SOCKET sock;

  1636 	int objSize, offs;

  1637 	int n;

  1638 	char *extPtr;

  1639 	unsigned char *buffer;

  1640 	unsigned char *allocatedBuffer;

  1641 	int flags = 0;

  1642 

  1643 	sock = SOCKET_FROM_FILE_OBJECT(fp);

  1644 

  1645 	if (! setupBufferParameters(aDataBuffer, startIndex, &extPtr, &offs, &objSize)) goto bad;

  1646 	if (__isSmallInteger(nBytes)) {

  1647 	    if (__intVal(nBytes) < objSize) {

  1648 		objSize = __intVal(nBytes);

  1649 	    }

  1650 	}

  1651 

  1652 # ifdef DO_WRAP_CALLS

  1653 	if (extPtr) {

  1654 	    buffer = extPtr + offs;

  1655 	} else {

  1656 	    allocatedBuffer = buffer = (char *)malloc(objSize);

  1657 	}

  1658 

  1659 	do {

  1660 	    __threadErrno = 0;

  1661 	    n = STX_WSA_CALL4("recv", recv, sock, buffer, objSize, flags);

  1662 	} while ((n < 0) && (__threadErrno == EINTR));

  1663 

  1664 	if (allocatedBuffer) {

  1665 	    if (n > 0) {

  1666 		bcopy(allocatedBuffer, (char *)__InstPtr(aDataBuffer) + offs, n);

  1667 	    }

  1668 	    free(allocatedBuffer);

  1669 	}

  1670 # else

  1671 	__BEGIN_INTERRUPTABLE__

  1672 	do {

  1673 	    if (extPtr) {

  1674 		n = recv(sock, extPtr + offs, objSize, flags);

  1675 	    } else {

  1676 		n = recv(sock, (char *)__InstPtr(aDataBuffer) + offs, objSize, flags);

  1677 	    }

  1678 	} while ((n < 0) && (errno == EINTR));

  1679 	__END_INTERRUPTABLE__

  1680 # endif

  1681 

  1682 	if (n < 0) {

  1683 	    __INST(lastErrorNumber) = __MKSMALLINT(errno);

  1684 	}

  1685 	nReceived = __MKSMALLINT(n);

  1686     }

  1687 #endif

  1688 bad: ;

  1689 %}.

  1690     nReceived notNil ifTrue:[

  1691 	nReceived < 0 ifTrue:[

  1692 	    'Socket [warning]: ' infoPrint.

  1693 	    (OperatingSystem errorTextForNumber:lastErrorNumber) infoPrintCR.

  1694 	].

  1695 	^ nReceived

  1696     ].

  1697     "

  1698      arrive here if you try to receive into an invalid buffer (i.e. not ByteArray-like)

  1699     "

  1700     self primitiveFailed

  1701 !

  1702 

  1703 receiveFrom:anAddressBuffer buffer:aDataBuffer

  1704     "receive datagramm data - put address of originating host into

  1705      anAddressBuffer, data into aBuffer.

  1706      Both must be ByteArray-like. The addressBuffer must

  1707      provide space for a valid address for my domain (i.e. for inet, a 4-byte byteArray).

  1708      Return the number of bytes received, or a negative number on error.

  1709      On error, the unix error code is left in the lastErrorNumber

  1710      instance variable."

  1711 

  1712     ^ self receiveFrom:anAddressBuffer buffer:aDataBuffer start:1 for:(aDataBuffer size)

  1713 !

  1714 

  1715 receiveFrom:anAddressBuffer buffer:aDataBuffer start:startIndex for:nBytes

  1716     "receive datagramm data

  1717      - put address of originating host into anAddressBuffer, data into aBuffer.

  1718      For backward compatibility, the addressBuffer may be a non-SocketAddress;

  1719      then, it must be a byteArray with appropriate size for the addressBytes.

  1720 

  1721      Return the number of bytes received, or a negative number on error.

  1722      On error, the unix error code is left in the lastErrorNumber

  1723      instance variable.

  1724      The thread blocks until data arrives - you may want to wait before

  1725      receiving, using #readWait or #readWaitWithTimeout:."

  1726 

  1727     |domainClass addr addrLen nReceived|

  1728 

  1729     domainClass := self class socketAddressClassForDomain:domain.

  1730     domainClass isNil ifTrue:[

  1731 	^ self error:'invalid (unsupported) domain'.

  1732     ].

  1733     (anAddressBuffer isKindOf:SocketAddress) ifTrue:[

  1734 	anAddressBuffer class == domainClass ifFalse:[

  1735 	    ^ self error:'addressBuffer class mismatch (domain)'.

  1736 	].

  1737 	addr := anAddressBuffer.

  1738     ] ifFalse:[

  1739 	anAddressBuffer notNil ifTrue:[

  1740 	    addr := domainClass new.

  1741 	].

  1742     ].

  1743 

  1744 %{

  1745 #ifndef NO_SOCKET

  1746     OBJ fp = __INST(filePointer);

  1747 

  1748     if (fp != nil) {

  1749 	SOCKET sock;

  1750 	int objSize;

  1751 	union sockaddr_u sa;

  1752 	unsigned int alen = 0;

  1753 	int n, offs;

  1754 	int flags = 0;

  1755 	char *extPtr;

  1756 	unsigned char *allocatedBuffer = NULL;

  1757 	unsigned char *buffer = NULL;

  1758 

  1759 	sock = SOCKET_FROM_FILE_OBJECT(fp);

  1760 

  1761 	if (! setupBufferParameters(aDataBuffer, startIndex, &extPtr, &offs, &objSize)) goto bad;

  1762 	if (__isSmallInteger(nBytes)) {

  1763 	    if (__intVal(nBytes) < objSize) {

  1764 		objSize = __intVal(nBytes);

  1765 	    }

  1766 	}

  1767 # ifdef DO_WRAP_CALLS

  1768 	if (extPtr) {

  1769 	    buffer = extPtr + offs;

  1770 	} else {

  1771 	    allocatedBuffer = buffer = (char *)malloc(objSize);

  1772 	}

  1773 

  1774 	do {

  1775 	    __threadErrno = 0;

  1776 	    alen = sizeof(sa);

  1777 	    n = STX_WSA_CALL6("recvfrom", recvfrom, sock, buffer, objSize, flags, (struct sockaddr *)&sa, &alen);

  1778 	} while ((n < 0) && (__threadErrno == EINTR));

  1779 

  1780 	if (allocatedBuffer) {

  1781 	    if (n > 0) {

  1782 		bcopy(allocatedBuffer, (char *)__InstPtr(aDataBuffer) + offs, n);

  1783 	    }

  1784 	    free(allocatedBuffer);

  1785 	}

  1786 # else

  1787 	__BEGIN_INTERRUPTABLE__

  1788 	do {

  1789 	    alen = sizeof(sa);

  1790 	    if (extPtr) {

  1791 		n = recvfrom(sock, extPtr + offs, objSize, flags, (struct sockaddr *) &sa, &alen);

  1792 	    } else {

  1793 		n = recvfrom(sock, (char *)__InstPtr(aDataBuffer) + offs, objSize, flags, (struct sockaddr *) &sa, &alen);

  1794 	    }

  1795 	} while ((n < 0) && (errno == EINTR));

  1796 	__END_INTERRUPTABLE__

  1797 # endif

  1798 

  1799 	if (n >= 0) {

  1800 	    if (__isNonNilObject(addr)) {

  1801 		char *addrPtr;

  1802 		OBJ oClass;

  1803 		int nInstVars, nInstBytes, objSize;

  1804 

  1805 		oClass = __qClass(addr);

  1806 		if (! __isBytes(addr) )

  1807 		    goto bad;

  1808 		nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);

  1809 		nInstBytes = OHDR_SIZE + (nInstVars * sizeof(OBJ));

  1810 		objSize = __qSize(addr) - nInstBytes;

  1811 		addrPtr = (char *)__InstPtr(addr) + nInstBytes;

  1812 		if (objSize < alen)

  1813 		    goto bad;

  1814 

  1815 		/*

  1816 		 * extract the datagrams address

  1817 		 */

  1818 		bcopy((char *)&sa, addrPtr, alen);

  1819 		addrLen = __MKSMALLINT(alen);

  1820 	    }

  1821 	}

  1822 	if (n < 0) {

  1823 	    __INST(lastErrorNumber) = __MKSMALLINT(errno);

  1824 	}

  1825 	nReceived = __MKSMALLINT(n);

  1826     }

  1827 #endif

  1828 bad: ;

  1829 %}.

  1830     nReceived notNil ifTrue:[

  1831 	nReceived < 0 ifTrue:[

  1832 	    'Socket [warning]: ' infoPrint.

  1833 	    (OperatingSystem errorTextForNumber:lastErrorNumber) infoPrintCR.

  1834 	].

  1835 	addrLen notNil ifTrue:[

  1836 	    (addr == anAddressBuffer) ifFalse:[

  1837 		self obsoleteFeatureWarning:'please use a socketAddress argument'.

  1838 

  1839 		" can be a ByteArray for backward compatibility "

  1840 		anAddressBuffer replaceFrom:1 to:addrLen with:(addr hostAddress).

  1841 	    ].

  1842 	].

  1843 	^ nReceived

  1844     ].

  1845     "

  1846      arrive here if you try to receive into an invalid buffer

  1847      (i.e. not ByteArray-like),

  1848      or if the addressBuffer is nonNil AND not a SocketAddress/ByteArray

  1849      or if the addressBuffer is nonNil AND too small.

  1850     "

  1851     self primitiveFailed

  1852 !

  1853 

  1854 sendBuffer:aDataBuffer start:startIndex for:nBytes flags:flags

  1855     "send data.

  1856      Both must be ByteArray-like. The bytes in the addressBuffer must

  1857      be a valid address for my domain (i.e. for inet, a 4-byte byteArray).

  1858      Return the number of bytes transmitted, or a negative number on error.

  1859      On error, the unix error code is left in the lastErrorNumber

  1860      instance variable."

  1861 

  1862     |nReceived portNo|

  1863 

  1864 %{

  1865 #ifndef NO_SOCKET

  1866     OBJ fp = __INST(filePointer);

  1867 

  1868     if ((fp != nil)

  1869      && __isSmallInteger(startIndex)

  1870      && __isSmallInteger(nBytes)) {

  1871 	SOCKET sock;

  1872 	int objSize;

  1873 	int n;

  1874 	char *extPtr;

  1875 	int _flags = 0;

  1876 	int offs;

  1877 	unsigned long norder;

  1878 	unsigned char *buffer;

  1879 	unsigned char *allocatedBuffer;

  1880 

  1881 	_flags = __longIntVal(flags);

  1882 

  1883 	sock = SOCKET_FROM_FILE_OBJECT(fp);

  1884 

  1885 	if (! setupBufferParameters(aDataBuffer, startIndex, &extPtr, &offs, &objSize)) goto bad;

  1886 	if (__isSmallInteger(nBytes)) {

  1887 	    if (__intVal(nBytes) < objSize) {

  1888 		objSize = __intVal(nBytes);

  1889 	    }

  1890 	}

  1891 

  1892 # ifdef DGRAM_DEBUG

  1893 	console_printf("sending %d bytes ...\n", nBytes);

  1894 # endif

  1895 

  1896 #ifdef DO_WRAP_CALLS

  1897 	if (extPtr) {

  1898 	    buffer = extPtr + offs;

  1899 	} else {

  1900 	    allocatedBuffer = buffer = (char *)malloc(objSize);

  1901 	    bcopy((char *)__InstPtr(aDataBuffer) + offs, allocatedBuffer, objSize);

  1902 	}

  1903 

  1904 	do {

  1905 	    __threadErrno = 0;

  1906 	    n = STX_WSA_CALL4("send", send, sock, buffer, objSize, _flags);

  1907 	} while ((n < 0) && (__threadErrno == EINTR));

  1908 

  1909 	if (allocatedBuffer) {

  1910 	    free(allocatedBuffer);

  1911 	}

  1912 #else

  1913 	__BEGIN_INTERRUPTABLE__

  1914 	do {

  1915 	    if (extPtr) {

  1916 		n = send(sock, extPtr + offs, objSize, _flags);

  1917 	    } else {

  1918 		n = send(sock, (char *)__InstPtr(aDataBuffer) + offs, objSize, _flags);

  1919 	    }

  1920 	} while ((n < 0) && (errno == EINTR));

  1921 	__END_INTERRUPTABLE__

  1922 #endif

  1923 

  1924 	if (n < 0) {

  1925 	    __INST(lastErrorNumber) = __MKSMALLINT(errno);

  1926 	}

  1927 	RETURN (__MKSMALLINT(n));

  1928     }

  1929 #endif

  1930 bad: ;

  1931 %}.

  1932     "

  1933      arrive here if you try to send from an invalid buffer (i.e. not ByteArray-like),

  1934     "

  1935     self primitiveFailed

  1936 !

  1937 

  1938 sendTo:anAddressBuffer buffer:buffer

  1939     "send datagramm data - fetch address of destination host from

  1940      anAddressBuffer, data from aDataBuffer.

  1941      Both must be ByteArray-like. The bytes in the addressBuffer must

  1942      be a valid address for my domain (i.e. for inet, a 4-byte byteArray).

  1943      Return the number of bytes transmitted, or a negative number on error.

  1944      On error, the unix error code is left in the lastErrorNumber

  1945      instance variable.

  1946      Flags is currently ignored; it is there for ST-80 compatibility."

  1947 

  1948     ^ self sendTo:anAddressBuffer buffer:buffer start:1 for:buffer size flags:0

  1949 !

  1950 

  1951 sendTo:anAddressBuffer buffer:buffer start:startIndex for:count

  1952     "send datagramm data - fetch address of destination host from

  1953      anAddressBuffer, data from aDataBuffer.

  1954      Both must be ByteArray-like. The bytes in the addressBuffer must

  1955      be a valid address for my domain (i.e. for inet, a 4-byte byteArray).

  1956      Return the number of bytes transmitted, or a negative number on error.

  1957      On error, the unix error code is left in the lastErrorNumber

  1958      instance variable.

  1959      Flags is currently ignored; it is there for ST-80 compatibility."

  1960 

  1961     ^ self sendTo:anAddressBuffer buffer:buffer start:startIndex for:count flags:0

  1962 !

  1963 

  1964 sendTo:anAddressBuffer buffer:aDataBuffer start:startIndex for:nBytes flags:flags

  1965     "send datagramm data - fetch address of destination host from

  1966      anAddressBuffer, data from aDataBuffer starting at startIndex,

  1967      sending count bytes.

  1968      Both must be ByteArray-like. The bytes in the addressBuffer must

  1969      be a valid address for my domain (i.e. for inet, a 4-byte byteArray).

  1970      Return the number of bytes transmitted, or a negative number on error.

  1971      On error, the unix error code is left in the lastErrorNumber

  1972      instance variable."

  1973 

  1974     |domainClass addr|

  1975 

  1976     domainClass := self class socketAddressClassForDomain:domain.

  1977     domainClass isNil ifTrue:[

  1978 	^ self error:'invalid (unsupported) domain'.

  1979     ].

  1980 

  1981     (anAddressBuffer isKindOf:SocketAddress) ifTrue:[

  1982 	addr := anAddressBuffer.

  1983     ] ifFalse:[

  1984 	anAddressBuffer isByteArray ifFalse:[

  1985 	    ^ self error:'bad socketAddress argument'

  1986 	].

  1987 	addr := domainClass hostAddress:anAddressBuffer.

  1988     ].

  1989 %{

  1990 #ifndef NO_SOCKET

  1991     OBJ fp = __INST(filePointer);

  1992 

  1993     if ((fp != nil)

  1994      && __isSmallInteger(startIndex)

  1995      && __isSmallInteger(nBytes)) {

  1996 	SOCKET sock;

  1997 	int objSize;

  1998 	struct sockaddr *sockaddr_ptr;

  1999 	union sockaddr_u sa;

  2000 	int alen = 0;

  2001 	int sockAddrOffs, sockaddr_size;

  2002 	int n;

  2003 	char *extPtr;

  2004 	int _flags = 0;

  2005 	int offs;

  2006 	unsigned long norder;

  2007 	unsigned char *buffer;

  2008 	unsigned char *allocatedBuffer;

  2009 

  2010 	_flags = __longIntVal(flags);

  2011 	sock = SOCKET_FROM_FILE_OBJECT(fp);

  2012 

  2013 	if (! __isBytes(addr)) {

  2014 	    sockaddr_size = 0;

  2015 	    sockaddr_ptr = (struct sockaddr *)0;

  2016 	} else {

  2017 	    int nIndex;

  2018 	    OBJ cls;

  2019 

  2020 	    sockAddrOffs = 0;

  2021 	    if ((cls = __qClass(addr)) != @global(ByteArray))

  2022 		sockAddrOffs += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

  2023 	    nIndex = __qSize(addr) - OHDR_SIZE;

  2024 	    sockaddr_size = nIndex - sockAddrOffs;

  2025 	    if (sockaddr_size > sizeof(sa)) {

  2026 		console_fprintf(stderr, "Socket [warning]: bad socketAddr\n");

  2027 		goto bad;

  2028 	    }

  2029 	    bcopy((__byteArrayVal(addr) + sockAddrOffs), &sa, sockaddr_size);

  2030 	    sockaddr_ptr = (struct sockaddr *)(&sa);

  2031 	}

  2032 

  2033 	if (! setupBufferParameters(aDataBuffer, startIndex, &extPtr, &offs, &objSize)) goto bad;

  2034 	if (__isSmallInteger(nBytes)) {

  2035 	    if (__intVal(nBytes) < objSize) {

  2036 		objSize = __intVal(nBytes);

  2037 	    }

  2038 	}

  2039 

  2040 #ifdef DO_WRAP_CALLS

  2041 	if (extPtr) {

  2042 	    buffer = extPtr + offs;

  2043 	} else {

  2044 	    allocatedBuffer = buffer = (char *)malloc(objSize);

  2045 	    bcopy((char *)__InstPtr(aDataBuffer) + offs, allocatedBuffer, objSize);

  2046 	}

  2047 

  2048 	do {

  2049 	    __threadErrno = 0;

  2050 	    n = STX_WSA_CALL6("sendto", sendto, sock, buffer, objSize, _flags, sockaddr_ptr, sockaddr_size);

  2051 	} while ((n < 0) && (__threadErrno == EINTR));

  2052 

  2053 	if (allocatedBuffer) {

  2054 	    free(allocatedBuffer);

  2055 	}

  2056 #else

  2057 	__BEGIN_INTERRUPTABLE__

  2058 	do {

  2059 	    if (extPtr) {

  2060 		n = sendto(sock, extPtr + offs, objSize, _flags, sockaddr_ptr, sockaddr_size);

  2061 	    } else {

  2062 		n = sendto(sock, (char *)__InstPtr(aDataBuffer) + offs, objSize, _flags, sockaddr_ptr, sockaddr_size);

  2063 	    }

  2064 	} while ((n < 0) && (errno == EINTR));

  2065 	__END_INTERRUPTABLE__

  2066 #endif

  2067 

  2068 	if (n < 0) {

  2069 	    __INST(lastErrorNumber) = __MKSMALLINT(errno);

  2070 	}

  2071 	RETURN (__MKSMALLINT(n));

  2072     }

  2073 #endif

  2074 bad: ;

  2075 %}.

  2076     "

  2077      arrive here if you try to send from an invalid buffer

  2078      (i.e. not ByteArray-like),

  2079      or if the addressBuffer is nonNil AND not a ByteArray/String

  2080      or if the addressBuffer is nonNil AND too small.

  2081     "

  2082     self primitiveFailed

  2083 ! !

  2084 

  2085 !Socket methodsFor:'low level'!

  2389     "same as listenWithBacklog: - for ST-80 compatibility"

  1841     "start listening; return true if ok, false on error

  2390 

  1842      aNumber is the number of connect requests, that may be queued on the socket"

  2391     ^ self listenWithBacklog:aNumber

  2392 !

  2393 

  2394 listenWithBacklog:aNumber

  2395     "start listening; return true if ok, false on error"

  2398 	^ self errorNotOpen

  1845         ^ self errorNotOpen

  2407 	DBGPRINTF(("SOCKET: invalid arg\n"));

  1854         DBGPRINTF(("SOCKET: invalid arg\n"));

  2408 	RETURN (false);

  1855         RETURN (false);

  2416 	__threadErrno = 0;

  1863         __threadErrno = 0;

  2417 	ret = STX_WSA_CALL2("listen", listen, sock, __intVal(aNumber));

  1864         ret = STX_WSA_CALL2("listen", listen, sock, __intVal(aNumber));

  2422 	ret = listen(sock, __intVal(aNumber));

  1869         ret = listen(sock, __intVal(aNumber));

  2431 	DBGPRINTF(("SOCKET: listen call failed errno=%d\n", errno));

  1878         DBGPRINTF(("SOCKET: listen call failed errno=%d\n", errno));

  2432 	__INST(lastErrorNumber) = __MKSMALLINT(errno);

  1879         __INST(lastErrorNumber) = __MKSMALLINT(errno);

  2433 	RETURN (false);

  1880         RETURN (false);

  2443 !Socket protectedMethodsFor:'low level'!

  1890 !Socket methodsFor:'closing'!

  2444 

  1891 

  2445 setSocketOption:option argument:arg1 argument:arg2

  1892 shutDown

  2446     |ok|

  1893     "shutDown and close the socket"

  2447 

  1894 

  2448 %{  /* STACK: 32000 */

  1895     self shutdown:2.

  2449     OBJ fp = __INST(filePointer);

  1896     self close

  2450 

  1897 !

  2451     if (fp != nil) {

  1898 

  2452 	SOCKET sock;

  1899 shutDownInput

  2453 	int opt = -1;

  1900     "shutDown the input side of the socket.

  2454 	int level = -1;

  1901      Any read on the socket will signal end-of-file from now on.

  2455 	int usize = -1;

  1902      The other side MAY be informed, that no more data will be accepted

  2456 	int ret;

  1903      (e.g. setting the TCP-Windowsize to 0)"

  2457 	union u {

  1904 

  2458 	    BOOL        u_bool;

  1905     self shutdown:0.

  2459 	    int         u_int;

  1906 !

  2460 	    struct linger u_linger;

  1907 

  2461 	} u;

  1908 shutDownOutput

  2462 

  1909     "shutDown the output side of the socket.

  2463 	sock = SOCKET_FROM_FILE_OBJECT(fp);

  1910      Any write to the socket will signal end-of-file from now on.

  2464 

  1911      The other side will get a end-of-file condition,

  2465 # ifdef SO_BROADCAST

  1912      after the last buffered data has been read"

  2466 	if (option == @symbol(SO_BROADCAST)) {

  1913 

  2467 	    /* Enables transmission and receipt of broadcast messages on the socket. */

  1914     self shutdown:1.

  2468 	    opt = SO_BROADCAST;

  2469 	    level = SOL_SOCKET;

  2470 	    usize = sizeof(u.u_bool);

  2471 	    if (arg1 == true) u.u_bool = TRUE;

  2472 	    else if (arg1 == false) u.u_bool = FALSE;

  2473 	    else goto argError;

  2474 	}

  2475 # endif /* SO_BROADCAST */

  2476 

  2477 # ifdef SO_CONDITIONAL

  2478 #  if 0

  2479 	if (option == @symbol(SO_CONDITIONAL)) {

  2480 	    /* Enables sockets to delay the acknowledgment of a connection until after the WSAAccept condition function is called. */

  2481 	    opt = SO_CONDITIONAL;

  2482 	    level = SOL_SOCKET;

  2483 	    usize = sizeof(u.u_bool);

  2484 	    if (arg1 == true) u.u_bool = TRUE;

  2485 	    else if (arg1 == false) u.u_bool = FALSE;

  2486 	    else goto argError;

  2487 	}

  2488 #  endif

  2489 # endif /* SO_CONDITIONAL */

  2490 

  2491 # ifdef SO_DEBUG

  2492 	if (option == @symbol(SO_DEBUG)) {

  2493 	    /* Records debugging information. */

  2494 	    opt = SO_DEBUG;

  2495 	    level = SOL_SOCKET;

  2496 	    usize = sizeof(u.u_bool);

  2497 	    if (arg1 == true) u.u_bool = TRUE;

  2498 	    else if (arg1 == false) u.u_bool = FALSE;

  2499 	    else goto argError;

  2500 	}

  2501 # endif /* SO_DEBUG */

  2502 

  2503 # ifdef SO_DONTLINGER

  2504 	    if (option == @symbol(SO_DONTLINGER)) {

  2505 		/* Does not block close waiting for unsent data to be sent.

  2506 		   Setting this option is equivalent to setting SO_LINGER with l_onoff set to zero. */

  2507 		opt = SO_DONTLINGER;

  2508 		level = SOL_SOCKET;

  2509 		usize = sizeof(u.u_bool);

  2510 		if (arg1 == true) u.u_bool = TRUE;

  2511 		else if (arg1 == false) u.u_bool = FALSE;

  2512 		else goto argError;

  2513 	    }

  2514 # endif /* SO_DONTLINGER */

  2515 

  2516 # ifdef SO_DONTROUTE

  2517 	if (option == @symbol(SO_DONTROUTE)) {

  2518 	    /* Does not route: sends directly to interface.

  2519 	       Succeeds but is ignored on AF_INET sockets;

  2520 	       fails on AF_INET6 sockets with WSAENOPROTOOPT.

  2521 	       Not supported on ATM sockets (results in an error). */

  2522 	    opt = SO_DONTROUTE;

  2523 	    level = SOL_SOCKET;

  2524 	    usize = sizeof(u.u_bool);

  2525 	    if (arg1 == true) u.u_bool = TRUE;

  2526 	    else if (arg1 == false) u.u_bool = FALSE;

  2527 	    else goto argError;

  2528 	}

  2529 # endif /* SO_DONTROUTE */

  2530 

  2531 # ifdef SO_KEEPALIVE

  2532 	if (option == @symbol(SO_KEEPALIVE)) {

  2533 	    /* Sends keep-alives. Not supported on ATM sockets (results in an error). */

  2534 	    opt = SO_KEEPALIVE;

  2535 	    level = SOL_SOCKET;

  2536 	    usize = sizeof(u.u_bool);

  2537 	    if (arg1 == true) u.u_bool = TRUE;

  2538 	    else if (arg1 == false) u.u_bool = FALSE;

  2539 	    else goto argError;

  2540 	}

  2541 # endif /* SO_KEEPALIVE */

  2542 

  2543 # ifdef SO_LINGER

  2544 	if (option == @symbol(SO_LINGER)) {

  2545 	    /* Lingers on close if unsent data is present. */

  2546 	    opt = SO_LINGER;

  2547 	    level = SOL_SOCKET;

  2548 	    usize = sizeof(u.u_linger);

  2549 	    if (arg1 == true) u.u_linger.l_onoff = TRUE;

  2550 	    else if (arg1 == false) u.u_linger.l_onoff = FALSE;

  2551 	    else goto argError;

  2552 	    if (arg2 == nil) u.u_linger.l_linger = 0;

  2553 	    else if (__isSmallInteger(arg2))u.u_linger.l_linger = __intVal(arg2);

  2554 	    else goto argError;

  2555 	    DBGPRINTF(("SOCKET: SO_LINGER %d %d\n", u.u_linger.l_onoff, u.u_linger.l_linger));

  2556 	}

  2557 # endif /* SO_LINGER */

  2558 

  2559 # ifdef SO_OOBINLINE

  2560 	if (option == @symbol(SO_OOBINLINE)) {

  2561 	    /* Receives OOB data in the normal data stream. */

  2562 	    opt = SO_OOBINLINE;

  2563 	    level = SOL_SOCKET;

  2564 	    usize = sizeof(u.u_bool);

  2565 	    if (arg1 == true) u.u_bool = TRUE;

  2566 	    else if (arg1 == false) u.u_bool = FALSE;

  2567 	    else goto argError;

  2568 	}

  2569 # endif /* SO_OOBINLINE */

  2570 

  2571 # ifdef SO_RCVBUF

  2572 	if (option == @symbol(SO_RCVBUF)) {

  2573 	    /* Specifies the total per-socket buffer space reserved for receives.

  2574 	       This is unrelated to SO_MAX_MSG_SIZE or the size of a TCP window. */

  2575 	    opt = SO_RCVBUF;

  2576 	    level = SOL_SOCKET;

  2577 	    usize = sizeof(u.u_int);

  2578 	    if (__isSmallInteger(arg1))u.u_int = __intVal(arg1);

  2579 	    else goto argError;

  2580 	}

  2581 # endif /* SO_RCVBUF */

  2582 

  2583 # ifdef SO_SNDBUF

  2584 	if (option == @symbol(SO_SNDBUF)) {

  2585 	    /* Specifies the total per-socket buffer space reserved for sends.

  2586 	       This is unrelated to SO_MAX_MSG_SIZE or the size of a TCP window. */

  2587 	    opt = SO_SNDBUF;

  2588 	    level = SOL_SOCKET;

  2589 	    usize = sizeof(u.u_int);

  2590 	    if (__isSmallInteger(arg1))u.u_int = __intVal(arg1);

  2591 	    else goto argError;

  2592 	}

  2593 # endif /* SO_SNDBUF */

  2594 

  2595 # ifdef SO_REUSEADDR

  2596 	if (option == @symbol(SO_REUSEADDR)) {

  2597 	    /* Allows the socket to be bound to an address that is already in use.  */

  2598 	    opt = SO_REUSEADDR;

  2599 	    level = SOL_SOCKET;

  2600 	    usize = sizeof(u.u_bool);

  2601 	    if (arg1 == true) u.u_bool = TRUE;

  2602 	    else if (arg1 == false) u.u_bool = FALSE;

  2603 	    else goto argError;

  2604 	}

  2605 # endif /* SO_OOBINLINE */

  2606 

  2607 # ifdef SO_EXCLUSIVEADDRUSE

  2608 	if (option == @symbol(SO_EXCLUSIVEADDRUSE)) {

  2609 	    /* Enables a socket to be bound for exclusive access.

  2610 	       Does not require administrative privilege.  */

  2611 	    opt = SO_EXCLUSIVEADDRUSE;

  2612 	    level = SOL_SOCKET;

  2613 	    usize = sizeof(u.u_bool);

  2614 	    if (arg1 == true) u.u_bool = TRUE;

  2615 	    else if (arg1 == false) u.u_bool = FALSE;

  2616 	    else goto argError;

  2617 	}

  2618 # endif /* SO_OOBINLINE */

  2619 

  2620 	if (usize == -1) goto argError;

  2621 

  2622 	ok = ( setsockopt( sock, level, opt, &u, usize) >= 0) ? true : false;

  2623     }

  2624 argError: ;

  2625 

  2626 %}.

  2627     ok isNil ifTrue:[

  2628 	self primitiveFailed

  2629     ].

  2630     ok ifFalse:[

  2631 	'setsocketoption failed' infoPrintCR.

  2632     ].

  2635 !Socket methodsFor:'low level'!

  1917 !Socket methodsFor:'connecting'!

  2636 

  2637 shutdown: howNum

  2638     "shutDown the socket - inform it that no more I/O will be performed.

  2639 	 0 - read side   (no further reads)

  2640 	 1 - write side  (no further writes)

  2641 	 2 - both        (no further I/O at all)

  2642      shutDown:2

  2643 	discards any pending data

  2644 	(as opposed to close, which might wait until data is delivered as set by LINGER)"

  2645 

  2646 %{

  2647 #ifndef NO_SOCKET

  2648 

  2649     OBJ fp;

  2650 

  2651     fp = __INST(filePointer);

  2652     if ((fp != nil) && __isSmallInteger(howNum)) {

  2653 	SOCKET sock;

  2654 	int ret;

  2655 

  2656 	sock = SOCKET_FROM_FILE_OBJECT(fp);

  2657 # ifdef DO_WRAP_CALLS

  2658 	do {

  2659 	    __threadErrno = 0;

  2660 	    DBGFPRINTF((stderr, "SOCKET: shutDown...\n"));

  2661 	    ret = STX_WSA_CALL2("shutdown", shutdown, sock, __intVal(howNum));

  2662 	    DBGFPRINTF((stderr, "SOCKET: shutDown -> %d (%d)\n", ret, __threadErrno));

  2663 	} while ((ret < 0) && (__threadErrno == EINTR));

  2664 # else

  2665 	__BEGIN_INTERRUPTABLE__

  2666 	shutdown(sock, __intVal(howNum));

  2667 	__END_INTERRUPTABLE__

  2668 # endif

  2669     }

  2670 #endif

  2671 %}.

  2672 ! !

  2673 

  2674 !Socket methodsFor:'low level-accepting'!

  2675 

  2676 accept

  2677     "create a new TCP socket from accepting on the receiver.

  2678      This method will suspend the current process if no connection is waiting.

  2679      For ST-80 compatibility"

  2680 

  2681     |newSock|

  2682 

  2683     newSock := self class new.

  2684     (newSock acceptOn:self) ifFalse:[^ nil].

  2685     ^ newSock

  2686 

  2687     "

  2688      |sock newSock|

  2689 

  2690      sock := Socket provide:8004.

  2691      sock listenFor:5.

  2692      newSock := sock accept.

  2693     "

  2694 !

  2695 

  2696 acceptOn:aSocket

  2697     "accept a connection on a server port (created with:'Socket>>onIPPort:')

  2698      usage is: (Socket basicNew acceptOn:(Socket onIPPort:9999)).

  2699      This method will suspend the current process if no connection is waiting.

  2700      Return the true if ok; false if not."

  2701 

  2702     aSocket readWait.

  2703     ^ self primAcceptOn:aSocket blocking:false.

  2704 

  2705     "Modified: / 11.3.1996 / 14:21:31 / stefan"

  2706     "Modified: / 1.8.1998 / 23:39:10 / cg"

  2707 !

  2708 

  2709 blockingAccept

  2710     "create a new TCP socket from accepting on the receiver.

  2711      This method will suspend the current process if no connection is waiting.

  2712      For ST-80 compatibility"

  2713 

  2714     |newSock|

  2715 

  2716     newSock := self class new.

  2717     (newSock blockingAcceptOn:self) ifFalse:[^ nil].

  2718     ^ newSock

  2719 !

  2720 

  2721 blockingAcceptOn:aSocket

  2722     "accept a connection on a server port (created with:'Socket>>onIPPort:')

  2723      usage is: (Socket basicNew acceptOn:(Socket onIPPort:9999)).

  2724      This method will suspend the current process if no connection is waiting.

  2725      Return the true if ok; false if not."

  2726 

  2727     ^ self primAcceptOn:aSocket blocking:true.

  2728 !

  2729 

  2730 pollingWaitForNewConnectionOrDataOnAny:otherConnections timeout:timeoutSeconds

  2731     <resource: #obsolete>

  2732     "stupid MSDOS does not support select on sockets (sigh).

  2733      Must poll here."

  2734 

  2735     |millis newConnection|

  2736 

  2737     millis := timeoutSeconds * 1000.

  2738     [millis > 0] whileTrue:[

  2739 	otherConnections size > 0 ifTrue:[

  2740 	    otherConnections do:[:aConnection |

  2741 		aConnection canReadWithoutBlocking ifTrue:[

  2742 		    ^ aConnection

  2743 		]

  2744 	    ].

  2745 	].

  2746 	newConnection := self blockingAccept.

  2747 	newConnection notNil ifTrue:[^ newConnection].

  2748 	Delay waitForMilliseconds:20.

  2749 	millis := millis - 20.

  2750     ].

  2751     ^ nil.

  2752 !

  2753 

  2754 pollingWaitForNewConnectionWithTimeout:timeoutSeconds

  2755     <resource: #obsolete>

  2756     "stupid MSDOS does not support select on sockets (sigh).

  2757      Must poll here."

  2758 

  2759     |millis newConnection|

  2760 

  2761     timeoutSeconds notNil ifTrue:[

  2762 	millis := timeoutSeconds * 1000.

  2763     ].

  2764     [millis isNil or:[millis > 0]] whileTrue:[

  2765 	newConnection := self blockingAccept.

  2766 	newConnection notNil ifTrue:[^ newConnection].

  2767 	Delay waitForMilliseconds:20.

  2768 	millis notNil ifTrue:[

  2769 	    millis := millis - 20.

  2770 	]

  2771     ].

  2772     ^ nil.

  2773 !

  2774 

  2775 primAcceptOn:aSocket blocking:blocking

  2776     "accept a connection on a server port (created with:'Socket>>onIPPort:')

  2777      usage is: (Socket basicNew acceptOn:(Socket onIPPort:9999)).

  2778      Return the true if ok; false if not."

  2779 

  2780     |serverSocketFd addr addrLen domainClass|

  2781 

  2782     filePointer notNil ifTrue:[

  2783 	^ self errorAlreadyOpen

  2784     ].

  2785 

  2786     domain := aSocket domain.

  2787     socketType := aSocket type.

  2788     serverSocketFd := aSocket fileDescriptor.

  2789     serverSocketFd isNil ifTrue:[

  2790 	^ self error:'invalid server socket'

  2791     ].

  2792     (serverSocketFd isMemberOf:SmallInteger) ifFalse:[

  2793 	^ self error:'invalid server socket'

  2794     ].

  2795 

  2796     domainClass := self class socketAddressClassForDomain:domain.

  2797     domainClass isNil ifTrue:[

  2798 	^ self error:'invalid (unsupported) domain'.

  2799     ].

  2800     addrLen := domainClass socketAddressSize.

  2801     addr := domainClass new.

  2802 

  2803 %{  /* STACK: 100000 */

  2804 #ifndef NO_SOCKET

  2805     FILE *fp;

  2806     int flags;

  2807     SOCKET sock, newSock;

  2808     union sockaddr_u sa;

  2809     unsigned int alen, alen0;

  2810     struct hostent *he ;

  2811     char dotted[20] ;

  2812 

  2813     if (!__isSmallInteger(addrLen)) {

  2814 	DBGPRINTF(("SOCKET: bad addrLen\n"));

  2815 	RETURN (false);

  2816     }

  2817     alen0 = __intVal(addrLen);

  2818     sock = SOCKET_FROM_FD(__intVal(serverSocketFd));

  2819 

  2820     if (blocking == false) {

  2821 # if defined(O_NONBLOCK) && defined(SET_NDELAY)

  2822 	flags = fcntl(sock, F_GETFL);

  2823 	fcntl(sock, F_SETFL, flags | O_NONBLOCK);

  2824 # endif

  2825     }

  2826 

  2827 # ifdef DO_WRAP_CALLS

  2828     do {

  2829 	__threadErrno = 0;

  2830 	alen = alen0;

  2831 	newSock = STX_WSA_CALL3("accept", accept, sock, &sa, &alen);

  2832     } while ((newSock < 0) && (__threadErrno == EINTR));

  2833 # else

  2834     __BEGIN_INTERRUPTABLE__

  2835     do {

  2836 	alen = alen0;

  2837 	newSock = accept(sock, (struct sockaddr *) &sa, &alen);

  2838     } while ((newSock < 0) && (errno == EINTR));

  2839     __END_INTERRUPTABLE__

  2840 # endif

  2841     DBGFPRINTF((stderr, "SOCKET: accept newSock=%d\n", newSock));

  2842 

  2843     if (blocking == false) {

  2844 # if defined(O_NDELAY) && defined(SET_NDELAY)

  2845 	fcntl(sock, F_SETFL, flags);

  2846 # endif

  2847     }

  2848 

  2849     if (newSock < 0) {

  2850 	DBGPRINTF(("SOCKET: accept call failed errno=%d\n", errno));

  2851 	__INST(lastErrorNumber) = __MKSMALLINT(errno);

  2852 	RETURN (false);

  2853     }

  2854 

  2855     if (__isNonNilObject(addr)) {

  2856 	OBJ oClass;

  2857 	int nInstVars, nInstBytes, objSize;

  2858 	char *cp;

  2859 

  2860 	oClass = __qClass(addr);

  2861 	if (! __isBytes(addr) ) {

  2862 	    DBGPRINTF(("SOCKET: bad addr\n"));

  2863 	    closesocket(newSock);

  2864 	    RETURN (false);

  2865 	}

  2866 

  2867 	nInstVars = __intVal(__ClassInstPtr(oClass)->c_ninstvars);

  2868 	nInstBytes = OHDR_SIZE + (nInstVars * sizeof(OBJ));

  2869 	objSize = __qSize(addr) - nInstBytes;