Page Menu
Home
GnuPG
Search
Configure Global Search
Log In
Files
F18826119
trustlist.c
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Size
6 KB
Subscribers
None
trustlist.c
View Options
/* trustlist.c - Trust item listing.
* Copyright (C) 2000 Werner Koch (dd9jn)
* Copyright (C) 2001, 2002, 2003, 2004 g10 Code GmbH
*
* This file is part of GPGME.
*
* GPGME is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* GPGME 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see <https://gnu.org/licenses/>.
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#if HAVE_CONFIG_H
#include
<config.h>
#endif
#include
<stdlib.h>
#include
<string.h>
#include
<assert.h>
#include
<errno.h>
#include
"gpgme.h"
#include
"debug.h"
#include
"util.h"
#include
"context.h"
#include
"ops.h"
struct
trust_queue_item_s
{
struct
trust_queue_item_s
*
next
;
gpgme_trust_item_t
item
;
};
typedef
struct
{
/* Something new is available. */
int
trust_cond
;
struct
trust_queue_item_s
*
trust_queue
;
}
*
op_data_t
;
static
gpgme_error_t
trustlist_status_handler
(
void
*
priv
,
gpgme_status_code_t
code
,
char
*
args
)
{
(
void
)
priv
;
(
void
)
code
;
(
void
)
args
;
return
0
;
}
/* This handler is used to parse the output of --list-trust-path:
Format:
level:keyid:type:recno:ot:val:mc:cc:name:
With TYPE = U for a user ID
K for a key
The RECNO is either the one of the dir record or the one of the uid
record. OT is the the usual trust letter and only available on K
lines. VAL is the calculated validity MC is the marginal trust
counter and only available on U lines CC is the same for the
complete count NAME ist the username and only printed on U
lines. */
static
gpgme_error_t
trustlist_colon_handler
(
void
*
priv
,
char
*
line
)
{
gpgme_ctx_t
ctx
=
(
gpgme_ctx_t
)
priv
;
gpgme_error_t
err
;
char
*
p
,
*
pend
;
int
field
=
0
;
gpgme_trust_item_t
item
=
NULL
;
if
(
!
line
)
return
0
;
/* EOF */
for
(
p
=
line
;
p
;
p
=
pend
)
{
field
++
;
pend
=
strchr
(
p
,
':'
);
if
(
pend
)
*
pend
++
=
0
;
switch
(
field
)
{
case
1
:
/* level */
err
=
_gpgme_trust_item_new
(
&
item
);
if
(
err
)
return
err
;
item
->
level
=
atoi
(
p
);
break
;
case
2
:
/* long keyid */
if
(
strlen
(
p
)
==
DIM
(
item
->
keyid
)
-
1
)
strcpy
(
item
->
keyid
,
p
);
break
;
case
3
:
/* type */
item
->
type
=
*
p
==
'K'
?
1
:
*
p
==
'U'
?
2
:
0
;
break
;
case
5
:
/* owner trust */
item
->
_owner_trust
[
0
]
=
*
p
;
break
;
case
6
:
/* validity */
item
->
_validity
[
0
]
=
*
p
;
break
;
case
9
:
/* user ID */
item
->
name
=
strdup
(
p
);
if
(
!
item
->
name
)
{
int
saved_err
=
gpg_error_from_syserror
();
gpgme_trust_item_unref
(
item
);
return
saved_err
;
}
break
;
}
}
if
(
item
)
_gpgme_engine_io_event
(
ctx
->
engine
,
GPGME_EVENT_NEXT_TRUSTITEM
,
item
);
return
0
;
}
void
_gpgme_op_trustlist_event_cb
(
void
*
data
,
gpgme_event_io_t
type
,
void
*
type_data
)
{
gpgme_ctx_t
ctx
=
(
gpgme_ctx_t
)
data
;
gpgme_error_t
err
;
void
*
hook
;
op_data_t
opd
;
gpgme_trust_item_t
item
=
(
gpgme_trust_item_t
)
type_data
;
struct
trust_queue_item_s
*
q
,
*
q2
;
assert
(
type
==
GPGME_EVENT_NEXT_TRUSTITEM
);
err
=
_gpgme_op_data_lookup
(
ctx
,
OPDATA_TRUSTLIST
,
&
hook
,
-1
,
NULL
);
opd
=
hook
;
if
(
err
)
return
;
q
=
malloc
(
sizeof
*
q
);
if
(
!
q
)
{
gpgme_trust_item_unref
(
item
);
/* FIXME: GPGME_Out_Of_Core; */
return
;
}
q
->
item
=
item
;
q
->
next
=
NULL
;
/* FIXME: Use a tail pointer */
q2
=
opd
->
trust_queue
;
if
(
!
q2
)
opd
->
trust_queue
=
q
;
else
{
while
(
q2
->
next
)
q2
=
q2
->
next
;
q2
->
next
=
q
;
}
/* FIXME: unlock queue */
opd
->
trust_cond
=
1
;
}
gpgme_error_t
gpgme_op_trustlist_start
(
gpgme_ctx_t
ctx
,
const
char
*
pattern
,
int
max_level
)
{
gpgme_error_t
err
=
0
;
void
*
hook
;
op_data_t
opd
;
TRACE_BEG
(
DEBUG_CTX
,
"gpgme_op_trustlist_start"
,
ctx
,
"pattern=%s, max_level=%i"
,
pattern
,
max_level
);
if
(
!
ctx
||
!
pattern
||
!*
pattern
)
return
TRACE_ERR
(
gpg_error
(
GPG_ERR_INV_VALUE
));
err
=
_gpgme_op_reset
(
ctx
,
2
);
if
(
err
)
return
TRACE_ERR
(
err
);
err
=
_gpgme_op_data_lookup
(
ctx
,
OPDATA_TRUSTLIST
,
&
hook
,
sizeof
(
*
opd
),
NULL
);
opd
=
hook
;
if
(
err
)
return
TRACE_ERR
(
err
);
_gpgme_engine_set_status_handler
(
ctx
->
engine
,
trustlist_status_handler
,
ctx
);
err
=
_gpgme_engine_set_colon_line_handler
(
ctx
->
engine
,
trustlist_colon_handler
,
ctx
);
if
(
err
)
return
TRACE_ERR
(
err
);
err
=
_gpgme_engine_op_trustlist
(
ctx
->
engine
,
pattern
);
return
TRACE_ERR
(
err
);
}
gpgme_error_t
gpgme_op_trustlist_next
(
gpgme_ctx_t
ctx
,
gpgme_trust_item_t
*
r_item
)
{
gpgme_error_t
err
;
void
*
hook
;
op_data_t
opd
;
struct
trust_queue_item_s
*
q
;
TRACE_BEG
(
DEBUG_CTX
,
"gpgme_op_trustlist_next"
,
ctx
,
""
);
if
(
!
ctx
||
!
r_item
)
return
TRACE_ERR
(
gpg_error
(
GPG_ERR_INV_VALUE
));
*
r_item
=
NULL
;
if
(
!
ctx
)
return
TRACE_ERR
(
gpg_error
(
GPG_ERR_INV_VALUE
));
err
=
_gpgme_op_data_lookup
(
ctx
,
OPDATA_TRUSTLIST
,
&
hook
,
-1
,
NULL
);
opd
=
hook
;
if
(
err
)
return
TRACE_ERR
(
err
);
if
(
opd
==
NULL
)
return
TRACE_ERR
(
gpg_error
(
GPG_ERR_INV_VALUE
));
if
(
!
opd
->
trust_queue
)
{
err
=
_gpgme_wait_on_condition
(
ctx
,
&
opd
->
trust_cond
,
NULL
);
if
(
err
)
return
TRACE_ERR
(
err
);
if
(
!
opd
->
trust_cond
)
return
TRACE_ERR
(
gpg_error
(
GPG_ERR_EOF
));
opd
->
trust_cond
=
0
;
assert
(
opd
->
trust_queue
);
}
q
=
opd
->
trust_queue
;
opd
->
trust_queue
=
q
->
next
;
*
r_item
=
q
->
item
;
free
(
q
);
if
((
*
r_item
)
->
type
==
1
)
{
TRACE_SUC
(
"trust_item=%p: %s: owner trust %s with level %i "
"and validity %s"
,
*
r_item
,
(
*
r_item
)
->
keyid
,
(
*
r_item
)
->
owner_trust
,
(
*
r_item
)
->
level
,
(
*
r_item
)
->
validity
);
}
else
if
((
*
r_item
)
->
type
==
2
)
{
TRACE_SUC
(
"trust_item=%p: %s: UID %s with level %i "
"and validity %s"
,
*
r_item
,
(
*
r_item
)
->
keyid
,
(
*
r_item
)
->
name
,
(
*
r_item
)
->
level
,
(
*
r_item
)
->
validity
);
}
else
{
TRACE_SUC
(
"trust_item=%p: %s: unknown type %i with level %i "
"and validity %s"
,
*
r_item
,
(
*
r_item
)
->
keyid
,
(
*
r_item
)
->
type
,
(
*
r_item
)
->
level
,
(
*
r_item
)
->
validity
);
}
return
0
;
}
/* Terminate a pending trustlist operation within CTX. */
gpgme_error_t
gpgme_op_trustlist_end
(
gpgme_ctx_t
ctx
)
{
TRACE
(
DEBUG_CTX
,
"gpgme_op_trustlist_end"
,
ctx
,
""
);
if
(
!
ctx
)
return
gpg_error
(
GPG_ERR_INV_VALUE
);
return
0
;
}
File Metadata
Details
Attached
Mime Type
text/x-c
Expires
Mon, Dec 23, 4:17 PM (14 h, 11 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
8f/94/1971d7d22214a36b1960c6fd577c
Attached To
rM GPGME
Event Timeline
Log In to Comment