root/source4/lib/ldb/nssldb/ldb-pwd.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. _nss_ldb_setpwent
  2. _nss_ldb_endpwent
  3. _nss_ldb_getpwent_r
  4. _nss_ldb_getpwuid_r
  5. _nss_ldb_getpwnam_r

   1 /* 
   2    LDB nsswitch module
   3 
   4    Copyright (C) Simo Sorce 2006
   5    
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 3 of the License, or (at your option) any later version.
  10    
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Library General Public License for more details.
  15    
  16    You should have received a copy of the GNU Lesser General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 
  20 #include "ldb-nss.h"
  21 
  22 extern struct _ldb_nss_context *_ldb_nss_ctx;
  23 
  24 const char *_ldb_nss_pw_attrs[] = {
  25         "uid",
  26         "userPassword",
  27         "uidNumber",
  28         "gidNumber",
  29         "gecos",
  30         "homeDirectory",
  31         "loginShell",
  32         NULL
  33 };
  34 
  35 NSS_STATUS _nss_ldb_setpwent(void)
     /* [<][>][^][v][top][bottom][index][help] */
  36 {
  37         int ret;
  38         ret = _ldb_nss_init();
  39         if (ret != NSS_STATUS_SUCCESS) {
  40                 return ret;
  41         }
  42 
  43         _ldb_nss_ctx->pw_cur = 0;
  44         if (_ldb_nss_ctx->pw_res != NULL) {
  45                 talloc_free(_ldb_nss_ctx->pw_res);
  46                 _ldb_nss_ctx->pw_res = NULL;
  47         }
  48 
  49         ret = ldb_search(_ldb_nss_ctx->ldb,
  50                          _ldb_nss_ctx->ldb,
  51                          &_ldb_nss_ctx->pw_res,
  52                          _ldb_nss_ctx->base,
  53                          LDB_SCOPE_SUBTREE,
  54                          _ldb_nss_pw_attrs,
  55                          _LDB_NSS_PWENT_FILTER);
  56         if (ret != LDB_SUCCESS) {
  57                 return NSS_STATUS_UNAVAIL;
  58         }
  59 
  60         return NSS_STATUS_SUCCESS;
  61 }
  62 
  63 NSS_STATUS _nss_ldb_endpwent(void)
     /* [<][>][^][v][top][bottom][index][help] */
  64 {
  65         int ret;
  66 
  67         ret = _ldb_nss_init();
  68         if (ret != NSS_STATUS_SUCCESS) {
  69                 return ret;
  70         }
  71 
  72         _ldb_nss_ctx->pw_cur = 0;
  73         if (_ldb_nss_ctx->pw_res) {
  74                 talloc_free(_ldb_nss_ctx->pw_res);
  75                 _ldb_nss_ctx->pw_res = NULL;
  76         }
  77 
  78         return NSS_STATUS_SUCCESS;
  79 }
  80 
  81 NSS_STATUS _nss_ldb_getpwent_r(struct passwd *result_buf,
     /* [<][>][^][v][top][bottom][index][help] */
  82                                 char *buffer,
  83                                 int buflen,
  84                                 int *errnop)
  85 {
  86         int ret;
  87 
  88         ret = _ldb_nss_init();
  89         if (ret != NSS_STATUS_SUCCESS) {
  90                 return ret;
  91         }
  92 
  93         *errnop = 0;
  94 
  95         if (_ldb_nss_ctx->pw_cur >= _ldb_nss_ctx->pw_res->count) {
  96                 /* already returned all entries */
  97                 return NSS_STATUS_NOTFOUND;
  98         }
  99 
 100         ret = _ldb_nss_fill_passwd(result_buf,
 101                                    buffer,
 102                                    buflen,
 103                                    errnop,
 104                                    _ldb_nss_ctx->pw_res->msgs[_ldb_nss_ctx->pw_cur]);
 105         if (ret != NSS_STATUS_SUCCESS) {
 106                 return ret;
 107         }
 108 
 109         _ldb_nss_ctx->pw_cur++;
 110 
 111         return NSS_STATUS_SUCCESS;
 112 }
 113 
 114 NSS_STATUS _nss_ldb_getpwuid_r(uid_t uid, struct passwd *result_buf, char *buffer, size_t buflen, int *errnop)
     /* [<][>][^][v][top][bottom][index][help] */
 115 {
 116         int ret;
 117         char *filter;
 118         struct ldb_result *res;
 119 
 120         if (uid == 0) { /* we don't serve root uid by policy */
 121                 *errnop = errno = ENOENT;
 122                 return NSS_STATUS_NOTFOUND;
 123         }
 124 
 125         ret = _ldb_nss_init();
 126         if (ret != NSS_STATUS_SUCCESS) {
 127                 return ret;
 128         }
 129 
 130         /* build the filter for this uid */
 131         filter = talloc_asprintf(_ldb_nss_ctx, _LDB_NSS_PWUID_FILTER, uid);
 132         if (filter == NULL) {
 133                 /* this is a fatal error */
 134                 *errnop = errno = ENOMEM;
 135                 ret = NSS_STATUS_UNAVAIL;
 136                 goto done;
 137         }
 138 
 139         /* search the entry */
 140         ret = ldb_search(_ldb_nss_ctx->ldb,
 141                          _ldb_nss_ctx->ldb,
 142                          &res,
 143                          _ldb_nss_ctx->base,
 144                          LDB_SCOPE_SUBTREE,
 145                          _ldb_nss_pw_attrs,
 146                          filter);
 147         if (ret != LDB_SUCCESS) {
 148                 /* this is a fatal error */
 149                 *errnop = errno = ENOENT;
 150                 ret = NSS_STATUS_UNAVAIL;
 151                 goto done;
 152         }
 153 
 154         /* if none found return */
 155         if (res->count == 0) {
 156                 *errnop = errno = ENOENT;
 157                 ret = NSS_STATUS_NOTFOUND;
 158                 goto done;
 159         }
 160 
 161         if (res->count != 1) {
 162                 /* this is a fatal error */
 163                 *errnop = errno = ENOENT;
 164                 ret = NSS_STATUS_UNAVAIL;
 165                 goto done;
 166         }
 167 
 168         /* fill in the passwd struct */
 169         ret = _ldb_nss_fill_passwd(result_buf,
 170                                    buffer,
 171                                    buflen,
 172                                    errnop,
 173                                    res->msgs[0]);
 174 
 175 done:
 176         talloc_free(filter);
 177         talloc_free(res);
 178         return ret;
 179 }
 180 
 181 NSS_STATUS _nss_ldb_getpwnam_r(const char *name, struct passwd *result_buf, char *buffer, size_t buflen, int *errnop)
     /* [<][>][^][v][top][bottom][index][help] */
 182 {
 183         int ret;
 184         char *filter;
 185         struct ldb_result *res;
 186 
 187         ret = _ldb_nss_init();
 188         if (ret != NSS_STATUS_SUCCESS) {
 189                 return ret;
 190         }
 191 
 192         /* build the filter for this name */
 193         filter = talloc_asprintf(_ldb_nss_ctx, _LDB_NSS_PWNAM_FILTER, name);
 194         if (filter == NULL) {
 195                 /* this is a fatal error */
 196                 *errnop = errno = ENOENT;
 197                 ret = NSS_STATUS_UNAVAIL;
 198                 goto done;
 199         }
 200 
 201         /* search the entry */
 202         ret = ldb_search(_ldb_nss_ctx->ldb,
 203                          _ldb_nss_ctx->ldb,
 204                          &res,
 205                          _ldb_nss_ctx->base,
 206                          LDB_SCOPE_SUBTREE,
 207                          _ldb_nss_pw_attrs,
 208                          filter);
 209         if (ret != LDB_SUCCESS) {
 210                 /* this is a fatal error */
 211                 *errnop = errno = ENOENT;
 212                 ret = NSS_STATUS_UNAVAIL;
 213                 goto done;
 214         }
 215 
 216         /* if none found return */
 217         if (res->count == 0) {
 218                 *errnop = errno = ENOENT;
 219                 ret = NSS_STATUS_NOTFOUND;
 220                 goto done;
 221         }
 222 
 223         if (res->count != 1) {
 224                 /* this is a fatal error */
 225                 *errnop = errno = ENOENT;
 226                 ret = NSS_STATUS_UNAVAIL;
 227                 goto done;
 228         }
 229 
 230         /* fill in the passwd struct */
 231         ret = _ldb_nss_fill_passwd(result_buf,
 232                                    buffer,
 233                                    buflen,
 234                                    errnop,
 235                                    res->msgs[0]);
 236 
 237 done:
 238         talloc_free(filter);
 239         talloc_free(res);
 240         return ret;
 241 }
 242 

/* [<][>][^][v][top][bottom][index][help] */