~ubuntu-branches/ubuntu/edgy/rxtx/edgy-201105201527

|   Copyright 1997-2004 by Trent Jarvi taj@www.linux.org.uk

#ifndef WIN32

#       include "config.h"

#endif

#ifndef WIN32

#       include <sys/ioctl.h>

#       include <sys/errno.h>

#       include <sys/param.h>

#else

#       include <errno.h>

#       include "win32termios.h"

#endif

 

#if defined (WIN32)

 

#define CTL_CODE( DeviceType, Function, Method, Access ) (((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))

 

#define FILE_DEVICE_PARALLEL_PORT       0x00000016

#define METHOD_BUFFERED                 0

#define FILE_ANY_ACCESS                 0

 

#define IOCTL_PAR_QUERY_INFORMATION CTL_CODE(FILE_DEVICE_PARALLEL_PORT,1,METHOD_BUFFERED,FILE_ANY_ACCESS)

 

#define PARALLEL_INIT            0x1

#define PARALLEL_AUTOFEED        0x2

#define PARALLEL_PAPER_EMPTY     0x4

#define PARALLEL_OFF_LINE        0x8

#define PARALLEL_POWER_OFF       0x10

#define PARALLEL_NOT_CONNECTED   0x20

#define PARALLEL_BUSY            0x40

#define PARALLEL_SELECTED        0x80

 

int getWin32ParallelStatusFlags(int fd){

        int status = 0;

        DWORD count;

        if(!DeviceIoControl( (HANDLE)fd, IOCTL_PAR_QUERY_INFORMATION, NULL,0, &status, sizeof(status), &count, 0) && count == 1){

                YACK();

                return 0;

        }

#ifdef DEBUG

        printf("getWin32ParallelStatusFlags: %d\n", status );

#endif

        return status;

}

 

jboolean getWin32ParallelStatus(int fd, int flag){

        return( (getWin32ParallelStatusFlags(fd) & flag) ? JNI_TRUE : JNI_FALSE);

}

#endif

 

        int status;

#elif defined (WIN32)

        return getWin32ParallelStatus( fd, PARALLEL_PAPER_EMPTY); 

        int fd = get_java_var( env, jobj,"fd","I" );

#elif defined (WIN32)

        return getWin32ParallelStatus( fd, PARALLEL_BUSY); 

        int status;

#elif defined (WIN32)

        return getWin32ParallelStatus( fd, PARALLEL_PAPER_EMPTY | 

                                                                           PARALLEL_OFF_LINE |

                                                                           PARALLEL_POWER_OFF |

                                                                           PARALLEL_NOT_CONNECTED |

                                                                           PARALLEL_BUSY); 

        int status;

#elif defined (WIN32)

        return getWin32ParallelStatus( fd, PARALLEL_SELECTED); 

#if defined(__linux__)

        int fd = get_java_var( env, jobj,"fd","I" );

#if !defined(WIN32)

#endif /* !WIN32 */

#ifdef WIN32

        int fd = (int)CreateFile( filename, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0 );

#else

#endif

        throw_java_exception_system_msg( env, PORT_IN_USE_EXCEPTION, "open" );

#ifdef WIN32

        CloseHandle( (HANDLE)fd );

#else

#endif

#ifdef WIN32

        DWORD countWritten; /* Fixme, should be a loop until all is written */

        if( WriteFile( (HANDLE)fd, &byte, sizeof( unsigned char ), &countWritten, NULL ) < 0 ) return;

#else

#endif

        throw_java_exception_system_msg( env, IO_EXCEPTION, "writeByte" );

#ifdef WIN32

        DWORD countWritten; /* Fixme, should be a loop until all is written */

        COMMTIMEOUTS timeouts;

        int errorCount = 0;

#endif

#ifdef WIN32

        /*

        we set a timeout because all calls are sequentiell (also with asynchron)

         this means that the default timeout of unlimited

        blocks all calls (also close and status request) if the device is down

        */

        GetCommTimeouts( (HANDLE)fd, &timeouts );

        timeouts.WriteTotalTimeoutMultiplier = 0;

        timeouts.WriteTotalTimeoutConstant = 2000; /*  2000 is the min value for the default Windows NT and Windows 2000 driver */

        SetCommTimeouts( (HANDLE)fd, &timeouts );

        while( count > 0 ){

                if(!WriteFile( (HANDLE)fd, bytes, count, &countWritten, NULL ) && countWritten == 0){

                        /*

                        this are 20 * 2 seconds, in this time a printer (or other parallel device)

                        should solv all problems like buffer full, etc

                        */

                        if(errorCount++ < 20){

                                Sleep( 20 ); /* make a small pause to execute all other requests in all other threads */

                                continue;

                        }

                        throw_java_exception_system_msg( env, IO_EXCEPTION, "writeArray" );

                        break;

                }

                errorCount = 0;

                bytes += countWritten;

                count -= countWritten;

        }

#else

                throw_java_exception_system_msg( env, IO_EXCEPTION, "writeArray" );

#endif

#if defined(WIN32)

                if(!ReadFile( (HANDLE)fd, buffer + bytes, left, (DWORD *)&ret, NULL )){

                        YACK();

                        ret = -1;

                }

#else

#endif

                throw_java_exception_system_msg( env, IO_EXCEPTION, "readByte" );

        if( (size_t) length < 1 || (size_t) length > SSIZE_MAX )

                throw_java_exception( env, IO_EXCEPTION, "readArray",

                throw_java_exception_system_msg( env, IO_EXCEPTION, "readArray" );

        throw_java_exception_system_msg( env, IO_EXCEPTION, "nativeavailable" );

        unsigned int pflags = 0;

#elif defined(WIN32)

                pflags = getWin32ParallelStatusFlags(fd);

#if defined(PARALLEL_BUSY)

                if (pflags & PARALLEL_BUSY)

                        send_event( env, jobj, PAR_EV_ERROR, JNI_TRUE );

#elif defined(LP_BUSY)

 

 

 

#define MSG_SIZE 128

        char buf[ 128 ];

        /* reduce the message size if it to large for the message buffer */

        if(MSG_SIZE < (strlen( msg ) + strlen(foo) + 5)){

                msg[ MSG_SIZE - strlen(foo) - 5] = 0;

        }

void throw_java_exception_system_msg( JNIEnv *env, char *exc, char *foo )

{

#ifdef WIN32

        char *allocTextBuf;

        FormatMessage (

                FORMAT_MESSAGE_ALLOCATE_BUFFER |

                FORMAT_MESSAGE_FROM_SYSTEM,

                NULL,

                GetLastError(),

                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

                (LPSTR)&allocTextBuf,

                16,

                NULL );

        throw_java_exception( env, exc, foo, allocTextBuf );

        LocalFree(allocTextBuf);

#else

        throw_java_exception( env, exc, foo, strerror( errno ) );

#endif

}

/*----------------------------------------------------------

 report_error

 

   accept:      string to send to report as an error

   perform:     send the string to stderr or however it needs to be reported.

   return:      none

   exceptions:  none

   comments:

----------------------------------------------------------*/

void report_error(char *msg)

{

#ifndef DEBUG_MW

        fprintf(stderr, msg);

#else

        mexWarnMsgTxt( msg );

#endif /* DEBUG_MW */

}