1 /* vim:tw=78:ts=8:sw=4:set ft=c: */
3 Copyright (C) 2006-2009 Ben Kibbey <bjk@luxsci.net>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02110-1301 USA
26 #include <sys/socket.h>
35 #include <sys/types.h>
37 #include <sys/select.h>
39 #include <netinet/in.h>
40 #include <sys/socket.h>
52 #define DNS_USE_GETTIMEOFDAY_FOR_ID 1
54 #include <arpa/nameser.h>
66 #define N_(msgid) dgettext("libpwmd", msgid)
73 static int gelapsed
, gtimeout
;
74 static gpg_error_t
pinentry_command(pwm_t
*pwm
, char **result
, const char *cmd
);
75 static gpg_error_t global_error
;
78 static char *_getpwuid(struct passwd
*pwd
)
80 size_t size
= sysconf(_SC_GETPW_R_SIZE_MAX
);
81 struct passwd
*result
;
88 buf
= pwmd_malloc(size
);
93 n
= getpwuid_r(getuid(), pwd
, buf
, size
, &result
);
110 const char *_pwmd_strerror(gpg_error_t e
)
112 gpg_err_code_t code
= gpg_err_code(e
);
114 if (code
>= GPG_ERR_USER_1
&& code
< gpg_err_code(EPWMD_MAX
)) {
119 return N_("Unknown error");
121 return N_("No cache slots available");
123 return N_("Recursion loop");
125 return N_("No file is open");
127 return N_("General LibXML error");
129 return N_("File modified");
131 return N_("Access denied");
138 const char *pwmd_strerror(gpg_error_t e
)
140 const char *p
= _pwmd_strerror(e
);
142 return p
? p
: gpg_strerror(e
);
145 int pwmd_strerror_r(gpg_error_t e
, char *buf
, size_t size
)
147 const char *p
= _pwmd_strerror(e
);
150 snprintf(buf
, size
, "%s", p
);
152 if (strlen(p
) > size
)
158 return gpg_strerror_r(e
, buf
, size
);
161 gpg_error_t
pwmd_init()
163 static int initialized
;
172 bindtextdomain("libpwmd", LOCALEDIR
);
175 assuan_set_malloc_hooks(pwmd_malloc
, pwmd_realloc
, pwmd_free
);
176 assuan_set_assuan_err_source(GPG_ERR_SOURCE_DEFAULT
);
181 static gpg_error_t
_socket_connect_finalize(pwm_t
*pwm
)
184 int n
= assuan_get_active_fds(pwm
->ctx
, 0, active
, sizeof(active
));
186 pwm
->fd
= n
<= 0 ? -1 : dup(active
[0]);
189 pwm
->pinentry_tries
= 3;
191 assuan_set_pointer(pwm
->ctx
, pwm
);
194 return pwmd_command(pwm
, NULL
, "OPTION CLIENT NAME=%s", pwm
->name
);
200 static int read_hook(assuan_context_t ctx
, assuan_fd_t fd
, void *data
,
201 size_t len
, ssize_t
*ret
)
203 pwm_t
*pwm
= assuan_get_pointer(ctx
);
205 if (!pwm
|| !pwm
->tcp_conn
)
207 *ret
= pth_read((int)fd
, data
, len
);
209 *ret
= read((int)fd
, data
, len
);
213 *ret
= libssh2_channel_read(pwm
->tcp_conn
->channel
, data
, len
);
214 } while (*ret
== LIBSSH2_ERROR_EAGAIN
);
217 return *ret
<= 0 ? 0 : 1;
220 static int write_hook(assuan_context_t ctx
, assuan_fd_t fd
, const void *data
,
221 size_t len
, ssize_t
*ret
)
223 pwm_t
*pwm
= assuan_get_pointer(ctx
);
225 if (!pwm
|| !pwm
->tcp_conn
)
227 *ret
= pth_write((int)fd
, data
, len
);
229 *ret
= write((int)fd
, data
, len
);
233 *ret
= libssh2_channel_write(pwm
->tcp_conn
->channel
, data
, len
);
234 } while (*ret
== LIBSSH2_ERROR_EAGAIN
);
237 return *ret
<= 0 ? 0 : 1;
240 static void _ssh_deinit(pwmd_tcp_conn_t
*conn
);
241 static void free_tcp_conn(pwmd_tcp_conn_t
*conn
)
246 if (conn
->username
) {
247 pwmd_free(conn
->username
);
248 conn
->username
= NULL
;
251 if (conn
->known_hosts
) {
252 pwmd_free(conn
->known_hosts
);
253 conn
->known_hosts
= NULL
;
256 if (conn
->identity
) {
257 pwmd_free(conn
->identity
);
258 conn
->identity
= NULL
;
261 if (conn
->identity_pub
) {
262 pwmd_free(conn
->identity_pub
);
263 conn
->identity_pub
= NULL
;
267 pwmd_free(conn
->host
);
272 pwmd_free(conn
->hostkey
);
273 conn
->hostkey
= NULL
;
277 ares_destroy(conn
->chan
);
282 ares_free_hostent(conn
->he
);
297 static void _ssh_deinit(pwmd_tcp_conn_t
*conn
)
303 libssh2_channel_free(conn
->channel
);
306 libssh2_session_disconnect(conn
->session
, "Bye!");
307 libssh2_session_free(conn
->session
);
310 conn
->session
= NULL
;
311 conn
->channel
= NULL
;
315 static void _ssh_assuan_deinit(assuan_context_t ctx
)
317 pwm_t
*pwm
= assuan_get_pointer(ctx
);
319 _ssh_deinit(pwm
->tcp_conn
);
320 pwm
->tcp_conn
= NULL
;
324 * Sets common options from both pwmd_tcp_connect() and
325 * pwmd_tcp_connect_async().
327 static gpg_error_t
init_tcp_conn(pwmd_tcp_conn_t
**dst
, const char *host
,
328 int port
, const char *identity
, const char *user
, const char *hosts
,
331 pwmd_tcp_conn_t
*conn
;
336 return GPG_ERR_INV_ARG
;
339 if (!host
|| !identity
|| !hosts
)
340 return GPG_ERR_INV_ARG
;
343 conn
= pwmd_calloc(1, sizeof(pwmd_tcp_conn_t
));
346 return gpg_error_from_errno(ENOMEM
);
348 conn
->port
= port
== -1 ? 22 : port
;
349 conn
->host
= pwmd_strdup(host
);
352 rc
= gpg_error_from_errno(ENOMEM
);
358 char *pwbuf
= _getpwuid(&pw
);
361 rc
= gpg_error_from_errno(errno
);
365 conn
->username
= pwmd_strdup(user
? user
: pw
.pw_name
);
368 if (!conn
->username
) {
369 rc
= gpg_error_from_errno(ENOMEM
);
373 conn
->identity
= pwmd_strdup(identity
);
375 if (!conn
->identity
) {
376 rc
= gpg_error_from_errno(ENOMEM
);
380 conn
->identity_pub
= pwmd_malloc(strlen(conn
->identity
)+5);
382 if (!conn
->identity_pub
) {
383 rc
= gpg_error_from_errno(ENOMEM
);
387 sprintf(conn
->identity_pub
, "%s.pub", conn
->identity
);
388 conn
->known_hosts
= pwmd_strdup(hosts
);
390 if (!conn
->known_hosts
) {
391 rc
= gpg_error_from_errno(ENOMEM
);
404 static gpg_error_t
do_connect(pwm_t
*pwm
, int prot
, void *addr
)
406 struct sockaddr_in their_addr
;
408 pwm
->tcp_conn
->fd
= socket(prot
, SOCK_STREAM
, 0);
410 if (pwm
->tcp_conn
->fd
== -1)
411 return gpg_error_from_syserror();
413 if (pwm
->tcp_conn
->async
)
414 fcntl(pwm
->tcp_conn
->fd
, F_SETFL
, O_NONBLOCK
);
416 pwm
->cmd
= ASYNC_CMD_CONNECT
;
417 their_addr
.sin_family
= prot
;
418 their_addr
.sin_port
= htons(pwm
->tcp_conn
->port
);
419 their_addr
.sin_addr
= *((struct in_addr
*)addr
);
420 memset(their_addr
.sin_zero
, '\0', sizeof their_addr
.sin_zero
);
423 if (pth_connect(pwm
->tcp_conn
->fd
, (struct sockaddr
*)&their_addr
,
424 sizeof(their_addr
)) == -1)
426 if (connect(pwm
->tcp_conn
->fd
, (struct sockaddr
*)&their_addr
,
427 sizeof(their_addr
)) == -1)
429 return gpg_error_from_syserror();
434 static gpg_error_t
ares_error_to_pwmd(int status
)
436 if (status
!= ARES_SUCCESS
)
437 warnx("%s", ares_strerror(status
));
443 return GPG_ERR_UNKNOWN_HOST
;
445 return GPG_ERR_EHOSTDOWN
;
447 return GPG_ERR_TIMEOUT
;
449 return gpg_error_from_errno(ENOMEM
);
450 case ARES_ECONNREFUSED
:
451 return GPG_ERR_ECONNREFUSED
;
454 return GPG_ERR_EHOSTUNREACH
;
460 static void dns_resolve_cb(void *arg
, int status
, int timeouts
,
461 unsigned char *abuf
, int alen
)
467 if (status
== ARES_EDESTRUCTION
)
470 if (status
!= ARES_SUCCESS
) {
471 pwm
->tcp_conn
->rc
= ares_error_to_pwmd(status
);
475 //FIXME localhost. works with ipv4. maybe local system config error
476 /* Check for an IPv6 address first. */
477 rc
= ares_parse_a_reply(abuf
, alen
, &he
, NULL
, NULL
);
479 if (rc
!= ARES_SUCCESS
) {
480 if (rc
!= ARES_ENODATA
) {
481 pwm
->tcp_conn
->rc
= ares_error_to_pwmd(status
);
485 rc
= ares_parse_aaaa_reply(abuf
, alen
, &he
, NULL
, NULL
);
487 if (rc
!= ARES_SUCCESS
) {
488 pwm
->tcp_conn
->rc
= ares_error_to_pwmd(status
);
493 pwm
->tcp_conn
->he
= he
;
494 pwm
->tcp_conn
->rc
= do_connect(pwm
, he
->h_addrtype
, he
->h_addr
);
497 static gpg_error_t
_do_pwmd_tcp_connect_async(pwm_t
*pwm
, const char *host
,
498 int port
, const char *identity
, const char *user
,
499 const char *known_hosts
, pwmd_async_cmd_t which
)
501 pwmd_tcp_conn_t
*conn
;
504 rc
= init_tcp_conn(&conn
, host
, port
, identity
, user
, known_hosts
,
505 which
== ASYNC_CMD_HOSTKEY
? 1 : 0);
511 pwm
->tcp_conn
= conn
;
512 pwm
->tcp_conn
->cmd
= which
;
514 if (pwm
->tcp_conn
->cmd
== ASYNC_CMD_HOSTKEY
)
515 pwm
->tcp_conn
->get_only
= 1;
517 pwm
->cmd
= ASYNC_CMD_DNS
;
518 pwm
->state
= ASYNC_PROCESS
;
519 ares_init(&pwm
->tcp_conn
->chan
);
520 ares_query(pwm
->tcp_conn
->chan
, pwm
->tcp_conn
->host
, ns_c_any
, ns_t_any
,
521 dns_resolve_cb
, pwm
);
525 gpg_error_t
pwmd_tcp_connect_async(pwm_t
*pwm
, const char *host
, int port
,
526 const char *identity
, const char *user
, const char *known_hosts
)
528 return _do_pwmd_tcp_connect_async(pwm
, host
, port
, identity
, user
,
529 known_hosts
, ASYNC_CMD_CONNECT
);
532 static void *_ssh_malloc(size_t size
, void **data
)
534 return pwmd_malloc(size
);
537 static void _ssh_free(void *ptr
, void **data
)
542 static void *_ssh_realloc(void *ptr
, size_t size
, void **data
)
544 return pwmd_realloc(ptr
, size
);
547 static char *to_hex(const char *str
, size_t slen
)
550 char *buf
= pwmd_malloc(slen
*2+1);
555 for (i
= 0, buf
[0] = 0; i
< slen
; i
++) {
558 sprintf(tmp
, "%02x", (unsigned char)str
[i
]);
565 static int verify_host_key(pwm_t
*pwm
)
567 FILE *fp
= fopen(pwm
->tcp_conn
->known_hosts
, "r");
573 buf
= pwmd_malloc(LINE_MAX
);
578 while ((p
= fgets(buf
, LINE_MAX
, fp
))) {
579 if (*p
== '#' || isspace(*p
))
582 if (p
[strlen(p
)-1] == '\n')
585 if (!strcmp(buf
, pwm
->tcp_conn
->hostkey
))
602 static gpg_error_t
authenticate_ssh(pwm_t
*pwm
)
604 const char *fp
= libssh2_hostkey_hash(pwm
->tcp_conn
->session
,
605 LIBSSH2_HOSTKEY_HASH_SHA1
);
608 pwm
->tcp_conn
->hostkey
= to_hex(fp
, 20);
610 if (!pwm
->tcp_conn
->hostkey
)
611 return gpg_error_from_errno(ENOMEM
);
613 if (pwm
->tcp_conn
->get_only
)
616 if (!fp
|| verify_host_key(pwm
))
617 return GPG_ERR_CHECKSUM
;
619 userauth
= libssh2_userauth_list(pwm
->tcp_conn
->session
,
620 pwm
->tcp_conn
->username
, strlen(pwm
->tcp_conn
->username
));
622 if (!userauth
|| !strstr(userauth
, "publickey"))
623 return GPG_ERR_BAD_PIN_METHOD
;
625 if (libssh2_userauth_publickey_fromfile(pwm
->tcp_conn
->session
,
626 pwm
->tcp_conn
->username
, pwm
->tcp_conn
->identity_pub
,
627 pwm
->tcp_conn
->identity
, NULL
))
628 return GPG_ERR_BAD_SECKEY
;
633 static gpg_error_t
setup_tcp_session(pwm_t
*pwm
)
635 assuan_context_t ctx
;
636 struct assuan_io_hooks io_hooks
= {read_hook
, write_hook
};
639 pwm
->tcp_conn
->session
= libssh2_session_init_ex(_ssh_malloc
, _ssh_free
,
642 if (!pwm
->tcp_conn
->session
) {
643 rc
= gpg_error_from_errno(ENOMEM
);
647 if (libssh2_session_startup(pwm
->tcp_conn
->session
, pwm
->tcp_conn
->fd
)) {
648 rc
= GPG_ERR_ASSUAN_SERVER_FAULT
;
652 rc
= authenticate_ssh(pwm
);
657 /* pwmd_get_hostkey(). */
658 if (pwm
->tcp_conn
->get_only
) {
659 pwm
->result
= pwmd_strdup(pwm
->tcp_conn
->hostkey
);
662 rc
= gpg_error_from_errno(ENOMEM
);
669 pwm
->tcp_conn
->channel
= libssh2_channel_open_session(pwm
->tcp_conn
->session
);
671 if (!pwm
->tcp_conn
->channel
) {
672 rc
= GPG_ERR_ASSUAN_SERVER_FAULT
;
676 if (libssh2_channel_shell(pwm
->tcp_conn
->channel
)) {
677 rc
= GPG_ERR_ASSUAN_SERVER_FAULT
;
681 assuan_set_io_hooks(&io_hooks
);
682 rc
= assuan_socket_connect_fd(&ctx
, pwm
->tcp_conn
->fd
, 0, pwm
);
687 assuan_set_finish_handler(ctx
, _ssh_assuan_deinit
);
689 return _socket_connect_finalize(pwm
);
692 free_tcp_conn(pwm
->tcp_conn
);
693 pwm
->tcp_conn
= NULL
;
697 static gpg_error_t
_do_pwmd_tcp_connect(pwm_t
*pwm
, const char *host
, int port
,
698 const char *identity
, const char *user
, const char *known_hosts
, int get
)
700 pwmd_tcp_conn_t
*conn
;
703 rc
= init_tcp_conn(&conn
, host
, port
, identity
, user
, known_hosts
, get
);
708 pwm
->tcp_conn
= conn
;
709 pwm
->tcp_conn
->get_only
= get
;
710 pwm
->cmd
= ASYNC_CMD_DNS
;
711 ares_init(&pwm
->tcp_conn
->chan
);
712 ares_query(pwm
->tcp_conn
->chan
, pwm
->tcp_conn
->host
, ns_c_any
, ns_t_any
,
713 dns_resolve_cb
, pwm
);
715 /* dns_resolve_cb() may have already been called. */
716 if (pwm
->tcp_conn
->rc
) {
717 rc
= pwm
->tcp_conn
->rc
;
722 * Fake a blocking DNS lookup. libcares does a better job than
732 n
= ares_fds(pwm
->tcp_conn
->chan
, &rfds
, &wfds
);
733 ares_timeout(pwm
->tcp_conn
->chan
, NULL
, &tv
);
735 n
= pth_select(n
, &rfds
, &wfds
, NULL
, &tv
);
737 n
= select(n
, &rfds
, &wfds
, NULL
, &tv
);
741 rc
= gpg_error_from_syserror();
745 rc
= GPG_ERR_TIMEOUT
;
749 ares_process(pwm
->tcp_conn
->chan
, &rfds
, &wfds
);
751 if (pwm
->tcp_conn
->rc
)
753 } while (pwm
->cmd
== ASYNC_CMD_DNS
);
755 if (pwm
->tcp_conn
->rc
) {
756 rc
= pwm
->tcp_conn
->rc
;
760 return setup_tcp_session(pwm
);
766 gpg_error_t
pwmd_tcp_connect(pwm_t
*pwm
, const char *host
, int port
,
767 const char *identity
, const char *user
, const char *known_hosts
)
769 return _do_pwmd_tcp_connect(pwm
, host
, port
, identity
, user
, known_hosts
, 0);
772 /* Must free the result with pwmd_free(). */
773 gpg_error_t
pwmd_get_hostkey(const char *host
, int port
, char **result
)
776 pwm_t
*pwm
= pwmd_new(NULL
);
780 return gpg_error_from_errno(ENOMEM
);
782 rc
= _do_pwmd_tcp_connect(pwm
, host
, port
, NULL
, NULL
, NULL
, 1);
789 hostkey
= pwmd_strdup(pwm
->tcp_conn
->hostkey
);
792 rc
= gpg_error_from_errno(ENOMEM
);
799 gpg_error_t
pwmd_get_hostkey_async(pwm_t
*pwm
, const char *host
, int port
)
801 return _do_pwmd_tcp_connect_async(pwm
, host
, port
, NULL
, NULL
, NULL
,
806 gpg_error_t
pwmd_connect(pwm_t
*pwm
, const char *path
)
808 char *socketpath
= NULL
;
809 assuan_context_t ctx
;
811 char *pwbuf
= _getpwuid(&pw
);
815 return gpg_error_from_errno(errno
);
818 socketpath
= (char *)pwmd_malloc(strlen(pw
.pw_dir
) + strlen("/.pwmd/socket") + 1);
819 sprintf(socketpath
, "%s/.pwmd/socket", pw
.pw_dir
);
822 socketpath
= pwmd_strdup(path
);
825 rc
= assuan_socket_connect_ext(&ctx
, socketpath
, -1, 0);
826 pwmd_free(socketpath
);
832 return _socket_connect_finalize(pwm
);
835 void pwmd_close(pwm_t
*pwm
)
841 assuan_disconnect(pwm
->ctx
);
844 pwmd_free(pwm
->password
);
847 pwmd_free(pwm
->title
);
850 pwmd_free(pwm
->desc
);
853 pwmd_free(pwm
->prompt
);
855 if (pwm
->pinentry_tty
)
856 pwmd_free(pwm
->pinentry_tty
);
858 if (pwm
->pinentry_display
)
859 pwmd_free(pwm
->pinentry_display
);
861 if (pwm
->pinentry_term
)
862 pwmd_free(pwm
->pinentry_term
);
865 pwmd_free(pwm
->lcctype
);
868 pwmd_free(pwm
->lcmessages
);
871 pwmd_free(pwm
->filename
);
874 pwmd_free(pwm
->name
);
878 free_tcp_conn(pwm
->tcp_conn
);
884 static int mem_realloc_cb(void *data
, const void *buffer
, size_t len
)
886 membuf_t
*mem
= (membuf_t
*)data
;
892 if ((p
= pwmd_realloc(mem
->buf
, mem
->len
+ len
)) == NULL
)
896 memcpy((char *)mem
->buf
+ mem
->len
, buffer
, len
);
901 static int _inquire_cb(void *data
, const char *keyword
)
903 pwm_t
*pwm
= (pwm_t
*)data
;
905 int flags
= fcntl(pwm
->fd
, F_GETFL
);
907 /* Shouldn't get this far without a callback. */
908 if (!pwm
->inquire_func
)
909 return GPG_ERR_INV_ARG
;
912 * Since the socket file descriptor is probably set to non-blocking, set to
913 * blocking to prevent GPG_ERR_EAGAIN errors. This should be fixes when
914 * asynchronous INQUIRE is supported by either libassuan or a later
917 fcntl(pwm
->fd
, F_SETFL
, 0);
924 rc
= pwm
->inquire_func(pwm
->inquire_data
, keyword
, rc
, &result
, &len
);
925 rc
= gpg_err_code(rc
);
927 if (rc
== GPG_ERR_EOF
|| !rc
) {
928 if (len
<= 0 || !result
|| !*result
) {
933 arc
= assuan_send_data(pwm
->ctx
, result
, len
);
935 if (rc
== GPG_ERR_EOF
) {
946 fcntl(pwm
->fd
, F_SETFL
, flags
);
950 gpg_error_t
pwmd_finalize(pwm_t
*pwm
)
953 return GPG_ERR_INV_ARG
;
955 if (pwm
->cmd
== ASYNC_CMD_NONE
|| pwm
->state
!= ASYNC_DONE
)
956 return GPG_ERR_INV_STATE
;
958 pwm
->state
= ASYNC_INIT
;
959 pwm
->cmd
= ASYNC_CMD_NONE
;
962 if (pwm
->cmd
== ASYNC_CMD_CONNECT
|| pwm
->cmd
== ASYNC_CMD_DNS
) {
963 gpg_error_t rc
= pwm
->tcp_conn
->rc
;
965 /* pwm is no longer a valid handle. */
974 return GPG_ERR_INV_ARG
;
978 pwm
->is_open_cmd
= 0;
983 static gpg_error_t
do_nb_command(pwm_t
*pwm
, const char *cmd
, const char *arg
)
987 size_t len
= strlen(cmd
) + 2;
989 len
+= arg
? strlen(arg
) : 0;
991 if (pwm
->state
!= ASYNC_INIT
)
992 return GPG_ERR_INV_STATE
;
994 buf
= (char *)pwmd_malloc(len
);
997 rc
= gpg_error_from_errno(ENOMEM
);
1001 snprintf(buf
, len
, "%s %s", cmd
, arg
? arg
: "");
1002 rc
= assuan_write_line(pwm
->ctx
, buf
);
1006 pwm
->state
= ASYNC_PROCESS
;
1012 gpg_error_t
pwmd_open_async(pwm_t
*pwm
, const char *filename
)
1014 if (!pwm
|| !filename
)
1015 return GPG_ERR_INV_ARG
;
1017 /* For pinentry retries. */
1018 if (!pwm
->is_open_cmd
) {
1020 pwmd_free(pwm
->filename
);
1022 pwm
->filename
= pwmd_strdup(filename
);
1025 pwm
->is_open_cmd
= 1;
1026 pwm
->cmd
= ASYNC_CMD_OPEN
;
1027 return do_nb_command(pwm
, "OPEN", filename
);
1030 gpg_error_t
pwmd_save_async(pwm_t
*pwm
)
1033 return GPG_ERR_INV_ARG
;
1035 pwm
->cmd
= ASYNC_CMD_SAVE
;
1036 return do_nb_command(pwm
, "SAVE", NULL
);
1039 static gpg_error_t
parse_assuan_line(pwm_t
*pwm
)
1045 rc
= assuan_read_line(pwm
->ctx
, &line
, &len
);
1048 if (line
[0] == 'O' && line
[1] == 'K' &&
1049 (line
[2] == 0 || line
[2] == ' ')) {
1050 pwm
->state
= ASYNC_DONE
;
1052 else if (line
[0] == '#') {
1054 else if (line
[0] == 'S' && (line
[1] == 0 || line
[1] == ' ')) {
1055 if (pwm
->status_func
) {
1056 pwm
->status_func(pwm
->status_data
,
1057 line
[1] == 0 ? line
+1 : line
+2);
1060 else if (line
[0] == 'E' && line
[1] == 'R' && line
[2] == 'R' &&
1061 (line
[3] == 0 || line
[3] == ' ')) {
1064 pwm
->state
= ASYNC_DONE
;
1071 gpg_error_t
pwmd_pending_line(pwm_t
*pwm
)
1074 return GPG_ERR_INV_ARG
;
1077 return GPG_ERR_INV_STATE
;
1079 return assuan_pending_line(pwm
->ctx
) ? 0 : GPG_ERR_NO_DATA
;
1082 pwmd_async_t
pwmd_process(pwm_t
*pwm
, gpg_error_t
*rc
, const char **result
)
1086 struct timeval tv
= {0, 0};
1091 *rc
= GPG_ERR_INV_ARG
;
1095 if (pwm
->state
== ASYNC_DONE
)
1098 /* When not in a command, this will let libassuan process status messages
1099 * by calling PWMD_OPTION_STATUS_FUNC. The client can poll the file
1100 * descriptor returned by pwmd_get_fd() to determine when this should be
1101 * called or call pwmd_pending_line() to determine whether a buffered line
1102 * needs to be processed. */
1103 if (pwm
->cmd
== ASYNC_CMD_NONE
) {
1104 *rc
= assuan_command(pwm
, pwm
->ctx
, NULL
, "NOP");
1109 if (pwm
->cmd
== ASYNC_CMD_DNS
) {
1112 if (pwm
->tcp_conn
->rc
) {
1113 *rc
= pwm
->tcp_conn
->rc
;
1114 close(pwm
->tcp_conn
->fd
);
1115 pwm
->tcp_conn
->fd
= -1;
1116 pwm
->state
= ASYNC_DONE
;
1122 n
= ares_fds(pwm
->tcp_conn
->chan
, &rfds
, &wfds
);
1124 /* Shouldn't happen. */
1129 n
= pth_select(n
, &rfds
, &wfds
, NULL
, &tv
);
1131 n
= select(n
, &rfds
, &wfds
, NULL
, &tv
);
1135 ares_process(pwm
->tcp_conn
->chan
, &rfds
, &wfds
);
1139 else if (pwm
->cmd
== ASYNC_CMD_CONNECT
) {
1140 if (pwm
->tcp_conn
->rc
== GPG_ERR_EINPROGRESS
) {
1142 socklen_t len
= sizeof(int);
1145 FD_SET(pwm
->tcp_conn
->fd
, &fds
);
1147 n
= pth_select(pwm
->tcp_conn
->fd
+1, NULL
, &fds
, NULL
, &tv
);
1149 n
= select(pwm
->tcp_conn
->fd
+1, NULL
, &fds
, NULL
, &tv
);
1152 if (!n
|| !FD_ISSET(pwm
->tcp_conn
->fd
, &fds
))
1155 *rc
= gpg_error_from_syserror();
1156 close(pwm
->tcp_conn
->fd
);
1157 pwm
->tcp_conn
->fd
= -1;
1158 pwm
->state
= ASYNC_DONE
;
1162 ret
= getsockopt(pwm
->tcp_conn
->fd
, SOL_SOCKET
, SO_ERROR
, &n
, &len
);
1165 *rc
= ret
? gpg_error_from_syserror() : gpg_error_from_errno(n
);
1166 close(pwm
->tcp_conn
->fd
);
1167 pwm
->tcp_conn
->fd
= -1;
1168 pwm
->state
= ASYNC_DONE
;
1172 else if (pwm
->tcp_conn
->rc
) {
1173 *rc
= pwm
->tcp_conn
->rc
;
1174 close(pwm
->tcp_conn
->fd
);
1175 pwm
->tcp_conn
->fd
= -1;
1176 pwm
->state
= ASYNC_DONE
;
1180 fcntl(pwm
->tcp_conn
->fd
, F_SETFL
, 0);
1181 *rc
= setup_tcp_session(pwm
);
1182 pwm
->state
= ASYNC_DONE
;
1188 *rc
= GPG_ERR_INV_ARG
;
1192 /* This is for the non-blocking OPEN and SAVE commands. */
1194 FD_SET(pwm
->fd
, &fds
);
1196 n
= pth_select(pwm
->fd
+1, &fds
, NULL
, NULL
, &tv
);
1198 n
= select(pwm
->fd
+1, &fds
, NULL
, NULL
, &tv
);
1202 if (FD_ISSET(pwm
->fd
, &fds
))
1203 *rc
= parse_assuan_line(pwm
);
1206 while (!*rc
&& assuan_pending_line(pwm
->ctx
))
1207 *rc
= parse_assuan_line(pwm
);
1209 /* For pinentry retries. */
1210 if (pwm
->is_open_cmd
&& gpg_err_code(*rc
) == EPWMD_BADKEY
&&
1211 ++pwm
->ntries
< pwm
->pinentry_tries
) {
1212 pwm
->state
= ASYNC_INIT
;
1213 *rc
= pwmd_open_async(pwm
, pwm
->filename
);
1219 static gpg_error_t
assuan_command(pwm_t
*pwm
, assuan_context_t ctx
,
1220 char **result
, const char *cmd
)
1228 rc
= assuan_transact(ctx
, cmd
, mem_realloc_cb
, &data
, _inquire_cb
, pwm
,
1229 pwm
->status_func
, pwm
->status_data
);
1233 pwmd_free(data
.buf
);
1239 mem_realloc_cb(&data
, "", 1);
1242 pwmd_free(data
.buf
);
1243 rc
= GPG_ERR_INV_ARG
;
1246 *result
= (char *)data
.buf
;
1250 return gpg_err_code(rc
);
1253 gpg_error_t
pwmd_inquire(pwm_t
*pwm
, const char *cmd
, pwmd_inquire_fn fn
,
1256 if (!pwm
|| !cmd
|| !fn
)
1257 return GPG_ERR_INV_ARG
;
1259 pwm
->inquire_func
= fn
;
1260 pwm
->inquire_data
= data
;
1261 return assuan_command(pwm
, pwm
->ctx
, NULL
, cmd
);
1264 gpg_error_t
pwmd_terminate_pinentry(pwm_t
*pwm
)
1266 #ifndef WITH_PINENTRY
1267 return GPG_ERR_NOT_IMPLEMENTED
;
1269 pid_t pid
= pwm
->pid
;
1273 if (!pwm
|| pid
== -1)
1274 return GPG_ERR_INV_ARG
;
1276 if (kill(pid
, 0) == 0) {
1277 if (kill(pid
, SIGTERM
) == -1) {
1278 if (kill(pid
, SIGKILL
) == -1)
1279 return gpg_error_from_errno(errno
);
1282 pwm
->pin_error
= GPG_ERR_TIMEOUT
;
1285 return gpg_error_from_errno(errno
);
1291 #ifdef WITH_PINENTRY
1292 static gpg_error_t
set_pinentry_strings(pwm_t
*pwm
, int which
)
1295 char tmp
[ASSUAN_LINELENGTH
];
1299 pwm
->title
= pwmd_strdup(N_("LibPWMD"));
1302 pwm
->prompt
= pwmd_strdup(N_("Passphrase:"));
1304 if (!pwm
->desc
&& !which
)
1305 pwm
->desc
= pwmd_strdup(N_("Enter a passphrase."));
1308 snprintf(tmp
, sizeof(tmp
), "SETERROR %s", N_("Invalid passphrase, please try again."));
1309 buf
= pwmd_strdup(tmp
);
1311 else if (which
== 2) {
1312 snprintf(tmp
, sizeof(tmp
), "SETERROR %s", N_("Please type the passphrase again for confirmation."));
1313 buf
= pwmd_strdup(tmp
);
1316 buf
= (char *)pwmd_malloc(strlen("SETERROR ") + strlen(pwm
->desc
) + 1);
1317 sprintf(buf
, "SETERROR %s", pwm
->desc
);
1320 error
= pinentry_command(pwm
, NULL
, buf
);
1326 buf
= (char *)pwmd_malloc(strlen("SETPROMPT ") + strlen(pwm
->prompt
) + 1);
1327 sprintf(buf
, "SETPROMPT %s", pwm
->prompt
);
1328 error
= pinentry_command(pwm
, NULL
, buf
);
1334 buf
= (char *)pwmd_malloc(strlen("SETDESC ") + strlen(pwm
->title
) + 1);
1335 sprintf(buf
, "SETDESC %s", pwm
->title
);
1336 error
= pinentry_command(pwm
, NULL
, buf
);
1341 static void update_pinentry_settings(pwm_t
*pwm
)
1347 char *pwbuf
= _getpwuid(&pw
);
1352 snprintf(buf
, sizeof(buf
), "%s/.pwmd/pinentry.conf", pw
.pw_dir
);
1355 if ((fp
= fopen(buf
, "r")) == NULL
)
1358 while ((p
= fgets(buf
, sizeof(buf
), fp
)) != NULL
) {
1359 char name
[32], val
[256];
1361 if (sscanf(p
, " %31[a-zA-Z] = %255s", name
, val
) != 2)
1364 if (strcasecmp(name
, "TTYNAME") == 0) {
1365 pwmd_free(pwm
->pinentry_tty
);
1366 pwm
->pinentry_tty
= pwmd_strdup(val
);
1368 else if (strcasecmp(name
, "TTYTYPE") == 0) {
1369 pwmd_free(pwm
->pinentry_term
);
1370 pwm
->pinentry_term
= pwmd_strdup(val
);
1372 else if (strcasecmp(name
, "DISPLAY") == 0) {
1373 pwmd_free(pwm
->pinentry_display
);
1374 pwm
->pinentry_display
= pwmd_strdup(val
);
1376 else if (strcasecmp(name
, "PATH") == 0) {
1377 pwmd_free(pwm
->pinentry_path
);
1378 pwm
->pinentry_path
= pwmd_strdup(val
);
1385 static gpg_error_t
launch_pinentry(pwm_t
*pwm
)
1388 assuan_context_t ctx
;
1389 int child_list
[] = {-1};
1390 char *display
= getenv("DISPLAY");
1391 const char *argv
[10];
1392 const char **p
= argv
;
1393 int have_display
= 0;
1395 char *ttybuf
= NULL
;
1397 update_pinentry_settings(pwm
);
1399 if (pwm
->pinentry_display
|| display
)
1402 if (!pwm
->pinentry_tty
) {
1403 ttybuf
= pwmd_malloc(255);
1406 return gpg_error_from_errno(ENOMEM
);
1408 rc
= ttyname_r(STDOUT_FILENO
, ttybuf
, 255);
1412 return gpg_error_from_errno(rc
);
1418 tty
= pwm
->pinentry_tty
;
1421 if (!have_display
&& !tty
)
1422 return GPG_ERR_ENOTTY
;
1425 *p
++ = have_display
? "--display" : "--ttyname";
1426 *p
++ = have_display
? pwm
->pinentry_display
? pwm
->pinentry_display
: display
: tty
;
1429 *p
++ = "--lc-ctype";
1430 *p
++ = pwm
->lcctype
;
1433 if (pwm
->lcmessages
) {
1434 *p
++ = "--lc-messages";
1435 *p
++ = pwm
->lcmessages
;
1440 if (!have_display
) {
1442 *p
++ = pwm
->pinentry_term
? pwm
->pinentry_term
: getenv("TERM");
1446 rc
= assuan_pipe_connect(&ctx
, pwm
->pinentry_path
? pwm
->pinentry_path
: PINENTRY_PATH
, argv
, child_list
);
1454 pwm
->pid
= assuan_get_pid(ctx
);
1456 return set_pinentry_strings(pwm
, 0);
1459 static gpg_error_t
pinentry_command(pwm_t
*pwm
, char **result
, const char *cmd
)
1464 n
= launch_pinentry(pwm
);
1470 return assuan_command(pwm
, pwm
->pctx
, result
, cmd
);
1473 static void pinentry_disconnect(pwm_t
*pwm
)
1476 assuan_disconnect(pwm
->pctx
);
1483 * Only called from a child process.
1485 static void catchsig(int sig
)
1489 if (gelapsed
++ >= gtimeout
) {
1490 global_error
= pwmd_terminate_pinentry(gpwm
);
1493 global_error
= GPG_ERR_TIMEOUT
;
1507 * Borrowed from libassuan.
1509 static char *percent_escape(const char *atext
)
1511 const unsigned char *s
;
1512 int len
= strlen(atext
) * 3 + 1;
1513 char *buf
= (char *)pwmd_malloc(len
), *p
= buf
;
1518 for (s
=(const unsigned char *)atext
; *s
; s
++) {
1520 sprintf (p
, "%%%02X", *s
);
1531 static gpg_error_t
send_command(pwm_t
*pwm
, char **result
, const char *cmd
)
1534 return GPG_ERR_INV_ARG
;
1536 return assuan_command(pwm
, pwm
->ctx
, result
, cmd
);
1539 gpg_error_t
pwmd_command_ap(pwm_t
*pwm
, char **result
, const char *cmd
,
1547 return GPG_ERR_INV_ARG
;
1550 * C99 allows the dst pointer to be null which will calculate the length
1551 * of the would-be result and return it.
1553 len
= vsnprintf(NULL
, 0, cmd
, ap
)+1;
1554 buf
= (char *)pwmd_malloc(len
);
1555 len
= vsnprintf(buf
, len
, cmd
, ap
);
1556 error
= send_command(pwm
, result
, buf
);
1562 * Avoid sending the BYE command here. libassuan will close the file
1563 * descriptor and release the assuan context. Use pwmd_close() instead.
1565 gpg_error_t
pwmd_command(pwm_t
*pwm
, char **result
, const char *cmd
, ...)
1571 return GPG_ERR_INV_ARG
;
1577 error
= pwmd_command_ap(pwm
, result
, cmd
, ap
);
1582 #ifdef WITH_PINENTRY
1583 static gpg_error_t
do_getpin(pwm_t
*pwm
, char **result
)
1586 signal(SIGALRM
, catchsig
);
1591 return pinentry_command(pwm
, result
, "GETPIN");
1594 static gpg_error_t
getpin(pwm_t
*pwm
, char **result
, int *try_n
, int which
)
1596 int pin_try
= *try_n
;
1602 if (pin_try
== -1) {
1603 error
= set_pinentry_strings(pwm
, which
);
1606 pinentry_disconnect(pwm
);
1611 if (pwm
->pinentry_tries
-1 != pin_try
) {
1612 error
= set_pinentry_strings(pwm
, 1);
1615 pinentry_disconnect(pwm
);
1621 error
= do_getpin(pwm
, result
);
1624 * Since there was input cancel any timeout setting.
1629 if (error
== GPG_ERR_CANCELED
)
1630 return GPG_ERR_CANCELED
;
1632 if (pin_try
!= -1 && pin_try
--)
1636 pinentry_disconnect(pwm
);
1646 gpg_error_t
pwmd_open_nb_finalize(pwm_t
*pwm
, pwmd_nb_status_t
*pw
)
1650 #ifndef WITH_PINENTRY
1651 return GPG_ERR_NOT_IMPLEMENTED
;
1654 if (!pwm
|| !pw
|| !pw
->filename
[0])
1655 return GPG_ERR_INV_ARG
;
1665 pwmd_free(pwm
->filename
);
1667 pwm
->filename
= pwmd_strdup(pw
->filename
);
1668 memset(pw
, 0, sizeof(pwmd_nb_status_t
));
1672 memset(pw
, 0, sizeof(pwmd_nb_status_t
));
1676 static gpg_error_t
do_open_command(pwm_t
*pwm
, const char *filename
, char *password
)
1678 char buf
[ASSUAN_LINELENGTH
];
1680 char *result
= NULL
;
1682 snprintf(buf
, sizeof(buf
), "OPEN %s %s", filename
, password
? password
: "");
1683 error
= send_command(pwm
, &result
, buf
);
1684 memset(buf
, 0, sizeof(buf
));
1686 if (error
&& result
)
1692 static int do_pwmd_open(pwm_t
*pwm
, gpg_error_t
*error
, const char *filename
,
1693 int nb
, int timeout
)
1695 char *result
= NULL
;
1696 char *password
= NULL
;
1697 char path
[PATH_MAX
];
1698 #ifdef WITH_PINENTRY
1702 if (!pwm
|| !filename
|| !*filename
) {
1703 *error
= GPG_ERR_INV_ARG
;
1707 #ifdef WITH_PINENTRY
1708 pin_try
= pwm
->pinentry_tries
- 1;
1712 * Avoid calling pinentry if the password is cached on the server or if
1713 * this is a new file.
1715 *error
= pwmd_command(pwm
, &result
, "GETCONFIG data_directory");
1720 snprintf(path
, sizeof(path
), "%s/%s", result
, filename
);
1723 if (access(path
, R_OK
) == -1) {
1724 if (errno
== ENOENT
)
1728 *error
= pwmd_command(pwm
, &result
, "ISCACHED %s", filename
);
1730 if (*error
== EPWMD_CACHE_NOT_FOUND
) {
1731 if (pwm
->passfunc
) {
1732 password
= (char *)pwm
->passfunc(pwm
->passdata
);
1736 #ifdef WITH_PINENTRY
1738 * Get the password from pinentry.
1740 if (pwm
->use_pinentry
) {
1742 * Nonblocking is wanted. fork() then return a file descriptor
1743 * that the client can use to read() from.
1748 pwmd_nb_status_t pw
;
1750 if (pipe(p
) == -1) {
1751 *error
= gpg_error_from_syserror();
1764 strncpy(pw
.filename
, filename
, sizeof(pw
.filename
));
1765 pw
.filename
[sizeof(pw
.filename
)-1] = 0;
1775 *error
= getpin(pwm
, &password
, &pin_try
, 0);
1780 pinentry_disconnect(pwm
);
1782 if (gtimeout
&& gelapsed
>= gtimeout
)
1783 *error
= GPG_ERR_TIMEOUT
;
1787 pth_write(p
[1], &pw
, sizeof(pw
));
1789 write(p
[1], &pw
, sizeof(pw
));
1796 * Don't count the time it takes to open the file
1797 * which may have many iterations.
1799 signal(SIGALRM
, SIG_DFL
);
1800 *error
= do_open_command(pwm
, filename
, password
);
1803 signal(SIGALRM
, catchsig
);
1805 if (pwm
->pctx
&& *error
== EPWMD_BADKEY
) {
1807 goto getpin_nb_again
;
1809 goto getpin_nb_fail
;
1812 pinentry_disconnect(pwm
);
1815 pth_write(p
[1], &pw
, sizeof(pw
));
1817 write(p
[1], &pw
, sizeof(pw
));
1823 *error
= gpg_error_from_syserror();
1839 * Not using pinentry and the file was not found
1842 password
= pwm
->password
;
1843 #ifdef WITH_PINENTRY
1851 *error
= do_open_command(pwm
, filename
, password
);
1854 * Keep the user defined password set with pwmd_setopt(). The password may
1855 * be needed later (pwmd_save()) depending on the pwmd file cache settings.
1857 if (!pwm
->passfunc
&& password
&& password
!= pwm
->password
)
1858 pwmd_free(password
);
1860 #ifdef WITH_PINENTRY
1861 if (*error
== EPWMD_BADKEY
) {
1862 if (pin_try
-- > 0 && !nb
) {
1863 *error
= pwmd_command(pwm
, &result
, "OPTION TITLE=%s",
1864 N_("Invalid passphrase, please try again."));
1873 pinentry_disconnect(pwm
);
1881 pwmd_free(pwm
->filename
);
1883 pwm
->filename
= pwmd_strdup(filename
);
1887 * The file is cached or the file is a new file.
1890 return *error
? -1 : -2;
1892 return *error
? 1 : 0;
1895 gpg_error_t
pwmd_open(pwm_t
*pwm
, const char *filename
)
1899 do_pwmd_open(pwm
, &error
, filename
, 0, 0);
1903 int pwmd_open_nb(pwm_t
*pwm
, gpg_error_t
*error
, const char *filename
,
1906 #ifndef WITH_PINENTRY
1907 *error
= GPG_ERR_NOT_IMPLEMENTED
;
1910 return do_pwmd_open(pwm
, error
, filename
, 1, timeout
);
1914 #ifdef WITH_PINENTRY
1915 static gpg_error_t
do_save_getpin(pwm_t
*pwm
, char **password
)
1919 char *result
= NULL
;
1923 error
= getpin(pwm
, &result
, &pin_try
, confirm
? 2 : 0);
1927 pinentry_disconnect(pwm
);
1930 pwmd_free(*password
);
1940 if (strcmp(*password
, result
)) {
1941 pwmd_free(*password
);
1943 pinentry_disconnect(pwm
);
1944 error
= EPWMD_BADKEY
;
1949 pinentry_disconnect(pwm
);
1954 static gpg_error_t
do_save_command(pwm_t
*pwm
, char *password
)
1956 char buf
[ASSUAN_LINELENGTH
];
1958 char *result
= NULL
;
1960 snprintf(buf
, sizeof(buf
), "SAVE %s", password
? password
: "");
1961 error
= send_command(pwm
, &result
, buf
);
1962 memset(&buf
, 0, sizeof(buf
));
1964 if (error
&& result
)
1970 gpg_error_t
pwmd_save_nb_finalize(pwm_t
*pwm
, pwmd_nb_status_t
*pw
)
1974 #ifndef WITH_PINENTRY
1975 return GPG_ERR_NOT_IMPLEMENTED
;
1978 if (!pwm
|| !pw
|| !pw
->filename
[0])
1979 return GPG_ERR_INV_ARG
;
1983 memset(pw
, 0, sizeof(pwmd_nb_status_t
));
1987 static int do_pwmd_save(pwm_t
*pwm
, gpg_error_t
*error
, int nb
)
1989 char *result
= NULL
;
1990 char *password
= NULL
;
1993 *error
= GPG_ERR_INV_ARG
;
1997 if (pwm
->use_pinentry
|| pwm
->passfunc
) {
1998 *error
= pwmd_command(pwm
, &result
, "ISCACHED %s", pwm
->filename
);
2000 if (*error
== EPWMD_CACHE_NOT_FOUND
) {
2002 password
= (char *)(*pwm
->passfunc
)(pwm
->passdata
);
2003 #ifdef WITH_PINENTRY
2004 else if (pwm
->use_pinentry
) {
2008 pwmd_nb_status_t pw
;
2010 if (pipe(p
) == -1) {
2011 *error
= gpg_error_from_syserror();
2024 strncpy(pw
.filename
, pwm
->filename
, sizeof(pw
.filename
));
2025 pw
.filename
[sizeof(pw
.filename
)-1] = 0;
2030 *error
= do_save_getpin(pwm
, &password
);
2031 } while (*error
== EPWMD_BADKEY
);
2035 pinentry_disconnect(pwm
);
2039 pth_write(p
[1], &pw
, sizeof(pw
));
2041 write(p
[1], &pw
, sizeof(pw
));
2047 *error
= do_save_command(pwm
, password
);
2048 pinentry_disconnect(pwm
);
2051 pth_write(p
[1], &pw
, sizeof(pw
));
2053 write(p
[1], &pw
, sizeof(pw
));
2059 *error
= gpg_error_from_syserror();
2072 *error
= do_save_getpin(pwm
, &password
);
2085 password
= pwm
->password
;
2087 *error
= do_save_command(pwm
, password
);
2089 if (!pwm
->passfunc
&& password
&& password
!= pwm
->password
)
2090 pwmd_free(password
);
2093 return *error
? -1 : -2;
2095 return *error
? 1 : 0;
2098 int pwmd_save_nb(pwm_t
*pwm
, gpg_error_t
*error
)
2100 #ifndef WITH_PINENTRY
2101 *error
= GPG_ERR_NOT_IMPLEMENTED
;
2104 return do_pwmd_save(pwm
, error
, 1);
2108 gpg_error_t
pwmd_save(pwm_t
*pwm
)
2112 do_pwmd_save(pwm
, &error
, 0);
2116 gpg_error_t
pwmd_setopt(pwm_t
*pwm
, pwmd_option_t opt
, ...)
2119 int n
= va_arg(ap
, int);
2122 gpg_error_t error
= 0;
2125 return GPG_ERR_INV_ARG
;
2130 case PWMD_OPTION_STATUS_FUNC
:
2131 pwm
->status_func
= va_arg(ap
, pwmd_status_fn
);
2133 case PWMD_OPTION_STATUS_DATA
:
2134 pwm
->status_data
= va_arg(ap
, void *);
2136 case PWMD_OPTION_PASSWORD_FUNC
:
2137 pwm
->passfunc
= va_arg(ap
, pwmd_password_fn
);
2139 case PWMD_OPTION_PASSWORD_DATA
:
2140 pwm
->passdata
= va_arg(ap
, void *);
2142 case PWMD_OPTION_PASSWORD
:
2143 arg1
= va_arg(ap
, char *);
2146 pwmd_free(pwm
->password
);
2148 pwm
->password
= pwmd_strdup(arg1
);
2150 case PWMD_OPTION_PINENTRY
:
2151 n
= va_arg(ap
, int);
2153 if (n
!= 0 && n
!= 1) {
2155 error
= GPG_ERR_INV_VALUE
;
2158 pwm
->use_pinentry
= n
;
2159 error
= pwmd_command(pwm
, &result
, "OPTION PINENTRY=%i",
2160 !pwm
->use_pinentry
);
2163 #ifdef WITH_PINENTRY
2164 case PWMD_OPTION_PINENTRY_TRIES
:
2165 n
= va_arg(ap
, int);
2169 error
= GPG_ERR_INV_VALUE
;
2172 pwm
->pinentry_tries
= n
;
2175 case PWMD_OPTION_PINENTRY_TIMEOUT
:
2176 n
= va_arg(ap
, int);
2180 error
= GPG_ERR_INV_VALUE
;
2183 pwm
->pinentry_timeout
= n
;
2185 if (!pwm
->use_pinentry
)
2186 error
= pwmd_command(pwm
, &result
, "OPTION TIMEOUT=%i",
2187 pwm
->pinentry_timeout
);
2189 case PWMD_OPTION_PINENTRY_PATH
:
2190 if (pwm
->pinentry_path
)
2191 pwmd_free(pwm
->pinentry_path
);
2193 pwm
->pinentry_path
= pwmd_strdup(va_arg(ap
, char *));
2195 if (!pwm
->use_pinentry
)
2196 error
= pwmd_command(pwm
, &result
, "OPTION PATH=%s",
2197 pwm
->pinentry_path
);
2199 case PWMD_OPTION_PINENTRY_TTY
:
2200 if (pwm
->pinentry_tty
)
2201 pwmd_free(pwm
->pinentry_tty
);
2203 pwm
->pinentry_tty
= pwmd_strdup(va_arg(ap
, char *));
2205 if (!pwm
->use_pinentry
)
2206 error
= pwmd_command(pwm
, &result
, "OPTION TTY=%s",
2209 case PWMD_OPTION_PINENTRY_DISPLAY
:
2210 if (pwm
->pinentry_display
)
2211 pwmd_free(pwm
->pinentry_display
);
2213 pwm
->pinentry_display
= pwmd_strdup(va_arg(ap
, char *));
2215 if (!pwm
->use_pinentry
)
2216 error
= pwmd_command(pwm
, &result
, "OPTION DISPLAY=%s",
2217 pwm
->pinentry_display
);
2219 case PWMD_OPTION_PINENTRY_TERM
:
2220 if (pwm
->pinentry_term
)
2221 pwmd_free(pwm
->pinentry_term
);
2223 pwm
->pinentry_term
= pwmd_strdup(va_arg(ap
, char *));
2225 if (!pwm
->use_pinentry
)
2226 error
= pwmd_command(pwm
, &result
, "OPTION TTYTYPE=%s",
2227 pwm
->pinentry_term
);
2229 case PWMD_OPTION_PINENTRY_TITLE
:
2231 pwmd_free(pwm
->title
);
2233 pwm
->title
= percent_escape(va_arg(ap
, char *));
2235 if (!pwm
->use_pinentry
)
2236 error
= pwmd_command(pwm
, &result
, "OPTION TITLE=%s",
2239 case PWMD_OPTION_PINENTRY_PROMPT
:
2241 pwmd_free(pwm
->prompt
);
2243 pwm
->prompt
= percent_escape(va_arg(ap
, char *));
2245 if (!pwm
->use_pinentry
)
2246 error
= pwmd_command(pwm
, &result
, "OPTION PROMPT=%s",
2249 case PWMD_OPTION_PINENTRY_DESC
:
2251 pwmd_free(pwm
->desc
);
2253 pwm
->desc
= percent_escape(va_arg(ap
, char *));
2255 if (!pwm
->use_pinentry
)
2256 error
= pwmd_command(pwm
, &result
, "OPTION DESC=%s",
2259 case PWMD_OPTION_PINENTRY_LC_CTYPE
:
2261 pwmd_free(pwm
->lcctype
);
2263 pwm
->lcctype
= pwmd_strdup(va_arg(ap
, char *));
2265 if (!pwm
->use_pinentry
)
2266 error
= pwmd_command(pwm
, &result
, "OPTION LC_CTYPE=%s",
2269 case PWMD_OPTION_PINENTRY_LC_MESSAGES
:
2270 if (pwm
->lcmessages
)
2271 pwmd_free(pwm
->lcmessages
);
2273 pwm
->lcmessages
= pwmd_strdup(va_arg(ap
, char *));
2275 if (!pwm
->use_pinentry
)
2276 error
= pwmd_command(pwm
, &result
, "OPTION LC_MESSAGES=%s",
2280 error
= GPG_ERR_NOT_IMPLEMENTED
;
2288 gpg_error_t
pwmd_get_fd(pwm_t
*pwm
, int *fd
)
2291 return GPG_ERR_INV_ARG
;
2294 return GPG_ERR_INV_STATE
;
2300 pwm_t
*pwmd_new(const char *name
)
2302 pwm_t
*h
= pwmd_malloc(sizeof(pwm_t
));
2308 h
->name
= pwmd_strdup(name
);
2319 void pwmd_free(void *ptr
)
2324 void *pwmd_malloc(size_t size
)
2326 return xmalloc(size
);
2329 void *pwmd_calloc(size_t nmemb
, size_t size
)
2331 return xcalloc(nmemb
, size
);
2334 void *pwmd_realloc(void *ptr
, size_t size
)
2336 return xrealloc(ptr
, size
);
2339 char *pwmd_strdup(const char *str
)
2341 return xstrdup(str
);