Mac Forum / Programming / CodeWarrior / February 2004

You would also need to change your includes (ie #include
<HIToolbox/Controls.h> instead of #include <Controls.h> (although for that
one you can just use #include <Carbon/Carbon.h>), change libraries you
link against etc.

What I would do is make a bundle that does your IOKit stuff. Your CFM
app can then load your bundle, extract whatever function pointers are
exported by it and call those.

Fred

I've had a lot of experience with this, so let me describe what I do:

I've got a Carbon CFM app.

To get it to compile, I made a new target, a static library, and put the OS X
serial port in that. That way, it can have its own access paths, without
affecting the rest of my application.

Here are the access paths I use for that part of the code:

{OS X Volume}usr/include
{Compiler}MSL
{Compiler}Mac OS Support
{Compiler}Mac OS X Support

where only the last three have the recursive flag (the second column in
access paths) turn on.

The start of my source file looks like this:

#include <Carbon.h>
#include "CarbonSerialPortX.h"
#include "CRegistryOSX.h"

#include <fcntl.h>
#include <sys/filio.h>
#include <termios.h>
#include <time.h>

typedef unsigned int natural_t;  // vm_types.h
typedef int    integer_t;        // vm_types.h
typedef long kern_return_t;
typedef unsigned int mach_port_t;
typedef mach_port_t  io_object_t;
typedef io_object_t  io_iterator_t;
typedef io_object_t  io_registry_entry_t;
typedef UInt32    IOOptionBits;
typedef natural_t thread_policy_flavor_t;
typedef integer_t *thread_policy_t;
typedef natural_t mach_msg_type_number_t; // mach/message.h
typedef  mach_port_t    thread_act_t;  // mach_types.h

When it became too difficult to #include what I needed, I just copied
the definitions to get the code to compile.

Under OS X, it does the following to enumerate the serial ports:

// ---------------------------------------------------------------------------
//    € InitSerialPortArray
// ---------------------------------------------------------------------------

#define MACH_PORT_NULL 0
#define kIOSerialBSDServiceValue "IOSerialBSDClient"
#define kIOSerialBSDTypeKey         "IOSerialBSDClientType"
#define kIOSerialBSDRS232Type    "IORS232SerialStream"
#define kIOTTYDeviceKey          "IOTTYDevice"

static CarbonSerialPortX ** sH;

static OSStatus InitSerialPortArray(void){
  OSStatus          err = noErr;
   mach_port_t         masterPort;
   CFMutableDictionaryRef classesToMatch;
   io_iterator_t       serialPortIterator = NULL;
   io_object_t         serialService = NULL;
   if(NULL == sH){
     sH = (CarbonSerialPortX **) NewHandle(0);
   }else{
     SetHandleSize((Handle) sH, 0);
   }
  err = (*ioMasterPort)(MACH_PORT_NULL, &masterPort);
  if(noErr == err && NULL == (classesToMatch = (*ioServiceMatching)(kIOSerialBSDServiceValue))){
     err = paramErr;
  }
  if(noErr == err){
      CFDictionarySetValue(classesToMatch,
                           CFSTR(kIOSerialBSDTypeKey),
                           CFSTR(kIOSerialBSDRS232Type));
  }
  if(noErr == err){ err = (*ioServiceGetMatchingServices)(masterPort, classesToMatch, &serialPortIterator); }  

   while (noErr == err && NULL != (serialService = (*ioIteratorNext)(serialPortIterator)))
   {
       CFTypeRef bsdPathAsCFString;
       CarbonSerialPortX     port = {0};
       Boolean      result;
     bsdPathAsCFString = (*ioRegistryEntryCreateCFProperty)(serialService,
                                                           CFSTR(kIOTTYDeviceKey),
                                                           kCFAllocatorDefault,
                                                           0);
      result = CFStringGetPascalString(bsdPathAsCFString,
                                       port.userName,
                                       sizeof port.userName,
                                       kCFStringEncodingASCII);
     CFRelease(bsdPathAsCFString);
     (*ioObjectRelease)(serialService);
       port.deviceName[0] = 0;
       if('/' != port.userName[1]){
        Concat(port.deviceName, "\p/dev/cu."); // use /dev/cu.* for non-blocking I/O on Keyspan serial port
        //Concat(port.deviceName, "\p/dev/tty."); // /dev/tty.* blocks on I/O
       }
       Concat(port.deviceName, port.userName);
  //    append port to the handle of ports.
     port.originalTTYAttrs = (struct termios*) NewPtrClear(sizeof(struct termios));
     err = PtrAndHand(&port, (Handle) sH, sizeof port);
     port.originalTTYAttrs = NULL;
   }
   if(NULL != sH){
     HLock((Handle) sH);
   }

  // clean up
  if(NULL != serialPortIterator){
     OSStatus e = (*ioObjectRelease)(serialPortIterator);
     if(noErr == err){ err = e; }
  }
  if(NULL != masterPort){
     OSStatus e = (*ioObjectRelease)(masterPort);
     if(noErr == err){ err = e; }
  }
  return err;
}

And the following code to initialize the function pointers:
(the reinterpret_cast_ macros are because this source file has moved back and
forth from C to C++ multiple times.)

// ---------------------------------------------------------------------------
//    € InitFuncPointers
// ---------------------------------------------------------------------------
/// InitFuncPointers - initialize our dynamicly loaded function pointers to system calls.

OSStatus InitFuncPointers(void){
  OSStatus          err = noErr;
  if(NULL == ioMasterPort){
     CFBundleRef       sysBundle;
     if (NULL == ioKitBundle) {
        CRegistryOSXInit();
        if(NULL == ioKitBundle){
           err = paramErr;
        }
     }
     if (noErr == err) {
        ioMasterPort = reinterpret_cast_(IOMasterPortProc)(CFBundleGetFunctionPointerForName(ioKitBundle, CFSTR("IOMasterPort")));
        ioServiceMatching = reinterpret_cast_(IOServiceMatchingProc)(CFBundleGetFunctionPointerForName(ioKitBundle, CFSTR("IOServiceMatching")));
        ioObjectRelease = reinterpret_cast_(IOObjectReleaseProc)(CFBundleGetFunctionPointerForName(ioKitBundle, CFSTR("IOObjectRelease")));
        ioIteratorNext = reinterpret_cast_(IOIteratorNextProc)(CFBundleGetFunctionPointerForName(ioKitBundle, CFSTR("IOIteratorNext")));
        ioRegistryEntryCreateCFProperty = reinterpret_cast_(IORegistryEntryCreateCFPropertyProc)(CFBundleGetFunctionPointerForName(ioKitBundle, CFSTR("IORegistryEntryCreateCFProperty")));
        ioServiceGetMatchingServices = reinterpret_cast_(IOServiceGetMatchingServicesProc)(CFBundleGetFunctionPointerForName(ioKitBundle, CFSTR("IOServiceGetMatchingServices")));
     }
     if(noErr == err){
        err = LoadFrameworkBundle(CFSTR("System.framework"), &sysBundle);
     }
     if(noErr == err){
        // see: errno.h in the System framework for the reasoning behind the next line
        errnop = reinterpret_cast_(ErrnoProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("__error")));
        openp = reinterpret_cast_(OpenProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("open")));
        closep = reinterpret_cast_(CloseProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("close")));
        fcntlp = reinterpret_cast_(FcntlProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("fcntl")));
        readp = reinterpret_cast_(ReadProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("read")));
        writep = reinterpret_cast_(WriteProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("write")));
        ioctlp = reinterpret_cast_(IoctlProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("ioctl")));
        tcdrainp = reinterpret_cast_(TcdrainProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("tcdrain")));
        tcgetattrp = reinterpret_cast_(TcgetattrProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("tcgetattr")));
        tcsetattrp = reinterpret_cast_(TcsetattrProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("tcsetattr")));
        cfsetspeedp = reinterpret_cast_(CfsetspeedProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("cfsetspeed")));
        cfmakerawp = reinterpret_cast_(CfmakerawProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("cfmakeraw")));
        mach_thread_selfp = reinterpret_cast_(MachThreadSelfProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("mach_thread_self")));
        sysctlp = reinterpret_cast_(SysctlProc)(CFBundleGetFunctionPointerForName(sysBundle, CFSTR("sysctl")));
     }
  }
  return err;
}

My problem is that under OS 9, I have analgous code to dynamicly attach
to InterfaceLib and pull the function pointers I need out of that, but
while CRMSearch() correctly enumerates the ports under Classic, it returns
0 ports when called from Carbon this way. Does anyone have a solution?