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	matthewc	432	#include "rdesktop.h"
2
3	n-ki	569	extern RDPDR_DEVICE g_rdpdr_device[];
4	matthewc	432
5	astrand	580	PRINTER *
6			get_printer_data(HANDLE handle)
7	n-ki	569	{
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	stargo	602	printer_enum_devices(uint32 id, char optarg)
20	n-ki	569	{
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	n-ki	582	pos2 = next_arg(optarg, '=');
56	n-ki	569	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	matthewc	432	static NTSTATUS
85	n-ki	569	printer_create(uint32 device_id, uint32 access, uint32 share_mode, uint32 disposition, uint32 flags,
86			char filename, HANDLE handle)
87	matthewc	432	{
88	n-ki	569	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	stargo	570	g_rdpdr_device[device_id].handle = fileno(pprinter_data->printer_fp);
105	n-ki	569	*handle = g_rdpdr_device[device_id].handle;
106	matthewc	432	return STATUS_SUCCESS;
107			}
108
109			static NTSTATUS
110			printer_close(HANDLE handle)
111			{
112	n-ki	569	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	matthewc	432	return STATUS_SUCCESS;
121			}
122
123			static NTSTATUS
124	n-ki	569	printer_write(HANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
125	matthewc	432	{
126	n-ki	569	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	matthewc	432	return STATUS_SUCCESS;
137			}
138
139	astrand	435	DEVICE_FNS printer_fns = {
140	matthewc	432	printer_create,
141			printer_close,
142	astrand	435	NULL, /* read */
143	matthewc	432	printer_write,
144	astrand	435	NULL /* device_control */
145	matthewc	432	};