void sqSocketListenOnPortBacklogSizeInterface(SocketPtr s, sqInt port, sqInt backlogSize, sqInt addr)
{
struct sockaddr_in saddr;
if (!socketValid(s))
return;
/* only TCP sockets have a backlog */
if ((backlogSize > 1) && (s->socketType != TCPSocketType))
{
interpreterProxy->success(false);
return;
}
PSP(s)->multiListen= (backlogSize > 1);
FPRINTF((stderr, "listenOnPortBacklogSize(%d, %d)\n", SOCKET(s), backlogSize));
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family= AF_INET;
saddr.sin_port= htons((short)port);
saddr.sin_addr.s_addr= htonl(addr);
bind(SOCKET(s), (struct sockaddr*) &saddr, sizeof(saddr));
if (TCPSocketType == s->socketType)
{
/* --- TCP --- */
listen(SOCKET(s), backlogSize);
SOCKETSTATE(s)= WaitingForConnection;
aioEnable(SOCKET(s), PSP(s), 0);
aioHandle(SOCKET(s), acceptHandler, AIO_RX); /* R => accept() */
}
else
{
/* --- UDP/RAW --- */
}
}
/* TCP => open a connection.
* UDP => set remote address.
*/
void sqSocketConnectToPort(SocketPtr s, sqInt addr, sqInt port)
{
struct sockaddr_in saddr;
if (!socketValid(s))
return;
FPRINTF((stderr, "connectTo(%d)\n", SOCKET(s)));
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family= AF_INET;
saddr.sin_port= htons((short)port);
saddr.sin_addr.s_addr= htonl(addr);
if (TCPSocketType != s->socketType)
{
/* --- UDP/RAW --- */
if (SOCKET(s) >= 0)
{
memcpy((void *)&SOCKETPEER(s), (void *)&saddr, sizeof(SOCKETPEER(s)));
SOCKETSTATE(s)= Connected;
}
}
else
{
/* --- TCP --- */
int result;
aioEnable(SOCKET(s), PSP(s), 0);
result= connect(SOCKET(s), (struct sockaddr *)&saddr, sizeof(saddr));
FPRINTF((stderr, "connect() => %d\n", result));
if (result == 0)
{
/* connection completed synchronously */
SOCKETSTATE(s)= Connected;
notify(PSP(s), CONN_NOTIFY);
setLinger(SOCKET(s), 1);
}
else
{
if (errno == EINPROGRESS || errno == EWOULDBLOCK)
{
/* asynchronous connection in progress */
SOCKETSTATE(s)= WaitingForConnection;
aioHandle(SOCKET(s), connectHandler, AIO_WX); /* W => connect() */
}
else
{
/* connection error */
perror("sqConnectToPort");
SOCKETSTATE(s)= Unconnected;
SOCKETERROR(s)= errno;
notify(PSP(s), CONN_NOTIFY);
}
}
}
}
void sqSocketDestroy(SocketPtr s)
{
if (!socketValid(s))
return;
FPRINTF((stderr, "destroy(%d)\n", SOCKET(s)));
if (SOCKET(s))
sqSocketAbortConnection(s); /* close if necessary */
if (PSP(s))
free(PSP(s)); /* release private struct */
_PSP(s)= 0;
}
sqInt sqSocketConnectionStatus(SocketPtr s)
{
if (!socketValid(s))
return Invalid;
/* we now know that the net session is valid, so if state is Invalid... */
if (SOCKETSTATE(s) == Invalid) /* see acceptHandler() */
{
fprintf(stderr, "socketStatus: freeing invalidated pss=%p\n", PSP(s));
/*free(PSP(s));*/ /* this almost never happens -- safer not to free()?? */
_PSP(s)= 0;
interpreterProxy->success(false);
return Invalid;
}
#if 0
/* check for connection closed by peer */
if (SOCKETSTATE(s) == Connected)
{
int fd= SOCKET(s);
int n= socketReadable(fd);
if (n < 0)
{
FPRINTF((stderr, "socketStatus(%d): detected other end closed\n", fd));
SOCKETSTATE(s)= OtherEndClosed;
}
}
#endif
FPRINTF((stderr, "socketStatus(%d) -> %d\n", SOCKET(s), SOCKETSTATE(s)));
return SOCKETSTATE(s);
}
void sqSocketCreateNetTypeSocketTypeRecvBytesSendBytesSemaIDReadSemaIDWriteSemaID(SocketPtr s, sqInt netType, sqInt socketType, sqInt recvBufSize, sqInt sendBufSize, sqInt semaIndex, sqInt readSemaIndex, sqInt writeSemaIndex)
{
int newSocket= -1;
privateSocketStruct *pss;
s->sessionID= 0;
if (TCPSocketType == socketType)
{
/* --- TCP --- */
newSocket= socket(AF_INET, SOCK_STREAM, 0);
}
else if (UDPSocketType == socketType)
{
/* --- UDP --- */
newSocket= socket(AF_INET, SOCK_DGRAM, 0);
}
if (-1 == newSocket)
{
/* socket() failed, or incorrect socketType */
interpreterProxy->success(false);
return;
}
setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
/* private socket structure */
pss= (privateSocketStruct *)calloc(1, sizeof(privateSocketStruct));
if (pss == NULL)
{
fprintf(stderr, "acceptFrom: out of memory\n");
interpreterProxy->success(false);
return;
}
pss->s= newSocket;
pss->connSema= semaIndex;
pss->readSema= readSemaIndex;
pss->writeSema= writeSemaIndex;
/* UDP sockets are born "connected" */
if (UDPSocketType == socketType)
{
pss->sockState= Connected;
aioEnable(pss->s, pss, 0);
}
else
{
pss->sockState= Unconnected;
}
pss->sockError= 0;
/* initial UDP peer := wildcard */
memset(&pss->peer, 0, sizeof(pss->peer));
pss->peer.sin_family= AF_INET;
pss->peer.sin_port= 0;
pss->peer.sin_addr.s_addr= INADDR_ANY;
/* Squeak socket */
s->sessionID= thisNetSession;
s->socketType= socketType;
s->privateSocketPtr= pss;
FPRINTF((stderr, "create(%d) -> %lx\n", SOCKET(s), (unsigned long)PSP(s)));
/* Note: socket is in BLOCKING mode until aioEnable is called for it! */
}
/* set the given option for the socket. the option comes in as a
* String. (why on earth we might think this a good idea eludes me
* ENTIRELY, so... if the string doesn't smell like an integer then we
* copy it verbatim, assuming it's really a ByteArray pretending to be
* a struct. caveat hackor.)
*/
sqInt sqSocketSetOptionsoptionNameStartoptionNameSizeoptionValueStartoptionValueSizereturnedValue(SocketPtr s, char *optionName, sqInt optionNameSize, char *optionValue, sqInt optionValueSize, sqInt *result)
{
if (socketValid(s))
{
socketOption *opt= findOption(optionName, (size_t)optionNameSize);
if (opt != 0)
{
int val= 0;
char buf[32];
char *endptr;
/* this is JUST PLAIN WRONG (I mean the design in the image rather
than the implementation here, which is probably correct
w.r.t. the broken design) */
if (optionValueSize > sizeof(buf) - 1)
goto barf;
memset((void *)buf, 0, sizeof(buf));
memcpy((void *)buf, optionValue, optionValueSize);
if (optionValueSize == 1) /* character `1' or `0' */
{
val= strtol(buf, &endptr, 0);
if (endptr != buf)
{
memcpy((void *)buf, (void *)&val, sizeof(val));
optionValueSize= sizeof(val);
}
}
if ((setsockopt(PSP(s)->s, opt->optlevel, opt->optname,
(const void *)buf, optionValueSize)) < 0)
{
perror("setsockopt");
goto barf;
}
/* it isn't clear what we're supposed to return here, since
setsockopt isn't supposed to have any value-result parameters
(go grok that `const' on the buffer argument if you don't
believe me). the image says "the result of the negotiated
value". what the f**k is there to negotiate? either
setsockopt sets the value or it barfs. and i'm not about to go
calling getsockopt just to see if the value got changed or not
(the image should send getOption: to the Socket if it really
wants to know). if the following is wrong then I could
probably care (a lot) less... fix the logic in the image and
then maybe i'll care about fixing the logic in here. (i know
that isn't very helpful, but it's 05:47 in the morning and i'm
severely grumpy after fixing several very unpleasant bugs that
somebody introduced into this file while i wasn't looking.) */
*result= val;
return 0;
}
}
barf:
interpreterProxy->success(false);
return false;
}
static int sampling_handler(struct kprobe *kp, uint32_t *stack,
uint32_t *kp_regs)
{
uint32_t *target_stack;
/* examine KTIMER LR */
if (stack[REG_LR] & 0x4)
target_stack = PSP();
else
target_stack = stack + 8;
sampled_pcpush((void *) target_stack[REG_PC]);
return 0;
}
void sqSocketCreateRawProtoTypeRecvBytesSendBytesSemaIDReadSemaIDWriteSemaID(SocketPtr s, sqInt netType, sqInt protocol, sqInt recvBufSize, sqInt sendBufSize, sqInt semaIndex, sqInt readSemaIndex, sqInt writeSemaIndex)
{
int newSocket= -1;
privateSocketStruct *pss;
s->sessionID= 0;
switch(protocol) {
case 1: newSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); break;
}
if (-1 == newSocket)
{
/* socket() failed, or incorrect protocol type */
fprintf(stderr, "primSocketCreateRAW: socket() failed; protocol = %d, errno = %d\n", protocol, errno);
interpreterProxy->success(false);
return;
}
/* private socket structure */
pss= (privateSocketStruct *)calloc(1, sizeof(privateSocketStruct));
if (pss == NULL)
{
fprintf(stderr, "acceptFrom: out of memory\n");
interpreterProxy->success(false);
return;
}
pss->s= newSocket;
pss->connSema= semaIndex;
pss->readSema= readSemaIndex;
pss->writeSema= writeSemaIndex;
/* RAW sockets are born "connected" */
pss->sockState= Connected;
aioEnable(pss->s, pss, 0);
pss->sockError= 0;
/* initial UDP peer := wildcard */
memset(&pss->peer, 0, sizeof(pss->peer));
pss->peer.sin_family= AF_INET;
pss->peer.sin_port= 0;
pss->peer.sin_addr.s_addr= INADDR_ANY;
/* Squeak socket */
s->sessionID= thisNetSession;
s->socketType= RAWSocketType;
s->privateSocketPtr= pss;
FPRINTF((stderr, "create(%d) -> %lx\n", SOCKET(s), (unsigned long)PSP(s)));
/* Note: socket is in BLOCKING mode until aioEnable is called for it! */
}
void sqSocketSetReusable(SocketPtr s)
{
char optionValue[256];
size_t bufSize;
unsigned char buf[4];
int err;
if (!socketValid(s)) return;
*(int *)buf= 1;
bufSize= 4;
if (setsockopt(SOCKET(s), SOL_SOCKET, SO_REUSEADDR, buf, bufSize) < 0)
{
PSP(s)->sockError= errno;
interpreterProxy->success(false);
return;
}
}
/* read data from the socket s into buf for at most bufSize bytes.
answer the number actually read. For UDP, fill in the peer's address
with the approriate value.
*/
sqInt sqSocketReceiveDataBufCount(SocketPtr s, char *buf, sqInt bufSize)
{
int nread= 0;
if (!socketValid(s))
return -1;
if (TCPSocketType != s->socketType)
{
/* --- UDP/RAW --- */
socklen_t addrSize= sizeof(SOCKETPEER(s));
if ((nread= recvfrom(SOCKET(s), buf, bufSize, 0, (struct sockaddr *)&SOCKETPEER(s), &addrSize)) <= 0)
{
if ((nread == -1) && (errno == EWOULDBLOCK))
{
FPRINTF((stderr, "UDP receiveData(%d) < 1 [blocked]\n", SOCKET(s)));
return 0;
}
SOCKETERROR(s)= errno;
FPRINTF((stderr, "UDP receiveData(%d) < 1 [a:%d]\n", SOCKET(s), errno));
return 0;
}
}
else
{
/* --- TCP --- */
if ((nread= read(SOCKET(s), buf, bufSize)) <= 0)
{
if ((nread == -1) && (errno == EWOULDBLOCK))
{
FPRINTF((stderr, "TCP receiveData(%d) < 1 [blocked]\n", SOCKET(s)));
return 0;
}
/* connection reset */
SOCKETSTATE(s)= OtherEndClosed;
SOCKETERROR(s)= errno;
FPRINTF((stderr, "TCP receiveData(%d) < 1 [b:%d]\n", SOCKET(s), errno));
notify(PSP(s), CONN_NOTIFY);
return 0;
}
}
/* read completed synchronously */
FPRINTF((stderr, "receiveData(%d) done = %d\n", SOCKET(s), nread));
return nread;
}
void sqSocketAcceptFromRecvBytesSendBytesSemaIDReadSemaIDWriteSemaID(SocketPtr s, SocketPtr serverSocket, sqInt recvBufSize, sqInt sendBufSize, sqInt semaIndex, sqInt readSemaIndex, sqInt writeSemaIndex)
{
/* The image has already called waitForConnection, so there is no
need to signal the server's connection semaphore again. */
struct privateSocketStruct *pss;
FPRINTF((stderr, "acceptFrom(%p, %d)\n", s, SOCKET(serverSocket)));
/* sanity checks */
if (!socketValid(serverSocket) || !PSP(serverSocket)->multiListen)
{
FPRINTF((stderr, "accept failed: (multi->%d)\n", PSP(serverSocket)->multiListen));
interpreterProxy->success(false);
return;
}
/* check that a connection is there */
if (PSP(serverSocket)->acceptedSock < 0)
{
fprintf(stderr, "acceptFrom: no socket available\n");
interpreterProxy->success(false);
return;
}
/* got connection -- fill in the structure */
s->sessionID= 0;
pss= (privateSocketStruct *)calloc(1, sizeof(privateSocketStruct));
if (pss == NULL)
{
fprintf(stderr, "acceptFrom: out of memory\n");
interpreterProxy->success(false);
return;
}
_PSP(s)= pss;
pss->s= PSP(serverSocket)->acceptedSock;
PSP(serverSocket)->acceptedSock= -1;
SOCKETSTATE(serverSocket)= WaitingForConnection;
aioHandle(SOCKET(serverSocket), acceptHandler, AIO_RX);
s->sessionID= thisNetSession;
pss->connSema= semaIndex;
pss->readSema= readSemaIndex;
pss->writeSema= writeSemaIndex;
pss->sockState= Connected;
pss->sockError= 0;
aioEnable(SOCKET(s), PSP(s), 0);
}
void sqSocketBindToPort(SocketPtr s, int addr, int port)
{
int result;
struct sockaddr_in inaddr;
privateSocketStruct *pss= PSP(s);
if (!socketValid(s)) return;
/* bind the socket */
memset(&inaddr, 0, sizeof(inaddr));
inaddr.sin_family= AF_INET;
inaddr.sin_port= htons(port);
inaddr.sin_addr.s_addr= htonl(addr);
if (bind(SOCKET(s), (struct sockaddr *)&inaddr, sizeof(struct sockaddr_in)) < 0)
{
pss->sockError= errno;
interpreterProxy->success(false);
return;
}
}
/* query the socket for the given option. */
sqInt sqSocketGetOptionsoptionNameStartoptionNameSizereturnedValue(SocketPtr s, char *optionName, sqInt optionNameSize, sqInt *result)
{
if (socketValid(s))
{
socketOption *opt= findOption(optionName, (size_t)optionNameSize);
if (opt != 0)
{
int optval; /* NOT sqInt */
socklen_t optlen= sizeof(optval);
if ((getsockopt(PSP(s)->s, opt->optlevel, opt->optname, (void *)&optval, &optlen)) < 0)
goto barf;
if (optlen != sizeof(optval))
goto barf;
*result= optval;
return 0;
}
}
barf:
interpreterProxy->success(false);
return errno;
}
void sqSocketCloseConnection(SocketPtr s)
{
int result= 0;
if (!socketValid(s))
return;
FPRINTF((stderr, "closeConnection(%d)\n", SOCKET(s)));
if (SOCKET(s) < 0)
return; /* already closed */
aioDisable(SOCKET(s));
SOCKETSTATE(s)= ThisEndClosed;
result= close(SOCKET(s));
if ((result == -1) && (errno != EWOULDBLOCK))
{
/* error */
SOCKETSTATE(s)= Unconnected;
SOCKETERROR(s)= errno;
notify(PSP(s), CONN_NOTIFY);
perror("closeConnection");
}
else if (0 == result)
{
/* close completed synchronously */
SOCKETSTATE(s)= Unconnected;
FPRINTF((stderr, "closeConnection: disconnected\n"));
SOCKET(s)= -1;
}
else
{
/* asynchronous close in progress */
SOCKETSTATE(s)= ThisEndClosed;
aioHandle(SOCKET(s), closeHandler, AIO_RWX); /* => close() done */
FPRINTF((stderr, "closeConnection: deferred [aioHandle is set]\n"));
}
}
unsigned int arch_get_thread_stack(void)
{
return PSP();
}
