int main(int argc, const char * argv[])
{
    io_iterator_t	serialPortIterator;
    char            bsdPath[MAXPATHLEN];
    
    if(udpServerInit() != 0) {
        consoleNotef("Simulator link input port open failed.\n");
        return -1;
    }

    if(initConsoleInput() != 0) {
        consoleNotef("Console input initialization failed.\n");
        return -2;
    }
    
    Boolean looking = false;

    while(1) {
        if(!looking) {
            consoleNotef("Looking for the serial port...\n");
            looking = true;
        }
        
        if(findModems(&serialPortIterator) == KERN_SUCCESS) {
            if(getModemPath(serialPortIterator, bsdPath, sizeof(bsdPath)) == KERN_SUCCESS) {
                if(openSerialPort(bsdPath) != -1) {
                    serverInit();
                    
                    consoleNotef("Entering server loop...\n");
                    serverLoop();
                    consoleNotef("Server loop exited.\n");
             
                    closeSerialPort(serialPort);
                    looking = false;
                } else
                    consoleNotef("Serial port could not be opened.\n");
            }
            
            IOObjectRelease(serialPortIterator);
        }

        sleep(1);
    }

    return EX_OK;
}
int serialPortsScanner(std::vector <std::string> &availableSerialPorts)
{
    int retcode = 0;
    kern_return_t kernResult = KERN_FAILURE;
    io_iterator_t serialPortIterator = 0;

    TRACE_INFO(SERIAL, "serialPortsScanner() [MacOS variant]\n");

    // Serial devices are instances of class IOSerialBSDClient. Create a matching dictionary to find those.
    CFMutableDictionaryRef classesToMatch = NULL;
    classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);

    if (classesToMatch != NULL)
    {
        // Look for devices that claim to be modems (will pick up usb adapters, but not regular RS232 ports)
        CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDModemType));

        // Get an iterator across all matching devices.
        kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, &serialPortIterator);

        if (kernResult != KERN_SUCCESS)
        {
            TRACE_ERROR(SERIAL, "IOServiceGetMatchingServices returned %d\n", kernResult);
        }
    }
    else
    {
        TRACE_ERROR(SERIAL, "IOServiceMatching returned a NULL dictionary.\n");
    }

    if (kernResult == KERN_SUCCESS)
    {
        char modemPath[MAXPATHLEN] = "\0";

        if (getModemPath(serialPortIterator, modemPath, sizeof(modemPath)) == true)
        {
            // Test the port?
            //int fileDescriptor = openSerialPort(bsdPath);
            //if (-1 == fileDescriptor)
            //{
            //    return EX_IOERR;
            //}

            TRACE_INFO(SERIAL, "- Scanning for serial port on '%s' > FOUND\n", modemPath);
            retcode++;

            // Add it to the list
            std::string portPath = modemPath;
            availableSerialPorts.push_back(portPath);
        }
        else
        {
            TRACE_ERROR(SERIAL, "Could not get path for modem.\n");
        }
    }
    else
    {
        TRACE_WARNING(SERIAL, "No modem port were found.\n");
    }

    IOObjectRelease(serialPortIterator);

    return retcode;
}