trunk/Src/wptKeyTrustPathDlg.cpp

/* wptKeyTrustPathDlg.cpp - List a trust path for a key.
 *      Copyright (C) 2001, 2002, 2003 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
 */
#if 0
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <commctrl.h>

#include "resource.h"
#include "wptGPGME.h"
#include "wptCommonCtl.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptDlgs.h"
#include "wptTypes.h"
#include "wptNLS.h"

struct trust_path_s {
    int level;
    int type;
    char otrust[2];
    char valid[2];
    char keyid[16+1];
    char uid[128];
};


static void
copy_trust_item(trust_path_s *tp, GpgmeTrustItem ti)
{
    const char *t;
    
    tp->level = gpgme_trust_item_get_int_attr( ti, GPGME_ATTR_LEVEL, NULL, 0 );
    tp->type = gpgme_trust_item_get_int_attr( ti, GPGME_ATTR_TYPE, NULL, 0 );
    t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_OTRUST, NULL, 0);
    strcpy( tp->otrust, t );
    t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_VALIDITY, NULL, 0 );
    strcpy( tp->valid, t );
    t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_KEYID, NULL, 0 );
    strcpy( tp->keyid, t );
    t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_USERID, NULL, 0 );
    strcpy( tp->uid, t );
} /* copy_trust_item */


static HTREEITEM
treeview_insert_item( HWND tree, HTREEITEM parent, const char *text )
{
    TVINSERTSTRUCT ti;
    HTREEITEM node;
    
    memset( &ti, 0, sizeof ti );
    ti.hParent = parent;
    ti.hInsertAfter = TVI_LAST;
    ti.item.mask = TVIF_TEXT;
    ti.item.pszText = (char *)text;     
    node = TreeView_InsertItem( tree, &ti );
    return node;
} /* treeview_insert_item */


HTREEITEM
treeview_create_child_item( HWND tree, trust_path_s *tp, HTREEITEM parent )
{
    char info[1024];
    HTREEITEM node;
    
    if( tp->type == 0 ) /* root */
        _snprintf( info, sizeof info-1, "%s", tp->uid );
    else if( tp->type == 1 )/* key */
        _snprintf(info, sizeof info -1, "0x%s (otrust=%s, validity=%s)",
                  tp->keyid, tp->otrust, tp->valid );
    else if( tp->type == 2 ) /* userid */
        _snprintf( info, sizeof info -1, "%s (validity=%s)", tp->uid, tp->valid );    
    node = treeview_insert_item( tree, parent, info );
    return node;
} /* treeview_create_child_item */


void
treeview_add_trustpath(HWND tree, HTREEITEM node, trust_path_s c[], int n, int level)
{
    HTREEITEM _node;
    int i;

    for( i=0; i<n; i++ ) {
        if( c[i].level == level ) {
            _node = treeview_create_child_item( tree, &c[i], node );
            treeview_add_trustpath( tree, _node, c, n, i );
        }       
    }
} /* treeview_add_trustpath */


BOOL CALLBACK
keytrust_dlg_proc( HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam )
{
    winpt_key_t k;
    HWND tree;  
    GpgmeTrustItem trust_item;
    gpgme_ctx_t ctx;
    gpgme_error_t ec;
    trust_path_s tp[256] = {0};
    int pos = 0;
    
    switch( msg ) {
    case WM_INITDIALOG:
        if( !lparam )
            dlg_fatal_error( dlg, "Could not get dialog param!" );
        k = (winpt_key_t )lparam;
#ifndef LANG_DE
        SetWindowText( dlg, _("List Trust Path") );
#endif
        tree = GetDlgItem( dlg, IDC_KEYTRUST_TREE );
        ec = gpgme_new( &ctx );
        if( ec )
            BUG( NULL );
        ec = gpgme_op_trustlist_start( ctx, k->keyid, 6 );
        if( ec ) {
            msg_box( dlg, gpgme_strerror( err ), _("Trustlist"), MB_ERR );
            gpgme_release( ctx );
            return FALSE;
        }        
        memset( &tp[0], 0, sizeof tp[0] );
        tp[0].level = -1; pos++;
        strcpy( tp[0].uid, k->uid );
        strcpy( tp[0].keyid, k->keyid );
        
        while( !gpgme_op_trustlist_next( ctx, &trust_item ) ) {
            copy_trust_item( &tp[pos++], trust_item );
            if( pos > 256 )
                break;
            gpgme_trust_item_release( trust_item );
        }
        gpgme_release( ctx );
        treeview_add_trustpath( tree, NULL, tp, pos, -1 );
        return TRUE;
        
    case WM_SYSCOMMAND:
        if( LOWORD( wparam ) == SC_CLOSE )
            EndDialog( dlg, FALSE );
        return FALSE;
        
    case WM_COMMAND:
        switch( LOWORD(wparam) ) {
        case IDOK:
            EndDialog( dlg, TRUE );
            return TRUE;
        }
    }
    
    return FALSE;
} /* keytrust_dlg_proc */
#else
#include <windows.h>
BOOL CALLBACK keytrust_dlg_proc( HWND dlg, UINT msg, WPARAM wparam, 
                                LPARAM lparam ) { return FALSE; }
