printercache.c File Reference

#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include "rdesktop.h"

Include dependency graph for printercache.c:

Go to the source code of this file.

Functions
static BOOL	printercache_mkdir (char *base, char *printer)
static BOOL	printercache_unlink_blob (char *printer)
static BOOL	printercache_rename_blob (char *printer, char *new_printer)
int	printercache_load_blob (char *printer_name, uint8 **data)
static void	printercache_save_blob (char *printer_name, uint8 *data, uint32 length)
void	printercache_process (RDPCLIENT *This, STREAM s)

Function Documentation

printercache_load_blob()

int printercache_load_blob	(	char *	printer_name,
		uint8 **	data
	)

Definition at line 154 of file printercache.c.

{
    char *home, *path;
    struct stat st;
    int fd, length;
 
    if (printer_name == NULL)
        return 0;
 
    *data = NULL;
 
    home = getenv("HOME");
    if (home == NULL)
        return 0;
 
    path = (char *) xmalloc(strlen(home) + sizeof("/.rdesktop/rdpdr/") + strlen(printer_name) +
                sizeof("/AutoPrinterCacheData") + 1);
    sprintf(path, "%s/.rdesktop/rdpdr/%s/AutoPrinterCacheData", home, printer_name);
 
    fd = open(path, O_RDONLY);
    if (fd == -1)
    {
        xfree(path);
        return 0;
    }
 
    if (fstat(fd, &st))
    {
        xfree(path);
        close(fd);
        return 0;
    }
 
    *data = (uint8 *) xmalloc(st.st_size);
    length = read(fd, *data, st.st_size);
    close(fd);
    xfree(path);
    return length;
}

Referenced by announcedata_size().

printercache_mkdir()

static BOOL printercache_mkdir ( char *  base, char *  printer  )

static

Definition at line 40 of file printercache.c.

{
    char *path;
 
    path = (char *) xmalloc(strlen(base) + sizeof("/.rdesktop/rdpdr/") + strlen(printer) + 1);
 
    sprintf(path, "%s/.rdesktop", base);
    if ((mkdir(path, 0700) == -1) && errno != EEXIST)
    {
        perror(path);
        xfree(path);
        return False;
    }
 
    strcat(path, "/rdpdr");
    if ((mkdir(path, 0700) == -1) && errno != EEXIST)
    {
        perror(path);
        xfree(path);
        return False;
    }
 
    strcat(path, "/");
    strcat(path, printer);
    if ((mkdir(path, 0700) == -1) && errno != EEXIST)
    {
        perror(path);
        xfree(path);
        return False;
    }
 
    xfree(path);
    return True;
}

Referenced by printercache_save_blob().

printercache_process()

void printercache_process	(	RDPCLIENT *	This,
		STREAM	s
	)

Definition at line 233 of file printercache.c.

{
    uint32 type, printer_length, driver_length, printer_unicode_length, blob_length;
    char device_name[9], printer[256], driver[256];
 
    in_uint32_le(s, type);
    switch (type)
    {
        case 4: /* rename item */
            in_uint8(s, printer_length);
            in_uint8s(s, 0x3);  /* padding */
            in_uint8(s, driver_length);
            in_uint8s(s, 0x3);  /* padding */
 
            /* NOTE - 'driver' doesn't contain driver, it contains the new printer name */
 
            rdp_in_unistr(This, s, printer, printer_length);
            rdp_in_unistr(This, s, driver, driver_length);
 
            printercache_rename_blob(printer, driver);
            break;
 
        case 3: /* delete item */
            in_uint8(s, printer_unicode_length);
            in_uint8s(s, 0x3);  /* padding */
            printer_length = rdp_in_unistr(This, s, printer, printer_unicode_length);
            printercache_unlink_blob(printer);
            break;
 
        case 2: /* save printer data */
            in_uint32_le(s, printer_unicode_length);
            in_uint32_le(s, blob_length);
 
            if (printer_unicode_length < 2 * 255)
            {
                rdp_in_unistr(This, s, printer, printer_unicode_length);
                printercache_save_blob(printer, s->p, blob_length);
            }
            break;
 
        case 1: /* save device data */
            in_uint8a(s, device_name, 5);   /* get LPTx/COMx name */
 
            /* need to fetch this data so that we can get the length of the packet to store. */
            in_uint8s(s, 0x2);  /* ??? */
            in_uint8s(s, 0x2)   /* pad?? */
                in_uint32_be(s, driver_length);
            in_uint32_be(s, printer_length);
            in_uint8s(s, 0x7)   /* pad?? */
                /* next is driver in unicode */
                /* next is printer in unicode */
                /* TODO: figure out how to use this information when reconnecting */
                /* actually - all we need to store is the driver and printer */
                /* and figure out what the first word is. */
                /* rewind stream so that we can save this blob   */
                /* length is driver_length + printer_length + 19 */
                /* rewind stream */
                s->p = s->p - 19;
 
            printercache_save_blob(device_name, s->p,
                           driver_length + printer_length + 19);
            break;
        default:
 
            unimpl("RDPDR Printer Cache Packet Type: %d\n", type);
            break;
    }
}

