svn rev #23392: trunk/src/ util/support/
tlyu@MIT.EDU
tlyu at MIT.EDU
Mon Nov 30 16:35:38 EST 2009
http://src.mit.edu/fisheye/changelog/krb5/?cs=23392
Commit By: tlyu
Log Message:
Mark and reindent util/support.
Changed Files:
U trunk/src/Makefile.in
U trunk/src/util/support/cache-addrinfo.h
U trunk/src/util/support/errors.c
U trunk/src/util/support/fake-addrinfo.c
U trunk/src/util/support/gmt_mktime.c
U trunk/src/util/support/init-addrinfo.c
U trunk/src/util/support/ipc_stream.c
U trunk/src/util/support/k5buf-int.h
U trunk/src/util/support/k5buf.c
U trunk/src/util/support/mkstemp.c
U trunk/src/util/support/plugins.c
U trunk/src/util/support/printf.c
U trunk/src/util/support/strlcpy.c
U trunk/src/util/support/supp-int.h
U trunk/src/util/support/t_k5buf.c
U trunk/src/util/support/t_unal.c
U trunk/src/util/support/threads.c
U trunk/src/util/support/utf8.c
U trunk/src/util/support/utf8_conv.c
Modified: trunk/src/Makefile.in
===================================================================
--- trunk/src/Makefile.in 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/Makefile.in 2009-11-30 21:35:38 UTC (rev 23392)
@@ -670,7 +670,8 @@
lib/krb5 \
plugins \
prototype \
- slave
+ slave \
+ util/support
BSDFILES = \
kadmin/cli/strftime.c \
@@ -683,7 +684,9 @@
lib/kadm5/srv/adb_xdr.c \
lib/krb5/krb/strftime.c \
lib/krb5/krb/strptime.c \
- slave/kpropd_rpc.c
+ slave/kpropd_rpc.c \
+ util/support/mkstemp.c \
+ util/support/strlcpy.c
OTHEREXCLUDES = \
include/iprop.h \
Modified: trunk/src/util/support/cache-addrinfo.h
===================================================================
--- trunk/src/util/support/cache-addrinfo.h 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/cache-addrinfo.h 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright (C) 2004 by the Massachusetts Institute of Technology,
* Cambridge, MA, USA. All Rights Reserved.
@@ -39,63 +40,66 @@
* fashion that it might be confused with the original M.I.T. software.
*/
-/* Approach overview:
+/*
+ * Approach overview:
+ *
+ * If a system version is available but buggy, save handles to it,
+ * redefine the names to refer to static functions defined here, and
+ * in those functions, call the system versions and fix up the
+ * returned data. Use the native data structures and flag values.
+ *
+ * If no system version exists, use gethostby* and fake it. Define
+ * the data structures and flag values locally.
+ *
+ *
+ * On Mac OS X, getaddrinfo results aren't cached (though
+ * gethostbyname results are), so we need to build a cache here. Now
+ * things are getting really messy. Because the cache is in use, we
+ * use getservbyname, and throw away thread safety. (Not that the
+ * cache is thread safe, but when we get locking support, that'll be
+ * dealt with.) This code needs tearing down and rebuilding, soon.
+ *
+ *
+ * Note that recent Windows developers' code has an interesting hack:
+ * When you include the right header files, with the right set of
+ * macros indicating system versions, you'll get an inline function
+ * that looks for getaddrinfo (or whatever) in the system library, and
+ * calls it if it's there. If it's not there, it fakes it with
+ * gethostby* calls.
+ *
+ * We're taking a simpler approach: A system provides these routines or
+ * it does not.
+ *
+ * Someday, we may want to take into account different versions (say,
+ * different revs of GNU libc) where some are broken in one way, and
+ * some work or are broken in another way. Cross that bridge when we
+ * come to it.
+ */
- If a system version is available but buggy, save handles to it,
- redefine the names to refer to static functions defined here, and
- in those functions, call the system versions and fix up the
- returned data. Use the native data structures and flag values.
-
- If no system version exists, use gethostby* and fake it. Define
- the data structures and flag values locally.
-
-
- On Mac OS X, getaddrinfo results aren't cached (though
- gethostbyname results are), so we need to build a cache here. Now
- things are getting really messy. Because the cache is in use, we
- use getservbyname, and throw away thread safety. (Not that the
- cache is thread safe, but when we get locking support, that'll be
- dealt with.) This code needs tearing down and rebuilding, soon.
-
-
- Note that recent Windows developers' code has an interesting hack:
- When you include the right header files, with the right set of
- macros indicating system versions, you'll get an inline function
- that looks for getaddrinfo (or whatever) in the system library, and
- calls it if it's there. If it's not there, it fakes it with
- gethostby* calls.
-
- We're taking a simpler approach: A system provides these routines or
- it does not.
-
- Someday, we may want to take into account different versions (say,
- different revs of GNU libc) where some are broken in one way, and
- some work or are broken in another way. Cross that bridge when we
- come to it. */
-
/* To do, maybe:
+ *
+ * + For AIX 4.3.3, using the RFC 2133 definition: Implement
+ * AI_NUMERICHOST. It's not defined in the header file.
+ *
+ * For certain (old?) versions of GNU libc, AI_NUMERICHOST is
+ * defined but not implemented.
+ *
+ * + Use gethostbyname2, inet_aton and other IPv6 or thread-safe
+ * functions if available. But, see
+ * http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=135182 for one
+ * gethostbyname2 problem on Linux. And besides, if a platform is
+ * supporting IPv6 at all, they really should be doing getaddrinfo
+ * by now.
+ *
+ * + inet_ntop, inet_pton
+ *
+ * + Conditionally export/import the function definitions, so a
+ * library can have a single copy instead of multiple.
+ *
+ * + Upgrade host requirements to include working implementations of
+ * these functions, and throw all this away. Pleeease? :-)
+ */
- + For AIX 4.3.3, using the RFC 2133 definition: Implement
- AI_NUMERICHOST. It's not defined in the header file.
-
- For certain (old?) versions of GNU libc, AI_NUMERICHOST is
- defined but not implemented.
-
- + Use gethostbyname2, inet_aton and other IPv6 or thread-safe
- functions if available. But, see
- http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=135182 for one
- gethostbyname2 problem on Linux. And besides, if a platform is
- supporting IPv6 at all, they really should be doing getaddrinfo
- by now.
-
- + inet_ntop, inet_pton
-
- + Conditionally export/import the function definitions, so a
- library can have a single copy instead of multiple.
-
- + Upgrade host requirements to include working implementations of
- these functions, and throw all this away. Pleeease? :-) */
-
#include "port-sockets.h"
#include "socket-utils.h"
#include "k5-platform.h"
Modified: trunk/src/util/support/errors.c
===================================================================
--- trunk/src/util/support/errors.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/errors.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/* Can't include krb5.h here, or k5-int.h which includes it, because
krb5.h needs to be generated with error tables, after util/et,
which builds after this directory. */
@@ -30,9 +31,9 @@
{
return k5_mutex_finish_init (&krb5int_error_info_support_mutex);
}
-#define initialize() krb5int_call_thread_support_init()
-#define lock() k5_mutex_lock(&krb5int_error_info_support_mutex)
-#define unlock() k5_mutex_unlock(&krb5int_error_info_support_mutex)
+#define initialize() krb5int_call_thread_support_init()
+#define lock() k5_mutex_lock(&krb5int_error_info_support_mutex)
+#define unlock() k5_mutex_unlock(&krb5int_error_info_support_mutex)
#undef krb5int_set_error
void
@@ -46,7 +47,7 @@
void
krb5int_set_error_fl (struct errinfo *ep, long code,
- const char *file, int line, const char *fmt, ...)
+ const char *file, int line, const char *fmt, ...)
{
va_list args;
va_start (args, fmt);
@@ -56,15 +57,15 @@
void
krb5int_vset_error (struct errinfo *ep, long code,
- const char *fmt, va_list args)
+ const char *fmt, va_list args)
{
krb5int_vset_error_fl(ep, code, NULL, 0, fmt, args);
}
void
krb5int_vset_error_fl (struct errinfo *ep, long code,
- const char *file, int line,
- const char *fmt, va_list args)
+ const char *file, int line,
+ const char *fmt, va_list args)
{
va_list args2;
char *str = NULL, *str2, *slash;
@@ -79,19 +80,19 @@
/* try vasprintf first */
va_copy(args2, args);
if (vasprintf(&str, fmt, args2) < 0) {
- str = NULL;
+ str = NULL;
}
va_end(args2);
if (str && line) {
- /* Try to add file and line suffix. */
- slash = strrchr(file, '/');
- if (slash)
- file = slash + 1;
- if (asprintf(&str2, "%s (%s: %d)", str, file, line) > 0) {
- free(str);
- str = str2;
- }
+ /* Try to add file and line suffix. */
+ slash = strrchr(file, '/');
+ if (slash)
+ file = slash + 1;
+ if (asprintf(&str2, "%s (%s: %d)", str, file, line) > 0) {
+ free(str);
+ str = str2;
+ }
}
/* If that failed, try using scratch_buf */
@@ -102,8 +103,8 @@
/* free old string before setting new one */
if (ep->msg && ep->msg != ep->scratch_buf) {
- krb5int_free_error (ep, ep->msg);
- ep->msg = NULL;
+ krb5int_free_error (ep, ep->msg);
+ ep->msg = NULL;
}
ep->code = code;
ep->msg = str ? str : ep->scratch_buf;
@@ -118,72 +119,72 @@
{
const char *r, *r2;
if (code == ep->code && ep->msg) {
- r = strdup(ep->msg);
- if (r == NULL) {
- strlcpy(ep->scratch_buf, _("Out of memory"),
- sizeof(ep->scratch_buf));
- r = ep->scratch_buf;
- }
- return r;
+ r = strdup(ep->msg);
+ if (r == NULL) {
+ strlcpy(ep->scratch_buf, _("Out of memory"),
+ sizeof(ep->scratch_buf));
+ r = ep->scratch_buf;
+ }
+ return r;
}
if (initialize() != 0) {
- strncpy(ep->scratch_buf, _("Kerberos library initialization failure"),
- sizeof(ep->scratch_buf));
- ep->scratch_buf[sizeof(ep->scratch_buf)-1] = 0;
- ep->msg = NULL;
- return ep->scratch_buf;
+ strncpy(ep->scratch_buf, _("Kerberos library initialization failure"),
+ sizeof(ep->scratch_buf));
+ ep->scratch_buf[sizeof(ep->scratch_buf)-1] = 0;
+ ep->msg = NULL;
+ return ep->scratch_buf;
}
if (lock())
- goto no_fptr;
+ goto no_fptr;
if (fptr == NULL) {
- unlock();
+ unlock();
no_fptr:
- /* Theoretically, according to ISO C, strerror should be able
- to give us a message back for any int value. However, on
- UNIX at least, the errno codes strerror will actually be
- useful for are positive, so a negative value here would be
- kind of weird.
+ /* Theoretically, according to ISO C, strerror should be able
+ to give us a message back for any int value. However, on
+ UNIX at least, the errno codes strerror will actually be
+ useful for are positive, so a negative value here would be
+ kind of weird.
- Coverity Prevent thinks we shouldn't be passing negative
- values to strerror, and it's not likely to be useful, so
- let's not do it.
+ Coverity Prevent thinks we shouldn't be passing negative
+ values to strerror, and it's not likely to be useful, so
+ let's not do it.
- Besides, normally we shouldn't get here; fptr should take
- us to a callback function in the com_err library. */
- if (code < 0)
- goto format_number;
+ Besides, normally we shouldn't get here; fptr should take
+ us to a callback function in the com_err library. */
+ if (code < 0)
+ goto format_number;
#ifdef HAVE_STRERROR_R
- if (strerror_r(code, ep->scratch_buf, sizeof(ep->scratch_buf)) == 0) {
- char *p = strdup(ep->scratch_buf);
- if (p)
- return p;
- return ep->scratch_buf;
- }
+ if (strerror_r(code, ep->scratch_buf, sizeof(ep->scratch_buf)) == 0) {
+ char *p = strdup(ep->scratch_buf);
+ if (p)
+ return p;
+ return ep->scratch_buf;
+ }
#endif
- r = strerror(code);
- if (r) {
- strlcpy(ep->scratch_buf, r, sizeof(ep->scratch_buf));
- return ep->scratch_buf;
- }
+ r = strerror(code);
+ if (r) {
+ strlcpy(ep->scratch_buf, r, sizeof(ep->scratch_buf));
+ return ep->scratch_buf;
+ }
format_number:
- snprintf (ep->scratch_buf, sizeof(ep->scratch_buf),
- _("error %ld"), code);
- return ep->scratch_buf;
+ snprintf (ep->scratch_buf, sizeof(ep->scratch_buf),
+ _("error %ld"), code);
+ return ep->scratch_buf;
}
r = fptr(code);
if (r == NULL) {
- unlock();
- goto format_number;
+ unlock();
+ goto format_number;
}
r2 = strdup(r);
if (r2 == NULL) {
- strlcpy(ep->scratch_buf, r, sizeof(ep->scratch_buf));
- unlock();
- return ep->scratch_buf;
+ strlcpy(ep->scratch_buf, r, sizeof(ep->scratch_buf));
+ unlock();
+ return ep->scratch_buf;
} else {
- unlock();
- return r2;
+ unlock();
+ return r2;
}
}
@@ -191,7 +192,7 @@
krb5int_free_error (struct errinfo *ep, const char *msg)
{
if (msg != ep->scratch_buf)
- free ((char *) msg);
+ free ((char *) msg);
}
void
@@ -206,7 +207,7 @@
{
initialize();
if (lock() == 0) {
- fptr = f;
- unlock();
+ fptr = f;
+ unlock();
}
}
Modified: trunk/src/util/support/fake-addrinfo.c
===================================================================
--- trunk/src/util/support/fake-addrinfo.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/fake-addrinfo.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright (C) 2001,2002,2003,2004,2005,2006 by the Massachusetts Institute of Technology,
* Cambridge, MA, USA. All Rights Reserved.
@@ -39,63 +40,67 @@
* fashion that it might be confused with the original M.I.T. software.
*/
-/* Approach overview:
+/*
+ * Approach overview:
+ *
+ * If a system version is available but buggy, save handles to it,
+ * redefine the names to refer to static functions defined here, and
+ * in those functions, call the system versions and fix up the
+ * returned data. Use the native data structures and flag values.
+ *
+ * If no system version exists, use gethostby* and fake it. Define
+ * the data structures and flag values locally.
+ *
+ *
+ * On Mac OS X, getaddrinfo results aren't cached (though
+ * gethostbyname results are), so we need to build a cache here. Now
+ * things are getting really messy. Because the cache is in use, we
+ * use getservbyname, and throw away thread safety. (Not that the
+ * cache is thread safe, but when we get locking support, that'll be
+ * dealt with.) This code needs tearing down and rebuilding, soon.
+ *
+ *
+ * Note that recent Windows developers' code has an interesting hack:
+ * When you include the right header files, with the right set of
+ * macros indicating system versions, you'll get an inline function
+ * that looks for getaddrinfo (or whatever) in the system library, and
+ * calls it if it's there. If it's not there, it fakes it with
+ * gethostby* calls.
+ *
+ * We're taking a simpler approach: A system provides these routines or
+ * it does not.
+ *
+ * Someday, we may want to take into account different versions (say,
+ * different revs of GNU libc) where some are broken in one way, and
+ * some work or are broken in another way. Cross that bridge when we
+ * come to it.
+ */
- If a system version is available but buggy, save handles to it,
- redefine the names to refer to static functions defined here, and
- in those functions, call the system versions and fix up the
- returned data. Use the native data structures and flag values.
+/*
+ * To do, maybe:
+ *
+ * + For AIX 4.3.3, using the RFC 2133 definition: Implement
+ * AI_NUMERICHOST. It's not defined in the header file.
+ *
+ * For certain (old?) versions of GNU libc, AI_NUMERICHOST is
+ * defined but not implemented.
+ *
+ * + Use gethostbyname2, inet_aton and other IPv6 or thread-safe
+ * functions if available. But, see
+ * http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=135182 for one
+ * gethostbyname2 problem on Linux. And besides, if a platform is
+ * supporting IPv6 at all, they really should be doing getaddrinfo
+ * by now.
+ *
+ * + inet_ntop, inet_pton
+ *
+ * + Conditionally export/import the function definitions, so a
+ * library can have a single copy instead of multiple.
+ *
+ * + Upgrade host requirements to include working implementations of
+ * these functions, and throw all this away. Pleeease? :-)
+ */
- If no system version exists, use gethostby* and fake it. Define
- the data structures and flag values locally.
-
-
- On Mac OS X, getaddrinfo results aren't cached (though
- gethostbyname results are), so we need to build a cache here. Now
- things are getting really messy. Because the cache is in use, we
- use getservbyname, and throw away thread safety. (Not that the
- cache is thread safe, but when we get locking support, that'll be
- dealt with.) This code needs tearing down and rebuilding, soon.
-
-
- Note that recent Windows developers' code has an interesting hack:
- When you include the right header files, with the right set of
- macros indicating system versions, you'll get an inline function
- that looks for getaddrinfo (or whatever) in the system library, and
- calls it if it's there. If it's not there, it fakes it with
- gethostby* calls.
-
- We're taking a simpler approach: A system provides these routines or
- it does not.
-
- Someday, we may want to take into account different versions (say,
- different revs of GNU libc) where some are broken in one way, and
- some work or are broken in another way. Cross that bridge when we
- come to it. */
-
-/* To do, maybe:
-
- + For AIX 4.3.3, using the RFC 2133 definition: Implement
- AI_NUMERICHOST. It's not defined in the header file.
-
- For certain (old?) versions of GNU libc, AI_NUMERICHOST is
- defined but not implemented.
-
- + Use gethostbyname2, inet_aton and other IPv6 or thread-safe
- functions if available. But, see
- http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=135182 for one
- gethostbyname2 problem on Linux. And besides, if a platform is
- supporting IPv6 at all, they really should be doing getaddrinfo
- by now.
-
- + inet_ntop, inet_pton
-
- + Conditionally export/import the function definitions, so a
- library can have a single copy instead of multiple.
-
- + Upgrade host requirements to include working implementations of
- these functions, and throw all this away. Pleeease? :-) */
-
#include "port-sockets.h"
#include "socket-utils.h"
#include "k5-platform.h"
@@ -112,20 +117,20 @@
/*@-incondefs@*/
extern int
getaddrinfo (/*@in@*/ /*@null@*/ const char *,
- /*@in@*/ /*@null@*/ const char *,
- /*@in@*/ /*@null@*/ const struct addrinfo *,
- /*@out@*/ struct addrinfo **)
+ /*@in@*/ /*@null@*/ const char *,
+ /*@in@*/ /*@null@*/ const struct addrinfo *,
+ /*@out@*/ struct addrinfo **)
;
extern void
freeaddrinfo (/*@only@*/ /*@out@*/ struct addrinfo *)
;
extern int
getnameinfo (const struct sockaddr *addr, socklen_t addrsz,
- /*@out@*/ /*@null@*/ char *h, socklen_t hsz,
- /*@out@*/ /*@null@*/ char *s, socklen_t ssz,
- int flags)
- /*@requires (maxSet(h)+1) >= hsz /\ (maxSet(s)+1) >= ssz @*/
- /* too hard: maxRead(addr) >= (addrsz-1) */
+ /*@out@*/ /*@null@*/ char *h, socklen_t hsz,
+ /*@out@*/ /*@null@*/ char *s, socklen_t ssz,
+ int flags)
+/*@requires (maxSet(h)+1) >= hsz /\ (maxSet(s)+1) >= ssz @*/
+/* too hard: maxRead(addr) >= (addrsz-1) */
/*@modifies *h, *s@*/;
extern /*@dependent@*/ char *gai_strerror (int code) /*@*/;
/*@=incondefs@*/
@@ -162,8 +167,8 @@
#endif
#ifdef NUMERIC_SERVICE_BROKEN
-# include <ctype.h> /* isdigit */
-# include <stdlib.h> /* strtoul */
+# include <ctype.h> /* isdigit */
+# include <stdlib.h> /* strtoul */
#endif
@@ -172,9 +177,9 @@
gethostbyname_r? */
#if !defined(HAVE_GETHOSTBYNAME_R) || defined(THREADSAFE_GETHOSTBYNAME)
typedef struct hostent *GET_HOST_TMP;
-#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
+#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
{ TMP = gethostbyname (NAME); (ERR) = h_errno; (HP) = TMP; }
-#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR, TMP) \
+#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR, TMP) \
{ TMP = gethostbyaddr ((ADDR), (ADDRLEN), (FAMILY)); (ERR) = h_errno; (HP) = TMP; }
#else
#ifdef _AIX /* XXX should have a feature test! */
@@ -182,24 +187,24 @@
struct hostent ent;
struct hostent_data data;
} GET_HOST_TMP;
-#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
- { \
- (HP) = (gethostbyname_r((NAME), &TMP.ent, &TMP.data) \
- ? 0 \
- : &TMP.ent); \
- (ERR) = h_errno; \
+#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
+ { \
+ (HP) = (gethostbyname_r((NAME), &TMP.ent, &TMP.data) \
+ ? 0 \
+ : &TMP.ent); \
+ (ERR) = h_errno; \
}
/*
-#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR) \
- { \
- struct hostent my_h_ent; \
- struct hostent_data my_h_ent_data; \
- (HP) = (gethostbyaddr_r((ADDR), (ADDRLEN), (FAMILY), &my_h_ent, \
- &my_h_ent_data) \
- ? 0 \
- : &my_h_ent); \
- (ERR) = my_h_err; \
- }
+ #define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR) \
+ { \
+ struct hostent my_h_ent; \
+ struct hostent_data my_h_ent_data; \
+ (HP) = (gethostbyaddr_r((ADDR), (ADDRLEN), (FAMILY), &my_h_ent, \
+ &my_h_ent_data) \
+ ? 0 \
+ : &my_h_ent); \
+ (ERR) = my_h_err; \
+ }
*/
#else
#ifdef GETHOSTBYNAME_R_RETURNS_INT
@@ -207,48 +212,48 @@
struct hostent ent;
char buf[8192];
} GET_HOST_TMP;
-#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
- { \
- struct hostent *my_hp = NULL; \
- int my_h_err, my_ret; \
- my_ret = gethostbyname_r((NAME), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf), &my_hp, \
- &my_h_err); \
- (HP) = (((my_ret != 0) || (my_hp != &TMP.ent)) \
- ? 0 \
- : &TMP.ent); \
- (ERR) = my_h_err; \
+#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
+ { \
+ struct hostent *my_hp = NULL; \
+ int my_h_err, my_ret; \
+ my_ret = gethostbyname_r((NAME), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf), &my_hp, \
+ &my_h_err); \
+ (HP) = (((my_ret != 0) || (my_hp != &TMP.ent)) \
+ ? 0 \
+ : &TMP.ent); \
+ (ERR) = my_h_err; \
}
-#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR, TMP) \
- { \
- struct hostent *my_hp; \
- int my_h_err, my_ret; \
- my_ret = gethostbyaddr_r((ADDR), (ADDRLEN), (FAMILY), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf), &my_hp, \
- &my_h_err); \
- (HP) = (((my_ret != 0) || (my_hp != &TMP.ent)) \
- ? 0 \
- : &TMP.ent); \
- (ERR) = my_h_err; \
+#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR, TMP) \
+ { \
+ struct hostent *my_hp; \
+ int my_h_err, my_ret; \
+ my_ret = gethostbyaddr_r((ADDR), (ADDRLEN), (FAMILY), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf), &my_hp, \
+ &my_h_err); \
+ (HP) = (((my_ret != 0) || (my_hp != &TMP.ent)) \
+ ? 0 \
+ : &TMP.ent); \
+ (ERR) = my_h_err; \
}
#else
typedef struct {
struct hostent ent;
char buf[8192];
} GET_HOST_TMP;
-#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
- { \
- int my_h_err; \
- (HP) = gethostbyname_r((NAME), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf), &my_h_err); \
- (ERR) = my_h_err; \
+#define GET_HOST_BY_NAME(NAME, HP, ERR, TMP) \
+ { \
+ int my_h_err; \
+ (HP) = gethostbyname_r((NAME), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf), &my_h_err); \
+ (ERR) = my_h_err; \
}
-#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR, TMP) \
- { \
- int my_h_err; \
- (HP) = gethostbyaddr_r((ADDR), (ADDRLEN), (FAMILY), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf), &my_h_err); \
- (ERR) = my_h_err; \
+#define GET_HOST_BY_ADDR(ADDR, ADDRLEN, FAMILY, HP, ERR, TMP) \
+ { \
+ int my_h_err; \
+ (HP) = gethostbyaddr_r((ADDR), (ADDRLEN), (FAMILY), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf), &my_h_err); \
+ (ERR) = my_h_err; \
}
#endif /* returns int? */
#endif /* _AIX */
@@ -257,9 +262,9 @@
/* Now do the same for getservby* functions. */
#ifndef HAVE_GETSERVBYNAME_R
typedef struct servent *GET_SERV_TMP;
-#define GET_SERV_BY_NAME(NAME, PROTO, SP, ERR, TMP) \
+#define GET_SERV_BY_NAME(NAME, PROTO, SP, ERR, TMP) \
(TMP = getservbyname (NAME, PROTO), (SP) = TMP, (ERR) = (SP) ? 0 : -1)
-#define GET_SERV_BY_PORT(PORT, PROTO, SP, ERR, TMP) \
+#define GET_SERV_BY_PORT(PORT, PROTO, SP, ERR, TMP) \
(TMP = getservbyport (PORT, PROTO), (SP) = TMP, (ERR) = (SP) ? 0 : -1)
#else
#ifdef GETSERVBYNAME_R_RETURNS_INT
@@ -267,27 +272,27 @@
struct servent ent;
char buf[8192];
} GET_SERV_TMP;
-#define GET_SERV_BY_NAME(NAME, PROTO, SP, ERR, TMP) \
- { \
- struct servent *my_sp; \
- int my_s_err; \
- (SP) = (getservbyname_r((NAME), (PROTO), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf), &my_sp, \
- &my_s_err) \
- ? 0 \
- : &TMP.ent); \
- (ERR) = my_s_err; \
+#define GET_SERV_BY_NAME(NAME, PROTO, SP, ERR, TMP) \
+ { \
+ struct servent *my_sp; \
+ int my_s_err; \
+ (SP) = (getservbyname_r((NAME), (PROTO), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf), &my_sp, \
+ &my_s_err) \
+ ? 0 \
+ : &TMP.ent); \
+ (ERR) = my_s_err; \
}
-#define GET_SERV_BY_PORT(PORT, PROTO, SP, ERR, TMP) \
- { \
- struct servent *my_sp; \
- int my_s_err; \
- (SP) = (getservbyport_r((PORT), (PROTO), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf), &my_sp, \
- &my_s_err) \
- ? 0 \
- : &TMP.ent); \
- (ERR) = my_s_err; \
+#define GET_SERV_BY_PORT(PORT, PROTO, SP, ERR, TMP) \
+ { \
+ struct servent *my_sp; \
+ int my_s_err; \
+ (SP) = (getservbyport_r((PORT), (PROTO), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf), &my_sp, \
+ &my_s_err) \
+ ? 0 \
+ : &TMP.ent); \
+ (ERR) = my_s_err; \
}
#else
/* returns ptr -- IRIX? */
@@ -295,21 +300,21 @@
struct servent ent;
char buf[8192];
} GET_SERV_TMP;
-#define GET_SERV_BY_NAME(NAME, PROTO, SP, ERR, TMP) \
- { \
- (SP) = getservbyname_r((NAME), (PROTO), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf)); \
- (ERR) = (SP) == NULL; \
+#define GET_SERV_BY_NAME(NAME, PROTO, SP, ERR, TMP) \
+ { \
+ (SP) = getservbyname_r((NAME), (PROTO), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf)); \
+ (ERR) = (SP) == NULL; \
}
-#define GET_SERV_BY_PORT(PORT, PROTO, SP, ERR, TMP) \
- { \
- struct servent *my_sp; \
- my_sp = getservbyport_r((PORT), (PROTO), &TMP.ent, \
- TMP.buf, sizeof (TMP.buf)); \
- (SP) = my_sp; \
- (ERR) = my_sp == 0; \
- (ERR) = (ERR); /* avoid "unused" warning */ \
+#define GET_SERV_BY_PORT(PORT, PROTO, SP, ERR, TMP) \
+ { \
+ struct servent *my_sp; \
+ my_sp = getservbyport_r((PORT), (PROTO), &TMP.ent, \
+ TMP.buf, sizeof (TMP.buf)); \
+ (SP) = my_sp; \
+ (ERR) = my_sp == 0; \
+ (ERR) = (ERR); /* avoid "unused" warning */ \
}
#endif
#endif
@@ -317,8 +322,8 @@
#if defined(WRAP_GETADDRINFO) || defined(FAI_CACHE)
static inline int
system_getaddrinfo (const char *name, const char *serv,
- const struct addrinfo *hint,
- struct addrinfo **res)
+ const struct addrinfo *hint,
+ struct addrinfo **res)
{
return getaddrinfo(name, serv, hint, res);
}
@@ -336,8 +341,8 @@
but we don't have an autoconf test for that right now. */
static inline int
system_getnameinfo (const struct sockaddr *sa, socklen_t salen,
- char *host, size_t hostlen, char *serv, size_t servlen,
- int flags)
+ char *host, size_t hostlen, char *serv, size_t servlen,
+ int flags)
{
return getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
}
@@ -346,16 +351,16 @@
#if !defined (HAVE_GETADDRINFO) || defined(WRAP_GETADDRINFO) || defined(FAI_CACHE)
#undef getaddrinfo
-#define getaddrinfo my_fake_getaddrinfo
+#define getaddrinfo my_fake_getaddrinfo
#undef freeaddrinfo
-#define freeaddrinfo my_fake_freeaddrinfo
+#define freeaddrinfo my_fake_freeaddrinfo
#endif
#if !defined (HAVE_GETADDRINFO)
#undef gai_strerror
-#define gai_strerror my_fake_gai_strerror
+#define gai_strerror my_fake_gai_strerror
#endif /* ! HAVE_GETADDRINFO */
@@ -400,8 +405,8 @@
static const char *familyname (int f, char *buf, size_t bufsize) {
switch (f) {
default:
- snprintf(buf, bufsize, "AF %d", f);
- return buf;
+ snprintf(buf, bufsize, "AF %d", f);
+ return buf;
case AF_INET: return "AF_INET";
case AF_INET6: return "AF_INET6";
#ifdef AF_UNIX
@@ -411,35 +416,35 @@
}
static void debug_dump_getaddrinfo_args (const char *name, const char *serv,
- const struct addrinfo *hint)
+ const struct addrinfo *hint)
{
const char *sep;
fprintf(stderr,
- "getaddrinfo(hostname %s, service %s,\n"
- " hints { ",
- name ? name : "(null)", serv ? serv : "(null)");
+ "getaddrinfo(hostname %s, service %s,\n"
+ " hints { ",
+ name ? name : "(null)", serv ? serv : "(null)");
if (hint) {
- char buf[30];
- sep = "";
+ char buf[30];
+ sep = "";
#define Z(FLAG) if (hint->ai_flags & AI_##FLAG) fprintf(stderr, "%s%s", sep, #FLAG), sep = "|"
- Z(CANONNAME);
- Z(PASSIVE);
+ Z(CANONNAME);
+ Z(PASSIVE);
#ifdef AI_NUMERICHOST
- Z(NUMERICHOST);
+ Z(NUMERICHOST);
#endif
- if (sep[0] == 0)
- fprintf(stderr, "no-flags");
- if (hint->ai_family)
- fprintf(stderr, " %s", familyname(hint->ai_family, buf,
- sizeof(buf)));
- if (hint->ai_socktype)
- fprintf(stderr, " SOCK_%s", socktypename(hint->ai_socktype, buf,
- sizeof(buf)));
- if (hint->ai_protocol)
- fprintf(stderr, " IPPROTO_%s", protoname(hint->ai_protocol, buf,
- sizeof(buf)));
+ if (sep[0] == 0)
+ fprintf(stderr, "no-flags");
+ if (hint->ai_family)
+ fprintf(stderr, " %s", familyname(hint->ai_family, buf,
+ sizeof(buf)));
+ if (hint->ai_socktype)
+ fprintf(stderr, " SOCK_%s", socktypename(hint->ai_socktype, buf,
+ sizeof(buf)));
+ if (hint->ai_protocol)
+ fprintf(stderr, " IPPROTO_%s", protoname(hint->ai_protocol, buf,
+ sizeof(buf)));
} else
- fprintf(stderr, "(null)");
+ fprintf(stderr, "(null)");
fprintf(stderr, " }):\n");
}
@@ -454,17 +459,17 @@
char buf[10];
fprintf(stderr, "addrinfos returned:\n");
while (ai) {
- fprintf(stderr, "%p...", ai);
- fprintf(stderr, " socktype=%s", socktypename(ai->ai_socktype, buf,
- sizeof(buf)));
- fprintf(stderr, " ai_family=%s", familyname(ai->ai_family, buf,
- sizeof(buf)));
- if (ai->ai_family != ai->ai_addr->sa_family)
- fprintf(stderr, " sa_family=%s",
- familyname(ai->ai_addr->sa_family, buf, sizeof(buf)));
- fprintf(stderr, "\n");
- ai = ai->ai_next;
- count++;
+ fprintf(stderr, "%p...", ai);
+ fprintf(stderr, " socktype=%s", socktypename(ai->ai_socktype, buf,
+ sizeof(buf)));
+ fprintf(stderr, " ai_family=%s", familyname(ai->ai_family, buf,
+ sizeof(buf)));
+ if (ai->ai_family != ai->ai_addr->sa_family)
+ fprintf(stderr, " sa_family=%s",
+ familyname(ai->ai_addr->sa_family, buf, sizeof(buf)));
+ fprintf(stderr, "\n");
+ ai = ai->ai_next;
+ count++;
}
fprintf(stderr, "end addrinfos returned (%d)\n");
}
@@ -475,7 +480,7 @@
static
int getaddrinfo (const char *name, const char *serv,
- const struct addrinfo *hint, struct addrinfo **result);
+ const struct addrinfo *hint, struct addrinfo **result);
static
void freeaddrinfo (struct addrinfo *ai);
@@ -491,7 +496,7 @@
#define HAVE_GETNAMEINFO 1
#undef getnameinfo
-#define getnameinfo my_fake_getnameinfo
+#define getnameinfo my_fake_getnameinfo
static
char *gai_strerror (int code);
@@ -501,9 +506,9 @@
#if !defined (HAVE_GETADDRINFO)
static
int getnameinfo (const struct sockaddr *addr, socklen_t len,
- char *host, socklen_t hostlen,
- char *service, socklen_t servicelen,
- int flags);
+ char *host, socklen_t hostlen,
+ char *service, socklen_t servicelen,
+ int flags);
#endif
/* Fudge things on older gai implementations. */
@@ -541,45 +546,45 @@
static inline int translate_h_errno (int h);
static inline int fai_add_entry (struct addrinfo **result, void *addr,
- int port, const struct addrinfo *template)
+ int port, const struct addrinfo *template)
{
struct addrinfo *n = malloc (sizeof (struct addrinfo));
if (n == 0)
- return EAI_MEMORY;
+ return EAI_MEMORY;
if (template->ai_family != AF_INET
#ifdef KRB5_USE_INET6
- && template->ai_family != AF_INET6
+ && template->ai_family != AF_INET6
#endif
- )
- return EAI_FAMILY;
+ )
+ return EAI_FAMILY;
*n = *template;
if (template->ai_family == AF_INET) {
- struct sockaddr_in *sin4;
- sin4 = malloc (sizeof (struct sockaddr_in));
- if (sin4 == 0)
- return EAI_MEMORY;
+ struct sockaddr_in *sin4;
+ sin4 = malloc (sizeof (struct sockaddr_in));
+ if (sin4 == 0)
+ return EAI_MEMORY;
memset (sin4, 0, sizeof (struct sockaddr_in)); /* for sin_zero */
- n->ai_addr = (struct sockaddr *) sin4;
- sin4->sin_family = AF_INET;
- sin4->sin_addr = *(struct in_addr *)addr;
- sin4->sin_port = port;
+ n->ai_addr = (struct sockaddr *) sin4;
+ sin4->sin_family = AF_INET;
+ sin4->sin_addr = *(struct in_addr *)addr;
+ sin4->sin_port = port;
#ifdef HAVE_SA_LEN
- sin4->sin_len = sizeof (struct sockaddr_in);
+ sin4->sin_len = sizeof (struct sockaddr_in);
#endif
}
#ifdef KRB5_USE_INET6
if (template->ai_family == AF_INET6) {
- struct sockaddr_in6 *sin6;
- sin6 = malloc (sizeof (struct sockaddr_in6));
- if (sin6 == 0)
- return EAI_MEMORY;
+ struct sockaddr_in6 *sin6;
+ sin6 = malloc (sizeof (struct sockaddr_in6));
+ if (sin6 == 0)
+ return EAI_MEMORY;
memset (sin6, 0, sizeof (struct sockaddr_in6)); /* for sin_zero */
- n->ai_addr = (struct sockaddr *) sin6;
- sin6->sin6_family = AF_INET6;
- sin6->sin6_addr = *(struct in6_addr *)addr;
- sin6->sin6_port = port;
+ n->ai_addr = (struct sockaddr *) sin6;
+ sin6->sin6_family = AF_INET6;
+ sin6->sin6_addr = *(struct in6_addr *)addr;
+ sin6->sin6_port = port;
#ifdef HAVE_SA_LEN
- sin6->sin6_len = sizeof (struct sockaddr_in6);
+ sin6->sin6_len = sizeof (struct sockaddr_in6);
#endif
}
#endif
@@ -590,21 +595,21 @@
#ifdef FAI_CACHE
/* fake addrinfo cache entries */
-#define CACHE_ENTRY_LIFETIME 15 /* seconds */
+#define CACHE_ENTRY_LIFETIME 15 /* seconds */
static void plant_face (const char *name, struct face *entry)
{
entry->name = strdup(name);
if (entry->name == NULL)
- /* @@ Wastes memory. */
- return;
+ /* @@ Wastes memory. */
+ return;
k5_mutex_assert_locked(&krb5int_fac.lock);
entry->next = krb5int_fac.data;
entry->expiration = time(0) + CACHE_ENTRY_LIFETIME;
krb5int_fac.data = entry;
#ifdef DEBUG_ADDRINFO
printf("added cache entry '%s' at %p: %d ipv4, %d ipv6; expire %d\n",
- name, entry, entry->naddrs4, entry->naddrs6, entry->expiration);
+ name, entry, entry->naddrs4, entry->naddrs6, entry->expiration);
#endif
}
@@ -620,38 +625,38 @@
#endif
k5_mutex_assert_locked(&krb5int_fac.lock);
for (fpp = &krb5int_fac.data; *fpp; ) {
- fp = *fpp;
+ fp = *fpp;
#ifdef DEBUG_ADDRINFO
- printf(" checking expiration time of @%p: %d\n",
- fp, fp->expiration);
+ printf(" checking expiration time of @%p: %d\n",
+ fp, fp->expiration);
#endif
- if (fp->expiration < now) {
+ if (fp->expiration < now) {
#ifdef DEBUG_ADDRINFO
- printf("\texpiring cache entry\n");
+ printf("\texpiring cache entry\n");
#endif
- free(fp->name);
- free(fp->canonname);
- free(fp->addrs4);
- free(fp->addrs6);
- *fpp = fp->next;
- free(fp);
- /* Stay at this point in the list, and check again. */
- } else
- /* Move forward. */
- fpp = &(*fpp)->next;
+ free(fp->name);
+ free(fp->canonname);
+ free(fp->addrs4);
+ free(fp->addrs6);
+ *fpp = fp->next;
+ free(fp);
+ /* Stay at this point in the list, and check again. */
+ } else
+ /* Move forward. */
+ fpp = &(*fpp)->next;
}
for (fp = krb5int_fac.data; fp; fp = fp->next) {
#ifdef DEBUG_ADDRINFO
- printf(" comparing entry @%p\n", fp);
+ printf(" comparing entry @%p\n", fp);
#endif
- if (!strcasecmp(fp->name, name)) {
+ if (!strcasecmp(fp->name, name)) {
#ifdef DEBUG_ADDRINFO
- printf("\tMATCH!\n");
+ printf("\tMATCH!\n");
#endif
- *entry = fp;
- return 1;
- }
+ *entry = fp;
+ return 1;
+ }
}
return 0;
}
@@ -663,9 +668,9 @@
#endif
static inline int fai_add_hosts_by_name (const char *name,
- struct addrinfo *template,
- int portnum, int flags,
- struct addrinfo **result)
+ struct addrinfo *template,
+ int portnum, int flags,
+ struct addrinfo **result)
{
#ifdef FAI_CACHE
@@ -674,127 +679,127 @@
err = krb5int_lock_fac();
if (err) {
- errno = err;
- return EAI_SYSTEM;
+ errno = err;
+ return EAI_SYSTEM;
}
if (!find_face(name, &ce)) {
- struct addrinfo myhints = { 0 }, *ai, *ai2;
- int i4, i6, aierr;
+ struct addrinfo myhints = { 0 }, *ai, *ai2;
+ int i4, i6, aierr;
#ifdef DEBUG_ADDRINFO
- printf("looking up new data for '%s'...\n", name);
+ printf("looking up new data for '%s'...\n", name);
#endif
- myhints.ai_socktype = SOCK_STREAM;
- myhints.ai_flags = AI_CANONNAME;
- /* Don't set ai_family -- we want to cache all address types,
- because the next lookup may not use the same constraints as
- the current one. We *could* cache them separately, so that
- we never have to look up an IPv6 address if we are always
- asked for IPv4 only, but let's deal with that later, if we
- have to. */
- /* Try NULL for the service for now.
+ myhints.ai_socktype = SOCK_STREAM;
+ myhints.ai_flags = AI_CANONNAME;
+ /* Don't set ai_family -- we want to cache all address types,
+ because the next lookup may not use the same constraints as
+ the current one. We *could* cache them separately, so that
+ we never have to look up an IPv6 address if we are always
+ asked for IPv4 only, but let's deal with that later, if we
+ have to. */
+ /* Try NULL for the service for now.
- It would be nice to use the requested service name, and not
- have to patch things up, but then we'd be doing multiple
- queries for the same host when we get different services.
- We were using "telnet" for a little more confidence that
- getaddrinfo would heed the hints to only give us stream
- socket types (with no socket type and null service name, we
- might get stream *and* dgram *and* raw, for each address,
- or only raw). The RFC 3493 description of ai_socktype
- sometimes associates it with the specified service,
- sometimes not.
+ It would be nice to use the requested service name, and not
+ have to patch things up, but then we'd be doing multiple
+ queries for the same host when we get different services.
+ We were using "telnet" for a little more confidence that
+ getaddrinfo would heed the hints to only give us stream
+ socket types (with no socket type and null service name, we
+ might get stream *and* dgram *and* raw, for each address,
+ or only raw). The RFC 3493 description of ai_socktype
+ sometimes associates it with the specified service,
+ sometimes not.
- But on Mac OS X (10.3, 10.4) they've "extended" getaddrinfo
- to make SRV RR queries. (Please, somebody, show me
- something in the specs that actually supports this? RFC
- 3493 says nothing about it, but it does say getaddrinfo is
- the new way to look up hostnames. RFC 2782 says SRV
- records should *not* be used unless the application
- protocol spec says to do so. The Telnet spec does not say
- to do it.) And then they complain when our code
- "unexpectedly" seems to use this "extension" in cases where
- they don't want it to be used.
+ But on Mac OS X (10.3, 10.4) they've "extended" getaddrinfo
+ to make SRV RR queries. (Please, somebody, show me
+ something in the specs that actually supports this? RFC
+ 3493 says nothing about it, but it does say getaddrinfo is
+ the new way to look up hostnames. RFC 2782 says SRV
+ records should *not* be used unless the application
+ protocol spec says to do so. The Telnet spec does not say
+ to do it.) And then they complain when our code
+ "unexpectedly" seems to use this "extension" in cases where
+ they don't want it to be used.
- Fortunately, it appears that if we specify ai_socktype as
- SOCK_STREAM and use a null service name, we only get one
- copy of each address on all the platforms I've tried,
- although it may not have ai_socktype filled in properly.
- So, we'll fudge it with that for now. */
- aierr = system_getaddrinfo(name, NULL, &myhints, &ai);
- if (aierr) {
- krb5int_unlock_fac();
- return aierr;
- }
- ce = malloc(sizeof(struct face));
- memset(ce, 0, sizeof(*ce));
- ce->expiration = time(0) + 30;
- for (ai2 = ai; ai2; ai2 = ai2->ai_next) {
+ Fortunately, it appears that if we specify ai_socktype as
+ SOCK_STREAM and use a null service name, we only get one
+ copy of each address on all the platforms I've tried,
+ although it may not have ai_socktype filled in properly.
+ So, we'll fudge it with that for now. */
+ aierr = system_getaddrinfo(name, NULL, &myhints, &ai);
+ if (aierr) {
+ krb5int_unlock_fac();
+ return aierr;
+ }
+ ce = malloc(sizeof(struct face));
+ memset(ce, 0, sizeof(*ce));
+ ce->expiration = time(0) + 30;
+ for (ai2 = ai; ai2; ai2 = ai2->ai_next) {
#ifdef DEBUG_ADDRINFO
- printf(" found an address in family %d...\n", ai2->ai_family);
+ printf(" found an address in family %d...\n", ai2->ai_family);
#endif
- switch (ai2->ai_family) {
- case AF_INET:
- ce->naddrs4++;
- break;
- case AF_INET6:
- ce->naddrs6++;
- break;
- default:
- break;
- }
- }
- ce->addrs4 = calloc(ce->naddrs4, sizeof(*ce->addrs4));
- if (ce->addrs4 == NULL && ce->naddrs4 != 0) {
- krb5int_unlock_fac();
- system_freeaddrinfo(ai);
- return EAI_MEMORY;
- }
- ce->addrs6 = calloc(ce->naddrs6, sizeof(*ce->addrs6));
- if (ce->addrs6 == NULL && ce->naddrs6 != 0) {
- krb5int_unlock_fac();
- free(ce->addrs4);
- system_freeaddrinfo(ai);
- return EAI_MEMORY;
- }
- for (ai2 = ai, i4 = i6 = 0; ai2; ai2 = ai2->ai_next) {
- switch (ai2->ai_family) {
- case AF_INET:
- ce->addrs4[i4++] = ((struct sockaddr_in *)ai2->ai_addr)->sin_addr;
- break;
- case AF_INET6:
- ce->addrs6[i6++] = ((struct sockaddr_in6 *)ai2->ai_addr)->sin6_addr;
- break;
- default:
- break;
- }
- }
- ce->canonname = ai->ai_canonname ? strdup(ai->ai_canonname) : 0;
- system_freeaddrinfo(ai);
- plant_face(name, ce);
+ switch (ai2->ai_family) {
+ case AF_INET:
+ ce->naddrs4++;
+ break;
+ case AF_INET6:
+ ce->naddrs6++;
+ break;
+ default:
+ break;
+ }
+ }
+ ce->addrs4 = calloc(ce->naddrs4, sizeof(*ce->addrs4));
+ if (ce->addrs4 == NULL && ce->naddrs4 != 0) {
+ krb5int_unlock_fac();
+ system_freeaddrinfo(ai);
+ return EAI_MEMORY;
+ }
+ ce->addrs6 = calloc(ce->naddrs6, sizeof(*ce->addrs6));
+ if (ce->addrs6 == NULL && ce->naddrs6 != 0) {
+ krb5int_unlock_fac();
+ free(ce->addrs4);
+ system_freeaddrinfo(ai);
+ return EAI_MEMORY;
+ }
+ for (ai2 = ai, i4 = i6 = 0; ai2; ai2 = ai2->ai_next) {
+ switch (ai2->ai_family) {
+ case AF_INET:
+ ce->addrs4[i4++] = ((struct sockaddr_in *)ai2->ai_addr)->sin_addr;
+ break;
+ case AF_INET6:
+ ce->addrs6[i6++] = ((struct sockaddr_in6 *)ai2->ai_addr)->sin6_addr;
+ break;
+ default:
+ break;
+ }
+ }
+ ce->canonname = ai->ai_canonname ? strdup(ai->ai_canonname) : 0;
+ system_freeaddrinfo(ai);
+ plant_face(name, ce);
}
template->ai_family = AF_INET6;
template->ai_addrlen = sizeof(struct sockaddr_in6);
for (i = 0; i < ce->naddrs6; i++) {
- r = fai_add_entry (result, &ce->addrs6[i], portnum, template);
- if (r) {
- krb5int_unlock_fac();
- return r;
- }
+ r = fai_add_entry (result, &ce->addrs6[i], portnum, template);
+ if (r) {
+ krb5int_unlock_fac();
+ return r;
+ }
}
template->ai_family = AF_INET;
template->ai_addrlen = sizeof(struct sockaddr_in);
for (i = 0; i < ce->naddrs4; i++) {
- r = fai_add_entry (result, &ce->addrs4[i], portnum, template);
- if (r) {
- krb5int_unlock_fac();
- return r;
- }
+ r = fai_add_entry (result, &ce->addrs4[i], portnum, template);
+ if (r) {
+ krb5int_unlock_fac();
+ return r;
+ }
}
if (*result && (flags & AI_CANONNAME))
- (*result)->ai_canonname = (ce->canonname
- ? strdup(ce->canonname)
- : NULL);
+ (*result)->ai_canonname = (ce->canonname
+ ? strdup(ce->canonname)
+ : NULL);
krb5int_unlock_fac();
return 0;
@@ -807,14 +812,14 @@
GET_HOST_BY_NAME (name, hp, herr, htmp);
if (hp == 0)
- return translate_h_errno (herr);
+ return translate_h_errno (herr);
for (i = 0; hp->h_addr_list[i]; i++) {
- r = fai_add_entry (result, hp->h_addr_list[i], portnum, template);
- if (r)
- return r;
+ r = fai_add_entry (result, hp->h_addr_list[i], portnum, template);
+ if (r)
+ return r;
}
if (*result && (flags & AI_CANONNAME))
- (*result)->ai_canonname = strdup (hp->h_name);
+ (*result)->ai_canonname = strdup (hp->h_name);
return 0;
#endif
@@ -825,19 +830,19 @@
{
struct addrinfo *next;
while (ai) {
- next = ai->ai_next;
- if (ai->ai_canonname)
- free (ai->ai_canonname);
- if (ai->ai_addr)
- free (ai->ai_addr);
- free (ai);
- ai = next;
+ next = ai->ai_next;
+ if (ai->ai_canonname)
+ free (ai->ai_canonname);
+ if (ai->ai_addr)
+ free (ai->ai_addr);
+ free (ai);
+ ai = next;
}
}
static inline int
fake_getaddrinfo (const char *name, const char *serv,
- const struct addrinfo *hint, struct addrinfo **result)
+ const struct addrinfo *hint, struct addrinfo **result)
{
struct addrinfo *res = 0;
int ret;
@@ -850,49 +855,49 @@
#endif
if (hint != 0) {
- if (hint->ai_family != 0 && hint->ai_family != AF_INET)
- return EAI_NODATA;
- socktype = hint->ai_socktype;
- flags = hint->ai_flags;
+ if (hint->ai_family != 0 && hint->ai_family != AF_INET)
+ return EAI_NODATA;
+ socktype = hint->ai_socktype;
+ flags = hint->ai_flags;
} else {
- socktype = 0;
- flags = 0;
+ socktype = 0;
+ flags = 0;
}
if (serv) {
- size_t numlen = strspn (serv, "0123456789");
- if (serv[numlen] == '\0') {
- /* pure numeric */
- unsigned long p = strtoul (serv, 0, 10);
- if (p == 0 || p > 65535)
- return EAI_NONAME;
- port = htons (p);
- } else {
- struct servent *sp;
- int try_dgram_too = 0, s_err;
- GET_SERV_TMP stmp;
+ size_t numlen = strspn (serv, "0123456789");
+ if (serv[numlen] == '\0') {
+ /* pure numeric */
+ unsigned long p = strtoul (serv, 0, 10);
+ if (p == 0 || p > 65535)
+ return EAI_NONAME;
+ port = htons (p);
+ } else {
+ struct servent *sp;
+ int try_dgram_too = 0, s_err;
+ GET_SERV_TMP stmp;
- if (socktype == 0) {
- try_dgram_too = 1;
- socktype = SOCK_STREAM;
- }
- try_service_lookup:
- GET_SERV_BY_NAME(serv, socktype == SOCK_STREAM ? "tcp" : "udp",
- sp, s_err, stmp);
- if (sp == 0) {
- if (try_dgram_too) {
- socktype = SOCK_DGRAM;
- goto try_service_lookup;
- }
- return EAI_SERVICE;
- }
- port = sp->s_port;
- }
+ if (socktype == 0) {
+ try_dgram_too = 1;
+ socktype = SOCK_STREAM;
+ }
+ try_service_lookup:
+ GET_SERV_BY_NAME(serv, socktype == SOCK_STREAM ? "tcp" : "udp",
+ sp, s_err, stmp);
+ if (sp == 0) {
+ if (try_dgram_too) {
+ socktype = SOCK_DGRAM;
+ goto try_service_lookup;
+ }
+ return EAI_SERVICE;
+ }
+ port = sp->s_port;
+ }
}
if (name == 0) {
- name = (flags & AI_PASSIVE) ? "0.0.0.0" : "127.0.0.1";
- flags |= AI_NUMERICHOST;
+ name = (flags & AI_PASSIVE) ? "0.0.0.0" : "127.0.0.1";
+ flags |= AI_NUMERICHOST;
}
template.ai_family = AF_INET;
@@ -907,29 +912,29 @@
/* If NUMERICHOST is set, parse a numeric address.
If it's not set, don't accept such names. */
if (flags & AI_NUMERICHOST) {
- struct in_addr addr4;
+ struct in_addr addr4;
#if 0
- ret = inet_aton (name, &addr4);
- if (ret)
- return EAI_NONAME;
+ ret = inet_aton (name, &addr4);
+ if (ret)
+ return EAI_NONAME;
#else
- addr4.s_addr = inet_addr (name);
- if (addr4.s_addr == 0xffffffff || addr4.s_addr == -1)
- /* 255.255.255.255 or parse error, both bad */
- return EAI_NONAME;
+ addr4.s_addr = inet_addr (name);
+ if (addr4.s_addr == 0xffffffff || addr4.s_addr == -1)
+ /* 255.255.255.255 or parse error, both bad */
+ return EAI_NONAME;
#endif
- ret = fai_add_entry (&res, &addr4, port, &template);
+ ret = fai_add_entry (&res, &addr4, port, &template);
} else {
- ret = fai_add_hosts_by_name (name, &template, port, flags,
- &res);
+ ret = fai_add_hosts_by_name (name, &template, port, flags,
+ &res);
}
if (ret && ret != NO_ADDRESS) {
- fake_freeaddrinfo (res);
- return ret;
+ fake_freeaddrinfo (res);
+ return ret;
}
if (res == 0)
- return NO_ADDRESS;
+ return NO_ADDRESS;
*result = res;
return 0;
}
@@ -937,9 +942,9 @@
#ifdef NEED_FAKE_GETNAMEINFO
static inline int
fake_getnameinfo (const struct sockaddr *sa, socklen_t len,
- char *host, socklen_t hostlen,
- char *service, socklen_t servicelen,
- int flags)
+ char *host, socklen_t hostlen,
+ char *service, socklen_t servicelen,
+ int flags)
{
struct hostent *hp;
const struct sockaddr_in *sinp;
@@ -947,83 +952,83 @@
size_t hlen, slen;
if (sa->sa_family != AF_INET) {
- return EAI_FAMILY;
+ return EAI_FAMILY;
}
sinp = (const struct sockaddr_in *) sa;
hlen = hostlen;
if (hostlen < 0 || hlen != hostlen) {
- errno = EINVAL;
- return EAI_SYSTEM;
+ errno = EINVAL;
+ return EAI_SYSTEM;
}
slen = servicelen;
if (servicelen < 0 || slen != servicelen) {
- errno = EINVAL;
- return EAI_SYSTEM;
+ errno = EINVAL;
+ return EAI_SYSTEM;
}
if (host) {
- if (flags & NI_NUMERICHOST) {
+ if (flags & NI_NUMERICHOST) {
#if (defined(__GNUC__) && defined(__mips__)) || 1 /* thread safety always */
- /* The inet_ntoa call, passing a struct, fails on IRIX 6.5
- using gcc 2.95; we get back "0.0.0.0". Since this in a
- configuration still important at Athena, here's the
- workaround, which also happens to be thread-safe.... */
- const unsigned char *uc;
- char tmpbuf[20];
- numeric_host:
- uc = (const unsigned char *) &sinp->sin_addr;
- snprintf(tmpbuf, sizeof(tmpbuf), "%d.%d.%d.%d",
- uc[0], uc[1], uc[2], uc[3]);
- strncpy(host, tmpbuf, hlen);
+ /* The inet_ntoa call, passing a struct, fails on IRIX 6.5
+ using gcc 2.95; we get back "0.0.0.0". Since this in a
+ configuration still important at Athena, here's the
+ workaround, which also happens to be thread-safe.... */
+ const unsigned char *uc;
+ char tmpbuf[20];
+ numeric_host:
+ uc = (const unsigned char *) &sinp->sin_addr;
+ snprintf(tmpbuf, sizeof(tmpbuf), "%d.%d.%d.%d",
+ uc[0], uc[1], uc[2], uc[3]);
+ strncpy(host, tmpbuf, hlen);
#else
- char *p;
- numeric_host:
- p = inet_ntoa (sinp->sin_addr);
- strncpy (host, p, hlen);
+ char *p;
+ numeric_host:
+ p = inet_ntoa (sinp->sin_addr);
+ strncpy (host, p, hlen);
#endif
- } else {
- int herr;
- GET_HOST_TMP htmp;
+ } else {
+ int herr;
+ GET_HOST_TMP htmp;
- GET_HOST_BY_ADDR((const char *) &sinp->sin_addr,
- sizeof (struct in_addr),
- sa->sa_family, hp, herr, htmp);
- if (hp == 0) {
- if (herr == NO_ADDRESS && !(flags & NI_NAMEREQD)) /* ??? */
- goto numeric_host;
- return translate_h_errno (herr);
- }
- /* According to the Open Group spec, getnameinfo can
- silently truncate, but must still return a
- null-terminated string. */
- strncpy (host, hp->h_name, hlen);
- }
- host[hostlen-1] = 0;
+ GET_HOST_BY_ADDR((const char *) &sinp->sin_addr,
+ sizeof (struct in_addr),
+ sa->sa_family, hp, herr, htmp);
+ if (hp == 0) {
+ if (herr == NO_ADDRESS && !(flags & NI_NAMEREQD)) /* ??? */
+ goto numeric_host;
+ return translate_h_errno (herr);
+ }
+ /* According to the Open Group spec, getnameinfo can
+ silently truncate, but must still return a
+ null-terminated string. */
+ strncpy (host, hp->h_name, hlen);
+ }
+ host[hostlen-1] = 0;
}
if (service) {
- if (flags & NI_NUMERICSERV) {
- char numbuf[10];
- int port;
- numeric_service:
- port = ntohs (sinp->sin_port);
- if (port < 0 || port > 65535)
- return EAI_FAIL;
- snprintf (numbuf, sizeof(numbuf), "%d", port);
- strncpy (service, numbuf, slen);
- } else {
- int serr;
- GET_SERV_TMP stmp;
+ if (flags & NI_NUMERICSERV) {
+ char numbuf[10];
+ int port;
+ numeric_service:
+ port = ntohs (sinp->sin_port);
+ if (port < 0 || port > 65535)
+ return EAI_FAIL;
+ snprintf (numbuf, sizeof(numbuf), "%d", port);
+ strncpy (service, numbuf, slen);
+ } else {
+ int serr;
+ GET_SERV_TMP stmp;
- GET_SERV_BY_PORT(sinp->sin_port,
- (flags & NI_DGRAM) ? "udp" : "tcp",
- sp, serr, stmp);
- if (sp == 0)
- goto numeric_service;
- strncpy (service, sp->s_name, slen);
- }
- service[servicelen-1] = 0;
+ GET_SERV_BY_PORT(sinp->sin_port,
+ (flags & NI_DGRAM) ? "udp" : "tcp",
+ sp, serr, stmp);
+ if (sp == 0)
+ goto numeric_service;
+ strncpy (service, sp->s_name, slen);
+ }
+ service[servicelen-1] = 0;
}
return 0;
@@ -1037,17 +1042,17 @@
{
switch (code) {
case EAI_ADDRFAMILY: return "address family for nodename not supported";
- case EAI_AGAIN: return "temporary failure in name resolution";
- case EAI_BADFLAGS: return "bad flags to getaddrinfo/getnameinfo";
- case EAI_FAIL: return "non-recoverable failure in name resolution";
- case EAI_FAMILY: return "ai_family not supported";
- case EAI_MEMORY: return "out of memory";
- case EAI_NODATA: return "no address associated with hostname";
- case EAI_NONAME: return "name does not exist";
- case EAI_SERVICE: return "service name not supported for specified socket type";
- case EAI_SOCKTYPE: return "ai_socktype not supported";
- case EAI_SYSTEM: return strerror (errno);
- default: return "bogus getaddrinfo error?";
+ case EAI_AGAIN: return "temporary failure in name resolution";
+ case EAI_BADFLAGS: return "bad flags to getaddrinfo/getnameinfo";
+ case EAI_FAIL: return "non-recoverable failure in name resolution";
+ case EAI_FAMILY: return "ai_family not supported";
+ case EAI_MEMORY: return "out of memory";
+ case EAI_NODATA: return "no address associated with hostname";
+ case EAI_NONAME: return "name does not exist";
+ case EAI_SERVICE: return "service name not supported for specified socket type";
+ case EAI_SOCKTYPE: return "ai_socktype not supported";
+ case EAI_SYSTEM: return strerror (errno);
+ default: return "bogus getaddrinfo error?";
}
}
#endif
@@ -1056,33 +1061,33 @@
{
switch (h) {
case 0:
- return 0;
+ return 0;
#ifdef NETDB_INTERNAL
case NETDB_INTERNAL:
- if (errno == ENOMEM)
- return EAI_MEMORY;
- return EAI_SYSTEM;
+ if (errno == ENOMEM)
+ return EAI_MEMORY;
+ return EAI_SYSTEM;
#endif
case HOST_NOT_FOUND:
- return EAI_NONAME;
+ return EAI_NONAME;
case TRY_AGAIN:
- return EAI_AGAIN;
+ return EAI_AGAIN;
case NO_RECOVERY:
- return EAI_FAIL;
+ return EAI_FAIL;
case NO_DATA:
#if NO_DATA != NO_ADDRESS
case NO_ADDRESS:
#endif
- return EAI_NODATA;
+ return EAI_NODATA;
default:
- return EAI_SYSTEM;
+ return EAI_SYSTEM;
}
}
#if defined(HAVE_FAKE_GETADDRINFO) || defined(FAI_CACHE)
static inline
int getaddrinfo (const char *name, const char *serv,
- const struct addrinfo *hint, struct addrinfo **result)
+ const struct addrinfo *hint, struct addrinfo **result)
{
return fake_getaddrinfo(name, serv, hint, result);
}
@@ -1096,12 +1101,12 @@
#ifdef NEED_FAKE_GETNAMEINFO
static inline
int getnameinfo (const struct sockaddr *sa, socklen_t len,
- char *host, socklen_t hostlen,
- char *service, socklen_t servicelen,
- int flags)
+ char *host, socklen_t hostlen,
+ char *service, socklen_t servicelen,
+ int flags)
{
return fake_getnameinfo(sa, len, host, hostlen, service, servicelen,
- flags);
+ flags);
}
#endif /* NEED_FAKE_GETNAMEINFO */
#endif /* HAVE_FAKE_GETADDRINFO */
@@ -1113,7 +1118,7 @@
static inline
int
getaddrinfo (const char *name, const char *serv, const struct addrinfo *hint,
- struct addrinfo **result)
+ struct addrinfo **result)
{
int aierr;
#if defined(_AIX) || defined(COPY_FIRST_CANONNAME)
@@ -1137,32 +1142,32 @@
code (for "host not found") is returned. If the port maps to a
known service for both udp and tcp, all is well. */
if (serv && serv[0] && isdigit(serv[0])) {
- unsigned long lport;
- char *end;
- lport = strtoul(serv, &end, 10);
- if (!*end) {
- if (lport > 65535)
- return EAI_SOCKTYPE;
- service_is_numeric = 1;
- service_port = htons(lport);
+ unsigned long lport;
+ char *end;
+ lport = strtoul(serv, &end, 10);
+ if (!*end) {
+ if (lport > 65535)
+ return EAI_SOCKTYPE;
+ service_is_numeric = 1;
+ service_port = htons(lport);
#ifdef AI_NUMERICSERV
- if (hint && hint->ai_flags & AI_NUMERICSERV)
- serv = "9";
- else
+ if (hint && hint->ai_flags & AI_NUMERICSERV)
+ serv = "9";
+ else
#endif
- serv = "discard"; /* defined for both udp and tcp */
- if (hint)
- socket_type = hint->ai_socktype;
- }
+ serv = "discard"; /* defined for both udp and tcp */
+ if (hint)
+ socket_type = hint->ai_socktype;
+ }
}
#endif
aierr = system_getaddrinfo (name, serv, hint, result);
if (aierr || *result == 0) {
#ifdef DEBUG_ADDRINFO
- debug_dump_error(aierr);
+ debug_dump_error(aierr);
#endif
- return aierr;
+ return aierr;
}
/* Linux libc version 6 prior to 2.3.4 is broken.
@@ -1221,87 +1226,87 @@
*/
ai = *result;
if (ai->ai_canonname) {
- struct hostent *hp;
- const char *name2 = 0;
- int i, herr;
- GET_HOST_TMP htmp;
+ struct hostent *hp;
+ const char *name2 = 0;
+ int i, herr;
+ GET_HOST_TMP htmp;
- /*
- * Current versions of GET_HOST_BY_NAME will fail if the
- * target hostname has IPv6 addresses only. Make sure it
- * fails fairly cleanly.
- */
- GET_HOST_BY_NAME (name, hp, herr, htmp);
- if (hp == 0) {
- /*
- * This case probably means it's an IPv6-only name. If
- * ai_canonname is a numeric address, get rid of it.
- */
- if (ai->ai_canonname && strchr(ai->ai_canonname, ':'))
- ai->ai_canonname = 0;
- name2 = ai->ai_canonname ? ai->ai_canonname : name;
- } else {
- /* Sometimes gethostbyname will be directed to /etc/hosts
- first, and sometimes that file will have entries with
- the unqualified name first. So take the first entry
- that looks like it could be a FQDN. */
- for (i = 0; hp->h_aliases[i]; i++) {
- if (strchr(hp->h_aliases[i], '.') != 0) {
- name2 = hp->h_aliases[i];
- break;
- }
- }
- /* Give up, just use the first name (h_name ==
- h_aliases[0] on all systems I've seen). */
- if (hp->h_aliases[i] == 0)
- name2 = hp->h_name;
- }
+ /*
+ * Current versions of GET_HOST_BY_NAME will fail if the
+ * target hostname has IPv6 addresses only. Make sure it
+ * fails fairly cleanly.
+ */
+ GET_HOST_BY_NAME (name, hp, herr, htmp);
+ if (hp == 0) {
+ /*
+ * This case probably means it's an IPv6-only name. If
+ * ai_canonname is a numeric address, get rid of it.
+ */
+ if (ai->ai_canonname && strchr(ai->ai_canonname, ':'))
+ ai->ai_canonname = 0;
+ name2 = ai->ai_canonname ? ai->ai_canonname : name;
+ } else {
+ /* Sometimes gethostbyname will be directed to /etc/hosts
+ first, and sometimes that file will have entries with
+ the unqualified name first. So take the first entry
+ that looks like it could be a FQDN. */
+ for (i = 0; hp->h_aliases[i]; i++) {
+ if (strchr(hp->h_aliases[i], '.') != 0) {
+ name2 = hp->h_aliases[i];
+ break;
+ }
+ }
+ /* Give up, just use the first name (h_name ==
+ h_aliases[0] on all systems I've seen). */
+ if (hp->h_aliases[i] == 0)
+ name2 = hp->h_name;
+ }
- ai->ai_canonname = strdup(name2);
- if (name2 != 0 && ai->ai_canonname == 0) {
- system_freeaddrinfo(ai);
- *result = 0;
+ ai->ai_canonname = strdup(name2);
+ if (name2 != 0 && ai->ai_canonname == 0) {
+ system_freeaddrinfo(ai);
+ *result = 0;
#ifdef DEBUG_ADDRINFO
- debug_dump_error(EAI_MEMORY);
+ debug_dump_error(EAI_MEMORY);
#endif
- return EAI_MEMORY;
- }
- /* Zap the remaining ai_canonname fields glibc fills in, in
- case the application messes around with the list
- structure. */
- while ((ai = ai->ai_next) != NULL)
- ai->ai_canonname = 0;
+ return EAI_MEMORY;
+ }
+ /* Zap the remaining ai_canonname fields glibc fills in, in
+ case the application messes around with the list
+ structure. */
+ while ((ai = ai->ai_next) != NULL)
+ ai->ai_canonname = 0;
}
#endif
#ifdef NUMERIC_SERVICE_BROKEN
if (service_port != 0) {
- for (ai = *result; ai; ai = ai->ai_next) {
- if (socket_type != 0 && ai->ai_socktype == 0)
- /* Is this check actually needed? */
- ai->ai_socktype = socket_type;
- switch (ai->ai_family) {
- case AF_INET:
- ((struct sockaddr_in *)ai->ai_addr)->sin_port = service_port;
- break;
- case AF_INET6:
- ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port = service_port;
- break;
- }
- }
+ for (ai = *result; ai; ai = ai->ai_next) {
+ if (socket_type != 0 && ai->ai_socktype == 0)
+ /* Is this check actually needed? */
+ ai->ai_socktype = socket_type;
+ switch (ai->ai_family) {
+ case AF_INET:
+ ((struct sockaddr_in *)ai->ai_addr)->sin_port = service_port;
+ break;
+ case AF_INET6:
+ ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port = service_port;
+ break;
+ }
+ }
}
#endif
#ifdef _AIX
for (ai = *result; ai; ai = ai->ai_next) {
- /* AIX 4.3.3 libc is broken. It doesn't set the family or len
- fields of the sockaddr structures. Usually, sa_family is
- zero, but I've seen it set to 1 in some cases also (maybe
- just leftover from previous contents of the memory
- block?). So, always override what libc returned. */
- ai->ai_addr->sa_family = ai->ai_family;
+ /* AIX 4.3.3 libc is broken. It doesn't set the family or len
+ fields of the sockaddr structures. Usually, sa_family is
+ zero, but I've seen it set to 1 in some cases also (maybe
+ just leftover from previous contents of the memory
+ block?). So, always override what libc returned. */
+ ai->ai_addr->sa_family = ai->ai_family;
#ifdef HAVE_SA_LEN /* always true on AIX, actually */
- ai->ai_addr->sa_len = ai->ai_addrlen;
+ ai->ai_addr->sa_len = ai->ai_addrlen;
#endif
}
#endif
@@ -1309,8 +1314,8 @@
/* Not dealt with currently:
- Some versions of GNU libc can lose some IPv4 addresses in
- certain cases when multiple IPv4 and IPv6 addresses are
- available. */
+ certain cases when multiple IPv4 and IPv6 addresses are
+ available. */
#ifdef DEBUG_ADDRINFO
debug_dump_addrinfos(*result);
@@ -1324,9 +1329,9 @@
{
#ifdef COPY_FIRST_CANONNAME
if (ai) {
- free(ai->ai_canonname);
- ai->ai_canonname = 0;
- system_freeaddrinfo(ai);
+ free(ai->ai_canonname);
+ ai->ai_canonname = 0;
+ system_freeaddrinfo(ai);
}
#else
system_freeaddrinfo(ai);
@@ -1340,7 +1345,7 @@
int err;
err = krb5int_call_thread_support_init();
if (err)
- return err;
+ return err;
return k5_mutex_lock(&krb5int_fac.lock);
}
@@ -1361,8 +1366,8 @@
#endif
int krb5int_getaddrinfo (const char *node, const char *service,
- const struct addrinfo *hints,
- struct addrinfo **aip)
+ const struct addrinfo *hints,
+ struct addrinfo **aip)
{
return getaddrinfo(node, service, hints, aip);
}
@@ -1378,9 +1383,9 @@
}
int krb5int_getnameinfo (const struct sockaddr *sa, socklen_t salen,
- char *hbuf, size_t hbuflen,
- char *sbuf, size_t sbuflen,
- int flags)
+ char *hbuf, size_t hbuflen,
+ char *sbuf, size_t sbuflen,
+ int flags)
{
return getnameinfo(sa, salen, hbuf, hbuflen, sbuf, sbuflen, flags);
}
Modified: trunk/src/util/support/gmt_mktime.c
===================================================================
--- trunk/src/util/support/gmt_mktime.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/gmt_mktime.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/* This code placed in the public domain by Mark W. Eichin */
#include <stdio.h>
@@ -22,108 +23,108 @@
/* unlike mktime, this does not set them... it only passes a return value. */
static const int days_in_month[12] = {
-0, /* jan 31 */
-31, /* feb 28 */
-59, /* mar 31 */
-90, /* apr 30 */
-120, /* may 31 */
-151, /* jun 30 */
-181, /* jul 31 */
-212, /* aug 31 */
-243, /* sep 30 */
-273, /* oct 31 */
-304, /* nov 30 */
-334 /* dec 31 */
+ 0, /* jan 31 */
+ 31, /* feb 28 */
+ 59, /* mar 31 */
+ 90, /* apr 30 */
+ 120, /* may 31 */
+ 151, /* jun 30 */
+ 181, /* jul 31 */
+ 212, /* aug 31 */
+ 243, /* sep 30 */
+ 273, /* oct 31 */
+ 304, /* nov 30 */
+ 334 /* dec 31 */
};
#define hasleapday(year) (year%400?(year%100?(year%4?0:1):0):1)
time_t krb5int_gmt_mktime(struct tm *t)
{
- time_t accum;
+ time_t accum;
#define assert_time(cnd) if(!(cnd)) return (time_t) -1
- /*
- * For 32-bit signed time_t centered on 1/1/1970, the range is:
- * time 0x80000000 -> Fri Dec 13 16:45:52 1901
- * time 0x7fffffff -> Mon Jan 18 22:14:07 2038
- *
- * So years 1901 and 2038 are allowable, but we can't encode all
- * dates in those years, and we're not doing overflow/underflow
- * checking for such cases.
- */
- assert_time(t->tm_year>=1);
- assert_time(t->tm_year<=138);
+ /*
+ * For 32-bit signed time_t centered on 1/1/1970, the range is:
+ * time 0x80000000 -> Fri Dec 13 16:45:52 1901
+ * time 0x7fffffff -> Mon Jan 18 22:14:07 2038
+ *
+ * So years 1901 and 2038 are allowable, but we can't encode all
+ * dates in those years, and we're not doing overflow/underflow
+ * checking for such cases.
+ */
+ assert_time(t->tm_year>=1);
+ assert_time(t->tm_year<=138);
- assert_time(t->tm_mon>=0);
- assert_time(t->tm_mon<=11);
- assert_time(t->tm_mday>=1);
- assert_time(t->tm_mday<=31);
- assert_time(t->tm_hour>=0);
- assert_time(t->tm_hour<=23);
- assert_time(t->tm_min>=0);
- assert_time(t->tm_min<=59);
- assert_time(t->tm_sec>=0);
- assert_time(t->tm_sec<=62);
+ assert_time(t->tm_mon>=0);
+ assert_time(t->tm_mon<=11);
+ assert_time(t->tm_mday>=1);
+ assert_time(t->tm_mday<=31);
+ assert_time(t->tm_hour>=0);
+ assert_time(t->tm_hour<=23);
+ assert_time(t->tm_min>=0);
+ assert_time(t->tm_min<=59);
+ assert_time(t->tm_sec>=0);
+ assert_time(t->tm_sec<=62);
#undef assert_time
- accum = t->tm_year - 70;
- accum *= 365; /* 365 days/normal year */
+ accum = t->tm_year - 70;
+ accum *= 365; /* 365 days/normal year */
- /* add in leap day for all previous years */
- if (t->tm_year >= 70)
- accum += (t->tm_year - 69) / 4;
- else
- accum -= (72 - t->tm_year) / 4;
- /* add in leap day for this year */
- if(t->tm_mon >= 2) /* march or later */
- if(hasleapday((t->tm_year + 1900))) accum += 1;
+ /* add in leap day for all previous years */
+ if (t->tm_year >= 70)
+ accum += (t->tm_year - 69) / 4;
+ else
+ accum -= (72 - t->tm_year) / 4;
+ /* add in leap day for this year */
+ if(t->tm_mon >= 2) /* march or later */
+ if(hasleapday((t->tm_year + 1900))) accum += 1;
- accum += days_in_month[t->tm_mon];
- accum += t->tm_mday-1; /* days of month are the only 1-based field */
- accum *= 24; /* 24 hour/day */
- accum += t->tm_hour;
- accum *= 60; /* 60 minute/hour */
- accum += t->tm_min;
- accum *= 60; /* 60 seconds/minute */
- accum += t->tm_sec;
+ accum += days_in_month[t->tm_mon];
+ accum += t->tm_mday-1; /* days of month are the only 1-based field */
+ accum *= 24; /* 24 hour/day */
+ accum += t->tm_hour;
+ accum *= 60; /* 60 minute/hour */
+ accum += t->tm_min;
+ accum *= 60; /* 60 seconds/minute */
+ accum += t->tm_sec;
- return accum;
+ return accum;
}
#ifdef TEST_LEAP
int
main (int argc, char *argv[])
{
- int yr;
- time_t t;
- struct tm tm = {
- .tm_mon = 0, .tm_mday = 1,
- .tm_hour = 0, .tm_min = 0, .tm_sec = 0,
- };
- for (yr = 60; yr <= 104; yr++)
+ int yr;
+ time_t t;
+ struct tm tm = {
+ .tm_mon = 0, .tm_mday = 1,
+ .tm_hour = 0, .tm_min = 0, .tm_sec = 0,
+ };
+ for (yr = 60; yr <= 104; yr++)
{
- printf ("1/1/%d%c -> ", 1900 + yr, hasleapday((1900+yr)) ? '*' : ' ');
- tm.tm_year = yr;
- t = gmt_mktime (&tm);
- if (t == (time_t) -1)
- printf ("-1\n");
- else
- {
- long u;
- if (t % (24 * 60 * 60))
- printf ("(not integral multiple of days) ");
- u = t / (24 * 60 * 60);
- printf ("%3ld*365%+ld\t0x%08lx\n",
- (long) (u / 365), (long) (u % 365),
- (long) t);
- }
+ printf ("1/1/%d%c -> ", 1900 + yr, hasleapday((1900+yr)) ? '*' : ' ');
+ tm.tm_year = yr;
+ t = gmt_mktime (&tm);
+ if (t == (time_t) -1)
+ printf ("-1\n");
+ else
+ {
+ long u;
+ if (t % (24 * 60 * 60))
+ printf ("(not integral multiple of days) ");
+ u = t / (24 * 60 * 60);
+ printf ("%3ld*365%+ld\t0x%08lx\n",
+ (long) (u / 365), (long) (u % 365),
+ (long) t);
+ }
}
- t = 0x80000000, printf ("time 0x%lx -> %s", t, ctime (&t));
- t = 0x7fffffff, printf ("time 0x%lx -> %s", t, ctime (&t));
- return 0;
+ t = 0x80000000, printf ("time 0x%lx -> %s", t, ctime (&t));
+ t = 0x7fffffff, printf ("time 0x%lx -> %s", t, ctime (&t));
+ return 0;
}
#endif
Modified: trunk/src/util/support/init-addrinfo.c
===================================================================
--- trunk/src/util/support/init-addrinfo.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/init-addrinfo.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright (C) 2004 by the Massachusetts Institute of Technology,
* Cambridge, MA, USA. All Rights Reserved.
Modified: trunk/src/util/support/ipc_stream.c
===================================================================
--- trunk/src/util/support/ipc_stream.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/ipc_stream.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* $Header$
*
@@ -53,7 +54,7 @@
/* ------------------------------------------------------------------------ */
static uint32_t krb5int_ipc_stream_reallocate (k5_ipc_stream io_stream,
- uint64_t in_new_size)
+ uint64_t in_new_size)
{
int32_t err = 0;
uint64_t new_max_size = 0;
@@ -165,8 +166,8 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_read (k5_ipc_stream io_stream,
- void *io_data,
- uint64_t in_size)
+ void *io_data,
+ uint64_t in_size)
{
int32_t err = 0;
@@ -197,8 +198,8 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_write (k5_ipc_stream io_stream,
- const void *in_data,
- uint64_t in_size)
+ const void *in_data,
+ uint64_t in_size)
{
int32_t err = 0;
@@ -238,7 +239,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_read_string (k5_ipc_stream io_stream,
- char **out_string)
+ char **out_string)
{
int32_t err = 0;
uint32_t length = 0;
@@ -273,7 +274,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_write_string (k5_ipc_stream io_stream,
- const char *in_string)
+ const char *in_string)
{
int32_t err = 0;
uint32_t length = 0;
@@ -301,7 +302,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_read_int32 (k5_ipc_stream io_stream,
- int32_t *out_int32)
+ int32_t *out_int32)
{
int32_t err = 0;
int32_t int32 = 0;
@@ -323,7 +324,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_write_int32 (k5_ipc_stream io_stream,
- int32_t in_int32)
+ int32_t in_int32)
{
int32_t err = 0;
int32_t int32 = htonl (in_int32);
@@ -344,7 +345,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_read_uint32 (k5_ipc_stream io_stream,
- uint32_t *out_uint32)
+ uint32_t *out_uint32)
{
int32_t err = 0;
uint32_t uint32 = 0;
@@ -366,7 +367,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
- uint32_t in_uint32)
+ uint32_t in_uint32)
{
int32_t err = 0;
int32_t uint32 = htonl (in_uint32);
@@ -387,7 +388,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_read_int64 (k5_ipc_stream io_stream,
- int64_t *out_int64)
+ int64_t *out_int64)
{
int32_t err = 0;
uint64_t int64 = 0;
@@ -409,7 +410,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_write_int64 (k5_ipc_stream io_stream,
- int64_t in_int64)
+ int64_t in_int64)
{
int32_t err = 0;
int64_t int64 = htonll (in_int64);
@@ -431,7 +432,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_read_uint64 (k5_ipc_stream io_stream,
- uint64_t *out_uint64)
+ uint64_t *out_uint64)
{
int32_t err = 0;
uint64_t uint64 = 0;
@@ -453,7 +454,7 @@
/* ------------------------------------------------------------------------ */
uint32_t krb5int_ipc_stream_write_uint64 (k5_ipc_stream io_stream,
- uint64_t in_uint64)
+ uint64_t in_uint64)
{
int32_t err = 0;
int64_t uint64 = htonll (in_uint64);
Modified: trunk/src/util/support/k5buf-int.h
===================================================================
--- trunk/src/util/support/k5buf-int.h 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/k5buf-int.h 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,4 +1,4 @@
-/* -*- mode: c; indent-tabs-mode: nil -*- */
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* k5buf-int.h
Modified: trunk/src/util/support/k5buf.c
===================================================================
--- trunk/src/util/support/k5buf.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/k5buf.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,5 +1,4 @@
-/* -*- mode: c; indent-tabs-mode: nil -*- */
-
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* k5buf.c
*
@@ -34,16 +33,17 @@
#include "k5buf-int.h"
#include <assert.h>
-/* Structure invariants:
+/*
+ * Structure invariants:
+ *
+ * buftype is BUFTYPE_FIXED, BUFTYPE_DYNAMIC, or BUFTYPE_ERROR
+ * if buftype is not BUFTYPE_ERROR:
+ * space > 0
+ * space <= floor(SIZE_MAX / 2) (to fit within ssize_t)
+ * len < space
+ * data[len] = '\0'
+ */
- buftype is BUFTYPE_FIXED, BUFTYPE_DYNAMIC, or BUFTYPE_ERROR
- if buftype is not BUFTYPE_ERROR:
- space > 0
- space <= floor(SIZE_MAX / 2) (to fit within ssize_t)
- len < space
- data[len] = '\0'
-*/
-
/* Make sure there is room for LEN more characters in BUF, in addition
to the null terminator and what's already in there. Return true on
success. On failure, set the error flag and return false. */
@@ -71,7 +71,7 @@
buf->space = new_space;
return 1;
- error_exit:
+error_exit:
if (buf->buftype == BUFTYPE_DYNAMIC) {
free(buf->data);
buf->data = NULL;
Modified: trunk/src/util/support/mkstemp.c
===================================================================
--- trunk/src/util/support/mkstemp.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/mkstemp.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-file-style: "bsd"; indent-tabs-mode: t -*- */
/*
* Copyright (c) 1987, 1993
* The Regents of the University of California. All rights reserved.
Modified: trunk/src/util/support/plugins.c
===================================================================
--- trunk/src/util/support/plugins.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/plugins.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* util/support/plugins.c
*
@@ -269,7 +270,7 @@
const char *e = dlerror();
Tprintf ("dlopen(%s): %s\n", filepath, e);
err = ENOENT; /* XXX */
- krb5int_set_error (ep, err, "%s", e);
+ krb5int_set_error (ep, err, "%s", e);
}
}
@@ -322,7 +323,7 @@
static long
krb5int_get_plugin_sym (struct plugin_file_handle *h,
const char *csymname, int isfunc, void **ptr,
- struct errinfo *ep)
+ struct errinfo *ep)
{
long err = 0;
void *sym = NULL;
@@ -330,13 +331,13 @@
#if USE_DLOPEN
if (!err && !sym && (h->dlhandle != NULL)) {
/* XXX Do we need to add a leading "_" to the symbol name on any
- modern platforms? */
+ modern platforms? */
sym = dlsym (h->dlhandle, csymname);
if (sym == NULL) {
const char *e = dlerror (); /* XXX copy and save away */
Tprintf ("dlsym(%s): %s\n", csymname, e);
err = ENOENT; /* XXX */
- krb5int_set_error(ep, err, "%s", e);
+ krb5int_set_error(ep, err, "%s", e);
}
}
#endif
@@ -362,9 +363,9 @@
(LPTSTR) &lpMsgBuf,
0, NULL )) {
- fprintf (stderr, "unable to get dll symbol, %s\n", (LPCTSTR)lpMsgBuf);
- LocalFree(lpMsgBuf);
- }
+ fprintf (stderr, "unable to get dll symbol, %s\n", (LPCTSTR)lpMsgBuf);
+ LocalFree(lpMsgBuf);
+ }
}
}
#endif
@@ -382,14 +383,14 @@
long KRB5_CALLCONV
krb5int_get_plugin_data (struct plugin_file_handle *h, const char *csymname,
- void **ptr, struct errinfo *ep)
+ void **ptr, struct errinfo *ep)
{
return krb5int_get_plugin_sym (h, csymname, 0, ptr, ep);
}
long KRB5_CALLCONV
krb5int_get_plugin_func (struct plugin_file_handle *h, const char *csymname,
- void (**ptr)(), struct errinfo *ep)
+ void (**ptr)(), struct errinfo *ep)
{
void *dptr = NULL;
long err = krb5int_get_plugin_sym (h, csymname, 1, &dptr, ep);
@@ -434,10 +435,10 @@
#ifdef HAVE_STRERROR_R
-#define ERRSTR(ERR, BUF) \
+#define ERRSTR(ERR, BUF) \
(strerror_r (ERR, BUF, sizeof(BUF)) == 0 ? BUF : strerror (ERR))
#else
-#define ERRSTR(ERR, BUF) \
+#define ERRSTR(ERR, BUF) \
(strerror (ERR))
#endif
@@ -466,7 +467,7 @@
} else {
newharray[newcount - 1] = p;
newharray[newcount] = NULL;
- *count = newcount;
+ *count = newcount;
*harray = newharray;
}
@@ -531,11 +532,11 @@
size_t j;
for (i = 0; !err && filebases[i]; i++) {
for (j = 0; !err && fileexts[j]; j++) {
- if (asprintf(&tempnames[(i*exts_count)+j], "%s%s",
+ if (asprintf(&tempnames[(i*exts_count)+j], "%s%s",
filebases[i], fileexts[j]) < 0) {
- tempnames[(i*exts_count)+j] = NULL;
- err = ENOMEM;
- }
+ tempnames[(i*exts_count)+j] = NULL;
+ err = ENOMEM;
+ }
}
}
tempnames[bases_count * exts_count] = NULL; /* NUL-terminate */
@@ -559,7 +560,7 @@
long KRB5_CALLCONV
krb5int_open_plugin_dirs (const char * const *dirnames,
const char * const *filebases,
- struct plugin_dir_handle *dirhandle,
+ struct plugin_dir_handle *dirhandle,
struct errinfo *ep)
{
long err = 0;
@@ -573,7 +574,7 @@
}
if (!err && (filebases != NULL)) {
- err = krb5int_get_plugin_filenames (filebases, &filenames);
+ err = krb5int_get_plugin_filenames (filebases, &filenames);
}
for (i = 0; !err && dirnames[i] != NULL; i++) {
@@ -583,26 +584,26 @@
for (j = 0; !err && filenames[j] != NULL; j++) {
struct plugin_file_handle *handle = NULL;
- char *filepath = NULL;
+ char *filepath = NULL;
- if (!err) {
- if (asprintf(&filepath, "%s/%s", dirnames[i], filenames[j]) < 0) {
- filepath = NULL;
- err = ENOMEM;
- }
- }
+ if (!err) {
+ if (asprintf(&filepath, "%s/%s", dirnames[i], filenames[j]) < 0) {
+ filepath = NULL;
+ err = ENOMEM;
+ }
+ }
if (krb5int_open_plugin (filepath, &handle, ep) == 0) {
err = krb5int_plugin_file_handle_array_add (&h, &count, handle);
if (!err) { handle = NULL; } /* h takes ownership */
}
- if (filepath != NULL) { free (filepath); }
- if (handle != NULL) { krb5int_close_plugin (handle); }
+ if (filepath != NULL) { free (filepath); }
+ if (handle != NULL) { krb5int_close_plugin (handle); }
}
} else {
/* load all plugins in each directory */
- DIR *dir = opendir (dirnames[i]);
+ DIR *dir = opendir (dirnames[i]);
while (dir != NULL && !err) {
struct dirent *d = NULL;
@@ -617,13 +618,13 @@
continue;
}
- if (!err) {
+ if (!err) {
int len = NAMELEN (d);
- if (asprintf(&filepath, "%s/%*s", dirnames[i], len, d->d_name) < 0) {
- filepath = NULL;
- err = ENOMEM;
- }
- }
+ if (asprintf(&filepath, "%s/%*s", dirnames[i], len, d->d_name) < 0) {
+ filepath = NULL;
+ err = ENOMEM;
+ }
+ }
if (!err) {
if (krb5int_open_plugin (filepath, &handle, ep) == 0) {
@@ -677,9 +678,9 @@
long KRB5_CALLCONV
krb5int_get_plugin_dir_data (struct plugin_dir_handle *dirhandle,
- const char *symname,
- void ***ptrs,
- struct errinfo *ep)
+ const char *symname,
+ void ***ptrs,
+ struct errinfo *ep)
{
long err = 0;
void **p = NULL;
@@ -736,16 +737,16 @@
long KRB5_CALLCONV
krb5int_get_plugin_dir_func (struct plugin_dir_handle *dirhandle,
- const char *symname,
- void (***ptrs)(void),
- struct errinfo *ep)
+ const char *symname,
+ void (***ptrs)(void),
+ struct errinfo *ep)
{
long err = 0;
void (**p)() = NULL;
size_t count = 0;
/* XXX Do we need to add a leading "_" to the symbol name on any
- modern platforms? */
+ modern platforms? */
Tprintf("get_plugin_data_sym(%s)\n", symname);
Modified: trunk/src/util/support/printf.c
===================================================================
--- trunk/src/util/support/printf.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/printf.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* printf.c
*
@@ -16,7 +17,7 @@
* this permission notice appear in supporting documentation, and that
* the name of M.I.T. not be used in advertising or publicity pertaining
* to distribution of the software without specific, written prior
- * permission. Furthermore if you modify this software you must label
+ * permission. Furthermore if you modify this software you must label
* your software as modified software and not distribute it in such a
* fashion that it might be confused with the original M.I.T. software.
* M.I.T. makes no representations about the suitability of
@@ -42,43 +43,43 @@
int len2;
while (1) {
- if (len >= INT_MAX || len == 0)
- goto fail;
- nstr = realloc(str, len);
- if (nstr == NULL)
- goto fail;
- str = nstr;
- va_copy(ap2, ap);
- len2 = vsnprintf(str, len, format, ap2);
- va_end(ap2);
- /* ISO C vsnprintf returns the needed length. Some old
- vsnprintf implementations return -1 on truncation. */
- if (len2 < 0) {
- /* Don't know how much space we need, just that we didn't
- supply enough; get a bigger buffer and try again. */
- if (len <= SIZE_MAX/2)
- len *= 2;
- else if (len < SIZE_MAX)
- len = SIZE_MAX;
- else
- goto fail;
- } else if ((unsigned int) len2 >= SIZE_MAX) {
- /* Need more space than we can request. */
- goto fail;
- } else if ((size_t) len2 >= len) {
- /* Need more space, but we know how much. */
- len = (size_t) len2 + 1;
- } else {
- /* Success! */
- break;
- }
+ if (len >= INT_MAX || len == 0)
+ goto fail;
+ nstr = realloc(str, len);
+ if (nstr == NULL)
+ goto fail;
+ str = nstr;
+ va_copy(ap2, ap);
+ len2 = vsnprintf(str, len, format, ap2);
+ va_end(ap2);
+ /* ISO C vsnprintf returns the needed length. Some old
+ vsnprintf implementations return -1 on truncation. */
+ if (len2 < 0) {
+ /* Don't know how much space we need, just that we didn't
+ supply enough; get a bigger buffer and try again. */
+ if (len <= SIZE_MAX/2)
+ len *= 2;
+ else if (len < SIZE_MAX)
+ len = SIZE_MAX;
+ else
+ goto fail;
+ } else if ((unsigned int) len2 >= SIZE_MAX) {
+ /* Need more space than we can request. */
+ goto fail;
+ } else if ((size_t) len2 >= len) {
+ /* Need more space, but we know how much. */
+ len = (size_t) len2 + 1;
+ } else {
+ /* Success! */
+ break;
+ }
}
/* We might've allocated more than we need, if we're still using
the initial guess, or we got here by doubling. */
if ((size_t) len2 < len - 1) {
- nstr = realloc(str, (size_t) len2 + 1);
- if (nstr)
- str = nstr;
+ nstr = realloc(str, (size_t) len2 + 1);
+ if (nstr)
+ str = nstr;
}
*ret = str;
return len2;
Modified: trunk/src/util/support/strlcpy.c
===================================================================
--- trunk/src/util/support/strlcpy.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/strlcpy.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-file-style: "bsd"; indent-tabs-mode: t -*- */
#include "k5-platform.h"
/* Provide strlcpy and strlcat for platforms that don't have them. */
Modified: trunk/src/util/support/supp-int.h
===================================================================
--- trunk/src/util/support/supp-int.h 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/supp-int.h 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* util/support/supp-int.h
*
Modified: trunk/src/util/support/t_k5buf.c
===================================================================
--- trunk/src/util/support/t_k5buf.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/t_k5buf.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,4 +1,4 @@
-/* -*- mode: c; indent-tabs-mode: nil -*- */
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* t_k5buf.c
Modified: trunk/src/util/support/t_unal.c
===================================================================
--- trunk/src/util/support/t_unal.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/t_unal.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
#undef NDEBUG
#include <assert.h>
#include "k5-platform.h"
@@ -4,8 +5,8 @@
int main ()
{
- /* Test some low-level assumptions the Kerberos code depends
- on. */
+ /* Test some low-level assumptions the Kerberos code depends
+ on. */
union {
UINT64_TYPE n64;
Modified: trunk/src/util/support/threads.c
===================================================================
--- trunk/src/util/support/threads.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/threads.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* util/support/threads.c
*
@@ -55,7 +56,7 @@
static DWORD tls_idx;
static CRITICAL_SECTION key_lock;
struct tsd_block {
- void *values[K5_KEY_MAX];
+ void *values[K5_KEY_MAX];
};
static void (*destructors[K5_KEY_MAX])(void *);
static unsigned char destructors_set[K5_KEY_MAX];
@@ -69,17 +70,17 @@
err = CALL_INIT_FUNCTION(krb5int_thread_support_init);
if (err)
- return;
+ return;
t = TlsGetValue(tls_idx);
if (t == NULL)
- return;
+ return;
for (i = 0; i < K5_KEY_MAX; i++) {
- if (destructors_set[i] && destructors[i] && t->values[i]) {
- void *v = t->values[i];
- t->values[i] = 0;
- (*destructors[i])(v);
- }
+ if (destructors_set[i] && destructors[i] && t->values[i]) {
+ void *v = t->values[i];
+ t->values[i] = 0;
+ (*destructors[i])(v);
+ }
}
}
@@ -124,44 +125,44 @@
static void loaded_test_aux(void)
{
if (flag_pthread_loaded == -1)
- flag_pthread_loaded = 1;
+ flag_pthread_loaded = 1;
else
- /* Could we have been called twice? */
- flag_pthread_loaded = 0;
+ /* Could we have been called twice? */
+ flag_pthread_loaded = 0;
}
static pthread_once_t loaded_test_once = PTHREAD_ONCE_INIT;
int krb5int_pthread_loaded (void)
{
int x = flag_pthread_loaded;
if (x != -1)
- return x;
+ return x;
if (&pthread_getspecific == 0
- || &pthread_setspecific == 0
- || &pthread_key_create == 0
- || &pthread_key_delete == 0
- || &pthread_once == 0
- || &pthread_mutex_lock == 0
- || &pthread_mutex_unlock == 0
- || &pthread_mutex_destroy == 0
- || &pthread_mutex_init == 0
- || &pthread_self == 0
- || &pthread_equal == 0
- /* Any program that's really multithreaded will have to be
- able to create threads. */
- || &pthread_create == 0
- || &pthread_join == 0
- /* Okay, all the interesting functions -- or stubs for them --
- seem to be present. If we call pthread_once, does it
- actually seem to cause the indicated function to get called
- exactly one time? */
- || pthread_once(&loaded_test_once, loaded_test_aux) != 0
- || pthread_once(&loaded_test_once, loaded_test_aux) != 0
- /* This catches cases where pthread_once does nothing, and
- never causes the function to get called. That's a pretty
- clear violation of the POSIX spec, but hey, it happens. */
- || flag_pthread_loaded < 0) {
- flag_pthread_loaded = 0;
- return 0;
+ || &pthread_setspecific == 0
+ || &pthread_key_create == 0
+ || &pthread_key_delete == 0
+ || &pthread_once == 0
+ || &pthread_mutex_lock == 0
+ || &pthread_mutex_unlock == 0
+ || &pthread_mutex_destroy == 0
+ || &pthread_mutex_init == 0
+ || &pthread_self == 0
+ || &pthread_equal == 0
+ /* Any program that's really multithreaded will have to be
+ able to create threads. */
+ || &pthread_create == 0
+ || &pthread_join == 0
+ /* Okay, all the interesting functions -- or stubs for them --
+ seem to be present. If we call pthread_once, does it
+ actually seem to cause the indicated function to get called
+ exactly one time? */
+ || pthread_once(&loaded_test_once, loaded_test_aux) != 0
+ || pthread_once(&loaded_test_once, loaded_test_aux) != 0
+ /* This catches cases where pthread_once does nothing, and
+ never causes the function to get called. That's a pretty
+ clear violation of the POSIX spec, but hey, it happens. */
+ || flag_pthread_loaded < 0) {
+ flag_pthread_loaded = 0;
+ return 0;
}
/* If we wanted to be super-paranoid, we could try testing whether
pthread_get/setspecific work, too. I don't know -- so far --
@@ -169,13 +170,13 @@
return flag_pthread_loaded;
}
static struct tsd_block tsd_if_single;
-# define GET_NO_PTHREAD_TSD() (&tsd_if_single)
+# define GET_NO_PTHREAD_TSD() (&tsd_if_single)
#else
int krb5int_pthread_loaded (void)
{
return 1;
}
-# define GET_NO_PTHREAD_TSD() (abort(),(struct tsd_block *)0)
+# define GET_NO_PTHREAD_TSD() (abort(),(struct tsd_block *)0)
#endif
static pthread_key_t key;
@@ -189,12 +190,12 @@
struct tsd_block *t = tptr;
/* Make multiple passes in case, for example, a libkrb5 cleanup
- function wants to print out an error message, which causes
- com_err to allocate a thread-specific buffer, after we just
- freed up the old one.
+ function wants to print out an error message, which causes
+ com_err to allocate a thread-specific buffer, after we just
+ freed up the old one.
- Shouldn't actually happen, if we're careful, but check just in
- case. */
+ Shouldn't actually happen, if we're careful, but check just in
+ case. */
pass = 0;
none_found = 0;
@@ -211,7 +212,7 @@
}
free (t);
err = k5_mutex_unlock(&key_lock);
- }
+ }
/* remove thread from global linked list */
}
@@ -225,7 +226,7 @@
err = CALL_INIT_FUNCTION(krb5int_thread_support_init);
if (err)
- return NULL;
+ return NULL;
assert(keynum >= 0 && keynum < K5_KEY_MAX);
assert(destructors_set[keynum] == 1);
@@ -241,14 +242,14 @@
#else /* POSIX */
if (K5_PTHREADS_LOADED)
- t = pthread_getspecific(key);
+ t = pthread_getspecific(key);
else
- t = GET_NO_PTHREAD_TSD();
+ t = GET_NO_PTHREAD_TSD();
#endif
if (t == NULL)
- return NULL;
+ return NULL;
return t->values[keynum];
}
@@ -259,7 +260,7 @@
err = CALL_INIT_FUNCTION(krb5int_thread_support_init);
if (err)
- return err;
+ return err;
assert(keynum >= 0 && keynum < K5_KEY_MAX);
assert(destructors_set[keynum] == 1);
@@ -272,42 +273,42 @@
t = TlsGetValue(tls_idx);
if (t == NULL) {
- int i;
- t = malloc(sizeof(*t));
- if (t == NULL)
- return ENOMEM;
- for (i = 0; i < K5_KEY_MAX; i++)
- t->values[i] = 0;
- /* add to global linked list */
- /* t->next = 0; */
- err = TlsSetValue(tls_idx, t);
- if (!err) {
- free(t);
- return GetLastError();
- }
+ int i;
+ t = malloc(sizeof(*t));
+ if (t == NULL)
+ return ENOMEM;
+ for (i = 0; i < K5_KEY_MAX; i++)
+ t->values[i] = 0;
+ /* add to global linked list */
+ /* t->next = 0; */
+ err = TlsSetValue(tls_idx, t);
+ if (!err) {
+ free(t);
+ return GetLastError();
+ }
}
#else /* POSIX */
if (K5_PTHREADS_LOADED) {
- t = pthread_getspecific(key);
- if (t == NULL) {
- int i;
- t = malloc(sizeof(*t));
- if (t == NULL)
- return ENOMEM;
- for (i = 0; i < K5_KEY_MAX; i++)
- t->values[i] = 0;
- /* add to global linked list */
- t->next = 0;
- err = pthread_setspecific(key, t);
- if (err) {
- free(t);
- return err;
- }
- }
+ t = pthread_getspecific(key);
+ if (t == NULL) {
+ int i;
+ t = malloc(sizeof(*t));
+ if (t == NULL)
+ return ENOMEM;
+ for (i = 0; i < K5_KEY_MAX; i++)
+ t->values[i] = 0;
+ /* add to global linked list */
+ t->next = 0;
+ err = pthread_setspecific(key, t);
+ if (err) {
+ free(t);
+ return err;
+ }
+ }
} else {
- t = GET_NO_PTHREAD_TSD();
+ t = GET_NO_PTHREAD_TSD();
}
#endif
@@ -322,7 +323,7 @@
err = CALL_INIT_FUNCTION(krb5int_thread_support_init);
if (err)
- return err;
+ return err;
assert(keynum >= 0 && keynum < K5_KEY_MAX);
@@ -347,10 +348,10 @@
err = k5_mutex_lock(&key_lock);
if (err == 0) {
- assert(destructors_set[keynum] == 0);
- destructors_set[keynum] = 1;
- destructors[keynum] = destructor;
- err = k5_mutex_unlock(&key_lock);
+ assert(destructors_set[keynum] == 0);
+ destructors_set[keynum] = 1;
+ destructors[keynum] = destructor;
+ err = k5_mutex_unlock(&key_lock);
}
#endif
@@ -365,7 +366,7 @@
assert(destructors_set[keynum] == 1);
if (destructors[keynum] && tsd_no_threads.values[keynum])
- (*destructors[keynum])(tsd_no_threads.values[keynum]);
+ (*destructors[keynum])(tsd_no_threads.values[keynum]);
destructors[keynum] = 0;
tsd_no_threads.values[keynum] = 0;
destructors_set[keynum] = 0;
@@ -385,19 +386,19 @@
#else /* POSIX */
{
- int err;
+ int err;
- /* XXX RESOURCE LEAK:
+ /* XXX RESOURCE LEAK:
- Need to destroy the allocated objects first! */
+ Need to destroy the allocated objects first! */
- err = k5_mutex_lock(&key_lock);
- if (err == 0) {
- assert(destructors_set[keynum] == 1);
- destructors_set[keynum] = 0;
- destructors[keynum] = NULL;
- k5_mutex_unlock(&key_lock);
- }
+ err = k5_mutex_lock(&key_lock);
+ if (err == 0) {
+ assert(destructors_set[keynum] == 1);
+ destructors_set[keynum] = 0;
+ destructors[keynum] = NULL;
+ k5_mutex_unlock(&key_lock);
+ }
}
#endif
@@ -434,22 +435,22 @@
err = k5_mutex_finish_init(&key_lock);
if (err)
- return err;
+ return err;
if (K5_PTHREADS_LOADED) {
- err = pthread_key_create(&key, thread_termination);
- if (err)
- return err;
+ err = pthread_key_create(&key, thread_termination);
+ if (err)
+ return err;
}
#endif
err = krb5int_init_fac();
if (err)
- return err;
+ return err;
err = krb5int_err_init();
if (err)
- return err;
+ return err;
return 0;
}
@@ -457,7 +458,7 @@
void krb5int_thread_support_fini (void)
{
if (! INITIALIZER_RAN (krb5int_thread_support_init))
- return;
+ return;
#ifdef SHOW_INITFINI_FUNCS
printf("krb5int_thread_support_fini\n");
@@ -476,9 +477,9 @@
#else /* POSIX */
if (! INITIALIZER_RAN(krb5int_thread_support_init))
- return;
+ return;
if (K5_PTHREADS_LOADED)
- pthread_key_delete(key);
+ pthread_key_delete(key);
/* ... delete stuff ... */
k5_mutex_destroy(&key_lock);
@@ -497,11 +498,11 @@
ptr = malloc (sizeof (k5_mutex_t));
if (ptr == NULL)
- return ENOMEM;
+ return ENOMEM;
err = k5_mutex_init (ptr);
if (err) {
- free (ptr);
- return err;
+ free (ptr);
+ return err;
}
*m = ptr;
return 0;
Modified: trunk/src/util/support/utf8.c
===================================================================
--- trunk/src/util/support/utf8.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/utf8.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* util/support/utf8.c
*
@@ -60,7 +61,7 @@
size_t bytes;
for (bytes = 0; p[bytes]; bytes++)
- ;
+ ;
return bytes;
}
@@ -71,7 +72,7 @@
size_t chars = 0;
for ( ; *p ; KRB5_UTF8_INCR(p))
- chars++;
+ chars++;
return chars;
}
@@ -83,7 +84,7 @@
const char *end = p + length;
for ( ; p < end; KRB5_UTF8_INCR(p))
- chars++;
+ chars++;
return chars;
}
@@ -110,7 +111,7 @@
int krb5int_utf8_charlen(const char *p)
{
if (!(*p & 0x80))
- return 1;
+ return 1;
return krb5int_utf8_lentab[*(const unsigned char *)p ^ 0x80];
}
@@ -152,8 +153,8 @@
int i = KRB5_UTF8_CHARLEN(p);
if (i > 2) {
- if (!(krb5int_utf8_mintab[*p & 0x1f] & p[1]))
- i = 0;
+ if (!(krb5int_utf8_mintab[*p & 0x1f] & p[1]))
+ i = 0;
}
return i;
@@ -169,22 +170,22 @@
krb5_ucs4 ch;
int len, i;
static unsigned char mask[] = {
- 0, 0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
+ 0, 0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01 };
*out = 0;
len = KRB5_UTF8_CHARLEN2(p, len);
if (len == 0)
- return -1;
+ return -1;
ch = c[0] & mask[len];
for (i = 1; i < len; i++) {
- if ((c[i] & 0xc0) != 0x80)
- return -1;
+ if ((c[i] & 0xc0) != 0x80)
+ return -1;
- ch <<= 6;
- ch |= c[i] & 0x3f;
+ ch <<= 6;
+ ch |= c[i] & 0x3f;
}
*out = ch;
@@ -197,7 +198,7 @@
*out = 0;
if (krb5int_utf8_to_ucs4(p, &ch) == -1 || ch > 0xFFFF)
- return -1;
+ return -1;
*out = (krb5_ucs2) ch;
return 0;
}
@@ -210,45 +211,45 @@
/* not a valid Unicode character */
if (c < 0)
- return 0;
+ return 0;
/* Just return length, don't convert */
if (buf == NULL) {
- if (c < 0x80) return 1;
- else if (c < 0x800) return 2;
- else if (c < 0x10000) return 3;
- else if (c < 0x200000) return 4;
- else if (c < 0x4000000) return 5;
- else return 6;
+ if (c < 0x80) return 1;
+ else if (c < 0x800) return 2;
+ else if (c < 0x10000) return 3;
+ else if (c < 0x200000) return 4;
+ else if (c < 0x4000000) return 5;
+ else return 6;
}
if (c < 0x80) {
- p[len++] = c;
+ p[len++] = c;
} else if (c < 0x800) {
- p[len++] = 0xc0 | ( c >> 6 );
- p[len++] = 0x80 | ( c & 0x3f );
+ p[len++] = 0xc0 | ( c >> 6 );
+ p[len++] = 0x80 | ( c & 0x3f );
} else if (c < 0x10000) {
- p[len++] = 0xe0 | ( c >> 12 );
- p[len++] = 0x80 | ( (c >> 6) & 0x3f );
- p[len++] = 0x80 | ( c & 0x3f );
+ p[len++] = 0xe0 | ( c >> 12 );
+ p[len++] = 0x80 | ( (c >> 6) & 0x3f );
+ p[len++] = 0x80 | ( c & 0x3f );
} else if (c < 0x200000) {
- p[len++] = 0xf0 | ( c >> 18 );
- p[len++] = 0x80 | ( (c >> 12) & 0x3f );
- p[len++] = 0x80 | ( (c >> 6) & 0x3f );
- p[len++] = 0x80 | ( c & 0x3f );
+ p[len++] = 0xf0 | ( c >> 18 );
+ p[len++] = 0x80 | ( (c >> 12) & 0x3f );
+ p[len++] = 0x80 | ( (c >> 6) & 0x3f );
+ p[len++] = 0x80 | ( c & 0x3f );
} else if (c < 0x4000000) {
- p[len++] = 0xf8 | ( c >> 24 );
- p[len++] = 0x80 | ( (c >> 18) & 0x3f );
- p[len++] = 0x80 | ( (c >> 12) & 0x3f );
- p[len++] = 0x80 | ( (c >> 6) & 0x3f );
- p[len++] = 0x80 | ( c & 0x3f );
+ p[len++] = 0xf8 | ( c >> 24 );
+ p[len++] = 0x80 | ( (c >> 18) & 0x3f );
+ p[len++] = 0x80 | ( (c >> 12) & 0x3f );
+ p[len++] = 0x80 | ( (c >> 6) & 0x3f );
+ p[len++] = 0x80 | ( c & 0x3f );
} else /* if( c < 0x80000000 ) */ {
- p[len++] = 0xfc | ( c >> 30 );
- p[len++] = 0x80 | ( (c >> 24) & 0x3f );
- p[len++] = 0x80 | ( (c >> 18) & 0x3f );
- p[len++] = 0x80 | ( (c >> 12) & 0x3f );
- p[len++] = 0x80 | ( (c >> 6) & 0x3f );
- p[len++] = 0x80 | ( c & 0x3f );
+ p[len++] = 0xfc | ( c >> 30 );
+ p[len++] = 0x80 | ( (c >> 24) & 0x3f );
+ p[len++] = 0x80 | ( (c >> 18) & 0x3f );
+ p[len++] = 0x80 | ( (c >> 12) & 0x3f );
+ p[len++] = 0x80 | ( (c >> 6) & 0x3f );
+ p[len++] = 0x80 | ( c & 0x3f );
}
return len;
@@ -259,9 +260,9 @@
return krb5int_ucs4_to_utf8((krb5_ucs4)c, buf);
}
-#define KRB5_UCS_UTF8LEN(c) \
- c < 0 ? 0 : (c < 0x80 ? 1 : (c < 0x800 ? 2 : (c < 0x10000 ? 3 : \
- (c < 0x200000 ? 4 : (c < 0x4000000 ? 5 : 6)))))
+#define KRB5_UCS_UTF8LEN(c) \
+ c < 0 ? 0 : (c < 0x80 ? 1 : (c < 0x800 ? 2 : (c < 0x10000 ? 3 : \
+ (c < 0x200000 ? 4 : (c < 0x4000000 ? 5 : 6)))))
/*
* Advance to the next UTF-8 character
@@ -278,13 +279,13 @@
const unsigned char *u = (const unsigned char *) p;
if (KRB5_UTF8_ISASCII(u)) {
- return (char *) &p[1];
+ return (char *) &p[1];
}
for (i = 1; i < 6; i++) {
- if ((u[i] & 0xc0) != 0x80) {
- return (char *) &p[i];
- }
+ if ((u[i] & 0xc0) != 0x80) {
+ return (char *) &p[i];
+ }
}
return (char *) &p[i];
@@ -305,9 +306,9 @@
const unsigned char *u = (const unsigned char *) p;
for (i = -1; i>-6 ; i--) {
- if ((u[i] & 0xc0 ) != 0x80) {
- return (char *) &p[i];
- }
+ if ((u[i] & 0xc0 ) != 0x80) {
+ return (char *) &p[i];
+ }
}
return (char *) &p[i];
@@ -331,14 +332,14 @@
dst[0] = src[0];
if (KRB5_UTF8_ISASCII(u)) {
- return 1;
+ return 1;
}
for (i=1; i<6; i++) {
- if ((u[i] & 0xc0) != 0x80) {
- return i;
- }
- dst[i] = src[i];
+ if ((u[i] & 0xc0) != 0x80) {
+ return i;
+ }
+ dst[i] = src[i];
}
return i;
@@ -362,7 +363,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
return KRB5_DIGIT( c );
}
@@ -372,7 +373,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
return KRB5_HEX(c);
}
@@ -382,7 +383,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
switch(c) {
case ' ':
@@ -391,7 +392,7 @@
case '\r':
case '\v':
case '\f':
- return 1;
+ return 1;
}
return 0;
@@ -406,7 +407,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
return KRB5_ALPHA(c);
}
@@ -416,7 +417,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
return KRB5_ALNUM(c);
}
@@ -427,7 +428,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
return KRB5_LOWER(c);
}
@@ -437,7 +438,7 @@
unsigned c = * (const unsigned char *) p;
if (!KRB5_ASCII(c))
- return 0;
+ return 0;
return KRB5_UPPER(c);
}
@@ -455,10 +456,10 @@
krb5_ucs4 chs, ch;
if (krb5int_utf8_to_ucs4(chr, &ch) == -1)
- return NULL;
+ return NULL;
for ( ; *str != '\0'; KRB5_UTF8_INCR(str)) {
- if (krb5int_utf8_to_ucs4(str, &chs) == 0 && chs == ch)
- return (char *)str;
+ if (krb5int_utf8_to_ucs4(str, &chs) == 0 && chs == ch)
+ return (char *)str;
}
return NULL;
@@ -471,11 +472,11 @@
krb5_ucs4 chstr, chset;
for (cstr = str; *cstr != '\0'; KRB5_UTF8_INCR(cstr)) {
- for (cset = set; *cset != '\0'; KRB5_UTF8_INCR(cset)) {
- if (krb5int_utf8_to_ucs4(cstr, &chstr) == 0
- && krb5int_utf8_to_ucs4(cset, &chset) == 0 && chstr == chset)
- return cstr - str;
- }
+ for (cset = set; *cset != '\0'; KRB5_UTF8_INCR(cset)) {
+ if (krb5int_utf8_to_ucs4(cstr, &chstr) == 0
+ && krb5int_utf8_to_ucs4(cset, &chset) == 0 && chstr == chset)
+ return cstr - str;
+ }
}
return cstr - str;
@@ -488,13 +489,13 @@
krb5_ucs4 chstr, chset;
for (cstr = str; *cstr != '\0'; KRB5_UTF8_INCR(cstr)) {
- for (cset = set; ; KRB5_UTF8_INCR(cset)) {
- if (*cset == '\0')
- return cstr - str;
- if (krb5int_utf8_to_ucs4(cstr, &chstr) == 0
- && krb5int_utf8_to_ucs4(cset, &chset) == 0 && chstr == chset)
- break;
- }
+ for (cset = set; ; KRB5_UTF8_INCR(cset)) {
+ if (*cset == '\0')
+ return cstr - str;
+ if (krb5int_utf8_to_ucs4(cstr, &chstr) == 0
+ && krb5int_utf8_to_ucs4(cset, &chset) == 0 && chstr == chset)
+ break;
+ }
}
return cstr - str;
@@ -507,11 +508,11 @@
krb5_ucs4 chstr, chset;
for ( ; *str != '\0'; KRB5_UTF8_INCR(str)) {
- for (cset = set; *cset != '\0'; KRB5_UTF8_INCR(cset)) {
- if (krb5int_utf8_to_ucs4(str, &chstr) == 0
- && krb5int_utf8_to_ucs4(cset, &chset) == 0 && chstr == chset)
- return (char *)str;
- }
+ for (cset = set; *cset != '\0'; KRB5_UTF8_INCR(cset)) {
+ if (krb5int_utf8_to_ucs4(str, &chstr) == 0
+ && krb5int_utf8_to_ucs4(cset, &chset) == 0 && chstr == chset)
+ return (char *)str;
+ }
}
return NULL;
@@ -524,23 +525,23 @@
char *end;
if (last == NULL)
- return NULL;
+ return NULL;
begin = str ? str : *last;
begin += krb5int_utf8_strspn(begin, sep);
if (*begin == '\0') {
- *last = NULL;
- return NULL;
+ *last = NULL;
+ return NULL;
}
end = &begin[krb5int_utf8_strcspn(begin, sep)];
if (*end != '\0') {
- char *next = KRB5_UTF8_NEXT(end);
- *end = '\0';
- end = next;
+ char *next = KRB5_UTF8_NEXT(end);
+ *end = '\0';
+ end = next;
}
*last = end;
Modified: trunk/src/util/support/utf8_conv.c
===================================================================
--- trunk/src/util/support/utf8_conv.c 2009-11-30 19:37:31 UTC (rev 23391)
+++ trunk/src/util/support/utf8_conv.c 2009-11-30 21:35:38 UTC (rev 23392)
@@ -1,3 +1,4 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* util/support/utf8_conv.c
*
@@ -67,9 +68,9 @@
static ssize_t
k5_utf8s_to_ucs2s(krb5_ucs2 *ucs2str,
- const char *utf8str,
- size_t count,
- int little_endian)
+ const char *utf8str,
+ size_t count,
+ int little_endian)
{
size_t ucs2len = 0;
size_t utflen, i;
@@ -77,52 +78,52 @@
/* If input ptr is NULL or empty... */
if (utf8str == NULL || *utf8str == '\0') {
- *ucs2str = 0;
+ *ucs2str = 0;
- return 0;
+ return 0;
}
/* Examine next UTF-8 character. */
while (*utf8str && ucs2len < count) {
- /* Get UTF-8 sequence length from 1st byte */
- utflen = KRB5_UTF8_CHARLEN2(utf8str, utflen);
+ /* Get UTF-8 sequence length from 1st byte */
+ utflen = KRB5_UTF8_CHARLEN2(utf8str, utflen);
- if (utflen == 0 || utflen > KRB5_MAX_UTF8_LEN)
- return -1;
+ if (utflen == 0 || utflen > KRB5_MAX_UTF8_LEN)
+ return -1;
- /* First byte minus length tag */
- ch = (krb5_ucs2)(utf8str[0] & mask[utflen]);
+ /* First byte minus length tag */
+ ch = (krb5_ucs2)(utf8str[0] & mask[utflen]);
- for (i = 1; i < utflen; i++) {
- /* Subsequent bytes must start with 10 */
- if ((utf8str[i] & 0xc0) != 0x80)
- return -1;
+ for (i = 1; i < utflen; i++) {
+ /* Subsequent bytes must start with 10 */
+ if ((utf8str[i] & 0xc0) != 0x80)
+ return -1;
- ch <<= 6; /* 6 bits of data in each subsequent byte */
- ch |= (krb5_ucs2)(utf8str[i] & 0x3f);
- }
+ ch <<= 6; /* 6 bits of data in each subsequent byte */
+ ch |= (krb5_ucs2)(utf8str[i] & 0x3f);
+ }
- if (ucs2str != NULL) {
+ if (ucs2str != NULL) {
#ifdef K5_BE
#ifndef SWAP16
-#define SWAP16(X) ((((X) << 8) | ((X) >> 8)) & 0xFFFF)
+#define SWAP16(X) ((((X) << 8) | ((X) >> 8)) & 0xFFFF)
#endif
- if (little_endian)
- ucs2str[ucs2len] = SWAP16(ch);
- else
+ if (little_endian)
+ ucs2str[ucs2len] = SWAP16(ch);
+ else
#endif
- ucs2str[ucs2len] = ch;
- }
+ ucs2str[ucs2len] = ch;
+ }
- utf8str += utflen; /* Move to next UTF-8 character */
- ucs2len++; /* Count number of wide chars stored/required */
+ utf8str += utflen; /* Move to next UTF-8 character */
+ ucs2len++; /* Count number of wide chars stored/required */
}
assert(ucs2len < count);
if (ucs2str != NULL) {
- /* Add null terminator if there's room in the buffer. */
- ucs2str[ucs2len] = 0;
+ /* Add null terminator if there's room in the buffer. */
+ ucs2str[ucs2len] = 0;
}
return ucs2len;
@@ -130,8 +131,8 @@
int
krb5int_utf8s_to_ucs2s(const char *utf8s,
- krb5_ucs2 **ucs2s,
- size_t *ucs2chars)
+ krb5_ucs2 **ucs2s,
+ size_t *ucs2chars)
{
ssize_t len;
size_t chars;
@@ -139,18 +140,18 @@
chars = krb5int_utf8_chars(utf8s);
*ucs2s = (krb5_ucs2 *)malloc((chars + 1) * sizeof(krb5_ucs2));
if (*ucs2s == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_utf8s_to_ucs2s(*ucs2s, utf8s, chars + 1, 0);
if (len < 0) {
- free(*ucs2s);
- *ucs2s = NULL;
- return EINVAL;
+ free(*ucs2s);
+ *ucs2s = NULL;
+ return EINVAL;
}
if (ucs2chars != NULL) {
- *ucs2chars = chars;
+ *ucs2chars = chars;
}
return 0;
@@ -158,9 +159,9 @@
int
krb5int_utf8cs_to_ucs2s(const char *utf8s,
- size_t utf8slen,
- krb5_ucs2 **ucs2s,
- size_t *ucs2chars)
+ size_t utf8slen,
+ krb5_ucs2 **ucs2s,
+ size_t *ucs2chars)
{
ssize_t len;
size_t chars;
@@ -168,18 +169,18 @@
chars = krb5int_utf8c_chars(utf8s, utf8slen);
*ucs2s = (krb5_ucs2 *)malloc((chars + 1) * sizeof(krb5_ucs2));
if (*ucs2s == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_utf8s_to_ucs2s(*ucs2s, utf8s, chars + 1, 0);
if (len < 0) {
- free(*ucs2s);
- *ucs2s = NULL;
- return EINVAL;
+ free(*ucs2s);
+ *ucs2s = NULL;
+ return EINVAL;
}
if (ucs2chars != NULL) {
- *ucs2chars = chars;
+ *ucs2chars = chars;
}
return 0;
@@ -188,7 +189,7 @@
int
krb5int_utf8s_to_ucs2les(const char *utf8s,
unsigned char **ucs2les,
- size_t *ucs2leslen)
+ size_t *ucs2leslen)
{
ssize_t len;
size_t chars;
@@ -197,18 +198,18 @@
*ucs2les = (unsigned char *)malloc((chars + 1) * sizeof(krb5_ucs2));
if (*ucs2les == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_utf8s_to_ucs2s((krb5_ucs2 *)*ucs2les, utf8s, chars + 1, 1);
if (len < 0) {
- free(*ucs2les);
- *ucs2les = NULL;
- return EINVAL;
+ free(*ucs2les);
+ *ucs2les = NULL;
+ return EINVAL;
}
if (ucs2leslen != NULL) {
- *ucs2leslen = chars * sizeof(krb5_ucs2);
+ *ucs2leslen = chars * sizeof(krb5_ucs2);
}
return 0;
@@ -216,9 +217,9 @@
int
krb5int_utf8cs_to_ucs2les(const char *utf8s,
- size_t utf8slen,
- unsigned char **ucs2les,
- size_t *ucs2leslen)
+ size_t utf8slen,
+ unsigned char **ucs2les,
+ size_t *ucs2leslen)
{
ssize_t len;
size_t chars;
@@ -227,95 +228,95 @@
*ucs2les = (unsigned char *)malloc((chars + 1) * sizeof(krb5_ucs2));
if (*ucs2les == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_utf8s_to_ucs2s((krb5_ucs2 *)*ucs2les, utf8s, chars + 1, 1);
if (len < 0) {
- free(*ucs2les);
- *ucs2les = NULL;
- return EINVAL;
+ free(*ucs2les);
+ *ucs2les = NULL;
+ return EINVAL;
}
if (ucs2leslen != NULL) {
- *ucs2leslen = chars * sizeof(krb5_ucs2);
+ *ucs2leslen = chars * sizeof(krb5_ucs2);
}
return 0;
}
/*-----------------------------------------------------------------------------
- Convert a wide char string to a UTF-8 string.
- No more than 'count' bytes will be written to the output buffer.
- Return the # of bytes written to the output buffer, excl null terminator.
+ Convert a wide char string to a UTF-8 string.
+ No more than 'count' bytes will be written to the output buffer.
+ Return the # of bytes written to the output buffer, excl null terminator.
- ucs2len is -1 if the UCS-2 string is NUL terminated, otherwise it is the
- length of the UCS-2 string in characters
+ ucs2len is -1 if the UCS-2 string is NUL terminated, otherwise it is the
+ length of the UCS-2 string in characters
*/
static ssize_t
k5_ucs2s_to_utf8s(char *utf8str, const krb5_ucs2 *ucs2str,
- size_t count, ssize_t ucs2len, int little_endian)
+ size_t count, ssize_t ucs2len, int little_endian)
{
int len = 0;
int n;
char *p = utf8str;
krb5_ucs2 empty = 0, ch;
- if (ucs2str == NULL) /* Treat input ptr NULL as an empty string */
- ucs2str = ∅
+ if (ucs2str == NULL) /* Treat input ptr NULL as an empty string */
+ ucs2str = ∅
- if (utf8str == NULL) /* Just compute size of output, excl null */
+ if (utf8str == NULL) /* Just compute size of output, excl null */
{
- while (ucs2len == -1 ? *ucs2str : --ucs2len >= 0) {
- /* Get UTF-8 size of next wide char */
- ch = *ucs2str++;
+ while (ucs2len == -1 ? *ucs2str : --ucs2len >= 0) {
+ /* Get UTF-8 size of next wide char */
+ ch = *ucs2str++;
#ifdef K5_BE
- if (little_endian)
- ch = SWAP16(ch);
+ if (little_endian)
+ ch = SWAP16(ch);
#endif
- n = krb5int_ucs2_to_utf8(ch, NULL);
- if (n < 1)
- return -1;
- if (len + n < len)
- return -1; /* overflow */
- len += n;
- }
+ n = krb5int_ucs2_to_utf8(ch, NULL);
+ if (n < 1)
+ return -1;
+ if (len + n < len)
+ return -1; /* overflow */
+ len += n;
+ }
- return len;
+ return len;
}
/* Do the actual conversion. */
- n = 1; /* In case of empty ucs2str */
+ n = 1; /* In case of empty ucs2str */
while (ucs2len == -1 ? *ucs2str != 0 : --ucs2len >= 0) {
- ch = *ucs2str++;
+ ch = *ucs2str++;
#ifdef K5_BE
- if (little_endian)
- ch = SWAP16(ch);
+ if (little_endian)
+ ch = SWAP16(ch);
#endif
- n = krb5int_ucs2_to_utf8(ch, p);
+ n = krb5int_ucs2_to_utf8(ch, p);
- if (n < 1)
- break;
+ if (n < 1)
+ break;
- p += n;
- count -= n; /* Space left in output buffer */
+ p += n;
+ count -= n; /* Space left in output buffer */
}
/* If not enough room for last character, pad remainder with null
so that return value = original count, indicating buffer full. */
if (n == 0) {
- while (count--)
- *p++ = 0;
+ while (count--)
+ *p++ = 0;
}
/* Add a null terminator if there's room. */
else if (count)
- *p = 0;
+ *p = 0;
- if (n == -1) /* Conversion encountered invalid wide char. */
- return -1;
+ if (n == -1) /* Conversion encountered invalid wide char. */
+ return -1;
/* Return the number of bytes written to output buffer, excl null. */
return (p - utf8str);
@@ -323,30 +324,30 @@
int
krb5int_ucs2s_to_utf8s(const krb5_ucs2 *ucs2s,
- char **utf8s,
- size_t *utf8slen)
+ char **utf8s,
+ size_t *utf8slen)
{
ssize_t len;
len = k5_ucs2s_to_utf8s(NULL, ucs2s, 0, -1, 0);
if (len < 0) {
- return EINVAL;
+ return EINVAL;
}
*utf8s = (char *)malloc((size_t)len + 1);
if (*utf8s == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_ucs2s_to_utf8s(*utf8s, ucs2s, (size_t)len + 1, -1, 0);
if (len < 0) {
- free(*utf8s);
- *utf8s = NULL;
- return EINVAL;
+ free(*utf8s);
+ *utf8s = NULL;
+ return EINVAL;
}
if (utf8slen != NULL) {
- *utf8slen = len;
+ *utf8slen = len;
}
return 0;
@@ -354,29 +355,29 @@
int
krb5int_ucs2les_to_utf8s(const unsigned char *ucs2les,
- char **utf8s,
- size_t *utf8slen)
+ char **utf8s,
+ size_t *utf8slen)
{
ssize_t len;
len = k5_ucs2s_to_utf8s(NULL, (krb5_ucs2 *)ucs2les, 0, -1, 1);
if (len < 0)
- return EINVAL;
+ return EINVAL;
*utf8s = (char *)malloc((size_t)len + 1);
if (*utf8s == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_ucs2s_to_utf8s(*utf8s, (krb5_ucs2 *)ucs2les, (size_t)len + 1, -1, 1);
if (len < 0) {
- free(*utf8s);
- *utf8s = NULL;
- return EINVAL;
+ free(*utf8s);
+ *utf8s = NULL;
+ return EINVAL;
}
if (utf8slen != NULL) {
- *utf8slen = len;
+ *utf8slen = len;
}
return 0;
@@ -391,28 +392,28 @@
ssize_t len;
if (ucs2slen > SSIZE_MAX)
- return ERANGE;
+ return ERANGE;
len = k5_ucs2s_to_utf8s(NULL, (krb5_ucs2 *)ucs2s, 0,
- (ssize_t)ucs2slen, 0);
+ (ssize_t)ucs2slen, 0);
if (len < 0)
- return EINVAL;
+ return EINVAL;
*utf8s = (char *)malloc((size_t)len + 1);
if (*utf8s == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_ucs2s_to_utf8s(*utf8s, (krb5_ucs2 *)ucs2s,
- (size_t)len + 1, (ssize_t)ucs2slen, 0);
+ (size_t)len + 1, (ssize_t)ucs2slen, 0);
if (len < 0) {
- free(*utf8s);
- *utf8s = NULL;
- return EINVAL;
+ free(*utf8s);
+ *utf8s = NULL;
+ return EINVAL;
}
if (utf8slen != NULL) {
- *utf8slen = len;
+ *utf8slen = len;
}
return 0;
@@ -427,28 +428,28 @@
ssize_t len;
if (ucs2leslen > SSIZE_MAX)
- return ERANGE;
+ return ERANGE;
len = k5_ucs2s_to_utf8s(NULL, (krb5_ucs2 *)ucs2les, 0,
- (ssize_t)ucs2leslen, 1);
+ (ssize_t)ucs2leslen, 1);
if (len < 0)
- return EINVAL;
+ return EINVAL;
*utf8s = (char *)malloc((size_t)len + 1);
if (*utf8s == NULL) {
- return ENOMEM;
+ return ENOMEM;
}
len = k5_ucs2s_to_utf8s(*utf8s, (krb5_ucs2 *)ucs2les,
- (size_t)len + 1, (ssize_t)ucs2leslen, 1);
+ (size_t)len + 1, (ssize_t)ucs2leslen, 1);
if (len < 0) {
- free(*utf8s);
- *utf8s = NULL;
- return EINVAL;
+ free(*utf8s);
+ *utf8s = NULL;
+ return EINVAL;
}
if (utf8slen != NULL) {
- *utf8slen = len;
+ *utf8slen = len;
}
return 0;
More information about the cvs-krb5
mailing list