nsswitch/libwbclient/wbc_idmap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind client API
   5
   6    Copyright (C) Gerald (Jerry) Carter 2007
   7    Copyright (C) Kai Blin 2009
   8
   9
  10    This library is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU Lesser General Public
  12    License as published by the Free Software Foundation; either
  13    version 3 of the License, or (at your option) any later version.
  14
  15    This library is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    Library General Public License for more details.
  19
  20    You should have received a copy of the GNU Lesser General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 /* Required Headers */
  25
  26 #include "replace.h"
  27 #include "libwbclient.h"
  28
  29 struct wbc_sid_to_uid_state {
  30         struct winbindd_request req;
  31         uid_t uid;
  32 };
  33
  34 static void wbcSidToUid_done(struct tevent_req *subreq);
  35
  36 /**
  37  * @brief Convert a Windows SID to a Unix uid, allocating an uid if needed
  38  *
  39  * @param mem_ctx       talloc context to allocate the request from
  40  * @param ev            tevent context to use for async operation
  41  * @param wb_ctx        winbind context to use
  42  * @param *sid          pointer to the domain SID to be resolved
  43  *
  44  * @return tevent_req on success, NULL on error
  45  */
  46
  47 struct tevent_req *wbcSidToUid_send(TALLOC_CTX *mem_ctx,
  48                                     struct tevent_context *ev,
  49                                     struct wb_context *wb_ctx,
  50                                     const struct wbcDomainSid *sid)
  51 {
  52         struct tevent_req *req, *subreq;
  53         struct wbc_sid_to_uid_state *state;
  54         char *sid_string;
  55         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
  56
  57         req = tevent_req_create(mem_ctx, &state, struct wbc_sid_to_uid_state);
  58         if (req == NULL) {
  59                 return NULL;
  60         }
  61
  62         ZERO_STRUCT(state->req);
  63
  64         state->req.cmd = WINBINDD_SID_TO_UID;
  65         wbc_status = wbcSidToString(sid, &sid_string);
  66         if (!WBC_ERROR_IS_OK(wbc_status)) {
  67                 return tevent_req_post(req, ev);
  68         }
  69         strncpy(state->req.data.sid, sid_string, sizeof(state->req.data.sid)-1);
  70         wbcFreeMemory(sid_string);
  71
  72         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
  73         if (tevent_req_nomem(subreq, req)) {
  74                 return tevent_req_post(req, ev);
  75         }
  76
  77         tevent_req_set_callback(subreq, wbcSidToUid_done, req);
  78         return req;
  79 }
  80
  81 static void wbcSidToUid_done(struct tevent_req *subreq)
  82 {
  83         struct tevent_req *req = tevent_req_callback_data(
  84                         subreq, struct tevent_req);
  85         struct wbc_sid_to_uid_state *state = tevent_req_data(
  86                         req, struct wbc_sid_to_uid_state);
  87         struct winbindd_response *resp;
  88         wbcErr wbc_status;
  89
  90         wbc_status = wb_trans_recv(subreq, state, &resp);
  91         TALLOC_FREE(subreq);
  92         if (!WBC_ERROR_IS_OK(wbc_status)) {
  93                 tevent_req_error(req, wbc_status);
  94                 return;
  95         }
  96         state->uid = resp->data.uid;
  97         TALLOC_FREE(resp);
  98
  99         tevent_req_done(req);
 100 }
 101
 102 /**
 103  * @brief Receive a Unix uid mapped to a Windows SID
 104  *
 105  * @param req           tevent_req containing the request
 106  * @param *puid         pointer to hold the resolved uid_t value
 107  *
 108  * @return #wbcErr
 109  */
 110
 111 wbcErr wbcSidToUid_recv(struct tevent_req *req, uid_t *puid)
 112 {
 113         struct wbc_sid_to_uid_state *state = tevent_req_data(
 114                         req, struct wbc_sid_to_uid_state);
 115         wbcErr wbc_status;
 116
 117         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 118                 tevent_req_received(req);
 119                 return wbc_status;
 120         }
 121
 122         *puid = state->uid;
 123
 124         tevent_req_received(req);
 125         return WBC_ERR_SUCCESS;
 126 }
 127
 128 /* Convert a Windows SID to a Unix uid, allocating an uid if needed */
 129 wbcErr wbcSidToUid(const struct wbcDomainSid *sid, uid_t *puid)
 130 {
 131         struct winbindd_request request;
 132         struct winbindd_response response;
 133         char *sid_string = NULL;
 134         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 135
 136         if (!sid || !puid) {
 137                 wbc_status = WBC_ERR_INVALID_PARAM;
 138                 BAIL_ON_WBC_ERROR(wbc_status);
 139         }
 140
 141         /* Initialize request */
 142
 143         ZERO_STRUCT(request);
 144         ZERO_STRUCT(response);
 145
 146         wbc_status = wbcSidToString(sid, &sid_string);
 147         BAIL_ON_WBC_ERROR(wbc_status);
 148
 149         strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
 150         wbcFreeMemory(sid_string);
 151
 152         /* Make request */
 153
 154         wbc_status = wbcRequestResponse(WINBINDD_SID_TO_UID,
 155                                         &request,
 156                                         &response);
 157         BAIL_ON_WBC_ERROR(wbc_status);
 158
 159         *puid = response.data.uid;
 160
 161         wbc_status = WBC_ERR_SUCCESS;
 162
 163  done:
 164         return wbc_status;
 165 }
 166
 167 /* Convert a Windows SID to a Unix uid if there already is a mapping */
 168 wbcErr wbcQuerySidToUid(const struct wbcDomainSid *sid,
 169                         uid_t *puid)
 170 {
 171         return WBC_ERR_NOT_IMPLEMENTED;
 172 }
 173
 174 struct wbc_uid_to_sid_state {
 175         struct winbindd_request req;
 176         struct wbcDomainSid *sid;
 177 };
 178
 179 static void wbcUidToSid_done(struct tevent_req *subreq);
 180
 181 /**
 182  * @brief Request a Windows SID for an Unix uid, allocating an SID if needed
 183  *
 184  * @param mem_ctx       talloc context to allocate the request from
 185  * @param ev            tevent context to use for async operation
 186  * @param wb_ctx        winbind context to use
 187  * @param uid           uid to be resolved to a SID
 188  *
 189  * @return tevent_req on success, NULL on error
 190  */
 191
 192 struct tevent_req *wbcUidToSid_send(TALLOC_CTX *mem_ctx,
 193                                     struct tevent_context *ev,
 194                                     struct wb_context *wb_ctx,
 195                                     uid_t uid)
 196 {
 197         struct tevent_req *req, *subreq;
 198         struct wbc_uid_to_sid_state *state;
 199
 200         req = tevent_req_create(mem_ctx, &state, struct wbc_uid_to_sid_state);
 201         if (req == NULL) {
 202                 return NULL;
 203         }
 204
 205         ZERO_STRUCT(state->req);
 206
 207         state->req.cmd = WINBINDD_UID_TO_SID;
 208         state->req.data.uid = uid;
 209
 210         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 211         if (tevent_req_nomem(subreq, req)) {
 212                 return tevent_req_post(req, ev);
 213         }
 214
 215         tevent_req_set_callback(subreq, wbcUidToSid_done, req);
 216         return req;
 217 }
 218
 219 static void wbcUidToSid_done(struct tevent_req *subreq)
 220 {
 221         struct tevent_req *req = tevent_req_callback_data(
 222                         subreq, struct tevent_req);
 223         struct wbc_uid_to_sid_state *state = tevent_req_data(
 224                         req, struct wbc_uid_to_sid_state);
 225         struct winbindd_response *resp;
 226         wbcErr wbc_status;
 227
 228         wbc_status = wb_trans_recv(subreq, state, &resp);
 229         TALLOC_FREE(subreq);
 230         if (!WBC_ERROR_IS_OK(wbc_status)) {
 231                 tevent_req_error(req, wbc_status);
 232                 return;
 233         }
 234
 235         state->sid = talloc(state, struct wbcDomainSid);
 236         if (state->sid == NULL) {
 237                 TALLOC_FREE(resp);
 238                 tevent_req_error(req, WBC_ERR_NO_MEMORY);
 239                 return;
 240         }
 241
 242         wbc_status = wbcStringToSid(resp->data.sid.sid, state->sid);
 243         TALLOC_FREE(resp);
 244
 245         if (!WBC_ERROR_IS_OK(wbc_status)) {
 246                 tevent_req_error(req, wbc_status);
 247                 return;
 248         }
 249
 250         tevent_req_done(req);
 251 }
 252
 253 /**
 254  * @brief Receive a Unix uid mapped to a Windows SID
 255  *
 256  * @param req           tevent_req containing the request
 257  * @param *psid         pointer to hold the resolved SID
 258  *
 259  * @return #wbcErr
 260  */
 261
 262 wbcErr wbcUidToSid_recv(struct tevent_req *req, struct wbcDomainSid *psid)
 263 {
 264         struct wbc_uid_to_sid_state *state = tevent_req_data(
 265                         req, struct wbc_uid_to_sid_state);
 266         wbcErr wbc_status;
 267
 268         if (psid == NULL) {
 269                 tevent_req_received(req);
 270                 return WBC_ERR_INVALID_PARAM;
 271         }
 272
 273         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 274                 tevent_req_received(req);
 275                 return wbc_status;
 276         }
 277
 278         memcpy(psid, state->sid, sizeof(struct wbcDomainSid));
 279
 280         tevent_req_received(req);
 281         return WBC_ERR_SUCCESS;
 282 }
 283
 284 /* Convert a Unix uid to a Windows SID, allocating a SID if needed */
 285 wbcErr wbcUidToSid(uid_t uid, struct wbcDomainSid *sid)
 286 {
 287         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 288         struct winbindd_request request;
 289         struct winbindd_response response;
 290
 291         if (!sid) {
 292                 wbc_status = WBC_ERR_INVALID_PARAM;
 293                 BAIL_ON_WBC_ERROR(wbc_status);
 294         }
 295
 296         /* Initialize request */
 297
 298         ZERO_STRUCT(request);
 299         ZERO_STRUCT(response);
 300
 301         request.data.uid = uid;
 302
 303         /* Make request */
 304
 305         wbc_status = wbcRequestResponse(WINBINDD_UID_TO_SID,
 306                                         &request,
 307                                         &response);
 308         BAIL_ON_WBC_ERROR(wbc_status);
 309
 310         wbc_status = wbcStringToSid(response.data.sid.sid, sid);
 311         BAIL_ON_WBC_ERROR(wbc_status);
 312
 313 done:
 314         return wbc_status;
 315 }
 316
 317 /* Convert a Unix uid to a Windows SID if there already is a mapping */
 318 wbcErr wbcQueryUidToSid(uid_t uid,
 319                         struct wbcDomainSid *sid)
 320 {
 321         return WBC_ERR_NOT_IMPLEMENTED;
 322 }
 323
 324 struct wbc_sid_to_gid_state {
 325         struct winbindd_request req;
 326         gid_t gid;
 327 };
 328
 329 static void wbcSidToGid_done(struct tevent_req *subreq);
 330
 331 /**
 332  * @brief Request to convert a Windows SID to a Unix gid,
 333  * allocating a gid if needed
 334  *
 335  * @param mem_ctx       talloc context to allocate the request from
 336  * @param ev            tevent context to use for async operation
 337  * @param wb_ctx        winbind context to use
 338  * @param *sid          pointer to the domain SID to be resolved
 339  *
 340  * @return tevent_req on success, NULL on error
 341  */
 342
 343 struct tevent_req *wbcSidToGid_send(TALLOC_CTX *mem_ctx,
 344                                     struct tevent_context *ev,
 345                                     struct wb_context *wb_ctx,
 346                                     const struct wbcDomainSid *sid)
 347 {
 348         struct tevent_req *req, *subreq;
 349         struct wbc_sid_to_gid_state *state;
 350         char *sid_string;
 351         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 352
 353         req = tevent_req_create(mem_ctx, &state, struct wbc_sid_to_gid_state);
 354         if (req == NULL) {
 355                 return NULL;
 356         }
 357
 358         ZERO_STRUCT(state->req);
 359
 360         state->req.cmd = WINBINDD_SID_TO_GID;
 361         wbc_status = wbcSidToString(sid, &sid_string);
 362         if (!WBC_ERROR_IS_OK(wbc_status)) {
 363                 return tevent_req_post(req, ev);
 364         }
 365         strncpy(state->req.data.sid, sid_string, sizeof(state->req.data.sid)-1);
 366         wbcFreeMemory(sid_string);
 367
 368         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 369         if (tevent_req_nomem(subreq, req)) {
 370                 return tevent_req_post(req, ev);
 371         }
 372
 373         tevent_req_set_callback(subreq, wbcSidToGid_done, req);
 374         return req;
 375 }
 376
 377 static void wbcSidToGid_done(struct tevent_req *subreq)
 378 {
 379         struct tevent_req *req = tevent_req_callback_data(
 380                         subreq, struct tevent_req);
 381         struct wbc_sid_to_gid_state *state = tevent_req_data(
 382                         req, struct wbc_sid_to_gid_state);
 383         struct winbindd_response *resp;
 384         wbcErr wbc_status;
 385
 386         wbc_status = wb_trans_recv(subreq, state, &resp);
 387         TALLOC_FREE(subreq);
 388         if (!WBC_ERROR_IS_OK(wbc_status)) {
 389                 tevent_req_error(req, wbc_status);
 390                 return;
 391         }
 392         state->gid = resp->data.gid;
 393         TALLOC_FREE(resp);
 394
 395         tevent_req_done(req);
 396 }
 397
 398 /**
 399  * @brief Receive a Unix gid mapped to a Windows SID
 400  *
 401  * @param req           tevent_req containing the request
 402  * @param *pgid         pointer to hold the resolved gid_t value
 403  *
 404  * @return #wbcErr
 405  */
 406
 407 wbcErr wbcSidToGid_recv(struct tevent_req *req, gid_t *pgid)
 408 {
 409         struct wbc_sid_to_gid_state *state = tevent_req_data(
 410                         req, struct wbc_sid_to_gid_state);
 411         wbcErr wbc_status;
 412
 413         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 414                 tevent_req_received(req);
 415                 return wbc_status;
 416         }
 417
 418         *pgid = state->gid;
 419
 420         tevent_req_received(req);
 421         return WBC_ERR_SUCCESS;
 422 }
 423
 424 /** @brief Convert a Windows SID to a Unix gid, allocating a gid if needed
 425  *
 426  * @param *sid        Pointer to the domain SID to be resolved
 427  * @param *pgid       Pointer to the resolved gid_t value
 428  *
 429  * @return #wbcErr
 430  *
 431  **/
 432
 433 wbcErr wbcSidToGid(const struct wbcDomainSid *sid, gid_t *pgid)
 434 {
 435         struct winbindd_request request;
 436         struct winbindd_response response;
 437         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 438         char *sid_string = NULL;
 439
 440         if (!sid || !pgid) {
 441                 wbc_status = WBC_ERR_INVALID_PARAM;
 442                 BAIL_ON_WBC_ERROR(wbc_status);
 443         }
 444
 445         /* Initialize request */
 446
 447         ZERO_STRUCT(request);
 448         ZERO_STRUCT(response);
 449
 450         wbc_status = wbcSidToString(sid, &sid_string);
 451         BAIL_ON_WBC_ERROR(wbc_status);
 452
 453         strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
 454         wbcFreeMemory(sid_string);
 455
 456         /* Make request */
 457
 458         wbc_status = wbcRequestResponse(WINBINDD_SID_TO_GID,
 459                                         &request,
 460                                         &response);
 461         BAIL_ON_WBC_ERROR(wbc_status);
 462
 463         *pgid = response.data.gid;
 464
 465         wbc_status = WBC_ERR_SUCCESS;
 466
 467  done:
 468         return wbc_status;
 469 }
 470
 471
 472 /* Convert a Windows SID to a Unix gid if there already is a mapping */
 473
 474 wbcErr wbcQuerySidToGid(const struct wbcDomainSid *sid,
 475                         gid_t *pgid)
 476 {
 477         return WBC_ERR_NOT_IMPLEMENTED;
 478 }
 479
 480 struct wbc_gid_to_sid_state {
 481         struct winbindd_request req;
 482         struct wbcDomainSid *sid;
 483 };
 484
 485 static void wbcGidToSid_done(struct tevent_req *subreq);
 486
 487 /**
 488  * @brief Request a Windows SID for an Unix Gid, allocating an SID if needed
 489  *
 490  * @param mem_ctx       talloc context to allocate the request from
 491  * @param ev            tevent context to use for async operation
 492  * @param wb_ctx        winbind context to use
 493  * @param gid           gid to be resolved to a SID
 494  *
 495  * @return tevent_req on success, NULL on error
 496  */
 497
 498 struct tevent_req *wbcGidToSid_send(TALLOC_CTX *mem_ctx,
 499                                     struct tevent_context *ev,
 500                                     struct wb_context *wb_ctx,
 501                                     gid_t gid)
 502 {
 503         struct tevent_req *req, *subreq;
 504         struct wbc_gid_to_sid_state *state;
 505
 506         req = tevent_req_create(mem_ctx, &state, struct wbc_gid_to_sid_state);
 507         if (req == NULL) {
 508                 return NULL;
 509         }
 510
 511         ZERO_STRUCT(state->req);
 512
 513         state->req.cmd = WINBINDD_GID_TO_SID;
 514         state->req.data.gid = gid;
 515
 516         subreq = wb_trans_send(state, ev, wb_ctx, false, &state->req);
 517         if (tevent_req_nomem(subreq, req)) {
 518                 return tevent_req_post(req, ev);
 519         }
 520
 521         tevent_req_set_callback(subreq, wbcGidToSid_done, req);
 522         return req;
 523 }
 524
 525 static void wbcGidToSid_done(struct tevent_req *subreq)
 526 {
 527         struct tevent_req *req = tevent_req_callback_data(
 528                         subreq, struct tevent_req);
 529         struct wbc_gid_to_sid_state *state = tevent_req_data(
 530                         req, struct wbc_gid_to_sid_state);
 531         struct winbindd_response *resp;
 532         wbcErr wbc_status;
 533
 534         wbc_status = wb_trans_recv(subreq, state, &resp);
 535         TALLOC_FREE(subreq);
 536         if (!WBC_ERROR_IS_OK(wbc_status)) {
 537                 tevent_req_error(req, wbc_status);
 538                 return;
 539         }
 540
 541         state->sid = talloc(state, struct wbcDomainSid);
 542         if (state->sid == NULL) {
 543                 TALLOC_FREE(resp);
 544                 tevent_req_error(req, WBC_ERR_NO_MEMORY);
 545                 return;
 546         }
 547
 548         wbc_status = wbcStringToSid(resp->data.sid.sid, state->sid);
 549         TALLOC_FREE(resp);
 550
 551         if (!WBC_ERROR_IS_OK(wbc_status)) {
 552                 tevent_req_error(req, wbc_status);
 553                 return;
 554         }
 555
 556         tevent_req_done(req);
 557 }
 558
 559 /**
 560  * @brief Receive a Unix gid mapped to a Windows SID
 561  *
 562  * @param req           tevent_req containing the request
 563  * @param *psid         pointer to hold the resolved SID
 564  *
 565  * @return #wbcErr
 566  */
 567
 568 wbcErr wbcGidToSid_recv(struct tevent_req *req, struct wbcDomainSid *psid)
 569 {
 570         struct wbc_gid_to_sid_state *state = tevent_req_data(
 571                         req, struct wbc_gid_to_sid_state);
 572         wbcErr wbc_status;
 573
 574         if (psid == NULL) {
 575                 tevent_req_received(req);
 576                 return WBC_ERR_INVALID_PARAM;
 577         }
 578
 579         if (tevent_req_is_wbcerr(req, &wbc_status)) {
 580                 tevent_req_received(req);
 581                 return wbc_status;
 582         }
 583
 584         memcpy(psid, state->sid, sizeof(struct wbcDomainSid));
 585
 586         tevent_req_received(req);
 587         return WBC_ERR_SUCCESS;
 588 }
 589
 590
 591 /* Convert a Unix gid to a Windows SID, allocating a SID if needed */
 592 wbcErr wbcGidToSid(gid_t gid, struct wbcDomainSid *sid)
 593 {
 594         struct winbindd_request request;
 595         struct winbindd_response response;
 596         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 597
 598         if (!sid) {
 599                 wbc_status = WBC_ERR_INVALID_PARAM;
 600                 BAIL_ON_WBC_ERROR(wbc_status);
 601         }
 602
 603         /* Initialize request */
 604
 605         ZERO_STRUCT(request);
 606         ZERO_STRUCT(response);
 607
 608         request.data.gid = gid;
 609
 610         /* Make request */
 611
 612         wbc_status = wbcRequestResponse(WINBINDD_GID_TO_SID,
 613                                         &request,
 614                                         &response);
 615         BAIL_ON_WBC_ERROR(wbc_status);
 616
 617         wbc_status = wbcStringToSid(response.data.sid.sid, sid);
 618         BAIL_ON_WBC_ERROR(wbc_status);
 619
 620 done:
 621         return wbc_status;
 622 }
 623
 624 /* Convert a Unix gid to a Windows SID if there already is a mapping */
 625 wbcErr wbcQueryGidToSid(gid_t gid,
 626                         struct wbcDomainSid *sid)
 627 {
 628         return WBC_ERR_NOT_IMPLEMENTED;
 629 }
 630
 631 /* Obtain a new uid from Winbind */
 632 wbcErr wbcAllocateUid(uid_t *puid)
 633 {
 634         struct winbindd_request request;
 635         struct winbindd_response response;
 636         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 637
 638         if (!puid)
 639                 return WBC_ERR_INVALID_PARAM;
 640
 641         /* Initialise request */
 642
 643         ZERO_STRUCT(request);
 644         ZERO_STRUCT(response);
 645
 646         /* Make request */
 647
 648         wbc_status = wbcRequestResponse(WINBINDD_ALLOCATE_UID,
 649                                            &request, &response);
 650         BAIL_ON_WBC_ERROR(wbc_status);
 651
 652         /* Copy out result */
 653         *puid = response.data.uid;
 654
 655         wbc_status = WBC_ERR_SUCCESS;
 656
 657  done:
 658         return wbc_status;
 659 }
 660
 661 /* Obtain a new gid from Winbind */
 662 wbcErr wbcAllocateGid(gid_t *pgid)
 663 {
 664         struct winbindd_request request;
 665         struct winbindd_response response;
 666         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 667
 668         if (!pgid)
 669                 return WBC_ERR_INVALID_PARAM;
 670
 671         /* Initialise request */
 672
 673         ZERO_STRUCT(request);
 674         ZERO_STRUCT(response);
 675
 676         /* Make request */
 677
 678         wbc_status = wbcRequestResponse(WINBINDD_ALLOCATE_GID,
 679                                            &request, &response);
 680         BAIL_ON_WBC_ERROR(wbc_status);
 681
 682         /* Copy out result */
 683         *pgid = response.data.gid;
 684
 685         wbc_status = WBC_ERR_SUCCESS;
 686
 687  done:
 688         return wbc_status;
 689 }
 690
 691 /* we can't include smb.h here... */
 692 #define _ID_TYPE_UID 1
 693 #define _ID_TYPE_GID 2
 694
 695 /* Set an user id mapping */
 696 wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid)
 697 {
 698         struct winbindd_request request;
 699         struct winbindd_response response;
 700         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 701         char *sid_string = NULL;
 702
 703         if (!sid) {
 704                 return WBC_ERR_INVALID_PARAM;
 705         }
 706
 707         /* Initialise request */
 708
 709         ZERO_STRUCT(request);
 710         ZERO_STRUCT(response);
 711
 712         /* Make request */
 713
 714         request.data.dual_idmapset.id = uid;
 715         request.data.dual_idmapset.type = _ID_TYPE_UID;
 716
 717         wbc_status = wbcSidToString(sid, &sid_string);
 718         BAIL_ON_WBC_ERROR(wbc_status);
 719
 720         strncpy(request.data.dual_idmapset.sid, sid_string,
 721                 sizeof(request.data.dual_idmapset.sid)-1);
 722         wbcFreeMemory(sid_string);
 723
 724         wbc_status = wbcRequestResponse(WINBINDD_SET_MAPPING,
 725                                         &request, &response);
 726         BAIL_ON_WBC_ERROR(wbc_status);
 727
 728  done:
 729         return wbc_status;
 730 }
 731
 732 /* Set a group id mapping */
 733 wbcErr wbcSetGidMapping(gid_t gid, const struct wbcDomainSid *sid)
 734 {
 735         struct winbindd_request request;
 736         struct winbindd_response response;
 737         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 738         char *sid_string = NULL;
 739
 740         if (!sid) {
 741                 return WBC_ERR_INVALID_PARAM;
 742         }
 743
 744         /* Initialise request */
 745
 746         ZERO_STRUCT(request);
 747         ZERO_STRUCT(response);
 748
 749         /* Make request */
 750
 751         request.data.dual_idmapset.id = gid;
 752         request.data.dual_idmapset.type = _ID_TYPE_GID;
 753
 754         wbc_status = wbcSidToString(sid, &sid_string);
 755         BAIL_ON_WBC_ERROR(wbc_status);
 756
 757         strncpy(request.data.dual_idmapset.sid, sid_string,
 758                 sizeof(request.data.dual_idmapset.sid)-1);
 759         wbcFreeMemory(sid_string);
 760
 761         wbc_status = wbcRequestResponse(WINBINDD_SET_MAPPING,
 762                                         &request, &response);
 763         BAIL_ON_WBC_ERROR(wbc_status);
 764
 765  done:
 766         return wbc_status;
 767 }
 768
 769 /* Remove a user id mapping */
 770 wbcErr wbcRemoveUidMapping(uid_t uid, const struct wbcDomainSid *sid)
 771 {
 772         struct winbindd_request request;
 773         struct winbindd_response response;
 774         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 775         char *sid_string = NULL;
 776
 777         if (!sid) {
 778                 return WBC_ERR_INVALID_PARAM;
 779         }
 780
 781         /* Initialise request */
 782
 783         ZERO_STRUCT(request);
 784         ZERO_STRUCT(response);
 785
 786         /* Make request */
 787
 788         request.data.dual_idmapset.id = uid;
 789         request.data.dual_idmapset.type = _ID_TYPE_UID;
 790
 791         wbc_status = wbcSidToString(sid, &sid_string);
 792         BAIL_ON_WBC_ERROR(wbc_status);
 793
 794         strncpy(request.data.dual_idmapset.sid, sid_string,
 795                 sizeof(request.data.dual_idmapset.sid)-1);
 796         wbcFreeMemory(sid_string);
 797
 798         wbc_status = wbcRequestResponse(WINBINDD_REMOVE_MAPPING,
 799                                         &request, &response);
 800         BAIL_ON_WBC_ERROR(wbc_status);
 801
 802  done:
 803         return wbc_status;
 804 }
 805
 806 /* Remove a group id mapping */
 807 wbcErr wbcRemoveGidMapping(gid_t gid, const struct wbcDomainSid *sid)
 808 {
 809         struct winbindd_request request;
 810         struct winbindd_response response;
 811         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 812         char *sid_string = NULL;
 813
 814         if (!sid) {
 815                 return WBC_ERR_INVALID_PARAM;
 816         }
 817
 818         /* Initialise request */
 819
 820         ZERO_STRUCT(request);
 821         ZERO_STRUCT(response);
 822
 823         /* Make request */
 824
 825         request.data.dual_idmapset.id = gid;
 826         request.data.dual_idmapset.type = _ID_TYPE_GID;
 827
 828         wbc_status = wbcSidToString(sid, &sid_string);
 829         BAIL_ON_WBC_ERROR(wbc_status);
 830
 831         strncpy(request.data.dual_idmapset.sid, sid_string,
 832                 sizeof(request.data.dual_idmapset.sid)-1);
 833         wbcFreeMemory(sid_string);
 834
 835         wbc_status = wbcRequestResponse(WINBINDD_REMOVE_MAPPING,
 836                                         &request, &response);
 837         BAIL_ON_WBC_ERROR(wbc_status);
 838
 839  done:
 840         return wbc_status;
 841 }
 842
 843 /* Set the highwater mark for allocated uids. */
 844 wbcErr wbcSetUidHwm(uid_t uid_hwm)
 845 {
 846         struct winbindd_request request;
 847         struct winbindd_response response;
 848         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 849
 850         /* Initialise request */
 851
 852         ZERO_STRUCT(request);
 853         ZERO_STRUCT(response);
 854
 855         /* Make request */
 856
 857         request.data.dual_idmapset.id = uid_hwm;
 858         request.data.dual_idmapset.type = _ID_TYPE_UID;
 859
 860         wbc_status = wbcRequestResponse(WINBINDD_SET_HWM,
 861                                         &request, &response);
 862         BAIL_ON_WBC_ERROR(wbc_status);
 863
 864  done:
 865         return wbc_status;
 866 }
 867
 868 /* Set the highwater mark for allocated gids. */
 869 wbcErr wbcSetGidHwm(gid_t gid_hwm)
 870 {
 871         struct winbindd_request request;
 872         struct winbindd_response response;
 873         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 874
 875         /* Initialise request */
 876
 877         ZERO_STRUCT(request);
 878         ZERO_STRUCT(response);
 879
 880         /* Make request */
 881
 882         request.data.dual_idmapset.id = gid_hwm;
 883         request.data.dual_idmapset.type = _ID_TYPE_GID;
 884
 885         wbc_status = wbcRequestResponse(WINBINDD_SET_HWM,
 886                                         &request, &response);
 887         BAIL_ON_WBC_ERROR(wbc_status);
 888
 889  done:
 890         return wbc_status;
 891 }