1/* assuan.h - Definitions for the Assuan IPC library -*- c -*-
2 Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010,
3 2011, 2013 Free Software Foundation, Inc.
4
5 This file is part of Assuan.
6
7 Assuan is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as
9 published by the Free Software Foundation; either version 2.1 of
10 the License, or (at your option) any later version.
11
12 Assuan is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public
18 License along with this program; if not, see <http://www.gnu.org/licenses/>.
19
20 Do not edit. Generated from assuan.h.in by mkheader for linux-gnu.
21 */
22
23#ifndef ASSUAN_H
24#define ASSUAN_H
25
26#include <stdio.h>
27#include <sys/types.h>
28#include <unistd.h>
29#include <stdarg.h>
30
31#ifndef _ASSUAN_NO_SOCKET_WRAPPER
32#include <sys/socket.h>
33#endif /*!_ASSUAN_NO_SOCKET_WRAPPER*/
34
35typedef struct msghdr *assuan_msghdr_t;
36
37#include <gpg-error.h>
38
39/* Compile time configuration:
40
41 #define _ASSUAN_NO_SOCKET_WRAPPER
42
43 Do not include the definitions for the socket wrapper feature. */
44
45
46#ifdef __cplusplus
47extern "C"
48{
49#if 0
50}
51#endif
52#endif
53
54/* The version of this header should match the one of the library. Do
55 not use this symbol in your application; use assuan_check_version
56 instead. */
57#define ASSUAN_VERSION "2.1.1"
58
59/* The version number of this header. It may be used to handle minor
60 API incompatibilities. */
61#define ASSUAN_VERSION_NUMBER 0x020101
62
63
64/* Check for compiler features. */
65#if __GNUC__
66#define _ASSUAN_GCC_VERSION (__GNUC__ * 10000 \
67 + __GNUC_MINOR__ * 100 \
68 + __GNUC_PATCHLEVEL__)
69
70#if _ASSUAN_GCC_VERSION > 30100
71#define _ASSUAN_DEPRECATED __attribute__ ((__deprecated__))
72#endif
73#endif
74#ifndef _ASSUAN_DEPRECATED
75#define _ASSUAN_DEPRECATED
76#endif
77
78
79#define ASSUAN_LINELENGTH 1002 /* 1000 + [CR,]LF */
80
81struct assuan_context_s;
82typedef struct assuan_context_s *assuan_context_t;
83
84typedef int assuan_fd_t;
85#define ASSUAN_INVALID_FD (-1)
86#define ASSUAN_INVALID_PID ((pid_t) -1)
87static GPG_ERR_INLINE assuan_fd_t
88assuan_fd_from_posix_fd (int fd)
89{
90 return fd;
91}
92
93
94assuan_fd_t assuan_fdopen (int fd);
95
96/* Under Windows Assuan features an emulation of Unix domain sockets
97 based on a local TCP connections. To implement access permissions
98 based on file permissions a nonce is used which is expected by the
99 server as the first bytes received. On POSIX systems this is a
100 dummy structure. */
101struct assuan_sock_nonce_s
102{
103 size_t length;
104};
105typedef struct assuan_sock_nonce_s assuan_sock_nonce_t;
106
107
108/* Global interface. */
109
110struct assuan_malloc_hooks
111{
112 void *(*malloc) (size_t cnt);
113 void *(*realloc) (void *ptr, size_t cnt);
114 void (*free) (void *ptr);
115};
116typedef struct assuan_malloc_hooks *assuan_malloc_hooks_t;
117
118/* Categories for log messages. */
119#define ASSUAN_LOG_INIT 1
120#define ASSUAN_LOG_CTX 2
121#define ASSUAN_LOG_ENGINE 3
122#define ASSUAN_LOG_DATA 4
123#define ASSUAN_LOG_SYSIO 5
124#define ASSUAN_LOG_CONTROL 8
125
126/* If MSG is NULL, return true/false depending on if this category is
127 logged. This is used to probe before expensive log message
128 generation (buffer dumps). */
129typedef int (*assuan_log_cb_t) (assuan_context_t ctx, void *hook,
130 unsigned int cat, const char *msg);
131
132/* Return or check the version number. */
133const char *assuan_check_version (const char *req_version);
134
135/* Set the default gpg error source. */
136void assuan_set_gpg_err_source (gpg_err_source_t errsource);
137
138/* Get the default gpg error source. */
139gpg_err_source_t assuan_get_gpg_err_source (void);
140
141
142/* Set the default malloc hooks. */
143void assuan_set_malloc_hooks (assuan_malloc_hooks_t malloc_hooks);
144
145/* Get the default malloc hooks. */
146assuan_malloc_hooks_t assuan_get_malloc_hooks (void);
147
148
149/* Set the default log callback handler. */
150void assuan_set_log_cb (assuan_log_cb_t log_cb, void *log_cb_data);
151
152/* Get the default log callback handler. */
153void assuan_get_log_cb (assuan_log_cb_t *log_cb, void **log_cb_data);
154
155
156/* Create a new Assuan context. The initial parameters are all needed
157 in the creation of the context. */
158gpg_error_t assuan_new_ext (assuan_context_t *ctx, gpg_err_source_t errsource,
159 assuan_malloc_hooks_t malloc_hooks,
160 assuan_log_cb_t log_cb, void *log_cb_data);
161
162/* Create a new context with default arguments. */
163gpg_error_t assuan_new (assuan_context_t *ctx);
164
165/* Release all resources associated with the given context. */
166void assuan_release (assuan_context_t ctx);
167
168/* Release the memory at PTR using the allocation handler of the
169 context CTX. This is a convenience function. */
170void assuan_free (assuan_context_t ctx, void *ptr);
171
172
173/* Set user-data in a context. */
174void assuan_set_pointer (assuan_context_t ctx, void *pointer);
175
176/* Get user-data in a context. */
177void *assuan_get_pointer (assuan_context_t ctx);
178
179
180/* Definitions of flags for assuan_set_flag(). */
181typedef unsigned int assuan_flag_t;
182
183/* When using a pipe server, by default Assuan will wait for the
184 forked process to die in assuan_release. In certain cases this
185 is not desirable. By setting this flag, the waitpid will be
186 skipped and the caller is responsible to cleanup a forked
187 process. */
188#define ASSUAN_NO_WAITPID 1
189/* This flag indicates whether Assuan logging is in confidential mode.
190 You can use assuan_{begin,end}_condidential to change the mode. */
191#define ASSUAN_CONFIDENTIAL 2
192/* This flag suppresses fix up of signal handlers for pipes. */
193#define ASSUAN_NO_FIXSIGNALS 3
194/* This flag changes assuan_transact to return comment lines via the
195 status callback. The default is to skip comment lines. */
196#define ASSUAN_CONVEY_COMMENTS 4
197/* This flag disables logging for one context. */
198#define ASSUAN_NO_LOGGING 5
199/* This flag forces a connection close. */
200#define ASSUAN_FORCE_CLOSE 6
201
202/* For context CTX, set the flag FLAG to VALUE. Values for flags
203 are usually 1 or 0 but certain flags might allow for other values;
204 see the description of the type assuan_flag_t for details. */
205void assuan_set_flag (assuan_context_t ctx, assuan_flag_t flag, int value);
206
207/* Return the VALUE of FLAG in context CTX. */
208int assuan_get_flag (assuan_context_t ctx, assuan_flag_t flag);
209
210
211/* Same as assuan_set_flag (ctx, ASSUAN_CONFIDENTIAL, 1). */
212void assuan_begin_confidential (assuan_context_t ctx);
213
214/* Same as assuan_set_flag (ctx, ASSUAN_CONFIDENTIAL, 0). */
215void assuan_end_confidential (assuan_context_t ctx);
216
217
218/* Direction values for assuan_set_io_monitor. */
219#define ASSUAN_IO_FROM_PEER 0
220#define ASSUAN_IO_TO_PEER 1
221
222/* Return flags of I/O monitor. */
223#define ASSUAN_IO_MONITOR_NOLOG 1
224#define ASSUAN_IO_MONITOR_IGNORE 2
225
226/* The IO monitor gets to see all I/O on the context, and can return
227 ASSUAN_IO_MONITOR_* bits to control actions on it. */
228typedef unsigned int (*assuan_io_monitor_t) (assuan_context_t ctx, void *hook,
229 int inout, const char *line,
230 size_t linelen);
231
232/* Set the IO monitor function. */
233void assuan_set_io_monitor (assuan_context_t ctx,
234 assuan_io_monitor_t io_monitor, void *hook_data);
235
236
237#define ASSUAN_SYSTEM_HOOKS_VERSION 2
238#define ASSUAN_SPAWN_DETACHED 128
239struct assuan_system_hooks
240{
241 /* Always set to ASSUAN_SYTEM_HOOKS_VERSION. */
242 int version;
243
244 /* Sleep for the given number of microseconds. */
245 void (*usleep) (assuan_context_t ctx, unsigned int usec);
246
247 /* Create a pipe with an inheritable end. */
248 int (*pipe) (assuan_context_t ctx, assuan_fd_t fd[2], int inherit_idx);
249
250 /* Close the given file descriptor, created with _assuan_pipe or one
251 of the socket functions. */
252 int (*close) (assuan_context_t ctx, assuan_fd_t fd);
253
254
255 ssize_t (*read) (assuan_context_t ctx, assuan_fd_t fd, void *buffer,
256 size_t size);
257 ssize_t (*write) (assuan_context_t ctx, assuan_fd_t fd,
258 const void *buffer, size_t size);
259
260 int (*recvmsg) (assuan_context_t ctx, assuan_fd_t fd, assuan_msghdr_t msg,
261 int flags);
262 int (*sendmsg) (assuan_context_t ctx, assuan_fd_t fd,
263 const assuan_msghdr_t msg, int flags);
264
265 /* If NAME is NULL, don't exec, just fork. FD_CHILD_LIST is
266 modified to reflect the value of the FD in the peer process (on
267 Windows). */
268 int (*spawn) (assuan_context_t ctx, pid_t *r_pid, const char *name,
269 const char **argv,
270 assuan_fd_t fd_in, assuan_fd_t fd_out,
271 assuan_fd_t *fd_child_list,
272 void (*atfork) (void *opaque, int reserved),
273 void *atforkvalue, unsigned int flags);
274
275 /* If action is 0, like waitpid. If action is 1, just release the PID? */
276 pid_t (*waitpid) (assuan_context_t ctx, pid_t pid,
277 int action, int *status, int options);
278 int (*socketpair) (assuan_context_t ctx, int _namespace, int style,
279 int protocol, assuan_fd_t filedes[2]);
280 int (*socket) (assuan_context_t ctx, int _namespace, int style, int protocol);
281 int (*connect) (assuan_context_t ctx, int sock, struct sockaddr *addr, socklen_t length);
282};
283typedef struct assuan_system_hooks *assuan_system_hooks_t;
284
285
286/* Configuration of the default log handler. */
287
288/* Set the prefix to be used at the start of a line emitted by assuan
289 on the log stream. The default is the empty string. Note, that
290 this function is not thread-safe and should in general be used
291 right at startup. */
292void assuan_set_assuan_log_prefix (const char *text);
293
294/* Return a prefix to be used at the start of a line emitted by assuan
295 on the log stream. The default implementation returns the empty
296 string, i.e. "" */
297const char *assuan_get_assuan_log_prefix (void);
298
299/* Global default log stream. */
300void assuan_set_assuan_log_stream (FILE *fp);
301
302/* Set the per context log stream for the default log handler. */
303void assuan_set_log_stream (assuan_context_t ctx, FILE *fp);
304
305
306typedef gpg_error_t (*assuan_handler_t) (assuan_context_t, char *);
307
308/*-- assuan-handler.c --*/
309gpg_error_t assuan_register_command (assuan_context_t ctx,
310 const char *cmd_string,
311 assuan_handler_t handler,
312 const char *help_string);
313gpg_error_t assuan_register_pre_cmd_notify (assuan_context_t ctx,
314 gpg_error_t (*fnc)(assuan_context_t, const char *cmd));
315gpg_error_t assuan_register_post_cmd_notify (assuan_context_t ctx,
316 void (*fnc)(assuan_context_t,
317 gpg_error_t));
318gpg_error_t assuan_register_bye_notify (assuan_context_t ctx,
319 assuan_handler_t handler);
320gpg_error_t assuan_register_reset_notify (assuan_context_t ctx,
321 assuan_handler_t handler);
322gpg_error_t assuan_register_cancel_notify (assuan_context_t ctx,
323 assuan_handler_t handler);
324gpg_error_t assuan_register_input_notify (assuan_context_t ctx,
325 assuan_handler_t handler);
326gpg_error_t assuan_register_output_notify (assuan_context_t ctx,
327 assuan_handler_t handler);
328
329gpg_error_t assuan_register_option_handler (assuan_context_t ctx,
330 gpg_error_t (*fnc)(assuan_context_t,
331 const char*,
332 const char*));
333
334gpg_error_t assuan_process (assuan_context_t ctx);
335gpg_error_t assuan_process_next (assuan_context_t ctx, int *done);
336gpg_error_t assuan_process_done (assuan_context_t ctx, gpg_error_t rc);
337int assuan_get_active_fds (assuan_context_t ctx, int what,
338 assuan_fd_t *fdarray, int fdarraysize);
339
340const char *assuan_get_command_name (assuan_context_t ctx);
341
342FILE *assuan_get_data_fp (assuan_context_t ctx);
343gpg_error_t assuan_set_okay_line (assuan_context_t ctx, const char *line);
344gpg_error_t assuan_write_status (assuan_context_t ctx,
345 const char *keyword, const char *text);
346
347/* Negotiate a file descriptor. If LINE contains "FD=N", returns N
348 assuming a local file descriptor. If LINE contains "FD" reads a
349 file descriptor via CTX and stores it in *RDF (the CTX must be
350 capable of passing file descriptors). Under W32 the returned FD is
351 a libc-type one. */
352gpg_error_t assuan_command_parse_fd (assuan_context_t ctx, char *line,
353 assuan_fd_t *rfd);
354
355
356/*-- assuan-listen.c --*/
357gpg_error_t assuan_set_hello_line (assuan_context_t ctx, const char *line);
358gpg_error_t assuan_accept (assuan_context_t ctx);
359assuan_fd_t assuan_get_input_fd (assuan_context_t ctx);
360assuan_fd_t assuan_get_output_fd (assuan_context_t ctx);
361gpg_error_t assuan_close_input_fd (assuan_context_t ctx);
362gpg_error_t assuan_close_output_fd (assuan_context_t ctx);
363
364
365/*-- assuan-pipe-server.c --*/
366gpg_error_t assuan_init_pipe_server (assuan_context_t ctx,
367 assuan_fd_t filedes[2]);
368
369/*-- assuan-socket-server.c --*/
370#define ASSUAN_SOCKET_SERVER_FDPASSING 1
371#define ASSUAN_SOCKET_SERVER_ACCEPTED 2
372gpg_error_t assuan_init_socket_server (assuan_context_t ctx,
373 assuan_fd_t listen_fd,
374 unsigned int flags);
375void assuan_set_sock_nonce (assuan_context_t ctx, assuan_sock_nonce_t *nonce);
376
377/*-- assuan-pipe-connect.c --*/
378#define ASSUAN_PIPE_CONNECT_FDPASSING 1
379#define ASSUAN_PIPE_CONNECT_DETACHED 128
380gpg_error_t assuan_pipe_connect (assuan_context_t ctx,
381 const char *name,
382 const char *argv[],
383 assuan_fd_t *fd_child_list,
384 void (*atfork) (void *, int),
385 void *atforkvalue,
386 unsigned int flags);
387
388/*-- assuan-socket-connect.c --*/
389#define ASSUAN_SOCKET_CONNECT_FDPASSING 1
390gpg_error_t assuan_socket_connect (assuan_context_t ctx, const char *name,
391 pid_t server_pid, unsigned int flags);
392
393/*-- assuan-socket-connect.c --*/
394gpg_error_t assuan_socket_connect_fd (assuan_context_t ctx, int fd,
395 unsigned int flags);
396
397/*-- context.c --*/
398pid_t assuan_get_pid (assuan_context_t ctx);
399struct _assuan_peercred
400{
401#ifdef _WIN32
402 /* Empty struct not allowed on some compilers. */
403 unsigned int _dummy;
404#else
405 pid_t pid;
406 uid_t uid;
407 gid_t gid;
408#endif
409};
410typedef struct _assuan_peercred *assuan_peercred_t;
411
412gpg_error_t assuan_get_peercred (assuan_context_t ctx,
413 assuan_peercred_t *peercred);
414
415
416
417/* Client interface. */
418#define ASSUAN_RESPONSE_ERROR 0
419#define ASSUAN_RESPONSE_OK 1
420#define ASSUAN_RESPONSE_DATA 2
421#define ASSUAN_RESPONSE_INQUIRE 3
422#define ASSUAN_RESPONSE_STATUS 4
423#define ASSUAN_RESPONSE_END 5
424#define ASSUAN_RESPONSE_COMMENT 6
425typedef int assuan_response_t;
426
427/* This already de-escapes data lines. */
428gpg_error_t assuan_client_read_response (assuan_context_t ctx,
429 char **line, int *linelen);
430
431gpg_error_t assuan_client_parse_response (assuan_context_t ctx,
432 char *line, int linelen,
433 assuan_response_t *response,
434 int *off);
435
436/*-- assuan-client.c --*/
437gpg_error_t
438assuan_transact (assuan_context_t ctx,
439 const char *command,
440 gpg_error_t (*data_cb)(void *, const void *, size_t),
441 void *data_cb_arg,
442 gpg_error_t (*inquire_cb)(void*, const char *),
443 void *inquire_cb_arg,
444 gpg_error_t (*status_cb)(void*, const char *),
445 void *status_cb_arg);
446
447
448/*-- assuan-inquire.c --*/
449gpg_error_t assuan_inquire (assuan_context_t ctx, const char *keyword,
450 unsigned char **r_buffer, size_t *r_length,
451 size_t maxlen);
452gpg_error_t assuan_inquire_ext (assuan_context_t ctx, const char *keyword,
453 size_t maxlen,
454 gpg_error_t (*cb) (void *cb_data,
455 gpg_error_t rc,
456 unsigned char *buf,
457 size_t buf_len),
458 void *cb_data);
459/*-- assuan-buffer.c --*/
460gpg_error_t assuan_read_line (assuan_context_t ctx,
461 char **line, size_t *linelen);
462int assuan_pending_line (assuan_context_t ctx);
463gpg_error_t assuan_write_line (assuan_context_t ctx, const char *line);
464gpg_error_t assuan_send_data (assuan_context_t ctx,
465 const void *buffer, size_t length);
466
467/* The file descriptor must be pending before assuan_receivefd is
468 called. This means that assuan_sendfd should be called *before* the
469 trigger is sent (normally via assuan_write_line ("INPUT FD")). */
470gpg_error_t assuan_sendfd (assuan_context_t ctx, assuan_fd_t fd);
471gpg_error_t assuan_receivefd (assuan_context_t ctx, assuan_fd_t *fd);
472
473
474/*-- assuan-util.c --*/
475gpg_error_t assuan_set_error (assuan_context_t ctx, gpg_error_t err,
476 const char *text);
477
478
479
480/*-- assuan-socket.c --*/
481
482/* These are socket wrapper functions to support an emulation of Unix
483 domain sockets on Windows W32. */
484gpg_error_t assuan_sock_init (void);
485void assuan_sock_deinit (void);
486int assuan_sock_close (assuan_fd_t fd);
487assuan_fd_t assuan_sock_new (int domain, int type, int proto);
488int assuan_sock_connect (assuan_fd_t sockfd,
489 struct sockaddr *addr, int addrlen);
490int assuan_sock_bind (assuan_fd_t sockfd, struct sockaddr *addr, int addrlen);
491int assuan_sock_get_nonce (struct sockaddr *addr, int addrlen,
492 assuan_sock_nonce_t *nonce);
493int assuan_sock_check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce);
494
495
496/* Set the default or per context system callbacks. This is
497 irreversible. */
498void assuan_set_system_hooks (assuan_system_hooks_t system_hooks);
499
500void assuan_ctx_set_system_hooks (assuan_context_t ctx,
501 assuan_system_hooks_t system_hooks);
502
503void __assuan_usleep (assuan_context_t ctx, unsigned int usec);
504int __assuan_pipe (assuan_context_t ctx, assuan_fd_t fd[2], int inherit_idx);
505int __assuan_close (assuan_context_t ctx, assuan_fd_t fd);
506int __assuan_spawn (assuan_context_t ctx, pid_t *r_pid, const char *name,
507 const char **argv, assuan_fd_t fd_in, assuan_fd_t fd_out,
508 assuan_fd_t *fd_child_list,
509 void (*atfork) (void *opaque, int reserved),
510 void *atforkvalue, unsigned int flags);
511int __assuan_socketpair (assuan_context_t ctx, int _namespace, int style,
512 int protocol, assuan_fd_t filedes[2]);
513int __assuan_socket (assuan_context_t ctx, int _namespace, int style, int protocol);
514int __assuan_connect (assuan_context_t ctx, int sock, struct sockaddr *addr, socklen_t length);
515ssize_t __assuan_read (assuan_context_t ctx, assuan_fd_t fd, void *buffer, size_t size);
516ssize_t __assuan_write (assuan_context_t ctx, assuan_fd_t fd, const void *buffer, size_t size);
517int __assuan_recvmsg (assuan_context_t ctx, assuan_fd_t fd, assuan_msghdr_t msg, int flags);
518int __assuan_sendmsg (assuan_context_t ctx, assuan_fd_t fd, const assuan_msghdr_t msg, int flags);
519pid_t __assuan_waitpid (assuan_context_t ctx, pid_t pid, int nowait, int *status, int options);
520
521
522#define ASSUAN_SYSTEM_PTH_IMPL \
523 static void _assuan_pth_usleep (assuan_context_t ctx, unsigned int usec) \
524 { (void) ctx; pth_usleep (usec); } \
525 static ssize_t _assuan_pth_read (assuan_context_t ctx, assuan_fd_t fd, \
526 void *buffer, size_t size) \
527 { (void) ctx; return pth_read (fd, buffer, size); } \
528 static ssize_t _assuan_pth_write (assuan_context_t ctx, assuan_fd_t fd, \
529 const void *buffer, size_t size) \
530 { (void) ctx; return pth_write (fd, buffer, size); } \
531 static int _assuan_pth_recvmsg (assuan_context_t ctx, assuan_fd_t fd, \
532 assuan_msghdr_t msg, int flags) \
533 { \
534 /* Pth does not provide a recvmsg function. We implement it. */ \
535 int ret; \
536 int fdmode; \
537 \
538 (void) ctx; \
539 fdmode = pth_fdmode (fd, PTH_FDMODE_POLL); \
540 if (fdmode == PTH_FDMODE_ERROR) \
541 { \
542 errno = EBADF; \
543 return -1; \
544 } \
545 if (fdmode == PTH_FDMODE_BLOCK) \
546 { \
547 fd_set fds; \
548 \
549 FD_ZERO (&fds); \
550 FD_SET (fd, &fds); \
551 while ((ret = pth_select (fd + 1, &fds, NULL, NULL, NULL)) < 0 \
552 && errno == EINTR) \
553 ; \
554 if (ret < 0) \
555 return -1; \
556 } \
557 \
558 while ((ret = recvmsg (fd, msg, flags)) == -1 && errno == EINTR) \
559 ; \
560 return ret; \
561 } \
562 static int _assuan_pth_sendmsg (assuan_context_t ctx, assuan_fd_t fd, \
563 const assuan_msghdr_t msg, int flags) \
564 { \
565 /* Pth does not provide a sendmsg function. We implement it. */ \
566 int ret; \
567 int fdmode; \
568 \
569 (void) ctx; \
570 fdmode = pth_fdmode (fd, PTH_FDMODE_POLL); \
571 if (fdmode == PTH_FDMODE_ERROR) \
572 { \
573 errno = EBADF; \
574 return -1; \
575 } \
576 if (fdmode == PTH_FDMODE_BLOCK) \
577 { \
578 fd_set fds; \
579 \
580 FD_ZERO (&fds); \
581 FD_SET (fd, &fds); \
582 while ((ret = pth_select (fd + 1, NULL, &fds, NULL, NULL)) < 0 \
583 && errno == EINTR) \
584 ; \
585 if (ret < 0) \
586 return -1; \
587 } \
588 \
589 while ((ret = sendmsg (fd, msg, flags)) == -1 && errno == EINTR) \
590 ; \
591 return ret; \
592 } \
593 static pid_t _assuan_pth_waitpid (assuan_context_t ctx, pid_t pid, \
594 int nowait, int *status, int options) \
595 { (void) ctx; \
596 if (!nowait) return pth_waitpid (pid, status, options); \
597 else return 0; } \
598 \
599 struct assuan_system_hooks _assuan_system_pth = \
600 { ASSUAN_SYSTEM_HOOKS_VERSION, _assuan_pth_usleep, __assuan_pipe, \
601 __assuan_close, _assuan_pth_read, _assuan_pth_write, \
602 _assuan_pth_recvmsg, _assuan_pth_sendmsg, \
603 __assuan_spawn, _assuan_pth_waitpid, __assuan_socketpair, \
604 __assuan_socket, __assuan_connect }
605
606extern struct assuan_system_hooks _assuan_system_pth;
607#define ASSUAN_SYSTEM_PTH &_assuan_system_pth
608
609#define ASSUAN_SYSTEM_NPTH_IMPL \
610 static void _assuan_npth_usleep (assuan_context_t ctx, unsigned int usec) \
611 { (void) ctx; npth_usleep (usec); } \
612 static ssize_t _assuan_npth_read (assuan_context_t ctx, assuan_fd_t fd, \
613 void *buffer, size_t size) \
614 { ssize_t res; (void) ctx; npth_unprotect(); \
615 res = __assuan_read (ctx, fd, buffer, size); \
616 npth_protect(); return res; } \
617 static ssize_t _assuan_npth_write (assuan_context_t ctx, assuan_fd_t fd, \
618 const void *buffer, size_t size) \
619 { ssize_t res; (void) ctx; npth_unprotect(); \
620 res = __assuan_write (ctx, fd, buffer, size); \
621 npth_protect(); return res; } \
622 static int _assuan_npth_recvmsg (assuan_context_t ctx, assuan_fd_t fd, \
623 assuan_msghdr_t msg, int flags) \
624 { int res; (void) ctx; npth_unprotect(); \
625 res = __assuan_recvmsg (ctx, fd, msg, flags); \
626 npth_protect(); return res; } \
627 static int _assuan_npth_sendmsg (assuan_context_t ctx, assuan_fd_t fd, \
628 const assuan_msghdr_t msg, int flags) \
629 { int res; (void) ctx; npth_unprotect(); \
630 res = __assuan_sendmsg (ctx, fd, msg, flags); \
631 npth_protect(); return res; } \
632 static pid_t _assuan_npth_waitpid (assuan_context_t ctx, pid_t pid, \
633 int nowait, int *status, int options) \
634 { pid_t res; (void) ctx; npth_unprotect(); \
635 res = __assuan_waitpid (ctx, pid, nowait, status, options); \
636 npth_protect(); return res; } \
637 \
638 struct assuan_system_hooks _assuan_system_npth = \
639 { ASSUAN_SYSTEM_HOOKS_VERSION, _assuan_npth_usleep, __assuan_pipe, \
640 __assuan_close, _assuan_npth_read, _assuan_npth_write, \
641 _assuan_npth_recvmsg, _assuan_npth_sendmsg, \
642 __assuan_spawn, _assuan_npth_waitpid, __assuan_socketpair, \
643 __assuan_socket, __assuan_connect }
644
645extern struct assuan_system_hooks _assuan_system_npth;
646#define ASSUAN_SYSTEM_NPTH &_assuan_system_npth
647
648
649#ifdef __cplusplus
650}
651#endif
652#endif /* ASSUAN_H */
653/*
654Local Variables:
655buffer-read-only: t
656End:
657*/
658