tevent-0.9.19/ABI/tevent-0.9.10.sigs 0000660 0000000 0000000 00000012761 12101212317 016362 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.11.sigs 0000660 0000000 0000000 00000012761 12101212317 016363 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.12.sigs 0000660 0000000 0000000 00000013053 12101212317 016357 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.13.sigs 0000660 0000000 0000000 00000013172 12101212317 016362 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.14.sigs 0000660 0000000 0000000 00000013756 12101212317 016373 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_running: bool (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.15.sigs 0000660 0000000 0000000 00000013756 12101212317 016374 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_running: bool (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.16.sigs 0000660 0000000 0000000 00000014535 12101212317 016371 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_context_init_ops: struct tevent_context *(TALLOC_CTX *, const struct tevent_ops *, void *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_get_trace_callback: void (struct tevent_context *, tevent_trace_callback_t *, void *)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_running: bool (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_set_trace_callback: void (struct tevent_context *, tevent_trace_callback_t, void *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_trace_point_callback: void (struct tevent_context *, enum tevent_trace_point)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.17.sigs 0000660 0000000 0000000 00000014535 12101212317 016372 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_context_init_ops: struct tevent_context *(TALLOC_CTX *, const struct tevent_ops *, void *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_get_trace_callback: void (struct tevent_context *, tevent_trace_callback_t *, void *)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_running: bool (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_set_trace_callback: void (struct tevent_context *, tevent_trace_callback_t, void *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_trace_point_callback: void (struct tevent_context *, enum tevent_trace_point)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.18.sigs 0000660 0000000 0000000 00000015002 12153373752 016403 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_add_timer_v2: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_context_init_ops: struct tevent_context *(TALLOC_CTX *, const struct tevent_ops *, void *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_get_trace_callback: void (struct tevent_context *, tevent_trace_callback_t *, void *)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_running: bool (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_set_trace_callback: void (struct tevent_context *, tevent_trace_callback_t, void *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_trace_point_callback: void (struct tevent_context *, enum tevent_trace_point)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.19.sigs 0000660 0000000 0000000 00000015002 12176475205 016405 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_req_oom: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_add_timer_v2: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_context_init_ops: struct tevent_context *(TALLOC_CTX *, const struct tevent_ops *, void *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_get_trace_callback: void (struct tevent_context *, tevent_trace_callback_t *, void *)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_running: bool (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_set_trace_callback: void (struct tevent_context *, tevent_trace_callback_t, void *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_trace_point_callback: void (struct tevent_context *, enum tevent_trace_point)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/ABI/tevent-0.9.9.sigs 0000660 0000000 0000000 00000012761 11741275274 016336 0 ustar root root 0000000 0000000 _tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
_tevent_loop_once: int (struct tevent_context *, const char *)
_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
_tevent_loop_wait: int (struct tevent_context *, const char *)
_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
_tevent_req_callback_data: void *(struct tevent_req *)
_tevent_req_cancel: bool (struct tevent_req *, const char *)
_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
_tevent_req_data: void *(struct tevent_req *)
_tevent_req_done: void (struct tevent_req *, const char *)
_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
_tevent_req_notify_callback: void (struct tevent_req *, const char *)
_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_backend_list: const char **(TALLOC_CTX *)
tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
tevent_common_check_signal: int (struct tevent_context *)
tevent_common_context_destructor: int (struct tevent_context *)
tevent_common_fd_destructor: int (struct tevent_fd *)
tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_common_loop_immediate: bool (struct tevent_context *)
tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
tevent_common_loop_wait: int (struct tevent_context *, const char *)
tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
tevent_context_init: struct tevent_context *(TALLOC_CTX *)
tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
tevent_fd_get_flags: uint16_t (struct tevent_fd *)
tevent_fd_set_auto_close: void (struct tevent_fd *)
tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
tevent_loop_allow_nesting: void (struct tevent_context *)
tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
tevent_queue_length: size_t (struct tevent_queue *)
tevent_queue_start: void (struct tevent_queue *)
tevent_queue_stop: void (struct tevent_queue *)
tevent_re_initialise: int (struct tevent_context *)
tevent_register_backend: bool (const char *, const struct tevent_ops *)
tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
tevent_req_is_in_progress: bool (struct tevent_req *)
tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
tevent_req_received: void (struct tevent_req *)
tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
tevent_set_abort_fn: void (void (*)(const char *))
tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
tevent_set_debug_stderr: int (struct tevent_context *)
tevent_set_default_backend: void (const char *)
tevent_signal_support: bool (struct tevent_context *)
tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
tevent_timeval_current: struct timeval (void)
tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
tevent_timeval_is_zero: bool (const struct timeval *)
tevent_timeval_set: struct timeval (uint32_t, uint32_t)
tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
tevent_timeval_zero: struct timeval (void)
tevent_wakeup_recv: bool (struct tevent_req *)
tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)
tevent-0.9.19/Makefile 0000660 0000000 0000000 00000001235 12101212317 014502 0 ustar root root 0000000 0000000 # simple makefile wrapper to run waf
WAF=WAF_MAKE=1 PATH=buildtools/bin:../../buildtools/bin:$$PATH waf
all:
$(WAF) build
install:
$(WAF) install
uninstall:
$(WAF) uninstall
test:
$(WAF) test $(TEST_OPTIONS)
dist:
touch .tmplock
WAFLOCK=.tmplock $(WAF) dist
distcheck:
touch .tmplock
WAFLOCK=.tmplock $(WAF) distcheck
clean:
$(WAF) clean
distclean:
$(WAF) distclean
reconfigure: configure
$(WAF) reconfigure
show_waf_options:
$(WAF) --help
# some compatibility make targets
everything: all
testsuite: all
check: test
# this should do an install as well, once install is finished
installcheck: test
etags:
$(WAF) etags
ctags:
$(WAF) ctags
tevent-0.9.19/bindings.py 0000660 0000000 0000000 00000003601 11741275274 015234 0 ustar root root 0000000 0000000 #!/usr/bin/python
#
# Python integration for tevent - tests
#
# Copyright (C) Jelmer Vernooij 2010
#
# ** NOTE! The following LGPL license applies to the tevent
# ** library. This does NOT imply that all of Samba is released
# ** under the LGPL
#
# This library 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 3 of the License, or (at your option) any later version.
#
# This library 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 library; if not, see .
import signal
import _tevent
from unittest import TestCase
class BackendListTests(TestCase):
def test_backend_list(self):
self.assertTrue(isinstance(_tevent.backend_list(), list))
class CreateContextTests(TestCase):
def test_by_name(self):
ctx = _tevent.Context(_tevent.backend_list()[0])
self.assertTrue(ctx is not None)
def test_no_name(self):
ctx = _tevent.Context()
self.assertTrue(ctx is not None)
class ContextTests(TestCase):
def setUp(self):
super(ContextTests, self).setUp()
self.ctx = _tevent.Context()
def test_signal_support(self):
self.assertTrue(type(self.ctx.signal_support) is bool)
def test_reinitialise(self):
self.ctx.reinitialise()
def test_loop_wait(self):
self.ctx.loop_wait()
def test_add_signal(self):
sig = self.ctx.add_signal(signal.SIGINT, 0, lambda callback: None)
self.assertTrue(isinstance(sig, _tevent.Signal))
tevent-0.9.19/configure 0000770 0000000 0000000 00000000647 11741275274 015002 0 ustar root root 0000000 0000000 #!/bin/sh
PREVPATH=`dirname $0`
if [ -f $PREVPATH/../../buildtools/bin/waf ]; then
WAF=../../buildtools/bin/waf
elif [ -f $PREVPATH/buildtools/bin/waf ]; then
WAF=./buildtools/bin/waf
else
echo "tevent: Unable to find waf"
exit 1
fi
# using JOBS=1 gives maximum compatibility with
# systems like AIX which have broken threading in python
JOBS=1
export JOBS
cd . || exit 1
$WAF configure "$@" || exit 1
cd $PREVPATH
tevent-0.9.19/doc/img/tevent_context_stucture.png 0000660 0000000 0000000 00000052600 12162141064 022111 0 ustar root root 0000000 0000000 ‰PNG
IHDR - ^ ÆÕ¸× UGIDATxÚí½w\TGÛÿOï ¤I D, Ñ;Š4–[
¶ƒ±Ý&Æ’¦b¬Ñ<‰1¶X"Ñ;v%±5‚
EEEEP ŠbC$¿Ïã|³¿}¶¹,,ì.Ÿ÷ ¼ØSæœ3sÍõ™kÎœ£¿ !„êÈY@!„:D!„:D!„P‡!„P‡!„ C >¼páÂÎ;WZ5oÞ¼©S§&½`Ú´iß}÷ݦM›Nœ8‘ŸŸÿüùs–!„P‡*‡¬¬¬¥K—¾ýöÛþþþ¦¦¦&R¿@z pvvîرã¨Q£~úé§Û·oS–!„:T>ž›ô‚‰' <¸sçÎááávvvÆÿ€mllºtéòõ×_#N*++cùBuH™™™3fÌ 433Úƒ0hàÀË—/?}útqqqiiés)Ê^ ½ „úùçŸ?úè£ÈÈHkkk‰ uïÞý÷߇ȱ !„:$ËÑ£Gû÷ïïääÍ€ü ²ùøãÏž=ûôéS¡7åJM"N7oÞ\°`A‡ ¬¬¬„ µlÙ299ùþýû !„:ôÿb (èOCÔòÆo¤¤¤ÝÉÉÉßßÿÔ©Sz7w΃bcc---ûöí{çÎ †t„Rsu())ÉÑѱI“&×®]Óë—+¸ù~ýúY[[¿ýöÛº?ØB¨CÿKff¦XPuóæÍ°øé… ‚ƒƒ-,,¶nÝÊõŠ!DtHŒ‘{çw &€˜={¶““S‹-®_¿Î±s„¢Ó:tôèÑÚµk[ZZ 9rD§f«÷îÝ 311Y¶lçû!„Ö¡Áƒ#9rdaa¡!=ö¢E‹\\\¢££srrh„¢£:$Þ ÙÚÚ¦¥¥Øè²ââ∈SSÓ-[¶ð-!„è¨Í™3ÇÙÙ9>>Þ ?üœ}º···Ïš5k ï¿ÿ>??¿äädÉ’Ûø?22ÒÞÞ¾mÛ¶iiiÏž=+o
*Ø·o_LL ‡ö }¬¬¬¦OŸÎ™!DçtèñãÇõë×711ùõ×_
òÏÌÌÌÀÀ@KKËsçÎՄϤ!DÏtŒ7ÎÞÞ^LQjxOž””äèèøúë¯çååÑ!DuèìÙ³vvvéééöÿáǯ¼ò
¢½7r: BÑQ 666†7ZAŒPˆŠŠR±N+!„êס#GŽx{{[YY½tM =¢¨¨HCK—.å Û„¢Ó:TVVöÖ[oY[[2¤ À0žyîܹÎÎΆ²³³9BBtZ‡À… ÌÍÍ·nÝZ]ÓžV"™™™uêÔÁãp¡BÑ “'OvttlÖ¬™ @x‡¿9B S‡îÝ»233›2e
þ×ߧ]³fMZµœ
o !„²Ã‡ûúú"’Ø´i“žvgedd„‡‡›˜˜,_¾œÃ!DÏt¨¬¬lêÔ©ŽŽŽçϟ׻`ÂÓ©S' ‹øøøÛ·o³à !DÏt””” 0ÀÆƦM›6z·jܨQ£ìììš4irùòeŽ‘#„½Ô!““Wnff†¨BÞó#’srrrvvÞ³gÔ”¥N!úªCàÏ?ÿ
211yï½÷
uÿ ,Xàêêjii¹nݺG ±È !D¿u¨¬¬,55500PHÑíÛ·u¹›K"B?ýôÇ&Bˆ!è¢@Šâããoݺ¥›R4iÒ$'''ˆÐ÷ß_\\ÌÂ&„Ñ!™¨¨M›6—/_Ö©t}FŒaooÏHˆB S‡„ýùçŸfff¤mÛ¶éÈwEíÛ·‡9;;ÿüóÏ|'D!†©CBŠrrrúõëgcccmm””Tí³-¬Y³FDiMš49xð LˆG!Ô¡—PRR2iÒ$GGGccãæÍ›ïÝ»·Z¼fffÿþýmmmŒŒâãã³³³9s!„Ô ÑáÇ5jdfffaa1|øðË—/WÙzEEEE_|ñ…··7 ggç•+WrT!„Ô, Rt÷îÝO?ýÔÅÅz`mmýᇠ޼yS«AÉÇ¿ÿþûàà`³¼õÖ[—.]2˜õú!„:Tn :çÏŸïÓ§tÈØØØÞÞ¾ÿþû÷ï¯ôžºÌÌLhž¿¿?äÇÈÈ(**j×®] ?f‰BHÖ!‰ >|ø7Þj$F
Lš4 õìÙ³Š¤œ››»pḸ8$ BÊ+V¬@(ÆYã!„:ôÿU±ÑçŸîççgjj
AÂß ÄÄÄU«V;wNÍ©Þ®]»¶}ûvÈXtt´ äIYZZvéÒ1УG¨@„B R%HŠ”””wß}7$$ÄÌÌLDHÀÍÍ-22²gÏž ãÇŸ2eJÒ >ùä“!C†tíÚ5""ÂÑѧíòÓ©S§ùóççåå•––R!„:TŽðÊéûï¿ 0`€’TcddäààЮ]»áǯX±âÆÏž=£üBu¨4éþýûçÎÛ¶mÛòåËgÏž gmm 5qâÄE‹mܸ155qOIIÉóP~!„:¤YÌŸ?ßÙÙyôèÑ’,!B¡U_}õtè?ÿùÏ_ýÅ‚!„êuˆBuˆBuˆ:D!„:D!„:D "„B "„B ¢B¡B¡Q‡!„P‡!„P‡¨C„B¨C„B¨CÔ!B!Ô!B!Ô!ê!„ê!„êuˆBuˆBuˆ:DˆbŽ =:{öì$RµìܹóÑ£G,—êÊjê}SMw1:j«««1©Z^êvX.ZÍjê}SMw1ºVÖ¨QQQãÇŸL´Oll¬µµµ::ÄrÑ^VS‡è›jº‹ÑÁ² =ztAAAÑ>óçÏWÇí°\´šÕÔ!ú¦šîbt°¬Y t-ÃY.ZÍjê}ó÷L#¡Q‡XÒÌæËš:D b
¤ob¾ñžU™™9iÒ¤€€€«W¯ªsüÆ[·níèè¸`Á‚û÷ï+L§N:¦ÿ••¥¥›WvÐ!]+
²š:Dߤ÷u ‚.†e&M›6533322º|ùòKþý÷ß½½½×[WXX8a„ðððììl…éãÿ‹/–––¦¤¤Ô®]åhgg·eË–'Ož(,eeVqëÖŸ~úéwÞñðð¸råŠô®ÒÉܿ讕‹YM ¢oÒõ: 9 g%&&º¸¸´jÕ*==]²«‚.F_Ê://Ϩ½ˆá¥<{öL>“•1°±±A âÿç/P–Ž(kñYY <)) -hɱcǤKÏîçç·k×®Ç +¼h—.]^yåKKKe7)}ÊÒ!–‹Âr)WVS‡è›t½HˆŽŽÆé Ð-‰†UÐÅèKY¯_¿¾VZêä³öPX.
366Vv¤t:òiÂ뉡¡¡”¥íÛU\ Gª6HmèËEa¹P‡jÕœ:°mÛ6OOÏo¾ù¦¸¸-/ü?kÖ,I·žÁëÐ[·"""LMMõ¥¬U ©º¬ÅƘ˜[[ÛvíÚåæ檩C/½t¥ëË…:TÓu¨FÕ#FÀúwìØñôéSäC@@@\\ ÂÁ¢C]ºtÝM(n777ñ-99922ÒÞÞ¾mÛ¶iiik×®…<‹núÖ[Ã|8tôÈ‘#!ˆ¨¿¿ll¬Ìˆòº˜íÛ·+Œ‡©899I|\BB‚ä}¬f»ÆC3gάˆ¿ëÚµ+¤.&&&;;;''§iӦ׮]»ð300°E‹ˆ¤ñ¿$e§¨(kÄgˆ;“““ ?~ Õ÷óó“.2õËZE:/õwÂå!Oììì¤,•¢‚ýr/DXÅœ¹,™r¡†×_ Ž¿5¼lܸÑÝÝ}Ñ¢Eå ·ÚÅ(¼Ï’’$îíímee5hÐ dˆdÄf»v·–×߉~?´zõê…’‚6Š©©)J°OŸ>wîÜ‘ Œ€l£Á!ýi¡ÂSîÝ»Ã@Öýï‡X.
Ë…:d ̘1íkT*xRÖøèV›6m°·ÿþ2—«ÜqÛÑЖ×ÍvU¼l޼ƀ삇}ö쮵téÒÄO;wÎÈÈv»{öì0`€¤÷Ur{ò§ˆ€ÀPF2?Å)ˆ>½¼¼>6lØVtàÀé™]ä‘NDò:AY:ò1½xU)ÞYJ÷mBcÐRaf’sž®% b¹(,ê!ðÇ øøø˜››C'fÏž]Ãë€ //¯wïÞÐæ :œ:u꥽16Ÿ‚9(œ$ŒSˆ
µPþ™Þ-ùÎ.É)"MéP†Â 3eéÈ\éÿE&åÜÜ\ع:×Uxº6tˆå¢°\¨CzÏÝ»w£££ÍÌÌ>øà䆊¾šR$à ™ç9:d¨¨ÿ~Q×âºZ*êÞ3bÄ;;;Éj¬Zu1Ô!êuˆ:D ú?$''»»»ÛÛÛ 8p@¼Ga éaaa6J(כּ
4°´´´¶¶ÖàÜòÞ°å lý!]+
²š:¤[\»v-44ÔÄÄdîܹ’Á`¬Zu1Ô!
(UNE’ªšÖ ÃY.ZÍjênÙP¯^½¬¬¬ºté"ýe ë€V] u¨&Ã~9]Èjên•“‹‹‹··÷éÓ§¥0gjŽE±¬©CÔ!ÖÀjãäÉ“þþþ&&&«W¯–ùÈŸu€:D¨CÔ!Ö@íR\\üÚk¯™›› :T~9Öê¡Q‡XµËøñãíííÃÃÃÅW¢Ì™®CQQQª—! •…Š ÎY.U–ÕÔ¡êgûöížžž(¡””ùùIY´íbtP‡ŒI¢l‚s–K•e5u¨šÉÍÍk{O:U,Ä:PÅ.F§P67Ñ*Êf^g¹TMVS‡ª“²²² Í #=6ë@Uº]3 R-°\ª1«©CÕÉ’%KÜ^pâÄ ÊÐpµêb!Õ u¨ÚÈÈÈ666þᇠ>|H[$„P‡¨CUÇãÇccc-,, ½D!„P‡¨CUARR’££cHHHff&;Ž!Ô!êP•²oß>ooossóÍ›7«^;ŽB¨CÔ¡J¦°°°Y³f¦¦¦&Làw©„B ªj† jkk }ãÆ
Ú !„P‡ª”5kÖ¸»»;::þñÇ 2˹Buˆ:¤]²²²êׯobb‚'}ðàú' =ztöìÙœ§§*Ù¹s§.ýJ“ yP‡¨CåÑO÷îÝ---{ôè‘——WÞœquuå$=U‰ŽÛ!M‚æA ¢•›9sæàé|}}Ïž=+½Æú95~üxÎÓ£mbccuvTšÍƒ:D * ©©©P SSÓõë×?~üX³œ=ztAA'éÑ6óçÏ×};¤IÐ<¨CÔ¡rPTTÔªU+33³‘#G2gt ½Èmšsž:Ä.cÆŒ±··å•W®^½ªÙÔ 4}Ú!M‚9O bkȦM›<<Eßuˆ&¡¬|ËÊÊ]bª{TÌcÇŽI7JpK~~~»ví’ Ñª§æA ¢ý/§OŸ011Y¾|yÅ׸S‘3ëׯ¯U«–ŒçÕ6ê_´ŠoOÞklÛ¶ÍÓÓó›o¾)..†‹Áÿ³fͺÿ¾ëMBµI@ÄÆÐÐÐÌÌLiÄv™£Q‡ô•G µk×ÎÜÜ|Ð AùùùÚË™[·nEDD˜ššV¥ÓQÿ¢U{ò^cĈ¶¶¶;vìxúô)rƒ¸¸8éù, L‡hê„ÈØÃ@=ÍÍÍ¥Q‡ P‡>ýôS‡zõê]ºt©RÖ¸S–3]ºt±´´D=AÅvss»zõ*6&''GFFÚÛÛ·mÛ6--míÚµD¯wëÖÅ›*xgÜ!¶¬Zµ
ª)sʳgÏÐNœ2eJ``à¹sç’’’¼¼¼|||pVxQ…È ™’’"ÒÄ)’ô/\¸0}útooo¤¿fÍÜÞûï¿ö²ŸŸŸ¸œHJÙ ÂM ;v¬C‡¯½öZNNŽ¼×hÙ²¥™™®‚‚@ËàÁ¯\¹R¹Ž¦´´tÎœ9¾¾¾pm‰‰‰ÙÙÙ’V¶f»hÚ3 Qèééé±±±¸™J‹Ô!êðo¿ý†*
ûÞ¾};ÚàZÍáX¥ßÌ㢸ú†
à,Po¡…ðn¨ØݺukÐ ü¯ÐEœØ»wïãÇ—””ÈŸrýúõæÍ›Ã}#å©S§¢2ïݻLj]òU†Ì‘Mš4i¢V7mÚTü¿`Á‚Û·o‹Þ3ø \~çàÁƒpCâr
Û%),Y²dË–-¸a<©¼×ÀÁÆÆÆ’-8 gI¿ÆPæh¢££'Nœ¨æ—sçÎuqq1z.7xðà‚‚‚Šì’ æ3 2dî'$$$è \]]MLLh˜„DoCÉpÊ´iÓÄpVêuÈ
øÎ;°l´õݽ{·
rF¦žôë×ÏÚÚ
÷ œØµÿ~Ô[¸3áéà†~üñÇ{÷î);K1R!¤KÝÜÜ\xp…uû¥½"’4•¥¯ìr
ï M¤ OÔD$!cuêÔ‘Þ‚,,,ÔÑ¡rMpÙ¨Q#ÜžÑ?XYYI.¡Ù.雑Ìgj$MB“ÖRø ‰,[¶ìáÇÔ!êÞ0ª
š´666[·®Äq¨p_~ù¥š:T¿~}8,ÑØHîU«V¶¶¶Ø…ÿÇŒ#J®ì™”¥jætT'¢â§šw¨pKãÆáp®è‘„tÇ‘2G£l
Q´Äå㡆
J+
¢a‰¢h¶K: š9sæ;＃Ö=n>à H)Œ‡h/5 i ƒoݺÕÃÃÃÞÞ~×®]¾¾¾Ô!ê~ðòåËkÕª…GHMM¬5îöìÙoõꫯ*›âW¦žˆæÿÎ;å»,X çµxñâ… ®[·®¸¸Xõ)ºãtÔ¼C…[† W{äȸ*øYÿØØX™WÓ
Š)Då söìÙNNNEIHH¼rÐl—tãF¼Ù¥RÌ›7Oͦ MB…‰ ùàééiffF ¢éqgff¢n ¶hÑ"I}®Ož|½$ü¸jïµ»{÷ntt44õƒ>¨ ]BÏ7nŒgD¤¸páBéw4}5Qÿ-…ë© IP‡ D‡nÞ¼ùñÇ ‹©m¡ ø'!!!99¹ Ò¢lБŠ”ФóçÏOž<¹Q£FpÖP#77·qãÆ•ë+ôJgĈ_ägÏ,h‚Íž=[|&Ò¬Y³ÔÔT™•ŠhúÔ!êuˆ:TŽž%D*¾¾¾¢¶I“&ß~ûmaa¡:»úšôÛo¿õë×Ñ 7ÔhÊ”)bˆmç ”ÕÝÝÝÞÞþÀ¯qwõêÕ.]ºXYY!¨3fÌ;wä D—M?,,ÌF U<å3hÐ ‚okkku®.îÜò\ˆ&aHæQ£uhÇŽ ‘‘‘V @QQQ¿üòKqq±6äA¨QzzºDÂÃÃSRR*k u¸víZhh(²¹sçJ÷¡• dQ`` ñññÙ¸q£²÷^ºlú¥Ê©Þ›Ñø`êP5 ƒ1ªC(’Ñ£G;88@ @›7o~ø𡶡FˆE5j„`ÂÂÂâã?®ÄÙtTÛh¯^½Ä ”‘þ(R}ŠŠŠF… ƒfwëÖMõÄ\4}ºxšsž:¤Š'Nˆ0¡ÉÔ©Sóó󫲋 ×B!Ö¶‚
¶oß A´¶ßÁ]\\¼½½OŸ>ÁµcPkä˜í—_~ùÒ%Ãiút44 æ|¸²fÖ‘çäÉ“þþþxäÕ«W—w9‚ رø/""âСCêô%ÒôéhhÌyêb.\èææfdd4f̘¼¼¼ª ) #E999qqq–––~~~; ‚âââ×^{
¡ÌСCågéWÍÍ›7{õê…¨6lØ°ÜÜ\5sŒ¦OGC“`ÎS‡‹«««™™ÙôéÓÅtñºÀÝ»wûôécmm%)?~¼½½}xx¸ø¨[ý·lÙR·n]„kžžžëÖ+×bá’ ®ˆC*—N:)›UV×¼!M‚æQ£uhÁ‚!D ßÿýƒtê‘ =z4xð`[[[HQåvÐmß¾ *+,×Ø}ºuëÖP/Žš
ç‹ÐL&UˆÂu†tšÍ£Fë*€¿¿?³fÍzé@¯êí Cˆ]»v7nܨà»+œ>`À hILLŒêé„%@ü/^ìåå…¼jÐ Áž={4ž}®ŒTº\oY:4š«C7oÞë^ ;¶°°PÇŸíúõë"‚?~|¿+Z²d‰Û Ä´ó/=>//¯_¿~¶¶¶¡Aƒ!ßôb BÑi ‚ÿíÛ·/b‚öíÛÃÅëE‹`ïÞ½b2ì[·j<ÛBFFFpp0å‡ ~Pg|Áo¿ýfffÝZ¾|¹nv]BˆþéÐܹs=== ;¦½¯s*½ûbòäÉŽŽŽ†Ë—/k ?Žµ°°0`€ôbÊþì³ÏÄbϯ½öÚ©S§ô%£!D×uèÚµk
4011A¿\cŽ«{÷>úè#
zçÄL
!!!™™™ªeìüùó111–––-¨Ñ_ýÅNdB©4 zçwlllÔ‰ tßÿ aœ‹‹ ”r½§Ù·oŸ···¹¹ùæÍ›UŒ2€Þ@ž}|| ÓP¬;wJ¯²L!¤¢:tôèÑÚµk;;;«ù–^×€NtïÞ ‘J¹Fý6kÖÌÔÔt„ *Î*((4hXDµÿþ 9$B*Y‡zôè'w\5³Yk5$:w:1tèP[[Ûèèè7n(;æÀfffNNNß}÷Æ @¢h#Ξ=›Ó T;;wîäEZÔ¡?þøÃÛÛÛÁÁ!--M[ú‰âââ,,,¦L™¢ÎW¨kÖ¬qwwwttÄã+ kðôéÓéÓ§CØŒ¡Uˆµ7Ç+}
ý‹2¾úê+±’/©^8Âvuè½÷ÞCX0|øpÝÿ`H5bùÔzõê]½zUõ‚¬¬¬úõ뛘˜ ’+œµtêÔI,¢:nÜ8m/uA_Cÿ¢Â6ÄDsãÇç4ÕBll,gœÓ®Ý¼y388ØÒÒòÈ‘#úøfH„5-[¶„rüúë¯* à0ñ2©G yyyò¬[·. *åïï¿iÓ¦*h,Ó×п¨¶Ñ£GpŽƒjaþüùœ[»:´xñb´Äãââ4[uT×øüóÏ ‡
¦"¶›3g¬Ê××÷ìÙ³2ý÷îÝùöööFFF={öDTT5ÚL_Cÿ¢Ú6èY†¬C]»v“jƤ ‡ òòòrwwWöMkjj*ÈÔÔtýúõ2c¯ =Ú¬Y3sssè,¯*çÖ£¡Ó¿Ð6X5T‡233á”mll222 ã“ÌgÏž½òÊ+&&&
»æ -Zµ2339r¤tÀ„ çË/¿¬U«–±±qddä‘#GªxÙY:ý mƒEPCuhÙ²ennníÛ·7ŒN9Á |`gg§pn…1cÆ ÖPIdÈÎÎîÞ½»µµ5‚¤Q£Fݾ}»ê%™†NÿRCl£OŸ>¯¾úêÍ›7+1M´§'Mš€zŸuêÔ1ý‡¬¬,õÓQv"«§vuèã?vppøä“Otg¹ÕŠ#FÍõêÕ Š"½}Ó¦M þöìÙ# w6…„„Àìj×®«kB#úú½ö/†g-[¶¬\ÛhÞ¼¹™™™‘‘ÑåË—ñ388ÿ_¼x±´´4%%U厶é–-[¤ûH¤BFé ‚‚‚$IQ‡ªB‡:vìhaa±nÝ: ™¥&//FP®&Œ<çÎóññÃB #Ù»711™9s¦xñóàÁ„GaØ\çÎ/\¸PÃék*âk$Ç&&&º¸¸´jÕ*==]²K¯ý‹Š›¬”úRÅ•ôù *÷–ž={&]¸Â6ÄÿeeeÈ71‡$š¡ÇŽ “¶
<…ŸŸß®]»¤ ôéÔ!ëÚþõë×766>yò¤Ž|¾º~ýúZµjI[€fÔ[>KòY®d=‹ØØØ[·na ŽŒðhÖ¬YÕ Ò×TÄ×HˆŽŽ†8%$$4mÚTº!¢¿þEÅMVV}©–JZ¹H®|ACÄÆÐÐPÖÒƉí2ÏB ªR ÊÈÈ@Ü€ õÚµkºp£P±¨]ÅM¼C‡æææ’0|Ñ¢E®®®h
A™àÎ.\èéé F„´ÿ~W-¢¯Ñ)_³mÛ6ë7ß|S\\Œ.þG Cz &Ó¡J¬/ÕRI«Ò6ÄƘ˜[[ÛvíÚI¿§U³ :tÈÛÛû_ÿú—^Jrrrdd¤½½}Û¶máÐ×®]‹ª.ºV[·n-1b„ƒƒ¶¬ZµJõçŸûöíƒY 5˜õÁƒKJJºtébii ÀénnnV$]·‹/¼j¾xLLLD #\ÒéÓ§ÅG©Ë—/ǹ½{÷Æ.ˆÐ!CpÏ:2J¾¦â¾¶/³cÇ4,(ô¸¸8éï”
L‡dê‹xm¦A%•9
5D S¦L 00¯X±BýùFÅ£ÁùâDx1ü…»üí·ßTL~Z.P] ?~üàÁƒ»wïÞ¹sµ¾žÞÿìÙ³éééDŽ 9ràÀ={öà1‘lÚ´ ÉÏ?ÿŒø‘Á?üðí·ß~ýõ×ÿó?ÿóÅ_@2•M¸I_£¦¯ÂÁ×ã1EAçàÐ¥;UÄC ü±ü,¨(5y“kØ°¡´¢àö$Š¢Ù.ùxѼômÄÅÅ©iPI•R)¶
2nÜ8DÃ0¿Aƒ‰’ôéb8Ìœ9sP7ÑÜD)ˆoÏU\ýÌ™3-[¶DÌ
-A¬¬‰Ê"2ÄÓÓÆI Ò ÓÐÁéÀá¢];Œ²ÃOHÜ
¼†|“M!bÙ=üÍÍͽ~ýzTT”Â~91Þá3ÒG³ú¥«9È<œ²¨ü8wðàÁÇ÷Ýwßyçöïß¿wïÞ={öÄsuêÔ wÞ¦MøqÜI“&MÐzÅ).\Í%«›››““ÄmÃpM•c¢¢Í«ŽÑ×(»C”/
HL
ö÷÷•¥Ð¿¨˜^VþygÏž
K(Š$Ôx— Ê&cUXOežHƒJªì”J±
Ѥ8qâ* j臗> ¹?üí$´`E’ŽWG=EÜ µFKEÙ]½T‡D>£º‰E–©Czó~hãÆîîî"¼€áöéÓq€d/ Pÿ{X1µRƒI!Ù·ÞzK¤&º/à1ÑúƒùB*Ð&EšpL>>> ;v¼té’:o‰Äû!ܧðï¢S¾\©™`ee#ÆUàd½¼¼üüüÐ ‡t………EDD >GGG·nݺmÛ¶ :t€ÔuëÖ
²‡'‚¾ýöÛ¨™Ã†
9r$Ô@x$¨ŽÑ×(»Ca¢‹-Òê¸mDðH‚Šò‚ÙK/¯Ù®ŠôÙJ×”¬•Tá)÷î݃!!¯Ä—…2?e.ªºEÌ]róæM4ò`~2IM:5##Í#4 $¢úê¨_¢+åðá₆"Eécä Žº{÷né˜'OžÄÇÇ£D¨CÕ©Cÿýïa‚ÿþ÷¿Õ/‡æÃÒ¥KCBB¬;wî ë‘~ƒ
k0`€šã¿EjPÁ€€ ¢¢óçÏ‹Ô6oÞŒ‘‘‘©©©¢;ƒ-zQ[Ô·-ÆËI^‡@ &L˜€p±Â?ü°bÅŠÕ«WÿüóÏ6lÀ!uhªïÝ»÷àÁƒð}p©§N:wî\ff&¼*Â5´©!ÕhÅ£íÛ…s,UÎsP± }š¾éCï¡ap:{´d>Œ«,ÿë•”u¥ìÒX‡¤ë ÌRƒJªðQÝ l ÕMæ§ÌEUÜ92 •.**
ÿüòË/°I™¤BCC¥û`¥å¡Ö*®¾råJ ÁãtïÞ )Ã6|}}¥‘ïB®@¼"•v ¨×h·iÉNˆZ:täÈ”¨Â÷ŸT¿òÖ.…©‰Ø"Ù+*’´£W'ñ!C†ØØØ :TÒâââòÍ7ß u¬æÊ4º3N¾F _#ÈËËCĉBG ŠÆ„ŒµÞ|
ÒõEãJ*ŠLu“ù)Q¯QÅEÅ?òI¡Á„ƨèîFãÍGÐK¯.“²Ì1òÝû* Z™2N ªR }èÈt1XÖóæÁ™ŠAÃb´xýõ×e 7}aøéNBewnx:¤ïìÞ½û×_EëPë7Z¶lYñé]ÊÕ«¬ÎéÔ!-êÐß/ÆÔš››Ÿ9sFGæ—«,Äs¥¥¥ MjÞ¼¹›››ø0ó»ï¾ÓµEÿèkªÀ×P‡t
„Ñ“'OFƒþçÁƒ3gÎTsÀ-uÈ t¨{÷îh¥*\2®‚„……Ù(AÛSvŠÅý$óæ! B{ ÁдiÓºuë&b#üS½lÓ×P‡ À6*XÍE¿««««]‹-~ùå—JYx¥Aƒpk¨éåõ6âq,_Àõ‡ªN‡Ægoo¯pɸ
¢âM¾¶ xË–- :tŒÙýñÇ aë...‡ ^¶l™¿¿¿xQñÃ?èH`D_£U_£×þE—o²‚Õ\Òïªf'°wU)'R‡´«C›7o†ËîÒ¥‹ôtúŽ,'=OL|Ð AðDbq6ÄIo¼ñ†Œzöì©æXpúýõ5zí_èY®CðÔÁÁÁŽŽŽðÅ:2ótśʌ]¾s玘ßpâĉþàùøø@Š¼¼¼–/_^]+±ÒЙí´
ÚIÖ¡¿ÿyEôóÏ?ëÈ’¬áNPPƒƒƒ˜ÞFz×îÝ»===ñ°b]"ì½råJ =¬¬¬ F½{÷ÎÊʪ®Àˆ†Îl§m°j®}ùå—Èb5¿fÕ}æÍ›‡Ç‰‹‹“žÐE áË#«üýbRÎ%K–Ô®]Räíí½zõjõg±£¡Ó¿ð&i'¤tèòåËbY”³gÏÀèm1‡ÍÒ¥Kö³!æƒDYXXôíÛW2
éÒ¥K8QFýúõ»zõjg
þEõMFEEMœ81‰Tbé
VO-êèÕ«\ðçŸ.†Ò_ÒÒÒ|||jÕª% wäÁ®è˜ˆL²½¤¤äÛo¿õôôÄ.óºuëª20¢¯¡QmƤZQ6
1©4 JNNvww¬¢¦§ˆõ[ß}÷]e‹Œ V¬Xáæ憺}äÈé)=ðìP©Î;#¢255}ë·²³³«&Cèkè_”!¿©®B*M‡ ?~,ÖT†7|ðàž>çÍ›7ƒƒƒØ :tHõ”h–ÄÄD<µüòzŒ¾þúkFÐfÉbÕô5ô/ÕBÑ('ZÔ!°víÚZµjéuH$Æ ÄÇÇ«3à"??_,_=~üxùox‘ ;vÑ Aƒnܸ¡Õla
§!¤¦ëˆöíÛ[XXL™2E,&_\»v
Átå÷ß—YãUûöíóööÆ#oÚ´Iá´FOŸ>7ož»»;£ ÿþ÷¿†1´BtQ‡ÀÁƒ}}}]]] ?®ƒ3R«æí·ß¶±±0`€ôbÿüs„PИóçÏ+›¦úÌ™3íÚµsE2$''‡ÍgBÑŠÁ½ >ÜÎήM›6Ú\¶nÝêéééì윚šZ.E$F%ÄÇÇ«0 6wî\777FuêÔŸÁÒ°!¤’uܾ};**ÊÜÜ\zçòóó###MMMçÍ›'½´š\¼xÒùæ›oTÌy
UNOO‡B[XX Þ{ï½ÜÜ\F„RÉ:öîÝëããcmm½mÛ¶§OŸêþãõíÛw«p5ù駟ë8:: >|XÅ@;¨ÎãÇgÎœéêê
ݪW¯ÞöíÛBH%ë¼íŒ3œœœBBBþüóO Q´`ÁÑ#§z¬¶êG :t¨-bÁ7n¼ô`dKëÖ-^0räȼ¼<F„Ri:ô÷‹hzöìiee™••¥³NvýúõÞÞÞfffŸ-» Y³fHjìر/ý¤òèÑ£iÓ¦Aÿ…††¦¤¤èEìH!ú¡CàîÝ»íÚµC{
]XžGž?þø#((ÈØØø³Ï>«”Eü <U377߸q£:½mP£cÇŽµlÙ§ £Þÿý;wîh¬ÙG ={6'Ú1`vîÜ©k_ËÒêh:C ;;[ô>µiÓæêÕ«: 8p@ .>|¸ê)|4è ÈÈÈPGzqJqqñäÉ“q±aÆ»wïÖ,0úꫯ\]]9ËŽ£ƒ³Ñêhº®CÒRÔ¼yó³gÏêÈ»¢ ;vˆ‰J+Q„ƒºtébiiÙ«W/õWÁ€ >|XŒ3Ĺ ~øa~~~ye[2Ïéøñã9ÑŽ«›³©Òêhz CBŠÄ`åúõëëÂ[U«VyyyAÛGŽ Y¹"$¸|ùrݺu!råšjªƒƒ?ùäGGGÜ[DDľ}ûÊ•WÂ#Œ =ÅYv Œùóçëæê´:Z ~èxWôïÿÛÊÊ
Šš””T]ß¡Â888M˜0A{ºfÍšZµjáB//U†çϟ㔦M›"0Bv}ôÑGê+%× 2`t¶piu´@½Ñ¡¿_Œ ›>}ºx ÒºuëS§NUq ÝÑ£G_}õU„e666?þø£ŠN+åEÑ°aÃlmm›5kvýúõòž{ÿþý‰'BÆWMš49xð :óÝÑ#Ð ðÆuèå vïÞ½uëÖ555ussûôÓOoß¾]ƒ >|ø?ÿó? pëAAA»wﮂOGQZQQQfffï¿ÿ¾%‡Àhß¾}7F
"‘W/M„ ^€7F¨CjIQvvöСCíìì
~~~óæÍ»{÷®–Ô!ך5kÂÃÃÍÍÍáЪr¹î?þø£víÚ¸î/¿ü¢Á4ÛÈ“{÷î‰uùWÍ›7?|ø°ŠÀH=BŸ>}ªÊ/ãT•dffNš4) R¹·T§N ÓÈÊÊÒì`êN{V§/hT¹ÉA 8 zÉLLL F(ŒœœœJTdÖòåË[´haiiiddÔ²eK„AU¼æ„dÖ¬YNNNxÀsçÎiöt8 w =³µµMJJRö©“^{…Ë V%b))˜ÊåË—+÷–‚ƒƒ‘ìÅ‹¥;¢ ]\\Zµj•žž.ÙUúDí’;¡Ñê*hu)))hCWÐú—™aYZu„ðè²UzŠðÑOŸ>E°Ò A”Úûhõ÷ïßÆ
xNÃ#äàÑ£G‡
æãã#’Eú«VzðàAµ|½„gìÖ´ðßÿþ·úøåó
y2fÌA\NA¤ÂPòòò`XåjU õ/úüÕë•ŸÒuO[Ró…G®Ò >>>::n1:œQvv¶êSôQ‡hu:buˆE>=<<Ž ;&ÝîARh(ïÚµKº™®›h¤¥tÅô6?ÿüs§N Õ&/€·…מ?þž={à»_Z0 > |²Û¶móôô³³£Lñ?âfé‰Þ
C‡hu:eup¶bchhhff¦´WÄv™k–I2™’žžß*ü,„Dh’……Ä *õöÛo# ˜4i’˜^b„ PÎ;7jÔ"Sp° ¤0vìØ´´4„Ÿ:2ƒ„V ã>pà€ÆS©ŠŒ*((1b„ÐìVZ ?~\’ 2C¹uëVDD‚œÕrѪôê? |²(A[[Û ;v \Fa¡ñ‡vnåz4uçÌ™ãëë‹k%&&"ä’¸ Ív•K‡huºfubcLL J¶]»vÒk P‡þ“‚tæÌ™E‹
<9nmmýÒ©& BPø¾}û"$ºtéê6Ñ©9„Äò€(þ&Mš”w·ÂÀ
jÑŸ‰ÀM颢"†"æw€U‰aŠâhrrrdd$NoÛ¶-4{íÚµh•‹>bÄ‘0wá.¡Ø²jÕ*„2§@ÿЪš2eJ``à¹sçÐ8ðòòòññÁa8XáE"IÇHþ¿pá%ÞÞÞHpÍš5¸Ÿ÷ß Zîçç'ÒWÿHqù›ÛSSSQ'‘o .ôððuOú–DO=HÓÊÊ
œÕ«W#W'WÅUä«tË–-Qv¸sað8 ù|åÊ•ÊõsçÎuqq1zª *”ä[4Ív•K‡huºfub#šû±±±HdàÀùùùÔ¡—GH Ï|êÔ©7.[¶ 5dòäÉ“^ çûý÷ßoÞ¼ùìÙ³ÅÅÅhÄéšöÈp÷îÝ-ZÀûŒ =ºâ‰'…
½ûî»Ð6F¯½öÚÉ“'¿üòK…†"<ô«òíÛ·£önØ°55§^½zhö¢juëÖ
ò‡(r'öîÝ!WII‰ü)ÔæÍ›‹·¬S§NÍÉÉÙ»w/Ž»ä/ª éWµ’ÿ,XpûömÑ…ªŽôQÕÅ4²"}õTø¼bûµk×êׯj‰Ç_±b*¶ÌmˆzˆÊoccƒ4 :T»vmwwwœ¨N®Š«ÈWiì‚‹—lÁ¸œt¿2/ЫW¯O?ýTÍÙ'5jÛ0ú¸3É%4Û%™Ø´S§N
§{¡ÕéšÕIô
ݵ¦M›&š°Ô!uã$eü? 9rDŒžX¿~}¥ŒÜƒQB‰ayh 9::²!K
Eƪúõëßwƒ…»»öïß›F+L4á#~üñGñJá)’·¬C% ÐæææÂs©Ùá ýªVa‚
ÓWÿHÏ;a´"áÄŸ¾@þ6Äa;wFjð"YÉxV5sU> êÔ©#½XXX¨£CÑÑÑðMjÎ>Ù°aCiEAXr ÍvIîDfbS F«Ó}«“Ö„M"M´ïfQ‡j°§9sæ ,¡Fã*eôÒD»,11
¤¾G@s ‹&•@’Z«Vváÿ1cƈ®§È¤,ýSýŽog©Ÿ¾ŠŸÊn¾qãƨÀ/M % ÖCûöíE¯ˆÂP3‹$×Å‘â} ¼<»t'’Šxèã?–ŸƒbùxQ‹“““DQ$ý0ší’ÄC3gΔ\:..NÙô—´:²:i B>oݺÕÃʸk×.___êP
¢¤¤D̳×[7é÷ÒŒ6nÜcRÖ4–±*Ñ -2™#Åê´‹/^¸páºuë$³ );E/<‚²›¯[·®èâPø™3gZ¶lÙ´iSTÝÚµk+»5³ˆ—…ˆá5àsýýýËʼ7VèTL'ªÐØfÍšåíí
{4hèÕ©È.…ý*¦¿¤Õé”ÕÉô¿¡ìD¶{zzš™™Q‡jhö6hÐ 1b#顺ŒÄô}êx„®]»¢…“““[‡»»ð300°E‹h…áI
ÊNÑ ìæ;uêdaa‘œœüøñc”‹ŸŸŸÄAHŸÞ¦MsssÄhŸª¸5³ Ñàîî¾hÑ"mÛ†Uˆ6²|ðÙ.õÇ)ÐêtÍêäß¡ Qpvvv
¤80A¸!DÄûöíSgS5QÑ2/ŸÑhêÕ«ŒUøAOCqŸ>}îܹ#9`´ÖÑ,•~‰¥ð”{÷îÁ}À^Ož< Ÿ%óSæ¢Ên[ú,ܹŠ%?Oœ8¡þ‘ð§ÊžW|ŠyúôéC‡!À)ØrêÔ)éÔÂÂÂpnJJÊáÇEËT¼áS3Wå«4n ÎŽ.£ÿþ¬Ë^ ¼:D«Ó)«ƒAóvïÞ-ísž}åÊ•pð È™îÝ»£ŠÂ#"Q½h Q‡*™¢¢¢W_}q÷ˆ#
µíDO‹ôÐvÕÝ2
;däO)•Bþ§üERªÕ髤êç•l—|* Ù"ó ’cÄ?ê窲ž"‘”Âü1 ¢ÕéŽÕÉß¼4¹¹¹2šM ª) ;vÌ××m“µk×Êvª\@ª‘òNÜb0:DôËê¨C5´wN|yZ»víÓ§OW|7=uˆ:D¨C¤|”””ôêÕËÊÊêõ×_¯ø0n]öaaa6J¨âù˜«ž
XZZZ[[«ó°"£,_Àõ‡huUcuúbÔ!m‘ jjj:{öì
ãÖePª ƒ/âr=¬²ƒ©C´:íY¾X uH‹ˆ‘—¶¶¶{öì©È0nö0Ô!‚¦i1—‰]DDÄÕ«W5 ÆM@/À#Ô!¢!EEE[·677 6l˜Æøéèxc„:D4çøñãb÷êÕ«5ÆM@/À#Ô!¢9eee¢¤½¼¼N:¥Á0nqzTTÔĉ“ˆa¡l™ qO´:Z uÈ@xö왘ëIf•èrycb ([ÔCtˆ¥C ¤7nÜ 3551c†X*Q}d†!†‡Âu†ªZ -:d€lÚ´ÉÃÃÃÆÆæ÷ß/×0î2RÐÁþdB ¤à‹¢±cÇÚÛÛ7lØðÊ•+úµö9!„P‡ û÷ï¿öÚkæææC‡-((`†Bu¨ª9yò¤ŸŸŸ©©éÊ•+uí• !„P‡ Ÿ²²²¯¿þZ¬ Ÿ––VfÄ"„êníéÓ§µµuÇŽ sss™!„ê©jnÞ¼ njj:mÚ´òã&„ꩶnÝêáá¨è·ß~{úô)3„B "UJYYÙ¸qãìííCCC³²²8Œ›B "U̓ڶmknnþÎ;ïp7!„:Dªôôô€€ SSÓåË—?|øB¡‘*¥¬¬lÑ¢E...îîî'Ožä0nBuˆT5Оþýû[[[·k׎ø !Ô!R
äää4jÔÈÔÔ4))‰Ã¸ !Ô!R
ìرÃÃÃÃÊÊj×®] ÆM¡‘ª¦¬¬lâĉ
4à0nBuˆTÅÅÅ111 ùùùÌBuˆT5§OŸ 411ùñÇ 9Œ›B "UMYYÙwß}çêêZ«V'Np7!„:DªšçÏŸ0ÀÚÚºmÛ¶·nÝb†B¨C¤ªÉÍ͈ˆ0554iÒ½{÷˜!„ê©jvíÚåééiii¹}ûvã&„P‡HUSVVöÉ'Ÿ888Ô«WïÒ¥K ÆM¡‘ªæÑ£GíÛ··°°8p ‡qB¨C¤8{ö¬Æ=xðàI“&%ɱcÇÈ•ü‰G ={6Wçø ~øáþýû46B¨CD1K–,quu5VÂèÑ£ÿúë/ù³¾úê+…gñxùã!ó_|ñ¥ˆêQÌóçÏcbbÌÍÍŒŒFŽ 9éÿ²mÛ6…íý#GŽÌ˜1c’ <^æxgggd¬2¹"„P‡Èÿ2þ|¸KˆPAAA™
O)S—>~Þ¼yÈ[ê!Ô!¢Š¯¾úŠ¾’yKuˆÐW ¢ƒNY÷ !„:D¨CÚEu÷ !„:DØf'„P‡Ûì„B "„B "„B¨C„B¨C„BuˆŠ"&>þ?ÿù$
{cbb¦NŠbofff =powïÞÅaH
*(oÊŽdáB "ºÎ¥K—: pƒ¤áâ¡""Âxï½÷¦H¿ Z½zõ¤I“®_¿Ž&))iòäÉ" ‚„ôïßÿæÍ›8}Ó¦MÐ'ɘº‰'":IOOúô)Î’¿ÄÄD¤#ь޽{ïß¿ ‹8iÔ¨QW¯^'B« jOž<‘¿7Gjç2'„:Dªˆ & †
xðàAxx8¢8ô°°°H>âi×®ÝG }Ý!H‡ 9 ?ÆÿŸ~úéöíÛ¡ ï¿ÿ~Û¶mOŸ>- SpØîÝ»…®Èƒ³»H‚$DW-Z´ôÝ!P[»v-nIü 2dˆè¯“¿7eGj ç2'„:Dª¨Í %=(`Û¶mC‡½}û6"¤fÍšI$áÎ;uëÖMNNÂÁhܸ±äƒÖèèh—×_ýûï¿/**’ %ÏÏÏïÕ«â$eWïׯßæÍ›EšàÃ? 4h®.~¾ù曧N’ýûä“OÄ`n™{SqdEtˆsUB "UÑfG`!yÏ/ úÎ;Ÿ½÷Þ{’Ÿˆ?$/‡ Q/^D˜*,,„@
iÁYHDr˜<õëׇlˆÿùå—W^yå‡ ~(..[$=„Hyøðá8@(®Ì½©8’:DuˆhW‡*î+ûöí»páÂû÷ï#âùì³Ï¦M›&Rƒê,Y²díÚµŸ~úiAAÁøñãW®\)Qˆ#F|üñÇø+ÆÅõèÑ’õÊÌÌ|ã7öíÛ':âptEÒ]&O‹- i >\´hQŸ>}zöìùÅ_|ðÁ"š ß°aÂ)<éÀq ܌̽©8’:DuˆèºÝ¸q£K—.7^±b…D3UÄÆÆ6 Êi×®]ZZšäO|||×®]Ïž=+¶¤§§CQìíí!B§OŸ–~¥tüøqÓÄmݺ5äóæÍ»wïÞ˜1c:wîŒ ‰S |ÞÞÞHò6räȸ¸8¡p2÷¦âHê!Ô!¢ë:ô÷‹¾,ȉèU“Þ(ü”ß+ù‰]ÊQ=íö–¾@ &’•œ"öŠ Iï’¹7GR‡¡=Ð!¼%„:Dè+u ®?DuˆP‡ª®?Duˆ°ÍN¡¶Ù !„:D!„:D!„P‡!„P‡!„ê!Ú…ëB "¤:áúC„P‡ÛìÕ¬CüF˜êa›:DuˆÐW2o !Ô!B_ɼ%„:Dè+™·„ꡯdÞB "ô•ç2'„:D¨CÕ ç2'„:D4o³‹ïŠ’äPö¥W}馛îèJ’dô}~÷õù¼îyÏSͶÕÔãñÇzý8¯ çt¶×£×yóúË $&á `r €É & ðŒLnqqñ€Ø,--ñß à‘šœ ÕˆÍÛ·oùo ð¨M®´´ô-ÀŸ)))Áä Àä!î
L09 Àä šÝÝÝŠŠŠ[©ªªÚÛÛÃä “{HVVVÒÓÓ}>ßJMMM¥¥¥¯¯cr €É= ûûûN§srr2Ž²###©©©‡‡‡˜ `r€×ëu»ÝqÏÉÉ©Åä “»o677å
Ä]C¿Ô°½½É &w#ýêèèp:/_¾,--ÕŸºýÛ…0DÕÁ)))§§§mmmv»ýÅ‹zoƒÎÎN9l~~>îÎøý~©¡«« “ LîzDË”¨ÍÍ͉Heff MN OGEøTxttTdnaaAÂ999êÈÂÂB‰žŸŸÇÝ™ããc©¡ “ Lîf§úã«F“3FC¡Pd–ÕjUa»ÝnÌŠU¿ÔƒÉ &w “3I‰|Øz“¬¸;£Õ0±L®´´ôçÍââ"¿8 “KT“Ssr¡Pè;“ sr ×_ €É=¼ÉY,–H]SŠfbrj\0Œ»'ggg‰»Nî9ÏÉar €É= ê%ƒ0“ËÎΖ”………ÓÓÓ >¨RSSõÁ0–UÑÈwWÅíŒZf €ÔÐÑÑ‘ˆ&÷œ×É©+€É &wïçùw²²²ŒF•‘‘a³Ù^¿~}vvæt:Å®Ôç⌠% ‹nooKÀ¸OWQQ‘èÚ
£ÂÐÐÔ
ar˜ &wßÔÕÕ•––Æ]Üãñx½ÞõL“ L.±9::JKK £ìää$û®br ˜ÜC²±±!B611q«R>Ÿ/==}ee%q=“Ãä “{
ÔÔÔܪHeeåÞÞ^B{ &‡É &˜ & ð{L®¤¤ä€?#w&‡É @˜ @,09L ¯É---½ˆÜ!˜ ¿8 à‘š `r €É`r ˜ & €É`r €É`r ˜ & €É`r €É= çççoÞ¼±Ûíuuu¿µ!‡Ã!#ñÁÁÁãùÌÏÏ[ryy+*}¾“ÝZå
[,–ããcî{L 0¹;£²²rxx8
eddüÖ†ÄáÜn÷cû –——ÇŠŠxÝUŸåôóòò¸é19 ÀänÁÐиZ¬ÜéééÚÚÚû9Û±±±®®®Çö3øøñc¬¨ô¹»»ûNšššº«ª09 €garûûû¹¹¹_¿~šûãÇŒŒŒû9Ûúúú………Çö3‘][[3‰~ùòå Ÿ>& p¯&777çr¹,‹ÚRÝ(m¯_¿NNN¶ÙljîgrrR-ó
;RQ]]³UâÒÒRaa¡”òx<âyÆãM²L ”Þ¦¤¤¬¬¬È¿¡PȤÂíímé¼ /á`0øêÕ+»Ý.5˜œc$r.ê©A%J»ïÞ½KMMs]^^NJJR+á$=--M—Œ:Îõõõââb©-;;[ΘµÎX}ª¤HKK‹¾ìóóóü Àä ày™œøÁêêêÕÏõøÚÏ$Åív‹º‰LˆFˆ ©ôááam‘H
^¯WG?~ü(²òíÛ7 û|>Ñ—›dÅâôô´¬¬¬««ëäääèèHŠÜ¤-‘¹ÆÆF9¾²²RNjzzZŒÓü ˆiIµ >|¸¸¸m’°êIyyyOOT+‚XUUÕÜܬŽÿòåK}}½. ×ÌÌÌlkkƒ”ÚFFFT…æuFíƒt^Èîî®”ªxõ“ €çhr………J€4âEEE¢*ÚßßßÒҢµµµ¢>±ªêîî Rá-q]‰`³Ù®Í2¡¦¦fttTGEãDn®p``àÓ§OMMM*wvvVDÊü 5’ër¹677ÃÒŒsiƦSSS:+,*¢¦Z×XVó:cõáýû÷r©'&&òòò¾ÿ ÷ ³¸¸øÇs¥¤¤DLNþýb#~ð‹ àQ›œ¸B~~þçÏŸÂ1??/z$ªTPPÐÚÚª Úív“/hH=z‘œÈS ÐYÁ`Ðáp\› ŸÏgœÜWÓcRaYY™(šñHµ¶,Ö9“ã#ç ÞÃêI>ÁívïïïÇŠŠuéçÎW?Ÿí¾|ùҼΨ}Pç•••e±XÎÏÏ}^
oß¾å+ À£6¹«ŸöŠŠŠÄ–T4##CL¨¼¼¼··w{{[ ¶ººªÖœÅªÄétêhjjª1wbb¢¡¡áÚ¬X”––{ÒÑÑ‘™™ym["gâ:ccc*]¢jm™É9IOO÷ûýa‰âXÆW:$,²¥ÂbiúiidTŒÙãñ«êû‰yQû '’’’"ò*¦ø‹ï—(““ËûàϨ9KL àQ›œü¦VsQÁ`P¤A%ŠýÙÙÙQOúo8m¶ìLœC¿Âi’ ãã×OŸ>IC׶5;;›ŸŸ¯Ó§¦¦tc£9Æ8Q·°°pvvfìÉÉɉ¸àúúºŠŽ·µµ‰À©GÌaÑééi±F£®½|ùRô7ììÂêŒÚ9/u""¬Æ§·q› £5po $ªÉuww‡B¡¥¥¥¬¬,•X\\ÜÕÕ%Æ é¢#"CêUÐÚÚZѿ߯f’ÂxýúµÑ*¤µ¢n_üÏøM5“¬XˆeŠiIÞ¿/B)'zÔÓÓc^¡ˆÔÄÄ„®DìGŠ+ŠuŽF< T% I£íííW?7–’(×A.]KK‹X£z6*õ‹ÎvvvŠiE.//+W ÍÎÎÖ«ßLêŒÚ9/u©å¬å|Em#ù1Z& ð,LN°X,¹¹¹z hwwWÌÆjµfffÊïqÑ •îõz+**Ä¢ÄE"«ÊÉÉ1®Ù’Jòòò¤©jnnÎx¤IV,fff’““Å5%põs.ª¼¼\¯Ø‹UaØkrŒœ‚ÚÝ+Ö9Ó‘’‹#Mëul¢}III.—kxxXù™žB+--•úU#£rLuuµÍf“âr
æLêŒÚ9/u;;;r
MMM‘‹üžÀh-.7•\1ù™¼góx –¨vJJJXºÜlò çVUUUUÝÉ–n˜ À7¹»BÄâõë×ü ˜w¹+>þ, ûöí›üyÐÒÒb\ùh‡‹üÔâÊÊJzzº^„zC¦¦¦ÒÒÒô WÜ ˜Ü勵¿?Ö{€ÉÅAee¥tÌøåçÇô6òóÚN§3¾ Å‘‘‘ÔÔTãÜ-÷ &wÇdeeÉèõéÓ§wïÞqõ1¹;Än·Gî#’ ÿÿlr^¯×ívÇ][NNνíbŒÉ >–
ðÞ(--}æû•-..ò‹ 09Àä~ÉäD•$ª>#¢&ᢢ¢k³L°X,a{à^ýüÊ`ät`ä{ Öæ655é ¢’Æ#}©Ÿj:ìÃ×÷|o€\~Q &˜Ü/™œÑŠ.//.e’eBVV– ™->§¿Æ'£ºW¤Ééhrrr¬¬;YêwÃÓù}÷Æsž“Ãä “LînLÎf³IôââBç: Žk³L8==mnnV¨3®~NÔIT=u½¡É©"úk)‘sr¿ø!•Ÿ“{ÎëäÔÀä “LîWM®¬¬L¢jõSo¡k’u-ËËËuuuZ•< ¯ªª’zöööRSS¯5¹ÜÜ\ «}ØÔê:moj\0Œû"œ=ø:9L“ L0¹Û±½½”Ho†ûõëWå4çççïß¿·Z×f™›âÎÎŽÄØô“““zu”Ô£v³U¯ ˆŒŽ«ÖŽŽÔ*=A)`仫âvF-3^ý|'WjèèèàÞÀä “H˜Ñ:ò$‚ÏçËÊÊÁòx<Æ€˜g™41==-çr¹¾}û¦Ó‡††œN§Íf«««SÓia‰ì›q8 js-)ÛÞÞ®TRù¨qŸ®¢¢"ѵFUÍRÃææ&÷& ˜ £õ}#:XZZwqS¯×Ë½É &Àhý ¥¥¥ŽŽÆQvrr’}W19 Àä ’
²‰‰‰[•òù|ééé+++ܘ `r Ïq´~<Ûø ÔÔÔܪHeeåÞÞ ÷& ˜ £5po`r €ÉÁÓ «JJJþ ø3rW`r˜ `r c@,09L 09x¼,--½ˆÍ
¿Ï‡É `r ˜ `r €É & €Éq) “ Àä 09 L 09 ¸ü~¿Ýn!xÀ T“ Là144TYYyWµmmmy< ®*& €Éüvö÷÷sss¿~ýzWöööra19 Lào ¶¶¶&''Ûl¶W¯^IÊöö¶„VëÅÅECCCjjª6³×¯_«#»»»u
¡PèÝ»wrXFFÆòòrRRÒåååää¤Ô w80¯A«iEYY™Ôÿd®üâââ3Ù¯ì þá JJJä_¶n»ÏùkÒ ˜ ÀXYYÉÎÎþðი“™„UúÖÖVUU•ßïÅÅÅ’²ººêv»ÅÏÄÒDþìv»:òôô´¼¼¼§§çèè( J©ææf•5<<¬ÔP«†0"›VœŸŸ;Χ7SÀo ˜ @<ˆ{¹\®ÍÍÍȬ¾¾¾ÞÞÞ ?~¨èññqQQ‘ ¯¢ýýý---*ÜÐÐ :¨ ÖÖÖ~ùòE‡ÅÛ®Á¼iÏç3zá“1¹ÒÒR¶2ƒ0JJJ09 Là:;;›šš¢f‰^ý¬§§g~~~kkëÇ———’.‰aI«««U
Ùíö½½=ó®mZÓÜÜ<==ýôLŽÑ¸7 09€xHOO÷ûý‘éâX………Æ”ŒŒ ‡ÃQ^^ÞÛÛ»½½mô¶
•°Ø¡
¯®®º\®kk¸¶ico“ Làÿc±XŒc ggg˜¯¯;ÒÝÙÙQPm6›N<99Q[__WÑÁÁÁÆÆÆkk#²iíˆEEEŒÖ¿›ÍÍÍööö”””ĺ’±º½»»[QQq«ªªªªôD2÷ &ð¨ñx<ýýý¡PèèèHÄKÆB•þæͽ¾MQ\\ÜÕÕ%ž'ççç«ul‡#H¢ßïïîîniiY[[SÏ[kkk§§§%½¯¯Ï¤†0"›¾úù®CMMÍÓÕ áhít:ï'
âp‘Ý^YYIOO÷ù|·ªjjj*--MÿA½€É<ê™ ‘9‹Å’œœl\î–½¿¿ 6·!îeµZ333etQSw‚8YRR’Ëå –h}}½ž–óz½'''&5„ÙôÌÌŒ~•O¿‹Éý&ijÑä"»-w‘Xiä_7add$55õa·Áä 09 ÀäâúÝ—€&ÙmùCÂívÇ][NNNmm-÷ & €ÉÝw·777%<00wmýýýRƒÉ«9˜ & ˜Üã5¹•••—/_Úíö7oÞè¬ýýýššI´Zn·{~~^iSGG‡Óé<88"¥¥¥æõ¯®®fddØl¶žž £2Ž©ôŠŠ
õ„]Õœ’’rzzÚÖÖ&í¾xñ¸í„sss%]?‚WéVÝ‹¿ß/5tuuqo `r ‰gr¢2UUU~÷îÊm²X,¢Y_¿~•ô´´´+ÃÛsssR*33Ó¼~QÀ- |ÿþ]»—R1‘<•˜““sexýbttTdnaaAg]ý|ýY Îëõ^^^ŽŒŒM®°°PÂçççq_„ããc©¡ à¡~
ÿðÿ ¾ýœ7+[\\ä·`r €ÉÅcr*¼½½-ᬬ,mrZÔ$]YF¹á+Rª-,±¸¸8l£ª«hï1HØjµªpSS“~ *Òi&˜ |Ý”SSçerR_¾|©¯¯×Åâñ]¨¨}ΫÙÝÝ•‚RÕ¼ú€Éý>ä'+Z?::GY¹KÙw“L œÂÂB㳤«Ÿë~ŠŠŠÔúñ«Ÿé¥åµµµ±6ÿÿû —þVBCCƒqÚ)ìÙb___oo¯š?»–ššã(('r£PüFw[°Ùl*000ðéÓ§¦¦&•;;;«ºjr¦Æ¡×årE>Ï29©ÎÎΩ©)ãBÅêÃû÷†&&&òòò¾ÿÎhlllˆÉOíV¥ä/“ôôtãíÉar€ÉüÍTòóó?þlTùùy#‘¤‚‚‚ÖÖVýÐÐn·Çúv†È„q¶`ÿåË—W?§ú Yêù0Eiié
Ç'ÌŒ“[âaâjÚ`DÔ€Î
ƒú+eee¢hÆ#ÕÚ²XgjD55¥[Œu¦FäãDÝÂÂÂÙÙ™ÉI·µµ‰À
EFã»PQû /«ñéí]
W%%% üµ[&Çؘ <"“ëîî…BKKKúc
ÅÅÅ]]]â
’.""¤±ÕÖÖŠˆøý~5‡dD”B}
Udtt4;;[/êr8 @@ª’‚ÒVKK‹–~ŒøæÍ›X ï¢N‰iIUïß¿=êééÑÝVUíïï‹qêï·‰H×$IW¥¸Ò©XgjÄãñHUrÀÑÑ‘4ª¾þorRR¿ÏçëììÓŠãBE태—89k9_QÛÈE~¿2\Ä“cì L ‘É© Çsssõ Ðîî®8ÕjÍÌÌ”_Ù":*ÝëõVTTˆ?‰…„Õ#e«««m6[RR’ `\&†$‰.—kxxX©Œq¶ITƸ†Ìœ™™™ääd1N ¨¹(©J/ ’nçååI·¥ósssºTØkrŒœˆÚÝ+Ö™Ó‘’K$Mk59©ÒÒR©_õ02ß…ŠÚ9/u;;;r
MMM‘‹üâC´þ-@läÁä 09 L09 Àä “ L09€øy< ý Àä “ Àä 09 L09 Àä “ €;àì쬫«+55Õf³•——ßü#‹ÅÅÅgµÅÛŸÜ–gûBL à±344TYYùëõÔÖÖJUêÛÎ[[[Æýå ?l
l
‚É $ ûûû¹¹¹_¿~½óšVk™\iié“ßÜ¢©©INSþeŸòÌ7êÅä î€ÃÃÃÖÖÖääd›ÍöêÕ+IÙÞÞ–°ØÒÅÅECCCjjª6³×¯_«#õ®hB(z÷î –‘‘±¼¼œ””tyy999)5èYó4±š6rvv&‚˜p&Çh
ܘ À ³²²’ýáÃ1'2 «ôªª*¿ß Š‹‹%euuÕív‹Ÿ‰¥‰üÙívuäééiyyyOOÏÑÑQ0”RÍÍÍ*kxxX©¡"V
aD6 †T+ f´L“ xÖˆ{¹\®ÍÍÍȬ¾¾¾ÞÞÞ ?~¨èññqQQ‘ ¯¢ýýý---*ÜÐÐ :¨ ÖÖÖ~ùòE‡ÅÛ®Á¼é0666¼^/£õsFîØööö”””°ôÝÝÝŠŠŠ[U%3ìííqo`r IgggSSSÔ¬ÒÒR£ŸõôôÌÏÏomm}øð¡ µµU½| ‰aI«««U
Ùív=LƪáÚ¦|ÿþ]Äñüü “{Έà Ù+äžIOO÷ù|·ªjjj*--m}}{“ H“ˆlZ"*¼¼¼\ZZŠÉý"{{{êå=—ý &·¹¹)a¹Iâ®MþH
&SŘ & ð‘!PdÎb±$''—»egg‡m¢°»»+îeµZ333eÔQSw‚VRR’Ëå –h}}½ž–óz½'''&5„Ùt]]]ØgTEæ0¹_$77W_O§Ó©ÇÆÆ222l6›üàôOauuU%öôô(yŠZ6‘Åcµ%wcGG‡8âééi[[›Ýnñâ…qó KÓ’>33c4¹ÎÎN ÏÏÏÇ}5äï
©AþÒx¨{Cþ8yæ»\,..br €ÉÝfÚãÏ(• ‰x}ÿþ]999*Ýívomm]ý|ÝD ùÂA,¢Ú–H¡ªvttTdnaaÁØ q8ùóàòòrddÄØÂÂB ÿÊ{0ÇÇÇRCAAÁCݶW/& ˜ÜíL®¸¸8lpU鋥ͼ¬ Q‹Gm+ò= ëÍ<šššôЋ‹ ã‘bx¿ø¨W5 ë‡÷po<ç99L 0¹;09µ!GäaYYY’žm|qøæ&µx¬¶"MNG“““ceݼ3æWãA¶€cœº˜ `r¿dr‹E¢êI¨‘ÓÓÓææfu°~'ææòµx¬¶LLN …B‘YjNNgÅ}5 pN“Ãä “û%“óx<ªªº¸¸ØÛÛ Ûñvyy¹®®N»Îm§ÁŠÇjËÄäÔkêeµºNÛ›Z' ã¾ggg»N“Ãä “» ‡CMŒItrrR¯Z³Zz/5‰îìì\ýüøHfffÔ²æ¾Y]â—ÆBÌ£ªf©!êĘ & ðD‡û•Ïèÿ&ËËËcEE¼îªÏrúyyyŒÖÑÁ_ù^´Çãñz½è1˜ & O¡¡¡ÊÊÊÛfýJµæŒ=ȧSÍùøñc¬¨ôÙøÅã_ajj*îª7GGGiii£££q”œœdßUL àŽÙßßÏÍÍýúõë²~¥Úk©¯¯_XXxlª¶¶vmmÍ$uw×{>}Fë{`ccC„lbbâV¥|>_zzúÊÊÊÃz &‡É@077çr¹ÔÇŒ/è‰]½~ý:99Ùf³©YŸÉÉIµÀ+ò
Á¨Y‘5DmΤÚX J%)))2ÔÉ¿Æ=,--J… Gí º½½- ã% _½ze·Û¥“3äðð°µµU #5¨Di÷Ý»w2Ngdd,//'%%©•p’ž––¦ËFFNçúúzqq±Ô–m °cÕ«R•iiiÑðæÛC=íÑÚ›{îÉÁÁAMMÍŠTVVÞÉ2JL“€§˜ÁêêêÕÏ•øZ¤$Åív‹c‰Fˆ@èÏ4 k‡#,+V
Q›3©6ŒÓÓÓ²²²®®®“““££#‘!ãB¢ ?Š©ì>ŸOrUºÈ\cc£ /¤´>==]]]mÞO#bZRí‡ ...D›$¬zR^^ÞÓÓ#ÕŠ VUU577«ã¿|ùR__¯‹‡EÅ5333ÛÚÚÄ ¥¶‘‘U¡yQû W'²»»+¥ª[½úÀh
ܘ $<………Æw÷®~®Ç/**™PÑþþ~ýé‡ÚÚZ‘ž¨õ³LjˆlμÚ0jjjŒ«ŽDãDnTxkkKüF7ªfeT```àÓ§OMMM*wvvVíÔdÒOäº\®È÷ŒsiƦSSS:+,*¢¶O”þˆ¬:cõáýû÷CCCyyyß¿o¬*))ùàÏÈ]Éar ˆ%äççþüÙ¨óóó"F"Iú¡¡ÝnúÐ',+V
Q›3©6 ŸÏgœÜWÓ#¢tn0t8 *\VV&Šf¨óÊÊʲX,ñmÓÎ.é`&‡É@bpzzZTT¤?|•‘‘!T^^ÞÛÛ«¶W¬®®ªÕf‘„eŪ!js&Õ†QZZj¬££CÓUûúÿÄÄDCCƒDÎÄuÆÆÆTºDÕÚ²kû©HOO÷ûýa‰âXê›a
‹l©°Xš~Z‘õx<ƪú~b^gÔ>ȉ¤¤¤ˆ¼Š) Þœ¥¥¥· ±‘;“Ãä àQ#¿ªÔ,T0]P‰â=ÆcvvvÔ3¾ÁÁÁÆÆƨõ„eŪ!js&Õ†a\«þéÓ§úúúÖÖV¶ÄMüF½.:;;›ŸŸ¯Ó§¦¦ôÄ^¬~‘cŒu gggÆžœœœˆ ®¯¯«èøøx[[›ÜÐÐPdtzzZ¬Ñ¨k/_¾µ
;»°:£öAÎKˆ«ñé- `r ðŒL®»»;
É ßYYY*±¸¸¸««K\AÒEDDƒÔK µµµ""~¿_Í! ËŠUCÔæLªœ Ó’âïß¿ÿ=êééÑÝV‹íö÷÷E
õ÷ÛD¤Œß€û‘âJ§bõÓˆÇ㑪䀣£#iTí¶îp8€$J·åŒZZZÄÕ³Q©ßçóuvvŠiEª=:ÅÕFGG³³³õê7“:£öAÎK œœµœ¯¨mä"? Àä à‰›œ`±Xrssõ Ðîî®8ÕjÍÌÌ|ûöˆŽJ÷z½âOb!aõ„eŪ!js&Õ†133“œœ,
(«ŸsQåååz4š——'JÓsssºTØkrŒ´¨v÷ŠÕO#bZ"RÒgiZ¯cíKJJr¹\ÃÃÃÊÏôZii©Ô¯z•cª««m6›—S6.˜3©3j ä¼ÔYìììÈ)455E.ò L “Ãä ööv19µ’“ xÖ ×××ÛíöÌÌÌøv¥ƒ{F}QOþÅä nÇãÙd ž9CCC•••wRUuuµzgerr2##ƒkûøùÇüG19ù“ H<ö÷÷sssï|þLd.))‰Ëûøa Àoçðð°µµ599Ùf³©{···%lµZ/..ô÷¢ÅÌ^¿~Ž4î¥!jõîÝ;9,##cyyY4ëòòrrrRjÐ[ ˜× ‰Õ´‘ ?ŽŒŒðƒ{ü,..ŠÆÉ¿˜ Àoaee%;;ûÇbN"dz/ªª*¿ß Š‹‹¯~î#âv»ÅÏÄÒDþôG¤OOOËËË{zzŽŽŽ‚Á ”jnnVYÃÃÃJ
±j#²iÅùùùçÏŸ;;;õ÷h Áä îq/—Ë¥¿«l¤¯¯¯··Wäùøø¸¨¨HS°¿¿_B¹¡¡AtP¬Õ›|HX}hÚ¼ó¦ÿÏ ~’••%FÈÏ“ xîtvv655EÍ*--5úYOOÏüüüÖÖÖ‡
Z[[Õ'”%1ì!iuuµ
„B!»Ý®?: «†k›ÖH…ëë냃ƒ999üì09 €çNzzºßïLÇ*,,4¦ddd8 ŽòòòÞÞÞíím£·mll訄ÅUxuuÕår][õMGÂë˜ \Y,ãÄØ‚Úlmvv¶¾¾>ìHctggG=B5~×æääDï& 666^[C‘M‡!TTTð³Ãä ž; G}¡íèèHÄK‹ÿÍ›7z}›¢¸¸¸««K+’ÄÂÂÂìììP(¤,**RÒµˆ~YattTdnaaAg]Ýf¦Íx¤ü
*ÂÔ××wqq!N)é_¾|1ÏRóa‚tòòò²ººZÂïÞ½3otggGú/bzrr"Q)èr¹ô{¦MJJRç.¢f±X$,V'5§¥¥z²r%%z~~ ÷OóøøXjˆ|7“Àä ๛\qqqØŽì*]©Xgg§Šnll|øðÁ¤HäË
Ùú“SÊ®DÔ$,6ižÖµµ5 gee]Ûnww· Ùßß/á`0hù‰z éóù^½z¥“ËÌÌÔ]•c"
;Y»Ýþ‹Ï‹UýRÏÍÊbŸýë_åߨ’käÿ÷c©öÃæÊ E÷œû_ÿõ_ÿöoÿö?ÿó?0÷¿ÿû¿cý%ö›rå/ÆÈW
<÷¹›œùÕùÏÿüOÉ\Œò»s@ä#ðG’+=š;77÷›rÿã?þ£´´T~Ñ$P®ü"ÜXÏ~_îÈȈËå
{æx[“ÙŠåêù©ÿêëëõü\¬"‘&KnnhrF’nÕÐ$ËXƒr eÂÞÞžh™\O wuuI5553^d©sll,///Ö š\‡øÿþŽv&?åù—‘¬¡¡¡¨µ=ÎÜþç–Üý×½çÜú§z„¹---‘‹ÜÉš+ʳÊ}î&÷Ü~Þæ¹ü.xü¿ÍÍsMƧ››œè‹D·¶¶"|÷îd‰ÄÈÐküZ¬"wnr⑾¸¸ÐY‡ãÚ¬Ènè,sêêêä`ùKC,mww·µµU¢KKKÉÉÉz:gmmMl/??uuõ†&§¤Óøœ:>“»ÕœÜÀÀ€ôSþ‰ZÛïË5ùëâÑæþî¿ÄëïÒß÷WºyîãœÑx¨ù æä⟓{¨Üß73lžû8gÑ ê™Âc~Â+×ä™ÑÍMÎãñH´ªªJ¬hoo/555lšJ~éë÷ ܹ̋ɕ••)µ’°´%áúúúk³T
ʜ俀êêMšVKß^¾|)§,Qù%«,P×,ˆHâÑÑ‘É F]' ãþÅuvvÆ:9 Àä ž&c¼¨‰šQS Ë&''õr7«ÕÚÒÒb<¸²²RÒ¿}ûfLŒZDÊ$
k4a¥”Z‰ÁˆË¾ÿ^ÚÚØØ0ZWÔ,ýâ…È\cc£„———oxÝ”¤Ž«¨ZhœTl"yªê☟l仫a[{™GÕ´ÔÐÑÑÉ &ðÜMnzz:)))??_oè944¤Þܬ«« ›:òûýjX‘EÂ^€‹F6ýwSÄ‹bQYYY"jâXê›&šXYªøðð°tÏårÍÌÌÜüº‰«éIPé¶Ô¯Ÿá
"ˆRÛíV¯÷JýÒ´ùɪ¹=£†míe UW[jØÜÜÄä “xî&÷ôÁ=¾o ‹ïª'¶ñ!ªêõzù) &€ÉarÀÑÑQZZÚèèh e'''Ùw 09 LîYpzzj\²öxØØØ!›˜˜¸U)ŸÏ—žž¾²²ÂO 09 LîQ`‹ÍÝV~ŸíÞ„ƒƒƒ¨‹M¨¬¬4YYˆÉ`rÏ‹¿þõ¯×~ “~Ê €É=Þßzæ M`Œ~Ê €É=FÖ××M>å Àü” “ Æxৠ˜ 0Æ?e Àä žç_RRò<]äç‹É`r ðdMž˜ & O¥¥¥·ð<ÛŽ 09 Àä “»Øã 0¹D…= “KTØã 09 Àä “ Àä “ L 09 L.1a Àäöx L.Qa Àä “ L “ L 09 Àä 0¹Ä„= “KTØã 0¹D…= “ L 09 L 09 Àä à“[\\ü 6KKKüç x¤&§>œ ‹·oßòŸ àQ›\iié[€?SRR‚É $€É1Z÷ &˜ `r‰ÉîînEEÅŠTUUíííar €É=$+++ééé>ŸïV¥¦¦¦ÒÒÒÖ××19 Àä †ýý}§Ó999GÙ‘‘‘ÔÔÔÃÃCL 0¹ÀëõºÝçääÔÖÖbr €ÉÝ7›››r⮡¿¿_jØÞÞÆä QMÎï÷ëoÒ666£¯_¿–êëëUôßÿýß;::œNçÁÁÁË—/KKK¯~>⬩©±ÛíV«ÕívÏÏÏ+ÍêììLMMýþý»Çã‘Üææfm`±²ccc6›¢¢B*WE"Û•J¤Kª¹_9ñ®®.L Õä„ ñ$‘§““‰^^^º\.ýB¨D“’’DªRRR”ÒÍÍ͉effJnnn®Åb‘ܯ_¿JVZZš$ê#gff¤xuuµ„ß½{gž%H¢DWWWÅó$““c,bl·°°PRÎÏÏã>ëããc©¡ “ €69¡»»[zÕßß/á`0hù‰zòèóù^½zõ·Sú‰ñE19¥V*WJI
©#UúÚÚš„³²²Ì³„âââ°«bµk·Ûun|¨žH=˜ $¶Éíí퉄¹\. wuu‰âÔÔÔHT4nvvÖhT‘J466–——é^Fg²Z×fI ªŸE¶µ'·þ š~<&×ÔÔôdzgqq‘ß €ÉÝ‚ºº:õSœlww·µµU¢KKKÉÉÉ———±üimmMü/??uu5–É©¨Ãá¸6KlR¢[[[ךœš“üE“{„sr¥¥¥yöÈ¥à7 `r·@-tÓ¯loo+Ǫ¯¯71*Ñ8I9::
ËUaeZ;;;®ªªº6Ëãñ¨èÅÅÅÞÞ^jjj¬vÕ:¹`0÷ùž=ÎurÏ|N“ L.N”H«¨Zµ¦wPP¯DíS"(|ûöM»×èè¨[cc£„———Z5krrRÏÊXÖ–––XíF¾»*ngÔ2󨤆ŽŽŽÇfrÏ|œº˜ `r·fllLÌL¿:==-:uqqa40ã
‚™Ífs»Ý[[[bK.—kiiI <<<,¹’833ó×%v–044¤^¤««SSnQÛUS†Æ}ºŠŠŠ¤7Œª†¤†ÍÍML“ x
&w—' û„;yYáêçÂ>õ 8>< ×ë}„ƒÉar €É=}“;::JKK £ìää$û®br ˜\NOO•® ß<+666DÈ&&&nUÊç󥧧¯¬¬È‡Éñ £É & ˜ & €É`r ˜ & ˜ & €É`r ˜ÜcÃápÈppÀ¥Àä 0¹_åøø¸¾¾Þn·gff~ýúõw7'çv»¹Ï09 €gmrCCC•••¿^Ouuu(šœœÌÈÈøÝÝ ëêêâ>Ãä ž¯ÉíïïçææÞíšÈ\RRÒïîy}}ýÂÂ÷& ð¤LnnnÎårY,µ§QÚ^¿~œœl³Ùº»»%errÒjµê ?MÊj¶··¥¸”º¸¸hhhHMM<æãÇ###±$ïÝ»wR*##cyyY„ïòòò&í*å°”””••ùWjÓYKKK………Ò1ÇóãÇÝU9^ÂÁ`ðÕ«Wv»]j0¹ €É <°É‰š¬®®J`~~^[‘¤¸ÝnQ71§ÃÃCq•><<,Šc^6Œªª*¿ß Š‹‹uúùùùçÏŸ;;;gff¢<==-//ïéé9::µ’Jš››oØ®”-++ëêê:99‘âÒ®×ë5ºcvvö·oß$ìóùt¯DæåøÊÊJ©zzºººÚü‚ & ð&WXX¨œFs||\TT$B£¢ýýý---*\[[+6cR6’¾¾¾ÞÞ^5ïõ§þIVV–r²HVVVtTšþòåË
Û©© ÕQѸ >h³Óg'Øl6øôéSSS“Êmkk3¿ €É <¤É‰ äççþüY§ôôôÌÏÏ‹ñˆý´¶¶ªgš¡PÈn·ïíí™”¤´´Ô(d©m}}}pp0'''2W:öSO]Û®Ï端¯7Š©¸Ú÷ïßUTD-èÜ`0èp8T¸¬¬LÍx¤ZZë‚<ÿx®”””ˆÉÉ¿@l–––ø
ðdMîêç³È¢¢" ÍÈȹ)//ïííÝÞÞÖ‡®®ªed&eÃã),,4o=êëâm:*áÎÎζ+îhìvGGGff¦Ž†Õ›˜˜hhhP]µX,cccºçN§S-‹uA Õ¼@,Þ¾}ËoX €§irò[^M/ƒÁôôt•(Bc33fr@ÀãñXÖœœœÙÙYíd "‹§§§mmmRðÅ‹Æ]¢ö³³³SjžŸŸûšøý~©¡«« “ Àä ûh &UJ³ÄÛ¾ÿ.½E›ÛíÞÚÚ’€JZÖ„ Q1¯×{yy922b,¸¾¾.×××wqqQ^^.éê{Îb‡ê°ÑÑQ‘¹……cbõ³°°P¢çççq_ããc©¡ €{ “H0“+..ÛBJ¥[,–¶¶6ó²&455éG–blÆ‚¢wVß>‡“pQQÑU´#$,ÎgÞOñÅ_|n«Ú
Ûbä~î
¹Jl>»¸¸Èï
Àä “‹ÓäD•¢šPVV–¤ggg‹Ï©MØnerÉÉÉaNÕ½¤f£®EšœŽÆêç¬À3öá>ïÒÒR6Ÿ•KÁï
Àä “‹Óä,‹DÕƒT#§§§ÍÍÍêàöööÛj“ª6
E´Ùl¾¸¸ÐY‡ãZ“‹ÕOå…º¡¸¯ sr÷& ˜ `r¿jr G¢UUU¢V{{{©©©Æƒ———ëêê´åÜÜäÔëRüêï+í´o•••IXmȦ ¼Ö××_kr±ú©ÖɃÁ¸/ÈÙÙëä ð?& ˜ `r·Àáp¨É-µ:mrrR?ç²Z---Ú¢ÔÞ»¢M™™™QËš0>>®ôèèèH-†”~}ýúUeŸŸ¿ÿ^ÝØظúû›‚"£±úùQËÌ£W?_¤•:::¸709 Àä ûh===”””ŸŸ¯· r:6›®®NOnIÏåHq8—ËõíÛ·XeMjÅüÔvXR{{»26Áçóeee‰y< ý‘°·"_nˆÚÏíím9À¸O—X¦èÚ
£ªZ©ass“{“ L€Ñú¾±+--»¸Ø¤×ëåÞÀä “`´~ ŽŽŽÒÒÒFGGã(;99ɾ«˜ `r ŒÖÉÆƆÙÄÄÄJù|¾ôôô••î
L 09€ç5ZÛbó ý988¨©©¹U‘ÊÊÊ›,øãÞÀä “L€{“ Lm *))aG&Cî
L“ L` ˆ&‡É &—¥¥¥· ±ÑßÒÃä 09 L “ Àä “ L 09 L “ Àä “ L 09 ¸‡Cþƒƒ.& €Éüggg]]]©©©6›¼¼|ÿw·(çv»¹ò˜ &Ïš¡¡¡ÊÊÊ_¬¤¶¶Vê¹¼¼”ðÖÖV~~þïîöØؘ¸#?>L “ƒçËþþ~nnîׯ_ï¶Z«Õú»{^__¿°°ÀO“ ÀäàI177çr¹,‹ÚÍÓ(m¯_¿NNN¶ÙlÝÝÝ’299)Ê¥÷ý4)«ÙÞÞ–âRêâ⢡¡!555ò˜³³3±Ã¨} …BïÞ½“RËËËIIIjïÚvƒƒƒrXJJÊÊÊŠü+µé¬¥¥¥ÂÂBé˜Çãùñã‡îª /á`0øêÕ+»Ý.5˜\Àä “x`DMVWW%0??¯HRÜn·¨›˜Óáá¡8J Å1/ÆÖÖVUU•ßïÅÅÅ‘H >|ˆL?==-//ïéé9::µ’Jš››oØ®”-++ëêê:99‘âÒ®×ëÕ¹ ?~ÌÎÎþö후}>Ÿî•È\cc£ _YY)õOOOWWW›_Àä “xH
•ÓhŽ‹ŠŠDhT´¿¿¿¥¥E…kkkÅfLÊFÒ×××ÛÛ«æ½"ÙØØ0:–‘†††•• •¦¿|ùrÃvkjjFGGuTšÐ²(f)§ÏN°Ùl*000ðéÓ§¦¦&•;;;ÛÖÖf~A –ÅÅÅ?ž+%%%bròï ›¥¥%~Å`rðÄAÉÏÏÿüù³Néé陟Ÿãû)((hmmUÏ4C¡ÝnßÛÛ3)Iii©QÈŒ|ÿþ]tíüü<2K:öSO]Û®Ï端¯7Š©¸š´¥¢"j@@çƒA‡Ã¡Âeee¢hÆ#ÕÒºXä‘ÌKÄâíÛ·üŠÀäàészzZTT$¤¢"7ååå½½½ÛÛÛú°ÕÕUµŒÌ¤lb<………Q³ÖÖÖÚÚÚb)‘xÛÆƆqꮳ³ó†íŠ;»ÝÑÑ‘™™©£akõ&&&Ä&UW-ËØؘî¹ÓéTKëb]Gbrr¾oþŒš³Ää 09xê7è_þ¢\* ¦§§«Dã1;;;ê±æàà`cc£yÙ0fggÓcÆ)7ó1F?ñNNNÄ¢Ö××oØ®±ì§OŸ¤:%l‰›Ûí§T]5~ ejjJ÷<Öy$&Çh
Ü ˜ <_“ëîî…BKKKYYY*±¸¸¸««ëììLÒÇÇÇÅoÔ*·ÚÚÚééi¿ßß×׫loÞ¼1®«S Hµ*¼¼¼\ZZYÐáp©\š“VZZZÄ·ÔóÖkÛ½Ó’Þ¿/ö)744ÔÓÓ£ÏNui_Ä´¿¿_¥·µµMLLèJDã¤xoo¯Éa´L “x`“,Knn®žôÚÝÝY±Z™™™2ˆÁ¨t¯×[QQ!btrr«lÙÙÙaû7ÔÕÕ…-噋,(”””är¹†‡‡•Wéi¹kÛ™™INNÉ“ÀÕÏ7'¤¬^Þ'g———'g'ç877gìªñ59FÎWíîë‚0ZG²¹¹ÙÞÞž’’ò”š“@îü[©ªª2®(åÞ Àä `´v:æ ù»[Äá~ws+++ééé±V‚Æbjj*---Ö_8˜ & ðGëP(tŸ&÷»›Ûßß7\!pFFFRSS¹7 09 €„ïÓä~ws^¯×ívÇ]<''§¶¶–{ “ ÀäÍÍM©y`` îúûû¥†ùr
&€É &¿Z¬¬¼|ùÒn·¿yóFgíïï×ÔÔH¢Õju»ÝóóóJ˜:::œNçÁÁ‰ú.sKKK¹¹¹RÏÌÌL˜ÉÇ#õçääÌÎÎj'“&RRRNOOÛÚÚ¤à‹/Œû ŒeddØl¶ŠŠ
ýŽNgg§Ô¬: ~¿_jèêêâÞ Àä ÉäDb...ªªª$üîÝ;•%úe±XD•¾~ý*éiiiW†·ææ椔ñ3ÎQÙÙÙóz½———###F“[__‡ëë듦ËËË%]}ùO¿‡1::*2·°° aQ=UJéàêêê÷ïßé………ºÉ
9>>–
¸7 09 €D29ÞÞÞ–°þ쟘œ5õ)c‘¾ ÐÔÔ¤ YŠ±›½“°úJŽ8œ„‹ŠŠ®¢½!aq>...û2ŽJ_üÅ綪ݰQßç½!׊Ígù]˜ `rñ˜\˜3)¹ËËË3 v«µnÉÉÉaõGu¯ËËKcÓ‘½ÒQ9&jëw²/ìôïùÞ(--eóY¹ü® L 0¹xLNMJ9 ][[s¹\ùùù«««q›œÅb‘ƒÕ–¸aem6›„/..t–nÚÄäT…[[[a
)/Ô
Å}5˜“{(09Àä “û%“[__—pKK‹ŠŠÆITí¥·ÉåææêAÔÊ6í[eeej½ÝÕß ¼êÍsMLÎãñH¸ªªJŠìíí¥¦¦ªtµN. Æ})ÎÎÎX'÷àÿA09Àä “»bBÒ«™™õÆCzzº^ §f¹¶··Õ·oßÔk77¹ññq¥Gb„j1œ ôKU+Yçççïß¿·ZWó@@dtrrR?‰“"Ú;#ß]·3j™yôêç‹´RCGG÷&˜ @bŒÖ{{{6›M¼M¬Èø Ãè訤»Ýî-ñ —˵´´¤-J¿q-CCC‡Cm‡åt:ÛÛÛ•± >ŸOê!óx<ú;#ao3D¾Ü J=Ò·ºº:= §^×0îÓUTT$ݾaTU+5lnnro`r€É 0Zß7"v7ù¾],Ä&½^/÷&˜ £õptt”––6::GÙÉÉIö]Åä “ `´~H666DÈ&&&nUÊç󥧧¯¬¬po`r€É <¯ÑÚ›éÏÁÁAMMÍŠTVVîííqo`r€É 0Z÷&˜ <Ѫ¤¤„ ™ ¹+09L09 H€
˜ &˜ <^–––ÞÄFQ“Àä 09Àä “L 09Àä 09 L “L ‡Ã! pppÀ¥Àä “ €_Åï÷Ûív›ïg[zq8·ÛÍeÇä “ xÖ
UVVÞIU[[[ ç~º=66ÖÕÕÅ“L àù²¿¿Ÿ››ûõë×;©mpp°··÷~z^__¿°°ÀO“L àI177çr¹,‹ÚÊ(m¯_¿NNN¶ÙlÝÝÝ’299iµZõæQ&e5ÛÛÛR\J]\\444¤¦¦sËÊÊ–——Mú
…Þ½{'¥222äȤ¤¤ËËË›´«MQKIIYYY‘¥6µ´´TXX( óxŸO÷Jd®±±QŽ¯¬¬”ú§§§«««Í/`r€É <$………Êi4ÇÇÇEEE"4*ÚßßßÒҢµµµb3&e#éëëëííUó^FD¡ŒRICCÃÊÊŠŽJÓ_¾|¹a»555£££:*÷áÃm–¢qúì›Í¦Ÿ>}jjjR¹³³³mmmæ09Àä ”üüüÏŸ?딞žžùùy1 ±Ÿ‚‚‚ÖÖVõL3
Ùíö½½=“²‘”––…LÓÜÜ<== «”t ì ¦ž »¶]qÄúúz£˜Š«}ÿþ]EEÔ€Î
ƒ‡C…ËÊÊDÑŒGª¥u±.Èý³¸¸øÇs¥¤¤DLNþýb³´´Äï4L ž §§§EEE"@*š‘‘!rS^^ÞÛÛ»½½[]]UËÈLʆ!ÆSXX5+==] +V—ÄÛ666tTÂ7lWÜÑØ펎ŽÌÌL
[«711ÑÐÐ ºj±XÆÆÆtÏN§ZZë‚<Ô¼@,Þ¾}Ë/4L žÓ/µ¿üEM/ƒAQ+•(Bc>–
¸709 €69Q%‰ªïŠ¨IXoéa’e‚Åbikk K,..ŽœŒ|AÂâŽ*ÜÔÔ¤ €ŠJüõ¥~ªé°MD¸709 €39£]^^]Ê$Ë„¬¬,92;;[|NíÕ&HÁ¨îir:šœœ +ëN–úÝðt09L 0¹Çkr6›M¢:×áp\›eÂééiss³j¥½½]%Z,‰ª§®749UD-%rNî?¤Âœ & ð&WVV&QµšzˆY__mÖµ,//×ÕÕiUòxjܧ«¨¨Htí†QU³Ô°¹¹É½É 0Zß7¢ƒ¥¥¥q1õz½Ü˜ £õptt”––6::GÙÉÉIö]Åä ’
²‰‰‰[•òù|ééé+++ܘ Às m±¹çž ÔÔÔܪHeeåÞÞ ÷& Àh
ܘ <ÝѺ¤¤ä€?#w&‡É @˜ @,09L /KKKobsÃïóar €É & ˜ & ˜ @¢p~~þæÍ»Ý^WW—p¿¼¼ôûý79² àÇ ü¸19 €'Eeeåððp(ÊÈÈH¬žƒÁÑÑÑ <22òñãG~ܘ ÀÓazzúÿµwíýq Ç¿df&»I]$‘I™˜™9vÑÝt‘n2“LÆÑE’ŒÌLºØMÒÕt“$éf’d2’t‘D’™IÌd232I2ßßû÷=|Ìô[¿‹ïæù¸˜Ï¿ó9çô¹èå윳™™™N<òJ¥ %€¶8þùùÙï÷³â$9 º„„›ÁÁÁ‡‡‡Ž;r pš¦e2™¶¶aÑIr tƒ©©)õ›Q¯¯¯Fãåå¥Ûí6™L‡£á®²&]ßÊf³f³YÆ~~þþ~£ýåå%
Ùl6é
‡Ãj¼ ƒ®ëF»ßï7,—˽v»ÝëõªÁÑh4 ¶þ, ëN’ K¤R©ééiUÝÙÙ‘Àt}}-åd2©iZ+]Md2ŸÏwvv–N§MnooÇÇÇ÷÷÷¿¾¾$º©huss#ó' ‰}¹¤,Ÿ g{{ÛpttdµZr¡Pèé鹿¿oëdew²‹N’ K„Ãá-•º$?•J%Õk6›ìjncc#‰¨ x•JE™š' /,,HAZ††† 6—cSw¶U«Uu.‹Éñ´{²ÇÇÇ* ‚$ @Çs:ê&¹ùùùt:ºÊårooï]Íy½Þ››U][[K¥R’ ‰„ËåÒuýëëKÚWVVdßf¯ÉÉI£¼´´”Íf²¦iRm÷de/’#Yt’ Ý Zöõõ©ªºÍ°··~ìjBRšÛí®o ”(á,‰¨X&¾}'ÜÕÕ•±ë“““ååeÕn±X$äµ{¾£££±XŒu'É Ð
’Éäììl}<ªï ¿»»û±« [õó‹†ÛÔžžž...Œvãâœáüüüýý]
oooV«5—Ë9N£EÍS,Û:Ù‡‡“ÉT(Xw’ Ý
¨ª¦iûûû¿ÿ<[:77Ç[éjbqqÑت~žÕÕUÉdµZmwwWò™q Ãá9¥±T*mnnªoN%ÞIh nx¸¡!YºÝn—ËÕ¼¬ëz4eÑIr t‰±±±UÍçó&“IÖééiýÈ&]MØívI~
óÈ 2„³X,¦.³=>>J˜“Ðf³ÙêßKòïñ_¿âàï?ß“ÖW= ú÷Ûr.—óz½¿C$9 þjÅb1
uèÁûý~ …×u½R©°è$9 ºD< ¯æ ³ììì´þs«2¸\.³â$9 :ÞÈÈHV;<<\__ïܳÈçó-¾O$N×?K’ ÌçóÙl¶ÿ+Æ™ÿjä Hr É €$ ’ I › ï ÁŠñ°¥ IEND®B`‚ tevent-0.9.19/doc/mainpage.dox 0000660 0000000 0000000 00000003261 12162141064 016114 0 ustar root root 0000000 0000000 /**
* @mainpage
*
* Tevent is an event system based on the talloc memory management library. It
* is the core event system used in Samba.
*
* The low level tevent has support for many event types, including timers,
* signals, and the classic file descriptor events.
*
* Tevent also provide helpers to deal with asynchronous code providing the
* tevent_req (tevent request) functions.
*
* @section main_tevent_tutorial Tutorial
*
* You should start by reading @subpage tevent_tutorial, then reading the
* documentation of the interesting functions as you go.
*
* @section main_tevent_download Download
*
* You can download the latest releases of tevent from the
* tevent directory
* on the samba public source archive.
*
* @section main_tevent_bugs Discussion and bug reports
*
* tevent does not currently have its own mailing list or bug tracking system.
* For now, please use the
* samba-technical
* mailing list, and the
* Samba bugzilla
* bug tracking system.
*
* @section main_tevent_devel Development
* You can download the latest code either via git or rsync.
*
* To fetch via git see the following guide:
*
* Using Git for Samba Development
*
* Once you have cloned the tree switch to the master branch and cd into the
* lib/tevent directory.
*
* To fetch via rsync use this command:
*
* rsync -Pavz samba.org::ftp/unpacked/standalone_projects/lib/tevent .
*
*/
tevent-0.9.19/doc/tevent_context.dox 0000660 0000000 0000000 00000006002 12162141064 017400 0 ustar root root 0000000 0000000 /**
@page tevent_context Chapter 1: Tevent context
@section context Tevent context
Tevent context is an essential logical unit of tevent library. For working with
events at least one such context has to be created - allocated, initialized.
Then, events which are meant to be caught and handled have to be registered
within this specific context. Reason for subordinating events to a tevent
context structure rises from the fact that several context can be created and
each of them is processed at different time. So, there can be 1 context
containing just file descriptor events, another one taking care of signal and
time events and the third one which keeps information about the rest.
Tevent loops are the part of the library which represents the mechanism where
noticing events and triggering handlers actually happens. They accept just one
argument - tevent context structure. Therefore if theoretically an infinity
loop (tevent_loop_wait) was called, only those arguments which belong to the
passed tevent context structure can be caught and invoked within this call.
Although some more signal events were registered (but within some other
context) they will not be noticed.
@subsection Example
First lines which handle mem_ctx belong to talloc library
knowledge but because of the fact that tevent uses the talloc library for its
mechanisms it is necessary to understand a bit talloc as well. For more
information about working with talloc, please visit talloc website where tutorial and
documentation are located.
Tevent context structure *event_ctx represents the unit which will
further contain information about registered events. It is created via calling
tevent_context_init().
@code
TALLOC_CTX *mem_ctx = talloc_new(NULL);
if (mem_ctx == NULL) {
// error handling
}
struct tevent_context *ev_ctx = tevent_context_init(mem_ctx);
if(ev_ctx == NULL) {
// error handling
}
@endcode
Tevent context has a structure containing lots of information. It include lists
of all events which are divided according their type and are in order showing
the sequence as they came.
@image html tevent_context_stucture.png
In addition to the lists shown in the diagram, the tevent context also contains
many other data (e.g. information about the available system mechanism for
triggering callbacks).
@section tevent_loops Tevent loops
Tevent loops are the dispatcher for events. They catch them and trigger the
handlers. In the case of longer processes, the program spends most of its time
at this point waiting for events, invoking handlers and waiting for another
event again. There are 2 types of loop available for use in tevent library:
- int tevent_loop_wait()
- int tevent_loop_once()
Both of functions accept just one parametr (tevent context) and the only
difference lies in the fact that the first loop can theoretically last for ever
but the second one will wait just for a single one event to catch and then the
loop breaks and the program continue.
*/
tevent-0.9.19/doc/tevent_data.dox 0000660 0000000 0000000 00000006537 12162141064 016642 0 ustar root root 0000000 0000000 /**
@page tevent_data Chapter 3: Accessing data
@section data Accessing data with tevent
A tevent request is (usually) created together with a structure for storing the
data necessary for an asynchronous computation. For these private data, tevent
library uses void (generic) pointers, therefore any data type can be very
simply pointed at. However, this attitude requires clear and guaranteed
knowledge of the data type that will be handled, in advance. Private data can
be of 2 types: connected with a request itself or given as an individual
argument to a callback. It is necessary to differentiate these types, because
there is a slightly different method of data access for each. There are two
possibilities how to access data that is given as an argument directly to a
callback. The difference lies in the pointer that is returned. In one case it
is the data type specified in the function’s argument, in another void* is
returned.
@code
void tevent_req_callback_data (struct tevent_req *req, #type)
void tevent_req_callback_data_void (struct tevent_req *req)
@endcode
To obtain data that are strictly bound to a request, this function is the only
direct procedure.
@code
void *tevent_req_data (struct tevent_req *req, #type)
@endcode
Example with both calls which differs between private data within tevent
request and data handed over as an argument.
@code
#include
#include
#include
struct foo_state {
int x;
};
struct testA {
int y;
};
static void foo_done(struct tevent_req *req) {
// a->x contains 9
struct foo_state *a = tevent_req_data(req, struct foo_state);
// b->y contains 10
struct testA *b = tevent_req_callback_data(req, struct testA);
// c->y contains 10
struct testA *c = (struct testA *)tevent_req_callback_data_void(req);
printf("a->x: %d\n", a->x);
printf("b->y: %d\n", b->y);
printf("c->y: %d\n", c->y);
}
struct tevent_req * foo_send(TALLOC_CTX *mem_ctx, struct tevent_context *event_ctx) {
printf("_send\n");
struct tevent_req *req;
struct foo_state *state;
req = tevent_req_create(event_ctx, &state, struct foo_state);
state->x = 10;
return req;
}
static void run(struct tevent_context *ev, struct tevent_timer *te,
struct timeval current_time, void *private_data) {
struct tevent_req *req;
struct testA *tmp = talloc(ev, struct testA);
tmp->y = 9;
req = foo_send(ev, ev);
tevent_req_set_callback(req, foo_done, tmp);
tevent_req_done(req);
}
int main (int argc, char **argv) {
struct tevent_context *event_ctx;
struct testA *data;
TALLOC_CTX *mem_ctx;
struct tevent_timer *time_event;
mem_ctx = talloc_new(NULL); //parent
if (mem_ctx == NULL)
return EXIT_FAILURE;
event_ctx = tevent_context_init(mem_ctx);
if (event_ctx == NULL)
return EXIT_FAILURE;
data = talloc(mem_ctx, struct testA);
data->y = 10;
time_event = tevent_add_timer(event_ctx,
mem_ctx,
tevent_timeval_current(),
run,
data);
if (time_event == NULL) {
fprintf(stderr, " FAILED\n");
return EXIT_FAILURE;
}
tevent_loop_once(event_ctx);
talloc_free(mem_ctx);
printf("Quit\n");
return EXIT_SUCCESS;
}
@endcode
Output of this example is:
@code
a->x: 9
b->y: 10
c->y: 10
@endcode
*/
tevent-0.9.19/doc/tevent_events.dox 0000660 0000000 0000000 00000025634 12162141064 017234 0 ustar root root 0000000 0000000 /**
@page tevent_events Chapter 2: Tevent events
@section pools Tevent events
Ok, after reading previous chapter we can start doing something useful. So, the
way of creating events is similar for all types - signals, file descriptors,
time or immediate events. At the beginning it is good to know about some
typedefs which are set in tevent library and which specify the arguments for
each callback. These callbacks are:
- tevent_timer_handler_t()
- tevent_immediate_handler_t()
- tevent_signal_handler_t()
- tevent_fd_handler_t()
According their names it is obvious that for creating callback for e.g. time
event, tevent_timer_handler_t will be used.
The best way how to introduce registering an event and setting up a callback
would be example, so examples describing all the types of events follow.
@subsection Time Time event
This example shows how to set up an event which will be repeated for a minute
with interval of 2 seconds (will be triggered 30 times). After exceeding this
limit, the event loop will finish and all the memory resources will be freed.
This is just example describing repeated activity, nothing usefull is done
within foo function
@code
#include
#include
#include
#include
struct state {
struct timeval endtime;
int counter;
TALLOC_CTX *ctx;
};
static void callback(struct tevent_context *ev, struct tevent_timer *tim,
struct timeval current_time, void *private_data)
{
struct state *data = talloc_get_type(private_data, struct state);
struct tevent_timer *time_event;
struct timeval schedule;
printf("Data value: %d\n", data->counter);
data->counter += 1; // increase counter
// if time has not reached its limit, set another event
if (tevent_timeval_compare(¤t_time, &(data->endtime)) < 0) {
// do something
// set repeat with delay 2 seconds
schedule = tevent_timeval_current_ofs(2, 0);
time_event = tevent_add_timer(ev, data->ctx, schedule, callback, data);
if (time_event == NULL) { // error ...
fprintf(stderr, "MEMORY PROBLEM\n");
return;
}
} else {
// time limit exceeded
}
}
int main(void) {
struct tevent_context *event_ctx;
TALLOC_CTX *mem_ctx;
struct tevent_timer *time_event;
struct timeval schedule;
mem_ctx = talloc_new(NULL); // parent
event_ctx = tevent_context_init(mem_ctx);
struct state *data = talloc(mem_ctx, struct state);
schedule = tevent_timeval_current_ofs(2, 0); // +2 second time value
data->endtime = tevent_timeval_add(&schedule, 60, 0); // one minute time limit
data->ctx = mem_ctx;
data->counter = 0;
// add time event
time_event = tevent_add_timer(event_ctx, mem_ctx, schedule, callback, data);
if (time_event == NULL) {
fprintf(stderr, "FAILED\n");
return EXIT_FAILURE;
}
tevent_loop_wait(event_ctx);
talloc_free(mem_ctx);
return EXIT_SUCCESS;
}
@endcode
Variable counter is only used for counting the number of triggered
functions. List of all available functions which tevent offers for working with
time are listed
here together
with their description. More detailed view at these functions is unnecessary
because their purpose and usage is quite simple and clear.
@subsection Immediate Immediate event
These events are, as their name indicates, activated and performed immediately.
It means that this kind of events have priority over others (except signal
events). So if there is a bulk of events registered and after that a
tevent loop is launched, then all the immediate events will be triggered before
the other events. Except other immediate events (and signal events) because
they are also processed sequentially - according the order they were scheduled.
Signals have the highest priority and therefore they are processed
preferentially. Therefore the expression immediate may not correspond exactly
to the dictionary definition of "something without delay" but rather "as soon
as possible" after all preceding immediate events.
For creating an immediate event there is a small different which lies in the
fact that the creation of such event is done in 2 steps. One represents the
creation (memory allocation), the second one represents registering as the
event within some tevent context.
@code
struct tevent_immediate *run(TALLOC_CTX* mem_ctx,
struct tevent_context event_ctx,
void * data)
{
struct tevent_immediate *im;
im = tevent_create_immediate(mem_ctx);
if (im == NULL) {
return NULL;
}
tevent_schedule_immediate(im, event_ctx, foo, data);
return im;
}
@endcode
Example which may be compiled and run representing the creation of immediate event.
@code
#include
#include
#include
struct info_struct {
int counter;
};
static void foo(struct tevent_context *ev, struct tevent_immediate *im,
void *private_data)
{
struct info_struct *data = talloc_get_type(private_data, struct info_struct);
printf("Data value: %d\n", data->counter);
}
int main (void) {
struct tevent_context *event_ctx;
TALLOC_CTX *mem_ctx;
struct tevent_immediate *im;
printf("INIT\n");
mem_ctx = talloc_new(NULL);
event_ctx = tevent_context_init(mem_ctx);
struct info_struct *data = talloc(mem_ctx, struct info_struct);
// setting up private data
data->counter = 1;
// first immediate event
im = tevent_create_immediate(mem_ctx);
if (im == NULL) {
fprintf(stderr, "FAILED\n");
return EXIT_FAILURE;
}
tevent_schedule_immediate(im, event_ctx, foo, data);
tevent_loop_wait(event_ctx);
talloc_free(mem_ctx);
return 0;
}
@endcode
@subsection Signal Signal event
This is an alternative to standard C library functions signal() or sigaction().
The main difference that distinguishes these ways of treating signals is their
setting up of handlers for different time intervals of the running program.
While standard C library methods for dealing with signals offer sufficient
tools for most cases, they are inadequate for handling signals within the
tevent loop. It could be necessary to finish certain tevent requests within the
tevent loop without interruption. If a signal was sent to a program at a moment
when the tevent loop is in progress, a standard signal handler would not return
processing to the application at the very same place and it would quit the
tevent loop for ever. In such cases, tevent signal handlers offer the
possibility of dealing with these signals by masking them from the rest of
application and not quitting the loop, so the other events can still be
processed.
Tevent offers also a control function, which enables us to verify whether it is
possible to handle signals via tevent, is defined within tevent library and it
returns a boolean value revealing the result of the verification.
@code
bool tevent_signal_support (struct tevent_context *ev)
@endcode
Checking for signal support is not necessary, but if it is not guaranteed, this
is a good and easy control to prevent unexpected behaviour or failure of the
program occurring. Such a test of course does not have to be run every single
time you wish to create a signal handler, but simply at the beginning - during
the initialization procedures of the program. Afterthat, simply adapt to each
situation that arises.
@code
#include
#include
#include
static void handler(struct tevent_context *ev,
struct tevent_signal *se,
int signum,
int count,
void *siginfo,
void *private_data)
{
// Do something usefull
printf("handling signal...\n");
exit(EXIT_SUCCESS);
}
int main (void)
{
struct tevent_context *event_ctx;
TALLOC_CTX *mem_ctx;
struct tevent_signal *sig;
mem_ctx = talloc_new(NULL); //parent
if (mem_ctx == NULL) {
fprintf(stderr, "FAILED\n");
return EXIT_FAILURE;
}
event_ctx = tevent_context_init(mem_ctx);
if (event_ctx == NULL) {
fprintf(stderr, "FAILED\n");
return EXIT_FAILURE;
}
if (tevent_signal_support(event_ctx)) {
// create signal event
sig = tevent_add_signal(event_ctx, mem_ctx, SIGINT, 0, handler, NULL);
if (sig == NULL) {
fprintf(stderr, "FAILED\n");
return EXIT_FAILURE;
}
tevent_loop_wait(event_ctx);
}
talloc_free(mem_ctx);
return EXIT_SUCCESS;
}
@endcode
@subsection File File descriptor event
Support of events on file descriptors is mainly useful for socket communication
but it certainly works flawlessly with standard streams (stdin, stdout, stderr)
as well. Working asynchronously with file descriptors enables switching
within processing I/O operations. This ability may rise with a greater
number of I/O operations and such overlapping leads to enhancement of the
throughput.
There are several other functions included in tevent API related to handling
file descriptors (there are too many functions defined within tevent therefore
just some of them are fully described within this thesis. The
declaration of the rest can be easily found on the library’s website or
directly from the source code):
- tevent_fd_set_close_fn() - can add another function to be called at the
moment when a structure tevent fd is freed.
- tevent_fd_set_auto_close() - calling this function can simplify the
maintenance of file descriptors, because it instructs tevent to close the
appropriate file descriptor when the tevent fd structure is about to be
freed.
- tevent_fd_get_flags() - returns flags which are set on the file descriptor
connected with this tevent fd structure.
- tevent_fd_set_flags() - sets specified flags on the event’s file
descriptor.
@code
static void close_fd(struct tevent_context *ev, struct tevent_fd *fd_event,
int fd, void *private_data)
{
// processing when fd_event is freed
}
struct static void handler(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
// handling event; reading from a file descriptor
tevent_fd_set_close_fn (fd_event, close_fd);
}
int run(TALLOC_CTX *mem_ctx, struct tevent_context *event_ctx,
int fd, uint16_t flags, char *buffer)
{
struct tevent_fd* fd_event = NULL;
if (flags & TEVENT_FD_READ) {
fd_event = tevent_add_fd(event_ctx,
mem_ctx,
fd,
flags,
handler,
buffer);
}
if (fd_event == NULL) {
// error handling
}
return tevent_loop_once();
}
@endcode
*/
tevent-0.9.19/doc/tevent_queue.dox 0000660 0000000 0000000 00000022775 12162141064 017057 0 ustar root root 0000000 0000000 /**
@page tevent_queue Chapter 5: Tevent queue
@section queue Tevent queue
There is a possibility that the dispatcher and its handlers may not be able to
handle all the incoming events as quickly as they arrive. One way to deal with
this situation is to buffer the received events by introducing an event queue
into the events stream, between the events generator and the dispatcher. Events
are added to the queue as they arrive, and the dispatcher pops them off the
beginning of the queue as fast as possible. In tevent library it is
similar, but the queue is not automatically set for any event. The queue has to
be created on purpose, and events which should follow the order of the FIFO
queue have to be explicitly pinpointed. Creating such a queue is crucial in
situations when sequential processing is absolutely essential for the succesful
completion of a task, e.g. for a large quantity of data that are about to be
written from a buffer into a socket. The tevent library has its own queue
structure that is ready to use after it has been initialized and started up
once.
@subsection cr_queue Creation of Queues
The first and most important step is the creation of the tevent queue
(represented by struct tevent queue), which will then be in running mode.
@code
struct tevent_queue* tevent_queue_create (TALLOC_CTX *mem_ctx, const char *name)
@endcode
When the program returns from this function, the allocated memory, set
destructor and labeled queue as running has been done and the structure is
ready to be filled with entries. Stopping and starting queues on the run. If
you need to stop a queue from processing its entries, and then turn it on
again, a couple of functions which serve this purpose are:
- bool tevent_queue_stop()
- bool tevent_queue_start()
These functions actually only provide for the simple setting of a variable,
which indicates that the queue has been stopped/started. Returned value
indicates result.
@subsection add_queue Adding Requests to a Queue
Tevent in fact offers 3 possible ways of inserting a request into a queue.
There are no vast differences between them, but still there might be situations
where one of them is more suitable and desired than another.
@code
bool tevent_queue_add(struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data)
@endcode
This call is the simplest of all three. It offers only boolean verification of
whether the operation of adding the request into a queue was successful or not.
No additional deletion of an item from the queue is possible, i.e. it is only
possible to deallocate the whole tevent request, which would cause triggering
of destructor handling and also dropping the request from the queue.
Extended Options
Both of the following functions have a feature in common - they return tevent
queue entry structure representing the item in a queue. There is no further
possible handling with this structure except the use of the structure’s pointer
for its deallocation (which leads also its removal from the queue). The
difference lies in the possibility that with the following functions it is
possible to remove the tevent request from a queue without its deallocation.
The previous function can only deallocate the tevent request as it was from
memory, and thereby logically cause its removal from the queue as well. There
is no other utilization of this structure via API at this stage of tevent
library. The possibility of easier debugging while developing with tevent could
be considered to be an advantage of this returned pointer.
@code
struct tevent_queue_entry *tevent_queue_add_entry(struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data)
@endcode
The feature that allows for the optimized addition of entries to a queue is
that a check for an empty queue with no items is first of all carried out. If
it is found that the queue is empty, then the request for inserting the entry
into a queue will be omitted and directly triggered.
@code
struct tevent_queue_entry *tevent_queue_add_optimize_empty(struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data)
@endcode
When calling any of the functions serving for inserting an item into a queue,
it is possible to leave out the fourth argument (trigger) and instead of a
function pass a NULL pointer. This usage sets so-called blocking entries.
These entries, since they do not have any trigger operation to be activated,
just sit in their position until they are labeled as a done by another
function. Their purpose is to block other items in the queue from being
triggered.
@subsection example_q Example of tevent queue
@code
#include
#include
#include
struct foo_state {
int local_var;
int x;
};
struct juststruct {
TALLOC_CTX * ctx;
struct tevent_context *ev;
int y;
};
int created = 0;
static void timer_handler(struct tevent_context *ev, struct tevent_timer *te,
struct timeval current_time, void *private_data)
{
// time event which after all sets request as done. Following item from
// the queue may be invoked.
struct tevent_req *req = private_data;
struct foo_state *stateX = tevent_req_data(req, struct foo_state);
// processing some stuff
printf("time_handler\n");
tevent_req_done(req);
talloc_free(req);
printf("Request #%d set as done.\n", stateX->x);
}
static void trigger(struct tevent_req *req, void *private_data)
{
struct juststruct *priv = tevent_req_callback_data (req, struct juststruct);
struct foo_state *in = tevent_req_data(req, struct foo_state);
struct timeval schedule;
struct tevent_timer *tim;
schedule = tevent_timeval_current_ofs(1, 0);
printf("Processing request #%d\n", in->x);
if (in->x % 3 == 0) { // just example; third request does not contain
// any further operation and will be finished right
// away.
tim = NULL;
} else {
tim = tevent_add_timer(priv->ev, req, schedule, timer_handler, req);
}
if (tim == NULL) {
tevent_req_done(req);
talloc_free(req);
printf("Request #%d set as done.\n", in->x);
}
}
struct tevent_req *foo_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
const char *name, int num)
{
struct tevent_req *req;
struct foo_state *state;
struct foo_state *in;
struct tevent_timer *tim;
printf("foo_send\n");
req = tevent_req_create(mem_ctx, &state, struct foo_state);
if (req == NULL) { // check for appropriate allocation
tevent_req_error(req, 1);
return NULL;
}
// exemplary filling of variables
state->local_var = 1;
state->x = num;
return req;
}
static void foo_done(struct tevent_req *req) {
enum tevent_req_state state;
uint64_t err;
if (tevent_req_is_error(req, &state, &err)) {
printf("ERROR WAS SET %d\n", state);
return;
} else {
// processing some stuff
printf("Callback is done...\n");
}
}
int main (int argc, char **argv)
{
TALLOC_CTX *mem_ctx;
struct tevent_req* req[6];
struct tevent_req* tmp;
struct tevent_context *ev;
struct tevent_queue *fronta = NULL;
struct juststruct *data;
int ret;
int i = 0;
const char * const names[] = {
"first", "second", "third", "fourth", "fifth"
};
printf("INIT\n");
mem_ctx = talloc_new(NULL); //parent
talloc_parent(mem_ctx);
ev = tevent_context_init(mem_ctx);
if (ev == NULL) {
fprintf(stderr, "MEMORY ERROR\n");
return EXIT_FAILURE;
}
// setting up queue
fronta = tevent_queue_create(mem_ctx, "test_queue");
tevent_queue_stop(fronta);
tevent_queue_start(fronta);
if (tevent_queue_running(fronta)) {
printf ("Queue is runnning (length: %d)\n", tevent_queue_length(fronta));
} else {
printf ("Queue is not runnning\n");
}
data = talloc(ev, struct juststruct);
data->ctx = mem_ctx;
data->ev = ev;
// create 4 requests
for (i = 1; i < 5; i++) {
req[i] = foo_send(mem_ctx, ev, names[i], i);
tmp = req[i];
if (req[i] == NULL) {
fprintf(stderr, "Request error! %d \n", ret);
break;
}
tevent_req_set_callback(req[i], foo_done, data);
created++;
}
// add item to a queue
tevent_queue_add(fronta, ev, req[1], trigger, data);
tevent_queue_add(fronta, ev, req[2], trigger, data);
tevent_queue_add(fronta, ev, req[3], trigger, data);
tevent_queue_add(fronta, ev, req[4], trigger, data);
printf("Queue length: %d\n", tevent_queue_length(fronta));
while(tevent_queue_length(fronta) > 0) {
tevent_loop_once(ev);
printf("Queue: %d items left\n", tevent_queue_length(fronta));
}
talloc_free(mem_ctx);
printf("FINISH\n");
return EXIT_SUCCESS;
}
@endcode
*/
tevent-0.9.19/doc/tevent_request.dox 0000660 0000000 0000000 00000021342 12165515312 017414 0 ustar root root 0000000 0000000 /**
@page tevent_request Chapter 4: Tevent request
@section request Tevent request
A specific feature of the library is the tevent request API that provides for
asynchronous computation and allows much more interconnected working and
cooperation among func- tions and events. When working with tevent request it
is possible to nest one event under another and handle them bit by bit. This
enables the creation of sequences of steps, and provides an opportunity to
prepare for all problems which may unexpectedly happen within the different
phases. One way or another, subrequests split bigger tasks into smaller ones
which allow a clearer view of each task as a whole.
@subsection name Naming conventions
There is a naming convention which is not obligatory but it is followed in this
tutorial:
- Functions triggered before the event happens. These establish a request.
- \b foo_send(...) - this function is called first and it includes the
creation of tevent request - tevent req structure. It does not block
anything, it simply creates a request, sets a callback (foo done) and lets
the program continue
- Functions as a result of event.
- \b foo_done(...) - this function contains code providing for handling itself
and based upon its results, the request is set either as a done or, if an
error occurs, the request is set as a failure.
- \b foo_recv(...) - this function contains code which should, if demanded,
access the result data and make them further visible. The foo state should
be deallocated from memory when the request’s processing is over and
therefore all computed data up to this point would be lost.
As was already mentioned, specific naming subsumes not only functions but also
the data themselves:
- \b foo_state - this is a structure. It contains all the data necessary for
the asynchronous task.
@subsection cr_req Creating a New Asynchronous Request
The first step for working asynchronously is the allocation of memory
requirements. As in previous cases, the talloc context is required, upon which
the asynchronous request will be tied. The next step is the creation of the
request itself.
@code
struct tevent_req* tevent_req_create (TALLOC_CTX *mem_ctx, void **pstate, #type)
@endcode
The pstate is the pointer to the private data. The necessary amount of memory
(based on data type) is allocated during this call. Within this same memory
area all the data from the asynchronous request that need to be preserved for
some time should be kept.
Dealing with a lack of memory
The verification of the returned pointer against NULL is necessary in order to
identify a potential lack of memory. There is a special function which helps
with this check tevent_req_nomem().
It handles verification both of the talloc memory allocation and of the
associated tevent request, and is therefore a very useful function for avoiding
unexpected situations. It can easily be used when checking the availability of
further memory resources that are required for a tevent request. Imagine an
example where additional memory needs arise although no memory resources are
currently available.
@code
bar = talloc(mem_ctx, struct foo);
if(tevent_req_nomem (bar, req)) {
// handling a problem
}
@endcode
This code ensures that the variable bar, which contains NULL as a result of the
unsuccessful satisfaction of its memory requirements, is noticed, and also that
the tevent request req declares it exceeds memory capacity, which implies the
impossibility of finishing the request as originally programmed.
@subsection fini_req Finishing a Request
Marking each request as finished is an essential principle of the tevent
library. Without marking the request as completed - either successfully or with
an error - the tevent loop could not let the appropriate callback be triggered.
It is important to understand that this would be a significant threat, because
it is not usually a question of one single function which prints some text on a
screen, but rather the request is itself probably just a link in a series of
other requests. Stopping one request would stop the others, memory resources
would not be freed, file descriptors might remain open, communication via
socket could be interrupted, and so on. Therefore it is important to think
about finishing requests, either successfully or not, and also to prepare
functions for all possible scenarios, so that the the callbacks do not process
data that are actually invalid or, even worse, in fact non-existent meaning
that a segmentation fault may arise.
- \b Manually - This is the most common type of finishing request. Calling
this function sets the request as a TEVENT_REQ_DONE. This is the only purpose
of this function and it should be used when everything went well. Typically it
is used within the done functions.
@code
void tevent_req_done (struct tevent_req *req)
@endcode
Alternatively, the request can end up being unsuccessful.
@code
bool tevent_req_error (struct tevent_req *req, uint64_t error)
@endcode
The second argument takes the number of an error (declared by the programmer,
for example in an enumerated variable). The function tevent_req_error() sets
the status of the request as a TEVENT_REQ_USER_ERROR and also stores the code
of error within the structure so it can be used, for example for debugging. The
function returns true, if marking the request as an error was processed with no
problem - value error passed to this function is not equal to 1.
-
Setting up a timeout for request - A request can be finished virtually,
or if the process takes too much time, it can be timed out. This is considered
as an error of the request and it leads to calling callback. In the
background, this timeout is set through a time event (described in
@subpage tevent_events ) which eventually triggers an operation marking the
request as a TEVENT_REQ_TIMED_OUT (can not be considered as successfully
finished). In case a time out was already set, this operation will overwrite it
with a new time value (so the timeout may be lengthened) and if everything is
set properly, it returns true.
@code
bool tevent_req_set_endtime(struct tevent_req *req,
struct tevent_context *ev,
struct timeval endtime);
@endcode
- Premature Triggering - Imagine a situation in which some part of a
nested subrequest ended up with a failure and it is still required to trigger a
callback. Such as example might result from lack of memory leading to the
impossibility of allocating enough memory requirements for the event to start
processing another subrequest, or from a clear intention to skip other
procedures and trigger the callback regardless of other progress. In these
cases, the function tevent_req_post() is very handy and offers this option.
@code
struct tevent_req* tevent_req_post (struct tevent_req *req,
struct tevent_context *ev);
@endcode
A request finished in this way does not behave as a time event nor as a file
descriptor event but as a immediately scheduled event, and therefore it will be
treated according the description laid down in @subpage tevent_events .
@section nested Subrequests - Nested Requests
To create more complex and interconnected asynchronous operations, it is
possible to submerge a request into another and thus create a so-called
subrequest. Subrequests are not represented by any other special structure but
they are created from tevent_req_create(). This diagram shows the nesting and
life time of each request. The table below describes the same in words, and
shows the triggering of functions during the application run.
Wrapper represents the trigger of the whole cascade of (sub)requests. It
may be e.g. a time or file descriptor event, or another request that was
created at a specific time by the function tevent_wakeup_send() which is a
slightly exceptional method of creating
@code
struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct timeval wakeup_time);
@endcode
By calling this function, it is possible to create a tevent request which is
actually the return value of this function. In summary, it sets the time value
of the tevent request’s creation. While using this function it is necessary to
use another function in the subrequest’s callback to check for any problems
tevent_wakeup_recv() )
@image html tevent_subrequest.png
Comprehensive example containing features from this chapter is especially by
reason of nested subrequests very long and therefore it is located as an
example on the attached CD. Description and explanation is placed within the
source code itself (subrequest.c) and enclosed file README. The example is
available here.
*/
tevent-0.9.19/doc/tevent_tutorial.dox 0000660 0000000 0000000 00000000470 12162141064 017562 0 ustar root root 0000000 0000000 /**
@page tevent_tutorial The Tutorial
@section tevent_tutorial_introduction Introduction
Tutorial describing working with tevent library.
@section tevent_tutorial_toc Table of contents
@subpage tevent_context
@subpage tevent_events
@subpage tevent_data
@subpage tevent_request
@subpage tevent_queue
*/
tevent-0.9.19/doc/tutorials.dox 0000660 0000000 0000000 00000004001 11741275274 016367 0 ustar root root 0000000 0000000 /**
* @page tevent_queue_tutorial The tevent_queue tutorial
*
* @section Introduction
*
* A tevent_queue is used to queue up async requests that must be
* serialized. For example writing buffers into a socket must be
* serialized. Writing a large lump of data into a socket can require
* multiple write(2) or send(2) system calls. If more than one async
* request is outstanding to write large buffers into a socket, every
* request must individually be completed before the next one begins,
* even if multiple syscalls are required.
*
* To do this, every socket gets assigned a tevent_queue struct.
*
* Creating a serialized async request follows the usual convention to
* return a tevent_req structure with an embedded state structure. To
* serialize the work the requests is about to so, instead of directly
* starting or doing that work, tevent_queue_add must be called. When it
* is time for the serialized async request to do its work, the trigger
* callback function tevent_queue_add was given is called. In the example
* of writing to a socket, the trigger is called when the write request
* can begin accessing the socket.
*
* How does this engine work behind the scenes? When the queue is empty,
* tevent_queue_add schedules an immediate call to the trigger
* callback. The trigger callback starts its work, likely by starting
* other async subrequests. While these async subrequests are working,
* more requests can accumulate in the queue by tevent_queue_add. While
* there is no function to explicitly trigger the next waiter in line, it
* still works: When the active request in the queue is done, it will be
* destroyed by talloc_free. Talloc_free of an serialized async request
* that had been added to a queue will trigger the next request in the
* queue via a talloc destructor attached to a child of the serialized
* request. This way the queue will be kept busy when an async request
* finishes.
*
* @section Example
*
* @code
* Metze: Please add a code example here.
* @endcode
*/
tevent-0.9.19/doxy.config 0000660 0000000 0000000 00000236457 12162141064 015243 0 ustar root root 0000000 0000000 # Doxyfile 1.8.4
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.
#
# All text after a double hash (##) is considered a comment and is placed
# in front of the TAG it is preceding .
# All text after a hash (#) is considered a comment and will be ignored.
# The format is:
# TAG = value [value, ...]
# For lists items can also be appended using:
# TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ").
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# http://www.gnu.org/software/libiconv for the list of possible encodings.
DOXYFILE_ENCODING = UTF-8
# The PROJECT_NAME tag is a single word (or sequence of words) that should
# identify the project. Note that if you do not use Doxywizard you need
# to put quotes around the project name if it contains spaces.
PROJECT_NAME = tevent
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.
PROJECT_NUMBER = 0.9.8
# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer
# a quick idea about the purpose of the project. Keep the description short.
PROJECT_BRIEF =
# With the PROJECT_LOGO tag one can specify an logo or icon that is
# included in the documentation. The maximum height of the logo should not
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
# Doxygen will copy the logo to the output directory.
PROJECT_LOGO =
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.
OUTPUT_DIRECTORY = doc
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
# 4096 sub-directories (in 2 levels) under the output directory of each output
# format and will distribute the generated files over these directories.
# Enabling this option can be useful when feeding doxygen a huge amount of
# source files, where putting all generated files in the same directory would
# otherwise cause performance problems for the file system.
CREATE_SUBDIRS = NO
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
# messages), Korean, Korean-en, Latvian, Lithuanian, Norwegian, Macedonian,
# Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic,
# Slovak, Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
OUTPUT_LANGUAGE = English
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.
BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.
REPEAT_BRIEF = YES
# This tag implements a quasi-intelligent brief description abbreviator
# that is used to form the text in various listings. Each string
# in this list, if found as the leading text of the brief description, will be
# stripped from the text and the result after processing the whole list, is
# used as the annotated text. Otherwise, the brief description is used as-is.
# If left blank, the following values are used ("$name" is automatically
# replaced with the name of the entity): "The $name class" "The $name widget"
# "The $name file" "is" "provides" "specifies" "contains"
# "represents" "a" "an" "the"
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.
ALWAYS_DETAILED_SEC = NO
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.
INLINE_INHERITED_MEMB = NO
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.
FULL_PATH_NAMES = YES
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user-defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the
# path to strip. Note that you specify absolute paths here, but also
# relative paths, which will be relative from the directory where doxygen is
# started.
STRIP_FROM_PATH =
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
# the path mentioned in the documentation of a class, which tells
# the reader which header file to include in order to use a class.
# If left blank only the name of the header file containing the class
# definition is used. Otherwise one should specify the include paths that
# are normally passed to the compiler using the -I flag.
STRIP_FROM_INC_PATH =
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful if your file system
# doesn't support long names like on DOS, Mac, or CD-ROM.
SHORT_NAMES = NO
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the JavaDoc
# comments will behave just like regular Qt-style comments
# (thus requiring an explicit @brief command for a brief description.)
JAVADOC_AUTOBRIEF = YES
# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
# interpret the first line (until the first dot) of a Qt-style
# comment as the brief description. If set to NO, the comments
# will behave just like regular Qt-style comments (thus requiring
# an explicit \brief command for a brief description.)
QT_AUTOBRIEF = NO
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
# comments) as a brief description. This used to be the default behaviour.
# The new default is to treat a multi-line C++ comment block as a detailed
# description. Set this tag to YES if you prefer the old behaviour instead.
MULTILINE_CPP_IS_BRIEF = NO
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.
INHERIT_DOCS = YES
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
# a new page for each member. If set to NO, the documentation of a member will
# be part of the file/class/namespace that contains it.
SEPARATE_MEMBER_PAGES = NO
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.
TAB_SIZE = 8
# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user-defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.
ALIASES =
# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding
# "class=itcl::class" will allow you to use the command class in the
# itcl::class meaning.
TCL_SUBST =
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
# sources only. Doxygen will then generate output that is more tailored for C.
# For instance, some of the names that are used will be different. The list
# of all members will be omitted, etc.
OPTIMIZE_OUTPUT_FOR_C = YES
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
# sources only. Doxygen will then generate output that is more tailored for
# Java. For instance, namespaces will be presented as packages, qualified
# scopes will look different, etc.
OPTIMIZE_OUTPUT_JAVA = NO
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources only. Doxygen will then generate output that is more tailored for
# Fortran.
OPTIMIZE_FOR_FORTRAN = NO
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for
# VHDL.
OPTIMIZE_OUTPUT_VHDL = NO
# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given
# extension. Doxygen has a built-in mapping, but you can override or extend it
# using this tag. The format is ext=language, where ext is a file extension,
# and language is one of the parsers supported by doxygen: IDL, Java,
# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
# C++. For instance to make doxygen treat .inc files as Fortran files (default
# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
# that for custom extensions you also need to set FILE_PATTERNS otherwise the
# files are not read by doxygen.
EXTENSION_MAPPING =
# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
# comments according to the Markdown format, which allows for more readable
# documentation. See http://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you
# can mix doxygen, HTML, and XML commands with Markdown formatting.
# Disable only in case of backward compatibilities issues.
MARKDOWN_SUPPORT = YES
# When enabled doxygen tries to link words that correspond to documented
# classes, or namespaces to their corresponding documentation. Such a link can
# be prevented in individual cases by by putting a % sign in front of the word
# or globally by setting AUTOLINK_SUPPORT to NO.
AUTOLINK_SUPPORT = YES
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also makes the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.
BUILTIN_STL_SUPPORT = NO
# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.
CPP_CLI_SUPPORT = NO
# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
# Doxygen will parse them like normal C++ but will assume all classes use public
# instead of private inheritance when no explicit protection keyword is present.
SIP_SUPPORT = NO
# For Microsoft's IDL there are propget and propput attributes to indicate
# getter and setter methods for a property. Setting this option to YES (the
# default) will make doxygen replace the get and set methods by a property in
# the documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.
IDL_PROPERTY_SUPPORT = YES
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.
DISTRIBUTE_GROUP_DOC = NO
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
# the same type (for instance a group of public functions) to be put as a
# subgroup of that type (e.g. under the Public Functions section). Set it to
# NO to prevent subgrouping. Alternatively, this can be done per class using
# the \nosubgrouping command.
SUBGROUPING = YES
# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
# unions are shown inside the group in which they are included (e.g. using
# @ingroup) instead of on a separate page (for HTML and Man pages) or
# section (for LaTeX and RTF).
INLINE_GROUPED_CLASSES = NO
# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
# unions with only public data fields or simple typedef fields will be shown
# inline in the documentation of the scope in which they are defined (i.e. file,
# namespace, or group documentation), provided this scope is documented. If set
# to NO (the default), structs, classes, and unions are shown on a separate
# page (for HTML and Man pages) or section (for LaTeX and RTF).
INLINE_SIMPLE_STRUCTS = NO
# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
# is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically
# be useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.
TYPEDEF_HIDES_STRUCT = NO
# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
# cache is used to resolve symbols given their name and scope. Since this can
# be an expensive process and often the same symbol appear multiple times in
# the code, doxygen keeps a cache of pre-resolved symbols. If the cache is too
# small doxygen will become slower. If the cache is too large, memory is wasted.
# The cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid
# range is 0..9, the default is 0, corresponding to a cache size of 2^16 = 65536
# symbols.
LOOKUP_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES
EXTRACT_ALL = NO
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.
EXTRACT_PRIVATE = NO
# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
# scope will be included in the documentation.
EXTRACT_PACKAGE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.
EXTRACT_STATIC = NO
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
# If set to NO only classes defined in header files are included.
EXTRACT_LOCAL_CLASSES = NO
# This flag is only useful for Objective-C code. When set to YES local
# methods, which are defined in the implementation section but not in
# the interface are included in the documentation.
# If set to NO (the default) only methods in the interface are included.
EXTRACT_LOCAL_METHODS = NO
# If this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base
# name of the file that contains the anonymous namespace. By default
# anonymous namespaces are hidden.
EXTRACT_ANON_NSPACES = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_MEMBERS = YES
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these classes will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_CLASSES = YES
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
# friend (class|struct|union) declarations.
# If set to NO (the default) these declarations will be included in the
# documentation.
HIDE_FRIEND_COMPOUNDS = NO
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
# documentation blocks found inside the body of a function.
# If set to NO (the default) these blocks will be appended to the
# function's detailed documentation block.
HIDE_IN_BODY_DOCS = NO
# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.
INTERNAL_DOCS = NO
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower-case letters. If set to YES upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.
CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.
HIDE_SCOPE_NAMES = NO
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put a list of the files that are included by a file in the documentation
# of that file.
SHOW_INCLUDE_FILES = YES
# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
# will list include files with double quotes in the documentation
# rather than with sharp brackets.
FORCE_LOCAL_INCLUDES = NO
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.
INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.
SORT_MEMBER_DOCS = YES
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
# brief documentation of file, namespace and class members alphabetically
# by member name. If set to NO (the default) the members will appear in
# declaration order.
SORT_BRIEF_DOCS = NO
# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
# will sort the (brief and detailed) documentation of class members so that
# constructors and destructors are listed first. If set to NO (the default)
# the constructors will appear in the respective orders defined by
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
SORT_MEMBERS_CTORS_1ST = NO
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
# hierarchy of group names into alphabetical order. If set to NO (the default)
# the group names will appear in their defined order.
SORT_GROUP_NAMES = NO
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
# sorted by fully-qualified names, including namespaces. If set to
# NO (the default), the class list will be sorted only by class name,
# not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the
# alphabetical list.
SORT_BY_SCOPE_NAME = NO
# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
# do proper type resolution of all parameters of a function it will reject a
# match between the prototype and the implementation of a member function even
# if there is only one candidate or it is obvious which candidate to choose
# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
# will still accept a match between prototype and implementation in such cases.
STRICT_PROTO_MATCHING = NO
# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.
GENERATE_TODOLIST = YES
# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.
GENERATE_TESTLIST = YES
# The GENERATE_BUGLIST tag can be used to enable (YES) or
# disable (NO) the bug list. This list is created by putting \bug
# commands in the documentation.
GENERATE_BUGLIST = YES
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
# disable (NO) the deprecated list. This list is created by putting
# \deprecated commands in the documentation.
GENERATE_DEPRECATEDLIST= YES
# The ENABLED_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if section-label ... \endif
# and \cond section-label ... \endcond blocks.
ENABLED_SECTIONS =
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or macro consists of for it to appear in
# the documentation. If the initializer consists of more lines than specified
# here it will be hidden. Use a value of 0 to hide initializers completely.
# The appearance of the initializer of individual variables and macros in the
# documentation can be controlled using \showinitializer or \hideinitializer
# command in the documentation regardless of this setting.
MAX_INITIALIZER_LINES = 30
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
# at the bottom of the documentation of classes and structs. If set to YES the
# list will mention the files that were used to generate the documentation.
SHOW_USED_FILES = YES
# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.
SHOW_FILES = YES
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page.
# This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.
SHOW_NAMESPACES = YES
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command , where is the value of
# the FILE_VERSION_FILTER tag, and is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.
FILE_VERSION_FILTER =
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. To create the layout file
# that represents doxygen's defaults, run doxygen with the -l option.
# You can optionally specify a file name after the option, if omitted
# DoxygenLayout.xml will be used as the name of the layout file.
LAYOUT_FILE =
# The CITE_BIB_FILES tag can be used to specify one or more bib files
# containing the references data. This must be a list of .bib files. The
# .bib extension is automatically appended if omitted. Using this command
# requires the bibtex tool to be installed. See also
# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
# feature you need bibtex and perl available in the search path. Do not use
# file names with spaces, bibtex cannot handle them.
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.
QUIET = NO
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.
WARNINGS = YES
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.
WARN_IF_UNDOCUMENTED = YES
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some
# parameters in a documented function, or documenting parameters that
# don't exist or using markup commands wrongly.
WARN_IF_DOC_ERROR = YES
# The WARN_NO_PARAMDOC option can be enabled to get warnings for
# functions that are documented, but have no documentation for their parameters
# or return value. If set to NO (the default) doxygen will only warn about
# wrong or incomplete parameter documentation, but not about the absence of
# documentation.
WARN_NO_PARAMDOC = NO
# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)
WARN_FORMAT = "$file:$line: $text"
# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = . \
doc
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
# also the default input encoding. Doxygen uses libiconv (or the iconv built
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
# the list of possible encodings.
INPUT_ENCODING = UTF-8
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank the following patterns are tested:
# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
# *.f90 *.f *.for *.vhd *.vhdl
FILE_PATTERNS = *.cpp \
*.cc \
*.c \
*.h \
*.hh \
*.hpp \
*.dox
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.
RECURSIVE = NO
# The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
# Note that relative paths are relative to the directory from which doxygen is
# run.
EXCLUDE =
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.
EXCLUDE_SYMLINKS = NO
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*
EXCLUDE_PATTERNS = */.git/*
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).
EXAMPLE_PATH =
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.
EXAMPLE_PATTERNS =
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude
# commands irrespective of the value of the RECURSIVE tag.
# Possible values are YES and NO. If left blank NO is used.
EXAMPLE_RECURSIVE = NO
# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).
IMAGE_PATH = doc/img
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command , where
# is the value of the INPUT_FILTER tag, and is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output.
# If FILTER_PATTERNS is specified, this tag will be ignored.
# Note that the filter must not add or remove lines; it is applied before the
# code is scanned, but not when the output code is generated. If lines are added
# or removed, the anchors will not be placed correctly.
INPUT_FILTER =
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis.
# Doxygen will compare the file name with each pattern and apply the
# filter if there is a match.
# The filters are a list of the form:
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
# info on how filters are used. If FILTER_PATTERNS is empty or if
# non of the patterns match the file name, INPUT_FILTER is applied.
FILTER_PATTERNS =
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will be used to filter the input files when producing source
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
FILTER_SOURCE_FILES = NO
# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
# and it is also possible to disable source filtering for a specific pattern
# using *.ext= (so without naming a filter). This option only has effect when
# FILTER_SOURCE_FILES is enabled.
FILTER_SOURCE_PATTERNS =
# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
# is part of the input, its contents will be placed on the main page
# (index.html). This can be useful if you have a project on for instance GitHub
# and want reuse the introduction page also for the doxygen output.
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
# be generated. Documented entities will be cross-referenced with these sources.
# Note: To get rid of all source code in the generated output, make sure also
# VERBATIM_HEADERS is set to NO.
SOURCE_BROWSER = NO
# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C, C++ and Fortran comments will always remain visible.
STRIP_CODE_COMMENTS = YES
# If the REFERENCED_BY_RELATION tag is set to YES
# then for each documented function all documented
# functions referencing it will be listed.
REFERENCED_BY_RELATION = NO
# If the REFERENCES_RELATION tag is set to YES
# then for each documented function all documented entities
# called/used by that function will be listed.
REFERENCES_RELATION = NO
# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code.
# Otherwise they will link to the documentation.
REFERENCES_LINK_SOURCE = YES
# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.
USE_HTAGS = NO
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.
ALPHABETICAL_INDEX = NO
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])
COLS_IN_ALPHA_INDEX = 5
# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.
GENERATE_HTML = YES
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.
HTML_OUTPUT = html
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
# doxygen will generate files with .html extension.
HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header. Note that when using a custom header you are responsible
# for the proper inclusion of any scripts and style sheets that doxygen
# needs, which is dependent on the configuration options used.
# It is advised to generate a default header using "doxygen -w html
# header.html footer.html stylesheet.css YourConfigFile" and then modify
# that header. Note that the header is subject to change so you typically
# have to redo this when upgrading to a newer version of doxygen or when
# changing the value of configuration settings such as GENERATE_TREEVIEW!
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.
HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If left blank doxygen will
# generate a default style sheet. Note that it is recommended to use
# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
# tag will in the future become obsolete.
HTML_STYLESHEET =
# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
# user-defined cascading style sheet that is included after the standard
# style sheets created by doxygen. Using this option one can overrule
# certain style aspects. This is preferred over using HTML_STYLESHEET
# since it does not replace the standard style sheet and is therefor more
# robust against future updates. Doxygen will copy the style sheet file to
# the output directory.
HTML_EXTRA_STYLESHEET =
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that
# the files will be copied as-is; there are no commands or markers available.
HTML_EXTRA_FILES =
# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
# Doxygen will adjust the colors in the style sheet and background images
# according to this color. Hue is specified as an angle on a colorwheel,
# see http://en.wikipedia.org/wiki/Hue for more information.
# For instance the value 0 represents red, 60 is yellow, 120 is green,
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
# The allowed range is 0 to 359.
HTML_COLORSTYLE_HUE = 220
# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
# the colors in the HTML output. For a value of 0 the output will use
# grayscales only. A value of 255 will produce the most vivid colors.
HTML_COLORSTYLE_SAT = 100
# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
# the luminance component of the colors in the HTML output. Values below
# 100 gradually make the output lighter, whereas values above 100 make
# the output darker. The value divided by 100 is the actual gamma applied,
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
# and 100 does not change the gamma.
HTML_COLORSTYLE_GAMMA = 80
# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting
# this to NO can help when comparing the output of multiple runs.
HTML_TIMESTAMP = NO
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.
HTML_DYNAMIC_SECTIONS = NO
# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
# entries shown in the various tree structured indices initially; the user
# can expand and collapse entries dynamically later on. Doxygen will expand
# the tree to such a level that at most the specified number of entries are
# visible (unless a fully collapsed tree already exceeds this amount).
# So setting the number of entries 1 will produce a full collapsed tree by
# default. 0 is a special value representing an infinite number of entries
# and will result in a full expanded tree by default.
HTML_INDEX_NUM_ENTRIES = 100
# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
# integrated development environment, introduced with OSX 10.5 (Leopard).
# To create a documentation set, doxygen will generate a Makefile in the
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.
GENERATE_DOCSET = NO
# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
# feed. A documentation feed provides an umbrella under which multiple
# documentation sets from a single provider (such as a company or product suite)
# can be grouped.
DOCSET_FEEDNAME = "Doxygen generated docs"
# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
# should uniquely identify the documentation set bundle. This should be a
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
# will append .docset to the name.
DOCSET_BUNDLE_ID = org.doxygen.Project
# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
# identify the documentation publisher. This should be a reverse domain-name
# style string, e.g. com.mycompany.MyDocSet.documentation.
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
DOCSET_PUBLISHER_NAME = Publisher
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.
GENERATE_HTMLHELP = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
# can add a path in front of the file if the result should not be
# written to the html output directory.
CHM_FILE =
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
# be used to specify the location (absolute path including file name) of
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
# the HTML help compiler on the generated index.hhp.
HHC_LOCATION =
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
# controls if a separate .chi index file is generated (YES) or that
# it should be included in the master .chm file (NO).
GENERATE_CHI = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.
CHM_INDEX_ENCODING =
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.
BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members
# to the contents of the HTML help documentation and to the tree view.
TOC_EXPAND = NO
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
# that can be used as input for Qt's qhelpgenerator to generate a
# Qt Compressed Help (.qch) of the generated HTML documentation.
GENERATE_QHP = NO
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.
QCH_FILE =
# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#namespace
QHP_NAMESPACE =
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#virtual-folders
QHP_VIRTUAL_FOLDER = doc
# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
# add. For more information please see
# http://doc.trolltech.com/qthelpproject.html#custom-filters
QHP_CUST_FILTER_NAME =
# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see
#
# Qt Help Project / Custom Filters.
QHP_CUST_FILTER_ATTRS =
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's
# filter section matches.
#
# Qt Help Project / Filter Attributes.
QHP_SECT_FILTER_ATTRS =
# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file.
QHG_LOCATION =
# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
# will be generated, which together with the HTML files, form an Eclipse help
# plugin. To install this plugin and make it available under the help contents
# menu in Eclipse, the contents of the directory containing the HTML and XML
# files needs to be copied into the plugins directory of eclipse. The name of
# the directory within the plugins directory should be the same as
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
# the help appears.
GENERATE_ECLIPSEHELP = NO
# A unique identifier for the eclipse help plugin. When installing the plugin
# the directory name containing the HTML and XML files should also have
# this name.
ECLIPSE_DOC_ID = org.doxygen.Project
# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
# at top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it. Since the tabs have the same information as the
# navigation tree you can set this option to NO if you already set
# GENERATE_TREEVIEW to YES.
DISABLE_INDEX = NO
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value is set to YES, a side panel will be generated
# containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
# Windows users are probably better off using the HTML help feature.
# Since the tree basically has the same information as the tab index you
# could consider to set DISABLE_INDEX to NO when enabling this option.
GENERATE_TREEVIEW = NONE
# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
# (range [0,1..20]) that doxygen will group on one line in the generated HTML
# documentation. Note that a value of 0 will completely suppress the enum
# values from appearing in the overview section.
ENUM_VALUES_PER_LINE = 4
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
# used to set the initial width (in pixels) of the frame in which the tree
# is shown.
TREEVIEW_WIDTH = 250
# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
# links to external symbols imported via tag files in a separate window.
EXT_LINKS_IN_WINDOW = NO
# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.
FORMULA_FONTSIZE = 10
# Use the FORMULA_TRANPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are
# not supported properly for IE 6.0, but are supported on all modern browsers.
# Note that when changing this option you need to delete any form_*.png files
# in the HTML output before the changes have effect.
FORMULA_TRANSPARENT = YES
# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
# (see http://www.mathjax.org) which uses client side Javascript for the
# rendering instead of using prerendered bitmaps. Use this if you do not
# have LaTeX installed or if you want to formulas look prettier in the HTML
# output. When enabled you may also need to install MathJax separately and
# configure the path to it using the MATHJAX_RELPATH option.
USE_MATHJAX = NO
# When MathJax is enabled you can set the default output format to be used for
# the MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
# SVG. The default value is HTML-CSS, which is slower, but has the best
# compatibility.
MATHJAX_FORMAT = HTML-CSS
# When MathJax is enabled you need to specify the location relative to the
# HTML output directory using the MATHJAX_RELPATH option. The destination
# directory should contain the MathJax.js script. For instance, if the mathjax
# directory is located at the same level as the HTML output directory, then
# MATHJAX_RELPATH should be ../mathjax. The default value points to
# the MathJax Content Delivery Network so you can quickly see the result without
# installing MathJax.
# However, it is strongly recommended to install a local
# copy of MathJax from http://www.mathjax.org before deployment.
MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
# names that should be enabled during MathJax rendering.
MATHJAX_EXTENSIONS =
# The MATHJAX_CODEFILE tag can be used to specify a file with javascript
# pieces of code that will be used on startup of the MathJax code.
MATHJAX_CODEFILE =
# When the SEARCHENGINE tag is enabled doxygen will generate a search box
# for the HTML output. The underlying search engine uses javascript
# and DHTML and should work on any modern browser. Note that when using
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
# (GENERATE_DOCSET) there is already a search function so this one should
# typically be disabled. For large projects the javascript based search engine
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
SEARCHENGINE = NO
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a web server instead of a web client using Javascript.
# There are two flavours of web server based search depending on the
# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
# searching and an index file used by the script. When EXTERNAL_SEARCH is
# enabled the indexing and searching needs to be provided by external tools.
# See the manual for details.
SERVER_BASED_SEARCH = NO
# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
# script for searching. Instead the search results are written to an XML file
# which needs to be processed by an external indexer. Doxygen will invoke an
# external search engine pointed to by the SEARCHENGINE_URL option to obtain
# the search results. Doxygen ships with an example indexer (doxyindexer) and
# search engine (doxysearch.cgi) which are based on the open source search
# engine library Xapian. See the manual for configuration details.
EXTERNAL_SEARCH = NO
# The SEARCHENGINE_URL should point to a search engine hosted by a web server
# which will returned the search results when EXTERNAL_SEARCH is enabled.
# Doxygen ships with an example search engine (doxysearch) which is based on
# the open source search engine library Xapian. See the manual for configuration
# details.
SEARCHENGINE_URL =
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
# search data is written to a file for indexing by an external tool. With the
# SEARCHDATA_FILE tag the name of this file can be specified.
SEARCHDATA_FILE = searchdata.xml
# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
# projects and redirect the results back to the right project.
EXTERNAL_SEARCH_ID =
# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
# projects other than the one defined by this configuration file, but that are
# all added to the same external search index. Each project needs to have a
# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
# of to a relative location where the documentation can be found.
# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.
GENERATE_LATEX = YES
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.
LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked. If left blank `latex' will be used as the default command name.
# Note that when enabling USE_PDFLATEX this option is only used for
# generating bitmaps for formulas in the HTML output, but not in the
# Makefile that is written to the output directory.
LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
# generate index for LaTeX. If left blank `makeindex' will be used as the
# default command name.
MAKEINDEX_CMD_NAME = makeindex
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, letter, legal and
# executive. If left blank a4 will be used.
PAPER_TYPE = a4wide
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.
EXTRA_PACKAGES =
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!
LATEX_HEADER =
# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
# the generated latex document. The footer should contain everything after
# the last chapter. If it is left blank doxygen will generate a
# standard footer. Notice: only use this tag if you know what you are doing!
LATEX_FOOTER =
# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images
# or other source files which should be copied to the LaTeX output directory.
# Note that the files will be copied as-is; there are no commands or markers
# available.
LATEX_EXTRA_FILES =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.
PDF_HYPERLINKS = YES
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.
USE_PDFLATEX = YES
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.
LATEX_BATCHMODE = NO
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
# in the output.
LATEX_HIDE_INDICES = NO
# If LATEX_SOURCE_CODE is set to YES then doxygen will include
# source code with syntax highlighting in the LaTeX output.
# Note that which sources are shown also depends on other settings
# such as SOURCE_BROWSER.
LATEX_SOURCE_CODE = NO
# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
# http://en.wikipedia.org/wiki/BibTeX for more info.
LATEX_BIB_STYLE = plain
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimized for Word 97 and may not look very pretty with
# other RTF readers or editors.
GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.
RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using WORD or other
# programs which support those fields.
# Note: wordpad (write) and others do not support links.
RTF_HYPERLINKS = NO
# Load style sheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.
RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an rtf document.
# Syntax is similar to doxygen's config file.
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages
GENERATE_MAN = YES
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)
MAN_EXTENSION = .3
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation.
GENERATE_XML = NO
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `xml' will be used as the default path.
XML_OUTPUT = xml
# The XML_SCHEMA tag can be used to specify an XML schema,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_SCHEMA =
# The XML_DTD tag can be used to specify an XML DTD,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_DTD =
# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
# dump the program listings (including syntax highlighting
# and cross-referencing information) to the XML output. Note that
# enabling this will significantly increase the size of the XML output.
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
# If the GENERATE_DOCBOOK tag is set to YES Doxygen will generate DOCBOOK files
# that can be used to generate PDF.
GENERATE_DOCBOOK = NO
# The DOCBOOK_OUTPUT tag is used to specify where the DOCBOOK pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
# front of it. If left blank docbook will be used as the default path.
DOCBOOK_OUTPUT = docbook
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
# generate an AutoGen Definitions (see autogen.sf.net) file
# that captures the structure of the code including all
# documentation. Note that this feature is still experimental
# and incomplete at the moment.
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
# generate a Perl module file that captures the structure of
# the code including all documentation. Note that this
# feature is still experimental and incomplete at the
# moment.
GENERATE_PERLMOD = NO
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
# to generate PDF and DVI output from the Perl module output.
PERLMOD_LATEX = NO
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
# nicely formatted so it can be parsed by a human reader.
# This is useful
# if you want to understand what is going on.
# On the other hand, if this
# tag is set to NO the size of the Perl module output will be much smaller
# and Perl will parse it just the same.
PERLMOD_PRETTY = YES
# The names of the make variables in the generated doxyrules.make file
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
# This is useful so different doxyrules.make files included by the same
# Makefile don't overwrite each other's variables.
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.
ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.
MACRO_EXPANSION = YES
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_DEFINED tags.
EXPAND_ONLY_PREDEF = YES
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# pointed to by INCLUDE_PATH will be searched when a #include is found.
SEARCH_INCLUDES = YES
# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by
# the preprocessor.
INCLUDE_PATH =
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.
INCLUDE_FILE_PATTERNS =
# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. To prevent a macro definition from being
# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.
PREDEFINED = DOXYGEN \
PRINTF_ATTRIBUTE(x,y)=
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition that
# overrules the definition found in the source code.
EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all references to function-like macros
# that are alone on a line, have an all uppercase name, and do not end with a
# semicolon, because these will confuse the parser if not removed.
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
# The TAGFILES option can be used to specify one or more tagfiles. For each
# tag file the location of the external documentation should be added. The
# format of a tag file without this location is as follows:
#
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
#
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where "loc1" and "loc2" can be relative or absolute paths
# or URLs. Note that each tag file must have a unique name (where the name does
# NOT include the path). If a tag file is not located in the directory in which
# doxygen is run, you must also specify the path to the tagfile here.
TAGFILES =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.
GENERATE_TAGFILE =
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.
ALLEXTERNALS = NO
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will
# be listed.
EXTERNAL_GROUPS = YES
# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed
# in the related pages index. If set to NO, only the current project's
# pages will be listed.
EXTERNAL_PAGES = YES
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option also works with HAVE_DOT disabled, but it is recommended to
# install and use dot, since it yields more powerful graphs.
CLASS_DIAGRAMS = YES
# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.
MSCGEN_PATH =
# If set to YES, the inheritance and collaboration graphs will hide
# inheritance and usage relations if the target is undocumented
# or is not a class.
HIDE_UNDOC_RELATIONS = YES
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)
HAVE_DOT = NO
# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
# allowed to run in parallel. When set to 0 (the default) doxygen will
# base this on the number of processors available in the system. You can set it
# explicitly to a value larger than 0 to get control over the balance
# between CPU load and processing speed.
DOT_NUM_THREADS = 0
# By default doxygen will use the Helvetica font for all dot files that
# doxygen generates. When you want a differently looking font you can specify
# the font name using DOT_FONTNAME. You need to make sure dot is able to find
# the font, which can be done by putting it in a standard location or by setting
# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
# directory containing the font.
DOT_FONTNAME = FreeSans
# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
# The default size is 10pt.
DOT_FONTSIZE = 10
# By default doxygen will tell dot to use the Helvetica font.
# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
# set the path where dot can find it.
DOT_FONTPATH =
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# CLASS_DIAGRAMS tag to NO.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.
COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for groups, showing the direct groups dependencies
GROUP_GRAPHS = YES
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.
UML_LOOK = NO
# If the UML_LOOK tag is enabled, the fields and methods are shown inside
# the class node. If there are many fields or methods and many nodes the
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
# threshold limits the number of items for each type to make the size more
# manageable. Set this to 0 for no limit. Note that the threshold may be
# exceeded by 50% before the limit is enforced.
UML_LIMIT_NUM_FIELDS = 10
# If set to YES, the inheritance and collaboration graphs will show the
# relations between templates and their instances.
TEMPLATE_RELATIONS = NO
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
# tags are set to YES then doxygen will generate a graph for each documented
# file showing the direct and indirect include dependencies of the file with
# other documented files.
INCLUDE_GRAPH = YES
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
# documented header file showing the documented files that directly or
# indirectly include this file.
INCLUDED_BY_GRAPH = YES
# If the CALL_GRAPH and HAVE_DOT options are set to YES then
# doxygen will generate a call dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable call graphs
# for selected functions only using the \callgraph command.
CALL_GRAPH = NO
# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
# doxygen will generate a caller dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable caller
# graphs for selected functions only using the \callergraph command.
CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will generate a graphical hierarchy of all classes instead of a textual one.
GRAPHICAL_HIERARCHY = YES
# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
# then doxygen will show the dependencies a directory has on other directories
# in a graphical way. The dependency relations are determined by the #include
# relations between the files in the directories.
DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. Possible values are svg, png, jpg, or gif.
# If left blank png will be used. If you choose svg you need to set
# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible in IE 9+ (other browsers do not have this requirement).
DOT_IMAGE_FORMAT = png
# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
# Note that this requires a modern browser other than Internet Explorer.
# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
# visible. Older versions of IE do not have SVG support.
INTERACTIVE_SVG = NO
# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.
DOT_PATH =
# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the
# \dotfile command).
DOTFILE_DIRS =
# The MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the
# \mscfile command).
MSCFILE_DIRS =
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
# number of direct children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
DOT_GRAPH_MAX_NODES = 50
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
# graphs generated by dot. A depth value of 3 means that only nodes reachable
# from the root by following a path via at most 3 edges will be shown. Nodes
# that lay further from the root node will be omitted. Note that setting this
# option to 1 or 2 may greatly reduce the computation time needed for large
# code bases. Also note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).
DOT_TRANSPARENT = YES
# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10)
# support this, this feature is disabled by default.
DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
# generate a legend page explaining the meaning of the various boxes and
# arrows in the dot generated graphs.
GENERATE_LEGEND = YES
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
# remove the intermediate dot files that are used to generate
# the various graphs.
DOT_CLEANUP = YES
tevent-0.9.19/pytevent.c 0000660 0000000 0000000 00000043713 12101212317 015073 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Python bindings for tevent
Copyright (C) Jelmer Vernooij 2010
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include
#include
void init_tevent(void);
typedef struct {
PyObject_HEAD
struct tevent_context *ev;
} TeventContext_Object;
typedef struct {
PyObject_HEAD
struct tevent_queue *queue;
} TeventQueue_Object;
typedef struct {
PyObject_HEAD
struct tevent_req *req;
} TeventReq_Object;
typedef struct {
PyObject_HEAD
struct tevent_signal *signal;
} TeventSignal_Object;
typedef struct {
PyObject_HEAD
struct tevent_timer *timer;
} TeventTimer_Object;
typedef struct {
PyObject_HEAD
struct tevent_fd *fd;
} TeventFd_Object;
staticforward PyTypeObject TeventContext_Type;
staticforward PyTypeObject TeventReq_Type;
staticforward PyTypeObject TeventQueue_Type;
staticforward PyTypeObject TeventSignal_Type;
staticforward PyTypeObject TeventTimer_Type;
staticforward PyTypeObject TeventFd_Type;
static int py_context_init(struct tevent_context *ev)
{
/* FIXME */
return 0;
}
static struct tevent_fd *py_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
/* FIXME */
return NULL;
}
static void py_set_fd_close_fn(struct tevent_fd *fde,
tevent_fd_close_fn_t close_fn)
{
/* FIXME */
}
static uint16_t py_get_fd_flags(struct tevent_fd *fde)
{
/* FIXME */
return 0;
}
static void py_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
{
/* FIXME */
}
/* timed_event functions */
static struct tevent_timer *py_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
/* FIXME */
return NULL;
}
/* immediate event functions */
static void py_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ev,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
/* FIXME */
}
/* signal functions */
static struct tevent_signal *py_add_signal(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum, int sa_flags,
tevent_signal_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
/* FIXME */
return NULL;
}
/* loop functions */
static int py_loop_once(struct tevent_context *ev, const char *location)
{
/* FIXME */
return 0;
}
static int py_loop_wait(struct tevent_context *ev, const char *location)
{
/* FIXME */
return 0;
}
const static struct tevent_ops py_tevent_ops = {
.context_init = py_context_init,
.add_fd = py_add_fd,
.set_fd_close_fn = py_set_fd_close_fn,
.get_fd_flags = py_get_fd_flags,
.set_fd_flags = py_set_fd_flags,
.add_timer = py_add_timer,
.schedule_immediate = py_schedule_immediate,
.add_signal = py_add_signal,
.loop_wait = py_loop_wait,
.loop_once = py_loop_once,
};
static PyObject *py_register_backend(PyObject *self, PyObject *args)
{
PyObject *name, *py_backend;
if (!PyArg_ParseTuple(args, "O", &py_backend))
return NULL;
name = PyObject_GetAttrString(py_backend, "name");
if (name == NULL) {
PyErr_SetNone(PyExc_AttributeError);
return NULL;
}
if (!PyString_Check(name)) {
PyErr_SetNone(PyExc_TypeError);
return NULL;
}
if (!tevent_register_backend(PyString_AsString(name), &py_tevent_ops)) { /* FIXME: What to do with backend */
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *py_tevent_context_reinitialise(TeventContext_Object *self)
{
int ret = tevent_re_initialise(self->ev);
if (ret != 0) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *py_tevent_queue_stop(TeventQueue_Object *self)
{
tevent_queue_stop(self->queue);
Py_RETURN_NONE;
}
static PyObject *py_tevent_queue_start(TeventQueue_Object *self)
{
tevent_queue_start(self->queue);
Py_RETURN_NONE;
}
static void py_queue_trigger(struct tevent_req *req, void *private_data)
{
PyObject *callback = private_data, *ret;
ret = PyObject_CallFunction(callback, "");
Py_XDECREF(ret);
}
static PyObject *py_tevent_queue_add(TeventQueue_Object *self, PyObject *args)
{
TeventContext_Object *py_ev;
TeventReq_Object *py_req;
PyObject *trigger;
bool ret;
if (!PyArg_ParseTuple(args, "O!O!O",
&TeventContext_Type, &py_ev,
&TeventReq_Type, &py_req,
&trigger))
return NULL;
Py_INCREF(trigger);
ret = tevent_queue_add(self->queue, py_ev->ev, py_req->req,
py_queue_trigger, trigger);
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "queue add failed");
Py_DECREF(trigger);
return NULL;
}
Py_RETURN_NONE;
}
static PyMethodDef py_tevent_queue_methods[] = {
{ "stop", (PyCFunction)py_tevent_queue_stop, METH_NOARGS,
"S.stop()" },
{ "start", (PyCFunction)py_tevent_queue_start, METH_NOARGS,
"S.start()" },
{ "add", (PyCFunction)py_tevent_queue_add, METH_VARARGS,
"S.add(ctx, req, trigger, baton)" },
{ NULL },
};
static PyObject *py_tevent_context_wakeup_send(PyObject *self, PyObject *args)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_context_loop_wait(TeventContext_Object *self)
{
if (tevent_loop_wait(self->ev) != 0) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *py_tevent_context_loop_once(TeventContext_Object *self)
{
if (tevent_loop_once(self->ev) != 0) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
Py_RETURN_NONE;
}
#ifdef TEVENT_DEPRECATED
static bool py_tevent_finished(PyObject *callback)
{
PyObject *py_ret;
bool ret;
py_ret = PyObject_CallFunction(callback, "");
if (py_ret == NULL)
return true;
ret = PyObject_IsTrue(py_ret);
Py_DECREF(py_ret);
return ret;
}
static PyObject *py_tevent_context_loop_until(TeventContext_Object *self, PyObject *args)
{
PyObject *callback;
if (!PyArg_ParseTuple(args, "O", &callback))
return NULL;
if (tevent_loop_until(self->ev, py_tevent_finished, callback) != 0) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
if (PyErr_Occurred())
return NULL;
Py_RETURN_NONE;
}
#endif
static void py_tevent_signal_handler(struct tevent_context *ev,
struct tevent_signal *se,
int signum,
int count,
void *siginfo,
void *private_data)
{
PyObject *callback = (PyObject *)private_data, *ret;
ret = PyObject_CallFunction(callback, "ii", signum, count);
Py_XDECREF(ret);
}
static void py_tevent_signal_dealloc(TeventSignal_Object *self)
{
talloc_free(self->signal);
PyObject_Del(self);
}
static PyTypeObject TeventSignal_Type = {
.tp_name = "tevent.Signal",
.tp_basicsize = sizeof(TeventSignal_Object),
.tp_dealloc = (destructor)py_tevent_signal_dealloc,
.tp_flags = Py_TPFLAGS_DEFAULT,
};
static PyObject *py_tevent_context_add_signal(TeventContext_Object *self, PyObject *args)
{
int signum, sa_flags;
PyObject *handler;
struct tevent_signal *sig;
TeventSignal_Object *ret;
if (!PyArg_ParseTuple(args, "iiO", &signum, &sa_flags, &handler))
return NULL;
Py_INCREF(handler);
sig = tevent_add_signal(self->ev, NULL, signum, sa_flags,
py_tevent_signal_handler, handler);
ret = PyObject_New(TeventSignal_Object, &TeventSignal_Type);
if (ret == NULL) {
PyErr_NoMemory();
talloc_free(sig);
return NULL;
}
ret->signal = sig;
return (PyObject *)ret;
}
static void py_timer_handler(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data)
{
PyObject *callback = private_data, *ret;
ret = PyObject_CallFunction(callback, "l", te);
Py_XDECREF(ret);
}
static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args)
{
TeventTimer_Object *ret;
struct timeval next_event;
struct tevent_timer *timer;
PyObject *handler;
if (!PyArg_ParseTuple(args, "lO", &next_event, &handler))
return NULL;
timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler,
handler);
if (timer == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
ret = PyObject_New(TeventTimer_Object, &TeventTimer_Type);
if (ret == NULL) {
PyErr_NoMemory();
talloc_free(timer);
return NULL;
}
ret->timer = timer;
return (PyObject *)ret;
}
static void py_fd_handler(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
PyObject *callback = private_data, *ret;
ret = PyObject_CallFunction(callback, "i", flags);
Py_XDECREF(ret);
}
static PyObject *py_tevent_context_add_fd(TeventContext_Object *self, PyObject *args)
{
int fd, flags;
PyObject *handler;
struct tevent_fd *tfd;
TeventFd_Object *ret;
if (!PyArg_ParseTuple(args, "iiO", &fd, &flags, &handler))
return NULL;
tfd = tevent_add_fd(self->ev, NULL, fd, flags, py_fd_handler, handler);
if (tfd == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
ret = PyObject_New(TeventFd_Object, &TeventFd_Type);
if (ret == NULL) {
talloc_free(tfd);
return NULL;
}
ret->fd = tfd;
return (PyObject *)ret;
}
#ifdef TEVENT_DEPRECATED
static PyObject *py_tevent_context_set_allow_nesting(TeventContext_Object *self)
{
tevent_loop_allow_nesting(self->ev);
Py_RETURN_NONE;
}
#endif
static PyMethodDef py_tevent_context_methods[] = {
{ "reinitialise", (PyCFunction)py_tevent_context_reinitialise, METH_NOARGS,
"S.reinitialise()" },
{ "wakeup_send", (PyCFunction)py_tevent_context_wakeup_send,
METH_VARARGS, "S.wakeup_send(wakeup_time) -> req" },
{ "loop_wait", (PyCFunction)py_tevent_context_loop_wait,
METH_NOARGS, "S.loop_wait()" },
{ "loop_once", (PyCFunction)py_tevent_context_loop_once,
METH_NOARGS, "S.loop_once()" },
#ifdef TEVENT_DEPRECATED
{ "loop_until", (PyCFunction)py_tevent_context_loop_until,
METH_VARARGS, "S.loop_until(callback)" },
#endif
{ "add_signal", (PyCFunction)py_tevent_context_add_signal,
METH_VARARGS, "S.add_signal(signum, sa_flags, handler) -> signal" },
{ "add_timer", (PyCFunction)py_tevent_context_add_timer,
METH_VARARGS, "S.add_timer(next_event, handler) -> timer" },
{ "add_fd", (PyCFunction)py_tevent_context_add_fd,
METH_VARARGS, "S.add_fd(fd, flags, handler) -> fd" },
#ifdef TEVENT_DEPRECATED
{ "allow_nesting", (PyCFunction)py_tevent_context_set_allow_nesting,
METH_NOARGS, "Whether to allow nested tevent loops." },
#endif
{ NULL },
};
static PyObject *py_tevent_req_wakeup_recv(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_received(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_is_error(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_poll(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_is_in_progress(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyGetSetDef py_tevent_req_getsetters[] = {
{ "in_progress", (getter)py_tevent_req_is_in_progress, NULL,
"Whether the request is in progress" },
{ NULL }
};
static PyObject *py_tevent_req_post(PyObject *self, PyObject *args)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_set_error(PyObject *self, PyObject *args)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_done(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_notify_callback(PyObject *self)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_set_endtime(PyObject *self, PyObject *args)
{
/* FIXME */
Py_RETURN_NONE;
}
static PyObject *py_tevent_req_cancel(TeventReq_Object *self)
{
if (!tevent_req_cancel(self->req)) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
Py_RETURN_NONE;
}
static PyMethodDef py_tevent_req_methods[] = {
{ "wakeup_recv", (PyCFunction)py_tevent_req_wakeup_recv, METH_NOARGS,
"Wakeup received" },
{ "received", (PyCFunction)py_tevent_req_received, METH_NOARGS,
"Receive finished" },
{ "is_error", (PyCFunction)py_tevent_req_is_error, METH_NOARGS,
"is_error() -> (error, state)" },
{ "poll", (PyCFunction)py_tevent_req_poll, METH_VARARGS,
"poll(ctx)" },
{ "post", (PyCFunction)py_tevent_req_post, METH_VARARGS,
"post(ctx) -> req" },
{ "set_error", (PyCFunction)py_tevent_req_set_error, METH_VARARGS,
"set_error(error)" },
{ "done", (PyCFunction)py_tevent_req_done, METH_NOARGS,
"done()" },
{ "notify_callback", (PyCFunction)py_tevent_req_notify_callback,
METH_NOARGS, "notify_callback()" },
{ "set_endtime", (PyCFunction)py_tevent_req_set_endtime,
METH_VARARGS, "set_endtime(ctx, endtime)" },
{ "cancel", (PyCFunction)py_tevent_req_cancel,
METH_NOARGS, "cancel()" },
{ NULL }
};
static void py_tevent_req_dealloc(TeventReq_Object *self)
{
talloc_free(self->req);
PyObject_DEL(self);
}
static PyTypeObject TeventReq_Type = {
.tp_name = "tevent.Request",
.tp_basicsize = sizeof(TeventReq_Object),
.tp_methods = py_tevent_req_methods,
.tp_dealloc = (destructor)py_tevent_req_dealloc,
.tp_getset = py_tevent_req_getsetters,
/* FIXME: .tp_new = py_tevent_req_new, */
};
static PyObject *py_tevent_queue_get_length(TeventQueue_Object *self)
{
return PyInt_FromLong(tevent_queue_length(self->queue));
}
static PyGetSetDef py_tevent_queue_getsetters[] = {
{ "length", (getter)py_tevent_queue_get_length,
NULL, "The number of elements in the queue." },
{ NULL },
};
static void py_tevent_queue_dealloc(TeventQueue_Object *self)
{
talloc_free(self->queue);
PyObject_Del(self);
}
static PyTypeObject TeventQueue_Type = {
.tp_name = "tevent.Queue",
.tp_basicsize = sizeof(TeventQueue_Object),
.tp_dealloc = (destructor)py_tevent_queue_dealloc,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_getset = py_tevent_queue_getsetters,
.tp_methods = py_tevent_queue_methods,
};
static PyObject *py_tevent_context_signal_support(PyObject *_self)
{
TeventContext_Object *self = (TeventContext_Object *)_self;
return PyBool_FromLong(tevent_signal_support(self->ev));
}
static PyGetSetDef py_tevent_context_getsetters[] = {
{ "signal_support", (getter)py_tevent_context_signal_support,
NULL, "if this platform and tevent context support signal handling" },
{ NULL }
};
static void py_tevent_context_dealloc(TeventContext_Object *self)
{
talloc_free(self->ev);
PyObject_Del(self);
}
static PyObject *py_tevent_context_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
const char * const kwnames[] = { "name", NULL };
char *name = NULL;
struct tevent_context *ev;
TeventContext_Object *ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwnames, &name))
return NULL;
if (name == NULL) {
ev = tevent_context_init(NULL);
} else {
ev = tevent_context_init_byname(NULL, name);
}
if (ev == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
return NULL;
}
ret = PyObject_New(TeventContext_Object, type);
if (ret == NULL) {
PyErr_NoMemory();
talloc_free(ev);
return NULL;
}
ret->ev = ev;
return (PyObject *)ret;
}
static PyTypeObject TeventContext_Type = {
.tp_name = "tevent.Context",
.tp_new = py_tevent_context_new,
.tp_basicsize = sizeof(TeventContext_Object),
.tp_dealloc = (destructor)py_tevent_context_dealloc,
.tp_methods = py_tevent_context_methods,
.tp_getset = py_tevent_context_getsetters,
.tp_flags = Py_TPFLAGS_DEFAULT,
};
static PyObject *py_set_default_backend(PyObject *self, PyObject *args)
{
char *backend_name;
if (!PyArg_ParseTuple(args, "s", &backend_name))
return NULL;
tevent_set_default_backend(backend_name);
Py_RETURN_NONE;
}
static PyObject *py_backend_list(PyObject *self)
{
PyObject *ret;
int i;
const char **backends;
ret = PyList_New(0);
if (ret == NULL) {
return NULL;
}
backends = tevent_backend_list(NULL);
if (backends == NULL) {
PyErr_SetNone(PyExc_RuntimeError);
Py_DECREF(ret);
return NULL;
}
for (i = 0; backends[i]; i++) {
PyList_Append(ret, PyString_FromString(backends[i]));
}
talloc_free(backends);
return ret;
}
static PyMethodDef tevent_methods[] = {
{ "register_backend", (PyCFunction)py_register_backend, METH_VARARGS,
"register_backend(backend)" },
{ "set_default_backend", (PyCFunction)py_set_default_backend,
METH_VARARGS, "set_default_backend(backend)" },
{ "backend_list", (PyCFunction)py_backend_list,
METH_NOARGS, "backend_list() -> list" },
{ NULL },
};
void init_tevent(void)
{
PyObject *m;
if (PyType_Ready(&TeventContext_Type) < 0)
return;
if (PyType_Ready(&TeventQueue_Type) < 0)
return;
if (PyType_Ready(&TeventReq_Type) < 0)
return;
if (PyType_Ready(&TeventSignal_Type) < 0)
return;
if (PyType_Ready(&TeventTimer_Type) < 0)
return;
if (PyType_Ready(&TeventFd_Type) < 0)
return;
m = Py_InitModule3("_tevent", tevent_methods, "Tevent integration for twisted.");
if (m == NULL)
return;
Py_INCREF(&TeventContext_Type);
PyModule_AddObject(m, "Context", (PyObject *)&TeventContext_Type);
Py_INCREF(&TeventQueue_Type);
PyModule_AddObject(m, "Queue", (PyObject *)&TeventQueue_Type);
Py_INCREF(&TeventReq_Type);
PyModule_AddObject(m, "Request", (PyObject *)&TeventReq_Type);
Py_INCREF(&TeventSignal_Type);
PyModule_AddObject(m, "Signal", (PyObject *)&TeventSignal_Type);
Py_INCREF(&TeventTimer_Type);
PyModule_AddObject(m, "Timer", (PyObject *)&TeventTimer_Type);
Py_INCREF(&TeventFd_Type);
PyModule_AddObject(m, "Fd", (PyObject *)&TeventFd_Type);
PyModule_AddObject(m, "__version__", PyString_FromString(PACKAGE_VERSION));
}
tevent-0.9.19/release-script.sh 0000770 0000000 0000000 00000002202 11741275274 016341 0 ustar root root 0000000 0000000 #!/bin/bash
if [ "$1" = "" ]; then
echo "Please provide version string, eg: 1.2.0"
exit 1
fi
if [ ! -d "lib/tevent" ]; then
echo "Run this script from the samba base directory."
exit 1
fi
git clean -f -x -d lib/tevent
git clean -f -x -d lib/replace
curbranch=`git-branch |grep "^*" | tr -d "* "`
version=$1
strver=`echo ${version} | tr "." "-"`
# Checkout the release tag
git branch -f tevent-release-script-${strver} tevent-${strver}
if [ ! "$?" = "0" ]; then
echo "Unable to checkout tevent-${strver} release"
exit 1
fi
git checkout tevent-release-script-${strver}
# Test configure agrees with us
confver=`grep "^AC_INIT" lib/tevent/configure.ac | tr -d "AC_INIT(tevent, " | tr -d ")"`
if [ ! "$confver" = "$version" ]; then
echo "Wrong version, requested release for ${version}, found ${confver}"
exit 1
fi
# Now build tarball
cp -a lib/tevent tevent-${version}
cp -a lib/replace tevent-${version}/libreplace
pushd tevent-${version}
./autogen.sh
popd
tar cvzf tevent-${version}.tar.gz tevent-${version}
rm -fr tevent-${version}
#Clean up
git checkout $curbranch
git branch -d tevent-release-script-${strver}
tevent-0.9.19/testsuite.c 0000660 0000000 0000000 00000047017 12153373752 015271 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
testing of the events subsystem
Copyright (C) Stefan Metzmacher 2006-2009
Copyright (C) Jeremy Allison 2013
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "includes.h"
#include "lib/tevent/tevent.h"
#include "system/filesys.h"
#include "system/select.h"
#include "system/network.h"
#include "torture/torture.h"
#ifdef HAVE_PTHREAD
#include
#include
#endif
static int fde_count;
static void fde_handler_read(struct tevent_context *ev_ctx, struct tevent_fd *f,
uint16_t flags, void *private_data)
{
int *fd = (int *)private_data;
char c;
#ifdef SA_SIGINFO
kill(getpid(), SIGUSR1);
#endif
kill(getpid(), SIGALRM);
read(fd[0], &c, 1);
fde_count++;
}
static void fde_handler_write(struct tevent_context *ev_ctx, struct tevent_fd *f,
uint16_t flags, void *private_data)
{
int *fd = (int *)private_data;
char c = 0;
write(fd[1], &c, 1);
}
/* This will only fire if the fd's returned from pipe() are bi-directional. */
static void fde_handler_read_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
uint16_t flags, void *private_data)
{
int *fd = (int *)private_data;
char c;
#ifdef SA_SIGINFO
kill(getpid(), SIGUSR1);
#endif
kill(getpid(), SIGALRM);
read(fd[1], &c, 1);
fde_count++;
}
/* This will only fire if the fd's returned from pipe() are bi-directional. */
static void fde_handler_write_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
uint16_t flags, void *private_data)
{
int *fd = (int *)private_data;
char c = 0;
write(fd[0], &c, 1);
}
static void finished_handler(struct tevent_context *ev_ctx, struct tevent_timer *te,
struct timeval tval, void *private_data)
{
int *finished = (int *)private_data;
(*finished) = 1;
}
static void count_handler(struct tevent_context *ev_ctx, struct tevent_signal *te,
int signum, int count, void *info, void *private_data)
{
int *countp = (int *)private_data;
(*countp) += count;
}
static bool test_event_context(struct torture_context *test,
const void *test_data)
{
struct tevent_context *ev_ctx;
int fd[2] = { -1, -1 };
const char *backend = (const char *)test_data;
int alarm_count=0, info_count=0;
struct tevent_fd *fde_read;
struct tevent_fd *fde_read_1;
struct tevent_fd *fde_write;
struct tevent_fd *fde_write_1;
#ifdef SA_RESTART
struct tevent_signal *se1 = NULL;
#endif
#ifdef SA_RESETHAND
struct tevent_signal *se2 = NULL;
#endif
#ifdef SA_SIGINFO
struct tevent_signal *se3 = NULL;
#endif
int finished=0;
struct timeval t;
ev_ctx = tevent_context_init_byname(test, backend);
if (ev_ctx == NULL) {
torture_comment(test, "event backend '%s' not supported\n", backend);
return true;
}
torture_comment(test, "backend '%s' - %s\n",
backend, __FUNCTION__);
/* reset globals */
fde_count = 0;
/* create a pipe */
pipe(fd);
fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_READ,
fde_handler_read, fd);
fde_write_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_WRITE,
fde_handler_write_1, fd);
fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_WRITE,
fde_handler_write, fd);
fde_read_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_READ,
fde_handler_read_1, fd);
tevent_fd_set_auto_close(fde_read);
tevent_fd_set_auto_close(fde_write);
tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(2,0),
finished_handler, &finished);
#ifdef SA_RESTART
se1 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
torture_assert(test, se1 != NULL, "failed to setup se1");
#endif
#ifdef SA_RESETHAND
se2 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
torture_assert(test, se2 != NULL, "failed to setup se2");
#endif
#ifdef SA_SIGINFO
se3 = tevent_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
torture_assert(test, se3 != NULL, "failed to setup se3");
#endif
t = timeval_current();
while (!finished) {
errno = 0;
if (tevent_loop_once(ev_ctx) == -1) {
talloc_free(ev_ctx);
torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
}
}
talloc_free(fde_read);
talloc_free(fde_write);
talloc_free(fde_read_1);
talloc_free(fde_write_1);
while (alarm_count < fde_count+1) {
if (tevent_loop_once(ev_ctx) == -1) {
break;
}
}
torture_comment(test, "Got %.2f pipe events/sec\n", fde_count/timeval_elapsed(&t));
#ifdef SA_RESTART
talloc_free(se1);
#endif
torture_assert_int_equal(test, alarm_count, 1+fde_count, "alarm count mismatch");
#ifdef SA_RESETHAND
/*
* we do not call talloc_free(se2)
* because it is already gone,
* after triggering the event handler.
*/
#endif
#ifdef SA_SIGINFO
talloc_free(se3);
torture_assert_int_equal(test, info_count, fde_count, "info count mismatch");
#endif
talloc_free(ev_ctx);
return true;
}
struct test_event_fd1_state {
struct torture_context *tctx;
const char *backend;
struct tevent_context *ev;
int sock[2];
struct tevent_timer *te;
struct tevent_fd *fde0;
struct tevent_fd *fde1;
bool got_write;
bool got_read;
bool drain;
bool drain_done;
unsigned loop_count;
bool finished;
const char *error;
};
static void test_event_fd1_fde_handler(struct tevent_context *ev_ctx,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
struct test_event_fd1_state *state =
(struct test_event_fd1_state *)private_data;
if (state->drain_done) {
state->finished = true;
state->error = __location__;
return;
}
if (state->drain) {
ssize_t ret;
uint8_t c = 0;
if (!(flags & TEVENT_FD_READ)) {
state->finished = true;
state->error = __location__;
return;
}
ret = read(state->sock[0], &c, 1);
if (ret == 1) {
return;
}
/*
* end of test...
*/
tevent_fd_set_flags(fde, 0);
state->drain_done = true;
return;
}
if (!state->got_write) {
uint8_t c = 0;
if (flags != TEVENT_FD_WRITE) {
state->finished = true;
state->error = __location__;
return;
}
state->got_write = true;
/*
* we write to the other socket...
*/
write(state->sock[1], &c, 1);
TEVENT_FD_NOT_WRITEABLE(fde);
TEVENT_FD_READABLE(fde);
return;
}
if (!state->got_read) {
if (flags != TEVENT_FD_READ) {
state->finished = true;
state->error = __location__;
return;
}
state->got_read = true;
TEVENT_FD_NOT_READABLE(fde);
return;
}
state->finished = true;
state->error = __location__;
return;
}
static void test_event_fd1_finished(struct tevent_context *ev_ctx,
struct tevent_timer *te,
struct timeval tval,
void *private_data)
{
struct test_event_fd1_state *state =
(struct test_event_fd1_state *)private_data;
if (state->drain_done) {
state->finished = true;
return;
}
if (!state->got_write) {
state->finished = true;
state->error = __location__;
return;
}
if (!state->got_read) {
state->finished = true;
state->error = __location__;
return;
}
state->loop_count++;
if (state->loop_count > 3) {
state->finished = true;
state->error = __location__;
return;
}
state->got_write = false;
state->got_read = false;
tevent_fd_set_flags(state->fde0, TEVENT_FD_WRITE);
if (state->loop_count > 2) {
state->drain = true;
TALLOC_FREE(state->fde1);
TEVENT_FD_READABLE(state->fde0);
}
state->te = tevent_add_timer(state->ev, state->ev,
timeval_current_ofs(0,2000),
test_event_fd1_finished, state);
}
static bool test_event_fd1(struct torture_context *tctx,
const void *test_data)
{
struct test_event_fd1_state state;
ZERO_STRUCT(state);
state.tctx = tctx;
state.backend = (const char *)test_data;
state.ev = tevent_context_init_byname(tctx, state.backend);
if (state.ev == NULL) {
torture_skip(tctx, talloc_asprintf(tctx,
"event backend '%s' not supported\n",
state.backend));
return true;
}
tevent_set_debug_stderr(state.ev);
torture_comment(tctx, "backend '%s' - %s\n",
state.backend, __FUNCTION__);
/*
* This tests the following:
*
* It monitors the state of state.sock[0]
* with tevent_fd, but we never read/write on state.sock[0]
* while state.sock[1] * is only used to write a few bytes.
*
* We have a loop:
* - we wait only for TEVENT_FD_WRITE on state.sock[0]
* - we write 1 byte to state.sock[1]
* - we wait only for TEVENT_FD_READ on state.sock[0]
* - we disable events on state.sock[0]
* - the timer event restarts the loop
* Then we close state.sock[1]
* We have a loop:
* - we wait for TEVENT_FD_READ/WRITE on state.sock[0]
* - we try to read 1 byte
* - if the read gets an error of returns 0
* we disable the event handler
* - the timer finishes the test
*/
state.sock[0] = -1;
state.sock[1] = -1;
socketpair(AF_UNIX, SOCK_STREAM, 0, state.sock);
state.te = tevent_add_timer(state.ev, state.ev,
timeval_current_ofs(0,1000),
test_event_fd1_finished, &state);
state.fde0 = tevent_add_fd(state.ev, state.ev,
state.sock[0], TEVENT_FD_WRITE,
test_event_fd1_fde_handler, &state);
/* state.fde1 is only used to auto close */
state.fde1 = tevent_add_fd(state.ev, state.ev,
state.sock[1], 0,
test_event_fd1_fde_handler, &state);
tevent_fd_set_auto_close(state.fde0);
tevent_fd_set_auto_close(state.fde1);
while (!state.finished) {
errno = 0;
if (tevent_loop_once(state.ev) == -1) {
talloc_free(state.ev);
torture_fail(tctx, talloc_asprintf(tctx,
"Failed event loop %s\n",
strerror(errno)));
}
}
talloc_free(state.ev);
torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
"%s", state.error));
return true;
}
struct test_event_fd2_state {
struct torture_context *tctx;
const char *backend;
struct tevent_context *ev;
struct tevent_timer *te;
struct test_event_fd2_sock {
struct test_event_fd2_state *state;
int fd;
struct tevent_fd *fde;
size_t num_written;
size_t num_read;
bool got_full;
} sock0, sock1;
bool finished;
const char *error;
};
static void test_event_fd2_sock_handler(struct tevent_context *ev_ctx,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
struct test_event_fd2_sock *cur_sock =
(struct test_event_fd2_sock *)private_data;
struct test_event_fd2_state *state = cur_sock->state;
struct test_event_fd2_sock *oth_sock = NULL;
uint8_t v = 0, c;
ssize_t ret;
if (cur_sock == &state->sock0) {
oth_sock = &state->sock1;
} else {
oth_sock = &state->sock0;
}
if (oth_sock->num_written == 1) {
if (flags != (TEVENT_FD_READ | TEVENT_FD_WRITE)) {
state->finished = true;
state->error = __location__;
return;
}
}
if (cur_sock->num_read == oth_sock->num_written) {
state->finished = true;
state->error = __location__;
return;
}
if (!(flags & TEVENT_FD_READ)) {
state->finished = true;
state->error = __location__;
return;
}
if (oth_sock->num_read >= PIPE_BUF) {
/*
* On Linux we become writable once we've read
* one byte. On Solaris we only become writable
* again once we've read 4096 bytes. PIPE_BUF
* is probably a safe bet to test against.
*
* There should be room to write a byte again
*/
if (!(flags & TEVENT_FD_WRITE)) {
state->finished = true;
state->error = __location__;
return;
}
}
if ((flags & TEVENT_FD_WRITE) && !cur_sock->got_full) {
v = (uint8_t)cur_sock->num_written;
ret = write(cur_sock->fd, &v, 1);
if (ret != 1) {
state->finished = true;
state->error = __location__;
return;
}
cur_sock->num_written++;
if (cur_sock->num_written > 0x80000000) {
state->finished = true;
state->error = __location__;
return;
}
return;
}
if (!cur_sock->got_full) {
cur_sock->got_full = true;
if (!oth_sock->got_full) {
/*
* cur_sock is full,
* lets wait for oth_sock
* to be filled
*/
tevent_fd_set_flags(cur_sock->fde, 0);
return;
}
/*
* oth_sock waited for cur_sock,
* lets restart it
*/
tevent_fd_set_flags(oth_sock->fde,
TEVENT_FD_READ|TEVENT_FD_WRITE);
}
ret = read(cur_sock->fd, &v, 1);
if (ret != 1) {
state->finished = true;
state->error = __location__;
return;
}
c = (uint8_t)cur_sock->num_read;
if (c != v) {
state->finished = true;
state->error = __location__;
return;
}
cur_sock->num_read++;
if (cur_sock->num_read < oth_sock->num_written) {
/* there is more to read */
return;
}
/*
* we read everything, we need to remove TEVENT_FD_WRITE
* to avoid spinning
*/
TEVENT_FD_NOT_WRITEABLE(cur_sock->fde);
if (oth_sock->num_read == cur_sock->num_written) {
/*
* both directions are finished
*/
state->finished = true;
}
return;
}
static void test_event_fd2_finished(struct tevent_context *ev_ctx,
struct tevent_timer *te,
struct timeval tval,
void *private_data)
{
struct test_event_fd2_state *state =
(struct test_event_fd2_state *)private_data;
/*
* this should never be triggered
*/
state->finished = true;
state->error = __location__;
}
static bool test_event_fd2(struct torture_context *tctx,
const void *test_data)
{
struct test_event_fd2_state state;
int sock[2];
uint8_t c = 0;
ZERO_STRUCT(state);
state.tctx = tctx;
state.backend = (const char *)test_data;
state.ev = tevent_context_init_byname(tctx, state.backend);
if (state.ev == NULL) {
torture_skip(tctx, talloc_asprintf(tctx,
"event backend '%s' not supported\n",
state.backend));
return true;
}
tevent_set_debug_stderr(state.ev);
torture_comment(tctx, "backend '%s' - %s\n",
state.backend, __FUNCTION__);
/*
* This tests the following
*
* - We write 1 byte to each socket
* - We wait for TEVENT_FD_READ/WRITE on both sockets
* - When we get TEVENT_FD_WRITE we write 1 byte
* until both socket buffers are full, which
* means both sockets only get TEVENT_FD_READ.
* - Then we read 1 byte until we have consumed
* all bytes the other end has written.
*/
sock[0] = -1;
sock[1] = -1;
socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
/*
* the timer should never expire
*/
state.te = tevent_add_timer(state.ev, state.ev,
timeval_current_ofs(600, 0),
test_event_fd2_finished, &state);
state.sock0.state = &state;
state.sock0.fd = sock[0];
state.sock0.fde = tevent_add_fd(state.ev, state.ev,
state.sock0.fd,
TEVENT_FD_READ | TEVENT_FD_WRITE,
test_event_fd2_sock_handler,
&state.sock0);
state.sock1.state = &state;
state.sock1.fd = sock[1];
state.sock1.fde = tevent_add_fd(state.ev, state.ev,
state.sock1.fd,
TEVENT_FD_READ | TEVENT_FD_WRITE,
test_event_fd2_sock_handler,
&state.sock1);
tevent_fd_set_auto_close(state.sock0.fde);
tevent_fd_set_auto_close(state.sock1.fde);
write(state.sock0.fd, &c, 1);
state.sock0.num_written++;
write(state.sock1.fd, &c, 1);
state.sock1.num_written++;
while (!state.finished) {
errno = 0;
if (tevent_loop_once(state.ev) == -1) {
talloc_free(state.ev);
torture_fail(tctx, talloc_asprintf(tctx,
"Failed event loop %s\n",
strerror(errno)));
}
}
talloc_free(state.ev);
torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
"%s", state.error));
return true;
}
#ifdef HAVE_PTHREAD
static pthread_mutex_t threaded_mutex = PTHREAD_MUTEX_INITIALIZER;
static bool do_shutdown = false;
static void test_event_threaded_lock(void)
{
int ret;
ret = pthread_mutex_lock(&threaded_mutex);
assert(ret == 0);
}
static void test_event_threaded_unlock(void)
{
int ret;
ret = pthread_mutex_unlock(&threaded_mutex);
assert(ret == 0);
}
static void test_event_threaded_trace(enum tevent_trace_point point,
void *private_data)
{
switch (point) {
case TEVENT_TRACE_BEFORE_WAIT:
test_event_threaded_unlock();
break;
case TEVENT_TRACE_AFTER_WAIT:
test_event_threaded_lock();
break;
case TEVENT_TRACE_BEFORE_LOOP_ONCE:
case TEVENT_TRACE_AFTER_LOOP_ONCE:
break;
}
}
static void test_event_threaded_timer(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data)
{
return;
}
static void *test_event_poll_thread(void *private_data)
{
struct tevent_context *ev = (struct tevent_context *)private_data;
test_event_threaded_lock();
while (true) {
int ret;
ret = tevent_loop_once(ev);
assert(ret == 0);
if (do_shutdown) {
test_event_threaded_unlock();
return NULL;
}
}
}
static void test_event_threaded_read_handler(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
int *pfd = (int *)private_data;
char c;
ssize_t nread;
if ((flags & TEVENT_FD_READ) == 0) {
return;
}
do {
nread = read(*pfd, &c, 1);
} while ((nread == -1) && (errno == EINTR));
assert(nread == 1);
}
static bool test_event_context_threaded(struct torture_context *test,
const void *test_data)
{
struct tevent_context *ev;
struct tevent_timer *te;
struct tevent_fd *fde;
pthread_t poll_thread;
int fds[2];
int ret;
char c = 0;
ev = tevent_context_init_byname(test, "poll_mt");
torture_assert(test, ev != NULL, "poll_mt not supported");
tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);
te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),
test_event_threaded_timer, NULL);
torture_assert(test, te != NULL, "Could not add timer");
ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);
torture_assert(test, ret == 0, "Could not create poll thread");
ret = pipe(fds);
torture_assert(test, ret == 0, "Could not create pipe");
poll(NULL, 0, 100);
test_event_threaded_lock();
fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,
test_event_threaded_read_handler, &fds[0]);
torture_assert(test, fde != NULL, "Could not add fd event");
test_event_threaded_unlock();
poll(NULL, 0, 100);
write(fds[1], &c, 1);
poll(NULL, 0, 100);
test_event_threaded_lock();
do_shutdown = true;
test_event_threaded_unlock();
write(fds[1], &c, 1);
ret = pthread_join(poll_thread, NULL);
torture_assert(test, ret == 0, "pthread_join failed");
return true;
}
#endif
struct torture_suite *torture_local_event(TALLOC_CTX *mem_ctx)
{
struct torture_suite *suite = torture_suite_create(mem_ctx, "event");
const char **list = tevent_backend_list(suite);
int i;
for (i=0;list && list[i];i++) {
struct torture_suite *backend_suite;
backend_suite = torture_suite_create(mem_ctx, list[i]);
torture_suite_add_simple_tcase_const(backend_suite,
"context",
test_event_context,
(const void *)list[i]);
torture_suite_add_simple_tcase_const(backend_suite,
"fd1",
test_event_fd1,
(const void *)list[i]);
torture_suite_add_simple_tcase_const(backend_suite,
"fd2",
test_event_fd2,
(const void *)list[i]);
torture_suite_add_suite(suite, backend_suite);
}
#ifdef HAVE_PTHREAD
torture_suite_add_simple_tcase_const(suite, "threaded_poll_mt",
test_event_context_threaded,
NULL);
#endif
return suite;
}
tevent-0.9.19/tevent.c 0000660 0000000 0000000 00000037154 12153373752 014546 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
main select loop and event handling
Copyright (C) Andrew Tridgell 2003
Copyright (C) Stefan Metzmacher 2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
/*
PLEASE READ THIS BEFORE MODIFYING!
This module is a general abstraction for the main select loop and
event handling. Do not ever put any localised hacks in here, instead
register one of the possible event types and implement that event
somewhere else.
There are 2 types of event handling that are handled in this module:
1) a file descriptor becoming readable or writeable. This is mostly
used for network sockets, but can be used for any type of file
descriptor. You may only register one handler for each file
descriptor/io combination or you will get unpredictable results
(this means that you can have a handler for read events, and a
separate handler for write events, but not two handlers that are
both handling read events)
2) a timed event. You can register an event that happens at a
specific time. You can register as many of these as you
like. They are single shot - add a new timed event in the event
handler to get another event.
To setup a set of events you first need to create a event_context
structure using the function tevent_context_init(); This returns a
'struct tevent_context' that you use in all subsequent calls.
After that you can add/remove events that you are interested in
using tevent_add_*() and talloc_free()
Finally, you call tevent_loop_wait_once() to block waiting for one of the
events to occor or tevent_loop_wait() which will loop
forever.
*/
#include "replace.h"
#include "system/filesys.h"
#define TEVENT_DEPRECATED 1
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
struct tevent_ops_list {
struct tevent_ops_list *next, *prev;
const char *name;
const struct tevent_ops *ops;
};
/* list of registered event backends */
static struct tevent_ops_list *tevent_backends = NULL;
static char *tevent_default_backend = NULL;
/*
register an events backend
*/
bool tevent_register_backend(const char *name, const struct tevent_ops *ops)
{
struct tevent_ops_list *e;
for (e = tevent_backends; e != NULL; e = e->next) {
if (0 == strcmp(e->name, name)) {
/* already registered, skip it */
return true;
}
}
e = talloc(NULL, struct tevent_ops_list);
if (e == NULL) return false;
e->name = name;
e->ops = ops;
DLIST_ADD(tevent_backends, e);
return true;
}
/*
set the default event backend
*/
void tevent_set_default_backend(const char *backend)
{
talloc_free(tevent_default_backend);
tevent_default_backend = talloc_strdup(NULL, backend);
}
/*
initialise backends if not already done
*/
static void tevent_backend_init(void)
{
static bool done;
if (done) {
return;
}
done = true;
tevent_select_init();
tevent_poll_init();
tevent_poll_mt_init();
#ifdef HAVE_EPOLL
tevent_epoll_init();
#endif
tevent_standard_init();
}
_PRIVATE_ const struct tevent_ops *tevent_find_ops_byname(const char *name)
{
struct tevent_ops_list *e;
tevent_backend_init();
if (name == NULL) {
name = tevent_default_backend;
}
if (name == NULL) {
name = "standard";
}
for (e = tevent_backends; e != NULL; e = e->next) {
if (0 == strcmp(e->name, name)) {
return e->ops;
}
}
return NULL;
}
/*
list available backends
*/
const char **tevent_backend_list(TALLOC_CTX *mem_ctx)
{
const char **list = NULL;
struct tevent_ops_list *e;
tevent_backend_init();
for (e=tevent_backends;e;e=e->next) {
list = ev_str_list_add(list, e->name);
}
talloc_steal(mem_ctx, list);
return list;
}
int tevent_common_context_destructor(struct tevent_context *ev)
{
struct tevent_fd *fd, *fn;
struct tevent_timer *te, *tn;
struct tevent_immediate *ie, *in;
struct tevent_signal *se, *sn;
if (ev->pipe_fde) {
talloc_free(ev->pipe_fde);
close(ev->pipe_fds[0]);
close(ev->pipe_fds[1]);
ev->pipe_fde = NULL;
}
for (fd = ev->fd_events; fd; fd = fn) {
fn = fd->next;
fd->event_ctx = NULL;
DLIST_REMOVE(ev->fd_events, fd);
}
ev->last_zero_timer = NULL;
for (te = ev->timer_events; te; te = tn) {
tn = te->next;
te->event_ctx = NULL;
DLIST_REMOVE(ev->timer_events, te);
}
for (ie = ev->immediate_events; ie; ie = in) {
in = ie->next;
ie->event_ctx = NULL;
ie->cancel_fn = NULL;
DLIST_REMOVE(ev->immediate_events, ie);
}
for (se = ev->signal_events; se; se = sn) {
sn = se->next;
se->event_ctx = NULL;
DLIST_REMOVE(ev->signal_events, se);
/*
* This is important, Otherwise signals
* are handled twice in child. eg, SIGHUP.
* one added in parent, and another one in
* the child. -- BoYang
*/
tevent_cleanup_pending_signal_handlers(se);
}
/* removing nesting hook or we get an abort when nesting is
* not allowed. -- SSS
* Note that we need to leave the allowed flag at its current
* value, otherwise the use in tevent_re_initialise() will
* leave the event context with allowed forced to false, which
* will break users that expect nesting to be allowed
*/
ev->nesting.level = 0;
ev->nesting.hook_fn = NULL;
ev->nesting.hook_private = NULL;
return 0;
}
/*
create a event_context structure for a specific implemementation.
This must be the first events call, and all subsequent calls pass
this event_context as the first element. Event handlers also
receive this as their first argument.
This function is for allowing third-party-applications to hook in gluecode
to their own event loop code, so that they can make async usage of our client libs
NOTE: use tevent_context_init() inside of samba!
*/
struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
const struct tevent_ops *ops,
void *additional_data)
{
struct tevent_context *ev;
int ret;
ev = talloc_zero(mem_ctx, struct tevent_context);
if (!ev) return NULL;
talloc_set_destructor(ev, tevent_common_context_destructor);
ev->ops = ops;
ev->additional_data = additional_data;
ret = ev->ops->context_init(ev);
if (ret != 0) {
talloc_free(ev);
return NULL;
}
return ev;
}
/*
create a event_context structure. This must be the first events
call, and all subsequent calls pass this event_context as the first
element. Event handlers also receive this as their first argument.
*/
struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx,
const char *name)
{
const struct tevent_ops *ops;
ops = tevent_find_ops_byname(name);
if (ops == NULL) {
return NULL;
}
return tevent_context_init_ops(mem_ctx, ops, NULL);
}
/*
create a event_context structure. This must be the first events
call, and all subsequent calls pass this event_context as the first
element. Event handlers also receive this as their first argument.
*/
struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx)
{
return tevent_context_init_byname(mem_ctx, NULL);
}
/*
add a fd based event
return NULL on failure (memory allocation error)
*/
struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd,
uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
return ev->ops->add_fd(ev, mem_ctx, fd, flags, handler, private_data,
handler_name, location);
}
/*
set a close function on the fd event
*/
void tevent_fd_set_close_fn(struct tevent_fd *fde,
tevent_fd_close_fn_t close_fn)
{
if (!fde) return;
if (!fde->event_ctx) return;
fde->event_ctx->ops->set_fd_close_fn(fde, close_fn);
}
static void tevent_fd_auto_close_fn(struct tevent_context *ev,
struct tevent_fd *fde,
int fd,
void *private_data)
{
close(fd);
}
void tevent_fd_set_auto_close(struct tevent_fd *fde)
{
tevent_fd_set_close_fn(fde, tevent_fd_auto_close_fn);
}
/*
return the fd event flags
*/
uint16_t tevent_fd_get_flags(struct tevent_fd *fde)
{
if (!fde) return 0;
if (!fde->event_ctx) return 0;
return fde->event_ctx->ops->get_fd_flags(fde);
}
/*
set the fd event flags
*/
void tevent_fd_set_flags(struct tevent_fd *fde, uint16_t flags)
{
if (!fde) return;
if (!fde->event_ctx) return;
fde->event_ctx->ops->set_fd_flags(fde, flags);
}
bool tevent_signal_support(struct tevent_context *ev)
{
if (ev->ops->add_signal) {
return true;
}
return false;
}
static void (*tevent_abort_fn)(const char *reason);
void tevent_set_abort_fn(void (*abort_fn)(const char *reason))
{
tevent_abort_fn = abort_fn;
}
static void tevent_abort(struct tevent_context *ev, const char *reason)
{
tevent_debug(ev, TEVENT_DEBUG_FATAL,
"abort: %s\n", reason);
if (!tevent_abort_fn) {
abort();
}
tevent_abort_fn(reason);
}
/*
add a timer event
return NULL on failure
*/
struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
return ev->ops->add_timer(ev, mem_ctx, next_event, handler, private_data,
handler_name, location);
}
/*
allocate an immediate event
return NULL on failure (memory allocation error)
*/
struct tevent_immediate *_tevent_create_immediate(TALLOC_CTX *mem_ctx,
const char *location)
{
struct tevent_immediate *im;
im = talloc(mem_ctx, struct tevent_immediate);
if (im == NULL) return NULL;
im->prev = NULL;
im->next = NULL;
im->event_ctx = NULL;
im->create_location = location;
im->handler = NULL;
im->private_data = NULL;
im->handler_name = NULL;
im->schedule_location = NULL;
im->cancel_fn = NULL;
im->additional_data = NULL;
return im;
}
/*
schedule an immediate event
*/
void _tevent_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ev,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
ev->ops->schedule_immediate(im, ev, handler, private_data,
handler_name, location);
}
/*
add a signal event
sa_flags are flags to sigaction(2)
return NULL on failure
*/
struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum,
int sa_flags,
tevent_signal_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
return ev->ops->add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data,
handler_name, location);
}
void tevent_loop_allow_nesting(struct tevent_context *ev)
{
ev->nesting.allowed = true;
}
void tevent_loop_set_nesting_hook(struct tevent_context *ev,
tevent_nesting_hook hook,
void *private_data)
{
if (ev->nesting.hook_fn &&
(ev->nesting.hook_fn != hook ||
ev->nesting.hook_private != private_data)) {
/* the way the nesting hook code is currently written
we cannot support two different nesting hooks at the
same time. */
tevent_abort(ev, "tevent: Violation of nesting hook rules\n");
}
ev->nesting.hook_fn = hook;
ev->nesting.hook_private = private_data;
}
static void tevent_abort_nesting(struct tevent_context *ev, const char *location)
{
const char *reason;
reason = talloc_asprintf(NULL, "tevent_loop_once() nesting at %s",
location);
if (!reason) {
reason = "tevent_loop_once() nesting";
}
tevent_abort(ev, reason);
}
/*
do a single event loop using the events defined in ev
*/
int _tevent_loop_once(struct tevent_context *ev, const char *location)
{
int ret;
void *nesting_stack_ptr = NULL;
ev->nesting.level++;
if (ev->nesting.level > 1) {
if (!ev->nesting.allowed) {
tevent_abort_nesting(ev, location);
errno = ELOOP;
return -1;
}
}
if (ev->nesting.level > 0) {
if (ev->nesting.hook_fn) {
int ret2;
ret2 = ev->nesting.hook_fn(ev,
ev->nesting.hook_private,
ev->nesting.level,
true,
(void *)&nesting_stack_ptr,
location);
if (ret2 != 0) {
ret = ret2;
goto done;
}
}
}
tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_LOOP_ONCE);
ret = ev->ops->loop_once(ev, location);
tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_LOOP_ONCE);
if (ev->nesting.level > 0) {
if (ev->nesting.hook_fn) {
int ret2;
ret2 = ev->nesting.hook_fn(ev,
ev->nesting.hook_private,
ev->nesting.level,
false,
(void *)&nesting_stack_ptr,
location);
if (ret2 != 0) {
ret = ret2;
goto done;
}
}
}
done:
ev->nesting.level--;
return ret;
}
/*
this is a performance optimization for the samba4 nested event loop problems
*/
int _tevent_loop_until(struct tevent_context *ev,
bool (*finished)(void *private_data),
void *private_data,
const char *location)
{
int ret = 0;
void *nesting_stack_ptr = NULL;
ev->nesting.level++;
if (ev->nesting.level > 1) {
if (!ev->nesting.allowed) {
tevent_abort_nesting(ev, location);
errno = ELOOP;
return -1;
}
}
if (ev->nesting.level > 0) {
if (ev->nesting.hook_fn) {
int ret2;
ret2 = ev->nesting.hook_fn(ev,
ev->nesting.hook_private,
ev->nesting.level,
true,
(void *)&nesting_stack_ptr,
location);
if (ret2 != 0) {
ret = ret2;
goto done;
}
}
}
while (!finished(private_data)) {
tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_LOOP_ONCE);
ret = ev->ops->loop_once(ev, location);
tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_LOOP_ONCE);
if (ret != 0) {
break;
}
}
if (ev->nesting.level > 0) {
if (ev->nesting.hook_fn) {
int ret2;
ret2 = ev->nesting.hook_fn(ev,
ev->nesting.hook_private,
ev->nesting.level,
false,
(void *)&nesting_stack_ptr,
location);
if (ret2 != 0) {
ret = ret2;
goto done;
}
}
}
done:
ev->nesting.level--;
return ret;
}
/*
return on failure or (with 0) if all fd events are removed
*/
int tevent_common_loop_wait(struct tevent_context *ev,
const char *location)
{
/*
* loop as long as we have events pending
*/
while (ev->fd_events ||
ev->timer_events ||
ev->immediate_events ||
ev->signal_events) {
int ret;
ret = _tevent_loop_once(ev, location);
if (ret != 0) {
tevent_debug(ev, TEVENT_DEBUG_FATAL,
"_tevent_loop_once() failed: %d - %s\n",
ret, strerror(errno));
return ret;
}
}
tevent_debug(ev, TEVENT_DEBUG_WARNING,
"tevent_common_loop_wait() out of events\n");
return 0;
}
/*
return on failure or (with 0) if all fd events are removed
*/
int _tevent_loop_wait(struct tevent_context *ev, const char *location)
{
return ev->ops->loop_wait(ev, location);
}
/*
re-initialise a tevent context. This leaves you with the same
event context, but all events are wiped and the structure is
re-initialised. This is most useful after a fork()
zero is returned on success, non-zero on failure
*/
int tevent_re_initialise(struct tevent_context *ev)
{
tevent_common_context_destructor(ev);
return ev->ops->context_init(ev);
}
tevent-0.9.19/tevent.h 0000660 0000000 0000000 00000151623 12176475205 014552 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
generalised event loop handling
Copyright (C) Andrew Tridgell 2005
Copyright (C) Stefan Metzmacher 2005-2009
Copyright (C) Volker Lendecke 2008
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifndef __TEVENT_H__
#define __TEVENT_H__
#include
#include
#include
#include
struct tevent_context;
struct tevent_ops;
struct tevent_fd;
struct tevent_timer;
struct tevent_immediate;
struct tevent_signal;
/**
* @defgroup tevent The tevent API
*
* The tevent low-level API
*
* This API provides the public interface to manage events in the tevent
* mainloop. Functions are provided for managing low-level events such
* as timer events, fd events and signal handling.
*
* @{
*/
/* event handler types */
/**
* Called when a file descriptor monitored by tevent has
* data to be read or written on it.
*/
typedef void (*tevent_fd_handler_t)(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data);
/**
* Called when tevent is ceasing the monitoring of a file descriptor.
*/
typedef void (*tevent_fd_close_fn_t)(struct tevent_context *ev,
struct tevent_fd *fde,
int fd,
void *private_data);
/**
* Called when a tevent timer has fired.
*/
typedef void (*tevent_timer_handler_t)(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data);
/**
* Called when a tevent immediate event is invoked.
*/
typedef void (*tevent_immediate_handler_t)(struct tevent_context *ctx,
struct tevent_immediate *im,
void *private_data);
/**
* Called after tevent detects the specified signal.
*/
typedef void (*tevent_signal_handler_t)(struct tevent_context *ev,
struct tevent_signal *se,
int signum,
int count,
void *siginfo,
void *private_data);
/**
* @brief Create a event_context structure.
*
* This must be the first events call, and all subsequent calls pass this
* event_context as the first element. Event handlers also receive this as
* their first argument.
*
* @param[in] mem_ctx The memory context to use.
*
* @return An allocated tevent context, NULL on error.
*
* @see tevent_context_init()
*/
struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx);
/**
* @brief Create a event_context structure and select a specific backend.
*
* This must be the first events call, and all subsequent calls pass this
* event_context as the first element. Event handlers also receive this as
* their first argument.
*
* @param[in] mem_ctx The memory context to use.
*
* @param[in] name The name of the backend to use.
*
* @return An allocated tevent context, NULL on error.
*/
struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx, const char *name);
/**
* @brief Create a custom event context
*
* @param[in] mem_ctx The memory context to use.
* @param[in] ops The function pointer table of the backend.
* @param[in] additional_data The additional/private data to this instance
*
* @return An allocated tevent context, NULL on error.
*
*/
struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
const struct tevent_ops *ops,
void *additional_data);
/**
* @brief List available backends.
*
* @param[in] mem_ctx The memory context to use.
*
* @return A string vector with a terminating NULL element, NULL
* on error.
*/
const char **tevent_backend_list(TALLOC_CTX *mem_ctx);
/**
* @brief Set the default tevent backend.
*
* @param[in] backend The name of the backend to set.
*/
void tevent_set_default_backend(const char *backend);
#ifdef DOXYGEN
/**
* @brief Add a file descriptor based event.
*
* @param[in] ev The event context to work on.
*
* @param[in] mem_ctx The talloc memory context to use.
*
* @param[in] fd The file descriptor to base the event on.
*
* @param[in] flags #TEVENT_FD_READ or #TEVENT_FD_WRITE
*
* @param[in] handler The callback handler for the event.
*
* @param[in] private_data The private data passed to the callback handler.
*
* @return The file descriptor based event, NULL on error.
*
* @note To cancel the monitoring of a file descriptor, call talloc_free()
* on the object returned by this function.
*/
struct tevent_fd *tevent_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd,
uint16_t flags,
tevent_fd_handler_t handler,
void *private_data);
#else
struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd,
uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
#define tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data) \
_tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data, \
#handler, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief Add a timed event
*
* @param[in] ev The event context to work on.
*
* @param[in] mem_ctx The talloc memory context to use.
*
* @param[in] next_event Timeval specifying the absolute time to fire this
* event. This is not an offset.
*
* @param[in] handler The callback handler for the event.
*
* @param[in] private_data The private data passed to the callback handler.
*
* @return The newly-created timer event, or NULL on error.
*
* @note To cancel a timer event before it fires, call talloc_free() on the
* event returned from this function. This event is automatically
* talloc_free()-ed after its event handler files, if it hasn't been freed yet.
*
* @note Unlike some mainloops, tevent timers are one-time events. To set up
* a recurring event, it is necessary to call tevent_add_timer() again during
* the handler processing.
*
* @note Due to the internal mainloop processing, a timer set to run
* immediately will do so after any other pending timers fire, but before
* any further file descriptor or signal handling events fire. Callers should
* not rely on this behavior!
*/
struct tevent_timer *tevent_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data);
#else
struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
#define tevent_add_timer(ev, mem_ctx, next_event, handler, private_data) \
_tevent_add_timer(ev, mem_ctx, next_event, handler, private_data, \
#handler, __location__)
#endif
#ifdef DOXYGEN
/**
* Initialize an immediate event object
*
* This object can be used to trigger an event to occur immediately after
* returning from the current event (before any other event occurs)
*
* @param[in] mem_ctx The talloc memory context to use as the parent
*
* @return An empty tevent_immediate object. Use tevent_schedule_immediate
* to populate and use it.
*
* @note Available as of tevent 0.9.8
*/
struct tevent_immediate *tevent_create_immediate(TALLOC_CTX *mem_ctx);
#else
struct tevent_immediate *_tevent_create_immediate(TALLOC_CTX *mem_ctx,
const char *location);
#define tevent_create_immediate(mem_ctx) \
_tevent_create_immediate(mem_ctx, __location__)
#endif
#ifdef DOXYGEN
/**
* Schedule an event for immediate execution. This event will occur
* immediately after returning from the current event (before any other
* event occurs)
*
* @param[in] im The tevent_immediate object to populate and use
* @param[in] ctx The tevent_context to run this event
* @param[in] handler The event handler to run when this event fires
* @param[in] private_data Data to pass to the event handler
*/
void tevent_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ctx,
tevent_immediate_handler_t handler,
void *private_data);
#else
void _tevent_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ctx,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
#define tevent_schedule_immediate(im, ctx, handler, private_data) \
_tevent_schedule_immediate(im, ctx, handler, private_data, \
#handler, __location__);
#endif
#ifdef DOXYGEN
/**
* @brief Add a tevent signal handler
*
* tevent_add_signal() creates a new event for handling a signal the next
* time through the mainloop. It implements a very simple traditional signal
* handler whose only purpose is to add the handler event into the mainloop.
*
* @param[in] ev The event context to work on.
*
* @param[in] mem_ctx The talloc memory context to use.
*
* @param[in] signum The signal to trap
*
* @param[in] handler The callback handler for the signal.
*
* @param[in] sa_flags sigaction flags for this signal handler.
*
* @param[in] private_data The private data passed to the callback handler.
*
* @return The newly-created signal handler event, or NULL on error.
*
* @note To cancel a signal handler, call talloc_free() on the event returned
* from this function.
*/
struct tevent_signal *tevent_add_signal(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum,
int sa_flags,
tevent_signal_handler_t handler,
void *private_data);
#else
struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum,
int sa_flags,
tevent_signal_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
#define tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data) \
_tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data, \
#handler, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief Pass a single time through the mainloop
*
* This will process any appropriate signal, immediate, fd and timer events
*
* @param[in] ev The event context to process
*
* @return Zero on success, nonzero if an internal error occurred
*/
int tevent_loop_once(struct tevent_context *ev);
#else
int _tevent_loop_once(struct tevent_context *ev, const char *location);
#define tevent_loop_once(ev) \
_tevent_loop_once(ev, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief Run the mainloop
*
* The mainloop will run until there are no events remaining to be processed
*
* @param[in] ev The event context to process
*
* @return Zero if all events have been processed. Nonzero if an internal
* error occurred.
*/
int tevent_loop_wait(struct tevent_context *ev);
#else
int _tevent_loop_wait(struct tevent_context *ev, const char *location);
#define tevent_loop_wait(ev) \
_tevent_loop_wait(ev, __location__)
#endif
/**
* Assign a function to run when a tevent_fd is freed
*
* This function is a destructor for the tevent_fd. It does not automatically
* close the file descriptor. If this is the desired behavior, then it must be
* performed by the close_fn.
*
* @param[in] fde File descriptor event on which to set the destructor
* @param[in] close_fn Destructor to execute when fde is freed
*/
void tevent_fd_set_close_fn(struct tevent_fd *fde,
tevent_fd_close_fn_t close_fn);
/**
* Automatically close the file descriptor when the tevent_fd is freed
*
* This function calls close(fd) internally.
*
* @param[in] fde File descriptor event to auto-close
*/
void tevent_fd_set_auto_close(struct tevent_fd *fde);
/**
* Return the flags set on this file descriptor event
*
* @param[in] fde File descriptor event to query
*
* @return The flags set on the event. See #TEVENT_FD_READ and
* #TEVENT_FD_WRITE
*/
uint16_t tevent_fd_get_flags(struct tevent_fd *fde);
/**
* Set flags on a file descriptor event
*
* @param[in] fde File descriptor event to set
* @param[in] flags Flags to set on the event. See #TEVENT_FD_READ and
* #TEVENT_FD_WRITE
*/
void tevent_fd_set_flags(struct tevent_fd *fde, uint16_t flags);
/**
* Query whether tevent supports signal handling
*
* @param[in] ev An initialized tevent context
*
* @return True if this platform and tevent context support signal handling
*/
bool tevent_signal_support(struct tevent_context *ev);
void tevent_set_abort_fn(void (*abort_fn)(const char *reason));
/* bits for file descriptor event flags */
/**
* Monitor a file descriptor for write availability
*/
#define TEVENT_FD_READ 1
/**
* Monitor a file descriptor for data to be read
*/
#define TEVENT_FD_WRITE 2
/**
* Convenience function for declaring a tevent_fd writable
*/
#define TEVENT_FD_WRITEABLE(fde) \
tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) | TEVENT_FD_WRITE)
/**
* Convenience function for declaring a tevent_fd readable
*/
#define TEVENT_FD_READABLE(fde) \
tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) | TEVENT_FD_READ)
/**
* Convenience function for declaring a tevent_fd non-writable
*/
#define TEVENT_FD_NOT_WRITEABLE(fde) \
tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_WRITE)
/**
* Convenience function for declaring a tevent_fd non-readable
*/
#define TEVENT_FD_NOT_READABLE(fde) \
tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_READ)
/**
* Debug level of tevent
*/
enum tevent_debug_level {
TEVENT_DEBUG_FATAL,
TEVENT_DEBUG_ERROR,
TEVENT_DEBUG_WARNING,
TEVENT_DEBUG_TRACE
};
/**
* @brief The tevent debug callbac.
*
* @param[in] context The memory context to use.
*
* @param[in] level The debug level.
*
* @param[in] fmt The format string.
*
* @param[in] ap The arguments for the format string.
*/
typedef void (*tevent_debug_fn)(void *context,
enum tevent_debug_level level,
const char *fmt,
va_list ap) PRINTF_ATTRIBUTE(3,0);
/**
* Set destination for tevent debug messages
*
* @param[in] ev Event context to debug
* @param[in] debug Function to handle output printing
* @param[in] context The context to pass to the debug function.
*
* @return Always returns 0 as of version 0.9.8
*
* @note Default is to emit no debug messages
*/
int tevent_set_debug(struct tevent_context *ev,
tevent_debug_fn debug,
void *context);
/**
* Designate stderr for debug message output
*
* @param[in] ev Event context to debug
*
* @note This function will only output TEVENT_DEBUG_FATAL, TEVENT_DEBUG_ERROR
* and TEVENT_DEBUG_WARNING messages. For TEVENT_DEBUG_TRACE, please define a
* function for tevent_set_debug()
*/
int tevent_set_debug_stderr(struct tevent_context *ev);
enum tevent_trace_point {
/**
* Corresponds to a trace point just before waiting
*/
TEVENT_TRACE_BEFORE_WAIT,
/**
* Corresponds to a trace point just after waiting
*/
TEVENT_TRACE_AFTER_WAIT,
#define TEVENT_HAS_LOOP_ONCE_TRACE_POINTS 1
/**
* Corresponds to a trace point just before calling
* the loop_once() backend function.
*/
TEVENT_TRACE_BEFORE_LOOP_ONCE,
/**
* Corresponds to a trace point right after the
* loop_once() backend function has returned.
*/
TEVENT_TRACE_AFTER_LOOP_ONCE,
};
typedef void (*tevent_trace_callback_t)(enum tevent_trace_point,
void *private_data);
/**
* Register a callback to be called at certain trace points
*
* @param[in] ev Event context
* @param[in] cb Trace callback
* @param[in] private_data Data to be passed to callback
*
* @note The callback will be called at trace points defined by
* tevent_trace_point. Call with NULL to reset.
*/
void tevent_set_trace_callback(struct tevent_context *ev,
tevent_trace_callback_t cb,
void *private_data);
/**
* Retrieve the current trace callback
*
* @param[in] ev Event context
* @param[out] cb Registered trace callback
* @param[out] private_data Registered data to be passed to callback
*
* @note This can be used to allow one component that wants to
* register a callback to respect the callback that another component
* has already registered.
*/
void tevent_get_trace_callback(struct tevent_context *ev,
tevent_trace_callback_t *cb,
void *private_data);
/**
* @}
*/
/**
* @defgroup tevent_request The tevent request functions.
* @ingroup tevent
*
* A tevent_req represents an asynchronous computation.
*
* The tevent_req group of API calls is the recommended way of
* programming async computations within tevent. In particular the
* file descriptor (tevent_add_fd) and timer (tevent_add_timed) events
* are considered too low-level to be used in larger computations. To
* read and write from and to sockets, Samba provides two calls on top
* of tevent_add_fd: read_packet_send/recv and writev_send/recv. These
* requests are much easier to compose than the low-level event
* handlers called from tevent_add_fd.
*
* A lot of the simplicity tevent_req has brought to the notoriously
* hairy async programming came via a set of conventions that every
* async computation programmed should follow. One central piece of
* these conventions is the naming of routines and variables.
*
* Every async computation needs a name (sensibly called "computation"
* down from here). From this name quite a few naming conventions are
* derived.
*
* Every computation that requires local state needs a
* @code
* struct computation_state {
* int local_var;
* };
* @endcode
* Even if no local variables are required, such a state struct should
* be created containing a dummy variable. Quite a few helper
* functions and macros (for example tevent_req_create()) assume such
* a state struct.
*
* An async computation is started by a computation_send
* function. When it is finished, its result can be received by a
* computation_recv function. For an example how to set up an async
* computation, see the code example in the documentation for
* tevent_req_create() and tevent_req_post(). The prototypes for _send
* and _recv functions should follow some conventions:
*
* @code
* struct tevent_req *computation_send(TALLOC_CTX *mem_ctx,
* struct tevent_req *ev,
* ... further args);
* int computation_recv(struct tevent_req *req, ... further output args);
* @endcode
*
* The "int" result of computation_recv() depends on the result the
* sync version of the function would have, "int" is just an example
* here.
*
* Another important piece of the conventions is that the program flow
* is interrupted as little as possible. Because a blocking
* sub-computation requires that the flow needs to continue in a
* separate function that is the logical sequel of some computation,
* it should lexically follow sending off the blocking
* sub-computation. Setting the callback function via
* tevent_req_set_callback() requires referencing a function lexically
* below the call to tevent_req_set_callback(), forward declarations
* are required. A lot of the async computations thus begin with a
* sequence of declarations such as
*
* @code
* static void computation_step1_done(struct tevent_req *subreq);
* static void computation_step2_done(struct tevent_req *subreq);
* static void computation_step3_done(struct tevent_req *subreq);
* @endcode
*
* It really helps readability a lot to do these forward declarations,
* because the lexically sequential program flow makes the async
* computations almost as clear to read as a normal, sync program
* flow.
*
* It is up to the user of the async computation to talloc_free it
* after it has finished. If an async computation should be aborted,
* the tevent_req structure can be talloc_free'ed. After it has
* finished, it should talloc_free'ed by the API user.
*
* @{
*/
/**
* An async request moves from TEVENT_REQ_INIT to
* TEVENT_REQ_IN_PROGRESS. All other states are valid after a request
* has finished.
*/
enum tevent_req_state {
/**
* We are creating the request
*/
TEVENT_REQ_INIT,
/**
* We are waiting the request to complete
*/
TEVENT_REQ_IN_PROGRESS,
/**
* The request is finished successfully
*/
TEVENT_REQ_DONE,
/**
* A user error has occurred. The user error has been
* indicated by tevent_req_error(), it can be retrieved via
* tevent_req_is_error().
*/
TEVENT_REQ_USER_ERROR,
/**
* Request timed out after the timeout set by tevent_req_set_endtime.
*/
TEVENT_REQ_TIMED_OUT,
/**
* An internal allocation has failed, or tevent_req_nomem has
* been given a NULL pointer as the first argument.
*/
TEVENT_REQ_NO_MEMORY,
/**
* The request has been received by the caller. No further
* action is valid.
*/
TEVENT_REQ_RECEIVED
};
/**
* @brief An async request
*/
struct tevent_req;
/**
* @brief A tevent request callback function.
*
* @param[in] req The tevent async request which executed this callback.
*/
typedef void (*tevent_req_fn)(struct tevent_req *req);
/**
* @brief Set an async request callback.
*
* See the documentation of tevent_req_post() for an example how this
* is supposed to be used.
*
* @param[in] req The async request to set the callback.
*
* @param[in] fn The callback function to set.
*
* @param[in] pvt A pointer to private data to pass to the async request
* callback.
*/
void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt);
#ifdef DOXYGEN
/**
* @brief Get the private data cast to the given type for a callback from
* a tevent request structure.
*
* @code
* static void computation_done(struct tevent_req *subreq) {
* struct tevent_req *req = tevent_req_callback_data(subreq, struct tevent_req);
* struct computation_state *state = tevent_req_data(req, struct computation_state);
* .... more things, eventually maybe call tevent_req_done(req);
* }
* @endcode
*
* @param[in] req The structure to get the callback data from.
*
* @param[in] type The type of the private callback data to get.
*
* @return The type casted private data set NULL if not set.
*/
void *tevent_req_callback_data(struct tevent_req *req, #type);
#else
void *_tevent_req_callback_data(struct tevent_req *req);
#define tevent_req_callback_data(_req, _type) \
talloc_get_type_abort(_tevent_req_callback_data(_req), _type)
#endif
#ifdef DOXYGEN
/**
* @brief Get the private data for a callback from a tevent request structure.
*
* @param[in] req The structure to get the callback data from.
*
* @param[in] req The structure to get the data from.
*
* @return The private data or NULL if not set.
*/
void *tevent_req_callback_data_void(struct tevent_req *req);
#else
#define tevent_req_callback_data_void(_req) \
_tevent_req_callback_data(_req)
#endif
#ifdef DOXYGEN
/**
* @brief Get the private data from a tevent request structure.
*
* When the tevent_req has been created by tevent_req_create, the
* result of tevent_req_data() is the state variable created by
* tevent_req_create() as a child of the req.
*
* @param[in] req The structure to get the private data from.
*
* @param[in] type The type of the private data
*
* @return The private data or NULL if not set.
*/
void *tevent_req_data(struct tevent_req *req, #type);
#else
void *_tevent_req_data(struct tevent_req *req);
#define tevent_req_data(_req, _type) \
talloc_get_type_abort(_tevent_req_data(_req), _type)
#endif
/**
* @brief The print function which can be set for a tevent async request.
*
* @param[in] req The tevent async request.
*
* @param[in] ctx A talloc memory context which can be uses to allocate
* memory.
*
* @return An allocated string buffer to print.
*
* Example:
* @code
* static char *my_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
* {
* struct my_data *data = tevent_req_data(req, struct my_data);
* char *result;
*
* result = tevent_req_default_print(mem_ctx, req);
* if (result == NULL) {
* return NULL;
* }
*
* return talloc_asprintf_append_buffer(result, "foo=%d, bar=%d",
* data->foo, data->bar);
* }
* @endcode
*/
typedef char *(*tevent_req_print_fn)(struct tevent_req *req, TALLOC_CTX *ctx);
/**
* @brief This function sets a print function for the given request.
*
* This function can be used to setup a print function for the given request.
* This will be triggered if the tevent_req_print() function was
* called on the given request.
*
* @param[in] req The request to use.
*
* @param[in] fn A pointer to the print function
*
* @note This function should only be used for debugging.
*/
void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn);
/**
* @brief The default print function for creating debug messages.
*
* The function should not be used by users of the async API,
* but custom print function can use it and append custom text
* to the string.
*
* @param[in] req The request to be printed.
*
* @param[in] mem_ctx The memory context for the result.
*
* @return Text representation of request.
*
*/
char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx);
/**
* @brief Print an tevent_req structure in debug messages.
*
* This function should be used by callers of the async API.
*
* @param[in] mem_ctx The memory context for the result.
*
* @param[in] req The request to be printed.
*
* @return Text representation of request.
*/
char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req);
/**
* @brief A typedef for a cancel function for a tevent request.
*
* @param[in] req The tevent request calling this function.
*
* @return True if the request could be canceled, false if not.
*/
typedef bool (*tevent_req_cancel_fn)(struct tevent_req *req);
/**
* @brief This function sets a cancel function for the given tevent request.
*
* This function can be used to setup a cancel function for the given request.
* This will be triggered if the tevent_req_cancel() function was
* called on the given request.
*
* @param[in] req The request to use.
*
* @param[in] fn A pointer to the cancel function.
*/
void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn);
#ifdef DOXYGEN
/**
* @brief Try to cancel the given tevent request.
*
* This function can be used to cancel the given request.
*
* It is only possible to cancel a request when the implementation
* has registered a cancel function via the tevent_req_set_cancel_fn().
*
* @param[in] req The request to use.
*
* @return This function returns true is the request is cancelable,
* othererwise false is returned.
*
* @note Even if the function returns true, the caller need to wait
* for the function to complete normally.
* Only the _recv() function of the given request indicates
* if the request was really canceled.
*/
bool tevent_req_cancel(struct tevent_req *req);
#else
bool _tevent_req_cancel(struct tevent_req *req, const char *location);
#define tevent_req_cancel(req) \
_tevent_req_cancel(req, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief Create an async tevent request.
*
* The new async request will be initialized in state TEVENT_REQ_IN_PROGRESS.
*
* @code
* struct tevent_req *req;
* struct computation_state *state;
* req = tevent_req_create(mem_ctx, &state, struct computation_state);
* @endcode
*
* Tevent_req_create() allocates and zeros the state variable as a talloc
* child of its result. The state variable should be used as the talloc
* parent for all temporary variables that are allocated during the async
* computation. This way, when the user of the async computation frees
* the request, the state as a talloc child will be free'd along with
* all the temporary variables hanging off the state.
*
* @param[in] mem_ctx The memory context for the result.
* @param[in] pstate Pointer to the private request state.
* @param[in] type The name of the request.
*
* @return A new async request. NULL on error.
*/
struct tevent_req *tevent_req_create(TALLOC_CTX *mem_ctx,
void **pstate, #type);
#else
struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
void *pstate,
size_t state_size,
const char *type,
const char *location);
#define tevent_req_create(_mem_ctx, _pstate, _type) \
_tevent_req_create((_mem_ctx), (_pstate), sizeof(_type), \
#_type, __location__)
#endif
/**
* @brief Set a timeout for an async request.
*
* @param[in] req The request to set the timeout for.
*
* @param[in] ev The event context to use for the timer.
*
* @param[in] endtime The endtime of the request.
*
* @return True if succeeded, false if not.
*/
bool tevent_req_set_endtime(struct tevent_req *req,
struct tevent_context *ev,
struct timeval endtime);
#ifdef DOXYGEN
/**
* @brief Call the notify callback of the given tevent request manually.
*
* @param[in] req The tevent request to call the notify function from.
*
* @see tevent_req_set_callback()
*/
void tevent_req_notify_callback(struct tevent_req *req);
#else
void _tevent_req_notify_callback(struct tevent_req *req, const char *location);
#define tevent_req_notify_callback(req) \
_tevent_req_notify_callback(req, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief An async request has successfully finished.
*
* This function is to be used by implementors of async requests. When a
* request is successfully finished, this function calls the user's completion
* function.
*
* @param[in] req The finished request.
*/
void tevent_req_done(struct tevent_req *req);
#else
void _tevent_req_done(struct tevent_req *req,
const char *location);
#define tevent_req_done(req) \
_tevent_req_done(req, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief An async request has seen an error.
*
* This function is to be used by implementors of async requests. When a
* request can not successfully completed, the implementation should call this
* function with the appropriate status code.
*
* If error is 0 the function returns false and does nothing more.
*
* @param[in] req The request with an error.
*
* @param[in] error The error code.
*
* @return On success true is returned, false if error is 0.
*
* @code
* int error = first_function();
* if (tevent_req_error(req, error)) {
* return;
* }
*
* error = second_function();
* if (tevent_req_error(req, error)) {
* return;
* }
*
* tevent_req_done(req);
* return;
* @endcode
*/
bool tevent_req_error(struct tevent_req *req,
uint64_t error);
#else
bool _tevent_req_error(struct tevent_req *req,
uint64_t error,
const char *location);
#define tevent_req_error(req, error) \
_tevent_req_error(req, error, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief Helper function for nomem check.
*
* Convenience helper to easily check alloc failure within a callback
* implementing the next step of an async request.
*
* @param[in] p The pointer to be checked.
*
* @param[in] req The request being processed.
*
* @code
* p = talloc(mem_ctx, bla);
* if (tevent_req_nomem(p, req)) {
* return;
* }
* @endcode
*/
bool tevent_req_nomem(const void *p,
struct tevent_req *req);
#else
bool _tevent_req_nomem(const void *p,
struct tevent_req *req,
const char *location);
#define tevent_req_nomem(p, req) \
_tevent_req_nomem(p, req, __location__)
#endif
#ifdef DOXYGEN
/**
* @brief Indicate out of memory to a request
*
* @param[in] req The request being processed.
*/
void tevent_req_oom(struct tevent_req *req);
#else
void _tevent_req_oom(struct tevent_req *req,
const char *location);
#define tevent_req_oom(req) \
_tevent_req_oom(req, __location__)
#endif
/**
* @brief Finish a request before the caller had the change to set the callback.
*
* An implementation of an async request might find that it can either finish
* the request without waiting for an external event, or it can not even start
* the engine. To present the illusion of a callback to the user of the API,
* the implementation can call this helper function which triggers an
* immediate event. This way the caller can use the same calling
* conventions, independent of whether the request was actually deferred.
*
* @code
* struct tevent_req *computation_send(TALLOC_CTX *mem_ctx,
* struct tevent_context *ev)
* {
* struct tevent_req *req, *subreq;
* struct computation_state *state;
* req = tevent_req_create(mem_ctx, &state, struct computation_state);
* if (req == NULL) {
* return NULL;
* }
* subreq = subcomputation_send(state, ev);
* if (tevent_req_nomem(subreq, req)) {
* return tevent_req_post(req, ev);
* }
* tevent_req_set_callback(subreq, computation_done, req);
* return req;
* }
* @endcode
*
* @param[in] req The finished request.
*
* @param[in] ev The tevent_context for the immediate event.
*
* @return The given request will be returned.
*/
struct tevent_req *tevent_req_post(struct tevent_req *req,
struct tevent_context *ev);
/**
* @brief Finish multiple requests within one function
*
* Normally tevent_req_notify_callback() and all wrappers
* (e.g. tevent_req_done() and tevent_req_error())
* need to be the last thing an event handler should call.
* This is because the callback is likely to destroy the
* context of the current function.
*
* If a function wants to notify more than one caller,
* it is dangerous if it just triggers multiple callbacks
* in a row. With tevent_req_defer_callback() it is possible
* to set an event context that will be used to defer the callback
* via an immediate event (similar to tevent_req_post()).
*
* @code
* struct complete_state {
* struct tevent_context *ev;
*
* struct tevent_req **reqs;
* };
*
* void complete(struct complete_state *state)
* {
* size_t i, c = talloc_array_length(state->reqs);
*
* for (i=0; i < c; i++) {
* tevent_req_defer_callback(state->reqs[i], state->ev);
* tevent_req_done(state->reqs[i]);
* }
* }
* @endcode
*
* @param[in] req The finished request.
*
* @param[in] ev The tevent_context for the immediate event.
*
* @return The given request will be returned.
*/
void tevent_req_defer_callback(struct tevent_req *req,
struct tevent_context *ev);
/**
* @brief Check if the given request is still in progress.
*
* It is typically used by sync wrapper functions.
*
* @param[in] req The request to poll.
*
* @return The boolean form of "is in progress".
*/
bool tevent_req_is_in_progress(struct tevent_req *req);
/**
* @brief Actively poll for the given request to finish.
*
* This function is typically used by sync wrapper functions.
*
* @param[in] req The request to poll.
*
* @param[in] ev The tevent_context to be used.
*
* @return On success true is returned. If a critical error has
* happened in the tevent loop layer false is returned.
* This is not the return value of the given request!
*
* @note This should only be used if the given tevent context was created by the
* caller, to avoid event loop nesting.
*
* @code
* req = tstream_writev_queue_send(mem_ctx,
* ev_ctx,
* tstream,
* send_queue,
* iov, 2);
* ok = tevent_req_poll(req, tctx->ev);
* rc = tstream_writev_queue_recv(req, &sys_errno);
* TALLOC_FREE(req);
* @endcode
*/
bool tevent_req_poll(struct tevent_req *req,
struct tevent_context *ev);
/**
* @brief Get the tevent request state and the actual error set by
* tevent_req_error.
*
* @code
* int computation_recv(struct tevent_req *req, uint64_t *perr)
* {
* enum tevent_req_state state;
* uint64_t err;
* if (tevent_req_is_error(req, &state, &err)) {
* *perr = err;
* return -1;
* }
* return 0;
* }
* @endcode
*
* @param[in] req The tevent request to get the error from.
*
* @param[out] state A pointer to store the tevent request error state.
*
* @param[out] error A pointer to store the error set by tevent_req_error().
*
* @return True if the function could set error and state, false
* otherwise.
*
* @see tevent_req_error()
*/
bool tevent_req_is_error(struct tevent_req *req,
enum tevent_req_state *state,
uint64_t *error);
/**
* @brief Use as the last action of a _recv() function.
*
* This function destroys the attached private data.
*
* @param[in] req The finished request.
*/
void tevent_req_received(struct tevent_req *req);
/**
* @brief Create a tevent subrequest at a given time.
*
* The idea is that always the same syntax for tevent requests.
*
* @param[in] mem_ctx The talloc memory context to use.
*
* @param[in] ev The event handle to setup the request.
*
* @param[in] wakeup_time The time to wakeup and execute the request.
*
* @return The new subrequest, NULL on error.
*
* Example:
* @code
* static void my_callback_wakeup_done(tevent_req *subreq)
* {
* struct tevent_req *req = tevent_req_callback_data(subreq,
* struct tevent_req);
* bool ok;
*
* ok = tevent_wakeup_recv(subreq);
* TALLOC_FREE(subreq);
* if (!ok) {
* tevent_req_error(req, -1);
* return;
* }
* ...
* }
* @endcode
*
* @code
* subreq = tevent_wakeup_send(mem_ctx, ev, wakeup_time);
* if (tevent_req_nomem(subreq, req)) {
* return false;
* }
* tevent_set_callback(subreq, my_callback_wakeup_done, req);
* @endcode
*
* @see tevent_wakeup_recv()
*/
struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct timeval wakeup_time);
/**
* @brief Check if the wakeup has been correctly executed.
*
* This function needs to be called in the callback function set after calling
* tevent_wakeup_send().
*
* @param[in] req The tevent request to check.
*
* @return True on success, false otherwise.
*
* @see tevent_wakeup_recv()
*/
bool tevent_wakeup_recv(struct tevent_req *req);
/* @} */
/**
* @defgroup tevent_helpers The tevent helper functiions
* @ingroup tevent
*
* @todo description
*
* @{
*/
/**
* @brief Compare two timeval values.
*
* @param[in] tv1 The first timeval value to compare.
*
* @param[in] tv2 The second timeval value to compare.
*
* @return 0 if they are equal.
* 1 if the first time is greater than the second.
* -1 if the first time is smaller than the second.
*/
int tevent_timeval_compare(const struct timeval *tv1,
const struct timeval *tv2);
/**
* @brief Get a zero timval value.
*
* @return A zero timval value.
*/
struct timeval tevent_timeval_zero(void);
/**
* @brief Get a timeval value for the current time.
*
* @return A timval value with the current time.
*/
struct timeval tevent_timeval_current(void);
/**
* @brief Get a timeval structure with the given values.
*
* @param[in] secs The seconds to set.
*
* @param[in] usecs The microseconds to set.
*
* @return A timeval structure with the given values.
*/
struct timeval tevent_timeval_set(uint32_t secs, uint32_t usecs);
/**
* @brief Get the difference between two timeval values.
*
* @param[in] tv1 The first timeval.
*
* @param[in] tv2 The second timeval.
*
* @return A timeval structure with the difference between the
* first and the second value.
*/
struct timeval tevent_timeval_until(const struct timeval *tv1,
const struct timeval *tv2);
/**
* @brief Check if a given timeval structure is zero.
*
* @param[in] tv The timeval to check if it is zero.
*
* @return True if it is zero, false otherwise.
*/
bool tevent_timeval_is_zero(const struct timeval *tv);
/**
* @brief Add the given amount of time to a timeval structure.
*
* @param[in] tv The timeval structure to add the time.
*
* @param[in] secs The seconds to add to the timeval.
*
* @param[in] usecs The microseconds to add to the timeval.
*
* @return The timeval structure with the new time.
*/
struct timeval tevent_timeval_add(const struct timeval *tv, uint32_t secs,
uint32_t usecs);
/**
* @brief Get a timeval in the future with a specified offset from now.
*
* @param[in] secs The seconds of the offset from now.
*
* @param[in] usecs The microseconds of the offset from now.
*
* @return A timval with the given offset in the future.
*/
struct timeval tevent_timeval_current_ofs(uint32_t secs, uint32_t usecs);
/* @} */
/**
* @defgroup tevent_queue The tevent queue functions
* @ingroup tevent
*
* A tevent_queue is used to queue up async requests that must be
* serialized. For example writing buffers into a socket must be
* serialized. Writing a large lump of data into a socket can require
* multiple write(2) or send(2) system calls. If more than one async
* request is outstanding to write large buffers into a socket, every
* request must individually be completed before the next one begins,
* even if multiple syscalls are required.
*
* Take a look at @ref tevent_queue_tutorial for more details.
* @{
*/
struct tevent_queue;
struct tevent_queue_entry;
#ifdef DOXYGEN
/**
* @brief Create and start a tevent queue.
*
* @param[in] mem_ctx The talloc memory context to allocate the queue.
*
* @param[in] name The name to use to identify the queue.
*
* @return An allocated tevent queue on success, NULL on error.
*
* @see tevent_queue_start()
* @see tevent_queue_stop()
*/
struct tevent_queue *tevent_queue_create(TALLOC_CTX *mem_ctx,
const char *name);
#else
struct tevent_queue *_tevent_queue_create(TALLOC_CTX *mem_ctx,
const char *name,
const char *location);
#define tevent_queue_create(_mem_ctx, _name) \
_tevent_queue_create((_mem_ctx), (_name), __location__)
#endif
/**
* @brief A callback trigger function run by the queue.
*
* @param[in] req The tevent request the trigger function is executed on.
*
* @param[in] private_data The private data pointer specified by
* tevent_queue_add().
*
* @see tevent_queue_add()
* @see tevent_queue_add_entry()
* @see tevent_queue_add_optimize_empty()
*/
typedef void (*tevent_queue_trigger_fn_t)(struct tevent_req *req,
void *private_data);
/**
* @brief Add a tevent request to the queue.
*
* @param[in] queue The queue to add the request.
*
* @param[in] ev The event handle to use for the request.
*
* @param[in] req The tevent request to add to the queue.
*
* @param[in] trigger The function triggered by the queue when the request
* is called. Since tevent 0.9.14 it's possible to
* pass NULL, in order to just add a "blocker" to the
* queue.
*
* @param[in] private_data The private data passed to the trigger function.
*
* @return True if the request has been successfully added, false
* otherwise.
*/
bool tevent_queue_add(struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data);
/**
* @brief Add a tevent request to the queue.
*
* The request can be removed from the queue by calling talloc_free()
* (or a similar function) on the returned queue entry. This
* is the only difference to tevent_queue_add().
*
* @param[in] queue The queue to add the request.
*
* @param[in] ev The event handle to use for the request.
*
* @param[in] req The tevent request to add to the queue.
*
* @param[in] trigger The function triggered by the queue when the request
* is called. Since tevent 0.9.14 it's possible to
* pass NULL, in order to just add a "blocker" to the
* queue.
*
* @param[in] private_data The private data passed to the trigger function.
*
* @return a pointer to the tevent_queue_entry if the request
* has been successfully added, NULL otherwise.
*
* @see tevent_queue_add()
* @see tevent_queue_add_optimize_empty()
*/
struct tevent_queue_entry *tevent_queue_add_entry(
struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data);
/**
* @brief Add a tevent request to the queue using a possible optimization.
*
* This tries to optimize for the empty queue case and may calls
* the trigger function directly. This is the only difference compared
* to tevent_queue_add_entry().
*
* The caller needs to be prepared that the trigger function has
* already called tevent_req_notify_callback(), tevent_req_error(),
* tevent_req_done() or a similar function.
*
* The request can be removed from the queue by calling talloc_free()
* (or a similar function) on the returned queue entry.
*
* @param[in] queue The queue to add the request.
*
* @param[in] ev The event handle to use for the request.
*
* @param[in] req The tevent request to add to the queue.
*
* @param[in] trigger The function triggered by the queue when the request
* is called. Since tevent 0.9.14 it's possible to
* pass NULL, in order to just add a "blocker" to the
* queue.
*
* @param[in] private_data The private data passed to the trigger function.
*
* @return a pointer to the tevent_queue_entry if the request
* has been successfully added, NULL otherwise.
*
* @see tevent_queue_add()
* @see tevent_queue_add_entry()
*/
struct tevent_queue_entry *tevent_queue_add_optimize_empty(
struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data);
/**
* @brief Start a tevent queue.
*
* The queue is started by default.
*
* @param[in] queue The queue to start.
*/
void tevent_queue_start(struct tevent_queue *queue);
/**
* @brief Stop a tevent queue.
*
* The queue is started by default.
*
* @param[in] queue The queue to stop.
*/
void tevent_queue_stop(struct tevent_queue *queue);
/**
* @brief Get the length of the queue.
*
* @param[in] queue The queue to get the length from.
*
* @return The number of elements.
*/
size_t tevent_queue_length(struct tevent_queue *queue);
/**
* @brief Is the tevent queue running.
*
* The queue is started by default.
*
* @param[in] queue The queue.
*
* @return Wether the queue is running or not..
*/
bool tevent_queue_running(struct tevent_queue *queue);
typedef int (*tevent_nesting_hook)(struct tevent_context *ev,
void *private_data,
uint32_t level,
bool begin,
void *stack_ptr,
const char *location);
#ifdef TEVENT_DEPRECATED
#ifndef _DEPRECATED_
#if (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 1 )
#define _DEPRECATED_ __attribute__ ((deprecated))
#else
#define _DEPRECATED_
#endif
#endif
void tevent_loop_allow_nesting(struct tevent_context *ev) _DEPRECATED_;
void tevent_loop_set_nesting_hook(struct tevent_context *ev,
tevent_nesting_hook hook,
void *private_data) _DEPRECATED_;
int _tevent_loop_until(struct tevent_context *ev,
bool (*finished)(void *private_data),
void *private_data,
const char *location) _DEPRECATED_;
#define tevent_loop_until(ev, finished, private_data) \
_tevent_loop_until(ev, finished, private_data, __location__)
#endif
int tevent_re_initialise(struct tevent_context *ev);
/* @} */
/**
* @defgroup tevent_ops The tevent operation functions
* @ingroup tevent
*
* The following structure and registration functions are exclusively
* needed for people writing and pluggin a different event engine.
* There is nothing useful for normal tevent user in here.
* @{
*/
struct tevent_ops {
/* context init */
int (*context_init)(struct tevent_context *ev);
/* fd_event functions */
struct tevent_fd *(*add_fd)(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
void (*set_fd_close_fn)(struct tevent_fd *fde,
tevent_fd_close_fn_t close_fn);
uint16_t (*get_fd_flags)(struct tevent_fd *fde);
void (*set_fd_flags)(struct tevent_fd *fde, uint16_t flags);
/* timed_event functions */
struct tevent_timer *(*add_timer)(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
/* immediate event functions */
void (*schedule_immediate)(struct tevent_immediate *im,
struct tevent_context *ev,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
/* signal functions */
struct tevent_signal *(*add_signal)(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum, int sa_flags,
tevent_signal_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
/* loop functions */
int (*loop_once)(struct tevent_context *ev, const char *location);
int (*loop_wait)(struct tevent_context *ev, const char *location);
};
bool tevent_register_backend(const char *name, const struct tevent_ops *ops);
/* @} */
/**
* @defgroup tevent_compat The tevent compatibility functions
* @ingroup tevent
*
* The following definitions are usueful only for compatibility with the
* implementation originally developed within the samba4 code and will be
* soon removed. Please NEVER use in new code.
*
* @todo Ignore it?
*
* @{
*/
#ifdef TEVENT_COMPAT_DEFINES
#define event_context tevent_context
#define event_ops tevent_ops
#define fd_event tevent_fd
#define timed_event tevent_timer
#define signal_event tevent_signal
#define event_fd_handler_t tevent_fd_handler_t
#define event_timed_handler_t tevent_timer_handler_t
#define event_signal_handler_t tevent_signal_handler_t
#define event_context_init(mem_ctx) \
tevent_context_init(mem_ctx)
#define event_context_init_byname(mem_ctx, name) \
tevent_context_init_byname(mem_ctx, name)
#define event_backend_list(mem_ctx) \
tevent_backend_list(mem_ctx)
#define event_set_default_backend(backend) \
tevent_set_default_backend(backend)
#define event_add_fd(ev, mem_ctx, fd, flags, handler, private_data) \
tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data)
#define event_add_timed(ev, mem_ctx, next_event, handler, private_data) \
tevent_add_timer(ev, mem_ctx, next_event, handler, private_data)
#define event_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data) \
tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data)
#define event_loop_once(ev) \
tevent_loop_once(ev)
#define event_loop_wait(ev) \
tevent_loop_wait(ev)
#define event_get_fd_flags(fde) \
tevent_fd_get_flags(fde)
#define event_set_fd_flags(fde, flags) \
tevent_fd_set_flags(fde, flags)
#define EVENT_FD_READ TEVENT_FD_READ
#define EVENT_FD_WRITE TEVENT_FD_WRITE
#define EVENT_FD_WRITEABLE(fde) \
TEVENT_FD_WRITEABLE(fde)
#define EVENT_FD_READABLE(fde) \
TEVENT_FD_READABLE(fde)
#define EVENT_FD_NOT_WRITEABLE(fde) \
TEVENT_FD_NOT_WRITEABLE(fde)
#define EVENT_FD_NOT_READABLE(fde) \
TEVENT_FD_NOT_READABLE(fde)
#define ev_debug_level tevent_debug_level
#define EV_DEBUG_FATAL TEVENT_DEBUG_FATAL
#define EV_DEBUG_ERROR TEVENT_DEBUG_ERROR
#define EV_DEBUG_WARNING TEVENT_DEBUG_WARNING
#define EV_DEBUG_TRACE TEVENT_DEBUG_TRACE
#define ev_set_debug(ev, debug, context) \
tevent_set_debug(ev, debug, context)
#define ev_set_debug_stderr(_ev) tevent_set_debug_stderr(ev)
#endif /* TEVENT_COMPAT_DEFINES */
/* @} */
#endif /* __TEVENT_H__ */
tevent-0.9.19/tevent.pc.in 0000660 0000000 0000000 00000000407 12101212317 015300 0 ustar root root 0000000 0000000 prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: tevent
Description: An event system library
Version: @PACKAGE_VERSION@
Requires: talloc
Libs: -L${libdir} -ltevent
Cflags: @LIB_RPATH@ -I${includedir}
URL: http://samba.org/
tevent-0.9.19/tevent.py 0000660 0000000 0000000 00000001772 12101212317 014727 0 ustar root root 0000000 0000000 #!/usr/bin/python
#
# Python integration for tevent
#
# Copyright (C) Jelmer Vernooij 2011
#
# ** NOTE! The following LGPL license applies to the tevent
# ** library. This does NOT imply that all of Samba is released
# ** under the LGPL
#
# This library 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 3 of the License, or (at your option) any later version.
#
# This library 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 library; if not, see .
from _tevent import (
__version__,
backend_list,
Context,
Signal,
)
tevent-0.9.19/tevent_debug.c 0000660 0000000 0000000 00000006441 12101212317 015665 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Copyright (C) Andrew Tridgell 2005
Copyright (C) Jelmer Vernooij 2005
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_internal.h"
/********************************************************************
* Debug wrapper functions, modeled (with lot's of code copied as is)
* after the ev debug wrapper functions
********************************************************************/
/*
this allows the user to choose their own debug function
*/
int tevent_set_debug(struct tevent_context *ev,
void (*debug)(void *context,
enum tevent_debug_level level,
const char *fmt,
va_list ap) PRINTF_ATTRIBUTE(3,0),
void *context)
{
ev->debug_ops.debug = debug;
ev->debug_ops.context = context;
return 0;
}
/*
debug function for ev_set_debug_stderr
*/
static void tevent_debug_stderr(void *private_data,
enum tevent_debug_level level,
const char *fmt,
va_list ap) PRINTF_ATTRIBUTE(3,0);
static void tevent_debug_stderr(void *private_data,
enum tevent_debug_level level,
const char *fmt, va_list ap)
{
if (level <= TEVENT_DEBUG_WARNING) {
vfprintf(stderr, fmt, ap);
}
}
/*
convenience function to setup debug messages on stderr
messages of level TEVENT_DEBUG_WARNING and higher are printed
*/
int tevent_set_debug_stderr(struct tevent_context *ev)
{
return tevent_set_debug(ev, tevent_debug_stderr, ev);
}
/*
* log a message
*
* The default debug action is to ignore debugging messages.
* This is the most appropriate action for a library.
* Applications using the library must decide where to
* redirect debugging messages
*/
void tevent_debug(struct tevent_context *ev, enum tevent_debug_level level,
const char *fmt, ...)
{
va_list ap;
if (!ev) {
return;
}
if (ev->debug_ops.debug == NULL) {
return;
}
va_start(ap, fmt);
ev->debug_ops.debug(ev->debug_ops.context, level, fmt, ap);
va_end(ap);
}
void tevent_set_trace_callback(struct tevent_context *ev,
tevent_trace_callback_t cb,
void *private_data)
{
ev->tracing.callback = cb;
ev->tracing.private_data = private_data;
}
void tevent_get_trace_callback(struct tevent_context *ev,
tevent_trace_callback_t *cb,
void *private_data)
{
*cb = ev->tracing.callback;
*(void**)private_data = ev->tracing.private_data;
}
void tevent_trace_point_callback(struct tevent_context *ev,
enum tevent_trace_point tp)
{
if (ev->tracing.callback != NULL) {
ev->tracing.callback(tp, ev->tracing.private_data);
}
}
tevent-0.9.19/tevent_epoll.c 0000660 0000000 0000000 00000061703 12153373752 015736 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
main select loop and event handling - epoll implementation
Copyright (C) Andrew Tridgell 2003-2005
Copyright (C) Stefan Metzmacher 2005-2013
Copyright (C) Jeremy Allison 2013
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/filesys.h"
#include "system/select.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
struct epoll_event_context {
/* a pointer back to the generic event_context */
struct tevent_context *ev;
/* when using epoll this is the handle from epoll_create */
int epoll_fd;
pid_t pid;
bool panic_force_replay;
bool *panic_state;
bool (*panic_fallback)(struct tevent_context *ev, bool replay);
};
#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT (1<<0)
#define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR (1<<1)
#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR (1<<2)
#define EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX (1<<3)
#ifdef TEST_PANIC_FALLBACK
static int epoll_create_panic_fallback(struct epoll_event_context *epoll_ev,
int size)
{
if (epoll_ev->panic_fallback == NULL) {
return epoll_create(size);
}
/* 50% of the time, fail... */
if ((random() % 2) == 0) {
errno = EINVAL;
return -1;
}
return epoll_create(size);
}
static int epoll_ctl_panic_fallback(struct epoll_event_context *epoll_ev,
int epfd, int op, int fd,
struct epoll_event *event)
{
if (epoll_ev->panic_fallback == NULL) {
return epoll_ctl(epfd, op, fd, event);
}
/* 50% of the time, fail... */
if ((random() % 2) == 0) {
errno = EINVAL;
return -1;
}
return epoll_ctl(epfd, op, fd, event);
}
static int epoll_wait_panic_fallback(struct epoll_event_context *epoll_ev,
int epfd,
struct epoll_event *events,
int maxevents,
int timeout)
{
if (epoll_ev->panic_fallback == NULL) {
return epoll_wait(epfd, events, maxevents, timeout);
}
/* 50% of the time, fail... */
if ((random() % 2) == 0) {
errno = EINVAL;
return -1;
}
return epoll_wait(epfd, events, maxevents, timeout);
}
#define epoll_create(_size) \
epoll_create_panic_fallback(epoll_ev, _size)
#define epoll_ctl(_epfd, _op, _fd, _event) \
epoll_ctl_panic_fallback(epoll_ev,_epfd, _op, _fd, _event)
#define epoll_wait(_epfd, _events, _maxevents, _timeout) \
epoll_wait_panic_fallback(epoll_ev, _epfd, _events, _maxevents, _timeout)
#endif
/*
called to set the panic fallback function.
*/
_PRIVATE_ bool tevent_epoll_set_panic_fallback(struct tevent_context *ev,
bool (*panic_fallback)(struct tevent_context *ev,
bool replay))
{
struct epoll_event_context *epoll_ev;
if (ev->additional_data == NULL) {
return false;
}
epoll_ev = talloc_get_type(ev->additional_data,
struct epoll_event_context);
if (epoll_ev == NULL) {
return false;
}
epoll_ev->panic_fallback = panic_fallback;
return true;
}
/*
called when a epoll call fails
*/
static void epoll_panic(struct epoll_event_context *epoll_ev,
const char *reason, bool replay)
{
struct tevent_context *ev = epoll_ev->ev;
bool (*panic_fallback)(struct tevent_context *ev, bool replay);
panic_fallback = epoll_ev->panic_fallback;
if (epoll_ev->panic_state != NULL) {
*epoll_ev->panic_state = true;
}
if (epoll_ev->panic_force_replay) {
replay = true;
}
TALLOC_FREE(ev->additional_data);
if (panic_fallback == NULL) {
tevent_debug(ev, TEVENT_DEBUG_FATAL,
"%s (%s) replay[%u] - calling abort()\n",
reason, strerror(errno), (unsigned)replay);
abort();
}
tevent_debug(ev, TEVENT_DEBUG_ERROR,
"%s (%s) replay[%u] - calling panic_fallback\n",
reason, strerror(errno), (unsigned)replay);
if (!panic_fallback(ev, replay)) {
/* Fallback failed. */
tevent_debug(ev, TEVENT_DEBUG_FATAL,
"%s (%s) replay[%u] - calling abort()\n",
reason, strerror(errno), (unsigned)replay);
abort();
}
}
/*
map from TEVENT_FD_* to EPOLLIN/EPOLLOUT
*/
static uint32_t epoll_map_flags(uint16_t flags)
{
uint32_t ret = 0;
if (flags & TEVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
if (flags & TEVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
return ret;
}
/*
free the epoll fd
*/
static int epoll_ctx_destructor(struct epoll_event_context *epoll_ev)
{
close(epoll_ev->epoll_fd);
epoll_ev->epoll_fd = -1;
return 0;
}
/*
init the epoll fd
*/
static int epoll_init_ctx(struct epoll_event_context *epoll_ev)
{
epoll_ev->epoll_fd = epoll_create(64);
if (epoll_ev->epoll_fd == -1) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
"Failed to create epoll handle.\n");
return -1;
}
if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
"Failed to set close-on-exec, file descriptor may be leaked to children.\n");
}
epoll_ev->pid = getpid();
talloc_set_destructor(epoll_ev, epoll_ctx_destructor);
return 0;
}
static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde);
/*
reopen the epoll handle when our pid changes
see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an
demonstration of why this is needed
*/
static void epoll_check_reopen(struct epoll_event_context *epoll_ev)
{
struct tevent_fd *fde;
bool *caller_panic_state = epoll_ev->panic_state;
bool panic_triggered = false;
if (epoll_ev->pid == getpid()) {
return;
}
close(epoll_ev->epoll_fd);
epoll_ev->epoll_fd = epoll_create(64);
if (epoll_ev->epoll_fd == -1) {
epoll_panic(epoll_ev, "epoll_create() failed", false);
return;
}
if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
"Failed to set close-on-exec, file descriptor may be leaked to children.\n");
}
epoll_ev->pid = getpid();
epoll_ev->panic_state = &panic_triggered;
for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
epoll_update_event(epoll_ev, fde);
if (panic_triggered) {
if (caller_panic_state != NULL) {
*caller_panic_state = true;
}
return;
}
}
epoll_ev->panic_state = NULL;
}
/*
epoll cannot add the same file descriptor twice, once
with read, once with write which is allowed by the
tevent backend. Multiplex the existing fde, flag it
as such so we can search for the correct fde on
event triggering.
*/
static int epoll_add_multiplex_fd(struct epoll_event_context *epoll_ev,
struct tevent_fd *add_fde)
{
struct epoll_event event;
struct tevent_fd *mpx_fde;
int ret;
/* Find the existing fde that caused the EEXIST error. */
for (mpx_fde = epoll_ev->ev->fd_events; mpx_fde; mpx_fde = mpx_fde->next) {
if (mpx_fde->fd != add_fde->fd) {
continue;
}
if (mpx_fde == add_fde) {
continue;
}
break;
}
if (mpx_fde == NULL) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
"can't find multiplex fde for fd[%d]",
add_fde->fd);
return -1;
}
if (mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
/* Logic error. Can't have more than 2 multiplexed fde's. */
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
"multiplex fde for fd[%d] is already multiplexed\n",
mpx_fde->fd);
return -1;
}
/*
* The multiplex fde must have the same fd, and also
* already have an epoll event attached.
*/
if (!(mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) {
/* Logic error. Can't have more than 2 multiplexed fde's. */
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
"multiplex fde for fd[%d] has no event\n",
mpx_fde->fd);
return -1;
}
/* Modify the mpx_fde to add in the new flags. */
ZERO_STRUCT(event);
event.events = epoll_map_flags(mpx_fde->flags);
event.events |= epoll_map_flags(add_fde->flags);
event.data.ptr = mpx_fde;
ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, mpx_fde->fd, &event);
if (ret != 0 && errno == EBADF) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
"EPOLL_CTL_MOD EBADF for "
"add_fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
add_fde, mpx_fde, add_fde->fd);
DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
mpx_fde->event_ctx = NULL;
DLIST_REMOVE(epoll_ev->ev->fd_events, add_fde);
add_fde->event_ctx = NULL;
return 0;
} else if (ret != 0) {
return ret;
}
/*
* Make each fde->additional_data pointers point at each other
* so we can look them up from each other. They are now paired.
*/
mpx_fde->additional_data = (struct tevent_fd *)add_fde;
add_fde->additional_data = (struct tevent_fd *)mpx_fde;
/* Now flag both fde's as being multiplexed. */
mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
add_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
/* we need to keep the GOT_ERROR flag */
if (mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR) {
add_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
}
return 0;
}
/*
add the epoll event to the given fd_event
*/
static void epoll_add_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
{
struct epoll_event event;
int ret;
struct tevent_fd *mpx_fde = NULL;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
/*
* This is a multiplexed fde, we need to include both
* flags in the modified event.
*/
mpx_fde = talloc_get_type_abort(fde->additional_data,
struct tevent_fd);
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
ZERO_STRUCT(event);
event.events = epoll_map_flags(fde->flags);
if (mpx_fde != NULL) {
event.events |= epoll_map_flags(mpx_fde->flags);
}
event.data.ptr = fde;
ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event);
if (ret != 0 && errno == EBADF) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
"EPOLL_CTL_ADD EBADF for "
"fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
fde, mpx_fde, fde->fd);
DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
fde->event_ctx = NULL;
if (mpx_fde != NULL) {
DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
mpx_fde->event_ctx = NULL;
}
return;
} else if (ret != 0 && errno == EEXIST && mpx_fde == NULL) {
ret = epoll_add_multiplex_fd(epoll_ev, fde);
if (ret != 0) {
epoll_panic(epoll_ev, "epoll_add_multiplex_fd failed",
false);
return;
}
} else if (ret != 0) {
epoll_panic(epoll_ev, "EPOLL_CTL_ADD failed", false);
return;
}
fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
/* only if we want to read we want to tell the event handler about errors */
if (fde->flags & TEVENT_FD_READ) {
fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
if (mpx_fde == NULL) {
return;
}
mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
/* only if we want to read we want to tell the event handler about errors */
if (mpx_fde->flags & TEVENT_FD_READ) {
mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
}
/*
delete the epoll event for given fd_event
*/
static void epoll_del_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
{
struct epoll_event event;
int ret;
struct tevent_fd *mpx_fde = NULL;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
/*
* This is a multiplexed fde, we need to modify both events.
*/
mpx_fde = talloc_get_type_abort(fde->additional_data,
struct tevent_fd);
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
ZERO_STRUCT(event);
ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
if (ret != 0 && errno == ENOENT) {
/*
* This can happen after a epoll_check_reopen
* within epoll_event_fd_destructor.
*/
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_TRACE,
"EPOLL_CTL_DEL ignoring ENOENT for fd[%d]\n",
fde->fd);
return;
} else if (ret != 0 && errno == EBADF) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
"EPOLL_CTL_DEL EBADF for "
"fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
fde, mpx_fde, fde->fd);
DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
fde->event_ctx = NULL;
if (mpx_fde != NULL) {
DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
mpx_fde->event_ctx = NULL;
}
return;
} else if (ret != 0) {
epoll_panic(epoll_ev, "EPOLL_CTL_DEL failed", false);
return;
}
}
/*
change the epoll event to the given fd_event
*/
static void epoll_mod_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
{
struct tevent_fd *mpx_fde = NULL;
struct epoll_event event;
int ret;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
/*
* This is a multiplexed fde, we need to include both
* flags in the modified event.
*/
mpx_fde = talloc_get_type_abort(fde->additional_data,
struct tevent_fd);
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
ZERO_STRUCT(event);
event.events = epoll_map_flags(fde->flags);
if (mpx_fde != NULL) {
event.events |= epoll_map_flags(mpx_fde->flags);
}
event.data.ptr = fde;
ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event);
if (ret != 0 && errno == EBADF) {
tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
"EPOLL_CTL_MOD EBADF for "
"fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
fde, mpx_fde, fde->fd);
DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
fde->event_ctx = NULL;
if (mpx_fde != NULL) {
DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
mpx_fde->event_ctx = NULL;
}
return;
} else if (ret != 0) {
epoll_panic(epoll_ev, "EPOLL_CTL_MOD failed", false);
return;
}
fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
/* only if we want to read we want to tell the event handler about errors */
if (fde->flags & TEVENT_FD_READ) {
fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
if (mpx_fde == NULL) {
return;
}
mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
/* only if we want to read we want to tell the event handler about errors */
if (mpx_fde->flags & TEVENT_FD_READ) {
mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
}
}
static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
{
bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
bool want_read = (fde->flags & TEVENT_FD_READ);
bool want_write= (fde->flags & TEVENT_FD_WRITE);
struct tevent_fd *mpx_fde = NULL;
if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
/*
* work out what the multiplexed fde wants.
*/
mpx_fde = talloc_get_type_abort(fde->additional_data,
struct tevent_fd);
if (mpx_fde->flags & TEVENT_FD_READ) {
want_read = true;
}
if (mpx_fde->flags & TEVENT_FD_WRITE) {
want_write = true;
}
}
/* there's already an event */
if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
if (want_read || (want_write && !got_error)) {
epoll_mod_event(epoll_ev, fde);
return;
}
/*
* if we want to match the select behavior, we need to remove the epoll_event
* when the caller isn't interested in events.
*
* this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
*/
epoll_del_event(epoll_ev, fde);
return;
}
/* there's no epoll_event attached to the fde */
if (want_read || (want_write && !got_error)) {
epoll_add_event(epoll_ev, fde);
return;
}
}
/*
Cope with epoll returning EPOLLHUP|EPOLLERR on an event.
Return true if there's nothing else to do, false if
this event needs further handling.
*/
static bool epoll_handle_hup_or_err(struct epoll_event_context *epoll_ev,
struct tevent_fd *fde)
{
if (fde == NULL) {
/* Nothing to do if no event. */
return true;
}
fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
/*
* if we only wait for TEVENT_FD_WRITE, we should not tell the
* event handler about it, and remove the epoll_event,
* as we only report errors when waiting for read events,
* to match the select() behavior
*/
if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
/*
* Do the same as the poll backend and
* remove the writeable flag.
*/
fde->flags &= ~TEVENT_FD_WRITE;
return true;
}
/* This has TEVENT_FD_READ set, we're not finished. */
return false;
}
/*
event loop handling using epoll
*/
static int epoll_event_loop(struct epoll_event_context *epoll_ev, struct timeval *tvalp)
{
int ret, i;
#define MAXEVENTS 1
struct epoll_event events[MAXEVENTS];
int timeout = -1;
int wait_errno;
if (tvalp) {
/* it's better to trigger timed events a bit later than too early */
timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
}
if (epoll_ev->ev->signal_events &&
tevent_common_check_signal(epoll_ev->ev)) {
return 0;
}
tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
ret = epoll_wait(epoll_ev->epoll_fd, events, MAXEVENTS, timeout);
wait_errno = errno;
tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
if (ret == -1 && wait_errno == EINTR && epoll_ev->ev->signal_events) {
if (tevent_common_check_signal(epoll_ev->ev)) {
return 0;
}
}
if (ret == -1 && wait_errno != EINTR) {
epoll_panic(epoll_ev, "epoll_wait() failed", true);
return -1;
}
if (ret == 0 && tvalp) {
/* we don't care about a possible delay here */
tevent_common_loop_timer_delay(epoll_ev->ev);
return 0;
}
for (i=0;iadditional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
/*
* Save off the multiplexed event in case we need
* to use it to call the handler function.
*/
mpx_fde = talloc_get_type_abort(fde->additional_data,
struct tevent_fd);
}
if (events[i].events & (EPOLLHUP|EPOLLERR)) {
bool handled_fde = epoll_handle_hup_or_err(epoll_ev, fde);
bool handled_mpx = epoll_handle_hup_or_err(epoll_ev, mpx_fde);
if (handled_fde && handled_mpx) {
epoll_update_event(epoll_ev, fde);
continue;
}
if (!handled_mpx) {
/*
* If the mpx event was the one that needs
* further handling, it's the TEVENT_FD_READ
* event so switch over and call that handler.
*/
fde = mpx_fde;
mpx_fde = NULL;
}
flags |= TEVENT_FD_READ;
}
if (events[i].events & EPOLLIN) flags |= TEVENT_FD_READ;
if (events[i].events & EPOLLOUT) flags |= TEVENT_FD_WRITE;
if (flags & TEVENT_FD_WRITE) {
if (fde->flags & TEVENT_FD_WRITE) {
mpx_fde = NULL;
}
if (mpx_fde && mpx_fde->flags & TEVENT_FD_WRITE) {
fde = mpx_fde;
mpx_fde = NULL;
}
}
if (mpx_fde) {
/* Ensure we got the right fde. */
if ((flags & fde->flags) == 0) {
fde = mpx_fde;
mpx_fde = NULL;
}
}
/*
* make sure we only pass the flags
* the handler is expecting.
*/
flags &= fde->flags;
if (flags) {
fde->handler(epoll_ev->ev, fde, flags, fde->private_data);
break;
}
}
return 0;
}
/*
create a epoll_event_context structure.
*/
static int epoll_event_context_init(struct tevent_context *ev)
{
int ret;
struct epoll_event_context *epoll_ev;
/*
* We might be called during tevent_re_initialise()
* which means we need to free our old additional_data.
*/
TALLOC_FREE(ev->additional_data);
epoll_ev = talloc_zero(ev, struct epoll_event_context);
if (!epoll_ev) return -1;
epoll_ev->ev = ev;
epoll_ev->epoll_fd = -1;
ret = epoll_init_ctx(epoll_ev);
if (ret != 0) {
talloc_free(epoll_ev);
return ret;
}
ev->additional_data = epoll_ev;
return 0;
}
/*
destroy an fd_event
*/
static int epoll_event_fd_destructor(struct tevent_fd *fde)
{
struct tevent_context *ev = fde->event_ctx;
struct epoll_event_context *epoll_ev = NULL;
bool panic_triggered = false;
struct tevent_fd *mpx_fde = NULL;
int flags = fde->flags;
if (ev == NULL) {
return tevent_common_fd_destructor(fde);
}
epoll_ev = talloc_get_type_abort(ev->additional_data,
struct epoll_event_context);
/*
* we must remove the event from the list
* otherwise a panic fallback handler may
* reuse invalid memory
*/
DLIST_REMOVE(ev->fd_events, fde);
if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
mpx_fde = talloc_get_type_abort(fde->additional_data,
struct tevent_fd);
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
fde->additional_data = NULL;
mpx_fde->additional_data = NULL;
fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
}
epoll_ev->panic_state = &panic_triggered;
epoll_check_reopen(epoll_ev);
if (panic_triggered) {
return tevent_common_fd_destructor(fde);
}
if (mpx_fde != NULL) {
epoll_update_event(epoll_ev, mpx_fde);
if (panic_triggered) {
return tevent_common_fd_destructor(fde);
}
}
fde->flags = 0;
epoll_update_event(epoll_ev, fde);
fde->flags = flags;
if (panic_triggered) {
return tevent_common_fd_destructor(fde);
}
epoll_ev->panic_state = NULL;
return tevent_common_fd_destructor(fde);
}
/*
add a fd based event
return NULL on failure (memory allocation error)
*/
static struct tevent_fd *epoll_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
struct epoll_event_context);
struct tevent_fd *fde;
bool panic_triggered = false;
fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
handler, private_data,
handler_name, location);
if (!fde) return NULL;
talloc_set_destructor(fde, epoll_event_fd_destructor);
epoll_ev->panic_state = &panic_triggered;
epoll_check_reopen(epoll_ev);
if (panic_triggered) {
return fde;
}
epoll_ev->panic_state = NULL;
epoll_update_event(epoll_ev, fde);
return fde;
}
/*
set the fd event flags
*/
static void epoll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
{
struct tevent_context *ev;
struct epoll_event_context *epoll_ev;
bool panic_triggered = false;
if (fde->flags == flags) return;
ev = fde->event_ctx;
epoll_ev = talloc_get_type(ev->additional_data, struct epoll_event_context);
fde->flags = flags;
epoll_ev->panic_state = &panic_triggered;
epoll_check_reopen(epoll_ev);
if (panic_triggered) {
return;
}
epoll_ev->panic_state = NULL;
epoll_update_event(epoll_ev, fde);
}
/*
do a single event loop using the events defined in ev
*/
static int epoll_event_loop_once(struct tevent_context *ev, const char *location)
{
struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
struct epoll_event_context);
struct timeval tval;
bool panic_triggered = false;
if (ev->signal_events &&
tevent_common_check_signal(ev)) {
return 0;
}
if (ev->immediate_events &&
tevent_common_loop_immediate(ev)) {
return 0;
}
tval = tevent_common_loop_timer_delay(ev);
if (tevent_timeval_is_zero(&tval)) {
return 0;
}
epoll_ev->panic_state = &panic_triggered;
epoll_ev->panic_force_replay = true;
epoll_check_reopen(epoll_ev);
if (panic_triggered) {
errno = EINVAL;
return -1;
}
epoll_ev->panic_force_replay = false;
epoll_ev->panic_state = NULL;
return epoll_event_loop(epoll_ev, &tval);
}
static const struct tevent_ops epoll_event_ops = {
.context_init = epoll_event_context_init,
.add_fd = epoll_event_add_fd,
.set_fd_close_fn = tevent_common_fd_set_close_fn,
.get_fd_flags = tevent_common_fd_get_flags,
.set_fd_flags = epoll_event_set_fd_flags,
.add_timer = tevent_common_add_timer_v2,
.schedule_immediate = tevent_common_schedule_immediate,
.add_signal = tevent_common_add_signal,
.loop_once = epoll_event_loop_once,
.loop_wait = tevent_common_loop_wait,
};
_PRIVATE_ bool tevent_epoll_init(void)
{
return tevent_register_backend("epoll", &epoll_event_ops);
}
tevent-0.9.19/tevent_fd.c 0000660 0000000 0000000 00000004771 12101212317 015174 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
common events code for fd events
Copyright (C) Stefan Metzmacher 2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
int tevent_common_fd_destructor(struct tevent_fd *fde)
{
if (fde->event_ctx) {
DLIST_REMOVE(fde->event_ctx->fd_events, fde);
}
if (fde->close_fn) {
fde->close_fn(fde->event_ctx, fde, fde->fd, fde->private_data);
fde->fd = -1;
}
return 0;
}
struct tevent_fd *tevent_common_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
struct tevent_fd *fde;
/* tevent will crash later on select() if we save
* a negative file descriptor. Better to fail here
* so that consumers will be able to debug it
*/
if (fd < 0) return NULL;
fde = talloc(mem_ctx?mem_ctx:ev, struct tevent_fd);
if (!fde) return NULL;
fde->event_ctx = ev;
fde->fd = fd;
fde->flags = flags;
fde->handler = handler;
fde->close_fn = NULL;
fde->private_data = private_data;
fde->handler_name = handler_name;
fde->location = location;
fde->additional_flags = 0;
fde->additional_data = NULL;
DLIST_ADD(ev->fd_events, fde);
talloc_set_destructor(fde, tevent_common_fd_destructor);
return fde;
}
uint16_t tevent_common_fd_get_flags(struct tevent_fd *fde)
{
return fde->flags;
}
void tevent_common_fd_set_flags(struct tevent_fd *fde, uint16_t flags)
{
if (fde->flags == flags) return;
fde->flags = flags;
}
void tevent_common_fd_set_close_fn(struct tevent_fd *fde,
tevent_fd_close_fn_t close_fn)
{
fde->close_fn = close_fn;
}
tevent-0.9.19/tevent_immediate.c 0000660 0000000 0000000 00000006674 11741275274 016571 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
common events code for immediate events
Copyright (C) Stefan Metzmacher 2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
static void tevent_common_immediate_cancel(struct tevent_immediate *im)
{
if (!im->event_ctx) {
return;
}
tevent_debug(im->event_ctx, TEVENT_DEBUG_TRACE,
"Cancel immediate event %p \"%s\"\n",
im, im->handler_name);
/* let the backend free im->additional_data */
if (im->cancel_fn) {
im->cancel_fn(im);
}
DLIST_REMOVE(im->event_ctx->immediate_events, im);
im->event_ctx = NULL;
im->handler = NULL;
im->private_data = NULL;
im->handler_name = NULL;
im->schedule_location = NULL;
im->cancel_fn = NULL;
im->additional_data = NULL;
talloc_set_destructor(im, NULL);
}
/*
destroy an immediate event
*/
static int tevent_common_immediate_destructor(struct tevent_immediate *im)
{
tevent_common_immediate_cancel(im);
return 0;
}
/*
* schedule an immediate event on
*/
void tevent_common_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ev,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
tevent_common_immediate_cancel(im);
if (!handler) {
return;
}
im->event_ctx = ev;
im->handler = handler;
im->private_data = private_data;
im->handler_name = handler_name;
im->schedule_location = location;
im->cancel_fn = NULL;
im->additional_data = NULL;
DLIST_ADD_END(ev->immediate_events, im, struct tevent_immediate *);
talloc_set_destructor(im, tevent_common_immediate_destructor);
tevent_debug(ev, TEVENT_DEBUG_TRACE,
"Schedule immediate event \"%s\": %p\n",
handler_name, im);
}
/*
trigger the first immediate event and return true
if no event was triggered return false
*/
bool tevent_common_loop_immediate(struct tevent_context *ev)
{
struct tevent_immediate *im = ev->immediate_events;
tevent_immediate_handler_t handler;
void *private_data;
if (!im) {
return false;
}
tevent_debug(ev, TEVENT_DEBUG_TRACE,
"Run immediate event \"%s\": %p\n",
im->handler_name, im);
/*
* remember the handler and then clear the event
* the handler might reschedule the event
*/
handler = im->handler;
private_data = im->private_data;
DLIST_REMOVE(im->event_ctx->immediate_events, im);
im->event_ctx = NULL;
im->handler = NULL;
im->private_data = NULL;
im->handler_name = NULL;
im->schedule_location = NULL;
im->cancel_fn = NULL;
im->additional_data = NULL;
talloc_set_destructor(im, NULL);
handler(ev, im, private_data);
return true;
}
tevent-0.9.19/tevent_internal.h 0000660 0000000 0000000 00000023343 12153373752 016442 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
generalised event loop handling
INTERNAL STRUCTS. THERE ARE NO API GUARANTEES.
External users should only ever have to include this header when
implementing new tevent backends.
Copyright (C) Stefan Metzmacher 2005-2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
struct tevent_req {
/**
* @brief What to do on completion
*
* This is used for the user of an async request, fn is called when
* the request completes, either successfully or with an error.
*/
struct {
/**
* @brief Completion function
* Completion function, to be filled by the API user
*/
tevent_req_fn fn;
/**
* @brief Private data for the completion function
*/
void *private_data;
} async;
/**
* @brief Private state pointer for the actual implementation
*
* The implementation doing the work for the async request needs to
* keep around current data like for example a fd event. The user of
* an async request should not touch this.
*/
void *data;
/**
* @brief A function to overwrite the default print function
*
* The implementation doing the work may want to implement a
* custom function to print the text representation of the async
* request.
*/
tevent_req_print_fn private_print;
/**
* @brief A function to cancel the request
*
* The implementation might want to set a function
* that is called when the tevent_req_cancel() function
* was called.
*/
tevent_req_cancel_fn private_cancel;
/**
* @brief Internal state of the request
*
* Callers should only access this via functions and never directly.
*/
struct {
/**
* @brief The talloc type of the data pointer
*
* This is filled by the tevent_req_create() macro.
*
* This for debugging only.
*/
const char *private_type;
/**
* @brief The location where the request was created
*
* This uses the __location__ macro via the tevent_req_create()
* macro.
*
* This for debugging only.
*/
const char *create_location;
/**
* @brief The location where the request was finished
*
* This uses the __location__ macro via the tevent_req_done(),
* tevent_req_error() or tevent_req_nomem() macro.
*
* This for debugging only.
*/
const char *finish_location;
/**
* @brief The location where the request was canceled
*
* This uses the __location__ macro via the
* tevent_req_cancel() macro.
*
* This for debugging only.
*/
const char *cancel_location;
/**
* @brief The external state - will be queried by the caller
*
* While the async request is being processed, state will remain in
* TEVENT_REQ_IN_PROGRESS. A request is finished if
* req->state>=TEVENT_REQ_DONE.
*/
enum tevent_req_state state;
/**
* @brief status code when finished
*
* This status can be queried in the async completion function. It
* will be set to 0 when everything went fine.
*/
uint64_t error;
/**
* @brief the immediate event used by tevent_req_post
*
*/
struct tevent_immediate *trigger;
/**
* @brief An event context which will be used to
* defer the _tevent_req_notify_callback().
*/
struct tevent_context *defer_callback_ev;
/**
* @brief the timer event if tevent_req_set_endtime was used
*
*/
struct tevent_timer *timer;
} internal;
};
struct tevent_fd {
struct tevent_fd *prev, *next;
struct tevent_context *event_ctx;
int fd;
uint16_t flags; /* see TEVENT_FD_* flags */
tevent_fd_handler_t handler;
tevent_fd_close_fn_t close_fn;
/* this is private for the specific handler */
void *private_data;
/* this is for debugging only! */
const char *handler_name;
const char *location;
/* this is private for the events_ops implementation */
uint64_t additional_flags;
void *additional_data;
};
struct tevent_timer {
struct tevent_timer *prev, *next;
struct tevent_context *event_ctx;
struct timeval next_event;
tevent_timer_handler_t handler;
/* this is private for the specific handler */
void *private_data;
/* this is for debugging only! */
const char *handler_name;
const char *location;
/* this is private for the events_ops implementation */
void *additional_data;
};
struct tevent_immediate {
struct tevent_immediate *prev, *next;
struct tevent_context *event_ctx;
tevent_immediate_handler_t handler;
/* this is private for the specific handler */
void *private_data;
/* this is for debugging only! */
const char *handler_name;
const char *create_location;
const char *schedule_location;
/* this is private for the events_ops implementation */
void (*cancel_fn)(struct tevent_immediate *im);
void *additional_data;
};
struct tevent_signal {
struct tevent_signal *prev, *next;
struct tevent_context *event_ctx;
int signum;
int sa_flags;
tevent_signal_handler_t handler;
/* this is private for the specific handler */
void *private_data;
/* this is for debugging only! */
const char *handler_name;
const char *location;
/* this is private for the events_ops implementation */
void *additional_data;
};
struct tevent_debug_ops {
void (*debug)(void *context, enum tevent_debug_level level,
const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
void *context;
};
void tevent_debug(struct tevent_context *ev, enum tevent_debug_level level,
const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
struct tevent_context {
/* the specific events implementation */
const struct tevent_ops *ops;
/* list of fd events - used by common code */
struct tevent_fd *fd_events;
/* list of timed events - used by common code */
struct tevent_timer *timer_events;
/* list of immediate events - used by common code */
struct tevent_immediate *immediate_events;
/* list of signal events - used by common code */
struct tevent_signal *signal_events;
/* this is private for the events_ops implementation */
void *additional_data;
/* pipe hack used with signal handlers */
struct tevent_fd *pipe_fde;
int pipe_fds[2];
/* debugging operations */
struct tevent_debug_ops debug_ops;
/* info about the nesting status */
struct {
bool allowed;
uint32_t level;
tevent_nesting_hook hook_fn;
void *hook_private;
} nesting;
struct {
tevent_trace_callback_t callback;
void *private_data;
} tracing;
/*
* an optimization pointer into timer_events
* used by used by common code via
* tevent_common_add_timer_v2()
*/
struct tevent_timer *last_zero_timer;
};
const struct tevent_ops *tevent_find_ops_byname(const char *name);
int tevent_common_context_destructor(struct tevent_context *ev);
int tevent_common_loop_wait(struct tevent_context *ev,
const char *location);
int tevent_common_fd_destructor(struct tevent_fd *fde);
struct tevent_fd *tevent_common_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd,
uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
void tevent_common_fd_set_close_fn(struct tevent_fd *fde,
tevent_fd_close_fn_t close_fn);
uint16_t tevent_common_fd_get_flags(struct tevent_fd *fde);
void tevent_common_fd_set_flags(struct tevent_fd *fde, uint16_t flags);
struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
struct tevent_timer *tevent_common_add_timer_v2(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
struct timeval tevent_common_loop_timer_delay(struct tevent_context *);
void tevent_common_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ev,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
bool tevent_common_loop_immediate(struct tevent_context *ev);
struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum,
int sa_flags,
tevent_signal_handler_t handler,
void *private_data,
const char *handler_name,
const char *location);
int tevent_common_check_signal(struct tevent_context *ev);
void tevent_cleanup_pending_signal_handlers(struct tevent_signal *se);
bool tevent_standard_init(void);
bool tevent_select_init(void);
bool tevent_poll_init(void);
void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
struct tevent_fd *fde);
bool tevent_poll_mt_init(void);
#ifdef HAVE_EPOLL
bool tevent_epoll_init(void);
bool tevent_epoll_set_panic_fallback(struct tevent_context *ev,
bool (*panic_fallback)(struct tevent_context *ev,
bool replay));
#endif
void tevent_trace_point_callback(struct tevent_context *ev,
enum tevent_trace_point);
tevent-0.9.19/tevent_liboop.c 0000660 0000000 0000000 00000015760 12153373752 016111 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
main select loop and event handling
wrapper for http://git.lysator.liu.se/liboop/
Copyright (C) Stefan Metzmacher 2005
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "events.h"
#include "events_internal.h"
#include
/*
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
NOTE: this code compiles fine, but is completely *UNTESTED*
and is only committed as an example
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*/
static int oop_event_context_destructor(struct tevent_context *ev)
{
oop_source_sys *oop_sys = ev->additional_data;
oop_sys_delete(oop_sys);
return 0;
}
/*
create a oop_event_context structure.
*/
static int oop_event_context_init(struct tevent_context *ev, void *private_data)
{
oop_source_sys *oop_sys = private_data;
if (!oop_sys) {
oop_sys = oop_sys_new();
if (!oop_sys) {
return -1;
}
talloc_set_destructor(ev, oop_event_context_destructor);
}
ev->additional_data = oop_sys;
return 0;
}
static void *oop_event_fd_handler(oop_source *oop, int fd, oop_event oop_type, void *ptr)
{
struct tevent_fd *fde = ptr;
if (fd != fde->fd) return OOP_ERROR;
switch(oop_type) {
case OOP_READ:
fde->handler(fde->event_ctx, fde, EVENT_FD_READ, fde->private_data);
return OOP_CONTINUE;
case OOP_WRITE:
fde->handler(fde->event_ctx, fde, EVENT_FD_WRITE, fde->private_data);
return OOP_CONTINUE;
case OOP_EXCEPTION:
return OOP_ERROR;
case OOP_NUM_EVENTS:
return OOP_ERROR;
}
return OOP_ERROR;
}
/*
destroy an fd_event
*/
static int oop_event_fd_destructor(struct tevent_fd *fde)
{
struct tevent_context *ev = fde->event_ctx;
oop_source_sys *oop_sys = ev->additional_data;
oop_source *oop = oop_sys_source(oop_sys);
if (fde->flags & EVENT_FD_READ)
oop->cancel_fd(oop, fde->fd, OOP_READ);
if (fde->flags & EVENT_FD_WRITE)
oop->cancel_fd(oop, fde->fd, OOP_WRITE);
if (fde->flags & EVENT_FD_AUTOCLOSE) {
close(fde->fd);
fde->fd = -1;
}
return 0;
}
/*
add a fd based event
return NULL on failure (memory allocation error)
*/
static struct tevent_fd *oop_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
event_fd_handler_t handler,
void *private_data)
{
struct tevent_fd *fde;
oop_source_sys *oop_sys = ev->additional_data;
oop_source *oop = oop_sys_source(oop_sys);
fde = talloc(mem_ctx?mem_ctx:ev, struct tevent_fd);
if (!fde) return NULL;
fde->event_ctx = ev;
fde->fd = fd;
fde->flags = flags;
fde->handler = handler;
fde->private_data = private_data;
fde->additional_flags = 0;
fde->additional_data = NULL;
if (fde->flags & EVENT_FD_READ)
oop->on_fd(oop, fde->fd, OOP_READ, oop_event_fd_handler, fde);
if (fde->flags & EVENT_FD_WRITE)
oop->on_fd(oop, fde->fd, OOP_WRITE, oop_event_fd_handler, fde);
talloc_set_destructor(fde, oop_event_fd_destructor);
return fde;
}
/*
return the fd event flags
*/
static uint16_t oop_event_get_fd_flags(struct tevent_fd *fde)
{
return fde->flags;
}
/*
set the fd event flags
*/
static void oop_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
{
oop_source_sys *oop_sys;
oop_source *oop;
oop_sys = fde->event_ctx->additional_data;
oop = oop_sys_source(oop_sys);
if ((fde->flags & EVENT_FD_READ)&&(!(flags & EVENT_FD_READ)))
oop->cancel_fd(oop, fde->fd, OOP_READ);
if ((!(fde->flags & EVENT_FD_READ))&&(flags & EVENT_FD_READ))
oop->on_fd(oop, fde->fd, OOP_READ, oop_event_fd_handler, fde);
if ((fde->flags & EVENT_FD_WRITE)&&(!(flags & EVENT_FD_WRITE)))
oop->cancel_fd(oop, fde->fd, OOP_WRITE);
if ((!(fde->flags & EVENT_FD_WRITE))&&(flags & EVENT_FD_WRITE))
oop->on_fd(oop, fde->fd, OOP_WRITE, oop_event_fd_handler, fde);
fde->flags = flags;
}
static int oop_event_timed_destructor(struct tevent_timer *te);
static int oop_event_timed_deny_destructor(struct tevent_timer *te)
{
return -1;
}
static void *oop_event_timed_handler(oop_source *oop, struct timeval t, void *ptr)
{
struct tevent_timer *te = ptr;
/* deny the handler to free the event */
talloc_set_destructor(te, oop_event_timed_deny_destructor);
te->handler(te->event_ctx, te, t, te->private_data);
talloc_set_destructor(te, oop_event_timed_destructor);
talloc_free(te);
return OOP_CONTINUE;
}
/*
destroy a timed event
*/
static int oop_event_timed_destructor(struct tevent_timer *te)
{
struct tevent_context *ev = te->event_ctx;
oop_source_sys *oop_sys = ev->additional_data;
oop_source *oop = oop_sys_source(oop_sys);
oop->cancel_time(oop, te->next_event, oop_event_timed_handler, te);
return 0;
}
/*
add a timed event
return NULL on failure (memory allocation error)
*/
static struct tevent_timer *oop_event_add_timed(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
struct timeval next_event,
event_timed_handler_t handler,
void *private_data)
{
oop_source_sys *oop_sys = ev->additional_data;
oop_source *oop = oop_sys_source(oop_sys);
struct tevent_timer *te;
te = talloc(mem_ctx?mem_ctx:ev, struct tevent_timer);
if (te == NULL) return NULL;
te->event_ctx = ev;
te->next_event = next_event;
te->handler = handler;
te->private_data = private_data;
te->additional_data = NULL;
oop->on_time(oop, te->next_event, oop_event_timed_handler, te);
talloc_set_destructor(te, oop_event_timed_destructor);
return te;
}
/*
do a single event loop using the events defined in ev
*/
static int oop_event_loop_once(struct tevent_context *ev)
{
void *oop_ret;
oop_source_sys *oop_sys = ev->additional_data;
oop_ret = oop_sys_run_once(oop_sys);
if (oop_ret == OOP_CONTINUE) {
return 0;
}
return -1;
}
/*
return on failure or (with 0) if all fd events are removed
*/
static int oop_event_loop_wait(struct tevent_context *ev)
{
void *oop_ret;
oop_source_sys *oop_sys = ev->additional_data;
oop_ret = oop_sys_run(oop_sys);
if (oop_ret == OOP_CONTINUE) {
return 0;
}
return -1;
}
static const struct event_ops event_oop_ops = {
.context_init = oop_event_context_init,
.add_fd = oop_event_add_fd,
.get_fd_flags = oop_event_get_fd_flags,
.set_fd_flags = oop_event_set_fd_flags,
.add_timer = oop_event_add_timed,
.add_signal = common_event_add_signal,
.loop_once = oop_event_loop_once,
.loop_wait = oop_event_loop_wait,
};
const struct event_ops *event_liboop_get_ops(void)
{
return &event_oop_ops;
}
tevent-0.9.19/tevent_poll.c 0000660 0000000 0000000 00000040724 12162141064 015556 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
main select loop and event handling
Copyright (C) Andrew Tridgell 2003-2005
Copyright (C) Stefan Metzmacher 2005-2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/filesys.h"
#include "system/select.h"
#include "tevent.h"
#include "tevent_util.h"
#include "tevent_internal.h"
struct poll_event_context {
/* a pointer back to the generic event_context */
struct tevent_context *ev;
/*
* A DLIST for fresh fde's added by poll_event_add_fd but not
* picked up yet by poll_event_loop_once
*/
struct tevent_fd *fresh;
/*
* A DLIST for disabled fde's.
*/
struct tevent_fd *disabled;
/*
* one or more events were deleted or disabled
*/
bool deleted;
/*
* These two arrays are maintained together.
*/
struct pollfd *fds;
struct tevent_fd **fdes;
unsigned num_fds;
/*
* Signal fd to wake the poll() thread
*/
int signal_fd;
/* information for exiting from the event loop */
int exit_code;
};
static int poll_event_context_destructor(struct poll_event_context *poll_ev)
{
struct tevent_fd *fd, *fn;
for (fd = poll_ev->fresh; fd; fd = fn) {
fn = fd->next;
fd->event_ctx = NULL;
DLIST_REMOVE(poll_ev->fresh, fd);
}
for (fd = poll_ev->disabled; fd; fd = fn) {
fn = fd->next;
fd->event_ctx = NULL;
DLIST_REMOVE(poll_ev->disabled, fd);
}
if (poll_ev->signal_fd == -1) {
/*
* Non-threaded, no signal pipe
*/
return 0;
}
close(poll_ev->signal_fd);
poll_ev->signal_fd = -1;
if (poll_ev->num_fds == 0) {
return 0;
}
if (poll_ev->fds[0].fd != -1) {
close(poll_ev->fds[0].fd);
poll_ev->fds[0].fd = -1;
}
return 0;
}
/*
create a poll_event_context structure.
*/
static int poll_event_context_init(struct tevent_context *ev)
{
struct poll_event_context *poll_ev;
/*
* we might be called during tevent_re_initialise()
* which means we need to free our old additional_data
* in order to detach old fd events from the
* poll_ev->fresh list
*/
TALLOC_FREE(ev->additional_data);
poll_ev = talloc_zero(ev, struct poll_event_context);
if (poll_ev == NULL) {
return -1;
}
poll_ev->ev = ev;
poll_ev->signal_fd = -1;
ev->additional_data = poll_ev;
talloc_set_destructor(poll_ev, poll_event_context_destructor);
return 0;
}
static bool set_nonblock(int fd)
{
int val;
val = fcntl(fd, F_GETFL, 0);
if (val == -1) {
return false;
}
val |= O_NONBLOCK;
return (fcntl(fd, F_SETFL, val) != -1);
}
static int poll_event_context_init_mt(struct tevent_context *ev)
{
struct poll_event_context *poll_ev;
struct pollfd *pfd;
int fds[2];
int ret;
ret = poll_event_context_init(ev);
if (ret == -1) {
return ret;
}
poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
poll_ev->fds = talloc_zero(poll_ev, struct pollfd);
if (poll_ev->fds == NULL) {
return -1;
}
ret = pipe(fds);
if (ret == -1) {
return -1;
}
if (!set_nonblock(fds[0]) || !set_nonblock(fds[1])) {
close(fds[0]);
close(fds[1]);
return -1;
}
poll_ev->signal_fd = fds[1];
pfd = &poll_ev->fds[0];
pfd->fd = fds[0];
pfd->events = (POLLIN|POLLHUP);
poll_ev->num_fds = 1;
talloc_set_destructor(poll_ev, poll_event_context_destructor);
return 0;
}
static void poll_event_wake_pollthread(struct poll_event_context *poll_ev)
{
char c;
ssize_t ret;
if (poll_ev->signal_fd == -1) {
return;
}
c = 0;
do {
ret = write(poll_ev->signal_fd, &c, sizeof(c));
} while ((ret == -1) && (errno == EINTR));
}
static void poll_event_drain_signal_fd(struct poll_event_context *poll_ev)
{
char buf[16];
ssize_t ret;
int fd;
if (poll_ev->signal_fd == -1) {
return;
}
if (poll_ev->num_fds < 1) {
return;
}
fd = poll_ev->fds[0].fd;
do {
ret = read(fd, buf, sizeof(buf));
} while (ret == sizeof(buf));
}
/*
destroy an fd_event
*/
static int poll_event_fd_destructor(struct tevent_fd *fde)
{
struct tevent_context *ev = fde->event_ctx;
struct poll_event_context *poll_ev;
uint64_t del_idx = fde->additional_flags;
if (ev == NULL) {
goto done;
}
poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
if (del_idx == UINT64_MAX) {
struct tevent_fd **listp =
(struct tevent_fd **)fde->additional_data;
DLIST_REMOVE((*listp), fde);
goto done;
}
poll_ev->fdes[del_idx] = NULL;
poll_ev->deleted = true;
poll_event_wake_pollthread(poll_ev);
done:
return tevent_common_fd_destructor(fde);
}
static void poll_event_schedule_immediate(struct tevent_immediate *im,
struct tevent_context *ev,
tevent_immediate_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
struct poll_event_context *poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
tevent_common_schedule_immediate(im, ev, handler, private_data,
handler_name, location);
poll_event_wake_pollthread(poll_ev);
}
/*
Private function called by "standard" backend fallback.
Note this only allows fallback to "poll" backend, not "poll-mt".
*/
_PRIVATE_ void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
struct tevent_fd *fde)
{
struct poll_event_context *poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
struct tevent_fd **listp;
if (fde->flags != 0) {
listp = &poll_ev->fresh;
} else {
listp = &poll_ev->disabled;
}
fde->additional_flags = UINT64_MAX;
fde->additional_data = listp;
DLIST_ADD((*listp), fde);
talloc_set_destructor(fde, poll_event_fd_destructor);
}
/*
add a fd based event
return NULL on failure (memory allocation error)
*/
static struct tevent_fd *poll_event_add_fd(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
struct poll_event_context *poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
struct tevent_fd *fde;
if (fd < 0) {
return NULL;
}
fde = talloc(mem_ctx ? mem_ctx : ev, struct tevent_fd);
if (fde == NULL) {
return NULL;
}
fde->event_ctx = ev;
fde->fd = fd;
fde->flags = flags;
fde->handler = handler;
fde->close_fn = NULL;
fde->private_data = private_data;
fde->handler_name = handler_name;
fde->location = location;
fde->additional_flags = UINT64_MAX;
fde->additional_data = NULL;
tevent_poll_event_add_fd_internal(ev, fde);
poll_event_wake_pollthread(poll_ev);
/*
* poll_event_loop_poll will take care of the rest in
* poll_event_setup_fresh
*/
return fde;
}
/*
set the fd event flags
*/
static void poll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
{
struct tevent_context *ev = fde->event_ctx;
struct poll_event_context *poll_ev;
uint64_t idx = fde->additional_flags;
uint16_t pollflags;
if (ev == NULL) {
return;
}
poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
fde->flags = flags;
if (idx == UINT64_MAX) {
struct tevent_fd **listp =
(struct tevent_fd **)fde->additional_data;
/*
* We move it between the fresh and disabled lists.
*/
DLIST_REMOVE((*listp), fde);
tevent_poll_event_add_fd_internal(ev, fde);
poll_event_wake_pollthread(poll_ev);
return;
}
if (fde->flags == 0) {
/*
* We need to remove it from the array
* and move it to the disabled list.
*/
poll_ev->fdes[idx] = NULL;
poll_ev->deleted = true;
DLIST_REMOVE(ev->fd_events, fde);
tevent_poll_event_add_fd_internal(ev, fde);
poll_event_wake_pollthread(poll_ev);
return;
}
pollflags = 0;
if (flags & TEVENT_FD_READ) {
pollflags |= (POLLIN|POLLHUP);
}
if (flags & TEVENT_FD_WRITE) {
pollflags |= (POLLOUT);
}
poll_ev->fds[idx].events = pollflags;
poll_event_wake_pollthread(poll_ev);
}
static bool poll_event_setup_fresh(struct tevent_context *ev,
struct poll_event_context *poll_ev)
{
struct tevent_fd *fde, *next;
unsigned num_fresh, num_fds;
if (poll_ev->deleted) {
unsigned first_fd = (poll_ev->signal_fd != -1) ? 1 : 0;
unsigned i;
for (i=first_fd; i < poll_ev->num_fds;) {
fde = poll_ev->fdes[i];
if (fde != NULL) {
i++;
continue;
}
/*
* This fde was talloc_free()'ed. Delete it
* from the arrays
*/
poll_ev->num_fds -= 1;
if (poll_ev->num_fds == i) {
break;
}
poll_ev->fds[i] = poll_ev->fds[poll_ev->num_fds];
poll_ev->fdes[i] = poll_ev->fdes[poll_ev->num_fds];
if (poll_ev->fdes[i] != NULL) {
poll_ev->fdes[i]->additional_flags = i;
}
}
poll_ev->deleted = false;
}
if (poll_ev->fresh == NULL) {
return true;
}
num_fresh = 0;
for (fde = poll_ev->fresh; fde; fde = fde->next) {
num_fresh += 1;
}
num_fds = poll_ev->num_fds + num_fresh;
/*
* We check the length of fdes here. It is the last one
* enlarged, so if the realloc for poll_fd->fdes fails,
* poll_fd->fds will have at least the size of poll_fd->fdes
*/
if (num_fds >= talloc_array_length(poll_ev->fdes)) {
struct pollfd *tmp_fds;
struct tevent_fd **tmp_fdes;
unsigned array_length;
array_length = (num_fds + 15) & ~15; /* round up to 16 */
tmp_fds = talloc_realloc(
poll_ev, poll_ev->fds, struct pollfd, array_length);
if (tmp_fds == NULL) {
return false;
}
poll_ev->fds = tmp_fds;
tmp_fdes = talloc_realloc(
poll_ev, poll_ev->fdes, struct tevent_fd *,
array_length);
if (tmp_fdes == NULL) {
return false;
}
poll_ev->fdes = tmp_fdes;
}
for (fde = poll_ev->fresh; fde; fde = next) {
struct pollfd *pfd;
pfd = &poll_ev->fds[poll_ev->num_fds];
pfd->fd = fde->fd;
pfd->events = 0;
pfd->revents = 0;
if (fde->flags & TEVENT_FD_READ) {
pfd->events |= (POLLIN|POLLHUP);
}
if (fde->flags & TEVENT_FD_WRITE) {
pfd->events |= (POLLOUT);
}
fde->additional_flags = poll_ev->num_fds;
poll_ev->fdes[poll_ev->num_fds] = fde;
next = fde->next;
DLIST_REMOVE(poll_ev->fresh, fde);
DLIST_ADD(ev->fd_events, fde);
poll_ev->num_fds += 1;
}
return true;
}
/*
event loop handling using poll()
*/
static int poll_event_loop_poll(struct tevent_context *ev,
struct timeval *tvalp)
{
struct poll_event_context *poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
int pollrtn;
int timeout = -1;
int poll_errno;
struct tevent_fd *fde = NULL;
unsigned i;
if (ev->signal_events && tevent_common_check_signal(ev)) {
return 0;
}
if (tvalp != NULL) {
timeout = tvalp->tv_sec * 1000;
timeout += (tvalp->tv_usec + 999) / 1000;
}
poll_event_drain_signal_fd(poll_ev);
if (!poll_event_setup_fresh(ev, poll_ev)) {
return -1;
}
tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
pollrtn = poll(poll_ev->fds, poll_ev->num_fds, timeout);
poll_errno = errno;
tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
if (pollrtn == -1 && poll_errno == EINTR && ev->signal_events) {
tevent_common_check_signal(ev);
return 0;
}
if (pollrtn == 0 && tvalp) {
/* we don't care about a possible delay here */
tevent_common_loop_timer_delay(ev);
return 0;
}
if (pollrtn <= 0) {
/*
* No fd's ready
*/
return 0;
}
/* at least one file descriptor is ready - check
which ones and call the handler, being careful to allow
the handler to remove itself when called */
for (fde = ev->fd_events; fde; fde = fde->next) {
uint64_t idx = fde->additional_flags;
struct pollfd *pfd;
uint16_t flags = 0;
if (idx == UINT64_MAX) {
continue;
}
pfd = &poll_ev->fds[idx];
if (pfd->revents & POLLNVAL) {
/*
* the socket is dead! this should never
* happen as the socket should have first been
* made readable and that should have removed
* the event, so this must be a bug.
*
* We ignore it here to match the epoll
* behavior.
*/
tevent_debug(ev, TEVENT_DEBUG_ERROR,
"POLLNVAL on fde[%p] fd[%d] - disabling\n",
fde, pfd->fd);
poll_ev->fdes[idx] = NULL;
poll_ev->deleted = true;
DLIST_REMOVE(ev->fd_events, fde);
fde->event_ctx = NULL;
continue;
}
if (pfd->revents & (POLLHUP|POLLERR)) {
/* If we only wait for TEVENT_FD_WRITE, we
should not tell the event handler about it,
and remove the writable flag, as we only
report errors when waiting for read events
to match the select behavior. */
if (!(fde->flags & TEVENT_FD_READ)) {
TEVENT_FD_NOT_WRITEABLE(fde);
continue;
}
flags |= TEVENT_FD_READ;
}
if (pfd->revents & POLLIN) {
flags |= TEVENT_FD_READ;
}
if (pfd->revents & POLLOUT) {
flags |= TEVENT_FD_WRITE;
}
/*
* Note that fde->flags could be changed when using
* the poll_mt backend together with threads,
* that why we need to check pfd->revents and fde->flags
*/
flags &= fde->flags;
if (flags != 0) {
DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd);
fde->handler(ev, fde, flags, fde->private_data);
return 0;
}
}
for (i = 0; i < poll_ev->num_fds; i++) {
if (poll_ev->fds[i].revents & POLLNVAL) {
/*
* the socket is dead! this should never
* happen as the socket should have first been
* made readable and that should have removed
* the event, so this must be a bug or
* a race in the poll_mt usage.
*/
fde = poll_ev->fdes[i];
tevent_debug(ev, TEVENT_DEBUG_WARNING,
"POLLNVAL on dangling fd[%d] fde[%p] - disabling\n",
poll_ev->fds[i].fd, fde);
poll_ev->fdes[i] = NULL;
poll_ev->deleted = true;
if (fde != NULL) {
DLIST_REMOVE(ev->fd_events, fde);
fde->event_ctx = NULL;
}
}
}
return 0;
}
/*
do a single event loop using the events defined in ev
*/
static int poll_event_loop_once(struct tevent_context *ev,
const char *location)
{
struct timeval tval;
if (ev->signal_events &&
tevent_common_check_signal(ev)) {
return 0;
}
if (ev->immediate_events &&
tevent_common_loop_immediate(ev)) {
return 0;
}
tval = tevent_common_loop_timer_delay(ev);
if (tevent_timeval_is_zero(&tval)) {
return 0;
}
return poll_event_loop_poll(ev, &tval);
}
static int poll_event_loop_wait(struct tevent_context *ev,
const char *location)
{
struct poll_event_context *poll_ev = talloc_get_type_abort(
ev->additional_data, struct poll_event_context);
/*
* loop as long as we have events pending
*/
while (ev->fd_events ||
ev->timer_events ||
ev->immediate_events ||
ev->signal_events ||
poll_ev->fresh ||
poll_ev->disabled) {
int ret;
ret = _tevent_loop_once(ev, location);
if (ret != 0) {
tevent_debug(ev, TEVENT_DEBUG_FATAL,
"_tevent_loop_once() failed: %d - %s\n",
ret, strerror(errno));
return ret;
}
}
tevent_debug(ev, TEVENT_DEBUG_WARNING,
"poll_event_loop_wait() out of events\n");
return 0;
}
static const struct tevent_ops poll_event_ops = {
.context_init = poll_event_context_init,
.add_fd = poll_event_add_fd,
.set_fd_close_fn = tevent_common_fd_set_close_fn,
.get_fd_flags = tevent_common_fd_get_flags,
.set_fd_flags = poll_event_set_fd_flags,
.add_timer = tevent_common_add_timer_v2,
.schedule_immediate = tevent_common_schedule_immediate,
.add_signal = tevent_common_add_signal,
.loop_once = poll_event_loop_once,
.loop_wait = poll_event_loop_wait,
};
_PRIVATE_ bool tevent_poll_init(void)
{
return tevent_register_backend("poll", &poll_event_ops);
}
static const struct tevent_ops poll_event_mt_ops = {
.context_init = poll_event_context_init_mt,
.add_fd = poll_event_add_fd,
.set_fd_close_fn = tevent_common_fd_set_close_fn,
.get_fd_flags = tevent_common_fd_get_flags,
.set_fd_flags = poll_event_set_fd_flags,
.add_timer = tevent_common_add_timer_v2,
.schedule_immediate = poll_event_schedule_immediate,
.add_signal = tevent_common_add_signal,
.loop_once = poll_event_loop_once,
.loop_wait = poll_event_loop_wait,
};
_PRIVATE_ bool tevent_poll_mt_init(void)
{
return tevent_register_backend("poll_mt", &poll_event_mt_ops);
}
tevent-0.9.19/tevent_queue.c 0000660 0000000 0000000 00000014225 12101212317 015722 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Infrastructure for async requests
Copyright (C) Volker Lendecke 2008
Copyright (C) Stefan Metzmacher 2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
struct tevent_queue_entry {
struct tevent_queue_entry *prev, *next;
struct tevent_queue *queue;
bool triggered;
struct tevent_req *req;
struct tevent_context *ev;
tevent_queue_trigger_fn_t trigger;
void *private_data;
};
struct tevent_queue {
const char *name;
const char *location;
bool running;
struct tevent_immediate *immediate;
size_t length;
struct tevent_queue_entry *list;
};
static void tevent_queue_immediate_trigger(struct tevent_context *ev,
struct tevent_immediate *im,
void *private_data);
static int tevent_queue_entry_destructor(struct tevent_queue_entry *e)
{
struct tevent_queue *q = e->queue;
if (!q) {
return 0;
}
DLIST_REMOVE(q->list, e);
q->length--;
if (!q->running) {
return 0;
}
if (!q->list) {
return 0;
}
if (q->list->triggered) {
return 0;
}
tevent_schedule_immediate(q->immediate,
q->list->ev,
tevent_queue_immediate_trigger,
q);
return 0;
}
static int tevent_queue_destructor(struct tevent_queue *q)
{
q->running = false;
while (q->list) {
struct tevent_queue_entry *e = q->list;
talloc_free(e);
}
return 0;
}
struct tevent_queue *_tevent_queue_create(TALLOC_CTX *mem_ctx,
const char *name,
const char *location)
{
struct tevent_queue *queue;
queue = talloc_zero(mem_ctx, struct tevent_queue);
if (!queue) {
return NULL;
}
queue->name = talloc_strdup(queue, name);
if (!queue->name) {
talloc_free(queue);
return NULL;
}
queue->immediate = tevent_create_immediate(queue);
if (!queue->immediate) {
talloc_free(queue);
return NULL;
}
queue->location = location;
/* queue is running by default */
queue->running = true;
talloc_set_destructor(queue, tevent_queue_destructor);
return queue;
}
static void tevent_queue_immediate_trigger(struct tevent_context *ev,
struct tevent_immediate *im,
void *private_data)
{
struct tevent_queue *q = talloc_get_type(private_data,
struct tevent_queue);
if (!q->running) {
return;
}
q->list->triggered = true;
q->list->trigger(q->list->req, q->list->private_data);
}
static struct tevent_queue_entry *tevent_queue_add_internal(
struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data,
bool allow_direct)
{
struct tevent_queue_entry *e;
e = talloc_zero(req, struct tevent_queue_entry);
if (e == NULL) {
return NULL;
}
e->queue = queue;
e->req = req;
e->ev = ev;
e->trigger = trigger;
e->private_data = private_data;
/*
* if there is no trigger, it is just a blocker
*/
if (trigger == NULL) {
e->triggered = true;
}
if (queue->length > 0) {
/*
* if there are already entries in the
* queue do not optimize.
*/
allow_direct = false;
}
if (req->async.fn != NULL) {
/*
* If the callers wants to optimize for the
* empty queue case, call the trigger only
* if there is no callback defined for the
* request yet.
*/
allow_direct = false;
}
DLIST_ADD_END(queue->list, e, struct tevent_queue_entry *);
queue->length++;
talloc_set_destructor(e, tevent_queue_entry_destructor);
if (!queue->running) {
return e;
}
if (queue->list->triggered) {
return e;
}
/*
* If allowed we directly call the trigger
* avoiding possible delays caused by
* an immediate event.
*/
if (allow_direct) {
queue->list->triggered = true;
queue->list->trigger(queue->list->req,
queue->list->private_data);
return e;
}
tevent_schedule_immediate(queue->immediate,
queue->list->ev,
tevent_queue_immediate_trigger,
queue);
return e;
}
bool tevent_queue_add(struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data)
{
struct tevent_queue_entry *e;
e = tevent_queue_add_internal(queue, ev, req,
trigger, private_data, false);
if (e == NULL) {
return false;
}
return true;
}
struct tevent_queue_entry *tevent_queue_add_entry(
struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data)
{
return tevent_queue_add_internal(queue, ev, req,
trigger, private_data, false);
}
struct tevent_queue_entry *tevent_queue_add_optimize_empty(
struct tevent_queue *queue,
struct tevent_context *ev,
struct tevent_req *req,
tevent_queue_trigger_fn_t trigger,
void *private_data)
{
return tevent_queue_add_internal(queue, ev, req,
trigger, private_data, true);
}
void tevent_queue_start(struct tevent_queue *queue)
{
if (queue->running) {
/* already started */
return;
}
queue->running = true;
if (!queue->list) {
return;
}
if (queue->list->triggered) {
return;
}
tevent_schedule_immediate(queue->immediate,
queue->list->ev,
tevent_queue_immediate_trigger,
queue);
}
void tevent_queue_stop(struct tevent_queue *queue)
{
queue->running = false;
}
size_t tevent_queue_length(struct tevent_queue *queue)
{
return queue->length;
}
bool tevent_queue_running(struct tevent_queue *queue)
{
return queue->running;
}
tevent-0.9.19/tevent_req.c 0000660 0000000 0000000 00000015506 12101212317 015370 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Infrastructure for async requests
Copyright (C) Volker Lendecke 2008
Copyright (C) Stefan Metzmacher 2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
return talloc_asprintf(mem_ctx,
"tevent_req[%p/%s]: state[%d] error[%lld (0x%llX)] "
" state[%s (%p)] timer[%p]",
req, req->internal.create_location,
req->internal.state,
(unsigned long long)req->internal.error,
(unsigned long long)req->internal.error,
talloc_get_name(req->data),
req->data,
req->internal.timer
);
}
char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req)
{
if (!req->private_print) {
return tevent_req_default_print(req, mem_ctx);
}
return req->private_print(req, mem_ctx);
}
struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
void *pdata,
size_t data_size,
const char *type,
const char *location)
{
struct tevent_req *req;
void **ppdata = (void **)pdata;
void *data;
req = talloc_zero(mem_ctx, struct tevent_req);
if (req == NULL) {
return NULL;
}
req->internal.private_type = type;
req->internal.create_location = location;
req->internal.finish_location = NULL;
req->internal.state = TEVENT_REQ_IN_PROGRESS;
req->internal.trigger = tevent_create_immediate(req);
if (!req->internal.trigger) {
talloc_free(req);
return NULL;
}
req->internal.defer_callback_ev = NULL;
data = talloc_zero_size(req, data_size);
if (data == NULL) {
talloc_free(req);
return NULL;
}
talloc_set_name_const(data, type);
req->data = data;
*ppdata = data;
return req;
}
void _tevent_req_notify_callback(struct tevent_req *req, const char *location)
{
req->internal.finish_location = location;
if (req->internal.defer_callback_ev) {
(void)tevent_req_post(req, req->internal.defer_callback_ev);
req->internal.defer_callback_ev = NULL;
return;
}
if (req->async.fn != NULL) {
req->async.fn(req);
}
}
static void tevent_req_finish(struct tevent_req *req,
enum tevent_req_state state,
const char *location)
{
req->internal.state = state;
_tevent_req_notify_callback(req, location);
}
void _tevent_req_done(struct tevent_req *req,
const char *location)
{
tevent_req_finish(req, TEVENT_REQ_DONE, location);
}
bool _tevent_req_error(struct tevent_req *req,
uint64_t error,
const char *location)
{
if (error == 0) {
return false;
}
req->internal.error = error;
tevent_req_finish(req, TEVENT_REQ_USER_ERROR, location);
return true;
}
void _tevent_req_oom(struct tevent_req *req, const char *location)
{
tevent_req_finish(req, TEVENT_REQ_NO_MEMORY, location);
}
bool _tevent_req_nomem(const void *p,
struct tevent_req *req,
const char *location)
{
if (p != NULL) {
return false;
}
_tevent_req_oom(req, location);
return true;
}
/**
* @internal
*
* @brief Immediate event callback.
*
* @param[in] ev The event context to use.
*
* @param[in] im The immediate event.
*
* @param[in] priv The async request to be finished.
*/
static void tevent_req_trigger(struct tevent_context *ev,
struct tevent_immediate *im,
void *private_data)
{
struct tevent_req *req = talloc_get_type(private_data,
struct tevent_req);
tevent_req_finish(req, req->internal.state,
req->internal.finish_location);
}
struct tevent_req *tevent_req_post(struct tevent_req *req,
struct tevent_context *ev)
{
tevent_schedule_immediate(req->internal.trigger,
ev, tevent_req_trigger, req);
return req;
}
void tevent_req_defer_callback(struct tevent_req *req,
struct tevent_context *ev)
{
req->internal.defer_callback_ev = ev;
}
bool tevent_req_is_in_progress(struct tevent_req *req)
{
if (req->internal.state == TEVENT_REQ_IN_PROGRESS) {
return true;
}
return false;
}
void tevent_req_received(struct tevent_req *req)
{
TALLOC_FREE(req->data);
req->private_print = NULL;
TALLOC_FREE(req->internal.trigger);
TALLOC_FREE(req->internal.timer);
req->internal.state = TEVENT_REQ_RECEIVED;
}
bool tevent_req_poll(struct tevent_req *req,
struct tevent_context *ev)
{
while (tevent_req_is_in_progress(req)) {
int ret;
ret = tevent_loop_once(ev);
if (ret != 0) {
return false;
}
}
return true;
}
bool tevent_req_is_error(struct tevent_req *req, enum tevent_req_state *state,
uint64_t *error)
{
if (req->internal.state == TEVENT_REQ_DONE) {
return false;
}
if (req->internal.state == TEVENT_REQ_USER_ERROR) {
*error = req->internal.error;
}
*state = req->internal.state;
return true;
}
static void tevent_req_timedout(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval now,
void *private_data)
{
struct tevent_req *req = talloc_get_type(private_data,
struct tevent_req);
TALLOC_FREE(req->internal.timer);
tevent_req_finish(req, TEVENT_REQ_TIMED_OUT, __FUNCTION__);
}
bool tevent_req_set_endtime(struct tevent_req *req,
struct tevent_context *ev,
struct timeval endtime)
{
TALLOC_FREE(req->internal.timer);
req->internal.timer = tevent_add_timer(ev, req, endtime,
tevent_req_timedout,
req);
if (tevent_req_nomem(req->internal.timer, req)) {
return false;
}
return true;
}
void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt)
{
req->async.fn = fn;
req->async.private_data = pvt;
}
void *_tevent_req_callback_data(struct tevent_req *req)
{
return req->async.private_data;
}
void *_tevent_req_data(struct tevent_req *req)
{
return req->data;
}
void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn)
{
req->private_print = fn;
}
void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn)
{
req->private_cancel = fn;
}
bool _tevent_req_cancel(struct tevent_req *req, const char *location)
{
if (req->private_cancel == NULL) {
return false;
}
return req->private_cancel(req);
}
tevent-0.9.19/tevent_select.c 0000660 0000000 0000000 00000016234 12153373752 016101 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
main select loop and event handling
Copyright (C) Andrew Tridgell 2003-2005
Copyright (C) Stefan Metzmacher 2005-2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/filesys.h"
#include "system/select.h"
#include "tevent.h"
#include "tevent_util.h"
#include "tevent_internal.h"
struct select_event_context {
/* a pointer back to the generic event_context */
struct tevent_context *ev;
/* the maximum file descriptor number in fd_events */
int maxfd;
/* information for exiting from the event loop */
int exit_code;
};
/*
create a select_event_context structure.
*/
static int select_event_context_init(struct tevent_context *ev)
{
struct select_event_context *select_ev;
/*
* We might be called during tevent_re_initialise()
* which means we need to free our old additional_data.
*/
TALLOC_FREE(ev->additional_data);
select_ev = talloc_zero(ev, struct select_event_context);
if (!select_ev) return -1;
select_ev->ev = ev;
ev->additional_data = select_ev;
return 0;
}
/*
recalculate the maxfd
*/
static void calc_maxfd(struct select_event_context *select_ev)
{
struct tevent_fd *fde;
select_ev->maxfd = 0;
for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
if (fde->fd > select_ev->maxfd) {
select_ev->maxfd = fde->fd;
}
}
}
/* to mark the ev->maxfd invalid
* this means we need to recalculate it
*/
#define EVENT_INVALID_MAXFD (-1)
/*
destroy an fd_event
*/
static int select_event_fd_destructor(struct tevent_fd *fde)
{
struct tevent_context *ev = fde->event_ctx;
struct select_event_context *select_ev = NULL;
if (ev) {
select_ev = talloc_get_type(ev->additional_data,
struct select_event_context);
if (select_ev->maxfd == fde->fd) {
select_ev->maxfd = EVENT_INVALID_MAXFD;
}
}
return tevent_common_fd_destructor(fde);
}
/*
add a fd based event
return NULL on failure (memory allocation error)
*/
static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
int fd, uint16_t flags,
tevent_fd_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
struct select_event_context);
struct tevent_fd *fde;
if (fd < 0 || fd >= FD_SETSIZE) {
errno = EBADF;
return NULL;
}
fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
handler, private_data,
handler_name, location);
if (!fde) return NULL;
if ((select_ev->maxfd != EVENT_INVALID_MAXFD)
&& (fde->fd > select_ev->maxfd)) {
select_ev->maxfd = fde->fd;
}
talloc_set_destructor(fde, select_event_fd_destructor);
return fde;
}
/*
event loop handling using select()
*/
static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
{
fd_set r_fds, w_fds;
struct tevent_fd *fde;
int selrtn;
int select_errno;
/* we maybe need to recalculate the maxfd */
if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
calc_maxfd(select_ev);
}
FD_ZERO(&r_fds);
FD_ZERO(&w_fds);
/* setup any fd events */
for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
"ERROR: EBADF fd[%d] >= %d "
"select_event_loop_once\n",
fde->fd, FD_SETSIZE);
errno = EBADF;
return -1;
}
if (fde->flags & TEVENT_FD_READ) {
FD_SET(fde->fd, &r_fds);
}
if (fde->flags & TEVENT_FD_WRITE) {
FD_SET(fde->fd, &w_fds);
}
}
if (select_ev->ev->signal_events &&
tevent_common_check_signal(select_ev->ev)) {
return 0;
}
tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
select_errno = errno;
tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_AFTER_WAIT);
if (selrtn == -1 && select_errno == EINTR &&
select_ev->ev->signal_events) {
tevent_common_check_signal(select_ev->ev);
return 0;
}
if (selrtn == -1 && select_errno == EBADF) {
/* the socket is dead! this should never
happen as the socket should have first been
made readable and that should have removed
the event, so this must be a bug. This is a
fatal error. */
tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
"ERROR: EBADF on select_event_loop_once\n");
select_ev->exit_code = EBADF;
return -1;
}
if (selrtn == 0 && tvalp) {
/* we don't care about a possible delay here */
tevent_common_loop_timer_delay(select_ev->ev);
return 0;
}
if (selrtn > 0) {
/* at least one file descriptor is ready - check
which ones and call the handler, being careful to allow
the handler to remove itself when called */
for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
uint16_t flags = 0;
if (FD_ISSET(fde->fd, &r_fds) && (fde->flags & TEVENT_FD_READ)) {
flags |= TEVENT_FD_READ;
}
if (FD_ISSET(fde->fd, &w_fds) && (fde->flags & TEVENT_FD_WRITE)) {
flags |= TEVENT_FD_WRITE;
}
if (flags) {
DLIST_DEMOTE(select_ev->ev->fd_events, fde, struct tevent_fd);
fde->handler(select_ev->ev, fde, flags, fde->private_data);
break;
}
}
}
return 0;
}
/*
do a single event loop using the events defined in ev
*/
static int select_event_loop_once(struct tevent_context *ev, const char *location)
{
struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
struct select_event_context);
struct timeval tval;
if (ev->signal_events &&
tevent_common_check_signal(ev)) {
return 0;
}
if (ev->immediate_events &&
tevent_common_loop_immediate(ev)) {
return 0;
}
tval = tevent_common_loop_timer_delay(ev);
if (tevent_timeval_is_zero(&tval)) {
return 0;
}
return select_event_loop_select(select_ev, &tval);
}
static const struct tevent_ops select_event_ops = {
.context_init = select_event_context_init,
.add_fd = select_event_add_fd,
.set_fd_close_fn = tevent_common_fd_set_close_fn,
.get_fd_flags = tevent_common_fd_get_flags,
.set_fd_flags = tevent_common_fd_set_flags,
.add_timer = tevent_common_add_timer_v2,
.schedule_immediate = tevent_common_schedule_immediate,
.add_signal = tevent_common_add_signal,
.loop_once = select_event_loop_once,
.loop_wait = tevent_common_loop_wait,
};
_PRIVATE_ bool tevent_select_init(void)
{
return tevent_register_backend("select", &select_event_ops);
}
tevent-0.9.19/tevent_signal.c 0000660 0000000 0000000 00000031745 12176475205 016104 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
common events code for signal events
Copyright (C) Andrew Tridgell 2007
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/filesys.h"
#include "system/wait.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
/* maximum number of SA_SIGINFO signals to hold in the queue.
NB. This *MUST* be a power of 2, in order for the ring buffer
wrap to work correctly. Thanks to Petr Vandrovec
for this. */
#define TEVENT_SA_INFO_QUEUE_COUNT 64
struct tevent_sigcounter {
uint32_t count;
uint32_t seen;
};
#define TEVENT_SIG_INCREMENT(s) (s).count++
#define TEVENT_SIG_SEEN(s, n) (s).seen += (n)
#define TEVENT_SIG_PENDING(s) ((s).seen != (s).count)
struct tevent_common_signal_list {
struct tevent_common_signal_list *prev, *next;
struct tevent_signal *se;
};
/*
the poor design of signals means that this table must be static global
*/
static struct tevent_sig_state {
struct tevent_common_signal_list *sig_handlers[TEVENT_NUM_SIGNALS+1];
struct sigaction *oldact[TEVENT_NUM_SIGNALS+1];
struct tevent_sigcounter signal_count[TEVENT_NUM_SIGNALS+1];
struct tevent_sigcounter got_signal;
#ifdef SA_SIGINFO
/* with SA_SIGINFO we get quite a lot of info per signal */
siginfo_t *sig_info[TEVENT_NUM_SIGNALS+1];
struct tevent_sigcounter sig_blocked[TEVENT_NUM_SIGNALS+1];
#endif
} *sig_state;
/*
return number of sigcounter events not processed yet
*/
static uint32_t tevent_sig_count(struct tevent_sigcounter s)
{
return s.count - s.seen;
}
/*
signal handler - redirects to registered signals
*/
static void tevent_common_signal_handler(int signum)
{
char c = 0;
struct tevent_common_signal_list *sl;
struct tevent_context *ev = NULL;
int saved_errno = errno;
TEVENT_SIG_INCREMENT(sig_state->signal_count[signum]);
TEVENT_SIG_INCREMENT(sig_state->got_signal);
/* Write to each unique event context. */
for (sl = sig_state->sig_handlers[signum]; sl; sl = sl->next) {
if (sl->se->event_ctx && sl->se->event_ctx != ev) {
ev = sl->se->event_ctx;
/* doesn't matter if this pipe overflows */
(void) write(ev->pipe_fds[1], &c, 1);
}
}
errno = saved_errno;
}
#ifdef SA_SIGINFO
/*
signal handler with SA_SIGINFO - redirects to registered signals
*/
static void tevent_common_signal_handler_info(int signum, siginfo_t *info,
void *uctx)
{
uint32_t count = tevent_sig_count(sig_state->signal_count[signum]);
/* sig_state->signal_count[signum].seen % TEVENT_SA_INFO_QUEUE_COUNT
* is the base of the unprocessed signals in the ringbuffer. */
uint32_t ofs = (sig_state->signal_count[signum].seen + count) %
TEVENT_SA_INFO_QUEUE_COUNT;
sig_state->sig_info[signum][ofs] = *info;
tevent_common_signal_handler(signum);
/* handle SA_SIGINFO */
if (count+1 == TEVENT_SA_INFO_QUEUE_COUNT) {
/* we've filled the info array - block this signal until
these ones are delivered */
#ifdef HAVE_UCONTEXT_T
/*
* This is the only way for this to work.
* By default signum is blocked inside this
* signal handler using a temporary mask,
* but what we really need to do now is
* block it in the callers mask, so it
* stays blocked when the temporary signal
* handler mask is replaced when we return
* from here. The callers mask can be found
* in the ucontext_t passed in as the
* void *uctx argument.
*/
ucontext_t *ucp = (ucontext_t *)uctx;
sigaddset(&ucp->uc_sigmask, signum);
#else
/*
* WARNING !!! WARNING !!!!
*
* This code doesn't work.
* By default signum is blocked inside this
* signal handler, but calling sigprocmask
* modifies the temporary signal mask being
* used *inside* this handler, which will be
* replaced by the callers signal mask once
* we return from here. See Samba
* bug #9550 for details.
*/
sigset_t set;
sigemptyset(&set);
sigaddset(&set, signum);
sigprocmask(SIG_BLOCK, &set, NULL);
#endif
TEVENT_SIG_INCREMENT(sig_state->sig_blocked[signum]);
}
}
#endif
static int tevent_common_signal_list_destructor(struct tevent_common_signal_list *sl)
{
if (sig_state->sig_handlers[sl->se->signum]) {
DLIST_REMOVE(sig_state->sig_handlers[sl->se->signum], sl);
}
return 0;
}
/*
destroy a signal event
*/
static int tevent_signal_destructor(struct tevent_signal *se)
{
struct tevent_common_signal_list *sl;
sl = talloc_get_type(se->additional_data,
struct tevent_common_signal_list);
if (se->event_ctx) {
struct tevent_context *ev = se->event_ctx;
DLIST_REMOVE(ev->signal_events, se);
if (ev->signal_events == NULL && ev->pipe_fde != NULL) {
/*
* This was the last signal. Destroy the pipe.
*/
TALLOC_FREE(ev->pipe_fde);
close(ev->pipe_fds[0]);
close(ev->pipe_fds[1]);
}
}
talloc_free(sl);
if (sig_state->sig_handlers[se->signum] == NULL) {
/* restore old handler, if any */
if (sig_state->oldact[se->signum]) {
sigaction(se->signum, sig_state->oldact[se->signum], NULL);
sig_state->oldact[se->signum] = NULL;
}
#ifdef SA_SIGINFO
if (se->sa_flags & SA_SIGINFO) {
if (sig_state->sig_info[se->signum]) {
talloc_free(sig_state->sig_info[se->signum]);
sig_state->sig_info[se->signum] = NULL;
}
}
#endif
}
return 0;
}
/*
this is part of the pipe hack needed to avoid the signal race condition
*/
static void signal_pipe_handler(struct tevent_context *ev, struct tevent_fd *fde,
uint16_t flags, void *_private)
{
char c[16];
/* its non-blocking, doesn't matter if we read too much */
(void) read(fde->fd, c, sizeof(c));
}
/*
add a signal event
return NULL on failure (memory allocation error)
*/
struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
int signum,
int sa_flags,
tevent_signal_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
struct tevent_signal *se;
struct tevent_common_signal_list *sl;
sigset_t set, oldset;
if (signum >= TEVENT_NUM_SIGNALS) {
errno = EINVAL;
return NULL;
}
/* the sig_state needs to be on a global context as it can last across
multiple event contexts */
if (sig_state == NULL) {
sig_state = talloc_zero(NULL, struct tevent_sig_state);
if (sig_state == NULL) {
return NULL;
}
}
se = talloc(mem_ctx?mem_ctx:ev, struct tevent_signal);
if (se == NULL) return NULL;
se->event_ctx = ev;
se->signum = signum;
se->sa_flags = sa_flags;
se->handler = handler;
se->private_data = private_data;
se->handler_name = handler_name;
se->location = location;
se->additional_data = NULL;
sl = talloc(se, struct tevent_common_signal_list);
if (!sl) {
talloc_free(se);
return NULL;
}
sl->se = se;
se->additional_data = sl;
/* Ensure, no matter the destruction order, that we always have a handle on the global sig_state */
if (!talloc_reference(se, sig_state)) {
talloc_free(se);
return NULL;
}
/* we need to setup the pipe hack handler if not already
setup */
if (ev->pipe_fde == NULL) {
if (pipe(ev->pipe_fds) == -1) {
talloc_free(se);
return NULL;
}
ev_set_blocking(ev->pipe_fds[0], false);
ev_set_blocking(ev->pipe_fds[1], false);
ev->pipe_fde = tevent_add_fd(ev, ev, ev->pipe_fds[0],
TEVENT_FD_READ,
signal_pipe_handler, NULL);
if (!ev->pipe_fde) {
close(ev->pipe_fds[0]);
close(ev->pipe_fds[1]);
talloc_free(se);
return NULL;
}
}
/* only install a signal handler if not already installed */
if (sig_state->sig_handlers[signum] == NULL) {
struct sigaction act;
ZERO_STRUCT(act);
act.sa_handler = tevent_common_signal_handler;
act.sa_flags = sa_flags;
#ifdef SA_SIGINFO
if (sa_flags & SA_SIGINFO) {
act.sa_handler = NULL;
act.sa_sigaction = tevent_common_signal_handler_info;
if (sig_state->sig_info[signum] == NULL) {
sig_state->sig_info[signum] =
talloc_zero_array(sig_state, siginfo_t,
TEVENT_SA_INFO_QUEUE_COUNT);
if (sig_state->sig_info[signum] == NULL) {
talloc_free(se);
return NULL;
}
}
}
#endif
sig_state->oldact[signum] = talloc(sig_state, struct sigaction);
if (sig_state->oldact[signum] == NULL) {
talloc_free(se);
return NULL;
}
if (sigaction(signum, &act, sig_state->oldact[signum]) == -1) {
talloc_free(se);
return NULL;
}
}
DLIST_ADD(se->event_ctx->signal_events, se);
/* Make sure the signal doesn't come in while we're mangling list. */
sigemptyset(&set);
sigaddset(&set, signum);
sigprocmask(SIG_BLOCK, &set, &oldset);
DLIST_ADD(sig_state->sig_handlers[signum], sl);
sigprocmask(SIG_SETMASK, &oldset, NULL);
talloc_set_destructor(se, tevent_signal_destructor);
talloc_set_destructor(sl, tevent_common_signal_list_destructor);
return se;
}
struct tevent_se_exists {
struct tevent_se_exists **myself;
};
static int tevent_se_exists_destructor(struct tevent_se_exists *s)
{
*s->myself = NULL;
return 0;
}
/*
check if a signal is pending
return != 0 if a signal was pending
*/
int tevent_common_check_signal(struct tevent_context *ev)
{
int i;
if (!sig_state || !TEVENT_SIG_PENDING(sig_state->got_signal)) {
return 0;
}
for (i=0;isignal_count[i];
uint32_t count = tevent_sig_count(counter);
#ifdef SA_SIGINFO
/* Ensure we null out any stored siginfo_t entries
* after processing for debugging purposes. */
bool clear_processed_siginfo = false;
#endif
if (count == 0) {
continue;
}
for (sl=sig_state->sig_handlers[i];sl;sl=next) {
struct tevent_signal *se = sl->se;
struct tevent_se_exists *exists;
next = sl->next;
/*
* We have to be careful to not touch "se"
* after it was deleted in its handler. Thus
* we allocate a child whose destructor will
* tell by nulling out itself that its parent
* is gone.
*/
exists = talloc(se, struct tevent_se_exists);
if (exists == NULL) {
continue;
}
exists->myself = &exists;
talloc_set_destructor(
exists, tevent_se_exists_destructor);
#ifdef SA_SIGINFO
if (se->sa_flags & SA_SIGINFO) {
uint32_t j;
clear_processed_siginfo = true;
for (j=0;jsignal_count[i].seen
* % TEVENT_SA_INFO_QUEUE_COUNT is
* the base position of the unprocessed
* signals in the ringbuffer. */
uint32_t ofs = (counter.seen + j)
% TEVENT_SA_INFO_QUEUE_COUNT;
se->handler(ev, se, i, 1,
(void*)&sig_state->sig_info[i][ofs],
se->private_data);
if (!exists) {
break;
}
}
#ifdef SA_RESETHAND
if (exists && (se->sa_flags & SA_RESETHAND)) {
talloc_free(se);
}
#endif
talloc_free(exists);
continue;
}
#endif
se->handler(ev, se, i, count, NULL, se->private_data);
#ifdef SA_RESETHAND
if (exists && (se->sa_flags & SA_RESETHAND)) {
talloc_free(se);
}
#endif
talloc_free(exists);
}
#ifdef SA_SIGINFO
if (clear_processed_siginfo) {
uint32_t j;
for (j=0;jsig_info[i][ofs],
'\0',
sizeof(siginfo_t));
}
}
#endif
TEVENT_SIG_SEEN(sig_state->signal_count[i], count);
TEVENT_SIG_SEEN(sig_state->got_signal, count);
#ifdef SA_SIGINFO
if (TEVENT_SIG_PENDING(sig_state->sig_blocked[i])) {
/* We'd filled the queue, unblock the
signal now the queue is empty again.
Note we MUST do this after the
TEVENT_SIG_SEEN(sig_state->signal_count[i], count)
call to prevent a new signal running
out of room in the sig_state->sig_info[i][]
ring buffer. */
sigset_t set;
sigemptyset(&set);
sigaddset(&set, i);
TEVENT_SIG_SEEN(sig_state->sig_blocked[i],
tevent_sig_count(sig_state->sig_blocked[i]));
sigprocmask(SIG_UNBLOCK, &set, NULL);
}
#endif
}
return 1;
}
void tevent_cleanup_pending_signal_handlers(struct tevent_signal *se)
{
struct tevent_common_signal_list *sl;
sl = talloc_get_type(se->additional_data,
struct tevent_common_signal_list);
tevent_common_signal_list_destructor(sl);
if (sig_state->sig_handlers[se->signum] == NULL) {
if (sig_state->oldact[se->signum]) {
sigaction(se->signum, sig_state->oldact[se->signum], NULL);
sig_state->oldact[se->signum] = NULL;
}
}
return;
}
tevent-0.9.19/tevent_standard.c 0000660 0000000 0000000 00000013505 12153373752 016420 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
main select loop and event handling
Copyright (C) Stefan Metzmacher 2013
Copyright (C) Jeremy Allison 2013
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
/*
This is SAMBA's default event loop code
- we try to use epoll if configure detected support for it
otherwise we use poll()
- if epoll is broken on the system or the kernel doesn't support it
at runtime we fallback to poll()
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_util.h"
#include "tevent_internal.h"
struct std_event_glue {
const struct tevent_ops *epoll_ops;
const struct tevent_ops *poll_ops;
struct tevent_ops *glue_ops;
bool fallback_replay;
};
static int std_event_context_init(struct tevent_context *ev);
static const struct tevent_ops std_event_ops = {
.context_init = std_event_context_init,
};
/*
If this function gets called. epoll failed at runtime.
Move us to using poll instead. If we return false here,
caller should abort().
*/
static bool std_fallback_to_poll(struct tevent_context *ev, bool replay)
{
void *glue_ptr = talloc_parent(ev->ops);
struct std_event_glue *glue =
talloc_get_type_abort(glue_ptr,
struct std_event_glue);
int ret;
struct tevent_fd *fde;
struct tevent_fd *fde_next;
glue->fallback_replay = replay;
/* First switch all the ops to poll. */
glue->epoll_ops = NULL;
/*
* Set custom_ops the same as poll.
*/
*glue->glue_ops = *glue->poll_ops;
glue->glue_ops->context_init = std_event_context_init;
/* Next initialize the poll backend. */
ret = glue->poll_ops->context_init(ev);
if (ret != 0) {
return false;
}
/*
* Now we have to change all the existing file descriptor
* events from the epoll backend to the poll backend.
*/
for (fde = ev->fd_events; fde; fde = fde_next) {
/*
* We must remove this fde off the ev->fd_events list.
*/
fde_next = fde->next;
/* Remove from the ev->fd_events list. */
DLIST_REMOVE(ev->fd_events, fde);
/* Re-add this event as a poll backend event. */
tevent_poll_event_add_fd_internal(ev, fde);
}
return true;
}
static int std_event_loop_once(struct tevent_context *ev, const char *location)
{
void *glue_ptr = talloc_parent(ev->ops);
struct std_event_glue *glue =
talloc_get_type_abort(glue_ptr,
struct std_event_glue);
int ret;
ret = glue->epoll_ops->loop_once(ev, location);
if (glue->epoll_ops != NULL) {
/* No fallback */
return ret;
}
if (!glue->fallback_replay) {
/*
* The problem happened while modifying an event.
* An event handler was triggered in this case
* and there is no need to call loop_once() again.
*/
return ret;
}
return glue->poll_ops->loop_once(ev, location);
}
static int std_event_loop_wait(struct tevent_context *ev, const char *location)
{
void *glue_ptr = talloc_parent(ev->ops);
struct std_event_glue *glue =
talloc_get_type_abort(glue_ptr,
struct std_event_glue);
int ret;
ret = glue->epoll_ops->loop_wait(ev, location);
if (glue->epoll_ops != NULL) {
/* No fallback */
return ret;
}
return glue->poll_ops->loop_wait(ev, location);
}
/*
Initialize the epoll backend and allow it to call a
switch function if epoll fails at runtime.
*/
static int std_event_context_init(struct tevent_context *ev)
{
struct std_event_glue *glue;
int ret;
/*
* If this is the first initialization
* we need to set up the allocated ops
* pointers.
*/
if (ev->ops == &std_event_ops) {
glue = talloc_zero(ev, struct std_event_glue);
if (glue == NULL) {
return -1;
}
glue->epoll_ops = tevent_find_ops_byname("epoll");
glue->poll_ops = tevent_find_ops_byname("poll");
if (glue->poll_ops == NULL) {
return -1;
}
/*
* Allocate space for our custom ops.
* Allocate as a child of our epoll_ops pointer
* so we can easily get to it using talloc_parent.
*/
glue->glue_ops = talloc_zero(glue, struct tevent_ops);
if (glue->glue_ops == NULL) {
talloc_free(glue);
return -1;
}
ev->ops = glue->glue_ops;
} else {
void *glue_ptr = talloc_parent(ev->ops);
glue = talloc_get_type_abort(glue_ptr, struct std_event_glue);
}
if (glue->epoll_ops != NULL) {
/*
* Set custom_ops the same as epoll,
* except re-init using std_event_context_init()
* and use std_event_loop_once() to add the
* ability to fallback to a poll backend on
* epoll runtime error.
*/
*glue->glue_ops = *glue->epoll_ops;
glue->glue_ops->context_init = std_event_context_init;
glue->glue_ops->loop_once = std_event_loop_once;
glue->glue_ops->loop_wait = std_event_loop_wait;
ret = glue->epoll_ops->context_init(ev);
if (ret == -1) {
goto fallback;
}
#ifdef HAVE_EPOLL
if (!tevent_epoll_set_panic_fallback(ev, std_fallback_to_poll)) {
TALLOC_FREE(ev->additional_data);
goto fallback;
}
#endif
return ret;
}
fallback:
glue->epoll_ops = NULL;
/*
* Set custom_ops the same as poll.
*/
*glue->glue_ops = *glue->poll_ops;
glue->glue_ops->context_init = std_event_context_init;
return glue->poll_ops->context_init(ev);
}
_PRIVATE_ bool tevent_standard_init(void)
{
return tevent_register_backend("standard", &std_event_ops);
}
tevent-0.9.19/tevent_timed.c 0000660 0000000 0000000 00000021451 12153373752 015721 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
common events code for timed events
Copyright (C) Andrew Tridgell 2003-2006
Copyright (C) Stefan Metzmacher 2005-2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/time.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
/**
compare two timeval structures.
Return -1 if tv1 < tv2
Return 0 if tv1 == tv2
Return 1 if tv1 > tv2
*/
int tevent_timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
{
if (tv1->tv_sec > tv2->tv_sec) return 1;
if (tv1->tv_sec < tv2->tv_sec) return -1;
if (tv1->tv_usec > tv2->tv_usec) return 1;
if (tv1->tv_usec < tv2->tv_usec) return -1;
return 0;
}
/**
return a zero timeval
*/
struct timeval tevent_timeval_zero(void)
{
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
return tv;
}
/**
return a timeval for the current time
*/
struct timeval tevent_timeval_current(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
return tv;
}
/**
return a timeval struct with the given elements
*/
struct timeval tevent_timeval_set(uint32_t secs, uint32_t usecs)
{
struct timeval tv;
tv.tv_sec = secs;
tv.tv_usec = usecs;
return tv;
}
/**
return the difference between two timevals as a timeval
if tv1 comes after tv2, then return a zero timeval
(this is *tv2 - *tv1)
*/
struct timeval tevent_timeval_until(const struct timeval *tv1,
const struct timeval *tv2)
{
struct timeval t;
if (tevent_timeval_compare(tv1, tv2) >= 0) {
return tevent_timeval_zero();
}
t.tv_sec = tv2->tv_sec - tv1->tv_sec;
if (tv1->tv_usec > tv2->tv_usec) {
t.tv_sec--;
t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
} else {
t.tv_usec = tv2->tv_usec - tv1->tv_usec;
}
return t;
}
/**
return true if a timeval is zero
*/
bool tevent_timeval_is_zero(const struct timeval *tv)
{
return tv->tv_sec == 0 && tv->tv_usec == 0;
}
struct timeval tevent_timeval_add(const struct timeval *tv, uint32_t secs,
uint32_t usecs)
{
struct timeval tv2 = *tv;
tv2.tv_sec += secs;
tv2.tv_usec += usecs;
tv2.tv_sec += tv2.tv_usec / 1000000;
tv2.tv_usec = tv2.tv_usec % 1000000;
return tv2;
}
/**
return a timeval in the future with a specified offset
*/
struct timeval tevent_timeval_current_ofs(uint32_t secs, uint32_t usecs)
{
struct timeval tv = tevent_timeval_current();
return tevent_timeval_add(&tv, secs, usecs);
}
/*
destroy a timed event
*/
static int tevent_common_timed_destructor(struct tevent_timer *te)
{
if (te->event_ctx == NULL) {
return 0;
}
tevent_debug(te->event_ctx, TEVENT_DEBUG_TRACE,
"Destroying timer event %p \"%s\"\n",
te, te->handler_name);
if (te->event_ctx->last_zero_timer == te) {
te->event_ctx->last_zero_timer = DLIST_PREV(te);
}
DLIST_REMOVE(te->event_ctx->timer_events, te);
return 0;
}
static int tevent_common_timed_deny_destructor(struct tevent_timer *te)
{
return -1;
}
/*
add a timed event
return NULL on failure (memory allocation error)
*/
static struct tevent_timer *tevent_common_add_timer_internal(
struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location,
bool optimize_zero)
{
struct tevent_timer *te, *prev_te, *cur_te;
te = talloc(mem_ctx?mem_ctx:ev, struct tevent_timer);
if (te == NULL) return NULL;
te->event_ctx = ev;
te->next_event = next_event;
te->handler = handler;
te->private_data = private_data;
te->handler_name = handler_name;
te->location = location;
te->additional_data = NULL;
if (ev->timer_events == NULL) {
ev->last_zero_timer = NULL;
}
/* keep the list ordered */
prev_te = NULL;
if (optimize_zero && tevent_timeval_is_zero(&te->next_event)) {
/*
* Some callers use zero tevent_timer
* instead of tevent_immediate events.
*
* As these can happen very often,
* we remember the last zero timer
* in the list.
*/
prev_te = ev->last_zero_timer;
ev->last_zero_timer = te;
} else {
/*
* we traverse the list from the tail
* because it's much more likely that
* timers are added at the end of the list
*/
for (cur_te = DLIST_TAIL(ev->timer_events);
cur_te != NULL;
cur_te = DLIST_PREV(cur_te))
{
int ret;
/*
* if the new event comes before the current
* we continue searching
*/
ret = tevent_timeval_compare(&te->next_event,
&cur_te->next_event);
if (ret < 0) {
continue;
}
break;
}
prev_te = cur_te;
}
DLIST_ADD_AFTER(ev->timer_events, te, prev_te);
talloc_set_destructor(te, tevent_common_timed_destructor);
tevent_debug(ev, TEVENT_DEBUG_TRACE,
"Added timed event \"%s\": %p\n",
handler_name, te);
return te;
}
struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
/*
* do not use optimization, there are broken Samba
* versions which use tevent_common_add_timer()
* without using tevent_common_loop_timer_delay(),
* it just uses DLIST_REMOVE(ev->timer_events, te)
* and would leave ev->last_zero_timer behind.
*/
return tevent_common_add_timer_internal(ev, mem_ctx, next_event,
handler, private_data,
handler_name, location,
false);
}
struct tevent_timer *tevent_common_add_timer_v2(struct tevent_context *ev,
TALLOC_CTX *mem_ctx,
struct timeval next_event,
tevent_timer_handler_t handler,
void *private_data,
const char *handler_name,
const char *location)
{
/*
* Here we turn on last_zero_timer optimization
*/
return tevent_common_add_timer_internal(ev, mem_ctx, next_event,
handler, private_data,
handler_name, location,
true);
}
/*
do a single event loop using the events defined in ev
return the delay until the next timed event,
or zero if a timed event was triggered
*/
struct timeval tevent_common_loop_timer_delay(struct tevent_context *ev)
{
struct timeval current_time = tevent_timeval_zero();
struct tevent_timer *te = ev->timer_events;
if (!te) {
/* have a default tick time of 30 seconds. This guarantees
that code that uses its own timeout checking will be
able to proceed eventually */
return tevent_timeval_set(30, 0);
}
/*
* work out the right timeout for the next timed event
*
* avoid the syscall to gettimeofday() if the timed event should
* be triggered directly
*
* if there's a delay till the next timed event, we're done
* with just returning the delay
*/
if (!tevent_timeval_is_zero(&te->next_event)) {
struct timeval delay;
current_time = tevent_timeval_current();
delay = tevent_timeval_until(¤t_time, &te->next_event);
if (!tevent_timeval_is_zero(&delay)) {
return delay;
}
}
/*
* ok, we have a timed event that we'll process ...
*/
/* deny the handler to free the event */
talloc_set_destructor(te, tevent_common_timed_deny_destructor);
/* We need to remove the timer from the list before calling the
* handler because in a semi-async inner event loop called from the
* handler we don't want to come across this event again -- vl */
if (ev->last_zero_timer == te) {
ev->last_zero_timer = DLIST_PREV(te);
}
DLIST_REMOVE(ev->timer_events, te);
tevent_debug(te->event_ctx, TEVENT_DEBUG_TRACE,
"Running timer event %p \"%s\"\n",
te, te->handler_name);
/*
* If the timed event was registered for a zero current_time,
* then we pass a zero timeval here too! To avoid the
* overhead of gettimeofday() calls.
*
* otherwise we pass the current time
*/
te->handler(ev, te, current_time, te->private_data);
/* The destructor isn't necessary anymore, we've already removed the
* event from the list. */
talloc_set_destructor(te, NULL);
tevent_debug(te->event_ctx, TEVENT_DEBUG_TRACE,
"Ending timer event %p \"%s\"\n",
te, te->handler_name);
talloc_free(te);
return tevent_timeval_zero();
}
tevent-0.9.19/tevent_util.c 0000660 0000000 0000000 00000004546 12101212317 015560 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Copyright (C) Andrew Tridgell 2005
Copyright (C) Jelmer Vernooij 2005
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "talloc.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
#include
/**
return the number of elements in a string list
*/
size_t ev_str_list_length(const char **list)
{
size_t ret;
for (ret=0;list && list[ret];ret++) /* noop */ ;
return ret;
}
/**
add an entry to a string list
*/
const char **ev_str_list_add(const char **list, const char *s)
{
size_t len = ev_str_list_length(list);
const char **ret;
ret = talloc_realloc(NULL, list, const char *, len+2);
if (ret == NULL) return NULL;
ret[len] = talloc_strdup(ret, s);
if (ret[len] == NULL) return NULL;
ret[len+1] = NULL;
return ret;
}
/**
Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
else
if SYSV use O_NDELAY
if BSD use FNDELAY
**/
int ev_set_blocking(int fd, bool set)
{
int val;
#ifdef O_NONBLOCK
#define FLAG_TO_SET O_NONBLOCK
#else
#ifdef SYSV
#define FLAG_TO_SET O_NDELAY
#else /* BSD */
#define FLAG_TO_SET FNDELAY
#endif
#endif
if((val = fcntl(fd, F_GETFL, 0)) == -1)
return -1;
if(set) /* Turn blocking on - ie. clear nonblock flag */
val &= ~FLAG_TO_SET;
else
val |= FLAG_TO_SET;
return fcntl( fd, F_SETFL, val);
#undef FLAG_TO_SET
}
bool ev_set_close_on_exec(int fd)
{
#ifdef FD_CLOEXEC
int val;
val = fcntl(fd, F_GETFD, 0);
if (val >= 0) {
val |= FD_CLOEXEC;
val = fcntl(fd, F_SETFD, val);
if (val != -1) {
return true;
}
}
#endif
return false;
}
tevent-0.9.19/tevent_util.h 0000660 0000000 0000000 00000011751 12101212317 015561 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Copyright (C) Andrew Tridgell 1998-2010
Copyright (C) Jelmer Vernooij 2005
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/* To use these macros you must have a structure containing a next and
prev pointer */
#ifndef _DLINKLIST_H
#define _DLINKLIST_H
/*
February 2010 - changed list format to have a prev pointer from the
list head. This makes DLIST_ADD_END() O(1) even though we only have
one list pointer.
The scheme is as follows:
1) with no entries in the list:
list_head == NULL
2) with 1 entry in the list:
list_head->next == NULL
list_head->prev == list_head
3) with 2 entries in the list:
list_head->next == element2
list_head->prev == element2
element2->prev == list_head
element2->next == NULL
4) with N entries in the list:
list_head->next == element2
list_head->prev == elementN
elementN->prev == element{N-1}
elementN->next == NULL
This allows us to find the tail of the list by using
list_head->prev, which means we can add to the end of the list in
O(1) time
Note that the 'type' arguments below are no longer needed, but
are kept for now to prevent an incompatible argument change
*/
/*
add an element at the front of a list
*/
#define DLIST_ADD(list, p) \
do { \
if (!(list)) { \
(p)->prev = (list) = (p); \
(p)->next = NULL; \
} else { \
(p)->prev = (list)->prev; \
(list)->prev = (p); \
(p)->next = (list); \
(list) = (p); \
} \
} while (0)
/*
remove an element from a list
Note that the element doesn't have to be in the list. If it
isn't then this is a no-op
*/
#define DLIST_REMOVE(list, p) \
do { \
if ((p) == (list)) { \
if ((p)->next) (p)->next->prev = (p)->prev; \
(list) = (p)->next; \
} else if ((list) && (p) == (list)->prev) { \
(p)->prev->next = NULL; \
(list)->prev = (p)->prev; \
} else { \
if ((p)->prev) (p)->prev->next = (p)->next; \
if ((p)->next) (p)->next->prev = (p)->prev; \
} \
if ((p) != (list)) (p)->next = (p)->prev = NULL; \
} while (0)
/*
find the head of the list given any element in it.
Note that this costs O(N), so you should avoid this macro
if at all possible!
*/
#define DLIST_HEAD(p, result_head) \
do { \
(result_head) = (p); \
while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
} while(0)
/* return the last element in the list */
#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
/* return the previous element in the list. */
#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
/* insert 'p' after the given element 'el' in a list. If el is NULL then
this is the same as a DLIST_ADD() */
#define DLIST_ADD_AFTER(list, p, el) \
do { \
if (!(list) || !(el)) { \
DLIST_ADD(list, p); \
} else { \
(p)->prev = (el); \
(p)->next = (el)->next; \
(el)->next = (p); \
if ((p)->next) (p)->next->prev = (p); \
if ((list)->prev == (el)) (list)->prev = (p); \
}\
} while (0)
/*
add to the end of a list.
Note that 'type' is ignored
*/
#define DLIST_ADD_END(list, p, type) \
do { \
if (!(list)) { \
DLIST_ADD(list, p); \
} else { \
DLIST_ADD_AFTER(list, p, (list)->prev); \
} \
} while (0)
/* promote an element to the from of a list */
#define DLIST_PROMOTE(list, p) \
do { \
DLIST_REMOVE(list, p); \
DLIST_ADD(list, p); \
} while (0)
/*
demote an element to the end of a list.
Note that 'type' is ignored
*/
#define DLIST_DEMOTE(list, p, type) \
do { \
DLIST_REMOVE(list, p); \
DLIST_ADD_END(list, p, NULL); \
} while (0)
/*
concatenate two lists - putting all elements of the 2nd list at the
end of the first list.
Note that 'type' is ignored
*/
#define DLIST_CONCATENATE(list1, list2, type) \
do { \
if (!(list1)) { \
(list1) = (list2); \
} else { \
(list1)->prev->next = (list2); \
if (list2) { \
void *_tmplist = (void *)(list1)->prev; \
(list1)->prev = (list2)->prev; \
(list2)->prev = _tmplist; \
} \
} \
} while (0)
#endif /* _DLINKLIST_H */
const char **ev_str_list_add(const char **list, const char *s);
int ev_set_blocking(int fd, bool set);
size_t ev_str_list_length(const char **list);
bool ev_set_close_on_exec(int fd);
/* Defined here so we can build against older talloc versions that don't
* have this define yet. */
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
#endif
tevent-0.9.19/tevent_wakeup.c 0000660 0000000 0000000 00000003441 11741275274 016114 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Infrastructure for async requests
Copyright (C) Volker Lendecke 2008
Copyright (C) Stefan Metzmacher 2009
** NOTE! The following LGPL license applies to the tevent
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "tevent.h"
#include "tevent_internal.h"
#include "tevent_util.h"
struct tevent_wakeup_state {
struct timeval wakeup_time;
};
struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct timeval wakeup_time)
{
struct tevent_req *req;
struct tevent_wakeup_state *state;
req = tevent_req_create(mem_ctx, &state,
struct tevent_wakeup_state);
if (!req) {
return NULL;
}
state->wakeup_time = wakeup_time;
if (!tevent_req_set_endtime(req, ev, wakeup_time)) {
goto post;
}
return req;
post:
return tevent_req_post(req, ev);
}
bool tevent_wakeup_recv(struct tevent_req *req)
{
enum tevent_req_state state;
uint64_t error;
if (tevent_req_is_error(req, &state, &error)) {
if (state == TEVENT_REQ_TIMED_OUT) {
return true;
}
}
return false;
}
tevent-0.9.19/wscript 0000770 0000000 0000000 00000011440 12176475205 014504 0 ustar root root 0000000 0000000 #!/usr/bin/env python
APPNAME = 'tevent'
VERSION = '0.9.19'
blddir = 'bin'
import sys, os
# find the buildtools directory
srcdir = '.'
while not os.path.exists(srcdir+'/buildtools') and len(srcdir.split('/')) < 5:
srcdir = '../' + srcdir
sys.path.insert(0, srcdir + '/buildtools/wafsamba')
import wafsamba, samba_dist, Options, Logs
samba_dist.DIST_DIRS('lib/tevent:. lib/replace:lib/replace lib/talloc:lib/talloc buildtools:buildtools')
def set_options(opt):
opt.BUILTIN_DEFAULT('replace')
opt.PRIVATE_EXTENSION_DEFAULT('tevent', noextension='tevent')
opt.RECURSE('lib/replace')
opt.RECURSE('lib/talloc')
if opt.IN_LAUNCH_DIR():
opt.add_option('--disable-python',
help=("disable the pytevent module"),
action="store_true", dest='disable_python', default=False)
def configure(conf):
conf.RECURSE('lib/replace')
conf.RECURSE('lib/talloc')
conf.env.standalone_tevent = conf.IN_LAUNCH_DIR()
if not conf.env.standalone_tevent:
if conf.CHECK_BUNDLED_SYSTEM_PKG('tevent', minversion=VERSION,
onlyif='talloc', implied_deps='replace talloc'):
conf.define('USING_SYSTEM_TEVENT', 1)
if conf.CHECK_BUNDLED_SYSTEM_PYTHON('pytevent', 'tevent', minversion=VERSION):
conf.define('USING_SYSTEM_PYTEVENT', 1)
if conf.CHECK_FUNCS('epoll_create', headers='sys/epoll.h'):
conf.DEFINE('HAVE_EPOLL', 1)
tevent_num_signals = 64
v = conf.CHECK_VALUEOF('NSIG', headers='signal.h')
if v is not None:
tevent_num_signals = max(tevent_num_signals, v)
v = conf.CHECK_VALUEOF('_NSIG', headers='signal.h')
if v is not None:
tevent_num_signals = max(tevent_num_signals, v)
v = conf.CHECK_VALUEOF('SIGRTMAX', headers='signal.h')
if v is not None:
tevent_num_signals = max(tevent_num_signals, v)
v = conf.CHECK_VALUEOF('SIGRTMIN', headers='signal.h')
if v is not None:
tevent_num_signals = max(tevent_num_signals, v*2)
if not conf.CONFIG_SET('USING_SYSTEM_TEVENT'):
conf.DEFINE('TEVENT_NUM_SIGNALS', tevent_num_signals)
conf.env.disable_python = getattr(Options.options, 'disable_python', False)
if not conf.env.disable_python:
# also disable if we don't have the python libs installed
conf.find_program('python', var='PYTHON')
conf.check_tool('python')
conf.check_python_version((2,4,2))
conf.SAMBA_CHECK_PYTHON_HEADERS(mandatory=False)
if not conf.env.HAVE_PYTHON_H:
Logs.warn('Disabling pytevent as python devel libs not found')
conf.env.disable_python = True
conf.SAMBA_CONFIG_H()
conf.SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS()
def build(bld):
bld.RECURSE('lib/replace')
bld.RECURSE('lib/talloc')
SRC = '''tevent.c tevent_debug.c tevent_fd.c tevent_immediate.c
tevent_queue.c tevent_req.c tevent_select.c
tevent_poll.c
tevent_signal.c tevent_standard.c tevent_timed.c tevent_util.c tevent_wakeup.c'''
if bld.CONFIG_SET('HAVE_EPOLL'):
SRC += ' tevent_epoll.c'
if bld.env.standalone_tevent:
bld.env.PKGCONFIGDIR = '${LIBDIR}/pkgconfig'
private_library = False
else:
private_library = True
if not bld.CONFIG_SET('USING_SYSTEM_TEVENT'):
bld.SAMBA_LIBRARY('tevent',
SRC,
deps='replace talloc',
enabled= not bld.CONFIG_SET('USING_SYSTEM_TEVENT'),
includes='.',
abi_directory='ABI',
abi_match='tevent_* _tevent_*',
vnum=VERSION,
public_headers='tevent.h',
public_headers_install=not private_library,
pc_files='tevent.pc',
private_library=private_library)
if not bld.CONFIG_SET('USING_SYSTEM_PYTEVENT') and not bld.env.disable_python:
bld.SAMBA_PYTHON('pytevent',
'pytevent.c',
deps='tevent',
realname='_tevent.so',
cflags='-DPACKAGE_VERSION=\"%s\"' % VERSION)
# install out various python scripts for use by make test
bld.SAMBA_SCRIPT('tevent_python',
pattern='tevent.py',
installdir='python')
bld.INSTALL_WILDCARD('${PYTHONARCHDIR}', 'tevent.py', flat=False)
def test(ctx):
'''test tevent'''
print("The tevent testsuite is part of smbtorture in samba4")
def dist():
'''makes a tarball for distribution'''
samba_dist.dist()
def reconfigure(ctx):
'''reconfigure if config scripts have changed'''
import samba_utils
samba_utils.reconfigure(ctx)
tevent-0.9.19/lib/replace/.checker_innocent 0000660 0000000 0000000 00000000246 11741275274 020552 0 ustar root root 0000000 0000000 >>>MISTAKE21_create_files_6a9e68ada99a97cb
>>>MISTAKE21_os2_delete_9b2bfa7f38711d09
>>>MISTAKE21_os2_delete_2fcc29aaa99a97cb
>>>SECURITY2_os2_delete_9b2bfa7f1c9396ca
tevent-0.9.19/lib/replace/Makefile 0000660 0000000 0000000 00000001503 12101212317 016661 0 ustar root root 0000000 0000000 # simple makefile wrapper to run waf
WAF=WAF_MAKE=1 PATH=buildtools/bin:../../buildtools/bin:$$PATH waf
all:
$(WAF) build
install:
$(WAF) install
uninstall:
$(WAF) uninstall
test:
$(WAF) test $(TEST_OPTIONS)
testenv:
$(WAF) test --testenv $(TEST_OPTIONS)
quicktest:
$(WAF) test --quick $(TEST_OPTIONS)
dist:
touch .tmplock
WAFLOCK=.tmplock $(WAF) dist
distcheck:
touch .tmplock
WAFLOCK=.tmplock $(WAF) distcheck
clean:
$(WAF) clean
distclean:
$(WAF) distclean
reconfigure: configure
$(WAF) reconfigure
show_waf_options:
$(WAF) --help
# some compatibility make targets
everything: all
testsuite: all
check: test
torture: all
# this should do an install as well, once install is finished
installcheck: test
etags:
$(WAF) etags
ctags:
$(WAF) ctags
bin/%:: FORCE
$(WAF) --targets=`basename $@`
FORCE:
tevent-0.9.19/lib/replace/README 0000660 0000000 0000000 00000003040 12153373752 016121 0 ustar root root 0000000 0000000 This subsystem ensures that we can always use a certain core set of
functions and types, that are either provided by the OS or by replacement
functions / definitions in this subsystem. The aim is to try to stick
to POSIX functions in here as much as possible. Convenience functions
that are available on no platform at all belong in other subsystems
(such as LIBUTIL).
The following functions are guaranteed:
ftruncate
strlcpy
strlcat
mktime
rename
initgroups
memmove
strdup
setlinebuf
vsyslog
timegm
setenv
unsetenv
strndup
strnlen
waitpid
seteuid
setegid
asprintf
snprintf
vasprintf
vsnprintf
opendir
readdir
telldir
seekdir
clock_gettime
closedir
dlopen
dlclose
dlsym
dlerror
chroot
bzero
strerror
errno
mkdtemp
mkstemp (a secure one!)
pread
pwrite
chown
lchown
readline (the library)
inet_ntoa
inet_ntop
inet_pton
inet_aton
strtoll
strtoull
socketpair
strptime
getaddrinfo
freeaddrinfo
getnameinfo
gai_strerror
getifaddrs
freeifaddrs
utime
utimes
dup2
link
readlink
symlink
realpath
poll
setproctitle
Types:
bool
socklen_t
uint{8,16,32,64}_t
int{8,16,32,64}_t
intptr_t
sig_atomic_t
blksize_t
blkcnt_t
Constants:
PATH_NAME_MAX
UINT{16,32,64}_MAX
INT32_MAX
RTLD_LAZY
HOST_NAME_MAX
UINT16_MAX
UINT32_MAX
UINT64_MAX
CHAR_BIT
Macros:
va_copy
__FUNCTION__
__FILE__
__LINE__
__LINESTR__
__location__
__STRING
__STRINGSTRING
MIN
MAX
QSORT_CAST
ZERO_STRUCT
ZERO_STRUCTP
ZERO_STRUCTPN
ZERO_ARRAY
ARRAY_SIZE
PTR_DIFF
Headers:
stdint.h
stdbool.h
Optional C keywords:
volatile
Prerequisites:
memset (for bzero)
syslog (for vsyslog)
mktemp (for mkstemp and mkdtemp)
tevent-0.9.19/lib/replace/configure 0000770 0000000 0000000 00000000650 11741275274 017155 0 ustar root root 0000000 0000000 #!/bin/sh
PREVPATH=`dirname $0`
if [ -f $PREVPATH/../../buildtools/bin/waf ]; then
WAF=../../buildtools/bin/waf
elif [ -f $PREVPATH/buildtools/bin/waf ]; then
WAF=./buildtools/bin/waf
else
echo "replace: Unable to find waf"
exit 1
fi
# using JOBS=1 gives maximum compatibility with
# systems like AIX which have broken threading in python
JOBS=1
export JOBS
cd . || exit 1
$WAF configure "$@" || exit 1
cd $PREVPATH
tevent-0.9.19/lib/replace/crypt.c 0000660 0000000 0000000 00000053461 11741275274 016564 0 ustar root root 0000000 0000000 /*
This bit of code was derived from the UFC-crypt package which
carries the following copyright
Modified for use by Samba by Andrew Tridgell, October 1994
Note that this routine is only faster on some machines. Under Linux 1.1.51
libc 4.5.26 I actually found this routine to be slightly slower.
Under SunOS I found a huge speedup by using these routines
(a factor of 20 or so)
Warning: I've had a report from Steve Kennedy
that this crypt routine may sometimes get the wrong answer. Only
use UFC_CRYT if you really need it.
*/
#include "replace.h"
#ifndef HAVE_CRYPT
/*
* UFC-crypt: ultra fast crypt(3) implementation
*
* Copyright (C) 1991-1998, Free Software Foundation, Inc.
*
* This library 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 3 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see .
*
* @(#)crypt_util.c 2.31 02/08/92
*
* Support routines
*
*/
#ifndef long32
#define long32 int32_t
#endif
#ifndef long64
#define long64 int64_t
#endif
#ifndef ufc_long
#define ufc_long unsigned
#endif
#ifndef _UFC_64_
#define _UFC_32_
#endif
/*
* Permutation done once on the 56 bit
* key derived from the original 8 byte ASCII key.
*/
static int pc1[56] = {
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
};
/*
* How much to rotate each 28 bit half of the pc1 permutated
* 56 bit key before using pc2 to give the i' key
*/
static int rots[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
/*
* Permutation giving the key
* of the i' DES round
*/
static int pc2[48] = {
14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
};
/*
* The E expansion table which selects
* bits from the 32 bit intermediate result.
*/
static int esel[48] = {
32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1
};
static int e_inverse[64];
/*
* Permutation done on the
* result of sbox lookups
*/
static int perm32[32] = {
16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
};
/*
* The sboxes
*/
static int sbox[8][4][16]= {
{ { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
{ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
{ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
{ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 }
},
{ { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
{ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
{ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
{ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 }
},
{ { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
{ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
{ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
{ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 }
},
{ { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
{ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },
{ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
{ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 }
},
{ { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
{ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
{ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
{ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 }
},
{ { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
{ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
{ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
{ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 }
},
{ { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
{ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
{ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
{ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 }
},
{ { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
{ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
{ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
{ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 }
}
};
/*
* This is the final
* permutation matrix
*/
static int final_perm[64] = {
40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
};
/*
* The 16 DES keys in BITMASK format
*/
#ifdef _UFC_32_
long32 _ufc_keytab[16][2];
#endif
#ifdef _UFC_64_
long64 _ufc_keytab[16];
#endif
#define ascii_to_bin(c) ((c)>='a'?(c-59):(c)>='A'?((c)-53):(c)-'.')
#define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
/* Macro to set a bit (0..23) */
#define BITMASK(i) ( (1<<(11-(i)%12+3)) << ((i)<12?16:0) )
/*
* sb arrays:
*
* Workhorses of the inner loop of the DES implementation.
* They do sbox lookup, shifting of this value, 32 bit
* permutation and E permutation for the next round.
*
* Kept in 'BITMASK' format.
*/
#ifdef _UFC_32_
long32 _ufc_sb0[8192], _ufc_sb1[8192], _ufc_sb2[8192], _ufc_sb3[8192];
static long32 *sb[4] = {_ufc_sb0, _ufc_sb1, _ufc_sb2, _ufc_sb3};
#endif
#ifdef _UFC_64_
long64 _ufc_sb0[4096], _ufc_sb1[4096], _ufc_sb2[4096], _ufc_sb3[4096];
static long64 *sb[4] = {_ufc_sb0, _ufc_sb1, _ufc_sb2, _ufc_sb3};
#endif
/*
* eperm32tab: do 32 bit permutation and E selection
*
* The first index is the byte number in the 32 bit value to be permuted
* - second - is the value of this byte
* - third - selects the two 32 bit values
*
* The table is used and generated internally in init_des to speed it up
*/
static ufc_long eperm32tab[4][256][2];
/*
* do_pc1: permform pc1 permutation in the key schedule generation.
*
* The first index is the byte number in the 8 byte ASCII key
* - second - - the two 28 bits halfs of the result
* - third - selects the 7 bits actually used of each byte
*
* The result is kept with 28 bit per 32 bit with the 4 most significant
* bits zero.
*/
static ufc_long do_pc1[8][2][128];
/*
* do_pc2: permform pc2 permutation in the key schedule generation.
*
* The first index is the septet number in the two 28 bit intermediate values
* - second - - - septet values
*
* Knowledge of the structure of the pc2 permutation is used.
*
* The result is kept with 28 bit per 32 bit with the 4 most significant
* bits zero.
*/
static ufc_long do_pc2[8][128];
/*
* efp: undo an extra e selection and do final
* permutation giving the DES result.
*
* Invoked 6 bit a time on two 48 bit values
* giving two 32 bit longs.
*/
static ufc_long efp[16][64][2];
static unsigned char bytemask[8] = {
0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
};
static ufc_long longmask[32] = {
0x80000000, 0x40000000, 0x20000000, 0x10000000,
0x08000000, 0x04000000, 0x02000000, 0x01000000,
0x00800000, 0x00400000, 0x00200000, 0x00100000,
0x00080000, 0x00040000, 0x00020000, 0x00010000,
0x00008000, 0x00004000, 0x00002000, 0x00001000,
0x00000800, 0x00000400, 0x00000200, 0x00000100,
0x00000080, 0x00000040, 0x00000020, 0x00000010,
0x00000008, 0x00000004, 0x00000002, 0x00000001
};
/*
* Silly rewrite of 'bzero'. I do so
* because some machines don't have
* bzero and some don't have memset.
*/
static void clearmem(char *start, int cnt)
{ while(cnt--)
*start++ = '\0';
}
static int initialized = 0;
/* lookup a 6 bit value in sbox */
#define s_lookup(i,s) sbox[(i)][(((s)>>4) & 0x2)|((s) & 0x1)][((s)>>1) & 0xf];
/*
* Initialize unit - may be invoked directly
* by fcrypt users.
*/
static void ufc_init_des(void)
{ int comes_from_bit;
int bit, sg;
ufc_long j;
ufc_long mask1, mask2;
/*
* Create the do_pc1 table used
* to affect pc1 permutation
* when generating keys
*/
for(bit = 0; bit < 56; bit++) {
comes_from_bit = pc1[bit] - 1;
mask1 = bytemask[comes_from_bit % 8 + 1];
mask2 = longmask[bit % 28 + 4];
for(j = 0; j < 128; j++) {
if(j & mask1)
do_pc1[comes_from_bit / 8][bit / 28][j] |= mask2;
}
}
/*
* Create the do_pc2 table used
* to affect pc2 permutation when
* generating keys
*/
for(bit = 0; bit < 48; bit++) {
comes_from_bit = pc2[bit] - 1;
mask1 = bytemask[comes_from_bit % 7 + 1];
mask2 = BITMASK(bit % 24);
for(j = 0; j < 128; j++) {
if(j & mask1)
do_pc2[comes_from_bit / 7][j] |= mask2;
}
}
/*
* Now generate the table used to do combined
* 32 bit permutation and e expansion
*
* We use it because we have to permute 16384 32 bit
* longs into 48 bit in order to initialize sb.
*
* Looping 48 rounds per permutation becomes
* just too slow...
*
*/
clearmem((char*)eperm32tab, sizeof(eperm32tab));
for(bit = 0; bit < 48; bit++) {
ufc_long inner_mask1,comes_from;
comes_from = perm32[esel[bit]-1]-1;
inner_mask1 = bytemask[comes_from % 8];
for(j = 256; j--;) {
if(j & inner_mask1)
eperm32tab[comes_from / 8][j][bit / 24] |= BITMASK(bit % 24);
}
}
/*
* Create the sb tables:
*
* For each 12 bit segment of an 48 bit intermediate
* result, the sb table precomputes the two 4 bit
* values of the sbox lookups done with the two 6
* bit halves, shifts them to their proper place,
* sends them through perm32 and finally E expands
* them so that they are ready for the next
* DES round.
*
*/
for(sg = 0; sg < 4; sg++) {
int j1, j2;
int s1, s2;
for(j1 = 0; j1 < 64; j1++) {
s1 = s_lookup(2 * sg, j1);
for(j2 = 0; j2 < 64; j2++) {
ufc_long to_permute, inx;
s2 = s_lookup(2 * sg + 1, j2);
to_permute = ((s1 << 4) | s2) << (24 - 8 * sg);
#ifdef _UFC_32_
inx = ((j1 << 6) | j2) << 1;
sb[sg][inx ] = eperm32tab[0][(to_permute >> 24) & 0xff][0];
sb[sg][inx+1] = eperm32tab[0][(to_permute >> 24) & 0xff][1];
sb[sg][inx ] |= eperm32tab[1][(to_permute >> 16) & 0xff][0];
sb[sg][inx+1] |= eperm32tab[1][(to_permute >> 16) & 0xff][1];
sb[sg][inx ] |= eperm32tab[2][(to_permute >> 8) & 0xff][0];
sb[sg][inx+1] |= eperm32tab[2][(to_permute >> 8) & 0xff][1];
sb[sg][inx ] |= eperm32tab[3][(to_permute) & 0xff][0];
sb[sg][inx+1] |= eperm32tab[3][(to_permute) & 0xff][1];
#endif
#ifdef _UFC_64_
inx = ((j1 << 6) | j2);
sb[sg][inx] =
((long64)eperm32tab[0][(to_permute >> 24) & 0xff][0] << 32) |
(long64)eperm32tab[0][(to_permute >> 24) & 0xff][1];
sb[sg][inx] |=
((long64)eperm32tab[1][(to_permute >> 16) & 0xff][0] << 32) |
(long64)eperm32tab[1][(to_permute >> 16) & 0xff][1];
sb[sg][inx] |=
((long64)eperm32tab[2][(to_permute >> 8) & 0xff][0] << 32) |
(long64)eperm32tab[2][(to_permute >> 8) & 0xff][1];
sb[sg][inx] |=
((long64)eperm32tab[3][(to_permute) & 0xff][0] << 32) |
(long64)eperm32tab[3][(to_permute) & 0xff][1];
#endif
}
}
}
/*
* Create an inverse matrix for esel telling
* where to plug out bits if undoing it
*/
for(bit=48; bit--;) {
e_inverse[esel[bit] - 1 ] = bit;
e_inverse[esel[bit] - 1 + 32] = bit + 48;
}
/*
* create efp: the matrix used to
* undo the E expansion and effect final permutation
*/
clearmem((char*)efp, sizeof efp);
for(bit = 0; bit < 64; bit++) {
int o_bit, o_long;
ufc_long word_value, inner_mask1, inner_mask2;
int comes_from_f_bit, comes_from_e_bit;
int comes_from_word, bit_within_word;
/* See where bit i belongs in the two 32 bit long's */
o_long = bit / 32; /* 0..1 */
o_bit = bit % 32; /* 0..31 */
/*
* And find a bit in the e permutated value setting this bit.
*
* Note: the e selection may have selected the same bit several
* times. By the initialization of e_inverse, we only look
* for one specific instance.
*/
comes_from_f_bit = final_perm[bit] - 1; /* 0..63 */
comes_from_e_bit = e_inverse[comes_from_f_bit]; /* 0..95 */
comes_from_word = comes_from_e_bit / 6; /* 0..15 */
bit_within_word = comes_from_e_bit % 6; /* 0..5 */
inner_mask1 = longmask[bit_within_word + 26];
inner_mask2 = longmask[o_bit];
for(word_value = 64; word_value--;) {
if(word_value & inner_mask1)
efp[comes_from_word][word_value][o_long] |= inner_mask2;
}
}
initialized++;
}
/*
* Process the elements of the sb table permuting the
* bits swapped in the expansion by the current salt.
*/
#ifdef _UFC_32_
static void shuffle_sb(long32 *k, ufc_long saltbits)
{ ufc_long j;
long32 x;
for(j=4096; j--;) {
x = (k[0] ^ k[1]) & (long32)saltbits;
*k++ ^= x;
*k++ ^= x;
}
}
#endif
#ifdef _UFC_64_
static void shuffle_sb(long64 *k, ufc_long saltbits)
{ ufc_long j;
long64 x;
for(j=4096; j--;) {
x = ((*k >> 32) ^ *k) & (long64)saltbits;
*k++ ^= (x << 32) | x;
}
}
#endif
/*
* Setup the unit for a new salt
* Hopefully we'll not see a new salt in each crypt call.
*/
static unsigned char current_salt[3] = "&&"; /* invalid value */
static ufc_long current_saltbits = 0;
static int direction = 0;
static void setup_salt(const char *s1)
{ ufc_long i, j, saltbits;
const unsigned char *s2 = (const unsigned char *)s1;
if(!initialized)
ufc_init_des();
if(s2[0] == current_salt[0] && s2[1] == current_salt[1])
return;
current_salt[0] = s2[0]; current_salt[1] = s2[1];
/*
* This is the only crypt change to DES:
* entries are swapped in the expansion table
* according to the bits set in the salt.
*/
saltbits = 0;
for(i = 0; i < 2; i++) {
long c=ascii_to_bin(s2[i]);
if(c < 0 || c > 63)
c = 0;
for(j = 0; j < 6; j++) {
if((c >> j) & 0x1)
saltbits |= BITMASK(6 * i + j);
}
}
/*
* Permute the sb table values
* to reflect the changed e
* selection table
*/
shuffle_sb(_ufc_sb0, current_saltbits ^ saltbits);
shuffle_sb(_ufc_sb1, current_saltbits ^ saltbits);
shuffle_sb(_ufc_sb2, current_saltbits ^ saltbits);
shuffle_sb(_ufc_sb3, current_saltbits ^ saltbits);
current_saltbits = saltbits;
}
static void ufc_mk_keytab(char *key)
{ ufc_long v1, v2, *k1;
int i;
#ifdef _UFC_32_
long32 v, *k2 = &_ufc_keytab[0][0];
#endif
#ifdef _UFC_64_
long64 v, *k2 = &_ufc_keytab[0];
#endif
v1 = v2 = 0; k1 = &do_pc1[0][0][0];
for(i = 8; i--;) {
v1 |= k1[*key & 0x7f]; k1 += 128;
v2 |= k1[*key++ & 0x7f]; k1 += 128;
}
for(i = 0; i < 16; i++) {
k1 = &do_pc2[0][0];
v1 = (v1 << rots[i]) | (v1 >> (28 - rots[i]));
v = k1[(v1 >> 21) & 0x7f]; k1 += 128;
v |= k1[(v1 >> 14) & 0x7f]; k1 += 128;
v |= k1[(v1 >> 7) & 0x7f]; k1 += 128;
v |= k1[(v1 ) & 0x7f]; k1 += 128;
#ifdef _UFC_32_
*k2++ = v;
v = 0;
#endif
#ifdef _UFC_64_
v <<= 32;
#endif
v2 = (v2 << rots[i]) | (v2 >> (28 - rots[i]));
v |= k1[(v2 >> 21) & 0x7f]; k1 += 128;
v |= k1[(v2 >> 14) & 0x7f]; k1 += 128;
v |= k1[(v2 >> 7) & 0x7f]; k1 += 128;
v |= k1[(v2 ) & 0x7f];
*k2++ = v;
}
direction = 0;
}
/*
* Undo an extra E selection and do final permutations
*/
ufc_long *_ufc_dofinalperm(ufc_long l1, ufc_long l2, ufc_long r1, ufc_long r2)
{ ufc_long v1, v2, x;
static ufc_long ary[2];
x = (l1 ^ l2) & current_saltbits; l1 ^= x; l2 ^= x;
x = (r1 ^ r2) & current_saltbits; r1 ^= x; r2 ^= x;
v1=v2=0; l1 >>= 3; l2 >>= 3; r1 >>= 3; r2 >>= 3;
v1 |= efp[15][ r2 & 0x3f][0]; v2 |= efp[15][ r2 & 0x3f][1];
v1 |= efp[14][(r2 >>= 6) & 0x3f][0]; v2 |= efp[14][ r2 & 0x3f][1];
v1 |= efp[13][(r2 >>= 10) & 0x3f][0]; v2 |= efp[13][ r2 & 0x3f][1];
v1 |= efp[12][(r2 >>= 6) & 0x3f][0]; v2 |= efp[12][ r2 & 0x3f][1];
v1 |= efp[11][ r1 & 0x3f][0]; v2 |= efp[11][ r1 & 0x3f][1];
v1 |= efp[10][(r1 >>= 6) & 0x3f][0]; v2 |= efp[10][ r1 & 0x3f][1];
v1 |= efp[ 9][(r1 >>= 10) & 0x3f][0]; v2 |= efp[ 9][ r1 & 0x3f][1];
v1 |= efp[ 8][(r1 >>= 6) & 0x3f][0]; v2 |= efp[ 8][ r1 & 0x3f][1];
v1 |= efp[ 7][ l2 & 0x3f][0]; v2 |= efp[ 7][ l2 & 0x3f][1];
v1 |= efp[ 6][(l2 >>= 6) & 0x3f][0]; v2 |= efp[ 6][ l2 & 0x3f][1];
v1 |= efp[ 5][(l2 >>= 10) & 0x3f][0]; v2 |= efp[ 5][ l2 & 0x3f][1];
v1 |= efp[ 4][(l2 >>= 6) & 0x3f][0]; v2 |= efp[ 4][ l2 & 0x3f][1];
v1 |= efp[ 3][ l1 & 0x3f][0]; v2 |= efp[ 3][ l1 & 0x3f][1];
v1 |= efp[ 2][(l1 >>= 6) & 0x3f][0]; v2 |= efp[ 2][ l1 & 0x3f][1];
v1 |= efp[ 1][(l1 >>= 10) & 0x3f][0]; v2 |= efp[ 1][ l1 & 0x3f][1];
v1 |= efp[ 0][(l1 >>= 6) & 0x3f][0]; v2 |= efp[ 0][ l1 & 0x3f][1];
ary[0] = v1; ary[1] = v2;
return ary;
}
/*
* crypt only: convert from 64 bit to 11 bit ASCII
* prefixing with the salt
*/
static char *output_conversion(ufc_long v1, ufc_long v2, const char *salt)
{ static char outbuf[14];
int i, s;
outbuf[0] = salt[0];
outbuf[1] = salt[1] ? salt[1] : salt[0];
for(i = 0; i < 5; i++)
outbuf[i + 2] = bin_to_ascii((v1 >> (26 - 6 * i)) & 0x3f);
s = (v2 & 0xf) << 2;
v2 = (v2 >> 2) | ((v1 & 0x3) << 30);
for(i = 5; i < 10; i++)
outbuf[i + 2] = bin_to_ascii((v2 >> (56 - 6 * i)) & 0x3f);
outbuf[12] = bin_to_ascii(s);
outbuf[13] = 0;
return outbuf;
}
/*
* UNIX crypt function
*/
static ufc_long *_ufc_doit(ufc_long , ufc_long, ufc_long, ufc_long, ufc_long);
char *ufc_crypt(const char *key,const char *salt)
{ ufc_long *s;
char ktab[9];
/*
* Hack DES tables according to salt
*/
setup_salt(salt);
/*
* Setup key schedule
*/
clearmem(ktab, sizeof ktab);
strncpy(ktab, key, 8);
ufc_mk_keytab(ktab);
/*
* Go for the 25 DES encryptions
*/
s = _ufc_doit((ufc_long)0, (ufc_long)0,
(ufc_long)0, (ufc_long)0, (ufc_long)25);
/*
* And convert back to 6 bit ASCII
*/
return output_conversion(s[0], s[1], salt);
}
#ifdef _UFC_32_
/*
* 32 bit version
*/
extern long32 _ufc_keytab[16][2];
extern long32 _ufc_sb0[], _ufc_sb1[], _ufc_sb2[], _ufc_sb3[];
#define SBA(sb, v) (*(long32*)((char*)(sb)+(v)))
static ufc_long *_ufc_doit(ufc_long l1, ufc_long l2, ufc_long r1, ufc_long r2, ufc_long itr)
{ int i;
long32 s, *k;
while(itr--) {
k = &_ufc_keytab[0][0];
for(i=8; i--; ) {
s = *k++ ^ r1;
l1 ^= SBA(_ufc_sb1, s & 0xffff); l2 ^= SBA(_ufc_sb1, (s & 0xffff)+4);
l1 ^= SBA(_ufc_sb0, s >>= 16); l2 ^= SBA(_ufc_sb0, (s) +4);
s = *k++ ^ r2;
l1 ^= SBA(_ufc_sb3, s & 0xffff); l2 ^= SBA(_ufc_sb3, (s & 0xffff)+4);
l1 ^= SBA(_ufc_sb2, s >>= 16); l2 ^= SBA(_ufc_sb2, (s) +4);
s = *k++ ^ l1;
r1 ^= SBA(_ufc_sb1, s & 0xffff); r2 ^= SBA(_ufc_sb1, (s & 0xffff)+4);
r1 ^= SBA(_ufc_sb0, s >>= 16); r2 ^= SBA(_ufc_sb0, (s) +4);
s = *k++ ^ l2;
r1 ^= SBA(_ufc_sb3, s & 0xffff); r2 ^= SBA(_ufc_sb3, (s & 0xffff)+4);
r1 ^= SBA(_ufc_sb2, s >>= 16); r2 ^= SBA(_ufc_sb2, (s) +4);
}
s=l1; l1=r1; r1=s; s=l2; l2=r2; r2=s;
}
return _ufc_dofinalperm(l1, l2, r1, r2);
}
#endif
#ifdef _UFC_64_
/*
* 64 bit version
*/
extern long64 _ufc_keytab[16];
extern long64 _ufc_sb0[], _ufc_sb1[], _ufc_sb2[], _ufc_sb3[];
#define SBA(sb, v) (*(long64*)((char*)(sb)+(v)))
static ufc_long *_ufc_doit(ufc_long l1, ufc_long l2, ufc_long r1, ufc_long r2, ufc_long itr)
{ int i;
long64 l, r, s, *k;
l = (((long64)l1) << 32) | ((long64)l2);
r = (((long64)r1) << 32) | ((long64)r2);
while(itr--) {
k = &_ufc_keytab[0];
for(i=8; i--; ) {
s = *k++ ^ r;
l ^= SBA(_ufc_sb3, (s >> 0) & 0xffff);
l ^= SBA(_ufc_sb2, (s >> 16) & 0xffff);
l ^= SBA(_ufc_sb1, (s >> 32) & 0xffff);
l ^= SBA(_ufc_sb0, (s >> 48) & 0xffff);
s = *k++ ^ l;
r ^= SBA(_ufc_sb3, (s >> 0) & 0xffff);
r ^= SBA(_ufc_sb2, (s >> 16) & 0xffff);
r ^= SBA(_ufc_sb1, (s >> 32) & 0xffff);
r ^= SBA(_ufc_sb0, (s >> 48) & 0xffff);
}
s=l; l=r; r=s;
}
l1 = l >> 32; l2 = l & 0xffffffff;
r1 = r >> 32; r2 = r & 0xffffffff;
return _ufc_dofinalperm(l1, l2, r1, r2);
}
#endif
#else
int ufc_dummy_procedure(void);
int ufc_dummy_procedure(void) {return 0;}
#endif
tevent-0.9.19/lib/replace/dlfcn.c 0000660 0000000 0000000 00000003543 11741275274 016505 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Samba system utilities
Copyright (C) Andrew Tridgell 1992-1998
Copyright (C) Jeremy Allison 1998-2002
Copyright (C) Jelmer Vernooij 2006
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#ifdef HAVE_DL_H
#include
#endif
#ifndef HAVE_DLOPEN
#ifdef DLOPEN_TAKES_UNSIGNED_FLAGS
void *rep_dlopen(const char *name, unsigned int flags)
#else
void *rep_dlopen(const char *name, int flags)
#endif
{
#ifdef HAVE_SHL_LOAD
if (name == NULL)
return PROG_HANDLE;
return (void *)shl_load(name, flags, 0);
#else
return NULL;
#endif
}
#endif
#ifndef HAVE_DLSYM
void *rep_dlsym(void *handle, const char *symbol)
{
#ifdef HAVE_SHL_FINDSYM
void *sym_addr;
if (!shl_findsym((shl_t *)&handle, symbol, TYPE_UNDEFINED, &sym_addr))
return sym_addr;
#endif
return NULL;
}
#endif
#ifndef HAVE_DLERROR
char *rep_dlerror(void)
{
return "dynamic loading of objects not supported on this platform";
}
#endif
#ifndef HAVE_DLCLOSE
int rep_dlclose(void *handle)
{
#ifdef HAVE_SHL_CLOSE
return shl_unload((shl_t)handle);
#else
return 0;
#endif
}
#endif
tevent-0.9.19/lib/replace/getaddrinfo.c 0000660 0000000 0000000 00000024637 11741275274 017714 0 ustar root root 0000000 0000000 /*
PostgreSQL Database Management System
(formerly known as Postgres, then as Postgres95)
Portions Copyright (c) 1996-2005, The PostgreSQL Global Development Group
Portions Copyright (c) 1994, The Regents of the University of California
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose, without fee, and without a written agreement
is hereby granted, provided that the above copyright notice and this paragraph
and the following two paragraphs appear in all copies.
IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS
TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
/*-------------------------------------------------------------------------
*
* getaddrinfo.c
* Support getaddrinfo() on platforms that don't have it.
*
* We also supply getnameinfo() here, assuming that the platform will have
* it if and only if it has getaddrinfo(). If this proves false on some
* platform, we'll need to split this file and provide a separate configure
* test for getnameinfo().
*
* Copyright (c) 2003-2007, PostgreSQL Global Development Group
*
* Copyright (C) 2007 Jeremy Allison.
* Modified to return multiple IPv4 addresses for Samba.
*
*-------------------------------------------------------------------------
*/
#include "replace.h"
#include "system/network.h"
#ifndef SMB_MALLOC
#define SMB_MALLOC(s) malloc(s)
#endif
#ifndef SMB_STRDUP
#define SMB_STRDUP(s) strdup(s)
#endif
static int check_hostent_err(struct hostent *hp)
{
if (!hp) {
switch (h_errno) {
case HOST_NOT_FOUND:
case NO_DATA:
return EAI_NONAME;
case TRY_AGAIN:
return EAI_AGAIN;
case NO_RECOVERY:
default:
return EAI_FAIL;
}
}
if (!hp->h_name || hp->h_addrtype != AF_INET) {
return EAI_FAIL;
}
return 0;
}
static char *canon_name_from_hostent(struct hostent *hp,
int *perr)
{
char *ret = NULL;
*perr = check_hostent_err(hp);
if (*perr) {
return NULL;
}
ret = SMB_STRDUP(hp->h_name);
if (!ret) {
*perr = EAI_MEMORY;
}
return ret;
}
static char *get_my_canon_name(int *perr)
{
char name[HOST_NAME_MAX+1];
if (gethostname(name, HOST_NAME_MAX) == -1) {
*perr = EAI_FAIL;
return NULL;
}
/* Ensure null termination. */
name[HOST_NAME_MAX] = '\0';
return canon_name_from_hostent(gethostbyname(name), perr);
}
static char *get_canon_name_from_addr(struct in_addr ip,
int *perr)
{
return canon_name_from_hostent(
gethostbyaddr(&ip, sizeof(ip), AF_INET),
perr);
}
static struct addrinfo *alloc_entry(const struct addrinfo *hints,
struct in_addr ip,
unsigned short port)
{
struct sockaddr_in *psin = NULL;
struct addrinfo *ai = SMB_MALLOC(sizeof(*ai));
if (!ai) {
return NULL;
}
memset(ai, '\0', sizeof(*ai));
psin = SMB_MALLOC(sizeof(*psin));
if (!psin) {
free(ai);
return NULL;
}
memset(psin, '\0', sizeof(*psin));
psin->sin_family = AF_INET;
psin->sin_port = htons(port);
psin->sin_addr = ip;
ai->ai_flags = 0;
ai->ai_family = AF_INET;
ai->ai_socktype = hints->ai_socktype;
ai->ai_protocol = hints->ai_protocol;
ai->ai_addrlen = sizeof(*psin);
ai->ai_addr = (struct sockaddr *) psin;
ai->ai_canonname = NULL;
ai->ai_next = NULL;
return ai;
}
/*
* get address info for a single ipv4 address.
*
* Bugs: - servname can only be a number, not text.
*/
static int getaddr_info_single_addr(const char *service,
uint32_t addr,
const struct addrinfo *hints,
struct addrinfo **res)
{
struct addrinfo *ai = NULL;
struct in_addr ip;
unsigned short port = 0;
if (service) {
port = (unsigned short)atoi(service);
}
ip.s_addr = htonl(addr);
ai = alloc_entry(hints, ip, port);
if (!ai) {
return EAI_MEMORY;
}
/* If we're asked for the canonical name,
* make sure it returns correctly. */
if (!(hints->ai_flags & AI_NUMERICSERV) &&
hints->ai_flags & AI_CANONNAME) {
int err;
if (addr == INADDR_LOOPBACK || addr == INADDR_ANY) {
ai->ai_canonname = get_my_canon_name(&err);
} else {
ai->ai_canonname =
get_canon_name_from_addr(ip,&err);
}
if (ai->ai_canonname == NULL) {
freeaddrinfo(ai);
return err;
}
}
*res = ai;
return 0;
}
/*
* get address info for multiple ipv4 addresses.
*
* Bugs: - servname can only be a number, not text.
*/
static int getaddr_info_name(const char *node,
const char *service,
const struct addrinfo *hints,
struct addrinfo **res)
{
struct addrinfo *listp = NULL, *prevp = NULL;
char **pptr = NULL;
int err;
struct hostent *hp = NULL;
unsigned short port = 0;
if (service) {
port = (unsigned short)atoi(service);
}
hp = gethostbyname(node);
err = check_hostent_err(hp);
if (err) {
return err;
}
for(pptr = hp->h_addr_list; *pptr; pptr++) {
struct in_addr ip = *(struct in_addr *)*pptr;
struct addrinfo *ai = alloc_entry(hints, ip, port);
if (!ai) {
freeaddrinfo(listp);
return EAI_MEMORY;
}
if (!listp) {
listp = ai;
prevp = ai;
ai->ai_canonname = SMB_STRDUP(hp->h_name);
if (!ai->ai_canonname) {
freeaddrinfo(listp);
return EAI_MEMORY;
}
} else {
prevp->ai_next = ai;
prevp = ai;
}
}
*res = listp;
return 0;
}
/*
* get address info for ipv4 sockets.
*
* Bugs: - servname can only be a number, not text.
*/
int rep_getaddrinfo(const char *node,
const char *service,
const struct addrinfo * hintp,
struct addrinfo ** res)
{
struct addrinfo hints;
/* Setup the hints struct. */
if (hintp == NULL) {
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
} else {
memcpy(&hints, hintp, sizeof(hints));
}
if (hints.ai_family != AF_INET && hints.ai_family != AF_UNSPEC) {
return EAI_FAMILY;
}
if (hints.ai_socktype == 0) {
hints.ai_socktype = SOCK_STREAM;
}
if (!node && !service) {
return EAI_NONAME;
}
if (node) {
if (node[0] == '\0') {
return getaddr_info_single_addr(service,
INADDR_ANY,
&hints,
res);
} else if (hints.ai_flags & AI_NUMERICHOST) {
struct in_addr ip;
if (!inet_aton(node, &ip)) {
return EAI_FAIL;
}
return getaddr_info_single_addr(service,
ntohl(ip.s_addr),
&hints,
res);
} else {
return getaddr_info_name(node,
service,
&hints,
res);
}
} else if (hints.ai_flags & AI_PASSIVE) {
return getaddr_info_single_addr(service,
INADDR_ANY,
&hints,
res);
}
return getaddr_info_single_addr(service,
INADDR_LOOPBACK,
&hints,
res);
}
void rep_freeaddrinfo(struct addrinfo *res)
{
struct addrinfo *next = NULL;
for (;res; res = next) {
next = res->ai_next;
if (res->ai_canonname) {
free(res->ai_canonname);
}
if (res->ai_addr) {
free(res->ai_addr);
}
free(res);
}
}
const char *rep_gai_strerror(int errcode)
{
#ifdef HAVE_HSTRERROR
int hcode;
switch (errcode)
{
case EAI_NONAME:
hcode = HOST_NOT_FOUND;
break;
case EAI_AGAIN:
hcode = TRY_AGAIN;
break;
case EAI_FAIL:
default:
hcode = NO_RECOVERY;
break;
}
return hstrerror(hcode);
#else /* !HAVE_HSTRERROR */
switch (errcode)
{
case EAI_NONAME:
return "Unknown host";
case EAI_AGAIN:
return "Host name lookup failure";
#ifdef EAI_BADFLAGS
case EAI_BADFLAGS:
return "Invalid argument";
#endif
#ifdef EAI_FAMILY
case EAI_FAMILY:
return "Address family not supported";
#endif
#ifdef EAI_MEMORY
case EAI_MEMORY:
return "Not enough memory";
#endif
#ifdef EAI_NODATA
case EAI_NODATA:
return "No host data of that type was found";
#endif
#ifdef EAI_SERVICE
case EAI_SERVICE:
return "Class type not found";
#endif
#ifdef EAI_SOCKTYPE
case EAI_SOCKTYPE:
return "Socket type not supported";
#endif
default:
return "Unknown server error";
}
#endif /* HAVE_HSTRERROR */
}
static int gethostnameinfo(const struct sockaddr *sa,
char *node,
size_t nodelen,
int flags)
{
int ret = -1;
char *p = NULL;
if (!(flags & NI_NUMERICHOST)) {
struct hostent *hp = gethostbyaddr(
&((struct sockaddr_in *)sa)->sin_addr,
sizeof(struct in_addr),
sa->sa_family);
ret = check_hostent_err(hp);
if (ret == 0) {
/* Name looked up successfully. */
ret = snprintf(node, nodelen, "%s", hp->h_name);
if (ret < 0 || (size_t)ret >= nodelen) {
return EAI_MEMORY;
}
if (flags & NI_NOFQDN) {
p = strchr(node,'.');
if (p) {
*p = '\0';
}
}
return 0;
}
if (flags & NI_NAMEREQD) {
/* If we require a name and didn't get one,
* automatically fail. */
return ret;
}
/* Otherwise just fall into the numeric host code... */
}
p = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
ret = snprintf(node, nodelen, "%s", p);
if (ret < 0 || (size_t)ret >= nodelen) {
return EAI_MEMORY;
}
return 0;
}
static int getservicenameinfo(const struct sockaddr *sa,
char *service,
size_t servicelen,
int flags)
{
int ret = -1;
int port = ntohs(((struct sockaddr_in *)sa)->sin_port);
if (!(flags & NI_NUMERICSERV)) {
struct servent *se = getservbyport(
port,
(flags & NI_DGRAM) ? "udp" : "tcp");
if (se && se->s_name) {
/* Service name looked up successfully. */
ret = snprintf(service, servicelen, "%s", se->s_name);
if (ret < 0 || (size_t)ret >= servicelen) {
return EAI_MEMORY;
}
return 0;
}
/* Otherwise just fall into the numeric service code... */
}
ret = snprintf(service, servicelen, "%d", port);
if (ret < 0 || (size_t)ret >= servicelen) {
return EAI_MEMORY;
}
return 0;
}
/*
* Convert an ipv4 address to a hostname.
*
* Bugs: - No IPv6 support.
*/
int rep_getnameinfo(const struct sockaddr *sa, socklen_t salen,
char *node, size_t nodelen,
char *service, size_t servicelen, int flags)
{
/* Invalid arguments. */
if (sa == NULL || (node == NULL && service == NULL)) {
return EAI_FAIL;
}
if (sa->sa_family != AF_INET) {
return EAI_FAIL;
}
if (salen < sizeof(struct sockaddr_in)) {
return EAI_FAIL;
}
if (node) {
return gethostnameinfo(sa, node, nodelen, flags);
}
if (service) {
return getservicenameinfo(sa, service, servicelen, flags);
}
return 0;
}
tevent-0.9.19/lib/replace/getaddrinfo.h 0000660 0000000 0000000 00000006141 11741275274 017707 0 ustar root root 0000000 0000000 /*
PostgreSQL Database Management System
(formerly known as Postgres, then as Postgres95)
Portions Copyright (c) 1996-2005, The PostgreSQL Global Development Group
Portions Copyright (c) 1994, The Regents of the University of California
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose, without fee, and without a written agreement
is hereby granted, provided that the above copyright notice and this paragraph
and the following two paragraphs appear in all copies.
IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS
TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
/*-------------------------------------------------------------------------
*
* getaddrinfo.h
* Support getaddrinfo() on platforms that don't have it.
*
* Note: we use our own routines on platforms that don't HAVE_STRUCT_ADDRINFO,
* whether or not the library routine getaddrinfo() can be found. This
* policy is needed because on some platforms a manually installed libbind.a
* may provide getaddrinfo(), yet the system headers may not provide the
* struct definitions needed to call it. To avoid conflict with the libbind
* definition in such cases, we rename our routines to pg_xxx() via macros.
*
in lib/replace we use rep_xxx()
* This code will also work on platforms where struct addrinfo is defined
* in the system headers but no getaddrinfo() can be located.
*
* Copyright (c) 2003-2007, PostgreSQL Global Development Group
*
*-------------------------------------------------------------------------
*/
#ifndef GETADDRINFO_H
#define GETADDRINFO_H
#ifndef HAVE_GETADDRINFO
/* Rename private copies per comments above */
#ifdef getaddrinfo
#undef getaddrinfo
#endif
#define getaddrinfo rep_getaddrinfo
#define HAVE_GETADDRINFO
#ifdef freeaddrinfo
#undef freeaddrinfo
#endif
#define freeaddrinfo rep_freeaddrinfo
#define HAVE_FREEADDRINFO
#ifdef gai_strerror
#undef gai_strerror
#endif
#define gai_strerror rep_gai_strerror
#define HAVE_GAI_STRERROR
#ifdef getnameinfo
#undef getnameinfo
#endif
#define getnameinfo rep_getnameinfo
#ifndef HAVE_GETNAMEINFO
#define HAVE_GETNAMEINFO
#endif
extern int rep_getaddrinfo(const char *node, const char *service,
const struct addrinfo * hints, struct addrinfo ** res);
extern void rep_freeaddrinfo(struct addrinfo * res);
extern const char *rep_gai_strerror(int errcode);
extern int rep_getnameinfo(const struct sockaddr * sa, socklen_t salen,
char *node, size_t nodelen,
char *service, size_t servicelen, int flags);
#endif /* HAVE_GETADDRINFO */
#endif /* GETADDRINFO_H */
tevent-0.9.19/lib/replace/getifaddrs.c 0000660 0000000 0000000 00000020542 12176475205 017530 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Samba utility functions
Copyright (C) Andrew Tridgell 1998
Copyright (C) Jeremy Allison 2007
Copyright (C) Jelmer Vernooij 2007
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see .
*/
#define SOCKET_WRAPPER_NOT_REPLACE
#include "replace.h"
#include "system/network.h"
#include
#include
#include
#ifdef HAVE_SYS_TIME_H
#include
#endif
#ifndef SIOCGIFCONF
#ifdef HAVE_SYS_SOCKIO_H
#include
#endif
#endif
#ifdef HAVE_IFACE_GETIFADDRS
#define _FOUND_IFACE_ANY
#else
void rep_freeifaddrs(struct ifaddrs *ifp)
{
if (ifp != NULL) {
free(ifp->ifa_name);
free(ifp->ifa_addr);
free(ifp->ifa_netmask);
free(ifp->ifa_dstaddr);
freeifaddrs(ifp->ifa_next);
free(ifp);
}
}
static struct sockaddr *sockaddr_dup(struct sockaddr *sa)
{
struct sockaddr *ret;
socklen_t socklen;
#ifdef HAVE_SOCKADDR_SA_LEN
socklen = sa->sa_len;
#else
socklen = sizeof(struct sockaddr_storage);
#endif
ret = calloc(1, socklen);
if (ret == NULL)
return NULL;
memcpy(ret, sa, socklen);
return ret;
}
#endif
#if HAVE_IFACE_IFCONF
/* this works for Linux 2.2, Solaris 2.5, SunOS4, HPUX 10.20, OSF1
V4.0, Ultrix 4.4, SCO Unix 3.2, IRIX 6.4 and FreeBSD 3.2.
It probably also works on any BSD style system. */
int rep_getifaddrs(struct ifaddrs **ifap)
{
struct ifconf ifc;
char buff[8192];
int fd, i, n;
struct ifreq *ifr=NULL;
struct ifaddrs *curif;
struct ifaddrs *lastif = NULL;
*ifap = NULL;
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
return -1;
}
ifc.ifc_len = sizeof(buff);
ifc.ifc_buf = buff;
if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
close(fd);
return -1;
}
ifr = ifc.ifc_req;
n = ifc.ifc_len / sizeof(struct ifreq);
/* Loop through interfaces, looking for given IP address */
for (i=n-1; i>=0; i--) {
if (ioctl(fd, SIOCGIFFLAGS, &ifr[i]) == -1) {
freeifaddrs(*ifap);
close(fd);
return -1;
}
curif = calloc(1, sizeof(struct ifaddrs));
if (curif == NULL) {
freeifaddrs(*ifap);
close(fd);
return -1;
}
curif->ifa_name = strdup(ifr[i].ifr_name);
if (curif->ifa_name == NULL) {
free(curif);
freeifaddrs(*ifap);
close(fd);
return -1;
}
curif->ifa_flags = ifr[i].ifr_flags;
curif->ifa_dstaddr = NULL;
curif->ifa_data = NULL;
curif->ifa_next = NULL;
curif->ifa_addr = NULL;
if (ioctl(fd, SIOCGIFADDR, &ifr[i]) != -1) {
curif->ifa_addr = sockaddr_dup(&ifr[i].ifr_addr);
if (curif->ifa_addr == NULL) {
free(curif->ifa_name);
free(curif);
freeifaddrs(*ifap);
close(fd);
return -1;
}
}
curif->ifa_netmask = NULL;
if (ioctl(fd, SIOCGIFNETMASK, &ifr[i]) != -1) {
curif->ifa_netmask = sockaddr_dup(&ifr[i].ifr_addr);
if (curif->ifa_netmask == NULL) {
if (curif->ifa_addr != NULL) {
free(curif->ifa_addr);
}
free(curif->ifa_name);
free(curif);
freeifaddrs(*ifap);
close(fd);
return -1;
}
}
if (lastif == NULL) {
*ifap = curif;
} else {
lastif->ifa_next = curif;
}
lastif = curif;
}
close(fd);
return 0;
}
#define _FOUND_IFACE_ANY
#endif /* HAVE_IFACE_IFCONF */
#ifdef HAVE_IFACE_IFREQ
#ifndef I_STR
#include
#endif
/****************************************************************************
this should cover most of the streams based systems
Thanks to Andrej.Borsenkow@mow.siemens.ru for several ideas in this code
****************************************************************************/
int rep_getifaddrs(struct ifaddrs **ifap)
{
struct ifreq ifreq;
struct strioctl strioctl;
char buff[8192];
int fd, i, n;
struct ifreq *ifr=NULL;
struct ifaddrs *curif;
struct ifaddrs *lastif = NULL;
*ifap = NULL;
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
return -1;
}
strioctl.ic_cmd = SIOCGIFCONF;
strioctl.ic_dp = buff;
strioctl.ic_len = sizeof(buff);
if (ioctl(fd, I_STR, &strioctl) < 0) {
close(fd);
return -1;
}
/* we can ignore the possible sizeof(int) here as the resulting
number of interface structures won't change */
n = strioctl.ic_len / sizeof(struct ifreq);
/* we will assume that the kernel returns the length as an int
at the start of the buffer if the offered size is a
multiple of the structure size plus an int */
if (n*sizeof(struct ifreq) + sizeof(int) == strioctl.ic_len) {
ifr = (struct ifreq *)(buff + sizeof(int));
} else {
ifr = (struct ifreq *)buff;
}
/* Loop through interfaces */
for (i = 0; iifa_next = curif;
}
strioctl.ic_cmd = SIOCGIFFLAGS;
strioctl.ic_dp = (char *)&ifreq;
strioctl.ic_len = sizeof(struct ifreq);
if (ioctl(fd, I_STR, &strioctl) != 0) {
freeifaddrs(*ifap);
return -1;
}
curif->ifa_flags = ifreq.ifr_flags;
strioctl.ic_cmd = SIOCGIFADDR;
strioctl.ic_dp = (char *)&ifreq;
strioctl.ic_len = sizeof(struct ifreq);
if (ioctl(fd, I_STR, &strioctl) != 0) {
freeifaddrs(*ifap);
return -1;
}
curif->ifa_name = strdup(ifreq.ifr_name);
curif->ifa_addr = sockaddr_dup(&ifreq.ifr_addr);
curif->ifa_dstaddr = NULL;
curif->ifa_data = NULL;
curif->ifa_next = NULL;
curif->ifa_netmask = NULL;
strioctl.ic_cmd = SIOCGIFNETMASK;
strioctl.ic_dp = (char *)&ifreq;
strioctl.ic_len = sizeof(struct ifreq);
if (ioctl(fd, I_STR, &strioctl) != 0) {
freeifaddrs(*ifap);
return -1;
}
curif->ifa_netmask = sockaddr_dup(&ifreq.ifr_addr);
lastif = curif;
}
close(fd);
return 0;
}
#define _FOUND_IFACE_ANY
#endif /* HAVE_IFACE_IFREQ */
#ifdef HAVE_IFACE_AIX
/****************************************************************************
this one is for AIX (tested on 4.2)
****************************************************************************/
int rep_getifaddrs(struct ifaddrs **ifap)
{
char buff[8192];
int fd, i;
struct ifconf ifc;
struct ifreq *ifr=NULL;
struct ifaddrs *curif;
struct ifaddrs *lastif = NULL;
*ifap = NULL;
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
return -1;
}
ifc.ifc_len = sizeof(buff);
ifc.ifc_buf = buff;
if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
close(fd);
return -1;
}
ifr = ifc.ifc_req;
/* Loop through interfaces */
i = ifc.ifc_len;
while (i > 0) {
unsigned int inc;
inc = ifr->ifr_addr.sa_len;
if (ioctl(fd, SIOCGIFADDR, ifr) != 0) {
freeaddrinfo(*ifap);
return -1;
}
curif = calloc(1, sizeof(struct ifaddrs));
if (lastif == NULL) {
*ifap = curif;
} else {
lastif->ifa_next = curif;
}
curif->ifa_name = strdup(ifr->ifr_name);
curif->ifa_addr = sockaddr_dup(&ifr->ifr_addr);
curif->ifa_dstaddr = NULL;
curif->ifa_data = NULL;
curif->ifa_netmask = NULL;
curif->ifa_next = NULL;
if (ioctl(fd, SIOCGIFFLAGS, ifr) != 0) {
freeaddrinfo(*ifap);
return -1;
}
curif->ifa_flags = ifr->ifr_flags;
if (ioctl(fd, SIOCGIFNETMASK, ifr) != 0) {
freeaddrinfo(*ifap);
return -1;
}
curif->ifa_netmask = sockaddr_dup(&ifr->ifr_addr);
lastif = curif;
next:
/*
* Patch from Archie Cobbs (archie@whistle.com). The
* addresses in the SIOCGIFCONF interface list have a
* minimum size. Usually this doesn't matter, but if
* your machine has tunnel interfaces, etc. that have
* a zero length "link address", this does matter. */
if (inc < sizeof(ifr->ifr_addr))
inc = sizeof(ifr->ifr_addr);
inc += IFNAMSIZ;
ifr = (struct ifreq*) (((char*) ifr) + inc);
i -= inc;
}
close(fd);
return 0;
}
#define _FOUND_IFACE_ANY
#endif /* HAVE_IFACE_AIX */
#ifndef _FOUND_IFACE_ANY
int rep_getifaddrs(struct ifaddrs **ifap)
{
errno = ENOSYS;
return -1;
}
#endif
tevent-0.9.19/lib/replace/hdr_replace.h 0000660 0000000 0000000 00000000124 11741275274 017664 0 ustar root root 0000000 0000000 /* this is a replacement header for a missing system header */
#include "replace.h"
tevent-0.9.19/lib/replace/inet_aton.c 0000660 0000000 0000000 00000002232 11741275274 017371 0 ustar root root 0000000 0000000 /*
* Unix SMB/CIFS implementation.
* replacement functions
* Copyright (C) Michael Adam 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library 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 3 of the License, or (at your option) any later version.
*
* This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/network.h"
/**
* We know that we have inet_pton from earlier libreplace checks.
*/
int rep_inet_aton(const char *src, struct in_addr *dst)
{
return (inet_pton(AF_INET, src, dst) > 0) ? 1 : 0;
}
tevent-0.9.19/lib/replace/inet_ntoa.c 0000660 0000000 0000000 00000002475 11741275274 017402 0 ustar root root 0000000 0000000 /*
* Unix SMB/CIFS implementation.
* replacement routines for broken systems
* Copyright (C) Andrew Tridgell 2003
* Copyright (C) Michael Adam 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library 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 3 of the License, or (at your option) any later version.
*
* This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/network.h"
/**
* NOTE: this is not thread safe, but it can't be, either
* since it returns a pointer to static memory.
*/
char *rep_inet_ntoa(struct in_addr ip)
{
uint8_t *p = (uint8_t *)&ip.s_addr;
static char buf[18];
slprintf(buf, 17, "%d.%d.%d.%d",
(int)p[0], (int)p[1], (int)p[2], (int)p[3]);
return buf;
}
tevent-0.9.19/lib/replace/inet_ntop.c 0000660 0000000 0000000 00000011632 11741275274 017414 0 ustar root root 0000000 0000000 /*
* Copyright (C) 1996-2001 Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
* DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
* INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "replace.h"
#include "system/network.h"
#define NS_INT16SZ 2
#define NS_IN6ADDRSZ 16
/*
* WARNING: Don't even consider trying to compile this on a system where
* sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX.
*/
static const char *inet_ntop4(const unsigned char *src, char *dst,
socklen_t size);
#ifdef AF_INET6
static const char *inet_ntop6(const unsigned char *src, char *dst,
socklen_t size);
#endif
/* char *
* isc_net_ntop(af, src, dst, size)
* convert a network format address to presentation format.
* return:
* pointer to presentation format address (`dst'), or NULL (see errno).
* author:
* Paul Vixie, 1996.
*/
const char *
rep_inet_ntop(int af, const void *src, char *dst, socklen_t size)
{
switch (af) {
case AF_INET:
return (inet_ntop4(src, dst, size));
#ifdef AF_INET6
case AF_INET6:
return (inet_ntop6(src, dst, size));
#endif
default:
errno = EAFNOSUPPORT;
return (NULL);
}
/* NOTREACHED */
}
/* const char *
* inet_ntop4(src, dst, size)
* format an IPv4 address
* return:
* `dst' (as a const)
* notes:
* (1) uses no statics
* (2) takes a unsigned char* not an in_addr as input
* author:
* Paul Vixie, 1996.
*/
static const char *
inet_ntop4(const unsigned char *src, char *dst, socklen_t size)
{
static const char *fmt = "%u.%u.%u.%u";
char tmp[sizeof "255.255.255.255"];
size_t len;
len = snprintf(tmp, sizeof tmp, fmt, src[0], src[1], src[2], src[3]);
if (len >= size) {
errno = ENOSPC;
return (NULL);
}
memcpy(dst, tmp, len + 1);
return (dst);
}
/* const char *
* isc_inet_ntop6(src, dst, size)
* convert IPv6 binary address into presentation (printable) format
* author:
* Paul Vixie, 1996.
*/
#ifdef AF_INET6
static const char *
inet_ntop6(const unsigned char *src, char *dst, socklen_t size)
{
/*
* Note that int32_t and int16_t need only be "at least" large enough
* to contain a value of the specified size. On some systems, like
* Crays, there is no such thing as an integer variable with 16 bits.
* Keep this in mind if you think this function should have been coded
* to use pointer overlays. All the world's not a VAX.
*/
char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp;
struct { int base, len; } best, cur;
unsigned int words[NS_IN6ADDRSZ / NS_INT16SZ];
int i, inc;
/*
* Preprocess:
* Copy the input (bytewise) array into a wordwise array.
* Find the longest run of 0x00's in src[] for :: shorthanding.
*/
memset(words, '\0', sizeof words);
for (i = 0; i < NS_IN6ADDRSZ; i++)
words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
best.base = -1;
best.len = 0;
cur.base = -1;
cur.len = 0;
for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
if (words[i] == 0) {
if (cur.base == -1)
cur.base = i, cur.len = 1;
else
cur.len++;
} else {
if (cur.base != -1) {
if (best.base == -1 || cur.len > best.len)
best = cur;
cur.base = -1;
}
}
}
if (cur.base != -1) {
if (best.base == -1 || cur.len > best.len)
best = cur;
}
if (best.base != -1 && best.len < 2)
best.base = -1;
/*
* Format the result.
*/
tp = tmp;
for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
/* Are we inside the best run of 0x00's? */
if (best.base != -1 && i >= best.base &&
i < (best.base + best.len)) {
if (i == best.base)
*tp++ = ':';
continue;
}
/* Are we following an initial run of 0x00s or any real hex? */
if (i != 0)
*tp++ = ':';
/* Is this address an encapsulated IPv4? */
if (i == 6 && best.base == 0 &&
(best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp)))
return (NULL);
tp += strlen(tp);
break;
}
inc = snprintf(tp, 5, "%x", words[i]);
if (inc >= 5) {
abort();
}
tp += inc;
}
/* Was it a trailing run of 0x00's? */
if (best.base != -1 && (best.base + best.len) ==
(NS_IN6ADDRSZ / NS_INT16SZ))
*tp++ = ':';
*tp++ = '\0';
/*
* Check for overflow, copy, and we're done.
*/
if ((size_t)(tp - tmp) > size) {
errno = ENOSPC;
return (NULL);
}
memcpy(dst, tmp, tp - tmp);
return (dst);
}
#endif /* AF_INET6 */
tevent-0.9.19/lib/replace/inet_pton.c 0000660 0000000 0000000 00000012010 11741275274 017403 0 ustar root root 0000000 0000000 /*
* Copyright (C) 1996-2001 Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
* DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
* INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "replace.h"
#include "system/network.h"
#define NS_INT16SZ 2
#define NS_INADDRSZ 4
#define NS_IN6ADDRSZ 16
/*
* WARNING: Don't even consider trying to compile this on a system where
* sizeof(int) < 4. sizeof(int) > 4 is fine; all the world's not a VAX.
*/
static int inet_pton4(const char *src, unsigned char *dst);
#ifdef AF_INET6
static int inet_pton6(const char *src, unsigned char *dst);
#endif
/* int
* inet_pton(af, src, dst)
* convert from presentation format (which usually means ASCII printable)
* to network format (which is usually some kind of binary format).
* return:
* 1 if the address was valid for the specified address family
* 0 if the address wasn't valid (`dst' is untouched in this case)
* -1 if some other error occurred (`dst' is untouched in this case, too)
* author:
* Paul Vixie, 1996.
*/
int
rep_inet_pton(int af,
const char *src,
void *dst)
{
switch (af) {
case AF_INET:
return (inet_pton4(src, dst));
#ifdef AF_INET6
case AF_INET6:
return (inet_pton6(src, dst));
#endif
default:
errno = EAFNOSUPPORT;
return (-1);
}
/* NOTREACHED */
}
/* int
* inet_pton4(src, dst)
* like inet_aton() but without all the hexadecimal and shorthand.
* return:
* 1 if `src' is a valid dotted quad, else 0.
* notice:
* does not touch `dst' unless it's returning 1.
* author:
* Paul Vixie, 1996.
*/
static int
inet_pton4(src, dst)
const char *src;
unsigned char *dst;
{
static const char digits[] = "0123456789";
int saw_digit, octets, ch;
unsigned char tmp[NS_INADDRSZ], *tp;
saw_digit = 0;
octets = 0;
*(tp = tmp) = 0;
while ((ch = *src++) != '\0') {
const char *pch;
if ((pch = strchr(digits, ch)) != NULL) {
unsigned int new = *tp * 10 + (pch - digits);
if (new > 255)
return (0);
*tp = new;
if (! saw_digit) {
if (++octets > 4)
return (0);
saw_digit = 1;
}
} else if (ch == '.' && saw_digit) {
if (octets == 4)
return (0);
*++tp = 0;
saw_digit = 0;
} else
return (0);
}
if (octets < 4)
return (0);
memcpy(dst, tmp, NS_INADDRSZ);
return (1);
}
/* int
* inet_pton6(src, dst)
* convert presentation level address to network order binary form.
* return:
* 1 if `src' is a valid [RFC1884 2.2] address, else 0.
* notice:
* (1) does not touch `dst' unless it's returning 1.
* (2) :: in a full address is silently ignored.
* credit:
* inspired by Mark Andrews.
* author:
* Paul Vixie, 1996.
*/
#ifdef AF_INET6
static int
inet_pton6(src, dst)
const char *src;
unsigned char *dst;
{
static const char xdigits_l[] = "0123456789abcdef",
xdigits_u[] = "0123456789ABCDEF";
unsigned char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
const char *xdigits, *curtok;
int ch, saw_xdigit;
unsigned int val;
memset((tp = tmp), '\0', NS_IN6ADDRSZ);
endp = tp + NS_IN6ADDRSZ;
colonp = NULL;
/* Leading :: requires some special handling. */
if (*src == ':')
if (*++src != ':')
return (0);
curtok = src;
saw_xdigit = 0;
val = 0;
while ((ch = *src++) != '\0') {
const char *pch;
if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
pch = strchr((xdigits = xdigits_u), ch);
if (pch != NULL) {
val <<= 4;
val |= (pch - xdigits);
if (val > 0xffff)
return (0);
saw_xdigit = 1;
continue;
}
if (ch == ':') {
curtok = src;
if (!saw_xdigit) {
if (colonp)
return (0);
colonp = tp;
continue;
}
if (tp + NS_INT16SZ > endp)
return (0);
*tp++ = (unsigned char) (val >> 8) & 0xff;
*tp++ = (unsigned char) val & 0xff;
saw_xdigit = 0;
val = 0;
continue;
}
if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
inet_pton4(curtok, tp) > 0) {
tp += NS_INADDRSZ;
saw_xdigit = 0;
break; /* '\0' was seen by inet_pton4(). */
}
return (0);
}
if (saw_xdigit) {
if (tp + NS_INT16SZ > endp)
return (0);
*tp++ = (unsigned char) (val >> 8) & 0xff;
*tp++ = (unsigned char) val & 0xff;
}
if (colonp != NULL) {
/*
* Since some memmove()'s erroneously fail to handle
* overlapping regions, we'll do the shift by hand.
*/
const int n = tp - colonp;
int i;
for (i = 1; i <= n; i++) {
endp[- i] = colonp[n - i];
colonp[n - i] = 0;
}
tp = endp;
}
if (tp != endp)
return (0);
memcpy(dst, tmp, NS_IN6ADDRSZ);
return (1);
}
#endif
tevent-0.9.19/lib/replace/poll.c 0000660 0000000 0000000 00000006405 12101212317 016341 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
poll.c - poll wrapper
This file is based on code from libssh (LGPLv2.1+ at the time it
was downloaded), thus the following copyrights:
Copyright (c) 2009-2010 by Andreas Schneider
Copyright (c) 2003-2009 by Aris Adamantiadis
Copyright (c) 2009 Aleksandar Kanchev
Copyright (C) Volker Lendecke 2011
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/select.h"
#ifdef HAVE_SYS_TIME_H
#include
#endif
#ifdef HAVE_SYS_IOCTL_H
#include
#endif
int rep_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
fd_set rfds, wfds, efds;
struct timeval tv, *ptv;
int max_fd;
int rc;
nfds_t i;
if ((fds == NULL) && (nfds != 0)) {
errno = EFAULT;
return -1;
}
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
rc = 0;
max_fd = 0;
/* compute fd_sets and find largest descriptor */
for (i = 0; i < nfds; i++) {
if ((fds[i].fd < 0) || (fds[i].fd >= FD_SETSIZE)) {
fds[i].revents = POLLNVAL;
continue;
}
if (fds[i].events & (POLLIN | POLLRDNORM)) {
FD_SET(fds[i].fd, &rfds);
}
if (fds[i].events & (POLLOUT | POLLWRNORM | POLLWRBAND)) {
FD_SET(fds[i].fd, &wfds);
}
if (fds[i].events & (POLLPRI | POLLRDBAND)) {
FD_SET(fds[i].fd, &efds);
}
if (fds[i].fd > max_fd &&
(fds[i].events & (POLLIN | POLLOUT | POLLPRI |
POLLRDNORM | POLLRDBAND |
POLLWRNORM | POLLWRBAND))) {
max_fd = fds[i].fd;
}
}
if (timeout < 0) {
ptv = NULL;
} else {
ptv = &tv;
if (timeout == 0) {
tv.tv_sec = 0;
tv.tv_usec = 0;
} else {
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
}
}
rc = select(max_fd + 1, &rfds, &wfds, &efds, ptv);
if (rc < 0) {
return -1;
}
for (rc = 0, i = 0; i < nfds; i++) {
if ((fds[i].fd < 0) || (fds[i].fd >= FD_SETSIZE)) {
continue;
}
fds[i].revents = 0;
if (FD_ISSET(fds[i].fd, &rfds)) {
int err = errno;
int available = 0;
int ret;
/* support for POLLHUP */
ret = ioctl(fds[i].fd, FIONREAD, &available);
if ((ret == -1) || (available == 0)) {
fds[i].revents |= POLLHUP;
} else {
fds[i].revents |= fds[i].events
& (POLLIN | POLLRDNORM);
}
errno = err;
}
if (FD_ISSET(fds[i].fd, &wfds)) {
fds[i].revents |= fds[i].events
& (POLLOUT | POLLWRNORM | POLLWRBAND);
}
if (FD_ISSET(fds[i].fd, &efds)) {
fds[i].revents |= fds[i].events
& (POLLPRI | POLLRDBAND);
}
if (fds[i].revents & ~POLLHUP) {
rc++;
}
}
return rc;
}
tevent-0.9.19/lib/replace/repdir_getdents.c 0000660 0000000 0000000 00000010213 11741275274 020571 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Copyright (C) Andrew Tridgell 2005
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
/*
a replacement for opendir/readdir/telldir/seekdir/closedir for BSD systems
This is needed because the existing directory handling in FreeBSD
and OpenBSD (and possibly NetBSD) doesn't correctly handle unlink()
on files in a directory where telldir() has been used. On a block
boundary it will occasionally miss a file when seekdir() is used to
return to a position previously recorded with telldir().
This also fixes a severe performance and memory usage problem with
telldir() on BSD systems. Each call to telldir() in BSD adds an
entry to a linked list, and those entries are cleaned up on
closedir(). This means with a large directory closedir() can take an
arbitrary amount of time, causing network timeouts as millions of
telldir() entries are freed
Note! This replacement code is not portable. It relies on getdents()
always leaving the file descriptor at a seek offset that is a
multiple of DIR_BUF_SIZE. If the code detects that this doesn't
happen then it will abort(). It also does not handle directories
with offsets larger than can be stored in a long,
This code is available under other free software licenses as
well. Contact the author.
*/
#include
#include
#include
#include
#include
#include
#include
#define DIR_BUF_BITS 9
#define DIR_BUF_SIZE (1<fd = open(dname, O_RDONLY);
if (d->fd == -1) {
free(d);
return NULL;
}
if (fstat(d->fd, &sb) < 0) {
close(d->fd);
free(d);
return NULL;
}
if (!S_ISDIR(sb.st_mode)) {
close(d->fd);
free(d);
errno = ENOTDIR;
return NULL;
}
d->ofs = 0;
d->seekpos = 0;
d->nbytes = 0;
return (DIR *)d;
}
struct dirent *readdir(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
struct dirent *de;
if (d->ofs >= d->nbytes) {
d->seekpos = lseek(d->fd, 0, SEEK_CUR);
d->nbytes = getdents(d->fd, d->buf, DIR_BUF_SIZE);
d->ofs = 0;
}
if (d->ofs >= d->nbytes) {
return NULL;
}
de = (struct dirent *)&d->buf[d->ofs];
d->ofs += de->d_reclen;
return de;
}
long telldir(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
if (d->ofs >= d->nbytes) {
d->seekpos = lseek(d->fd, 0, SEEK_CUR);
d->ofs = 0;
d->nbytes = 0;
}
/* this relies on seekpos always being a multiple of
DIR_BUF_SIZE. Is that always true on BSD systems? */
if (d->seekpos & (DIR_BUF_SIZE-1)) {
abort();
}
return d->seekpos + d->ofs;
}
void seekdir(DIR *dir, long ofs)
{
struct dir_buf *d = (struct dir_buf *)dir;
d->seekpos = lseek(d->fd, ofs & ~(DIR_BUF_SIZE-1), SEEK_SET);
d->nbytes = getdents(d->fd, d->buf, DIR_BUF_SIZE);
d->ofs = 0;
while (d->ofs < (ofs & (DIR_BUF_SIZE-1))) {
if (readdir(dir) == NULL) break;
}
}
void rewinddir(DIR *dir)
{
seekdir(dir, 0);
}
int closedir(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
int r = close(d->fd);
if (r != 0) {
return r;
}
free(d);
return 0;
}
#ifndef dirfd
/* darn, this is a macro on some systems. */
int dirfd(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
return d->fd;
}
#endif
tevent-0.9.19/lib/replace/repdir_getdirentries.c 0000660 0000000 0000000 00000010623 11741275274 021631 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
Copyright (C) Andrew Tridgell 2005
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
/*
a replacement for opendir/readdir/telldir/seekdir/closedir for BSD
systems using getdirentries
This is needed because the existing directory handling in FreeBSD
and OpenBSD (and possibly NetBSD) doesn't correctly handle unlink()
on files in a directory where telldir() has been used. On a block
boundary it will occasionally miss a file when seekdir() is used to
return to a position previously recorded with telldir().
This also fixes a severe performance and memory usage problem with
telldir() on BSD systems. Each call to telldir() in BSD adds an
entry to a linked list, and those entries are cleaned up on
closedir(). This means with a large directory closedir() can take an
arbitrary amount of time, causing network timeouts as millions of
telldir() entries are freed
Note! This replacement code is not portable. It relies on
getdirentries() always leaving the file descriptor at a seek offset
that is a multiple of DIR_BUF_SIZE. If the code detects that this
doesn't happen then it will abort(). It also does not handle
directories with offsets larger than can be stored in a long,
This code is available under other free software licenses as
well. Contact the author.
*/
#include "replace.h"
#include
#include
#include
#include
#include
#include
#include
#define DIR_BUF_BITS 9
#define DIR_BUF_SIZE (1<fd = open(dname, O_RDONLY);
if (d->fd == -1) {
free(d);
return NULL;
}
if (fstat(d->fd, &sb) < 0) {
close(d->fd);
free(d);
return NULL;
}
if (!S_ISDIR(sb.st_mode)) {
close(d->fd);
free(d);
errno = ENOTDIR;
return NULL;
}
d->ofs = 0;
d->seekpos = 0;
d->nbytes = 0;
return (DIR *)d;
}
struct dirent *readdir(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
struct dirent *de;
if (d->ofs >= d->nbytes) {
long pos;
d->nbytes = getdirentries(d->fd, d->buf, DIR_BUF_SIZE, &pos);
d->seekpos = pos;
d->ofs = 0;
}
if (d->ofs >= d->nbytes) {
return NULL;
}
de = (struct dirent *)&d->buf[d->ofs];
d->ofs += de->d_reclen;
return de;
}
#ifdef TELLDIR_TAKES_CONST_DIR
long telldir(const DIR *dir)
#else
long telldir(DIR *dir)
#endif
{
struct dir_buf *d = (struct dir_buf *)dir;
if (d->ofs >= d->nbytes) {
d->seekpos = lseek(d->fd, 0, SEEK_CUR);
d->ofs = 0;
d->nbytes = 0;
}
/* this relies on seekpos always being a multiple of
DIR_BUF_SIZE. Is that always true on BSD systems? */
if (d->seekpos & (DIR_BUF_SIZE-1)) {
abort();
}
return d->seekpos + d->ofs;
}
#ifdef SEEKDIR_RETURNS_INT
int seekdir(DIR *dir, long ofs)
#else
void seekdir(DIR *dir, long ofs)
#endif
{
struct dir_buf *d = (struct dir_buf *)dir;
long pos;
d->seekpos = lseek(d->fd, ofs & ~(DIR_BUF_SIZE-1), SEEK_SET);
d->nbytes = getdirentries(d->fd, d->buf, DIR_BUF_SIZE, &pos);
d->ofs = 0;
while (d->ofs < (ofs & (DIR_BUF_SIZE-1))) {
if (readdir(dir) == NULL) break;
}
#ifdef SEEKDIR_RETURNS_INT
return -1;
#endif
}
void rewinddir(DIR *dir)
{
seekdir(dir, 0);
}
int closedir(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
int r = close(d->fd);
if (r != 0) {
return r;
}
free(d);
return 0;
}
#ifndef dirfd
/* darn, this is a macro on some systems. */
int dirfd(DIR *dir)
{
struct dir_buf *d = (struct dir_buf *)dir;
return d->fd;
}
#endif
tevent-0.9.19/lib/replace/replace-test.h 0000660 0000000 0000000 00000000337 12153373752 020010 0 ustar root root 0000000 0000000 #ifndef __LIB_REPLACE_REPLACE_TEST_H__
#define __LIB_REPLACE_REPLACE_TEST_H__
int libreplace_test_strptime(void);
int test_readdir_os2_delete(void);
int getifaddrs_test(void);
#endif /* __LIB_REPLACE_REPLACE_TEST_H__ */
tevent-0.9.19/lib/replace/replace-testsuite.h 0000660 0000000 0000000 00000000363 12153373752 021061 0 ustar root root 0000000 0000000 #ifndef __LIB_REPLACE_REPLACE_TESTSUITE_H__
#define __LIB_REPLACE_REPLACE_TESTSUITE_H__
#include
struct torture_context;
bool torture_local_replace(struct torture_context *ctx);
#endif /* __LIB_REPLACE_REPLACE_TESTSUITE_H__ */
tevent-0.9.19/lib/replace/replace.c 0000660 0000000 0000000 00000044731 12101212317 017012 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
replacement routines for broken systems
Copyright (C) Andrew Tridgell 1992-1998
Copyright (C) Jelmer Vernooij 2005-2008
Copyright (C) Matthieu Patou 2010
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/filesys.h"
#include "system/time.h"
#include "system/network.h"
#include "system/passwd.h"
#include "system/syslog.h"
#include "system/locale.h"
#include "system/wait.h"
#ifdef _WIN32
#define mkdir(d,m) _mkdir(d)
#endif
void replace_dummy(void);
void replace_dummy(void) {}
#ifndef HAVE_FTRUNCATE
/*******************************************************************
ftruncate for operating systems that don't have it
********************************************************************/
int rep_ftruncate(int f, off_t l)
{
#ifdef HAVE_CHSIZE
return chsize(f,l);
#elif defined(F_FREESP)
struct flock fl;
fl.l_whence = 0;
fl.l_len = 0;
fl.l_start = l;
fl.l_type = F_WRLCK;
return fcntl(f, F_FREESP, &fl);
#else
#error "you must have a ftruncate function"
#endif
}
#endif /* HAVE_FTRUNCATE */
#ifndef HAVE_STRLCPY
/* like strncpy but does not 0 fill the buffer and always null
terminates. bufsize is the size of the destination buffer */
size_t rep_strlcpy(char *d, const char *s, size_t bufsize)
{
size_t len = strlen(s);
size_t ret = len;
if (bufsize <= 0) return 0;
if (len >= bufsize) len = bufsize-1;
memcpy(d, s, len);
d[len] = 0;
return ret;
}
#endif
#ifndef HAVE_STRLCAT
/* like strncat but does not 0 fill the buffer and always null
terminates. bufsize is the length of the buffer, which should
be one more than the maximum resulting string length */
size_t rep_strlcat(char *d, const char *s, size_t bufsize)
{
size_t len1 = strlen(d);
size_t len2 = strlen(s);
size_t ret = len1 + len2;
if (len1+len2 >= bufsize) {
if (bufsize < (len1+1)) {
return ret;
}
len2 = bufsize - (len1+1);
}
if (len2 > 0) {
memcpy(d+len1, s, len2);
d[len1+len2] = 0;
}
return ret;
}
#endif
#ifndef HAVE_MKTIME
/*******************************************************************
a mktime() replacement for those who don't have it - contributed by
C.A. Lademann
Corrections by richard.kettlewell@kewill.com
********************************************************************/
#define MINUTE 60
#define HOUR 60*MINUTE
#define DAY 24*HOUR
#define YEAR 365*DAY
time_t rep_mktime(struct tm *t)
{
struct tm *u;
time_t epoch = 0;
int n;
int mon [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
y, m, i;
if(t->tm_year < 70)
return((time_t)-1);
n = t->tm_year + 1900 - 1;
epoch = (t->tm_year - 70) * YEAR +
((n / 4 - n / 100 + n / 400) - (1969 / 4 - 1969 / 100 + 1969 / 400)) * DAY;
y = t->tm_year + 1900;
m = 0;
for(i = 0; i < t->tm_mon; i++) {
epoch += mon [m] * DAY;
if(m == 1 && y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
epoch += DAY;
if(++m > 11) {
m = 0;
y++;
}
}
epoch += (t->tm_mday - 1) * DAY;
epoch += t->tm_hour * HOUR + t->tm_min * MINUTE + t->tm_sec;
if((u = localtime(&epoch)) != NULL) {
t->tm_sec = u->tm_sec;
t->tm_min = u->tm_min;
t->tm_hour = u->tm_hour;
t->tm_mday = u->tm_mday;
t->tm_mon = u->tm_mon;
t->tm_year = u->tm_year;
t->tm_wday = u->tm_wday;
t->tm_yday = u->tm_yday;
t->tm_isdst = u->tm_isdst;
}
return(epoch);
}
#endif /* !HAVE_MKTIME */
#ifndef HAVE_INITGROUPS
/****************************************************************************
some systems don't have an initgroups call
****************************************************************************/
int rep_initgroups(char *name, gid_t id)
{
#ifndef HAVE_SETGROUPS
/* yikes! no SETGROUPS or INITGROUPS? how can this work? */
errno = ENOSYS;
return -1;
#else /* HAVE_SETGROUPS */
#include
gid_t *grouplst = NULL;
int max_gr = NGROUPS_MAX;
int ret;
int i,j;
struct group *g;
char *gr;
if((grouplst = malloc(sizeof(gid_t) * max_gr)) == NULL) {
errno = ENOMEM;
return -1;
}
grouplst[0] = id;
i = 1;
while (i < max_gr && ((g = (struct group *)getgrent()) != (struct group *)NULL)) {
if (g->gr_gid == id)
continue;
j = 0;
gr = g->gr_mem[0];
while (gr && (*gr != (char)NULL)) {
if (strcmp(name,gr) == 0) {
grouplst[i] = g->gr_gid;
i++;
gr = (char *)NULL;
break;
}
gr = g->gr_mem[++j];
}
}
endgrent();
ret = setgroups(i, grouplst);
free(grouplst);
return ret;
#endif /* HAVE_SETGROUPS */
}
#endif /* HAVE_INITGROUPS */
#ifndef HAVE_MEMMOVE
/*******************************************************************
safely copies memory, ensuring no overlap problems.
this is only used if the machine does not have its own memmove().
this is not the fastest algorithm in town, but it will do for our
needs.
********************************************************************/
void *rep_memmove(void *dest,const void *src,int size)
{
unsigned long d,s;
int i;
if (dest==src || !size) return(dest);
d = (unsigned long)dest;
s = (unsigned long)src;
if ((d >= (s+size)) || (s >= (d+size))) {
/* no overlap */
memcpy(dest,src,size);
return(dest);
}
if (d < s) {
/* we can forward copy */
if (s-d >= sizeof(int) &&
!(s%sizeof(int)) &&
!(d%sizeof(int)) &&
!(size%sizeof(int))) {
/* do it all as words */
int *idest = (int *)dest;
int *isrc = (int *)src;
size /= sizeof(int);
for (i=0;i= sizeof(int) &&
!(s%sizeof(int)) &&
!(d%sizeof(int)) &&
!(size%sizeof(int))) {
/* do it all as words */
int *idest = (int *)dest;
int *isrc = (int *)src;
size /= sizeof(int);
for (i=size-1;i>=0;i--) idest[i] = isrc[i];
} else {
/* simplest */
char *cdest = (char *)dest;
char *csrc = (char *)src;
for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
}
}
return(dest);
}
#endif /* HAVE_MEMMOVE */
#ifndef HAVE_STRDUP
/****************************************************************************
duplicate a string
****************************************************************************/
char *rep_strdup(const char *s)
{
size_t len;
char *ret;
if (!s) return(NULL);
len = strlen(s)+1;
ret = (char *)malloc(len);
if (!ret) return(NULL);
memcpy(ret,s,len);
return(ret);
}
#endif /* HAVE_STRDUP */
#ifndef HAVE_SETLINEBUF
void rep_setlinebuf(FILE *stream)
{
setvbuf(stream, (char *)NULL, _IOLBF, 0);
}
#endif /* HAVE_SETLINEBUF */
#ifndef HAVE_VSYSLOG
#ifdef HAVE_SYSLOG
void rep_vsyslog (int facility_priority, const char *format, va_list arglist)
{
char *msg = NULL;
vasprintf(&msg, format, arglist);
if (!msg)
return;
syslog(facility_priority, "%s", msg);
free(msg);
}
#endif /* HAVE_SYSLOG */
#endif /* HAVE_VSYSLOG */
#ifndef HAVE_STRNLEN
/**
Some platforms don't have strnlen
**/
size_t rep_strnlen(const char *s, size_t max)
{
size_t len;
for (len = 0; len < max; len++) {
if (s[len] == '\0') {
break;
}
}
return len;
}
#endif
#ifndef HAVE_STRNDUP
/**
Some platforms don't have strndup.
**/
char *rep_strndup(const char *s, size_t n)
{
char *ret;
n = strnlen(s, n);
ret = malloc(n+1);
if (!ret)
return NULL;
memcpy(ret, s, n);
ret[n] = 0;
return ret;
}
#endif
#if !defined(HAVE_WAITPID) && defined(HAVE_WAIT4)
int rep_waitpid(pid_t pid,int *status,int options)
{
return wait4(pid, status, options, NULL);
}
#endif
#ifndef HAVE_SETEUID
int rep_seteuid(uid_t euid)
{
#ifdef HAVE_SETRESUID
return setresuid(-1, euid, -1);
#else
errno = ENOSYS;
return -1;
#endif
}
#endif
#ifndef HAVE_SETEGID
int rep_setegid(gid_t egid)
{
#ifdef HAVE_SETRESGID
return setresgid(-1, egid, -1);
#else
errno = ENOSYS;
return -1;
#endif
}
#endif
/*******************************************************************
os/2 also doesn't have chroot
********************************************************************/
#ifndef HAVE_CHROOT
int rep_chroot(const char *dname)
{
errno = ENOSYS;
return -1;
}
#endif
/*****************************************************************
Possibly replace mkstemp if it is broken.
*****************************************************************/
#ifndef HAVE_SECURE_MKSTEMP
int rep_mkstemp(char *template)
{
/* have a reasonable go at emulating it. Hope that
the system mktemp() isn't completely hopeless */
mktemp(template);
if (template[0] == 0)
return -1;
return open(template, O_CREAT|O_EXCL|O_RDWR, 0600);
}
#endif
#ifndef HAVE_MKDTEMP
char *rep_mkdtemp(char *template)
{
char *dname;
if ((dname = mktemp(template))) {
if (mkdir(dname, 0700) >= 0) {
return dname;
}
}
return NULL;
}
#endif
/*****************************************************************
Watch out: this is not thread safe.
*****************************************************************/
#ifndef HAVE_PREAD
ssize_t rep_pread(int __fd, void *__buf, size_t __nbytes, off_t __offset)
{
if (lseek(__fd, __offset, SEEK_SET) != __offset) {
return -1;
}
return read(__fd, __buf, __nbytes);
}
#endif
/*****************************************************************
Watch out: this is not thread safe.
*****************************************************************/
#ifndef HAVE_PWRITE
ssize_t rep_pwrite(int __fd, const void *__buf, size_t __nbytes, off_t __offset)
{
if (lseek(__fd, __offset, SEEK_SET) != __offset) {
return -1;
}
return write(__fd, __buf, __nbytes);
}
#endif
#ifndef HAVE_STRCASESTR
char *rep_strcasestr(const char *haystack, const char *needle)
{
const char *s;
size_t nlen = strlen(needle);
for (s=haystack;*s;s++) {
if (toupper(*needle) == toupper(*s) &&
strncasecmp(s, needle, nlen) == 0) {
return (char *)((uintptr_t)s);
}
}
return NULL;
}
#endif
#ifndef HAVE_STRTOK_R
/* based on GLIBC version, copyright Free Software Foundation */
char *rep_strtok_r(char *s, const char *delim, char **save_ptr)
{
char *token;
if (s == NULL) s = *save_ptr;
s += strspn(s, delim);
if (*s == '\0') {
*save_ptr = s;
return NULL;
}
token = s;
s = strpbrk(token, delim);
if (s == NULL) {
*save_ptr = token + strlen(token);
} else {
*s = '\0';
*save_ptr = s + 1;
}
return token;
}
#endif
#ifndef HAVE_STRTOLL
long long int rep_strtoll(const char *str, char **endptr, int base)
{
#ifdef HAVE_STRTOQ
return strtoq(str, endptr, base);
#elif defined(HAVE___STRTOLL)
return __strtoll(str, endptr, base);
#elif SIZEOF_LONG == SIZEOF_LONG_LONG
return (long long int) strtol(str, endptr, base);
#else
# error "You need a strtoll function"
#endif
}
#else
#ifdef HAVE_BSD_STRTOLL
#ifdef HAVE_STRTOQ
long long int rep_strtoll(const char *str, char **endptr, int base)
{
long long int nb = strtoq(str, endptr, base);
/* In linux EINVAL is only returned if base is not ok */
if (errno == EINVAL) {
if (base == 0 || (base >1 && base <37)) {
/* Base was ok so it's because we were not
* able to make the convertion.
* Let's reset errno.
*/
errno = 0;
}
}
return nb;
}
#else
#error "You need the strtoq function"
#endif /* HAVE_STRTOQ */
#endif /* HAVE_BSD_STRTOLL */
#endif /* HAVE_STRTOLL */
#ifndef HAVE_STRTOULL
unsigned long long int rep_strtoull(const char *str, char **endptr, int base)
{
#ifdef HAVE_STRTOUQ
return strtouq(str, endptr, base);
#elif defined(HAVE___STRTOULL)
return __strtoull(str, endptr, base);
#elif SIZEOF_LONG == SIZEOF_LONG_LONG
return (unsigned long long int) strtoul(str, endptr, base);
#else
# error "You need a strtoull function"
#endif
}
#else
#ifdef HAVE_BSD_STRTOLL
#ifdef HAVE_STRTOUQ
unsigned long long int rep_strtoull(const char *str, char **endptr, int base)
{
unsigned long long int nb = strtouq(str, endptr, base);
/* In linux EINVAL is only returned if base is not ok */
if (errno == EINVAL) {
if (base == 0 || (base >1 && base <37)) {
/* Base was ok so it's because we were not
* able to make the convertion.
* Let's reset errno.
*/
errno = 0;
}
}
return nb;
}
#else
#error "You need the strtouq function"
#endif /* HAVE_STRTOUQ */
#endif /* HAVE_BSD_STRTOLL */
#endif /* HAVE_STRTOULL */
#ifndef HAVE_SETENV
int rep_setenv(const char *name, const char *value, int overwrite)
{
char *p;
size_t l1, l2;
int ret;
if (!overwrite && getenv(name)) {
return 0;
}
l1 = strlen(name);
l2 = strlen(value);
p = malloc(l1+l2+2);
if (p == NULL) {
return -1;
}
memcpy(p, name, l1);
p[l1] = '=';
memcpy(p+l1+1, value, l2);
p[l1+l2+1] = 0;
ret = putenv(p);
if (ret != 0) {
free(p);
}
return ret;
}
#endif
#ifndef HAVE_UNSETENV
int rep_unsetenv(const char *name)
{
extern char **environ;
size_t len = strlen(name);
size_t i, count;
if (environ == NULL || getenv(name) == NULL) {
return 0;
}
for (i=0;environ[i];i++) /* noop */ ;
count=i;
for (i=0;i= needlelen) {
char *p = (char *)memchr(haystack, *(const char *)needle,
haystacklen-(needlelen-1));
if (!p) return NULL;
if (memcmp(p, needle, needlelen) == 0) {
return p;
}
haystack = p+1;
haystacklen -= (p - (const char *)haystack) + 1;
}
return NULL;
}
#endif
#if !defined(HAVE_VDPRINTF) || !defined(HAVE_C99_VSNPRINTF)
int rep_vdprintf(int fd, const char *format, va_list ap)
{
char *s = NULL;
int ret;
vasprintf(&s, format, ap);
if (s == NULL) {
errno = ENOMEM;
return -1;
}
ret = write(fd, s, strlen(s));
free(s);
return ret;
}
#endif
#if !defined(HAVE_DPRINTF) || !defined(HAVE_C99_VSNPRINTF)
int rep_dprintf(int fd, const char *format, ...)
{
int ret;
va_list ap;
va_start(ap, format);
ret = vdprintf(fd, format, ap);
va_end(ap);
return ret;
}
#endif
#ifndef HAVE_GET_CURRENT_DIR_NAME
char *rep_get_current_dir_name(void)
{
char buf[PATH_MAX+1];
char *p;
p = getcwd(buf, sizeof(buf));
if (p == NULL) {
return NULL;
}
return strdup(p);
}
#endif
#ifndef HAVE_STRERROR_R
int rep_strerror_r(int errnum, char *buf, size_t buflen)
{
char *s = strerror(errnum);
if (strlen(s)+1 > buflen) {
errno = ERANGE;
return -1;
}
strncpy(buf, s, buflen);
return 0;
}
#endif
#ifndef HAVE_CLOCK_GETTIME
int rep_clock_gettime(clockid_t clk_id, struct timespec *tp)
{
struct timeval tval;
switch (clk_id) {
case 0: /* CLOCK_REALTIME :*/
#ifdef HAVE_GETTIMEOFDAY_TZ
gettimeofday(&tval,NULL);
#else
gettimeofday(&tval);
#endif
tp->tv_sec = tval.tv_sec;
tp->tv_nsec = tval.tv_usec * 1000;
break;
default:
errno = EINVAL;
return -1;
}
return 0;
}
#endif
#ifndef HAVE_MEMALIGN
void *rep_memalign( size_t align, size_t size )
{
#if defined(HAVE_POSIX_MEMALIGN)
void *p = NULL;
int ret = posix_memalign( &p, align, size );
if ( ret == 0 )
return p;
return NULL;
#else
/* On *BSD systems memaligns doesn't exist, but memory will
* be aligned on allocations of > pagesize. */
#if defined(SYSCONF_SC_PAGESIZE)
size_t pagesize = (size_t)sysconf(_SC_PAGESIZE);
#elif defined(HAVE_GETPAGESIZE)
size_t pagesize = (size_t)getpagesize();
#else
size_t pagesize = (size_t)-1;
#endif
if (pagesize == (size_t)-1) {
errno = ENOSYS;
return NULL;
}
if (size < pagesize) {
size = pagesize;
}
return malloc(size);
#endif
}
#endif
#ifndef HAVE_GETPEEREID
int rep_getpeereid(int s, uid_t *uid, gid_t *gid)
{
#if defined(HAVE_PEERCRED)
struct ucred cred;
socklen_t cred_len = sizeof(struct ucred);
int ret;
#undef getsockopt
ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
if (ret != 0) {
return -1;
}
if (cred_len != sizeof(struct ucred)) {
errno = EINVAL;
return -1;
}
*uid = cred.uid;
*gid = cred.gid;
return 0;
#else
errno = ENOSYS;
return -1;
#endif
}
#endif
#ifndef HAVE_USLEEP
int rep_usleep(useconds_t sec)
{
struct timeval tval;
/*
* Fake it with select...
*/
tval.tv_sec = 0;
tval.tv_usec = usecs/1000;
select(0,NULL,NULL,NULL,&tval);
return 0;
}
#endif /* HAVE_USLEEP */
#ifndef HAVE_SETPROCTITLE
void rep_setproctitle(const char *fmt, ...)
{
}
#endif
tevent-0.9.19/lib/replace/replace.h 0000660 0000000 0000000 00000046153 12153373752 017041 0 ustar root root 0000000 0000000 /*
Unix SMB/CIFS implementation.
macros to go along with the lib/replace/ portability layer code
Copyright (C) Andrew Tridgell 2005
Copyright (C) Jelmer Vernooij 2006-2008
Copyright (C) Jeremy Allison 2007.
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifndef _LIBREPLACE_REPLACE_H
#define _LIBREPLACE_REPLACE_H
#ifndef NO_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_STANDARDS_H
#include
#endif
#include
#include
#include
#include
#if defined(_MSC_VER) || defined(__MINGW32__)
#include "win32_replace.h"
#endif
#ifdef HAVE_INTTYPES_H
#define __STDC_FORMAT_MACROS
#include
#elif HAVE_STDINT_H
#include
/* force off HAVE_INTTYPES_H so that roken doesn't try to include both,
which causes a warning storm on irix */
#undef HAVE_INTTYPES_H
#endif
#ifdef HAVE_MALLOC_H
#include
#endif
#ifndef __PRI64_PREFIX
# if __WORDSIZE == 64 && ! defined __APPLE__
# define __PRI64_PREFIX "l"
# else
# define __PRI64_PREFIX "ll"
# endif
#endif
/* Decimal notation. */
#ifndef PRId8
# define PRId8 "d"
#endif
#ifndef PRId16
# define PRId16 "d"
#endif
#ifndef PRId32
# define PRId32 "d"
#endif
#ifndef PRId64
# define PRId64 __PRI64_PREFIX "d"
#endif
#ifndef PRIi8
# define PRIi8 "i"
#endif
#ifndef PRIi16
# define PRIi16 "i"
#endif
#ifndef PRIi32
# define PRIi32 "i"
#endif
#ifndef PRIi64
# define PRIi64 __PRI64_PREFIX "i"
#endif
#ifndef PRIu8
# define PRIu8 "u"
#endif
#ifndef PRIu16
# define PRIu16 "u"
#endif
#ifndef PRIu32
# define PRIu32 "u"
#endif
#ifndef PRIu64
# define PRIu64 __PRI64_PREFIX "u"
#endif
#ifndef SCNd8
# define SCNd8 "hhd"
#endif
#ifndef SCNd16
# define SCNd16 "hd"
#endif
#ifndef SCNd32
# define SCNd32 "d"
#endif
#ifndef SCNd64
# define SCNd64 __PRI64_PREFIX "d"
#endif
#ifndef SCNi8
# define SCNi8 "hhi"
#endif
#ifndef SCNi16
# define SCNi16 "hi"
#endif
#ifndef SCNi32
# define SCNi32 "i"
#endif
#ifndef SCNi64
# define SCNi64 __PRI64_PREFIX "i"
#endif
#ifndef SCNu8
# define SCNu8 "hhu"
#endif
#ifndef SCNu16
# define SCNu16 "hu"
#endif
#ifndef SCNu32
# define SCNu32 "u"
#endif
#ifndef SCNu64
# define SCNu64 __PRI64_PREFIX "u"
#endif
#ifdef HAVE_BSD_STRING_H
#include
#endif
#ifdef HAVE_BSD_UNISTD_H
#include
#endif
#ifdef HAVE_STRING_H
#include
#endif
#ifdef HAVE_STRINGS_H
#include
#endif
#ifdef HAVE_SYS_TYPES_H
#include
#endif
#ifdef HAVE_SETPROCTITLE_H
#include
#endif
#if STDC_HEADERS
#include
#include
#endif
#ifdef HAVE_LINUX_TYPES_H
/*
* This is needed as some broken header files require this to be included early
*/
#include
#endif
#ifndef HAVE_STRERROR
extern char *sys_errlist[];
#define strerror(i) sys_errlist[i]
#endif
#ifndef HAVE_ERRNO_DECL
extern int errno;
#endif
#ifndef HAVE_STRDUP
#define strdup rep_strdup
char *rep_strdup(const char *s);
#endif
#ifndef HAVE_MEMMOVE
#define memmove rep_memmove
void *rep_memmove(void *dest,const void *src,int size);
#endif
#ifndef HAVE_MEMMEM
#define memmem rep_memmem
void *rep_memmem(const void *haystack, size_t haystacklen,
const void *needle, size_t needlelen);
#endif
#ifndef HAVE_MEMALIGN
#define memalign rep_memalign
void *rep_memalign(size_t boundary, size_t size);
#endif
#ifndef HAVE_MKTIME
#define mktime rep_mktime
/* prototype is in "system/time.h" */
#endif
#ifndef HAVE_TIMEGM
#define timegm rep_timegm
/* prototype is in "system/time.h" */
#endif
#ifndef HAVE_UTIME
#define utime rep_utime
/* prototype is in "system/time.h" */
#endif
#ifndef HAVE_UTIMES
#define utimes rep_utimes
/* prototype is in "system/time.h" */
#endif
#ifndef HAVE_STRLCPY
#define strlcpy rep_strlcpy
size_t rep_strlcpy(char *d, const char *s, size_t bufsize);
#endif
#ifndef HAVE_STRLCAT
#define strlcat rep_strlcat
size_t rep_strlcat(char *d, const char *s, size_t bufsize);
#endif
#if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
#undef HAVE_STRNDUP
#define strndup rep_strndup
char *rep_strndup(const char *s, size_t n);
#endif
#if (defined(BROKEN_STRNLEN) || !defined(HAVE_STRNLEN))
#undef HAVE_STRNLEN
#define strnlen rep_strnlen
size_t rep_strnlen(const char *s, size_t n);
#endif
#if !HAVE_DECL_ENVIRON
#ifdef __APPLE__
#include
#define environ (*_NSGetEnviron())
#else
extern char **environ;
#endif
#endif
#ifndef HAVE_SETENV
#define setenv rep_setenv
int rep_setenv(const char *name, const char *value, int overwrite);
#else
#ifndef HAVE_SETENV_DECL
int setenv(const char *name, const char *value, int overwrite);
#endif
#endif
#ifndef HAVE_UNSETENV
#define unsetenv rep_unsetenv
int rep_unsetenv(const char *name);
#endif
#ifndef HAVE_SETEUID
#define seteuid rep_seteuid
int rep_seteuid(uid_t);
#endif
#ifndef HAVE_SETEGID
#define setegid rep_setegid
int rep_setegid(gid_t);
#endif
#if (defined(USE_SETRESUID) && !defined(HAVE_SETRESUID_DECL))
/* stupid glibc */
int setresuid(uid_t ruid, uid_t euid, uid_t suid);
#endif
#if (defined(USE_SETRESUID) && !defined(HAVE_SETRESGID_DECL))
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
#endif
#ifndef HAVE_CHOWN
#define chown rep_chown
int rep_chown(const char *path, uid_t uid, gid_t gid);
#endif
#ifndef HAVE_CHROOT
#define chroot rep_chroot
int rep_chroot(const char *dirname);
#endif
#ifndef HAVE_LINK
#define link rep_link
int rep_link(const char *oldpath, const char *newpath);
#endif
#ifndef HAVE_READLINK
#define readlink rep_readlink
ssize_t rep_readlink(const char *path, char *buf, size_t bufsize);
#endif
#ifndef HAVE_SYMLINK
#define symlink rep_symlink
int rep_symlink(const char *oldpath, const char *newpath);
#endif
#ifndef HAVE_REALPATH
#define realpath rep_realpath
char *rep_realpath(const char *path, char *resolved_path);
#endif
#ifndef HAVE_LCHOWN
#define lchown rep_lchown
int rep_lchown(const char *fname,uid_t uid,gid_t gid);
#endif
#ifdef HAVE_UNIX_H
#include
#endif
#ifndef HAVE_SETLINEBUF
#define setlinebuf rep_setlinebuf
void rep_setlinebuf(FILE *);
#endif
#ifndef HAVE_STRCASESTR
#define strcasestr rep_strcasestr
char *rep_strcasestr(const char *haystack, const char *needle);
#endif
#ifndef HAVE_STRTOK_R
#define strtok_r rep_strtok_r
char *rep_strtok_r(char *s, const char *delim, char **save_ptr);
#endif
#ifndef HAVE_STRTOLL
#define strtoll rep_strtoll
long long int rep_strtoll(const char *str, char **endptr, int base);
#else
#ifdef HAVE_BSD_STRTOLL
#define strtoll rep_strtoll
long long int rep_strtoll(const char *str, char **endptr, int base);
#endif
#endif
#ifndef HAVE_STRTOULL
#define strtoull rep_strtoull
unsigned long long int rep_strtoull(const char *str, char **endptr, int base);
#else
#ifdef HAVE_BSD_STRTOLL /* yes, it's not HAVE_BSD_STRTOULL */
#define strtoull rep_strtoull
unsigned long long int rep_strtoull(const char *str, char **endptr, int base);
#endif
#endif
#ifndef HAVE_FTRUNCATE
#define ftruncate rep_ftruncate
int rep_ftruncate(int,off_t);
#endif
#ifndef HAVE_INITGROUPS
#define initgroups rep_initgroups
int rep_initgroups(char *name, gid_t id);
#endif
#if !defined(HAVE_BZERO) && defined(HAVE_MEMSET)
#define bzero(a,b) memset((a),'\0',(b))
#endif
#ifndef HAVE_DLERROR
#define dlerror rep_dlerror
char *rep_dlerror(void);
#endif
#ifndef HAVE_DLOPEN
#define dlopen rep_dlopen
#ifdef DLOPEN_TAKES_UNSIGNED_FLAGS
void *rep_dlopen(const char *name, unsigned int flags);
#else
void *rep_dlopen(const char *name, int flags);
#endif
#endif
#ifndef HAVE_DLSYM
#define dlsym rep_dlsym
void *rep_dlsym(void *handle, const char *symbol);
#endif
#ifndef HAVE_DLCLOSE
#define dlclose rep_dlclose
int rep_dlclose(void *handle);
#endif
#ifndef HAVE_SOCKETPAIR
#define socketpair rep_socketpair
/* prototype is in system/network.h */
#endif
#ifndef PRINTF_ATTRIBUTE
#if (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 1 )
/** Use gcc attribute to check printf fns. a1 is the 1-based index of
* the parameter containing the format, and a2 the index of the first
* argument. Note that some gcc 2.x versions don't handle this
* properly **/
#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2)))
#else
#define PRINTF_ATTRIBUTE(a1, a2)
#endif
#endif
#ifndef _DEPRECATED_
#if (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 1 )
#define _DEPRECATED_ __attribute__ ((deprecated))
#else
#define _DEPRECATED_
#endif
#endif
#if !defined(HAVE_VDPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#define vdprintf rep_vdprintf
int rep_vdprintf(int fd, const char *format, va_list ap) PRINTF_ATTRIBUTE(2,0);
#endif
#if !defined(HAVE_DPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#define dprintf rep_dprintf
int rep_dprintf(int fd, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
#endif
#if !defined(HAVE_VASPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#define vasprintf rep_vasprintf
int rep_vasprintf(char **ptr, const char *format, va_list ap) PRINTF_ATTRIBUTE(2,0);
#endif
#if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#define snprintf rep_snprintf
int rep_snprintf(char *,size_t ,const char *, ...) PRINTF_ATTRIBUTE(3,4);
#endif
#if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#define vsnprintf rep_vsnprintf
int rep_vsnprintf(char *,size_t ,const char *, va_list ap) PRINTF_ATTRIBUTE(3,0);
#endif
#if !defined(HAVE_ASPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#define asprintf rep_asprintf
int rep_asprintf(char **,const char *, ...) PRINTF_ATTRIBUTE(2,3);
#endif
#if !defined(HAVE_C99_VSNPRINTF)
#ifdef REPLACE_BROKEN_PRINTF
/*
* We do not redefine printf by default
* as it breaks the build if system headers
* use __attribute__((format(printf, 3, 0)))
* instead of __attribute__((format(__printf__, 3, 0)))
*/
#define printf rep_printf
#endif
int rep_printf(const char *, ...) PRINTF_ATTRIBUTE(1,2);
#endif
#if !defined(HAVE_C99_VSNPRINTF)
#define fprintf rep_fprintf
int rep_fprintf(FILE *stream, const char *, ...) PRINTF_ATTRIBUTE(2,3);
#endif
#ifndef HAVE_VSYSLOG
#ifdef HAVE_SYSLOG
#define vsyslog rep_vsyslog
void rep_vsyslog (int facility_priority, const char *format, va_list arglist) PRINTF_ATTRIBUTE(2,0);
#endif
#endif
/* we used to use these fns, but now we have good replacements
for snprintf and vsnprintf */
#define slprintf snprintf
#ifndef HAVE_VA_COPY
#undef va_copy
#ifdef HAVE___VA_COPY
#define va_copy(dest, src) __va_copy(dest, src)
#else
#define va_copy(dest, src) (dest) = (src)
#endif
#endif
#ifndef HAVE_VOLATILE
#define volatile
#endif
#ifndef HAVE_COMPARISON_FN_T
typedef int (*comparison_fn_t)(const void *, const void *);
#endif
#ifndef HAVE_WORKING_STRPTIME
#define strptime rep_strptime
struct tm;
char *rep_strptime(const char *buf, const char *format, struct tm *tm);
#endif
#ifndef HAVE_DUP2
#define dup2 rep_dup2
int rep_dup2(int oldfd, int newfd);
#endif
/* Load header file for dynamic linking stuff */
#ifdef HAVE_DLFCN_H
#include
#endif
#ifndef RTLD_LAZY
#define RTLD_LAZY 0
#endif
#ifndef RTLD_NOW
#define RTLD_NOW 0
#endif
#ifndef RTLD_GLOBAL
#define RTLD_GLOBAL 0
#endif
#ifndef HAVE_SECURE_MKSTEMP
#define mkstemp(path) rep_mkstemp(path)
int rep_mkstemp(char *temp);
#endif
#ifndef HAVE_MKDTEMP
#define mkdtemp rep_mkdtemp
char *rep_mkdtemp(char *template);
#endif
#ifndef HAVE_PREAD
#define pread rep_pread
ssize_t rep_pread(int __fd, void *__buf, size_t __nbytes, off_t __offset);
#define LIBREPLACE_PREAD_REPLACED 1
#else
#define LIBREPLACE_PREAD_NOT_REPLACED 1
#endif
#ifndef HAVE_PWRITE
#define pwrite rep_pwrite
ssize_t rep_pwrite(int __fd, const void *__buf, size_t __nbytes, off_t __offset);
#define LIBREPLACE_PWRITE_REPLACED 1
#else
#define LIBREPLACE_PWRITE_NOT_REPLACED 1
#endif
#if !defined(HAVE_INET_NTOA) || defined(REPLACE_INET_NTOA)
#define inet_ntoa rep_inet_ntoa
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_INET_PTON
#define inet_pton rep_inet_pton
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_INET_NTOP
#define inet_ntop rep_inet_ntop
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_INET_ATON
#define inet_aton rep_inet_aton
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_CONNECT
#define connect rep_connect
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_GETHOSTBYNAME
#define gethostbyname rep_gethostbyname
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_GETIFADDRS
#define getifaddrs rep_getifaddrs
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_FREEIFADDRS
#define freeifaddrs rep_freeifaddrs
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_GET_CURRENT_DIR_NAME
#define get_current_dir_name rep_get_current_dir_name
char *rep_get_current_dir_name(void);
#endif
#ifndef HAVE_STRERROR_R
#define strerror_r rep_strerror_r
int rep_strerror_r(int errnum, char *buf, size_t buflen);
#endif
#if !defined(HAVE_CLOCK_GETTIME)
#define clock_gettime rep_clock_gettime
#endif
#ifdef HAVE_LIMITS_H
#include
#endif
#ifdef HAVE_SYS_PARAM_H
#include
#endif
/* The extra casts work around common compiler bugs. */
#define _TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
/* The outer cast is needed to work around a bug in Cray C 5.0.3.0.
It is necessary at least when t == time_t. */
#define _TYPE_MINIMUM(t) ((t) (_TYPE_SIGNED (t) \
? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0))
#define _TYPE_MAXIMUM(t) ((t) (~ (t) 0 - _TYPE_MINIMUM (t)))
#ifndef UINT16_MAX
#define UINT16_MAX 65535
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#ifndef UINT64_MAX
#define UINT64_MAX ((uint64_t)-1)
#endif
#ifndef INT64_MAX
#define INT64_MAX 9223372036854775807LL
#endif
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif
#ifndef INT32_MAX
#define INT32_MAX _TYPE_MAXIMUM(int32_t)
#endif
#ifdef HAVE_STDBOOL_H
#include
#endif
#if !defined(HAVE_BOOL)
#ifdef HAVE__Bool
#define bool _Bool
#else
typedef int bool;
#endif
#endif
#if !defined(HAVE_INTPTR_T)
typedef long long intptr_t ;
#endif
#if !defined(HAVE_UINTPTR_T)
typedef unsigned long long uintptr_t ;
#endif
#if !defined(HAVE_PTRDIFF_T)
typedef unsigned long long ptrdiff_t ;
#endif
/*
* to prevent from doing a redefine of 'bool'
*
* IRIX, HPUX, MacOS 10 and Solaris need BOOL_DEFINED
* Tru64 needs _BOOL_EXISTS
* AIX needs _BOOL,_TRUE,_FALSE
*/
#ifndef BOOL_DEFINED
#define BOOL_DEFINED
#endif
#ifndef _BOOL_EXISTS
#define _BOOL_EXISTS
#endif
#ifndef _BOOL
#define _BOOL
#endif
#ifndef __bool_true_false_are_defined
#define __bool_true_false_are_defined
#endif
#ifndef true
#define true (1)
#endif
#ifndef false
#define false (0)
#endif
#ifndef _TRUE
#define _TRUE true
#endif
#ifndef _FALSE
#define _FALSE false
#endif
#ifndef HAVE_FUNCTION_MACRO
#ifdef HAVE_func_MACRO
#define __FUNCTION__ __func__
#else
#define __FUNCTION__ ("")
#endif
#endif
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
#ifndef MAX
#define MAX(a,b) ((a)>(b)?(a):(b))
#endif
#if !defined(HAVE_VOLATILE)
#define volatile
#endif
/**
this is a warning hack. The idea is to use this everywhere that we
get the "discarding const" warning from gcc. That doesn't actually
fix the problem of course, but it means that when we do get to
cleaning them up we can do it by searching the code for
discard_const.
It also means that other error types aren't as swamped by the noise
of hundreds of const warnings, so we are more likely to notice when
we get new errors.
Please only add more uses of this macro when you find it
_really_ hard to fix const warnings. Our aim is to eventually use
this function in only a very few places.
Also, please call this via the discard_const_p() macro interface, as that
makes the return type safe.
*/
#define discard_const(ptr) ((void *)((uintptr_t)(ptr)))
/** Type-safe version of discard_const */
#define discard_const_p(type, ptr) ((type *)discard_const(ptr))
#ifndef __STRING
#define __STRING(x) #x
#endif
#ifndef __STRINGSTRING
#define __STRINGSTRING(x) __STRING(x)
#endif
#ifndef __LINESTR__
#define __LINESTR__ __STRINGSTRING(__LINE__)
#endif
#ifndef __location__
#define __location__ __FILE__ ":" __LINESTR__
#endif
/**
* zero a structure
*/
#define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x))
/**
* zero a structure given a pointer to the structure
*/
#define ZERO_STRUCTP(x) do { if ((x) != NULL) memset((char *)(x), 0, sizeof(*(x))); } while(0)
/**
* zero a structure given a pointer to the structure - no zero check
*/
#define ZERO_STRUCTPN(x) memset((char *)(x), 0, sizeof(*(x)))
/* zero an array - note that sizeof(array) must work - ie. it must not be a
pointer */
#define ZERO_ARRAY(x) memset((char *)(x), 0, sizeof(x))
/**
* work out how many elements there are in a static array
*/
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
/**
* pointer difference macro
*/
#define PTR_DIFF(p1,p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
#if MMAP_BLACKLIST
#undef HAVE_MMAP
#endif
#ifdef __COMPAR_FN_T
#define QSORT_CAST (__compar_fn_t)
#endif
#ifndef QSORT_CAST
#define QSORT_CAST (int (*)(const void *, const void *))
#endif
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
#ifndef MAX_DNS_NAME_LENGTH
#define MAX_DNS_NAME_LENGTH 256 /* Actually 255 but +1 for terminating null. */
#endif
#ifndef HAVE_CRYPT
char *ufc_crypt(const char *key, const char *salt);
#define crypt ufc_crypt
#else
#ifdef HAVE_CRYPT_H
#include
#endif
#endif
/* these macros gain us a few percent of speed on gcc */
#if (__GNUC__ >= 3)
/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
as its first argument */
#ifndef likely
#define likely(x) __builtin_expect(!!(x), 1)
#endif
#ifndef unlikely
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif
#else
#ifndef likely
#define likely(x) (x)
#endif
#ifndef unlikely
#define unlikely(x) (x)
#endif
#endif
#ifndef HAVE_FDATASYNC
#define fdatasync(fd) fsync(fd)
#elif !defined(HAVE_DECL_FDATASYNC)
int fdatasync(int );
#endif
/* these are used to mark symbols as local to a shared lib, or
* publicly available via the shared lib API */
#ifndef _PUBLIC_
#ifdef HAVE_VISIBILITY_ATTR
#define _PUBLIC_ __attribute__((visibility("default")))
#else
#define _PUBLIC_
#endif
#endif
#ifndef _PRIVATE_
#ifdef HAVE_VISIBILITY_ATTR
# define _PRIVATE_ __attribute__((visibility("hidden")))
#else
# define _PRIVATE_
#endif
#endif
#ifndef HAVE_POLL
#define poll rep_poll
/* prototype is in "system/network.h" */
#endif
#ifndef HAVE_GETPEEREID
#define getpeereid rep_getpeereid
int rep_getpeereid(int s, uid_t *uid, gid_t *gid);
#endif
#ifndef HAVE_USLEEP
#define usleep rep_usleep
typedef long useconds_t;
int usleep(useconds_t);
#endif
#ifndef HAVE_SETPROCTITLE
#define setproctitle rep_setproctitle
void rep_setproctitle(const char *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
#endif
#endif /* _LIBREPLACE_REPLACE_H */
tevent-0.9.19/lib/replace/snprintf.c 0000660 0000000 0000000 00000106663 12101212317 017245 0 ustar root root 0000000 0000000 /*
* NOTE: If you change this file, please merge it into rsync, samba, etc.
*/
/*
* Copyright Patrick Powell 1995
* This code is based on code written by Patrick Powell (papowell@astart.com)
* It may be used for any purpose as long as this notice remains intact
* on all source code distributions
*/
/**************************************************************
* Original:
* Patrick Powell Tue Apr 11 09:48:21 PDT 1995
* A bombproof version of doprnt (dopr) included.
* Sigh. This sort of thing is always nasty do deal with. Note that
* the version here does not include floating point...
*
* snprintf() is used instead of sprintf() as it does limit checks
* for string length. This covers a nasty loophole.
*
* The other functions are there to prevent NULL pointers from
* causing nast effects.
*
* More Recently:
* Brandon Long 9/15/96 for mutt 0.43
* This was ugly. It is still ugly. I opted out of floating point
* numbers, but the formatter understands just about everything
* from the normal C string format, at least as far as I can tell from
* the Solaris 2.5 printf(3S) man page.
*
* Brandon Long 10/22/97 for mutt 0.87.1
* Ok, added some minimal floating point support, which means this
* probably requires libm on most operating systems. Don't yet
* support the exponent (e,E) and sigfig (g,G). Also, fmtint()
* was pretty badly broken, it just wasn't being exercised in ways
* which showed it, so that's been fixed. Also, formated the code
* to mutt conventions, and removed dead code left over from the
* original. Also, there is now a builtin-test, just compile with:
* gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
* and run snprintf for results.
*
* Thomas Roessler 01/27/98 for mutt 0.89i
* The PGP code was using unsigned hexadecimal formats.
* Unfortunately, unsigned formats simply didn't work.
*
* Michael Elkins 03/05/98 for mutt 0.90.8
* The original code assumed that both snprintf() and vsnprintf() were
* missing. Some systems only have snprintf() but not vsnprintf(), so
* the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
*
* Andrew Tridgell (tridge@samba.org) Oct 1998
* fixed handling of %.0f
* added test for HAVE_LONG_DOUBLE
*
* tridge@samba.org, idra@samba.org, April 2001
* got rid of fcvt code (twas buggy and made testing harder)
* added C99 semantics
*
* date: 2002/12/19 19:56:31; author: herb; state: Exp; lines: +2 -0
* actually print args for %g and %e
*
* date: 2002/06/03 13:37:52; author: jmcd; state: Exp; lines: +8 -0
* Since includes.h isn't included here, VA_COPY has to be defined here. I don't
* see any include file that is guaranteed to be here, so I'm defining it
* locally. Fixes AIX and Solaris builds.
*
* date: 2002/06/03 03:07:24; author: tridge; state: Exp; lines: +5 -13
* put the ifdef for HAVE_VA_COPY in one place rather than in lots of
* functions
*
* date: 2002/05/17 14:51:22; author: jmcd; state: Exp; lines: +21 -4
* Fix usage of va_list passed as an arg. Use __va_copy before using it
* when it exists.
*
* date: 2002/04/16 22:38:04; author: idra; state: Exp; lines: +20 -14
* Fix incorrect zpadlen handling in fmtfp.
* Thanks to Ollie Oldham for spotting it.
* few mods to make it easier to compile the tests.
* addedd the "Ollie" test to the floating point ones.
*
* Martin Pool (mbp@samba.org) April 2003
* Remove NO_CONFIG_H so that the test case can be built within a source
* tree with less trouble.
* Remove unnecessary SAFE_FREE() definition.
*
* Martin Pool (mbp@samba.org) May 2003
* Put in a prototype for dummy_snprintf() to quiet compiler warnings.
*
* Move #endif to make sure VA_COPY, LDOUBLE, etc are defined even
* if the C library has some snprintf functions already.
*
* Darren Tucker (dtucker@zip.com.au) 2005
* Fix bug allowing read overruns of the source string with "%.*s"
* Usually harmless unless the read runs outside the process' allocation
* (eg if your malloc does guard pages) in which case it will segfault.
* From OpenSSH. Also added test for same.
*
* Simo Sorce (idra@samba.org) Jan 2006
*
* Add support for position independent parameters
* fix fmtstr now it conforms to sprintf wrt min.max
*
**************************************************************/
#include "replace.h"
#include "system/locale.h"
#ifdef TEST_SNPRINTF /* need math library headers for testing */
/* In test mode, we pretend that this system doesn't have any snprintf
* functions, regardless of what config.h says. */
# undef HAVE_SNPRINTF
# undef HAVE_VSNPRINTF
# undef HAVE_C99_VSNPRINTF
# undef HAVE_ASPRINTF
# undef HAVE_VASPRINTF
# include
#endif /* TEST_SNPRINTF */
#if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
/* only include stdio.h if we are not re-defining snprintf or vsnprintf */
#include
/* make the compiler happy with an empty file */
void dummy_snprintf(void);
void dummy_snprintf(void) {}
#endif /* HAVE_SNPRINTF, etc */
/* yes this really must be a ||. Don't muck with this (tridge) */
#if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
#ifdef HAVE_LONG_DOUBLE
#define LDOUBLE long double
#else
#define LDOUBLE double
#endif
#ifdef HAVE_LONG_LONG
#define LLONG long long
#else
#define LLONG long
#endif
#ifndef VA_COPY
#ifdef HAVE_VA_COPY
#define VA_COPY(dest, src) va_copy(dest, src)
#else
#ifdef HAVE___VA_COPY
#define VA_COPY(dest, src) __va_copy(dest, src)
#else
#define VA_COPY(dest, src) (dest) = (src)
#endif
#endif
/*
* dopr(): poor man's version of doprintf
*/
/* format read states */
#define DP_S_DEFAULT 0
#define DP_S_FLAGS 1
#define DP_S_MIN 2
#define DP_S_DOT 3
#define DP_S_MAX 4
#define DP_S_MOD 5
#define DP_S_CONV 6
#define DP_S_DONE 7
/* format flags - Bits */
#define DP_F_MINUS (1 << 0)
#define DP_F_PLUS (1 << 1)
#define DP_F_SPACE (1 << 2)
#define DP_F_NUM (1 << 3)
#define DP_F_ZERO (1 << 4)
#define DP_F_UP (1 << 5)
#define DP_F_UNSIGNED (1 << 6)
/* Conversion Flags */
#define DP_C_CHAR 1
#define DP_C_SHORT 2
#define DP_C_LONG 3
#define DP_C_LDOUBLE 4
#define DP_C_LLONG 5
#define DP_C_SIZET 6
/* Chunk types */
#define CNK_FMT_STR 0
#define CNK_INT 1
#define CNK_OCTAL 2
#define CNK_UINT 3
#define CNK_HEX 4
#define CNK_FLOAT 5
#define CNK_CHAR 6
#define CNK_STRING 7
#define CNK_PTR 8
#define CNK_NUM 9
#define CNK_PRCNT 10
#define char_to_int(p) ((p)- '0')
#ifndef MAX
#define MAX(p,q) (((p) >= (q)) ? (p) : (q))
#endif
struct pr_chunk {
int type; /* chunk type */
int num; /* parameter number */
int min;
int max;
int flags;
int cflags;
int start;
int len;
LLONG value;
LDOUBLE fvalue;
char *strvalue;
void *pnum;
struct pr_chunk *min_star;
struct pr_chunk *max_star;
struct pr_chunk *next;
};
struct pr_chunk_x {
struct pr_chunk **chunks;
int num;
};
static int dopr(char *buffer, size_t maxlen, const char *format,
va_list args_in);
static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
char *value, int flags, int min, int max);
static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
LLONG value, int base, int min, int max, int flags);
static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
LDOUBLE fvalue, int min, int max, int flags);
static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
static struct pr_chunk *new_chunk(void);
static int add_cnk_list_entry(struct pr_chunk_x **list,
int max_num, struct pr_chunk *chunk);
static int dopr(char *buffer, size_t maxlen, const char *format, va_list args_in)
{
char ch;
int state;
int pflag;
int pnum;
int pfirst;
size_t currlen;
va_list args;
const char *base;
struct pr_chunk *chunks = NULL;
struct pr_chunk *cnk = NULL;
struct pr_chunk_x *clist = NULL;
int max_pos;
int ret = -1;
VA_COPY(args, args_in);
state = DP_S_DEFAULT;
pfirst = 1;
pflag = 0;
pnum = 0;
max_pos = 0;
base = format;
ch = *format++;
/* retrieve the string structure as chunks */
while (state != DP_S_DONE) {
if (ch == '\0')
state = DP_S_DONE;
switch(state) {
case DP_S_DEFAULT:
if (cnk) {
cnk->next = new_chunk();
cnk = cnk->next;
} else {
cnk = new_chunk();
}
if (!cnk) goto done;
if (!chunks) chunks = cnk;
if (ch == '%') {
state = DP_S_FLAGS;
ch = *format++;
} else {
cnk->type = CNK_FMT_STR;
cnk->start = format - base -1;
while ((ch != '\0') && (ch != '%')) ch = *format++;
cnk->len = format - base - cnk->start -1;
}
break;
case DP_S_FLAGS:
switch (ch) {
case '-':
cnk->flags |= DP_F_MINUS;
ch = *format++;
break;
case '+':
cnk->flags |= DP_F_PLUS;
ch = *format++;
break;
case ' ':
cnk->flags |= DP_F_SPACE;
ch = *format++;
break;
case '#':
cnk->flags |= DP_F_NUM;
ch = *format++;
break;
case '0':
cnk->flags |= DP_F_ZERO;
ch = *format++;
break;
case 'I':
/* internationalization not supported yet */
ch = *format++;
break;
default:
state = DP_S_MIN;
break;
}
break;
case DP_S_MIN:
if (isdigit((unsigned char)ch)) {
cnk->min = 10 * cnk->min + char_to_int (ch);
ch = *format++;
} else if (ch == '$') {
if (!pfirst && !pflag) {
/* parameters must be all positioned or none */
goto done;
}
if (pfirst) {
pfirst = 0;
pflag = 1;
}
if (cnk->min == 0) /* what ?? */
goto done;
cnk->num = cnk->min;
cnk->min = 0;
ch = *format++;
} else if (ch == '*') {
if (pfirst) pfirst = 0;
cnk->min_star = new_chunk();
if (!cnk->min_star) /* out of memory :-( */
goto done;
cnk->min_star->type = CNK_INT;
if (pflag) {
int num;
ch = *format++;
if (!isdigit((unsigned char)ch)) {
/* parameters must be all positioned or none */
goto done;
}
for (num = 0; isdigit((unsigned char)ch); ch = *format++) {
num = 10 * num + char_to_int(ch);
}
cnk->min_star->num = num;
if (ch != '$') /* what ?? */
goto done;
} else {
cnk->min_star->num = ++pnum;
}
max_pos = add_cnk_list_entry(&clist, max_pos, cnk->min_star);
if (max_pos == 0) /* out of memory :-( */
goto done;
ch = *format++;
state = DP_S_DOT;
} else {
if (pfirst) pfirst = 0;
state = DP_S_DOT;
}
break;
case DP_S_DOT:
if (ch == '.') {
state = DP_S_MAX;
ch = *format++;
} else {
state = DP_S_MOD;
}
break;
case DP_S_MAX:
if (isdigit((unsigned char)ch)) {
if (cnk->max < 0)
cnk->max = 0;
cnk->max = 10 * cnk->max + char_to_int (ch);
ch = *format++;
} else if (ch == '$') {
if (!pfirst && !pflag) {
/* parameters must be all positioned or none */
goto done;
}
if (cnk->max <= 0) /* what ?? */
goto done;
cnk->num = cnk->max;
cnk->max = -1;
ch = *format++;
} else if (ch == '*') {
cnk->max_star = new_chunk();
if (!cnk->max_star) /* out of memory :-( */
goto done;
cnk->max_star->type = CNK_INT;
if (pflag) {
int num;
ch = *format++;
if (!isdigit((unsigned char)ch)) {
/* parameters must be all positioned or none */
goto done;
}
for (num = 0; isdigit((unsigned char)ch); ch = *format++) {
num = 10 * num + char_to_int(ch);
}
cnk->max_star->num = num;
if (ch != '$') /* what ?? */
goto done;
} else {
cnk->max_star->num = ++pnum;
}
max_pos = add_cnk_list_entry(&clist, max_pos, cnk->max_star);
if (max_pos == 0) /* out of memory :-( */
goto done;
ch = *format++;
state = DP_S_MOD;
} else {
state = DP_S_MOD;
}
break;
case DP_S_MOD:
switch (ch) {
case 'h':
cnk->cflags = DP_C_SHORT;
ch = *format++;
if (ch == 'h') {
cnk->cflags = DP_C_CHAR;
ch = *format++;
}
break;
case 'l':
cnk->cflags = DP_C_LONG;
ch = *format++;
if (ch == 'l') { /* It's a long long */
cnk->cflags = DP_C_LLONG;
ch = *format++;
}
break;
case 'L':
cnk->cflags = DP_C_LDOUBLE;
ch = *format++;
break;
case 'z':
cnk->cflags = DP_C_SIZET;
ch = *format++;
break;
default:
break;
}
state = DP_S_CONV;
break;
case DP_S_CONV:
if (cnk->num == 0) cnk->num = ++pnum;
max_pos = add_cnk_list_entry(&clist, max_pos, cnk);
if (max_pos == 0) /* out of memory :-( */
goto done;
switch (ch) {
case 'd':
case 'i':
cnk->type = CNK_INT;
break;
case 'o':
cnk->type = CNK_OCTAL;
cnk->flags |= DP_F_UNSIGNED;
break;
case 'u':
cnk->type = CNK_UINT;
cnk->flags |= DP_F_UNSIGNED;
break;
case 'X':
cnk->flags |= DP_F_UP;
case 'x':
cnk->type = CNK_HEX;
cnk->flags |= DP_F_UNSIGNED;
break;
case 'A':
/* hex float not supported yet */
case 'E':
case 'G':
case 'F':
cnk->flags |= DP_F_UP;
case 'a':
/* hex float not supported yet */
case 'e':
case 'f':
case 'g':
cnk->type = CNK_FLOAT;
break;
case 'c':
cnk->type = CNK_CHAR;
break;
case 's':
cnk->type = CNK_STRING;
break;
case 'p':
cnk->type = CNK_PTR;
cnk->flags |= DP_F_UNSIGNED;
break;
case 'n':
cnk->type = CNK_NUM;
break;
case '%':
cnk->type = CNK_PRCNT;
break;
default:
/* Unknown, bail out*/
goto done;
}
ch = *format++;
state = DP_S_DEFAULT;
break;
case DP_S_DONE:
break;
default:
/* hmm? */
break; /* some picky compilers need this */
}
}
/* retrieve the format arguments */
for (pnum = 0; pnum < max_pos; pnum++) {
int i;
if (clist[pnum].num == 0) {
/* ignoring a parameter should not be permitted
* all parameters must be matched at least once
* BUT seem some system ignore this rule ...
* at least my glibc based system does --SSS
*/
#ifdef DEBUG_SNPRINTF
printf("parameter at position %d not used\n", pnum+1);
#endif
/* eat the parameter */
va_arg (args, int);
continue;
}
for (i = 1; i < clist[pnum].num; i++) {
if (clist[pnum].chunks[0]->type != clist[pnum].chunks[i]->type) {
/* nooo noo no!
* all the references to a parameter
* must be of the same type
*/
goto done;
}
}
cnk = clist[pnum].chunks[0];
switch (cnk->type) {
case CNK_INT:
if (cnk->cflags == DP_C_SHORT)
cnk->value = va_arg (args, int);
else if (cnk->cflags == DP_C_LONG)
cnk->value = va_arg (args, long int);
else if (cnk->cflags == DP_C_LLONG)
cnk->value = va_arg (args, LLONG);
else if (cnk->cflags == DP_C_SIZET)
cnk->value = va_arg (args, ssize_t);
else
cnk->value = va_arg (args, int);
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->value = cnk->value;
}
break;
case CNK_OCTAL:
case CNK_UINT:
case CNK_HEX:
if (cnk->cflags == DP_C_SHORT)
cnk->value = va_arg (args, unsigned int);
else if (cnk->cflags == DP_C_LONG)
cnk->value = (unsigned long int)va_arg (args, unsigned long int);
else if (cnk->cflags == DP_C_LLONG)
cnk->value = (LLONG)va_arg (args, unsigned LLONG);
else if (cnk->cflags == DP_C_SIZET)
cnk->value = (size_t)va_arg (args, size_t);
else
cnk->value = (unsigned int)va_arg (args, unsigned int);
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->value = cnk->value;
}
break;
case CNK_FLOAT:
if (cnk->cflags == DP_C_LDOUBLE)
cnk->fvalue = va_arg (args, LDOUBLE);
else
cnk->fvalue = va_arg (args, double);
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->fvalue = cnk->fvalue;
}
break;
case CNK_CHAR:
cnk->value = va_arg (args, int);
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->value = cnk->value;
}
break;
case CNK_STRING:
cnk->strvalue = va_arg (args, char *);
if (!cnk->strvalue) cnk->strvalue = "(NULL)";
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->strvalue = cnk->strvalue;
}
break;
case CNK_PTR:
cnk->strvalue = va_arg (args, void *);
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->strvalue = cnk->strvalue;
}
break;
case CNK_NUM:
if (cnk->cflags == DP_C_CHAR)
cnk->pnum = va_arg (args, char *);
else if (cnk->cflags == DP_C_SHORT)
cnk->pnum = va_arg (args, short int *);
else if (cnk->cflags == DP_C_LONG)
cnk->pnum = va_arg (args, long int *);
else if (cnk->cflags == DP_C_LLONG)
cnk->pnum = va_arg (args, LLONG *);
else if (cnk->cflags == DP_C_SIZET)
cnk->pnum = va_arg (args, ssize_t *);
else
cnk->pnum = va_arg (args, int *);
for (i = 1; i < clist[pnum].num; i++) {
clist[pnum].chunks[i]->pnum = cnk->pnum;
}
break;
case CNK_PRCNT:
break;
default:
/* what ?? */
goto done;
}
}
/* print out the actual string from chunks */
currlen = 0;
cnk = chunks;
while (cnk) {
int len, min, max;
if (cnk->min_star) min = cnk->min_star->value;
else min = cnk->min;
if (cnk->max_star) max = cnk->max_star->value;
else max = cnk->max;
switch (cnk->type) {
case CNK_FMT_STR:
if (maxlen != 0 && maxlen > currlen) {
if (maxlen > (currlen + cnk->len)) len = cnk->len;
else len = maxlen - currlen;
memcpy(&(buffer[currlen]), &(base[cnk->start]), len);
}
currlen += cnk->len;
break;
case CNK_INT:
case CNK_UINT:
fmtint (buffer, &currlen, maxlen, cnk->value, 10, min, max, cnk->flags);
break;
case CNK_OCTAL:
fmtint (buffer, &currlen, maxlen, cnk->value, 8, min, max, cnk->flags);
break;
case CNK_HEX:
fmtint (buffer, &currlen, maxlen, cnk->value, 16, min, max, cnk->flags);
break;
case CNK_FLOAT:
fmtfp (buffer, &currlen, maxlen, cnk->fvalue, min, max, cnk->flags);
break;
case CNK_CHAR:
dopr_outch (buffer, &currlen, maxlen, cnk->value);
break;
case CNK_STRING:
if (max == -1) {
max = strlen(cnk->strvalue);
}
fmtstr (buffer, &currlen, maxlen, cnk->strvalue, cnk->flags, min, max);
break;
case CNK_PTR:
fmtint (buffer, &currlen, maxlen, (long)(cnk->strvalue), 16, min, max, cnk->flags);
break;
case CNK_NUM:
if (cnk->cflags == DP_C_CHAR)
*((char *)(cnk->pnum)) = (char)currlen;
else if (cnk->cflags == DP_C_SHORT)
*((short int *)(cnk->pnum)) = (short int)currlen;
else if (cnk->cflags == DP_C_LONG)
*((long int *)(cnk->pnum)) = (long int)currlen;
else if (cnk->cflags == DP_C_LLONG)
*((LLONG *)(cnk->pnum)) = (LLONG)currlen;
else if (cnk->cflags == DP_C_SIZET)
*((ssize_t *)(cnk->pnum)) = (ssize_t)currlen;
else
*((int *)(cnk->pnum)) = (int)currlen;
break;
case CNK_PRCNT:
dopr_outch (buffer, &currlen, maxlen, '%');
break;
default:
/* what ?? */
goto done;
}
cnk = cnk->next;
}
if (maxlen != 0) {
if (currlen < maxlen - 1)
buffer[currlen] = '\0';
else if (maxlen > 0)
buffer[maxlen - 1] = '\0';
}
ret = currlen;
done:
va_end(args);
while (chunks) {
cnk = chunks->next;
free(chunks);
chunks = cnk;
}
if (clist) {
for (pnum = 0; pnum < max_pos; pnum++) {
if (clist[pnum].chunks) free(clist[pnum].chunks);
}
free(clist);
}
return ret;
}
static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
char *value, int flags, int min, int max)
{
int padlen, strln; /* amount to pad */
int cnt = 0;
#ifdef DEBUG_SNPRINTF
printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
#endif
if (value == 0) {
value = "";
}
for (strln = 0; strln < max && value[strln]; ++strln); /* strlen */
padlen = min - strln;
if (padlen < 0)
padlen = 0;
if (flags & DP_F_MINUS)
padlen = -padlen; /* Left Justify */
while (padlen > 0) {
dopr_outch (buffer, currlen, maxlen, ' ');
--padlen;
}
while (*value && (cnt < max)) {
dopr_outch (buffer, currlen, maxlen, *value++);
++cnt;
}
while (padlen < 0) {
dopr_outch (buffer, currlen, maxlen, ' ');
++padlen;
}
}
/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
LLONG value, int base, int min, int max, int flags)
{
int signvalue = 0;
unsigned LLONG uvalue;
char convert[20];
int place = 0;
int spadlen = 0; /* amount to space pad */
int zpadlen = 0; /* amount to zero pad */
int caps = 0;
if (max < 0)
max = 0;
uvalue = value;
if(!(flags & DP_F_UNSIGNED)) {
if( value < 0 ) {
signvalue = '-';
uvalue = -value;
} else {
if (flags & DP_F_PLUS) /* Do a sign (+/i) */
signvalue = '+';
else if (flags & DP_F_SPACE)
signvalue = ' ';
}
}
if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
do {
convert[place++] =
(caps? "0123456789ABCDEF":"0123456789abcdef")
[uvalue % (unsigned)base ];
uvalue = (uvalue / (unsigned)base );
} while(uvalue && (place < 20));
if (place == 20) place--;
convert[place] = 0;
zpadlen = max - place;
spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
if (zpadlen < 0) zpadlen = 0;
if (spadlen < 0) spadlen = 0;
if (flags & DP_F_ZERO) {
zpadlen = MAX(zpadlen, spadlen);
spadlen = 0;
}
if (flags & DP_F_MINUS)
spadlen = -spadlen; /* Left Justifty */
#ifdef DEBUG_SNPRINTF
printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
zpadlen, spadlen, min, max, place);
#endif
/* Spaces */
while (spadlen > 0) {
dopr_outch (buffer, currlen, maxlen, ' ');
--spadlen;
}
/* Sign */
if (signvalue)
dopr_outch (buffer, currlen, maxlen, signvalue);
/* Zeros */
if (zpadlen > 0) {
while (zpadlen > 0) {
dopr_outch (buffer, currlen, maxlen, '0');
--zpadlen;
}
}
/* Digits */
while (place > 0)
dopr_outch (buffer, currlen, maxlen, convert[--place]);
/* Left Justified spaces */
while (spadlen < 0) {
dopr_outch (buffer, currlen, maxlen, ' ');
++spadlen;
}
}
static LDOUBLE abs_val(LDOUBLE value)
{
LDOUBLE result = value;
if (value < 0)
result = -value;
return result;
}
static LDOUBLE POW10(int exp)
{
LDOUBLE result = 1;
while (exp) {
result *= 10;
exp--;
}
return result;
}
static LLONG ROUND(LDOUBLE value)
{
LLONG intpart;
intpart = (LLONG)value;
value = value - intpart;
if (value >= 0.5) intpart++;
return intpart;
}
/* a replacement for modf that doesn't need the math library. Should
be portable, but slow */
static double my_modf(double x0, double *iptr)
{
int i;
LLONG l=0;
double x = x0;
double f = 1.0;
for (i=0;i<100;i++) {
l = (long)x;
if (l <= (x+1) && l >= (x-1)) break;
x *= 0.1;
f *= 10.0;
}
if (i == 100) {
/* yikes! the number is beyond what we can handle. What do we do? */
(*iptr) = 0;
return 0;
}
if (i != 0) {
double i2;
double ret;
ret = my_modf(x0-l*f, &i2);
(*iptr) = l*f + i2;
return ret;
}
(*iptr) = l;
return x - (*iptr);
}
static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
LDOUBLE fvalue, int min, int max, int flags)
{
int signvalue = 0;
double ufvalue;
char iconvert[311];
char fconvert[311];
int iplace = 0;
int fplace = 0;
int padlen = 0; /* amount to pad */
int zpadlen = 0;
int caps = 0;
int idx;
double intpart;
double fracpart;
double temp;
/*
* AIX manpage says the default is 0, but Solaris says the default
* is 6, and sprintf on AIX defaults to 6
*/
if (max < 0)
max = 6;
ufvalue = abs_val (fvalue);
if (fvalue < 0) {
signvalue = '-';
} else {
if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
signvalue = '+';
} else {
if (flags & DP_F_SPACE)
signvalue = ' ';
}
}
#if 0
if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
#endif
#if 0
if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
#endif
/*
* Sorry, we only support 9 digits past the decimal because of our
* conversion method
*/
if (max > 9)
max = 9;
/* We "cheat" by converting the fractional part to integer by
* multiplying by a factor of 10
*/
temp = ufvalue;
my_modf(temp, &intpart);
fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
if (fracpart >= POW10(max)) {
intpart++;
fracpart -= POW10(max);
}
/* Convert integer part */
do {
temp = intpart*0.1;
my_modf(temp, &intpart);
idx = (int) ((temp -intpart +0.05)* 10.0);
/* idx = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
/* printf ("%llf, %f, %x\n", temp, intpart, idx); */
iconvert[iplace++] =
(caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
} while (intpart && (iplace < 311));
if (iplace == 311) iplace--;
iconvert[iplace] = 0;
/* Convert fractional part */
if (fracpart)
{
do {
temp = fracpart*0.1;
my_modf(temp, &fracpart);
idx = (int) ((temp -fracpart +0.05)* 10.0);
/* idx = (int) ((((temp/10) -fracpart) +0.05) *10); */
/* printf ("%lf, %lf, %ld\n", temp, fracpart, idx ); */
fconvert[fplace++] =
(caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
} while(fracpart && (fplace < 311));
if (fplace == 311) fplace--;
}
fconvert[fplace] = 0;
/* -1 for decimal point, another -1 if we are printing a sign */
padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
zpadlen = max - fplace;
if (zpadlen < 0) zpadlen = 0;
if (padlen < 0)
padlen = 0;
if (flags & DP_F_MINUS)
padlen = -padlen; /* Left Justifty */
if ((flags & DP_F_ZERO) && (padlen > 0)) {
if (signvalue) {
dopr_outch (buffer, currlen, maxlen, signvalue);
--padlen;
signvalue = 0;
}
while (padlen > 0) {
dopr_outch (buffer, currlen, maxlen, '0');
--padlen;
}
}
while (padlen > 0) {
dopr_outch (buffer, currlen, maxlen, ' ');
--padlen;
}
if (signvalue)
dopr_outch (buffer, currlen, maxlen, signvalue);
while (iplace > 0)
dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
#ifdef DEBUG_SNPRINTF
printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
#endif
/*
* Decimal point. This should probably use locale to find the correct
* char to print out.
*/
if (max > 0) {
dopr_outch (buffer, currlen, maxlen, '.');
while (zpadlen > 0) {
dopr_outch (buffer, currlen, maxlen, '0');
--zpadlen;
}
while (fplace > 0)
dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
}
while (padlen < 0) {
dopr_outch (buffer, currlen, maxlen, ' ');
++padlen;
}
}
static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
{
if (*currlen < maxlen) {
buffer[(*currlen)] = c;
}
(*currlen)++;
}
static struct pr_chunk *new_chunk(void) {
struct pr_chunk *new_c = (struct pr_chunk *)malloc(sizeof(struct pr_chunk));
if (!new_c)
return NULL;
new_c->type = 0;
new_c->num = 0;
new_c->min = 0;
new_c->min_star = NULL;
new_c->max = -1;
new_c->max_star = NULL;
new_c->flags = 0;
new_c->cflags = 0;
new_c->start = 0;
new_c->len = 0;
new_c->value = 0;
new_c->fvalue = 0;
new_c->strvalue = NULL;
new_c->pnum = NULL;
new_c->next = NULL;
return new_c;
}
static int add_cnk_list_entry(struct pr_chunk_x **list,
int max_num, struct pr_chunk *chunk) {
struct pr_chunk_x *l;
struct pr_chunk **c;
int max;
int cnum;
int i, pos;
if (chunk->num > max_num) {
max = chunk->num;
if (*list == NULL) {
l = (struct pr_chunk_x *)malloc(sizeof(struct pr_chunk_x) * max);
pos = 0;
} else {
l = (struct pr_chunk_x *)realloc(*list, sizeof(struct pr_chunk_x) * max);
pos = max_num;
}
if (l == NULL) {
for (i = 0; i < max; i++) {
if ((*list)[i].chunks) free((*list)[i].chunks);
}
return 0;
}
for (i = pos; i < max; i++) {
l[i].chunks = NULL;
l[i].num = 0;
}
} else {
l = *list;
max = max_num;
}
i = chunk->num - 1;
cnum = l[i].num + 1;
if (l[i].chunks == NULL) {
c = (struct pr_chunk **)malloc(sizeof(struct pr_chunk *) * cnum);
} else {
c = (struct pr_chunk **)realloc(l[i].chunks, sizeof(struct pr_chunk *) * cnum);
}
if (c == NULL) {
for (i = 0; i < max; i++) {
if (l[i].chunks) free(l[i].chunks);
}
return 0;
}
c[l[i].num] = chunk;
l[i].chunks = c;
l[i].num = cnum;
*list = l;
return max;
}
int rep_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
{
return dopr(str, count, fmt, args);
}
#endif
/* yes this really must be a ||. Don't muck with this (tridge)
*
* The logic for these two is that we need our own definition if the
* OS *either* has no definition of *sprintf, or if it does have one
* that doesn't work properly according to the autoconf test.
*/
#if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
int rep_snprintf(char *str,size_t count,const char *fmt,...)
{
size_t ret;
va_list ap;
va_start(ap, fmt);
ret = vsnprintf(str, count, fmt, ap);
va_end(ap);
return ret;
}
#endif
#ifndef HAVE_C99_VSNPRINTF
int rep_printf(const char *fmt, ...)
{
va_list ap;
int ret;
char *s;
s = NULL;
va_start(ap, fmt);
ret = vasprintf(&s, fmt, ap);
va_end(ap);
if (s) {
fwrite(s, 1, strlen(s), stdout);
}
free(s);
return ret;
}
#endif
#ifndef HAVE_C99_VSNPRINTF
int rep_fprintf(FILE *stream, const char *fmt, ...)
{
va_list ap;
int ret;
char *s;
s = NULL;
va_start(ap, fmt);
ret = vasprintf(&s, fmt, ap);
va_end(ap);
if (s) {
fwrite(s, 1, strlen(s), stream);
}
free(s);
return ret;
}
#endif
#endif
#if !defined(HAVE_VASPRINTF) || !defined(HAVE_C99_VSNPRINTF)
int rep_vasprintf(char **ptr, const char *format, va_list ap)
{
int ret;
va_list ap2;
VA_COPY(ap2, ap);
ret = vsnprintf(NULL, 0, format, ap2);
va_end(ap2);
if (ret < 0) return ret;
(*ptr) = (char *)malloc(ret+1);
if (!*ptr) return -1;
VA_COPY(ap2, ap);
ret = vsnprintf(*ptr, ret+1, format, ap2);
va_end(ap2);
return ret;
}
#endif
#if !defined(HAVE_ASPRINTF) || !defined(HAVE_C99_VSNPRINTF)
int rep_asprintf(char **ptr, const char *format, ...)
{
va_list ap;
int ret;
*ptr = NULL;
va_start(ap, format);
ret = vasprintf(ptr, format, ap);
va_end(ap);
return ret;
}
#endif
#ifdef TEST_SNPRINTF
int sprintf(char *str,const char *fmt,...);
int printf(const char *fmt,...);
int main (void)
{
char buf1[1024];
char buf2[1024];
char *buf3;
char *fp_fmt[] = {
"%1.1f",
"%-1.5f",
"%1.5f",
"%123.9f",
"%10.5f",
"% 10.5f",
"%+22.9f",
"%+4.9f",
"%01.3f",
"%4f",
"%3.1f",
"%3.2f",
"%.0f",
"%f",
"%-8.8f",
"%-9.9f",
NULL
};
double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 203.9, 0.96, 0.996,
0.9996, 1.996, 4.136, 5.030201, 0.00205,
/* END LIST */ 0};
char *int_fmt[] = {
"%-1.5d",
"%1.5d",
"%123.9d",
"%5.5d",
"%10.5d",
"% 10.5d",
"%+22.33d",
"%01.3d",
"%4d",
"%d",
NULL
};
long int_nums[] = { -1, 134, 91340, 341, 0203, 1234567890, 0};
char *str_fmt[] = {
"%10.5s",
"%-10.5s",
"%5.10s",
"%-5.10s",
"%10.1s",
"%0.10s",
"%10.0s",
"%1.10s",
"%s",
"%.1s",
"%.10s",
"%10s",
NULL
};
char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
#ifdef HAVE_LONG_LONG
char *ll_fmt[] = {
"%llu",
NULL
};
LLONG ll_nums[] = { 134, 91340, 341, 0203, 1234567890, 128006186140000000LL, 0};
#endif
int x, y;
int fail = 0;
int num = 0;
int l1, l2;
char *ss_fmt[] = {
"%zd",
"%zu",
NULL
};
size_t ss_nums[] = {134, 91340, 123456789, 0203, 1234567890, 0};
printf ("Testing snprintf format codes against system sprintf...\n");
for (x = 0; fp_fmt[x] ; x++) {
for (y = 0; fp_nums[y] != 0 ; y++) {
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
l2 = sprintf (buf2, fp_fmt[x], fp_nums[y]);
buf1[1023] = buf2[1023] = '\0';
if (strcmp (buf1, buf2) || (l1 != l2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
fp_fmt[x], l1, buf1, l2, buf2);
fail++;
}
num++;
}
}
for (x = 0; int_fmt[x] ; x++) {
for (y = 0; int_nums[y] != 0 ; y++) {
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
l2 = sprintf (buf2, int_fmt[x], int_nums[y]);
buf1[1023] = buf2[1023] = '\0';
if (strcmp (buf1, buf2) || (l1 != l2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
int_fmt[x], l1, buf1, l2, buf2);
fail++;
}
num++;
}
}
for (x = 0; str_fmt[x] ; x++) {
for (y = 0; str_vals[y] != 0 ; y++) {
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
l2 = sprintf (buf2, str_fmt[x], str_vals[y]);
buf1[1023] = buf2[1023] = '\0';
if (strcmp (buf1, buf2) || (l1 != l2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
str_fmt[x], l1, buf1, l2, buf2);
fail++;
}
num++;
}
}
#ifdef HAVE_LONG_LONG
for (x = 0; ll_fmt[x] ; x++) {
for (y = 0; ll_nums[y] != 0 ; y++) {
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), ll_fmt[x], ll_nums[y]);
l2 = sprintf (buf2, ll_fmt[x], ll_nums[y]);
buf1[1023] = buf2[1023] = '\0';
if (strcmp (buf1, buf2) || (l1 != l2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
ll_fmt[x], l1, buf1, l2, buf2);
fail++;
}
num++;
}
}
#endif
#define BUFSZ 2048
buf1[0] = buf2[0] = '\0';
if ((buf3 = malloc(BUFSZ)) == NULL) {
fail++;
} else {
num++;
memset(buf3, 'a', BUFSZ);
snprintf(buf1, sizeof(buf1), "%.*s", 1, buf3);
buf1[1023] = '\0';
if (strcmp(buf1, "a") != 0) {
printf("length limit buf1 '%s' expected 'a'\n", buf1);
fail++;
}
}
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), "%4$*1$d %2$s %3$*1$.*1$f", 3, "pos test", 12.3456, 9);
l2 = sprintf(buf2, "%4$*1$d %2$s %3$*1$.*1$f", 3, "pos test", 12.3456, 9);
buf1[1023] = buf2[1023] = '\0';
if (strcmp(buf1, buf2) || (l1 != l2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
"%4$*1$d %2$s %3$*1$.*1$f", l1, buf1, l2, buf2);
fail++;
}
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), "%4$*4$d %2$s %3$*4$.*4$f", 3, "pos test", 12.3456, 9);
l2 = sprintf(buf2, "%4$*4$d %2$s %3$*4$.*4$f", 3, "pos test", 12.3456, 9);
buf1[1023] = buf2[1023] = '\0';
if (strcmp(buf1, buf2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
"%4$*1$d %2$s %3$*1$.*1$f", l1, buf1, l2, buf2);
fail++;
}
for (x = 0; ss_fmt[x] ; x++) {
for (y = 0; ss_nums[y] != 0 ; y++) {
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), ss_fmt[x], ss_nums[y]);
l2 = sprintf (buf2, ss_fmt[x], ss_nums[y]);
buf1[1023] = buf2[1023] = '\0';
if (strcmp (buf1, buf2) || (l1 != l2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
ss_fmt[x], l1, buf1, l2, buf2);
fail++;
}
num++;
}
}
#if 0
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), "%lld", (LLONG)1234567890);
l2 = sprintf(buf2, "%lld", (LLONG)1234567890);
buf1[1023] = buf2[1023] = '\0';
if (strcmp(buf1, buf2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
"%lld", l1, buf1, l2, buf2);
fail++;
}
buf1[0] = buf2[0] = '\0';
l1 = snprintf(buf1, sizeof(buf1), "%Lf", (LDOUBLE)890.1234567890123);
l2 = sprintf(buf2, "%Lf", (LDOUBLE)890.1234567890123);
buf1[1023] = buf2[1023] = '\0';
if (strcmp(buf1, buf2)) {
printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
"%Lf", l1, buf1, l2, buf2);
fail++;
}
#endif
printf ("%d tests failed out of %d.\n", fail, num);
printf("seeing how many digits we support\n");
{
double v0 = 0.12345678901234567890123456789012345678901;
for (x=0; x<100; x++) {
double p = pow(10, x);
double r = v0*p;
snprintf(buf1, sizeof(buf1), "%1.1f", r);
sprintf(buf2, "%1.1f", r);
if (strcmp(buf1, buf2)) {
printf("we seem to support %d digits\n", x-1);
break;
}
}
}
return 0;
}
#endif /* TEST_SNPRINTF */
tevent-0.9.19/lib/replace/socket.c 0000660 0000000 0000000 00000002307 12153373752 016702 0 ustar root root 0000000 0000000 /*
* Unix SMB/CIFS implementation.
*
* Dummy replacements for socket functions.
*
* Copyright (C) Michael Adam 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library 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 3 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see .
*/
#include "replace.h"
#include "system/network.h"
int rep_connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen)
{
errno = ENOSYS;
return -1;
}
struct hostent *rep_gethostbyname(const char *name)
{
errno = ENOSYS;
return NULL;
}
tevent-0.9.19/lib/replace/socketpair.c 0000660 0000000 0000000 00000002501 11741275274 017554 0 ustar root root 0000000 0000000 /*
* Unix SMB/CIFS implementation.
* replacement routines for broken systems
* Copyright (C) Jelmer Vernooij 2006
* Copyright (C) Michael Adam 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library 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 3 of the License, or (at your option) any later version.
*
* This library 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 library; if not, see .
*/
#include "replace.h"
#include "system/network.h"
int rep_socketpair(int d, int type, int protocol, int sv[2])
{
if (d != AF_UNIX) {
errno = EAFNOSUPPORT;
return -1;
}
if (protocol != 0) {
errno = EPROTONOSUPPORT;
return -1;
}
if (type != SOCK_STREAM) {
errno = EOPNOTSUPP;
return -1;
}
return pipe(sv);
}
tevent-0.9.19/lib/replace/strptime.c 0000660 0000000 0000000 00000056755 12101212317 017257 0 ustar root root 0000000 0000000 /* Convert a string representation of time to a time value.
Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper , 1996.
The GNU C Library 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 3 of the
License, or (at your option) any later version.
The GNU C Library 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
Library General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
see . */
/* XXX This version of the implementation is not really complete.
Some of the fields cannot add information alone. But if seeing
some of them in the same format (such as year, week and weekday)
this is enough information for determining the date. */
#include "replace.h"
#include "system/locale.h"
#include "system/time.h"
#ifndef __P
# if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
# define __P(args) args
# else
# define __P(args) ()
# endif /* GCC. */
#endif /* Not __P. */
#if ! HAVE_LOCALTIME_R && ! defined localtime_r
# ifdef _LIBC
# define localtime_r __localtime_r
# else
/* Approximate localtime_r as best we can in its absence. */
# define localtime_r my_localtime_r
static struct tm *localtime_r __P ((const time_t *, struct tm *));
static struct tm *
localtime_r (t, tp)
const time_t *t;
struct tm *tp;
{
struct tm *l = localtime (t);
if (! l)
return 0;
*tp = *l;
return tp;
}
# endif /* ! _LIBC */
#endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
#define match_char(ch1, ch2) if (ch1 != ch2) return NULL
#if defined __GNUC__ && __GNUC__ >= 2
# define match_string(cs1, s2) \
({ size_t len = strlen (cs1); \
int result = strncasecmp ((cs1), (s2), len) == 0; \
if (result) (s2) += len; \
result; })
#else
/* Oh come on. Get a reasonable compiler. */
# define match_string(cs1, s2) \
(strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
#endif
/* We intentionally do not use isdigit() for testing because this will
lead to problems with the wide character version. */
#define get_number(from, to, n) \
do { \
int __n = n; \
val = 0; \
while (*rp == ' ') \
++rp; \
if (*rp < '0' || *rp > '9') \
return NULL; \
do { \
val *= 10; \
val += *rp++ - '0'; \
} while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \
if (val < from || val > to) \
return NULL; \
} while (0)
#ifdef _NL_CURRENT
# define get_alt_number(from, to, n) \
({ \
__label__ do_normal; \
if (*decided != raw) \
{ \
const char *alts = _NL_CURRENT (LC_TIME, ALT_DIGITS); \
int __n = n; \
int any = 0; \
while (*rp == ' ') \
++rp; \
val = 0; \
do { \
val *= 10; \
while (*alts != '\0') \
{ \
size_t len = strlen (alts); \
if (strncasecmp (alts, rp, len) == 0) \
break; \
alts += len + 1; \
++val; \
} \
if (*alts == '\0') \
{ \
if (*decided == not && ! any) \
goto do_normal; \
/* If we haven't read anything it's an error. */ \
if (! any) \
return NULL; \
/* Correct the premature multiplication. */ \
val /= 10; \
break; \
} \
else \
*decided = loc; \
} while (--__n > 0 && val * 10 <= to); \
if (val < from || val > to) \
return NULL; \
} \
else \
{ \
do_normal: \
get_number (from, to, n); \
} \
0; \
})
#else
# define get_alt_number(from, to, n) \
/* We don't have the alternate representation. */ \
get_number(from, to, n)
#endif
#define recursive(new_fmt) \
(*(new_fmt) != '\0' \
&& (rp = strptime_internal (rp, (new_fmt), tm, decided, era_cnt)) != NULL)
#ifdef _LIBC
/* This is defined in locale/C-time.c in the GNU libc. */
extern const struct locale_data _nl_C_LC_TIME;
extern const unsigned short int __mon_yday[2][13];
# define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)
# define ab_weekday_name \
(&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)
# define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)
# define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)
# define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)
# define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)
# define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)
# define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)
# define HERE_T_FMT_AMPM \
(_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)
# define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)
# define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)
#else
static char const weekday_name[][10] =
{
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
static char const ab_weekday_name[][4] =
{
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static char const month_name[][10] =
{
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
};
static char const ab_month_name[][4] =
{
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
# define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"
# define HERE_D_FMT "%m/%d/%y"
# define HERE_AM_STR "AM"
# define HERE_PM_STR "PM"
# define HERE_T_FMT_AMPM "%I:%M:%S %p"
# define HERE_T_FMT "%H:%M:%S"
static const unsigned short int __mon_yday[2][13] =
{
/* Normal years. */
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
/* Leap years. */
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
};
#endif
/* Status of lookup: do we use the locale data or the raw data? */
enum locale_status { not, loc, raw };
#ifndef __isleap
/* Nonzero if YEAR is a leap year (every 4 years,
except every 100th isn't, and every 400th is). */
# define __isleap(year) \
((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
#endif
/* Compute the day of the week. */
static void
day_of_the_week (struct tm *tm)
{
/* We know that January 1st 1970 was a Thursday (= 4). Compute the
the difference between this data in the one on TM and so determine
the weekday. */
int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
int wday = (-473
+ (365 * (tm->tm_year - 70))
+ (corr_year / 4)
- ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
+ (((corr_year / 4) / 25) / 4)
+ __mon_yday[0][tm->tm_mon]
+ tm->tm_mday - 1);
tm->tm_wday = ((wday % 7) + 7) % 7;
}
/* Compute the day of the year. */
static void
day_of_the_year (struct tm *tm)
{
tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
+ (tm->tm_mday - 1));
}
static char *
#ifdef _LIBC
internal_function
#endif
strptime_internal __P ((const char *rp, const char *fmt, struct tm *tm,
enum locale_status *decided, int era_cnt));
static char *
#ifdef _LIBC
internal_function
#endif
strptime_internal (rp, fmt, tm, decided, era_cnt)
const char *rp;
const char *fmt;
struct tm *tm;
enum locale_status *decided;
int era_cnt;
{
int cnt;
size_t val;
int have_I, is_pm;
int century, want_century;
int want_era;
int have_wday, want_xday;
int have_yday;
int have_mon, have_mday;
#ifdef _NL_CURRENT
const char *rp_backup;
size_t num_eras;
struct era_entry *era;
era = NULL;
#endif
have_I = is_pm = 0;
century = -1;
want_century = 0;
want_era = 0;
have_wday = want_xday = have_yday = have_mon = have_mday = 0;
while (*fmt != '\0')
{
/* A white space in the format string matches 0 more or white
space in the input string. */
if (isspace (*fmt))
{
while (isspace (*rp))
++rp;
++fmt;
continue;
}
/* Any character but `%' must be matched by the same character
in the iput string. */
if (*fmt != '%')
{
match_char (*fmt++, *rp++);
continue;
}
++fmt;
#ifndef _NL_CURRENT
/* We need this for handling the `E' modifier. */
start_over:
#endif
#ifdef _NL_CURRENT
/* Make back up of current processing pointer. */
rp_backup = rp;
#endif
switch (*fmt++)
{
case '%':
/* Match the `%' character itself. */
match_char ('%', *rp++);
break;
case 'a':
case 'A':
/* Match day of week. */
for (cnt = 0; cnt < 7; ++cnt)
{
#ifdef _NL_CURRENT
if (*decided !=raw)
{
if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), rp))
{
if (*decided == not
&& strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),
weekday_name[cnt]))
*decided = loc;
break;
}
if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), rp))
{
if (*decided == not
&& strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),
ab_weekday_name[cnt]))
*decided = loc;
break;
}
}
#endif
if (*decided != loc
&& (match_string (weekday_name[cnt], rp)
|| match_string (ab_weekday_name[cnt], rp)))
{
*decided = raw;
break;
}
}
if (cnt == 7)
/* Does not match a weekday name. */
return NULL;
tm->tm_wday = cnt;
have_wday = 1;
break;
case 'b':
case 'B':
case 'h':
/* Match month name. */
for (cnt = 0; cnt < 12; ++cnt)
{
#ifdef _NL_CURRENT
if (*decided !=raw)
{
if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), rp))
{
if (*decided == not
&& strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),
month_name[cnt]))
*decided = loc;
break;
}
if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), rp))
{
if (*decided == not
&& strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),
ab_month_name[cnt]))
*decided = loc;
break;
}
}
#endif
if (match_string (month_name[cnt], rp)
|| match_string (ab_month_name[cnt], rp))
{
*decided = raw;
break;
}
}
if (cnt == 12)
/* Does not match a month name. */
return NULL;
tm->tm_mon = cnt;
want_xday = 1;
break;
case 'c':
/* Match locale's date and time format. */
#ifdef _NL_CURRENT
if (*decided != raw)
{
if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (*decided == not &&
strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))
*decided = loc;
want_xday = 1;
break;
}
*decided = raw;
}
#endif
if (!recursive (HERE_D_T_FMT))
return NULL;
want_xday = 1;
break;
case 'C':
/* Match century number. */
#ifdef _NL_CURRENT
match_century:
#endif
get_number (0, 99, 2);
century = val;
want_xday = 1;
break;
case 'd':
case 'e':
/* Match day of month. */
get_number (1, 31, 2);
tm->tm_mday = val;
have_mday = 1;
want_xday = 1;
break;
case 'F':
if (!recursive ("%Y-%m-%d"))
return NULL;
want_xday = 1;
break;
case 'x':
#ifdef _NL_CURRENT
if (*decided != raw)
{
if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (*decided == not
&& strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))
*decided = loc;
want_xday = 1;
break;
}
*decided = raw;
}
#endif
/* Fall through. */
case 'D':
/* Match standard day format. */
if (!recursive (HERE_D_FMT))
return NULL;
want_xday = 1;
break;
case 'k':
case 'H':
/* Match hour in 24-hour clock. */
get_number (0, 23, 2);
tm->tm_hour = val;
have_I = 0;
break;
case 'I':
/* Match hour in 12-hour clock. */
get_number (1, 12, 2);
tm->tm_hour = val % 12;
have_I = 1;
break;
case 'j':
/* Match day number of year. */
get_number (1, 366, 3);
tm->tm_yday = val - 1;
have_yday = 1;
break;
case 'm':
/* Match number of month. */
get_number (1, 12, 2);
tm->tm_mon = val - 1;
have_mon = 1;
want_xday = 1;
break;
case 'M':
/* Match minute. */
get_number (0, 59, 2);
tm->tm_min = val;
break;
case 'n':
case 't':
/* Match any white space. */
while (isspace (*rp))
++rp;
break;
case 'p':
/* Match locale's equivalent of AM/PM. */
#ifdef _NL_CURRENT
if (*decided != raw)
{
if (match_string (_NL_CURRENT (LC_TIME, AM_STR), rp))
{
if (strcmp (_NL_CURRENT (LC_TIME, AM_STR), HERE_AM_STR))
*decided = loc;
break;
}
if (match_string (_NL_CURRENT (LC_TIME, PM_STR), rp))
{
if (strcmp (_NL_CURRENT (LC_TIME, PM_STR), HERE_PM_STR))
*decided = loc;
is_pm = 1;
break;
}
*decided = raw;
}
#endif
if (!match_string (HERE_AM_STR, rp)) {
if (match_string (HERE_PM_STR, rp)) {
is_pm = 1;
} else {
return NULL;
}
}
break;
case 'r':
#ifdef _NL_CURRENT
if (*decided != raw)
{
if (!recursive (_NL_CURRENT (LC_TIME, T_FMT_AMPM)))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (*decided == not &&
strcmp (_NL_CURRENT (LC_TIME, T_FMT_AMPM),
HERE_T_FMT_AMPM))
*decided = loc;
break;
}
*decided = raw;
}
#endif
if (!recursive (HERE_T_FMT_AMPM))
return NULL;
break;
case 'R':
if (!recursive ("%H:%M"))
return NULL;
break;
case 's':
{
/* The number of seconds may be very high so we cannot use
the `get_number' macro. Instead read the number
character for character and construct the result while
doing this. */
time_t secs = 0;
if (*rp < '0' || *rp > '9')
/* We need at least one digit. */
return NULL;
do
{
secs *= 10;
secs += *rp++ - '0';
}
while (*rp >= '0' && *rp <= '9');
if (localtime_r (&secs, tm) == NULL)
/* Error in function. */
return NULL;
}
break;
case 'S':
get_number (0, 61, 2);
tm->tm_sec = val;
break;
case 'X':
#ifdef _NL_CURRENT
if (*decided != raw)
{
if (!recursive (_NL_CURRENT (LC_TIME, T_FMT)))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (strcmp (_NL_CURRENT (LC_TIME, T_FMT), HERE_T_FMT))
*decided = loc;
break;
}
*decided = raw;
}
#endif
/* Fall through. */
case 'T':
if (!recursive (HERE_T_FMT))
return NULL;
break;
case 'u':
get_number (1, 7, 1);
tm->tm_wday = val % 7;
have_wday = 1;
break;
case 'g':
get_number (0, 99, 2);
/* XXX This cannot determine any field in TM. */
break;
case 'G':
if (*rp < '0' || *rp > '9')
return NULL;
/* XXX Ignore the number since we would need some more
information to compute a real date. */
do
++rp;
while (*rp >= '0' && *rp <= '9');
break;
case 'U':
case 'V':
case 'W':
get_number (0, 53, 2);
/* XXX This cannot determine any field in TM without some
information. */
break;
case 'w':
/* Match number of weekday. */
get_number (0, 6, 1);
tm->tm_wday = val;
have_wday = 1;
break;
case 'y':
#ifdef _NL_CURRENT
match_year_in_century:
#endif
/* Match year within century. */
get_number (0, 99, 2);
/* The "Year 2000: The Millennium Rollover" paper suggests that
values in the range 69-99 refer to the twentieth century. */
tm->tm_year = val >= 69 ? val : val + 100;
/* Indicate that we want to use the century, if specified. */
want_century = 1;
want_xday = 1;
break;
case 'Y':
/* Match year including century number. */
get_number (0, 9999, 4);
tm->tm_year = val - 1900;
want_century = 0;
want_xday = 1;
break;
case 'Z':
/* XXX How to handle this? */
break;
case 'E':
#ifdef _NL_CURRENT
switch (*fmt++)
{
case 'c':
/* Match locale's alternate date and time format. */
if (*decided != raw)
{
const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT);
if (*fmt == '\0')
fmt = _NL_CURRENT (LC_TIME, D_T_FMT);
if (!recursive (fmt))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (strcmp (fmt, HERE_D_T_FMT))
*decided = loc;
want_xday = 1;
break;
}
*decided = raw;
}
/* The C locale has no era information, so use the
normal representation. */
if (!recursive (HERE_D_T_FMT))
return NULL;
want_xday = 1;
break;
case 'C':
if (*decided != raw)
{
if (era_cnt >= 0)
{
era = _nl_select_era_entry (era_cnt);
if (match_string (era->era_name, rp))
{
*decided = loc;
break;
}
else
return NULL;
}
else
{
num_eras = _NL_CURRENT_WORD (LC_TIME,
_NL_TIME_ERA_NUM_ENTRIES);
for (era_cnt = 0; era_cnt < (int) num_eras;
++era_cnt, rp = rp_backup)
{
era = _nl_select_era_entry (era_cnt);
if (match_string (era->era_name, rp))
{
*decided = loc;
break;
}
}
if (era_cnt == (int) num_eras)
{
era_cnt = -1;
if (*decided == loc)
return NULL;
}
else
break;
}
*decided = raw;
}
/* The C locale has no era information, so use the
normal representation. */
goto match_century;
case 'y':
if (*decided == raw)
goto match_year_in_century;
get_number(0, 9999, 4);
tm->tm_year = val;
want_era = 1;
want_xday = 1;
break;
case 'Y':
if (*decided != raw)
{
num_eras = _NL_CURRENT_WORD (LC_TIME,
_NL_TIME_ERA_NUM_ENTRIES);
for (era_cnt = 0; era_cnt < (int) num_eras;
++era_cnt, rp = rp_backup)
{
era = _nl_select_era_entry (era_cnt);
if (recursive (era->era_format))
break;
}
if (era_cnt == (int) num_eras)
{
era_cnt = -1;
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
*decided = loc;
era_cnt = -1;
break;
}
*decided = raw;
}
get_number (0, 9999, 4);
tm->tm_year = val - 1900;
want_century = 0;
want_xday = 1;
break;
case 'x':
if (*decided != raw)
{
const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_FMT);
if (*fmt == '\0')
fmt = _NL_CURRENT (LC_TIME, D_FMT);
if (!recursive (fmt))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (strcmp (fmt, HERE_D_FMT))
*decided = loc;
break;
}
*decided = raw;
}
if (!recursive (HERE_D_FMT))
return NULL;
break;
case 'X':
if (*decided != raw)
{
const char *fmt = _NL_CURRENT (LC_TIME, ERA_T_FMT);
if (*fmt == '\0')
fmt = _NL_CURRENT (LC_TIME, T_FMT);
if (!recursive (fmt))
{
if (*decided == loc)
return NULL;
else
rp = rp_backup;
}
else
{
if (strcmp (fmt, HERE_T_FMT))
*decided = loc;
break;
}
*decided = raw;
}
if (!recursive (HERE_T_FMT))
return NULL;
break;
default:
return NULL;
}
break;
#else
/* We have no information about the era format. Just use
the normal format. */
if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y'
&& *fmt != 'x' && *fmt != 'X')
/* This is an illegal format. */
return NULL;
goto start_over;
#endif
case 'O':
switch (*fmt++)
{
case 'd':
case 'e':
/* Match day of month using alternate numeric symbols. */
get_alt_number (1, 31, 2);
tm->tm_mday = val;
have_mday = 1;
want_xday = 1;
break;
case 'H':
/* Match hour in 24-hour clock using alternate numeric
symbols. */
get_alt_number (0, 23, 2);
tm->tm_hour = val;
have_I = 0;
break;
case 'I':
/* Match hour in 12-hour clock using alternate numeric
symbols. */
get_alt_number (1, 12, 2);
tm->tm_hour = val - 1;
have_I = 1;
break;
case 'm':
/* Match month using alternate numeric symbols. */
get_alt_number (1, 12, 2);
tm->tm_mon = val - 1;
have_mon = 1;
want_xday = 1;
break;
case 'M':
/* Match minutes using alternate numeric symbols. */
get_alt_number (0, 59, 2);
tm->tm_min = val;
break;
case 'S':
/* Match seconds using alternate numeric symbols. */
get_alt_number (0, 61, 2);
tm->tm_sec = val;
break;
case 'U':
case 'V':
case 'W':
get_alt_number (0, 53, 2);
/* XXX This cannot determine any field in TM without
further information. */
break;
case 'w':
/* Match number of weekday using alternate numeric symbols. */
get_alt_number (0, 6, 1);
tm->tm_wday = val;
have_wday = 1;
break;
case 'y':
/* Match year within century using alternate numeric symbols. */
get_alt_number (0, 99, 2);
tm->tm_year = val >= 69 ? val : val + 100;
want_xday = 1;
break;
default:
return NULL;
}
break;
default:
return NULL;
}
}
if (have_I && is_pm)
tm->tm_hour += 12;
if (century != -1)
{
if (want_century)
tm->tm_year = tm->tm_year % 100 + (century - 19) * 100;
else
/* Only the century, but not the year. Strange, but so be it. */
tm->tm_year = (century - 19) * 100;
}
#ifdef _NL_CURRENT
if (era_cnt != -1)
{
era = _nl_select_era_entry(era_cnt);
if (want_era)
tm->tm_year = (era->start_date[0]
+ ((tm->tm_year - era->offset)
* era->absolute_direction));
else
/* Era start year assumed. */
tm->tm_year = era->start_date[0];
}
else
#endif
if (want_era)
return NULL;
if (want_xday && !have_wday)
{
if ( !(have_mon && have_mday) && have_yday)
{
/* We don't have tm_mon and/or tm_mday, compute them. */
int t_mon = 0;
while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
t_mon++;
if (!have_mon)
tm->tm_mon = t_mon - 1;
if (!have_mday)
tm->tm_mday =
(tm->tm_yday
- __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
}
day_of_the_week (tm);
}
if (want_xday && !have_yday)
day_of_the_year (tm);
return discard_const_p(char, rp);
}
char *rep_strptime(const char *buf, const char *format, struct tm *tm)
{
enum locale_status decided;
#ifdef _NL_CURRENT
decided = not;
#else
decided = raw;
#endif
return strptime_internal (buf, format, tm, &decided, -1);
}
tevent-0.9.19/lib/replace/system/README 0000660 0000000 0000000 00000000362 11741275274 017453 0 ustar root root 0000000 0000000 This directory contains wrappers around logical groups of system
include files. The idea is to avoid #ifdef blocks in the main code,
and instead put all the necessary conditional includes in subsystem
specific header files in this directory.
tevent-0.9.19/lib/replace/system/aio.h 0000660 0000000 0000000 00000002014 11741275274 017510 0 ustar root root 0000000 0000000 #ifndef _system_aio_h
#define _system_aio_h
/*
Unix SMB/CIFS implementation.
AIO system include wrappers
Copyright (C) Andrew Tridgell 2006
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_LIBAIO_H
#include
#endif
#endif
tevent-0.9.19/lib/replace/system/capability.h 0000660 0000000 0000000 00000003160 11741275274 021064 0 ustar root root 0000000 0000000 #ifndef _system_capability_h
#define _system_capability_h
/*
Unix SMB/CIFS implementation.
capability system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_SYS_CAPABILITY_H
#if defined(BROKEN_REDHAT_7_SYSTEM_HEADERS) && !defined(_I386_STATFS_H) && !defined(_PPC_STATFS_H)
#define _I386_STATFS_H
#define _PPC_STATFS_H
#define BROKEN_REDHAT_7_STATFS_WORKAROUND
#endif
#if defined(BROKEN_RHEL5_SYS_CAP_HEADER) && !defined(_LINUX_TYPES_H)
#define BROKEN_RHEL5_SYS_CAP_HEADER_WORKAROUND
#endif
#include
#ifdef BROKEN_RHEL5_SYS_CAP_HEADER_WORKAROUND
#undef _LINUX_TYPES_H
#undef BROKEN_RHEL5_SYS_CAP_HEADER_WORKAROUND
#endif
#ifdef BROKEN_REDHAT_7_STATFS_WORKAROUND
#undef _PPC_STATFS_H
#undef _I386_STATFS_H
#undef BROKEN_REDHAT_7_STATFS_WORKAROUND
#endif
#endif
#endif
tevent-0.9.19/lib/replace/system/dir.h 0000660 0000000 0000000 00000003440 11741275274 017522 0 ustar root root 0000000 0000000 #ifndef _system_dir_h
#define _system_dir_h
/*
Unix SMB/CIFS implementation.
directory system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#if HAVE_DIRENT_H
# include
# define NAMLEN(dirent) strlen((dirent)->d_name)
#else
# define dirent direct
# define NAMLEN(dirent) (dirent)->d_namlen
# if HAVE_SYS_NDIR_H
# include
# endif
# if HAVE_SYS_DIR_H
# include
# endif
# if HAVE_NDIR_H
# include
# endif
#endif
#ifndef HAVE_MKDIR_MODE
#define mkdir(dir, mode) mkdir(dir)
#endif
/* Test whether a file name is the "." or ".." directory entries.
* These really should be inline functions.
*/
#ifndef ISDOT
#define ISDOT(path) ( \
*((const char *)(path)) == '.' && \
*(((const char *)(path)) + 1) == '\0' \
)
#endif
#ifndef ISDOTDOT
#define ISDOTDOT(path) ( \
*((const char *)(path)) == '.' && \
*(((const char *)(path)) + 1) == '.' && \
*(((const char *)(path)) + 2) == '\0' \
)
#endif
#endif
tevent-0.9.19/lib/replace/system/filesys.h 0000660 0000000 0000000 00000015304 12101212317 020400 0 ustar root root 0000000 0000000 #ifndef _system_filesys_h
#define _system_filesys_h
/*
Unix SMB/CIFS implementation.
filesystem system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#include
#include
#ifdef HAVE_SYS_PARAM_H
#include
#endif
#ifdef HAVE_SYS_MOUNT_H
#include
#endif
#ifdef HAVE_MNTENT_H
#include
#endif
#ifdef HAVE_SYS_VFS_H
#include
#endif
#ifdef HAVE_SYS_ACL_H
#include
#endif
#ifdef HAVE_ACL_LIBACL_H
#include
#endif
#ifdef HAVE_SYS_FS_S5PARAM_H
#include
#endif
#if defined (HAVE_SYS_FILSYS_H) && !defined (_CRAY)
#include
#endif
#ifdef HAVE_SYS_STATFS_H
# include
#endif
#ifdef HAVE_DUSTAT_H
#include
#endif
#ifdef HAVE_SYS_STATVFS_H
#include
#endif
#ifdef HAVE_SYS_FILIO_H
#include
#endif
#ifdef HAVE_SYS_FILE_H
#include
#endif
#ifdef HAVE_FCNTL_H
#include
#else
#ifdef HAVE_SYS_FCNTL_H
#include
#endif
#endif
#ifdef HAVE_SYS_MODE_H
/* apparently AIX needs this for S_ISLNK */
#ifndef S_ISLNK
#include
#endif
#endif
#ifdef HAVE_SYS_IOCTL_H
#include
#endif
#ifdef HAVE_SYS_UIO_H
#include
#endif
/*
* Veritas File System. Often in addition to native.
* Quotas different.
*/
#if defined(HAVE_SYS_FS_VX_QUOTA_H)
#define VXFS_QUOTA
#endif
#if HAVE_SYS_ATTRIBUTES_H
#include
#elif HAVE_ATTR_ATTRIBUTES_H
#include
#endif
/* mutually exclusive (SuSE 8.2) */
#if HAVE_ATTR_XATTR_H
#include
#elif HAVE_SYS_XATTR_H
#include
#endif
#ifdef HAVE_SYS_EA_H
#include
#endif
#ifdef HAVE_SYS_EXTATTR_H
#include
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include
#endif
#ifndef XATTR_CREATE
#define XATTR_CREATE 0x1 /* set value, fail if attr already exists */
#endif
#ifndef XATTR_REPLACE
#define XATTR_REPLACE 0x2 /* set value, fail if attr does not exist */
#endif
/* Some POSIX definitions for those without */
#ifndef S_IFDIR
#define S_IFDIR 0x4000
#endif
#ifndef S_ISDIR
#define S_ISDIR(mode) ((mode & 0xF000) == S_IFDIR)
#endif
#ifndef S_IRWXU
#define S_IRWXU 00700 /* read, write, execute: owner */
#endif
#ifndef S_IRUSR
#define S_IRUSR 00400 /* read permission: owner */
#endif
#ifndef S_IWUSR
#define S_IWUSR 00200 /* write permission: owner */
#endif
#ifndef S_IXUSR
#define S_IXUSR 00100 /* execute permission: owner */
#endif
#ifndef S_IRWXG
#define S_IRWXG 00070 /* read, write, execute: group */
#endif
#ifndef S_IRGRP
#define S_IRGRP 00040 /* read permission: group */
#endif
#ifndef S_IWGRP
#define S_IWGRP 00020 /* write permission: group */
#endif
#ifndef S_IXGRP
#define S_IXGRP 00010 /* execute permission: group */
#endif
#ifndef S_IRWXO
#define S_IRWXO 00007 /* read, write, execute: other */
#endif
#ifndef S_IROTH
#define S_IROTH 00004 /* read permission: other */
#endif
#ifndef S_IWOTH
#define S_IWOTH 00002 /* write permission: other */
#endif
#ifndef S_IXOTH
#define S_IXOTH 00001 /* execute permission: other */
#endif
#ifndef O_ACCMODE
#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
#endif
#ifndef MAXPATHLEN
#define MAXPATHLEN 256
#endif
#ifndef SEEK_SET
#define SEEK_SET 0
#endif
#ifdef _WIN32
#define mkdir(d,m) _mkdir(d)
#endif
#ifdef UID_WRAPPER
# ifndef UID_WRAPPER_DISABLE
# ifndef UID_WRAPPER_NOT_REPLACE
# define UID_WRAPPER_REPLACE
# endif /* UID_WRAPPER_NOT_REPLACE */
# include "../uid_wrapper/uid_wrapper.h"
# endif /* UID_WRAPPER_DISABLE */
#else /* UID_WRAPPER */
# define uwrap_enabled() 0
#endif /* UID_WRAPPER */
/*
this allows us to use a uniform error handling for our xattr
wrappers
*/
#ifndef ENOATTR
#define ENOATTR ENODATA
#endif
#if !defined(HAVE_GETXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
ssize_t rep_getxattr (const char *path, const char *name, void *value, size_t size);
#define getxattr(path, name, value, size) rep_getxattr(path, name, value, size)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_FGETXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
ssize_t rep_fgetxattr (int filedes, const char *name, void *value, size_t size);
#define fgetxattr(filedes, name, value, size) rep_fgetxattr(filedes, name, value, size)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_LISTXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
ssize_t rep_listxattr (const char *path, char *list, size_t size);
#define listxattr(path, list, size) rep_listxattr(path, list, size)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_FLISTXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
ssize_t rep_flistxattr (int filedes, char *list, size_t size);
#define flistxattr(filedes, value, size) rep_flistxattr(filedes, value, size)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_REMOVEXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
int rep_removexattr (const char *path, const char *name);
#define removexattr(path, name) rep_removexattr(path, name)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_FREMOVEXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
int rep_fremovexattr (int filedes, const char *name);
#define fremovexattr(filedes, name) rep_fremovexattr(filedes, name)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_SETXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
int rep_setxattr (const char *path, const char *name, const void *value, size_t size, int flags);
#define setxattr(path, name, value, size, flags) rep_setxattr(path, name, value, size, flags)
/* define is in "replace.h" */
#endif
#if !defined(HAVE_FSETXATTR) || defined(XATTR_ADDITIONAL_OPTIONS)
int rep_fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags);
#define fsetxattr(filedes, name, value, size, flags) rep_fsetxattr(filedes, name, value, size, flags)
/* define is in "replace.h" */
#endif
#endif
tevent-0.9.19/lib/replace/system/glob.h 0000660 0000000 0000000 00000002077 11741275274 017674 0 ustar root root 0000000 0000000 #ifndef _system_glob_h
#define _system_glob_h
/*
Unix SMB/CIFS implementation.
glob system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_GLOB_H
#include
#endif
#ifdef HAVE_FNMATCH_H
#include
#endif
#endif
tevent-0.9.19/lib/replace/system/gssapi.h 0000660 0000000 0000000 00000002653 12101212317 020213 0 ustar root root 0000000 0000000 #ifndef _system_gssapi_h
#define _system_gssapi_h
/*
Unix SMB/CIFS implementation.
GSSAPI system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_GSSAPI
#ifdef HAVE_GSSAPI_GSSAPI_EXT_H
#include
#elif HAVE_GSSAPI_GSSAPI_H
#include
#elif HAVE_GSSAPI_GSSAPI_GENERIC_H
#include
#elif HAVE_GSSAPI_H
#include
#endif
#if HAVE_GSSAPI_GSSAPI_KRB5_H
#include
#endif
#if HAVE_GSSAPI_GSSAPI_SPNEGO_H
#include
#elif HAVE_GSSAPI_SPNEGO_H
#include
#endif
#endif
#endif
tevent-0.9.19/lib/replace/system/iconv.h 0000660 0000000 0000000 00000003046 11741275274 020064 0 ustar root root 0000000 0000000 #ifndef _system_iconv_h
#define _system_iconv_h
/*
Unix SMB/CIFS implementation.
iconv memory system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#if !defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
#define HAVE_ICONV
#endif
#if !defined(HAVE_GICONV) && defined(HAVE_GICONV_H)
#define HAVE_GICONV
#endif
#if !defined(HAVE_BICONV) && defined(HAVE_BICONV_H)
#define HAVE_BICONV
#endif
#ifdef HAVE_NATIVE_ICONV
#if defined(HAVE_ICONV)
#include
#elif defined(HAVE_GICONV)
#include
#elif defined(HAVE_BICONV)
#include
#endif
#endif /* HAVE_NATIVE_ICONV */
/* needed for some systems without iconv. Doesn't really matter
what error code we use */
#ifndef EILSEQ
#define EILSEQ EIO
#endif
#endif
tevent-0.9.19/lib/replace/system/kerberos.h 0000660 0000000 0000000 00000002131 12101212317 020530 0 ustar root root 0000000 0000000 #ifndef _system_kerberos_h
#define _system_kerberos_h
/*
Unix SMB/CIFS implementation.
kerberos system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_KRB5
#if HAVE_KRB5_H
#include
#endif
#if HAVE_COM_ERR_H
#include
#endif
#endif
#endif
tevent-0.9.19/lib/replace/system/locale.h 0000660 0000000 0000000 00000002164 11741275274 020205 0 ustar root root 0000000 0000000 #ifndef _system_locale_h
#define _system_locale_h
/*
Unix SMB/CIFS implementation.
locale include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_CTYPE_H
#include
#endif
#ifdef HAVE_LOCALE_H
#include
#endif
#ifdef HAVE_LANGINFO_H
#include
#endif
#endif
tevent-0.9.19/lib/replace/system/network.h 0000660 0000000 0000000 00000020251 12101212317 020410 0 ustar root root 0000000 0000000 #ifndef _system_network_h
#define _system_network_h
/*
Unix SMB/CIFS implementation.
networking system include wrappers
Copyright (C) Andrew Tridgell 2004
Copyright (C) Jelmer Vernooij 2007
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifndef LIBREPLACE_NETWORK_CHECKS
#error "AC_LIBREPLACE_NETWORK_CHECKS missing in configure"
#endif
#include
#ifdef HAVE_SYS_SOCKET_H
#include
#endif
#ifdef HAVE_UNIXSOCKET
#include
#endif
#ifdef HAVE_NETINET_IN_H
#include
#endif
#ifdef HAVE_ARPA_INET_H
#include
#endif
#ifdef HAVE_NETDB_H
#include
#endif
#ifdef HAVE_NETINET_TCP_H
#include
#endif
/*
* The next three defines are needed to access the IPTOS_* options
* on some systems.
*/
#ifdef HAVE_NETINET_IN_SYSTM_H
#include
#endif
#ifdef HAVE_NETINET_IN_IP_H
#include
#endif
#ifdef HAVE_NETINET_IP_H
#include
#endif
#ifdef HAVE_NET_IF_H
#include
#endif
#ifdef HAVE_UNISTD_H
#include
#endif
#ifdef HAVE_SYS_IOCTL_H
#include
#endif
#ifdef HAVE_SYS_UIO_H
#include
#endif
#ifdef HAVE_STROPTS_H
#include
#endif
#ifndef HAVE_SOCKLEN_T
#define HAVE_SOCKLEN_T
typedef int socklen_t;
#endif
#if !defined (HAVE_INET_NTOA) || defined(REPLACE_INET_NTOA)
/* define is in "replace.h" */
char *rep_inet_ntoa(struct in_addr ip);
#endif
#ifndef HAVE_INET_PTON
/* define is in "replace.h" */
int rep_inet_pton(int af, const char *src, void *dst);
#endif
#ifndef HAVE_INET_NTOP
/* define is in "replace.h" */
const char *rep_inet_ntop(int af, const void *src, char *dst, socklen_t size);
#endif
#ifndef HAVE_INET_ATON
/* define is in "replace.h" */
int rep_inet_aton(const char *src, struct in_addr *dst);
#endif
#ifndef HAVE_CONNECT
/* define is in "replace.h" */
int rep_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
#endif
#ifndef HAVE_GETHOSTBYNAME
/* define is in "replace.h" */
struct hostent *rep_gethostbyname(const char *name);
#endif
#ifdef HAVE_IFADDRS_H
#include
#endif
#ifndef HAVE_STRUCT_IFADDRS
struct ifaddrs {
struct ifaddrs *ifa_next; /* Pointer to next struct */
char *ifa_name; /* Interface name */
unsigned int ifa_flags; /* Interface flags */
struct sockaddr *ifa_addr; /* Interface address */
struct sockaddr *ifa_netmask; /* Interface netmask */
#undef ifa_dstaddr
struct sockaddr *ifa_dstaddr; /* P2P interface destination */
void *ifa_data; /* Address specific data */
};
#endif
#ifndef HAVE_GETIFADDRS
int rep_getifaddrs(struct ifaddrs **);
#endif
#ifndef HAVE_FREEIFADDRS
void rep_freeifaddrs(struct ifaddrs *);
#endif
#ifndef HAVE_SOCKETPAIR
/* define is in "replace.h" */
int rep_socketpair(int d, int type, int protocol, int sv[2]);
#endif
/*
* Some systems have getaddrinfo but not the
* defines needed to use it.
*/
/* Various macros that ought to be in , but might not be */
#ifndef EAI_FAIL
#define EAI_BADFLAGS (-1)
#define EAI_NONAME (-2)
#define EAI_AGAIN (-3)
#define EAI_FAIL (-4)
#define EAI_FAMILY (-6)
#define EAI_SOCKTYPE (-7)
#define EAI_SERVICE (-8)
#define EAI_MEMORY (-10)
#define EAI_SYSTEM (-11)
#endif /* !EAI_FAIL */
#ifndef AI_PASSIVE
#define AI_PASSIVE 0x0001
#endif
#ifndef AI_CANONNAME
#define AI_CANONNAME 0x0002
#endif
#ifndef AI_NUMERICHOST
/*
* some platforms don't support AI_NUMERICHOST; define as zero if using
* the system version of getaddrinfo...
*/
#if defined(HAVE_STRUCT_ADDRINFO) && defined(HAVE_GETADDRINFO)
#define AI_NUMERICHOST 0
#else
#define AI_NUMERICHOST 0x0004
#endif
#endif
/*
* Some of the functions in source3/lib/util_sock.c use AI_ADDRCONFIG. On QNX
* 6.3.0, this macro is defined but, if it's used, getaddrinfo will fail. This
* prevents smbd from opening any sockets.
*
* If I undefine AI_ADDRCONFIG on such systems and define it to be 0,
* this works around the issue.
*/
#ifdef __QNX__
#include
#if _NTO_VERSION == 630
#undef AI_ADDRCONFIG
#endif
#endif
#ifndef AI_ADDRCONFIG
/*
* logic copied from AI_NUMERICHOST
*/
#if defined(HAVE_STRUCT_ADDRINFO) && defined(HAVE_GETADDRINFO)
#define AI_ADDRCONFIG 0
#else
#define AI_ADDRCONFIG 0x0020
#endif
#endif
#ifndef AI_NUMERICSERV
/*
* logic copied from AI_NUMERICHOST
*/
#if defined(HAVE_STRUCT_ADDRINFO) && defined(HAVE_GETADDRINFO)
#define AI_NUMERICSERV 0
#else
#define AI_NUMERICSERV 0x0400
#endif
#endif
#ifndef NI_NUMERICHOST
#define NI_NUMERICHOST 1
#endif
#ifndef NI_NUMERICSERV
#define NI_NUMERICSERV 2
#endif
#ifndef NI_NOFQDN
#define NI_NOFQDN 4
#endif
#ifndef NI_NAMEREQD
#define NI_NAMEREQD 8
#endif
#ifndef NI_DGRAM
#define NI_DGRAM 16
#endif
#ifndef NI_MAXHOST
#define NI_MAXHOST 1025
#endif
#ifndef NI_MAXSERV
#define NI_MAXSERV 32
#endif
/*
* glibc on linux doesn't seem to have MSG_WAITALL
* defined. I think the kernel has it though..
*/
#ifndef MSG_WAITALL
#define MSG_WAITALL 0
#endif
#ifndef INADDR_LOOPBACK
#define INADDR_LOOPBACK 0x7f000001
#endif
#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif
#ifndef EAFNOSUPPORT
#define EAFNOSUPPORT EINVAL
#endif
#ifndef INET_ADDRSTRLEN
#define INET_ADDRSTRLEN 16
#endif
#ifndef INET6_ADDRSTRLEN
#define INET6_ADDRSTRLEN 46
#endif
#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 255
#endif
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN HOST_NAME_MAX
#endif
#ifndef HAVE_SA_FAMILY_T
#define HAVE_SA_FAMILY_T
typedef unsigned short int sa_family_t;
#endif
#ifndef HAVE_STRUCT_SOCKADDR_STORAGE
#define HAVE_STRUCT_SOCKADDR_STORAGE
#ifdef HAVE_STRUCT_SOCKADDR_IN6
#define sockaddr_storage sockaddr_in6
#define ss_family sin6_family
#define HAVE_SS_FAMILY 1
#else /*HAVE_STRUCT_SOCKADDR_IN6*/
#define sockaddr_storage sockaddr_in
#define ss_family sin_family
#define HAVE_SS_FAMILY 1
#endif /*HAVE_STRUCT_SOCKADDR_IN6*/
#endif /*HAVE_STRUCT_SOCKADDR_STORAGE*/
#ifndef HAVE_SS_FAMILY
#ifdef HAVE___SS_FAMILY
#define ss_family __ss_family
#define HAVE_SS_FAMILY 1
#endif
#endif
#ifndef IOV_MAX
# ifdef UIO_MAXIOV
# define IOV_MAX UIO_MAXIOV
# else
# ifdef __sgi
/*
* IRIX 6.5 has sysconf(_SC_IOV_MAX)
* which might return 512 or bigger
*/
# define IOV_MAX 512
# endif
# endif
#endif
#ifndef HAVE_STRUCT_ADDRINFO
#define HAVE_STRUCT_ADDRINFO
struct addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
#endif /* HAVE_STRUCT_ADDRINFO */
#if !defined(HAVE_GETADDRINFO)
#include "getaddrinfo.h"
#endif
/* Needed for some systems that don't define it (Solaris). */
#ifndef ifr_netmask
#define ifr_netmask ifr_addr
#endif
/* Some old Linux systems have broken header files */
#ifdef HAVE_IPV6
#ifdef HAVE_LINUX_IPV6_V6ONLY_26
#define IPV6_V6ONLY 26
#endif /* HAVE_LINUX_IPV6_V6ONLY_26 */
#endif /* HAVE_IPV6 */
#ifdef SOCKET_WRAPPER
#ifndef SOCKET_WRAPPER_DISABLE
#ifndef SOCKET_WRAPPER_NOT_REPLACE
#define SOCKET_WRAPPER_REPLACE
#endif /* SOCKET_WRAPPER_NOT_REPLACE */
#include "../socket_wrapper/socket_wrapper.h"
#endif /* SOCKET_WRAPPER_DISABLE */
#endif /* SOCKET_WRAPPER */
#ifdef UID_WRAPPER
# ifndef UID_WRAPPER_DISABLE
# ifndef UID_WRAPPER_NOT_REPLACE
# define UID_WRAPPER_REPLACE
# endif /* UID_WRAPPER_NOT_REPLACE */
# include "../uid_wrapper/uid_wrapper.h"
# endif /* UID_WRAPPER_DISABLE */
#else /* UID_WRAPPER */
# define uwrap_enabled() 0
#endif /* UID_WRAPPER */
#endif
tevent-0.9.19/lib/replace/system/passwd.h 0000660 0000000 0000000 00000005317 12153373752 020250 0 ustar root root 0000000 0000000 #ifndef _system_passwd_h
#define _system_passwd_h
/*
Unix SMB/CIFS implementation.
passwd system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
/* this needs to be included before nss_wrapper.h on some systems */
#include
#ifdef HAVE_PWD_H
#include
#endif
#ifdef HAVE_GRP_H
#include
#endif
#ifdef HAVE_SYS_PRIV_H
#include
#endif
#ifdef HAVE_SYS_ID_H
#include
#endif
#ifdef HAVE_CRYPT_H
#include
#endif
#ifdef HAVE_SHADOW_H
#include
#endif
#ifdef HAVE_SYS_SECURITY_H
#include
#include
#define PASSWORD_LENGTH 16
#endif /* HAVE_SYS_SECURITY_H */
#ifdef HAVE_GETPWANAM
#include
#include
#include
#endif
#ifdef HAVE_COMPAT_H
#include
#endif
#ifndef NGROUPS_MAX
#define NGROUPS_MAX 32 /* Guess... */
#endif
/* what is the longest significant password available on your system?
Knowing this speeds up password searches a lot */
#ifndef PASSWORD_LENGTH
#define PASSWORD_LENGTH 8
#endif
#if defined(HAVE_PUTPRPWNAM) && defined(AUTH_CLEARTEXT_SEG_CHARS)
#define OSF1_ENH_SEC 1
#endif
#ifndef ALLOW_CHANGE_PASSWORD
#if (defined(HAVE_TERMIOS_H) && defined(HAVE_DUP2) && defined(HAVE_SETSID))
#define ALLOW_CHANGE_PASSWORD 1
#endif
#endif
#if defined(HAVE_CRYPT16) && defined(HAVE_GETAUTHUID)
#define ULTRIX_AUTH 1
#endif
#ifdef NSS_WRAPPER
#ifndef NSS_WRAPPER_DISABLE
#ifndef NSS_WRAPPER_NOT_REPLACE
#define NSS_WRAPPER_REPLACE
#endif /* NSS_WRAPPER_NOT_REPLACE */
#include "../nss_wrapper/nss_wrapper.h"
#endif /* NSS_WRAPPER_DISABLE */
#endif /* NSS_WRAPPER */
#ifdef UID_WRAPPER
# ifndef UID_WRAPPER_DISABLE
# ifndef UID_WRAPPER_NOT_REPLACE
# define UID_WRAPPER_REPLACE
# endif /* UID_WRAPPER_NOT_REPLACE */
# include "../uid_wrapper/uid_wrapper.h"
# endif /* UID_WRAPPER_DISABLE */
#else /* UID_WRAPPER */
# define uwrap_enabled() 0
#endif /* UID_WRAPPER */
#endif
tevent-0.9.19/lib/replace/system/readline.h 0000660 0000000 0000000 00000003213 11741275274 020525 0 ustar root root 0000000 0000000 #ifndef _system_readline_h
#define _system_readline_h
/*
Unix SMB/CIFS implementation.
Readline wrappers
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_LIBREADLINE
# ifdef HAVE_READLINE_READLINE_H
# include
# ifdef HAVE_READLINE_HISTORY_H
# include
# endif
# else
# ifdef HAVE_READLINE_H
# include
# ifdef HAVE_HISTORY_H
# include
# endif
# else
# undef HAVE_LIBREADLINE
# endif
# endif
#endif
#ifdef HAVE_NEW_LIBREADLINE
#ifdef HAVE_CPPFUNCTION
# define RL_COMPLETION_CAST (CPPFunction *)
#elif HAVE_RL_COMPLETION_T
# define RL_COMPLETION_CAST (rl_completion_t *)
#else
# define RL_COMPLETION_CAST
#endif
#else
/* This type is missing from libreadline<4.0 (approximately) */
# define RL_COMPLETION_CAST
#endif /* HAVE_NEW_LIBREADLINE */
#endif
tevent-0.9.19/lib/replace/system/select.h 0000660 0000000 0000000 00000004536 12101212317 020206 0 ustar root root 0000000 0000000 #ifndef _system_select_h
#define _system_select_h
/*
Unix SMB/CIFS implementation.
select system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_SYS_SELECT_H
#include
#endif
#ifdef HAVE_SYS_EPOLL_H
#include
#endif
#ifndef SELECT_CAST
#define SELECT_CAST
#endif
#ifdef HAVE_POLL
#include
#else
/* Type used for the number of file descriptors. */
typedef unsigned long int nfds_t;
/* Data structure describing a polling request. */
struct pollfd
{
int fd; /* File descriptor to poll. */
short int events; /* Types of events poller cares about. */
short int revents; /* Types of events that actually occurred. */
};
/* Event types that can be polled for. These bits may be set in `events'
to indicate the interesting event types; they will appear in `revents'
to indicate the status of the file descriptor. */
#define POLLIN 0x001 /* There is data to read. */
#define POLLPRI 0x002 /* There is urgent data to read. */
#define POLLOUT 0x004 /* Writing now will not block. */
#define POLLRDNORM 0x040 /* Normal data may be read. */
#define POLLRDBAND 0x080 /* Priority data may be read. */
#define POLLWRNORM 0x100 /* Writing now will not block. */
#define POLLWRBAND 0x200 /* Priority data may be written. */
#define POLLERR 0x008 /* Error condition. */
#define POLLHUP 0x010 /* Hung up. */
#define POLLNVAL 0x020 /* Invalid polling request. */
/* define is in "replace.h" */
int rep_poll(struct pollfd *fds, nfds_t nfds, int timeout);
#endif
#endif
tevent-0.9.19/lib/replace/system/shmem.h 0000660 0000000 0000000 00000002625 11741275274 020061 0 ustar root root 0000000 0000000 #ifndef _system_shmem_h
#define _system_shmem_h
/*
Unix SMB/CIFS implementation.
shared memory system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#if defined(HAVE_SYS_IPC_H)
#include
#endif /* HAVE_SYS_IPC_H */
#if defined(HAVE_SYS_SHM_H)
#include
#endif /* HAVE_SYS_SHM_H */
#ifdef HAVE_SYS_MMAN_H
#include
#endif
/* NetBSD doesn't have these */
#ifndef SHM_R
#define SHM_R 0400
#endif
#ifndef SHM_W
#define SHM_W 0200
#endif
#ifndef MAP_FILE
#define MAP_FILE 0
#endif
#ifndef MAP_FAILED
#define MAP_FAILED ((void *)-1)
#endif
#endif
tevent-0.9.19/lib/replace/system/syslog.h 0000660 0000000 0000000 00000003435 11741275274 020270 0 ustar root root 0000000 0000000 #ifndef _system_syslog_h
#define _system_syslog_h
/*
Unix SMB/CIFS implementation.
syslog system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_SYSLOG_H
#include
#else
#ifdef HAVE_SYS_SYSLOG_H
#include
#endif
#endif
/* For sys_adminlog(). */
#ifndef LOG_EMERG
#define LOG_EMERG 0 /* system is unusable */
#endif
#ifndef LOG_ALERT
#define LOG_ALERT 1 /* action must be taken immediately */
#endif
#ifndef LOG_CRIT
#define LOG_CRIT 2 /* critical conditions */
#endif
#ifndef LOG_ERR
#define LOG_ERR 3 /* error conditions */
#endif
#ifndef LOG_WARNING
#define LOG_WARNING 4 /* warning conditions */
#endif
#ifndef LOG_NOTICE
#define LOG_NOTICE 5 /* normal but significant condition */
#endif
#ifndef LOG_INFO
#define LOG_INFO 6 /* informational */
#endif
#ifndef LOG_DEBUG
#define LOG_DEBUG 7 /* debug-level messages */
#endif
#endif
tevent-0.9.19/lib/replace/system/terminal.h 0000660 0000000 0000000 00000002625 11741275274 020563 0 ustar root root 0000000 0000000 #ifndef _system_terminal_h
#define _system_terminal_h
/*
Unix SMB/CIFS implementation.
terminal system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef SUNOS4
/* on SUNOS4 termios.h conflicts with sys/ioctl.h */
#undef HAVE_TERMIOS_H
#endif
#if defined(HAVE_TERMIOS_H)
/* POSIX terminal handling. */
#include
#elif defined(HAVE_TERMIO_H)
/* Older SYSV terminal handling - don't use if we can avoid it. */
#include
#elif defined(HAVE_SYS_TERMIO_H)
/* Older SYSV terminal handling - don't use if we can avoid it. */
#include
#endif
#endif
tevent-0.9.19/lib/replace/system/time.h 0000660 0000000 0000000 00000004461 12101212317 017662 0 ustar root root 0000000 0000000 #ifndef _system_time_h
#define _system_time_h
/*
Unix SMB/CIFS implementation.
time system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef TIME_WITH_SYS_TIME
#include
#include
#else
#ifdef HAVE_SYS_TIME_H
#include
#else
#include
#endif
#endif
#ifdef HAVE_UTIME_H
#include
#else
struct utimbuf {
time_t actime; /* access time */
time_t modtime; /* modification time */
};
#endif
#ifndef HAVE_STRUCT_TIMESPEC
struct timespec {
time_t tv_sec; /* Seconds. */
long tv_nsec; /* Nanoseconds. */
};
#endif
#ifndef HAVE_MKTIME
/* define is in "replace.h" */
time_t rep_mktime(struct tm *t);
#endif
#ifndef HAVE_TIMEGM
/* define is in "replace.h" */
time_t rep_timegm(struct tm *tm);
#endif
#ifndef HAVE_UTIME
/* define is in "replace.h" */
int rep_utime(const char *filename, const struct utimbuf *buf);
#endif
#ifndef HAVE_UTIMES
/* define is in "replace.h" */
int rep_utimes(const char *filename, const struct timeval tv[2]);
#endif
#ifndef HAVE_CLOCK_GETTIME
/* CLOCK_REALTIME is required by POSIX */
#define CLOCK_REALTIME 0
typedef int clockid_t;
int rep_clock_gettime(clockid_t clk_id, struct timespec *tp);
#endif
/* make sure we have a best effort CUSTOM_CLOCK_MONOTONIC we can rely on */
#if defined(CLOCK_MONOTONIC)
#define CUSTOM_CLOCK_MONOTONIC CLOCK_MONOTONIC
#elif defined(CLOCK_HIGHRES)
#define CUSTOM_CLOCK_MONOTONIC CLOCK_HIGHRES
#else
#define CUSTOM_CLOCK_MONOTONIC CLOCK_REALTIME
#endif
#endif
tevent-0.9.19/lib/replace/system/wait.h 0000660 0000000 0000000 00000002571 12101212317 017670 0 ustar root root 0000000 0000000 #ifndef _system_wait_h
#define _system_wait_h
/*
Unix SMB/CIFS implementation.
waitpid system include wrappers
Copyright (C) Andrew Tridgell 2004
** NOTE! The following LGPL license applies to the replace
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library 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 3 of the License, or (at your option) any later version.
This library 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 library; if not, see .
*/
#ifdef HAVE_SYS_WAIT_H
#include
#endif
#include
#ifndef SIGCLD
#define SIGCLD SIGCHLD
#endif
#ifdef HAVE_SETJMP_H
#include
#endif
#ifdef HAVE_SYS_UCONTEXT_H
#include
#endif
#if !defined(HAVE_SIG_ATOMIC_T_TYPE)
typedef int sig_atomic_t;
#endif
#if !defined(HAVE_WAITPID) && defined(HAVE_WAIT4)
int rep_waitpid(pid_t pid,int *status,int options)
#endif
#endif
tevent-0.9.19/lib/replace/system/wscript_configure 0000660 0000000 0000000 00000002303 11741275274 022247 0 ustar root root 0000000 0000000 #!/usr/bin/env python
conf.CHECK_HEADERS('sys/capability.h')
conf.CHECK_FUNCS('getpwnam_r getpwuid_r getpwent_r')
# solaris varients of getXXent_r
conf.CHECK_C_PROTOTYPE('getpwent_r',
'struct passwd *getpwent_r(struct passwd *src, char *buf, int buflen)',
define='SOLARIS_GETPWENT_R', headers='pwd.h')
conf.CHECK_C_PROTOTYPE('getgrent_r',
'struct group *getgrent_r(struct group *src, char *buf, int buflen)',
define='SOLARIS_GETGRENT_R', headers='grp.h')
# the irix varients
conf.CHECK_C_PROTOTYPE('getpwent_r',
'struct passwd *getpwent_r(struct passwd *src, char *buf, size_t buflen)',
define='SOLARIS_GETPWENT_R', headers='pwd.h')
conf.CHECK_C_PROTOTYPE('getgrent_r',
'struct group *getgrent_r(struct group *src, char *buf, size_t buflen)',
define='SOLARIS_GETGRENT_R', headers='grp.h')
conf.CHECK_FUNCS('getgrouplist')
conf.CHECK_HEADERS('ctype.h locale.h langinfo.h')
conf.CHECK_HEADERS('fnmatch.h locale.h langinfo.h')
conf.CHECK_HEADERS('sys/ipc.h sys/mman.h sys/shm.h')
conf.CHECK_HEADERS('termios.h termio.h sys/termio.h')
tevent-0.9.19/lib/replace/test/getifaddrs.c 0000660 0000000 0000000 00000005045 12153373752 020507 0 ustar root root 0000000 0000000 /*
* Unix SMB/CIFS implementation.
*
* libreplace getifaddrs test
*
* Copyright (C) Michael Adam 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library 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 3 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see .
*/
#ifndef AUTOCONF_TEST
#include "replace.h"
#include "system/network.h"
#include "replace-test.h"
#endif
#ifdef HAVE_INET_NTOP
#define rep_inet_ntop inet_ntop
#endif
static const char *format_sockaddr(struct sockaddr *addr,
char *addrstring,
socklen_t addrlen)
{
const char *result = NULL;
if (addr->sa_family == AF_INET) {
result = rep_inet_ntop(AF_INET,
&((struct sockaddr_in *)addr)->sin_addr,
addrstring,
addrlen);
#ifdef HAVE_STRUCT_SOCKADDR_IN6
} else if (addr->sa_family == AF_INET6) {
result = rep_inet_ntop(AF_INET6,
&((struct sockaddr_in6 *)addr)->sin6_addr,
addrstring,
addrlen);
#endif
}
return result;
}
int getifaddrs_test(void)
{
struct ifaddrs *ifs = NULL;
struct ifaddrs *ifs_head = NULL;
int ret;
ret = getifaddrs(&ifs);
ifs_head = ifs;
if (ret != 0) {
fprintf(stderr, "getifaddrs() failed: %s\n", strerror(errno));
return 1;
}
while (ifs) {
printf("%-10s ", ifs->ifa_name);
if (ifs->ifa_addr != NULL) {
char addrstring[INET6_ADDRSTRLEN];
const char *result;
result = format_sockaddr(ifs->ifa_addr,
addrstring,
sizeof(addrstring));
if (result != NULL) {
printf("IP=%s ", addrstring);
}
if (ifs->ifa_netmask != NULL) {
result = format_sockaddr(ifs->ifa_netmask,
addrstring,
sizeof(addrstring));
if (result != NULL) {
printf("NETMASK=%s", addrstring);
}
} else {
printf("AF=%d ", ifs->ifa_addr->sa_family);
}
} else {
printf("");
}
printf("\n");
ifs = ifs->ifa_next;
}
freeifaddrs(ifs_head);
return 0;
}
tevent-0.9.19/lib/replace/test/incoherent_mmap.c 0000660 0000000 0000000 00000003456 12101212317 021525 0 ustar root root 0000000 0000000 /* In OpenBSD, if you write to a file, another process doesn't see it
* in its mmap. Returns with exit status 0 if that is the case, 1 if
* it's coherent, and other if there's a problem. */
#include
#include
#include
#include
#include
#include
#include
#include
#include