trunk/Include/wptKeyCache.h

/* wptKeyCache.h
 *      Copyright (C) 2005, 2006 Timo Schulz
 *
 * 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
 */
#ifndef WPT_KEYCACHE_H
#define WPT_KEYCACHE_H

enum keycache_flag_t {
    KC_FLAG_ADD = 1,
    KC_FLAG_UPD = 2
};

struct keycache_s {
    struct keycache_s * next;
    int flags;
    gpgme_key_t key;                    /* actual key context. */
    struct keycache_s *pubpart;         /* corresponding public key. */
    struct {
        unsigned int is_protected:1;    /* key is protected. */
        unsigned int divert_to_card:1;  /* secret key on card. */
        unsigned int has_desig_rev:1;   /* has desig. revokers. */
    } gloflags;
    struct {
        unsigned int   flags;
        unsigned char *d;           /* attribute (JPG) data. */
        unsigned int   len;         /* attribute data length. */
        gpgme_validity_t validity;  /* attribute id validity. */
    } attrib;
    unsigned char *sym_prefs;/* symmetric cipher preferences. */
    char *card_type;        /* if != NULL key stored on smart card. */
};

struct gpg_keycache_s {    
    struct keycache_s *item;
    struct keycache_s *tmp;
    int secret;
    int pos;
    void (*cb) (void *, const char *, int, int, int);
    void *cb_value;
    int cb_value2;
};
typedef struct gpg_keycache_s *gpg_keycache_t;

gpgme_error_t gpg_keycache_new (gpg_keycache_t * r_ctx);
void gpg_keycache_release (gpg_keycache_t ctx);
void gpg_keycache_set_cb (gpg_keycache_t ctx,
                            void (*cb)(void *, const char *, int, int, int),
                            void * cb_value1, int cb_value2);
void gpg_keycache_rewind (gpg_keycache_t ctx);
int gpg_keycache_get_size (gpg_keycache_t ctx);
gpgme_error_t gpg_keycache_add_key (gpg_keycache_t ctx, gpgme_key_t key, 
                                      void **opaque);
gpgme_error_t gpg_keycache_update_key (gpg_keycache_t ctx, int is_sec, 
                                         void *opaque, const char *keyid);
gpgme_error_t gpg_keycache_find_key (gpg_keycache_t ctx, const char * pattern,
                                       int flags, gpgme_key_t * r_key);
gpgme_error_t gpg_keycache_find_key2 (gpg_keycache_t ctx, const char *pattern, int flags,
                                        gpgme_key_t *r_key, struct keycache_s **r_item);
gpgme_error_t gpg_keycache_delete_key (gpg_keycache_t ctx, 
                                         const char * pattern);
gpgme_error_t gpg_keycache_init (gpg_keycache_t ctx, const char * pattern, 
                                   int secret);
gpgme_error_t gpg_keycache_next_key (gpg_keycache_t ctx, int flags,
                                       gpgme_key_t * r_key);
gpgme_error_t gpg_keycache_prepare (gpg_keycache_t ctx, 
                                      const char *pubring, const char * secring);
gpgme_error_t gpg_keycache_prepare_single (gpg_keycache_t ctx, 
                                             const char *keyid,
                                             const char *pubr, 
                                             const char *secr);
gpgme_error_t gpg_keycache_sync (gpg_keycache_t pub, gpg_keycache_t sec);
gpgme_error_t gpg_keycache_next_updated_key (gpg_keycache_t ctx,
                                             struct keycache_s **r_obj,
                                             int *r_status);

#endif /*WPT_KEYCACHE_H*/
1	twoaday	38	/* wptKeyCache.h
2	twoaday	146	* Copyright (C) 2005, 2006 Timo Schulz
3	twoaday	38	*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20			#ifndef WPT_KEYCACHE_H
21			#define WPT_KEYCACHE_H
22
23	twoaday	151	enum keycache_flag_t {
24			KC_FLAG_ADD = 1,
25			KC_FLAG_UPD = 2
26			};
27
28	twoaday	38	struct keycache_s {
29			struct keycache_s * next;
30			int flags;
31			gpgme_key_t key; /* actual key context. */
32			struct keycache_s pubpart; / corresponding public key. */
33			struct {
34			unsigned int is_protected:1; /* key is protected. */
35			unsigned int divert_to_card:1; /* secret key on card. */
36			unsigned int has_desig_rev:1; /* has desig. revokers. */
37			} gloflags;
38			struct {
39	twoaday	133	unsigned int flags;
40	twoaday	38	unsigned char d; / attribute (JPG) data. */
41			unsigned int len; /* attribute data length. */
42			gpgme_validity_t validity; /* attribute id validity. */
43			} attrib;
44			unsigned char sym_prefs;/ symmetric cipher preferences. */
45			char card_type; / if != NULL key stored on smart card. */
46			};
47
48			struct gpg_keycache_s {
49			struct keycache_s *item;
50			struct keycache_s *tmp;
51			int secret;
52			int pos;
53			void (cb) (void , const char *, int, int, int);
54			void *cb_value;
55			int cb_value2;
56			};
57			typedef struct gpg_keycache_s *gpg_keycache_t;
58
59			gpgme_error_t gpg_keycache_new (gpg_keycache_t * r_ctx);
60			void gpg_keycache_release (gpg_keycache_t ctx);
61			void gpg_keycache_set_cb (gpg_keycache_t ctx,
62			void (cb)(void , const char *, int, int, int),
63			void * cb_value1, int cb_value2);
64			void gpg_keycache_rewind (gpg_keycache_t ctx);
65			int gpg_keycache_get_size (gpg_keycache_t ctx);
66			gpgme_error_t gpg_keycache_add_key (gpg_keycache_t ctx, gpgme_key_t key,
67			void **opaque);
68			gpgme_error_t gpg_keycache_update_key (gpg_keycache_t ctx, int is_sec,
69			void opaque, const char keyid);
70			gpgme_error_t gpg_keycache_find_key (gpg_keycache_t ctx, const char * pattern,
71			int flags, gpgme_key_t * r_key);
72			gpgme_error_t gpg_keycache_find_key2 (gpg_keycache_t ctx, const char *pattern, int flags,
73			gpgme_key_t r_key, struct keycache_s *r_item);
74			gpgme_error_t gpg_keycache_delete_key (gpg_keycache_t ctx,
75			const char * pattern);
76			gpgme_error_t gpg_keycache_init (gpg_keycache_t ctx, const char * pattern,
77			int secret);
78			gpgme_error_t gpg_keycache_next_key (gpg_keycache_t ctx, int flags,
79			gpgme_key_t * r_key);
80			gpgme_error_t gpg_keycache_prepare (gpg_keycache_t ctx,
81			const char pubring, const char secring);
82			gpgme_error_t gpg_keycache_prepare_single (gpg_keycache_t ctx,
83			const char *keyid,
84			const char *pubr,
85			const char *secr);
86			gpgme_error_t gpg_keycache_sync (gpg_keycache_t pub, gpg_keycache_t sec);
87	twoaday	146	gpgme_error_t gpg_keycache_next_updated_key (gpg_keycache_t ctx,
88	twoaday	151	struct keycache_s **r_obj,
89			int *r_status);
90	twoaday	38
91			#endif /WPT_KEYCACHE_H/