trunk/rdesktop/parallel.c

#define MAX_PARALLEL_DEVICES            1

#define FILE_DEVICE_PARALLEL            0x22

#define IOCTL_PAR_QUERY_RAW_DEVICE_ID   0x0c

#include "rdesktop.h"
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <errno.h>

#if defined(__linux__)
#include <linux/lp.h>
#endif

extern int errno;

extern RDPDR_DEVICE g_rdpdr_device[];

static PARALLEL_DEVICE *
get_parallel_data(HANDLE handle)
{
        int index;

        for (index = 0; index < RDPDR_MAX_DEVICES; index++)
        {
                if (handle == g_rdpdr_device[index].handle)
                        return (PARALLEL_DEVICE *) g_rdpdr_device[index].pdevice_data;
        }
        return NULL;
}


/* Enumeration of devices from rdesktop.c        */
/* returns numer of units found and initialized. */
/* optarg looks like ':LPT1=/dev/lp0'            */
/* when it arrives to this function.             */
int
parallel_enum_devices(uint32 * id, char *optarg)
{
        PARALLEL_DEVICE *ppar_info;

        char *pos = optarg;
        char *pos2;
        int count = 0;

        // skip the first colon
        optarg++;
        while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
        {
                ppar_info = (PARALLEL_DEVICE *) xmalloc(sizeof(PARALLEL_DEVICE));

                pos2 = next_arg(optarg, '=');
                strcpy(g_rdpdr_device[*id].name, optarg);

                toupper_str(g_rdpdr_device[*id].name);

                g_rdpdr_device[*id].local_path = xmalloc(strlen(pos2) + 1);
                strcpy(g_rdpdr_device[*id].local_path, pos2);
                printf("PARALLEL %s to %s\n", optarg, pos2);

                // set device type
                g_rdpdr_device[*id].device_type = DEVICE_TYPE_PARALLEL;
                g_rdpdr_device[*id].pdevice_data = (void *) ppar_info;
                g_rdpdr_device[*id].handle = 0;
                count++;
                (*id)++;

                optarg = pos;
        }
        return count;
}

static NTSTATUS
parallel_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition,
                uint32 flags, char *filename, HANDLE * handle)
{
        int parallel_fd;

        parallel_fd = open(g_rdpdr_device[device_id].local_path, O_RDWR);
        if (parallel_fd == -1)
        {
                perror("open");
                return STATUS_ACCESS_DENIED;
        }

        /* all read and writes should be non blocking */
        if (fcntl(parallel_fd, F_SETFL, O_NONBLOCK) == -1)
                perror("fcntl");

#if defined(LPABORT)
        /* Retry on errors */
        ioctl(parallel_fd, LPABORT, (int) 1);
#endif

        g_rdpdr_device[device_id].handle = parallel_fd;

        *handle = parallel_fd;

        return STATUS_SUCCESS;
}

static NTSTATUS
parallel_close(HANDLE handle)
{
        int i = get_device_index(handle);
        if (i >= 0)
                g_rdpdr_device[i].handle = 0;
        close(handle);
        return STATUS_SUCCESS;
}

