trunk/rdesktop/printer.c

#include "rdesktop.h"

extern RDPDR_DEVICE g_rdpdr_device[];

PRINTER *
get_printer_data(HANDLE handle)
{
        int index;

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

int
printer_enum_devices(uint32 *id, char *optarg)
{
        PRINTER *pprinter_data;

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

        // we need to know how many printers we've already set up
        // supplied from other -r flags than this one.
        while (count < *id)
        {
                if (g_rdpdr_device[count].device_type == DEVICE_TYPE_PRINTER)
                        already++;
                count++;
        }

        count = 0;

        if (*optarg == ':')
                optarg++;

        while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
        {
                pprinter_data = (PRINTER *) xmalloc(sizeof(PRINTER));

                strcpy(g_rdpdr_device[*id].name, "PRN");
                strcat(g_rdpdr_device[*id].name, ltoa(already + count + 1, 10));

                /* first printer is set as default printer */
                if ((already + count) == 0)
                        pprinter_data->default_printer = True;
                else
                        pprinter_data->default_printer = False;

                pos2 = next_arg(optarg, '=');
                if (*optarg == (char) 0x00)
                        pprinter_data->printer = "mydeskjet";   /* set default */
                else
                {
                        pprinter_data->printer = xmalloc(strlen(optarg) + 1);
                        strcpy(pprinter_data->printer, optarg);
                }

                if (!pos2 || (*pos2 == (char) 0x00))
                        pprinter_data->driver = "HP LaserJet IIIP";     /* no printer driver supplied set default */
                else
                {
                        pprinter_data->driver = xmalloc(strlen(pos2) + 1);
                        strcpy(pprinter_data->driver, pos2);
                }

                printf("PRINTER %s to %s driver %s\n", g_rdpdr_device[*id].name,
                       pprinter_data->printer, pprinter_data->driver);
                g_rdpdr_device[*id].device_type = DEVICE_TYPE_PRINTER;
                g_rdpdr_device[*id].pdevice_data = (void *) pprinter_data;
                count++;
                (*id)++;

                optarg = pos;
        }
        return count;
}

static NTSTATUS
printer_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition, uint32 flags,
               char *filename, HANDLE * handle)
{
        char cmd[256];
        PRINTER *pprinter_data;

        pprinter_data = (PRINTER *) g_rdpdr_device[device_id].pdevice_data;

        /* default printer name use default printer queue as well in unix */
        if (pprinter_data->printer == "mydeskjet")
        {
                pprinter_data->printer_fp = popen("lpr", "w");
        }
        else
        {
                sprintf(cmd, "lpr -P %s", pprinter_data->printer);
                pprinter_data->printer_fp = popen(cmd, "w");
        }

        g_rdpdr_device[device_id].handle = fileno(pprinter_data->printer_fp);
        *handle = g_rdpdr_device[device_id].handle;
        return STATUS_SUCCESS;
}

static NTSTATUS
printer_close(HANDLE handle)
{
        PRINTER *pprinter_data;

        pprinter_data = get_printer_data(handle);

        g_rdpdr_device[get_device_index(handle)].handle = 0;

        pclose(pprinter_data->printer_fp);

        return STATUS_SUCCESS;
}

static NTSTATUS
printer_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
{
        PRINTER *pprinter_data;

        pprinter_data = get_printer_data(handle);
        *result = length * fwrite(data, length, 1, pprinter_data->printer_fp);

        if (ferror(pprinter_data->printer_fp))
        {
                *result = 0;
                return STATUS_INVALID_HANDLE;
        }
        return STATUS_SUCCESS;
}