/* GPG 1.2.x does not support this yet */
#endif
1	werner	36	/* wptKeyTrustPathDlg.cpp - List a trust path for a key.
2			* Copyright (C) 2001, 2002, 2003 Timo Schulz
3			*
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			#if 0
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25			#include <windows.h>
26			#include <commctrl.h>
27
28	werner	47	#include "resource.h"
29	werner	36	#include "wptGPGME.h"
30			#include "wptCommonCtl.h"
31			#include "wptContext.h" /* for passphrase_s */
32			#include "wptDlgs.h"
33			#include "wptTypes.h"
34			#include "wptNLS.h"
35
36			struct trust_path_s {
37			int level;
38			int type;
39			char otrust[2];
40			char valid[2];
41			char keyid[16+1];
42			char uid[128];
43			};
44
45
46			static void
47			copy_trust_item(trust_path_s *tp, GpgmeTrustItem ti)
48			{
49			const char *t;
50
51			tp->level = gpgme_trust_item_get_int_attr( ti, GPGME_ATTR_LEVEL, NULL, 0 );
52			tp->type = gpgme_trust_item_get_int_attr( ti, GPGME_ATTR_TYPE, NULL, 0 );
53			t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_OTRUST, NULL, 0);
54			strcpy( tp->otrust, t );
55			t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_VALIDITY, NULL, 0 );
56			strcpy( tp->valid, t );
57			t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_KEYID, NULL, 0 );
58			strcpy( tp->keyid, t );
59			t = gpgme_trust_item_get_string_attr( ti, GPGME_ATTR_USERID, NULL, 0 );
60			strcpy( tp->uid, t );
61			} /* copy_trust_item */
62
63
64			static HTREEITEM
65			treeview_insert_item( HWND tree, HTREEITEM parent, const char *text )
66			{
67			TVINSERTSTRUCT ti;
68			HTREEITEM node;
69
70			memset( &ti, 0, sizeof ti );
71			ti.hParent = parent;
72			ti.hInsertAfter = TVI_LAST;
73			ti.item.mask = TVIF_TEXT;
74			ti.item.pszText = (char *)text;
75			node = TreeView_InsertItem( tree, &ti );
76			return node;
77			} /* treeview_insert_item */
78
79
80			HTREEITEM
81			treeview_create_child_item( HWND tree, trust_path_s *tp, HTREEITEM parent )
82			{
83			char info[1024];
84			HTREEITEM node;
85
86			if( tp->type == 0 ) /* root */
87			_snprintf( info, sizeof info-1, "%s", tp->uid );
88			else if( tp->type == 1 )/* key */
89			_snprintf(info, sizeof info -1, "0x%s (otrust=%s, validity=%s)",
90			tp->keyid, tp->otrust, tp->valid );
91			else if( tp->type == 2 ) /* userid */
92			_snprintf( info, sizeof info -1, "%s (validity=%s)", tp->uid, tp->valid );
93			node = treeview_insert_item( tree, parent, info );
94			return node;
95			} /* treeview_create_child_item */
96
97
98			void
99			treeview_add_trustpath(HWND tree, HTREEITEM node, trust_path_s c[], int n, int level)
100			{
101			HTREEITEM _node;
102			int i;
103
104			for( i=0; i<n; i++ ) {
105			if( c[i].level == level ) {
106			_node = treeview_create_child_item( tree, &c[i], node );
107			treeview_add_trustpath( tree, _node, c, n, i );
108			}
109			}
110			} /* treeview_add_trustpath */
111
112
113			BOOL CALLBACK
114			keytrust_dlg_proc( HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam )
115			{
116			winpt_key_t k;
117			HWND tree;
118			GpgmeTrustItem trust_item;
119			gpgme_ctx_t ctx;
120			gpgme_error_t ec;
121			trust_path_s tp[256] = {0};
122			int pos = 0;
123
124			switch( msg ) {
125			case WM_INITDIALOG:
126			if( !lparam )
127			dlg_fatal_error( dlg, "Could not get dialog param!" );
128			k = (winpt_key_t )lparam;
129			#ifndef LANG_DE
130			SetWindowText( dlg, _("List Trust Path") );
131			#endif
132			tree = GetDlgItem( dlg, IDC_KEYTRUST_TREE );
133			ec = gpgme_new( &ctx );
134			if( ec )
135			BUG( NULL );
136			ec = gpgme_op_trustlist_start( ctx, k->keyid, 6 );
137			if( ec ) {
138			msg_box( dlg, gpgme_strerror( err ), _("Trustlist"), MB_ERR );
139			gpgme_release( ctx );
140			return FALSE;
141			}
142			memset( &tp[0], 0, sizeof tp[0] );
143			tp[0].level = -1; pos++;
144			strcpy( tp[0].uid, k->uid );
145			strcpy( tp[0].keyid, k->keyid );
146
147			while( !gpgme_op_trustlist_next( ctx, &trust_item ) ) {
148			copy_trust_item( &tp[pos++], trust_item );
149			if( pos > 256 )
150			break;
151			gpgme_trust_item_release( trust_item );
152			}
153			gpgme_release( ctx );
154			treeview_add_trustpath( tree, NULL, tp, pos, -1 );
155			return TRUE;
156
157			case WM_SYSCOMMAND:
158			if( LOWORD( wparam ) == SC_CLOSE )
159			EndDialog( dlg, FALSE );
160			return FALSE;
161
162			case WM_COMMAND:
163			switch( LOWORD(wparam) ) {
164			case IDOK:
165			EndDialog( dlg, TRUE );
166			return TRUE;
167			}
168			}
169
170			return FALSE;
171	twoaday	2	} /* keytrust_dlg_proc */
172	werner	36	#else
173			#include <windows.h>
174			BOOL CALLBACK keytrust_dlg_proc( HWND dlg, UINT msg, WPARAM wparam,
175			LPARAM lparam ) { return FALSE; }
176			/* GPG 1.2.x does not support this yet */
177			#endif