static NTSTATUS
parallel_read(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
{
        *result = read(handle, data, length);
        return STATUS_SUCCESS;
}

static NTSTATUS
parallel_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
{
        int rc = STATUS_SUCCESS;

        int n = write(handle, data, length);
        if (n < 0)
        {
                int status;

                *result = 0;
                switch (errno)
                {
                        case EAGAIN:
                                rc = STATUS_DEVICE_OFF_LINE;
                        case ENOSPC:
                                rc = STATUS_DEVICE_PAPER_EMPTY;
                        case EIO:
                                rc = STATUS_DEVICE_OFF_LINE;
                        default:
                                rc = STATUS_DEVICE_POWERED_OFF;
                }
#if defined(LPGETSTATUS)
                if (ioctl(handle, LPGETSTATUS, &status) == 0)
                {
                        /* coming soon: take care for the printer status */
                        printf("parallel_write: status = %d, errno = %d\n", status, errno);
                }
#endif
        }
        *result = n;
        return rc;
}

static NTSTATUS
parallel_device_control(HANDLE handle, uint32 request, STREAM in, STREAM out)
{
        if ((request >> 16) != FILE_DEVICE_PARALLEL)
                return STATUS_INVALID_PARAMETER;

        /* extract operation */
        request >>= 2;
        request &= 0xfff;

        printf("PARALLEL IOCTL %d: ", request);

        switch (request)
        {
                case IOCTL_PAR_QUERY_RAW_DEVICE_ID:

                default:

                        printf("\n");
                        unimpl("UNKNOWN IOCTL %d\n", request);
        }
        return STATUS_SUCCESS;
}

DEVICE_FNS parallel_fns = {
        parallel_create,
        parallel_close,
        parallel_read,
        parallel_write,
        parallel_device_control
};
1	n-ki	569	#define MAX_PARALLEL_DEVICES 1
2
3			#define FILE_DEVICE_PARALLEL 0x22
4
5			#define IOCTL_PAR_QUERY_RAW_DEVICE_ID 0x0c
6
7			#include "rdesktop.h"
8			#include <unistd.h>
9			#include <fcntl.h>
10	n-ki	631	#include <sys/ioctl.h>
11			#include <errno.h>
12	n-ki	569
13	stargo	632	#if defined(__linux__)
14			#include <linux/lp.h>
15			#endif
16
17	n-ki	631	extern int errno;
18
19	n-ki	569	extern RDPDR_DEVICE g_rdpdr_device[];
20
21	astrand	664	static PARALLEL_DEVICE *
22	astrand	580	get_parallel_data(HANDLE handle)
23	n-ki	569	{
24			int index;
25
26			for (index = 0; index < RDPDR_MAX_DEVICES; index++)
27			{
28			if (handle == g_rdpdr_device[index].handle)
29			return (PARALLEL_DEVICE *) g_rdpdr_device[index].pdevice_data;
30			}
31			return NULL;
32			}
33
34
35			/* Enumeration of devices from rdesktop.c */
36			/* returns numer of units found and initialized. */
37			/* optarg looks like ':LPT1=/dev/lp0' */
38			/* when it arrives to this function. */
39			int
40	astrand	608	parallel_enum_devices(uint32 * id, char *optarg)
41	n-ki	569	{
42			PARALLEL_DEVICE *ppar_info;
43
44			char *pos = optarg;
45			char *pos2;
46			int count = 0;
47
48			// skip the first colon
49			optarg++;
50			while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
51			{
52			ppar_info = (PARALLEL_DEVICE *) xmalloc(sizeof(PARALLEL_DEVICE));
53
54			pos2 = next_arg(optarg, '=');
55			strcpy(g_rdpdr_device[*id].name, optarg);
56
57	stargo	570	toupper_str(g_rdpdr_device[*id].name);
58	n-ki	569
59			g_rdpdr_device[*id].local_path = xmalloc(strlen(pos2) + 1);
60			strcpy(g_rdpdr_device[*id].local_path, pos2);
61			printf("PARALLEL %s to %s\n", optarg, pos2);
62
63			// set device type
64			g_rdpdr_device[*id].device_type = DEVICE_TYPE_PARALLEL;
65			g_rdpdr_device[id].pdevice_data = (void ) ppar_info;
66	n-ki	631	g_rdpdr_device[*id].handle = 0;
67	n-ki	569	count++;
68			(*id)++;
69
70			optarg = pos;
71			}
72			return count;
73			}
74
75			static NTSTATUS
76	n-ki	592	parallel_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition,
77			uint32 flags, char filename, HANDLE handle)
78	n-ki	569	{
79			int parallel_fd;
80
81	n-ki	589	parallel_fd = open(g_rdpdr_device[device_id].local_path, O_RDWR);
82	n-ki	592	if (parallel_fd == -1)
83			{
84	n-ki	589	perror("open");
85	n-ki	569	return STATUS_ACCESS_DENIED;
86	n-ki	589	}
87	n-ki	569
88	n-ki	631	/* all read and writes should be non blocking */
89			if (fcntl(parallel_fd, F_SETFL, O_NONBLOCK) == -1)
90			perror("fcntl");
91
92	stargo	632	#if defined(LPABORT)
93			/* Retry on errors */
94	n-ki	631	ioctl(parallel_fd, LPABORT, (int) 1);
95	stargo	632	#endif
96	n-ki	631
97	n-ki	584	g_rdpdr_device[device_id].handle = parallel_fd;
98
99	n-ki	569	*handle = parallel_fd;
100	n-ki	592
101	n-ki	569	return STATUS_SUCCESS;
102			}
103
104			static NTSTATUS
105			parallel_close(HANDLE handle)
106			{
107	n-ki	631	int i = get_device_index(handle);
108			if (i >= 0)
109			g_rdpdr_device[i].handle = 0;
110	n-ki	569	close(handle);
111			return STATUS_SUCCESS;
112			}
113
114	astrand	664	static NTSTATUS
115	n-ki	589	parallel_read(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
116			{
117			*result = read(handle, data, length);
118			return STATUS_SUCCESS;
119			}
120
121	n-ki	569	static NTSTATUS
122			parallel_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
123			{
124	n-ki	631	int rc = STATUS_SUCCESS;
125
126			int n = write(handle, data, length);
127			if (n < 0)
128			{
129			int status;
130
131			*result = 0;
132			switch (errno)
133			{
134			case EAGAIN:
135			rc = STATUS_DEVICE_OFF_LINE;
136			case ENOSPC:
137			rc = STATUS_DEVICE_PAPER_EMPTY;
138			case EIO:
139			rc = STATUS_DEVICE_OFF_LINE;
140			default:
141			rc = STATUS_DEVICE_POWERED_OFF;
142			}
143	stargo	632	#if defined(LPGETSTATUS)
144	n-ki	631	if (ioctl(handle, LPGETSTATUS, &status) == 0)
145			{
146			/* coming soon: take care for the printer status */
147			printf("parallel_write: status = %d, errno = %d\n", status, errno);
148			}
149	stargo	632	#endif
150	n-ki	631	}
151			*result = n;
152			return rc;
153	n-ki	569	}
154
155			static NTSTATUS
156			parallel_device_control(HANDLE handle, uint32 request, STREAM in, STREAM out)
157			{
158			if ((request >> 16) != FILE_DEVICE_PARALLEL)
159			return STATUS_INVALID_PARAMETER;
160
161			/* extract operation */
162			request >>= 2;
163			request &= 0xfff;
164
165			printf("PARALLEL IOCTL %d: ", request);
166
167			switch (request)
168			{
169			case IOCTL_PAR_QUERY_RAW_DEVICE_ID:
170
171			default:
172
173			printf("\n");
174			unimpl("UNKNOWN IOCTL %d\n", request);
175			}
176			return STATUS_SUCCESS;
177			}
178
179			DEVICE_FNS parallel_fns = {
180			parallel_create,
181			parallel_close,
182	n-ki	589	parallel_read,
183	n-ki	569	parallel_write,
184			parallel_device_control
185			};