int
commScanAddr(
commScanAddrReq_t * req, // Request
commScanAddrResp_t * resp) // Response (or NULL)
{
commScanAddrReq_t reqDummy;
commScanAddrResp_t respDummy;
ip_adr_t* adr;
OSStatus err;
InetHostInfo theHost;
if (req == NULL)
req = (commScanAddrReq_t *)memset(&reqDummy, 0, sizeof(*req));
if (resp == NULL)
resp = &respDummy;
DPRINT(("@TRUMP commScanAddr(%s):\n", req->printable));
if (req->size < sizeof(ip_adr_t)) {
resp->status = comm_STATUS_FULL;
return FALSE;
}
adr = (ip_adr_t*) req->address;
// convert the dotted decimal address or host name to an IP address (we do
// this sync.)
OTSetSynchronous(gInetService);
err = OTInetStringToAddress(gInetService, req->printable, &theHost);
OTSetAsynchronous(gInetService);
if (err != noErr) {
//{
// Str255 theString;
//
// NumToString(err, theString);
// DebugStr(theString);
//}
DPRINT(("@TRUMP commScanAddr: resolve failed!\n"));
resp->status = comm_STATUS_BAD;
return FALSE;
}
*adr = theHost.addrs[0]; // we only want the first address
// return the length of the address
resp->length = sizeof(ip_adr_t);
resp->status = comm_STATUS_OK;
return (TRUE);
}
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;
}
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 int DoDialogItem(DialogPtr dlog, short itemHit) {
short type,okay=FALSE,keepGoing=TRUE,val;
Handle hndl; Rect box; Point pt;
unsigned char *p,str[256];
if (itemHit<1 || itemHit>=LASTITEM)
return(keepGoing); /* Only legal items, please */
GetDialogItem(dlog,itemHit,&type,&hndl,&box);
switch(type) {
case ctrlItem+btnCtrl:
switch(itemHit) {
case BUT1_OK:
// the default is that we're done
keepGoing = FALSE; okay = TRUE;
// check to see if the name that has been entered can be resolved
{
extern InetSvcRef gInetService;
Str255 theString;
InetHostInfo theHost;
short aShort;
OSStatus err;
GetDlgString(dlog, EDIT5, theString); // machine name
ParamText(theString, "\p", "\p", "\p"); // show the name in the dialog
p2cstr(theString);
OTSetSynchronous(gInetService);
err = OTInetStringToAddress(gInetService, theString, &theHost);
OTSetAsynchronous(gInetService);
if (err != noErr) {
// the name cannot be looked up, ask the user if they want
// to add the entry anyway
aShort = CautionAlert(1501, nil); // returns 1 if OK to add
if (aShort != 1) {
keepGoing = TRUE; okay = FALSE;
}
}
}
break;
case BUT2_Cancel:
keepGoing = FALSE;
break;
}
break;
case ctrlItem+chkCtrl:
break;
case ctrlItem+radCtrl:
break;
case ctrlItem+resCtrl:
break;
case statText:
switch(itemHit) {
case STXT3_Host: /* NOT Enabled */
break;
case STXT4_Notes: /* NOT Enabled */
break;
case STXT7_Enter: /* NOT Enabled */
break;
}
break;
case editText:
switch(itemHit) {
case EDIT5:
break;
case EDIT6:
break;
}
break;
case iconItem:
break;
case picItem:
break;
case userItem:
break;
}
if (okay) keepGoing = AnyBadValues(dlog);
return(keepGoing);
}
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
}
