comport.c

Open DMT Client C Source code

        logWARNING(LOGSRC,"ComPort structure is 'null'");
        return (ComPort_t*)0;
        
    } else
    if (comPortIsOpen(com)) {
        
        /* close */
        //logDEBUG(LOGSRC,"Closing port %d", com->name);
        if (com->read_fd != fileno(stdin)) {
            // don't close stdin
            close(com->read_fd);
            if ((com->write_fd >= 0) && (com->read_fd != com->write_fd) && (com->write_fd != fileno(stdout))) {
                close(com->write_fd);
            }
            com->read_fd  = -1;
            com->write_fd = -1;
        }
        
        /* re-open */
        logDEBUG(LOGSRC,"Reopenning port %d", com->name);
        ComPort_t newCom;
        if (comPortOpen(&newCom, com->name, com->bps, DTAFMT_8N1, com->hwFlow)) {
            newCom.flags  = com->flags;
            newCom.logger = com->logger;
            memcpy(com, &newCom, sizeof(newCom));
            return com;
        }
        
    }
    
    /* error */
    com->error = COMERR_GENERAL;
    return (ComPort_t*)0;
    
}
#endif // defined(TARGET_WINCE)

/* return true if port is open */
utBool comPortIsOpen(ComPort_t *com)
{
    return (com && com->open)? utTrue : utFalse;
}

// ----------------------------------------------------------------------------

#if defined(TARGET_WINCE)
void comPortClose(ComPort_t *com)
{
    if (com) { // don't use "comPortIsOpen(com)"
        
        /* close port ID */
        if (com->portId != INVALID_HANDLE_VALUE) {
            CloseHandle(com->portId);
            com->portId = INVALID_HANDLE_VALUE;
        }
        
        /* clear structure */
        // save error?
        comPortInitStruct(com);
        // restore error?
        
    }
}
#else
void comPortClose(ComPort_t *com)
{
    if (comPortIsOpen(com)) {
        if (com->read_fd != fileno(stdin)) {
            // don't close stdin/stdout
            close(com->read_fd);
            if ((com->write_fd >= 0) && (com->read_fd != com->write_fd) && (com->write_fd != fileno(stdout))) {
                close(com->write_fd);
            }
            com->read_fd  = -1;
            com->write_fd = -1;
        }
        comPortInitStruct(com);
    }
}
#endif // defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

/* return name of specified port */
const char *comPortName(ComPort_t *com)
{
    if (comPortIsOpen(com)) {
        if (!(*com->name)) {
            // init port name
            _comPortNameForPort(com->name, com->port);
        }
        return com->name;
    } else {
        return ComName_INVALID;
    }
}

// ----------------------------------------------------------------------------

/* the the timeout vtime */
#if defined(TARGET_WINCE)
// not supported 
#else
static utBool _comPortSetVtimeMS(ComPort_t *com, long timeoutMS)
{
    if (comPortIsOpen(com)) {
        struct termios options;
        tcgetattr(com->read_fd, &options);
        if (timeoutMS <= 0L) {
            options.c_cc[VTIME] = 0L;                   // block forever
        } else {
            long deciSec = (timeoutMS + 99L) / 100L;    // millisec => decisec (round up)
            if (deciSec <= 0L) {
                options.c_cc[VTIME] = 1;                // don't let it be zero
            } else
            if (deciSec <= 255L) {
                options.c_cc[VTIME] = deciSec;          // range 1 <= VTIME <= 255
            } else {
                // internal error
                logWARNING(LOGSRC,"Warning: VTIME cannot be > 255 [%ld]", deciSec);
                options.c_cc[VTIME] = 255;              // max 255
            }
        }
        com->lastVtimeMS = (long)options.c_cc[VTIME] * 100L; // deciSec => milliSec
        if (tcsetattr(com->read_fd, TCSANOW, &options) == 0) {
            // success
            errno = 0;
            return utTrue;
        } else {
            // error (error in 'errno')
            return utFalse;
        }
    } else {
        errno = EBADF;
        return utFalse;
    }
}
#endif // !defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
// not supported
#else
static long _comPortGetVtimeMS(ComPort_t *com)
{
    if (comPortIsOpen(com)) {
        return com->lastVtimeMS;
    } else {
        return -1L;
    }
}
#endif // !defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

/* return the 'read' ComPort file descriptor */
#if defined(TARGET_WINCE)
// not supported
#else
static int _comPortGetFD(ComPort_t *com)
{
    if (comPortIsOpen(com)) {
        return com->read_fd;
    } else {
        errno = ENODEV;
        return -1;
    }
}
#endif // !defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
// not supported
#else
static void _comPortSetControl(ComPort_t *com, int ctlMask, utBool state)
{
    int fd = _comPortGetFD(com);
    if (fd >= 0) {
        int status;
        ioctl(fd, TIOCMGET, &status);
        if (state) {
            status |= ctlMask;
        } else {
            status &= ~ctlMask;
        }
        ioctl(fd, TIOCMSET, &status);
    }
}
#endif // !defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
// not supported
#else
static utBool _comPortGetControl(ComPort_t *com, int ctlMask)
{
    int fd = _comPortGetFD(com);
    if (fd >= 0) {
        int status;
        ioctl(fd, TIOCMGET, &status);
        return (status & ctlMask)? utTrue : utFalse;
    }
    return utFalse;
}
#endif // !defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

