source/nsswitch/winbind_nss_solaris.c

   1 /*
   2   Solaris NSS wrapper for winbind
   3   - Shirish Kalele 2000
   4
   5   Based on Luke Howard's ldap_nss module for Solaris
   6   */
   7
   8 /*
   9   Copyright (C) 1997-2003 Luke Howard.
  10   This file is part of the nss_ldap library.
  11
  12   The nss_ldap library is free software; you can redistribute it and/or
  13   modify it under the terms of the GNU Library General Public License as
  14   published by the Free Software Foundation; either version 2 of the
  15   License, or (at your option) any later version.
  16
  17   The nss_ldap library is distributed in the hope that it will be useful,
  18   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20   Library General Public License for more details.
  21
  22   You should have received a copy of the GNU Library General Public
  23   License along with the nss_ldap library; see the file COPYING.LIB.  If not,
  24   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25   Boston, MA 02111-1307, USA.
  26 */
  27
  28 #include <stdlib.h>
  29 #include <sys/types.h>
  30 #include <sys/param.h>
  31 #include <string.h>
  32 #include <pwd.h>
  33 #include "includes.h"
  34 #include <syslog.h>
  35 #if !defined(HPUX)
  36 #include <sys/syslog.h>
  37 #endif /*hpux*/
  38 #include "winbind_nss_config.h"
  39
  40 #if defined(HAVE_NSS_COMMON_H) || defined(HPUX)
  41
  42 #undef NSS_DEBUG
  43
  44 #ifdef NSS_DEBUG
  45 #define NSS_DEBUG(str) syslog(LOG_DEBUG, "nss_winbind: %s", str);
  46 #else
  47 #define NSS_DEBUG(str) ;
  48 #endif
  49
  50 #define NSS_ARGS(args) ((nss_XbyY_args_t *)args)
  51
  52 #ifdef HPUX
  53
  54 /*
  55  * HP-UX 11 has no definiton of the nss_groupsbymem structure.   This
  56  * definition is taken from the nss_ldap project at:
  57  *  http://www.padl.com/OSS/nss_ldap.html
  58  */
  59
  60 struct nss_groupsbymem {
  61        const char *username;
  62        gid_t *gid_array;
  63        int maxgids;
  64        int force_slow_way;
  65        int (*str2ent)(const char *instr, int instr_len, void *ent,
  66                       char *buffer, int buflen);
  67        nss_status_t (*process_cstr)(const char *instr, int instr_len,
  68                                     struct nss_groupsbymem *);
  69        int numgids;
  70 };
  71
  72 #endif /* HPUX */
  73
  74 #define make_pwent_str(dest, src)                                       \
  75 {                                                                       \
  76   if((dest = get_static(buffer, buflen, strlen(src)+1)) == NULL)        \
  77     {                                                                   \
  78       *errnop = ERANGE;                                                 \
  79       NSS_DEBUG("ERANGE error");                                        \
  80       return NSS_STATUS_TRYAGAIN;                                       \
  81     }                                                                   \
  82   strcpy(dest, src);                                                    \
  83 }
  84
  85 static NSS_STATUS _nss_winbind_setpwent_solwrap (nss_backend_t* be, void* args)
  86 {
  87         NSS_DEBUG("_nss_winbind_setpwent_solwrap");
  88         return _nss_winbind_setpwent();
  89 }
  90
  91 static NSS_STATUS
  92 _nss_winbind_endpwent_solwrap (nss_backend_t * be, void *args)
  93 {
  94         NSS_DEBUG("_nss_winbind_endpwent_solwrap");
  95         return _nss_winbind_endpwent();
  96 }
  97
  98 static NSS_STATUS
  99 _nss_winbind_getpwent_solwrap (nss_backend_t* be, void *args)
 100 {
 101         NSS_STATUS ret;
 102         char* buffer = NSS_ARGS(args)->buf.buffer;
 103         int buflen = NSS_ARGS(args)->buf.buflen;
 104         struct passwd* result = (struct passwd*) NSS_ARGS(args)->buf.result;
 105         int* errnop = &NSS_ARGS(args)->erange;
 106         char logmsg[80];
 107
 108         ret = _nss_winbind_getpwent_r(result, buffer,
 109                                       buflen, errnop);
 110
 111         if(ret == NSS_STATUS_SUCCESS)
 112                 {
 113                         snprintf(logmsg, 79, "_nss_winbind_getpwent_solwrap: Returning user: %s\n",
 114                                  result->pw_name);
 115                         NSS_DEBUG(logmsg);
 116                         NSS_ARGS(args)->returnval = (void*) result;
 117                 } else {
 118                         snprintf(logmsg, 79, "_nss_winbind_getpwent_solwrap: Returning error: %d.\n",ret);
 119                         NSS_DEBUG(logmsg);
 120                 }
 121
 122         return ret;
 123 }
 124
 125 static NSS_STATUS
 126 _nss_winbind_getpwnam_solwrap (nss_backend_t* be, void* args)
 127 {
 128         NSS_STATUS ret;
 129         struct passwd* result = (struct passwd*) NSS_ARGS(args)->buf.result;
 130
 131         NSS_DEBUG("_nss_winbind_getpwnam_solwrap");
 132
 133         ret = _nss_winbind_getpwnam_r (NSS_ARGS(args)->key.name,
 134                                                 result,
 135                                                 NSS_ARGS(args)->buf.buffer,
 136                                                 NSS_ARGS(args)->buf.buflen,
 137                                                 &NSS_ARGS(args)->erange);
 138         if(ret == NSS_STATUS_SUCCESS)
 139                 NSS_ARGS(args)->returnval = (void*) result;
 140
 141         return ret;
 142 }
 143
 144 static NSS_STATUS
 145 _nss_winbind_getpwuid_solwrap(nss_backend_t* be, void* args)
 146 {
 147         NSS_STATUS ret;
 148         struct passwd* result = (struct passwd*) NSS_ARGS(args)->buf.result;
 149
 150         NSS_DEBUG("_nss_winbind_getpwuid_solwrap");
 151         ret = _nss_winbind_getpwuid_r (NSS_ARGS(args)->key.uid,
 152                                        result,
 153                                        NSS_ARGS(args)->buf.buffer,
 154                                        NSS_ARGS(args)->buf.buflen,
 155                                        &NSS_ARGS(args)->erange);
 156         if(ret == NSS_STATUS_SUCCESS)
 157                 NSS_ARGS(args)->returnval = (void*) result;
 158
 159         return ret;
 160 }
 161
 162 static NSS_STATUS _nss_winbind_passwd_destr (nss_backend_t * be, void *args)
 163 {
 164         SAFE_FREE(be);
 165         NSS_DEBUG("_nss_winbind_passwd_destr");
 166         return NSS_STATUS_SUCCESS;
 167 }
 168
 169 static nss_backend_op_t passwd_ops[] =
 170 {
 171         _nss_winbind_passwd_destr,
 172         _nss_winbind_endpwent_solwrap,          /* NSS_DBOP_ENDENT */
 173         _nss_winbind_setpwent_solwrap,          /* NSS_DBOP_SETENT */
 174         _nss_winbind_getpwent_solwrap,          /* NSS_DBOP_GETENT */
 175         _nss_winbind_getpwnam_solwrap,          /* NSS_DBOP_PASSWD_BYNAME */
 176         _nss_winbind_getpwuid_solwrap           /* NSS_DBOP_PASSWD_BYUID */
 177 };
 178
 179 nss_backend_t*
 180 _nss_winbind_passwd_constr (const char* db_name,
 181                             const char* src_name,
 182                             const char* cfg_args)
 183 {
 184         nss_backend_t *be;
 185
 186         if(!(be = (nss_backend_t*) malloc(sizeof(nss_backend_t))) )
 187                 return NULL;
 188
 189         be->ops = passwd_ops;
 190         be->n_ops = sizeof(passwd_ops) / sizeof(nss_backend_op_t);
 191
 192         NSS_DEBUG("Initialized nss_winbind passwd backend");
 193         return be;
 194 }
 195
 196 /*****************************************************************
 197  GROUP database backend
 198  *****************************************************************/
 199
 200 static NSS_STATUS _nss_winbind_setgrent_solwrap (nss_backend_t* be, void* args)
 201 {
 202         NSS_DEBUG("_nss_winbind_setgrent_solwrap");
 203         return _nss_winbind_setgrent();
 204 }
 205
 206 static NSS_STATUS
 207 _nss_winbind_endgrent_solwrap (nss_backend_t * be, void *args)
 208 {
 209         NSS_DEBUG("_nss_winbind_endgrent_solwrap");
 210         return _nss_winbind_endgrent();
 211 }
 212
 213 static NSS_STATUS
 214 _nss_winbind_getgrent_solwrap(nss_backend_t* be, void* args)
 215 {
 216         NSS_STATUS ret;
 217         char* buffer = NSS_ARGS(args)->buf.buffer;
 218         int buflen = NSS_ARGS(args)->buf.buflen;
 219         struct group* result = (struct group*) NSS_ARGS(args)->buf.result;
 220         int* errnop = &NSS_ARGS(args)->erange;
 221         char logmsg[80];
 222
 223         ret = _nss_winbind_getgrent_r(result, buffer,
 224                                       buflen, errnop);
 225
 226         if(ret == NSS_STATUS_SUCCESS)
 227                 {
 228                         snprintf(logmsg, 79, "_nss_winbind_getgrent_solwrap: Returning group: %s\n", result->gr_name);
 229                         NSS_DEBUG(logmsg);
 230                         NSS_ARGS(args)->returnval = (void*) result;
 231                 } else {
 232                         snprintf(logmsg, 79, "_nss_winbind_getgrent_solwrap: Returning error: %d.\n", ret);
 233                         NSS_DEBUG(logmsg);
 234                 }
 235
 236         return ret;
 237
 238 }
 239
 240 static NSS_STATUS
 241 _nss_winbind_getgrnam_solwrap(nss_backend_t* be, void* args)
 242 {
 243         NSS_STATUS ret;
 244         struct group* result = (struct group*) NSS_ARGS(args)->buf.result;
 245
 246         NSS_DEBUG("_nss_winbind_getgrnam_solwrap");
 247         ret = _nss_winbind_getgrnam_r(NSS_ARGS(args)->key.name,
 248                                       result,
 249                                       NSS_ARGS(args)->buf.buffer,
 250                                       NSS_ARGS(args)->buf.buflen,
 251                                       &NSS_ARGS(args)->erange);
 252
 253         if(ret == NSS_STATUS_SUCCESS)
 254                 NSS_ARGS(args)->returnval = (void*) result;
 255
 256         return ret;
 257 }
 258
 259 static NSS_STATUS
 260 _nss_winbind_getgrgid_solwrap(nss_backend_t* be, void* args)
 261 {
 262         NSS_STATUS ret;
 263         struct group* result = (struct group*) NSS_ARGS(args)->buf.result;
 264
 265         NSS_DEBUG("_nss_winbind_getgrgid_solwrap");
 266         ret = _nss_winbind_getgrgid_r (NSS_ARGS(args)->key.gid,
 267                                        result,
 268                                        NSS_ARGS(args)->buf.buffer,
 269                                        NSS_ARGS(args)->buf.buflen,
 270                                        &NSS_ARGS(args)->erange);
 271
 272         if(ret == NSS_STATUS_SUCCESS)
 273                 NSS_ARGS(args)->returnval = (void*) result;
 274
 275         return ret;
 276 }
 277
 278 static NSS_STATUS
 279 _nss_winbind_getgroupsbymember_solwrap(nss_backend_t* be, void* args)
 280 {
 281         int errnop;
 282         struct nss_groupsbymem *gmem = (struct nss_groupsbymem *)args;
 283
 284         NSS_DEBUG("_nss_winbind_getgroupsbymember");
 285
 286         _nss_winbind_initgroups_dyn(gmem->username,
 287                 gmem->gid_array[0], /* Primary Group */
 288                 &gmem->numgids,
 289                 &gmem->maxgids,
 290                 &gmem->gid_array,
 291                 gmem->maxgids,
 292                 &errnop);
 293
 294         /*
 295          * If the maximum number of gids have been found, return
 296          * SUCCESS so the switch engine will stop searching. Otherwise
 297          * return NOTFOUND so nsswitch will continue to get groups
 298          * from the remaining database backends specified in the
 299          * nsswitch.conf file.
 300          */
 301         return (gmem->numgids == gmem->maxgids ? NSS_STATUS_SUCCESS : NSS_STATUS_NOTFOUND);
 302 }
 303
 304 static NSS_STATUS
 305 _nss_winbind_group_destr (nss_backend_t* be, void* args)
 306 {
 307         SAFE_FREE(be);
 308         NSS_DEBUG("_nss_winbind_group_destr");
 309         return NSS_STATUS_SUCCESS;
 310 }
 311
 312 static nss_backend_op_t group_ops[] =
 313 {
 314         _nss_winbind_group_destr,
 315         _nss_winbind_endgrent_solwrap,
 316         _nss_winbind_setgrent_solwrap,
 317         _nss_winbind_getgrent_solwrap,
 318         _nss_winbind_getgrnam_solwrap,
 319         _nss_winbind_getgrgid_solwrap,
 320         _nss_winbind_getgroupsbymember_solwrap
 321 };
 322
 323 nss_backend_t*
 324 _nss_winbind_group_constr (const char* db_name,
 325                            const char* src_name,
 326                            const char* cfg_args)
 327 {
 328         nss_backend_t* be;
 329
 330         if(!(be = (nss_backend_t*) malloc(sizeof(nss_backend_t))) )
 331                 return NULL;
 332
 333         be->ops = group_ops;
 334         be->n_ops = sizeof(group_ops) / sizeof(nss_backend_op_t);
 335
 336         NSS_DEBUG("Initialized nss_winbind group backend");
 337         return be;
 338 }
 339
 340 #endif /* SUN_NSS */