trunk/Src/wptFileCBS.cpp

/* wptFileCBS.cpp - Customized I/O callbacks for GPGME
 *      Copyright (C) 2005 Timo Schulz
 *      Copyright (C) 2005 g10 Code GmbH
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation; either version 2 
 * of the License, or (at your option) any later version.
 *  
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License 
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <stdio.h>
#include <errno.h>
#include <malloc.h>

#include "gpgme.h"
#include "wptListView.h"
#include "wptGPG.h"
#include "wptFileManager.h"
#include "wptErrors.h"
#include "wptTypes.h"

void progress_callback (void *opaque, const char *what, int type, 
                        int off, int max);


/* Predefined read callback. */
static long
read_cb (void *handle, void *buffer, size_t size)
{
    file_data_t cb = (file_data_t)handle;
    struct progress_filter_s *pfx = (struct progress_filter_s *)cb->cb_value;
    DWORD nread = 0;

    if (cb->error)
        return -1;

    if (!ReadFile (cb->handle, buffer, size, &nread, NULL)) {
        cb->error = (int)GetLastError ();
        return -1;
    }

    /* XXX: there is a sync problem with the progress dialog. */
    if (pfx)
        progress_callback (pfx, NULL, 0, cb->off, cb->size);
    cb->off += nread;
    return (long)nread;
}


/* Predefined write callback. */
static long
write_cb (void *handle, const void *buffer, size_t size)
{
    file_data_t cb = (file_data_t)handle;
    DWORD nwritten;

    if (cb->error)
        return -1;

    if (!cb->handle) {
        SECURITY_ATTRIBUTES sec_attr;

        memset (&sec_attr, 0, sizeof (sec_attr));
        sec_attr.bInheritHandle = FALSE;
        sec_attr.nLength = sizeof (sec_attr);
        cb->handle = CreateFile (cb->name, GENERIC_WRITE, FILE_SHARE_WRITE,
                                 &sec_attr, CREATE_ALWAYS, 0, NULL);
        if (cb->handle == INVALID_HANDLE_VALUE) {
            cb->error = (int)GetLastError ();
            return -1;
        }
    }

    if (!WriteFile (cb->handle, buffer, size, &nwritten, NULL)) {
        cb->error = (int)GetLastError ();
        return -1;
    }
    return (long)nwritten;
}


/* Create a new data -> file association with a static callback.
   @fname is the file which is associated to the object.
   @r_cb is the context which holds all information.
   @for_read is 1 if the file is opened for read only.
   Return value: 0 on success. */
gpgme_error_t
gpg_file_data_new (const char *fname, int flags, file_data_t *r_cb)
                      
{
    gpgme_error_t err;
    file_data_t cb;
    HANDLE fd = NULL;
    SECURITY_ATTRIBUTES sec_attr;

    memset (&sec_attr, 0, sizeof (sec_attr));
    sec_attr.bInheritHandle = FALSE;
    sec_attr.nLength = sizeof (sec_attr);
    if (flags & F_DATA_READ) {
        fd = CreateFile (fname, GENERIC_READ, FILE_SHARE_READ,
                         &sec_attr, OPEN_EXISTING, 0, NULL);
        if (fd == INVALID_HANDLE_VALUE)
            return gpgme_err_code_from_errno (ENOENT);
    }
    cb = (file_data_t)calloc (1, sizeof *cb);
    if (!cb)
        BUG (NULL);
    cb->name = strdup (fname);
    if (!cb->name)
        BUG (NULL);
    cb->cbs.read = read_cb;
    cb->cbs.write = write_cb;
    if (flags & F_DATA_READ) {
        cb->handle = fd;
        cb->size = GetFileSize (fd, NULL);
        cb->off = 0;
    }

    err = gpgme_data_new_from_cbs  (&cb->dat, &cb->cbs, cb);
    if (err) {
        CloseHandle (fd);
        free (cb);
        return err;
    }

    *r_cb = cb;
    return err;
}


/* Activate the progress callback for the given object @ctx. */
void
gpg_file_data_set_cb (file_data_t ctx, struct progress_filter_s *pfx)
{
    ctx->cb_value = (void*)pfx;
}