// Data-Terminal-Ready (-->)
#if defined(TARGET_WINCE)
void comPortSetDTR(ComPort_t *com, utBool state)
{
    if (comPortIsOpen(com)) {
        EscapeCommFunction(com->portId, (state?SETDTR:CLRDTR));
    }
}
#else
void comPortSetDTR(ComPort_t *com, utBool state)
{
    _comPortSetControl(com, TIOCM_DTR, state);
}
#endif // defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
// not yet implemented
#else
utBool comPortGetDTR(ComPort_t *com)
{
    return _comPortGetControl(com, TIOCM_DTR);
}
#endif // defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

// Request-To-Send (-->)
#if defined(TARGET_WINCE)
void comPortSetRTS(ComPort_t *com, utBool state)
{
    if (comPortIsOpen(com)) {
        EscapeCommFunction(com->portId, (state?SETRTS:CLRRTS));
    }
}
#else
void comPortSetRTS(ComPort_t *com, utBool state)
{
    _comPortSetControl(com, TIOCM_RTS, state);
}
#endif // defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
// not yet implemented
#else
utBool comPortGetRTS(ComPort_t *com)
{
    return _comPortGetControl(com, TIOCM_RTS);
}
#endif // defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

// Clear-To-Send (<--)
#if defined(TARGET_WINCE)
// not yet implemented
#else
void comPortSetCTS(ComPort_t *com, utBool state)
{
    _comPortSetControl(com, TIOCM_CTS, state);
}
#endif // defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
utBool comPortGetCTS(ComPort_t *com)
{
    if (comPortIsOpen(com)) {
        DWORD modemStat = 0;
        GetCommModemStatus(com->portId, &modemStat);
        return (modemStat & MS_CTS_ON)? utTrue : utFalse;
    } else {
        return utFalse;
    }
}
#else
utBool comPortGetCTS(ComPort_t *com)
{
    return _comPortGetControl(com, TIOCM_CTS);
}
#endif // defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

#if defined(TARGET_WINCE)
utBool comPortGetDSR(ComPort_t *com)
{
    if (comPortIsOpen(com)) {
        DWORD modemStat = 0;
        GetCommModemStatus(com->portId, &modemStat);
        return (modemStat & MS_DSR_ON)? utTrue : utFalse;
    } else {
        return utFalse;
    }
}
#else
// not yet implemented
#endif

// ----------------------------------------------------------------------------

// Data-Carrier-Detect (<--)
#if defined(TARGET_WINCE)
// not yet implemented
#else
void comPortSetDCD(ComPort_t *com, utBool state)
{
    _comPortSetControl(com, TIOCM_CD, state);
}
#endif // defined(TARGET_WINCE)

#if defined(TARGET_WINCE)
// not yet implemented
#else
utBool comPortGetDCD(ComPort_t *com)
{
    return _comPortGetControl(com, TIOCM_CD);
}
#endif // defined(TARGET_WINCE)

// ----------------------------------------------------------------------------

/* set options for the specified ComPort */
void comPortSetOptions(ComPort_t *com, UInt16 flags)
{
    if (com != (ComPort_t*)0) {
        com->flags = flags;
    }
}

/* add options to the specified ComPort */
void comPortAddOptions(ComPort_t *com, UInt16 flags)
{
    if (com != (ComPort_t*)0) {
        com->flags |= flags;
    }
}

/* add options to the specified ComPort */
void comPortRemoveOptions(ComPort_t *com, UInt16 flags)
{
    if (com != (ComPort_t*)0) {
        com->flags &= ~flags;
    }
}

/* return true if the specified ComPort has backspace mode set */
UInt16 comPortGetOptions(ComPort_t *com)
{
    return com->flags;
}

// ----------------------------------------------------------------------------

/* push character back into comport read buffer */
void comPortPush(ComPort_t *com, UInt8 ch)
{
    if (com != (ComPort_t*)0) {
        // ComPort_t currently only support a 1 character cache.
        if (com->push > 0) {
            logWARNING(LOGSRC,"Char already pushed for port '%s'", com->name);
        }
        com->push = ch;
    }
}

// ----------------------------------------------------------------------------

/* return number of bytes available for reading on specified ComPort */
#if defined(TARGET_WINCE)
// not yet implemented
#else
int comPortGetAvail(ComPort_t *com, long timeoutMS)
{
    // Do not check 'com->push' here!
    // This routine is for checking to see if we have data available on the 
    // physical com port.

    /* no timeout? */
    if (timeoutMS <= 0L) {
        // if we don't care about a timeout, always return that we
        // have at least 1 byte available
        return 1;
    }
    
    /* wait until data is available */
    fd_set rfds;
    struct timeval tv;