/* Open Transport helper procedures */
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 = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
if (err != noErr) {
post("е otudp: Error %d from OTOpenInternetServices().", err);
return 0;
}
err = OTInetStringToAddress(tcpipProvider, name, &hinfo);
OTCloseProvider(tcpipProvider);
if (err != noErr) {
post("е otudp: Error %d from OTInetStringToAddress", 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 ;
}
void TCPLow_Create(TCPINSTANCE* pTcp, u_short* port, TCPPEER* peer, int* status)
{
TBind boundAddr;
InetAddress boundInetAddr;
InetInterfaceInfo inetInfo;
OSStatus err;
pTcp->isValid = false;
// Initialize OpenTransport
err = InitOpenTransport();
if (err != noErr) {
*status = comm_STATUS_BAD;
return;
}
// initialize Internet Services
pTcp->inetService = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
if (err != noErr) {
*status = comm_STATUS_BAD;
return;
}
// open an endpoint for sending and recieving data
err = CreateAndConfigUDP(&pTcp->udpEndpoint);
if (err != noErr) {
ShutDownUDP(pTcp->udpEndpoint);
*status = comm_STATUS_BAD;
return;
}
pTcp->isValid = true;
// Get information about Internet
err = OTInetGetInterfaceInfo(&inetInfo, kDefaultInetInterface);
if (err != noErr) {
//DebugStr("\pCannot Get Information About Default Interface");
*status = comm_STATUS_BAD;
ShutDownUDP(pTcp->udpEndpoint);
return;
}
boundAddr.addr.maxlen = sizeof(boundInetAddr);
boundAddr.addr.buf = (unsigned char*) &boundInetAddr;;
err = OTGetProtAddress(pTcp->udpEndpoint,&boundAddr,NULL);
if (err != noErr) {
*status = comm_STATUS_BAD;
ShutDownUDP(pTcp->udpEndpoint);
return;
}
peer->addr = inetInfo.fAddress;
peer->port = *port = boundInetAddr.fPort;
pTcp->myHandle = dcstReplace(pTcp->handles,pTcp->myHandle,peer);
}
OSErr ot_init(void)
{
OSStatus err;
err = InitOpenTransport();
if (err != kOTNoError) return err;
ot.inetsvc = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
return err;
}
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);
}
/*---------------------------------------------------------------------------*/
ExportFunc
sword AGNetInit(AGNetCtx *ctx)
{
OSStatus rc = 0;
if (NULL == ctx)
return AG_NET_ERROR;
rc = InitOpenTransport();
if (noErr == rc) {
AGNetIsInited = 1;
bzero(ctx, sizeof(AGNetCtx));
ctx->inet_services =
OTOpenInternetServices(kDefaultInternetServicesPath,
0,
&rc);
AGNetSetIOFuncs(ctx, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
return rc;
}
void _MD_InitNetAccess()
{
OSErr err;
OSStatus errOT;
PRBool hasOTTCPIP = PR_FALSE;
PRBool hasOT = PR_FALSE;
long gestaltResult;
PRThread *me = _PR_MD_CURRENT_THREAD();
err = Gestalt(gestaltOpenTpt, &gestaltResult);
if (err == noErr)
if (gestaltResult & GESTALT_OPEN_TPT_PRESENT)
hasOT = PR_TRUE;
if (hasOT)
if (gestaltResult & GESTALT_OPEN_TPT_TCP_PRESENT)
hasOTTCPIP = PR_TRUE;
PR_ASSERT(hasOTTCPIP == PR_TRUE);
errOT = InitOpenTransport();
PR_ASSERT(err == kOTNoError);
sSvcRef = OTOpenInternetServices(kDefaultInternetServicesPath, NULL, &errOT);
if (errOT != kOTNoError) return; /* no network -- oh well */
PR_ASSERT((sSvcRef != NULL) && (errOT == kOTNoError));
/* Install notify function for DNR Address To String completion */
errOT = OTInstallNotifier(sSvcRef, NotifierRoutine, me);
PR_ASSERT(errOT == kOTNoError);
/* Put us into async mode */
errOT = OTSetAsynchronous(sSvcRef);
PR_ASSERT(errOT == kOTNoError);
/* XXX Does not handle absence of open tpt and tcp yet! */
}
int
commInit(
commInitReq_t * req, // Request (or NULL)
commInitResp_t * resp) // Response (or NULL)
{
commInitReq_t reqDummy;
commInitResp_t respDummy;
ip_adr_t adr_broadcast;
ip_adr_t *padr;
OSStatus err;
extern Str255 gSavedSelection;
// DebugStr ( "\pcommInit()" );
DPRINT(("@TRUMP commInit(): "));
if (req == NULL)
req = (commInitReq_t *)memset(&reqDummy, 0, sizeof(*req));
if (resp == NULL)
resp = &respDummy;
scratch_flat = malloc(MAX_RAW_PKTLEN);
//scratch_flat = my_dos_malloc(MAX_RAW_PKTLEN, &scratch_seg, &scratch_off, &scratch_selector);
if (!scratch_flat) {
DPRINT(("commInit: couldn't allocate DOS memory!\n"));
resp->status = comm_STATUS_BAD;
return FALSE;
}
// check for the existanct of OpenTransport
if(!OpenTransportExists() || !OpenTransportInetExists()) {
//DebugStr("\pOpen Transport Does Not Exist");
DPRINT(("commInit: UDP ABI not found\n"));
resp->status = comm_STATUS_NETWORK_NOT_PRESENT;
free(scratch_flat);
return FALSE;
}
// Initialize OpenTransport
err = InitOpenTransport();
if (err != noErr) {
resp->status = comm_STATUS_BAD;
free(scratch_flat);
return FALSE;
}
// initialize Internet Services
gInetService = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
if (err != noErr) {
resp->status = comm_STATUS_BAD;
free(scratch_flat);
return FALSE;
}
// open an endpoint for sending and recieving data
err = CreateAndConfigUDP(&gUDPEndpoint);
if (err != noErr) {
resp->status = comm_STATUS_BAD;
free(scratch_flat);
ShutDownUDP();
return FALSE;
}
// create the peer table
peertab = assoctab_create(sizeof(ip_adr_t));
if (!peertab) {
// ABORT! Out of Memory
resp->status = comm_STATUS_BAD;
free(scratch_flat);
ShutDownUDP();
return FALSE;
}
// Get information about the Internet
err = OTInetGetInterfaceInfo(&gInetInfo, kDefaultInetInterface);
if (err != noErr) {
//DebugStr("\pCannot Get Information About Default Interface");
resp->status = comm_STATUS_BAD;
free(scratch_flat);
ShutDownUDP();
return FALSE;
}
// Store our address in the peer table under the bogus ME handle
padr = (ip_adr_t *)assoctab_subscript_grow(peertab, trump_HDL_ME);
if (!padr) {
DPRINT(("commInit: couldn't grow peer table\n"));
resp->status = comm_STATUS_BAD;
free(scratch_flat);
assoctab_destroy(peertab);
ShutDownUDP();
return FALSE;
}
dprint_peertab(peertab);
DPRINT(("commInit: saving handle %d adr %x at %p\n", trump_HDL_ME, gInetInfo.fAddress, padr));
memcpy(padr, &gInetInfo.fAddress, sizeof(ip_adr_t));
dprint_peertab(peertab);
// Open a handle good for receiving packets on the standard port
// SRC = (*,*)
// DEST = (localhost, pt->port)
adr_broadcast = 0xffffffff;
hdl_rx = trump_adr2hdl(adr_broadcast, SOCKET_MW2, SOCKET_MW2, TRUE);
if (hdl_rx == trump_HDL_NONE) {
DPRINT(("commInit: couldn't open handle for listening\n"));
resp->status = comm_STATUS_BUSY;
free(scratch_flat);
assoctab_destroy(peertab);
ShutDownUDP();
return FALSE;
}
/*
if ((req->flags & comm_INIT_FLAGS_RESUME) == 0) {
if (!DoHostListDialog()) {
resp->status = comm_STATUS_EMPTY;
free(scratch_flat);
assoctab_destroy(peertab);
ShutDownUDP();
return FALSE;
}
} else {
// we need to load the last string selected when we are resuming
OpenPrefsFile();
p2cstr(gSavedSelection); // the apps like C-strings
ClosePrefsFile();
}
*/
// initialize our address list to nothing
InitAddressList();
// add our own address to the beginning of the list (it MUST Be the first
// address in our list - we broadcast to all _other_ addresses in our list)
AddAddressToList(gInetInfo.fAddress);
// add the address from the dialog to our broadcast list if the user chose one
if (gSavedSelection[0] != 0) {
InetHostInfo theHostInfo;
OTSetSynchronous(gInetService);
err = OTInetStringToAddress(gInetService, gSavedSelection, &theHostInfo);
OTSetAsynchronous(gInetService);
if (err == noErr) {
AddAddressToList(theHostInfo.addrs[0]);
}
}
resp->status = comm_STATUS_OK;
DPRINT(("commInit: success\n"));
return TRUE;
}
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
}