-- cgit v1.2.3 From 8eac6f4f55cee0a6183983f2fcd8db73dc76c8a9 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 30 Sep 2010 19:58:21 +0000 Subject: import Solaris support developed by Ted C. Cheng of Symas Corporation merged against SVN head (parts remain to be cleaned up) git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1232 ef36b2f9-881f-0410-afb5-c4e39611909c --- AUTHORS | 2 + README | 4 +- compat/nss_compat.h | 3 + configure.ac | 47 ++++++++++ debian/copyright | 6 ++ nss/Makefile.am | 21 +++-- nss/common.c | 112 +++++++++++++++++++++++- nss/common.h | 14 +++ nss/ethers.c | 131 +++++++++++++++++++++++++++- nss/exports.solaris | 23 +++++ nss/group.c | 234 ++++++++++++++++++++++++++++++++++++++++++++++++-- nss/hosts.c | 242 +++++++++++++++++++++++++++++++++++++++++++++++++++- nss/ldap-nss.h | 109 +++++++++++++++++++++++ nss/netgroup.c | 231 ++++++++++++++++++++++++++++++++++++++++++++++++- nss/networks.c | 216 +++++++++++++++++++++++++++++++++++++++++++++- nss/passwd.c | 169 +++++++++++++++++++++++++++++++++++- nss/protocols.c | 194 ++++++++++++++++++++++++++++++++++++++++- nss/prototypes.h | 22 +++++ nss/rpc.c | 193 ++++++++++++++++++++++++++++++++++++++++- nss/services.c | 185 +++++++++++++++++++++++++++++++++++++-- nss/shadow.c | 194 ++++++++++++++++++++++++++++++++++++++++- pam/Makefile.am | 18 ++-- pam/exports.solaris | 16 ++++ 23 files changed, 2335 insertions(+), 51 deletions(-) create mode 100644 nss/exports.solaris create mode 100644 nss/ldap-nss.h create mode 100644 pam/exports.solaris diff --git a/AUTHORS b/AUTHORS index 315b5f1..46f281f 100644 --- a/AUTHORS +++ b/AUTHORS @@ -7,6 +7,7 @@ Luke Howard West Consulting Arthur de Jong Howard Chu +Symas Corporation (contributed by Ted C. Cheng ) The following people (in no particular order) have also volunteered their time, effort, and ideas to make this software available. If you feel you are @@ -79,3 +80,4 @@ Leigh Wedding Jan Schampera Nalin Dahyabhai Daniel Dehennin +Ted C. Cheng diff --git a/README b/README index d6f7255..384670a 100644 --- a/README +++ b/README @@ -10,7 +10,8 @@ into a thin NSS part and a server part. Most of the code was rewritten. The software was renamed to nss-pam-ldapd when PAM code contributed by - Howard Chu for the OpenLDAP nssov module was integrated. + Howard Chu for the OpenLDAP nssov module was integrated. Solaris + compatibility was developed by Ted C. Cheng of Symas Corporation. http://arthurdejong.org/nss-pam-ldapd/ @@ -18,6 +19,7 @@ Copyright (C) 2006, 2007 West Consulting Copyright (C) 2006, 2007, 2008, 2009, 2010 Arthur de Jong Copyright (C) 2009 Howard Chu + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public diff --git a/compat/nss_compat.h b/compat/nss_compat.h index f38463e..232519e 100644 --- a/compat/nss_compat.h +++ b/compat/nss_compat.h @@ -49,6 +49,9 @@ #ifdef HAVE_NSSWITCH_H #include #endif /* HAVE_NSSWITCH_H */ +#ifdef HAVE_IRS_NSS_H +#include "irs-nss.h" +#endif /* HAVE_IRS_NSS_H */ #include "compat/ether.h" diff --git a/configure.ac b/configure.ac index d5f0df6..af2602a 100644 --- a/configure.ac +++ b/configure.ac @@ -207,6 +207,15 @@ AC_ARG_WITH(nslcd-socket, AC_DEFINE_UNQUOTED(NSLCD_SOCKET,"$NSLCD_SOCKET",[The location of the socket used for communicating.]) AC_SUBST(NSLCD_SOCKET) +# the directory PAM librabries are expected to be placed into +AC_ARG_WITH(pam-seclib-dir, + AS_HELP_STRING([--with-pam-seclib-dir=PAM_SECLIB_DIR], + [path to PAM security library]), + [ PAM_SECLIB_DIR="$with_pam_seclib_dir" ], + [ PAM_SECLIB_DIR="/lib/security" ]) +AC_DEFINE_UNQUOTED(PAM_SECLIB_DIR,"$PAM_SECLIB_DIR",[path to PAM security library]) +AC_SUBST(PAM_SECLIB_DIR) + # the SONAME to use for the NSS module AC_ARG_WITH(nss-ldap-soname, AS_HELP_STRING([--with-nss-ldap-soname=SONAME], @@ -638,6 +647,44 @@ then AC_SUBST(nslcd_LIBS) fi +# Always use native linker on Solaris +# but only invoke directly if compiling with gcc (?) +case "$target_os" in +solaris*) if test "$ac_cv_prog_gcc" = yes; then + nss_ldap_so_LD="/usr/ccs/bin/ld" + pam_ldap_so_LD="/usr/ccs/bin/ld" + fi + nss_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" + pam_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" + NSS_LDAP_SONAME="nss_ldap.so.1" + pam_ldap_so_VERSIONED="pam_ldap.so.1" + TARGET_OS="SUNOS" ;; +linux*) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" + pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" + NSS_LDAP_SONAME="libnss_ldap.so.2" + pam_ldap_so_VERSIONED="pam_ldap.so" + TARGET_OS="LINUX" ;; +*) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" + pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" + NSS_LDAP_SONAME="nss_ldap.so.1" + pam_ldap_so_VERSIONED="pam_ldap.so" ;; +esac + +AC_SUBST(nss_ldap_so_LD) +AC_SUBST(nss_ldap_so_LDFLAGS) +AC_SUBST(NSS_LDAP_SONAME) + +AC_SUBST(pam_ldap_so_LD) +AC_SUBST(pam_ldap_so_LDFLAGS) +AC_SUBST(pam_ldap_so_VERSIONED) + +AC_SUBST(AIX64SUFFIX) +AM_CONDITIONAL(GCC, test "$GCC" = "yes") +AM_CONDITIONAL(GLIBC, test "$target_os" = "linux" -o "$target_os" = "linux-gnu") +AM_CONDITIONAL(USE_NATIVE_LINKER, test -n "$nss_ldap_so_LD") +AM_CONDITIONAL(SUNOS, test "x${TARGET_OS}" = "xSUNOS") +AM_CONDITIONAL(LINUX, test "x${TARGET_OS}" = "xLINUX") + # generate files AC_CONFIG_FILES([Makefile compat/Makefile common/Makefile nss/Makefile pam/Makefile nslcd/Makefile man/Makefile tests/Makefile]) diff --git a/debian/copyright b/debian/copyright index 25ed843..1d2202a 100644 --- a/debian/copyright +++ b/debian/copyright @@ -7,6 +7,11 @@ http://www.padl.com/OSS/nss_ldap.html In 2006 Arthur de Jong of West Consuling forked the library to split it into a thin NSS part and a server part. Most of the code was rewritten. + +The software was renamed to nss-pam-ldapd when PAM code contributed by Howard +Chu for the OpenLDAP nssov module was integrated. Solaris compatibility was +developed by Ted C. Cheng of Symas Corporation. + http://arthurdejong.org/nss-pam-ldapd/ Arthur de Jong is both the upstream and Debian package maintainer, so there @@ -20,6 +25,7 @@ Davide Puricelli (evo), Sami Haahtinen and Stephen Frost. Copyright (C) 2006-2007 West Consulting Copyright (C) 2006-2009 Arthur de Jong Copyright (C) 2009 Howard Chu + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public diff --git a/nss/Makefile.am b/nss/Makefile.am index 9420d6a..7312a7a 100644 --- a/nss/Makefile.am +++ b/nss/Makefile.am @@ -27,23 +27,30 @@ AM_CFLAGS = -fPIC nss_ldap_so_SOURCES = common.c common.h prototypes.h \ ../nslcd.h ../common/nslcd-prot.h \ ../compat/attrs.h -EXTRA_nss_ldap_so_SOURCES = aliases.c ethers.c group.c hosts.c netgroup.c \ - networks.c passwd.c protocols.c rpc.c services.c \ - shadow.c -nss_ldap_so_LDFLAGS = -shared -Wl,-h,$(NSS_LDAP_SONAME) +nss_ldap_so_LDFLAGS = @nss_ldap_so_LDFLAGS@ if HAVE_VERSION_SCRIPT_FLAG nss_ldap_so_LDFLAGS += $(VERSION_SCRIPT_FLAG)\$(srcdir)/nss_ldap.map endif -nss_ldap_so_LDADD = ../common/libtio.a ../common/libprot.a $(NSS_MODULE_OBJS) nss_ldap_so_DEPENDENCIES = $(NSS_MODULE_OBJS) +EXTRA_nss_ldap_so_SOURCES = aliases.c ethers.c group.c hosts.c netgroup.c \ + networks.c passwd.c protocols.c rpc.c services.c \ + shadow.c + +if USE_NATIVE_LINKER +nss_ldap_so_LINK = @nss_ldap_so_LD@ @nss_ldap_so_LDFLAGS@ -o $@ +else +nss_ldap_so_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAG) -o $@ +endif EXTRA_DIST = nss_ldap.map install-exec-local: install-nss_ldap_so uninstall-local: uninstall-nss_ldap_so -# install libnss_ldap.so.2 install-nss_ldap_so: nss_ldap.so - $(INSTALL_PROGRAM) -D nss_ldap.so $(DESTDIR)$(libdir)/$(NSS_LDAP_SONAME) + -rm -f $(DESTDIR)$(libdir)/$(NSS_LDAP_SONAME) + $(mkinstalldirs) $(DESTDIR)$(libdir) + $(INSTALL_PROGRAM) nss_ldap.so $(DESTDIR)$(libdir)/$(NSS_LDAP_SONAME) + uninstall-nss_ldap_so: -rm -f $(DESTDIR)$(libdir)/$(NSS_LDAP_SONAME) diff --git a/nss/common.c b/nss/common.c index 20a3136..34c41fb 100644 --- a/nss/common.c +++ b/nss/common.c @@ -1,7 +1,8 @@ /* - common.c - common definitions + common.c - common functions for NSS lookups Copyright (C) 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -19,4 +20,113 @@ 02110-1301 USA */ +#include "config.h" + +#ifdef HAVE_STDINT_H +#include +#endif /* HAVE_STDINT_H */ +#include +#include +#include +#include +#include +#include +#include +#ifdef HAVE_NSS_H +#include +#endif /* HAVE_NSS_H */ +#include + +#include "nslcd.h" +#include "common.h" +#include "common/tio.h" + +/* flag used to disable NSS lookups using this module */ int _nss_ldap_enablelookups=1; + +#ifdef HAVE_NSSWITCH_H +/* Adapted from PADL */ +/* + *Default destructor. + *The entry point for this function is the destructor in the dispatch + *table for the switch. Thus,it's safe to grab the mutex from this + *function. + */ +nss_status_t _nss_ldap_default_destr(nss_backend_t *be,void *args) +{ + /* Ditch the backend. */ + free(be); + return NSS_STATUS_SUCCESS; +} + +/* + *This is the default "constructor" which gets called from each + *constructor,in the NSS dispatch table. + */ +nss_status_t _nss_ldap_default_constr(nss_ldap_backend_t *be) +{ + return NSS_STATUS_SUCCESS; +} + +/* add a nested netgroup or group to the namelist */ +nss_status_t _nss_ldap_namelist_push(struct name_list **head,const char *name) +{ + struct name_list *nl; + nl=(struct name_list *)malloc(sizeof(*nl)); + if (nl==NULL) + return NSS_STATUS_TRYAGAIN; + nl->name=strdup(name); + if (nl->name==NULL) + { + free(nl); + return NSS_STATUS_TRYAGAIN; + } + nl->next=*head; + *head=nl; + return NSS_STATUS_SUCCESS; +} + +/* remove last nested netgroup or group from the namelist */ +void _nss_ldap_namelist_pop(struct name_list **head) +{ + struct name_list *nl; + nl=*head; + *head=nl->next; + free(nl->name); + free(nl); +} + +/* cleanup nested netgroup or group namelist */ +void _nss_ldap_namelist_destroy(struct name_list **head) +{ + struct name_list *p,*next; + for (p=*head;p!=NULL;p=next) + { + next=p->next; + if (p->name!=NULL) + free(p->name); + free(p); + } + *head=NULL; +} + +/* + *Check whether we have already seen a netgroup or group, + *to avoid loops in nested netgroup traversal + */ +int _nss_ldap_namelist_find(struct name_list *head,const char *netgroup) +{ + struct name_list *p; + int found=0; + for (p=head;p!=NULL;p=p->next) + { + if (strcasecmp(p->name,netgroup)==0) + { + found++; + break; + } + } + return found; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/common.h b/nss/common.h index e7182de..c2d429b 100644 --- a/nss/common.h +++ b/nss/common.h @@ -24,12 +24,26 @@ #define NSS__COMMON_H 1 #include +#include #include "nslcd.h" #include "common/nslcd-prot.h" #include "compat/attrs.h" #include "compat/nss_compat.h" +#ifdef HAVE_NSSWITCH_H +#include "ldap-nss.h" +#endif /* HAVE_NSSWITCH_H */ + +#ifdef HAVE_NSSWITCH_H +/* Adapted from PADL */ +/* Routines for managing namelists */ +nss_status_t _nss_ldap_namelist_push(struct name_list **head,const char *name); +void _nss_ldap_namelist_pop(struct name_list **head); +int _nss_ldap_namelist_find(struct name_list *head,const char *netgroup); +void _nss_ldap_namelist_destroy(struct name_list **head); +#endif /* HAVE_NSSWITCH_H */ + /* These are macros for handling read and write problems, they are NSS specific due to the return code so are defined here. They genrally close the open file, set an error code and return with diff --git a/nss/ethers.c b/nss/ethers.c index f23af43..9f5a3de 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -2,7 +2,8 @@ ethers.c - NSS lookup functions for ethers database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -41,7 +42,11 @@ static nss_status_t read_etherent( } /* map a hostname to the corresponding ethernet address */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_gethostton_r( +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostton_r( +#endif /* HAVE_NSSWITCH_H */ const char *name,struct etherent *result, char *buffer,size_t buflen,int *errnop) { @@ -51,7 +56,11 @@ nss_status_t _nss_ldap_gethostton_r( } /* map an ethernet address to the corresponding hostname */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getntohost_r( +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getntohost_r( +#endif /* HAVE_NSSWITCH_H */ const struct ether_addr *addr,struct etherent *result, char *buffer,size_t buflen,int *errnop) { @@ -63,12 +72,21 @@ nss_status_t _nss_ldap_getntohost_r( /* thread-local file pointer to an ongoing request */ static __thread TFILE *etherentfp; +#ifdef HAVE_NSSWITCH_H +static nss_status_t _nss_ldap_setetherent( + nss_backend_t *be,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setetherent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(etherentfp); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getetherent_r( +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getetherent_r( +#endif /* HAVE_NSSWITCH_H */ struct etherent *result, char *buffer,size_t buflen,int *errnop) { @@ -76,7 +94,118 @@ nss_status_t _nss_ldap_getetherent_r( read_etherent(etherentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endetherent(nss_backend_t *be,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endetherent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(etherentfp); } + +#ifdef HAVE_NSSWITCH_H + +/* Solaris wrapper around _nss_nslcd_gethsotton_r */ +static nss_status_t _nss_ldap_gethostton_r(nss_backend_t *be,void *args) +{ + struct etherent result; + char buffer[NSS_BUFLEN_ETHERS]; + nss_status_t status; + char *name=(char *)(NSS_ARGS(args)->key.name); + status=_nss_nslcd_gethostton_r(name,&result,buffer,sizeof(buffer),&errno); + if (status==NSS_STATUS_SUCCESS) + { + /* if (NSS_ARGS(args)->buf.buffer!=NULL) { */ + if (NSS_ARGS(args)->buf.result==NULL) + { + strcpy(NSS_ARGS(args)->buf.buffer,ether_ntoa(&result.e_addr)); + NSS_ARGS(args)->buf.buflen=strlen(NSS_ARGS(args)->buf.buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return status; + } + memcpy(NSS_ARGS(args)->buf.result,&result.e_addr,sizeof(result.e_addr)); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +/* Solaris wrapper around _nss_nslcd_getntohost_r */ +static nss_status_t _nss_ldap_getntohost_r(nss_backend_t *be,void *args) +{ + struct etherent result; + struct ether_addr *addr; + char buffer[NSS_BUFLEN_ETHERS]; + size_t buflen=sizeof(buffer); + nss_status_t status; + addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); + status=_nss_nslcd_getntohost_r(addr,&result,buffer,buflen,&errno); + if (status==NSS_STATUS_SUCCESS) + { + if (NSS_ARGS(args)->buf.buffer!=NULL) + { + /* TODO: OpenSolaris expects " " */ + /* This output is handled correctly by NSCD,but not */ + /* when NSCD is off. Not an issue with NSS_LDAP,but */ + /* with the frontend. */ + sprintf(NSS_ARGS(args)->buf.buffer,"%s %s",ether_ntoa(addr),result.e_name); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return status; + } + memcpy(NSS_ARGS(args)->buf.buffer,result.e_name,strlen(result.e_name)+1); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->buf.buflen=strlen(result.e_name); + } + else + { + NSS_ARGS(args)->returnval=NULL; + } + return status; +} + +static nss_status_t _nss_ldap_getetherent_r(nss_backend_t *be,void *args) +{ + /* TODO: cns3 uses struct ether,verify */ + struct etherent result; + char *buffer; + size_t buflen; + int errnop; + nss_status_t status; + buffer=NSS_ARGS(args)->buf.buffer; + buflen=NSS_ARGS(args)->buf.buflen; + status=_nss_nslcd_getetherent_r(&result,buffer,buflen,&errnop); + if (status==NSS_STATUS_SUCCESS) + { + memcpy(NSS_ARGS(args)->buf.result,&result.e_addr,sizeof(result.e_addr)); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + else + NSS_ARGS(args)->returnval=NULL; + return status; +} + +static nss_status_t _nss_ldap_ethers_destr(nss_backend_t *ether_context,void *args) +{ + return _nss_ldap_default_destr(ether_context,args); +} + +static nss_backend_op_t ethers_ops[]={ + _nss_ldap_ethers_destr, + _nss_ldap_gethostton_r, + _nss_ldap_getntohost_r +}; + +nss_backend_t *_nss_ldap_ethers_constr(const char *db_name,const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=ethers_ops; + be->n_ops=sizeof(ethers_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/exports.solaris b/nss/exports.solaris new file mode 100644 index 0000000..5c191be --- /dev/null +++ b/nss/exports.solaris @@ -0,0 +1,23 @@ +# $Id: exports.solaris,v 1.1 2010-08-07 00:24:21 tedcheng Exp $ + +nss_ldap.so.1 { + # published NSS service functions + global: + # Published NSS service module interfaces + # _nss_ldap_bootparams_constr; + _nss_ldap_ethers_constr; + _nss_ldap_group_constr; + _nss_ldap_hosts_constr; + _nss_ldap_networks_constr; + _nss_ldap_protocols_constr; + _nss_ldap_passwd_constr; + _nss_ldap_rpc_constr; + _nss_ldap_services_constr; + _nss_ldap_shadow_constr; + _nss_ldap_netgroup_constr; + + # everything else should not be exported + local: + *; + +}; diff --git a/nss/group.c b/nss/group.c index 45cfeaa..dadac67 100644 --- a/nss/group.c +++ b/nss/group.c @@ -2,7 +2,8 @@ group.c - NSS lookup functions for group database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008, 2009 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2009, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -46,7 +47,10 @@ static nss_status_t read_group( /* read all group entries from the stream and add gids of these groups to the list */ static nss_status_t read_gids( - TFILE *fp,gid_t skipgroup,long int *start,long int *size, + TFILE *fp,gid_t skipgroup,long int *start, +#ifndef HAVE_NSSWITCH_H + long int *size, +#endif /* HAVE_NSSWITCH_H */ gid_t **groupsp,long int limit,int *errnop) { int32_t res=(int32_t)NSLCD_RESULT_BEGIN; @@ -72,6 +76,7 @@ static nss_status_t read_gids( if ( (limit>0) && (*start>=limit) ) return NSS_STATUS_TRYAGAIN; /* check if our buffer is large enough */ +#ifndef HAVE_NSSWITCH_H if ((*start)>=(*size)) { /* for some reason Glibc expects us to grow the array (completely @@ -88,6 +93,7 @@ static nss_status_t read_gids( *size=newsize; } /* add gid to list */ +#endif /* HAVE_NSSWITCH_H */ (*groupsp)[(*start)++]=gid; } /* read next response code @@ -99,14 +105,26 @@ static nss_status_t read_gids( return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getgrnam_r(const char *name,struct group *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getgrnam_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getgrnam_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,struct group *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME, name, read_group(fp,result,buffer,buflen,errnop)); } -nss_status_t _nss_ldap_getgrgid_r(gid_t gid,struct group *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getgrgid_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getgrgid_r( +#endif /* HAVE_NSSWITCH_H */ + gid_t gid,struct group *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID, gid,gid_t, @@ -127,16 +145,29 @@ nss_status_t _nss_ldap_getgrgid_r(gid_t gid,struct group *result,char *buffer,si */ nss_status_t _nss_ldap_initgroups_dyn( const char *user,gid_t skipgroup,long int *start, - long int *size,gid_t **groupsp,long int limit,int *errnop) +#ifndef HAVE_NSSWITCH_H + long int *size, +#endif /* HAVE_NSSWITCH_H */ + gid_t **groupsp,long int limit,int *errnop) { +#ifdef HAVE_NSSWITCH_H + long int buffer_size=limit; + long int *size=&buffer_size; +#endif /* HAVE_NSSWITCH_H */ /* temporarily map the buffer and buflen names so the check in NSS_BYNAME for validity of the buffer works (renaming the parameters may cause confusion) */ #define buffer groupsp #define buflen *size +#ifdef HAVE_NSSWITCH_H + NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER, + user, + read_gids(fp,skipgroup,start,groupsp,limit,errnop)); +#else /* not HAVE_NSSWITCH_H */ NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER, user, read_gids(fp,skipgroup,start,size,groupsp,limit,errnop)); +#endif /* not HAVE_NSSWITCH_H */ #undef buffer #undef buflen } @@ -144,18 +175,209 @@ nss_status_t _nss_ldap_initgroups_dyn( /* thread-local file pointer to an ongoing request */ static __thread TFILE *grentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setgrent(nss_backend_t *gr_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setgrent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(grentfp); } -nss_status_t _nss_ldap_getgrent_r(struct group *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getgrent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getgrent_r( +#endif /* HAVE_NSSWITCH_H */ + struct group *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL, read_group(grentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endgrent(nss_backend_t *gr_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endgrent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(grentfp); } + +#ifdef HAVE_NSSWITCH_H + +static nss_status_t _nss_ldap_getgrnam_r(nss_backend_t *be,void *args) +{ + char *name=(char *)NSS_ARGS(args)->key.name; + struct group priv_gr; + struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + nss_status_t status; + status=_nss_nslcd_getgrnam_r(name,gr,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s:%s:%d:",gr->gr_name,gr->gr_passwd,(int) gr->gr_gid); + if (gr->gr_mem) + { + int i; + for (i=0; gr->gr_mem[i]; i++) + { + if (i) + strcat(data_ptr,","); + strcat(data_ptr,gr->gr_mem[i]); + } + } + strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { /* result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getgrgid_r(nss_backend_t *be,void *args) +{ + gid_t gid=NSS_ARGS(args)->key.gid; + struct group priv_gr; + struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + nss_status_t status; + status=_nss_nslcd_getgrgid_r(gid,gr,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s:%s:%d:",gr->gr_name,gr->gr_passwd,(int) gr->gr_gid); + if (gr->gr_mem) + { + int i; + for (i=0; gr->gr_mem[i]; i++) + { + if (i) + strcat(data_ptr,","); + strcat(data_ptr,gr->gr_mem[i]); + } + } + strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { /* result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getgrent_r(nss_backend_t *gr_context,void *args) +{ + struct group priv_gr; + struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + nss_status_t status; + + status=_nss_nslcd_getgrent_r(gr,buffer,buflen,&errno); + + if (status!=NSS_STATUS_SUCCESS) + return status; + + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s:%s:%d:",gr->gr_name,gr->gr_passwd,(int)gr->gr_gid); + if (gr->gr_mem) + { + int i; + for (i=0; gr->gr_mem[i]; i++) + { + if (i) + strcat(data_ptr,","); + strcat(data_ptr,gr->gr_mem[i]); + } + } + strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); + free(data_ptr); + + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { /* result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_group_destr(nss_backend_t *gr_context,void *args) +{ + return _nss_ldap_default_destr(gr_context,args); +} + +static nss_status_t _nss_ldap_getgroupsbymember_r(nss_backend_t *gr_context,void *args) +{ + struct nss_groupsbymem *argp=(struct nss_groupsbymem *)args; + char *user=(char *)argp->username; + nss_status_t status; + long int limit=(long int) argp->maxgids; + long int start=(long int) argp->numgids; + gid_t skipgroup; + int i; + + if (start > 0) + skipgroup=argp->gid_array[0]; + + status=_nss_ldap_initgroups_dyn( + user, + (start > 0)?skipgroup:-1, + &start, + (gid_t **)&argp->gid_array, + limit, + &errno); + argp->numgids=(int)start; + + return status; +} + +static nss_backend_op_t group_ops[]={ + _nss_ldap_group_destr, + _nss_ldap_endgrent, + _nss_ldap_setgrent, + _nss_ldap_getgrent_r, + _nss_ldap_getgrnam_r, + _nss_ldap_getgrgid_r, + _nss_ldap_getgroupsbymember_r +}; + +nss_backend_t *_nss_ldap_group_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=group_ops; + be->n_ops=sizeof(group_ops)/sizeof(nss_backend_op_t); + /* a NOOP at the moment */ + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/hosts.c b/nss/hosts.c index 6d5c406..404dc5d 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -2,7 +2,8 @@ hosts.c - NSS lookup functions for hosts database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -179,12 +180,80 @@ nss_status_t _nss_ldap_gethostbyname2_r( /* this function just calls the gethostbyname2() variant with the address familiy set */ +#ifdef HAVE_NSSWITCH_H +static nss_status_t _nss_ldap_gethostbyname_r(nss_backend_t *be,void *args) +{ + struct hostent priv_host; + struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + int h_errno; + nss_status_t status; + status=_nss_ldap_gethostbyname2_r( + NSS_ARGS(args)->key.name, + AF_INET, + host, + NSS_ARGS(args)->buf.buffer, + NSS_ARGS(args)->buf.buflen, + &errno,&h_errno); + + if (status!=NSS_STATUS_SUCCESS) + { + NSS_ARGS(args)->h_errno=h_errno; + return status; + } + + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + if (host->h_addr_list) + { + int i; + struct in_addr in; + (void)memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); + sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); + if (host->h_aliases) + { + int j; + for (j=0; host->h_aliases[j]; j++) + { + strcat(data_ptr," "); + strcat(data_ptr,host->h_aliases[j]); + } + } + for (i=1; host->h_addr_list[i]; i++) + { + (void) memcpy(&in.s_addr,host->h_addr_list[i],sizeof(in.s_addr)); + strcat(data_ptr,"\n"); + strcat(data_ptr,inet_ntoa(in)); + strcat(data_ptr," "); + strcat(data_ptr,host->h_name); + /* TODO: aliases only supplied to the first address */ + /* need review */ + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { /* NSS_ARGS(args)->buf.result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + NSS_ARGS(args)->h_errno=h_errno; + return status; +} +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostbyname_r( const char *name,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { return _nss_ldap_gethostbyname2_r(name,AF_INET,result,buffer,buflen,errnop,h_errnop); } +#endif /* HAVE_NSSWITCH_H */ /* write an address value */ #define WRITE_ADDRESS(fp,af,len,addr) \ @@ -200,7 +269,11 @@ nss_status_t _nss_ldap_gethostbyname_r( result - OUT - entry found buffer,buflen - OUT - buffer to store allocated stuff on errnop,h_errnop - OUT - for reporting errors */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_gethostbyaddr_r( +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostbyaddr_r( +#endif /* HAVE_NSSWITCH_H */ const void *addr,socklen_t len,int af,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { @@ -212,13 +285,21 @@ nss_status_t _nss_ldap_gethostbyaddr_r( /* thread-local file pointer to an ongoing request */ static __thread TFILE *hostentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_sethostent(nss_backend_t *hosts_context,void *fakeargs) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_sethostent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(hostentfp); } /* this function only returns addresses of the AF_INET address family */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_gethostent_r( +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostent_r( +#endif /* HAVE_NSSWITCH_H */ struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { @@ -226,7 +307,166 @@ nss_status_t _nss_ldap_gethostent_r( read_hostent_nextonempty(hostentfp,AF_INET,result,buffer,buflen,errnop,h_errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endhostent(nss_backend_t *hosts_context,void *fakeargs ) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endhostent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(hostentfp); } + +#ifdef HAVE_NSSWITCH_H + +static nss_status_t _nss_ldap_gethostbyaddr_r(nss_backend_t *be,void *args) +{ + struct in_addr iaddr; + int type; + struct hostent priv_host; + struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + int h_errno; + nss_status_t status; + status=_nss_nslcd_gethostbyaddr_r( + NSS_ARGS(args)->key.hostaddr.addr, + NSS_ARGS(args)->key.hostaddr.len, + NSS_ARGS(args)->key.hostaddr.type, + host, + NSS_ARGS(args)->buf.buffer, + NSS_ARGS(args)->buf.buflen, + &errno,&h_errno); + if (status!=NSS_STATUS_SUCCESS) + { + NSS_ARGS(args)->h_errno=h_errno; + return status; + } + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + if (host->h_addr_list) + { + int i; + struct in_addr in; + (void) memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); + sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); + if (host->h_aliases) + { + int j; + for (j=0; host->h_aliases[j]; j++) + { + strcat(data_ptr," "); + strcat(data_ptr,host->h_aliases[j]); + } + } + for (i=1; host->h_addr_list[i]; i++) + { + (void) memcpy(&in.s_addr,host->h_addr_list[i],sizeof(in.s_addr)); + strcat(data_ptr,"\n"); + strcat(data_ptr,inet_ntoa(in)); + strcat(data_ptr," "); + strcat(data_ptr,host->h_name); + /* TODO: aliases only supplied to the first address */ + /* need review */ + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { /* NSS_ARGS(args)->buf.result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + NSS_ARGS(args)->h_errno=h_errno; + return status; +} + +/* this function only returns addresses of the AF_INET address family */ +static nss_status_t _nss_ldap_gethostent_r(nss_backend_t *hosts_context,void *args) +{ + struct hostent priv_host; + struct hostent *host=NSS_ARGS(args)->buf.result ? + NSS_ARGS(args)->buf.result : &priv_host; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + int h_errno; + nss_status_t status; + status=_nss_nslcd_gethostent_r(host,buffer,buflen,&errno,&h_errno); + if (status!=NSS_STATUS_SUCCESS) + { + NSS_ARGS(args)->h_errno=h_errno; + return status; + } + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + if (host->h_addr_list) + { + int i; + sprintf(data_ptr,"%s %s",host->h_addr_list[0],host->h_name); + if (host->h_aliases) + { + int j; + for (j=0; host->h_aliases[j]; j++) + { + strcat(data_ptr," "); + strcat(data_ptr,host->h_aliases[j]); + } + } + for (i=1; host->h_addr_list[i]; i++) + { + strcat(data_ptr,"\n"); + strcat(data_ptr,host->h_addr_list[i]); + strcat(data_ptr," "); + strcat(data_ptr,host->h_name); + /* TODO: aliases only supplied to the first address */ + /* need review */ + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { /* NSS_ARGS(args)->buf.result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + NSS_ARGS(args)->h_errno=h_errno; + return status; +} + +static nss_status_t _nss_ldap_hosts_destr(nss_backend_t *hosts_context,void *args) +{ + return _nss_ldap_default_destr(hosts_context,args); +} + +static nss_backend_op_t host_ops[]={ + _nss_ldap_hosts_destr, + _nss_ldap_endhostent, + _nss_ldap_sethostent, + _nss_ldap_gethostent_r, + _nss_ldap_gethostbyname_r, + _nss_ldap_gethostbyaddr_r +}; + +nss_backend_t *_nss_ldap_hosts_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=host_ops; + be->n_ops=sizeof(host_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/ldap-nss.h b/nss/ldap-nss.h new file mode 100644 index 0000000..369f165 --- /dev/null +++ b/nss/ldap-nss.h @@ -0,0 +1,109 @@ +/* + ldap-nss.h - compatibility definitions + Parts of this file were part of the nss_ldap library (as ldap-nss.h) + which has been forked into the nss-pam-ldapd library. + + Copyright (C) 1997-2005 Luke Howard + Copyright (C) 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +#ifndef _LDAP_NSS_LDAP_LDAP_NSS_H +#define _LDAP_NSS_LDAP_LDAP_NSS_H + +/* from ldap-parse.h */ +#define NSS_ARGS(args)((nss_XbyY_args_t *)args) + +#ifndef NSS_BUFSIZ +#define NSS_BUFSIZ 1024 +#endif + +#ifndef HAVE_NSSWITCH_H +#define NSS_BUFLEN_NETGROUP(MAXHOSTNAMELEN * 2 + LOGNAME_MAX + 3) +#define NSS_BUFLEN_ETHERS NSS_BUFSIZ +#endif /* HAVE_NSSWITCH_H */ + +#ifdef HAVE_NSSWITCH_H +/* + *thread specific context: result chain,and state data + */ +struct ent_context +{ + void *first_entry; + void *curr_entry; +}; + +typedef struct ent_context ent_context_t; + +#endif /* HAVE_NSSWITCH_H */ + +struct name_list +{ + char *name; + struct name_list *next; +}; + +#ifdef HAVE_NSSWITCH_H + +struct nss_ldap_backend +{ + nss_backend_op_t *ops; + int n_ops; + ent_context_t *state; +}; + +typedef struct nss_ldap_backend nss_ldap_backend_t; + +struct nss_ldap_netgr_backend +{ + nss_backend_op_t *ops; + int n_ops; + ent_context_t *state; + struct name_list *known_groups; /* netgroups seen,for loop detection */ + struct name_list *needed_groups; /* nested netgroups to chase */ +}; + +typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; + +#elif defined(HAVE_IRS_H) + +struct nss_ldap_netgr_backend +{ + char buffer[NSS_BUFLEN_NETGROUP]; + ent_context_t *state; + struct name_list *known_groups; /* netgroups seen,for loop detection */ + struct name_list *needed_groups; /* nested netgroups to chase */ +}; + +typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; + +#endif /* HAVE_NSSWITCH_H */ + +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_default_destr(nss_backend_t *,void *); +#endif + +/* + *context management routines. + *_nss_ldap_default_constr() is called once in the constructor + */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_default_constr(nss_ldap_backend_t *be); +#endif + +#endif /* _LDAP_NSS_LDAP_LDAP_NSS_H */ diff --git a/nss/netgroup.c b/nss/netgroup.c index 6315707..7fec5fc 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -2,7 +2,8 @@ netgroup.c - NSS lookup functions for netgroup entries Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -30,6 +31,51 @@ #include "common.h" #include "compat/attrs.h" +#ifdef HAVE_NSSWITCH_H +#include +#include +#include +#endif /* HAVE_NSSWITCH_H */ + + +#ifdef HAVE_NSSWITCH_H + +static nss_backend_op_t netgroup_ops[]; +static nss_status_t _nss_ldap_netgroup_destr(nss_backend_t *_ngbe,void *args); + +/* find a netgroup that has not been traversed */ +static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) +{ + nss_status_t status; + char *group=NULL; + int found=0; + if (!ngbe->needed_groups) + { + /* exhausted all netgroups */ + return NULL; + } + while (ngbe->needed_groups&&!found) + { + if (_nss_ldap_namelist_find(ngbe->known_groups, + ngbe->needed_groups->name)) + { + /* netgroup seen before,ignore it */ + _nss_ldap_namelist_pop(&ngbe->needed_groups); + } + else + found=1; + } + if (found) + { + group=strdup(ngbe->needed_groups->name); + status=_nss_ldap_namelist_push(&ngbe->known_groups, + ngbe->needed_groups->name); + _nss_ldap_namelist_pop(&ngbe->needed_groups); + } + return group; +} +#endif /* HAVE_NSSWITCH_H */ + /* we redefine this here because we need to return NSS_STATUS_RETURN instead of NSS_STATUS_NOTFOUND */ #undef ERROR_OUT_NOSUCCESS @@ -89,7 +135,19 @@ static nss_status_t read_netgrent( /* thread-local file pointer to an ongoing request */ static __thread TFILE *netgrentfp; -nss_status_t _nss_ldap_setnetgrent(const char *group,struct __netgrent UNUSED(*result)) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setnetgrent(nss_backend_t *be,void *_args) +{ + return NSS_STATUS_SUCCESS; +} +#endif /* HAVE_NSSWITCH_H */ + +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_setnetgrent( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_setnetgrent( +#endif /* HAVE_NSSWITCH_H */ + const char *group,struct __netgrent UNUSED(* result)) { /* we cannot use NSS_SETENT() here because we have a parameter that is only available in this function */ @@ -107,13 +165,180 @@ nss_status_t _nss_ldap_setnetgrent(const char *group,struct __netgrent UNUSED(*r return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getnetgrent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getnetgrent_r( +#endif /* HAVE_NSSWITCH_H */ + struct __netgrent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME, read_netgrent(netgrentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endnetgrent(nss_backend_t *be,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endnetgrent(struct __netgrent UNUSED(* result)) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(netgrentfp); } + +#ifdef HAVE_NSSWITCH_H + +nss_status_t _nss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) +{ + nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_be; + struct nss_getnetgrent_args *args=(struct nss_getnetgrent_args *)_args; + struct __netgrent result; + char *group=NULL; + int done=0; + int err; + nss_status_t status,rc; + args->status=NSS_NETGR_NO; + while (!done) + { + status=_nss_nslcd_getnetgrent_r(&result,args->buffer,args->buflen, + &err); + if (status!=NSS_STATUS_SUCCESS) + { + if (err==ENOENT) + { + /* done with the current netgroup */ + /* explore nested netgroup,if any */ + int found=0; + while (!found) + { + /* find a nested netgroup to pursue further */ + group=_nss_ldap_chase_netgroup(ngbe); + if (!group) + { + /* no more netgroup */ + found=1; done = 1; + errno=ENOENT; + } + else + { + rc=_nss_nslcd_setnetgrent(group,&result); + if (rc==NSS_STATUS_SUCCESS) + found=1; + free(group); + group=NULL; + } + } /* while !found */ + } + else + { /* err!=ENOENT */ + done=1; + } + } + else + { /* status==NSS_STATUS_SUCCESS */ + if (result.type==group_val) + { + /* a netgroup nested within the current netgroup */ + rc=_nss_ldap_namelist_push(&ngbe->needed_groups,result.val.group); + if (rc!=NSS_STATUS_SUCCESS) + { + /* unable to push the group name for later netgroup */ + } + } + else if (result.type==triple_val) + { + args->retp[NSS_NETGR_MACHINE]=result.val.triple.host; + args->retp[NSS_NETGR_USER]=result.val.triple.user; + args->retp[NSS_NETGR_DOMAIN]=result.val.triple.domain; + args->status=NSS_NETGR_FOUND; + done=1; + } + else + { + /* NSS_STATUS_SUCCESS,but type is not group_val or triple_val */ + /* should not be here,log a message */ + status=NSS_STATUS_NOTFOUND; + done=1; + } + } + } /* while !done */ + return status; +} + +static nss_status_t _nss_ldap_netgr_set(nss_backend_t *be,void *_args) +{ + nss_status_t stat; + struct nss_setnetgrent_args *args; + nss_ldap_netgr_backend_t *ngbe; + struct __netgrent result; + char *group=NULL; + args=(struct nss_setnetgrent_args *)_args; + args->iterator=NULL; /* initialize */ + ngbe=(nss_ldap_netgr_backend_t *)malloc(sizeof(*ngbe)); + if (ngbe==NULL) + return NSS_STATUS_UNAVAIL; + ngbe->ops=netgroup_ops; + ngbe->n_ops=6; + ngbe->state=NULL; + ngbe->known_groups=NULL; + ngbe->needed_groups=NULL; + stat=_nss_ldap_default_constr((nss_ldap_backend_t *)ngbe); + if (stat!=NSS_STATUS_SUCCESS) + { + free(ngbe); + return stat; + } + group=(char *)args->netgroup; + stat=_nss_nslcd_setnetgrent(group,&result); + if (stat!=NSS_STATUS_SUCCESS) + { + _nss_ldap_default_destr((nss_backend_t *)ngbe,NULL); + return stat; + } + /* place the group name in known list */ + stat=_nss_ldap_namelist_push(&ngbe->known_groups,group); + if (stat!=NSS_STATUS_SUCCESS) + { + _nss_ldap_netgroup_destr((nss_backend_t *)ngbe,NULL); + return stat; + } + args->iterator=(nss_backend_t *)ngbe; + return stat; +} + +static nss_status_t _nss_ldap_netgroup_destr(nss_backend_t *_ngbe,void *args) +{ + nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_ngbe; + /* free list of nested netgroups */ + _nss_ldap_namelist_destroy(&ngbe->known_groups); + _nss_ldap_namelist_destroy(&ngbe->needed_groups); + return _nss_ldap_default_destr(_ngbe,args); +} + +static nss_backend_op_t netgroup_ops[]={ + _nss_ldap_netgroup_destr, /* NSS_DBOP_DESTRUCTOR */ + _nss_ldap_endnetgrent, /* NSS_DBOP_ENDENT */ + _nss_ldap_setnetgrent, /* NSS_DBOP_SETNET */ + _nss_ldap_getnetgrent_r, /* NSS_DBOP_GETENT */ + NULL,/* TODO:_nss_ldap_netgr_in,*/ /* NSS_DBOP_NETGROUP_IN */ + _nss_ldap_netgr_set /* NSS_DBOP_NETGROUP_SET */ +}; + +nss_backend_t *_nss_ldap_netgroup_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_netgr_backend_t *be; + if (!(be=(nss_ldap_netgr_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=netgroup_ops; + be->n_ops=sizeof(netgroup_ops)/sizeof(nss_backend_op_t); + be->known_groups=NULL; + be->needed_groups=NULL; + if (_nss_ldap_default_constr((nss_ldap_backend_t *)be)!=NSS_STATUS_SUCCESS) + { + free(be); + return NULL; + } + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/networks.c b/nss/networks.c index 8273f27..623fca8 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -2,7 +2,8 @@ networks.c - NSS lookup functions for networks database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -99,7 +100,13 @@ static nss_status_t read_netent( return retv; } -nss_status_t _nss_ldap_getnetbyname_r(const char *name,struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getnetbyname_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getnetbyname_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,struct netent *result,char *buffer, + size_t buflen,int *errnop,int *h_errnop) { NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME, name, @@ -116,7 +123,13 @@ nss_status_t _nss_ldap_getnetbyname_r(const char *name,struct netent *result,cha /* Note: the af parameter is ignored and is assumed to be AF_INET */ /* TODO: implement handling of af parameter */ -nss_status_t _nss_ldap_getnetbyaddr_r(uint32_t addr,int UNUSED(af),struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getnetbyaddr_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getnetbyaddr_r( +#endif /* HAVE_NSSWITCH_H */ + uint32_t addr,int UNUSED(af),struct netent *result, + char *buffer,size_t buflen,int *errnop,int *h_errnop) { NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR, WRITE_ADDRESS(fp,addr), @@ -126,18 +139,213 @@ nss_status_t _nss_ldap_getnetbyaddr_r(uint32_t addr,int UNUSED(af),struct netent /* thread-local file pointer to an ongoing request */ static __thread TFILE *netentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setnetent(nss_backend_t *net_context,void *fakeargs) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setnetent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(netentfp); } -nss_status_t _nss_ldap_getnetent_r(struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getnetent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getnetent_r( +#endif /* HAVE_NSSWITCH_H */ + struct netent *result,char *buffer,size_t buflen, + int *errnop,int *h_errnop) { NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL, read_netent(netentfp,result,buffer,buflen,errnop,h_errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endnetent(nss_backend_t *net_context,void *fakeargs) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endnetent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(netentfp); } + +#ifdef HAVE_NSSWITCH_H +static nss_status_t _nss_ldap_getnetbyname_r(nss_backend_t *be,void *args) +{ + struct netent priv_network; + struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; + char *name=(char *)NSS_ARGS(args)->key.name; + int af=NSS_ARGS(args)->key.netaddr.type; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + int h_errno; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getnetbyname_r(name,network,buffer, + buflen,&errno,&h_errno); + if (status!=NSS_STATUS_SUCCESS) + { + NSS_ARGS(args)->h_errno=h_errno; + return status; + } + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %s",name,inet_ntoa(network->n_net)); /* ipNetworkNumber */ + if (network->n_aliases) + { + int i; + for (i=0; network->n_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,network->n_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + NSS_ARGS(args)->h_errno=h_errno; + return status; +} +#endif /* HAVE_NSSWITCH_H */ + +/* Note: the af parameter is ignored and is assumed to be AF_INET */ +/* TODO: implement handling of af parameter */ +#ifdef HAVE_NSSWITCH_H +static nss_status_t _nss_ldap_getnetbyaddr_r(nss_backend_t *be,void *args) +{ + struct netent priv_network; + struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; + int addr=NSS_ARGS(args)->key.netaddr.net; + int af=NSS_ARGS(args)->key.netaddr.type; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + int h_errno; + char *data_ptr; + struct in_addr in_addr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getnetbyaddr_r(addr,af,network,buffer,buflen,&errno,&h_errno); + if (status!=NSS_STATUS_SUCCESS) + { + NSS_ARGS(args)->h_errno=h_errno; + return status; + } + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + (void)memcpy(&in_addr.s_addr,addr,sizeof(in_addr.s_addr)); + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %s",network->n_name, + inet_ntoa(in_addr)); /* ipNetworkNumber */ + if (network->n_aliases) + { + int i; + for (i=0; network->n_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,network->n_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + NSS_ARGS(args)->h_errno=h_errno; + return status; +} + +static nss_status_t _nss_ldap_getnetent_r(nss_backend_t *net_context,void *args) +{ + struct netent priv_network; + struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + int h_errno; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getnetent_r(network,buffer,buflen,&errno,&h_errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %s",network->n_name, + inet_ntoa(network->n_net)); /* ipNetworkNumber */ + if (network->n_aliases) + { + int i; + for (i=0; network->n_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,network->n_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + NSS_ARGS(args)->h_errno=h_errno; + return status; +} + +static nss_status_t _nss_ldap_networks_destr(nss_backend_t *net_context,void *args) +{ + return _nss_ldap_default_destr(net_context,args); +} + +static nss_backend_op_t net_ops[]={ + _nss_ldap_networks_destr, + _nss_ldap_endnetent, + _nss_ldap_setnetent, + _nss_ldap_getnetent_r, + _nss_ldap_getnetbyname_r, + _nss_ldap_getnetbyaddr_r +}; + +nss_backend_t *_nss_ldap_networks_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=net_ops; + be->n_ops=sizeof(net_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/passwd.c b/nss/passwd.c index 6787d60..aaa346a 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -2,7 +2,8 @@ passwd.c - NSS lookup functions for passwd database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -45,14 +46,26 @@ static nss_status_t read_passwd( return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getpwnam_r(const char *name,struct passwd *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getpwnam_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getpwnam_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,struct passwd *result,char *buffer,size_t buflen, + int *errnop) { NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME, name, read_passwd(fp,result,buffer,buflen,errnop)); } -nss_status_t _nss_ldap_getpwuid_r(uid_t uid,struct passwd *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getpwuid_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getpwuid_r( +#endif /* HAVE_NSSWITCH_H */ + uid_t uid,struct passwd *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID, uid,uid_t, @@ -63,20 +76,168 @@ nss_status_t _nss_ldap_getpwuid_r(uid_t uid,struct passwd *result,char *buffer,s static __thread TFILE *pwentfp; /* open a connection to the nslcd and write the request */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setpwent(nss_backend_t *be,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setpwent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(pwentfp); } /* read password data from an opened stream */ -nss_status_t _nss_ldap_getpwent_r(struct passwd *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getpwent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getpwent_r( +#endif /* HAVE_NSSWITCH_H */ + struct passwd *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL, read_passwd(pwentfp,result,buffer,buflen,errnop)); } /* close the stream opened with setpwent() above */ +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endpwent(nss_backend_t *be,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endpwent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(pwentfp); } + +#ifdef HAVE_NSSWITCH_H +static nss_status_t _nss_ldap_getpwnam_r(nss_backend_t *be,void *args) +{ + struct passwd priv_pw; + struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *name=(char *)NSS_ARGS(args)->key.name; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + status=NSS_STATUS_TRYAGAIN; + return status; + } + status=_nss_nslcd_getpwnam_r(name,pw,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s:%s:%d:%d:%s:%s:%s", + pw->pw_name,"x",(int) pw->pw_uid,(int) pw->pw_gid,pw->pw_gecos, + pw->pw_dir,pw->pw_shell); + /* copy file-format data to buffer provided by front-end */ + strcpy(buffer,data_ptr); + if (data_ptr) + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getpwuid_r(nss_backend_t *be,void *args) +{ + struct passwd priv_pw; + struct passwd *pw=NSS_ARGS(args)->buf.result ? + NSS_ARGS(args)->buf.result : &priv_pw; + uid_t uid=NSS_ARGS(args)->key.uid; + char *data_ptr; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + nss_status_t status; + status=_nss_nslcd_getpwuid_r(uid,pw,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc((size_t) buflen); + sprintf(data_ptr,"%s:%s:%d:%d:%s:%s:%s", + pw->pw_name,"x",(int) pw->pw_uid,(int) pw->pw_gid,pw->pw_gecos, + pw->pw_dir,pw->pw_shell); + /* copy file-format data to buffer provided by front-end */ + strcpy(buffer,data_ptr); + if (data_ptr) + free((void *)data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getpwent_r(nss_backend_t *be,void *args) +{ + struct passwd priv_pw; + struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + status=_nss_nslcd_getpwent_r(pw,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s:%s:%d:%d:%s:%s:%s", + pw->pw_name,"x",(int) pw->pw_uid,(int) pw->pw_gid,pw->pw_gecos, + pw->pw_dir,pw->pw_shell); + /* copy file-format data to buffer provided by front-end */ + strcpy(buffer,data_ptr); + if (data_ptr) + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_passwd_destr(nss_backend_t *pw_context,void *args) +{ + return _nss_ldap_default_destr(pw_context,args); +} + +static nss_backend_op_t passwd_ops[]={ + _nss_ldap_passwd_destr, + _nss_ldap_endpwent, /* NSS_DBOP_ENDENT */ + _nss_ldap_setpwent, /* NSS_DBOP_SETENT */ + _nss_ldap_getpwent_r, /* NSS_DBOP_GETENT */ + _nss_ldap_getpwnam_r, /* NSS_DBOP_PASSWD_BYNAME */ + _nss_ldap_getpwuid_r /* NSS_DBOP_PASSWD_BYUID */ +}; + +nss_backend_t *_nss_ldap_passwd_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=passwd_ops; + be->n_ops=sizeof(passwd_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/protocols.c b/nss/protocols.c index 165c24f..244cdac 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -2,7 +2,8 @@ protocols.c - NSS lookup functions for protocol database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -41,14 +42,26 @@ static nss_status_t read_protoent( return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getprotobyname_r(const char *name,struct protoent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getprotobyname_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getprotobyname_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,struct protoent *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME, name, read_protoent(fp,result,buffer,buflen,errnop)); } -nss_status_t _nss_ldap_getprotobynumber_r(int number,struct protoent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getprotobynumber_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getprotobynumber_r( +#endif /* HAVE_NSSWITCH_H */ + int number,struct protoent *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER, number, @@ -58,18 +71,191 @@ nss_status_t _nss_ldap_getprotobynumber_r(int number,struct protoent *result,cha /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setprotoent(nss_backend_t *proto_context,void *fakeargs) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setprotoent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(protoentfp); } -nss_status_t _nss_ldap_getprotoent_r(struct protoent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getprotoent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getprotoent_r( +#endif /* HAVE_NSSWITCH_H */ + struct protoent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL, read_protoent(protoentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endprotoent(nss_backend_t *proto_context,void *fakeargs) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endprotoent(void) +#endif /* HAVE_NSSWITCH_H */ + { NSS_ENDENT(protoentfp); } + +#ifdef HAVE_NSSWITCH_H + +static nss_status_t _nss_ldap_getprotobyname_r(nss_backend_t *be,void *args) +{ + struct protoent priv_proto; + struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; + char *name=(char *)NSS_ARGS(args)->key.name; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getprotobyname_r(name,proto ,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); + if (proto->p_aliases) + { + int i; + for (i=0; proto->p_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,proto->p_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getprotobynumber_r(nss_backend_t *be,void *args) +{ + struct protoent priv_proto; + struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; + int number=NSS_ARGS(args)->key.number; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen<0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getprotobynumber_r(number,proto,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); + if (proto->p_aliases) + { + int i; + for (i=0; proto->p_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,proto->p_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getprotoent_r(nss_backend_t *proto_context,void *args) +{ + struct protoent priv_proto; + struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getprotoent_r(proto,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); + if (proto->p_aliases) + { + int i; + for (i=0; proto->p_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,proto->p_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_protocols_destr(nss_backend_t *proto_context,void *args) +{ + return _nss_ldap_default_destr(proto_context,args); +} + +static nss_backend_op_t proto_ops[]={ + _nss_ldap_protocols_destr, + _nss_ldap_endprotoent, + _nss_ldap_setprotoent, + _nss_ldap_getprotoent_r, + _nss_ldap_getprotobyname_r, + _nss_ldap_getprotobynumber_r +}; + +nss_backend_t *_nss_ldap_protocols_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=proto_ops; + be->n_ops=sizeof(proto_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/prototypes.h b/nss/prototypes.h index 862b04a..973a8ad 100644 --- a/nss/prototypes.h +++ b/nss/prototypes.h @@ -43,78 +43,100 @@ extern int _nss_ldap_enablelookups; /* aliases - mail aliases */ +#ifdef HAVE_ALIASES_H nss_status_t _nss_ldap_getaliasbyname_r(const char *name,struct aliasent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setaliasent(void); nss_status_t _nss_ldap_getaliasent_r(struct aliasent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endaliasent(void); +#endif /* HAVE_ALIASES_H */ /* ethers - ethernet numbers */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_gethostton_r(const char *name,struct etherent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getntohost_r(const struct ether_addr *addr,struct etherent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setetherent(int stayopen); nss_status_t _nss_ldap_getetherent_r(struct etherent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endetherent(void); +#endif /* not HAVE_NSSWITCH_H */ /* group - groups of users */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getgrnam_r(const char *name,struct group *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getgrgid_r(gid_t gid,struct group *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_initgroups_dyn(const char *user,gid_t group,long int *start,long int *size,gid_t **groupsp,long int limit,int *errnop); nss_status_t _nss_ldap_setgrent(int stayopen); nss_status_t _nss_ldap_getgrent_r(struct group *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endgrent(void); +#endif /* not HAVE_NSSWITCH_H */ /* hosts - host names and numbers */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_gethostbyname_r(const char *name,struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_gethostbyname2_r(const char *name,int af,struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_gethostbyaddr_r(const void *addr,socklen_t len,int af,struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_sethostent(int stayopen); nss_status_t _nss_ldap_gethostent_r(struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_endhostent(void); +#endif /* not HAVE_NSSWITCH_H */ /* netgroup - list of host and users */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_setnetgrent(const char *group,struct __netgrent *result); nss_status_t _nss_ldap_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endnetgrent(struct __netgrent *result); +#endif /* not HAVE_NSSWITCH_H */ /* networks - network names and numbers */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getnetbyname_r(const char *name,struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_getnetbyaddr_r(uint32_t addr,int af,struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_setnetent(int stayopen); nss_status_t _nss_ldap_getnetent_r(struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_endnetent(void); +#endif /* not HAVE_NSSWITCH_H */ /* passwd - user database and passwords */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getpwnam_r(const char *name,struct passwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getpwuid_r(uid_t uid,struct passwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setpwent(int stayopen); nss_status_t _nss_ldap_getpwent_r(struct passwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endpwent(void); +#endif /* not HAVE_NSSWITCH_H */ /* protocols - network protocols */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getprotobyname_r(const char *name,struct protoent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getprotobynumber_r(int number,struct protoent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setprotoent(int stayopen); nss_status_t _nss_ldap_getprotoent_r(struct protoent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endprotoent(void); +#endif /* not HAVE_NSSWITCH_H */ /* rpc - remote procedure call names and numbers */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getrpcbyname_r(const char *name,struct rpcent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getrpcbynumber_r(int number,struct rpcent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setrpcent(int stayopen); nss_status_t _nss_ldap_getrpcent_r(struct rpcent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endrpcent(void); +#endif /* not HAVE_NSSWITCH_H */ /* services - network services */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getservbyname_r(const char *name,const char *protocol,struct servent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getservbyport_r(int port,const char *protocol,struct servent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setservent(int stayopen); nss_status_t _nss_ldap_getservent_r(struct servent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endservent(void); +#endif /* not HAVE_NSSWITCH_H */ /* shadow - extended user information */ +#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getspnam_r(const char *name,struct spwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setspent(int stayopen); nss_status_t _nss_ldap_getspent_r(struct spwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endspent(void); +#endif /* not HAVE_NSSWITCH_H */ #endif /* not NSS__PROTOTYPES_H */ diff --git a/nss/rpc.c b/nss/rpc.c index 596d650..6a66686 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -2,7 +2,8 @@ rpc.c - NSS lookup functions for rpc database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -41,14 +42,26 @@ static nss_status_t read_rpcent( return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getrpcbyname_r(const char *name,struct rpcent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getrpcbyname_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getrpcbyname_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,struct rpcent *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME, name, read_rpcent(fp,result,buffer,buflen,errnop)); } -nss_status_t _nss_ldap_getrpcbynumber_r(int number,struct rpcent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getrpcbynumber_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getrpcbynumber_r( +#endif /* HAVE_NSSWITCH_H */ + int number,struct rpcent *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER, number, @@ -58,18 +71,190 @@ nss_status_t _nss_ldap_getrpcbynumber_r(int number,struct rpcent *result,char *b /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setrpcent(nss_backend_t *rpc_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setrpcent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(protoentfp); } -nss_status_t _nss_ldap_getrpcent_r(struct rpcent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getrpcent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getrpcent_r( +#endif /* HAVE_NSSWITCH_H */ + struct rpcent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(protoentfp,NSLCD_ACTION_RPC_ALL, read_rpcent(protoentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endrpcent(nss_backend_t *rpc_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endrpcent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(protoentfp); } + +#ifdef HAVE_NSSWITCH_H + +static nss_status_t _nss_ldap_getrpcbyname_r(nss_backend_t *be,void *args) +{ + struct rpcent priv_rpc; + struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; + char *name=NSS_ARGS(args)->key.name; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getrpcbyname_r(name,rpc,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %d",rpc->r_name,rpc->r_number); + if (rpc->r_aliases) + { + int i; + for (i=0; rpc->r_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,rpc->r_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getrpcbynumber_r(nss_backend_t *be,void *args) +{ + struct rpcent priv_rpc; + struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; + int number=NSS_ARGS(args)->key.number; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getrpcbynumber_r(number,rpc,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %d",rpc->r_name,rpc->r_number); + if (rpc->r_aliases) + { + int i; + for (i=0; rpc->r_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,rpc->r_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getrpcent_r(nss_backend_t *rpc_context,void *args) +{ + struct rpcent priv_rpc; + struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getrpcent_r(rpc,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %d",rpc->r_name,rpc->r_number); + if (rpc->r_aliases) + { + int i; + for (i=0; rpc->r_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,rpc->r_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_rpc_destr(nss_backend_t *rpc_context,void *args) +{ + return _nss_ldap_default_destr(rpc_context,args); +} + +static nss_backend_op_t rpc_ops[]={ + _nss_ldap_rpc_destr, + _nss_ldap_endrpcent, + _nss_ldap_setrpcent, + _nss_ldap_getrpcent_r, + _nss_ldap_getrpcbyname_r, + _nss_ldap_getrpcbynumber_r +}; + +nss_backend_t *_nss_ldap_rpc_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=rpc_ops; + be->n_ops=sizeof(rpc_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/services.c b/nss/services.c index 066acb5..4ef5e90 100644 --- a/nss/services.c +++ b/nss/services.c @@ -2,7 +2,8 @@ service.c - NSS lookup functions for services database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -37,7 +38,6 @@ static nss_status_t read_servent( size_t bufptr=0; READ_BUF_STRING(fp,result->s_name); READ_BUF_STRINGLIST(fp,result->s_aliases); - /* store port number in network byte order */ READ_TYPE(fp,tmpint32,int32_t); result->s_port=htons((uint16_t)tmpint32); READ_BUF_STRING(fp,result->s_proto); @@ -45,7 +45,13 @@ static nss_status_t read_servent( return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getservbyname_r(const char *name,const char *protocol,struct servent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getservbyname_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getservbyname_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,const char *protocol,struct servent *result, + char *buffer,size_t buflen,int *errnop) { NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME, WRITE_STRING(fp,name);WRITE_STRING(fp,protocol), @@ -53,7 +59,13 @@ nss_status_t _nss_ldap_getservbyname_r(const char *name,const char *protocol,str } -nss_status_t _nss_ldap_getservbyport_r(int port,const char *protocol,struct servent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getservbyport_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getservbyport_r( +#endif /* HAVE_NSSWITCH_H */ + int port,const char *protocol,struct servent *result, + char *buffer,size_t buflen,int *errnop) { NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER, WRITE_INT32(fp,ntohs(port));WRITE_STRING(fp,protocol), @@ -63,18 +75,181 @@ nss_status_t _nss_ldap_getservbyport_r(int port,const char *protocol,struct serv /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setservent(nss_backend_t *serv_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setservent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(protoentfp); } -nss_status_t _nss_ldap_getservent_r(struct servent *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getservent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getservent_r( +#endif /* HAVE_NSSWITCH_H */ + struct servent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL, read_servent(protoentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endservent(nss_backend_t *serv_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endservent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(protoentfp); } + +#ifdef HAVE_NSSWITCH_H + +static nss_status_t _nss_ldap_getservbyname_r(nss_backend_t *be,void *args) +{ + char *name=(char *)NSS_ARGS(args)->key.serv.serv.name; + char *protocol=NSS_ARGS(args)->key.serv.proto?(char *)NSS_ARGS(args)->key.serv.proto:""; + struct servent priv_service; + struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + status=_nss_nslcd_getservbyname_r(name,protocol,service, + buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %d/%s",name,service->s_port, + service->s_proto); + if (service->s_aliases) + { + int i; + for (i=0; service->s_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,service->s_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getservbyport_r(nss_backend_t *be,void *args) +{ + int port=NSS_ARGS(args)->key.serv.serv.port; + char *protocol=(char *)NSS_ARGS(args)->key.serv.proto; + struct servent priv_service; + struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + status=_nss_nslcd_getservbyport_r(port,protocol,service,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %d/%s",service->s_name,port, + service->s_proto); + if (service->s_aliases) + { + int i; + for (i=0; service->s_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,service->s_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getservent_r(nss_backend_t *serv_context,void *args) +{ + struct servent priv_service; + struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + status=_nss_nslcd_getservent_r(service,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + sprintf(data_ptr,"%s %d/%s",service->s_name,service->s_port, + service->s_proto); + if (service->s_aliases) + { + int i; + for (i=0; service->s_aliases[i]; i++) + { + strcat(data_ptr," "); + strcat(data_ptr,service->s_aliases[i]); + } + } + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_services_destr(nss_backend_t *serv_context,void *args) +{ + return _nss_ldap_default_destr(serv_context,args); +} + +static nss_backend_op_t services_ops[]={ + _nss_ldap_services_destr, + _nss_ldap_endservent, + _nss_ldap_setservent, + _nss_ldap_getservent_r, + _nss_ldap_getservbyname_r, + _nss_ldap_getservbyport_r +}; + +nss_backend_t *_nss_ldap_services_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=services_ops; + be->n_ops=sizeof(services_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/nss/shadow.c b/nss/shadow.c index 8132e17..4509708 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -2,7 +2,8 @@ shadow.c - NSS lookup functions for shadow database Copyright (C) 2006 West Consulting - Copyright (C) 2006, 2007, 2008 Arthur de Jong + Copyright (C) 2006, 2007, 2008, 2010 Arthur de Jong + Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -47,7 +48,13 @@ static nss_status_t read_spwd( return NSS_STATUS_SUCCESS; } -nss_status_t _nss_ldap_getspnam_r(const char *name,struct spwd *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getspnam_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getspnam_r( +#endif /* HAVE_NSSWITCH_H */ + const char *name,struct spwd *result,char *buffer, + size_t buflen,int *errnop) { NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME, name, @@ -57,18 +64,199 @@ nss_status_t _nss_ldap_getspnam_r(const char *name,struct spwd *result,char *buf /* thread-local file pointer to an ongoing request */ static __thread TFILE *spentfp; +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_setspent(nss_backend_t *be,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setspent(int UNUSED(stayopen)) +#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(spentfp); } -nss_status_t _nss_ldap_getspent_r(struct spwd *result,char *buffer,size_t buflen,int *errnop) +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_nslcd_getspent_r( +#else /* not HAVE_NSSWITCH_H */ +nss_status_t _nss_ldap_getspent_r( +#endif /* HAVE_NSSWITCH_H */ + struct spwd *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL, read_spwd(spentfp,result,buffer,buflen,errnop)); } +#ifdef HAVE_NSSWITCH_H +nss_status_t _nss_ldap_endspent(nss_backend_t *sp_context,void *args) +#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endspent(void) +#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(spentfp); } + +#ifdef HAVE_NSSWITCH_H +static nss_status_t _nss_ldap_getspnam_r(nss_backend_t *be,void *args) +{ + struct spwd priv_spwd; + struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *name=(char *)NSS_ARGS(args)->key.name; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getspnam_r(name,sp,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + char field_buf[128]; + sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); + if (sp->sp_lstchg >= 0) + sprintf(field_buf,"%d:",sp->sp_lstchg); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_min >= 0) + sprintf(field_buf,"%d:",sp->sp_min); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_max >= 0) + sprintf(field_buf,"%d:",sp->sp_max); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_warn >= 0) + sprintf(field_buf,"%d:",sp->sp_warn); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_inact >= 0) + sprintf(field_buf,"%d:",sp->sp_inact); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_expire >= 0) + sprintf(field_buf,"%d:",sp->sp_expire); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_flag >= 0) + sprintf(field_buf,"%x",sp->sp_flag); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_getspent_r(nss_backend_t *sp_context,void *args) +{ + struct spwd priv_spwd; + struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + char *data_ptr; + nss_status_t status; + if (NSS_ARGS(args)->buf.buflen < 0) + { + NSS_ARGS(args)->erange=1; + return NSS_STATUS_TRYAGAIN; + } + status=_nss_nslcd_getspent_r(sp,buffer,buflen,&errno); + if (status!=NSS_STATUS_SUCCESS) + return status; + if (!NSS_ARGS(args)->buf.result) + { + /* result==NULL, return file format */ + data_ptr=(char *)malloc(buflen); + char field_buf[128]; + sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); + if (sp->sp_lstchg >= 0) + sprintf(field_buf,"%d:",sp->sp_lstchg); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_min >= 0) + sprintf(field_buf,"%d:",sp->sp_min); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_max >= 0) + sprintf(field_buf,"%d:",sp->sp_max); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_warn >= 0) + sprintf(field_buf,"%d:",sp->sp_warn); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_inact >= 0) + sprintf(field_buf,"%d:",sp->sp_inact); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_expire >= 0) + sprintf(field_buf,"%d:",sp->sp_expire); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + if (sp->sp_flag >= 0) + sprintf(field_buf,"%x",sp->sp_flag); + else + sprintf(field_buf,":"); + strcat(data_ptr,field_buf); + strcpy(buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + } + else + { + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return status; +} + +static nss_status_t _nss_ldap_shadow_destr(nss_backend_t *sp_context,void *args) +{ + return _nss_ldap_default_destr(sp_context,args); +} + +static nss_backend_op_t shadow_ops[]={ + _nss_ldap_shadow_destr, + _nss_ldap_endspent, /* NSS_DBOP_ENDENT */ + _nss_ldap_setspent, /* NSS_DBOP_SETENT */ + _nss_ldap_getspent_r, /* NSS_DBOP_GETENT */ + _nss_ldap_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ +}; + +nss_backend_t *_nss_ldap_shadow_constr(const char *db_name, + const char *src_name,const char *cfg_args) +{ + nss_ldap_backend_t *be; + if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + return NULL; + be->ops=shadow_ops; + be->n_ops=sizeof(shadow_ops)/sizeof(nss_backend_op_t); + if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) + return NULL; + return (nss_backend_t *)be; +} + +#endif /* HAVE_NSSWITCH_H */ diff --git a/pam/Makefile.am b/pam/Makefile.am index 8bdd411..ba07a1f 100644 --- a/pam/Makefile.am +++ b/pam/Makefile.am @@ -24,20 +24,24 @@ AM_CFLAGS = -fPIC pam_ldap_so_SOURCES = ../nslcd.h ../common/nslcd-prot.h \ ../compat/attrs.h pam.c common.h -pam_ldap_so_LDFLAGS = -shared -if HAVE_VERSION_SCRIPT_FLAG -pam_ldap_so_LDFLAGS += $(VERSION_SCRIPT_FLAG)\$(srcdir)/pam_ldap.map -endif pam_ldap_so_LDADD = ../common/libtio.a ../common/libprot.a -lpam \ ../compat/libcompat.a -EXTRA_DIST = pam_ldap.map +EXTRA_DIST = pam_ldap.map exports.solaris + +if USE_NATIVE_LINKER +pam_ldap_so_LINK = @pam_ldap_so_LD@ @pam_ldap_so_LDFLAGS@ -o $@ +else +pam_ldap_so_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAG) -o $@ +endif install-exec-local: install-pam_ldap_so uninstall-local: uninstall-pam_ldap_so # install pam_ldap.so install-pam_ldap_so: pam_ldap.so - $(INSTALL_PROGRAM) -D pam_ldap.so $(DESTDIR)$(libdir)/security/pam_ldap.so + $(mkinstalldirs) $(DESTDIR)/$(PAM_SECLIB_DIR) + $(INSTALL_PROGRAM) pam_ldap.so $(DESTDIR)$(PAM_SECLIB_DIR)/$(pam_ldap_soVERSIONED) + uninstall-pam_ldap_so: - -rm -f $(DESTDIR)$(libdir)/security/pam_ldap.so + -rm -f $(DESTDIR)$(PAM_SECLIB_DIR)/$(pam_ldap_so_VERSIONED) diff --git a/pam/exports.solaris b/pam/exports.solaris new file mode 100644 index 0000000..02bcf2a --- /dev/null +++ b/pam/exports.solaris @@ -0,0 +1,16 @@ +pam_ldap.so { + + # published PAM service functions + global: + pam_sm_acct_mgmt; + pam_sm_authenticate; + pam_sm_chauthtok; + pam_sm_close_session; + pam_sm_open_session; + pam_sm_setcred; + + # everything else should not be exported + local: + *; + +}; -- cgit v1.2.3 From bebac035f67df5083daba4613c77cbc412faee86 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Sun, 3 Oct 2010 21:57:11 +0000 Subject: first attempt to split Solaris and Glibc code more and determine NSS flavour in configure script git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1236 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 50 ++++++++-- nss/aliases.c | 6 +- nss/common.c | 25 +---- nss/common.h | 33 +++---- nss/ethers.c | 130 +++++++++++++------------- nss/group.c | 216 +++++++++++++++++++++++--------------------- nss/hosts.c | 271 +++++++++++++++++++++++++------------------------------ nss/ldap-nss.h | 109 ---------------------- nss/netgroup.c | 233 +++++++++++++++++++++++++---------------------- nss/networks.c | 141 +++++++++++++++++------------ nss/passwd.c | 117 +++++++++++++++--------- nss/protocols.c | 118 ++++++++++++++---------- nss/prototypes.h | 52 +++++------ nss/rpc.c | 117 ++++++++++++++---------- nss/services.c | 118 ++++++++++++++---------- nss/shadow.c | 95 +++++++++++-------- 16 files changed, 936 insertions(+), 895 deletions(-) delete mode 100644 nss/ldap-nss.h diff --git a/configure.ac b/configure.ac index 32b4bb7..f6c65b7 100644 --- a/configure.ac +++ b/configure.ac @@ -217,11 +217,20 @@ AC_DEFINE_UNQUOTED(PAM_SECLIB_DIR,"$PAM_SECLIB_DIR",[path to PAM security librar AC_SUBST(PAM_SECLIB_DIR) # the SONAME to use for the NSS module +AC_MSG_CHECKING([name of NSS module]) AC_ARG_WITH(nss-ldap-soname, AS_HELP_STRING([--with-nss-ldap-soname=SONAME], - [name of NSS module @<:@libnss_ldap.so.2@:>@]), + [name of NSS module @<:@auto@:>@]), [ NSS_LDAP_SONAME="$with_nss_ldap_soname" ], - [ NSS_LDAP_SONAME="libnss_ldap.so.2" ]) + [ NSS_LDAP_SONAME="auto" ]) +if test "x$NSS_LDAP_SONAME" = "xauto" +then + case "$target_os" in + solaris*) NSS_LDAP_SONAME="nss_ldap.so.1" ;; + *) NSS_LDAP_SONAME="libnss_ldap.so.2" ;; + esac +fi +AC_MSG_RESULT($NSS_LDAP_SONAME) AC_DEFINE_UNQUOTED(NSS_LDAP_SONAME,"$NSS_LDAP_SONAME",[The SONAME of the NSS library module.]) AC_SUBST(NSS_LDAP_SONAME) @@ -335,15 +344,44 @@ then #include #endif]) - # check for a definition of enum nss_status - AC_CHECK_TYPES(enum nss_status,,,[ + # check for a definition of enum nss_status and nss_backend_t + AC_CHECK_TYPES([enum nss_status,nss_backend_t],,,[ #ifdef HAVE_NSS_H #include #endif #ifdef HAVE_NSS_COMMON_H #include + #endif + #ifdef HAVE_NSS_DBDEFS_H + #include + #endif + #ifdef HAVE_NSSWITCH_H + #include + #endif + #ifdef HAVE_IRS_NSS_H + #include "irs-nss.h" #endif]) + # check which NSS flavour to build + AC_MSG_CHECKING([which NSS flavour to build]) + AC_ARG_WITH(nss-flavour, + AS_HELP_STRING([--with-nss-flavour=auto|glibc|solaris], + [the libc flavour to build our NSS module for @<:@auto@:>@]),, + with_nss_flavour=auto) + if test "x$with_nss_flavour" = "xauto" + then + # do the guessing game + case "$target_os" in + solaris*) with_nss_flavour=solaris ;; + *) with_nss_flavour=glibc ;; + esac + fi + AC_MSG_RESULT($with_nss_flavour) + case "$with_nss_flavour" in + glibc) AC_DEFINE(NSS_FLAVOUR_GLIBC,1,[Whether to use the Glibc NSS interface flavour.]) ;; + solaris) AC_DEFINE(NSS_FLAVOUR_SOLARIS,1,[Whether to use the Solaris NSS interface flavour.]) ;; + esac + # check which module source files to use AC_MSG_CHECKING([which NSS maps to build]) if test "x$with_nss_ldap_maps" = "xall" @@ -616,23 +654,19 @@ solaris*) if test "$ac_cv_prog_gcc" = yes; then fi nss_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" pam_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" - NSS_LDAP_SONAME="nss_ldap.so.1" pam_ldap_so_VERSIONED="pam_ldap.so.1" TARGET_OS="SUNOS" ;; linux*) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" - NSS_LDAP_SONAME="libnss_ldap.so.2" pam_ldap_so_VERSIONED="pam_ldap.so" TARGET_OS="LINUX" ;; *) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" - NSS_LDAP_SONAME="nss_ldap.so.1" pam_ldap_so_VERSIONED="pam_ldap.so" ;; esac AC_SUBST(nss_ldap_so_LD) AC_SUBST(nss_ldap_so_LDFLAGS) -AC_SUBST(NSS_LDAP_SONAME) AC_SUBST(pam_ldap_so_LD) AC_SUBST(pam_ldap_so_LDFLAGS) diff --git a/nss/aliases.c b/nss/aliases.c index 042132a..4587f72 100644 --- a/nss/aliases.c +++ b/nss/aliases.c @@ -50,9 +50,10 @@ nss_status_t _nss_ldap_getaliasbyname_r( const char *name,struct aliasent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_ALIAS_BYNAME, + NSS_BYNAME(NSLCD_ACTION_ALIAS_BYNAME,buffer,buflen, name, read_aliasent(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ @@ -65,8 +66,9 @@ nss_status_t _nss_ldap_setaliasent(void) nss_status_t _nss_ldap_getaliasent_r(struct aliasent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(aliasentfp,NSLCD_ACTION_ALIAS_ALL, + NSS_GETENT(aliasentfp,NSLCD_ACTION_ALIAS_ALL,buffer,buflen, read_aliasent(aliasentfp,result,buffer,buflen,errnop)); + return retv; } nss_status_t _nss_ldap_endaliasent(void) diff --git a/nss/common.c b/nss/common.c index 34c41fb..c3c0616 100644 --- a/nss/common.c +++ b/nss/common.c @@ -44,29 +44,8 @@ /* flag used to disable NSS lookups using this module */ int _nss_ldap_enablelookups=1; -#ifdef HAVE_NSSWITCH_H +#ifdef NSS_FLAVOUR_SOLARIS /* Adapted from PADL */ -/* - *Default destructor. - *The entry point for this function is the destructor in the dispatch - *table for the switch. Thus,it's safe to grab the mutex from this - *function. - */ -nss_status_t _nss_ldap_default_destr(nss_backend_t *be,void *args) -{ - /* Ditch the backend. */ - free(be); - return NSS_STATUS_SUCCESS; -} - -/* - *This is the default "constructor" which gets called from each - *constructor,in the NSS dispatch table. - */ -nss_status_t _nss_ldap_default_constr(nss_ldap_backend_t *be) -{ - return NSS_STATUS_SUCCESS; -} /* add a nested netgroup or group to the namelist */ nss_status_t _nss_ldap_namelist_push(struct name_list **head,const char *name) @@ -129,4 +108,4 @@ int _nss_ldap_namelist_find(struct name_list *head,const char *netgroup) return found; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/common.h b/nss/common.h index c2d429b..93c7e2d 100644 --- a/nss/common.h +++ b/nss/common.h @@ -31,18 +31,17 @@ #include "compat/attrs.h" #include "compat/nss_compat.h" -#ifdef HAVE_NSSWITCH_H -#include "ldap-nss.h" -#endif /* HAVE_NSSWITCH_H */ - -#ifdef HAVE_NSSWITCH_H /* Adapted from PADL */ /* Routines for managing namelists */ +struct name_list +{ + char *name; + struct name_list *next; +}; nss_status_t _nss_ldap_namelist_push(struct name_list **head,const char *name); void _nss_ldap_namelist_pop(struct name_list **head); int _nss_ldap_namelist_find(struct name_list *head,const char *netgroup); void _nss_ldap_namelist_destroy(struct name_list **head); -#endif /* HAVE_NSSWITCH_H */ /* These are macros for handling read and write problems, they are NSS specific due to the return code so are defined here. They @@ -93,7 +92,7 @@ void _nss_ldap_namelist_destroy(struct name_list **head); the result structure, the user buffer with length and the errno to return. This macro should be called through some of the customized ones below. */ -#define NSS_BYGEN(action,writefn,readfn) \ +#define NSS_BYGEN(action,buffer,buflen,writefn,readfn) \ TFILE *fp; \ int32_t tmpint32; \ nss_status_t retv; \ @@ -112,23 +111,22 @@ void _nss_ldap_namelist_destroy(struct name_list **head); retv=readfn; \ /* close socket and we're done */ \ if ((retv==NSS_STATUS_SUCCESS)||(retv==NSS_STATUS_TRYAGAIN)) \ - (void)tio_close(fp); \ - return retv; + (void)tio_close(fp); /* This macro can be used to generate a get..byname() function body. */ -#define NSS_BYNAME(action,name,readfn) \ - NSS_BYGEN(action,WRITE_STRING(fp,name),readfn) +#define NSS_BYNAME(action,buffer,buflen,name,readfn) \ + NSS_BYGEN(action,buffer,buflen,WRITE_STRING(fp,name),readfn) /* This macro can be used to generate a get..by..() function body where the value that is the key has the specified type. */ -#define NSS_BYTYPE(action,val,type,readfn) \ - NSS_BYGEN(action,WRITE_TYPE(fp,val,type),readfn) +#define NSS_BYTYPE(action,buffer,buflen,val,type,readfn) \ + NSS_BYGEN(action,buffer,buflen,WRITE_TYPE(fp,val,type),readfn) /* This macro can be used to generate a get..by..() function body where the value should be passed as an int32_t. */ -#define NSS_BYINT32(action,val,readfn) \ - NSS_BYGEN(action,WRITE_INT32(fp,val),readfn) +#define NSS_BYINT32(action,buffer,buflen,val,readfn) \ + NSS_BYGEN(action,buffer,buflen,WRITE_INT32(fp,val),readfn) /* This macro generates a simple setent() function body. This closes any open streams so that NSS_GETENT() can open a new file. */ @@ -145,7 +143,7 @@ void _nss_ldap_namelist_destroy(struct name_list **head); /* This macro generates a getent() function body. If the stream is not yet open, a new one is opened, a request is written and a check is done for a response header. A single entry is read with the readfn() function. */ -#define NSS_GETENT(fp,action,readfn) \ +#define NSS_GETENT(fp,action,buffer,buflen,readfn) \ int32_t tmpint32; \ nss_status_t retv; \ if (!_nss_ldap_enablelookups) \ @@ -188,8 +186,7 @@ void _nss_ldap_namelist_destroy(struct name_list **head); } \ } \ else if (retv!=NSS_STATUS_SUCCESS) \ - fp=NULL; /* file should be closed by now */ \ - return retv; + fp=NULL; /* file should be closed by now */ /* This macro generates a endent() function body. This just closes the stream. */ diff --git a/nss/ethers.c b/nss/ethers.c index 9f5a3de..1fd7756 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -41,106 +41,95 @@ static nss_status_t read_etherent( return NSS_STATUS_SUCCESS; } +#ifdef NSS_FLAVOUR_GLIBC + /* map a hostname to the corresponding ethernet address */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_gethostton_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostton_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,struct etherent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME, + NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME,buffer,buflen, name, read_etherent(fp,result,buffer,buflen,errnop)); + return retv; } /* map an ethernet address to the corresponding hostname */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getntohost_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getntohost_r( -#endif /* HAVE_NSSWITCH_H */ const struct ether_addr *addr,struct etherent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER, + NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER,buffer,buflen, *addr,uint8_t[6], read_etherent(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *etherentfp; -#ifdef HAVE_NSSWITCH_H -static nss_status_t _nss_ldap_setetherent( - nss_backend_t *be,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setetherent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(etherentfp); } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getetherent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getetherent_r( -#endif /* HAVE_NSSWITCH_H */ struct etherent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(etherentfp,NSLCD_ACTION_ETHER_ALL, + NSS_GETENT(etherentfp,NSLCD_ACTION_ETHER_ALL,buffer,buflen, read_etherent(etherentfp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endetherent(nss_backend_t *be,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endetherent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(etherentfp); } -#ifdef HAVE_NSSWITCH_H +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +#define NSS_BUFLEN_ETHERS 1024 -/* Solaris wrapper around _nss_nslcd_gethsotton_r */ -static nss_status_t _nss_ldap_gethostton_r(nss_backend_t *be,void *args) +#define errnop &errno + +/* map a hostname to the corresponding ethernet address */ +static nss_status_t _xnss_ldap_gethostton_r(nss_backend_t *UNUSED(be),void *args) { struct etherent result; char buffer[NSS_BUFLEN_ETHERS]; - nss_status_t status; - char *name=(char *)(NSS_ARGS(args)->key.name); - status=_nss_nslcd_gethostton_r(name,&result,buffer,sizeof(buffer),&errno); - if (status==NSS_STATUS_SUCCESS) + const char *name=(NSS_ARGS(args)->key.name); + NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME,buffer,sizeof(buffer), + name, + read_etherent(fp,&result,buffer,sizeof(buffer),&errno)); + if (retv==NSS_STATUS_SUCCESS) { - /* if (NSS_ARGS(args)->buf.buffer!=NULL) { */ if (NSS_ARGS(args)->buf.result==NULL) { strcpy(NSS_ARGS(args)->buf.buffer,ether_ntoa(&result.e_addr)); NSS_ARGS(args)->buf.buflen=strlen(NSS_ARGS(args)->buf.buffer); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - return status; + return retv; } memcpy(NSS_ARGS(args)->buf.result,&result.e_addr,sizeof(result.e_addr)); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; } - return status; + return retv; } -/* Solaris wrapper around _nss_nslcd_getntohost_r */ -static nss_status_t _nss_ldap_getntohost_r(nss_backend_t *be,void *args) +/* map an ethernet address to the corresponding hostname */ +static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t *UNUSED(be),void *args) { struct etherent result; - struct ether_addr *addr; + struct ether_addr *addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); char buffer[NSS_BUFLEN_ETHERS]; - size_t buflen=sizeof(buffer); - nss_status_t status; - addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); - status=_nss_nslcd_getntohost_r(addr,&result,buffer,buflen,&errno); - if (status==NSS_STATUS_SUCCESS) + NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER,buffer,sizeof(buffer), + *addr,uint8_t[6], + read_etherent(fp,&result,buffer,sizeof(buffer),&errno)); + if (retv==NSS_STATUS_SUCCESS) { if (NSS_ARGS(args)->buf.buffer!=NULL) { @@ -151,61 +140,68 @@ static nss_status_t _nss_ldap_getntohost_r(nss_backend_t *be,void *args) sprintf(NSS_ARGS(args)->buf.buffer,"%s %s",ether_ntoa(addr),result.e_name); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - return status; + return retv; } memcpy(NSS_ARGS(args)->buf.buffer,result.e_name,strlen(result.e_name)+1); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->buf.buflen=strlen(result.e_name); + NSS_ARGS(args)->buf.buflen=strlen(result.e_name); /* ?? */ } else { NSS_ARGS(args)->returnval=NULL; } - return status; + return retv; +} + +static nss_status_t _xnss_ldap_setetherent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(etherentfp); } -static nss_status_t _nss_ldap_getetherent_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_getetherent_r(nss_backend_t *UNUSED(be),void *args) { /* TODO: cns3 uses struct ether,verify */ struct etherent result; - char *buffer; - size_t buflen; - int errnop; - nss_status_t status; - buffer=NSS_ARGS(args)->buf.buffer; - buflen=NSS_ARGS(args)->buf.buflen; - status=_nss_nslcd_getetherent_r(&result,buffer,buflen,&errnop); - if (status==NSS_STATUS_SUCCESS) + char *buffer=NSS_ARGS(args)->buf.buffer; + size_t buflen=NSS_ARGS(args)->buf.buflen; + NSS_GETENT(etherentfp,NSLCD_ACTION_ETHER_ALL,buffer,buflen, + read_etherent(etherentfp,&result,buffer,buflen,&errno)); + if (retv==NSS_STATUS_SUCCESS) { memcpy(NSS_ARGS(args)->buf.result,&result.e_addr,sizeof(result.e_addr)); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; } else NSS_ARGS(args)->returnval=NULL; - return status; + return retv; } -static nss_status_t _nss_ldap_ethers_destr(nss_backend_t *ether_context,void *args) +static nss_status_t _xnss_ldap_endetherent(nss_backend_t *UNUSED(be),void *UNUSED(args)) { - return _nss_ldap_default_destr(ether_context,args); + NSS_ENDENT(etherentfp); +} + +static nss_status_t _xnss_ldap_ethers_destr(nss_backend_t *be,void *UNUSED(args)) +{ + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t ethers_ops[]={ - _nss_ldap_ethers_destr, - _nss_ldap_gethostton_r, - _nss_ldap_getntohost_r + _xnss_ldap_ethers_destr, + _xnss_ldap_gethostton_r, + _xnss_ldap_getntohost_r }; -nss_backend_t *_nss_ldap_ethers_constr(const char *db_name,const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_ethers_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=ethers_ops; be->n_ops=sizeof(ethers_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; - return (nss_backend_t *)be; + return be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/group.c b/nss/group.c index dadac67..2e3013d 100644 --- a/nss/group.c +++ b/nss/group.c @@ -48,9 +48,7 @@ static nss_status_t read_group( gids of these groups to the list */ static nss_status_t read_gids( TFILE *fp,gid_t skipgroup,long int *start, -#ifndef HAVE_NSSWITCH_H long int *size, -#endif /* HAVE_NSSWITCH_H */ gid_t **groupsp,long int limit,int *errnop) { int32_t res=(int32_t)NSLCD_RESULT_BEGIN; @@ -76,7 +74,7 @@ static nss_status_t read_gids( if ( (limit>0) && (*start>=limit) ) return NSS_STATUS_TRYAGAIN; /* check if our buffer is large enough */ -#ifndef HAVE_NSSWITCH_H +#ifdef NSS_FLAVOUR_GLIBC if ((*start)>=(*size)) { /* for some reason Glibc expects us to grow the array (completely @@ -92,8 +90,8 @@ static nss_status_t read_gids( *groupsp=newgroups; *size=newsize; } +#endif /* NSS_FLAVOUR_GLIBC */ /* add gid to list */ -#endif /* HAVE_NSSWITCH_H */ (*groupsp)[(*start)++]=gid; } /* read next response code @@ -105,30 +103,47 @@ static nss_status_t read_gids( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getgrnam_r( -#else /* not HAVE_NSSWITCH_H */ +#ifdef NSS_FLAVOUR_GLIBC + nss_status_t _nss_ldap_getgrnam_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,struct group *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME, + NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME,buffer,buflen, name, read_group(fp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getgrgid_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getgrgid_r( -#endif /* HAVE_NSSWITCH_H */ gid_t gid,struct group *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID, + NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID,buffer,buflen, gid,gid_t, read_group(fp,result,buffer,buflen,errnop)); + return retv; +} + +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *grentfp; + +nss_status_t _nss_ldap_setgrent(int UNUSED(stayopen)) +{ + NSS_SETENT(grentfp); +} + +nss_status_t _nss_ldap_getgrent_r( + struct group *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL,buffer,buflen, + read_group(grentfp,result,buffer,buflen,errnop)); + return retv; +} + +nss_status_t _nss_ldap_endgrent(void) +{ + NSS_ENDENT(grentfp); } /* this function returns a list of groups, documentation for the @@ -145,77 +160,38 @@ nss_status_t _nss_ldap_getgrgid_r( */ nss_status_t _nss_ldap_initgroups_dyn( const char *user,gid_t skipgroup,long int *start, -#ifndef HAVE_NSSWITCH_H long int *size, -#endif /* HAVE_NSSWITCH_H */ gid_t **groupsp,long int limit,int *errnop) { -#ifdef HAVE_NSSWITCH_H - long int buffer_size=limit; - long int *size=&buffer_size; -#endif /* HAVE_NSSWITCH_H */ -/* temporarily map the buffer and buflen names so the check in NSS_BYNAME - for validity of the buffer works (renaming the parameters may cause - confusion) */ -#define buffer groupsp -#define buflen *size -#ifdef HAVE_NSSWITCH_H - NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER, - user, - read_gids(fp,skipgroup,start,groupsp,limit,errnop)); -#else /* not HAVE_NSSWITCH_H */ - NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER, + NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER,groupsp,*size, user, read_gids(fp,skipgroup,start,size,groupsp,limit,errnop)); -#endif /* not HAVE_NSSWITCH_H */ -#undef buffer -#undef buflen + return retv; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *grentfp; - -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setgrent(nss_backend_t *gr_context,void *args) -#else /* not HAVE_NSSWITCH_H */ -nss_status_t _nss_ldap_setgrent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ -{ - NSS_SETENT(grentfp); -} +#endif /* NSS_FLAVOUR_GLIBC */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getgrent_r( -#else /* not HAVE_NSSWITCH_H */ -nss_status_t _nss_ldap_getgrent_r( -#endif /* HAVE_NSSWITCH_H */ - struct group *result,char *buffer,size_t buflen,int *errnop) -{ - NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL, - read_group(grentfp,result,buffer,buflen,errnop)); -} +#ifdef NSS_FLAVOUR_SOLARIS -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endgrent(nss_backend_t *gr_context,void *args) -#else /* not HAVE_NSSWITCH_H */ -nss_status_t _nss_ldap_endgrent(void) -#endif /* HAVE_NSSWITCH_H */ +static nss_status_t _nss_nslcd_getgrnam_r( + const char *name,struct group *result,char *buffer, + size_t buflen,int *errnop) { - NSS_ENDENT(grentfp); + NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME,buffer,buflen, + name, + read_group(fp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H - -static nss_status_t _nss_ldap_getgrnam_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_getgrnam_r(nss_backend_t *UNUSED(be),void *args) { - char *name=(char *)NSS_ARGS(args)->key.name; struct group priv_gr; struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; char *data_ptr; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; nss_status_t status; - status=_nss_nslcd_getgrnam_r(name,gr,buffer,buflen,&errno); + status=_nss_nslcd_getgrnam_r(NSS_ARGS(args)->key.name,gr,buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; if (!NSS_ARGS(args)->buf.result) @@ -245,7 +221,17 @@ static nss_status_t _nss_ldap_getgrnam_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getgrgid_r(nss_backend_t *be,void *args) +static nss_status_t _nss_nslcd_getgrgid_r( + gid_t gid,struct group *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID,buffer,buflen, + gid,gid_t, + read_group(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t *UNUSED(be),void *args) { gid_t gid=NSS_ARGS(args)->key.gid; struct group priv_gr; @@ -284,7 +270,20 @@ static nss_status_t _nss_ldap_getgrgid_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getgrent_r(nss_backend_t *gr_context,void *args) +static nss_status_t _xnss_ldap_setgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(grentfp); +} + +static nss_status_t _nss_nslcd_getgrent_r( + struct group *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL,buffer,buflen, + read_group(grentfp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getgrent_r(nss_backend_t *UNUSED(be),void *args) { struct group priv_gr; struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; @@ -292,12 +291,9 @@ static nss_status_t _nss_ldap_getgrent_r(nss_backend_t *gr_context,void *args) char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; nss_status_t status; - status=_nss_nslcd_getgrent_r(gr,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) return status; - if (!NSS_ARGS(args)->buf.result) { /* result==NULL, return file format */ @@ -315,7 +311,6 @@ static nss_status_t _nss_ldap_getgrent_r(nss_backend_t *gr_context,void *args) } strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); } @@ -326,58 +321,77 @@ static nss_status_t _nss_ldap_getgrent_r(nss_backend_t *gr_context,void *args) return status; } -static nss_status_t _nss_ldap_group_destr(nss_backend_t *gr_context,void *args) +static nss_status_t _xnss_ldap_endgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) { - return _nss_ldap_default_destr(gr_context,args); + NSS_ENDENT(grentfp); } -static nss_status_t _nss_ldap_getgroupsbymember_r(nss_backend_t *gr_context,void *args) +/* this function returns a list of groups, documentation for the + interface is scarce (any pointers are welcome) but this is + what is assumed the parameters mean: + + user IN - the user name to find groups for + skipgroup IN - a group to not include in the list + *start IN/OUT - where to write in the array, is incremented + **groupsp IN/OUT - pointer to the array of returned groupids + limit IN - the maxium size of the array + *errnop OUT - for returning errno +*/ +static nss_status_t _xnss_ldap_initgroups_dyn( + const char *user,gid_t skipgroup,long int *start, + gid_t **groupsp,long int limit,int *errnop) +{ + NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER,groupsp,limit, + user, + read_gids(fp,skipgroup,start,&limit,groupsp,limit,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getgroupsbymember_r(nss_backend_t *UNUSED(be),void *args) { struct nss_groupsbymem *argp=(struct nss_groupsbymem *)args; - char *user=(char *)argp->username; nss_status_t status; - long int limit=(long int) argp->maxgids; - long int start=(long int) argp->numgids; + long int limit=(long int)argp->maxgids; + long int start=(long int)argp->numgids; gid_t skipgroup; - int i; - - if (start > 0) + if (start>0) skipgroup=argp->gid_array[0]; - - status=_nss_ldap_initgroups_dyn( - user, - (start > 0)?skipgroup:-1, + status=_xnss_ldap_initgroups_dyn( + argp->username, + (start>0)?skipgroup:(gid_t)-1, &start, (gid_t **)&argp->gid_array, limit, &errno); argp->numgids=(int)start; - return status; } +static nss_status_t _xnss_ldap_group_destr(nss_backend_t *be,void *UNUSED(args)) +{ + free(be); + return NSS_STATUS_SUCCESS; +} + static nss_backend_op_t group_ops[]={ - _nss_ldap_group_destr, - _nss_ldap_endgrent, - _nss_ldap_setgrent, - _nss_ldap_getgrent_r, - _nss_ldap_getgrnam_r, - _nss_ldap_getgrgid_r, - _nss_ldap_getgroupsbymember_r + _xnss_ldap_group_destr, + _xnss_ldap_endgrent, + _xnss_ldap_setgrent, + _xnss_ldap_getgrent_r, + _xnss_ldap_getgrnam_r, + _xnss_ldap_getgrgid_r, + _xnss_ldap_getgroupsbymember_r }; -nss_backend_t *_nss_ldap_group_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_group_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=group_ops; be->n_ops=sizeof(group_ops)/sizeof(nss_backend_op_t); - /* a NOOP at the moment */ - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/hosts.c b/nss/hosts.c index 404dc5d..f2edf22 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -25,6 +25,9 @@ #include #include +#include +#include +#include #include "prototypes.h" #include "common.h" @@ -162,6 +165,14 @@ static nss_status_t read_hostent_nextonempty( return NSS_STATUS_SUCCESS; } +/* write an address value */ +#define WRITE_ADDRESS(fp,af,len,addr) \ + WRITE_INT32(fp,af); \ + WRITE_INT32(fp,len); \ + WRITE(fp,addr,len); + +#ifdef NSS_FLAVOUR_GLIBC + /* this function looks up a single host entry and returns all the addresses associated with the host in a single address familiy name - IN - hostname to lookup @@ -173,93 +184,20 @@ nss_status_t _nss_ldap_gethostbyname2_r( const char *name,int af,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME, + NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME,buffer,buflen, name, read_hostent_erronempty(fp,af,result,buffer,buflen,errnop,h_errnop)); + return retv; } /* this function just calls the gethostbyname2() variant with the address familiy set */ -#ifdef HAVE_NSSWITCH_H -static nss_status_t _nss_ldap_gethostbyname_r(nss_backend_t *be,void *args) -{ - struct hostent priv_host; - struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; - char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - int h_errno; - nss_status_t status; - status=_nss_ldap_gethostbyname2_r( - NSS_ARGS(args)->key.name, - AF_INET, - host, - NSS_ARGS(args)->buf.buffer, - NSS_ARGS(args)->buf.buflen, - &errno,&h_errno); - - if (status!=NSS_STATUS_SUCCESS) - { - NSS_ARGS(args)->h_errno=h_errno; - return status; - } - - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - if (host->h_addr_list) - { - int i; - struct in_addr in; - (void)memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); - sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); - if (host->h_aliases) - { - int j; - for (j=0; host->h_aliases[j]; j++) - { - strcat(data_ptr," "); - strcat(data_ptr,host->h_aliases[j]); - } - } - for (i=1; host->h_addr_list[i]; i++) - { - (void) memcpy(&in.s_addr,host->h_addr_list[i],sizeof(in.s_addr)); - strcat(data_ptr,"\n"); - strcat(data_ptr,inet_ntoa(in)); - strcat(data_ptr," "); - strcat(data_ptr,host->h_name); - /* TODO: aliases only supplied to the first address */ - /* need review */ - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* NSS_ARGS(args)->buf.result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - NSS_ARGS(args)->h_errno=h_errno; - return status; -} -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostbyname_r( const char *name,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { return _nss_ldap_gethostbyname2_r(name,AF_INET,result,buffer,buflen,errnop,h_errnop); } -#endif /* HAVE_NSSWITCH_H */ - -/* write an address value */ -#define WRITE_ADDRESS(fp,af,len,addr) \ - WRITE_INT32(fp,af); \ - WRITE_INT32(fp,len); \ - WRITE(fp,addr,len); /* this function looks up a single host entry and returns all the addresses associated with the host in a single address familiy @@ -269,88 +207,66 @@ nss_status_t _nss_ldap_gethostbyname_r( result - OUT - entry found buffer,buflen - OUT - buffer to store allocated stuff on errnop,h_errnop - OUT - for reporting errors */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_gethostbyaddr_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostbyaddr_r( -#endif /* HAVE_NSSWITCH_H */ const void *addr,socklen_t len,int af,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR, + NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR,buffer,buflen, WRITE_ADDRESS(fp,af,len,addr), read_hostent_erronempty(fp,af,result,buffer,buflen,errnop,h_errnop)) + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *hostentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_sethostent(nss_backend_t *hosts_context,void *fakeargs) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_sethostent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(hostentfp); } /* this function only returns addresses of the AF_INET address family */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_gethostent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_gethostent_r( -#endif /* HAVE_NSSWITCH_H */ struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL, + NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL,buffer,buflen, read_hostent_nextonempty(hostentfp,AF_INET,result,buffer,buflen,errnop,h_errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endhostent(nss_backend_t *hosts_context,void *fakeargs ) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endhostent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(hostentfp); } -#ifdef HAVE_NSSWITCH_H +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_ldap_gethostbyaddr_r(nss_backend_t *be,void *args) +/* hack to set the correct errno and h_errno */ +#define errnop &errno +#define h_errnop &(NSS_ARGS(args)->h_errno) + +static nss_status_t _xnss_ldap_gethostbyname_r(nss_backend_t *UNUSED(be),void *args) { - struct in_addr iaddr; - int type; struct hostent priv_host; struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - int h_errno; - nss_status_t status; - status=_nss_nslcd_gethostbyaddr_r( - NSS_ARGS(args)->key.hostaddr.addr, - NSS_ARGS(args)->key.hostaddr.len, - NSS_ARGS(args)->key.hostaddr.type, - host, - NSS_ARGS(args)->buf.buffer, - NSS_ARGS(args)->buf.buflen, - &errno,&h_errno); - if (status!=NSS_STATUS_SUCCESS) - { - NSS_ARGS(args)->h_errno=h_errno; - return status; - } + NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen, + NSS_ARGS(args)->key.name, + read_hostent_erronempty(fp,AF_INET,host,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,h_errnop)); + if (retv!=NSS_STATUS_SUCCESS) + return retv; if (!NSS_ARGS(args)->buf.result) { /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); + data_ptr=(char *)malloc(NSS_ARGS(args)->buf.buflen); if (host->h_addr_list) { int i; struct in_addr in; - (void) memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); + (void)memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); if (host->h_aliases) { @@ -372,7 +288,7 @@ static nss_status_t _nss_ldap_gethostbyaddr_r(nss_backend_t *be,void *args) /* need review */ } } - strcpy(buffer,data_ptr); + strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); free(data_ptr); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); @@ -381,31 +297,83 @@ static nss_status_t _nss_ldap_gethostbyaddr_r(nss_backend_t *be,void *args) { /* NSS_ARGS(args)->buf.result!=NULL */ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; } - NSS_ARGS(args)->h_errno=h_errno; - return status; + return retv; } -/* this function only returns addresses of the AF_INET address family */ -static nss_status_t _nss_ldap_gethostent_r(nss_backend_t *hosts_context,void *args) +static nss_status_t _xnss_ldap_gethostbyaddr_r(nss_backend_t *UNUSED(be),void *args) { struct hostent priv_host; - struct hostent *host=NSS_ARGS(args)->buf.result ? - NSS_ARGS(args)->buf.result : &priv_host; + struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - int h_errno; - nss_status_t status; - status=_nss_nslcd_gethostent_r(host,buffer,buflen,&errno,&h_errno); - if (status!=NSS_STATUS_SUCCESS) + NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen, + WRITE_ADDRESS(fp,NSS_ARGS(args)->key.hostaddr.type,NSS_ARGS(args)->key.hostaddr.len,NSS_ARGS(args)->key.hostaddr.addr), + read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,host,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,h_errnop)) + + + if (retv!=NSS_STATUS_SUCCESS) + return retv; + if (!NSS_ARGS(args)->buf.result) { - NSS_ARGS(args)->h_errno=h_errno; - return status; + /* result==NULL, return file format */ + data_ptr=(char *)malloc(NSS_ARGS(args)->buf.buflen); + if (host->h_addr_list) + { + int i; + struct in_addr in; + (void)memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); + sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); + if (host->h_aliases) + { + int j; + for (j=0;host->h_aliases[j];j++) + { + strcat(data_ptr," "); + strcat(data_ptr,host->h_aliases[j]); + } + } + for (i=1;host->h_addr_list[i];i++) + { + (void)memcpy(&in.s_addr,host->h_addr_list[i],sizeof(in.s_addr)); + strcat(data_ptr,"\n"); + strcat(data_ptr,inet_ntoa(in)); + strcat(data_ptr," "); + strcat(data_ptr,host->h_name); + /* TODO: aliases only supplied to the first address */ + /* need review */ + } + } + strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); + free(data_ptr); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); } + else + { /* NSS_ARGS(args)->buf.result!=NULL */ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + } + return retv; +} + + +static nss_status_t _xnss_ldap_sethostent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(hostentfp); +} + +/* this function only returns addresses of the AF_INET address family */ +static nss_status_t _xnss_ldap_gethostent_r(nss_backend_t *UNUSED(be),void *args) +{ + struct hostent priv_host; + struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; + char *data_ptr; + NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen, + read_hostent_nextonempty(hostentfp,AF_INET,host,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,h_errnop)); + if (retv!=NSS_STATUS_SUCCESS) + return retv; if (!NSS_ARGS(args)->buf.result) { /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); + data_ptr=(char *)malloc(NSS_ARGS(args)->buf.buflen); if (host->h_addr_list) { int i; @@ -429,7 +397,7 @@ static nss_status_t _nss_ldap_gethostent_r(nss_backend_t *hosts_context,void *ar /* need review */ } } - strcpy(buffer,data_ptr); + strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); free(data_ptr); NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); @@ -438,35 +406,38 @@ static nss_status_t _nss_ldap_gethostent_r(nss_backend_t *hosts_context,void *ar { /* NSS_ARGS(args)->buf.result!=NULL */ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; } - NSS_ARGS(args)->h_errno=h_errno; - return status; + return retv; } -static nss_status_t _nss_ldap_hosts_destr(nss_backend_t *hosts_context,void *args) +static nss_status_t _xnss_ldap_endhostent(nss_backend_t *UNUSED(be),void *UNUSED(args)) { - return _nss_ldap_default_destr(hosts_context,args); + NSS_ENDENT(hostentfp); +} + +static nss_status_t _xnss_ldap_hosts_destr(nss_backend_t *be,void *UNUSED(args)) +{ + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t host_ops[]={ - _nss_ldap_hosts_destr, - _nss_ldap_endhostent, - _nss_ldap_sethostent, - _nss_ldap_gethostent_r, - _nss_ldap_gethostbyname_r, - _nss_ldap_gethostbyaddr_r + _xnss_ldap_hosts_destr, + _xnss_ldap_endhostent, + _xnss_ldap_sethostent, + _xnss_ldap_gethostent_r, + _xnss_ldap_gethostbyname_r, + _xnss_ldap_gethostbyaddr_r }; -nss_backend_t *_nss_ldap_hosts_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_hosts_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=host_ops; be->n_ops=sizeof(host_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/ldap-nss.h b/nss/ldap-nss.h deleted file mode 100644 index 369f165..0000000 --- a/nss/ldap-nss.h +++ /dev/null @@ -1,109 +0,0 @@ -/* - ldap-nss.h - compatibility definitions - Parts of this file were part of the nss_ldap library (as ldap-nss.h) - which has been forked into the nss-pam-ldapd library. - - Copyright (C) 1997-2005 Luke Howard - Copyright (C) 2010 Arthur de Jong - Copyright (C) 2010 Symas Corporation - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301 USA -*/ - -#ifndef _LDAP_NSS_LDAP_LDAP_NSS_H -#define _LDAP_NSS_LDAP_LDAP_NSS_H - -/* from ldap-parse.h */ -#define NSS_ARGS(args)((nss_XbyY_args_t *)args) - -#ifndef NSS_BUFSIZ -#define NSS_BUFSIZ 1024 -#endif - -#ifndef HAVE_NSSWITCH_H -#define NSS_BUFLEN_NETGROUP(MAXHOSTNAMELEN * 2 + LOGNAME_MAX + 3) -#define NSS_BUFLEN_ETHERS NSS_BUFSIZ -#endif /* HAVE_NSSWITCH_H */ - -#ifdef HAVE_NSSWITCH_H -/* - *thread specific context: result chain,and state data - */ -struct ent_context -{ - void *first_entry; - void *curr_entry; -}; - -typedef struct ent_context ent_context_t; - -#endif /* HAVE_NSSWITCH_H */ - -struct name_list -{ - char *name; - struct name_list *next; -}; - -#ifdef HAVE_NSSWITCH_H - -struct nss_ldap_backend -{ - nss_backend_op_t *ops; - int n_ops; - ent_context_t *state; -}; - -typedef struct nss_ldap_backend nss_ldap_backend_t; - -struct nss_ldap_netgr_backend -{ - nss_backend_op_t *ops; - int n_ops; - ent_context_t *state; - struct name_list *known_groups; /* netgroups seen,for loop detection */ - struct name_list *needed_groups; /* nested netgroups to chase */ -}; - -typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; - -#elif defined(HAVE_IRS_H) - -struct nss_ldap_netgr_backend -{ - char buffer[NSS_BUFLEN_NETGROUP]; - ent_context_t *state; - struct name_list *known_groups; /* netgroups seen,for loop detection */ - struct name_list *needed_groups; /* nested netgroups to chase */ -}; - -typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; - -#endif /* HAVE_NSSWITCH_H */ - -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_default_destr(nss_backend_t *,void *); -#endif - -/* - *context management routines. - *_nss_ldap_default_constr() is called once in the constructor - */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_default_constr(nss_ldap_backend_t *be); -#endif - -#endif /* _LDAP_NSS_LDAP_LDAP_NSS_H */ diff --git a/nss/netgroup.c b/nss/netgroup.c index 7fec5fc..fe3d928 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -31,51 +31,6 @@ #include "common.h" #include "compat/attrs.h" -#ifdef HAVE_NSSWITCH_H -#include -#include -#include -#endif /* HAVE_NSSWITCH_H */ - - -#ifdef HAVE_NSSWITCH_H - -static nss_backend_op_t netgroup_ops[]; -static nss_status_t _nss_ldap_netgroup_destr(nss_backend_t *_ngbe,void *args); - -/* find a netgroup that has not been traversed */ -static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) -{ - nss_status_t status; - char *group=NULL; - int found=0; - if (!ngbe->needed_groups) - { - /* exhausted all netgroups */ - return NULL; - } - while (ngbe->needed_groups&&!found) - { - if (_nss_ldap_namelist_find(ngbe->known_groups, - ngbe->needed_groups->name)) - { - /* netgroup seen before,ignore it */ - _nss_ldap_namelist_pop(&ngbe->needed_groups); - } - else - found=1; - } - if (found) - { - group=strdup(ngbe->needed_groups->name); - status=_nss_ldap_namelist_push(&ngbe->known_groups, - ngbe->needed_groups->name); - _nss_ldap_namelist_pop(&ngbe->needed_groups); - } - return group; -} -#endif /* HAVE_NSSWITCH_H */ - /* we redefine this here because we need to return NSS_STATUS_RETURN instead of NSS_STATUS_NOTFOUND */ #undef ERROR_OUT_NOSUCCESS @@ -132,22 +87,12 @@ static nss_status_t read_netgrent( return NSS_STATUS_SUCCESS; } +#ifdef NSS_FLAVOUR_GLIBC + /* thread-local file pointer to an ongoing request */ static __thread TFILE *netgrentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setnetgrent(nss_backend_t *be,void *_args) -{ - return NSS_STATUS_SUCCESS; -} -#endif /* HAVE_NSSWITCH_H */ - -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_setnetgrent( -#else /* not HAVE_NSSWITCH_H */ -nss_status_t _nss_ldap_setnetgrent( -#endif /* HAVE_NSSWITCH_H */ - const char *group,struct __netgrent UNUSED(* result)) +nss_status_t _nss_ldap_setnetgrent(const char *group,struct __netgrent UNUSED(* result)) { /* we cannot use NSS_SETENT() here because we have a parameter that is only available in this function */ @@ -165,29 +110,105 @@ nss_status_t _nss_ldap_setnetgrent( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getnetgrent_r( -#else /* not HAVE_NSSWITCH_H */ -nss_status_t _nss_ldap_getnetgrent_r( -#endif /* HAVE_NSSWITCH_H */ - struct __netgrent *result,char *buffer,size_t buflen,int *errnop) +nss_status_t _nss_ldap_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME, + NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, read_netgrent(netgrentfp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endnetgrent(nss_backend_t *be,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endnetgrent(struct __netgrent UNUSED(* result)) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(netgrentfp); } -#ifdef HAVE_NSSWITCH_H +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +/* + *thread specific context: result chain,and state data + */ +struct ent_context +{ + void *first_entry; + void *curr_entry; +}; +typedef struct ent_context ent_context_t; + +struct nss_ldap_netgr_backend +{ + nss_backend_op_t *ops; + int n_ops; + ent_context_t *state; + struct name_list *known_groups; /* netgroups seen, for loop detection */ + struct name_list *needed_groups; /* nested netgroups to chase */ +}; +typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; -nss_status_t _nss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) +static nss_status_t _xnss_ldap_setnetgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + return NSS_STATUS_SUCCESS; +} + +/* find a netgroup that has not been traversed */ +static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) +{ + nss_status_t status; + char *group=NULL; + int found=0; + if (!ngbe->needed_groups) + { + /* exhausted all netgroups */ + return NULL; + } + while (ngbe->needed_groups&&!found) + { + if (_nss_ldap_namelist_find(ngbe->known_groups, + ngbe->needed_groups->name)) + { + /* netgroup seen before,ignore it */ + _nss_ldap_namelist_pop(&ngbe->needed_groups); + } + else + found=1; + } + if (found) + { + group=strdup(ngbe->needed_groups->name); + status=_nss_ldap_namelist_push(&ngbe->known_groups, + ngbe->needed_groups->name); + _nss_ldap_namelist_pop(&ngbe->needed_groups); + } + return group; +} + +static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, + read_netgrent(netgrentfp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(* result)) +{ + /* we cannot use NSS_SETENT() here because we have a parameter that is only + available in this function */ + int32_t tmpint32; + int errnocp; + int *errnop; + if (!_nss_ldap_enablelookups) + return NSS_STATUS_UNAVAIL; + errnop=&errnocp; + /* check parameter */ + if ((group==NULL)||(group[0]=='\0')) + return NSS_STATUS_UNAVAIL; + /* open a new stream and write the request */ + NSLCD_REQUEST(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,WRITE_STRING(netgrentfp,group)); + return NSS_STATUS_SUCCESS; +} + +static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_be; struct nss_getnetgrent_args *args=(struct nss_getnetgrent_args *)_args; @@ -199,8 +220,7 @@ nss_status_t _nss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) args->status=NSS_NETGR_NO; while (!done) { - status=_nss_nslcd_getnetgrent_r(&result,args->buffer,args->buflen, - &err); + status=_nss_nslcd_getnetgrent_r(&result,args->buffer,args->buflen,&err); if (status!=NSS_STATUS_SUCCESS) { if (err==ENOENT) @@ -264,7 +284,33 @@ nss_status_t _nss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) return status; } -static nss_status_t _nss_ldap_netgr_set(nss_backend_t *be,void *_args) +static nss_status_t _xnss_ldap_endnetgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_ENDENT(netgrentfp); +} + +static nss_status_t _xnss_ldap_netgroup_destr(nss_backend_t *be,void *UNUSED(args)) +{ + nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)be; + /* free list of nested netgroups */ + _nss_ldap_namelist_destroy(&ngbe->known_groups); + _nss_ldap_namelist_destroy(&ngbe->needed_groups); + free(ngbe); + return NSS_STATUS_SUCCESS; +} + +static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args); + +static nss_backend_op_t netgroup_ops[]={ + _xnss_ldap_netgroup_destr, /* NSS_DBOP_DESTRUCTOR */ + _xnss_ldap_endnetgrent, /* NSS_DBOP_ENDENT */ + _xnss_ldap_setnetgrent, /* NSS_DBOP_SETNET */ + _xnss_ldap_getnetgrent_r, /* NSS_DBOP_GETENT */ + NULL,/* TODO:_nss_ldap_netgr_in,*/ /* NSS_DBOP_NETGROUP_IN */ + _xnss_ldap_netgr_set /* NSS_DBOP_NETGROUP_SET */ +}; + +static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) { nss_status_t stat; struct nss_setnetgrent_args *args; @@ -281,50 +327,26 @@ static nss_status_t _nss_ldap_netgr_set(nss_backend_t *be,void *_args) ngbe->state=NULL; ngbe->known_groups=NULL; ngbe->needed_groups=NULL; - stat=_nss_ldap_default_constr((nss_ldap_backend_t *)ngbe); - if (stat!=NSS_STATUS_SUCCESS) - { - free(ngbe); - return stat; - } group=(char *)args->netgroup; stat=_nss_nslcd_setnetgrent(group,&result); if (stat!=NSS_STATUS_SUCCESS) { - _nss_ldap_default_destr((nss_backend_t *)ngbe,NULL); + free(be); return stat; } /* place the group name in known list */ stat=_nss_ldap_namelist_push(&ngbe->known_groups,group); if (stat!=NSS_STATUS_SUCCESS) { - _nss_ldap_netgroup_destr((nss_backend_t *)ngbe,NULL); + _xnss_ldap_netgroup_destr((nss_backend_t *)ngbe,NULL); return stat; } args->iterator=(nss_backend_t *)ngbe; return stat; } -static nss_status_t _nss_ldap_netgroup_destr(nss_backend_t *_ngbe,void *args) -{ - nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_ngbe; - /* free list of nested netgroups */ - _nss_ldap_namelist_destroy(&ngbe->known_groups); - _nss_ldap_namelist_destroy(&ngbe->needed_groups); - return _nss_ldap_default_destr(_ngbe,args); -} - -static nss_backend_op_t netgroup_ops[]={ - _nss_ldap_netgroup_destr, /* NSS_DBOP_DESTRUCTOR */ - _nss_ldap_endnetgrent, /* NSS_DBOP_ENDENT */ - _nss_ldap_setnetgrent, /* NSS_DBOP_SETNET */ - _nss_ldap_getnetgrent_r, /* NSS_DBOP_GETENT */ - NULL,/* TODO:_nss_ldap_netgr_in,*/ /* NSS_DBOP_NETGROUP_IN */ - _nss_ldap_netgr_set /* NSS_DBOP_NETGROUP_SET */ -}; - -nss_backend_t *_nss_ldap_netgroup_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_netgroup_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { nss_ldap_netgr_backend_t *be; if (!(be=(nss_ldap_netgr_backend_t *)malloc(sizeof(*be)))) @@ -333,12 +355,7 @@ nss_backend_t *_nss_ldap_netgroup_constr(const char *db_name, be->n_ops=sizeof(netgroup_ops)/sizeof(nss_backend_op_t); be->known_groups=NULL; be->needed_groups=NULL; - if (_nss_ldap_default_constr((nss_ldap_backend_t *)be)!=NSS_STATUS_SUCCESS) - { - free(be); - return NULL; - } return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/networks.c b/nss/networks.c index 623fca8..205179a 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -25,6 +25,9 @@ #include #include +#include +#include +#include #include "prototypes.h" #include "common.h" @@ -100,19 +103,6 @@ static nss_status_t read_netent( return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getnetbyname_r( -#else /* not HAVE_NSSWITCH_H */ -nss_status_t _nss_ldap_getnetbyname_r( -#endif /* HAVE_NSSWITCH_H */ - const char *name,struct netent *result,char *buffer, - size_t buflen,int *errnop,int *h_errnop) -{ - NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME, - name, - read_netent(fp,result,buffer,buflen,errnop,h_errnop)); -} - /* write an address value */ /* version 2.10 of glibc changed the address from network to host order (changelog entry 2009-07-01) */ @@ -121,56 +111,67 @@ nss_status_t _nss_ldap_getnetbyname_r( WRITE_INT32(fp,4); \ WRITE_INT32(fp,htonl(addr)); +#ifdef NSS_FLAVOUR_GLIBC + +nss_status_t _nss_ldap_getnetbyname_r( + const char *name,struct netent *result,char *buffer, + size_t buflen,int *errnop,int *h_errnop) +{ + NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME,buffer,buflen, + name, + read_netent(fp,result,buffer,buflen,errnop,h_errnop)); + return retv; +} + /* Note: the af parameter is ignored and is assumed to be AF_INET */ /* TODO: implement handling of af parameter */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getnetbyaddr_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getnetbyaddr_r( -#endif /* HAVE_NSSWITCH_H */ uint32_t addr,int UNUSED(af),struct netent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR, + NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR,buffer,buflen, WRITE_ADDRESS(fp,addr), read_netent(fp,result,buffer,buflen,errnop,h_errnop)) + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *netentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setnetent(nss_backend_t *net_context,void *fakeargs) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setnetent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(netentfp); } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getnetent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getnetent_r( -#endif /* HAVE_NSSWITCH_H */ struct netent *result,char *buffer,size_t buflen, int *errnop,int *h_errnop) { - NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL, + NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL,buffer,buflen, read_netent(netentfp,result,buffer,buflen,errnop,h_errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endnetent(nss_backend_t *net_context,void *fakeargs) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endnetent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(netentfp); } -#ifdef HAVE_NSSWITCH_H -static nss_status_t _nss_ldap_getnetbyname_r(nss_backend_t *be,void *args) +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +static nss_status_t _nss_nslcd_getnetbyname_r( + const char *name,struct netent *result,char *buffer, + size_t buflen,int *errnop,int *h_errnop) +{ + NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME,buffer,buflen, + name, + read_netent(fp,result,buffer,buflen,errnop,h_errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t *UNUSED(be),void *args) { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; @@ -181,7 +182,7 @@ static nss_status_t _nss_ldap_getnetbyname_r(nss_backend_t *be,void *args) int h_errno; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -219,16 +220,26 @@ static nss_status_t _nss_ldap_getnetbyname_r(nss_backend_t *be,void *args) NSS_ARGS(args)->h_errno=h_errno; return status; } -#endif /* HAVE_NSSWITCH_H */ /* Note: the af parameter is ignored and is assumed to be AF_INET */ /* TODO: implement handling of af parameter */ -#ifdef HAVE_NSSWITCH_H -static nss_status_t _nss_ldap_getnetbyaddr_r(nss_backend_t *be,void *args) +static nss_status_t _nss_nslcd_getnetbyaddr_r( + uint32_t addr,int UNUSED(af),struct netent *result, + char *buffer,size_t buflen,int *errnop,int *h_errnop) +{ + NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR,buffer,buflen, + WRITE_ADDRESS(fp,addr), + read_netent(fp,result,buffer,buflen,errnop,h_errnop)) + return retv; +} + +/* Note: the af parameter is ignored and is assumed to be AF_INET */ +/* TODO: implement handling of af parameter */ +static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t *UNUSED(be),void *args) { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; - int addr=NSS_ARGS(args)->key.netaddr.net; + int addr=NSS_ARGS(args)->key.netaddr.net; /* is an addr an int? */ int af=NSS_ARGS(args)->key.netaddr.type; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; @@ -236,7 +247,7 @@ static nss_status_t _nss_ldap_getnetbyaddr_r(nss_backend_t *be,void *args) char *data_ptr; struct in_addr in_addr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -276,7 +287,21 @@ static nss_status_t _nss_ldap_getnetbyaddr_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getnetent_r(nss_backend_t *net_context,void *args) +static nss_status_t _xnss_ldap_setnetent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(netentfp); +} + +static nss_status_t _nss_nslcd_getnetent_r( + struct netent *result,char *buffer,size_t buflen, + int *errnop,int *h_errnop) +{ + NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL,buffer,buflen, + read_netent(netentfp,result,buffer,buflen,errnop,h_errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t *UNUSED(be),void *args) { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; @@ -285,7 +310,7 @@ static nss_status_t _nss_ldap_getnetent_r(nss_backend_t *net_context,void *args) int h_errno; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -321,31 +346,35 @@ static nss_status_t _nss_ldap_getnetent_r(nss_backend_t *net_context,void *args) return status; } -static nss_status_t _nss_ldap_networks_destr(nss_backend_t *net_context,void *args) +static nss_status_t _xnss_ldap_endnetent(nss_backend_t *UNUSED(be),void *UNUSED(args)) { - return _nss_ldap_default_destr(net_context,args); + NSS_ENDENT(netentfp); +} + +static nss_status_t _xnss_ldap_networks_destr(nss_backend_t *be,void *UNUSED(args)) +{ + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t net_ops[]={ - _nss_ldap_networks_destr, - _nss_ldap_endnetent, - _nss_ldap_setnetent, - _nss_ldap_getnetent_r, - _nss_ldap_getnetbyname_r, - _nss_ldap_getnetbyaddr_r + _xnss_ldap_networks_destr, + _xnss_ldap_endnetent, + _xnss_ldap_setnetent, + _xnss_ldap_getnetent_r, + _xnss_ldap_getnetbyname_r, + _xnss_ldap_getnetbyaddr_r }; -nss_backend_t *_nss_ldap_networks_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_networks_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=net_ops; be->n_ops=sizeof(net_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/passwd.c b/nss/passwd.c index aaa346a..5119e1c 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -46,84 +46,81 @@ static nss_status_t read_passwd( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getpwnam_r( -#else /* not HAVE_NSSWITCH_H */ +#ifdef NSS_FLAVOUR_GLIBC + nss_status_t _nss_ldap_getpwnam_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,struct passwd *result,char *buffer,size_t buflen, int *errnop) { - NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME, + NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME,buffer,buflen, name, read_passwd(fp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getpwuid_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getpwuid_r( -#endif /* HAVE_NSSWITCH_H */ uid_t uid,struct passwd *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID, + NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID,buffer,buflen, uid,uid_t, read_passwd(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *pwentfp; /* open a connection to the nslcd and write the request */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setpwent(nss_backend_t *be,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setpwent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(pwentfp); } /* read password data from an opened stream */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getpwent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getpwent_r( -#endif /* HAVE_NSSWITCH_H */ struct passwd *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL, + NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL,buffer,buflen, read_passwd(pwentfp,result,buffer,buflen,errnop)); + return retv; } /* close the stream opened with setpwent() above */ -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endpwent(nss_backend_t *be,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endpwent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(pwentfp); } -#ifdef HAVE_NSSWITCH_H -static nss_status_t _nss_ldap_getpwnam_r(nss_backend_t *be,void *args) +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +static nss_status_t _nss_nslcd_getpwnam_r( + const char *name,struct passwd *result,char *buffer,size_t buflen, + int *errnop) +{ + NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME,buffer,buflen, + name, + read_passwd(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getpwnam_r(nss_backend_t *UNUSED(be),void *args) { struct passwd priv_pw; struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; - char *name=(char *)NSS_ARGS(args)->key.name; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; status=NSS_STATUS_TRYAGAIN; return status; } - status=_nss_nslcd_getpwnam_r(name,pw,buffer,buflen,&errno); + status=_nss_nslcd_getpwnam_r(NSS_ARGS(args)->key.name,pw,buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; if (!NSS_ARGS(args)->buf.result) @@ -147,7 +144,38 @@ static nss_status_t _nss_ldap_getpwnam_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getpwuid_r(nss_backend_t *be,void *args) +static nss_status_t _nss_nslcd_getpwuid_r( + uid_t uid,struct passwd *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID,buffer,buflen, + uid,uid_t, + read_passwd(fp,result,buffer,buflen,errnop)); + return retv; +} + +/* open a connection to the nslcd and write the request */ +static nss_status_t _xnss_ldap_setpwent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(pwentfp); +} + +/* read password data from an opened stream */ +static nss_status_t _nss_nslcd_getpwent_r( + struct passwd *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL,buffer,buflen, + read_passwd(pwentfp,result,buffer,buflen,errnop)); + return retv; +} + +/* close the stream opened with setpwent() above */ +static nss_status_t _xnss_ldap_endpwent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_ENDENT(pwentfp); +} + +static nss_status_t _xnss_ldap_getpwuid_r(nss_backend_t *UNUSED(be),void *args) { struct passwd priv_pw; struct passwd *pw=NSS_ARGS(args)->buf.result ? @@ -181,7 +209,7 @@ static nss_status_t _nss_ldap_getpwuid_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getpwent_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_getpwent_r(nss_backend_t *UNUSED(be),void *args) { struct passwd priv_pw; struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; @@ -213,31 +241,30 @@ static nss_status_t _nss_ldap_getpwent_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_passwd_destr(nss_backend_t *pw_context,void *args) +static nss_status_t _xnss_ldap_passwd_destr(nss_backend_t *be,void *UNUSED(args)) { - return _nss_ldap_default_destr(pw_context,args); + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t passwd_ops[]={ - _nss_ldap_passwd_destr, - _nss_ldap_endpwent, /* NSS_DBOP_ENDENT */ - _nss_ldap_setpwent, /* NSS_DBOP_SETENT */ - _nss_ldap_getpwent_r, /* NSS_DBOP_GETENT */ - _nss_ldap_getpwnam_r, /* NSS_DBOP_PASSWD_BYNAME */ - _nss_ldap_getpwuid_r /* NSS_DBOP_PASSWD_BYUID */ + _xnss_ldap_passwd_destr, + _xnss_ldap_endpwent, /* NSS_DBOP_ENDENT */ + _xnss_ldap_setpwent, /* NSS_DBOP_SETENT */ + _xnss_ldap_getpwent_r, /* NSS_DBOP_GETENT */ + _xnss_ldap_getpwnam_r, /* NSS_DBOP_PASSWD_BYNAME */ + _xnss_ldap_getpwuid_r /* NSS_DBOP_PASSWD_BYUID */ }; -nss_backend_t *_nss_ldap_passwd_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_passwd_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=passwd_ops; be->n_ops=sizeof(passwd_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/protocols.c b/nss/protocols.c index 244cdac..4e3b401 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -42,88 +42,85 @@ static nss_status_t read_protoent( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getprotobyname_r( -#else /* not HAVE_NSSWITCH_H */ +#ifdef NSS_FLAVOUR_GLIBC + nss_status_t _nss_ldap_getprotobyname_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,struct protoent *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME, + NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME,buffer,buflen, name, read_protoent(fp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getprotobynumber_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getprotobynumber_r( -#endif /* HAVE_NSSWITCH_H */ int number,struct protoent *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER, + NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER,buffer,buflen, number, read_protoent(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setprotoent(nss_backend_t *proto_context,void *fakeargs) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setprotoent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(protoentfp); } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getprotoent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getprotoent_r( -#endif /* HAVE_NSSWITCH_H */ struct protoent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL, + NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL,buffer,buflen, read_protoent(protoentfp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endprotoent(nss_backend_t *proto_context,void *fakeargs) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endprotoent(void) -#endif /* HAVE_NSSWITCH_H */ - { NSS_ENDENT(protoentfp); } -#ifdef HAVE_NSSWITCH_H +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_ldap_getprotobyname_r(nss_backend_t *be,void *args) +static nss_status_t _nss_nslcd_getprotobyname_r( + const char *name,struct protoent *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME,buffer,buflen, + name, + read_protoent(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getprotobyname_r(nss_backend_t *UNUSED(be),void *args) { struct protoent priv_proto; struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; - char *name=(char *)NSS_ARGS(args)->key.name; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; } - status=_nss_nslcd_getprotobyname_r(name,proto ,buffer,buflen,&errno); + status=_nss_nslcd_getprotobyname_r(NSS_ARGS(args)->key.name,proto,buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; if (!NSS_ARGS(args)->buf.result) { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); + /* FIXME: shouldn't there be some range checks here to see if it actually + fits inside the buffer? */ sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); if (proto->p_aliases) { @@ -146,7 +143,17 @@ static nss_status_t _nss_ldap_getprotobyname_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getprotobynumber_r(nss_backend_t *be,void *args) +static nss_status_t _nss_nslcd_getprotobynumber_r( + int number,struct protoent *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER,buffer,buflen, + number, + read_protoent(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t *UNUSED(be),void *args) { struct protoent priv_proto; struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; @@ -189,7 +196,20 @@ static nss_status_t _nss_ldap_getprotobynumber_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getprotoent_r(nss_backend_t *proto_context,void *args) +static nss_status_t _xnss_ldap_setprotoent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(protoentfp); +} + +static nss_status_t _nss_nslcd_getprotoent_r( + struct protoent *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL,buffer,buflen, + read_protoent(protoentfp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getprotoent_r(nss_backend_t *UNUSED(be),void *args) { struct protoent priv_proto; struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; @@ -197,7 +217,7 @@ static nss_status_t _nss_ldap_getprotoent_r(nss_backend_t *proto_context,void *a size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -231,31 +251,35 @@ static nss_status_t _nss_ldap_getprotoent_r(nss_backend_t *proto_context,void *a return status; } -static nss_status_t _nss_ldap_protocols_destr(nss_backend_t *proto_context,void *args) +static nss_status_t _xnss_ldap_endprotoent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_ENDENT(protoentfp); +} + +static nss_status_t _xnss_ldap_protocols_destr(nss_backend_t *be,void *UNUSED(args)) { - return _nss_ldap_default_destr(proto_context,args); + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t proto_ops[]={ - _nss_ldap_protocols_destr, - _nss_ldap_endprotoent, - _nss_ldap_setprotoent, - _nss_ldap_getprotoent_r, - _nss_ldap_getprotobyname_r, - _nss_ldap_getprotobynumber_r + _xnss_ldap_protocols_destr, + _xnss_ldap_endprotoent, + _xnss_ldap_setprotoent, + _xnss_ldap_getprotoent_r, + _xnss_ldap_getprotobyname_r, + _xnss_ldap_getprotobynumber_r }; -nss_backend_t *_nss_ldap_protocols_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_protocols_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=proto_ops; be->n_ops=sizeof(proto_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/prototypes.h b/nss/prototypes.h index 973a8ad..4989fd9 100644 --- a/nss/prototypes.h +++ b/nss/prototypes.h @@ -25,6 +25,12 @@ #include "compat/nss_compat.h" +/* flag to gloabally disable lookups (all _nss_ldap_*() functions will return + NSS_STATUS_UNAVAIL */ +extern int _nss_ldap_enablelookups; + +#ifdef NSS_FLAVOUR_GLIBC + /* These are prototypes for functions exported from the ldap NSS module. For more complete definitions of these functions check the GLIBC @@ -38,105 +44,99 @@ http://www.gnu.org/software/libc/manual/html_node/Name-Service-Switch.html */ -/* flag to gloabally disable lookups (all _nss_ldap_*() functions will return - NSS_STATUS_UNAVAIL */ -extern int _nss_ldap_enablelookups; - /* aliases - mail aliases */ -#ifdef HAVE_ALIASES_H nss_status_t _nss_ldap_getaliasbyname_r(const char *name,struct aliasent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setaliasent(void); nss_status_t _nss_ldap_getaliasent_r(struct aliasent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endaliasent(void); -#endif /* HAVE_ALIASES_H */ /* ethers - ethernet numbers */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_gethostton_r(const char *name,struct etherent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getntohost_r(const struct ether_addr *addr,struct etherent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setetherent(int stayopen); nss_status_t _nss_ldap_getetherent_r(struct etherent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endetherent(void); -#endif /* not HAVE_NSSWITCH_H */ /* group - groups of users */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getgrnam_r(const char *name,struct group *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getgrgid_r(gid_t gid,struct group *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_initgroups_dyn(const char *user,gid_t group,long int *start,long int *size,gid_t **groupsp,long int limit,int *errnop); nss_status_t _nss_ldap_setgrent(int stayopen); nss_status_t _nss_ldap_getgrent_r(struct group *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endgrent(void); -#endif /* not HAVE_NSSWITCH_H */ /* hosts - host names and numbers */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_gethostbyname_r(const char *name,struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_gethostbyname2_r(const char *name,int af,struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_gethostbyaddr_r(const void *addr,socklen_t len,int af,struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_sethostent(int stayopen); nss_status_t _nss_ldap_gethostent_r(struct hostent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_endhostent(void); -#endif /* not HAVE_NSSWITCH_H */ /* netgroup - list of host and users */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_setnetgrent(const char *group,struct __netgrent *result); nss_status_t _nss_ldap_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endnetgrent(struct __netgrent *result); -#endif /* not HAVE_NSSWITCH_H */ /* networks - network names and numbers */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getnetbyname_r(const char *name,struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_getnetbyaddr_r(uint32_t addr,int af,struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_setnetent(int stayopen); nss_status_t _nss_ldap_getnetent_r(struct netent *result,char *buffer,size_t buflen,int *errnop,int *h_errnop); nss_status_t _nss_ldap_endnetent(void); -#endif /* not HAVE_NSSWITCH_H */ /* passwd - user database and passwords */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getpwnam_r(const char *name,struct passwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getpwuid_r(uid_t uid,struct passwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setpwent(int stayopen); nss_status_t _nss_ldap_getpwent_r(struct passwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endpwent(void); -#endif /* not HAVE_NSSWITCH_H */ /* protocols - network protocols */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getprotobyname_r(const char *name,struct protoent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getprotobynumber_r(int number,struct protoent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setprotoent(int stayopen); nss_status_t _nss_ldap_getprotoent_r(struct protoent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endprotoent(void); -#endif /* not HAVE_NSSWITCH_H */ /* rpc - remote procedure call names and numbers */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getrpcbyname_r(const char *name,struct rpcent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getrpcbynumber_r(int number,struct rpcent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setrpcent(int stayopen); nss_status_t _nss_ldap_getrpcent_r(struct rpcent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endrpcent(void); -#endif /* not HAVE_NSSWITCH_H */ /* services - network services */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getservbyname_r(const char *name,const char *protocol,struct servent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_getservbyport_r(int port,const char *protocol,struct servent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setservent(int stayopen); nss_status_t _nss_ldap_getservent_r(struct servent *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endservent(void); -#endif /* not HAVE_NSSWITCH_H */ /* shadow - extended user information */ -#ifndef HAVE_NSSWITCH_H nss_status_t _nss_ldap_getspnam_r(const char *name,struct spwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_setspent(int stayopen); nss_status_t _nss_ldap_getspent_r(struct spwd *result,char *buffer,size_t buflen,int *errnop); nss_status_t _nss_ldap_endspent(void); -#endif /* not HAVE_NSSWITCH_H */ + +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +#define NSS_ARGS(args) ((nss_XbyY_args_t *)args) + +/* these are the constructors we provide */ +nss_backend_t *_nss_ldap_ethers_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_group_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_hosts_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_netgroup_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_networks_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_passwd_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_protocols_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_rpc_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_services_constr(const char *db_name,const char *src_name,const char *cfg_args); +nss_backend_t *_nss_ldap_shadow_constr(const char *db_name,const char *src_name,const char *cfg_args); + +#endif /* NSS_FLAVOUR_SOLARIS */ #endif /* not NSS__PROTOTYPES_H */ diff --git a/nss/rpc.c b/nss/rpc.c index 6a66686..c6101dd 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -42,81 +42,105 @@ static nss_status_t read_rpcent( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getrpcbyname_r( -#else /* not HAVE_NSSWITCH_H */ +#ifdef NSS_FLAVOUR_GLIBC + nss_status_t _nss_ldap_getrpcbyname_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,struct rpcent *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME, + NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME,buffer,buflen, name, read_rpcent(fp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getrpcbynumber_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getrpcbynumber_r( -#endif /* HAVE_NSSWITCH_H */ int number,struct rpcent *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER, + NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER,buffer,buflen, number, read_rpcent(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setrpcent(nss_backend_t *rpc_context,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setrpcent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(protoentfp); } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getrpcent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getrpcent_r( -#endif /* HAVE_NSSWITCH_H */ struct rpcent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_RPC_ALL, + NSS_GETENT(protoentfp,NSLCD_ACTION_RPC_ALL,buffer,buflen, read_rpcent(protoentfp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endrpcent(nss_backend_t *rpc_context,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endrpcent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(protoentfp); } -#ifdef HAVE_NSSWITCH_H +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +static nss_status_t _nss_nslcd_getrpcbyname_r( + const char *name,struct rpcent *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME,buffer,buflen, + name, + read_rpcent(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _nss_nslcd_getrpcbynumber_r( + int number,struct rpcent *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER,buffer,buflen, + number, + read_rpcent(fp,result,buffer,buflen,errnop)); + return retv; +} -static nss_status_t _nss_ldap_getrpcbyname_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_setrpcent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(protoentfp); +} + +static nss_status_t _nss_nslcd_getrpcent_r( + struct rpcent *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(protoentfp,NSLCD_ACTION_RPC_ALL,buffer,buflen, + read_rpcent(protoentfp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_endrpcent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_ENDENT(protoentfp); +} + +static nss_status_t _xnss_ldap_getrpcbyname_r(nss_backend_t *UNUSED(be),void *args) { struct rpcent priv_rpc; struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; - char *name=NSS_ARGS(args)->key.name; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; } - status=_nss_nslcd_getrpcbyname_r(name,rpc,buffer,buflen,&errno); + status=_nss_nslcd_getrpcbyname_r(NSS_ARGS(args)->key.name,rpc,buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; if (!NSS_ARGS(args)->buf.result) @@ -145,7 +169,7 @@ static nss_status_t _nss_ldap_getrpcbyname_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getrpcbynumber_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_getrpcbynumber_r(nss_backend_t *UNUSED(be),void *args) { struct rpcent priv_rpc; struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; @@ -154,7 +178,7 @@ static nss_status_t _nss_ldap_getrpcbynumber_r(nss_backend_t *be,void *args) size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -188,7 +212,7 @@ static nss_status_t _nss_ldap_getrpcbynumber_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getrpcent_r(nss_backend_t *rpc_context,void *args) +static nss_status_t _xnss_ldap_getrpcent_r(nss_backend_t *UNUSED(be),void *args) { struct rpcent priv_rpc; struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; @@ -196,7 +220,7 @@ static nss_status_t _nss_ldap_getrpcent_r(nss_backend_t *rpc_context,void *args) size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -230,31 +254,30 @@ static nss_status_t _nss_ldap_getrpcent_r(nss_backend_t *rpc_context,void *args) return status; } -static nss_status_t _nss_ldap_rpc_destr(nss_backend_t *rpc_context,void *args) +static nss_status_t _xnss_ldap_rpc_destr(nss_backend_t *be,void *UNUSED(args)) { - return _nss_ldap_default_destr(rpc_context,args); + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t rpc_ops[]={ - _nss_ldap_rpc_destr, - _nss_ldap_endrpcent, - _nss_ldap_setrpcent, - _nss_ldap_getrpcent_r, - _nss_ldap_getrpcbyname_r, - _nss_ldap_getrpcbynumber_r + _xnss_ldap_rpc_destr, + _xnss_ldap_endrpcent, + _xnss_ldap_setrpcent, + _xnss_ldap_getrpcent_r, + _xnss_ldap_getrpcbyname_r, + _xnss_ldap_getrpcbynumber_r }; -nss_backend_t *_nss_ldap_rpc_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_rpc_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=rpc_ops; be->n_ops=sizeof(rpc_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/services.c b/nss/services.c index 4ef5e90..fa50776 100644 --- a/nss/services.c +++ b/nss/services.c @@ -45,78 +45,100 @@ static nss_status_t read_servent( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getservbyname_r( -#else /* not HAVE_NSSWITCH_H */ +#ifdef NSS_FLAVOUR_GLIBC + nss_status_t _nss_ldap_getservbyname_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,const char *protocol,struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME, + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME,buffer,buflen, WRITE_STRING(fp,name);WRITE_STRING(fp,protocol), read_servent(fp,result,buffer,buflen,errnop)); - + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getservbyport_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getservbyport_r( -#endif /* HAVE_NSSWITCH_H */ int port,const char *protocol,struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER, + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER,buffer,buflen, WRITE_INT32(fp,ntohs(port));WRITE_STRING(fp,protocol), read_servent(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setservent(nss_backend_t *serv_context,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setservent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(protoentfp); } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getservent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getservent_r( -#endif /* HAVE_NSSWITCH_H */ struct servent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL, + NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, read_servent(protoentfp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endservent(nss_backend_t *serv_context,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endservent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(protoentfp); } -#ifdef HAVE_NSSWITCH_H +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +static nss_status_t _nss_nslcd_getservbyname_r( + const char *name,const char *protocol,struct servent *result, + char *buffer,size_t buflen,int *errnop) +{ + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME,buffer,buflen, + WRITE_STRING(fp,name);WRITE_STRING(fp,protocol), + read_servent(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _nss_nslcd_getservbyport_r( + int port,const char *protocol,struct servent *result, + char *buffer,size_t buflen,int *errnop) +{ + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER,buffer,buflen, + WRITE_INT32(fp,ntohs(port));WRITE_STRING(fp,protocol), + read_servent(fp,result,buffer,buflen,errnop)); + return retv; +} -static nss_status_t _nss_ldap_getservbyname_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_setservent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(protoentfp); +} + +static nss_status_t _nss_nslcd_getservent_r( + struct servent *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(protoentfp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_endservent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_ENDENT(protoentfp); +} + +static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t *UNUSED(be),void *args) { - char *name=(char *)NSS_ARGS(args)->key.serv.serv.name; - char *protocol=NSS_ARGS(args)->key.serv.proto?(char *)NSS_ARGS(args)->key.serv.proto:""; struct servent priv_service; struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - status=_nss_nslcd_getservbyname_r(name,protocol,service, + status=_nss_nslcd_getservbyname_r(NSS_ARGS(args)->key.serv.serv.name,NSS_ARGS(args)->key.serv.proto,service, buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; @@ -124,7 +146,7 @@ static nss_status_t _nss_ldap_getservbyname_r(nss_backend_t *be,void *args) { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d/%s",name,service->s_port, + sprintf(data_ptr,"%s %d/%s",service->s_name,service->s_port, service->s_proto); if (service->s_aliases) { @@ -147,17 +169,16 @@ static nss_status_t _nss_ldap_getservbyname_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getservbyport_r(nss_backend_t *be,void *args) +static nss_status_t _xnss_ldap_getservbyport_r(nss_backend_t *UNUSED(be),void *args) { int port=NSS_ARGS(args)->key.serv.serv.port; - char *protocol=(char *)NSS_ARGS(args)->key.serv.proto; struct servent priv_service; struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - status=_nss_nslcd_getservbyport_r(port,protocol,service,buffer,buflen,&errno); + status=_nss_nslcd_getservbyport_r(port,NSS_ARGS(args)->key.serv.proto,service,buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; if (!NSS_ARGS(args)->buf.result) @@ -187,7 +208,7 @@ static nss_status_t _nss_ldap_getservbyport_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getservent_r(nss_backend_t *serv_context,void *args) +static nss_status_t _xnss_ldap_getservent_r(nss_backend_t *UNUSED(be),void *args) { struct servent priv_service; struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; @@ -225,31 +246,30 @@ static nss_status_t _nss_ldap_getservent_r(nss_backend_t *serv_context,void *arg return status; } -static nss_status_t _nss_ldap_services_destr(nss_backend_t *serv_context,void *args) +static nss_status_t _xnss_ldap_services_destr(nss_backend_t *be,void *UNUSED(args)) { - return _nss_ldap_default_destr(serv_context,args); + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t services_ops[]={ - _nss_ldap_services_destr, - _nss_ldap_endservent, - _nss_ldap_setservent, - _nss_ldap_getservent_r, - _nss_ldap_getservbyname_r, - _nss_ldap_getservbyport_r + _xnss_ldap_services_destr, + _xnss_ldap_endservent, + _xnss_ldap_setservent, + _xnss_ldap_getservent_r, + _xnss_ldap_getservbyname_r, + _xnss_ldap_getservbyport_r }; -nss_backend_t *_nss_ldap_services_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_services_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=services_ops; be->n_ops=sizeof(services_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/shadow.c b/nss/shadow.c index 4509708..b417edd 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -48,67 +48,67 @@ static nss_status_t read_spwd( return NSS_STATUS_SUCCESS; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getspnam_r( -#else /* not HAVE_NSSWITCH_H */ +#ifdef NSS_FLAVOUR_GLIBC + nss_status_t _nss_ldap_getspnam_r( -#endif /* HAVE_NSSWITCH_H */ const char *name,struct spwd *result,char *buffer, size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME, + NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME,buffer,buflen, name, read_spwd(fp,result,buffer,buflen,errnop)); + return retv; } /* thread-local file pointer to an ongoing request */ static __thread TFILE *spentfp; -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_setspent(nss_backend_t *be,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_setspent(int UNUSED(stayopen)) -#endif /* HAVE_NSSWITCH_H */ { NSS_SETENT(spentfp); } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_nslcd_getspent_r( -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_getspent_r( -#endif /* HAVE_NSSWITCH_H */ struct spwd *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL, + NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL,buffer,buflen, read_spwd(spentfp,result,buffer,buflen,errnop)); + return retv; } -#ifdef HAVE_NSSWITCH_H -nss_status_t _nss_ldap_endspent(nss_backend_t *sp_context,void *args) -#else /* not HAVE_NSSWITCH_H */ nss_status_t _nss_ldap_endspent(void) -#endif /* HAVE_NSSWITCH_H */ { NSS_ENDENT(spentfp); } -#ifdef HAVE_NSSWITCH_H -static nss_status_t _nss_ldap_getspnam_r(nss_backend_t *be,void *args) +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +static nss_status_t _nss_nslcd_getspnam_r( + const char *name,struct spwd *result,char *buffer, + size_t buflen,int *errnop) +{ + NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME,buffer,buflen, + name, + read_spwd(fp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t *UNUSED(be),void *args) { struct spwd priv_spwd; struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; - char *name=(char *)NSS_ARGS(args)->key.name; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; } - status=_nss_nslcd_getspnam_r(name,sp,buffer,buflen,&errno); + status=_nss_nslcd_getspnam_r(NSS_ARGS(args)->key.name,sp,buffer,buflen,&errno); if (status!=NSS_STATUS_SUCCESS) return status; if (!NSS_ARGS(args)->buf.result) @@ -164,7 +164,20 @@ static nss_status_t _nss_ldap_getspnam_r(nss_backend_t *be,void *args) return status; } -static nss_status_t _nss_ldap_getspent_r(nss_backend_t *sp_context,void *args) +static nss_status_t _xnss_ldap_setspent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +{ + NSS_SETENT(spentfp); +} + +static nss_status_t _nss_nslcd_getspent_r( + struct spwd *result,char *buffer,size_t buflen,int *errnop) +{ + NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL,buffer,buflen, + read_spwd(spentfp,result,buffer,buflen,errnop)); + return retv; +} + +static nss_status_t _xnss_ldap_getspent_r(nss_backend_t *UNUSED(be),void *args) { struct spwd priv_spwd; struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; @@ -172,7 +185,7 @@ static nss_status_t _nss_ldap_getspent_r(nss_backend_t *sp_context,void *args) size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen < 0) + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; @@ -233,30 +246,34 @@ static nss_status_t _nss_ldap_getspent_r(nss_backend_t *sp_context,void *args) return status; } -static nss_status_t _nss_ldap_shadow_destr(nss_backend_t *sp_context,void *args) +static nss_status_t _xnss_ldap_endspent(nss_backend_t *UNUSED(be),void *UNUSED(args)) { - return _nss_ldap_default_destr(sp_context,args); + NSS_ENDENT(spentfp); +} + +static nss_status_t _xnss_ldap_shadow_destr(nss_backend_t *be,void *UNUSED(args)) +{ + free(be); + return NSS_STATUS_SUCCESS; } static nss_backend_op_t shadow_ops[]={ - _nss_ldap_shadow_destr, - _nss_ldap_endspent, /* NSS_DBOP_ENDENT */ - _nss_ldap_setspent, /* NSS_DBOP_SETENT */ - _nss_ldap_getspent_r, /* NSS_DBOP_GETENT */ - _nss_ldap_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ + _xnss_ldap_shadow_destr, + _xnss_ldap_endspent, /* NSS_DBOP_ENDENT */ + _xnss_ldap_setspent, /* NSS_DBOP_SETENT */ + _xnss_ldap_getspent_r, /* NSS_DBOP_GETENT */ + _xnss_ldap_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ }; -nss_backend_t *_nss_ldap_shadow_constr(const char *db_name, - const char *src_name,const char *cfg_args) +nss_backend_t *_nss_ldap_shadow_constr(const char *UNUSED(db_name), + const char *UNUSED(src_name),const char *UNUSED(cfg_args)) { - nss_ldap_backend_t *be; - if (!(be=(nss_ldap_backend_t *)malloc(sizeof(*be)))) + nss_backend_t *be; + if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) return NULL; be->ops=shadow_ops; be->n_ops=sizeof(shadow_ops)/sizeof(nss_backend_op_t); - if (_nss_ldap_default_constr(be)!=NSS_STATUS_SUCCESS) - return NULL; return (nss_backend_t *)be; } -#endif /* HAVE_NSSWITCH_H */ +#endif /* NSS_FLAVOUR_SOLARIS */ -- cgit v1.2.3 From 9d172a45a64bbdbdbb31cdc50ae426e9dcf5e470 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 4 Oct 2010 17:16:15 +0000 Subject: add check for returnlen member of struct nss_XbyY_args git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1237 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/configure.ac b/configure.ac index f6c65b7..4954d55 100644 --- a/configure.ac +++ b/configure.ac @@ -362,6 +362,24 @@ then #include "irs-nss.h" #endif]) + # check if struct nss_XbyY_args has a returnlen attribute + AC_CHECK_MEMBER([struct nss_XbyY_args.returnlen],,,[[ + #ifdef HAVE_NSS_H + #include + #endif + #ifdef HAVE_NSS_COMMON_H + #include + #endif + #ifdef HAVE_NSS_DBDEFS_H + #include + #endif + #ifdef HAVE_NSSWITCH_H + #include + #endif + #ifdef HAVE_IRS_NSS_H + #include "irs-nss.h" + #endif]]) + # check which NSS flavour to build AC_MSG_CHECKING([which NSS flavour to build]) AC_ARG_WITH(nss-flavour, -- cgit v1.2.3 From 877af7f76294580505600e63d56a73367547582e Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 4 Oct 2010 19:26:34 +0000 Subject: switch to the same mechanims for pam_ldap.so that was already in use for nss_ldap.so git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1238 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 21 +++++++++++++++++---- pam/Makefile.am | 6 +++--- 2 files changed, 20 insertions(+), 7 deletions(-) diff --git a/configure.ac b/configure.ac index 4954d55..569e9a7 100644 --- a/configure.ac +++ b/configure.ac @@ -234,6 +234,23 @@ AC_MSG_RESULT($NSS_LDAP_SONAME) AC_DEFINE_UNQUOTED(NSS_LDAP_SONAME,"$NSS_LDAP_SONAME",[The SONAME of the NSS library module.]) AC_SUBST(NSS_LDAP_SONAME) +# the SONAME to use for the PAM module +AC_MSG_CHECKING([name of PAM module]) +AC_ARG_WITH(pam-ldap-soname, + AS_HELP_STRING([--with-pam-ldap-soname=SONAME], + [name of PAM module @<:@auto@:>@]), + [ PAM_LDAP_SONAME="$with_pam_ldap_soname" ], + [ PAM_LDAP_SONAME="auto" ]) +if test "x$PAM_LDAP_SONAME" = "xauto" +then + case "$target_os" in + solaris*) PAM_LDAP_SONAME="pam_ldap.so.1" ;; + *) PAM_LDAP_SONAME="pam_ldap.so" ;; + esac +fi +AC_MSG_RESULT($PAM_LDAP_SONAME) +AC_SUBST(PAM_LDAP_SONAME) + # check which modules should be build AC_ARG_WITH(nss-ldap-maps, AS_HELP_STRING([--with-nss-ldap-maps=MAP LIST], @@ -672,15 +689,12 @@ solaris*) if test "$ac_cv_prog_gcc" = yes; then fi nss_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" pam_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" - pam_ldap_so_VERSIONED="pam_ldap.so.1" TARGET_OS="SUNOS" ;; linux*) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" - pam_ldap_so_VERSIONED="pam_ldap.so" TARGET_OS="LINUX" ;; *) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" - pam_ldap_so_VERSIONED="pam_ldap.so" ;; esac AC_SUBST(nss_ldap_so_LD) @@ -688,7 +702,6 @@ AC_SUBST(nss_ldap_so_LDFLAGS) AC_SUBST(pam_ldap_so_LD) AC_SUBST(pam_ldap_so_LDFLAGS) -AC_SUBST(pam_ldap_so_VERSIONED) AC_SUBST(AIX64SUFFIX) AM_CONDITIONAL(GCC, test "$GCC" = "yes") diff --git a/pam/Makefile.am b/pam/Makefile.am index ba07a1f..5e7efed 100644 --- a/pam/Makefile.am +++ b/pam/Makefile.am @@ -38,10 +38,10 @@ endif install-exec-local: install-pam_ldap_so uninstall-local: uninstall-pam_ldap_so -# install pam_ldap.so install-pam_ldap_so: pam_ldap.so + -rm -f $(DESTDIR)/$(PAM_SECLIB_DIR)/$(PAM_LDAP_SONAME) $(mkinstalldirs) $(DESTDIR)/$(PAM_SECLIB_DIR) - $(INSTALL_PROGRAM) pam_ldap.so $(DESTDIR)$(PAM_SECLIB_DIR)/$(pam_ldap_soVERSIONED) + $(INSTALL_PROGRAM) pam_ldap.so $(DESTDIR)$(libdir)/$(PAM_LDAP_SONAME) uninstall-pam_ldap_so: - -rm -f $(DESTDIR)$(PAM_SECLIB_DIR)/$(pam_ldap_so_VERSIONED) + -rm -f $(DESTDIR)/$(PAM_SECLIB_DIR)/$(PAM_LDAP_SONAME) -- cgit v1.2.3 From 6a2c600499039036b1fa0efcd45747b21308375c Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 4 Oct 2010 20:07:40 +0000 Subject: try to make use of UNUSED() consistent git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1241 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 16 ++++++++-------- nss/group.c | 18 +++++++++--------- nss/hosts.c | 16 ++++++++-------- nss/netgroup.c | 10 +++++----- nss/networks.c | 16 ++++++++-------- nss/passwd.c | 16 ++++++++-------- nss/protocols.c | 16 ++++++++-------- nss/rpc.c | 16 ++++++++-------- nss/services.c | 16 ++++++++-------- nss/shadow.c | 14 +++++++------- 10 files changed, 77 insertions(+), 77 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 1fd7756..afe1e3f 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -96,7 +96,7 @@ nss_status_t _nss_ldap_endetherent(void) #define errnop &errno /* map a hostname to the corresponding ethernet address */ -static nss_status_t _xnss_ldap_gethostton_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_gethostton_r(nss_backend_t UNUSED(*be),void *args) { struct etherent result; char buffer[NSS_BUFLEN_ETHERS]; @@ -121,7 +121,7 @@ static nss_status_t _xnss_ldap_gethostton_r(nss_backend_t *UNUSED(be),void *args } /* map an ethernet address to the corresponding hostname */ -static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t UNUSED(*be),void *args) { struct etherent result; struct ether_addr *addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); @@ -153,12 +153,12 @@ static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t *UNUSED(be),void *args return retv; } -static nss_status_t _xnss_ldap_setetherent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(etherentfp); } -static nss_status_t _xnss_ldap_getetherent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getetherent_r(nss_backend_t UNUSED(*be),void *args) { /* TODO: cns3 uses struct ether,verify */ struct etherent result; @@ -176,12 +176,12 @@ static nss_status_t _xnss_ldap_getetherent_r(nss_backend_t *UNUSED(be),void *arg return retv; } -static nss_status_t _xnss_ldap_endetherent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(etherentfp); } -static nss_status_t _xnss_ldap_ethers_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_ethers_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -193,8 +193,8 @@ static nss_backend_op_t ethers_ops[]={ _xnss_ldap_getntohost_r }; -nss_backend_t *_nss_ldap_ethers_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_ethers_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/group.c b/nss/group.c index 2e3013d..be35cb8 100644 --- a/nss/group.c +++ b/nss/group.c @@ -183,7 +183,7 @@ static nss_status_t _nss_nslcd_getgrnam_r( return retv; } -static nss_status_t _xnss_ldap_getgrnam_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getgrnam_r(nss_backend_t UNUSED(*be),void *args) { struct group priv_gr; struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; @@ -231,7 +231,7 @@ static nss_status_t _nss_nslcd_getgrgid_r( return retv; } -static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t UNUSED(*be),void *args) { gid_t gid=NSS_ARGS(args)->key.gid; struct group priv_gr; @@ -270,7 +270,7 @@ static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_setgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(grentfp); } @@ -283,7 +283,7 @@ static nss_status_t _nss_nslcd_getgrent_r( return retv; } -static nss_status_t _xnss_ldap_getgrent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getgrent_r(nss_backend_t UNUSED(*be),void *args) { struct group priv_gr; struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; @@ -321,7 +321,7 @@ static nss_status_t _xnss_ldap_getgrent_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_endgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(grentfp); } @@ -347,7 +347,7 @@ static nss_status_t _xnss_ldap_initgroups_dyn( return retv; } -static nss_status_t _xnss_ldap_getgroupsbymember_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getgroupsbymember_r(nss_backend_t UNUSED(*be),void *args) { struct nss_groupsbymem *argp=(struct nss_groupsbymem *)args; nss_status_t status; @@ -367,7 +367,7 @@ static nss_status_t _xnss_ldap_getgroupsbymember_r(nss_backend_t *UNUSED(be),voi return status; } -static nss_status_t _xnss_ldap_group_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_group_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -383,8 +383,8 @@ static nss_backend_op_t group_ops[]={ _xnss_ldap_getgroupsbymember_r }; -nss_backend_t *_nss_ldap_group_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_group_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/hosts.c b/nss/hosts.c index f2edf22..79d7579 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -248,7 +248,7 @@ nss_status_t _nss_ldap_endhostent(void) #define errnop &errno #define h_errnop &(NSS_ARGS(args)->h_errno) -static nss_status_t _xnss_ldap_gethostbyname_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_gethostbyname_r(nss_backend_t UNUSED(*be),void *args) { struct hostent priv_host; struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; @@ -300,7 +300,7 @@ static nss_status_t _xnss_ldap_gethostbyname_r(nss_backend_t *UNUSED(be),void *a return retv; } -static nss_status_t _xnss_ldap_gethostbyaddr_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_gethostbyaddr_r(nss_backend_t UNUSED(*be),void *args) { struct hostent priv_host; struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; @@ -355,13 +355,13 @@ static nss_status_t _xnss_ldap_gethostbyaddr_r(nss_backend_t *UNUSED(be),void *a } -static nss_status_t _xnss_ldap_sethostent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(hostentfp); } /* this function only returns addresses of the AF_INET address family */ -static nss_status_t _xnss_ldap_gethostent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_gethostent_r(nss_backend_t UNUSED(*be),void *args) { struct hostent priv_host; struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; @@ -409,12 +409,12 @@ static nss_status_t _xnss_ldap_gethostent_r(nss_backend_t *UNUSED(be),void *args return retv; } -static nss_status_t _xnss_ldap_endhostent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endhostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(hostentfp); } -static nss_status_t _xnss_ldap_hosts_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_hosts_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -429,8 +429,8 @@ static nss_backend_op_t host_ops[]={ _xnss_ldap_gethostbyaddr_r }; -nss_backend_t *_nss_ldap_hosts_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_hosts_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/netgroup.c b/nss/netgroup.c index fe3d928..0e41da0 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -146,7 +146,7 @@ struct nss_ldap_netgr_backend }; typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; -static nss_status_t _xnss_ldap_setnetgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { return NSS_STATUS_SUCCESS; } @@ -284,12 +284,12 @@ static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) return status; } -static nss_status_t _xnss_ldap_endnetgrent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(netgrentfp); } -static nss_status_t _xnss_ldap_netgroup_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_netgroup_destr(nss_backend_t *be,void UNUSED(*args)) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)be; /* free list of nested netgroups */ @@ -345,8 +345,8 @@ static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) return stat; } -nss_backend_t *_nss_ldap_netgroup_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_netgroup_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_ldap_netgr_backend_t *be; if (!(be=(nss_ldap_netgr_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/networks.c b/nss/networks.c index 205179a..13b9e7c 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -171,7 +171,7 @@ static nss_status_t _nss_nslcd_getnetbyname_r( return retv; } -static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *args) { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; @@ -235,7 +235,7 @@ static nss_status_t _nss_nslcd_getnetbyaddr_r( /* Note: the af parameter is ignored and is assumed to be AF_INET */ /* TODO: implement handling of af parameter */ -static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *args) { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; @@ -287,7 +287,7 @@ static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t *UNUSED(be),void *ar return status; } -static nss_status_t _xnss_ldap_setnetent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(netentfp); } @@ -301,7 +301,7 @@ static nss_status_t _nss_nslcd_getnetent_r( return retv; } -static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t UNUSED(*be),void *args) { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; @@ -346,12 +346,12 @@ static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_endnetent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(netentfp); } -static nss_status_t _xnss_ldap_networks_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_networks_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -366,8 +366,8 @@ static nss_backend_op_t net_ops[]={ _xnss_ldap_getnetbyaddr_r }; -nss_backend_t *_nss_ldap_networks_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_networks_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/passwd.c b/nss/passwd.c index 5119e1c..2be7a25 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -106,7 +106,7 @@ static nss_status_t _nss_nslcd_getpwnam_r( return retv; } -static nss_status_t _xnss_ldap_getpwnam_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getpwnam_r(nss_backend_t UNUSED(*be),void *args) { struct passwd priv_pw; struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; @@ -155,7 +155,7 @@ static nss_status_t _nss_nslcd_getpwuid_r( } /* open a connection to the nslcd and write the request */ -static nss_status_t _xnss_ldap_setpwent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(pwentfp); } @@ -170,12 +170,12 @@ static nss_status_t _nss_nslcd_getpwent_r( } /* close the stream opened with setpwent() above */ -static nss_status_t _xnss_ldap_endpwent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(pwentfp); } -static nss_status_t _xnss_ldap_getpwuid_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getpwuid_r(nss_backend_t UNUSED(*be),void *args) { struct passwd priv_pw; struct passwd *pw=NSS_ARGS(args)->buf.result ? @@ -209,7 +209,7 @@ static nss_status_t _xnss_ldap_getpwuid_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_getpwent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getpwent_r(nss_backend_t UNUSED(*be),void *args) { struct passwd priv_pw; struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; @@ -241,7 +241,7 @@ static nss_status_t _xnss_ldap_getpwent_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_passwd_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_passwd_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -256,8 +256,8 @@ static nss_backend_op_t passwd_ops[]={ _xnss_ldap_getpwuid_r /* NSS_DBOP_PASSWD_BYUID */ }; -nss_backend_t *_nss_ldap_passwd_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_passwd_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/protocols.c b/nss/protocols.c index 4e3b401..ded7b17 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -99,7 +99,7 @@ static nss_status_t _nss_nslcd_getprotobyname_r( return retv; } -static nss_status_t _xnss_ldap_getprotobyname_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getprotobyname_r(nss_backend_t UNUSED(*be),void *args) { struct protoent priv_proto; struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; @@ -153,7 +153,7 @@ static nss_status_t _nss_nslcd_getprotobynumber_r( return retv; } -static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t UNUSED(*be),void *args) { struct protoent priv_proto; struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; @@ -196,7 +196,7 @@ static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t *UNUSED(be),void return status; } -static nss_status_t _xnss_ldap_setprotoent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); } @@ -209,7 +209,7 @@ static nss_status_t _nss_nslcd_getprotoent_r( return retv; } -static nss_status_t _xnss_ldap_getprotoent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getprotoent_r(nss_backend_t UNUSED(*be),void *args) { struct protoent priv_proto; struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; @@ -251,12 +251,12 @@ static nss_status_t _xnss_ldap_getprotoent_r(nss_backend_t *UNUSED(be),void *arg return status; } -static nss_status_t _xnss_ldap_endprotoent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(protoentfp); } -static nss_status_t _xnss_ldap_protocols_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_protocols_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -271,8 +271,8 @@ static nss_backend_op_t proto_ops[]={ _xnss_ldap_getprotobynumber_r }; -nss_backend_t *_nss_ldap_protocols_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_protocols_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/rpc.c b/nss/rpc.c index c6101dd..374ec12 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -109,7 +109,7 @@ static nss_status_t _nss_nslcd_getrpcbynumber_r( return retv; } -static nss_status_t _xnss_ldap_setrpcent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); } @@ -122,12 +122,12 @@ static nss_status_t _nss_nslcd_getrpcent_r( return retv; } -static nss_status_t _xnss_ldap_endrpcent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(protoentfp); } -static nss_status_t _xnss_ldap_getrpcbyname_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getrpcbyname_r(nss_backend_t UNUSED(*be),void *args) { struct rpcent priv_rpc; struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; @@ -169,7 +169,7 @@ static nss_status_t _xnss_ldap_getrpcbyname_r(nss_backend_t *UNUSED(be),void *ar return status; } -static nss_status_t _xnss_ldap_getrpcbynumber_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getrpcbynumber_r(nss_backend_t UNUSED(*be),void *args) { struct rpcent priv_rpc; struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; @@ -212,7 +212,7 @@ static nss_status_t _xnss_ldap_getrpcbynumber_r(nss_backend_t *UNUSED(be),void * return status; } -static nss_status_t _xnss_ldap_getrpcent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getrpcent_r(nss_backend_t UNUSED(*be),void *args) { struct rpcent priv_rpc; struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; @@ -254,7 +254,7 @@ static nss_status_t _xnss_ldap_getrpcent_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_rpc_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_rpc_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -269,8 +269,8 @@ static nss_backend_op_t rpc_ops[]={ _xnss_ldap_getrpcbynumber_r }; -nss_backend_t *_nss_ldap_rpc_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_rpc_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/services.c b/nss/services.c index fa50776..87a7c2f 100644 --- a/nss/services.c +++ b/nss/services.c @@ -112,7 +112,7 @@ static nss_status_t _nss_nslcd_getservbyport_r( return retv; } -static nss_status_t _xnss_ldap_setservent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); } @@ -125,12 +125,12 @@ static nss_status_t _nss_nslcd_getservent_r( return retv; } -static nss_status_t _xnss_ldap_endservent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(protoentfp); } -static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t UNUSED(*be),void *args) { struct servent priv_service; struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; @@ -169,7 +169,7 @@ static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t *UNUSED(be),void *a return status; } -static nss_status_t _xnss_ldap_getservbyport_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getservbyport_r(nss_backend_t UNUSED(*be),void *args) { int port=NSS_ARGS(args)->key.serv.serv.port; struct servent priv_service; @@ -208,7 +208,7 @@ static nss_status_t _xnss_ldap_getservbyport_r(nss_backend_t *UNUSED(be),void *a return status; } -static nss_status_t _xnss_ldap_getservent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getservent_r(nss_backend_t UNUSED(*be),void *args) { struct servent priv_service; struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; @@ -246,7 +246,7 @@ static nss_status_t _xnss_ldap_getservent_r(nss_backend_t *UNUSED(be),void *args return status; } -static nss_status_t _xnss_ldap_services_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_services_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -261,8 +261,8 @@ static nss_backend_op_t services_ops[]={ _xnss_ldap_getservbyport_r }; -nss_backend_t *_nss_ldap_services_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_services_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/shadow.c b/nss/shadow.c index b417edd..e7ec530 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -95,7 +95,7 @@ static nss_status_t _nss_nslcd_getspnam_r( return retv; } -static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) { struct spwd priv_spwd; struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; @@ -164,7 +164,7 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_setspent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(spentfp); } @@ -177,7 +177,7 @@ static nss_status_t _nss_nslcd_getspent_r( return retv; } -static nss_status_t _xnss_ldap_getspent_r(nss_backend_t *UNUSED(be),void *args) +static nss_status_t _xnss_ldap_getspent_r(nss_backend_t UNUSED(*be),void *args) { struct spwd priv_spwd; struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; @@ -246,12 +246,12 @@ static nss_status_t _xnss_ldap_getspent_r(nss_backend_t *UNUSED(be),void *args) return status; } -static nss_status_t _xnss_ldap_endspent(nss_backend_t *UNUSED(be),void *UNUSED(args)) +static nss_status_t _xnss_ldap_endspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(spentfp); } -static nss_status_t _xnss_ldap_shadow_destr(nss_backend_t *be,void *UNUSED(args)) +static nss_status_t _xnss_ldap_shadow_destr(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; @@ -265,8 +265,8 @@ static nss_backend_op_t shadow_ops[]={ _xnss_ldap_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ }; -nss_backend_t *_nss_ldap_shadow_constr(const char *UNUSED(db_name), - const char *UNUSED(src_name),const char *UNUSED(cfg_args)) +nss_backend_t *_nss_ldap_shadow_constr(const char UNUSED(*db_name), + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) -- cgit v1.2.3 From b863dc2636061c93d74c980e93d54fbf107d0fda Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 8 Oct 2010 10:22:35 +0000 Subject: move missing declarations of ether_ntoa() and ether_aton() to header file so they are available for other sources also git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1243 ef36b2f9-881f-0410-afb5-c4e39611909c --- compat/ether.c | 14 -------------- compat/ether.h | 17 ++++++++++++++++- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/compat/ether.c b/compat/ether.c index f02576c..ec42909 100644 --- a/compat/ether.c +++ b/compat/ether.c @@ -36,13 +36,6 @@ /* these functions are not really reentrant */ #ifndef HAVE_ETHER_NTOA_R - -#if !HAVE_DECL_ETHER_NTOA -/* we define ether_ntoa() here because on some platforms the function is - underfined */ -extern char *ether_ntoa(const struct ether_addr *e); -#endif /* not HAVE_DECL_ETHER_NTOA */ - char *ether_ntoa_r(const struct ether_addr *addr,char *buf) { char *tmp; @@ -55,13 +48,6 @@ char *ether_ntoa_r(const struct ether_addr *addr,char *buf) #endif /* not HAVE_ETHER_NTOA_R */ #ifndef HAVE_ETHER_ATON_R - -#if !HAVE_DECL_ETHER_ATON -/* we define ether_aton() here because on some platforms the function is - underfined */ -extern struct ether_addr *ether_aton(const char *s); -#endif /* not HAVE_DECL_ETHER_ATON */ - struct ether_addr *ether_aton_r(const char *asc,struct ether_addr *addr) { struct ether_addr *tmp; diff --git a/compat/ether.h b/compat/ether.h index 40f1c8c..6dea967 100644 --- a/compat/ether.h +++ b/compat/ether.h @@ -45,5 +45,20 @@ char *ether_ntoa_r(const struct ether_addr *addr,char *buf); struct ether_addr *ether_aton_r(const char *asc,struct ether_addr *addr); #endif /* not HAVE_ETHER_ATON_R */ -#endif /* not COMPAT__ETHER_H */ +#ifdef HAVE_ETHER_NTOA +#if !HAVE_DECL_ETHER_NTOA +/* we define ether_ntoa() here because on some platforms the function is + underfined */ +extern char *ether_ntoa(const struct ether_addr *e); +#endif /* not HAVE_DECL_ETHER_NTOA */ +#endif /* HAVE_ETHER_NTOA */ + +#ifdef HAVE_ETHER_ATON +#if !HAVE_DECL_ETHER_ATON +/* we define ether_aton() here because on some platforms the function is + underfined */ +extern struct ether_addr *ether_aton(const char *s); +#endif /* not HAVE_DECL_ETHER_ATON */ +#endif /* HAVE_ETHER_ATON */ +#endif /* not COMPAT__ETHER_H */ -- cgit v1.2.3 From 5afa471c1b514d82da2fde66fbed699a2e2862fa Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 8 Oct 2010 10:23:06 +0000 Subject: fix test of returnlen struct member check git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1244 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure.ac b/configure.ac index 569e9a7..edc675c 100644 --- a/configure.ac +++ b/configure.ac @@ -380,7 +380,7 @@ then #endif]) # check if struct nss_XbyY_args has a returnlen attribute - AC_CHECK_MEMBER([struct nss_XbyY_args.returnlen],,,[[ + AC_CHECK_MEMBERS([struct nss_XbyY_args.returnlen],,,[[ #ifdef HAVE_NSS_H #include #endif -- cgit v1.2.3 From 611dc583a05914f81c97c165163bcce021b0dfac Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 8 Oct 2010 11:56:56 +0000 Subject: re-introduce {set,get,end}**ent() file handle in Solaris code path and some other miscellaneous small fixes git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1246 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 5 +++++ nss/group.c | 5 +++++ nss/hosts.c | 2 ++ nss/netgroup.c | 5 ++++- nss/networks.c | 8 +++++--- nss/passwd.c | 3 +++ nss/protocols.c | 3 +++ nss/rpc.c | 3 +++ nss/services.c | 21 ++++++++++++--------- nss/shadow.c | 5 ++++- 10 files changed, 46 insertions(+), 14 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 72f1d9c..bc70e81 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -95,7 +95,9 @@ nss_status_t _nss_ldap_endetherent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifndef NSS_BUFLEN_ETHERS #define NSS_BUFLEN_ETHERS 1024 +#endif #define errnop &errno @@ -157,6 +159,9 @@ static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t UNUSED(*be),void *args return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *etherentfp; + static nss_status_t _xnss_ldap_setetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(etherentfp); diff --git a/nss/group.c b/nss/group.c index e100cf6..5a64ca5 100644 --- a/nss/group.c +++ b/nss/group.c @@ -54,8 +54,10 @@ static nss_status_t read_gids( int32_t res=(int32_t)NSLCD_RESULT_BEGIN; int32_t tmpint32,tmp2int32,tmp3int32; gid_t gid; +#ifdef NSS_FLAVOUR_GLIBC gid_t *newgroups; long int newsize; +#endif /* NSS_FLAVOUR_GLIBC */ /* loop over results */ while (res==(int32_t)NSLCD_RESULT_BEGIN) { @@ -275,6 +277,9 @@ static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t UNUSED(*be),void *args) return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *grentfp; + static nss_status_t _xnss_ldap_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(grentfp); diff --git a/nss/hosts.c b/nss/hosts.c index b07e56e..dbd782e 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -355,6 +355,8 @@ static nss_status_t _xnss_ldap_gethostbyaddr_r(nss_backend_t UNUSED(*be),void *a return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *hostentfp; static nss_status_t _xnss_ldap_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { diff --git a/nss/netgroup.c b/nss/netgroup.c index d536b12..1992ece 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -189,6 +189,9 @@ static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) return group; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *netgrentfp; + static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, @@ -196,7 +199,7 @@ static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buf return retv; } -static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(* result)) +static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(*result)) { /* we cannot use NSS_SETENT() here because we have a parameter that is only available in this function */ diff --git a/nss/networks.c b/nss/networks.c index 923f562..d25f8ad 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -179,7 +179,6 @@ static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *ar { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; - char *name=(char *)NSS_ARGS(args)->key.name; int af=NSS_ARGS(args)->key.netaddr.type; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; @@ -191,7 +190,7 @@ static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *ar NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; } - status=_nss_nslcd_getnetbyname_r(name,network,buffer, + status=_nss_nslcd_getnetbyname_r(NSS_ARGS(args)->key.name,network,buffer, buflen,&errno,&h_errno); if (status!=NSS_STATUS_SUCCESS) { @@ -202,7 +201,7 @@ static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *ar { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %s",name,inet_ntoa(network->n_net)); /* ipNetworkNumber */ + sprintf(data_ptr,"%s %s",network->n_name,inet_ntoa(network->n_net)); /* ipNetworkNumber */ if (network->n_aliases) { int i; @@ -291,6 +290,9 @@ static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *ar return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *netentfp; + static nss_status_t _xnss_ldap_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(netentfp); diff --git a/nss/passwd.c b/nss/passwd.c index ec8d1c2..26327e5 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -158,6 +158,9 @@ static nss_status_t _nss_nslcd_getpwuid_r( return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *pwentfp; + /* open a connection to the nslcd and write the request */ static nss_status_t _xnss_ldap_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { diff --git a/nss/protocols.c b/nss/protocols.c index 0ead9a3..b490fc3 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -203,6 +203,9 @@ static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t UNUSED(*be),void return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + static nss_status_t _xnss_ldap_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); diff --git a/nss/rpc.c b/nss/rpc.c index 6a33758..f9ceab9 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -116,6 +116,9 @@ static nss_status_t _nss_nslcd_getrpcbynumber_r( return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + static nss_status_t _xnss_ldap_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); diff --git a/nss/services.c b/nss/services.c index 61e978a..fb709a4 100644 --- a/nss/services.c +++ b/nss/services.c @@ -72,12 +72,12 @@ nss_status_t _nss_ldap_getservbyport_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; +static __thread TFILE *serventfp; /* open request to get all services */ nss_status_t _nss_ldap_setservent(int UNUSED(stayopen)) { - NSS_SETENT(protoentfp); + NSS_SETENT(serventfp); } /* read a single returned service definition */ @@ -85,15 +85,15 @@ nss_status_t _nss_ldap_getservent_r( struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(protoentfp,result,buffer,buflen,errnop)); + NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(serventfp,result,buffer,buflen,errnop)); return retv; } /* close the stream opened by setservent() above */ nss_status_t _nss_ldap_endservent(void) { - NSS_ENDENT(protoentfp); + NSS_ENDENT(serventfp); } #endif /* NSS_FLAVOUR_GLIBC */ @@ -120,22 +120,25 @@ static nss_status_t _nss_nslcd_getservbyport_r( return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *serventfp; + static nss_status_t _xnss_ldap_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_SETENT(protoentfp); + NSS_SETENT(serventfp); } static nss_status_t _nss_nslcd_getservent_r( struct servent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(protoentfp,result,buffer,buflen,errnop)); + NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(serventfp,result,buffer,buflen,errnop)); return retv; } static nss_status_t _xnss_ldap_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_ENDENT(protoentfp); + NSS_ENDENT(serventfp); } static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t UNUSED(*be),void *args) diff --git a/nss/shadow.c b/nss/shadow.c index 935d792..4ccb7b6 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -108,6 +108,7 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; + char field_buf[128]; nss_status_t status; if (NSS_ARGS(args)->buf.buflen<0) { @@ -121,7 +122,6 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); - char field_buf[128]; sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); if (sp->sp_lstchg >= 0) sprintf(field_buf,"%d:",sp->sp_lstchg); @@ -170,6 +170,9 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *spentfp; + static nss_status_t _xnss_ldap_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(spentfp); -- cgit v1.2.3 From bdbeab5693d7c28df3174d5352d5a3ff78b22d92 Mon Sep 17 00:00:00 2001 From: Ted Cheng Date: Sat, 9 Oct 2010 17:26:31 +0000 Subject: nss-pam-ldapd fixes for solaris 10 build git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1247 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 11 +++++------ nss/group.c | 9 +++------ nss/netgroup.c | 9 ++++----- nss/networks.c | 20 +++++++++++++------- nss/passwd.c | 8 ++++---- nss/protocols.c | 8 ++++---- nss/rpc.c | 8 ++++---- nss/services.c | 24 ++++++++++++------------ nss/shadow.c | 10 +++++----- 9 files changed, 54 insertions(+), 53 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index bc70e81..5c1b758 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -42,6 +42,8 @@ static nss_status_t read_etherent( return NSS_STATUS_SUCCESS; } +static __thread TFILE *etherentfp; + #ifdef NSS_FLAVOUR_GLIBC /* map a hostname to the corresponding ethernet address */ @@ -67,7 +69,7 @@ nss_status_t _nss_ldap_getntohost_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *etherentfp; +/* static __thread TFILE *etherentfp; */ /* open a connection to read all ether entries */ nss_status_t _nss_ldap_setetherent(int UNUSED(stayopen)) @@ -97,7 +99,7 @@ nss_status_t _nss_ldap_endetherent(void) #ifndef NSS_BUFLEN_ETHERS #define NSS_BUFLEN_ETHERS 1024 -#endif +#endif /* NSS_BUFLEN_ETHERS */ #define errnop &errno @@ -159,9 +161,6 @@ static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t UNUSED(*be),void *args return retv; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *etherentfp; - static nss_status_t _xnss_ldap_setetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(etherentfp); @@ -169,7 +168,7 @@ static nss_status_t _xnss_ldap_setetherent(nss_backend_t UNUSED(*be),void UNUSED static nss_status_t _xnss_ldap_getetherent_r(nss_backend_t UNUSED(*be),void *args) { - /* TODO: cns3 uses struct ether,verify */ + /* TODO: padl uses struct ether,verify */ struct etherent result; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; diff --git a/nss/group.c b/nss/group.c index 5a64ca5..38757e9 100644 --- a/nss/group.c +++ b/nss/group.c @@ -31,6 +31,8 @@ #include "common.h" #include "compat/attrs.h" +static __thread TFILE *grentfp; + /* read a single group entry from the stream */ static nss_status_t read_group( TFILE *fp,struct group *result, @@ -54,10 +56,8 @@ static nss_status_t read_gids( int32_t res=(int32_t)NSLCD_RESULT_BEGIN; int32_t tmpint32,tmp2int32,tmp3int32; gid_t gid; -#ifdef NSS_FLAVOUR_GLIBC gid_t *newgroups; long int newsize; -#endif /* NSS_FLAVOUR_GLIBC */ /* loop over results */ while (res==(int32_t)NSLCD_RESULT_BEGIN) { @@ -130,7 +130,7 @@ nss_status_t _nss_ldap_getgrgid_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *grentfp; +/* static __thread TFILE *grentfp; */ /* start a request to read all groups */ nss_status_t _nss_ldap_setgrent(int UNUSED(stayopen)) @@ -277,9 +277,6 @@ static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t UNUSED(*be),void *args) return status; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *grentfp; - static nss_status_t _xnss_ldap_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(grentfp); diff --git a/nss/netgroup.c b/nss/netgroup.c index 1992ece..6e31a4b 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -39,6 +39,8 @@ fp=NULL; \ return NSS_STATUS_RETURN; +static __thread TFILE *netgrentfp; + /* function for reading a single result entry */ static nss_status_t read_netgrent( TFILE *fp,struct __netgrent *result, @@ -90,7 +92,7 @@ static nss_status_t read_netgrent( #ifdef NSS_FLAVOUR_GLIBC /* thread-local file pointer to an ongoing request */ -static __thread TFILE *netgrentfp; +/* static __thread TFILE *netgrentfp; */ /* start a request to get a netgroup by name */ nss_status_t _nss_ldap_setnetgrent( @@ -189,9 +191,6 @@ static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) return group; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *netgrentfp; - static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, @@ -199,7 +198,7 @@ static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buf return retv; } -static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(*result)) +static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(* result)) { /* we cannot use NSS_SETENT() here because we have a parameter that is only available in this function */ diff --git a/nss/networks.c b/nss/networks.c index d25f8ad..5266362 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -61,6 +61,9 @@ #define ERROR_OUT_WRITEERROR(fp) \ ERROR_OUT_READERROR(fp) +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *netentfp; + /* read a single network entry from the stream, ignoring entries that are not AF_INET (IPv4), result is stored in result */ static nss_status_t read_netent( @@ -137,7 +140,7 @@ nss_status_t _nss_ldap_getnetbyaddr_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *netentfp; +/* static __thread TFILE *netentfp; */ /* start a request to read all networks */ nss_status_t _nss_ldap_setnetent(int UNUSED(stayopen)) @@ -179,6 +182,7 @@ static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *ar { struct netent priv_network; struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; + char *name=(char *)NSS_ARGS(args)->key.name; int af=NSS_ARGS(args)->key.netaddr.type; char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; @@ -190,7 +194,7 @@ static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *ar NSS_ARGS(args)->erange=1; return NSS_STATUS_TRYAGAIN; } - status=_nss_nslcd_getnetbyname_r(NSS_ARGS(args)->key.name,network,buffer, + status=_nss_nslcd_getnetbyname_r(name,network,buffer, buflen,&errno,&h_errno); if (status!=NSS_STATUS_SUCCESS) { @@ -200,8 +204,10 @@ static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *ar if (!NSS_ARGS(args)->buf.result) { /* result==NULL, return file format */ + struct in_addr priv_in_addr; + priv_in_addr.s_addr = network->n_net; data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %s",network->n_name,inet_ntoa(network->n_net)); /* ipNetworkNumber */ + sprintf(data_ptr,"%s %s",name,inet_ntoa(priv_in_addr)); /* ipNetworkNumber */ if (network->n_aliases) { int i; @@ -290,9 +296,6 @@ static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *ar return status; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *netentfp; - static nss_status_t _xnss_ldap_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(netentfp); @@ -316,6 +319,7 @@ static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t UNUSED(*be),void *args) int h_errno; char *data_ptr; nss_status_t status; + if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; @@ -327,9 +331,11 @@ static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t UNUSED(*be),void *args) if (!NSS_ARGS(args)->buf.result) { /* result==NULL, return file format */ + struct in_addr priv_in_addr; + priv_in_addr.s_addr = network->n_net; data_ptr=(char *)malloc(buflen); sprintf(data_ptr,"%s %s",network->n_name, - inet_ntoa(network->n_net)); /* ipNetworkNumber */ + inet_ntoa(priv_in_addr)); /* ipNetworkNumber */ if (network->n_aliases) { int i; diff --git a/nss/passwd.c b/nss/passwd.c index 26327e5..2b0cddd 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -30,6 +30,9 @@ #include "common.h" #include "compat/attrs.h" +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *pwentfp; + /* read a passwd entry from the stream */ static nss_status_t read_passwd( TFILE *fp,struct passwd *result, @@ -72,7 +75,7 @@ nss_status_t _nss_ldap_getpwuid_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *pwentfp; +/* static __thread TFILE *pwentfp; */ /* open a connection to read all passwd entries */ nss_status_t _nss_ldap_setpwent(int UNUSED(stayopen)) @@ -158,9 +161,6 @@ static nss_status_t _nss_nslcd_getpwuid_r( return retv; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *pwentfp; - /* open a connection to the nslcd and write the request */ static nss_status_t _xnss_ldap_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { diff --git a/nss/protocols.c b/nss/protocols.c index b490fc3..5a89075 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -30,6 +30,9 @@ #include "common.h" #include "compat/attrs.h" +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + /* read a single protocol entry from the stream */ static nss_status_t read_protoent( TFILE *fp,struct protoent *result, @@ -68,7 +71,7 @@ nss_status_t _nss_ldap_getprotobynumber_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; +/* static __thread TFILE *protoentfp; */ /* start a request to read all protocol entries */ nss_status_t _nss_ldap_setprotoent(int UNUSED(stayopen)) @@ -203,9 +206,6 @@ static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t UNUSED(*be),void return status; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; - static nss_status_t _xnss_ldap_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); diff --git a/nss/rpc.c b/nss/rpc.c index f9ceab9..8bc0f7f 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -30,6 +30,9 @@ #include "common.h" #include "compat/attrs.h" +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + /* read a sinlge rpc entry from the stream */ static nss_status_t read_rpcent( TFILE *fp,struct rpcent *result, @@ -68,7 +71,7 @@ nss_status_t _nss_ldap_getrpcbynumber_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; +/* static __thread TFILE *protoentfp; */ /* request a stream to list all rpc entries */ nss_status_t _nss_ldap_setrpcent(int UNUSED(stayopen)) @@ -116,9 +119,6 @@ static nss_status_t _nss_nslcd_getrpcbynumber_r( return retv; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; - static nss_status_t _xnss_ldap_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); diff --git a/nss/services.c b/nss/services.c index fb709a4..ff23243 100644 --- a/nss/services.c +++ b/nss/services.c @@ -30,6 +30,9 @@ #include "common.h" #include "compat/attrs.h" +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + /* read a single services result entry from the stream */ static nss_status_t read_servent( TFILE *fp,struct servent *result, @@ -72,12 +75,12 @@ nss_status_t _nss_ldap_getservbyport_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *serventfp; +/* static __thread TFILE *protoentfp; */ /* open request to get all services */ nss_status_t _nss_ldap_setservent(int UNUSED(stayopen)) { - NSS_SETENT(serventfp); + NSS_SETENT(protoentfp); } /* read a single returned service definition */ @@ -85,15 +88,15 @@ nss_status_t _nss_ldap_getservent_r( struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(serventfp,result,buffer,buflen,errnop)); + NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(protoentfp,result,buffer,buflen,errnop)); return retv; } /* close the stream opened by setservent() above */ nss_status_t _nss_ldap_endservent(void) { - NSS_ENDENT(serventfp); + NSS_ENDENT(protoentfp); } #endif /* NSS_FLAVOUR_GLIBC */ @@ -120,25 +123,22 @@ static nss_status_t _nss_nslcd_getservbyport_r( return retv; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *serventfp; - static nss_status_t _xnss_ldap_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_SETENT(serventfp); + NSS_SETENT(protoentfp); } static nss_status_t _nss_nslcd_getservent_r( struct servent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(serventfp,result,buffer,buflen,errnop)); + NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(protoentfp,result,buffer,buflen,errnop)); return retv; } static nss_status_t _xnss_ldap_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_ENDENT(serventfp); + NSS_ENDENT(protoentfp); } static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t UNUSED(*be),void *args) diff --git a/nss/shadow.c b/nss/shadow.c index 4ccb7b6..7e5e7ce 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -30,6 +30,9 @@ #include "common.h" #include "compat/attrs.h" +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *spentfp; + /* read a single shadow entry from the stream */ static nss_status_t read_spwd( TFILE *fp,struct spwd *result, @@ -63,7 +66,7 @@ nss_status_t _nss_ldap_getspnam_r( } /* thread-local file pointer to an ongoing request */ -static __thread TFILE *spentfp; +/* static __thread TFILE *spentfp; */ /* start listing all shadow users */ nss_status_t _nss_ldap_setspent(int UNUSED(stayopen)) @@ -108,7 +111,6 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; - char field_buf[128]; nss_status_t status; if (NSS_ARGS(args)->buf.buflen<0) { @@ -122,6 +124,7 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); + char field_buf[128]; sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); if (sp->sp_lstchg >= 0) sprintf(field_buf,"%d:",sp->sp_lstchg); @@ -170,9 +173,6 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) return status; } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *spentfp; - static nss_status_t _xnss_ldap_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(spentfp); -- cgit v1.2.3 From b978f0588a933c8a554b7a2a3f7416645d3da758 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Sat, 9 Oct 2010 18:15:40 +0000 Subject: re-introduce rename of protoentfp to serventfp which was introduced in r1246 and accidentally lost in r1247 git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1248 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/services.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/nss/services.c b/nss/services.c index ff23243..76d48f0 100644 --- a/nss/services.c +++ b/nss/services.c @@ -31,7 +31,7 @@ #include "compat/attrs.h" /* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; +static __thread TFILE *serventfp; /* read a single services result entry from the stream */ static nss_status_t read_servent( @@ -80,7 +80,7 @@ nss_status_t _nss_ldap_getservbyport_r( /* open request to get all services */ nss_status_t _nss_ldap_setservent(int UNUSED(stayopen)) { - NSS_SETENT(protoentfp); + NSS_SETENT(serventfp); } /* read a single returned service definition */ @@ -88,15 +88,15 @@ nss_status_t _nss_ldap_getservent_r( struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(protoentfp,result,buffer,buflen,errnop)); + NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(serventfp,result,buffer,buflen,errnop)); return retv; } /* close the stream opened by setservent() above */ nss_status_t _nss_ldap_endservent(void) { - NSS_ENDENT(protoentfp); + NSS_ENDENT(serventfp); } #endif /* NSS_FLAVOUR_GLIBC */ @@ -125,20 +125,20 @@ static nss_status_t _nss_nslcd_getservbyport_r( static nss_status_t _xnss_ldap_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_SETENT(protoentfp); + NSS_SETENT(serventfp); } static nss_status_t _nss_nslcd_getservent_r( struct servent *result,char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(protoentfp,result,buffer,buflen,errnop)); + NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + read_servent(serventfp,result,buffer,buflen,errnop)); return retv; } static nss_status_t _xnss_ldap_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_ENDENT(protoentfp); + NSS_ENDENT(serventfp); } static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t UNUSED(*be),void *args) -- cgit v1.2.3 From a7ac27ed9e31c8b6bfca11b73816d62528cef286 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Sat, 9 Oct 2010 20:10:27 +0000 Subject: have one shared file handle per flavour instead of one global one (for now) and re-introduce some other minor changes that got lost in r1247 git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1249 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 7 ++++--- nss/group.c | 9 ++++++--- nss/netgroup.c | 11 ++++++----- nss/networks.c | 9 ++++----- nss/passwd.c | 8 ++++---- nss/protocols.c | 8 ++++---- nss/rpc.c | 8 ++++---- nss/services.c | 8 ++++---- nss/shadow.c | 12 ++++++------ 9 files changed, 42 insertions(+), 38 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 5c1b758..9965a10 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -42,8 +42,6 @@ static nss_status_t read_etherent( return NSS_STATUS_SUCCESS; } -static __thread TFILE *etherentfp; - #ifdef NSS_FLAVOUR_GLIBC /* map a hostname to the corresponding ethernet address */ @@ -69,7 +67,7 @@ nss_status_t _nss_ldap_getntohost_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *etherentfp; */ +static __thread TFILE *etherentfp; /* open a connection to read all ether entries */ nss_status_t _nss_ldap_setetherent(int UNUSED(stayopen)) @@ -161,6 +159,9 @@ static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t UNUSED(*be),void *args return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *etherentfp; + static nss_status_t _xnss_ldap_setetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(etherentfp); diff --git a/nss/group.c b/nss/group.c index 38757e9..5a64ca5 100644 --- a/nss/group.c +++ b/nss/group.c @@ -31,8 +31,6 @@ #include "common.h" #include "compat/attrs.h" -static __thread TFILE *grentfp; - /* read a single group entry from the stream */ static nss_status_t read_group( TFILE *fp,struct group *result, @@ -56,8 +54,10 @@ static nss_status_t read_gids( int32_t res=(int32_t)NSLCD_RESULT_BEGIN; int32_t tmpint32,tmp2int32,tmp3int32; gid_t gid; +#ifdef NSS_FLAVOUR_GLIBC gid_t *newgroups; long int newsize; +#endif /* NSS_FLAVOUR_GLIBC */ /* loop over results */ while (res==(int32_t)NSLCD_RESULT_BEGIN) { @@ -130,7 +130,7 @@ nss_status_t _nss_ldap_getgrgid_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *grentfp; */ +static __thread TFILE *grentfp; /* start a request to read all groups */ nss_status_t _nss_ldap_setgrent(int UNUSED(stayopen)) @@ -277,6 +277,9 @@ static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t UNUSED(*be),void *args) return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *grentfp; + static nss_status_t _xnss_ldap_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(grentfp); diff --git a/nss/netgroup.c b/nss/netgroup.c index 6e31a4b..e3a86de 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -39,8 +39,6 @@ fp=NULL; \ return NSS_STATUS_RETURN; -static __thread TFILE *netgrentfp; - /* function for reading a single result entry */ static nss_status_t read_netgrent( TFILE *fp,struct __netgrent *result, @@ -92,7 +90,7 @@ static nss_status_t read_netgrent( #ifdef NSS_FLAVOUR_GLIBC /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *netgrentfp; */ +static __thread TFILE *netgrentfp; /* start a request to get a netgroup by name */ nss_status_t _nss_ldap_setnetgrent( @@ -125,7 +123,7 @@ nss_status_t _nss_ldap_getnetgrent_r( } /* close the stream opened with setnetgrent() above */ -nss_status_t _nss_ldap_endnetgrent(struct __netgrent UNUSED(* result)) +nss_status_t _nss_ldap_endnetgrent(struct __netgrent UNUSED(*result)) { NSS_ENDENT(netgrentfp); } @@ -191,6 +189,9 @@ static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) return group; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *netgrentfp; + static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) { NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, @@ -198,7 +199,7 @@ static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buf return retv; } -static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(* result)) +static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(*result)) { /* we cannot use NSS_SETENT() here because we have a parameter that is only available in this function */ diff --git a/nss/networks.c b/nss/networks.c index 5266362..0ba5d09 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -61,9 +61,6 @@ #define ERROR_OUT_WRITEERROR(fp) \ ERROR_OUT_READERROR(fp) -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *netentfp; - /* read a single network entry from the stream, ignoring entries that are not AF_INET (IPv4), result is stored in result */ static nss_status_t read_netent( @@ -140,7 +137,7 @@ nss_status_t _nss_ldap_getnetbyaddr_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *netentfp; */ +static __thread TFILE *netentfp; /* start a request to read all networks */ nss_status_t _nss_ldap_setnetent(int UNUSED(stayopen)) @@ -296,6 +293,9 @@ static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *ar return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *netentfp; + static nss_status_t _xnss_ldap_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(netentfp); @@ -319,7 +319,6 @@ static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t UNUSED(*be),void *args) int h_errno; char *data_ptr; nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) { NSS_ARGS(args)->erange=1; diff --git a/nss/passwd.c b/nss/passwd.c index 2b0cddd..26327e5 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -30,9 +30,6 @@ #include "common.h" #include "compat/attrs.h" -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *pwentfp; - /* read a passwd entry from the stream */ static nss_status_t read_passwd( TFILE *fp,struct passwd *result, @@ -75,7 +72,7 @@ nss_status_t _nss_ldap_getpwuid_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *pwentfp; */ +static __thread TFILE *pwentfp; /* open a connection to read all passwd entries */ nss_status_t _nss_ldap_setpwent(int UNUSED(stayopen)) @@ -161,6 +158,9 @@ static nss_status_t _nss_nslcd_getpwuid_r( return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *pwentfp; + /* open a connection to the nslcd and write the request */ static nss_status_t _xnss_ldap_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { diff --git a/nss/protocols.c b/nss/protocols.c index 5a89075..b490fc3 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -30,9 +30,6 @@ #include "common.h" #include "compat/attrs.h" -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; - /* read a single protocol entry from the stream */ static nss_status_t read_protoent( TFILE *fp,struct protoent *result, @@ -71,7 +68,7 @@ nss_status_t _nss_ldap_getprotobynumber_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *protoentfp; */ +static __thread TFILE *protoentfp; /* start a request to read all protocol entries */ nss_status_t _nss_ldap_setprotoent(int UNUSED(stayopen)) @@ -206,6 +203,9 @@ static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t UNUSED(*be),void return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + static nss_status_t _xnss_ldap_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); diff --git a/nss/rpc.c b/nss/rpc.c index 8bc0f7f..f9ceab9 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -30,9 +30,6 @@ #include "common.h" #include "compat/attrs.h" -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; - /* read a sinlge rpc entry from the stream */ static nss_status_t read_rpcent( TFILE *fp,struct rpcent *result, @@ -71,7 +68,7 @@ nss_status_t _nss_ldap_getrpcbynumber_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *protoentfp; */ +static __thread TFILE *protoentfp; /* request a stream to list all rpc entries */ nss_status_t _nss_ldap_setrpcent(int UNUSED(stayopen)) @@ -119,6 +116,9 @@ static nss_status_t _nss_nslcd_getrpcbynumber_r( return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *protoentfp; + static nss_status_t _xnss_ldap_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); diff --git a/nss/services.c b/nss/services.c index 76d48f0..fb709a4 100644 --- a/nss/services.c +++ b/nss/services.c @@ -30,9 +30,6 @@ #include "common.h" #include "compat/attrs.h" -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *serventfp; - /* read a single services result entry from the stream */ static nss_status_t read_servent( TFILE *fp,struct servent *result, @@ -75,7 +72,7 @@ nss_status_t _nss_ldap_getservbyport_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *protoentfp; */ +static __thread TFILE *serventfp; /* open request to get all services */ nss_status_t _nss_ldap_setservent(int UNUSED(stayopen)) @@ -123,6 +120,9 @@ static nss_status_t _nss_nslcd_getservbyport_r( return retv; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *serventfp; + static nss_status_t _xnss_ldap_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(serventfp); diff --git a/nss/shadow.c b/nss/shadow.c index 7e5e7ce..403dd3a 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -30,9 +30,6 @@ #include "common.h" #include "compat/attrs.h" -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *spentfp; - /* read a single shadow entry from the stream */ static nss_status_t read_spwd( TFILE *fp,struct spwd *result, @@ -66,7 +63,7 @@ nss_status_t _nss_ldap_getspnam_r( } /* thread-local file pointer to an ongoing request */ -/* static __thread TFILE *spentfp; */ +static __thread TFILE *spentfp; /* start listing all shadow users */ nss_status_t _nss_ldap_setspent(int UNUSED(stayopen)) @@ -111,6 +108,7 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; + char field_buf[128]; nss_status_t status; if (NSS_ARGS(args)->buf.buflen<0) { @@ -124,7 +122,6 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); - char field_buf[128]; sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); if (sp->sp_lstchg >= 0) sprintf(field_buf,"%d:",sp->sp_lstchg); @@ -173,6 +170,9 @@ static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) return status; } +/* thread-local file pointer to an ongoing request */ +static __thread TFILE *spentfp; + static nss_status_t _xnss_ldap_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(spentfp); @@ -193,6 +193,7 @@ static nss_status_t _xnss_ldap_getspent_r(nss_backend_t UNUSED(*be),void *args) char *buffer=NSS_ARGS(args)->buf.buffer; size_t buflen=NSS_ARGS(args)->buf.buflen; char *data_ptr; + char field_buf[128]; nss_status_t status; if (NSS_ARGS(args)->buf.buflen<0) { @@ -206,7 +207,6 @@ static nss_status_t _xnss_ldap_getspent_r(nss_backend_t UNUSED(*be),void *args) { /* result==NULL, return file format */ data_ptr=(char *)malloc(buflen); - char field_buf[128]; sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); if (sp->sp_lstchg >= 0) sprintf(field_buf,"%d:",sp->sp_lstchg); -- cgit v1.2.3 From 40421dc3652ce39150a79a1c75f6ddc20839b9de Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Sun, 10 Oct 2010 19:18:43 +0000 Subject: put all locgic on how to link in configure script (remove stuff from Makefile.ams) and make choice for NSS and PAM components independently (renaming and removing version scripts as needed) git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1250 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 77 ++++++++++++++++++---------------------------- nss/Makefile.am | 13 +------- nss/exports.glibc | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++ nss/nss_ldap.map | 88 ----------------------------------------------------- pam/Makefile.am | 8 +---- pam/exports.solaris | 16 ---------- 6 files changed, 120 insertions(+), 170 deletions(-) create mode 100644 nss/exports.glibc delete mode 100644 nss/nss_ldap.map delete mode 100644 pam/exports.solaris diff --git a/configure.ac b/configure.ac index edc675c..61cb551 100644 --- a/configure.ac +++ b/configure.ac @@ -298,23 +298,6 @@ then AC_DEFINE(__thread,,[Define to empty if compiler does not support `__thread' keyword.]) fi -# check how to pass a symbol map to the linker -AC_MSG_CHECKING([how linker wants the symbol map]) -if $CC -Wl,--help 2>&1 | grep -- --version-script >/dev/null -then - VERSION_SCRIPT_FLAG="-Wl,--version-script," - AC_SUBST(VERSION_SCRIPT_FLAG) - AC_MSG_RESULT([--version-script]) -elif $CC -Wl,--help 2>&1 | grep -- '-M mapfile' >/dev/null -then - VERSION_SCRIPT_FLAG="-Wl,-M," - AC_SUBST(VERSION_SCRIPT_FLAG) - AC_MSG_RESULT([-M]) -else - AC_MSG_RESULT([unknown, not passing symbol map]) -fi -AM_CONDITIONAL([HAVE_VERSION_SCRIPT_FLAG], [test "x${VERSION_SCRIPT_FLAG}" != x]) - # check for support for the struct ether_addr structure AC_CHECK_TYPES(struct ether_addr,,,[ #include @@ -427,6 +410,21 @@ then NSS_MODULE_OBJS="`echo "$with_nss_ldap_maps " | sed 's/,/ /g;s/ */.$(OBJEXT) /g'`" AC_SUBST(NSS_MODULE_OBJS) + # find out how to link the library + case "$target_os" in + solaris*) + if test "$ac_cv_prog_gcc" = yes; then + nss_ldap_so_LD="/usr/ccs/bin/ld" + AC_SUBST(nss_ldap_so_LD) + fi + nss_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" + ;; + *) + nss_ldap_so_LDFLAGS="-shared -Wl,-h,\$(NSS_LDAP_SONAME) -Wl,--version-script,\$(srcdir)/exports.glibc" + ;; + esac + AC_SUBST(nss_ldap_so_LDFLAGS) + # restore CFLAGS and LIBS CFLAGS="$nss_save_CFLAGS" LIBS="$nss_save_LIBS" @@ -464,6 +462,21 @@ then AC_REPLACE_FUNCS(pam_get_authtok pam_prompt) AC_CHECK_FUNCS(pam_modutil_getpwnam pam_syslog) + # find out how to link the library + case "$target_os" in + solaris*) + if test "$ac_cv_prog_gcc" = yes; then + pam_ldap_so_LD="/usr/ccs/bin/ld" + AC_SUBST(pam_ldap_so_LD) + fi + pam_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/pam_ldap.map -G" + ;; + *) + pam_ldap_so_LDFLAGS="-shared -Wl,--version-script,\$(srcdir)/pam_ldap.map" + ;; + esac + AC_SUBST(pam_ldap_so_LDFLAGS) + # restore CFLAGS and LIBS CFLAGS="$pam_save_CFLAGS" LIBS="$pam_save_LIBS" @@ -680,36 +693,6 @@ then AC_SUBST(nslcd_LIBS) fi -# Always use native linker on Solaris -# but only invoke directly if compiling with gcc (?) -case "$target_os" in -solaris*) if test "$ac_cv_prog_gcc" = yes; then - nss_ldap_so_LD="/usr/ccs/bin/ld" - pam_ldap_so_LD="/usr/ccs/bin/ld" - fi - nss_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" - pam_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" - TARGET_OS="SUNOS" ;; -linux*) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" - pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic -Wl,--version-script,\$(srcdir)/exports.linux" - TARGET_OS="LINUX" ;; -*) nss_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" - pam_ldap_so_LDFLAGS="-shared -Wl,-Bdynamic" -esac - -AC_SUBST(nss_ldap_so_LD) -AC_SUBST(nss_ldap_so_LDFLAGS) - -AC_SUBST(pam_ldap_so_LD) -AC_SUBST(pam_ldap_so_LDFLAGS) - -AC_SUBST(AIX64SUFFIX) -AM_CONDITIONAL(GCC, test "$GCC" = "yes") -AM_CONDITIONAL(GLIBC, test "$target_os" = "linux" -o "$target_os" = "linux-gnu") -AM_CONDITIONAL(USE_NATIVE_LINKER, test -n "$nss_ldap_so_LD") -AM_CONDITIONAL(SUNOS, test "x${TARGET_OS}" = "xSUNOS") -AM_CONDITIONAL(LINUX, test "x${TARGET_OS}" = "xLINUX") - # generate files AC_CONFIG_FILES([Makefile compat/Makefile common/Makefile nss/Makefile pam/Makefile nslcd/Makefile man/Makefile tests/Makefile]) diff --git a/nss/Makefile.am b/nss/Makefile.am index bd89de4..712c20e 100644 --- a/nss/Makefile.am +++ b/nss/Makefile.am @@ -34,18 +34,7 @@ EXTRA_nss_ldap_so_SOURCES = aliases.c ethers.c group.c hosts.c netgroup.c \ nss_ldap_so_DEPENDENCIES = $(NSS_MODULE_OBJS) nss_ldap_so_LDADD = ../common/libtio.a ../common/libprot.a $(NSS_MODULE_OBJS) -nss_ldap_so_LDFLAGS = @nss_ldap_so_LDFLAGS@ -if HAVE_VERSION_SCRIPT_FLAG -nss_ldap_so_LDFLAGS += $(VERSION_SCRIPT_FLAG)\$(srcdir)/nss_ldap.map -endif - -if USE_NATIVE_LINKER -nss_ldap_so_LINK = @nss_ldap_so_LD@ @nss_ldap_so_LDFLAGS@ -o $@ -else -nss_ldap_so_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAG) -o $@ -endif - -EXTRA_DIST = nss_ldap.map +EXTRA_DIST = exports.glibc exports.solaris install-exec-local: install-nss_ldap_so uninstall-local: uninstall-nss_ldap_so diff --git a/nss/exports.glibc b/nss/exports.glibc new file mode 100644 index 0000000..0ed5ea2 --- /dev/null +++ b/nss/exports.glibc @@ -0,0 +1,88 @@ +EXPORTED { + + # published NSS service functions + global: + + # flag to enable or disable lookups + _nss_ldap_enablelookups; + + # aliases - mail aliases + _nss_ldap_getaliasbyname_r; + _nss_ldap_setaliasent; + _nss_ldap_getaliasent_r; + _nss_ldap_endaliasent; + + # ethers - ethernet numbers + _nss_ldap_gethostton_r; + _nss_ldap_getntohost_r; + _nss_ldap_setetherent; + _nss_ldap_getetherent_r; + _nss_ldap_endetherent; + + # group - groups of users + _nss_ldap_getgrnam_r; + _nss_ldap_getgrgid_r; + _nss_ldap_initgroups_dyn; + _nss_ldap_setgrent; + _nss_ldap_getgrent_r; + _nss_ldap_endgrent; + + # hosts - host names and numbers + _nss_ldap_gethostbyname_r; + _nss_ldap_gethostbyname2_r; + _nss_ldap_gethostbyaddr_r; + _nss_ldap_sethostent; + _nss_ldap_gethostent_r; + _nss_ldap_endhostent; + + # netgroup - list of host and users + _nss_ldap_setnetgrent; + _nss_ldap_getnetgrent_r; + _nss_ldap_endnetgrent; + + # networks - network names and numbers + _nss_ldap_getnetbyname_r; + _nss_ldap_getnetbyaddr_r; + _nss_ldap_setnetent; + _nss_ldap_getnetent_r; + _nss_ldap_endnetent; + + # passwd - user database and passwords + _nss_ldap_getpwnam_r; + _nss_ldap_getpwuid_r; + _nss_ldap_setpwent; + _nss_ldap_getpwent_r; + _nss_ldap_endpwent; + + # protocols - network protocols + _nss_ldap_getprotobyname_r; + _nss_ldap_getprotobynumber_r; + _nss_ldap_setprotoent; + _nss_ldap_getprotoent_r; + _nss_ldap_endprotoent; + + # rpc - remote procedure call names and numbers + _nss_ldap_getrpcbyname_r; + _nss_ldap_getrpcbynumber_r; + _nss_ldap_setrpcent; + _nss_ldap_getrpcent_r; + _nss_ldap_endrpcent; + + # services - network services + _nss_ldap_getservbyname_r; + _nss_ldap_getservbyport_r; + _nss_ldap_setservent; + _nss_ldap_getservent_r; + _nss_ldap_endservent; + + # shadow - extended user information + _nss_ldap_getspnam_r; + _nss_ldap_setspent; + _nss_ldap_getspent_r; + _nss_ldap_endspent; + + # everything else should not be exported + local: + *; + +}; diff --git a/nss/nss_ldap.map b/nss/nss_ldap.map deleted file mode 100644 index 0ed5ea2..0000000 --- a/nss/nss_ldap.map +++ /dev/null @@ -1,88 +0,0 @@ -EXPORTED { - - # published NSS service functions - global: - - # flag to enable or disable lookups - _nss_ldap_enablelookups; - - # aliases - mail aliases - _nss_ldap_getaliasbyname_r; - _nss_ldap_setaliasent; - _nss_ldap_getaliasent_r; - _nss_ldap_endaliasent; - - # ethers - ethernet numbers - _nss_ldap_gethostton_r; - _nss_ldap_getntohost_r; - _nss_ldap_setetherent; - _nss_ldap_getetherent_r; - _nss_ldap_endetherent; - - # group - groups of users - _nss_ldap_getgrnam_r; - _nss_ldap_getgrgid_r; - _nss_ldap_initgroups_dyn; - _nss_ldap_setgrent; - _nss_ldap_getgrent_r; - _nss_ldap_endgrent; - - # hosts - host names and numbers - _nss_ldap_gethostbyname_r; - _nss_ldap_gethostbyname2_r; - _nss_ldap_gethostbyaddr_r; - _nss_ldap_sethostent; - _nss_ldap_gethostent_r; - _nss_ldap_endhostent; - - # netgroup - list of host and users - _nss_ldap_setnetgrent; - _nss_ldap_getnetgrent_r; - _nss_ldap_endnetgrent; - - # networks - network names and numbers - _nss_ldap_getnetbyname_r; - _nss_ldap_getnetbyaddr_r; - _nss_ldap_setnetent; - _nss_ldap_getnetent_r; - _nss_ldap_endnetent; - - # passwd - user database and passwords - _nss_ldap_getpwnam_r; - _nss_ldap_getpwuid_r; - _nss_ldap_setpwent; - _nss_ldap_getpwent_r; - _nss_ldap_endpwent; - - # protocols - network protocols - _nss_ldap_getprotobyname_r; - _nss_ldap_getprotobynumber_r; - _nss_ldap_setprotoent; - _nss_ldap_getprotoent_r; - _nss_ldap_endprotoent; - - # rpc - remote procedure call names and numbers - _nss_ldap_getrpcbyname_r; - _nss_ldap_getrpcbynumber_r; - _nss_ldap_setrpcent; - _nss_ldap_getrpcent_r; - _nss_ldap_endrpcent; - - # services - network services - _nss_ldap_getservbyname_r; - _nss_ldap_getservbyport_r; - _nss_ldap_setservent; - _nss_ldap_getservent_r; - _nss_ldap_endservent; - - # shadow - extended user information - _nss_ldap_getspnam_r; - _nss_ldap_setspent; - _nss_ldap_getspent_r; - _nss_ldap_endspent; - - # everything else should not be exported - local: - *; - -}; diff --git a/pam/Makefile.am b/pam/Makefile.am index e6674fe..dca583f 100644 --- a/pam/Makefile.am +++ b/pam/Makefile.am @@ -28,13 +28,7 @@ pam_ldap_so_SOURCES = ../nslcd.h ../common/nslcd-prot.h \ pam_ldap_so_LDADD = ../common/libtio.a ../common/libprot.a -lpam \ ../compat/libcompat.a -if USE_NATIVE_LINKER -pam_ldap_so_LINK = @pam_ldap_so_LD@ @pam_ldap_so_LDFLAGS@ -o $@ -else -pam_ldap_so_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAG) -o $@ -endif - -EXTRA_DIST = pam_ldap.map exports.solaris +EXTRA_DIST = pam_ldap.map install-exec-local: install-pam_ldap_so uninstall-local: uninstall-pam_ldap_so diff --git a/pam/exports.solaris b/pam/exports.solaris deleted file mode 100644 index 02bcf2a..0000000 --- a/pam/exports.solaris +++ /dev/null @@ -1,16 +0,0 @@ -pam_ldap.so { - - # published PAM service functions - global: - pam_sm_acct_mgmt; - pam_sm_authenticate; - pam_sm_chauthtok; - pam_sm_close_session; - pam_sm_open_session; - pam_sm_setcred; - - # everything else should not be exported - local: - *; - -}; -- cgit v1.2.3 From 002ed77f4772e6d028bd4ef7900c518005bc913e Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Sun, 10 Oct 2010 20:21:39 +0000 Subject: generate Solaris NSS functions using same macros that are used for Glibc, splitting functionality to make a string representation into a single function per NSS map git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1258 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/aliases.c | 6 +- nss/common.h | 96 +++++++++++++-------- nss/ethers.c | 139 +++++++++++------------------- nss/group.c | 256 +++++++++++++++++--------------------------------------- nss/hosts.c | 240 +++++++++++++++++++--------------------------------- nss/netgroup.c | 36 ++++---- nss/networks.c | 228 ++++++++++++------------------------------------- nss/passwd.c | 190 ++++++++++++----------------------------- nss/protocols.c | 221 +++++++++++++----------------------------------- nss/rpc.c | 222 ++++++++++++++---------------------------------- nss/services.c | 213 ++++++++++++++-------------------------------- nss/shadow.c | 240 ++++++++++++++++++---------------------------------- 12 files changed, 655 insertions(+), 1432 deletions(-) diff --git a/nss/aliases.c b/nss/aliases.c index 8c99f91..bbbb1ee 100644 --- a/nss/aliases.c +++ b/nss/aliases.c @@ -52,10 +52,9 @@ nss_status_t _nss_ldap_getaliasbyname_r( const char *name,struct aliasent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_ALIAS_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_ALIAS_BYNAME, name, read_aliasent(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -72,9 +71,8 @@ nss_status_t _nss_ldap_getaliasent_r( struct aliasent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(aliasentfp,NSLCD_ACTION_ALIAS_ALL,buffer,buflen, + NSS_GETENT(aliasentfp,NSLCD_ACTION_ALIAS_ALL, read_aliasent(aliasentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened with setaliasent() above */ diff --git a/nss/common.h b/nss/common.h index 93c7e2d..ffb718f 100644 --- a/nss/common.h +++ b/nss/common.h @@ -79,6 +79,45 @@ void _nss_ldap_namelist_destroy(struct name_list **head); fp=NULL; \ return NSS_STATUS_NOTFOUND; +/* These are some general macros that are used to build parts of the + genral macros below. */ + +/* check to see if we should answer NSS requests */ +#define NSS_AVAILCHECK \ + if (!_nss_ldap_enablelookups) \ + return NSS_STATUS_UNAVAIL; + +#ifdef NSS_FLAVOUR_GLIBC + +/* extra definitions we need (nothing for Glibc) */ +#define NSS_EXTRA_DEFS ; + +/* check validity of passed buffer (Glibc flavour) */ +#define NSS_BUFCHECK \ + if ((buffer==NULL)||(buflen<=0)) \ + { \ + *errnop=EINVAL; \ + return NSS_STATUS_UNAVAIL; \ + } + +#endif /* NSS_FLAVOUR_GLIBC */ + +#ifdef NSS_FLAVOUR_SOLARIS + +/* extra definitions we need (Solaris NSS functions don't pass errno) */ +#define NSS_EXTRA_DEFS \ + int *errnop=&(errno); + +/* check validity of passed buffer (Solaris flavour) */ +#define NSS_BUFCHECK \ + if ((NSS_ARGS(args)->buf.buffer==NULL)||(NSS_ARGS(args)->buf.buflen<=0)) \ + { \ + NSS_ARGS(args)->erange=1; \ + return NSS_STATUS_TRYAGAIN; \ + } \ + +#endif /* NSS_FLAVOUR_SOLARIS */ + /* The following macros to automatically generate get..byname(), get..bynumber(), setent(), getent() and endent() function bodies. These functions have very common code so this can @@ -92,18 +131,13 @@ void _nss_ldap_namelist_destroy(struct name_list **head); the result structure, the user buffer with length and the errno to return. This macro should be called through some of the customized ones below. */ -#define NSS_BYGEN(action,buffer,buflen,writefn,readfn) \ +#define NSS_BYGEN(action,writefn,readfn) \ TFILE *fp; \ int32_t tmpint32; \ nss_status_t retv; \ - if (!_nss_ldap_enablelookups) \ - return NSS_STATUS_UNAVAIL; \ - /* check that we have a valid buffer */ \ - if ((buffer==NULL)||(buflen<=0)) \ - { \ - *errnop=EINVAL; \ - return NSS_STATUS_UNAVAIL; \ - } \ + NSS_EXTRA_DEFS; \ + NSS_AVAILCHECK; \ + NSS_BUFCHECK; \ /* open socket and write request */ \ NSLCD_REQUEST(fp,action,writefn); \ /* read response */ \ @@ -111,28 +145,28 @@ void _nss_ldap_namelist_destroy(struct name_list **head); retv=readfn; \ /* close socket and we're done */ \ if ((retv==NSS_STATUS_SUCCESS)||(retv==NSS_STATUS_TRYAGAIN)) \ - (void)tio_close(fp); + (void)tio_close(fp); \ + return retv; /* This macro can be used to generate a get..byname() function body. */ -#define NSS_BYNAME(action,buffer,buflen,name,readfn) \ - NSS_BYGEN(action,buffer,buflen,WRITE_STRING(fp,name),readfn) +#define NSS_BYNAME(action,name,readfn) \ + NSS_BYGEN(action,WRITE_STRING(fp,name),readfn) /* This macro can be used to generate a get..by..() function body where the value that is the key has the specified type. */ -#define NSS_BYTYPE(action,buffer,buflen,val,type,readfn) \ - NSS_BYGEN(action,buffer,buflen,WRITE_TYPE(fp,val,type),readfn) +#define NSS_BYTYPE(action,val,type,readfn) \ + NSS_BYGEN(action,WRITE_TYPE(fp,val,type),readfn) /* This macro can be used to generate a get..by..() function body where the value should be passed as an int32_t. */ -#define NSS_BYINT32(action,buffer,buflen,val,readfn) \ - NSS_BYGEN(action,buffer,buflen,WRITE_INT32(fp,val),readfn) +#define NSS_BYINT32(action,val,readfn) \ + NSS_BYGEN(action,WRITE_INT32(fp,val),readfn) /* This macro generates a simple setent() function body. This closes any open streams so that NSS_GETENT() can open a new file. */ #define NSS_SETENT(fp) \ - if (!_nss_ldap_enablelookups) \ - return NSS_STATUS_UNAVAIL; \ + NSS_AVAILCHECK; \ if (fp!=NULL) \ { \ (void)tio_close(fp); \ @@ -143,24 +177,12 @@ void _nss_ldap_namelist_destroy(struct name_list **head); /* This macro generates a getent() function body. If the stream is not yet open, a new one is opened, a request is written and a check is done for a response header. A single entry is read with the readfn() function. */ -#define NSS_GETENT(fp,action,buffer,buflen,readfn) \ +#define NSS_GETENT(fp,action,readfn) \ int32_t tmpint32; \ nss_status_t retv; \ - if (!_nss_ldap_enablelookups) \ - return NSS_STATUS_UNAVAIL; \ - /* check that we have a valid buffer */ \ - if ((buffer==NULL)||(buflen<=0)) \ - { \ - /* close stream */ \ - if (fp!=NULL) \ - { \ - (void)tio_close(fp); \ - fp=NULL; \ - } \ - /* indicate error */ \ - *errnop=EINVAL; \ - return NSS_STATUS_UNAVAIL; \ - } \ + NSS_EXTRA_DEFS; \ + NSS_AVAILCHECK; \ + NSS_BUFCHECK; \ /* check that we have a valid file descriptor */ \ if (fp==NULL) \ { \ @@ -186,13 +208,13 @@ void _nss_ldap_namelist_destroy(struct name_list **head); } \ } \ else if (retv!=NSS_STATUS_SUCCESS) \ - fp=NULL; /* file should be closed by now */ + fp=NULL; /* file should be closed by now */ \ + return retv; /* This macro generates a endent() function body. This just closes the stream. */ #define NSS_ENDENT(fp) \ - if (!_nss_ldap_enablelookups) \ - return NSS_STATUS_UNAVAIL; \ + NSS_AVAILCHECK; \ if (fp!=NULL) \ { \ (void)tio_close(fp); \ diff --git a/nss/ethers.c b/nss/ethers.c index 9965a10..56cc0ee 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -49,10 +49,9 @@ nss_status_t _nss_ldap_gethostton_r( const char *name,struct etherent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME, name, read_etherent(fp,result,buffer,buflen,errnop)); - return retv; } /* map an ethernet address to the corresponding hostname */ @@ -60,10 +59,9 @@ nss_status_t _nss_ldap_getntohost_r( const struct ether_addr *addr,struct etherent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER,buffer,buflen, + NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER, *addr,uint8_t[6], read_etherent(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -80,9 +78,8 @@ nss_status_t _nss_ldap_getetherent_r( struct etherent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(etherentfp,NSLCD_ACTION_ETHER_ALL,buffer,buflen, + NSS_GETENT(etherentfp,NSLCD_ACTION_ETHER_ALL, read_etherent(etherentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened with setetherent() above */ @@ -99,107 +96,69 @@ nss_status_t _nss_ldap_endetherent(void) #define NSS_BUFLEN_ETHERS 1024 #endif /* NSS_BUFLEN_ETHERS */ -#define errnop &errno - -/* map a hostname to the corresponding ethernet address */ -static nss_status_t _xnss_ldap_gethostton_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t read_etherstring(TFILE *fp,nss_XbyY_args_t *args) { + /* TODO: padl uses struct ether, verify */ struct etherent result; - char buffer[NSS_BUFLEN_ETHERS]; - const char *name=(NSS_ARGS(args)->key.name); - NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME,buffer,sizeof(buffer), - name, - read_etherent(fp,&result,buffer,sizeof(buffer),&errno)); - if (retv==NSS_STATUS_SUCCESS) - { - if (NSS_ARGS(args)->buf.result==NULL) - { - strcpy(NSS_ARGS(args)->buf.buffer,ether_ntoa(&result.e_addr)); - NSS_ARGS(args)->buf.buflen=strlen(NSS_ARGS(args)->buf.buffer); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - return retv; - } - memcpy(NSS_ARGS(args)->buf.result,&result.e_addr,sizeof(result.e_addr)); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return retv; + nss_status_t retv; + char *buffer; + size_t buflen; + /* read the etherent */ + retv=read_etherent(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + /* TODO: OpenSolaris expects " " */ + /* This output is handled correctly by NSCD,but not */ + /* when NSCD is off. Not an issue with NSS_LDAP,but */ + /* with the frontend. */ + sprintf(buffer,"%s %s",ether_ntoa(&result.e_addr),result.e_name); + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -/* map an ethernet address to the corresponding hostname */ -static nss_status_t _xnss_ldap_getntohost_r(nss_backend_t UNUSED(*be),void *args) -{ - struct etherent result; - struct ether_addr *addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); - char buffer[NSS_BUFLEN_ETHERS]; - NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER,buffer,sizeof(buffer), - *addr,uint8_t[6], - read_etherent(fp,&result,buffer,sizeof(buffer),&errno)); - if (retv==NSS_STATUS_SUCCESS) - { - if (NSS_ARGS(args)->buf.buffer!=NULL) - { - /* TODO: OpenSolaris expects " " */ - /* This output is handled correctly by NSCD,but not */ - /* when NSCD is off. Not an issue with NSS_LDAP,but */ - /* with the frontend. */ - sprintf(NSS_ARGS(args)->buf.buffer,"%s %s",ether_ntoa(addr),result.e_name); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - return retv; - } - memcpy(NSS_ARGS(args)->buf.buffer,result.e_name,strlen(result.e_name)+1); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->buf.buflen=strlen(result.e_name); /* ?? */ - } - else - { - NSS_ARGS(args)->returnval=NULL; - } - return retv; -} +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_etherent(fp,(struct etherent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_etherstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *etherentfp; - -static nss_status_t _xnss_ldap_setetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +/* map a hostname to the corresponding ethernet address */ +static nss_status_t get_gethostton(nss_backend_t UNUSED(*be),void *args) { - NSS_SETENT(etherentfp); + NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } -static nss_status_t _xnss_ldap_getetherent_r(nss_backend_t UNUSED(*be),void *args) -{ - /* TODO: padl uses struct ether,verify */ - struct etherent result; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - NSS_GETENT(etherentfp,NSLCD_ACTION_ETHER_ALL,buffer,buflen, - read_etherent(etherentfp,&result,buffer,buflen,&errno)); - if (retv==NSS_STATUS_SUCCESS) - { - memcpy(NSS_ARGS(args)->buf.result,&result.e_addr,sizeof(result.e_addr)); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - else - NSS_ARGS(args)->returnval=NULL; - return retv; -} - -static nss_status_t _xnss_ldap_endetherent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +/* map an ethernet address to the corresponding hostname */ +static nss_status_t get_getntohost(nss_backend_t UNUSED(*be),void *args) { - NSS_ENDENT(etherentfp); + struct ether_addr *addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); + NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER, + *addr,uint8_t[6], + READ_RESULT(fp)); } -static nss_status_t _xnss_ldap_ethers_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t ethers_ops[]={ - _xnss_ldap_ethers_destr, - _xnss_ldap_gethostton_r, - _xnss_ldap_getntohost_r + destructor, + get_gethostton, + get_getntohost }; nss_backend_t *_nss_ldap_ethers_constr(const char UNUSED(*db_name), diff --git a/nss/group.c b/nss/group.c index 5a64ca5..cd68689 100644 --- a/nss/group.c +++ b/nss/group.c @@ -112,10 +112,9 @@ nss_status_t _nss_ldap_getgrnam_r( const char *name,struct group *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME, name, read_group(fp,result,buffer,buflen,errnop)); - return retv; } /* get a group entry by numeric gid */ @@ -123,10 +122,9 @@ nss_status_t _nss_ldap_getgrgid_r( gid_t gid,struct group *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID,buffer,buflen, + NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID, gid,gid_t, read_group(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -143,9 +141,8 @@ nss_status_t _nss_ldap_getgrent_r( struct group *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL,buffer,buflen, + NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL, read_group(grentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened with setgrent() above */ @@ -170,227 +167,124 @@ nss_status_t _nss_ldap_initgroups_dyn( const char *user,gid_t skipgroup,long int *start, long int *size,gid_t **groupsp,long int limit,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER,groupsp,*size, +/* temporarily map the buffer and buflen names so the check in NSS_BYNAME + for validity of the buffer works (renaming the parameters may cause + confusion) */ +#define buffer groupsp +#define buflen *size + NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER, user, read_gids(fp,skipgroup,start,size,groupsp,limit,errnop)); - return retv; +#undef buffer +#undef buflen } #endif /* NSS_FLAVOUR_GLIBC */ #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getgrnam_r( - const char *name,struct group *result,char *buffer, - size_t buflen,int *errnop) +static nss_status_t read_groupstring(TFILE *fp,nss_XbyY_args_t *args) { - NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME,buffer,buflen, - name, - read_group(fp,result,buffer,buflen,errnop)); - return retv; -} - -static nss_status_t _xnss_ldap_getgrnam_r(nss_backend_t UNUSED(*be),void *args) -{ - struct group priv_gr; - struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; - char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - nss_status_t status; - status=_nss_nslcd_getgrnam_r(NSS_ARGS(args)->key.name,gr,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:%d:",gr->gr_name,gr->gr_passwd,(int) gr->gr_gid); - if (gr->gr_mem) + struct group result; + nss_status_t retv; + char *buffer; + size_t buflen; + int i; + /* read the groupent */ + retv=read_group(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + sprintf(buffer,"%s:%s:%d:",result.gr_name,result.gr_passwd,(int)result.gr_gid); + if (result.gr_mem) + for (i=0;result.gr_mem[i];i++) { - int i; - for (i=0; gr->gr_mem[i]; i++) - { - if (i) - strcat(data_ptr,","); - strcat(data_ptr,gr->gr_mem[i]); - } + if (i) + strcat(buffer,","); + strcat(buffer,result.gr_mem[i]); } - strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -static nss_status_t _nss_nslcd_getgrgid_r( - gid_t gid,struct group *result,char *buffer, - size_t buflen,int *errnop) +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_group(fp,(struct group *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_groupstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +static nss_status_t get_getgrnam_r(nss_backend_t UNUSED(*be),void *args) { - NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID,buffer,buflen, - gid,gid_t, - read_group(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } -static nss_status_t _xnss_ldap_getgrgid_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t get_getgrgid_r(nss_backend_t UNUSED(*be),void *args) { - gid_t gid=NSS_ARGS(args)->key.gid; - struct group priv_gr; - struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; - char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - nss_status_t status; - status=_nss_nslcd_getgrgid_r(gid,gr,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:%d:",gr->gr_name,gr->gr_passwd,(int) gr->gr_gid); - if (gr->gr_mem) - { - int i; - for (i=0; gr->gr_mem[i]; i++) - { - if (i) - strcat(data_ptr,","); - strcat(data_ptr,gr->gr_mem[i]); - } - } - strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID, + NSS_ARGS(args)->key.gid,gid_t, + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *grentfp; -static nss_status_t _xnss_ldap_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(grentfp); } -static nss_status_t _nss_nslcd_getgrent_r( - struct group *result,char *buffer,size_t buflen,int *errnop) +static nss_status_t get_getgrent_r(nss_backend_t UNUSED(*be),void *args) { - NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL,buffer,buflen, - read_group(grentfp,result,buffer,buflen,errnop)); - return retv; + NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL, + READ_RESULT(grentfp)); } -static nss_status_t _xnss_ldap_getgrent_r(nss_backend_t UNUSED(*be),void *args) -{ - struct group priv_gr; - struct group *gr=NSS_ARGS(args)->buf.result?(struct group *)NSS_ARGS(args)->buf.result:&priv_gr; - char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - nss_status_t status; - status=_nss_nslcd_getgrent_r(gr,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:%d:",gr->gr_name,gr->gr_passwd,(int)gr->gr_gid); - if (gr->gr_mem) - { - int i; - for (i=0; gr->gr_mem[i]; i++) - { - if (i) - strcat(data_ptr,","); - strcat(data_ptr,gr->gr_mem[i]); - } - } - strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_endgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(grentfp); } -/* this function returns a list of groups, documentation for the - interface is scarce (any pointers are welcome) but this is - what is assumed the parameters mean: - - user IN - the user name to find groups for - skipgroup IN - a group to not include in the list - *start IN/OUT - where to write in the array, is incremented - **groupsp IN/OUT - pointer to the array of returned groupids - limit IN - the maxium size of the array - *errnop OUT - for returning errno -*/ -static nss_status_t _xnss_ldap_initgroups_dyn( +/* +static nss_status_t get_initgroups_dyn( const char *user,gid_t skipgroup,long int *start, gid_t **groupsp,long int limit,int *errnop) -{ - NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER,groupsp,limit, - user, - read_gids(fp,skipgroup,start,&limit,groupsp,limit,errnop)); - return retv; -} - -static nss_status_t _xnss_ldap_getgroupsbymember_r(nss_backend_t UNUSED(*be),void *args) +*/ +static nss_status_t get_getgroupsbymember_r(nss_backend_t UNUSED(*be),void *args) { struct nss_groupsbymem *argp=(struct nss_groupsbymem *)args; - nss_status_t status; - long int limit=(long int)argp->maxgids; long int start=(long int)argp->numgids; - gid_t skipgroup; - if (start>0) - skipgroup=argp->gid_array[0]; - status=_xnss_ldap_initgroups_dyn( - argp->username, - (start>0)?skipgroup:(gid_t)-1, - &start, - (gid_t **)&argp->gid_array, - limit, - &errno); - argp->numgids=(int)start; - return status; + gid_t skipgroup=(start>0)?argp->gid_array[0]:(gid_t)-1; + NSS_BYNAME(NSLCD_ACTION_GROUP_BYMEMBER, + argp->username, + read_gids(fp,skipgroup,&start,NULL,(gid_t **)&argp->gid_array,argp->maxgids,&errno); + argp->numgids=(int)start;); } -static nss_status_t _xnss_ldap_group_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t group_ops[]={ - _xnss_ldap_group_destr, - _xnss_ldap_endgrent, - _xnss_ldap_setgrent, - _xnss_ldap_getgrent_r, - _xnss_ldap_getgrnam_r, - _xnss_ldap_getgrgid_r, - _xnss_ldap_getgroupsbymember_r + destructor, + get_endgrent, + get_setgrent, + get_getgrent_r, + get_getgrnam_r, + get_getgrgid_r, + get_getgroupsbymember_r }; nss_backend_t *_nss_ldap_group_constr(const char UNUSED(*db_name), diff --git a/nss/hosts.c b/nss/hosts.c index dbd782e..3037a10 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -184,10 +184,9 @@ nss_status_t _nss_ldap_gethostbyname2_r( const char *name,int af,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME, name, read_hostent_erronempty(fp,af,result,buffer,buflen,errnop,h_errnop)); - return retv; } /* this function just calls the gethostbyname2() variant with the address @@ -211,10 +210,9 @@ nss_status_t _nss_ldap_gethostbyaddr_r( const void *addr,socklen_t len,int af,struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR,buffer,buflen, + NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR, WRITE_ADDRESS(fp,af,len,addr), read_hostent_erronempty(fp,af,result,buffer,buflen,errnop,h_errnop)) - return retv; } /* thread-local file pointer to an ongoing request */ @@ -230,9 +228,8 @@ nss_status_t _nss_ldap_gethostent_r( struct hostent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL,buffer,buflen, + NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL, read_hostent_nextonempty(hostentfp,AF_INET,result,buffer,buflen,errnop,h_errnop)); - return retv; } /* close the stream opened with sethostent() above */ @@ -245,191 +242,122 @@ nss_status_t _nss_ldap_endhostent(void) #ifdef NSS_FLAVOUR_SOLARIS -/* hack to set the correct errno and h_errno */ -#define errnop &errno -#define h_errnop &(NSS_ARGS(args)->h_errno) - -static nss_status_t _xnss_ldap_gethostbyname_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t read_hoststring(TFILE *fp,nss_XbyY_args_t *args,int erronempty) { - struct hostent priv_host; - struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; - char *data_ptr; - NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen, - NSS_ARGS(args)->key.name, - read_hostent_erronempty(fp,AF_INET,host,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,h_errnop)); + struct hostent result; + nss_status_t retv; + char *buffer; + size_t buflen; + int i; + /* read the hostent */ + if (erronempty) + retv=read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); + else + retv=read_hostent_nextonempty(fp,NSS_ARGS(args)->key.hostaddr.type,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); if (retv!=NSS_STATUS_SUCCESS) return retv; - if (!NSS_ARGS(args)->buf.result) + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + if (result.h_addr_list) { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(NSS_ARGS(args)->buf.buflen); - if (host->h_addr_list) + struct in_addr in; + (void)memcpy(&in.s_addr,result.h_addr_list[0],sizeof(in.s_addr)); + sprintf(buffer,"%s %s",inet_ntoa(in),result.h_name); + if (result.h_aliases) { - int i; - struct in_addr in; - (void)memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); - sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); - if (host->h_aliases) + int j; + for (j=0;result.h_aliases[j];j++) { - int j; - for (j=0; host->h_aliases[j]; j++) - { - strcat(data_ptr," "); - strcat(data_ptr,host->h_aliases[j]); - } - } - for (i=1; host->h_addr_list[i]; i++) - { - (void) memcpy(&in.s_addr,host->h_addr_list[i],sizeof(in.s_addr)); - strcat(data_ptr,"\n"); - strcat(data_ptr,inet_ntoa(in)); - strcat(data_ptr," "); - strcat(data_ptr,host->h_name); - /* TODO: aliases only supplied to the first address */ - /* need review */ + strcat(buffer," "); + strcat(buffer,result.h_aliases[j]); } } - strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* NSS_ARGS(args)->buf.result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + for (i=1;result.h_addr_list[i];i++) + { + (void)memcpy(&in.s_addr,result.h_addr_list[i],sizeof(in.s_addr)); + strcat(buffer,"\n"); + strcat(buffer,inet_ntoa(in)); + strcat(buffer," "); + strcat(buffer,result.h_name); + /* TODO: aliases only supplied to the first address */ + /* need review */ + } } - return retv; + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -static nss_status_t _xnss_ldap_gethostbyaddr_r(nss_backend_t UNUSED(*be),void *args) -{ - struct hostent priv_host; - struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; - char *data_ptr; - NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen, - WRITE_ADDRESS(fp,NSS_ARGS(args)->key.hostaddr.type,NSS_ARGS(args)->key.hostaddr.len,NSS_ARGS(args)->key.hostaddr.addr), - read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,host,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,h_errnop)) +#define READ_RESULT_ERRONEMPTY(fp) \ + NSS_ARGS(args)->buf.result? \ + read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ + read_hoststring(fp,args,1); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result +#define READ_RESULT_NEXTONEMPTY(fp) \ + NSS_ARGS(args)->buf.result? \ + read_hostent_nextonempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ + read_hoststring(fp,args,0); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result - if (retv!=NSS_STATUS_SUCCESS) - return retv; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(NSS_ARGS(args)->buf.buflen); - if (host->h_addr_list) - { - int i; - struct in_addr in; - (void)memcpy(&in.s_addr,host->h_addr_list[0],sizeof(in.s_addr)); - sprintf(data_ptr,"%s %s",inet_ntoa(in),host->h_name); - if (host->h_aliases) - { - int j; - for (j=0;host->h_aliases[j];j++) - { - strcat(data_ptr," "); - strcat(data_ptr,host->h_aliases[j]); - } - } - for (i=1;host->h_addr_list[i];i++) - { - (void)memcpy(&in.s_addr,host->h_addr_list[i],sizeof(in.s_addr)); - strcat(data_ptr,"\n"); - strcat(data_ptr,inet_ntoa(in)); - strcat(data_ptr," "); - strcat(data_ptr,host->h_name); - /* TODO: aliases only supplied to the first address */ - /* need review */ - } - } - strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* NSS_ARGS(args)->buf.result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return retv; + +/* hack to set the correct errno and h_errno */ +#define h_errnop &(NSS_ARGS(args)->h_errno) + +static nss_status_t get_gethostbyname(nss_backend_t UNUSED(*be),void *args) +{ + NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT_ERRONEMPTY(fp)); +} + +static nss_status_t get_gethostbyaddr(nss_backend_t UNUSED(*be),void *args) +{ + NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR, + WRITE_ADDRESS(fp,NSS_ARGS(args)->key.hostaddr.type,NSS_ARGS(args)->key.hostaddr.len,NSS_ARGS(args)->key.hostaddr.addr), + READ_RESULT_ERRONEMPTY(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *hostentfp; -static nss_status_t _xnss_ldap_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(hostentfp); } -/* this function only returns addresses of the AF_INET address family */ -static nss_status_t _xnss_ldap_gethostent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t get_gethostent(nss_backend_t UNUSED(*be),void *args) { - struct hostent priv_host; - struct hostent *host=NSS_ARGS(args)->buf.result?NSS_ARGS(args)->buf.result:&priv_host; - char *data_ptr; - NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen, - read_hostent_nextonempty(hostentfp,AF_INET,host,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,h_errnop)); - if (retv!=NSS_STATUS_SUCCESS) - return retv; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(NSS_ARGS(args)->buf.buflen); - if (host->h_addr_list) - { - int i; - sprintf(data_ptr,"%s %s",host->h_addr_list[0],host->h_name); - if (host->h_aliases) - { - int j; - for (j=0; host->h_aliases[j]; j++) - { - strcat(data_ptr," "); - strcat(data_ptr,host->h_aliases[j]); - } - } - for (i=1; host->h_addr_list[i]; i++) - { - strcat(data_ptr,"\n"); - strcat(data_ptr,host->h_addr_list[i]); - strcat(data_ptr," "); - strcat(data_ptr,host->h_name); - /* TODO: aliases only supplied to the first address */ - /* need review */ - } - } - strcpy(NSS_ARGS(args)->buf.buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { /* NSS_ARGS(args)->buf.result!=NULL */ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return retv; + NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL, + READ_RESULT_NEXTONEMPTY(hostentfp)); } -static nss_status_t _xnss_ldap_endhostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endhostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(hostentfp); } -static nss_status_t _xnss_ldap_hosts_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t host_ops[]={ - _xnss_ldap_hosts_destr, - _xnss_ldap_endhostent, - _xnss_ldap_sethostent, - _xnss_ldap_gethostent_r, - _xnss_ldap_gethostbyname_r, - _xnss_ldap_gethostbyaddr_r + destructor, + get_endhostent, + get_sethostent, + get_gethostent, + get_gethostbyname, + get_gethostbyaddr }; nss_backend_t *_nss_ldap_hosts_constr(const char UNUSED(*db_name), diff --git a/nss/netgroup.c b/nss/netgroup.c index e3a86de..4ad50e7 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -117,9 +117,8 @@ nss_status_t _nss_ldap_getnetgrent_r( struct __netgrent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, + NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME, read_netgrent(netgrentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened with setnetgrent() above */ @@ -192,13 +191,6 @@ static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) /* thread-local file pointer to an ongoing request */ static __thread TFILE *netgrentfp; -static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,int *errnop) -{ - NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,buffer,buflen, - read_netgrent(netgrentfp,result,buffer,buflen,errnop)); - return retv; -} - static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(*result)) { /* we cannot use NSS_SETENT() here because we have a parameter that is only @@ -206,8 +198,7 @@ static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent U int32_t tmpint32; int errnocp; int *errnop; - if (!_nss_ldap_enablelookups) - return NSS_STATUS_UNAVAIL; + NSS_AVAILCHECK; errnop=&errnocp; /* check parameter */ if ((group==NULL)||(group[0]=='\0')) @@ -217,6 +208,12 @@ static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent U return NSS_STATUS_SUCCESS; } +static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,void *args) +{ + NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME, + read_netgrent(netgrentfp,result,buffer,buflen,errnop)); +} + static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_be; @@ -224,15 +221,14 @@ static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) struct __netgrent result; char *group=NULL; int done=0; - int err; nss_status_t status,rc; args->status=NSS_NETGR_NO; while (!done) { - status=_nss_nslcd_getnetgrent_r(&result,args->buffer,args->buflen,&err); + status=_nss_nslcd_getnetgrent_r(&result,args->buffer,args->buflen,args); if (status!=NSS_STATUS_SUCCESS) { - if (err==ENOENT) + if (errno==ENOENT) { /* done with the current netgroup */ /* explore nested netgroup,if any */ @@ -298,7 +294,7 @@ static nss_status_t _xnss_ldap_endnetgrent(nss_backend_t UNUSED(*be),void UNUSED NSS_ENDENT(netgrentfp); } -static nss_status_t _xnss_ldap_netgroup_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)be; /* free list of nested netgroups */ @@ -311,7 +307,7 @@ static nss_status_t _xnss_ldap_netgroup_destr(nss_backend_t *be,void UNUSED(*arg static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args); static nss_backend_op_t netgroup_ops[]={ - _xnss_ldap_netgroup_destr, /* NSS_DBOP_DESTRUCTOR */ + destructor, /* NSS_DBOP_DESTRUCTOR */ _xnss_ldap_endnetgrent, /* NSS_DBOP_ENDENT */ _xnss_ldap_setnetgrent, /* NSS_DBOP_SETNET */ _xnss_ldap_getnetgrent_r, /* NSS_DBOP_GETENT */ @@ -325,7 +321,6 @@ static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) struct nss_setnetgrent_args *args; nss_ldap_netgr_backend_t *ngbe; struct __netgrent result; - char *group=NULL; args=(struct nss_setnetgrent_args *)_args; args->iterator=NULL; /* initialize */ ngbe=(nss_ldap_netgr_backend_t *)malloc(sizeof(*ngbe)); @@ -336,18 +331,17 @@ static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) ngbe->state=NULL; ngbe->known_groups=NULL; ngbe->needed_groups=NULL; - group=(char *)args->netgroup; - stat=_nss_nslcd_setnetgrent(group,&result); + stat=_nss_nslcd_setnetgrent(args->netgroup,&result); if (stat!=NSS_STATUS_SUCCESS) { free(be); return stat; } /* place the group name in known list */ - stat=_nss_ldap_namelist_push(&ngbe->known_groups,group); + stat=_nss_ldap_namelist_push(&ngbe->known_groups,args->netgroup); if (stat!=NSS_STATUS_SUCCESS) { - _xnss_ldap_netgroup_destr((nss_backend_t *)ngbe,NULL); + destructor((nss_backend_t *)ngbe,NULL); return stat; } args->iterator=(nss_backend_t *)ngbe; diff --git a/nss/networks.c b/nss/networks.c index 0ba5d09..f5a5a3d 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -118,10 +118,9 @@ nss_status_t _nss_ldap_getnetbyname_r( const char *name,struct netent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME, name, read_netent(fp,result,buffer,buflen,errnop,h_errnop)); - return retv; } /* Note: the af parameter is ignored and is assumed to be AF_INET */ @@ -130,10 +129,9 @@ nss_status_t _nss_ldap_getnetbyaddr_r( uint32_t addr,int UNUSED(af),struct netent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR,buffer,buflen, + NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR, WRITE_ADDRESS(fp,addr), read_netent(fp,result,buffer,buflen,errnop,h_errnop)) - return retv; } /* thread-local file pointer to an ongoing request */ @@ -150,9 +148,8 @@ nss_status_t _nss_ldap_getnetent_r( struct netent *result, char *buffer,size_t buflen,int *errnop,int *h_errnop) { - NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL,buffer,buflen, + NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL, read_netent(netentfp,result,buffer,buflen,errnop,h_errnop)); - return retv; } /* close the stream opened by setnetent() above */ @@ -165,132 +162,61 @@ nss_status_t _nss_ldap_endnetent(void) #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getnetbyname_r( - const char *name,struct netent *result,char *buffer, - size_t buflen,int *errnop,int *h_errnop) -{ - NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME,buffer,buflen, - name, - read_netent(fp,result,buffer,buflen,errnop,h_errnop)); - return retv; -} - -static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t read_netentstring(TFILE *fp,nss_XbyY_args_t *args) { - struct netent priv_network; - struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; - char *name=(char *)NSS_ARGS(args)->key.name; - int af=NSS_ARGS(args)->key.netaddr.type; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - int h_errno; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getnetbyname_r(name,network,buffer, - buflen,&errno,&h_errno); - if (status!=NSS_STATUS_SUCCESS) - { - NSS_ARGS(args)->h_errno=h_errno; - return status; - } - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - struct in_addr priv_in_addr; - priv_in_addr.s_addr = network->n_net; - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %s",name,inet_ntoa(priv_in_addr)); /* ipNetworkNumber */ - if (network->n_aliases) + struct netent result; + nss_status_t retv; + char *buffer; + size_t buflen; + int i; + struct in_addr priv_in_addr; + /* read the netent */ + retv=read_netent(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + priv_in_addr.s_addr = result.n_net; + sprintf(buffer,"%s %s",result.n_name,inet_ntoa(priv_in_addr)); /* ipNetworkNumber */ + if (result.n_aliases) + for (i=0;result.n_aliases[i];i++) { - int i; - for (i=0; network->n_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,network->n_aliases[i]); - } + strcat(buffer," "); + strcat(buffer,result.n_aliases[i]); } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - NSS_ARGS(args)->h_errno=h_errno; - return status; + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -/* Note: the af parameter is ignored and is assumed to be AF_INET */ -/* TODO: implement handling of af parameter */ -static nss_status_t _nss_nslcd_getnetbyaddr_r( - uint32_t addr,int UNUSED(af),struct netent *result, - char *buffer,size_t buflen,int *errnop,int *h_errnop) +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_netent(fp,(struct netent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ + read_netentstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +/* more of a dirty hack */ +#define h_errnop (&(NSS_ARGS(args)->h_errno)) + +static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *args) { - NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR,buffer,buflen, - WRITE_ADDRESS(fp,addr), - read_netent(fp,result,buffer,buflen,errnop,h_errnop)) - return retv; + NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } -/* Note: the af parameter is ignored and is assumed to be AF_INET */ -/* TODO: implement handling of af parameter */ static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *args) { - struct netent priv_network; - struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; - int addr=NSS_ARGS(args)->key.netaddr.net; /* is an addr an int? */ - int af=NSS_ARGS(args)->key.netaddr.type; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - int h_errno; - char *data_ptr; - struct in_addr in_addr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getnetbyaddr_r(addr,af,network,buffer,buflen,&errno,&h_errno); - if (status!=NSS_STATUS_SUCCESS) - { - NSS_ARGS(args)->h_errno=h_errno; - return status; - } - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - (void)memcpy(&in_addr.s_addr,addr,sizeof(in_addr.s_addr)); - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %s",network->n_name, - inet_ntoa(in_addr)); /* ipNetworkNumber */ - if (network->n_aliases) - { - int i; - for (i=0; network->n_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,network->n_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - NSS_ARGS(args)->h_errno=h_errno; - return status; + NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR, + WRITE_ADDRESS(fp,NSS_ARGS(args)->key.netaddr.net), + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ @@ -301,60 +227,10 @@ static nss_status_t _xnss_ldap_setnetent(nss_backend_t UNUSED(*be),void UNUSED(* NSS_SETENT(netentfp); } -static nss_status_t _nss_nslcd_getnetent_r( - struct netent *result,char *buffer,size_t buflen, - int *errnop,int *h_errnop) -{ - NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL,buffer,buflen, - read_netent(netentfp,result,buffer,buflen,errnop,h_errnop)); - return retv; -} - static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t UNUSED(*be),void *args) { - struct netent priv_network; - struct netent *network=NSS_ARGS(args)->buf.result?(struct netent *)NSS_ARGS(args)->buf.result:&priv_network; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - int h_errno; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getnetent_r(network,buffer,buflen,&errno,&h_errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - struct in_addr priv_in_addr; - priv_in_addr.s_addr = network->n_net; - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %s",network->n_name, - inet_ntoa(priv_in_addr)); /* ipNetworkNumber */ - if (network->n_aliases) - { - int i; - for (i=0; network->n_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,network->n_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - NSS_ARGS(args)->h_errno=h_errno; - return status; + NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL, + READ_RESULT(netentfp)); } static nss_status_t _xnss_ldap_endnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) @@ -362,14 +238,14 @@ static nss_status_t _xnss_ldap_endnetent(nss_backend_t UNUSED(*be),void UNUSED(* NSS_ENDENT(netentfp); } -static nss_status_t _xnss_ldap_networks_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t net_ops[]={ - _xnss_ldap_networks_destr, + destructor, _xnss_ldap_endnetent, _xnss_ldap_setnetent, _xnss_ldap_getnetent_r, diff --git a/nss/passwd.c b/nss/passwd.c index 26327e5..112cfa7 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -54,10 +54,9 @@ nss_status_t _nss_ldap_getpwnam_r( const char *name,struct passwd *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME, name, read_passwd(fp,result,buffer,buflen,errnop)); - return retv; } /* get a single passwd entry by uid */ @@ -65,10 +64,9 @@ nss_status_t _nss_ldap_getpwuid_r( uid_t uid,struct passwd *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID,buffer,buflen, + NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID, uid,uid_t, read_passwd(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -85,9 +83,8 @@ nss_status_t _nss_ldap_getpwent_r( struct passwd *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL,buffer,buflen, + NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL, read_passwd(pwentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened with setpwent() above */ @@ -100,167 +97,88 @@ nss_status_t _nss_ldap_endpwent(void) #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getpwnam_r( - const char *name,struct passwd *result,char *buffer,size_t buflen, - int *errnop) -{ - NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME,buffer,buflen, - name, - read_passwd(fp,result,buffer,buflen,errnop)); - return retv; +static nss_status_t read_passwdstring(TFILE *fp,nss_XbyY_args_t *args) +{ + struct passwd result; + nss_status_t retv; + char *buffer; + size_t buflen; + /* read the passwd */ + retv=read_passwd(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + sprintf(buffer,"%s:%s:%d:%d:%s:%s:%s", + result.pw_name,result.pw_passwd,(int)result.pw_uid,(int)result.pw_gid,result.pw_gecos, + result.pw_dir,result.pw_shell); + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -static nss_status_t _xnss_ldap_getpwnam_r(nss_backend_t UNUSED(*be),void *args) +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_passwd(fp,(struct passwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_passwdstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +static nss_status_t get_getpwnam(nss_backend_t UNUSED(*be),void *args) { - struct passwd priv_pw; - struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - status=NSS_STATUS_TRYAGAIN; - return status; - } - status=_nss_nslcd_getpwnam_r(NSS_ARGS(args)->key.name,pw,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:%d:%d:%s:%s:%s", - pw->pw_name,"x",(int) pw->pw_uid,(int) pw->pw_gid,pw->pw_gecos, - pw->pw_dir,pw->pw_shell); - /* copy file-format data to buffer provided by front-end */ - strcpy(buffer,data_ptr); - if (data_ptr) - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } -static nss_status_t _nss_nslcd_getpwuid_r( - uid_t uid,struct passwd *result,char *buffer, - size_t buflen,int *errnop) +static nss_status_t get_getpwuid(nss_backend_t UNUSED(*be),void *args) { - NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID,buffer,buflen, - uid,uid_t, - read_passwd(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID, + NSS_ARGS(args)->key.uid,uid_t, + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *pwentfp; /* open a connection to the nslcd and write the request */ -static nss_status_t _xnss_ldap_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(pwentfp); } /* read password data from an opened stream */ -static nss_status_t _nss_nslcd_getpwent_r( - struct passwd *result,char *buffer,size_t buflen,int *errnop) +static nss_status_t get_getpwent(nss_backend_t UNUSED(*be),void *args) { - NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL,buffer,buflen, - read_passwd(pwentfp,result,buffer,buflen,errnop)); - return retv; + NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL, + READ_RESULT(pwentfp)); } /* close the stream opened with setpwent() above */ -static nss_status_t _xnss_ldap_endpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(pwentfp); } -static nss_status_t _xnss_ldap_getpwuid_r(nss_backend_t UNUSED(*be),void *args) -{ - struct passwd priv_pw; - struct passwd *pw=NSS_ARGS(args)->buf.result ? - NSS_ARGS(args)->buf.result : &priv_pw; - uid_t uid=NSS_ARGS(args)->key.uid; - char *data_ptr; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - nss_status_t status; - status=_nss_nslcd_getpwuid_r(uid,pw,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc((size_t) buflen); - sprintf(data_ptr,"%s:%s:%d:%d:%s:%s:%s", - pw->pw_name,"x",(int) pw->pw_uid,(int) pw->pw_gid,pw->pw_gecos, - pw->pw_dir,pw->pw_shell); - /* copy file-format data to buffer provided by front-end */ - strcpy(buffer,data_ptr); - if (data_ptr) - free((void *)data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_getpwent_r(nss_backend_t UNUSED(*be),void *args) -{ - struct passwd priv_pw; - struct passwd *pw=NSS_ARGS(args)->buf.result?(struct passwd *)NSS_ARGS(args)->buf.result:&priv_pw; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - status=_nss_nslcd_getpwent_r(pw,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:%d:%d:%s:%s:%s", - pw->pw_name,"x",(int) pw->pw_uid,(int) pw->pw_gid,pw->pw_gecos, - pw->pw_dir,pw->pw_shell); - /* copy file-format data to buffer provided by front-end */ - strcpy(buffer,data_ptr); - if (data_ptr) - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_passwd_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t passwd_ops[]={ - _xnss_ldap_passwd_destr, - _xnss_ldap_endpwent, /* NSS_DBOP_ENDENT */ - _xnss_ldap_setpwent, /* NSS_DBOP_SETENT */ - _xnss_ldap_getpwent_r, /* NSS_DBOP_GETENT */ - _xnss_ldap_getpwnam_r, /* NSS_DBOP_PASSWD_BYNAME */ - _xnss_ldap_getpwuid_r /* NSS_DBOP_PASSWD_BYUID */ + destructor, + get_endpwent, /* NSS_DBOP_ENDENT */ + get_setpwent, /* NSS_DBOP_SETENT */ + get_getpwent, /* NSS_DBOP_GETENT */ + get_getpwnam, /* NSS_DBOP_PASSWD_BYNAME */ + get_getpwuid /* NSS_DBOP_PASSWD_BYUID */ }; nss_backend_t *_nss_ldap_passwd_constr(const char UNUSED(*db_name), diff --git a/nss/protocols.c b/nss/protocols.c index b490fc3..8c55cc3 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -50,10 +50,9 @@ nss_status_t _nss_ldap_getprotobyname_r( const char *name,struct protoent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME, name, read_protoent(fp,result,buffer,buflen,errnop)); - return retv; } /* get a protocol entry by number */ @@ -61,10 +60,9 @@ nss_status_t _nss_ldap_getprotobynumber_r( int number,struct protoent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER,buffer,buflen, + NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER, number, read_protoent(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -81,9 +79,8 @@ nss_status_t _nss_ldap_getprotoent_r( struct protoent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL,buffer,buflen, + NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL, read_protoent(protoentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened by setprotoent() above */ @@ -96,196 +93,98 @@ nss_status_t _nss_ldap_endprotoent(void) #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getprotobyname_r( - const char *name,struct protoent *result,char *buffer, - size_t buflen,int *errnop) -{ - NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME,buffer,buflen, - name, - read_protoent(fp,result,buffer,buflen,errnop)); - return retv; -} - -static nss_status_t _xnss_ldap_getprotobyname_r(nss_backend_t UNUSED(*be),void *args) -{ - struct protoent priv_proto; - struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getprotobyname_r(NSS_ARGS(args)->key.name,proto,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - /* FIXME: shouldn't there be some range checks here to see if it actually - fits inside the buffer? */ - sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); - if (proto->p_aliases) +static nss_status_t read_protostring(TFILE *fp,nss_XbyY_args_t *args) +{ + struct protoent result; + nss_status_t retv; + char *buffer; + size_t buflen; + int i; + /* read the protoent */ + retv=read_protoent(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + sprintf(buffer,"%s\t\t%d",result.p_name,result.p_proto); + if (result.p_aliases) + for (i=0; result.p_aliases[i]; i++) { - int i; - for (i=0; proto->p_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,proto->p_aliases[i]); - } + strcat(buffer," "); + strcat(buffer,result.p_aliases[i]); } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -static nss_status_t _nss_nslcd_getprotobynumber_r( - int number,struct protoent *result,char *buffer, - size_t buflen,int *errnop) +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_protoent(fp,(struct protoent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_protostring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +static nss_status_t get_getprotobyname(nss_backend_t UNUSED(*be),void *args) { - NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER,buffer,buflen, - number, - read_protoent(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } -static nss_status_t _xnss_ldap_getprotobynumber_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t get_getprotobynumber(nss_backend_t UNUSED(*be),void *args) { - struct protoent priv_proto; - struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; - int number=NSS_ARGS(args)->key.number; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getprotobynumber_r(number,proto,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); - if (proto->p_aliases) - { - int i; - for (i=0; proto->p_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,proto->p_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER, + NSS_ARGS(args)->key.number, + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; -static nss_status_t _xnss_ldap_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); } -static nss_status_t _nss_nslcd_getprotoent_r( - struct protoent *result,char *buffer,size_t buflen,int *errnop) +static nss_status_t get_getprotoent(nss_backend_t UNUSED(*be),void *args) { - NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL,buffer,buflen, - read_protoent(protoentfp,result,buffer,buflen,errnop)); - return retv; -} - -static nss_status_t _xnss_ldap_getprotoent_r(nss_backend_t UNUSED(*be),void *args) -{ - struct protoent priv_proto; - struct protoent *proto=NSS_ARGS(args)->buf.result?(struct protoent *)NSS_ARGS(args)->buf.result:&priv_proto; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getprotoent_r(proto,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s\t\t%d",proto->p_name,proto->p_proto); - if (proto->p_aliases) - { - int i; - for (i=0; proto->p_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,proto->p_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL, + READ_RESULT(protoentfp)); } -static nss_status_t _xnss_ldap_endprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(protoentfp); } -static nss_status_t _xnss_ldap_protocols_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t proto_ops[]={ - _xnss_ldap_protocols_destr, - _xnss_ldap_endprotoent, - _xnss_ldap_setprotoent, - _xnss_ldap_getprotoent_r, - _xnss_ldap_getprotobyname_r, - _xnss_ldap_getprotobynumber_r + destructor, + get_endprotoent, + get_setprotoent, + get_getprotoent, + get_getprotobyname, + get_getprotobynumber }; nss_backend_t *_nss_ldap_protocols_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) + be=(nss_backend_t *)malloc(sizeof(*be)); + if (be==NULL) return NULL; be->ops=proto_ops; be->n_ops=sizeof(proto_ops)/sizeof(nss_backend_op_t); diff --git a/nss/rpc.c b/nss/rpc.c index 4788462..b7da69c 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -50,10 +50,9 @@ nss_status_t _nss_ldap_getrpcbyname_r( const char *name,struct rpcent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME, name, read_rpcent(fp,result,buffer,buflen,errnop)); - return retv; } /* get a rpc entry by number */ @@ -61,10 +60,9 @@ nss_status_t _nss_ldap_getrpcbynumber_r( int number,struct rpcent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER,buffer,buflen, + NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER, number, read_rpcent(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -81,9 +79,8 @@ nss_status_t _nss_ldap_getrpcent_r( struct rpcent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(rpcentfp,NSLCD_ACTION_RPC_ALL,buffer,buflen, + NSS_GETENT(rpcentfp,NSLCD_ACTION_RPC_ALL, read_rpcent(rpcentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened by setrpcent() above */ @@ -96,187 +93,90 @@ nss_status_t _nss_ldap_endrpcent(void) #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getrpcbyname_r( - const char *name,struct rpcent *result,char *buffer, - size_t buflen,int *errnop) +static nss_status_t read_rpcstring(TFILE *fp,nss_XbyY_args_t *args) +{ + struct rpcent result; + nss_status_t retv; + char *buffer; + size_t buflen; + int i; + /* read the rpcent */ + retv=read_rpcent(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + sprintf(buffer,"%s %d",result.r_name,result.r_number); + if (result.r_aliases) + for (i=0; result.r_aliases[i]; i++) + { + strcat(buffer," "); + strcat(buffer,result.r_aliases[i]); + } + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; +} + +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_rpcent(fp,(struct rpcent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_rpcstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +static nss_status_t get_getrpcbyname_r(nss_backend_t UNUSED(*be),void *args) { - NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME,buffer,buflen, - name, - read_rpcent(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } -static nss_status_t _nss_nslcd_getrpcbynumber_r( - int number,struct rpcent *result,char *buffer, - size_t buflen,int *errnop) +static nss_status_t get_getrpcbynumber_r(nss_backend_t UNUSED(*be),void *args) { - NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER,buffer,buflen, - number, - read_rpcent(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER, + NSS_ARGS(args)->key.number, + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *rpcentfp; -static nss_status_t _xnss_ldap_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(rpcentfp); } -static nss_status_t _nss_nslcd_getrpcent_r( - struct rpcent *result,char *buffer,size_t buflen,int *errnop) +static nss_status_t get_getrpcent_r(nss_backend_t UNUSED(*be),void *args) { - NSS_GETENT(rpcentfp,NSLCD_ACTION_RPC_ALL,buffer,buflen, - read_rpcent(rpcentfp,result,buffer,buflen,errnop)); - return retv; + NSS_GETENT(rpcentfp,NSLCD_ACTION_RPC_ALL, + READ_RESULT(rpcentfp)); } -static nss_status_t _xnss_ldap_endrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(rpcentfp); } -static nss_status_t _xnss_ldap_getrpcbyname_r(nss_backend_t UNUSED(*be),void *args) -{ - struct rpcent priv_rpc; - struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getrpcbyname_r(NSS_ARGS(args)->key.name,rpc,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d",rpc->r_name,rpc->r_number); - if (rpc->r_aliases) - { - int i; - for (i=0; rpc->r_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,rpc->r_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_getrpcbynumber_r(nss_backend_t UNUSED(*be),void *args) -{ - struct rpcent priv_rpc; - struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; - int number=NSS_ARGS(args)->key.number; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getrpcbynumber_r(number,rpc,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d",rpc->r_name,rpc->r_number); - if (rpc->r_aliases) - { - int i; - for (i=0; rpc->r_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,rpc->r_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_getrpcent_r(nss_backend_t UNUSED(*be),void *args) -{ - struct rpcent priv_rpc; - struct rpcent *rpc=NSS_ARGS(args)->buf.result?(struct rpcent *)NSS_ARGS(args)->buf.result:&priv_rpc; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getrpcent_r(rpc,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d",rpc->r_name,rpc->r_number); - if (rpc->r_aliases) - { - int i; - for (i=0; rpc->r_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,rpc->r_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_rpc_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t rpc_ops[]={ - _xnss_ldap_rpc_destr, - _xnss_ldap_endrpcent, - _xnss_ldap_setrpcent, - _xnss_ldap_getrpcent_r, - _xnss_ldap_getrpcbyname_r, - _xnss_ldap_getrpcbynumber_r + destructor, + get_endrpcent, + get_setrpcent, + get_getrpcent_r, + get_getrpcbyname_r, + get_getrpcbynumber_r }; nss_backend_t *_nss_ldap_rpc_constr(const char UNUSED(*db_name), diff --git a/nss/services.c b/nss/services.c index fb709a4..0d7c23e 100644 --- a/nss/services.c +++ b/nss/services.c @@ -54,10 +54,9 @@ nss_status_t _nss_ldap_getservbyname_r( const char *name,const char *protocol,struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME,buffer,buflen, + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME, WRITE_STRING(fp,name);WRITE_STRING(fp,protocol), read_servent(fp,result,buffer,buflen,errnop)); - return retv; } /* get a service entry by port and protocol */ @@ -65,10 +64,9 @@ nss_status_t _nss_ldap_getservbyport_r( int port,const char *protocol,struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER,buffer,buflen, + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER, WRITE_INT32(fp,ntohs(port));WRITE_STRING(fp,protocol), read_servent(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -85,9 +83,8 @@ nss_status_t _nss_ldap_getservent_r( struct servent *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, + NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL, read_servent(serventfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened by setservent() above */ @@ -100,176 +97,92 @@ nss_status_t _nss_ldap_endservent(void) #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getservbyname_r( - const char *name,const char *protocol,struct servent *result, - char *buffer,size_t buflen,int *errnop) +static nss_status_t read_servstring(TFILE *fp,nss_XbyY_args_t *args) +{ + struct servent result; + nss_status_t retv; + char *buffer; + size_t buflen; + int i; + /* read the servent */ + retv=read_servent(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + sprintf(buffer,"%s %d/%s",result.s_name,result.s_port,result.s_proto); + if (result.s_aliases) + for (i=0;result.s_aliases[i];i++) + { + strcat(buffer," "); + strcat(buffer,result.s_aliases[i]); + } + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; +} + +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_servent(fp,(struct servent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_servstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +static nss_status_t get_getservbyname_r(nss_backend_t UNUSED(*be),void *args) { - NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME,buffer,buflen, - WRITE_STRING(fp,name);WRITE_STRING(fp,protocol), - read_servent(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME, + WRITE_STRING(fp,NSS_ARGS(args)->key.serv.serv.name); + WRITE_STRING(fp,NSS_ARGS(args)->key.serv.proto), + READ_RESULT(fp)); } -static nss_status_t _nss_nslcd_getservbyport_r( - int port,const char *protocol,struct servent *result, - char *buffer,size_t buflen,int *errnop) +static nss_status_t get_getservbyport_r(nss_backend_t UNUSED(*be),void *args) { - NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER,buffer,buflen, - WRITE_INT32(fp,ntohs(port));WRITE_STRING(fp,protocol), - read_servent(fp,result,buffer,buflen,errnop)); - return retv; + NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER, + WRITE_INT32(fp,ntohs(NSS_ARGS(args)->key.serv.serv.port)); + WRITE_STRING(fp,NSS_ARGS(args)->key.serv.proto), + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *serventfp; -static nss_status_t _xnss_ldap_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(serventfp); } -static nss_status_t _nss_nslcd_getservent_r( - struct servent *result,char *buffer,size_t buflen,int *errnop) +static nss_status_t get_getservent_r(nss_backend_t UNUSED(*be),void *args) { - NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL,buffer,buflen, - read_servent(serventfp,result,buffer,buflen,errnop)); - return retv; + NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL, + READ_RESULT(serventfp)); } -static nss_status_t _xnss_ldap_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(serventfp); } -static nss_status_t _xnss_ldap_getservbyname_r(nss_backend_t UNUSED(*be),void *args) -{ - struct servent priv_service; - struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - status=_nss_nslcd_getservbyname_r(NSS_ARGS(args)->key.serv.serv.name,NSS_ARGS(args)->key.serv.proto,service, - buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d/%s",service->s_name,service->s_port, - service->s_proto); - if (service->s_aliases) - { - int i; - for (i=0; service->s_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,service->s_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_getservbyport_r(nss_backend_t UNUSED(*be),void *args) -{ - int port=NSS_ARGS(args)->key.serv.serv.port; - struct servent priv_service; - struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - status=_nss_nslcd_getservbyport_r(port,NSS_ARGS(args)->key.serv.proto,service,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d/%s",service->s_name,port, - service->s_proto); - if (service->s_aliases) - { - int i; - for (i=0; service->s_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,service->s_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_getservent_r(nss_backend_t UNUSED(*be),void *args) -{ - struct servent priv_service; - struct servent *service=NSS_ARGS(args)->buf.result?(struct servent *)NSS_ARGS(args)->buf.result:&priv_service; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - nss_status_t status; - status=_nss_nslcd_getservent_r(service,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s %d/%s",service->s_name,service->s_port, - service->s_proto); - if (service->s_aliases) - { - int i; - for (i=0; service->s_aliases[i]; i++) - { - strcat(data_ptr," "); - strcat(data_ptr,service->s_aliases[i]); - } - } - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; -} - -static nss_status_t _xnss_ldap_services_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t services_ops[]={ - _xnss_ldap_services_destr, - _xnss_ldap_endservent, - _xnss_ldap_setservent, - _xnss_ldap_getservent_r, - _xnss_ldap_getservbyname_r, - _xnss_ldap_getservbyport_r + destructor, + get_endservent, + get_setservent, + get_getservent_r, + get_getservbyname_r, + get_getservbyport_r }; nss_backend_t *_nss_ldap_services_constr(const char UNUSED(*db_name), diff --git a/nss/shadow.c b/nss/shadow.c index 403dd3a..ae025b4 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -56,10 +56,9 @@ nss_status_t _nss_ldap_getspnam_r( const char *name,struct spwd *result, char *buffer,size_t buflen,int *errnop) { - NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME,buffer,buflen, + NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME, name, read_spwd(fp,result,buffer,buflen,errnop)); - return retv; } /* thread-local file pointer to an ongoing request */ @@ -76,9 +75,8 @@ nss_status_t _nss_ldap_getspent_r( struct spwd *result, char *buffer,size_t buflen,int *errnop) { - NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL,buffer,buflen, + NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL, read_spwd(spentfp,result,buffer,buflen,errnop)); - return retv; } /* close the stream opened by setspent() above */ @@ -91,187 +89,111 @@ nss_status_t _nss_ldap_endspent(void) #ifdef NSS_FLAVOUR_SOLARIS -static nss_status_t _nss_nslcd_getspnam_r( - const char *name,struct spwd *result,char *buffer, - size_t buflen,int *errnop) +static nss_status_t read_spwdstring(TFILE *fp,nss_XbyY_args_t *args) { - NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME,buffer,buflen, - name, - read_spwd(fp,result,buffer,buflen,errnop)); - return retv; + struct spwd result; + nss_status_t retv; + char *buffer; + char field_buf[128]; + size_t buflen; + /* read the spwd */ + retv=read_spwd(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + if (retv!=NSS_STATUS_SUCCESS) + return retv; + /* allocate a temporary buffer */ + buflen=args->buf.buflen; + buffer=(char *)malloc(buflen); + /* build the formatted string */ + /* FIXME: implement proper buffer size checking */ + sprintf(buffer,"%s:%s:",result.sp_namp,result.sp_pwdp); + if (result.sp_lstchg >= 0) + sprintf(field_buf,"%d:",result.sp_lstchg); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + if (result.sp_min >= 0) + sprintf(field_buf,"%d:",result.sp_min); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + if (result.sp_max >= 0) + sprintf(field_buf,"%d:",result.sp_max); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + if (result.sp_warn >= 0) + sprintf(field_buf,"%d:",result.sp_warn); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + if (result.sp_inact >= 0) + sprintf(field_buf,"%d:",result.sp_inact); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + if (result.sp_expire >= 0) + sprintf(field_buf,"%d:",result.sp_expire); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + if (result.sp_flag >= 0) + sprintf(field_buf,"%x",result.sp_flag); + else + sprintf(field_buf,":"); + strcat(buffer,field_buf); + /* copy the result back to the result buffer and free the temporary one */ + strcpy(NSS_ARGS(args)->buf.buffer,buffer); + free(buffer); + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; + NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); + return NSS_STATUS_SUCCESS; } -static nss_status_t _xnss_ldap_getspnam_r(nss_backend_t UNUSED(*be),void *args) +#define READ_RESULT(fp) \ + NSS_ARGS(args)->buf.result? \ + read_spwd(fp,(struct spwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ + read_spwdstring(fp,args); \ + if (NSS_ARGS(args)->buf.result) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + +static nss_status_t get_getspnam_r(nss_backend_t UNUSED(*be),void *args) { - struct spwd priv_spwd; - struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - char field_buf[128]; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getspnam_r(NSS_ARGS(args)->key.name,sp,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); - if (sp->sp_lstchg >= 0) - sprintf(field_buf,"%d:",sp->sp_lstchg); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_min >= 0) - sprintf(field_buf,"%d:",sp->sp_min); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_max >= 0) - sprintf(field_buf,"%d:",sp->sp_max); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_warn >= 0) - sprintf(field_buf,"%d:",sp->sp_warn); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_inact >= 0) - sprintf(field_buf,"%d:",sp->sp_inact); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_expire >= 0) - sprintf(field_buf,"%d:",sp->sp_expire); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_flag >= 0) - sprintf(field_buf,"%x",sp->sp_flag); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME, + NSS_ARGS(args)->key.name, + READ_RESULT(fp)); } /* thread-local file pointer to an ongoing request */ static __thread TFILE *spentfp; -static nss_status_t _xnss_ldap_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(spentfp); } -static nss_status_t _nss_nslcd_getspent_r( - struct spwd *result,char *buffer,size_t buflen,int *errnop) -{ - NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL,buffer,buflen, - read_spwd(spentfp,result,buffer,buflen,errnop)); - return retv; -} - -static nss_status_t _xnss_ldap_getspent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t get_getspent_r(nss_backend_t UNUSED(*be),void *args) { - struct spwd priv_spwd; - struct spwd *sp=NSS_ARGS(args)->buf.result?(struct spwd *)NSS_ARGS(args)->buf.result:&priv_spwd; - char *buffer=NSS_ARGS(args)->buf.buffer; - size_t buflen=NSS_ARGS(args)->buf.buflen; - char *data_ptr; - char field_buf[128]; - nss_status_t status; - if (NSS_ARGS(args)->buf.buflen<0) - { - NSS_ARGS(args)->erange=1; - return NSS_STATUS_TRYAGAIN; - } - status=_nss_nslcd_getspent_r(sp,buffer,buflen,&errno); - if (status!=NSS_STATUS_SUCCESS) - return status; - if (!NSS_ARGS(args)->buf.result) - { - /* result==NULL, return file format */ - data_ptr=(char *)malloc(buflen); - sprintf(data_ptr,"%s:%s:",sp->sp_namp,sp->sp_pwdp); - if (sp->sp_lstchg >= 0) - sprintf(field_buf,"%d:",sp->sp_lstchg); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_min >= 0) - sprintf(field_buf,"%d:",sp->sp_min); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_max >= 0) - sprintf(field_buf,"%d:",sp->sp_max); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_warn >= 0) - sprintf(field_buf,"%d:",sp->sp_warn); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_inact >= 0) - sprintf(field_buf,"%d:",sp->sp_inact); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_expire >= 0) - sprintf(field_buf,"%d:",sp->sp_expire); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - if (sp->sp_flag >= 0) - sprintf(field_buf,"%x",sp->sp_flag); - else - sprintf(field_buf,":"); - strcat(data_ptr,field_buf); - strcpy(buffer,data_ptr); - free(data_ptr); - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; - NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); - } - else - { - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; - } - return status; + NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL, + READ_RESULT(spentfp)); } -static nss_status_t _xnss_ldap_endspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t get_endspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(spentfp); } -static nss_status_t _xnss_ldap_shadow_destr(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t shadow_ops[]={ - _xnss_ldap_shadow_destr, - _xnss_ldap_endspent, /* NSS_DBOP_ENDENT */ - _xnss_ldap_setspent, /* NSS_DBOP_SETENT */ - _xnss_ldap_getspent_r, /* NSS_DBOP_GETENT */ - _xnss_ldap_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ + destructor, + get_endspent, /* NSS_DBOP_ENDENT */ + get_setspent, /* NSS_DBOP_SETENT */ + get_getspent_r, /* NSS_DBOP_GETENT */ + get_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ }; nss_backend_t *_nss_ldap_shadow_constr(const char UNUSED(*db_name), -- cgit v1.2.3 From 7abeeebdce8c63900d689381cf155a7c952a1107 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 11 Oct 2010 19:33:37 +0000 Subject: make all ethernet tests use the same includes git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1259 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 2 ++ 1 file changed, 2 insertions(+) diff --git a/configure.ac b/configure.ac index 61cb551..f6dba53 100644 --- a/configure.ac +++ b/configure.ac @@ -300,6 +300,7 @@ fi # check for support for the struct ether_addr structure AC_CHECK_TYPES(struct ether_addr,,,[ + #include #include #include #include @@ -534,6 +535,7 @@ then # check requirements for our replacement functions AC_CHECK_FUNCS(ether_ntoa ether_aton) AC_CHECK_DECLS([ether_ntoa,ether_aton],,,[ + #include #include #include #include -- cgit v1.2.3 From 3941082d1dcdb483fa2f6cb4d094140234bc0aed Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 11 Oct 2010 19:35:18 +0000 Subject: build Solaris NSS flavour without aliases for now git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1260 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/configure.ac b/configure.ac index f6dba53..04bd05b 100644 --- a/configure.ac +++ b/configure.ac @@ -405,7 +405,10 @@ then AC_MSG_CHECKING([which NSS maps to build]) if test "x$with_nss_ldap_maps" = "xall" then - with_nss_ldap_maps="aliases,ethers,group,hosts,netgroup,networks,passwd,protocols,rpc,services,shadow" + case "$with_nss_flavour" in + glibc) with_nss_ldap_maps="aliases,ethers,group,hosts,netgroup,networks,passwd,protocols,rpc,services,shadow" ;; + solaris) with_nss_ldap_maps="ethers,group,hosts,netgroup,networks,passwd,protocols,rpc,services,shadow" ;; + esac fi AC_MSG_RESULT($with_nss_ldap_maps) NSS_MODULE_OBJS="`echo "$with_nss_ldap_maps " | sed 's/,/ /g;s/ */.$(OBJEXT) /g'`" -- cgit v1.2.3 From 11428fdf252a18551d64fb6a119e44eab2d2c5d9 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 11 Oct 2010 19:37:38 +0000 Subject: use {nss,pam}_ldap_so_LINK to set custom linker invocation instead of {nss,pam}_ldap_so_LD+{nss,pam}_ldap_so_LDFLAGS because the _LD one wasn't automatically picked up git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1261 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/configure.ac b/configure.ac index 04bd05b..b0108e6 100644 --- a/configure.ac +++ b/configure.ac @@ -418,10 +418,11 @@ then case "$target_os" in solaris*) if test "$ac_cv_prog_gcc" = yes; then - nss_ldap_so_LD="/usr/ccs/bin/ld" - AC_SUBST(nss_ldap_so_LD) + nss_ldap_so_LINK="/usr/ccs/bin/ld -Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G -o \$@" + AC_SUBST(nss_ldap_so_LINK) + else + nss_ldap_so_LDFLAGS="-Wl,-Bdirect -Wl,-z,nodelete -Wl,-Bdynamic -Wl,-M,\$(srcdir)/exports.solaris -Wl,-G" fi - nss_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G" ;; *) nss_ldap_so_LDFLAGS="-shared -Wl,-h,\$(NSS_LDAP_SONAME) -Wl,--version-script,\$(srcdir)/exports.glibc" @@ -470,10 +471,11 @@ then case "$target_os" in solaris*) if test "$ac_cv_prog_gcc" = yes; then - pam_ldap_so_LD="/usr/ccs/bin/ld" - AC_SUBST(pam_ldap_so_LD) + pam_ldap_so_LINK="/usr/ccs/bin/ld -Bdirect -z nodelete -Bdynamic -M \$(srcdir)/pam_ldap.map -G -o \$@" + AC_SUBST(pam_ldap_so_LINK) + else + pam_ldap_so_LDFLAGS="-shared -Wl,-Bdirect -Wl,-z,nodelete -Wl,-Bdynamic -Wl,-M,\$(srcdir)/pam_ldap.map -Wl,-G" fi - pam_ldap_so_LDFLAGS="-Bdirect -z nodelete -Bdynamic -M \$(srcdir)/pam_ldap.map -G" ;; *) pam_ldap_so_LDFLAGS="-shared -Wl,--version-script,\$(srcdir)/pam_ldap.map" -- cgit v1.2.3 From 90fec72d7d1390d0744622928c6648355d3f6f33 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 11 Oct 2010 20:12:59 +0000 Subject: also try to support older Solaris releases that do not have the returnlen member of struct nss_XbyY_args git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1262 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 15 +++++++++++++-- nss/group.c | 15 +++++++++++++-- nss/hosts.c | 23 +++++++++++++++++++---- nss/networks.c | 15 +++++++++++++-- nss/passwd.c | 15 +++++++++++++-- nss/protocols.c | 15 +++++++++++++-- nss/rpc.c | 15 +++++++++++++-- nss/services.c | 15 +++++++++++++-- nss/shadow.c | 15 +++++++++++++-- 9 files changed, 123 insertions(+), 20 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 56cc0ee..75b09e9 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -96,6 +96,8 @@ nss_status_t _nss_ldap_endetherent(void) #define NSS_BUFLEN_ETHERS 1024 #endif /* NSS_BUFLEN_ETHERS */ +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_etherstring(TFILE *fp,nss_XbyY_args_t *args) { /* TODO: padl uses struct ether, verify */ @@ -129,8 +131,17 @@ static nss_status_t read_etherstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_etherent(fp,(struct etherent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_etherstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_etherent(fp,(struct etherent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ /* map a hostname to the corresponding ethernet address */ static nss_status_t get_gethostton(nss_backend_t UNUSED(*be),void *args) diff --git a/nss/group.c b/nss/group.c index cd68689..ef1461b 100644 --- a/nss/group.c +++ b/nss/group.c @@ -183,6 +183,8 @@ nss_status_t _nss_ldap_initgroups_dyn( #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_groupstring(TFILE *fp,nss_XbyY_args_t *args) { struct group result; @@ -219,8 +221,17 @@ static nss_status_t read_groupstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_group(fp,(struct group *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_groupstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_group(fp,(struct group *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ static nss_status_t get_getgrnam_r(nss_backend_t UNUSED(*be),void *args) { diff --git a/nss/hosts.c b/nss/hosts.c index 3037a10..8a699f3 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -242,6 +242,8 @@ nss_status_t _nss_ldap_endhostent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_hoststring(TFILE *fp,nss_XbyY_args_t *args,int erronempty) { struct hostent result; @@ -298,16 +300,29 @@ static nss_status_t read_hoststring(TFILE *fp,nss_XbyY_args_t *args,int erronemp NSS_ARGS(args)->buf.result? \ read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ read_hoststring(fp,args,1); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #define READ_RESULT_NEXTONEMPTY(fp) \ NSS_ARGS(args)->buf.result? \ read_hostent_nextonempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ read_hoststring(fp,args,0); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT_ERRONEMPTY(fp) \ + read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#define READ_RESULT_NEXTONEMPTY(fp) \ + read_hostent_nextonempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ /* hack to set the correct errno and h_errno */ #define h_errnop &(NSS_ARGS(args)->h_errno) diff --git a/nss/networks.c b/nss/networks.c index f5a5a3d..2a9443b 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -162,6 +162,8 @@ nss_status_t _nss_ldap_endnetent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_netentstring(TFILE *fp,nss_XbyY_args_t *args) { struct netent result; @@ -199,8 +201,17 @@ static nss_status_t read_netentstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_netent(fp,(struct netent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ read_netentstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_netent(fp,(struct netent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ /* more of a dirty hack */ #define h_errnop (&(NSS_ARGS(args)->h_errno)) diff --git a/nss/passwd.c b/nss/passwd.c index 112cfa7..2771fbf 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -97,6 +97,8 @@ nss_status_t _nss_ldap_endpwent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_passwdstring(TFILE *fp,nss_XbyY_args_t *args) { struct passwd result; @@ -127,8 +129,17 @@ static nss_status_t read_passwdstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_passwd(fp,(struct passwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_passwdstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_passwd(fp,(struct passwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ static nss_status_t get_getpwnam(nss_backend_t UNUSED(*be),void *args) { diff --git a/nss/protocols.c b/nss/protocols.c index 8c55cc3..75c5f32 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -93,6 +93,8 @@ nss_status_t _nss_ldap_endprotoent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_protostring(TFILE *fp,nss_XbyY_args_t *args) { struct protoent result; @@ -128,8 +130,17 @@ static nss_status_t read_protostring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_protoent(fp,(struct protoent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_protostring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_protoent(fp,(struct protoent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ static nss_status_t get_getprotobyname(nss_backend_t UNUSED(*be),void *args) { diff --git a/nss/rpc.c b/nss/rpc.c index b7da69c..9b55c8f 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -93,6 +93,8 @@ nss_status_t _nss_ldap_endrpcent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_rpcstring(TFILE *fp,nss_XbyY_args_t *args) { struct rpcent result; @@ -128,8 +130,17 @@ static nss_status_t read_rpcstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_rpcent(fp,(struct rpcent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_rpcstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_rpcent(fp,(struct rpcent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ static nss_status_t get_getrpcbyname_r(nss_backend_t UNUSED(*be),void *args) { diff --git a/nss/services.c b/nss/services.c index 0d7c23e..db66494 100644 --- a/nss/services.c +++ b/nss/services.c @@ -97,6 +97,8 @@ nss_status_t _nss_ldap_endservent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_servstring(TFILE *fp,nss_XbyY_args_t *args) { struct servent result; @@ -132,8 +134,17 @@ static nss_status_t read_servstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_servent(fp,(struct servent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_servstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_servent(fp,(struct servent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ static nss_status_t get_getservbyname_r(nss_backend_t UNUSED(*be),void *args) { diff --git a/nss/shadow.c b/nss/shadow.c index ae025b4..fdcc74f 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -89,6 +89,8 @@ nss_status_t _nss_ldap_endspent(void) #ifdef NSS_FLAVOUR_SOLARIS +#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN + static nss_status_t read_spwdstring(TFILE *fp,nss_XbyY_args_t *args) { struct spwd result; @@ -153,8 +155,17 @@ static nss_status_t read_spwdstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_spwd(fp,(struct spwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_spwdstring(fp,args); \ - if (NSS_ARGS(args)->buf.result) \ - NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result + if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ + +#define READ_RESULT(fp) \ + read_spwd(fp,(struct spwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ + if (retv=NSS_STATUS_SUCCESS) \ + NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; + +#endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ static nss_status_t get_getspnam_r(nss_backend_t UNUSED(*be),void *args) { -- cgit v1.2.3 From 147840dcf4a3ed565ca8311f8a3d489c668126cb Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 11 Oct 2010 20:58:05 +0000 Subject: always define {nss,pam}_ldap_so_LINK (defaults to default) because otherwise automake gets confused git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1263 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/configure.ac b/configure.ac index b0108e6..0785d4d 100644 --- a/configure.ac +++ b/configure.ac @@ -415,11 +415,12 @@ then AC_SUBST(NSS_MODULE_OBJS) # find out how to link the library + nss_ldap_so_LINK="\$(CCLD) \$(AM_CFLAGS) \$(CFLAGS) \$(nss_ldap_so_LDFLAGS) \$(LDFLAGS) -o \$@" case "$target_os" in solaris*) - if test "$ac_cv_prog_gcc" = yes; then + if test "$ac_cv_prog_gcc" = yes + then nss_ldap_so_LINK="/usr/ccs/bin/ld -Bdirect -z nodelete -Bdynamic -M \$(srcdir)/exports.solaris -G -o \$@" - AC_SUBST(nss_ldap_so_LINK) else nss_ldap_so_LDFLAGS="-Wl,-Bdirect -Wl,-z,nodelete -Wl,-Bdynamic -Wl,-M,\$(srcdir)/exports.solaris -Wl,-G" fi @@ -429,6 +430,7 @@ then ;; esac AC_SUBST(nss_ldap_so_LDFLAGS) + AC_SUBST(nss_ldap_so_LINK) # restore CFLAGS and LIBS CFLAGS="$nss_save_CFLAGS" @@ -468,11 +470,12 @@ then AC_CHECK_FUNCS(pam_modutil_getpwnam pam_syslog) # find out how to link the library + pam_ldap_so_LINK="\$(CCLD) \$(AM_CFLAGS) \$(CFLAGS) \$(pam_ldap_so_LDFLAGS) \$(LDFLAGS) -o \$@" case "$target_os" in solaris*) - if test "$ac_cv_prog_gcc" = yes; then + if test "$ac_cv_prog_gcc" = yes + then pam_ldap_so_LINK="/usr/ccs/bin/ld -Bdirect -z nodelete -Bdynamic -M \$(srcdir)/pam_ldap.map -G -o \$@" - AC_SUBST(pam_ldap_so_LINK) else pam_ldap_so_LDFLAGS="-shared -Wl,-Bdirect -Wl,-z,nodelete -Wl,-Bdynamic -Wl,-M,\$(srcdir)/pam_ldap.map -Wl,-G" fi @@ -482,6 +485,7 @@ then ;; esac AC_SUBST(pam_ldap_so_LDFLAGS) + AC_SUBST(pam_ldap_so_LINK) # restore CFLAGS and LIBS CFLAGS="$pam_save_CFLAGS" -- cgit v1.2.3 From 4ea9ad10160da3dcb572527c7ea9dcaa8182bc6a Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 15 Oct 2010 11:22:47 +0000 Subject: switch to using SETs to follow the netgroups git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1281 ef36b2f9-881f-0410-afb5-c4e39611909c --- configure.ac | 3 ++ nss/Makefile.am | 3 ++ nss/common.c | 91 +-------------------------------------------------------- nss/common.h | 12 -------- nss/netgroup.c | 61 ++++++++++++-------------------------- 5 files changed, 26 insertions(+), 144 deletions(-) diff --git a/configure.ac b/configure.ac index 69f8999..d55ede8 100644 --- a/configure.ac +++ b/configure.ac @@ -704,6 +704,9 @@ then AC_SUBST(nslcd_LIBS) fi +AM_CONDITIONAL([NSS_FLAVOUR_GLIBC], [test "x${with_nss_flavour}" = xglibc]) +AM_CONDITIONAL([NSS_FLAVOUR_SOLARIS], [test "x${with_nss_flavour}" = xsolaris]) + # generate files AC_CONFIG_FILES([Makefile compat/Makefile common/Makefile nss/Makefile pam/Makefile nslcd/Makefile man/Makefile tests/Makefile]) diff --git a/nss/Makefile.am b/nss/Makefile.am index 4c790bd..d16eba6 100644 --- a/nss/Makefile.am +++ b/nss/Makefile.am @@ -33,6 +33,9 @@ EXTRA_nss_ldap_so_SOURCES = aliases.c ethers.c group.c hosts.c netgroup.c \ shadow.c nss_ldap_so_DEPENDENCIES = $(NSS_MODULE_OBJS) nss_ldap_so_LDADD = $(NSS_MODULE_OBJS) ../common/libtio.a ../common/libprot.a +if NSS_FLAVOUR_SOLARIS +nss_ldap_so_LDADD += ../common/libdict.a +endif EXTRA_DIST = exports.glibc exports.solaris diff --git a/nss/common.c b/nss/common.c index c3c0616..20a3136 100644 --- a/nss/common.c +++ b/nss/common.c @@ -1,8 +1,7 @@ /* - common.c - common functions for NSS lookups + common.c - common definitions Copyright (C) 2010 Arthur de Jong - Copyright (C) 2010 Symas Corporation This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -20,92 +19,4 @@ 02110-1301 USA */ -#include "config.h" - -#ifdef HAVE_STDINT_H -#include -#endif /* HAVE_STDINT_H */ -#include -#include -#include -#include -#include -#include -#include -#ifdef HAVE_NSS_H -#include -#endif /* HAVE_NSS_H */ -#include - -#include "nslcd.h" -#include "common.h" -#include "common/tio.h" - -/* flag used to disable NSS lookups using this module */ int _nss_ldap_enablelookups=1; - -#ifdef NSS_FLAVOUR_SOLARIS -/* Adapted from PADL */ - -/* add a nested netgroup or group to the namelist */ -nss_status_t _nss_ldap_namelist_push(struct name_list **head,const char *name) -{ - struct name_list *nl; - nl=(struct name_list *)malloc(sizeof(*nl)); - if (nl==NULL) - return NSS_STATUS_TRYAGAIN; - nl->name=strdup(name); - if (nl->name==NULL) - { - free(nl); - return NSS_STATUS_TRYAGAIN; - } - nl->next=*head; - *head=nl; - return NSS_STATUS_SUCCESS; -} - -/* remove last nested netgroup or group from the namelist */ -void _nss_ldap_namelist_pop(struct name_list **head) -{ - struct name_list *nl; - nl=*head; - *head=nl->next; - free(nl->name); - free(nl); -} - -/* cleanup nested netgroup or group namelist */ -void _nss_ldap_namelist_destroy(struct name_list **head) -{ - struct name_list *p,*next; - for (p=*head;p!=NULL;p=next) - { - next=p->next; - if (p->name!=NULL) - free(p->name); - free(p); - } - *head=NULL; -} - -/* - *Check whether we have already seen a netgroup or group, - *to avoid loops in nested netgroup traversal - */ -int _nss_ldap_namelist_find(struct name_list *head,const char *netgroup) -{ - struct name_list *p; - int found=0; - for (p=head;p!=NULL;p=p->next) - { - if (strcasecmp(p->name,netgroup)==0) - { - found++; - break; - } - } - return found; -} - -#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/common.h b/nss/common.h index ffb718f..f1bd73e 100644 --- a/nss/common.h +++ b/nss/common.h @@ -31,18 +31,6 @@ #include "compat/attrs.h" #include "compat/nss_compat.h" -/* Adapted from PADL */ -/* Routines for managing namelists */ -struct name_list -{ - char *name; - struct name_list *next; -}; -nss_status_t _nss_ldap_namelist_push(struct name_list **head,const char *name); -void _nss_ldap_namelist_pop(struct name_list **head); -int _nss_ldap_namelist_find(struct name_list *head,const char *netgroup); -void _nss_ldap_namelist_destroy(struct name_list **head); - /* These are macros for handling read and write problems, they are NSS specific due to the return code so are defined here. They genrally close the open file, set an error code and return with diff --git a/nss/netgroup.c b/nss/netgroup.c index 4ad50e7..1531cc4 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -30,6 +30,7 @@ #include "prototypes.h" #include "common.h" #include "compat/attrs.h" +#include "common/set.h" /* we redefine this here because we need to return NSS_STATUS_RETURN instead of NSS_STATUS_NOTFOUND */ @@ -146,8 +147,8 @@ struct nss_ldap_netgr_backend nss_backend_op_t *ops; int n_ops; ent_context_t *state; - struct name_list *known_groups; /* netgroups seen, for loop detection */ - struct name_list *needed_groups; /* nested netgroups to chase */ + SET *known_groups; /* netgroups seen, for loop detection */ + SET *needed_groups; /* nested netgroups to chase */ }; typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; @@ -157,35 +158,20 @@ static nss_status_t _xnss_ldap_setnetgrent(nss_backend_t UNUSED(*be),void UNUSED } /* find a netgroup that has not been traversed */ -static char *_nss_ldap_chase_netgroup(nss_ldap_netgr_backend_t *ngbe) +static char *find_unseen_netgroup(nss_ldap_netgr_backend_t *ngbe) { - nss_status_t status; - char *group=NULL; - int found=0; - if (!ngbe->needed_groups) - { - /* exhausted all netgroups */ - return NULL; - } - while (ngbe->needed_groups&&!found) + char *group; + while (1) { - if (_nss_ldap_namelist_find(ngbe->known_groups, - ngbe->needed_groups->name)) + group=set_pop(ngbe->needed_groups); + if (group==NULL) + return NULL; + if (set_contains(ngbe->known_groups,group)) { - /* netgroup seen before,ignore it */ - _nss_ldap_namelist_pop(&ngbe->needed_groups); + set_add(ngbe->known_groups,group); + return group; } - else - found=1; - } - if (found) - { - group=strdup(ngbe->needed_groups->name); - status=_nss_ldap_namelist_push(&ngbe->known_groups, - ngbe->needed_groups->name); - _nss_ldap_namelist_pop(&ngbe->needed_groups); } - return group; } /* thread-local file pointer to an ongoing request */ @@ -236,7 +222,7 @@ static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) while (!found) { /* find a nested netgroup to pursue further */ - group=_nss_ldap_chase_netgroup(ngbe); + group=find_unseen_netgroup(ngbe); if (!group) { /* no more netgroup */ @@ -263,11 +249,7 @@ static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) if (result.type==group_val) { /* a netgroup nested within the current netgroup */ - rc=_nss_ldap_namelist_push(&ngbe->needed_groups,result.val.group); - if (rc!=NSS_STATUS_SUCCESS) - { - /* unable to push the group name for later netgroup */ - } + set_add(ngbe->needed_groups,result.val.group); } else if (result.type==triple_val) { @@ -298,8 +280,8 @@ static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)be; /* free list of nested netgroups */ - _nss_ldap_namelist_destroy(&ngbe->known_groups); - _nss_ldap_namelist_destroy(&ngbe->needed_groups); + set_free(ngbe->known_groups); + set_free(ngbe->needed_groups); free(ngbe); return NSS_STATUS_SUCCESS; } @@ -338,12 +320,7 @@ static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) return stat; } /* place the group name in known list */ - stat=_nss_ldap_namelist_push(&ngbe->known_groups,args->netgroup); - if (stat!=NSS_STATUS_SUCCESS) - { - destructor((nss_backend_t *)ngbe,NULL); - return stat; - } + set_add(ngbe->known_groups,args->netgroup); args->iterator=(nss_backend_t *)ngbe; return stat; } @@ -356,8 +333,8 @@ nss_backend_t *_nss_ldap_netgroup_constr(const char UNUSED(*db_name), return NULL; be->ops=netgroup_ops; be->n_ops=sizeof(netgroup_ops)/sizeof(nss_backend_op_t); - be->known_groups=NULL; - be->needed_groups=NULL; + be->known_groups=set_new(); + be->needed_groups=set_new(); return (nss_backend_t *)be; } -- cgit v1.2.3 From 5620ca3884c2960e8d926e9d1cb3b91fe3b19a90 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 15 Oct 2010 13:18:19 +0000 Subject: also export _nss_ldap_enablelookups so we can disable the NSS module from nslcd git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1282 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/exports.solaris | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/nss/exports.solaris b/nss/exports.solaris index 5c191be..d942e41 100644 --- a/nss/exports.solaris +++ b/nss/exports.solaris @@ -1,8 +1,11 @@ -# $Id: exports.solaris,v 1.1 2010-08-07 00:24:21 tedcheng Exp $ - nss_ldap.so.1 { + # published NSS service functions global: + + # flag to enable or disable lookups + _nss_ldap_enablelookups; + # Published NSS service module interfaces # _nss_ldap_bootparams_constr; _nss_ldap_ethers_constr; -- cgit v1.2.3 From c25aea317a565d6132eec490a9c67f14b177a989 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 15 Oct 2010 13:22:16 +0000 Subject: make formatting consistent git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1283 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/exports.solaris | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/nss/exports.solaris b/nss/exports.solaris index d942e41..be90512 100644 --- a/nss/exports.solaris +++ b/nss/exports.solaris @@ -6,18 +6,17 @@ nss_ldap.so.1 { # flag to enable or disable lookups _nss_ldap_enablelookups; - # Published NSS service module interfaces - # _nss_ldap_bootparams_constr; - _nss_ldap_ethers_constr; - _nss_ldap_group_constr; - _nss_ldap_hosts_constr; - _nss_ldap_networks_constr; - _nss_ldap_protocols_constr; - _nss_ldap_passwd_constr; - _nss_ldap_rpc_constr; - _nss_ldap_services_constr; - _nss_ldap_shadow_constr; - _nss_ldap_netgroup_constr; + # published NSS service module constructors + _nss_ldap_ethers_constr; + _nss_ldap_group_constr; + _nss_ldap_hosts_constr; + _nss_ldap_networks_constr; + _nss_ldap_protocols_constr; + _nss_ldap_passwd_constr; + _nss_ldap_rpc_constr; + _nss_ldap_services_constr; + _nss_ldap_shadow_constr; + _nss_ldap_netgroup_constr; # everything else should not be exported local: -- cgit v1.2.3 From f90f8d8eb4a3f963c881e30420038227f1a56592 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 28 Oct 2010 19:01:27 +0000 Subject: remove redundant backslash git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1289 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/common.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nss/common.h b/nss/common.h index f1bd73e..7a3edcf 100644 --- a/nss/common.h +++ b/nss/common.h @@ -102,7 +102,7 @@ { \ NSS_ARGS(args)->erange=1; \ return NSS_STATUS_TRYAGAIN; \ - } \ + } #endif /* NSS_FLAVOUR_SOLARIS */ -- cgit v1.2.3 From 2df226afd962fa2f1a3023228bcda5c5903ddfd2 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 28 Oct 2010 21:17:00 +0000 Subject: move acceptconnection() function body inside the worker() so we can more easily break out of the connection handling thread, close the server socket inside the signal handler to cause all threads waiting on accept() to fail and ensure that signals are handled in the main thread by blocking them in the worker threads git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1290 ef36b2f9-881f-0410-afb5-c4e39611909c --- nslcd/nslcd.c | 114 ++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 63 insertions(+), 51 deletions(-) diff --git a/nslcd/nslcd.c b/nslcd/nslcd.c index f8bae99..86a5d1a 100644 --- a/nslcd/nslcd.c +++ b/nslcd/nslcd.c @@ -234,7 +234,11 @@ static const char *signame(int signum) static void sigexit_handler(int signum) { int i; + /* indicate that we're stopping */ nslcd_exitsignal=signum; + /* close server socket to trigger failures in threads waiting on accept() */ + close(nslcd_serversocket); + nslcd_serversocket=-1; /* cancel all running threads */ for (i=0;ildc_threads;i++) if (pthread_cancel(nslcd_threads[i])) @@ -436,45 +440,6 @@ static void handleconnection(int sock,MYLDAP_SESSION *session) return; } -/* accept a connection on the socket */ -static void acceptconnection(MYLDAP_SESSION *session) -{ - int csock; - int j; - struct sockaddr_storage addr; - socklen_t alen; - /* accept a new connection */ - alen=(socklen_t)sizeof(struct sockaddr_storage); - csock=accept(nslcd_serversocket,(struct sockaddr *)&addr,&alen); - if (csock<0) - { - if ((errno==EINTR)||(errno==EAGAIN)||(errno==EWOULDBLOCK)) - { - log_log(LOG_DEBUG,"accept() failed (ignored): %s",strerror(errno)); - return; - } - log_log(LOG_ERR,"accept() failed: %s",strerror(errno)); - return; - } - /* make sure O_NONBLOCK is not inherited */ - if ((j=fcntl(csock,F_GETFL,0))<0) - { - log_log(LOG_ERR,"fctnl(F_GETFL) failed: %s",strerror(errno)); - if (close(csock)) - log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno)); - return; - } - if (fcntl(csock,F_SETFL,j&~O_NONBLOCK)<0) - { - log_log(LOG_ERR,"fctnl(F_SETFL,~O_NONBLOCK) failed: %s",strerror(errno)); - if (close(csock)) - log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno)); - return; - } - /* handle the connection */ - handleconnection(csock,session); -} - /* test to see if we can lock the specified file */ static int is_locked(const char* filename) { @@ -551,6 +516,10 @@ static void worker_cleanup(void *arg) static void *worker(void UNUSED(*arg)) { MYLDAP_SESSION *session; + int csock; + int j; + struct sockaddr_storage addr; + socklen_t alen; /* create a new LDAP session */ session=myldap_create_session(); /* clean up the session if we're done */ @@ -559,7 +528,38 @@ static void *worker(void UNUSED(*arg)) while (1) { /* wait for a new connection */ - acceptconnection(session); + alen=(socklen_t)sizeof(struct sockaddr_storage); + csock=accept(nslcd_serversocket,(struct sockaddr *)&addr,&alen); + /* see if we should exit before doing anything else */ + if (nslcd_exitsignal!=0) + return NULL; + if (csock<0) + { + if ((errno==EINTR)||(errno==EAGAIN)||(errno==EWOULDBLOCK)) + { + log_log(LOG_DEBUG,"accept() failed (ignored): %s",strerror(errno)); + continue; + } + log_log(LOG_ERR,"accept() failed: %s",strerror(errno)); + continue; + } + /* make sure O_NONBLOCK is not inherited */ + if ((j=fcntl(csock,F_GETFL,0))<0) + { + log_log(LOG_ERR,"fctnl(F_GETFL) failed: %s",strerror(errno)); + if (close(csock)) + log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno)); + continue; + } + if (fcntl(csock,F_SETFL,j&~O_NONBLOCK)<0) + { + log_log(LOG_ERR,"fctnl(F_SETFL,~O_NONBLOCK) failed: %s",strerror(errno)); + if (close(csock)) + log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno)); + continue; + } + /* handle the connection */ + handleconnection(csock,session); } pthread_cleanup_pop(1); return NULL; @@ -605,6 +605,7 @@ static void disable_nss_ldap(void) int main(int argc,char *argv[]) { int i; + sigset_t signalmask,oldmask; /* parse the command line */ parse_cmdline(argc,argv); /* clean the environment */ @@ -701,18 +702,19 @@ int main(int argc,char *argv[]) } log_log(LOG_DEBUG,"setuid(%d) done",(int)nslcd_cfg->ldc_uid); } - /* install signalhandlers for some signals */ - install_sighandler(SIGHUP, sigexit_handler); - install_sighandler(SIGINT, sigexit_handler); - install_sighandler(SIGQUIT,sigexit_handler); - install_sighandler(SIGABRT,sigexit_handler); - install_sighandler(SIGPIPE,SIG_IGN); - install_sighandler(SIGTERM,sigexit_handler); - install_sighandler(SIGUSR1,sigexit_handler); - install_sighandler(SIGUSR2,sigexit_handler); - /* TODO: install signal handlers for reloading configuration */ - log_log(LOG_INFO,"accepting connections"); + /* block all these signals so our worker threads won't handle them */ + sigemptyset(&signalmask); + sigaddset(&signalmask,SIGHUP); + sigaddset(&signalmask,SIGINT); + sigaddset(&signalmask,SIGQUIT); + sigaddset(&signalmask,SIGABRT); + sigaddset(&signalmask,SIGPIPE); + sigaddset(&signalmask,SIGTERM); + sigaddset(&signalmask,SIGUSR1); + sigaddset(&signalmask,SIGUSR2); + pthread_sigmask(SIG_BLOCK,&signalmask,&oldmask); /* start worker threads */ + log_log(LOG_INFO,"accepting connections"); nslcd_threads=(pthread_t *)malloc(nslcd_cfg->ldc_threads*sizeof(pthread_t)); if (nslcd_threads==NULL) { @@ -727,6 +729,16 @@ int main(int argc,char *argv[]) exit(EXIT_FAILURE); } } + pthread_sigmask(SIG_SETMASK,&oldmask,NULL); + /* install signalhandlers for some signals */ + install_sighandler(SIGHUP, sigexit_handler); + install_sighandler(SIGINT, sigexit_handler); + install_sighandler(SIGQUIT,sigexit_handler); + install_sighandler(SIGABRT,sigexit_handler); + install_sighandler(SIGPIPE,SIG_IGN); + install_sighandler(SIGTERM,sigexit_handler); + install_sighandler(SIGUSR1,sigexit_handler); + install_sighandler(SIGUSR2,sigexit_handler); /* wait for all threads to die */ /* BUG: this causes problems if for some reason we want to exit but one of our threads hangs (e.g. has one of the LDAP locks) -- cgit v1.2.3 From 85eefd6f9e2f384f7df2d5c503eb3a75f15bb53f Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 13 Dec 2010 21:13:12 +0000 Subject: fix assignment in if statement (was broken in r1262) git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1330 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 4 ++-- nss/group.c | 4 ++-- nss/hosts.c | 8 ++++---- nss/networks.c | 4 ++-- nss/passwd.c | 4 ++-- nss/protocols.c | 4 ++-- nss/rpc.c | 4 ++-- nss/services.c | 4 ++-- nss/shadow.c | 4 ++-- 9 files changed, 20 insertions(+), 20 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 75b09e9..35bb4ff 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -131,14 +131,14 @@ static nss_status_t read_etherstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_etherent(fp,(struct etherent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_etherstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_etherent(fp,(struct etherent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/group.c b/nss/group.c index ef1461b..4dffa75 100644 --- a/nss/group.c +++ b/nss/group.c @@ -221,14 +221,14 @@ static nss_status_t read_groupstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_group(fp,(struct group *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_groupstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_group(fp,(struct group *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/hosts.c b/nss/hosts.c index 8a699f3..fe83b1d 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -300,26 +300,26 @@ static nss_status_t read_hoststring(TFILE *fp,nss_XbyY_args_t *args,int erronemp NSS_ARGS(args)->buf.result? \ read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ read_hoststring(fp,args,1); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #define READ_RESULT_NEXTONEMPTY(fp) \ NSS_ARGS(args)->buf.result? \ read_hostent_nextonempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ read_hoststring(fp,args,0); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT_ERRONEMPTY(fp) \ read_hostent_erronempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #define READ_RESULT_NEXTONEMPTY(fp) \ read_hostent_nextonempty(fp,NSS_ARGS(args)->key.hostaddr.type,(struct hostent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/networks.c b/nss/networks.c index 2a9443b..114a21b 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -201,14 +201,14 @@ static nss_status_t read_netentstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_netent(fp,(struct netent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)): \ read_netentstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_netent(fp,(struct netent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno,&(NSS_ARGS(args)->h_errno)); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/passwd.c b/nss/passwd.c index 2771fbf..80f7159 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -129,14 +129,14 @@ static nss_status_t read_passwdstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_passwd(fp,(struct passwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_passwdstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_passwd(fp,(struct passwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/protocols.c b/nss/protocols.c index 75c5f32..93e230e 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -130,14 +130,14 @@ static nss_status_t read_protostring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_protoent(fp,(struct protoent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_protostring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_protoent(fp,(struct protoent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/rpc.c b/nss/rpc.c index 9b55c8f..9404ccf 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -130,14 +130,14 @@ static nss_status_t read_rpcstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_rpcent(fp,(struct rpcent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_rpcstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_rpcent(fp,(struct rpcent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/services.c b/nss/services.c index db66494..24b7491 100644 --- a/nss/services.c +++ b/nss/services.c @@ -134,14 +134,14 @@ static nss_status_t read_servstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_servent(fp,(struct servent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_servstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_servent(fp,(struct servent *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ diff --git a/nss/shadow.c b/nss/shadow.c index fdcc74f..130ba5a 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -155,14 +155,14 @@ static nss_status_t read_spwdstring(TFILE *fp,nss_XbyY_args_t *args) NSS_ARGS(args)->buf.result? \ read_spwd(fp,(struct spwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno): \ read_spwdstring(fp,args); \ - if ((NSS_ARGS(args)->buf.result)&&(retv=NSS_STATUS_SUCCESS)) \ + if ((NSS_ARGS(args)->buf.result)&&(retv==NSS_STATUS_SUCCESS)) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #else /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ #define READ_RESULT(fp) \ read_spwd(fp,(struct spwd *)NSS_ARGS(args)->buf.result,NSS_ARGS(args)->buf.buffer,NSS_ARGS(args)->buf.buflen,&errno); \ - if (retv=NSS_STATUS_SUCCESS) \ + if (retv==NSS_STATUS_SUCCESS) \ NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.result; #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -- cgit v1.2.3 From 669d8ae73e5a56aafa422e76e4179e22c29a99df Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Mon, 13 Dec 2010 21:36:15 +0000 Subject: have a more consistent naming convention for static lookup functions git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1331 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 14 +++++++------- nss/group.c | 30 +++++++++++++++--------------- nss/hosts.c | 26 +++++++++++++------------- nss/netgroup.c | 26 +++++++++++++------------- nss/networks.c | 26 +++++++++++++------------- nss/passwd.c | 26 +++++++++++++------------- nss/protocols.c | 26 +++++++++++++------------- nss/rpc.c | 26 +++++++++++++------------- nss/services.c | 26 +++++++++++++------------- nss/shadow.c | 22 +++++++++++----------- 10 files changed, 124 insertions(+), 124 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 35bb4ff..2f386d6 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -144,7 +144,7 @@ static nss_status_t read_etherstring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ /* map a hostname to the corresponding ethernet address */ -static nss_status_t get_gethostton(nss_backend_t UNUSED(*be),void *args) +static nss_status_t ethers_gethostton(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_ETHER_BYNAME, NSS_ARGS(args)->key.name, @@ -152,7 +152,7 @@ static nss_status_t get_gethostton(nss_backend_t UNUSED(*be),void *args) } /* map an ethernet address to the corresponding hostname */ -static nss_status_t get_getntohost(nss_backend_t UNUSED(*be),void *args) +static nss_status_t ethers_getntohost(nss_backend_t UNUSED(*be),void *args) { struct ether_addr *addr=(struct ether_addr *)(NSS_ARGS(args)->key.ether); NSS_BYTYPE(NSLCD_ACTION_ETHER_BYETHER, @@ -160,20 +160,20 @@ static nss_status_t get_getntohost(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t ethers_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t ethers_ops[]={ - destructor, - get_gethostton, - get_getntohost + ethers_destructor, + ethers_gethostton, + ethers_getntohost }; nss_backend_t *_nss_ldap_ethers_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/group.c b/nss/group.c index 4dffa75..7427e2d 100644 --- a/nss/group.c +++ b/nss/group.c @@ -233,14 +233,14 @@ static nss_status_t read_groupstring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -static nss_status_t get_getgrnam_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t group_getgrnam(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_GROUP_BYNAME, NSS_ARGS(args)->key.name, READ_RESULT(fp)); } -static nss_status_t get_getgrgid_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t group_getgrgid(nss_backend_t UNUSED(*be),void *args) { NSS_BYTYPE(NSLCD_ACTION_GROUP_BYGID, NSS_ARGS(args)->key.gid,gid_t, @@ -250,18 +250,18 @@ static nss_status_t get_getgrgid_r(nss_backend_t UNUSED(*be),void *args) /* thread-local file pointer to an ongoing request */ static __thread TFILE *grentfp; -static nss_status_t get_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t group_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(grentfp); } -static nss_status_t get_getgrent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t group_getgrent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL, READ_RESULT(grentfp)); } -static nss_status_t get_endgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t group_endgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(grentfp); } @@ -271,7 +271,7 @@ static nss_status_t get_initgroups_dyn( const char *user,gid_t skipgroup,long int *start, gid_t **groupsp,long int limit,int *errnop) */ -static nss_status_t get_getgroupsbymember_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t group_getgroupsbymember(nss_backend_t UNUSED(*be),void *args) { struct nss_groupsbymem *argp=(struct nss_groupsbymem *)args; long int start=(long int)argp->numgids; @@ -282,24 +282,24 @@ static nss_status_t get_getgroupsbymember_r(nss_backend_t UNUSED(*be),void *args argp->numgids=(int)start;); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t group_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t group_ops[]={ - destructor, - get_endgrent, - get_setgrent, - get_getgrent_r, - get_getgrnam_r, - get_getgrgid_r, - get_getgroupsbymember_r + group_destructor, + group_endgrent, + group_setgrent, + group_getgrent, + group_getgrnam, + group_getgrgid, + group_getgroupsbymember }; nss_backend_t *_nss_ldap_group_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/hosts.c b/nss/hosts.c index fe83b1d..019e2b5 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -327,14 +327,14 @@ static nss_status_t read_hoststring(TFILE *fp,nss_XbyY_args_t *args,int erronemp /* hack to set the correct errno and h_errno */ #define h_errnop &(NSS_ARGS(args)->h_errno) -static nss_status_t get_gethostbyname(nss_backend_t UNUSED(*be),void *args) +static nss_status_t hosts_gethostbyname(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_HOST_BYNAME, NSS_ARGS(args)->key.name, READ_RESULT_ERRONEMPTY(fp)); } -static nss_status_t get_gethostbyaddr(nss_backend_t UNUSED(*be),void *args) +static nss_status_t hosts_gethostbyaddr(nss_backend_t UNUSED(*be),void *args) { NSS_BYGEN(NSLCD_ACTION_HOST_BYADDR, WRITE_ADDRESS(fp,NSS_ARGS(args)->key.hostaddr.type,NSS_ARGS(args)->key.hostaddr.len,NSS_ARGS(args)->key.hostaddr.addr), @@ -344,39 +344,39 @@ static nss_status_t get_gethostbyaddr(nss_backend_t UNUSED(*be),void *args) /* thread-local file pointer to an ongoing request */ static __thread TFILE *hostentfp; -static nss_status_t get_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t hosts_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(hostentfp); } -static nss_status_t get_gethostent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t hosts_gethostent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL, READ_RESULT_NEXTONEMPTY(hostentfp)); } -static nss_status_t get_endhostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t hosts_endhostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(hostentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t hosts_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t host_ops[]={ - destructor, - get_endhostent, - get_sethostent, - get_gethostent, - get_gethostbyname, - get_gethostbyaddr + hosts_destructor, + hosts_endhostent, + hosts_sethostent, + hosts_gethostent, + hosts_gethostbyname, + hosts_gethostbyaddr }; nss_backend_t *_nss_ldap_hosts_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/netgroup.c b/nss/netgroup.c index 1531cc4..d2a8dd4 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -152,7 +152,7 @@ struct nss_ldap_netgr_backend }; typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; -static nss_status_t _xnss_ldap_setnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t netgroup_setnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { return NSS_STATUS_SUCCESS; } @@ -200,7 +200,7 @@ static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buf read_netgrent(netgrentfp,result,buffer,buflen,errnop)); } -static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) +static nss_status_t netgroup_getnetgrent(nss_backend_t *_be,void *_args) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_be; struct nss_getnetgrent_args *args=(struct nss_getnetgrent_args *)_args; @@ -271,12 +271,12 @@ static nss_status_t _xnss_ldap_getnetgrent_r(nss_backend_t *_be,void *_args) return status; } -static nss_status_t _xnss_ldap_endnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t netgroup_endnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(netgrentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t netgroup_destructor(nss_backend_t *be,void UNUSED(*args)) { nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)be; /* free list of nested netgroups */ @@ -286,18 +286,18 @@ static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) return NSS_STATUS_SUCCESS; } -static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args); +static nss_status_t netgroup_set(nss_backend_t *be,void *_args); static nss_backend_op_t netgroup_ops[]={ - destructor, /* NSS_DBOP_DESTRUCTOR */ - _xnss_ldap_endnetgrent, /* NSS_DBOP_ENDENT */ - _xnss_ldap_setnetgrent, /* NSS_DBOP_SETNET */ - _xnss_ldap_getnetgrent_r, /* NSS_DBOP_GETENT */ - NULL,/* TODO:_nss_ldap_netgr_in,*/ /* NSS_DBOP_NETGROUP_IN */ - _xnss_ldap_netgr_set /* NSS_DBOP_NETGROUP_SET */ + netgroup_destructor, + netgroup_endnetgrent, + netgroup_setnetgrent, + netgroup_getnetgrent, + NULL,/* TODO:_nss_ldap_netgr_in,*/ + netgroup_set }; -static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) +static nss_status_t netgroup_set(nss_backend_t *be,void *_args) { nss_status_t stat; struct nss_setnetgrent_args *args; @@ -326,7 +326,7 @@ static nss_status_t _xnss_ldap_netgr_set(nss_backend_t *be,void *_args) } nss_backend_t *_nss_ldap_netgroup_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_ldap_netgr_backend_t *be; if (!(be=(nss_ldap_netgr_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/networks.c b/nss/networks.c index 114a21b..98b737b 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -216,14 +216,14 @@ static nss_status_t read_netentstring(TFILE *fp,nss_XbyY_args_t *args) /* more of a dirty hack */ #define h_errnop (&(NSS_ARGS(args)->h_errno)) -static nss_status_t _xnss_ldap_getnetbyname_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t networks_getnetbyname(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_NETWORK_BYNAME, NSS_ARGS(args)->key.name, READ_RESULT(fp)); } -static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t networks_getnetbyaddr(nss_backend_t UNUSED(*be),void *args) { NSS_BYGEN(NSLCD_ACTION_NETWORK_BYADDR, WRITE_ADDRESS(fp,NSS_ARGS(args)->key.netaddr.net), @@ -233,39 +233,39 @@ static nss_status_t _xnss_ldap_getnetbyaddr_r(nss_backend_t UNUSED(*be),void *ar /* thread-local file pointer to an ongoing request */ static __thread TFILE *netentfp; -static nss_status_t _xnss_ldap_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t networks_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(netentfp); } -static nss_status_t _xnss_ldap_getnetent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t networks_getnetent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL, READ_RESULT(netentfp)); } -static nss_status_t _xnss_ldap_endnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t networks_endnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(netentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t networks_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t net_ops[]={ - destructor, - _xnss_ldap_endnetent, - _xnss_ldap_setnetent, - _xnss_ldap_getnetent_r, - _xnss_ldap_getnetbyname_r, - _xnss_ldap_getnetbyaddr_r + networks_destructor, + networks_endnetent, + networks_setnetent, + networks_getnetent, + networks_getnetbyname, + networks_getnetbyaddr }; nss_backend_t *_nss_ldap_networks_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/passwd.c b/nss/passwd.c index 80f7159..28022b1 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -141,14 +141,14 @@ static nss_status_t read_passwdstring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -static nss_status_t get_getpwnam(nss_backend_t UNUSED(*be),void *args) +static nss_status_t passwd_getpwnam(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_PASSWD_BYNAME, NSS_ARGS(args)->key.name, READ_RESULT(fp)); } -static nss_status_t get_getpwuid(nss_backend_t UNUSED(*be),void *args) +static nss_status_t passwd_getpwuid(nss_backend_t UNUSED(*be),void *args) { NSS_BYTYPE(NSLCD_ACTION_PASSWD_BYUID, NSS_ARGS(args)->key.uid,uid_t, @@ -159,41 +159,41 @@ static nss_status_t get_getpwuid(nss_backend_t UNUSED(*be),void *args) static __thread TFILE *pwentfp; /* open a connection to the nslcd and write the request */ -static nss_status_t get_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t passwd_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(pwentfp); } /* read password data from an opened stream */ -static nss_status_t get_getpwent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t passwd_getpwent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL, READ_RESULT(pwentfp)); } /* close the stream opened with setpwent() above */ -static nss_status_t get_endpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t passwd_endpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(pwentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t passwd_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t passwd_ops[]={ - destructor, - get_endpwent, /* NSS_DBOP_ENDENT */ - get_setpwent, /* NSS_DBOP_SETENT */ - get_getpwent, /* NSS_DBOP_GETENT */ - get_getpwnam, /* NSS_DBOP_PASSWD_BYNAME */ - get_getpwuid /* NSS_DBOP_PASSWD_BYUID */ + passwd_destructor, + passwd_endpwent, + passwd_setpwent, + passwd_getpwent, + passwd_getpwnam, + passwd_getpwuid }; nss_backend_t *_nss_ldap_passwd_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/protocols.c b/nss/protocols.c index 93e230e..5d61576 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -142,14 +142,14 @@ static nss_status_t read_protostring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -static nss_status_t get_getprotobyname(nss_backend_t UNUSED(*be),void *args) +static nss_status_t protocols_getprotobyname(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_PROTOCOL_BYNAME, NSS_ARGS(args)->key.name, READ_RESULT(fp)); } -static nss_status_t get_getprotobynumber(nss_backend_t UNUSED(*be),void *args) +static nss_status_t protocols_getprotobynumber(nss_backend_t UNUSED(*be),void *args) { NSS_BYINT32(NSLCD_ACTION_PROTOCOL_BYNUMBER, NSS_ARGS(args)->key.number, @@ -159,39 +159,39 @@ static nss_status_t get_getprotobynumber(nss_backend_t UNUSED(*be),void *args) /* thread-local file pointer to an ongoing request */ static __thread TFILE *protoentfp; -static nss_status_t get_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t protocols_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(protoentfp); } -static nss_status_t get_getprotoent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t protocols_getprotoent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL, READ_RESULT(protoentfp)); } -static nss_status_t get_endprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t protocols_endprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(protoentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t protocols_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t proto_ops[]={ - destructor, - get_endprotoent, - get_setprotoent, - get_getprotoent, - get_getprotobyname, - get_getprotobynumber + protocols_destructor, + protocols_endprotoent, + protocols_setprotoent, + protocols_getprotoent, + protocols_getprotobyname, + protocols_getprotobynumber }; nss_backend_t *_nss_ldap_protocols_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; be=(nss_backend_t *)malloc(sizeof(*be)); diff --git a/nss/rpc.c b/nss/rpc.c index 9404ccf..096cf94 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -142,14 +142,14 @@ static nss_status_t read_rpcstring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -static nss_status_t get_getrpcbyname_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t rpc_getrpcbyname(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_RPC_BYNAME, NSS_ARGS(args)->key.name, READ_RESULT(fp)); } -static nss_status_t get_getrpcbynumber_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t rpc_getrpcbynumber(nss_backend_t UNUSED(*be),void *args) { NSS_BYINT32(NSLCD_ACTION_RPC_BYNUMBER, NSS_ARGS(args)->key.number, @@ -159,39 +159,39 @@ static nss_status_t get_getrpcbynumber_r(nss_backend_t UNUSED(*be),void *args) /* thread-local file pointer to an ongoing request */ static __thread TFILE *rpcentfp; -static nss_status_t get_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t rpc_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(rpcentfp); } -static nss_status_t get_getrpcent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t rpc_getrpcent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(rpcentfp,NSLCD_ACTION_RPC_ALL, READ_RESULT(rpcentfp)); } -static nss_status_t get_endrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t rpc_endrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(rpcentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t rpc_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t rpc_ops[]={ - destructor, - get_endrpcent, - get_setrpcent, - get_getrpcent_r, - get_getrpcbyname_r, - get_getrpcbynumber_r + rpc_destructor, + rpc_endrpcent, + rpc_setrpcent, + rpc_getrpcent, + rpc_getrpcbyname, + rpc_getrpcbynumber }; nss_backend_t *_nss_ldap_rpc_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/services.c b/nss/services.c index 24b7491..4583ba7 100644 --- a/nss/services.c +++ b/nss/services.c @@ -146,7 +146,7 @@ static nss_status_t read_servstring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -static nss_status_t get_getservbyname_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t services_getservbyname(nss_backend_t UNUSED(*be),void *args) { NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNAME, WRITE_STRING(fp,NSS_ARGS(args)->key.serv.serv.name); @@ -154,7 +154,7 @@ static nss_status_t get_getservbyname_r(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -static nss_status_t get_getservbyport_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t services_getservbyport(nss_backend_t UNUSED(*be),void *args) { NSS_BYGEN(NSLCD_ACTION_SERVICE_BYNUMBER, WRITE_INT32(fp,ntohs(NSS_ARGS(args)->key.serv.serv.port)); @@ -165,39 +165,39 @@ static nss_status_t get_getservbyport_r(nss_backend_t UNUSED(*be),void *args) /* thread-local file pointer to an ongoing request */ static __thread TFILE *serventfp; -static nss_status_t get_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t services_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(serventfp); } -static nss_status_t get_getservent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t services_getservent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL, READ_RESULT(serventfp)); } -static nss_status_t get_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t services_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(serventfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t services_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t services_ops[]={ - destructor, - get_endservent, - get_setservent, - get_getservent_r, - get_getservbyname_r, - get_getservbyport_r + services_destructor, + services_endservent, + services_setservent, + services_getservent, + services_getservbyname, + services_getservbyport }; nss_backend_t *_nss_ldap_services_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) diff --git a/nss/shadow.c b/nss/shadow.c index 130ba5a..9bd84fc 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -167,7 +167,7 @@ static nss_status_t read_spwdstring(TFILE *fp,nss_XbyY_args_t *args) #endif /* not HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */ -static nss_status_t get_getspnam_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t shadow_getspnam(nss_backend_t UNUSED(*be),void *args) { NSS_BYNAME(NSLCD_ACTION_SHADOW_BYNAME, NSS_ARGS(args)->key.name, @@ -177,38 +177,38 @@ static nss_status_t get_getspnam_r(nss_backend_t UNUSED(*be),void *args) /* thread-local file pointer to an ongoing request */ static __thread TFILE *spentfp; -static nss_status_t get_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t shadow_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_SETENT(spentfp); } -static nss_status_t get_getspent_r(nss_backend_t UNUSED(*be),void *args) +static nss_status_t shadow_getspent(nss_backend_t UNUSED(*be),void *args) { NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL, READ_RESULT(spentfp)); } -static nss_status_t get_endspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t shadow_endspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { NSS_ENDENT(spentfp); } -static nss_status_t destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t shadow_destructor(nss_backend_t *be,void UNUSED(*args)) { free(be); return NSS_STATUS_SUCCESS; } static nss_backend_op_t shadow_ops[]={ - destructor, - get_endspent, /* NSS_DBOP_ENDENT */ - get_setspent, /* NSS_DBOP_SETENT */ - get_getspent_r, /* NSS_DBOP_GETENT */ - get_getspnam_r /* NSS_DBOP_SHADOW_BYNAME */ + shadow_destructor, + shadow_endspent, + shadow_setspent, + shadow_getspent, + shadow_getspnam }; nss_backend_t *_nss_ldap_shadow_constr(const char UNUSED(*db_name), - const char UNUSED(*src_name),const char UNUSED(*cfg_args)) + const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { nss_backend_t *be; if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) -- cgit v1.2.3 From 08f01639626bb2ec2537df7d9f8c5459867c0afb Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 16 Dec 2010 20:25:41 +0000 Subject: split NSS notes into a Glibc and a Solaris section and add Solaris documentation pointers git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1332 ef36b2f9-881f-0410-afb5-c4e39611909c --- HACKING | 42 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 38 insertions(+), 4 deletions(-) diff --git a/HACKING b/HACKING index 3983651..be9750c 100644 --- a/HACKING +++ b/HACKING @@ -91,7 +91,17 @@ NSS MODULE ========== The NSS module is implemented in the nss directory. The functions are split -into files according to the database they support. Functions look like: +into files according to the database they support. The files support multiple +NSS implementations. + +The NSS interface is specific to the C library that is used. The original +implementation was for the GNU C Library but now also includes an +implementation for Solaris' C Library and has some support for FreeBSD. + +GNU C Library notes +------------------- + +Function definitions for glibc look like: _nss_ldap_FUNCTION_r(...) This function opens the connection to the nslcd (with a time-out), builds @@ -99,17 +109,41 @@ _nss_ldap_FUNCTION_r(...) waiting for an answer (again with a time-out) The complete list of exported functions can be found in exports.linux and -prototypes.h. The NSS interface seems to be fairly libc-specific and is -currently tuned towards GNU Libc, although FreeBSD has a port based on this -code. +prototypes.h. Currently a number of macros are used to build most of the function bodies for these functions. Part of this is defined in the common/nslcd-prot.h file and the NSS-specific stuff is in nss/common.h. +For memory management, the general mechanism that is expected to be used is +to return NSS_STATUS_TRYAGAIN and set errno to ERANGE. This causes glibc to +retry the request with a larger buffer. + Some useful links: http://www.gnu.org/software/libc/manual/html_node/index.html +Solaris C Library notes +----------------------- + +The Solaris C library uses a different mechanism. For each map a back-end +object is allocated per thread which is used to do queries. The object is +created with a constructor (e.g. _nss_ldap_passwd_constr()) that returns a +back-end that contains a list of function pointer to lookup methods and a +destructor. + +A buffer is passed with every request but a local buffer that is stored in the +back-end can presumably also be created. + +Earlier versions of Solaris expected the NSS functions to return the binary +representation of the lookups (e.g. struct passwd) but later versions expect a +string representation of the data to be returned (just like a single line out +of /etc/passwd was read). + +Source and documentation pointers for Solaris NSS: +http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/nsswitch/ +http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/head/nss_common.h +http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/head/nss_dbdefs.h + PAM MODULE ========== -- cgit v1.2.3 From f67d6f67b84daa6acd33dd8f4192a72bc46c3a63 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 16 Dec 2010 21:50:51 +0000 Subject: switch to a common back-end with a common constructor and destructor and put file pointer shared between {set,get,end}ent() calls in there git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1333 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/common.c | 34 ++++++++++++++++++++++++++++++++++ nss/common.h | 20 ++++++++++++++++++++ nss/group.c | 32 +++++++++----------------------- nss/hosts.c | 41 +++++++++++++++++------------------------ nss/networks.c | 34 ++++++++++------------------------ nss/passwd.c | 32 +++++++++----------------------- nss/protocols.c | 35 ++++++++++------------------------- nss/rpc.c | 32 +++++++++----------------------- nss/services.c | 32 +++++++++----------------------- nss/shadow.c | 32 +++++++++----------------------- 10 files changed, 136 insertions(+), 188 deletions(-) diff --git a/nss/common.c b/nss/common.c index 20a3136..7a0f8e7 100644 --- a/nss/common.c +++ b/nss/common.c @@ -19,4 +19,38 @@ 02110-1301 USA */ +#include "config.h" + +#include + +#include "prototypes.h" +#include "common.h" +#include "compat/attrs.h" + +/* global symbol to prevent NSS name lookups using this module */ int _nss_ldap_enablelookups=1; + +#ifdef NSS_FLAVOUR_SOLARIS + +nss_backend_t *nss_ldap_constructor(nss_backend_op_t *ops,size_t sizeofops) +{ + struct nss_ldap_backend *ldapbe; + ldapbe=(struct nss_ldap_backend *)malloc(sizeof(struct nss_ldap_backend)); + if (ldapbe==NULL) + return NULL; + ldapbe->ops=ops; + ldapbe->n_ops=sizeofops/sizeof(nss_backend_op_t); + ldapbe->fp=NULL; + return (nss_backend_t *)ldapbe; +} + +nss_status_t nss_ldap_destructor(nss_backend_t *be,void UNUSED(*args)) +{ + struct nss_ldap_backend *ldapbe=(struct nss_ldap_backend *)be; + if (ldapbe->fp!=NULL) + (void)tio_close(ldapbe->fp); + free(ldapbe); + return NSS_STATUS_SUCCESS; +} + +#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/common.h b/nss/common.h index 7a3edcf..74ba519 100644 --- a/nss/common.h +++ b/nss/common.h @@ -104,6 +104,26 @@ return NSS_STATUS_TRYAGAIN; \ } +/* this is the backend structure for Solaris */ +struct nss_ldap_backend +{ + nss_backend_op_t *ops; /* function-pointer table */ + int n_ops; /* number of function pointers */ + TFILE *fp; /* the file pointer for {set,get,end}ent() functions */ +}; + +/* constructor for LDAP backends */ +nss_backend_t *nss_ldap_constructor(nss_backend_op_t *ops,size_t sizeofops); + +/* destructor for LDAP backends */ +nss_status_t nss_ldap_destructor(nss_backend_t *be,void UNUSED(*args)); + +extern TFILE *xxfp; + +/* easy way to get fp from back-end */ +/* #define LDAP_GET_FP(be) (((struct nss_ldap_backend*)(be))->fp) */ +#define LDAP_BE(be) ((struct nss_ldap_backend*)(be)) + #endif /* NSS_FLAVOUR_SOLARIS */ /* The following macros to automatically generate get..byname(), diff --git a/nss/group.c b/nss/group.c index 7427e2d..b460445 100644 --- a/nss/group.c +++ b/nss/group.c @@ -247,23 +247,20 @@ static nss_status_t group_getgrgid(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *grentfp; - -static nss_status_t group_setgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t group_setgrent(nss_backend_t *be,void UNUSED(*args)) { - NSS_SETENT(grentfp); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t group_getgrent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t group_getgrent(nss_backend_t *be,void *args) { - NSS_GETENT(grentfp,NSLCD_ACTION_GROUP_ALL, - READ_RESULT(grentfp)); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_GROUP_ALL, + READ_RESULT((LDAP_BE(be)->fp))); } -static nss_status_t group_endgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t group_endgrent(nss_backend_t *be,void UNUSED(*args)) { - NSS_ENDENT(grentfp); + NSS_ENDENT(LDAP_BE(be)->fp); } /* @@ -282,14 +279,8 @@ static nss_status_t group_getgroupsbymember(nss_backend_t UNUSED(*be),void *args argp->numgids=(int)start;); } -static nss_status_t group_destructor(nss_backend_t *be,void UNUSED(*args)) -{ - free(be); - return NSS_STATUS_SUCCESS; -} - static nss_backend_op_t group_ops[]={ - group_destructor, + nss_ldap_destructor, group_endgrent, group_setgrent, group_getgrent, @@ -301,12 +292,7 @@ static nss_backend_op_t group_ops[]={ nss_backend_t *_nss_ldap_group_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=group_ops; - be->n_ops=sizeof(group_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(group_ops,sizeof(group_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/hosts.c b/nss/hosts.c index 019e2b5..eda7dc5 100644 --- a/nss/hosts.c +++ b/nss/hosts.c @@ -242,6 +242,13 @@ nss_status_t _nss_ldap_endhostent(void) #ifdef NSS_FLAVOUR_SOLARIS +struct nss_ldap_hosts_backend +{ + nss_backend_op_t *ops; + int n_ops; + TFILE *fp; +}; + #ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN static nss_status_t read_hoststring(TFILE *fp,nss_XbyY_args_t *args,int erronempty) @@ -341,33 +348,24 @@ static nss_status_t hosts_gethostbyaddr(nss_backend_t UNUSED(*be),void *args) READ_RESULT_ERRONEMPTY(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *hostentfp; - -static nss_status_t hosts_sethostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t hosts_sethostent(nss_backend_t *be,void UNUSED(*args)) { - NSS_SETENT(hostentfp); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t hosts_gethostent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t hosts_gethostent(nss_backend_t *be,void *args) { - NSS_GETENT(hostentfp,NSLCD_ACTION_HOST_ALL, - READ_RESULT_NEXTONEMPTY(hostentfp)); -} - -static nss_status_t hosts_endhostent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - NSS_ENDENT(hostentfp); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_HOST_ALL, + READ_RESULT_NEXTONEMPTY(LDAP_BE(be)->fp)); } -static nss_status_t hosts_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t hosts_endhostent(nss_backend_t *be,void UNUSED(*args)) { - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } -static nss_backend_op_t host_ops[]={ - hosts_destructor, +static nss_backend_op_t hosts_ops[]={ + nss_ldap_destructor, hosts_endhostent, hosts_sethostent, hosts_gethostent, @@ -378,12 +376,7 @@ static nss_backend_op_t host_ops[]={ nss_backend_t *_nss_ldap_hosts_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=host_ops; - be->n_ops=sizeof(host_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(hosts_ops,sizeof(hosts_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/networks.c b/nss/networks.c index 98b737b..1b407de 100644 --- a/nss/networks.c +++ b/nss/networks.c @@ -230,33 +230,24 @@ static nss_status_t networks_getnetbyaddr(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *netentfp; - -static nss_status_t networks_setnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - NSS_SETENT(netentfp); -} - -static nss_status_t networks_getnetent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t networks_setnetent(nss_backend_t *be,void UNUSED(*args)) { - NSS_GETENT(netentfp,NSLCD_ACTION_NETWORK_ALL, - READ_RESULT(netentfp)); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t networks_endnetent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t networks_getnetent(nss_backend_t *be,void *args) { - NSS_ENDENT(netentfp); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_NETWORK_ALL, + READ_RESULT(LDAP_BE(be)->fp)); } -static nss_status_t networks_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t networks_endnetent(nss_backend_t *be,void UNUSED(*args)) { - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } -static nss_backend_op_t net_ops[]={ - networks_destructor, +static nss_backend_op_t networks_ops[]={ + nss_ldap_destructor, networks_endnetent, networks_setnetent, networks_getnetent, @@ -267,12 +258,7 @@ static nss_backend_op_t net_ops[]={ nss_backend_t *_nss_ldap_networks_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=net_ops; - be->n_ops=sizeof(net_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(networks_ops,sizeof(networks_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/passwd.c b/nss/passwd.c index 28022b1..9681eb5 100644 --- a/nss/passwd.c +++ b/nss/passwd.c @@ -155,36 +155,27 @@ static nss_status_t passwd_getpwuid(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *pwentfp; - /* open a connection to the nslcd and write the request */ -static nss_status_t passwd_setpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t passwd_setpwent(nss_backend_t *be,void UNUSED(*args)) { - NSS_SETENT(pwentfp); + NSS_SETENT(LDAP_BE(be)->fp); } /* read password data from an opened stream */ -static nss_status_t passwd_getpwent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t passwd_getpwent(nss_backend_t *be,void *args) { - NSS_GETENT(pwentfp,NSLCD_ACTION_PASSWD_ALL, - READ_RESULT(pwentfp)); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_PASSWD_ALL, + READ_RESULT(LDAP_BE(be)->fp)); } /* close the stream opened with setpwent() above */ -static nss_status_t passwd_endpwent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t passwd_endpwent(nss_backend_t *be,void UNUSED(*args)) { - NSS_ENDENT(pwentfp); -} - -static nss_status_t passwd_destructor(nss_backend_t *be,void UNUSED(*args)) -{ - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } static nss_backend_op_t passwd_ops[]={ - passwd_destructor, + nss_ldap_destructor, passwd_endpwent, passwd_setpwent, passwd_getpwent, @@ -195,12 +186,7 @@ static nss_backend_op_t passwd_ops[]={ nss_backend_t *_nss_ldap_passwd_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=passwd_ops; - be->n_ops=sizeof(passwd_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(passwd_ops,sizeof(passwd_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/protocols.c b/nss/protocols.c index 5d61576..c641eaa 100644 --- a/nss/protocols.c +++ b/nss/protocols.c @@ -156,33 +156,24 @@ static nss_status_t protocols_getprotobynumber(nss_backend_t UNUSED(*be),void *a READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *protoentfp; - -static nss_status_t protocols_setprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - NSS_SETENT(protoentfp); -} - -static nss_status_t protocols_getprotoent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t protocols_setprotoent(nss_backend_t *be,void UNUSED(*args)) { - NSS_GETENT(protoentfp,NSLCD_ACTION_PROTOCOL_ALL, - READ_RESULT(protoentfp)); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t protocols_endprotoent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t protocols_getprotoent(nss_backend_t *be,void *args) { - NSS_ENDENT(protoentfp); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_PROTOCOL_ALL, + READ_RESULT(LDAP_BE(be)->fp)); } -static nss_status_t protocols_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t protocols_endprotoent(nss_backend_t *be,void UNUSED(*args)) { - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } -static nss_backend_op_t proto_ops[]={ - protocols_destructor, +static nss_backend_op_t protocols_ops[]={ + nss_ldap_destructor, protocols_endprotoent, protocols_setprotoent, protocols_getprotoent, @@ -193,13 +184,7 @@ static nss_backend_op_t proto_ops[]={ nss_backend_t *_nss_ldap_protocols_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - be=(nss_backend_t *)malloc(sizeof(*be)); - if (be==NULL) - return NULL; - be->ops=proto_ops; - be->n_ops=sizeof(proto_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(protocols_ops,sizeof(protocols_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/rpc.c b/nss/rpc.c index 096cf94..cc1b12f 100644 --- a/nss/rpc.c +++ b/nss/rpc.c @@ -156,33 +156,24 @@ static nss_status_t rpc_getrpcbynumber(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *rpcentfp; - -static nss_status_t rpc_setrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - NSS_SETENT(rpcentfp); -} - -static nss_status_t rpc_getrpcent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t rpc_setrpcent(nss_backend_t *be,void UNUSED(*args)) { - NSS_GETENT(rpcentfp,NSLCD_ACTION_RPC_ALL, - READ_RESULT(rpcentfp)); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t rpc_endrpcent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t rpc_getrpcent(nss_backend_t *be,void *args) { - NSS_ENDENT(rpcentfp); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_RPC_ALL, + READ_RESULT(LDAP_BE(be)->fp)); } -static nss_status_t rpc_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t rpc_endrpcent(nss_backend_t *be,void UNUSED(*args)) { - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } static nss_backend_op_t rpc_ops[]={ - rpc_destructor, + nss_ldap_destructor, rpc_endrpcent, rpc_setrpcent, rpc_getrpcent, @@ -193,12 +184,7 @@ static nss_backend_op_t rpc_ops[]={ nss_backend_t *_nss_ldap_rpc_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=rpc_ops; - be->n_ops=sizeof(rpc_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(rpc_ops,sizeof(rpc_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/services.c b/nss/services.c index 4583ba7..4d03d5c 100644 --- a/nss/services.c +++ b/nss/services.c @@ -162,33 +162,24 @@ static nss_status_t services_getservbyport(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *serventfp; - -static nss_status_t services_setservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - NSS_SETENT(serventfp); -} - -static nss_status_t services_getservent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t services_setservent(nss_backend_t *be,void UNUSED(*args)) { - NSS_GETENT(serventfp,NSLCD_ACTION_SERVICE_ALL, - READ_RESULT(serventfp)); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t services_endservent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t services_getservent(nss_backend_t *be,void *args) { - NSS_ENDENT(serventfp); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_SERVICE_ALL, + READ_RESULT(LDAP_BE(be)->fp)); } -static nss_status_t services_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t services_endservent(nss_backend_t *be,void UNUSED(*args)) { - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } static nss_backend_op_t services_ops[]={ - services_destructor, + nss_ldap_destructor, services_endservent, services_setservent, services_getservent, @@ -199,12 +190,7 @@ static nss_backend_op_t services_ops[]={ nss_backend_t *_nss_ldap_services_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=services_ops; - be->n_ops=sizeof(services_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(services_ops,sizeof(services_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/shadow.c b/nss/shadow.c index 9bd84fc..d22af52 100644 --- a/nss/shadow.c +++ b/nss/shadow.c @@ -174,33 +174,24 @@ static nss_status_t shadow_getspnam(nss_backend_t UNUSED(*be),void *args) READ_RESULT(fp)); } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *spentfp; - -static nss_status_t shadow_setspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - NSS_SETENT(spentfp); -} - -static nss_status_t shadow_getspent(nss_backend_t UNUSED(*be),void *args) +static nss_status_t shadow_setspent(nss_backend_t *be,void UNUSED(*args)) { - NSS_GETENT(spentfp,NSLCD_ACTION_SHADOW_ALL, - READ_RESULT(spentfp)); + NSS_SETENT(LDAP_BE(be)->fp); } -static nss_status_t shadow_endspent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t shadow_getspent(nss_backend_t *be,void *args) { - NSS_ENDENT(spentfp); + NSS_GETENT(LDAP_BE(be)->fp,NSLCD_ACTION_SHADOW_ALL, + READ_RESULT(LDAP_BE(be)->fp)); } -static nss_status_t shadow_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t shadow_endspent(nss_backend_t *be,void UNUSED(*args)) { - free(be); - return NSS_STATUS_SUCCESS; + NSS_ENDENT(LDAP_BE(be)->fp); } static nss_backend_op_t shadow_ops[]={ - shadow_destructor, + nss_ldap_destructor, shadow_endspent, shadow_setspent, shadow_getspent, @@ -210,12 +201,7 @@ static nss_backend_op_t shadow_ops[]={ nss_backend_t *_nss_ldap_shadow_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_backend_t *be; - if (!(be=(nss_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=shadow_ops; - be->n_ops=sizeof(shadow_ops)/sizeof(nss_backend_op_t); - return (nss_backend_t *)be; + return nss_ldap_constructor(shadow_ops,sizeof(shadow_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ -- cgit v1.2.3 From 8afe8b7a20f72c980834f4e943a0db0e5809302e Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 16 Dec 2010 22:45:08 +0000 Subject: remove debugging left-overs git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1334 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/common.h | 3 --- 1 file changed, 3 deletions(-) diff --git a/nss/common.h b/nss/common.h index 74ba519..903f624 100644 --- a/nss/common.h +++ b/nss/common.h @@ -118,10 +118,7 @@ nss_backend_t *nss_ldap_constructor(nss_backend_op_t *ops,size_t sizeofops); /* destructor for LDAP backends */ nss_status_t nss_ldap_destructor(nss_backend_t *be,void UNUSED(*args)); -extern TFILE *xxfp; - /* easy way to get fp from back-end */ -/* #define LDAP_GET_FP(be) (((struct nss_ldap_backend*)(be))->fp) */ #define LDAP_BE(be) ((struct nss_ldap_backend*)(be)) #endif /* NSS_FLAVOUR_SOLARIS */ -- cgit v1.2.3 From 4e9224817ee303404b804a1a51f2f9c9a49164e4 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Fri, 17 Dec 2010 20:13:39 +0000 Subject: move LDAP_BE() definition git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1335 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/common.h | 3 --- nss/prototypes.h | 2 ++ 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/nss/common.h b/nss/common.h index 903f624..0dcce17 100644 --- a/nss/common.h +++ b/nss/common.h @@ -118,9 +118,6 @@ nss_backend_t *nss_ldap_constructor(nss_backend_op_t *ops,size_t sizeofops); /* destructor for LDAP backends */ nss_status_t nss_ldap_destructor(nss_backend_t *be,void UNUSED(*args)); -/* easy way to get fp from back-end */ -#define LDAP_BE(be) ((struct nss_ldap_backend*)(be)) - #endif /* NSS_FLAVOUR_SOLARIS */ /* The following macros to automatically generate get..byname(), diff --git a/nss/prototypes.h b/nss/prototypes.h index 4989fd9..23c7c33 100644 --- a/nss/prototypes.h +++ b/nss/prototypes.h @@ -123,7 +123,9 @@ nss_status_t _nss_ldap_endspent(void); #ifdef NSS_FLAVOUR_SOLARIS +/* helper marcos to do casts */ #define NSS_ARGS(args) ((nss_XbyY_args_t *)args) +#define LDAP_BE(be) ((struct nss_ldap_backend*)(be)) /* these are the constructors we provide */ nss_backend_t *_nss_ldap_ethers_constr(const char *db_name,const char *src_name,const char *cfg_args); -- cgit v1.2.3 From d99781bdf175fd7b66d37741c3acf33ca9331b49 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 30 Dec 2010 12:09:10 +0000 Subject: move Solaris specific NSS functions to separate file git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1350 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/Makefile.am | 7 ++++--- nss/common.c | 34 ---------------------------------- nss/solnss.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 53 insertions(+), 37 deletions(-) create mode 100644 nss/solnss.c diff --git a/nss/Makefile.am b/nss/Makefile.am index d16eba6..0fddbe7 100644 --- a/nss/Makefile.am +++ b/nss/Makefile.am @@ -31,11 +31,12 @@ nss_ldap_so_SOURCES = common.c common.h prototypes.h \ EXTRA_nss_ldap_so_SOURCES = aliases.c ethers.c group.c hosts.c netgroup.c \ networks.c passwd.c protocols.c rpc.c services.c \ shadow.c -nss_ldap_so_DEPENDENCIES = $(NSS_MODULE_OBJS) -nss_ldap_so_LDADD = $(NSS_MODULE_OBJS) ../common/libtio.a ../common/libprot.a +nss_ldap_so_DEPENDENCIES = $(NSS_MODULE_OBJS) solnss.$(OBJEXT) +nss_ldap_so_LDADD = $(NSS_MODULE_OBJS) if NSS_FLAVOUR_SOLARIS -nss_ldap_so_LDADD += ../common/libdict.a +nss_ldap_so_LDADD += solnss.$(OBJEXT) ../common/libdict.a endif +nss_ldap_so_LDADD += ../common/libtio.a ../common/libprot.a EXTRA_DIST = exports.glibc exports.solaris diff --git a/nss/common.c b/nss/common.c index 7a0f8e7..20a3136 100644 --- a/nss/common.c +++ b/nss/common.c @@ -19,38 +19,4 @@ 02110-1301 USA */ -#include "config.h" - -#include - -#include "prototypes.h" -#include "common.h" -#include "compat/attrs.h" - -/* global symbol to prevent NSS name lookups using this module */ int _nss_ldap_enablelookups=1; - -#ifdef NSS_FLAVOUR_SOLARIS - -nss_backend_t *nss_ldap_constructor(nss_backend_op_t *ops,size_t sizeofops) -{ - struct nss_ldap_backend *ldapbe; - ldapbe=(struct nss_ldap_backend *)malloc(sizeof(struct nss_ldap_backend)); - if (ldapbe==NULL) - return NULL; - ldapbe->ops=ops; - ldapbe->n_ops=sizeofops/sizeof(nss_backend_op_t); - ldapbe->fp=NULL; - return (nss_backend_t *)ldapbe; -} - -nss_status_t nss_ldap_destructor(nss_backend_t *be,void UNUSED(*args)) -{ - struct nss_ldap_backend *ldapbe=(struct nss_ldap_backend *)be; - if (ldapbe->fp!=NULL) - (void)tio_close(ldapbe->fp); - free(ldapbe); - return NSS_STATUS_SUCCESS; -} - -#endif /* NSS_FLAVOUR_SOLARIS */ diff --git a/nss/solnss.c b/nss/solnss.c new file mode 100644 index 0000000..5206e30 --- /dev/null +++ b/nss/solnss.c @@ -0,0 +1,49 @@ +/* + solnss.c - Solaris specific NSS interface functions + + Copyright (C) 2010 Arthur de Jong + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA +*/ + +#include "config.h" + +#include + +#include "prototypes.h" +#include "common.h" +#include "compat/attrs.h" + +nss_backend_t *nss_ldap_constructor(nss_backend_op_t *ops,size_t sizeofops) +{ + struct nss_ldap_backend *ldapbe; + ldapbe=(struct nss_ldap_backend *)malloc(sizeof(struct nss_ldap_backend)); + if (ldapbe==NULL) + return NULL; + ldapbe->ops=ops; + ldapbe->n_ops=sizeofops/sizeof(nss_backend_op_t); + ldapbe->fp=NULL; + return (nss_backend_t *)ldapbe; +} + +nss_status_t nss_ldap_destructor(nss_backend_t *be,void UNUSED(*args)) +{ + struct nss_ldap_backend *ldapbe=(struct nss_ldap_backend *)be; + if (ldapbe->fp!=NULL) + (void)tio_close(ldapbe->fp); + free(ldapbe); + return NSS_STATUS_SUCCESS; +} -- cgit v1.2.3 From 726a1a89d34fbdb4974cd24a1ecc3369f241de19 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 30 Dec 2010 12:24:46 +0000 Subject: implement buffer checking and simplify code somewhat git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1351 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/ethers.c | 30 ++++++++++++++---------------- nss/group.c | 29 +++++++++++++++++------------ 2 files changed, 31 insertions(+), 28 deletions(-) diff --git a/nss/ethers.c b/nss/ethers.c index 2f386d6..a109cf3 100644 --- a/nss/ethers.c +++ b/nss/ethers.c @@ -100,28 +100,26 @@ nss_status_t _nss_ldap_endetherent(void) static nss_status_t read_etherstring(TFILE *fp,nss_XbyY_args_t *args) { - /* TODO: padl uses struct ether, verify */ struct etherent result; nss_status_t retv; char *buffer; - size_t buflen; - /* read the etherent */ - retv=read_etherent(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + int res; + /* read the etherent into a temporary buffer */ + buffer=(char *)malloc(args->buf.buflen); + if (buffer==NULL) + return NSS_STATUS_UNAVAIL; + retv=read_etherent(fp,&result,buffer,args->buf.buflen,&errno); if (retv!=NSS_STATUS_SUCCESS) + { + free(buffer); return retv; - /* allocate a temporary buffer */ - buflen=args->buf.buflen; - buffer=(char *)malloc(buflen); - /* build the formatted string */ - /* FIXME: implement proper buffer size checking */ - /* TODO: OpenSolaris expects " " */ - /* This output is handled correctly by NSCD,but not */ - /* when NSCD is off. Not an issue with NSS_LDAP,but */ - /* with the frontend. */ - sprintf(buffer,"%s %s",ether_ntoa(&result.e_addr),result.e_name); - /* copy the result back to the result buffer and free the temporary one */ - strcpy(NSS_ARGS(args)->buf.buffer,buffer); + } + /* make a string representation */ + res=snprintf(args->buf.buffer,args->buf.buflen, + "%s %s",ether_ntoa(&result.e_addr),result.e_name); free(buffer); + if ((res<0)||(res>=args->buf.buflen)) + return NSS_STATUS_TRYAGAIN; NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); return NSS_STATUS_SUCCESS; diff --git a/nss/group.c b/nss/group.c index b460445..c20ac04 100644 --- a/nss/group.c +++ b/nss/group.c @@ -192,26 +192,31 @@ static nss_status_t read_groupstring(TFILE *fp,nss_XbyY_args_t *args) char *buffer; size_t buflen; int i; - /* read the groupent */ - retv=read_group(fp,&result,NSS_ARGS(args)->buf.buffer,args->buf.buflen,&errno); + /* read the group into a temporary buffer */ + buffer=(char *)malloc(args->buf.buflen); + if (buffer==NULL) + return NSS_STATUS_UNAVAIL; + retv=read_group(fp,&result,buffer,args->buf.buflen,&errno); if (retv!=NSS_STATUS_SUCCESS) + { + free(buffer); return retv; - /* allocate a temporary buffer */ - buflen=args->buf.buflen; - buffer=(char *)malloc(buflen); - /* build the formatted string */ - /* FIXME: implement proper buffer size checking */ - sprintf(buffer,"%s:%s:%d:",result.gr_name,result.gr_passwd,(int)result.gr_gid); + } + /* make a string representation */ + snprintf(args->buf.buffer,args->buf.buflen, + "%s:%s:%d:",result.gr_name,result.gr_passwd,(int)result.gr_gid); + args->buf.buffer[args->buf.buflen-1]='\0'; if (result.gr_mem) for (i=0;result.gr_mem[i];i++) { if (i) - strcat(buffer,","); - strcat(buffer,result.gr_mem[i]); + strncat(args->buf.buffer,args->buf.buflen-strlen(args->buf.buffer)-1,","); + strncat(args->buf.buffer,args->buf.buflen-strlen(args->buf.buffer)-1,result.gr_mem[i]); } - /* copy the result back to the result buffer and free the temporary one */ - strcpy(NSS_ARGS(args)->buf.buffer,buffer); free(buffer); + /* check if buffer overflowed */ + if (strlen(args->buf.buffer)>=args->buf.buffer-1) + return NSS_STATUS_TRYAGAIN; NSS_ARGS(args)->returnval=NSS_ARGS(args)->buf.buffer; NSS_ARGS(args)->returnlen=strlen(NSS_ARGS(args)->buf.buffer); return NSS_STATUS_SUCCESS; -- cgit v1.2.3 From 16a03cf6b5f54a4d65c68f21576337b7a8e0102e Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 30 Dec 2010 12:44:39 +0000 Subject: split netgroup backend into a "normal" backend and one for setnetgrent git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1352 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/netgroup.c | 177 +++++++++++++++++++++++++++------------------------------ 1 file changed, 84 insertions(+), 93 deletions(-) diff --git a/nss/netgroup.c b/nss/netgroup.c index d2a8dd4..51baa7d 100644 --- a/nss/netgroup.c +++ b/nss/netgroup.c @@ -132,86 +132,79 @@ nss_status_t _nss_ldap_endnetgrent(struct __netgrent UNUSED(*result)) #ifdef NSS_FLAVOUR_SOLARIS -/* - *thread specific context: result chain,and state data - */ -struct ent_context +/* this is the backend structure for the {set,get,end}ent() functions */ +struct setnetgrent_backend { - void *first_entry; - void *curr_entry; + nss_backend_op_t *ops; /* function-pointer table */ + int n_ops; /* number of function pointers */ + TFILE *fp; /* the file pointer for {set,get,end}ent() functions */ + SET *seen_groups; /* netgroups seen, for loop detection */ + SET *unseen_groups; /* netgroups that need to be chased */ }; -typedef struct ent_context ent_context_t; -struct nss_ldap_netgr_backend -{ - nss_backend_op_t *ops; - int n_ops; - ent_context_t *state; - SET *known_groups; /* netgroups seen, for loop detection */ - SET *needed_groups; /* nested netgroups to chase */ -}; -typedef struct nss_ldap_netgr_backend nss_ldap_netgr_backend_t; +/* easy way to get sets from back-end */ +#define NETGROUP_BE(be) ((struct setnetgrent_backend*)(be)) -static nss_status_t netgroup_setnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) -{ - return NSS_STATUS_SUCCESS; -} +/* access arguments */ +#define SETNETGRENT_ARGS(args) ((struct nss_setnetgrent_args *)(args)) +#define GETNETGRENT_ARGS(args) ((struct nss_getnetgrent_args *)(args)) -/* find a netgroup that has not been traversed */ -static char *find_unseen_netgroup(nss_ldap_netgr_backend_t *ngbe) +/* return a netgroup that has not been traversed */ +static char *find_unseen_netgroup(nss_backend_t *be) { char *group; while (1) { - group=set_pop(ngbe->needed_groups); + group=set_pop(NETGROUP_BE(be)->unseen_groups); if (group==NULL) return NULL; - if (set_contains(ngbe->known_groups,group)) + if (!set_contains(NETGROUP_BE(be)->seen_groups,group)) { - set_add(ngbe->known_groups,group); + set_add(NETGROUP_BE(be)->seen_groups,group); return group; } } } -/* thread-local file pointer to an ongoing request */ -static __thread TFILE *netgrentfp; - -static nss_status_t _nss_nslcd_setnetgrent(const char *group,struct __netgrent UNUSED(*result)) +static nss_status_t netgroup_nslcd_setnetgrent(nss_backend_t *be,const char *group) { /* we cannot use NSS_SETENT() here because we have a parameter that is only available in this function */ int32_t tmpint32; int errnocp; int *errnop; - NSS_AVAILCHECK; errnop=&errnocp; /* check parameter */ if ((group==NULL)||(group[0]=='\0')) return NSS_STATUS_UNAVAIL; /* open a new stream and write the request */ - NSLCD_REQUEST(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME,WRITE_STRING(netgrentfp,group)); + NSLCD_REQUEST(NETGROUP_BE(be)->fp,NSLCD_ACTION_NETGROUP_BYNAME, + WRITE_STRING(NETGROUP_BE(be)->fp,group)); return NSS_STATUS_SUCCESS; } -static nss_status_t _nss_nslcd_getnetgrent_r(struct __netgrent *result,char *buffer,size_t buflen,void *args) +static nss_status_t netgroup_nslcd_getnetgrent(nss_backend_t *be,struct __netgrent *result,char *buffer,size_t buflen,void *args) { - NSS_GETENT(netgrentfp,NSLCD_ACTION_NETGROUP_BYNAME, - read_netgrent(netgrentfp,result,buffer,buflen,errnop)); + NSS_GETENT(NETGROUP_BE(be)->fp,NSLCD_ACTION_NETGROUP_BYNAME, + read_netgrent(NETGROUP_BE(be)->fp,result,buffer,buflen,errnop)); +} + +static nss_status_t netgroup_setnetgrent_setnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +{ + return NSS_STATUS_SUCCESS; } -static nss_status_t netgroup_getnetgrent(nss_backend_t *_be,void *_args) +static nss_status_t netgroup_setnetgrent_getnetgrent(nss_backend_t *be,void *args) { - nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)_be; - struct nss_getnetgrent_args *args=(struct nss_getnetgrent_args *)_args; struct __netgrent result; char *group=NULL; int done=0; nss_status_t status,rc; - args->status=NSS_NETGR_NO; + GETNETGRENT_ARGS(args)->status=NSS_NETGR_NO; while (!done) { - status=_nss_nslcd_getnetgrent_r(&result,args->buffer,args->buflen,args); + status=netgroup_nslcd_getnetgrent(be,&result,GETNETGRENT_ARGS(args)->buffer, + GETNETGRENT_ARGS(args)->buflen,args); if (status!=NSS_STATUS_SUCCESS) { if (errno==ENOENT) @@ -222,16 +215,16 @@ static nss_status_t netgroup_getnetgrent(nss_backend_t *_be,void *_args) while (!found) { /* find a nested netgroup to pursue further */ - group=find_unseen_netgroup(ngbe); - if (!group) + group=find_unseen_netgroup(be); + if (group==NULL) { /* no more netgroup */ - found=1; done = 1; + found=1; done=1; errno=ENOENT; } else { - rc=_nss_nslcd_setnetgrent(group,&result); + rc=netgroup_nslcd_setnetgrent(be,group); if (rc==NSS_STATUS_SUCCESS) found=1; free(group); @@ -249,14 +242,14 @@ static nss_status_t netgroup_getnetgrent(nss_backend_t *_be,void *_args) if (result.type==group_val) { /* a netgroup nested within the current netgroup */ - set_add(ngbe->needed_groups,result.val.group); + set_add(NETGROUP_BE(be)->unseen_groups,result.val.group); } else if (result.type==triple_val) { - args->retp[NSS_NETGR_MACHINE]=result.val.triple.host; - args->retp[NSS_NETGR_USER]=result.val.triple.user; - args->retp[NSS_NETGR_DOMAIN]=result.val.triple.domain; - args->status=NSS_NETGR_FOUND; + GETNETGRENT_ARGS(args)->retp[NSS_NETGR_MACHINE]=result.val.triple.host; + GETNETGRENT_ARGS(args)->retp[NSS_NETGR_USER]=result.val.triple.user; + GETNETGRENT_ARGS(args)->retp[NSS_NETGR_DOMAIN]=result.val.triple.domain; + GETNETGRENT_ARGS(args)->status=NSS_NETGR_FOUND; done=1; } else @@ -271,71 +264,69 @@ static nss_status_t netgroup_getnetgrent(nss_backend_t *_be,void *_args) return status; } -static nss_status_t netgroup_endnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) +static nss_status_t netgroup_setnetgrent_endnetgrent(nss_backend_t UNUSED(*be),void UNUSED(*args)) { - NSS_ENDENT(netgrentfp); + NSS_ENDENT(NETGROUP_BE(be)->fp); } -static nss_status_t netgroup_destructor(nss_backend_t *be,void UNUSED(*args)) +static nss_status_t netgroup_setnetgrent_destructor(nss_backend_t *be,void *UNUSED(args)) { - nss_ldap_netgr_backend_t *ngbe=(nss_ldap_netgr_backend_t *)be; - /* free list of nested netgroups */ - set_free(ngbe->known_groups); - set_free(ngbe->needed_groups); + struct setnetgrent_backend *ngbe=(struct setnetgrent_backend *)be; + if (ngbe->fp!=NULL) + (void)tio_close(ngbe->fp); + set_free(ngbe->seen_groups); + set_free(ngbe->unseen_groups); free(ngbe); return NSS_STATUS_SUCCESS; } -static nss_status_t netgroup_set(nss_backend_t *be,void *_args); - -static nss_backend_op_t netgroup_ops[]={ - netgroup_destructor, - netgroup_endnetgrent, - netgroup_setnetgrent, - netgroup_getnetgrent, - NULL,/* TODO:_nss_ldap_netgr_in,*/ - netgroup_set +static nss_backend_op_t netgroup_setnetgrent_ops[]={ + netgroup_setnetgrent_destructor, + netgroup_setnetgrent_endnetgrent, + netgroup_setnetgrent_setnetgrent, + netgroup_setnetgrent_getnetgrent, }; -static nss_status_t netgroup_set(nss_backend_t *be,void *_args) +static nss_status_t netgroup_setnetgrent_constructor(nss_backend_t *be,void *args) { - nss_status_t stat; - struct nss_setnetgrent_args *args; - nss_ldap_netgr_backend_t *ngbe; - struct __netgrent result; - args=(struct nss_setnetgrent_args *)_args; - args->iterator=NULL; /* initialize */ - ngbe=(nss_ldap_netgr_backend_t *)malloc(sizeof(*ngbe)); + struct setnetgrent_backend *ngbe; + nss_status_t retv; + NSS_AVAILCHECK; + SETNETGRENT_ARGS(args)->iterator=NULL; /* initialize */ + /* allocate a back-end specific to this request */ + ngbe=(struct setnetgrent_backend *)malloc(sizeof(struct setnetgrent_backend)); if (ngbe==NULL) return NSS_STATUS_UNAVAIL; - ngbe->ops=netgroup_ops; - ngbe->n_ops=6; - ngbe->state=NULL; - ngbe->known_groups=NULL; - ngbe->needed_groups=NULL; - stat=_nss_nslcd_setnetgrent(args->netgroup,&result); - if (stat!=NSS_STATUS_SUCCESS) + ngbe->ops=netgroup_setnetgrent_ops; + ngbe->n_ops=sizeof(netgroup_setnetgrent_ops)/sizeof(nss_backend_op_t); + ngbe->fp=NULL; + ngbe->seen_groups=set_new(); + ngbe->unseen_groups=set_new(); + /* start the first search */ + retv=netgroup_nslcd_setnetgrent(be,SETNETGRENT_ARGS(args)->netgroup); + if (retv!=NSS_STATUS_SUCCESS) { - free(be); - return stat; + netgroup_setnetgrent_destructor(be,args); + return retv; } - /* place the group name in known list */ - set_add(ngbe->known_groups,args->netgroup); - args->iterator=(nss_backend_t *)ngbe; - return stat; + /* return the new back-end */ + SETNETGRENT_ARGS(args)->iterator=(nss_backend_t *)ngbe; + return NSS_STATUS_SUCCESS; } +static nss_backend_op_t netgroup_ops[]={ + nss_ldap_destructor, + NULL, + NULL, + NULL, + NULL,/* TODO:_nss_ldap_netgr_in,*/ + netgroup_setnetgrent_constructor +}; + nss_backend_t *_nss_ldap_netgroup_constr(const char UNUSED(*db_name), const char UNUSED(*src_name),const char UNUSED(*cfg_args)) { - nss_ldap_netgr_backend_t *be; - if (!(be=(nss_ldap_netgr_backend_t *)malloc(sizeof(*be)))) - return NULL; - be->ops=netgroup_ops; - be->n_ops=sizeof(netgroup_ops)/sizeof(nss_backend_op_t); - be->known_groups=set_new(); - be->needed_groups=set_new(); - return (nss_backend_t *)be; + return nss_ldap_constructor(netgroup_ops,sizeof(netgroup_ops)); } #endif /* NSS_FLAVOUR_SOLARIS */ -- cgit v1.2.3 From 7268fd2233a93f83b4acb2247fad2cc1645e5d36 Mon Sep 17 00:00:00 2001 From: Arthur de Jong Date: Thu, 30 Dec 2010 12:58:29 +0000 Subject: correctly set nss_ldap_so_DEPENDENCIES git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd-solaris@1353 ef36b2f9-881f-0410-afb5-c4e39611909c --- nss/Makefile.am | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nss/Makefile.am b/nss/Makefile.am index 0fddbe7..285592f 100644 --- a/nss/Makefile.am +++ b/nss/Makefile.am @@ -31,12 +31,12 @@ nss_ldap_so_SOURCES = common.c common.h prototypes.h \ EXTRA_nss_ldap_so_SOURCES = aliases.c ethers.c group.c hosts.c netgroup.c \ networks.c passwd.c protocols.c rpc.c services.c \ shadow.c -nss_ldap_so_DEPENDENCIES = $(NSS_MODULE_OBJS) solnss.$(OBJEXT) nss_ldap_so_LDADD = $(NSS_MODULE_OBJS) if NSS_FLAVOUR_SOLARIS nss_ldap_so_LDADD += solnss.$(OBJEXT) ../common/libdict.a endif nss_ldap_so_LDADD += ../common/libtio.a ../common/libprot.a +nss_ldap_so_DEPENDENCIES = $(nss_ldap_so_LDADD) EXTRA_DIST = exports.glibc exports.solaris -- cgit v1.2.3