/* answer whether the socket has data available for reading:
if the socket is not connected, answer "false";
if the socket is open and data can be read, answer "true".
if the socket is open and no data is currently readable, answer "false";
if the socket is closed by peer, change the state to OtherEndClosed
and answer "false";
*/
sqInt sqSocketReceiveDataAvailable(SocketPtr s)
{
if (!socketValid(s)) return false;
if (SOCKETSTATE(s) == Connected)
{
int fd= SOCKET(s);
int n= socketReadable(fd);
if (n > 0)
{
FPRINTF((stderr, "receiveDataAvailable(%d) -> true\n", fd));
return true;
}
else if (n < 0)
{
FPRINTF((stderr, "receiveDataAvailable(%d): other end closed\n", fd));
SOCKETSTATE(s)= OtherEndClosed;
}
}
else /* (SOCKETSTATE(s) != Connected) */
{
FPRINTF((stderr, "receiveDataAvailable(%d): socket not connected\n", SOCKET(s)));
}
aioHandle(SOCKET(s), dataHandler, AIO_RX);
FPRINTF((stderr, "receiveDataAvailable(%d) -> false [aioHandle is set]\n", SOCKET(s)));
return false;
}
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 --- */
}
}
/* write data to the UDP socket s from buf for at most bufSize bytes.
* answer the number of bytes actually written.
*/
sqInt sqSockettoHostportSendDataBufCount(SocketPtr s, sqInt address, sqInt port, char *buf, sqInt bufSize)
{
if (socketValid(s) && (TCPSocketType != s->socketType))
{
struct sockaddr_in saddr;
FPRINTF((stderr, "sendTo(%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(address);
{
int nsent= sendto(SOCKET(s), buf, bufSize, 0, (struct sockaddr *)&saddr, sizeof(saddr));
if (nsent >= 0)
return nsent;
if (errno == EWOULDBLOCK) /* asynchronous write in progress */
return 0;
FPRINTF((stderr, "UDP send failed\n"));
SOCKETERROR(s)= errno;
}
}
interpreterProxy->success(false);
return 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);
}
/* read data from the UDP socket s into buf for at most bufSize bytes.
answer the number of bytes actually read.
*/
sqInt sqSocketReceiveUDPDataBufCountaddressportmoreFlag(SocketPtr s, char *buf, sqInt bufSize, sqInt *address, sqInt *port, sqInt *moreFlag)
{
if (socketValid(s) && (TCPSocketType != s->socketType))
{
struct sockaddr_in saddr;
socklen_t addrSize= sizeof(saddr);
FPRINTF((stderr, "recvFrom(%d)\n", SOCKET(s)));
memset(&saddr, 0, sizeof(saddr));
{
int nread= recvfrom(SOCKET(s), buf, bufSize, 0, (struct sockaddr *)&saddr, &addrSize);
if (nread >= 0)
{
*address= ntohl(saddr.sin_addr.s_addr);
*port= ntohs(saddr.sin_port);
return nread;
}
if (errno == EWOULDBLOCK) /* asynchronous read in progress */
return 0;
SOCKETERROR(s)= errno;
FPRINTF((stderr, "receiveData(%d)= %da\n", SOCKET(s), 0));
}
}
interpreterProxy->success(false);
return 0;
}
/*
* Verify that closing a connecting socket before it is accepted will result in
* no activity on the accepting side later.
*/
void
test_connect_close(const struct socket_test_info *info)
{
int server_sd, client_sd, sd, on;
struct sockaddr_storage addr;
socklen_t len;
debug("entering test_connect_close()");
SOCKET(server_sd, info->domain, info->type, 0);
on = 1;
(void)setsockopt(server_sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (bind(server_sd, info->serveraddr, info->serveraddrlen) == -1)
test_fail("bind() should have worked");
if (info->callback_set_listen_opt != NULL)
info->callback_set_listen_opt(server_sd);
if (listen(server_sd, 8) == -1)
test_fail("listen() should have worked");
fcntl(server_sd, F_SETFL, fcntl(server_sd, F_GETFL) | O_NONBLOCK);
check_select(server_sd, 0 /*read*/, 1 /*write*/, 0 /*block*/);
SOCKET(client_sd, info->domain, info->type, 0);
fcntl(client_sd, F_SETFL, fcntl(client_sd, F_GETFL) | O_NONBLOCK);
if (connect(client_sd, info->clientaddr, info->clientaddrlen) != -1 ||
errno != EINPROGRESS)
test_fail("connect() should have yielded EINPROGRESS");
check_select_cond(client_sd, 0 /*read*/, 0 /*write*/, 0 /*block*/,
!info->ignore_select_delay);
check_select_cond(server_sd, 1 /*read*/, 1 /*write*/, 0 /*block*/,
!info->ignore_select_delay);
close(client_sd);
check_select_cond(server_sd, 0 /*read*/, 1 /*write*/, 0 /*block*/,
!info->ignore_select_delay);
len = sizeof(addr);
errno = 0;
if ((sd = accept(server_sd, (struct sockaddr *) &addr, &len)) != -1) {
if (!info->ignore_accept_delay) {
test_fail("accept() should have failed");
}
close(sd);
} else if (errno != EAGAIN) {
test_fail("accept() should have yielded EAGAIN");
}
close(server_sd);
info->callback_cleanup();
debug("leaving test_connect_close()");
}
void sqSocketAbortConnection(SocketPtr s)
{
FPRINTF((stderr, "abortConnection(%d)\n", SOCKET(s)));
if (!socketValid(s))
return;
setLinger(SOCKET(s), 0);
sqSocketCloseConnection(s);
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_socket( obj_t o, obj_t op ) {
if( BGL_SOCKET_UNIXP( o ) ) {
PRINTF1( op,
40 + (STRINGP( SOCKET( o ).hostname ) ?
STRING_LENGTH( SOCKET( o ).hostname ) :
sizeof( "localhost" )),
"#<unix-socket:%s>",
STRINGP( SOCKET( o ).hostname ) ?
BSTRING_TO_STRING( SOCKET( o ).hostname ) :
"localhost" );
} else {
PRINTF2( op,
40 + (STRINGP( SOCKET( o ).hostname ) ?
STRING_LENGTH( SOCKET( o ).hostname ) :
sizeof( "localhost" )),
"#<socket:%s.%d>",
STRINGP( SOCKET( o ).hostname ) ?
BSTRING_TO_STRING( SOCKET( o ).hostname ) :
"localhost",
SOCKET( o ).portnum );
}
return op;
}
sqInt sqSocketSendDone(SocketPtr s)
{
if (!socketValid(s))
return false;
if (SOCKETSTATE(s) == Connected)
{
if (socketWritable(SOCKET(s))) return true;
aioHandle(SOCKET(s), dataHandler, AIO_WX);
}
return false;
}
void test_shutdown(const struct socket_test_info *info)
{
int how[3] = { SHUT_RD, SHUT_WR, SHUT_RDWR };
int sd;
int rc;
int i;
debug("entering test_shutdown()");
/* test for each direction (read, write, read-write) */
for (i = 0; i < 3; i++) {
debug("test shutdown() with an invalid descriptor");
errno = 0;
rc = shutdown(-1, how[i]);
if (!(rc == -1 && errno == EBADF)) {
test_fail("shutdown(-1, how[i]) should have failed");
}
debug("test shutdown() with a non-socket descriptor");
errno = 0;
rc = shutdown(0, how[i]);
if (!(rc == -1 && errno == ENOTSOCK)) {
test_fail("shutdown() should have failed with "
"ENOTSOCK");
}
debug("test shutdown() with a socket that is not connected");
SOCKET(sd, info->domain, info->type, 0);
errno = 0;
rc = shutdown(sd, how[i]);
if (rc != 0 && !(rc == -1 && errno == ENOTCONN)) {
test_fail("shutdown() should have failed");
}
CLOSE(sd);
}
SOCKET(sd, info->domain, info->type, 0);
errno = 0;
rc = shutdown(sd, -1);
if (!(rc == -1 && errno == EINVAL)) {
test_fail("shutdown(sd, -1) should have failed with EINVAL");
}
CLOSE(sd);
debug("leaving test_shutdown()");
}
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;
}
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);
}
bool TcpServer::init(int port_num)
{
int rc;
bool rtn;
const int reuse_addr = 1;
//int err;
SOCKLEN_T addrSize = 0;
rc = SOCKET(AF_INET, SOCK_STREAM, 0);
if (this->SOCKET_FAIL != rc)
{
this->setSrvrHandle(rc);
LOG_DEBUG("Socket created, rc: %d", rc);
LOG_DEBUG("Socket handle: %d", this->getSrvrHandle());
SET_REUSE_ADDR(this->getSrvrHandle(), reuse_addr);
// Initialize address data structure
memset(&this->sockaddr_, 0, sizeof(this->sockaddr_));
this->sockaddr_.sin_family = AF_INET;
this->sockaddr_.sin_addr.s_addr = INADDR_ANY;
this->sockaddr_.sin_port = HTONS(port_num);
addrSize = sizeof(this->sockaddr_);
rc = BIND(this->getSrvrHandle(), (sockaddr *)&(this->sockaddr_), addrSize);
if (this->SOCKET_FAIL != rc)
{
LOG_INFO("Server socket successfully initialized");
rc = LISTEN(this->getSrvrHandle(), 1);
if (this->SOCKET_FAIL != rc)
{
LOG_INFO("Socket in listen mode");
rtn = true;
}
else
{
LOG_ERROR("Failed to set socket to listen");
rtn = false;
}
}
else
{
LOG_ERROR("Failed to bind socket, rc: %d", rc);
CLOSE(this->getSrvrHandle());
rtn = false;
}
}
else
{
LOG_ERROR("Failed to create socket, rc: %d", rc);
rtn = false;
}
return rtn;
}
ByteQueue UDPSocket::recv(Address& address) {
ByteQueue data;
#ifdef _WIN32
fd_set fds;
timeval timeout;
FD_ZERO(&fds);
FD_SET(sd, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if (select(0, &fds, nullptr, nullptr, &timeout) > 0) {
SOCKADDR_IN addr;
int addrsize = sizeof(SOCKADDR_IN);
data.resize(maxlen);
data.resize(uint32_t(recvfrom(SOCKET(sd), (char*)data.ptr(), maxlen, 0, (SOCKADDR*)&addr, &addrsize)));
address = Address(addr.sin_addr.S_un.S_addr, addr.sin_port);
}
#else
fd_set fds;
timeval timeout;
FD_ZERO(&fds);
FD_SET(sd, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if (select(sd + 1, &fds, nullptr, nullptr, &timeout) > 0) {
sockaddr_in addr;
socklen_t addrsize = sizeof(sockaddr_in);
data.resize(maxlen);
data.resize(uint32_t(recvfrom(sd, data.ptr(), maxlen, 0, (sockaddr*)&addr, &addrsize)));
address = Address(addr.sin_addr.s_addr, addr.sin_port);
}
#endif
return data;
}
int register_mtd(client_handle_t handle, mtd_reg_t *reg)
{
memory_handle_t list;
socket_info_t *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
s = SOCKET(handle);
if (reg->Attributes & REGION_TYPE_AM)
list = s->a_region;
else
list = s->c_region;
DEBUG(1, "cs: register_mtd(0x%p, '%s', 0x%x)\n",
handle, handle->dev_info, reg->Offset);
while (list) {
if (list->info.CardOffset == reg->Offset) break;
list = list->info.next;
}
if (list && (list->mtd == NULL) &&
(strcmp(handle->dev_info, list->dev_info) == 0)) {
list->info.Attributes = reg->Attributes;
list->MediaID = reg->MediaID;
list->mtd = handle;
handle->mtd_count++;
return CS_SUCCESS;
} else
return CS_BAD_OFFSET;
} /* register_mtd */
void test_getsockname(const struct socket_test_info *info)
{
int sd;
int rc;
int on;
struct sockaddr_storage sock_addr;
socklen_t sock_addr_len;
SOCKET(sd, info->domain, info->type, 0);
on = 1;
(void)setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
rc = bind(sd, info->serveraddr, info->serveraddrlen);
if (rc == -1) {
test_fail("bind() should have worked");
}
debug("Test getsockname() success");
memset(&sock_addr, '\0', sizeof(sock_addr));
sock_addr_len = sizeof(sock_addr);
rc = getsockname(sd, (struct sockaddr *) &sock_addr, &sock_addr_len);
if (rc == -1) {
test_fail("getsockname() should have worked");
}
info->callback_check_sockaddr((struct sockaddr *) &sock_addr,
sock_addr_len, "getsockname", 1);
CLOSE(sd);
}
IoObject *IoSocket_asyncStreamRead(IoSocket *self, IoObject *locals, IoMessage *m)
{
/*doc Socket asyncStreamRead(aSeq, readSize)
Reads up to readSize number of bytes into aSeq if data is available.
Returns self immediately if successful. Returns an error object on Error. Returns nil if the socket is disconnected.
*/
IoSeq *bufferSeq = IoMessage_locals_mutableSeqArgAt_(m, locals, 0);
UArray *buffer = IoSeq_rawUArray(bufferSeq);
size_t readSize = IoMessage_locals_intArgAt_(m, locals, 1);
if (Socket_streamRead(SOCKET(self), buffer, readSize))
{
return self;
}
if (Socket_asyncFailed())
{
IoSocket_close(self, locals, m);
return SOCKETERROR("Socket stream read failed");
}
//if (readSize == 0) //SocketErrorStatus() == 0)
if (SocketErrorStatus() == 0)
{
// 0 bytes means the other end disconnected
//printf("SocketErrorStatus() == 0, closing\n");
IoSocket_close(self, locals, m);
}
return IONIL(self);
}
int main(int argc,char *argv[]){
int sock,newsock;
int portNum,pid;
socklen_t clientLen;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
char buffer[1000];
if(argc != 2){
printf("ERROR, wrong number of arguments!\n");
printf("./ftps portNumber");
exit(0);
}
sock = SOCKET(AF_INET,SOCK_STREAM,0);
if(sock < 0){
printf("ERROR OPENING SOCKET!");
exit(0);
}
/*Sets up connection for the server */
//portNum = atoi(argv[1]);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = 0;
server_addr.sin_port = htons(SERVERPORT);
if(BIND(sock,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0){
perror("ERROR binding to socket!");
exit(0);
}
receiveFile(sock);
return 0;
}
IoObject *IoSocket_asyncUdpRead(IoSocket *self, IoObject *locals, IoMessage *m)
{
/*doc Socket asyncUdpRead(ipAddress, aSeq, readSize)
Reads up to readSize number of bytes from ipAddress into aSeq if data is available.
Returns self immediately if successful. Returns an error object on Error. Returns nil if the socket is disconnected.
*/
IoObject *address = IoMessage_locals_addressArgAt_(m, locals, 0);
UArray *buffer = IoSeq_rawUArray(IoMessage_locals_mutableSeqArgAt_(m, locals, 1));
size_t readSize = IoMessage_locals_sizetArgAt_(m, locals, 2);
if (Socket_udpRead(SOCKET(self), IoSocket_rawAddressFrom_(address), buffer, readSize))
{
return self;
}
else
{
if (Socket_asyncFailed())
{
return SOCKETERROR("Socket udp read failed");
}
else
{
return IONIL(self);
}
}
}
IoSocket *IoSocket_newWithSocket_(void *state, Socket *socket)
{
IoSocket *self = IoSocket_new(state);
Socket_free(SOCKET(self));
IoObject_setDataPointer_(self, socket);
return self;
}
IoObject *IoSocket_asyncAccept(IoSocket *self, IoObject *locals, IoMessage *m)
{
//doc Socket asyncAccept(addressObject) Immediately returns a socket for a connection if one is available or nil otherwise. Returns an Error object on error.
IoObject *address = IoMessage_locals_addressArgAt_(m, locals, 0);
Socket *socket = Socket_accept(SOCKET(self), IoSocket_rawAddressFrom_(address));
if (socket)
{
IoObject *newSocket = IoSocket_newWithSocket_(IOSTATE, socket);
newSocket = IoObject_initClone_(self, locals, m, newSocket);
return IoSocket_rawSetupEvents(newSocket, locals, m);
}
else
{
if (Socket_asyncFailed())
{
return SOCKETERROR("Socket accept failed");
}
else
{
return IONIL(self);
}
}
}
static void retry_erase(erase_busy_t *busy, u_int cause)
{
eraseq_entry_t *erase = busy->erase;
mtd_request_t req;
client_t *mtd;
socket_info_t *s;
int ret;
DEBUG(2, "cs: trying erase request 0x%p...\n", busy);
if (busy->next)
remove_queue(busy);
req.Function = MTD_REQ_ERASE | cause;
req.TransferLength = erase->Size;
req.DestCardOffset = erase->Offset + erase->Handle->info.CardOffset;
req.MediaID = erase->Handle->MediaID;
mtd = erase->Handle->mtd;
s = SOCKET(mtd);
mtd->event_callback_args.mtdrequest = &req;
wacquire(&mtd->mtd_req);
ret = EVENT(mtd, CS_EVENT_MTD_REQUEST, CS_EVENT_PRI_LOW);
wrelease(&mtd->mtd_req);
if (ret == CS_BUSY) {
DEBUG(2, " Status = %d, requeueing.\n", req.Status);
switch (req.Status) {
case MTD_WAITREQ:
case MTD_WAITPOWER:
insert_queue(&mtd->erase_busy, busy);
break;
case MTD_WAITTIMER:
case MTD_WAITRDY:
if (req.Status == MTD_WAITRDY)
insert_queue(&s->erase_busy, busy);
mod_timer(&busy->timeout, jiffies + req.Timeout*HZ/1000);
break;
}
} else {
/* update erase queue status */
DEBUG(2, " Ret = %d\n", ret);
switch (ret) {
case CS_SUCCESS:
erase->State = ERASE_PASSED; break;
case CS_WRITE_PROTECTED:
erase->State = ERASE_MEDIA_WRPROT; break;
case CS_BAD_OFFSET:
erase->State = ERASE_BAD_OFFSET; break;
case CS_BAD_SIZE:
erase->State = ERASE_BAD_SIZE; break;
case CS_NO_CARD:
erase->State = ERASE_BAD_SOCKET; break;
default:
erase->State = ERASE_FAILED; break;
}
busy->client->event_callback_args.info = erase;
EVENT(busy->client, CS_EVENT_ERASE_COMPLETE, CS_EVENT_PRI_LOW);
kfree(busy);
/* Resubmit anything waiting for a request to finish */
wakeup(&mtd->mtd_req);
retry_erase_list(&mtd->erase_busy, 0);
}
} /* retry_erase */
int open_memory(client_handle_t *handle, open_mem_t *open)
{
socket_info_t *s;
memory_handle_t region;
if ((handle == NULL) || CHECK_HANDLE(*handle))
return CS_BAD_HANDLE;
s = SOCKET(*handle);
if (open->Attributes & MEMORY_TYPE_AM)
region = s->a_region;
else
region = s->c_region;
while (region) {
if (region->info.CardOffset == open->Offset) break;
region = region->info.next;
}
#ifdef __BEOS__
if (region->dev_info[0] != '\0') {
char n[80];
struct module_info *m;
sprintf(n, MTD_MODULE_NAME("%s"), region->dev_info);
if (get_module(n, &m) != B_OK)
dprintf("cs: could not find MTD module %s\n", n);
}
#endif
if (region && region->mtd) {
*handle = (client_handle_t)region;
DEBUG(1, "cs: open_memory(0x%p, 0x%x) = 0x%p\n",
handle, open->Offset, region);
return CS_SUCCESS;
} else
return CS_BAD_OFFSET;
} /* open_memory */
bool UdpClient::init(char *buff, int port_num)
{
int rc;
bool rtn;
/* Create a socket using:
* AF_INET - IPv4 internet protocol
* SOCK_DGRAM - UDP type
* protocol (0) - System chooses
*/
rc = SOCKET(AF_INET, SOCK_DGRAM, 0);
if (this->SOCKET_FAIL != rc)
{
this->setSockHandle(rc);
// Initialize address data structure
memset(&this->sockaddr_, 0, sizeof(this->sockaddr_));
this->sockaddr_.sin_family = AF_INET;
this->sockaddr_.sin_addr.s_addr = INET_ADDR(buff);
this->sockaddr_.sin_port = HTONS(port_num);
rtn = true;
}
else
{
LOG_ERROR("Failed to create socket, rc: %d", rc);
rtn = false;
}
return rtn;
}
void test_dup2(const struct socket_test_info *info)
{
struct stat info1;
struct stat info2;
int sd;
int fd;
int rc;
int on;
debug("entering test_dup2()");
info->callback_cleanup();
SOCKET(sd, info->domain, info->type, 0);
on = 1;
(void)setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
rc = bind(sd, info->serveraddr, info->serveraddrlen);
if (rc != 0) {
test_fail("bind() should have worked");
}
fd = open("/dev/null", O_RDONLY);
if (fd == -1) {
test_fail("open(\"/dev/null\", O_RDONLY) failed");
}
fd = dup2(sd, fd);
if (fd == -1) {
test_fail("dup2(sd, fd) failed.");
}
memset(&info1, '\0', sizeof(struct stat));
memset(&info2, '\0', sizeof(struct stat));
rc = fstat(fd, &info1);
if (rc == -1) {
test_fail("fstat(fd, &info1) failed");
}
rc = fstat(sd, &info2);
if (rc == -1) {
test_fail("fstat(sd, &info2) failed");
}
if (!(info1.st_ino == info2.st_ino &&
major(info1.st_dev) == major(info2.st_dev) &&
minor(info1.st_dev) == minor(info2.st_dev))) {
test_fail("dup2() failed");
}
CLOSE(fd);
CLOSE(sd);
info->callback_cleanup();
debug("leaving test_dup2()");
}
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! */
}
int pcmcia_get_tuple_data(client_handle_t handle, tuple_t *tuple)
{
struct pcmcia_socket *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
s = SOCKET(handle);
return pccard_get_tuple_data(s, tuple);
}
IoObject *IoSocket_setSocketWriteBufferSize(IoSocket *self, IoObject *locals, IoMessage *m)
{
//doc Socket setSocketWriteBufferSize(numberOfBytes) Sets the write buffer size for the socket. Returns self on success or nil on error.
int size = IoMessage_locals_intArgAt_(m, locals, 0);
int r = setsockopt(SOCKET(self)->fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(int));
return (r == 0) ? self : IONIL(self);
}
int pcmcia_validate_cis(client_handle_t handle, cisinfo_t *info)
{
struct pcmcia_socket *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
s = SOCKET(handle);
return pccard_validate_cis(s, handle->Function, info);
}
int pcmcia_get_next_tuple(client_handle_t handle, tuple_t *tuple)
{
struct pcmcia_socket *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
s = SOCKET(handle);
return pccard_get_next_tuple(s, handle->Function, tuple);
}
