pub const _INTTYPES_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __WORDSIZE: u32 = 32;
pub const __WORDSIZE32_SIZE_ULONG: u32 = 0;
pub const __WORDSIZE32_PTRDIFF_LONG: u32 = 0;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 0;
pub const __TIMESIZE: u32 = 32;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_60559_BFP__: u32 = 201404;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 35;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const _STDINT_H: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 0;
pub const __STATFS_MATCHES_STATFS64: u32 = 0;
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 0;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i32 = -2147483648;
pub const INT_FAST32_MIN: i32 = -2147483648;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u32 = 2147483647;
pub const INT_FAST32_MAX: u32 = 2147483647;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: u32 = 4294967295;
pub const UINT_FAST32_MAX: u32 = 4294967295;
pub const INTPTR_MIN: i32 = -2147483648;
pub const INTPTR_MAX: u32 = 2147483647;
pub const UINTPTR_MAX: u32 = 4294967295;
pub const PTRDIFF_MIN: i32 = -2147483648;
pub const PTRDIFF_MAX: u32 = 2147483647;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: u32 = 4294967295;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const ____gwchar_t_defined: u32 = 1;
pub const __PRI64_PREFIX: &[u8; 3] = b"ll\0";
pub const PRId8: &[u8; 2] = b"d\0";
pub const PRId16: &[u8; 2] = b"d\0";
pub const PRId32: &[u8; 2] = b"d\0";
pub const PRId64: &[u8; 4] = b"lld\0";
pub const PRIdLEAST8: &[u8; 2] = b"d\0";
pub const PRIdLEAST16: &[u8; 2] = b"d\0";
pub const PRIdLEAST32: &[u8; 2] = b"d\0";
pub const PRIdLEAST64: &[u8; 4] = b"lld\0";
pub const PRIdFAST8: &[u8; 2] = b"d\0";
pub const PRIdFAST64: &[u8; 4] = b"lld\0";
pub const PRIi8: &[u8; 2] = b"i\0";
pub const PRIi16: &[u8; 2] = b"i\0";
pub const PRIi32: &[u8; 2] = b"i\0";
pub const PRIi64: &[u8; 4] = b"lli\0";
pub const PRIiLEAST8: &[u8; 2] = b"i\0";
pub const PRIiLEAST16: &[u8; 2] = b"i\0";
pub const PRIiLEAST32: &[u8; 2] = b"i\0";
pub const PRIiLEAST64: &[u8; 4] = b"lli\0";
pub const PRIiFAST8: &[u8; 2] = b"i\0";
pub const PRIiFAST64: &[u8; 4] = b"lli\0";
pub const PRIo8: &[u8; 2] = b"o\0";
pub const PRIo16: &[u8; 2] = b"o\0";
pub const PRIo32: &[u8; 2] = b"o\0";
pub const PRIo64: &[u8; 4] = b"llo\0";
pub const PRIoLEAST8: &[u8; 2] = b"o\0";
pub const PRIoLEAST16: &[u8; 2] = b"o\0";
pub const PRIoLEAST32: &[u8; 2] = b"o\0";
pub const PRIoLEAST64: &[u8; 4] = b"llo\0";
pub const PRIoFAST8: &[u8; 2] = b"o\0";
pub const PRIoFAST64: &[u8; 4] = b"llo\0";
pub const PRIu8: &[u8; 2] = b"u\0";
pub const PRIu16: &[u8; 2] = b"u\0";
pub const PRIu32: &[u8; 2] = b"u\0";
pub const PRIu64: &[u8; 4] = b"llu\0";
pub const PRIuLEAST8: &[u8; 2] = b"u\0";
pub const PRIuLEAST16: &[u8; 2] = b"u\0";
pub const PRIuLEAST32: &[u8; 2] = b"u\0";
pub const PRIuLEAST64: &[u8; 4] = b"llu\0";
pub const PRIuFAST8: &[u8; 2] = b"u\0";
pub const PRIuFAST64: &[u8; 4] = b"llu\0";
pub const PRIx8: &[u8; 2] = b"x\0";
pub const PRIx16: &[u8; 2] = b"x\0";
pub const PRIx32: &[u8; 2] = b"x\0";
pub const PRIx64: &[u8; 4] = b"llx\0";
pub const PRIxLEAST8: &[u8; 2] = b"x\0";
pub const PRIxLEAST16: &[u8; 2] = b"x\0";
pub const PRIxLEAST32: &[u8; 2] = b"x\0";
pub const PRIxLEAST64: &[u8; 4] = b"llx\0";
pub const PRIxFAST8: &[u8; 2] = b"x\0";
pub const PRIxFAST64: &[u8; 4] = b"llx\0";
pub const PRIX8: &[u8; 2] = b"X\0";
pub const PRIX16: &[u8; 2] = b"X\0";
pub const PRIX32: &[u8; 2] = b"X\0";
pub const PRIX64: &[u8; 4] = b"llX\0";
pub const PRIXLEAST8: &[u8; 2] = b"X\0";
pub const PRIXLEAST16: &[u8; 2] = b"X\0";
pub const PRIXLEAST32: &[u8; 2] = b"X\0";
pub const PRIXLEAST64: &[u8; 4] = b"llX\0";
pub const PRIXFAST8: &[u8; 2] = b"X\0";
pub const PRIXFAST64: &[u8; 4] = b"llX\0";
pub const PRIdMAX: &[u8; 4] = b"lld\0";
pub const PRIiMAX: &[u8; 4] = b"lli\0";
pub const PRIoMAX: &[u8; 4] = b"llo\0";
pub const PRIuMAX: &[u8; 4] = b"llu\0";
pub const PRIxMAX: &[u8; 4] = b"llx\0";
pub const PRIXMAX: &[u8; 4] = b"llX\0";
pub const SCNd8: &[u8; 4] = b"hhd\0";
pub const SCNd16: &[u8; 3] = b"hd\0";
pub const SCNd32: &[u8; 2] = b"d\0";
pub const SCNd64: &[u8; 4] = b"lld\0";
pub const SCNdLEAST8: &[u8; 4] = b"hhd\0";
pub const SCNdLEAST16: &[u8; 3] = b"hd\0";
pub const SCNdLEAST32: &[u8; 2] = b"d\0";
pub const SCNdLEAST64: &[u8; 4] = b"lld\0";
pub const SCNdFAST8: &[u8; 4] = b"hhd\0";
pub const SCNdFAST64: &[u8; 4] = b"lld\0";
pub const SCNi8: &[u8; 4] = b"hhi\0";
pub const SCNi16: &[u8; 3] = b"hi\0";
pub const SCNi32: &[u8; 2] = b"i\0";
pub const SCNi64: &[u8; 4] = b"lli\0";
pub const SCNiLEAST8: &[u8; 4] = b"hhi\0";
pub const SCNiLEAST16: &[u8; 3] = b"hi\0";
pub const SCNiLEAST32: &[u8; 2] = b"i\0";
pub const SCNiLEAST64: &[u8; 4] = b"lli\0";
pub const SCNiFAST8: &[u8; 4] = b"hhi\0";
pub const SCNiFAST64: &[u8; 4] = b"lli\0";
pub const SCNu8: &[u8; 4] = b"hhu\0";
pub const SCNu16: &[u8; 3] = b"hu\0";
pub const SCNu32: &[u8; 2] = b"u\0";
pub const SCNu64: &[u8; 4] = b"llu\0";
pub const SCNuLEAST8: &[u8; 4] = b"hhu\0";
pub const SCNuLEAST16: &[u8; 3] = b"hu\0";
pub const SCNuLEAST32: &[u8; 2] = b"u\0";
pub const SCNuLEAST64: &[u8; 4] = b"llu\0";
pub const SCNuFAST8: &[u8; 4] = b"hhu\0";
pub const SCNuFAST64: &[u8; 4] = b"llu\0";
pub const SCNo8: &[u8; 4] = b"hho\0";
pub const SCNo16: &[u8; 3] = b"ho\0";
pub const SCNo32: &[u8; 2] = b"o\0";
pub const SCNo64: &[u8; 4] = b"llo\0";
pub const SCNoLEAST8: &[u8; 4] = b"hho\0";
pub const SCNoLEAST16: &[u8; 3] = b"ho\0";
pub const SCNoLEAST32: &[u8; 2] = b"o\0";
pub const SCNoLEAST64: &[u8; 4] = b"llo\0";
pub const SCNoFAST8: &[u8; 4] = b"hho\0";
pub const SCNoFAST64: &[u8; 4] = b"llo\0";
pub const SCNx8: &[u8; 4] = b"hhx\0";
pub const SCNx16: &[u8; 3] = b"hx\0";
pub const SCNx32: &[u8; 2] = b"x\0";
pub const SCNx64: &[u8; 4] = b"llx\0";
pub const SCNxLEAST8: &[u8; 4] = b"hhx\0";
pub const SCNxLEAST16: &[u8; 3] = b"hx\0";
pub const SCNxLEAST32: &[u8; 2] = b"x\0";
pub const SCNxLEAST64: &[u8; 4] = b"llx\0";
pub const SCNxFAST8: &[u8; 4] = b"hhx\0";
pub const SCNxFAST64: &[u8; 4] = b"llx\0";
pub const SCNdMAX: &[u8; 4] = b"lld\0";
pub const SCNiMAX: &[u8; 4] = b"lli\0";
pub const SCNoMAX: &[u8; 4] = b"llo\0";
pub const SCNuMAX: &[u8; 4] = b"llu\0";
pub const SCNxMAX: &[u8; 4] = b"llx\0";
pub const _SYS_TYPES_H: u32 = 1;
pub const __clock_t_defined: u32 = 1;
pub const __clockid_t_defined: u32 = 1;
pub const __time_t_defined: u32 = 1;
pub const __timer_t_defined: u32 = 1;
pub const __BIT_TYPES_DEFINED__: u32 = 1;
pub const _ENDIAN_H: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const _BITS_BYTESWAP_H: u32 = 1;
pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
pub const _SYS_SELECT_H: u32 = 1;
pub const __sigset_t_defined: u32 = 1;
pub const __timeval_defined: u32 = 1;
pub const _STRUCT_TIMESPEC: u32 = 1;
pub const FD_SETSIZE: u32 = 1024;
pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
pub const _THREAD_SHARED_TYPES_H: u32 = 1;
pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 24;
pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 36;
pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 32;
pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 20;
pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 0;
pub const __have_pthread_attr_t: u32 = 1;
pub const AVAHI_ADDRESS_STR_MAX: u32 = 40;
pub const __GNUC_VA_LIST: u32 = 1;
pub const AVAHI_SERVICE_COOKIE: &[u8; 29] = b"org.freedesktop.Avahi.cookie\0";
pub const AVAHI_SERVICE_COOKIE_INVALID: u32 = 0;
pub const AVAHI_DEFAULT_TTL_HOST_NAME: u32 = 120;
pub const AVAHI_DEFAULT_TTL: u32 = 4500;
pub const _SYS_POLL_H: u32 = 1;
pub const POLLIN: u32 = 1;
pub const POLLPRI: u32 = 2;
pub const POLLOUT: u32 = 4;
pub const POLLRDNORM: u32 = 64;
pub const POLLRDBAND: u32 = 128;
pub const POLLWRNORM: u32 = 256;
pub const POLLWRBAND: u32 = 512;
pub const POLLERR: u32 = 8;
pub const POLLHUP: u32 = 16;
pub const POLLNVAL: u32 = 32;
pub const _SYS_TIME_H: u32 = 1;
pub const AVAHI_DOMAIN_NAME_MAX: u32 = 1014;
pub const AVAHI_LABEL_MAX: u32 = 64;
pub const _LIBC_LIMITS_H_: u32 = 1;
pub const MB_LEN_MAX: u32 = 16;
pub const _BITS_POSIX1_LIM_H: u32 = 1;
pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
pub const _POSIX_AIO_MAX: u32 = 1;
pub const _POSIX_ARG_MAX: u32 = 4096;
pub const _POSIX_CHILD_MAX: u32 = 25;
pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
pub const _POSIX_HOST_NAME_MAX: u32 = 255;
pub const _POSIX_LINK_MAX: u32 = 8;
pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
pub const _POSIX_MAX_CANON: u32 = 255;
pub const _POSIX_MAX_INPUT: u32 = 255;
pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
pub const _POSIX_NAME_MAX: u32 = 14;
pub const _POSIX_NGROUPS_MAX: u32 = 8;
pub const _POSIX_OPEN_MAX: u32 = 20;
pub const _POSIX_PATH_MAX: u32 = 256;
pub const _POSIX_PIPE_BUF: u32 = 512;
pub const _POSIX_RE_DUP_MAX: u32 = 255;
pub const _POSIX_RTSIG_MAX: u32 = 8;
pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
pub const _POSIX_SSIZE_MAX: u32 = 32767;
pub const _POSIX_STREAM_MAX: u32 = 8;
pub const _POSIX_SYMLINK_MAX: u32 = 255;
pub const _POSIX_SYMLOOP_MAX: u32 = 8;
pub const _POSIX_TIMER_MAX: u32 = 32;
pub const _POSIX_TTY_NAME_MAX: u32 = 9;
pub const _POSIX_TZNAME_MAX: u32 = 6;
pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
pub const NR_OPEN: u32 = 1024;
pub const NGROUPS_MAX: u32 = 65536;
pub const ARG_MAX: u32 = 131072;
pub const LINK_MAX: u32 = 127;
pub const MAX_CANON: u32 = 255;
pub const MAX_INPUT: u32 = 255;
pub const NAME_MAX: u32 = 255;
pub const PATH_MAX: u32 = 4096;
pub const PIPE_BUF: u32 = 4096;
pub const XATTR_NAME_MAX: u32 = 255;
pub const XATTR_SIZE_MAX: u32 = 65536;
pub const XATTR_LIST_MAX: u32 = 65536;
pub const RTSIG_MAX: u32 = 32;
pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
pub const PTHREAD_KEYS_MAX: u32 = 1024;
pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
pub const AIO_PRIO_DELTA_MAX: u32 = 20;
pub const PTHREAD_STACK_MIN: u32 = 16384;
pub const DELAYTIMER_MAX: u32 = 2147483647;
pub const TTY_NAME_MAX: u32 = 32;
pub const LOGIN_NAME_MAX: u32 = 256;
pub const HOST_NAME_MAX: u32 = 64;
pub const MQ_PRIO_MAX: u32 = 32768;
pub const SEM_VALUE_MAX: u32 = 2147483647;
pub const _BITS_POSIX2_LIM_H: u32 = 1;
pub const _POSIX2_BC_BASE_MAX: u32 = 99;
pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
pub const _POSIX2_LINE_MAX: u32 = 2048;
pub const _POSIX2_RE_DUP_MAX: u32 = 255;
pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
pub const BC_BASE_MAX: u32 = 99;
pub const BC_DIM_MAX: u32 = 2048;
pub const BC_SCALE_MAX: u32 = 99;
pub const BC_STRING_MAX: u32 = 1000;
pub const COLL_WEIGHTS_MAX: u32 = 255;
pub const EXPR_NEST_MAX: u32 = 32;
pub const LINE_MAX: u32 = 2048;
pub const CHARCLASS_NAME_MAX: u32 = 2048;
pub const RE_DUP_MAX: u32 = 32767;
pub const _ASSERT_H: u32 = 1;
pub type __u_char = ::libc::c_uchar;
pub type __u_short = ::libc::c_ushort;
pub type __u_int = ::libc::c_uint;
pub type __u_long = ::libc::c_ulong;
pub type __int8_t = ::libc::c_schar;
pub type __uint8_t = ::libc::c_uchar;
pub type __int16_t = ::libc::c_short;
pub type __uint16_t = ::libc::c_ushort;
pub type __int32_t = ::libc::c_int;
pub type __uint32_t = ::libc::c_uint;
pub type __int64_t = ::libc::c_longlong;
pub type __uint64_t = ::libc::c_ulonglong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::libc::c_longlong;
pub type __u_quad_t = ::libc::c_ulonglong;
pub type __intmax_t = ::libc::c_longlong;
pub type __uintmax_t = ::libc::c_ulonglong;
pub type __dev_t = __uint64_t;
pub type __uid_t = ::libc::c_uint;
pub type __gid_t = ::libc::c_uint;
pub type __ino_t = ::libc::c_ulong;
pub type __ino64_t = __uint64_t;
pub type __mode_t = ::libc::c_uint;
pub type __nlink_t = ::libc::c_uint;
pub type __off_t = ::libc::c_long;
pub type __off64_t = __int64_t;
pub type __pid_t = ::libc::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::libc::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::libc::c_long;
pub type __rlim_t = ::libc::c_ulong;
pub type __rlim64_t = __uint64_t;
pub type __id_t = ::libc::c_uint;
pub type __time_t = ::libc::c_long;
pub type __useconds_t = ::libc::c_uint;
pub type __suseconds_t = ::libc::c_long;
pub type __suseconds64_t = __int64_t;
pub type __daddr_t = ::libc::c_int;
pub type __key_t = ::libc::c_int;
pub type __clockid_t = ::libc::c_int;
pub type __timer_t = *mut ::libc::c_void;
pub type __blksize_t = ::libc::c_long;
pub type __blkcnt_t = ::libc::c_long;
pub type __blkcnt64_t = __int64_t;
pub type __fsblkcnt_t = ::libc::c_ulong;
pub type __fsblkcnt64_t = __uint64_t;
pub type __fsfilcnt_t = ::libc::c_ulong;
pub type __fsfilcnt64_t = __uint64_t;
pub type __fsword_t = ::libc::c_int;
pub type __ssize_t = ::libc::c_int;
pub type __syscall_slong_t = ::libc::c_long;
pub type __syscall_ulong_t = ::libc::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::libc::c_char;
pub type __intptr_t = ::libc::c_int;
pub type __socklen_t = ::libc::c_uint;
pub type __sig_atomic_t = ::libc::c_int;
pub type __time64_t = __int64_t;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::libc::c_schar;
pub type int_fast16_t = ::libc::c_int;
pub type int_fast32_t = ::libc::c_int;
pub type int_fast64_t = ::libc::c_longlong;
pub type uint_fast8_t = ::libc::c_uchar;
pub type uint_fast16_t = ::libc::c_uint;
pub type uint_fast32_t = ::libc::c_uint;
pub type uint_fast64_t = ::libc::c_ulonglong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type __gwchar_t = ::libc::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct imaxdiv_t {
pub quot: ::libc::c_longlong,
pub rem: ::libc::c_longlong,
}
#[test]
fn bindgen_test_layout_imaxdiv_t() {
const UNINIT: ::std::mem::MaybeUninit<imaxdiv_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<imaxdiv_t>(),
16usize,
concat!("Size of: ", stringify!(imaxdiv_t))
);
assert_eq!(
::std::mem::align_of::<imaxdiv_t>(),
4usize,
concat!("Alignment of ", stringify!(imaxdiv_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(imaxdiv_t),
"::",
stringify!(quot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(imaxdiv_t),
"::",
stringify!(rem)
)
);
}
extern "C" {
pub fn imaxabs(__n: intmax_t) -> intmax_t;
}
extern "C" {
pub fn imaxdiv(__numer: intmax_t, __denom: intmax_t) -> imaxdiv_t;
}
extern "C" {
pub fn strtoimax(
__nptr: *const ::libc::c_char,
__endptr: *mut *mut ::libc::c_char,
__base: ::libc::c_int,
) -> intmax_t;
}
extern "C" {
pub fn strtoumax(
__nptr: *const ::libc::c_char,
__endptr: *mut *mut ::libc::c_char,
__base: ::libc::c_int,
) -> uintmax_t;
}
extern "C" {
pub fn wcstoimax(
__nptr: *const __gwchar_t,
__endptr: *mut *mut __gwchar_t,
__base: ::libc::c_int,
) -> intmax_t;
}
extern "C" {
pub fn wcstoumax(
__nptr: *const __gwchar_t,
__endptr: *mut *mut __gwchar_t,
__base: ::libc::c_int,
) -> uintmax_t;
}
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type u_long = __u_long;
pub type quad_t = __quad_t;
pub type u_quad_t = __u_quad_t;
pub type fsid_t = __fsid_t;
pub type loff_t = __loff_t;
pub type ino_t = __ino_t;
pub type dev_t = __dev_t;
pub type gid_t = __gid_t;
pub type mode_t = __mode_t;
pub type nlink_t = __nlink_t;
pub type uid_t = __uid_t;
pub type off_t = __off_t;
pub type pid_t = __pid_t;
pub type id_t = __id_t;
pub type daddr_t = __daddr_t;
pub type caddr_t = __caddr_t;
pub type key_t = __key_t;
pub type clock_t = __clock_t;
pub type clockid_t = __clockid_t;
pub type time_t = __time_t;
pub type timer_t = __timer_t;
pub type ulong = ::libc::c_ulong;
pub type ushort = ::libc::c_ushort;
pub type uint = ::libc::c_uint;
pub type u_int8_t = __uint8_t;
pub type u_int16_t = __uint16_t;
pub type u_int32_t = __uint32_t;
pub type u_int64_t = __uint64_t;
pub type register_t = ::libc::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::libc::c_ulong; 32usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(__sigset_t))
);
assert_eq!(
::std::mem::align_of::<__sigset_t>(),
4usize,
concat!("Alignment of ", stringify!(__sigset_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sigset_t),
"::",
stringify!(__val)
)
);
}
pub type sigset_t = __sigset_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
pub tv_sec: __time_t,
pub tv_usec: __suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timeval>(),
8usize,
concat!("Size of: ", stringify!(timeval))
);
assert_eq!(
::std::mem::align_of::<timeval>(),
4usize,
concat!("Alignment of ", stringify!(timeval))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_usec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timespec>(),
8usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
4usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = ::libc::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fd_set {
pub __fds_bits: [__fd_mask; 32usize],
}
#[test]
fn bindgen_test_layout_fd_set() {
const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<fd_set>(),
128usize,
concat!("Size of: ", stringify!(fd_set))
);
assert_eq!(
::std::mem::align_of::<fd_set>(),
4usize,
concat!("Alignment of ", stringify!(fd_set))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fd_set),
"::",
stringify!(__fds_bits)
)
);
}
pub type fd_mask = __fd_mask;
extern "C" {
pub fn select(
__nfds: ::libc::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *mut timeval,
) -> ::libc::c_int;
}
extern "C" {
pub fn pselect(
__nfds: ::libc::c_int,
__readfds: *mut fd_set,
__writefds: *mut fd_set,
__exceptfds: *mut fd_set,
__timeout: *const timespec,
__sigmask: *const __sigset_t,
) -> ::libc::c_int;
}
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __atomic_wide_counter {
pub __value64: ::libc::c_ulonglong,
pub __value32: __atomic_wide_counter__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __atomic_wide_counter__bindgen_ty_1 {
pub __low: ::libc::c_uint,
pub __high: ::libc::c_uint,
}
#[test]
fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__atomic_wide_counter__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___atomic_wide_counter() {
const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__atomic_wide_counter>(),
8usize,
concat!("Size of: ", stringify!(__atomic_wide_counter))
);
assert_eq!(
::std::mem::align_of::<__atomic_wide_counter>(),
4usize,
concat!("Alignment of ", stringify!(__atomic_wide_counter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter),
"::",
stringify!(__value64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter),
"::",
stringify!(__value32)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
8usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_slist {
pub __next: *mut __pthread_internal_slist,
}
#[test]
fn bindgen_test_layout___pthread_internal_slist() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_internal_slist>(),
4usize,
concat!("Size of: ", stringify!(__pthread_internal_slist))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_slist>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_internal_slist))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_slist),
"::",
stringify!(__next)
)
);
}
pub type __pthread_slist_t = __pthread_internal_slist;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::libc::c_int,
pub __count: ::libc::c_uint,
pub __owner: ::libc::c_int,
pub __kind: ::libc::c_int,
pub __nusers: ::libc::c_uint,
pub __bindgen_anon_1: __pthread_mutex_s__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_mutex_s__bindgen_ty_1 {
pub __elision_data: __pthread_mutex_s__bindgen_ty_1__bindgen_ty_1,
pub __list: __pthread_slist_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s__bindgen_ty_1__bindgen_ty_1 {
pub __espins: ::libc::c_short,
pub __eelision: ::libc::c_short,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Alignment of ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__espins) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__espins)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__eelision) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__eelision)
)
);
}
#[test]
fn bindgen_test_layout___pthread_mutex_s__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(__pthread_mutex_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__elision_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1),
"::",
stringify!(__elision_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1),
"::",
stringify!(__list)
)
);
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
24usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
pub __readers: ::libc::c_uint,
pub __writers: ::libc::c_uint,
pub __wrphase_futex: ::libc::c_uint,
pub __writers_futex: ::libc::c_uint,
pub __pad3: ::libc::c_uint,
pub __pad4: ::libc::c_uint,
pub __flags: ::libc::c_uchar,
pub __shared: ::libc::c_uchar,
pub __rwelision: ::libc::c_schar,
pub __pad2: ::libc::c_uchar,
pub __cur_writer: ::libc::c_int,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_rwlock_arch_t>(),
32usize,
concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
::std::mem::align_of::<__pthread_rwlock_arch_t>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__readers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__wrphase_futex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers_futex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__shared)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__rwelision)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__cur_writer)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __wseq: __atomic_wide_counter,
pub __g1_start: __atomic_wide_counter,
pub __g_refs: [::libc::c_uint; 2usize],
pub __g_size: [::libc::c_uint; 2usize],
pub __g1_orig_size: ::libc::c_uint,
pub __wrefs: ::libc::c_uint,
pub __g_signals: [::libc::c_uint; 2usize],
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
pub type __tss_t = ::libc::c_uint;
pub type __thrd_t = ::libc::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __once_flag {
pub __data: ::libc::c_int,
}
#[test]
fn bindgen_test_layout___once_flag() {
const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__once_flag>(),
4usize,
concat!("Size of: ", stringify!(__once_flag))
);
assert_eq!(
::std::mem::align_of::<__once_flag>(),
4usize,
concat!("Alignment of ", stringify!(__once_flag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__once_flag),
"::",
stringify!(__data)
)
);
}
pub type pthread_t = ::libc::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
pub __size: [::libc::c_char; 4usize],
pub __align: ::libc::c_int,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_mutexattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutexattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_condattr_t {
pub __size: [::libc::c_char; 4usize],
pub __align: ::libc::c_int,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_condattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_condattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_condattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_key_t = ::libc::c_uint;
pub type pthread_once_t = ::libc::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
pub __size: [::libc::c_char; 36usize],
pub __align: ::libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_attr_t>(),
36usize,
concat!("Size of: ", stringify!(pthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_attr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_attr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::libc::c_char; 24usize],
pub __align: ::libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
24usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [::libc::c_char; 48usize],
pub __align: ::libc::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<pthread_cond_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
pub __data: __pthread_rwlock_arch_t,
pub __size: [::libc::c_char; 32usize],
pub __align: ::libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_rwlock_t>(),
32usize,
concat!("Size of: ", stringify!(pthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlock_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_rwlock_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlockattr_t {
pub __size: [::libc::c_char; 8usize],
pub __align: ::libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Size of: ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlockattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__align)
)
);
}
pub type pthread_spinlock_t = ::libc::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
pub __size: [::libc::c_char; 20usize],
pub __align: ::libc::c_long,
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_barrier_t>(),
20usize,
concat!("Size of: ", stringify!(pthread_barrier_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrier_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_barrier_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrierattr_t {
pub __size: [::libc::c_char; 4usize],
pub __align: ::libc::c_int,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_barrierattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrierattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__align)
)
);
}
pub type AvahiProtocol = ::libc::c_int;
pub type AvahiIfIndex = ::libc::c_int;
pub const AVAHI_PROTO_INET: _bindgen_ty_1 = 0;
pub const AVAHI_PROTO_INET6: _bindgen_ty_1 = 1;
pub const AVAHI_PROTO_UNSPEC: _bindgen_ty_1 = -1;
pub type _bindgen_ty_1 = ::libc::c_int;
pub const AVAHI_IF_UNSPEC: _bindgen_ty_2 = -1;
pub type _bindgen_ty_2 = ::libc::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiIPv4Address {
pub address: u32,
}
#[test]
fn bindgen_test_layout_AvahiIPv4Address() {
const UNINIT: ::std::mem::MaybeUninit<AvahiIPv4Address> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiIPv4Address>(),
4usize,
concat!("Size of: ", stringify!(AvahiIPv4Address))
);
assert_eq!(
::std::mem::align_of::<AvahiIPv4Address>(),
4usize,
concat!("Alignment of ", stringify!(AvahiIPv4Address))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).address) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiIPv4Address),
"::",
stringify!(address)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiIPv6Address {
pub address: [u8; 16usize],
}
#[test]
fn bindgen_test_layout_AvahiIPv6Address() {
const UNINIT: ::std::mem::MaybeUninit<AvahiIPv6Address> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiIPv6Address>(),
16usize,
concat!("Size of: ", stringify!(AvahiIPv6Address))
);
assert_eq!(
::std::mem::align_of::<AvahiIPv6Address>(),
1usize,
concat!("Alignment of ", stringify!(AvahiIPv6Address))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).address) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiIPv6Address),
"::",
stringify!(address)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct AvahiAddress {
pub proto: AvahiProtocol,
pub data: AvahiAddress__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union AvahiAddress__bindgen_ty_1 {
pub ipv6: AvahiIPv6Address,
pub ipv4: AvahiIPv4Address,
pub data: [u8; 1usize],
}
#[test]
fn bindgen_test_layout_AvahiAddress__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<AvahiAddress__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiAddress__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(AvahiAddress__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<AvahiAddress__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(AvahiAddress__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ipv6) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiAddress__bindgen_ty_1),
"::",
stringify!(ipv6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ipv4) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiAddress__bindgen_ty_1),
"::",
stringify!(ipv4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiAddress__bindgen_ty_1),
"::",
stringify!(data)
)
);
}
#[test]
fn bindgen_test_layout_AvahiAddress() {
const UNINIT: ::std::mem::MaybeUninit<AvahiAddress> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiAddress>(),
20usize,
concat!("Size of: ", stringify!(AvahiAddress))
);
assert_eq!(
::std::mem::align_of::<AvahiAddress>(),
4usize,
concat!("Alignment of ", stringify!(AvahiAddress))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiAddress),
"::",
stringify!(proto)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(AvahiAddress),
"::",
stringify!(data)
)
);
}
extern "C" {
pub fn avahi_address_cmp(a: *const AvahiAddress, b: *const AvahiAddress) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_address_snprint(
ret_s: *mut ::libc::c_char,
length: usize,
a: *const AvahiAddress,
) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_address_parse(
s: *const ::libc::c_char,
af: AvahiProtocol,
ret_addr: *mut AvahiAddress,
) -> *mut AvahiAddress;
}
extern "C" {
pub fn avahi_reverse_lookup_name(
a: *const AvahiAddress,
ret_s: *mut ::libc::c_char,
length: usize,
) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_proto_to_af(proto: AvahiProtocol) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_af_to_proto(af: ::libc::c_int) -> AvahiProtocol;
}
extern "C" {
pub fn avahi_proto_to_string(proto: AvahiProtocol) -> *const ::libc::c_char;
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiStringList {
pub next: *mut AvahiStringList,
pub size: usize,
pub text: [u8; 1usize],
}
#[test]
fn bindgen_test_layout_AvahiStringList() {
const UNINIT: ::std::mem::MaybeUninit<AvahiStringList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiStringList>(),
12usize,
concat!("Size of: ", stringify!(AvahiStringList))
);
assert_eq!(
::std::mem::align_of::<AvahiStringList>(),
4usize,
concat!("Alignment of ", stringify!(AvahiStringList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiStringList),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(AvahiStringList),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(AvahiStringList),
"::",
stringify!(text)
)
);
}
extern "C" {
pub fn avahi_string_list_new(txt: *const ::libc::c_char, ...) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_new_va(va: va_list) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_new_from_array(
array: *mut *const ::libc::c_char,
length: ::libc::c_int,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_free(l: *mut AvahiStringList);
}
extern "C" {
pub fn avahi_string_list_add(
l: *mut AvahiStringList,
text: *const ::libc::c_char,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_printf(
l: *mut AvahiStringList,
format: *const ::libc::c_char,
...
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_vprintf(
l: *mut AvahiStringList,
format: *const ::libc::c_char,
va: va_list,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_arbitrary(
l: *mut AvahiStringList,
text: *const u8,
size: usize,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_anonymous(
l: *mut AvahiStringList,
size: usize,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_many(r: *mut AvahiStringList, ...) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_many_va(
r: *mut AvahiStringList,
va: va_list,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_to_string(l: *mut AvahiStringList) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_string_list_serialize(
l: *mut AvahiStringList,
data: *mut ::libc::c_void,
size: usize,
) -> usize;
}
extern "C" {
pub fn avahi_string_list_parse(
data: *const ::libc::c_void,
size: usize,
ret: *mut *mut AvahiStringList,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_string_list_equal(
a: *const AvahiStringList,
b: *const AvahiStringList,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_string_list_copy(l: *const AvahiStringList) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_reverse(l: *mut AvahiStringList) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_length(l: *const AvahiStringList) -> ::libc::c_uint;
}
extern "C" {
pub fn avahi_string_list_get_next(l: *mut AvahiStringList) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_get_text(l: *mut AvahiStringList) -> *mut u8;
}
extern "C" {
pub fn avahi_string_list_get_size(l: *mut AvahiStringList) -> usize;
}
extern "C" {
pub fn avahi_string_list_find(
l: *mut AvahiStringList,
key: *const ::libc::c_char,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_get_pair(
l: *mut AvahiStringList,
key: *mut *mut ::libc::c_char,
value: *mut *mut ::libc::c_char,
size: *mut usize,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_string_list_add_pair(
l: *mut AvahiStringList,
key: *const ::libc::c_char,
value: *const ::libc::c_char,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_add_pair_arbitrary(
l: *mut AvahiStringList,
key: *const ::libc::c_char,
value: *const u8,
size: usize,
) -> *mut AvahiStringList;
}
extern "C" {
pub fn avahi_string_list_get_service_cookie(l: *mut AvahiStringList) -> u32;
}
pub const AvahiServerState_AVAHI_SERVER_INVALID: AvahiServerState = 0;
pub const AvahiServerState_AVAHI_SERVER_REGISTERING: AvahiServerState = 1;
pub const AvahiServerState_AVAHI_SERVER_RUNNING: AvahiServerState = 2;
pub const AvahiServerState_AVAHI_SERVER_COLLISION: AvahiServerState = 3;
pub const AvahiServerState_AVAHI_SERVER_FAILURE: AvahiServerState = 4;
pub type AvahiServerState = ::libc::c_uint;
pub const AvahiEntryGroupState_AVAHI_ENTRY_GROUP_UNCOMMITED: AvahiEntryGroupState = 0;
pub const AvahiEntryGroupState_AVAHI_ENTRY_GROUP_REGISTERING: AvahiEntryGroupState = 1;
pub const AvahiEntryGroupState_AVAHI_ENTRY_GROUP_ESTABLISHED: AvahiEntryGroupState = 2;
pub const AvahiEntryGroupState_AVAHI_ENTRY_GROUP_COLLISION: AvahiEntryGroupState = 3;
pub const AvahiEntryGroupState_AVAHI_ENTRY_GROUP_FAILURE: AvahiEntryGroupState = 4;
pub type AvahiEntryGroupState = ::libc::c_uint;
pub const AvahiPublishFlags_AVAHI_PUBLISH_UNIQUE: AvahiPublishFlags = 1;
pub const AvahiPublishFlags_AVAHI_PUBLISH_NO_PROBE: AvahiPublishFlags = 2;
pub const AvahiPublishFlags_AVAHI_PUBLISH_NO_ANNOUNCE: AvahiPublishFlags = 4;
pub const AvahiPublishFlags_AVAHI_PUBLISH_ALLOW_MULTIPLE: AvahiPublishFlags = 8;
pub const AvahiPublishFlags_AVAHI_PUBLISH_NO_REVERSE: AvahiPublishFlags = 16;
pub const AvahiPublishFlags_AVAHI_PUBLISH_NO_COOKIE: AvahiPublishFlags = 32;
pub const AvahiPublishFlags_AVAHI_PUBLISH_UPDATE: AvahiPublishFlags = 64;
pub const AvahiPublishFlags_AVAHI_PUBLISH_USE_WIDE_AREA: AvahiPublishFlags = 128;
pub const AvahiPublishFlags_AVAHI_PUBLISH_USE_MULTICAST: AvahiPublishFlags = 256;
pub type AvahiPublishFlags = ::libc::c_uint;
pub const AvahiLookupFlags_AVAHI_LOOKUP_USE_WIDE_AREA: AvahiLookupFlags = 1;
pub const AvahiLookupFlags_AVAHI_LOOKUP_USE_MULTICAST: AvahiLookupFlags = 2;
pub const AvahiLookupFlags_AVAHI_LOOKUP_NO_TXT: AvahiLookupFlags = 4;
pub const AvahiLookupFlags_AVAHI_LOOKUP_NO_ADDRESS: AvahiLookupFlags = 8;
pub type AvahiLookupFlags = ::libc::c_uint;
pub const AvahiLookupResultFlags_AVAHI_LOOKUP_RESULT_CACHED: AvahiLookupResultFlags = 1;
pub const AvahiLookupResultFlags_AVAHI_LOOKUP_RESULT_WIDE_AREA: AvahiLookupResultFlags = 2;
pub const AvahiLookupResultFlags_AVAHI_LOOKUP_RESULT_MULTICAST: AvahiLookupResultFlags = 4;
pub const AvahiLookupResultFlags_AVAHI_LOOKUP_RESULT_LOCAL: AvahiLookupResultFlags = 8;
pub const AvahiLookupResultFlags_AVAHI_LOOKUP_RESULT_OUR_OWN: AvahiLookupResultFlags = 16;
pub const AvahiLookupResultFlags_AVAHI_LOOKUP_RESULT_STATIC: AvahiLookupResultFlags = 32;
pub type AvahiLookupResultFlags = ::libc::c_uint;
pub const AvahiBrowserEvent_AVAHI_BROWSER_NEW: AvahiBrowserEvent = 0;
pub const AvahiBrowserEvent_AVAHI_BROWSER_REMOVE: AvahiBrowserEvent = 1;
pub const AvahiBrowserEvent_AVAHI_BROWSER_CACHE_EXHAUSTED: AvahiBrowserEvent = 2;
pub const AvahiBrowserEvent_AVAHI_BROWSER_ALL_FOR_NOW: AvahiBrowserEvent = 3;
pub const AvahiBrowserEvent_AVAHI_BROWSER_FAILURE: AvahiBrowserEvent = 4;
pub type AvahiBrowserEvent = ::libc::c_uint;
pub const AvahiResolverEvent_AVAHI_RESOLVER_FOUND: AvahiResolverEvent = 0;
pub const AvahiResolverEvent_AVAHI_RESOLVER_FAILURE: AvahiResolverEvent = 1;
pub type AvahiResolverEvent = ::libc::c_uint;
pub const AvahiDomainBrowserType_AVAHI_DOMAIN_BROWSER_BROWSE: AvahiDomainBrowserType = 0;
pub const AvahiDomainBrowserType_AVAHI_DOMAIN_BROWSER_BROWSE_DEFAULT: AvahiDomainBrowserType = 1;
pub const AvahiDomainBrowserType_AVAHI_DOMAIN_BROWSER_REGISTER: AvahiDomainBrowserType = 2;
pub const AvahiDomainBrowserType_AVAHI_DOMAIN_BROWSER_REGISTER_DEFAULT: AvahiDomainBrowserType = 3;
pub const AvahiDomainBrowserType_AVAHI_DOMAIN_BROWSER_BROWSE_LEGACY: AvahiDomainBrowserType = 4;
pub const AvahiDomainBrowserType_AVAHI_DOMAIN_BROWSER_MAX: AvahiDomainBrowserType = 5;
pub type AvahiDomainBrowserType = ::libc::c_uint;
pub const AVAHI_DNS_TYPE_A: _bindgen_ty_3 = 1;
pub const AVAHI_DNS_TYPE_NS: _bindgen_ty_3 = 2;
pub const AVAHI_DNS_TYPE_CNAME: _bindgen_ty_3 = 5;
pub const AVAHI_DNS_TYPE_SOA: _bindgen_ty_3 = 6;
pub const AVAHI_DNS_TYPE_PTR: _bindgen_ty_3 = 12;
pub const AVAHI_DNS_TYPE_HINFO: _bindgen_ty_3 = 13;
pub const AVAHI_DNS_TYPE_MX: _bindgen_ty_3 = 15;
pub const AVAHI_DNS_TYPE_TXT: _bindgen_ty_3 = 16;
pub const AVAHI_DNS_TYPE_AAAA: _bindgen_ty_3 = 28;
pub const AVAHI_DNS_TYPE_SRV: _bindgen_ty_3 = 33;
pub type _bindgen_ty_3 = ::libc::c_uint;
pub const AVAHI_DNS_CLASS_IN: _bindgen_ty_4 = 1;
pub type _bindgen_ty_4 = ::libc::c_uint;
pub type nfds_t = ::libc::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pollfd {
pub fd: ::libc::c_int,
pub events: ::libc::c_short,
pub revents: ::libc::c_short,
}
#[test]
fn bindgen_test_layout_pollfd() {
const UNINIT: ::std::mem::MaybeUninit<pollfd> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pollfd>(),
8usize,
concat!("Size of: ", stringify!(pollfd))
);
assert_eq!(
::std::mem::align_of::<pollfd>(),
4usize,
concat!("Alignment of ", stringify!(pollfd))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pollfd),
"::",
stringify!(fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(pollfd),
"::",
stringify!(events)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).revents) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(pollfd),
"::",
stringify!(revents)
)
);
}
extern "C" {
pub fn poll(__fds: *mut pollfd, __nfds: nfds_t, __timeout: ::libc::c_int) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timezone {
pub tz_minuteswest: ::libc::c_int,
pub tz_dsttime: ::libc::c_int,
}
#[test]
fn bindgen_test_layout_timezone() {
const UNINIT: ::std::mem::MaybeUninit<timezone> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timezone>(),
8usize,
concat!("Size of: ", stringify!(timezone))
);
assert_eq!(
::std::mem::align_of::<timezone>(),
4usize,
concat!("Alignment of ", stringify!(timezone))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tz_minuteswest) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timezone),
"::",
stringify!(tz_minuteswest)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tz_dsttime) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(timezone),
"::",
stringify!(tz_dsttime)
)
);
}
extern "C" {
pub fn gettimeofday(__tv: *mut timeval, __tz: *mut ::libc::c_void) -> ::libc::c_int;
}
extern "C" {
pub fn settimeofday(__tv: *const timeval, __tz: *const timezone) -> ::libc::c_int;
}
extern "C" {
pub fn adjtime(__delta: *const timeval, __olddelta: *mut timeval) -> ::libc::c_int;
}
pub const __itimer_which_ITIMER_REAL: __itimer_which = 0;
pub const __itimer_which_ITIMER_VIRTUAL: __itimer_which = 1;
pub const __itimer_which_ITIMER_PROF: __itimer_which = 2;
pub type __itimer_which = ::libc::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct itimerval {
pub it_interval: timeval,
pub it_value: timeval,
}
#[test]
fn bindgen_test_layout_itimerval() {
const UNINIT: ::std::mem::MaybeUninit<itimerval> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<itimerval>(),
16usize,
concat!("Size of: ", stringify!(itimerval))
);
assert_eq!(
::std::mem::align_of::<itimerval>(),
4usize,
concat!("Alignment of ", stringify!(itimerval))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).it_interval) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(itimerval),
"::",
stringify!(it_interval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).it_value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(itimerval),
"::",
stringify!(it_value)
)
);
}
pub type __itimer_which_t = ::libc::c_int;
extern "C" {
pub fn getitimer(__which: __itimer_which_t, __value: *mut itimerval) -> ::libc::c_int;
}
extern "C" {
pub fn setitimer(
__which: __itimer_which_t,
__new: *const itimerval,
__old: *mut itimerval,
) -> ::libc::c_int;
}
extern "C" {
pub fn utimes(__file: *const ::libc::c_char, __tvp: *const timeval) -> ::libc::c_int;
}
extern "C" {
pub fn lutimes(__file: *const ::libc::c_char, __tvp: *const timeval) -> ::libc::c_int;
}
extern "C" {
pub fn futimes(__fd: ::libc::c_int, __tvp: *const timeval) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiWatch {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiTimeout {
_unused: [u8; 0],
}
pub const AvahiWatchEvent_AVAHI_WATCH_IN: AvahiWatchEvent = 1;
pub const AvahiWatchEvent_AVAHI_WATCH_OUT: AvahiWatchEvent = 4;
pub const AvahiWatchEvent_AVAHI_WATCH_ERR: AvahiWatchEvent = 8;
pub const AvahiWatchEvent_AVAHI_WATCH_HUP: AvahiWatchEvent = 16;
pub type AvahiWatchEvent = ::libc::c_uint;
pub type AvahiWatchCallback = ::std::option::Option<
unsafe extern "C" fn(
w: *mut AvahiWatch,
fd: ::libc::c_int,
event: AvahiWatchEvent,
userdata: *mut ::libc::c_void,
),
>;
pub type AvahiTimeoutCallback = ::std::option::Option<
unsafe extern "C" fn(t: *mut AvahiTimeout, userdata: *mut ::libc::c_void),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiPoll {
pub userdata: *mut ::libc::c_void,
pub watch_new: ::std::option::Option<
unsafe extern "C" fn(
api: *const AvahiPoll,
fd: ::libc::c_int,
event: AvahiWatchEvent,
callback: AvahiWatchCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiWatch,
>,
pub watch_update:
::std::option::Option<unsafe extern "C" fn(w: *mut AvahiWatch, event: AvahiWatchEvent)>,
pub watch_get_events:
::std::option::Option<unsafe extern "C" fn(w: *mut AvahiWatch) -> AvahiWatchEvent>,
pub watch_free: ::std::option::Option<unsafe extern "C" fn(w: *mut AvahiWatch)>,
pub timeout_new: ::std::option::Option<
unsafe extern "C" fn(
api: *const AvahiPoll,
tv: *const timeval,
callback: AvahiTimeoutCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiTimeout,
>,
pub timeout_update:
::std::option::Option<unsafe extern "C" fn(arg1: *mut AvahiTimeout, tv: *const timeval)>,
pub timeout_free: ::std::option::Option<unsafe extern "C" fn(t: *mut AvahiTimeout)>,
}
#[test]
fn bindgen_test_layout_AvahiPoll() {
const UNINIT: ::std::mem::MaybeUninit<AvahiPoll> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiPoll>(),
32usize,
concat!("Size of: ", stringify!(AvahiPoll))
);
assert_eq!(
::std::mem::align_of::<AvahiPoll>(),
4usize,
concat!("Alignment of ", stringify!(AvahiPoll))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).watch_new) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(watch_new)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).watch_update) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(watch_update)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).watch_get_events) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(watch_get_events)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).watch_free) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(watch_free)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeout_new) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(timeout_new)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeout_update) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(timeout_update)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeout_free) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(AvahiPoll),
"::",
stringify!(timeout_free)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiClient {
_unused: [u8; 0],
}
pub const AvahiClientState_AVAHI_CLIENT_S_REGISTERING: AvahiClientState = 1;
pub const AvahiClientState_AVAHI_CLIENT_S_RUNNING: AvahiClientState = 2;
pub const AvahiClientState_AVAHI_CLIENT_S_COLLISION: AvahiClientState = 3;
pub const AvahiClientState_AVAHI_CLIENT_FAILURE: AvahiClientState = 100;
pub const AvahiClientState_AVAHI_CLIENT_CONNECTING: AvahiClientState = 101;
pub type AvahiClientState = ::libc::c_uint;
impl AvahiClientFlags {
pub const AVAHI_CLIENT_IGNORE_USER_CONFIG: AvahiClientFlags = AvahiClientFlags(1);
}
impl AvahiClientFlags {
pub const AVAHI_CLIENT_NO_FAIL: AvahiClientFlags = AvahiClientFlags(2);
}
impl ::std::ops::BitOr<AvahiClientFlags> for AvahiClientFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
AvahiClientFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for AvahiClientFlags {
#[inline]
fn bitor_assign(&mut self, rhs: AvahiClientFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<AvahiClientFlags> for AvahiClientFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
AvahiClientFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for AvahiClientFlags {
#[inline]
fn bitand_assign(&mut self, rhs: AvahiClientFlags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct AvahiClientFlags(pub ::libc::c_uint);
pub type AvahiClientCallback = ::std::option::Option<
unsafe extern "C" fn(
s: *mut AvahiClient,
state: AvahiClientState,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_client_new(
poll_api: *const AvahiPoll,
flags: AvahiClientFlags,
callback: AvahiClientCallback,
userdata: *mut ::libc::c_void,
error: *mut ::libc::c_int,
) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_client_free(client: *mut AvahiClient);
}
extern "C" {
pub fn avahi_client_get_version_string(arg1: *mut AvahiClient) -> *const ::libc::c_char;
}
extern "C" {
pub fn avahi_client_get_host_name(arg1: *mut AvahiClient) -> *const ::libc::c_char;
}
extern "C" {
pub fn avahi_client_set_host_name(
arg1: *mut AvahiClient,
name: *const ::libc::c_char,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_client_get_domain_name(arg1: *mut AvahiClient) -> *const ::libc::c_char;
}
extern "C" {
pub fn avahi_client_get_host_name_fqdn(arg1: *mut AvahiClient) -> *const ::libc::c_char;
}
extern "C" {
pub fn avahi_client_get_state(client: *mut AvahiClient) -> AvahiClientState;
}
extern "C" {
pub fn avahi_client_errno(arg1: *mut AvahiClient) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_client_get_local_service_cookie(client: *mut AvahiClient) -> u32;
}
extern "C" {
pub fn avahi_nss_support() -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiDomainBrowser {
_unused: [u8; 0],
}
pub type AvahiDomainBrowserCallback = ::std::option::Option<
unsafe extern "C" fn(
b: *mut AvahiDomainBrowser,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiBrowserEvent,
domain: *const ::libc::c_char,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_domain_browser_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
domain: *const ::libc::c_char,
btype: AvahiDomainBrowserType,
flags: AvahiLookupFlags,
callback: AvahiDomainBrowserCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiDomainBrowser;
}
extern "C" {
pub fn avahi_domain_browser_get_client(arg1: *mut AvahiDomainBrowser) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_domain_browser_free(arg1: *mut AvahiDomainBrowser) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiServiceBrowser {
_unused: [u8; 0],
}
pub type AvahiServiceBrowserCallback = ::std::option::Option<
unsafe extern "C" fn(
b: *mut AvahiServiceBrowser,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiBrowserEvent,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_service_browser_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
flags: AvahiLookupFlags,
callback: AvahiServiceBrowserCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiServiceBrowser;
}
extern "C" {
pub fn avahi_service_browser_get_client(arg1: *mut AvahiServiceBrowser) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_service_browser_free(arg1: *mut AvahiServiceBrowser) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiServiceTypeBrowser {
_unused: [u8; 0],
}
pub type AvahiServiceTypeBrowserCallback = ::std::option::Option<
unsafe extern "C" fn(
b: *mut AvahiServiceTypeBrowser,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiBrowserEvent,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_service_type_browser_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
domain: *const ::libc::c_char,
flags: AvahiLookupFlags,
callback: AvahiServiceTypeBrowserCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiServiceTypeBrowser;
}
extern "C" {
pub fn avahi_service_type_browser_get_client(
arg1: *mut AvahiServiceTypeBrowser,
) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_service_type_browser_free(arg1: *mut AvahiServiceTypeBrowser) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiServiceResolver {
_unused: [u8; 0],
}
pub type AvahiServiceResolverCallback = ::std::option::Option<
unsafe extern "C" fn(
r: *mut AvahiServiceResolver,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiResolverEvent,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
host_name: *const ::libc::c_char,
a: *const AvahiAddress,
port: u16,
txt: *mut AvahiStringList,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_service_resolver_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
aprotocol: AvahiProtocol,
flags: AvahiLookupFlags,
callback: AvahiServiceResolverCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiServiceResolver;
}
extern "C" {
pub fn avahi_service_resolver_get_client(arg1: *mut AvahiServiceResolver) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_service_resolver_free(r: *mut AvahiServiceResolver) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiHostNameResolver {
_unused: [u8; 0],
}
pub type AvahiHostNameResolverCallback = ::std::option::Option<
unsafe extern "C" fn(
r: *mut AvahiHostNameResolver,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiResolverEvent,
name: *const ::libc::c_char,
a: *const AvahiAddress,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_host_name_resolver_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
name: *const ::libc::c_char,
aprotocol: AvahiProtocol,
flags: AvahiLookupFlags,
callback: AvahiHostNameResolverCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiHostNameResolver;
}
extern "C" {
pub fn avahi_host_name_resolver_get_client(
arg1: *mut AvahiHostNameResolver,
) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_host_name_resolver_free(r: *mut AvahiHostNameResolver) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiAddressResolver {
_unused: [u8; 0],
}
pub type AvahiAddressResolverCallback = ::std::option::Option<
unsafe extern "C" fn(
r: *mut AvahiAddressResolver,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiResolverEvent,
a: *const AvahiAddress,
name: *const ::libc::c_char,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_address_resolver_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
a: *const AvahiAddress,
flags: AvahiLookupFlags,
callback: AvahiAddressResolverCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiAddressResolver;
}
extern "C" {
pub fn avahi_address_resolver_get_client(arg1: *mut AvahiAddressResolver) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_address_resolver_free(r: *mut AvahiAddressResolver) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiRecordBrowser {
_unused: [u8; 0],
}
pub type AvahiRecordBrowserCallback = ::std::option::Option<
unsafe extern "C" fn(
b: *mut AvahiRecordBrowser,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
event: AvahiBrowserEvent,
name: *const ::libc::c_char,
clazz: u16,
type_: u16,
rdata: *const ::libc::c_void,
size: usize,
flags: AvahiLookupResultFlags,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_record_browser_new(
client: *mut AvahiClient,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
name: *const ::libc::c_char,
clazz: u16,
type_: u16,
flags: AvahiLookupFlags,
callback: AvahiRecordBrowserCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiRecordBrowser;
}
extern "C" {
pub fn avahi_record_browser_get_client(arg1: *mut AvahiRecordBrowser) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_record_browser_free(arg1: *mut AvahiRecordBrowser) -> ::libc::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiEntryGroup {
_unused: [u8; 0],
}
pub type AvahiEntryGroupCallback = ::std::option::Option<
unsafe extern "C" fn(
g: *mut AvahiEntryGroup,
state: AvahiEntryGroupState,
userdata: *mut ::libc::c_void,
),
>;
extern "C" {
pub fn avahi_entry_group_new(
c: *mut AvahiClient,
callback: AvahiEntryGroupCallback,
userdata: *mut ::libc::c_void,
) -> *mut AvahiEntryGroup;
}
extern "C" {
pub fn avahi_entry_group_free(arg1: *mut AvahiEntryGroup) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_commit(arg1: *mut AvahiEntryGroup) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_reset(arg1: *mut AvahiEntryGroup) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_get_state(arg1: *mut AvahiEntryGroup) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_is_empty(arg1: *mut AvahiEntryGroup) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_get_client(arg1: *mut AvahiEntryGroup) -> *mut AvahiClient;
}
extern "C" {
pub fn avahi_entry_group_add_service(
group: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
host: *const ::libc::c_char,
port: u16,
...
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_add_service_strlst(
group: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
host: *const ::libc::c_char,
port: u16,
txt: *mut AvahiStringList,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_add_service_subtype(
group: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
subtype: *const ::libc::c_char,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_update_service_txt(
g: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
...
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_update_service_txt_strlst(
g: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
strlst: *mut AvahiStringList,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_add_address(
group: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
a: *const AvahiAddress,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_entry_group_add_record(
group: *mut AvahiEntryGroup,
interface: AvahiIfIndex,
protocol: AvahiProtocol,
flags: AvahiPublishFlags,
name: *const ::libc::c_char,
clazz: u16,
type_: u16,
ttl: u32,
rdata: *const ::libc::c_void,
size: usize,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_alternative_host_name(s: *const ::libc::c_char) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_alternative_service_name(s: *const ::libc::c_char) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_normalize_name(
s: *const ::libc::c_char,
ret_s: *mut ::libc::c_char,
size: usize,
) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_normalize_name_strdup(s: *const ::libc::c_char) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_domain_equal(a: *const ::libc::c_char, b: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_domain_hash(name: *const ::libc::c_char) -> ::libc::c_uint;
}
extern "C" {
pub fn avahi_unescape_label(
name: *mut *const ::libc::c_char,
dest: *mut ::libc::c_char,
size: usize,
) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_escape_label(
src: *const ::libc::c_char,
src_length: usize,
ret_name: *mut *mut ::libc::c_char,
ret_size: *mut usize,
) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_is_valid_service_type_generic(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_is_valid_service_type_strict(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_is_valid_service_subtype(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_is_valid_domain_name(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_is_valid_service_name(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_is_valid_host_name(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_is_valid_fqdn(t: *const ::libc::c_char) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_service_name_join(
p: *mut ::libc::c_char,
size: usize,
name: *const ::libc::c_char,
type_: *const ::libc::c_char,
domain: *const ::libc::c_char,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_service_name_split(
p: *const ::libc::c_char,
name: *mut ::libc::c_char,
name_size: usize,
type_: *mut ::libc::c_char,
type_size: usize,
domain: *mut ::libc::c_char,
domain_size: usize,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_get_type_from_subtype(t: *const ::libc::c_char) -> *const ::libc::c_char;
}
pub const AVAHI_OK: _bindgen_ty_5 = 0;
pub const AVAHI_ERR_FAILURE: _bindgen_ty_5 = -1;
pub const AVAHI_ERR_BAD_STATE: _bindgen_ty_5 = -2;
pub const AVAHI_ERR_INVALID_HOST_NAME: _bindgen_ty_5 = -3;
pub const AVAHI_ERR_INVALID_DOMAIN_NAME: _bindgen_ty_5 = -4;
pub const AVAHI_ERR_NO_NETWORK: _bindgen_ty_5 = -5;
pub const AVAHI_ERR_INVALID_TTL: _bindgen_ty_5 = -6;
pub const AVAHI_ERR_IS_PATTERN: _bindgen_ty_5 = -7;
pub const AVAHI_ERR_COLLISION: _bindgen_ty_5 = -8;
pub const AVAHI_ERR_INVALID_RECORD: _bindgen_ty_5 = -9;
pub const AVAHI_ERR_INVALID_SERVICE_NAME: _bindgen_ty_5 = -10;
pub const AVAHI_ERR_INVALID_SERVICE_TYPE: _bindgen_ty_5 = -11;
pub const AVAHI_ERR_INVALID_PORT: _bindgen_ty_5 = -12;
pub const AVAHI_ERR_INVALID_KEY: _bindgen_ty_5 = -13;
pub const AVAHI_ERR_INVALID_ADDRESS: _bindgen_ty_5 = -14;
pub const AVAHI_ERR_TIMEOUT: _bindgen_ty_5 = -15;
pub const AVAHI_ERR_TOO_MANY_CLIENTS: _bindgen_ty_5 = -16;
pub const AVAHI_ERR_TOO_MANY_OBJECTS: _bindgen_ty_5 = -17;
pub const AVAHI_ERR_TOO_MANY_ENTRIES: _bindgen_ty_5 = -18;
pub const AVAHI_ERR_OS: _bindgen_ty_5 = -19;
pub const AVAHI_ERR_ACCESS_DENIED: _bindgen_ty_5 = -20;
pub const AVAHI_ERR_INVALID_OPERATION: _bindgen_ty_5 = -21;
pub const AVAHI_ERR_DBUS_ERROR: _bindgen_ty_5 = -22;
pub const AVAHI_ERR_DISCONNECTED: _bindgen_ty_5 = -23;
pub const AVAHI_ERR_NO_MEMORY: _bindgen_ty_5 = -24;
pub const AVAHI_ERR_INVALID_OBJECT: _bindgen_ty_5 = -25;
pub const AVAHI_ERR_NO_DAEMON: _bindgen_ty_5 = -26;
pub const AVAHI_ERR_INVALID_INTERFACE: _bindgen_ty_5 = -27;
pub const AVAHI_ERR_INVALID_PROTOCOL: _bindgen_ty_5 = -28;
pub const AVAHI_ERR_INVALID_FLAGS: _bindgen_ty_5 = -29;
pub const AVAHI_ERR_NOT_FOUND: _bindgen_ty_5 = -30;
pub const AVAHI_ERR_INVALID_CONFIG: _bindgen_ty_5 = -31;
pub const AVAHI_ERR_VERSION_MISMATCH: _bindgen_ty_5 = -32;
pub const AVAHI_ERR_INVALID_SERVICE_SUBTYPE: _bindgen_ty_5 = -33;
pub const AVAHI_ERR_INVALID_PACKET: _bindgen_ty_5 = -34;
pub const AVAHI_ERR_INVALID_DNS_ERROR: _bindgen_ty_5 = -35;
pub const AVAHI_ERR_DNS_FORMERR: _bindgen_ty_5 = -36;
pub const AVAHI_ERR_DNS_SERVFAIL: _bindgen_ty_5 = -37;
pub const AVAHI_ERR_DNS_NXDOMAIN: _bindgen_ty_5 = -38;
pub const AVAHI_ERR_DNS_NOTIMP: _bindgen_ty_5 = -39;
pub const AVAHI_ERR_DNS_REFUSED: _bindgen_ty_5 = -40;
pub const AVAHI_ERR_DNS_YXDOMAIN: _bindgen_ty_5 = -41;
pub const AVAHI_ERR_DNS_YXRRSET: _bindgen_ty_5 = -42;
pub const AVAHI_ERR_DNS_NXRRSET: _bindgen_ty_5 = -43;
pub const AVAHI_ERR_DNS_NOTAUTH: _bindgen_ty_5 = -44;
pub const AVAHI_ERR_DNS_NOTZONE: _bindgen_ty_5 = -45;
pub const AVAHI_ERR_INVALID_RDATA: _bindgen_ty_5 = -46;
pub const AVAHI_ERR_INVALID_DNS_CLASS: _bindgen_ty_5 = -47;
pub const AVAHI_ERR_INVALID_DNS_TYPE: _bindgen_ty_5 = -48;
pub const AVAHI_ERR_NOT_SUPPORTED: _bindgen_ty_5 = -49;
pub const AVAHI_ERR_NOT_PERMITTED: _bindgen_ty_5 = -50;
pub const AVAHI_ERR_INVALID_ARGUMENT: _bindgen_ty_5 = -51;
pub const AVAHI_ERR_IS_EMPTY: _bindgen_ty_5 = -52;
pub const AVAHI_ERR_NO_CHANGE: _bindgen_ty_5 = -53;
pub const AVAHI_ERR_MAX: _bindgen_ty_5 = -54;
pub type _bindgen_ty_5 = ::libc::c_int;
extern "C" {
pub fn avahi_strerror(error: ::libc::c_int) -> *const ::libc::c_char;
}
extern "C" {
pub fn __assert_fail(
__assertion: *const ::libc::c_char,
__file: *const ::libc::c_char,
__line: ::libc::c_uint,
__function: *const ::libc::c_char,
) -> !;
}
extern "C" {
pub fn __assert_perror_fail(
__errnum: ::libc::c_int,
__file: *const ::libc::c_char,
__line: ::libc::c_uint,
__function: *const ::libc::c_char,
) -> !;
}
extern "C" {
pub fn __assert(
__assertion: *const ::libc::c_char,
__file: *const ::libc::c_char,
__line: ::libc::c_int,
) -> !;
}
extern "C" {
pub fn avahi_malloc(size: usize) -> *mut ::libc::c_void;
}
extern "C" {
pub fn avahi_malloc0(size: usize) -> *mut ::libc::c_void;
}
extern "C" {
pub fn avahi_free(p: *mut ::libc::c_void);
}
extern "C" {
pub fn avahi_realloc(p: *mut ::libc::c_void, size: usize) -> *mut ::libc::c_void;
}
extern "C" {
pub fn avahi_strdup(s: *const ::libc::c_char) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_strndup(s: *const ::libc::c_char, l: usize) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_memdup(s: *const ::libc::c_void, l: usize) -> *mut ::libc::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiAllocator {
pub malloc: ::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::libc::c_void>,
pub free: ::std::option::Option<unsafe extern "C" fn(p: *mut ::libc::c_void)>,
pub realloc: ::std::option::Option<
unsafe extern "C" fn(p: *mut ::libc::c_void, size: usize) -> *mut ::libc::c_void,
>,
pub calloc: ::std::option::Option<
unsafe extern "C" fn(nmemb: usize, size: usize) -> *mut ::libc::c_void,
>,
}
#[test]
fn bindgen_test_layout_AvahiAllocator() {
const UNINIT: ::std::mem::MaybeUninit<AvahiAllocator> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<AvahiAllocator>(),
16usize,
concat!("Size of: ", stringify!(AvahiAllocator))
);
assert_eq!(
::std::mem::align_of::<AvahiAllocator>(),
4usize,
concat!("Alignment of ", stringify!(AvahiAllocator))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).malloc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(AvahiAllocator),
"::",
stringify!(malloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(AvahiAllocator),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).realloc) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(AvahiAllocator),
"::",
stringify!(realloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).calloc) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(AvahiAllocator),
"::",
stringify!(calloc)
)
);
}
extern "C" {
pub fn avahi_set_allocator(a: *const AvahiAllocator);
}
extern "C" {
pub fn avahi_strdup_printf(fmt: *const ::libc::c_char, ...) -> *mut ::libc::c_char;
}
extern "C" {
pub fn avahi_strdup_vprintf(fmt: *const ::libc::c_char, ap: va_list) -> *mut ::libc::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiSimplePoll {
_unused: [u8; 0],
}
extern "C" {
pub fn avahi_simple_poll_new() -> *mut AvahiSimplePoll;
}
extern "C" {
pub fn avahi_simple_poll_free(s: *mut AvahiSimplePoll);
}
extern "C" {
pub fn avahi_simple_poll_get(s: *mut AvahiSimplePoll) -> *const AvahiPoll;
}
extern "C" {
pub fn avahi_simple_poll_iterate(
s: *mut AvahiSimplePoll,
sleep_time: ::libc::c_int,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_simple_poll_quit(s: *mut AvahiSimplePoll);
}
pub type AvahiPollFunc = ::std::option::Option<
unsafe extern "C" fn(
ufds: *mut pollfd,
nfds: ::libc::c_uint,
timeout: ::libc::c_int,
userdata: *mut ::libc::c_void,
) -> ::libc::c_int,
>;
extern "C" {
pub fn avahi_simple_poll_set_func(
s: *mut AvahiSimplePoll,
func: AvahiPollFunc,
userdata: *mut ::libc::c_void,
);
}
extern "C" {
pub fn avahi_simple_poll_prepare(
s: *mut AvahiSimplePoll,
timeout: ::libc::c_int,
) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_simple_poll_run(s: *mut AvahiSimplePoll) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_simple_poll_dispatch(s: *mut AvahiSimplePoll) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_simple_poll_loop(s: *mut AvahiSimplePoll) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_simple_poll_wakeup(s: *mut AvahiSimplePoll);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AvahiThreadedPoll {
_unused: [u8; 0],
}
extern "C" {
pub fn avahi_threaded_poll_new() -> *mut AvahiThreadedPoll;
}
extern "C" {
pub fn avahi_threaded_poll_free(p: *mut AvahiThreadedPoll);
}
extern "C" {
pub fn avahi_threaded_poll_get(p: *mut AvahiThreadedPoll) -> *const AvahiPoll;
}
extern "C" {
pub fn avahi_threaded_poll_start(p: *mut AvahiThreadedPoll) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_threaded_poll_stop(p: *mut AvahiThreadedPoll) -> ::libc::c_int;
}
extern "C" {
pub fn avahi_threaded_poll_quit(p: *mut AvahiThreadedPoll);
}
extern "C" {
pub fn avahi_threaded_poll_lock(p: *mut AvahiThreadedPoll);
}
extern "C" {
pub fn avahi_threaded_poll_unlock(p: *mut AvahiThreadedPoll);
}
pub type __builtin_va_list = *mut ::libc::c_char;