printercache_rename_blob()

static BOOL printercache_rename_blob ( char *  printer, char *  new_printer  )

static

Definition at line 113 of file printercache.c.

{
    char *printer_path;
    char *new_printer_path;
    int printer_maxlen;
 
    char *home;
 
    if (printer == NULL)
        return False;
 
    home = getenv("HOME");
    if (home == NULL)
        return False;
 
    printer_maxlen =
        (strlen(printer) >
         strlen(new_printer) ? strlen(printer) : strlen(new_printer)) + strlen(home) +
        sizeof("/.rdesktop/rdpdr/") + 1;
 
    printer_path = (char *) xmalloc(printer_maxlen);
    new_printer_path = (char *) xmalloc(printer_maxlen);
 
    sprintf(printer_path, "%s/.rdesktop/rdpdr/%s", home, printer);
    sprintf(new_printer_path, "%s/.rdesktop/rdpdr/%s", home, new_printer);
 
    printf("%s,%s\n", printer_path, new_printer_path);
    if (rename(printer_path, new_printer_path) < 0)
    {
        xfree(printer_path);
        xfree(new_printer_path);
        return False;
    }
 
    xfree(printer_path);
    xfree(new_printer_path);
    return True;
}

Referenced by printercache_process().

printercache_save_blob()

static void printercache_save_blob ( char *  printer_name, uint8 *  data, uint32  length  )

static

Definition at line 195 of file printercache.c.

{
    char *home, *path;
    int fd;
 
    if (printer_name == NULL)
        return;
 
    home = getenv("HOME");
    if (home == NULL)
        return;
 
    if (!printercache_mkdir(home, printer_name))
        return;
 
    path = (char *) xmalloc(strlen(home) + sizeof("/.rdesktop/rdpdr/") + strlen(printer_name) +
                sizeof("/AutoPrinterCacheData") + 1);
    sprintf(path, "%s/.rdesktop/rdpdr/%s/AutoPrinterCacheData", home, printer_name);
 
    fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600);
    if (fd == -1)
    {
        perror(path);
        xfree(path);
        return;
    }
 
    if (write(fd, data, length) != length)
    {
        perror(path);
        unlink(path);
    }
 
    close(fd);
    xfree(path);
}

Referenced by printercache_process().

printercache_unlink_blob()

static BOOL printercache_unlink_blob ( char *  printer )

static

Definition at line 76 of file printercache.c.

{
    char *path;
    char *home;
 
    if (printer == NULL)
        return False;
 
    home = getenv("HOME");
    if (home == NULL)
        return False;
 
    path = (char *) xmalloc(strlen(home) + sizeof("/.rdesktop/rdpdr/") + strlen(printer) +
                sizeof("/AutoPrinterCacheData") + 1);
 
    sprintf(path, "%s/.rdesktop/rdpdr/%s/AutoPrinterCacheData", home, printer);
 
    if (unlink(path) < 0)
    {
        xfree(path);
        return False;
    }
 
    sprintf(path, "%s/.rdesktop/rdpdr/%s", home, printer);
 
    if (rmdir(path) < 0)
    {
        xfree(path);
        return False;
    }
 
    xfree(path);
    return True;
}

Referenced by printercache_process().