nsswitch/libwbclient/wbc_sid_async.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind client API
   5
   6    Copyright (C) 2009,2010 Kai Blin  <kai@samba.org>
   7
   8    This library is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU Lesser General Public
  10    License as published by the Free Software Foundation; either
  11    version 3 of the License, or (at your option) any later version.
  12
  13    This library 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 GNU
  16    Library General Public License for more details.
  17
  18    You should have received a copy of the GNU Lesser General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /* Required Headers */
  23
  24 #include "replace.h"
  25 #include "libwbclient.h"
  26 #include "../winbind_client.h"
  27
  28 struct wbc_lookup_name_state {
  29         struct winbindd_request req;
  30         struct wb_context *wb_ctx;
  31         struct wbcDomainSid *sid;
  32         enum wbcSidType name_type;
  33 };
  34
  35 static void wbcLookupName_done(struct tevent_req *subreq);
  36
  37 /**
  38  * @brief Request a conversion of a domaind and name to a domain sid
  39  *
  40  * @param mem_ctx       talloc context to allocate the request from
  41  * @param ev            tevent context to use for async operation
  42  * @param wb_ctx        winbind context to use
  43  * @param *domain       Pointer to the domain to be resolved
  44  * @param *name         Pointer to the name to be resolved
  45  *
  46  * @return tevent_req on success, NULL on error
  47  **/
  48
  49 struct tevent_req *wbcLookupName_send(TALLOC_CTX *mem_ctx,
  50                                       struct tevent_context *ev,
  51                                       struct wb_context *wb_ctx,
  52                                       const char *domain,
  53                                       const char *name)
  54 {
  55         struct tevent_req *req, *subreq;
  56         struct wbc_lookup_name_state *state;
  57
  58         req = tevent_req_create(mem_ctx, &state, struct wbc_lookup_name_state);
  59         if (req == NULL) {
  60                 return NULL;
  61         }
  62
  63         ZERO_STRUCT(state->req);
  64
  65         state->req.cmd = WINBINDD_LOOKUPNAME;
  66         strncpy(state->req.data.name.dom_name, domain,
  67                 sizeof(state->req.data.name.dom_name)-1);
  68         strncpy(state->req.data.name.name, name,
  69                 sizeof(state->req.data.name.name)-1);
  70         state->wb_ctx = wb_ctx;
  71
  72
  73         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
  74         if (tevent_req_nomem(subreq, req)) {
  75                 return tevent_req_post(req, ev);
  76         }
  77
  78         tevent_req_set_callback(subreq, wbcLookupName_done, req);
  79         return req;
  80 }
  81
  82 static void wbcLookupName_done(struct tevent_req *subreq)
  83 {
  84         struct tevent_req *req = tevent_req_callback_data(
  85                         subreq, struct tevent_req);
  86         struct wbc_lookup_name_state *state = tevent_req_data(
  87                         req, struct wbc_lookup_name_state);
  88         struct winbindd_response *resp;
  89         wbcErr wbc_status;
  90
  91         wbc_status = wb_trans_recv(subreq, state, &resp);
  92         TALLOC_FREE(subreq);
  93         if (!WBC_ERROR_IS_OK(wbc_status)) {
  94                 tevent_req_error(req, wbc_status);
  95                 return;
  96         }
  97
  98         state->sid = talloc(state, struct wbcDomainSid);
  99         if (tevent_req_nomem(state->sid, req)) {
 100                 return;
 101         }
 102
 103         wbc_status = wbcStringToSid(resp->data.sid.sid, state->sid);
 104         if (!WBC_ERROR_IS_OK(wbc_status)) {
 105                 wbcDebug(state->wb_ctx, WBC_DEBUG_ERROR,
 106                          "wbcStringToSid returned %s!\n",
 107                          wbcErrorString(wbc_status));
 108                 tevent_req_error(req, wbc_status);
 109                 return;
 110         }
 111
 112         state->name_type = (enum wbcSidType)resp->data.sid.type;
 113
 114         TALLOC_FREE(resp);
 115
 116         tevent_req_done(req);
 117 }
 118
 119 /**
 120  * @brief Receive a conversion a SID to a domain and name
 121  *
 122  * @param *
 123  * @param *pname        Resolved User or group name
 124  * @param *pname_type   Pointer to the resolved SID type
 125  *
 126  * @return #wbcErr
 127  */
 128
 129 wbcErr wbcLookupName_recv(struct tevent_req *req,
 130                           struct wbcDomainSid *sid,
 131                           enum wbcSidType *name_type)
 132 {
 133         struct wbc_lookup_name_state *state = tevent_req_data(
 134                         req, struct wbc_lookup_name_state);
 135         wbcErr wbc_status = WBC_ERR_SUCCESS;
 136
 137         if (!sid || !name_type) {
 138                 wbcDebug(state->wb_ctx, WBC_DEBUG_TRACE,
 139                 "Sid is %p, name_type is %p\n", sid, name_type);
 140                 wbc_status = WBC_ERR_INVALID_PARAM;
 141                 goto failed;
 142         }
 143
 144         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 145                 goto failed;
 146         }
 147
 148         memcpy(sid, state->sid, sizeof(struct wbcDomainSid));
 149         *name_type = state->name_type;
 150
 151 failed:
 152         tevent_req_received(req);
 153         return wbc_status;
 154 }
 155
 156
 157 struct wbc_lookup_sid_state {
 158         struct winbindd_request req;
 159         char *domain;
 160         char *name;
 161         enum wbcSidType name_type;
 162 };
 163
 164 static void wbcLookupSid_done(struct tevent_req *subreq);
 165
 166 /**
 167  * @brief Request a conversion of a SID to a domain and name
 168  *
 169  * @param mem_ctx       talloc context to allocate the request from
 170  * @param ev            tevent context to use for async operation
 171  * @param wb_ctx        winbind context to use
 172  * @param *sid          Pointer to the domain SID to be resolved
 173  *
 174  * @return tevent_req on success, NULL on error
 175  **/
 176
 177 struct tevent_req *wbcLookupSid_send(TALLOC_CTX *mem_ctx,
 178                                      struct tevent_context *ev,
 179                                      struct wb_context *wb_ctx,
 180                                      const struct wbcDomainSid *sid)
 181 {
 182         struct tevent_req *req, *subreq;
 183         struct wbc_lookup_sid_state *state;
 184         char *sid_string;
 185         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 186
 187         req = tevent_req_create(mem_ctx, &state, struct wbc_lookup_sid_state);
 188         if (req == NULL) {
 189                 return NULL;
 190         }
 191
 192         ZERO_STRUCT(state->req);
 193
 194         state->req.cmd = WINBINDD_LOOKUPSID;
 195         wbc_status = wbcSidToString(sid, &sid_string);
 196         if (!WBC_ERROR_IS_OK(wbc_status)) {
 197                 tevent_req_error(req, wbc_status);
 198                 return tevent_req_post(req, ev);
 199         }
 200         strncpy(state->req.data.sid, sid_string, sizeof(state->req.data.sid)-1);
 201         wbcFreeMemory(sid_string);
 202
 203         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 204         if (tevent_req_nomem(subreq, req)) {
 205                 return tevent_req_post(req, ev);
 206         }
 207
 208         tevent_req_set_callback(subreq, wbcLookupSid_done, req);
 209         return req;
 210 }
 211
 212 static void wbcLookupSid_done(struct tevent_req *subreq)
 213 {
 214         struct tevent_req *req = tevent_req_callback_data(
 215                         subreq, struct tevent_req);
 216         struct wbc_lookup_sid_state *state = tevent_req_data(
 217                         req, struct wbc_lookup_sid_state);
 218         struct winbindd_response *resp;
 219         wbcErr wbc_status;
 220
 221         wbc_status = wb_trans_recv(subreq, state, &resp);
 222         TALLOC_FREE(subreq);
 223         if (!WBC_ERROR_IS_OK(wbc_status)) {
 224                 tevent_req_error(req, wbc_status);
 225                 return;
 226         }
 227         state->domain = talloc_strdup(state, resp->data.name.dom_name);
 228         if (tevent_req_nomem(state->domain, req)) {
 229                 return;
 230         }
 231
 232         state->name   = talloc_strdup(state, resp->data.name.name);
 233         if (tevent_req_nomem(state->name, req)) {
 234                 return;
 235         }
 236
 237         state->name_type = (enum wbcSidType)resp->data.name.type;
 238
 239         TALLOC_FREE(resp);
 240
 241         tevent_req_done(req);
 242 }
 243
 244 /**
 245  * @brief Receive a conversion a SID to a domain and name
 246  *
 247  * @param *mem_ctx,     talloc context to move results to
 248  * @param *pdomain      Resolved Domain name (possibly "")
 249  * @param *pname        Resolved User or group name
 250  * @param *pname_type   Pointer to the resolved SID type
 251  *
 252  * @return #wbcErr
 253  */
 254
 255 wbcErr wbcLookupSid_recv(struct tevent_req *req,
 256                          TALLOC_CTX *mem_ctx,
 257                          char **pdomain,
 258                          char **pname,
 259                          enum wbcSidType *pname_type)
 260 {
 261         struct wbc_lookup_sid_state *state = tevent_req_data(
 262                         req, struct wbc_lookup_sid_state);
 263         wbcErr wbc_status;
 264
 265         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 266                 tevent_req_received(req);
 267                 return wbc_status;
 268         }
 269
 270         if (pdomain != NULL) {
 271                 *pdomain = talloc_steal(mem_ctx, state->domain);
 272         }
 273
 274         if (pname != NULL) {
 275                 *pname   = talloc_steal(mem_ctx, state->name);
 276         }
 277
 278         if (pname_type != NULL) {
 279                 *pname_type = state->name_type;
 280         }
 281
 282         tevent_req_received(req);
 283         return WBC_ERR_SUCCESS;
 284 }