trunk/rdesktop/printer.c

#define MAX_PRINTERS    5

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