/* Release the context in @cb. Close all internal handles if possible. */
void
gpg_file_data_release (file_data_t cb)
{
    if (!cb)
        return;
    if (cb->handle) {
        CloseHandle (cb->handle);
        cb->handle = NULL;
    }
    if (cb->dat)
        gpgme_data_release (cb->dat);
    safe_free (cb->name);
    safe_free (cb);
}
1	twoaday	119	/* wptFileCBS.cpp - Customized I/O callbacks for GPGME
2	werner	36	* Copyright (C) 2005 Timo Schulz
3			* Copyright (C) 2005 g10 Code GmbH
4			*
5			* This file is part of WinPT.
6			*
7			* WinPT is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU General Public License
9			* as published by the Free Software Foundation; either version 2
10			* of the License, or (at your option) any later version.
11			*
12			* WinPT is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with WinPT; if not, write to the Free Software Foundation,
19			* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20			*/
21	twoaday	197
22	werner	36	#ifdef HAVE_CONFIG_H
23			#include <config.h>
24			#endif
25
26			#include <windows.h>
27			#include <stdio.h>
28	twoaday	119	#include <errno.h>
29	werner	36	#include <malloc.h>
30
31			#include "gpgme.h"
32			#include "wptListView.h"
33			#include "wptGPG.h"
34			#include "wptFileManager.h"
35			#include "wptErrors.h"
36			#include "wptTypes.h"
37
38	twoaday	119	void progress_callback (void opaque, const char what, int type,
39			int off, int max);
40	werner	36
41
42			/* Predefined read callback. */
43			static long
44			read_cb (void handle, void buffer, size_t size)
45			{
46			file_data_t cb = (file_data_t)handle;
47			struct progress_filter_s pfx = (struct progress_filter_s )cb->cb_value;
48	twoaday	119	DWORD nread = 0;
49	werner	36
50	twoaday	197	if (cb->error)
51			return -1;
52	twoaday	119
53	twoaday	197	if (!ReadFile (cb->handle, buffer, size, &nread, NULL)) {
54			cb->error = (int)GetLastError ();
55			return -1;
56			}
57
58	werner	36	/* XXX: there is a sync problem with the progress dialog. */
59			if (pfx)
60			progress_callback (pfx, NULL, 0, cb->off, cb->size);
61	twoaday	119	cb->off += nread;
62			return (long)nread;
63	werner	36	}
64
65
66			/* Predefined write callback. */
67			static long
68			write_cb (void handle, const void buffer, size_t size)
69			{
70			file_data_t cb = (file_data_t)handle;
71	twoaday	119	DWORD nwritten;
72	werner	36
73	twoaday	197	if (cb->error)
74			return -1;
75	twoaday	119
76			if (!cb->handle) {
77			SECURITY_ATTRIBUTES sec_attr;
78
79			memset (&sec_attr, 0, sizeof (sec_attr));
80			sec_attr.bInheritHandle = FALSE;
81			sec_attr.nLength = sizeof (sec_attr);
82			cb->handle = CreateFile (cb->name, GENERIC_WRITE, FILE_SHARE_WRITE,
83			&sec_attr, CREATE_ALWAYS, 0, NULL);
84	twoaday	197	if (cb->handle == INVALID_HANDLE_VALUE) {
85			cb->error = (int)GetLastError ();
86			return -1;
87			}
88	twoaday	119	}
89
90	twoaday	197	if (!WriteFile (cb->handle, buffer, size, &nwritten, NULL)) {
91			cb->error = (int)GetLastError ();
92			return -1;
93			}
94	twoaday	119	return (long)nwritten;
95	werner	36	}
96
97
98			/* Create a new data -> file association with a static callback.
99			@fname is the file which is associated to the object.
100			@r_cb is the context which holds all information.
101			@for_read is 1 if the file is opened for read only.
102			Return value: 0 on success. */
103			gpgme_error_t
104	twoaday	119	gpg_file_data_new (const char fname, int flags, file_data_t r_cb)
105	werner	36
106			{
107			gpgme_error_t err;
108			file_data_t cb;
109	twoaday	119	HANDLE fd = NULL;
110			SECURITY_ATTRIBUTES sec_attr;
111	werner	36
112	twoaday	119	memset (&sec_attr, 0, sizeof (sec_attr));
113			sec_attr.bInheritHandle = FALSE;
114			sec_attr.nLength = sizeof (sec_attr);
115			if (flags & F_DATA_READ) {
116			fd = CreateFile (fname, GENERIC_READ, FILE_SHARE_READ,
117			&sec_attr, OPEN_EXISTING, 0, NULL);
118			if (fd == INVALID_HANDLE_VALUE)
119			return gpgme_err_code_from_errno (ENOENT);
120			}
121	werner	36	cb = (file_data_t)calloc (1, sizeof *cb);
122			if (!cb)
123	twoaday	119	BUG (NULL);
124			cb->name = strdup (fname);
125			if (!cb->name)
126			BUG (NULL);
127	werner	36	cb->cbs.read = read_cb;
128			cb->cbs.write = write_cb;
129	twoaday	119	if (flags & F_DATA_READ) {
130			cb->handle = fd;
131			cb->size = GetFileSize (fd, NULL);
132	werner	36	cb->off = 0;
133			}
134
135			err = gpgme_data_new_from_cbs (&cb->dat, &cb->cbs, cb);
136			if (err) {
137	twoaday	119	CloseHandle (fd);
138	werner	36	free (cb);
139			return err;
140			}
141
142			*r_cb = cb;
143			return err;
144			}
145
146
147			/* Activate the progress callback for the given object @ctx. */
148			void
149			gpg_file_data_set_cb (file_data_t ctx, struct progress_filter_s *pfx)
150			{
151			ctx->cb_value = (void*)pfx;
152			}
153
154
155			/* Release the context in @cb. Close all internal handles if possible. */
156			void
157			gpg_file_data_release (file_data_t cb)
158			{
159			if (!cb)
160			return;
161			if (cb->handle) {
162	twoaday	119	CloseHandle (cb->handle);
163			cb->handle = NULL;
164	werner	36	}
165			if (cb->dat)
166			gpgme_data_release (cb->dat);
167	twoaday	119	safe_free (cb->name);
168			safe_free (cb);
169	werner	36	}