DEVICE_FNS printer_fns = {
        printer_create,
        printer_close,
        NULL,                   /* read */
        printer_write,
        NULL                    /* device_control */
};
1	#include "rdesktop.h"
2
3	extern RDPDR_DEVICE g_rdpdr_device[];
4
5	PRINTER *
6	get_printer_data(HANDLE handle)
7	{
8	int index;
9
10	for (index = 0; index < RDPDR_MAX_DEVICES; index++)
11	{
12	if (handle == g_rdpdr_device[index].handle)
13	return (PRINTER *) g_rdpdr_device[index].pdevice_data;
14	}
15	return NULL;
16	}
17
18	int
19	printer_enum_devices(uint32 id, char optarg)
20	{
21	PRINTER *pprinter_data;
22
23	char *pos = optarg;
24	char *pos2;
25	int count = 0;
26	int already = 0;
27
28	// we need to know how many printers we've already set up
29	// supplied from other -r flags than this one.
30	while (count < *id)
31	{
32	if (g_rdpdr_device[count].device_type == DEVICE_TYPE_PRINTER)
33	already++;
34	count++;
35	}
36
37	count = 0;
38
39	if (*optarg == ':')
40	optarg++;
41
42	while ((pos = next_arg(optarg, ',')) && *id < RDPDR_MAX_DEVICES)
43	{
44	pprinter_data = (PRINTER *) xmalloc(sizeof(PRINTER));
45
46	strcpy(g_rdpdr_device[*id].name, "PRN");
47	strcat(g_rdpdr_device[*id].name, ltoa(already + count + 1, 10));
48
49	/* first printer is set as default printer */
50	if ((already + count) == 0)
51	pprinter_data->default_printer = True;
52	else
53	pprinter_data->default_printer = False;
54
55	pos2 = next_arg(optarg, '=');
56	if (*optarg == (char) 0x00)
57	pprinter_data->printer = "mydeskjet"; /* set default */
58	else
59	{
60	pprinter_data->printer = xmalloc(strlen(optarg) + 1);
61	strcpy(pprinter_data->printer, optarg);
62	}
63
64	if (!pos2 \|\| (*pos2 == (char) 0x00))
65	pprinter_data->driver = "HP LaserJet IIIP"; /* no printer driver supplied set default */
66	else
67	{
68	pprinter_data->driver = xmalloc(strlen(pos2) + 1);
69	strcpy(pprinter_data->driver, pos2);
70	}
71
72	printf("PRINTER %s to %s driver %s\n", g_rdpdr_device[*id].name,
73	pprinter_data->printer, pprinter_data->driver);
74	g_rdpdr_device[*id].device_type = DEVICE_TYPE_PRINTER;
75	g_rdpdr_device[id].pdevice_data = (void ) pprinter_data;
76	count++;
77	(*id)++;
78
79	optarg = pos;
80	}
81	return count;
82	}
83
84	static NTSTATUS
85	printer_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition, uint32 flags,
86	char filename, HANDLE handle)
87	{
88	char cmd[256];
89	PRINTER *pprinter_data;
90
91	pprinter_data = (PRINTER *) g_rdpdr_device[device_id].pdevice_data;
92
93	/* default printer name use default printer queue as well in unix */
94	if (pprinter_data->printer == "mydeskjet")
95	{
96	pprinter_data->printer_fp = popen("lpr", "w");
97	}
98	else
99	{
100	sprintf(cmd, "lpr -P %s", pprinter_data->printer);
101	pprinter_data->printer_fp = popen(cmd, "w");
102	}
103
104	g_rdpdr_device[device_id].handle = fileno(pprinter_data->printer_fp);
105	*handle = g_rdpdr_device[device_id].handle;
106	return STATUS_SUCCESS;
107	}
108
109	static NTSTATUS
110	printer_close(HANDLE handle)
111	{
112	PRINTER *pprinter_data;
113
114	pprinter_data = get_printer_data(handle);
115
116	g_rdpdr_device[get_device_index(handle)].handle = 0;
117
118	pclose(pprinter_data->printer_fp);
119
120	return STATUS_SUCCESS;
121	}
122
123	static NTSTATUS
124	printer_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
125	{
126	PRINTER *pprinter_data;
127
128	pprinter_data = get_printer_data(handle);
129	result = length fwrite(data, length, 1, pprinter_data->printer_fp);
130
131	if (ferror(pprinter_data->printer_fp))
132	{
133	*result = 0;
134	return STATUS_INVALID_HANDLE;
135	}
136	return STATUS_SUCCESS;
137	}
138
139	DEVICE_FNS printer_fns = {
140	printer_create,
141	printer_close,
142	NULL, /* read */
143	printer_write,
144	NULL /* device_control */
145	};