source4/libcli/wbclient/wbclient.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind client library.
   5
   6    Copyright (C) 2008 Kai Blin  <kai@samba.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include <tevent.h>
  24 #include "nsswitch/winbind_client.h"
  25 #include "libcli/wbclient/wbclient.h"
  26 #include "libcli/security/dom_sid.h"
  27 #include "nsswitch/libwbclient/wbclient.h"
  28
  29 NTSTATUS wbc_sids_to_xids(struct tevent_context *ev, struct id_map *ids,
  30                           uint32_t count)
  31 {
  32         TALLOC_CTX *mem_ctx;
  33         uint32_t i;
  34         struct wbcDomainSid *sids;
  35         struct wbcUnixId *xids;
  36         wbcErr result;
  37         bool wb_off;
  38
  39         mem_ctx = talloc_new(NULL);
  40         if (mem_ctx == NULL) {
  41                 return NT_STATUS_NO_MEMORY;
  42         }
  43
  44         sids = talloc_array(mem_ctx, struct wbcDomainSid, count);
  45         if (sids == NULL) {
  46                 TALLOC_FREE(mem_ctx);
  47                 return NT_STATUS_NO_MEMORY;
  48         }
  49
  50         xids = talloc_array(mem_ctx, struct wbcUnixId, count);
  51         if (xids == NULL) {
  52                 TALLOC_FREE(mem_ctx);
  53                 return NT_STATUS_NO_MEMORY;
  54         }
  55
  56         for (i=0; i<count; i++) {
  57                 memcpy(&sids[i], ids[i].sid, sizeof(struct dom_sid));
  58         }
  59
  60         wb_off = winbind_env_set();
  61         if (wb_off) {
  62                 (void)winbind_on();
  63         }
  64
  65         result = wbcSidsToUnixIds(sids, count, xids);
  66
  67         if (wb_off) {
  68                 (void)winbind_off();
  69         }
  70
  71         if (!WBC_ERROR_IS_OK(result)) {
  72                 TALLOC_FREE(mem_ctx);
  73                 return NT_STATUS_INTERNAL_ERROR;
  74         }
  75
  76         for (i=0; i<count; i++) {
  77                 struct wbcUnixId *xid = &xids[i];
  78                 struct unixid *id = &ids[i].xid;
  79
  80                 switch (xid->type) {
  81                     case WBC_ID_TYPE_UID:
  82                         id->type = ID_TYPE_UID;
  83                         id->id = xid->id.uid;
  84                         break;
  85                     case WBC_ID_TYPE_GID:
  86                         id->type = ID_TYPE_GID;
  87                         id->id = xid->id.gid;
  88                         break;
  89                     case WBC_ID_TYPE_BOTH:
  90                         id->type = ID_TYPE_BOTH;
  91                         id->id = xid->id.uid;
  92                         break;
  93                     case WBC_ID_TYPE_NOT_SPECIFIED:
  94                         id->type = ID_TYPE_NOT_SPECIFIED;
  95                         id->id = UINT32_MAX;
  96                         break;
  97                 }
  98                 ids[i].status = ID_MAPPED;
  99         }
 100
 101         TALLOC_FREE(mem_ctx);
 102
 103         return NT_STATUS_OK;
 104 }
 105
 106 NTSTATUS wbc_xids_to_sids(struct tevent_context *ev, struct id_map *ids,
 107                           uint32_t count)
 108 {
 109         TALLOC_CTX *mem_ctx;
 110         uint32_t i;
 111         struct wbcDomainSid *sids;
 112         struct wbcUnixId *xids;
 113         wbcErr result;
 114         bool wb_off;
 115
 116         mem_ctx = talloc_new(NULL);
 117         if (mem_ctx == NULL) {
 118                 return NT_STATUS_NO_MEMORY;
 119         }
 120
 121         sids = talloc_array(mem_ctx, struct wbcDomainSid, count);
 122         if (sids == NULL) {
 123                 TALLOC_FREE(mem_ctx);
 124                 return NT_STATUS_NO_MEMORY;
 125         }
 126
 127         xids = talloc_array(mem_ctx, struct wbcUnixId, count);
 128         if (xids == NULL) {
 129                 TALLOC_FREE(mem_ctx);
 130                 return NT_STATUS_NO_MEMORY;
 131         }
 132
 133         for (i=0; i<count; i++) {
 134                 struct id_map *id = &ids[i];
 135                 struct wbcUnixId *xid = &xids[i];
 136
 137                 switch (id->xid.type) {
 138                     case ID_TYPE_UID:
 139                             *xid = (struct wbcUnixId) {
 140                                     .type = WBC_ID_TYPE_UID,
 141                                     .id.uid = id->xid.id
 142                             };
 143                             break;
 144                     case ID_TYPE_GID:
 145                             *xid = (struct wbcUnixId) {
 146                                     .type = WBC_ID_TYPE_GID,
 147                                     .id.uid = id->xid.id
 148                             };
 149                             break;
 150                     default:
 151                             TALLOC_FREE(mem_ctx);
 152                             return NT_STATUS_NOT_FOUND;
 153                 }
 154         }
 155
 156         wb_off = winbind_env_set();
 157         if (wb_off) {
 158                 (void)winbind_on();
 159         }
 160
 161         result = wbcUnixIdsToSids(xids, count, sids);
 162
 163         if (wb_off) {
 164                 (void)winbind_off();
 165         }
 166
 167         if (!WBC_ERROR_IS_OK(result)) {
 168                 TALLOC_FREE(mem_ctx);
 169                 return NT_STATUS_INTERNAL_ERROR;
 170         }
 171
 172         for (i=0; i<count; i++) {
 173                 struct wbcDomainSid *sid = &sids[i];
 174                 struct wbcDomainSid null_sid = { 0 };
 175                 struct id_map *id = &ids[i];
 176
 177                 if (memcmp(sid, &null_sid, sizeof(*sid)) != 0) {
 178                         struct dom_sid domsid;
 179                         id->status = ID_MAPPED;
 180
 181                         memcpy(&domsid, sid, sizeof(struct dom_sid));
 182                         id->sid = dom_sid_dup(ids, &domsid);
 183                         if (id->sid == NULL) {
 184                                 TALLOC_FREE(mem_ctx);
 185                                 return NT_STATUS_NO_MEMORY;
 186                         }
 187                 } else {
 188                         id->status = ID_UNMAPPED;
 189                         id->sid = NULL;
 190                 }
 191         }
 192
 193         TALLOC_FREE(mem_ctx);
 194         return NT_STATUS_OK;
 195 }