path: root/libexe/platform-mac.c

// Shave and a Haircut
// (c) 2019 Epic Games
// US Patent 6720962

///////////////

#include <IOKit/IOKitLib.h>
#include <IOKit/network/IOEthernetInterface.h>
#include <IOKit/network/IONetworkInterface.h>
#include <IOKit/network/IOEthernetController.h>

///////////////////////

int
getMOUSE1(  )
{

	return ( 0 );

}



int
getTAB(  )
{

	return ( 0 );

}



int
getCOMMAND(  )
{

	int             vv = 0, vv2;

#ifdef NOLIB

	int             k = 55;		// Escape = 53

	unsigned char   km[16];

//  GetKeys((unsigned long*)km);

	GetKeys( ( long * ) km );

//  if (valuator[MOUSE2]!=0)

	{

		vv = ( ( km[k >> 3] >> ( k & 7 ) ) & 1 );

//  if ((vv==0)&&(valuator[MOUSE1]==1))

//  valuator[MOUSE1]=2;  

//  if ((vv==1)&&(valuator[MOUSE1]==0))

//  valuator[MOUSE1]=1;  

//  if (valuator[MOUSE1]) DRAW_STATUS("got mouse1");

//if (vv) DRAW_STATUS("command");



	}

#endif

	return ( vv );

//  return(0);

}



int
getCTRL(  )
{

	int             vv = 0, vv2;

#ifdef NOLIB

	int             k = 59;		// Escape = 53

	unsigned char   km[16];

//  GetKeys((unsigned long*)km);

	GetKeys( ( long * ) km );

//  if (valuator[MOUSE2]!=0)

	{

		vv = ( ( km[k >> 3] >> ( k & 7 ) ) & 1 );

//  if ((vv==0)&&(valuator[MOUSE1]==1))

//  valuator[MOUSE1]=2;  

//  if ((vv==1)&&(valuator[MOUSE1]==0))

//  valuator[MOUSE1]=1;  

//  if (valuator[MOUSE1]) DRAW_STATUS("got mouse1");

//if (vv) DRAW_STATUS("command");



	}

#endif

	return ( vv );

//  return(0);

}






int
getESCAPE(  )
{
	int             vvv = 0;

	return ( valuator[ESCKEY] );

}



int
getSHIFT( void )
{
	int             tmp = 0;

	return ( tmp );



}



HWND
GetFocus( void )
{

	return ( 0 );

}



void
SetCapture( long junk )
{

	//fprintf(stderr, "SetCapture(): NOT YET IMPLEMENTED\n");

}



#define BOOL int

#define LPPOINT VERT *



BOOL
SetCursorPos( int x, int y )
{

	//fprintf(stderr, "SetCursorPos(): NOT YET IMPLEMENTED\n");

//    valuator[MOUSEX]=x;

	//   valuator[MOUSEY]=y;



}









BOOL
GetCursorPos( LPPOINT p )
{

	p->x = valuator[MOUSEX];

	p->y = valuator[MOUSEY];

}



// GET HANDLE TO WINDOW FOR TIMERS -- DOES NOTHING ON SGI

HWND
GetForegroundWindow(  )
{

	return ( 0 );

}



int
filechooserSV( const char *title, const char *comment, char *filename, int filenamemax, char *filter, int filtermax )
{

	return 0;

}

int
filechooser( const char *title, const char *comment, char *filename, int filenamemax, char *filter, int filtermax )
{

	int             ret = -1;

#ifdef NOLIB

	NavDialogOptions dialogOptions;

//    NavEventUPP         eventProc = NewNavEventProc(myEventProc);

//    NavObjectFilterUPP  filterProc = NewNavObjectFilterProc(myFilterProc);

	NavTypeListHandle typeList;

	NavReplyRecord  reply;

	OSErr           anErr = noErr;



	//  Specify default options for dialog box

	anErr = NavGetDefaultDialogOptions( &dialogOptions );



	if( anErr == noErr )

	{

		AEDesc          defaultLocation;

		//  Adjust the options to fit our needs

		//  Set default location option

		dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation;

//          dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation;

		//  Clear preview option

		dialogOptions.dialogOptionFlags ^= kNavAllowPreviews;



		// Get 'open' resource. A nil handle being returned is OK,

		// this simply means no automatic file filtering.

		typeList = ( NavTypeListHandle ) GetResource( 'open', 128 );



		// Call NavChooseFile() with specified options and

		// declare our app-defined functions and type list

//        anErr = NavChooseFile (nil, &reply, &dialogOptions, eventProc, nil, filterProc, typeList, nil);

		anErr = NavChooseFile( nil, &reply, &dialogOptions, nil, nil, nil, typeList, nil );



		if( anErr == noErr && reply.validRecord )

		{

			AEKeyword       theKeyword;

			DescType        actualType;

			Size            actualSize;

			FSSpec          documentFSSpec;



			// Get a pointer to selected file

			anErr = AEGetNthPtr( &( reply.selection ), 1, typeFSS, &theKeyword, &actualType, &documentFSSpec, sizeof( documentFSSpec ), &actualSize );

			if( anErr == noErr )

			{

				char           *pfilter;

				int             lenstr = ( int ) ( documentFSSpec.name[0] );

				int             i = 1;

				for( ; i <= lenstr; i++ )

				{

					filename[i - 1] = documentFSSpec.name[i];

				}

				filename[lenstr] = '\0';

				if( filter[0] == '*' && filter[1] == '.' )

					pfilter = filter + 2;

				else

					pfilter = filter;

				if( strstr( filename, pfilter ) )

					ret = 0;

				else

					filename[0] = '\0';

			}



			//  Dispose of NavReplyRecord, resources, descriptors

			anErr = NavDisposeReply( &reply );

		}



		if( typeList != NULL )

		{

			ReleaseResource( ( Handle ) typeList );

		}



	}



#endif

//    DisposeRoutineDescriptor(eventProc);

//    DisposeRoutineDescriptor(filterProc);

//if (ret==0) printf("DEBUG: gonna open %s\n", filename);

//else printf("DEBUG: not opening anything\n");



	return ( ret );

}



