PRInt32 _MD_closesocket(PRInt32 osfd)
{
OSStatus err;
EndpointRef endpoint = (EndpointRef) osfd;
PRThread *me = _PR_MD_CURRENT_THREAD();
if (endpoint == NULL) {
err = kEBADFErr;
goto ErrorExit;
}
if (me->io_pending && me->io_fd == osfd)
me->io_pending = PR_FALSE;
#if 0
{
OTResult state;
state = OTGetEndpointState(endpoint);
err = OTSndOrderlyDisconnect(endpoint);
if (err != kOTNoError && err != kOTOutStateErr)
goto ErrorExit;
state = OTGetEndpointState(endpoint);
err = OTUnbind(endpoint);
if (err != kOTNoError && err != kOTOutStateErr)
goto ErrorExit;
state = OTGetEndpointState(endpoint);
err = OTSetSynchronous(endpoint);
if (err != kOTNoError)
goto ErrorExit;
err = OTSetBlocking(endpoint);
if (err != kOTNoError)
goto ErrorExit;
}
#endif
(void) OTSndOrderlyDisconnect(endpoint);
err = OTCloseProvider(endpoint);
if (err != kOTNoError)
goto ErrorExit;
return kOTNoError;
ErrorExit:
macsock_map_error(err);
return -1;
}
/* Open a UDP network socket
If 'port' is non-zero, the UDP socket is bound to a fixed local port.
*/
extern UDPsocket SDLNet_UDP_Open(Uint16 port)
{
UDPsocket sock;
#ifdef MACOS_OPENTRANSPORT
EndpointRef dummy = NULL;
#endif
/* Allocate a UDP socket structure */
sock = (UDPsocket)malloc(sizeof(*sock));
if ( sock == NULL ) {
SDLNet_SetError("Out of memory");
goto error_return;
}
memset(sock, 0, sizeof(*sock));
/* Open the socket */
#ifdef MACOS_OPENTRANSPORT
{
sock->error = OTAsyncOpenEndpoint(
OTCreateConfiguration(kUDPName),0, &(sock->info),
(OTNotifyProcPtr)AsyncUDPNotifier, sock );
AsyncUDPPopEvent( sock );
while( !sock->error && !( sock->completion & CompleteMask(T_OPENCOMPLETE)))
{
AsyncUDPPopEvent( sock );
}
if( sock->error )
{
SDLNet_SetError("Could not open UDP socket");
goto error_return;
}
// Should we ??
// (01/05/03 minami<*****@*****.**>
OTSetBlocking( sock->channel );
}
#else
sock->channel = socket(AF_INET, SOCK_DGRAM, 0);
#endif /* MACOS_OPENTRANSPORT */
if ( sock->channel == INVALID_SOCKET )
{
SDLNet_SetError("Couldn't create socket");
goto error_return;
}
#ifdef MACOS_OPENTRANSPORT
{
InetAddress required, assigned;
TBind req_addr, assigned_addr;
OSStatus status;
InetInterfaceInfo info;
memset(&assigned_addr, 0, sizeof(assigned_addr));
assigned_addr.addr.maxlen = sizeof(assigned);
assigned_addr.addr.len = sizeof(assigned);
assigned_addr.addr.buf = (UInt8 *) &assigned;
if ( port ) {
status = OTInetGetInterfaceInfo( &info, kDefaultInetInterface );
if( status != kOTNoError )
goto error_return;
OTInitInetAddress(&required, port, info.fAddress );
req_addr.addr.maxlen = sizeof( required );
req_addr.addr.len = sizeof( required );
req_addr.addr.buf = (UInt8 *) &required;
sock->error = OTBind(sock->channel, &req_addr, &assigned_addr);
} else {
sock->error = OTBind(sock->channel, nil, &assigned_addr );
}
AsyncUDPPopEvent(sock);
while( !sock->error && !(sock->completion & CompleteMask(T_BINDCOMPLETE)))
{
AsyncUDPPopEvent(sock);
}
if (sock->error != noErr)
{
SDLNet_SetError("Couldn't bind to local port, OTBind() = %d",(int) status);
goto error_return;
}
sock->address.host = assigned.fHost;
sock->address.port = assigned.fPort;
#ifdef DEBUG_NET
printf("UDP open host = %d, port = %d\n", assigned.fHost, assigned.fPort );
#endif
}
#else
/* Bind locally, if appropriate */
if ( port )
{
struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_addr.s_addr = INADDR_ANY;
sock_addr.sin_port = SDL_SwapBE16(port);
/* Bind the socket for listening */
if ( bind(sock->channel, (struct sockaddr *)&sock_addr,
sizeof(sock_addr)) == SOCKET_ERROR ) {
SDLNet_SetError("Couldn't bind to local port");
goto error_return;
}
/* Fill in the channel host address */
sock->address.host = sock_addr.sin_addr.s_addr;
sock->address.port = sock_addr.sin_port;
}
/* Allow LAN broadcasts with the socket */
{ int yes = 1;
setsockopt(sock->channel, SOL_SOCKET, SO_BROADCAST, (char*)&yes, sizeof(yes));
}
#endif /* MACOS_OPENTRANSPORT */
/* The socket is ready */
return(sock);
error_return:
#ifdef MACOS_OPENTRANSPORT
if( dummy )
OTCloseProvider( dummy );
#endif
SDLNet_UDP_Close(sock);
return(NULL);
}
/* Open a TCP network socket
If 'remote' is NULL, this creates a local server socket on the given port,
otherwise a TCP connection to the remote host and port is attempted.
The newly created socket is returned, or NULL if there was an error.
( re-written by masahiro minami<*****@*****.**>
Now endpoint is created in Async mode.
01/02/20 )
*/
TCPsocket SDLNet_TCP_Open(IPaddress *ip)
{
EndpointRef dummy = NULL;
TCPsocket sock = AsyncTCPNewSocket();
if( ! sock)
return NULL;
// Determin whether bind locally, or connect to remote
if ( (ip->host != INADDR_NONE) && (ip->host != INADDR_ANY) )
{
// ######## Connect to remote
OTResult stat;
InetAddress inAddr;
TBind bindReq;
// Open endpoint
sock->error = OTAsyncOpenEndpoint(
OTCreateConfiguration(kTCPName), NULL, &(sock->info),
(OTNotifyProcPtr)(AsyncTCPNotifier),
sock );
AsyncTCPPopEvent( sock );
while( !sock->error && !( sock->completion & CompleteMask(T_OPENCOMPLETE)))
{
//SetThreadState( kCurrentThreadID, kReadyThreadState, kNoThreadID );
//YieldToAnyThread();
//WaitNextEvent(everyEvent, &macEvent, 1, NULL);
AsyncTCPPopEvent( sock );
}
if( !sock->channel )
{
SDLNet_SetError("OTAsyncOpenEndpoint failed --- client socket could not be opened");
goto error_return;
}
// Set blocking mode
// I'm not sure if this is a good solution....
// Check out Apple's sample code, OT Virtual Server
// ( 010314 masahiro minami<*****@*****.**>)
sock->error = OTSetBlocking( sock->channel );
if( sock->error != kOTNoError )
{
SDLNet_SetError("OTSetBlocking() returned an error");
goto error_return;
}
// Bind the socket
OTInitInetAddress(&inAddr, 0, 0 );
bindReq.addr.len = sizeof( InetAddress );
bindReq.addr.buf = (unsigned char*)&inAddr;
bindReq.qlen = 0;
sock->error = OTBind( sock->channel, &bindReq, NULL );
AsyncTCPPopEvent(sock);
while( !sock->error && !( sock->completion & CompleteMask(T_BINDCOMPLETE)))
{
//YieldToAnyThread();
//WaitNextEvent(everyEvent, &macEvent, 1, NULL);
AsyncTCPPopEvent(sock);
}
switch( stat = OTGetEndpointState( sock->channel ))
{
InetAddress inAddr;
TCall sndCall;
OTResult res;
case T_OUTCON:
SDLNet_SetError("SDLNet_Open() failed -- T_OUTCON");
goto error_return;
break;
case T_IDLE:
sock->readShutdown = false;
sock->writeShutdown = false;
sock->event &=~T_CONNECT;
OTMemzero(&sndCall, sizeof(TCall));
OTInitInetAddress(&inAddr, ip->port, ip->host );
sndCall.addr.len = sizeof(InetAddress);
sndCall.addr.buf = (unsigned char*)&inAddr;
sock->connected = 0;
res = OTConnect( sock->channel, &sndCall, NULL );
AsyncTCPPopEvent(sock);
while( sock->error == kOTNoDataErr || !sock->connected )
AsyncTCPPopEvent(sock);
break;
default:
// What's to be done ? (TODO)
SDLNet_SetError("SDLNet_TCP_Open() failed -- EndpointState not good");
goto error_return;
}
if( !(sock->event & (T_CONNECT|T_DISCONNECT)))
goto error_return;
AsyncTCPPopEvent( sock );
while( !(sock->event & (T_CONNECT|T_DISCONNECT)))
{
AsyncTCPPopEvent( sock );
}
// OTConnect successfull
if( sock->event & T_CONNECT)
{
sock->remoteAddress.host = inAddr.fHost;
sock->remoteAddress.port = inAddr.fPort;
sock->sflag = false;
}
else
{
// OTConnect failed
sock->event &= ~T_DISCONNECT;
goto error_return;
}
}
else
{
// ######## Bind locally
TBind bindReq;
InetAddress inAddr;
// First, get InetInterfaceInfo.
// I don't search for all of them.
// Does that matter ?
sock->error = OTAsyncOpenEndpoint(
OTCreateConfiguration("tilisten, tcp"), NULL, &(sock->info),
(OTNotifyProcPtr)(AsyncTCPNotifier),
sock);
AsyncTCPPopEvent( sock );
while( !sock->error && !( sock->completion & CompleteMask( T_OPENCOMPLETE)))
{
AsyncTCPPopEvent( sock );
}
if( ! sock->channel )
{
SDLNet_SetError("OTAsyncOpenEndpoint failed --- server socket could not be opened");
goto error_return;
}
// Create a master OTConfiguration
sock->config = OTCreateConfiguration(kTCPName);
if( ! sock->config )
{
SDLNet_SetError("Could not create master OTConfiguration");
goto error_return;
}
// Bind the socket
OTInitInetAddress(&inAddr, ip->port, 0 );
inAddr.fAddressType = AF_INET;
bindReq.addr.len = sizeof( InetAddress );
bindReq.addr.buf = (unsigned char*)&inAddr;
bindReq.qlen = 35; // This number is NOT well considered. (TODO)
sock->localAddress.host = inAddr.fHost;
sock->localAddress.port = inAddr.fPort;
sock->sflag = true;
sock->error = OTBind( sock->channel, &bindReq, NULL );
AsyncTCPPopEvent(sock);
while( !sock->error && !( sock->completion & CompleteMask(T_BINDCOMPLETE)))
{
AsyncTCPPopEvent(sock);
}
if( sock->error != kOTNoError )
{
SDLNet_SetError("Could not bind server socket");
goto error_return;
}
if( dummy )
OTCloseProvider( dummy );
}
sock->ready = 0;
return sock;
error_return:
if( dummy )
OTCloseProvider( dummy );
SDLNet_TCP_Close( sock );
return NULL;
}
int connect_chuukei_server(char *prf_name)
{
#ifndef MACINTOSH
#ifdef WINDOWS
WSADATA wsaData;
WORD wVersionRequested = (WORD) (( 1) | ( 1 << 8));
#endif
struct sockaddr_in ask;
struct hostent *hp;
if (read_chuukei_prf(prf_name) < 0)
{
printf("Wrong prf file\n");
return (-1);
}
if (init_buffer() < 0)
{
printf("Malloc error\n");
return (-1);
}
#ifdef WINDOWS
if (WSAStartup(wVersionRequested, &wsaData))
{
msg_print("Report: WSAStartup failed.");
return (-1);
}
#endif
printf("server = %s\nport = %d\n", server_name, server_port);
if ((hp = gethostbyname(server_name)) != NULL)
{
memset(&ask, 0, sizeof(ask));
memcpy(&ask.sin_addr, hp->h_addr_list[0], hp->h_length);
}
else
{
if ((ask.sin_addr.s_addr=inet_addr(server_name)) == 0)
{
printf("Bad hostname\n");
return (-1);
}
}
ask.sin_family = AF_INET;
ask.sin_port = htons((unsigned short)server_port);
#ifndef WINDOWS
if ((sd=socket(PF_INET,SOCK_STREAM, 0)) < 0)
#else
if ((sd=socket(PF_INET,SOCK_STREAM, 0)) == INVALID_SOCKET)
#endif
{
printf("Can't create socket\n");
return (-1);
}
if (connect(sd, (struct sockaddr *)&ask, sizeof(ask)) < 0)
{
close(sd);
printf("Can't connect %s port %d\n", server_name, server_port);
return (-1);
}
return (0);
#else /* MACINTOSH */
OSStatus err;
InetHostInfo response;
InetHost host_addr;
InetAddress inAddr;
TCall sndCall;
Boolean bind = false;
OSStatus junk;
if (read_chuukei_prf(prf_name) < 0){
printf("Wrong prf file\n");
return (-1);
}
init_buffer();
printf("server = %s\nport = %d\n", server_name, server_port);
#if TARGET_API_MAC_CARBON
err = InitOpenTransportInContext(kInitOTForApplicationMask, NULL);
#else
err = InitOpenTransport();
#endif
memset(&response, 0, sizeof(response));
#if TARGET_API_MAC_CARBON
inet_services = OTOpenInternetServicesInContext(kDefaultInternetServicesPath, 0, &err, NULL);
#else
inet_services = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
#endif
if (err == noErr) {
err = OTInetStringToAddress(inet_services, (char *)server_name, &response);
if (err == noErr) {
host_addr = response.addrs[0];
} else {
printf("Bad hostname\n");
}
#if TARGET_API_MAC_CARBON
ep = (void *)OTOpenEndpointInContext(OTCreateConfiguration(kTCPName), 0, nil, &err, NULL);
#else
ep = (void *)OTOpenEndpoint(OTCreateConfiguration(kTCPName), 0, nil, &err);
#endif
if (err == noErr) {
err = OTBind(ep, nil, nil);
bind = (err == noErr);
}
if (err == noErr){
OTInitInetAddress(&inAddr, server_port, host_addr);
sndCall.addr.len = sizeof(InetAddress);
sndCall.addr.buf = (unsigned char*) &inAddr;
sndCall.opt.buf = nil; /* no connection options */
sndCall.opt.len = 0;
sndCall.udata.buf = nil; /* no connection data */
sndCall.udata.len = 0;
sndCall.sequence = 0; /* ignored by OTConnect */
err = OTConnect(ep, &sndCall, NULL);
if( err != noErr ){
printf("Can't connect %s port %d\n", server_name, server_port);
}
}
err = OTSetSynchronous(ep);
if (err == noErr)
err = OTSetBlocking(ep);
}
if( err != noErr ){
if( bind ){
OTUnbind(ep);
}
/* Clean up. */
if (ep != kOTInvalidEndpointRef) {
OTCloseProvider(ep);
ep = nil;
}
if (inet_services != nil) {
OTCloseProvider(inet_services);
inet_services = nil;
}
return -1;
}
return 0;
#endif
}
