#include "daprobe.h"
#include "probeinfo.h"
#include "dautil.h"
+#include "dahelper.h"
#include "da_socket.h"
static enum DaOptions _sopt = OPT_FILE;
{
static int (*socketp)(int domain, int type, int protocol);
- BEFORE_ORIGINAL_NOFILTER(socket, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(socket, LIBC);
ret = socketp(domain, type, protocol);
{
static int (*socketpairp)(int domain, int type, int protocol,int socket_vector[2]);
- BEFORE_ORIGINAL_NOFILTER(socketpair, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(socketpair, LIBC);
ret = socketpairp(domain, type, protocol, socket_vector);
{
static int (*shutdownp)(int socket, int how);
- BEFORE_ORIGINAL_NOFILTER(shutdown, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(shutdown, LIBC);
ret = shutdownp(socket, how);
{
static int (*bindp)(int socket, const struct sockaddr *address, socklen_t address_len);
- BEFORE_ORIGINAL(bind, libc.so.6);
+ BEFORE_ORIGINAL(bind, LIBC);
ret = bindp(socket, address, address_len);
{
static int (*listenp)(int socket, int backlog);
- BEFORE_ORIGINAL(listen, libc.so.6);
+ BEFORE_ORIGINAL(listen, LIBC);
ret = listenp(socket, backlog);
{
static int (*acceptp)(int socket, struct sockaddr *address, socklen_t *address_len);
- BEFORE_ORIGINAL_NOFILTER(accept, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(accept, LIBC);
ret = acceptp(socket, address, address_len);
{
static int (*accept4p)(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
- BEFORE_ORIGINAL_NOFILTER(accept4, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(accept4, LIBC);
ret = accept4p(sockfd, addr, addrlen, flags);
{
static int (*connectp)(int socket, const struct sockaddr *address, socklen_t address_len);
- BEFORE_ORIGINAL(connect, libc.so.6);
+ BEFORE_ORIGINAL(connect, LIBC);
ret = connectp(socket, address, address_len);
{
static int (*selectp)(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
- BEFORE_ORIGINAL(select, libc.so.6);
+ BEFORE_ORIGINAL(select, LIBC);
ret = selectp(nfds, readfds, writefds,exceptfds, timeout);
{
static int (*pselectp)(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, const struct timespec *ntimeout, const sigset_t *sigmask);
- BEFORE_ORIGINAL(pselect, libc.so.6);
+ BEFORE_ORIGINAL(pselect, LIBC);
ret = pselectp(nfds, readfds, writefds,exceptfds, ntimeout, sigmask);
static ssize_t (*sendp)(int socket, const void *message, size_t length, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(send, libc.so.6);
+ BEFORE_ORIGINAL(send, LIBC);
sret = sendp(socket, message, length, flags);
static ssize_t (*sendmsgp)(int socket, const struct msghdr *message, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(sendmsg, libc.so.6);
+ BEFORE_ORIGINAL(sendmsg, LIBC);
sret = sendmsgp(socket, message, flags);
static ssize_t (*sendtop)(int socket, const void *message, size_t length, int flags,const struct sockaddr *dest_addr, socklen_t dest_len);
ssize_t sret;
- BEFORE_ORIGINAL(sendto, libc.so.6);
+ BEFORE_ORIGINAL(sendto, LIBC);
sret = sendtop(socket, message, length, flags, dest_addr, dest_len);
static ssize_t (*recvp)(int socket, void *buffer, size_t length, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(recv, libc.so.6);
+ BEFORE_ORIGINAL(recv, LIBC);
sret = recvp(socket, buffer, length, flags);
static ssize_t (*recvfromp)(int socket, void *buffer, size_t length, int flags, struct sockaddr *address, socklen_t *address_len);
ssize_t sret;
- BEFORE_ORIGINAL(recvfrom, libc.so.6);
+ BEFORE_ORIGINAL(recvfrom, LIBC);
sret = recvfromp(socket, buffer, length, flags, address, address_len);
static ssize_t (*recvmsgp)(int socket, struct msghdr *message, int flags);
ssize_t sret;
- BEFORE_ORIGINAL(recvmsg, libc.so.6);
+ BEFORE_ORIGINAL(recvmsg, LIBC);
sret = recvmsgp(socket, message, flags);
static uint32_t (*htonlp)(uint32_t hostlong);
uint32_t uret;
- BEFORE_ORIGINAL(htonl, libc.so.6);
+ BEFORE_ORIGINAL(htonl, LIBC);
uret = htonlp(hostlong);
static uint16_t (*htonsp)(uint16_t hostshort);
uint16_t uret;
- BEFORE_ORIGINAL(htons, libc.so.6);
+ BEFORE_ORIGINAL(htons, LIBC);
uret = htonsp(hostshort);
static uint32_t (*ntohlp)(uint32_t netlong);
uint32_t uret;
- BEFORE_ORIGINAL(ntohl, libc.so.6);
+ BEFORE_ORIGINAL(ntohl, LIBC);
uret = ntohlp(netlong);
static uint16_t (*ntohsp)(uint16_t netshort);
uint16_t uret;
- BEFORE_ORIGINAL(ntohs, libc.so.6);
+ BEFORE_ORIGINAL(ntohs, LIBC);
uret = ntohsp(netshort);
static uint16_t (*htobe16p)(uint16_t host_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(htobe16, libc.so.6);
+ BEFORE_ORIGINAL(htobe16, LIBC);
uret = htobe16p(host_16bits);
static uint16_t (*htole16p)(uint16_t host_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(htole16, libc.so.6);
+ BEFORE_ORIGINAL(htole16, LIBC);
uret = htole16p(host_16bits);
static uint16_t (*be16tohp)(uint16_t big_endian_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(be16toh, libc.so.6);
+ BEFORE_ORIGINAL(be16toh, LIBC);
uret = be16tohp(big_endian_16bits);
static uint16_t (*le16tohp)(uint16_t little_endian_16bits);
uint16_t uret;
- BEFORE_ORIGINAL(le16toh, libc.so.6);
+ BEFORE_ORIGINAL(le16toh, LIBC);
uret = le16tohp(little_endian_16bits);
static uint32_t (*htobe32p)(uint32_t host_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(htobe32, libc.so.6);
+ BEFORE_ORIGINAL(htobe32, LIBC);
uret = htobe32p(host_32bits);
static uint32_t (*htole32p)(uint32_t host_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(htole32, libc.so.6);
+ BEFORE_ORIGINAL(htole32, LIBC);
uret = htole32p(host_32bits);
static uint32_t (*be32tohp)(uint32_t big_endian_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(be32toh, libc.so.6);
+ BEFORE_ORIGINAL(be32toh, LIBC);
uret = be32tohp(big_endian_32bits);
static uint32_t (*le32tohp)(uint32_t little_endian_32bits);
uint32_t uret;
- BEFORE_ORIGINAL(le32toh, libc.so.6);
+ BEFORE_ORIGINAL(le32toh, LIBC);
uret = le32tohp(little_endian_32bits);
static uint64_t (*htobe64p)(uint64_t host_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(htobe64, libc.so.6);
+ BEFORE_ORIGINAL(htobe64, LIBC);
uret = htobe64p(host_64bits);
static uint64_t (*htole64p)(uint64_t host_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(htole64, libc.so.6);
+ BEFORE_ORIGINAL(htole64, LIBC);
uret = htole64p(host_64bits);
static uint64_t (*be64tohp)(uint64_t big_endian_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(be64toh, libc.so.6);
+ BEFORE_ORIGINAL(be64toh, LIBC);
uret = be64tohp(big_endian_64bits);
static uint64_t (*le64tohp)(uint64_t little_endian_64bits);
uint64_t uret;
- BEFORE_ORIGINAL(le64toh, libc.so.6);
+ BEFORE_ORIGINAL(le64toh, LIBC);
uret = le64tohp(little_endian_64bits);
{
static int (*inet_atonp)(const char *cp, struct in_addr *inp);
- BEFORE_ORIGINAL(inet_aton, libc.so.6);
+ BEFORE_ORIGINAL(inet_aton, LIBC);
ret = inet_atonp(cp,inp);
static in_addr_t (*inet_addrp)(const char *cp);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_addr, libc.so.6);
+ BEFORE_ORIGINAL(inet_addr, LIBC);
iret = inet_addrp(cp);
static in_addr_t (*inet_networkp)(const char *cp);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_network, libc.so.6);
+ BEFORE_ORIGINAL(inet_network, LIBC);
iret = inet_networkp(cp);
static char * (*inet_ntoap)(struct in_addr in);
char* sret;
- BEFORE_ORIGINAL(inet_ntoa, libc.so.6);
+ BEFORE_ORIGINAL(inet_ntoa, LIBC);
sret = inet_ntoap(in);
static struct in_addr (*inet_makeaddrp)(int net, int host);
struct in_addr iret;
- BEFORE_ORIGINAL(inet_makeaddr, libc.so.6);
+ BEFORE_ORIGINAL(inet_makeaddr, LIBC);
iret = inet_makeaddrp(net,host);
static in_addr_t (*inet_lnaofp)(struct in_addr in);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_lnaof, libc.so.6);
+ BEFORE_ORIGINAL(inet_lnaof, LIBC);
iret = inet_lnaofp(in);
static in_addr_t (*inet_netofp)(struct in_addr in);
in_addr_t iret;
- BEFORE_ORIGINAL(inet_netof, libc.so.6);
+ BEFORE_ORIGINAL(inet_netof, LIBC);
iret = inet_netofp(in);
static const char* (*inet_ntopp)(int af, const void *src, char *dst, socklen_t size);
const char* cret;
- BEFORE_ORIGINAL(inet_ntop, libc.so.6);
+ BEFORE_ORIGINAL(inet_ntop, LIBC);
cret = inet_ntopp(af, src, dst, size);
{
static int (*inet_ptonp)(int af, const char *src, void *dst);
- BEFORE_ORIGINAL(inet_pton, libc.so.6);
+ BEFORE_ORIGINAL(inet_pton, LIBC);
ret = inet_ptonp(af, src, dst);
{
static int (*getaddrinfop)(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
- BEFORE_ORIGINAL_NOFILTER(getaddrinfo, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(getaddrinfo, LIBC);
ret = getaddrinfop(node, service, hints, res);
{
static void (*freeaddrinfop)(struct addrinfo *res);
- BEFORE_ORIGINAL_NOFILTER(freeaddrinfo, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(freeaddrinfo, LIBC);
freeaddrinfop(res);
static const char * (*gai_strerrorp)(int errcode);
const char * cret;
- BEFORE_ORIGINAL(gai_strerror, libc.so.6);
+ BEFORE_ORIGINAL(gai_strerror, LIBC);
cret = gai_strerrorp(errcode);
{
static int (*gai_suspendp)(const struct gaicb* const list[], int nitems, const struct timespec *timeout);
- BEFORE_ORIGINAL(gai_suspend, libc.so.6);
+ BEFORE_ORIGINAL(gai_suspend, LIBC);
ret = gai_suspendp(list,nitems,timeout);
{
static int (*gai_errorp)(struct gaicb *req);
- BEFORE_ORIGINAL(gai_error, libc.so.6);
+ BEFORE_ORIGINAL(gai_error, LIBC);
ret = gai_errorp(req);
{
static int (*gai_cancelp)(struct gaicb *req);
- BEFORE_ORIGINAL(gai_cancel, libc.so.6);
+ BEFORE_ORIGINAL(gai_cancel, LIBC);
ret = gai_cancelp(req);
{
static int (*getaddrinfo_ap)(int mode, struct gaicb *list[], int nitems, struct sigevent *sevp);
- BEFORE_ORIGINAL(getaddrinfo_a, libc.so.6);
+ BEFORE_ORIGINAL(getaddrinfo_a, LIBC);
ret = getaddrinfo_ap(mode, list,nitems, sevp);
{
static int (*getsockoptp)(int socket, int level, int option_name, void *option_value, socklen_t *option_len);
- BEFORE_ORIGINAL(getsockopt, libc.so.6);
+ BEFORE_ORIGINAL(getsockopt, LIBC);
ret = getsockoptp(socket, level, option_name, option_value, option_len);
{
static int (*setsockoptp)(int socket, int level, int option_name, const void *option_value, socklen_t option_len);
- BEFORE_ORIGINAL(setsockopt, libc.so.6);
+ BEFORE_ORIGINAL(setsockopt, LIBC);
ret = setsockoptp(socket, level, option_name, option_value, option_len);
{
static int (*getsocknamep)(int sockfd, struct sockaddr *addr, socklen_t *addrlen );
- BEFORE_ORIGINAL(getsockname, libc.so.6);
+ BEFORE_ORIGINAL(getsockname, LIBC);
ret = getsocknamep(sockfd, addr, addrlen);
{
static int (*getdomainnamep)(char *name, size_t len);
- BEFORE_ORIGINAL(getdomainname, libc.so.6);
+ BEFORE_ORIGINAL(getdomainname, LIBC);
ret = getdomainnamep(name, len);
{
static int (*setdomainnamep)(const char *name, size_t len);
- BEFORE_ORIGINAL(setdomainname, libc.so.6);
+ BEFORE_ORIGINAL(setdomainname, LIBC);
ret = setdomainnamep(name, len);
{
static int (*gethostnamep)(char *name, size_t len);
- BEFORE_ORIGINAL(gethostname, libc.so.6);
+ BEFORE_ORIGINAL(gethostname, LIBC);
ret = gethostnamep(name, len);
{
static int (*sethostnamep)(const char *name, size_t len);
- BEFORE_ORIGINAL(sethostname, libc.so.6);
+ BEFORE_ORIGINAL(sethostname, LIBC);
ret = sethostnamep(name, len);
{
static int (*getpeernamep)(int s, struct sockaddr *addr, socklen_t *len);
- BEFORE_ORIGINAL(getpeername, libc.so.6);
+ BEFORE_ORIGINAL(getpeername, LIBC);
ret = getpeernamep(s, addr, len);
{
static int (*getnameinfop)(const struct sockaddr *sa, socklen_t salen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, unsigned int flags);
- BEFORE_ORIGINAL(getnameinfo, libc.so.6);
+ BEFORE_ORIGINAL(getnameinfo, LIBC);
ret = getnameinfop(sa, salen,host, hostlen, serv, servlen, flags);
static struct hostent * (*gethostbynamep)(const char *name);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostbyname, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname, LIBC);
pret = gethostbynamep(name);
static struct hostent * (*gethostbyaddrp)(const void *addr, socklen_t len, int type);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostbyaddr, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyaddr, LIBC);
pret = gethostbyaddrp(addr, len, type);
{
static void (*sethostentp)(int stayopen);
- BEFORE_ORIGINAL(sethostent, libc.so.6);
+ BEFORE_ORIGINAL(sethostent, LIBC);
sethostentp(stayopen);
{
static void (*endhostentp)(void);
- BEFORE_ORIGINAL(endhostent, libc.so.6);
+ BEFORE_ORIGINAL(endhostent, LIBC);
endhostentp();
{
static void (*herrorp)(const char *s);
- BEFORE_ORIGINAL(herror, libc.so.6);
+ BEFORE_ORIGINAL(herror, LIBC);
herrorp(s);
static const char* (*hstrerrorp)(int err);
const char* cret;
- BEFORE_ORIGINAL(hstrerror, libc.so.6);
+ BEFORE_ORIGINAL(hstrerror, LIBC);
cret = hstrerrorp(err);
static struct hostent* (*gethostentp)(void);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostent, libc.so.6);
+ BEFORE_ORIGINAL(gethostent, LIBC);
pret = gethostentp();
static struct hostent * (*gethostbyname2p)(const char *name, int af);
struct hostent* pret;
- BEFORE_ORIGINAL(gethostbyname2, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname2, LIBC);
pret = gethostbyname2p(name, af);
{
static int (*gethostent_rp)(struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostent_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostent_r, LIBC);
ret = gethostent_rp(rret, buf, buflen, result, h_errnop);
{
static int (*gethostbyaddr_rp)(const void *addr, socklen_t len, int type, struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostbyaddr_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyaddr_r, LIBC);
ret = gethostbyaddr_rp(addr, len, type, rret, buf, buflen, result, h_errnop);
{
static int (*gethostbyname_rp)(const char *name, struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostbyname_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname_r, LIBC);
ret = gethostbyname_rp(name, rret, buf, buflen, result, h_errnop);
{
static int (*gethostbyname2_rp)(const char *name, int af, struct hostent *rret, char *buf, size_t buflen, struct hostent **result, int *h_errnop);
- BEFORE_ORIGINAL(gethostbyname2_r, libc.so.6);
+ BEFORE_ORIGINAL(gethostbyname2_r, LIBC);
ret = gethostbyname2_rp(name, af, rret, buf, buflen, result, h_errnop);
static struct servent * (*getservbynamep)(const char *name, const char *proto);
struct servent* pret;
- BEFORE_ORIGINAL(getservbyname, libc.so.6);
+ BEFORE_ORIGINAL(getservbyname, LIBC);
pret = getservbynamep(name, proto);
{
static void (*setserventp)(int stayopen);
- BEFORE_ORIGINAL(setservent, libc.so.6);
+ BEFORE_ORIGINAL(setservent, LIBC);
setserventp(stayopen);
{
static void (*endserventp)(void);
- BEFORE_ORIGINAL(endservent, libc.so.6);
+ BEFORE_ORIGINAL(endservent, LIBC);
endserventp();
static struct servent * (*getserventp)(void);
struct servent* pret;
- BEFORE_ORIGINAL(getservent, libc.so.6);
+ BEFORE_ORIGINAL(getservent, LIBC);
pret = getserventp();
static struct servent * (*getservbyportp)(int port, const char *proto);
struct servent* pret;
- BEFORE_ORIGINAL(getservbyport, libc.so.6);
+ BEFORE_ORIGINAL(getservbyport, LIBC);
pret = getservbyportp(port, proto);
{
static int (*getservent_rp)(struct servent *result_buf, char *buf, size_t buflen, struct servent **result);
- BEFORE_ORIGINAL(getservent_r, libc.so.6);
+ BEFORE_ORIGINAL(getservent_r, LIBC);
ret = getservent_rp(result_buf, buf, buflen, result);
{
static int (*getservbyname_rp)(const char *name, const char *proto, struct servent *result_buf, char *buf, size_t buflen, struct servent **result);
- BEFORE_ORIGINAL(getservbyname_r, libc.so.6);
+ BEFORE_ORIGINAL(getservbyname_r, LIBC);
ret = getservbyname_rp(name, proto, result_buf, buf, buflen, result);
{
static int (*getservbyport_rp)(int port, const char *proto, struct servent *result_buf, char *buf, size_t buflen, struct servent **result);
- BEFORE_ORIGINAL(getservbyport_r, libc.so.6);
+ BEFORE_ORIGINAL(getservbyport_r, LIBC);
ret = getservbyport_rp(port, proto, result_buf, buf, buflen, result);
static struct netent * (*getnetentp)(void);
struct netent* pret;
- BEFORE_ORIGINAL(getnetent, libc.so.6);
+ BEFORE_ORIGINAL(getnetent, LIBC);
pret = getnetentp();
static struct netent * (*getnetbynamep)(const char *name);
struct netent* pret;
- BEFORE_ORIGINAL(getnetbyname, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyname, LIBC);
pret = getnetbynamep(name);
static struct netent * (*getnetbyaddrp)(uint32_t net, int type);
struct netent * pret;
- BEFORE_ORIGINAL(getnetbyaddr, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyaddr, LIBC);
pret = getnetbyaddrp(net, type);
{
static void (*setnetentp)(int stayopen);
- BEFORE_ORIGINAL(setnetent, libc.so.6);
+ BEFORE_ORIGINAL(setnetent, LIBC);
setnetentp(stayopen);
{
static void (*endnetentp)(void);
- BEFORE_ORIGINAL(endnetent, libc.so.6);
+ BEFORE_ORIGINAL(endnetent, LIBC);
endnetentp();
{
static int (*getnetent_rp)(struct netent *result_buf, char *buf, size_t buflen, struct netent **result, int *h_errnop);
- BEFORE_ORIGINAL(getnetent_r, libc.so.6);
+ BEFORE_ORIGINAL(getnetent_r, LIBC);
ret = getnetent_rp(result_buf, buf, buflen, result, h_errnop);
{
static int (*getnetbyname_rp)(const char *name, struct netent *result_buf, char *buf, size_t buflen, struct netent **result, int *h_errnop);
- BEFORE_ORIGINAL(getnetbyname_r, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyname_r, LIBC);
ret = getnetbyname_rp(name,result_buf, buf, buflen, result, h_errnop);
{
static int (*getnetbyaddr_rp)(uint32_t net, int type, struct netent *result_buf, char *buf, size_t buflen, struct netent **result, int *h_errnop);
- BEFORE_ORIGINAL(getnetbyaddr_r, libc.so.6);
+ BEFORE_ORIGINAL(getnetbyaddr_r, LIBC);
ret = getnetbyaddr_rp(net, type, result_buf, buf, buflen, result, h_errnop);
static struct protoent * (*getprotoentp)(void);
struct protoent * pret;
- BEFORE_ORIGINAL(getprotoent, libc.so.6);
+ BEFORE_ORIGINAL(getprotoent, LIBC);
pret = getprotoentp();
static struct protoent * (*getprotobynamep)(const char *name);
struct protoent * pret;
- BEFORE_ORIGINAL(getprotobyname, libc.so.6);
+ BEFORE_ORIGINAL(getprotobyname, LIBC);
pret = getprotobynamep(name);
static struct protoent * (*getprotobynumberp)(int proto);
struct protoent * pret;
- BEFORE_ORIGINAL(getprotobynumber, libc.so.6);
+ BEFORE_ORIGINAL(getprotobynumber, LIBC);
pret = getprotobynumberp(proto);
{
static void (*setprotoentp)(int stayopen);
- BEFORE_ORIGINAL(setprotoent, libc.so.6);
+ BEFORE_ORIGINAL(setprotoent, LIBC);
setprotoentp(stayopen);
{
static void (*endprotoentp)(void);
- BEFORE_ORIGINAL(endprotoent, libc.so.6);
+ BEFORE_ORIGINAL(endprotoent, LIBC);
endprotoentp();
{
static int (*getprotoent_rp)(struct protoent *result_buf, char *buf, size_t buflen, struct protoent **result);
- BEFORE_ORIGINAL(getprotoent_r, libc.so.6);
+ BEFORE_ORIGINAL(getprotoent_r, LIBC);
ret = getprotoent_rp(result_buf, buf, buflen, result);
{
static int (*getprotobyname_rp)(const char *name, struct protoent *result_buf, char *buf, size_t buflen, struct protoent **result);
- BEFORE_ORIGINAL(getprotobyname_r, libc.so.6);
+ BEFORE_ORIGINAL(getprotobyname_r, LIBC);
ret = getprotobyname_rp(name, result_buf, buf, buflen, result);
{
static int (*getprotobynumber_rp)(int proto, struct protoent *result_buf, char *buf, size_t buflen, struct protoent **result);
- BEFORE_ORIGINAL(getprotobynumber_r, libc.so.6);
+ BEFORE_ORIGINAL(getprotobynumber_r, LIBC);
ret = getprotobynumber_rp(proto, result_buf, buf, buflen, result);
static unsigned int (*if_nametoindexp)(__const char *__ifname);
unsigned int uret;
- BEFORE_ORIGINAL(if_nametoindex, libc.so.6);
+ BEFORE_ORIGINAL(if_nametoindex, LIBC);
uret = if_nametoindexp(__ifname);
static char * (*if_indextonamep)(unsigned int __ifindex, char *__ifname);
char * cret;
- BEFORE_ORIGINAL(if_indextoname, libc.so.6);
+ BEFORE_ORIGINAL(if_indextoname, LIBC);
cret = if_indextonamep(__ifindex, __ifname);
static struct if_nameindex * (*if_nameindexp)(void);
struct if_nameindex * pret;
- BEFORE_ORIGINAL_NOFILTER(if_nameindex, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(if_nameindex, LIBC);
pret = if_nameindexp();
{
static void (*if_freenameindexp)(struct if_nameindex *__ptr);
- BEFORE_ORIGINAL_NOFILTER(if_freenameindex, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(if_freenameindex, LIBC);
if_freenameindexp(__ptr);
{
static int (*getifaddrsp)(struct ifaddrs **ifap);
- BEFORE_ORIGINAL_NOFILTER(getifaddrs, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(getifaddrs, LIBC);
ret = getifaddrsp(ifap);
{
static void (*freeifaddrsp)(struct ifaddrs *ifa);
- BEFORE_ORIGINAL_NOFILTER(freeifaddrs, libc.so.6);
+ BEFORE_ORIGINAL_NOFILTER(freeifaddrs, LIBC);
freeifaddrsp(ifa);
{
static int (*pollp)(struct pollfd *ufds, unsigned int nfds, int timeout);
- BEFORE_ORIGINAL(poll, libc.so.6);
+ BEFORE_ORIGINAL(poll, LIBC);
ret = pollp(ufds, nfds, timeout);
{
static int (*ppollp)(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout_ts, const sigset_t *sigmask);
- BEFORE_ORIGINAL(ppoll, libc.so.6);
+ BEFORE_ORIGINAL(ppoll, LIBC);
ret = ppollp(fds, nfds, timeout_ts, sigmask);