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 | |
35 | typedef 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 |
47 | extern "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 | |
81 | struct assuan_context_s; |
82 | typedef struct assuan_context_s *assuan_context_t; |
83 | |
84 | typedef int assuan_fd_t; |
85 | #define ASSUAN_INVALID_FD (-1) |
86 | #define ASSUAN_INVALID_PID ((pid_t) -1) |
87 | static GPG_ERR_INLINE assuan_fd_t |
88 | assuan_fd_from_posix_fd (int fd) |
89 | { |
90 | return fd; |
91 | } |
92 | |
93 | |
94 | assuan_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. */ |
101 | struct assuan_sock_nonce_s |
102 | { |
103 | size_t length; |
104 | }; |
105 | typedef struct assuan_sock_nonce_s assuan_sock_nonce_t; |
106 | |
107 | |
108 | /* Global interface. */ |
109 | |
110 | struct assuan_malloc_hooks |
111 | { |
112 | void *(*malloc) (size_t cnt); |
113 | void *(*realloc) (void *ptr, size_t cnt); |
114 | void (*free) (void *ptr); |
115 | }; |
116 | typedef 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). */ |
129 | typedef 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. */ |
133 | const char *assuan_check_version (const char *req_version); |
134 | |
135 | /* Set the default gpg error source. */ |
136 | void assuan_set_gpg_err_source (gpg_err_source_t errsource); |
137 | |
138 | /* Get the default gpg error source. */ |
139 | gpg_err_source_t assuan_get_gpg_err_source (void); |
140 | |
141 | |
142 | /* Set the default malloc hooks. */ |
143 | void assuan_set_malloc_hooks (assuan_malloc_hooks_t malloc_hooks); |
144 | |
145 | /* Get the default malloc hooks. */ |
146 | assuan_malloc_hooks_t assuan_get_malloc_hooks (void); |
147 | |
148 | |
149 | /* Set the default log callback handler. */ |
150 | void assuan_set_log_cb (assuan_log_cb_t log_cb, void *log_cb_data); |
151 | |
152 | /* Get the default log callback handler. */ |
153 | void 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. */ |
158 | gpg_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. */ |
163 | gpg_error_t assuan_new (assuan_context_t *ctx); |
164 | |
165 | /* Release all resources associated with the given context. */ |
166 | void 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. */ |
170 | void assuan_free (assuan_context_t ctx, void *ptr); |
171 | |
172 | |
173 | /* Set user-data in a context. */ |
174 | void assuan_set_pointer (assuan_context_t ctx, void *pointer); |
175 | |
176 | /* Get user-data in a context. */ |
177 | void *assuan_get_pointer (assuan_context_t ctx); |
178 | |
179 | |
180 | /* Definitions of flags for assuan_set_flag(). */ |
181 | typedef 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. */ |
205 | void assuan_set_flag (assuan_context_t ctx, assuan_flag_t flag, int value); |
206 | |
207 | /* Return the VALUE of FLAG in context CTX. */ |
208 | int assuan_get_flag (assuan_context_t ctx, assuan_flag_t flag); |
209 | |
210 | |
211 | /* Same as assuan_set_flag (ctx, ASSUAN_CONFIDENTIAL, 1). */ |
212 | void assuan_begin_confidential (assuan_context_t ctx); |
213 | |
214 | /* Same as assuan_set_flag (ctx, ASSUAN_CONFIDENTIAL, 0). */ |
215 | void 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. */ |
228 | typedef 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. */ |
233 | void 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 |
239 | struct 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 | }; |
283 | typedef 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. */ |
292 | void 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. "" */ |
297 | const char *assuan_get_assuan_log_prefix (void); |
298 | |
299 | /* Global default log stream. */ |
300 | void assuan_set_assuan_log_stream (FILE *fp); |
301 | |
302 | /* Set the per context log stream for the default log handler. */ |
303 | void assuan_set_log_stream (assuan_context_t ctx, FILE *fp); |
304 | |
305 | |
306 | typedef gpg_error_t (*assuan_handler_t) (assuan_context_t, char *); |
307 | |
308 | /*-- assuan-handler.c --*/ |
309 | gpg_error_t assuan_register_command (assuan_context_t ctx, |
310 | const char *cmd_string, |
311 | assuan_handler_t handler, |
312 | const char *help_string); |
313 | gpg_error_t assuan_register_pre_cmd_notify (assuan_context_t ctx, |
314 | gpg_error_t (*fnc)(assuan_context_t, const char *cmd)); |
315 | gpg_error_t assuan_register_post_cmd_notify (assuan_context_t ctx, |
316 | void (*fnc)(assuan_context_t, |
317 | gpg_error_t)); |
318 | gpg_error_t assuan_register_bye_notify (assuan_context_t ctx, |
319 | assuan_handler_t handler); |
320 | gpg_error_t assuan_register_reset_notify (assuan_context_t ctx, |
321 | assuan_handler_t handler); |
322 | gpg_error_t assuan_register_cancel_notify (assuan_context_t ctx, |
323 | assuan_handler_t handler); |
324 | gpg_error_t assuan_register_input_notify (assuan_context_t ctx, |
325 | assuan_handler_t handler); |
326 | gpg_error_t assuan_register_output_notify (assuan_context_t ctx, |
327 | assuan_handler_t handler); |
328 | |
329 | gpg_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 | |
334 | gpg_error_t assuan_process (assuan_context_t ctx); |
335 | gpg_error_t assuan_process_next (assuan_context_t ctx, int *done); |
336 | gpg_error_t assuan_process_done (assuan_context_t ctx, gpg_error_t rc); |
337 | int assuan_get_active_fds (assuan_context_t ctx, int what, |
338 | assuan_fd_t *fdarray, int fdarraysize); |
339 | |
340 | const char *assuan_get_command_name (assuan_context_t ctx); |
341 | |
342 | FILE *assuan_get_data_fp (assuan_context_t ctx); |
343 | gpg_error_t assuan_set_okay_line (assuan_context_t ctx, const char *line); |
344 | gpg_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. */ |
352 | gpg_error_t assuan_command_parse_fd (assuan_context_t ctx, char *line, |
353 | assuan_fd_t *rfd); |
354 | |
355 | |
356 | /*-- assuan-listen.c --*/ |
357 | gpg_error_t assuan_set_hello_line (assuan_context_t ctx, const char *line); |
358 | gpg_error_t assuan_accept (assuan_context_t ctx); |
359 | assuan_fd_t assuan_get_input_fd (assuan_context_t ctx); |
360 | assuan_fd_t assuan_get_output_fd (assuan_context_t ctx); |
361 | gpg_error_t assuan_close_input_fd (assuan_context_t ctx); |
362 | gpg_error_t assuan_close_output_fd (assuan_context_t ctx); |
363 | |
364 | |
365 | /*-- assuan-pipe-server.c --*/ |
366 | gpg_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 |
372 | gpg_error_t assuan_init_socket_server (assuan_context_t ctx, |
373 | assuan_fd_t listen_fd, |
374 | unsigned int flags); |
375 | void 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 |
380 | gpg_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 |
390 | gpg_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 --*/ |
394 | gpg_error_t assuan_socket_connect_fd (assuan_context_t ctx, int fd, |
395 | unsigned int flags); |
396 | |
397 | /*-- context.c --*/ |
398 | pid_t assuan_get_pid (assuan_context_t ctx); |
399 | struct _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 | }; |
410 | typedef struct _assuan_peercred *assuan_peercred_t; |
411 | |
412 | gpg_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 |
425 | typedef int assuan_response_t; |
426 | |
427 | /* This already de-escapes data lines. */ |
428 | gpg_error_t assuan_client_read_response (assuan_context_t ctx, |
429 | char **line, int *linelen); |
430 | |
431 | gpg_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 --*/ |
437 | gpg_error_t |
438 | assuan_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 --*/ |
449 | gpg_error_t assuan_inquire (assuan_context_t ctx, const char *keyword, |
450 | unsigned char **r_buffer, size_t *r_length, |
451 | size_t maxlen); |
452 | gpg_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 --*/ |
460 | gpg_error_t assuan_read_line (assuan_context_t ctx, |
461 | char **line, size_t *linelen); |
462 | int assuan_pending_line (assuan_context_t ctx); |
463 | gpg_error_t assuan_write_line (assuan_context_t ctx, const char *line); |
464 | gpg_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")). */ |
470 | gpg_error_t assuan_sendfd (assuan_context_t ctx, assuan_fd_t fd); |
471 | gpg_error_t assuan_receivefd (assuan_context_t ctx, assuan_fd_t *fd); |
472 | |
473 | |
474 | /*-- assuan-util.c --*/ |
475 | gpg_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. */ |
484 | gpg_error_t assuan_sock_init (void); |
485 | void assuan_sock_deinit (void); |
486 | int assuan_sock_close (assuan_fd_t fd); |
487 | assuan_fd_t assuan_sock_new (int domain, int type, int proto); |
488 | int assuan_sock_connect (assuan_fd_t sockfd, |
489 | struct sockaddr *addr, int addrlen); |
490 | int assuan_sock_bind (assuan_fd_t sockfd, struct sockaddr *addr, int addrlen); |
491 | int assuan_sock_get_nonce (struct sockaddr *addr, int addrlen, |
492 | assuan_sock_nonce_t *nonce); |
493 | int 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. */ |
498 | void assuan_set_system_hooks (assuan_system_hooks_t system_hooks); |
499 | |
500 | void assuan_ctx_set_system_hooks (assuan_context_t ctx, |
501 | assuan_system_hooks_t system_hooks); |
502 | |
503 | void __assuan_usleep (assuan_context_t ctx, unsigned int usec); |
504 | int __assuan_pipe (assuan_context_t ctx, assuan_fd_t fd[2], int inherit_idx); |
505 | int __assuan_close (assuan_context_t ctx, assuan_fd_t fd); |
506 | int __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); |
511 | int __assuan_socketpair (assuan_context_t ctx, int _namespace, int style, |
512 | int protocol, assuan_fd_t filedes[2]); |
513 | int __assuan_socket (assuan_context_t ctx, int _namespace, int style, int protocol); |
514 | int __assuan_connect (assuan_context_t ctx, int sock, struct sockaddr *addr, socklen_t length); |
515 | ssize_t __assuan_read (assuan_context_t ctx, assuan_fd_t fd, void *buffer, size_t size); |
516 | ssize_t __assuan_write (assuan_context_t ctx, assuan_fd_t fd, const void *buffer, size_t size); |
517 | int __assuan_recvmsg (assuan_context_t ctx, assuan_fd_t fd, assuan_msghdr_t msg, int flags); |
518 | int __assuan_sendmsg (assuan_context_t ctx, assuan_fd_t fd, const assuan_msghdr_t msg, int flags); |
519 | pid_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 | |
606 | extern 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 | |
645 | extern 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 | /* |
654 | Local Variables: |
655 | buffer-read-only: t |
656 | End: |
657 | */ |
658 | |