source3/lib/ldb/nssldb/ldb-pwd.c

   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)
  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->base,
  51                          LDB_SCOPE_SUBTREE,
  52                          _LDB_NSS_PWENT_FILTER,
  53                          _ldb_nss_pw_attrs,
  54                          &_ldb_nss_ctx->pw_res);
  55         if (ret != LDB_SUCCESS) {
  56                 return NSS_STATUS_UNAVAIL;
  57         }
  58
  59         return NSS_STATUS_SUCCESS;
  60 }
  61
  62 NSS_STATUS _nss_ldb_endpwent(void)
  63 {
  64         int ret;
  65
  66         ret = _ldb_nss_init();
  67         if (ret != NSS_STATUS_SUCCESS) {
  68                 return ret;
  69         }
  70
  71         _ldb_nss_ctx->pw_cur = 0;
  72         if (_ldb_nss_ctx->pw_res) {
  73                 talloc_free(_ldb_nss_ctx->pw_res);
  74                 _ldb_nss_ctx->pw_res = NULL;
  75         }
  76
  77         return NSS_STATUS_SUCCESS;
  78 }
  79
  80 NSS_STATUS _nss_ldb_getpwent_r(struct passwd *result_buf,
  81                                 char *buffer,
  82                                 int buflen,
  83                                 int *errnop)
  84 {
  85         int ret;
  86
  87         ret = _ldb_nss_init();
  88         if (ret != NSS_STATUS_SUCCESS) {
  89                 return ret;
  90         }
  91
  92         *errnop = 0;
  93
  94         if (_ldb_nss_ctx->pw_cur >= _ldb_nss_ctx->pw_res->count) {
  95                 /* already returned all entries */
  96                 return NSS_STATUS_NOTFOUND;
  97         }
  98
  99         ret = _ldb_nss_fill_passwd(result_buf,
 100                                    buffer,
 101                                    buflen,
 102                                    errnop,
 103                                    _ldb_nss_ctx->pw_res->msgs[_ldb_nss_ctx->pw_cur]);
 104         if (ret != NSS_STATUS_SUCCESS) {
 105                 return ret;
 106         }
 107
 108         _ldb_nss_ctx->pw_cur++;
 109
 110         return NSS_STATUS_SUCCESS;
 111 }
 112
 113 NSS_STATUS _nss_ldb_getpwuid_r(uid_t uid, struct passwd *result_buf, char *buffer, size_t buflen, int *errnop)
 114 {
 115         int ret;
 116         char *filter;
 117         struct ldb_result *res;
 118
 119         if (uid == 0) { /* we don't serve root uid by policy */
 120                 *errnop = errno = ENOENT;
 121                 return NSS_STATUS_NOTFOUND;
 122         }
 123
 124         ret = _ldb_nss_init();
 125         if (ret != NSS_STATUS_SUCCESS) {
 126                 return ret;
 127         }
 128
 129         /* build the filter for this uid */
 130         filter = talloc_asprintf(_ldb_nss_ctx, _LDB_NSS_PWUID_FILTER, uid);
 131         if (filter == NULL) {
 132                 /* this is a fatal error */
 133                 *errnop = errno = ENOMEM;
 134                 ret = NSS_STATUS_UNAVAIL;
 135                 goto done;
 136         }
 137
 138         /* search the entry */
 139         ret = ldb_search(_ldb_nss_ctx->ldb,
 140                          _ldb_nss_ctx->base,
 141                          LDB_SCOPE_SUBTREE,
 142                          filter,
 143                          _ldb_nss_pw_attrs,
 144                          &res);
 145         if (ret != LDB_SUCCESS) {
 146                 /* this is a fatal error */
 147                 *errnop = errno = ENOENT;
 148                 ret = NSS_STATUS_UNAVAIL;
 149                 goto done;
 150         }
 151
 152         /* if none found return */
 153         if (res->count == 0) {
 154                 *errnop = errno = ENOENT;
 155                 ret = NSS_STATUS_NOTFOUND;
 156                 goto done;
 157         }
 158
 159         if (res->count != 1) {
 160                 /* this is a fatal error */
 161                 *errnop = errno = ENOENT;
 162                 ret = NSS_STATUS_UNAVAIL;
 163                 goto done;
 164         }
 165
 166         /* fill in the passwd struct */
 167         ret = _ldb_nss_fill_passwd(result_buf,
 168                                    buffer,
 169                                    buflen,
 170                                    errnop,
 171                                    res->msgs[0]);
 172
 173 done:
 174         talloc_free(filter);
 175         talloc_free(res);
 176         return ret;
 177 }
 178
 179 NSS_STATUS _nss_ldb_getpwnam_r(const char *name, struct passwd *result_buf, char *buffer, size_t buflen, int *errnop)
 180 {
 181         int ret;
 182         char *filter;
 183         struct ldb_result *res;
 184
 185         ret = _ldb_nss_init();
 186         if (ret != NSS_STATUS_SUCCESS) {
 187                 return ret;
 188         }
 189
 190         /* build the filter for this name */
 191         filter = talloc_asprintf(_ldb_nss_ctx, _LDB_NSS_PWNAM_FILTER, name);
 192         if (filter == NULL) {
 193                 /* this is a fatal error */
 194                 *errnop = errno = ENOENT;
 195                 ret = NSS_STATUS_UNAVAIL;
 196                 goto done;
 197         }
 198
 199         /* search the entry */
 200         ret = ldb_search(_ldb_nss_ctx->ldb,
 201                          _ldb_nss_ctx->base,
 202                          LDB_SCOPE_SUBTREE,
 203                          filter,
 204                          _ldb_nss_pw_attrs,
 205                          &res);
 206         if (ret != LDB_SUCCESS) {
 207                 /* this is a fatal error */
 208                 *errnop = errno = ENOENT;
 209                 ret = NSS_STATUS_UNAVAIL;
 210                 goto done;
 211         }
 212
 213         /* if none found return */
 214         if (res->count == 0) {
 215                 *errnop = errno = ENOENT;
 216                 ret = NSS_STATUS_NOTFOUND;
 217                 goto done;
 218         }
 219
 220         if (res->count != 1) {
 221                 /* this is a fatal error */
 222                 *errnop = errno = ENOENT;
 223                 ret = NSS_STATUS_UNAVAIL;
 224                 goto done;
 225         }
 226
 227         /* fill in the passwd struct */
 228         ret = _ldb_nss_fill_passwd(result_buf,
 229                                    buffer,
 230                                    buflen,
 231                                    errnop,
 232                                    res->msgs[0]);
 233
 234 done:
 235         talloc_free(filter);
 236         talloc_free(res);
 237         return ret;
 238 }
 239