Submitted By: Joe Ciccone Date: 2009-07-08 Initial Package Version: 2.2.3pre1 Upstream Status: Unknown Origin: Debian - http://ftp.de.debian.org/debian/pool/main/libn/libnss-db/libnss-db_2.2.3pre1-3.diff.gz Description: Fixes compilation errors on newer distros. diff -Naur nss_db-2.2.3pre1.orig/src/db-alias.c nss_db-2.2.3pre1/src/db-alias.c --- nss_db-2.2.3pre1.orig/src/db-alias.c 2001-04-29 21:07:41.000000000 -0400 +++ nss_db-2.2.3pre1/src/db-alias.c 2009-07-08 20:43:58.889005216 -0400 @@ -23,15 +23,14 @@ #include #include #include +#include #include #include -#include - #include "nss_db.h" /* Locks the static variables in this file. */ -__libc_lock_define_initialized (static, lock) +static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; /* Maintenance of the shared handle open on the database. */ @@ -46,7 +45,7 @@ { enum nss_status status; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); status = internal_setent (_PATH_VARDB "aliases.db", &db); @@ -57,7 +56,7 @@ /* Reset the sequential index. */ entidx = 0; - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; } @@ -67,14 +66,14 @@ enum nss_status _nss_db_endaliasent (void) { - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); internal_endent (&db); /* Reset STAYOPEN flag. */ keep_db = 0; - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return NSS_STATUS_SUCCESS; } @@ -180,14 +179,14 @@ char buf[20]; DBT key; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++); key.flags = 0; status = lookup (&key, result, buffer, buflen, errnop); if (status == NSS_STATUS_TRYAGAIN && *errnop == ERANGE) /* Give the user a chance to get the same entry with a larger buffer. */ --entidx; - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; } @@ -207,9 +206,9 @@ memcpy (&((char *) key.data)[1], name, key.size - 1); key.flags = 0; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); status = lookup (&key, result, buffer, buflen, errnop); - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; } diff -Naur nss_db-2.2.3pre1.orig/src/db-compat.c nss_db-2.2.3pre1/src/db-compat.c --- nss_db-2.2.3pre1.orig/src/db-compat.c 2001-04-29 21:07:41.000000000 -0400 +++ nss_db-2.2.3pre1/src/db-compat.c 2009-07-08 20:43:53.489005567 -0400 @@ -39,7 +39,15 @@ if (err) return err; - err = db->open (db, file, NULL, type, flags, mode); + err = db->open (db, NULL, file, NULL, type, flags, mode); + /* Make sure we upgrade, in case this is an older database */ + if (err == DB_OLD_VERSION) { + db->close (db, 0); + err = db->upgrade(db, file, 0); + if (err) + return err; + err = db->open (db, NULL, file, NULL, type, flags, mode); + } if (err) { db->close (db, 0); diff -Naur nss_db-2.2.3pre1.orig/src/db-netgrp.c nss_db-2.2.3pre1/src/db-netgrp.c --- nss_db-2.2.3pre1.orig/src/db-netgrp.c 2001-04-29 21:07:41.000000000 -0400 +++ nss_db-2.2.3pre1/src/db-netgrp.c 2009-07-08 20:43:58.889005216 -0400 @@ -21,8 +21,8 @@ #include #include #include +#include #include -#include #include #include "nss_db.h" @@ -32,7 +32,7 @@ /* Locks the static variables in this file. */ -__libc_lock_define_initialized (static, lock) +static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; /* Maintenance of the shared handle open on the database. */ static DB *db; @@ -44,7 +44,7 @@ { enum nss_status status; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); status = internal_setent (DBFILE, &db); @@ -60,7 +60,7 @@ cursor = entry = value.data; } - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; @@ -70,11 +70,11 @@ enum nss_status _nss_db_endnetgrent (void) { - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); internal_endent (&db); - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return NSS_STATUS_SUCCESS; } @@ -91,11 +91,11 @@ { int status; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); status = _nss_netgroup_parseline (&cursor, result, buffer, buflen, errnop); - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; } diff -Naur nss_db-2.2.3pre1.orig/src/db-open.c nss_db-2.2.3pre1/src/db-open.c --- nss_db-2.2.3pre1.orig/src/db-open.c 2001-04-29 21:07:41.000000000 -0400 +++ nss_db-2.2.3pre1/src/db-open.c 2009-07-08 20:43:58.889005216 -0400 @@ -58,7 +58,7 @@ if (err != 0) { if (err > 0) - __set_errno (err); + errno = err; return NSS_STATUS_UNAVAIL; } @@ -75,7 +75,7 @@ fail: db->close (db, 0); if (err > 0) - __set_errno (err); + errno = err; return NSS_STATUS_UNAVAIL; } diff -Naur nss_db-2.2.3pre1.orig/src/db-XXX.c nss_db-2.2.3pre1/src/db-XXX.c --- nss_db-2.2.3pre1.orig/src/db-XXX.c 2001-04-29 21:07:41.000000000 -0400 +++ nss_db-2.2.3pre1/src/db-XXX.c 2009-07-08 20:44:04.482150630 -0400 @@ -21,11 +21,10 @@ #include #include #include +#include #include #include -#include - #include "nss_db.h" /* These symbols are defined by the including source file: @@ -53,7 +52,7 @@ #endif /* Locks the static variables in this file. */ -__libc_lock_define_initialized (static, lock) +static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; /* Maintenance of the shared handle open on the database. */ @@ -68,7 +67,7 @@ { enum nss_status status; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); status = internal_setent (DBFILE, &db); @@ -78,7 +77,7 @@ /* Reset the sequential index. */ entidx = 0; - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; } @@ -88,14 +87,14 @@ enum nss_status CONCAT(_nss_db_end,ENTNAME) (void) { - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); internal_endent (&db); /* Reset STAYOPEN flag. */ keep_db = 0; - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return NSS_STATUS_SUCCESS; } @@ -123,6 +122,7 @@ } /* Succeed iff it matches a value that parses correctly. */ + *errnop = ENOENT; value.flags = 0; err = db->get (db, NULL, key, &value, 0); if (err) @@ -224,13 +224,14 @@ DBT key; \ enum nss_status status; \ const size_t size = (keysize) + 1; \ + memset(&key, 0, sizeof(key)); \ key.data = alloca (size); \ key.size = KEYPRINTF keypattern; \ key.flags = 0; \ - __libc_lock_lock (lock); \ + pthread_mutex_lock (&lock); \ status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG \ EXTRA_ARGS_VALUE); \ - __libc_lock_unlock (lock); \ + pthread_mutex_unlock (&lock); \ return status; \ } @@ -249,7 +250,7 @@ char buf[20]; DBT key; - __libc_lock_lock (lock); + pthread_mutex_lock (&lock); /* Loop until we find a valid entry or hit EOF. See above for the special meaning of the status value. */ @@ -270,7 +271,7 @@ } while (status == NSS_STATUS_RETURN); - __libc_lock_unlock (lock); + pthread_mutex_unlock (&lock); return status; } diff -Naur nss_db-2.2.3pre1.orig/src/db-XXX.c.orig nss_db-2.2.3pre1/src/db-XXX.c.orig --- nss_db-2.2.3pre1.orig/src/db-XXX.c.orig 1969-12-31 19:00:00.000000000 -0500 +++ nss_db-2.2.3pre1/src/db-XXX.c.orig 2009-07-08 20:43:58.889005216 -0400 @@ -0,0 +1,276 @@ +/* Common code for DB-based databases in nss_db module. + Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include +#include +#include +#include +#include +#include +#include + +#include "nss_db.h" + +/* These symbols are defined by the including source file: + + ENTNAME -- database name of the structure and functions (hostent, pwent). + STRUCTURE -- struct name, define only if not ENTNAME (passwd, group). + DATABASE -- database file name, ("hosts", "passwd") + + NEED_H_ERRNO - defined iff an arg `int *herrnop' is used. +*/ + +#define ENTNAME_r CONCAT(ENTNAME,_r) + +#include +#define DBFILE _PATH_VARDB DATABASE ".db" + +#ifdef NEED_H_ERRNO +#define H_ERRNO_PROTO , int *herrnop +#define H_ERRNO_ARG , herrnop +#define H_ERRNO_SET(val) (*herrnop = (val)) +#else +#define H_ERRNO_PROTO +#define H_ERRNO_ARG +#define H_ERRNO_SET(val) ((void) 0) +#endif + +/* Locks the static variables in this file. */ +static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + +/* Maintenance of the shared handle open on the database. */ + +static DB *db; +static int keep_db; +static int entidx; + + +/* Open the database. */ +enum nss_status +CONCAT(_nss_db_set,ENTNAME) (int stayopen) +{ + enum nss_status status; + + pthread_mutex_lock (&lock); + + status = internal_setent (DBFILE, &db); + + /* Remember STAYOPEN flag. */ + if (db != NULL) + keep_db |= stayopen; + /* Reset the sequential index. */ + entidx = 0; + + pthread_mutex_unlock (&lock); + + return status; +} + + +/* Close it again. */ +enum nss_status +CONCAT(_nss_db_end,ENTNAME) (void) +{ + pthread_mutex_lock (&lock); + + internal_endent (&db); + + /* Reset STAYOPEN flag. */ + keep_db = 0; + + pthread_mutex_unlock (&lock); + + return NSS_STATUS_SUCCESS; +} + +/* Do a database lookup for KEY. */ +static enum nss_status +lookup (DBT *key, struct STRUCTURE *result, + void *buffer, size_t buflen, int *errnop H_ERRNO_PROTO EXTRA_ARGS_DECL) +{ + char *p; + enum nss_status status; + int err; + DBT value; + + /* Open the database. */ + if (db == NULL) + { + status = internal_setent (DBFILE, &db); + if (status != NSS_STATUS_SUCCESS) + { + *errnop = errno; + H_ERRNO_SET (NETDB_INTERNAL); + return status; + } + } + + /* Succeed iff it matches a value that parses correctly. */ + *errnop = ENOENT; + value.flags = 0; + err = db->get (db, NULL, key, &value, 0); + if (err) + { + if (err > 0) + { + *errnop = err; + H_ERRNO_SET (NETDB_INTERNAL); + status = NSS_STATUS_UNAVAIL; + } + else + { + switch (err) + { + case DB_NOTFOUND: + H_ERRNO_SET (HOST_NOT_FOUND); + status = NSS_STATUS_NOTFOUND; + break; + + default: + H_ERRNO_SET (NO_RECOVERY); + status = NSS_STATUS_UNAVAIL; + break; + } + } + } + else if (buflen < value.size) + { + /* No room to copy the data to. */ + *errnop = ERANGE; + H_ERRNO_SET (NETDB_INTERNAL); + status = NSS_STATUS_TRYAGAIN; + } + else + { + /* Copy the result to a safe place. */ + p = (char *) memcpy (buffer, value.data, value.size); + + /* Skip leading blanks. */ + while (isspace (*p)) + ++p; + + err = parse_line (p, result, buffer, buflen, errnop EXTRA_ARGS); + + if (err == 0) + { + /* If the key begins with '0' we are trying to get the next + entry. We want to ignore unparsable lines in this case. */ + if (((char *) key->data)[0] == '0') + { + /* Super magical return value. We need to tell our caller + that it should continue looping. This value cannot + happen in other cases. */ + status = NSS_STATUS_RETURN; + } + else + { + H_ERRNO_SET (HOST_NOT_FOUND); + status = NSS_STATUS_NOTFOUND; + } + } + else if (err < 0) + { + H_ERRNO_SET (NETDB_INTERNAL); + status = NSS_STATUS_TRYAGAIN; + } + else + status = NSS_STATUS_SUCCESS; + } + + if (! keep_db) + internal_endent (&db); + + return status; +} + + +/* Macro for defining lookup functions for this DB-based database. + + NAME is the name of the lookup; e.g. `pwnam'. + + KEYPATTERN gives `printf' args to construct a key string; + e.g. `(".%s", name)'. + + KEYSIZE gives the allocation size of a buffer to construct it in; + e.g. `1 + strlen (name)'. + + PROTO describes the arguments for the lookup key; + e.g. `const char *name'. + + BREAK_IF_MATCH is ignored, but used by ../nss_files/files-XXX.c. */ + +#define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...) \ +enum nss_status \ +_nss_db_get##name##_r (proto, \ + struct STRUCTURE *result, \ + char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\ +{ \ + DBT key; \ + enum nss_status status; \ + const size_t size = (keysize) + 1; \ + key.data = alloca (size); \ + key.size = KEYPRINTF keypattern; \ + key.flags = 0; \ + pthread_mutex_lock (&lock); \ + status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG \ + EXTRA_ARGS_VALUE); \ + pthread_mutex_unlock (&lock); \ + return status; \ +} + +#define KEYPRINTF(pattern, args...) snprintf (key.data, size, pattern ,##args) + + + + +/* Return the next entry from the database file, doing locking. */ +enum nss_status +CONCAT(_nss_db_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer, + size_t buflen, int *errnop H_ERRNO_PROTO) +{ + /* Return next entry in host file. */ + enum nss_status status; + char buf[20]; + DBT key; + + pthread_mutex_lock (&lock); + + /* Loop until we find a valid entry or hit EOF. See above for the + special meaning of the status value. */ + do + { + key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++); + key.flags = 0; + status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG + EXTRA_ARGS_VALUE); + if (status == NSS_STATUS_TRYAGAIN +#ifdef NEED_H_ERRNO + && *herrnop == NETDB_INTERNAL +#endif + && *errnop == ERANGE) + /* Give the user a chance to get the same entry with a larger + buffer. */ + --entidx; + } + while (status == NSS_STATUS_RETURN); + + pthread_mutex_unlock (&lock); + + return status; +}