pollution: u_char pollution: uchar typedef unsigned char u_char, uchar; pollution: u_short pollution: ushort typedef unsigned short u_short, ushort; pollution: u_int pollution: uint typedef unsigned int u_int, uint; pollution: u_long pollution: ulong typedef unsigned long u_long, ulong; pollution: cbindgen_alias_iovec void cbindgen_alias_iovec(struct iovec); pollution: cmsg unsigned char *CMSG_DATA(const struct cmsghdr *cmsg); pollution: mhdr pollution: cmsg struct cmsghdr *CMSG_NXTHDR(const struct msghdr *mhdr, const struct cmsghdr *cmsg); pollution: mhdr struct cmsghdr *CMSG_FIRSTHDR(const struct msghdr *mhdr); pollution: len size_t CMSG_ALIGN(size_t len); pollution: len unsigned int CMSG_SPACE(unsigned int len); pollution: length unsigned int CMSG_LEN(unsigned int length); pollution: address pollution: address_len int accept(int socket, struct sockaddr *address, socklen_t *address_len); pollution: address pollution: address_len int bind(int socket, const struct sockaddr *address, socklen_t address_len); pollution: address pollution: address_len int connect(int socket, const struct sockaddr *address, socklen_t address_len); pollution: address pollution: address_len int getpeername(int socket, struct sockaddr *address, socklen_t *address_len); pollution: address pollution: address_len int getsockname(int socket, struct sockaddr *address, socklen_t *address_len); pollution: level pollution: option_name pollution: option_value pollution: option_len int getsockopt(int socket, int level, int option_name, void *option_value, socklen_t *option_len); pollution: backlog int listen(int socket, int backlog); pollution: buffer pollution: length pollution: flags ssize_t recv(int socket, void *buffer, size_t length, int flags); pollution: buffer pollution: length pollution: flags pollution: address pollution: address_len ssize_t recvfrom(int socket, void *buffer, size_t length, int flags, struct sockaddr *address, socklen_t *address_len); pollution: msg pollution: flags ssize_t recvmsg(int socket, struct msghdr *msg, int flags); pollution: message pollution: length pollution: flags ssize_t send(int socket, const void *message, size_t length, int flags); pollution: msg pollution: flags ssize_t sendmsg(int socket, const struct msghdr *msg, int flags); pollution: message pollution: length pollution: flags pollution: dest_addr pollution: dest_len ssize_t sendto(int socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len); pollution: level pollution: option_name pollution: option_value pollution: option_len int setsockopt(int socket, int level, int option_name, const void *option_value, socklen_t option_len); pollution: how int shutdown(int socket, int how); pollution: domain pollution: kind pollution: protocol int socket(int domain, int kind, int protocol); pollution: domain pollution: kind pollution: protocol pollution: sv int socketpair(int domain, int kind, int protocol, int *sv); pollution: pid pid_t pid; pollution: uid uid_t uid; pollution: gid gid_t gid; pollution: ucred struct ucred { pid_t pid; uid_t uid; gid_t gid; }; pollution: va_list typedef __gnuc_va_list va_list; pollution: FILE pollution: FILE typedef struct FILE FILE; pollution: stdin extern FILE *stdin; pollution: stdout extern FILE *stdout; pollution: stderr extern FILE *stderr; pollution: stream pollution: clearerr void clearerr(FILE *stream); pollution: s pollution: ctermid char *ctermid(char *s); pollution: stream pollution: fclose int fclose(FILE *stream); pollution: fildes pollution: mode pollution: fdopen FILE *fdopen(int fildes, const char *mode); pollution: stream pollution: feof int feof(FILE *stream); pollution: stream pollution: ferror int ferror(FILE *stream); pollution: stream pollution: fflush int fflush(FILE *stream); pollution: stream pollution: fgetc int fgetc(FILE *stream); pollution: stream pollution: pos pollution: fgetpos int fgetpos(FILE *stream, fpos_t *pos); pollution: original pollution: max pollution: stream pollution: fgets char *fgets(char *original, int max, FILE *stream); pollution: stream pollution: fileno int fileno(FILE *stream); pollution: file pollution: flockfile void flockfile(FILE *file); pollution: filename pollution: mode pollution: fopen FILE *fopen(const char *filename, const char *mode); pollution: stream void __fpurge(FILE *stream); pollution: c pollution: stream pollution: fputc int fputc(int c, FILE *stream); pollution: s pollution: stream pollution: fputs int fputs(const char *s, FILE *stream); pollution: ptr pollution: size pollution: nitems pollution: stream pollution: fread size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream); pollution: filename pollution: mode pollution: stream pollution: freopen FILE *freopen(const char *filename, const char *mode, FILE *stream); pollution: stream pollution: offset pollution: whence pollution: fseek int fseek(FILE *stream, long offset, int whence); pollution: stream pollution: off pollution: whence pollution: fseeko int fseeko(FILE *stream, off_t off, int whence); pollution: stream pollution: pos pollution: fsetpos int fsetpos(FILE *stream, const fpos_t *pos); pollution: stream pollution: ftell long ftell(FILE *stream); pollution: stream pollution: ftello off_t ftello(FILE *stream); pollution: file pollution: ftrylockfile int ftrylockfile(FILE *file); pollution: file pollution: funlockfile void funlockfile(FILE *file); pollution: ptr pollution: size pollution: nitems pollution: stream pollution: fwrite size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream); pollution: stream pollution: getc int getc(FILE *stream); pollution: getchar int getchar(void); pollution: stream pollution: getc_unlocked int getc_unlocked(FILE *stream); pollution: getchar_unlocked int getchar_unlocked(void); pollution: s pollution: gets char *gets(char *s); pollution: stream pollution: getw int getw(FILE *stream); pollution: stream pollution: pclose int pclose(FILE *stream); pollution: s pollution: perror void perror(const char *s); pollution: command pollution: mode pollution: popen FILE *popen(const char *command, const char *mode); pollution: c pollution: stream pollution: putc int putc(int c, FILE *stream); pollution: c pollution: putchar int putchar(int c); pollution: c pollution: stream pollution: putc_unlocked int putc_unlocked(int c, FILE *stream); pollution: c pollution: putchar_unlocked int putchar_unlocked(int c); pollution: s pollution: puts int puts(const char *s); pollution: w pollution: stream pollution: putw int putw(int w, FILE *stream); pollution: path pollution: remove int remove(const char *path); pollution: oldpath pollution: newpath pollution: rename int rename(const char *oldpath, const char *newpath); pollution: old_dir pollution: old_path pollution: new_dir pollution: new_path pollution: renameat int renameat(int old_dir, const char *old_path, int new_dir, const char *new_path); pollution: old_dir pollution: old_path pollution: new_dir pollution: new_path pollution: flags pollution: renameat2 int renameat2(int old_dir, const char *old_path, int new_dir, const char *new_path, unsigned int flags); pollution: stream pollution: rewind void rewind(FILE *stream); pollution: stream pollution: buf pollution: setbuf void setbuf(FILE *stream, char *buf); pollution: stream pollution: setlinebuf void setlinebuf(FILE *stream); pollution: stream pollution: buf pollution: mode pollution: size pollution: setvbuf int setvbuf(FILE *stream, char *buf, int mode, size_t size); pollution: dir pollution: pfx pollution: tempnam char *tempnam(const char *dir, const char *pfx); pollution: tmpfile FILE *tmpfile(void); pollution: s pollution: tmpnam char *tmpnam(char *s); pollution: c pollution: stream pollution: ungetc int ungetc(int c, FILE *stream); pollution: file pollution: format pollution: ap pollution: vfprintf int vfprintf(FILE *file, const char *format, va_list ap); pollution: file pollution: format pollution: fprintf int fprintf(FILE *file, const char *format, ...); pollution: fd pollution: format pollution: ap pollution: vdprintf int vdprintf(int fd, const char *format, va_list ap); pollution: fd pollution: format pollution: dprintf int dprintf(int fd, const char *format, ...); pollution: format pollution: ap pollution: vprintf int vprintf(const char *format, va_list ap); pollution: format pollution: printf int printf(const char *format, ...); pollution: strp pollution: format pollution: ap pollution: vasprintf int vasprintf(char **strp, const char *format, va_list ap); pollution: strp pollution: format pollution: asprintf int asprintf(char **strp, const char *format, ...); pollution: s pollution: n pollution: format pollution: ap pollution: vsnprintf int vsnprintf(char *s, size_t n, const char *format, va_list ap); pollution: s pollution: n pollution: format pollution: snprintf int snprintf(char *s, size_t n, const char *format, ...); pollution: s pollution: format pollution: ap pollution: vsprintf int vsprintf(char *s, const char *format, va_list ap); pollution: s pollution: format pollution: sprintf int sprintf(char *s, const char *format, ...); pollution: file pollution: format pollution: ap pollution: vfscanf int vfscanf(FILE *file, const char *format, va_list ap); pollution: file pollution: format pollution: fscanf int fscanf(FILE *file, const char *format, ...); pollution: format pollution: ap pollution: vscanf int vscanf(const char *format, va_list ap); pollution: format pollution: scanf int scanf(const char *format, ...); pollution: s pollution: format pollution: ap pollution: vsscanf int vsscanf(const char *s, const char *format, va_list ap); pollution: s pollution: format pollution: sscanf int sscanf(const char *s, const char *format, ...); pollution: lineptr pollution: n pollution: stream pollution: getline ssize_t getline(char **lineptr, size_t *n, FILE *stream); pollution: lineptr pollution: n pollution: delim pollution: stream pollution: getdelim ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream); pollution: stream size_t __fpending(FILE *stream); pollution: stream int __freadable(FILE *stream); pollution: stream int __fwritable(FILE *stream); pollution: stream int __freading(FILE *stream); pollution: stream int __fwriting(FILE *stream); pollution: FILE pollution: FILE typedef struct FILE FILE; pollution: tv_sec time_t tv_sec; pollution: tv_nsec long tv_nsec; pollution: timespec struct timespec { time_t tv_sec; long tv_nsec; }; pollution: timespec pollution: cbindgen_stupid_alias_timespec void cbindgen_stupid_alias_timespec(struct timespec); pollution: sigevent struct sigevent; pollution: tm_sec int tm_sec; pollution: tm_min int tm_min; pollution: tm_hour int tm_hour; pollution: tm_mday int tm_mday; pollution: tm_mon int tm_mon; pollution: tm_year int tm_year; pollution: tm_wday int tm_wday; pollution: tm_yday int tm_yday; pollution: tm_isdst int tm_isdst; pollution: tm_gmtoff long tm_gmtoff; pollution: tm_zone const char *tm_zone; pollution: tm struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; long tm_gmtoff; const char *tm_zone; }; pollution: timespec pollution: it_interval struct timespec it_interval; pollution: timespec pollution: it_value struct timespec it_value; pollution: itimerspec struct itimerspec { struct timespec it_interval; struct timespec it_value; }; pollution: TzName typedef char *TzName[2]; pollution: daylight extern int daylight; pollution: timezone extern long timezone; pollution: tzname extern TzName tzname; pollution: getdate_err extern int getdate_err; pollution: tm pollution: timeptr pollution: asctime [[deprecated]] char *asctime(const struct tm *timeptr); pollution: tm pollution: tm pollution: buf pollution: asctime_r [[deprecated]] char *asctime_r(const struct tm *tm, char *buf); pollution: clock clock_t clock(void); pollution: clock_id pollution: timespec pollution: res pollution: clock_getres int clock_getres(clockid_t clock_id, struct timespec *res); pollution: clock_id pollution: timespec pollution: tp pollution: clock_gettime int clock_gettime(clockid_t clock_id, struct timespec *tp); pollution: clock_id pollution: timespec pollution: tp pollution: clock_settime int clock_settime(clockid_t clock_id, const struct timespec *tp); pollution: clock pollution: ctime [[deprecated]] char *ctime(const time_t *clock); pollution: clock pollution: buf pollution: ctime_r [[deprecated]] char *ctime_r(const time_t *clock, char *buf); pollution: time1 pollution: time0 pollution: difftime double difftime(time_t time1, time_t time0); pollution: tm pollution: timer pollution: gmtime struct tm *gmtime(const time_t *timer); pollution: tm pollution: clock pollution: tm pollution: result pollution: gmtime_r struct tm *gmtime_r(const time_t *clock, struct tm *result); pollution: tm pollution: clock pollution: localtime struct tm *localtime(const time_t *clock); pollution: tm pollution: clock pollution: tm pollution: t pollution: localtime_r struct tm *localtime_r(const time_t *clock, struct tm *t); pollution: tm pollution: timeptr pollution: mktime time_t mktime(struct tm *timeptr); pollution: timespec pollution: rqtp pollution: timespec pollution: rmtp pollution: nanosleep int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); pollution: s pollution: maxsize pollution: format pollution: tm pollution: timeptr pollution: strftime size_t strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr); pollution: tloc pollution: time time_t time(time_t *tloc); pollution: tm pollution: tm pollution: timegm time_t timegm(struct tm *tm); pollution: tm pollution: tm pollution: timelocal [[deprecated]] time_t timelocal(struct tm *tm); pollution: clock_id pollution: sigevent pollution: evp pollution: timerid pollution: timer_create int timer_create(clockid_t clock_id, struct sigevent *evp, timer_t *timerid); pollution: timerid pollution: timer_delete int timer_delete(timer_t timerid); pollution: timerid pollution: itimerspec pollution: value pollution: timer_gettime int timer_gettime(timer_t timerid, struct itimerspec *value); pollution: timerid pollution: flags pollution: itimerspec pollution: value pollution: itimerspec pollution: ovalue pollution: timer_settime int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue); pollution: timespec pollution: tp pollution: base pollution: timespec_get int timespec_get(struct timespec *tp, int base); pollution: timespec pollution: res pollution: base pollution: timespec_getres int timespec_getres(struct timespec *res, int base); pollution: tzset void tzset(void); pollution: buf pollution: format pollution: tm pollution: tm pollution: strptime char *strptime(const char *buf, const char *format, struct tm *tm); pollution: c pollution: btowc wint_t btowc(int c); pollution: stream pollution: fgetwc wint_t fgetwc(FILE *stream); pollution: ws pollution: n pollution: stream pollution: fgetws wchar_t *fgetws(wchar_t *ws, int n, FILE *stream); pollution: wc pollution: stream pollution: fputwc wint_t fputwc(wchar_t wc, FILE *stream); pollution: ws pollution: stream pollution: fputws int fputws(const wchar_t *ws, FILE *stream); pollution: stream pollution: mode pollution: fwide int fwide(FILE *stream, int mode); pollution: stream pollution: format pollution: fwscanf int fwscanf(FILE *stream, const wchar_t *format, ...); pollution: stream pollution: getwc wint_t getwc(FILE *stream); pollution: getwchar wint_t getwchar(void); pollution: ps pollution: mbsinit int mbsinit(const mbstate_t *ps); pollution: s pollution: n pollution: ps pollution: mbrlen size_t mbrlen(const char *s, size_t n, mbstate_t *ps); pollution: pwc pollution: s pollution: n pollution: ps pollution: mbrtowc size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps); pollution: dst_ptr pollution: src_ptr pollution: src_len pollution: dst_len pollution: ps pollution: mbsnrtowcs size_t mbsnrtowcs(wchar_t *dst_ptr, const char **src_ptr, size_t src_len, size_t dst_len, mbstate_t *ps); pollution: dst pollution: src pollution: len pollution: ps pollution: mbsrtowcs size_t mbsrtowcs(wchar_t *dst, const char **src, size_t len, mbstate_t *ps); pollution: wc pollution: stream pollution: putwc wint_t putwc(wchar_t wc, FILE *stream); pollution: wc pollution: putwchar wint_t putwchar(wchar_t wc); pollution: s pollution: format pollution: vswscanf int vswscanf(const wchar_t *s, const wchar_t *format, va_list __valist); pollution: s pollution: format pollution: swscanf int swscanf(const wchar_t *s, const wchar_t *format, ...); pollution: wc pollution: stream pollution: ungetwc wint_t ungetwc(wint_t wc, FILE *stream); pollution: stream pollution: format pollution: arg pollution: vfwprintf int vfwprintf(FILE *stream, const wchar_t *format, va_list arg); pollution: stream pollution: format pollution: fwprintf int fwprintf(FILE *stream, const wchar_t *format, ...); pollution: format pollution: arg pollution: vwprintf int vwprintf(const wchar_t *format, va_list arg); pollution: format pollution: wprintf int wprintf(const wchar_t *format, ...); pollution: s pollution: n pollution: format pollution: arg pollution: vswprintf int vswprintf(wchar_t *s, size_t n, const wchar_t *format, va_list arg); pollution: s pollution: n pollution: format pollution: swprintf int swprintf(wchar_t *s, size_t n, const wchar_t *format, ...); pollution: d pollution: s pollution: wcpcpy wchar_t *wcpcpy(wchar_t *d, const wchar_t *s); pollution: d pollution: s pollution: n pollution: wcpncpy wchar_t *wcpncpy(wchar_t *d, const wchar_t *s, size_t n); pollution: s pollution: wc pollution: ps pollution: wcrtomb size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps); pollution: s pollution: wcsdup wchar_t *wcsdup(const wchar_t *s); pollution: s pollution: ws pollution: n pollution: st pollution: wcsrtombs size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st); pollution: ws1 pollution: ws2 pollution: wcscat wchar_t *wcscat(wchar_t *ws1, const wchar_t *ws2); pollution: ws pollution: wc pollution: wcschr wchar_t *wcschr(const wchar_t *ws, wchar_t wc); pollution: ws1 pollution: ws2 pollution: wcscmp int wcscmp(const wchar_t *ws1, const wchar_t *ws2); pollution: ws1 pollution: ws2 pollution: wcscoll int wcscoll(const wchar_t *ws1, const wchar_t *ws2); pollution: ws1 pollution: ws2 pollution: wcscpy wchar_t *wcscpy(wchar_t *ws1, const wchar_t *ws2); pollution: wcs pollution: set pollution: wcscspn size_t wcscspn(const wchar_t *wcs, const wchar_t *set); pollution: wcs pollution: maxsize pollution: format pollution: tm pollution: timptr pollution: wcsftime size_t wcsftime(wchar_t *wcs, size_t maxsize, const wchar_t *format, const struct tm *timptr); pollution: ws pollution: wcslen size_t wcslen(const wchar_t *ws); pollution: ws1 pollution: ws2 pollution: n pollution: wcsncat wchar_t *wcsncat(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wcsncmp int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wcsncpy wchar_t *wcsncpy(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: s pollution: maxlen pollution: wcsnlen size_t wcsnlen(const wchar_t *s, size_t maxlen); pollution: dest pollution: src pollution: nwc pollution: len pollution: ps pollution: wcsnrtombs size_t wcsnrtombs(char *dest, const wchar_t **src, size_t nwc, size_t len, mbstate_t *ps); pollution: wcs pollution: set pollution: wcspbrk wchar_t *wcspbrk(const wchar_t *wcs, const wchar_t *set); pollution: ws1 pollution: wc pollution: wcsrchr wchar_t *wcsrchr(const wchar_t *ws1, wchar_t wc); pollution: wcs pollution: set pollution: wcsspn size_t wcsspn(const wchar_t *wcs, const wchar_t *set); pollution: ws1 pollution: ws2 pollution: wcsstr wchar_t *wcsstr(const wchar_t *ws1, const wchar_t *ws2); pollution: ptr pollution: end pollution: wcstod double wcstod(const wchar_t *ptr, wchar_t **end); pollution: wcs pollution: delim pollution: state pollution: wcstok wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **state); pollution: ptr pollution: end pollution: base pollution: wcstol long wcstol(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoll long long wcstoll(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoul unsigned long wcstoul(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base pollution: wcstoull unsigned long long wcstoull(const wchar_t *ptr, wchar_t **end, int base); pollution: ws1 pollution: ws2 pollution: wcswcs wchar_t *wcswcs(const wchar_t *ws1, const wchar_t *ws2); pollution: pwcs pollution: n pollution: wcswidth int wcswidth(const wchar_t *pwcs, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wcsxfrm size_t wcsxfrm(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: c pollution: wctob int wctob(wint_t c); pollution: wc pollution: wcwidth int wcwidth(wchar_t wc); pollution: ws pollution: wc pollution: n pollution: wmemchr wchar_t *wmemchr(const wchar_t *ws, wchar_t wc, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wmemcmp int wmemcmp(const wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wmemcpy wchar_t *wmemcpy(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws1 pollution: ws2 pollution: n pollution: wmemmove wchar_t *wmemmove(wchar_t *ws1, const wchar_t *ws2, size_t n); pollution: ws pollution: wc pollution: n pollution: wmemset wchar_t *wmemset(wchar_t *ws, wchar_t wc, size_t n); pollution: stream pollution: format pollution: vfwscanf int vfwscanf(FILE *stream, const wchar_t *format, va_list __valist); pollution: format pollution: vwscanf int vwscanf(const wchar_t *format, va_list __valist); pollution: format pollution: wscanf int wscanf(const wchar_t *format, ...); pollution: s1 pollution: s2 pollution: wcscasecmp int wcscasecmp(const wchar_t *s1, const wchar_t *s2); pollution: s1 pollution: s2 pollution: n pollution: wcsncasecmp int wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n); pollution: i intmax_t imaxabs(intmax_t i); pollution: i pollution: j imaxdiv_t imaxdiv(intmax_t i, intmax_t j); pollution: s pollution: endptr pollution: base intmax_t strtoimax(const char *s, char **endptr, int base); pollution: s pollution: endptr pollution: base uintmax_t strtoumax(const char *s, char **endptr, int base); pollution: ptr pollution: end pollution: base intmax_t wcstoimax(const wchar_t *ptr, wchar_t **end, int base); pollution: ptr pollution: end pollution: base uintmax_t wcstoumax(const wchar_t *ptr, wchar_t **end, int base); pollution: hostlong uint32_t htonl(uint32_t hostlong); pollution: hostshort uint16_t htons(uint16_t hostshort); pollution: netlong uint32_t ntohl(uint32_t netlong); pollution: netshort uint16_t ntohs(uint16_t netshort); pollution: imr_multiaddr struct in_addr imr_multiaddr; pollution: imr_interface struct in_addr imr_interface; pollution: imr_multiaddr struct in_addr imr_multiaddr; pollution: imr_interface struct in_addr imr_interface; pollution: imr_sourceaddr struct in_addr imr_sourceaddr; pollution: gr_interface uint32_t gr_interface; pollution: gr_group struct sockaddr_storage gr_group; pollution: group_req struct group_req { uint32_t gr_interface; struct sockaddr_storage gr_group; }; pollution: gsr_interface uint32_t gsr_interface; pollution: gsr_group struct sockaddr_storage gsr_group; pollution: gsr_source struct sockaddr_storage gsr_source; pollution: group_source_req struct group_source_req { uint32_t gsr_interface; struct sockaddr_storage gsr_group; struct sockaddr_storage gsr_source; }; pollution: v pollution: length pollution: format pollution: gethostbyaddr [[deprecated]] struct hostent *gethostbyaddr(const void *v, socklen_t length, int format); pollution: name pollution: gethostbyname [[deprecated]] struct hostent *gethostbyname(const char *name); pollution: name struct netent *getnetbyname(const char *name); pollution: name struct protoent *getprotobyname(const char *name); pollution: number struct protoent *getprotobynumber(int number); pollution: name pollution: proto struct servent *getservbyname(const char *name, const char *proto); pollution: port pollution: proto struct servent *getservbyport(int port, const char *proto); pollution: stayopen void setnetent(int stayopen); pollution: stayopen void setprotoent(int stayopen); pollution: stayopen void setservent(int stayopen); pollution: node pollution: service pollution: hints pollution: res int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res); pollution: addr pollution: addrlen pollution: host pollution: hostlen pollution: serv pollution: servlen pollution: flags int getnameinfo(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags); pollution: res void freeaddrinfo(struct addrinfo *res); pollution: errcode const char *gai_strerror(int errcode); pollution: errcode pollution: hstrerror [[deprecated]] const char *hstrerror(int errcode); pollution: prefix pollution: herror [[deprecated]] void herror(const char *prefix); pollution: stayopen void sethostent(int stayopen); pollution: NI_MAXSERV #define NI_MAXSERV 32 pollution: F_BADJ #define F_BADJ 256 pollution: TIME_UTC #define TIME_UTC (CLOCK_REALTIME + 1) pollution: stderr #define stderr stderr pollution: va_start #define va_start(v,l) __builtin_va_start(v,l) pollution: MCAST_LEAVE_SOURCE_GROUP #define MCAST_LEAVE_SOURCE_GROUP 47 pollution: MCAST_JOIN_SOURCE_GROUP #define MCAST_JOIN_SOURCE_GROUP 46 pollution: WEOF #define WEOF (0xffffffffu) pollution: RENAME_NOREPLACE #define RENAME_NOREPLACE 1 pollution: F_PERM #define F_PERM 1 pollution: PTHREAD_COND_INITIALIZER #define PTHREAD_COND_INITIALIZER ((pthread_cond_t){0}) pollution: CLOCK_REALTIME #define CLOCK_REALTIME 1 pollution: F_NORD #define F_NORD 4 pollution: TMP_MAX #define TMP_MAX 2147483647 pollution: L_tmpnam #define L_tmpnam 7 pollution: offsetof #define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER) pollution: SEEK_CUR #define SEEK_CUR 1 pollution: pthread_cleanup_pop #define pthread_cleanup_pop(EXECUTE) __relibc_internal_pthread_cleanup_pop((EXECUTE)); } while(0) pollution: L_ctermid #define L_ctermid 9 pollution: F_SVB #define F_SVB 64 pollution: PTHREAD_MUTEX_INITIALIZER #define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t){0}) pollution: NO_RECOVERY #define NO_RECOVERY 3 pollution: pthread_cleanup_push #define pthread_cleanup_push(ROUTINE,ARG) do { struct { void (*routine)(void *); void *arg; void *prev; } __relibc_internal_pthread_ll_entry = { .routine = (void (*)(void *))(ROUTINE), .arg = (void *)(ARG), }; __relibc_internal_pthread_cleanup_push(&__relibc_internal_pthread_ll_entry); pollution: PTHREAD_RWLOCK_INITIALIZER #define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t){0}) pollution: HOST_NOT_FOUND #define HOST_NOT_FOUND 1 pollution: CLOCKS_PER_SEC #define CLOCKS_PER_SEC 1000000 pollution: F_EOF #define F_EOF 16 pollution: SEEK_SET #define SEEK_SET 0 pollution: EAI_NODATA #define EAI_NODATA -5 pollution: F_ERR #define F_ERR 32 pollution: NULL #define NULL ((void *)0) pollution: va_copy #define va_copy(d,s) __builtin_va_copy(d,s) pollution: NO_DATA #define NO_DATA 2 pollution: TIMER_ABSTIME #define TIMER_ABSTIME 1 pollution: CLOCK_MONOTONIC #define CLOCK_MONOTONIC 4 pollution: FILENAME_MAX #define FILENAME_MAX 4096 pollution: BUFSIZ #define BUFSIZ 1024 pollution: CLOCK_PROCESS_CPUTIME_ID #define CLOCK_PROCESS_CPUTIME_ID 2 pollution: stdout #define stdout stdout pollution: EOF #define EOF -1 pollution: EAI_ADDRFAMILY #define EAI_ADDRFAMILY -9 pollution: NI_MAXHOST #define NI_MAXHOST 1025 pollution: va_arg #define va_arg(v,l) __builtin_va_arg(v,l) pollution: F_NOWR #define F_NOWR 8 pollution: P_tmpdir #define P_tmpdir "/tmp" pollution: PTHREAD_ONCE_INIT #define PTHREAD_ONCE_INIT ((pthread_once_t){0}) pollution: va_end #define va_end(v) __builtin_va_end(v) pollution: stdin #define stdin stdin pollution: TIME_MONOTONIC #define TIME_MONOTONIC (CLOCK_MONOTONIC + 1)