source4/nsswitch/wb_client.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    winbind client code
   5
   6    Copyright (C) Tim Potter 2000
   7    Copyright (C) Andrew Tridgell 2000
   8
   9    This library is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU Library General Public
  11    License as published by the Free Software Foundation; either
  12    version 2 of the License, or (at your option) any later version.
  13
  14    This library is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    Library General Public License for more details.
  18
  19    You should have received a copy of the GNU Library General Public
  20    License along with this library; if not, write to the
  21    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA  02111-1307, USA.
  23 */
  24
  25 #include "includes.h"
  26 #include "nsswitch/nss.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_WINBIND
  30
  31 extern DOM_SID global_sid_NULL;                         /* NULL sid */
  32
  33 NSS_STATUS winbindd_request(int req_type,
  34                                  struct winbindd_request *request,
  35                                  struct winbindd_response *response);
  36
  37 /* Call winbindd to convert a name to a sid */
  38
  39 BOOL winbind_lookup_name(const char *dom_name, const char *name, DOM_SID *sid,
  40                          enum SID_NAME_USE *name_type)
  41 {
  42         struct winbindd_request request;
  43         struct winbindd_response response;
  44         NSS_STATUS result;
  45
  46         if (!sid || !name_type)
  47                 return False;
  48
  49         /* Send off request */
  50
  51         ZERO_STRUCT(request);
  52         ZERO_STRUCT(response);
  53
  54         fstrcpy(request.data.name.dom_name, dom_name);
  55         fstrcpy(request.data.name.name, name);
  56
  57         if ((result = winbindd_request(WINBINDD_LOOKUPNAME, &request,
  58                                        &response)) == NSS_STATUS_SUCCESS) {
  59                 if (!string_to_sid(sid, response.data.sid.sid))
  60                         return False;
  61                 *name_type = (enum SID_NAME_USE)response.data.sid.type;
  62         }
  63
  64         return result == NSS_STATUS_SUCCESS;
  65 }
  66
  67 /* Call winbindd to convert sid to name */
  68
  69 BOOL winbind_lookup_sid(const DOM_SID *sid,
  70                         fstring dom_name, fstring name,
  71                         enum SID_NAME_USE *name_type)
  72 {
  73         struct winbindd_request request;
  74         struct winbindd_response response;
  75         NSS_STATUS result;
  76         fstring sid_str;
  77
  78         /* Initialise request */
  79
  80         ZERO_STRUCT(request);
  81         ZERO_STRUCT(response);
  82
  83         sid_to_string(sid_str, sid);
  84         fstrcpy(request.data.sid, sid_str);
  85
  86         /* Make request */
  87
  88         result = winbindd_request(WINBINDD_LOOKUPSID, &request, &response);
  89
  90         /* Copy out result */
  91
  92         if (result == NSS_STATUS_SUCCESS) {
  93                 fstrcpy(dom_name, response.data.name.dom_name);
  94                 fstrcpy(name, response.data.name.name);
  95                 *name_type = (enum SID_NAME_USE)response.data.name.type;
  96
  97                 DEBUG(10, ("winbind_lookup_sid: SUCCESS: SID %s -> %s %s\n",
  98                            sid_str, dom_name, name));
  99         }
 100
 101         return (result == NSS_STATUS_SUCCESS);
 102 }
 103
 104 /* Call winbindd to convert SID to uid */
 105
 106 BOOL winbind_sid_to_uid(uid_t *puid, const DOM_SID *sid)
 107 {
 108         struct winbindd_request request;
 109         struct winbindd_response response;
 110         int result;
 111         fstring sid_str;
 112
 113         if (!puid)
 114                 return False;
 115
 116         /* Initialise request */
 117
 118         ZERO_STRUCT(request);
 119         ZERO_STRUCT(response);
 120
 121         sid_to_string(sid_str, sid);
 122         fstrcpy(request.data.sid, sid_str);
 123
 124         /* Make request */
 125
 126         result = winbindd_request(WINBINDD_SID_TO_UID, &request, &response);
 127
 128         /* Copy out result */
 129
 130         if (result == NSS_STATUS_SUCCESS) {
 131                 *puid = response.data.uid;
 132         }
 133
 134         return (result == NSS_STATUS_SUCCESS);
 135 }
 136
 137 /* Call winbindd to convert uid to sid */
 138
 139 BOOL winbind_uid_to_sid(DOM_SID *sid, uid_t uid)
 140 {
 141         struct winbindd_request request;
 142         struct winbindd_response response;
 143         int result;
 144
 145         if (!sid)
 146                 return False;
 147
 148         /* Initialise request */
 149
 150         ZERO_STRUCT(request);
 151         ZERO_STRUCT(response);
 152
 153         request.data.uid = uid;
 154
 155         /* Make request */
 156
 157         result = winbindd_request(WINBINDD_UID_TO_SID, &request, &response);
 158
 159         /* Copy out result */
 160
 161         if (result == NSS_STATUS_SUCCESS) {
 162                 if (!string_to_sid(sid, response.data.sid.sid))
 163                         return False;
 164         } else {
 165                 sid_copy(sid, &global_sid_NULL);
 166         }
 167
 168         return (result == NSS_STATUS_SUCCESS);
 169 }
 170
 171 /* Call winbindd to convert SID to gid */
 172
 173 BOOL winbind_sid_to_gid(gid_t *pgid, const DOM_SID *sid)
 174 {
 175         struct winbindd_request request;
 176         struct winbindd_response response;
 177         int result;
 178         fstring sid_str;
 179
 180         if (!pgid)
 181                 return False;
 182
 183         /* Initialise request */
 184
 185         ZERO_STRUCT(request);
 186         ZERO_STRUCT(response);
 187
 188         sid_to_string(sid_str, sid);
 189         fstrcpy(request.data.sid, sid_str);
 190
 191         /* Make request */
 192
 193         result = winbindd_request(WINBINDD_SID_TO_GID, &request, &response);
 194
 195         /* Copy out result */
 196
 197         if (result == NSS_STATUS_SUCCESS) {
 198                 *pgid = response.data.gid;
 199         }
 200
 201         return (result == NSS_STATUS_SUCCESS);
 202 }
 203
 204 /* Call winbindd to convert gid to sid */
 205
 206 BOOL winbind_gid_to_sid(DOM_SID *sid, gid_t gid)
 207 {
 208         struct winbindd_request request;
 209         struct winbindd_response response;
 210         int result;
 211
 212         if (!sid)
 213                 return False;
 214
 215         /* Initialise request */
 216
 217         ZERO_STRUCT(request);
 218         ZERO_STRUCT(response);
 219
 220         request.data.gid = gid;
 221
 222         /* Make request */
 223
 224         result = winbindd_request(WINBINDD_GID_TO_SID, &request, &response);
 225
 226         /* Copy out result */
 227
 228         if (result == NSS_STATUS_SUCCESS) {
 229                 if (!string_to_sid(sid, response.data.sid.sid))
 230                         return False;
 231         } else {
 232                 sid_copy(sid, &global_sid_NULL);
 233         }
 234
 235         return (result == NSS_STATUS_SUCCESS);
 236 }
 237
 238 /* Fetch the list of groups a user is a member of from winbindd.  This is
 239    used by winbind_getgroups. */
 240
 241 static int wb_getgroups(const char *user, gid_t **groups)
 242 {
 243         struct winbindd_request request;
 244         struct winbindd_response response;
 245         int result;
 246
 247         /* Call winbindd */
 248
 249         fstrcpy(request.data.username, user);
 250
 251         ZERO_STRUCT(response);
 252
 253         result = winbindd_request(WINBINDD_GETGROUPS, &request, &response);
 254
 255         if (result == NSS_STATUS_SUCCESS) {
 256
 257                 /* Return group list.  Don't forget to free the group list
 258                    when finished. */
 259
 260                 *groups = (gid_t *)response.extra_data;
 261                 return response.data.num_entries;
 262         }
 263
 264         return -1;
 265 }
 266
 267 /* Return a list of groups the user is a member of.  This function is
 268    useful for large systems where inverting the group database would be too
 269    time consuming.  If size is zero, list is not modified and the total
 270    number of groups for the user is returned. */
 271
 272 int winbind_getgroups(const char *user, int size, gid_t *list)
 273 {
 274         gid_t *groups = NULL;
 275         int result, i;
 276
 277         /*
 278          * Don't do the lookup if the name has no separator _and_ we are not in
 279          * 'winbind use default domain' mode.
 280          */
 281
 282         if (!(strchr(user, *lp_winbind_separator()) || lp_winbind_use_default_domain()))
 283                 return -1;
 284
 285         /* Fetch list of groups */
 286
 287         result = wb_getgroups(user, &groups);
 288
 289         if (size == 0)
 290                 goto done;
 291
 292         if (result > size) {
 293                 result = -1;
 294                 errno = EINVAL; /* This is what getgroups() does */
 295                 goto done;
 296         }
 297
 298         /* Copy list of groups across */
 299
 300         for (i = 0; i < result; i++) {
 301                 list[i] = groups[i];
 302         }
 303
 304  done:
 305         SAFE_FREE(groups);
 306         return result;
 307 }