static int LookUpInetHost(char *name, InetHost *result) {
OSStatus err;
// If the hostname is dots and numbers, like "128.32.122.13", we don't neet DNR
err = OTInetStringToHost(name, result);
if (err != noErr) {
// We do need DNR.
InetSvcRef tcpipProvider;
InetHostInfo hinfo;
tcpipProvider = OTOpenInternetServicesInContext(kDefaultInternetServicesPath, 0, &err, OTContext);
if (err != noErr) {
error("¥ otudp: Error %d from OTOpenInternetServices().", err);
return 0;
}
err = OTInetStringToAddress(tcpipProvider, name, &hinfo);
OTCloseProvider(tcpipProvider);
if (err == kOTBadNameErr) {
error("¥ otudp: Bad host name \"%s\"; not changing.", name);
} else if (err != noErr) {
error("¥ otudp: Error %d from OTInetStringToAddress; not changing host.", err);
return 0;
}
*result = hinfo.addrs[0];
}
return 1;
}
int GSocket_Verify_Inited()
{
OSStatus err ;
#if TARGET_CARBON
// Marc Newsam: added the clientcontext variable
// however, documentation is unclear how this works
OTClientContextPtr clientcontext;
if ( gInetSvcRef )
return TRUE ;
InitOpenTransportInContext(kInitOTForApplicationMask, &clientcontext);
gOTInited = 1 ;
gInetSvcRef = OTOpenInternetServicesInContext(kDefaultInternetServicesPath,
NULL, &err, clientcontext);
#else
if ( gInetSvcRef )
return TRUE ;
InitOpenTransport() ;
gOTInited = 1 ;
gInetSvcRef = OTOpenInternetServices(kDefaultInternetServicesPath, NULL, &err);
#endif
if ( gInetSvcRef == NULL || err != kOTNoError )
{
OTAssert("Could not open Inet Services", err == noErr);
return FALSE ;
}
gOTNotifierUPP = NewOTNotifyUPP( OTInetEventHandler ) ;
return TRUE ;
}
OSStatus ot_DNRInit(void)
{
OSStatus theError = kOTNoError;
// First, check to see if we've already initialized. If so, then just return...
if( gDNRep != kOTInvalidProviderRef){
return (kOTNoError);
}
// Next, check to see if any OT service has been used yet
if (!gOTInited){
theError = ot_OpenDriver();
}
// Get the internet services reference for DNS
if( theError == kOTNoError){
#if TARGET_API_MAC_CARBON
gDNRep = OTOpenInternetServicesInContext( kDefaultInternetServicesPath, 0, &theError, NULL);
#else
gDNRep = OTOpenInternetServices( kDefaultInternetServicesPath, 0, &theError);
#endif
}
/* We have to choose to be synchronous or async, sync is simpler but
* I think that async could be done in the future
*/
if( theError == kOTNoError){
theError = OTSetSynchronous( gDNRep);
}
// Give OT a pointer to a notifier function that handles async events
if( theError == kOTNoError){
gDNRYieldNotifyUPP = NewOTNotifyUPP(DNRYieldNotifier);
theError = OTInstallNotifier(gDNRep, gDNRYieldNotifyUPP, nil);
}
/* If we get idle events, then implementing a multi-threaded app shouldn't
* be any big deal
*/
if( theError == kOTNoError){
theError = OTUseSyncIdleEvents(gDNRep, true);
}
return( theError);
}
static OSStatus OpenTest(void)
{
OSStatus err;
OSStatus junk;
EndpointRef ep1;
EndpointRef ep2;
MapperRef map1;
MapperRef map2;
ATSvcRef at1;
ATSvcRef at2;
InetSvcRef inet1;
InetSvcRef inet2;
ProviderRef prov1;
ProviderRef prov2;
ep1 = NULL;
ep2 = NULL;
map1 = NULL;
map2 = NULL;
at1 = NULL;
at2 = NULL;
inet1 = NULL;
inet2 = NULL;
prov1 = NULL;
prov2 = NULL;
ep1 = OTOpenEndpointInContext(OTCreateConfiguration("tcp"), 0, NULL, &err, NULL);
if (err == noErr) {
err = OTAsyncOpenEndpointInContext(OTCreateConfiguration("tcp"), 0, NULL, DummyNotifier, &ep2, NULL);
if (err == noErr) {
while (ep2 == NULL) {
SystemTask();
}
if (ep2 == (void *) -1) {
err = -1;
}
}
}
if (err == noErr) {
map1 = OTOpenMapperInContext(OTCreateConfiguration("nbp"), 0, &err, NULL);
}
if (err == noErr) {
err = OTAsyncOpenMapperInContext(OTCreateConfiguration("nbp"), 0, DummyNotifier, &map2, NULL);
if (err == noErr) {
while (map2 == NULL) {
SystemTask();
}
if (map2 == (void *) -1) {
err = -1;
}
}
}
if (err == noErr) {
inet1 = OTOpenInternetServicesInContext(kDefaultInternetServicesPath, 0, &err, NULL);
}
if (err == noErr) {
err = OTAsyncOpenInternetServicesInContext(kDefaultInternetServicesPath, 0, DummyNotifier, &inet2, NULL);
if (err == noErr) {
while (inet2 == NULL) {
SystemTask();
}
if (inet2 == (void *) -1) {
err = -1;
}
}
}
if (err == noErr) {
at1 = OTOpenAppleTalkServicesInContext(kDefaultAppleTalkServicesPath, 0, &err, NULL);
}
if (err == noErr) {
err = OTAsyncOpenAppleTalkServicesInContext(kDefaultAppleTalkServicesPath, 0, DummyNotifier, &at2, NULL);
if (err == noErr) {
while (at2 == NULL) {
SystemTask();
}
if (at2 == (void *) -1) {
err = -1;
}
}
}
if (err == noErr) {
prov1 = OTOpenProviderInContext(OTCreateConfiguration("enet"), 0, &err, NULL);
}
if (err == noErr) {
err = OTAsyncOpenProviderInContext(OTCreateConfiguration("enet"), 0, DummyNotifier, &prov2, NULL);
if (err == noErr) {
while (prov2 == NULL) {
SystemTask();
}
if (prov2 == (void *) -1) {
err = -1;
}
}
}
if (ep1 != NULL) {
junk = OTCloseProvider(ep1);
assert(junk == noErr);
}
if (ep2 != NULL) {
junk = OTCloseProvider(ep2);
assert(junk == noErr);
}
if (map1 != NULL) {
junk = OTCloseProvider(map1);
assert(junk == noErr);
}
if (map2 != NULL) {
junk = OTCloseProvider(map2);
assert(junk == noErr);
}
if (at1 != NULL) {
junk = OTCloseProvider(at1);
assert(junk == noErr);
}
if (at2 != NULL) {
junk = OTCloseProvider(at2);
assert(junk == noErr);
}
if (inet1 != NULL) {
junk = OTCloseProvider(inet1);
assert(junk == noErr);
}
if (inet2 != NULL) {
junk = OTCloseProvider(inet2);
assert(junk == noErr);
}
if (prov1 != NULL) {
junk = OTCloseProvider(prov1);
assert(junk == noErr);
}
if (prov2 != NULL) {
junk = OTCloseProvider(prov2);
assert(junk == noErr);
}
return err;
}
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
}