/* NAVIGATION SERVICE EXAMPLE */

/*

This function allows the user to choose a single file, such as a preferences file, for an action other than opening. The NavChooseFile function is similar to NavGetFile, but is limited to selecting a single file. 



OSErr MyOpenDocument(const FSSpecPtr defaultLocationfssPtr)

{

    NavDialogOptions    dialogOptions;

    AEDesc              defaultLocation;

    NavEventUPP         eventProc = NewNavEventProc(myEventProc);

    NavObjectFilterUPP  filterProc = 

                        NewNavObjectFilterProc(myFilterProc);

    OSErr               anErr = noErr;

    

    //  Specify default options for dialog box

    anErr = NavGetDefaultDialogOptions(&dialogOptions);

    if (anErr == noErr)

    {

        //  Adjust the options to fit our needs

        //  Set default location option

        dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation;

        //  Clear preview option

        dialogOptions.dialogOptionFlags ^= kNavAllowPreviews;

        

        // make descriptor for default location

        anErr = AECreateDesc(typeFSS, defaultLocationfssPtr,

                             sizeof(*defaultLocationfssPtr),

                             &defaultLocation );

        if (anErr == noErr)

        {

            // Get 'open' resource. A nil handle being returned is OK,

            // this simply means no automatic file filtering.

            NavTypeListHandle typeList = (NavTypeListHandle)GetResource(

                                        'open', 128);

            NavReplyRecord reply;

            

            // Call NavGetFile() with specified options and

            // declare our app-defined functions and type list

            anErr = NavGetFile (&defaultLocation, &reply, &dialogOptions,

                                eventProc, nil, filterProc,

                                typeList, nil);

            if (anErr == noErr && reply.validRecord)

            {

                //  Deal with multiple file selection

                long    count;

                

                anErr = AECountItems(&(reply.selection), &count);

                // Set up index for file list

                if (anErr == noErr)

                {

                    longindex;

                    

                    for (index = 1; index <= count; index++)

                    {

                        AEKeyword   theKeyword;

                        DescType    actualType;

                        Size        actualSize;

                        FSSpec      documentFSSpec;

                        

                        // Get a pointer to selected file

                        anErr = AEGetNthPtr(&(reply.selection), index,

                                            typeFSS, &theKeyword,

                                            &actualType,&documentFSSpec,

                                            sizeof(documentFSSpec),

                                            &actualSize);

                        if (anErr == noErr)

                        {

                            anErr = DoOpenFile(&documentFSSpec);

                        }

                    }

                }

                //  Dispose of NavReplyRecord, resources, descriptors

                anErr = NavDisposeReply(&reply);

            }

            if (typeList != NULL)

            {

                ReleaseResource( (Handle)typeList);

            }

            (void) AEDisposeDesc(&defaultLocation);

        }

    }

    DisposeRoutineDescriptor(eventProc);

    DisposeRoutineDescriptor(filterProc);

    return anErr;

}

*/


///////////////// vald|10Jun2010 stuf to replace ...InetInterface deprecated in MacOS10.5 sdk  ///////////////////////
//////////////////////////////// used for retrieving MAC address ////////////////////////////////////////////////////

//static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices);
//static kern_return_t GetMACAddress(io_iterator_t intfIterator, UInt8 *MACAddress, UInt8 bufferSize);

