[Nagiosplug-checkins] CVS: nagiosplug/lib getaddrinfo.c,NONE,1.1 getaddrinfo.h,NONE,1.1 gethostbyname.c,NONE,1.1 gethostbyname.h,NONE,1.1 Makefile.am,1.3,1.4
Jeremy T. Bouse
undrgrid at users.sourceforge.net
Fri Mar 7 14:12:08 CET 2003
Update of /cvsroot/nagiosplug/nagiosplug/lib
In directory sc8-pr-cvs1:/tmp/cvs-serv11153/lib
Modified Files:
Makefile.am
Added Files:
getaddrinfo.c getaddrinfo.h gethostbyname.c gethostbyname.h
Log Message:
Added getaddrinfo.[ch] & gethostbyname.[ch] to provide RFC2553 functions
if missing in system libs and lwres not present
Moved all references to netdb.h and sys/socket.h into common.h.in
Modified automake call in tools/setup to include adding missing files
so config.sub and config.guess will be available
--- NEW FILE ---
/*
* This file is part of libESMTP, a library for submission of RFC 2822
* formatted electronic mail messages using the SMTP protocol described
* in RFC 2821.
*
* Copyright (C) 2001,2002 Brian Stafford <brian at stafford.uklinux.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* An emulation of the RFC 2553 / Posix getaddrinfo resolver interface.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/* Need to turn off Posix features in glibc to build this */
#undef _POSIX_C_SOURCE
#undef _XOPEN_SOURCE
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include "gethostbyname.h"
#include "getaddrinfo.h"
static struct addrinfo *
dup_addrinfo (struct addrinfo *info, void *addr, size_t addrlen)
{
struct addrinfo *ret;
ret = malloc (sizeof (struct addrinfo));
if (ret == NULL)
return NULL;
memcpy (ret, info, sizeof (struct addrinfo));
ret->ai_addr = malloc (addrlen);
if (ret->ai_addr == NULL)
{
free (ret);
return NULL;
}
memcpy (ret->ai_addr, addr, addrlen);
ret->ai_addrlen = addrlen;
return ret;
}
int
getaddrinfo (const char *nodename, const char *servname,
const struct addrinfo *hints, struct addrinfo **res)
{
struct hostent *hp;
struct servent *servent;
const char *socktype;
int port;
struct addrinfo hint, result;
struct addrinfo *ai, *sai, *eai;
struct ghbnctx ghbnctx;
char **addrs;
int code;
memset (&result, 0, sizeof result);
/* default for hints */
if (hints == NULL)
{
memset (&hint, 0, sizeof hint);
hint.ai_family = PF_UNSPEC;
hints = &hint;
}
/* servname must not be NULL in this implementation */
if (servname == NULL)
return EAI_NONAME;
/* check for tcp or udp sockets only */
if (hints->ai_socktype == SOCK_STREAM)
socktype = "tcp";
else if (hints->ai_socktype == SOCK_DGRAM)
socktype = "udp";
else
return EAI_SERVICE;
result.ai_socktype = hints->ai_socktype;
/* Note: maintain port in host byte order to make debugging easier */
if (isdigit (*servname))
port = strtol (servname, NULL, 10);
else if ((servent = getservbyname (servname, socktype)) != NULL)
port = ntohs (servent->s_port);
else
return EAI_NONAME;
/* if nodename == NULL refer to the local host for a client or any
for a server */
if (nodename == NULL)
{
struct sockaddr_in sin;
/* check protocol family is PF_UNSPEC or PF_INET - could try harder
for IPv6 but that's more code than I'm prepared to write */
if (hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET)
result.ai_family = AF_INET;
else
return EAI_FAMILY;
sin.sin_family = result.ai_family;
sin.sin_port = htons (port);
if (hints->ai_flags & AI_PASSIVE)
sin.sin_addr.s_addr = htonl (INADDR_ANY);
else
sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
/* Duplicate result and addr and return */
*res = dup_addrinfo (&result, &sin, sizeof sin);
return (*res == NULL) ? EAI_MEMORY : 0;
}
/* If AI_NUMERIC is specified, use inet_addr to translate numbers and
dots notation. */
if (hints->ai_flags & AI_NUMERICHOST)
{
struct sockaddr_in sin;
/* check protocol family is PF_UNSPEC or PF_INET */
if (hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET)
result.ai_family = AF_INET;
else
return EAI_FAMILY;
sin.sin_family = result.ai_family;
sin.sin_port = htons (port);
sin.sin_addr.s_addr = inet_addr (nodename);
/* Duplicate result and addr and return */
*res = dup_addrinfo (&result, &sin, sizeof sin);
return (*res == NULL) ? EAI_MEMORY : 0;
}
errno = 0;
hp = gethostbyname_ctx (nodename, &ghbnctx);
if (hp == NULL)
{
if (errno != 0)
{
free_ghbnctx (&ghbnctx);
return EAI_SYSTEM;
}
code = h_error_ctx (&ghbnctx);
switch (code)
{
case HOST_NOT_FOUND: code = EAI_NODATA; break;
case NO_DATA: code = EAI_NODATA; break;
#if defined(NO_ADDRESS) && NO_ADDRESS != NO_DATA
case NO_ADDRESS: code = EAI_NODATA; break;
#endif
case NO_RECOVERY: code = EAI_FAIL; break;
case TRY_AGAIN: code = EAI_AGAIN; break;
default: code = EAI_FAIL; break;
}
free_ghbnctx (&ghbnctx);
return code;
}
/* Check that the address family is acceptable.
*/
switch (hp->h_addrtype)
{
case AF_INET:
if (!(hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET))
goto eai_family;
break;
#ifdef USE_IPV6
case AF_INET6:
if (!(hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET6))
goto eai_family;
break;
#endif
default:
eai_family:
free_ghbnctx (&ghbnctx);
return EAI_FAMILY;
}
/* For each element pointed to by hp, create an element in the
result linked list. */
sai = eai = NULL;
for (addrs = hp->h_addr_list; *addrs != NULL; addrs++)
{
struct sockaddr sa;
size_t addrlen;
sa.sa_family = hp->h_addrtype;
switch (hp->h_addrtype)
{
case AF_INET:
((struct sockaddr_in *) &sa)->sin_port = htons (port);
memcpy (&((struct sockaddr_in *) &sa)->sin_addr,
*addrs, hp->h_length);
addrlen = sizeof (struct sockaddr_in);
break;
#ifdef USE_IPV6
case AF_INET6:
# if SIN6_LEN
((struct sockaddr_in6 *) &sa)->sin6_len = hp->h_length;
# endif
((struct sockaddr_in6 *) &sa)->sin6_port = htons (port);
memcpy (&((struct sockaddr_in6 *) &sa)->sin6_addr,
*addrs, hp->h_length);
addrlen = sizeof (struct sockaddr_in6);
break;
#endif
default:
continue;
}
result.ai_family = hp->h_addrtype;
ai = dup_addrinfo (&result, &sa, addrlen);
if (ai == NULL)
{
free_ghbnctx (&ghbnctx);
freeaddrinfo (sai);
return EAI_MEMORY;
}
if (sai == NULL)
sai = ai;
else
eai->ai_next = ai;
eai = ai;
}
if (sai == NULL)
{
free_ghbnctx (&ghbnctx);
return EAI_NODATA;
}
if (hints->ai_flags & AI_CANONNAME)
{
sai->ai_canonname = malloc (strlen (hp->h_name) + 1);
if (sai->ai_canonname == NULL)
{
free_ghbnctx (&ghbnctx);
freeaddrinfo (sai);
return EAI_MEMORY;
}
strcpy (sai->ai_canonname, hp->h_name);
}
free_ghbnctx (&ghbnctx);
*res = sai;
return 0;
}
void
freeaddrinfo (struct addrinfo *ai)
{
struct addrinfo *next;
while (ai != NULL)
{
next = ai->ai_next;
if (ai->ai_canonname != NULL)
free (ai->ai_canonname);
if (ai->ai_addr != NULL)
free (ai->ai_addr);
free (ai);
ai = next;
}
}
const char *
gai_strerror (int ecode)
{
static const char *eai_descr[] =
{
"no error",
"address family for nodename not supported", /* EAI_ADDRFAMILY */
"temporary failure in name resolution", /* EAI_AGAIN */
"invalid value for ai_flags", /* EAI_BADFLAGS */
"non-recoverable failure in name resolution", /* EAI_FAIL */
"ai_family not supported", /* EAI_FAMILY */
"memory allocation failure", /* EAI_MEMORY */
"no address associated with nodename", /* EAI_NODATA */
"nodename nor servname provided, or not known", /* EAI_NONAME */
"servname not supported for ai_socktype", /* EAI_SERVICE */
"ai_socktype not supported", /* EAI_SOCKTYPE */
"system error returned in errno", /* EAI_SYSTEM */
};
if (ecode < 0 || ecode > (int) (sizeof eai_descr/ sizeof eai_descr[0]))
return "unknown error";
return eai_descr[ecode];
}
--- NEW FILE ---
#ifndef _getaddrinfo_h
#define _getaddrinfo_h
/*
* This file is part of libESMTP, a library for submission of RFC 2822
* formatted electronic mail messages using the SMTP protocol described
* in RFC 2821.
*
* Copyright (C) 2001,2002 Brian Stafford <brian at stafford.uklinux.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* Structure and prototypes aken from RFC 2553 */
struct addrinfo
{
int ai_flags; /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
int ai_family; /* PF_xxx */
int ai_socktype; /* SOCK_xxx */
int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
size_t ai_addrlen; /* length of ai_addr */
char *ai_canonname; /* canonical name for nodename */
struct sockaddr *ai_addr; /* binary address */
struct addrinfo *ai_next; /* next structure in linked list */
};
/* Supposed to be defined in <netdb.h> */
#define AI_PASSIVE 1 /* Socket address is intended for `bind'. */
#define AI_CANONNAME 2 /* Request for canonical name. */
#define AI_NUMERICHOST 4 /* Don't use name resolution. */
/* Supposed to be defined in <netdb.h> */
#define EAI_ADDRFAMILY 1 /* address family for nodename not supported */
#define EAI_AGAIN 2 /* temporary failure in name resolution */
#define EAI_BADFLAGS 3 /* invalid value for ai_flags */
#define EAI_FAIL 4 /* non-recoverable failure in name resolution */
#define EAI_FAMILY 5 /* ai_family not supported */
#define EAI_MEMORY 6 /* memory allocation failure */
#define EAI_NODATA 7 /* no address associated with nodename */
#define EAI_NONAME 8 /* nodename nor servname provided, or not known */
#define EAI_SERVICE 9 /* servname not supported for ai_socktype */
#define EAI_SOCKTYPE 10 /* ai_socktype not supported */
#define EAI_SYSTEM 11 /* system error returned in errno */
/* RFC 2553 / Posix resolver */
int getaddrinfo (const char *nodename, const char *servname,
const struct addrinfo *hints, struct addrinfo **res);
/* Free addrinfo structure and associated storage */
void freeaddrinfo (struct addrinfo *ai);
/* Convert error return from getaddrinfo() to string */
const char *gai_strerror (int code);
#endif
--- NEW FILE ---
/*
* This file is a ghastly hack because nobody can agree on
* gethostbyname_r()'s prototype.
*
* Copyright (C) 2001,2002 Brian Stafford <brian at stafford.uklinux.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#define _SVID_SOURCE 1 /* Need this to get gethostbyname_r() */
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>
#include "gethostbyname.h"
#if HAVE_GETIPNODEBYNAME
void
free_ghbnctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
if (ctx->hostent != NULL)
freehostent (ctx->hostent);
}
struct hostent *
gethostbyname_ctx (const char *host, struct ghbnctx *ctx)
{
assert (ctx != NULL);
memset (ctx, 0, sizeof (struct ghbnctx));
ctx->hostent = getipnodebyname (host, AF_UNSPEC, AI_ADDRCONFIG, &ctx->h_err);
return ctx->hostent;
}
int
h_error_ctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
return ctx->h_err;
}
#elif HAVE_GETHOSTBYNAME_R == 6
void
free_ghbnctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
if (ctx->hostbuf != NULL)
free (ctx->hostbuf);
}
struct hostent *
gethostbyname_ctx (const char *host, struct ghbnctx *ctx)
{
struct hostent *hp;
char *tmp;
int err;
assert (ctx != NULL);
memset (ctx, 0, sizeof (struct ghbnctx));
ctx->hostbuf_len = 2048;
if ((ctx->hostbuf = malloc (ctx->hostbuf_len)) == NULL)
{
errno = ENOMEM;
return NULL;
}
while ((err = gethostbyname_r (host,
&ctx->hostent, ctx->hostbuf, ctx->hostbuf_len,
&hp, &ctx->h_err)) == ERANGE)
{
ctx->hostbuf_len += 1024;
if ((tmp = realloc (ctx->hostbuf, ctx->hostbuf_len)) == NULL)
{
errno = ENOMEM;
return NULL;
}
ctx->hostbuf = tmp;
}
if (err != 0)
{
errno = err;
return NULL;
}
return hp;
}
int
h_error_ctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
return ctx->h_err;
}
#elif HAVE_GETHOSTBYNAME_R == 5
void
free_ghbnctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
if (ctx->hostbuf != NULL)
free (ctx->hostbuf);
}
struct hostent *
gethostbyname_ctx (const char *host, struct ghbnctx *ctx)
{
struct hostent *hp;
char *tmp;
assert (ctx != NULL);
memset (ctx, 0, sizeof (struct ghbnctx));
ctx->hostbuf_len = 2048;
if ((ctx->hostbuf = malloc (ctx->hostbuf_len)) == NULL)
{
errno = ENOMEM;
return NULL;
}
while ((hp = gethostbyname_r (host, &ctx->hostent,
ctx->hostbuf, ctx->hostbuf_len,
&ctx->h_err)) == NULL && errno == ERANGE)
{
ctx->hostbuf_len += 1024;
if ((tmp = realloc (ctx->hostbuf, ctx->hostbuf_len)) == NULL)
{
errno = ENOMEM;
return NULL;
}
ctx->hostbuf = tmp;
}
return hp;
}
int
h_error_ctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
return ctx->h_err;
}
#elif HAVE_GETHOSTBYNAME_R == 3
void
free_ghbnctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
/* FIXME: does this need to do anything? */
}
struct hostent *
gethostbyname_ctx (const char *host, struct ghbnctx *ctx)
{
assert (ctx != NULL);
if (!gethostbyname_r (host, &ctx->hostent, &ctx->hostent_data))
{
ctx->h_err = h_errno; /* FIXME: is this correct? */
return NULL;
}
return &ctx->hostent;
}
int
h_error_ctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
return ctx->h_err;
}
#else
void
free_ghbnctx (struct ghbnctx *ctx __attribute__ ((unused)))
{
assert (ctx != NULL);
}
struct hostent *
gethostbyname_ctx (const char *host, struct ghbnctx *ctx)
{
struct hostent *hp;
hp = gethostbyname (host);
if (hp == NULL)
ctx->h_err = h_errno;
return hp;
}
int
h_error_ctx (struct ghbnctx *ctx)
{
assert (ctx != NULL);
return ctx->h_err;
}
#endif
--- NEW FILE ---
/*
* This file is a ghastly hack because nobody can agree on
* gethostbyname_r()'s prototype.
*
* Copyright (C) 2001,2002 Brian Stafford <brian at stafford.uklinux.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*************************************************************************
Usage:
#include <errno.h>
#include "gethostbyname.h"
f ()
{
struct ghbnctx ctx;
errno = 0;
hp = gethostbyname_ctx (host, &ctx);
if (hp == NULL)
{
if (errno != 0)
handle_value_of_errno (errno);
else
handle_value_of_h_errno (h_error_ctx (&ctx));
}
else
{
...
}
free_ghbnctx (&ctx);
}
*************************************************************************/
#ifndef _gethostbyname_h
#define _gethostbyname_h
#if HAVE_GETIPNODEBYNAME
struct ghbnctx
{
int h_err;
struct hostent *hostent;
};
#elif HAVE_GETHOSTBYNAME_R == 6
struct ghbnctx
{
int h_err;
struct hostent hostent;
char *hostbuf;
size_t hostbuf_len;
};
#elif HAVE_GETHOSTBYNAME_R == 5
struct ghbnctx
{
int h_err;
struct hostent hostent;
char *hostbuf;
int hostbuf_len;
};
#elif HAVE_GETHOSTBYNAME_R == 3
struct ghbnctx
{
int h_err;
struct hostent_data hostent_data;
struct hostent hostent;
};
#else
struct ghbnctx
{
int h_err;
};
#endif
struct hostent *gethostbyname_ctx (const char *host, struct ghbnctx *ctx);
int h_error_ctx (struct ghbnctx *ctx);
void free_ghbnctx (struct ghbnctx *ctx);
#endif
Index: Makefile.am
===================================================================
RCS file: /cvsroot/nagiosplug/nagiosplug/lib/Makefile.am,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -r1.3 -r1.4
*** Makefile.am 19 Feb 2003 22:56:27 -0000 1.3
--- Makefile.am 7 Mar 2003 22:11:24 -0000 1.4
***************
*** 3,7 ****
noinst_LIBRARIES = libnagiosplug.a
! noinst_HEADERS = getopt.h
libnagiosplug_a_SOURCES = getopt.c getopt1.c getloadavg.c
--- 3,7 ----
noinst_LIBRARIES = libnagiosplug.a
! noinst_HEADERS = getopt.h getaddrinfo.h gethostbyname.h
libnagiosplug_a_SOURCES = getopt.c getopt1.c getloadavg.c
***************
*** 9,10 ****
--- 9,11 ----
INCLUDES = -I$(srcdir)
+ EXTRA_DIST = getaddrinfo.c gethostbyname.c
More information about the Commits
mailing list