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>

extern RDPDR_DEVICE g_rdpdr_device[];

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;
                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;
        }

        g_rdpdr_device[device_id].handle = parallel_fd;

        *handle = parallel_fd;

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

        return STATUS_SUCCESS;
}

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

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)
{
        *result = write(handle, data, length);
        return STATUS_SUCCESS;
}

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
11			extern RDPDR_DEVICE g_rdpdr_device[];
12
13	astrand	580	PARALLEL_DEVICE *
14			get_parallel_data(HANDLE handle)
15	n-ki	569	{
16			int index;
17
18			for (index = 0; index < RDPDR_MAX_DEVICES; index++)
19			{
20			if (handle == g_rdpdr_device[index].handle)
21			return (PARALLEL_DEVICE *) g_rdpdr_device[index].pdevice_data;
22			}
23			return NULL;
24			}
25
26
27			/* Enumeration of devices from rdesktop.c */
28			/* returns numer of units found and initialized. */
29			/* optarg looks like ':LPT1=/dev/lp0' */
30			/* when it arrives to this function. */
31			int
32	astrand	608	parallel_enum_devices(uint32 * id, char *optarg)
33	n-ki	569	{
34			PARALLEL_DEVICE *ppar_info;
35
36			char *pos = optarg;
37			char *pos2;
38			int count = 0;
39
40			// skip the first colon
41			optarg++;
42			while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
43			{
44			ppar_info = (PARALLEL_DEVICE *) xmalloc(sizeof(PARALLEL_DEVICE));
45
46			pos2 = next_arg(optarg, '=');
47			strcpy(g_rdpdr_device[*id].name, optarg);
48
49	stargo	570	toupper_str(g_rdpdr_device[*id].name);
50	n-ki	569
51			g_rdpdr_device[*id].local_path = xmalloc(strlen(pos2) + 1);
52			strcpy(g_rdpdr_device[*id].local_path, pos2);
53			printf("PARALLEL %s to %s\n", optarg, pos2);
54
55			// set device type
56			g_rdpdr_device[*id].device_type = DEVICE_TYPE_PARALLEL;
57			g_rdpdr_device[id].pdevice_data = (void ) ppar_info;
58			count++;
59			(*id)++;
60
61			optarg = pos;
62			}
63			return count;
64			}
65
66			static NTSTATUS
67	n-ki	592	parallel_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition,
68			uint32 flags, char filename, HANDLE handle)
69	n-ki	569	{
70			int parallel_fd;
71
72	n-ki	589	parallel_fd = open(g_rdpdr_device[device_id].local_path, O_RDWR);
73	n-ki	592	if (parallel_fd == -1)
74			{
75	n-ki	589	perror("open");
76	n-ki	569	return STATUS_ACCESS_DENIED;
77	n-ki	589	}
78	n-ki	569
79	n-ki	584	g_rdpdr_device[device_id].handle = parallel_fd;
80
81	n-ki	569	*handle = parallel_fd;
82	n-ki	592
83			/* all read and writes should be non blocking */
84			if (fcntl(*handle, F_SETFL, O_NONBLOCK) == -1)
85			perror("fcntl");
86
87	n-ki	569	return STATUS_SUCCESS;
88			}
89
90			static NTSTATUS
91			parallel_close(HANDLE handle)
92			{
93	n-ki	584	g_rdpdr_device[get_device_index(handle)].handle = 0;
94	n-ki	569	close(handle);
95			return STATUS_SUCCESS;
96			}
97
98	n-ki	589	NTSTATUS
99			parallel_read(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
100			{
101			*result = read(handle, data, length);
102			return STATUS_SUCCESS;
103			}
104
105	n-ki	569	static NTSTATUS
106			parallel_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
107			{
108			*result = write(handle, data, length);
109			return STATUS_SUCCESS;
110			}
111
112			static NTSTATUS
113			parallel_device_control(HANDLE handle, uint32 request, STREAM in, STREAM out)
114			{
115			if ((request >> 16) != FILE_DEVICE_PARALLEL)
116			return STATUS_INVALID_PARAMETER;
117
118			/* extract operation */
119			request >>= 2;
120			request &= 0xfff;
121
122			printf("PARALLEL IOCTL %d: ", request);
123
124			switch (request)
125			{
126			case IOCTL_PAR_QUERY_RAW_DEVICE_ID:
127
128			default:
129
130			printf("\n");
131			unimpl("UNKNOWN IOCTL %d\n", request);
132			}
133			return STATUS_SUCCESS;
134			}
135
136			DEVICE_FNS parallel_fns = {
137			parallel_create,
138			parallel_close,
139	n-ki	589	parallel_read,
140	n-ki	569	parallel_write,
141			parallel_device_control
142			};