// Returns an iterator containing the primary (built-in) Ethernet interface. The caller is responsible for
// releasing the iterator after the caller is done with it.
static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices)
{
    kern_return_t		kernResult; 
    CFMutableDictionaryRef	matchingDict;
    CFMutableDictionaryRef	propertyMatchDict;
    
    // Ethernet interfaces are instances of class kIOEthernetInterfaceClass. 
    // IOServiceMatching is a convenience function to create a dictionary with the key kIOProviderClassKey and 
    // the specified value.
    matchingDict = IOServiceMatching(kIOEthernetInterfaceClass);

    // Note that another option here would be:
    // matchingDict = IOBSDMatching("en0");
        
    if (NULL == matchingDict) {
        printf("IOServiceMatching returned a NULL dictionary.\n");
    }
    else {
        // Each IONetworkInterface object has a Boolean property with the key kIOPrimaryInterface. Only the
        // primary (built-in) interface has this property set to TRUE.
        
        // IOServiceGetMatchingServices uses the default matching criteria defined by IOService. This considers
        // only the following properties plus any family-specific matching in this order of precedence 
        // (see IOService::passiveMatch):
        //
        // kIOProviderClassKey (IOServiceMatching)
        // kIONameMatchKey (IOServiceNameMatching)
        // kIOPropertyMatchKey
        // kIOPathMatchKey
        // kIOMatchedServiceCountKey
        // family-specific matching
        // kIOBSDNameKey (IOBSDNameMatching)
        // kIOLocationMatchKey
        
        // The IONetworkingFamily does not define any family-specific matching. This means that in            
        // order to have IOServiceGetMatchingServices consider the kIOPrimaryInterface property, we must
        // add that property to a separate dictionary and then add that to our matching dictionary
        // specifying kIOPropertyMatchKey.
            
        propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
													  &kCFTypeDictionaryKeyCallBacks,
													  &kCFTypeDictionaryValueCallBacks);
    
        if (NULL == propertyMatchDict) {
            printf("CFDictionaryCreateMutable returned a NULL dictionary.\n");
        }
        else {
            // Set the value in the dictionary of the property with the given key, or add the key 
            // to the dictionary if it doesn't exist. This call retains the value object passed in.
            CFDictionarySetValue(propertyMatchDict, CFSTR(kIOPrimaryInterface), kCFBooleanTrue); 
            
            // Now add the dictionary containing the matching value for kIOPrimaryInterface to our main
            // matching dictionary. This call will retain propertyMatchDict, so we can release our reference 
            // on propertyMatchDict after adding it to matchingDict.
            CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict);
            CFRelease(propertyMatchDict);
        }
    }
    
    // IOServiceGetMatchingServices retains the returned iterator, so release the iterator when we're done with it.
    // IOServiceGetMatchingServices also consumes a reference on the matching dictionary so we don't need to release
    // the dictionary explicitly.
    kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, matchingServices);    
    if (KERN_SUCCESS != kernResult) {
        printf("IOServiceGetMatchingServices returned 0x%08x\n", kernResult);
    }
        
    return kernResult;
}
    
// Given an iterator across a set of Ethernet interfaces, return the MAC address of the last one.
// If no interfaces are found the MAC address is set to an empty string.
// In this sample the iterator should contain just the primary interface.
static kern_return_t GetMACAddress(io_iterator_t intfIterator, UInt8 *MACAddress, UInt8 bufferSize)
{
    io_object_t		intfService;
    io_object_t		controllerService;
    kern_return_t	kernResult = KERN_FAILURE;
    
    // Make sure the caller provided enough buffer space. Protect against buffer overflow problems.
	if (bufferSize < kIOEthernetAddressSize) {
		return kernResult;
	}
	
	// Initialize the returned address
    bzero(MACAddress, bufferSize);
    
    // IOIteratorNext retains the returned object, so release it when we're done with it.
    while (intfService = IOIteratorNext(intfIterator))
    {
        CFTypeRef	MACAddressAsCFData;        

        // IONetworkControllers can't be found directly by the IOServiceGetMatchingServices call, 
        // since they are hardware nubs and do not participate in driver matching. In other words,
        // registerService() is never called on them. So we've found the IONetworkInterface and will 
        // get its parent controller by asking for it specifically.
        
        // IORegistryEntryGetParentEntry retains the returned object, so release it when we're done with it.
        kernResult = IORegistryEntryGetParentEntry(intfService,
												   kIOServicePlane,
												   &controllerService);
		
        if (KERN_SUCCESS != kernResult) {
            printf("IORegistryEntryGetParentEntry returned 0x%08x\n", kernResult);
        }
        else {
            // Retrieve the MAC address property from the I/O Registry in the form of a CFData
            MACAddressAsCFData = IORegistryEntryCreateCFProperty(controllerService,
																 CFSTR(kIOMACAddress),
																 kCFAllocatorDefault,
																 0);
            if (MACAddressAsCFData) {
                //CFShow(MACAddressAsCFData); // for display purposes only; output goes to stderr
                
                // Get the raw bytes of the MAC address from the CFData
                CFDataGetBytes(MACAddressAsCFData, CFRangeMake(0, kIOEthernetAddressSize), MACAddress);
                CFRelease(MACAddressAsCFData);
            }
                
            // Done with the parent Ethernet controller object so we release it.
            (void) IOObjectRelease(controllerService);
        }
        
        // Done with the Ethernet interface object so we release it.
        (void) IOObjectRelease(intfService);
    }
        
    return kernResult;
}