LCOV - code coverage report
Current view: top level - nsswitch/libwbclient - wbclient.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 96 136 70.6 %
Date: 2024-02-28 12:06:22 Functions: 15 16 93.8 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    Winbind client API
       5             : 
       6             :    Copyright (C) Gerald (Jerry) Carter 2007
       7             :    Copyright (C) Matthew Newton 2015
       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             : /* From wb_common.c */
      30             : 
      31             : struct winbindd_context;
      32             : 
      33             : NSS_STATUS winbindd_request_response(struct winbindd_context *wbctx,
      34             :                                      int req_type,
      35             :                                      struct winbindd_request *request,
      36             :                                      struct winbindd_response *response);
      37             : NSS_STATUS winbindd_priv_request_response(struct winbindd_context *wbctx,
      38             :                                           int req_type,
      39             :                                           struct winbindd_request *request,
      40             :                                           struct winbindd_response *response);
      41             : struct winbindd_context *winbindd_ctx_create(void);
      42             : void winbindd_ctx_free(struct winbindd_context *ctx);
      43             : 
      44             : /* Global context used for non-Ctx functions */
      45             : 
      46             : static struct wbcContext wbcGlobalCtx = {
      47             :         .winbindd_ctx = NULL,
      48             :         .pw_cache_size = 0,
      49             :         .pw_cache_idx = 0,
      50             :         .gr_cache_size = 0,
      51             :         .gr_cache_idx = 0
      52             : };
      53             : 
      54             : /*
      55             :  result == NSS_STATUS_UNAVAIL: winbind not around
      56             :  result == NSS_STATUS_NOTFOUND: winbind around, but domain missing
      57             : 
      58             :  Due to a bad API NSS_STATUS_NOTFOUND is returned both when winbind_off
      59             :  and when winbind return WINBINDD_ERROR. So the semantics of this
      60             :  routine depends on winbind_on. Grepping for winbind_off I just
      61             :  found 3 places where winbind is turned off, and this does not conflict
      62             :  (as far as I have seen) with the callers of is_trusted_domains.
      63             : 
      64             :  --Volker
      65             : */
      66             : 
      67     1013800 : static wbcErr wbcRequestResponseInt(
      68             :         struct winbindd_context *wbctx,
      69             :         int cmd,
      70             :         struct winbindd_request *request,
      71             :         struct winbindd_response *response,
      72             :         NSS_STATUS (*fn)(struct winbindd_context *wbctx, int req_type,
      73             :                          struct winbindd_request *request,
      74             :                          struct winbindd_response *response))
      75             : {
      76     1013800 :         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
      77        4243 :         NSS_STATUS nss_status;
      78             : 
      79             :         /* for some calls the request and/or response can be NULL */
      80             : 
      81     1018043 :         nss_status = fn(wbctx, cmd, request, response);
      82             : 
      83     1013800 :         switch (nss_status) {
      84      391263 :         case NSS_STATUS_SUCCESS:
      85      391263 :                 wbc_status = WBC_ERR_SUCCESS;
      86      391263 :                 break;
      87      610395 :         case NSS_STATUS_UNAVAIL:
      88      610395 :                 wbc_status = WBC_ERR_WINBIND_NOT_AVAILABLE;
      89      610395 :                 break;
      90        7899 :         case NSS_STATUS_NOTFOUND:
      91        7899 :                 wbc_status = WBC_ERR_DOMAIN_NOT_FOUND;
      92        7899 :                 break;
      93           0 :         default:
      94           0 :                 wbc_status = WBC_ERR_NSS_ERROR;
      95           0 :                 break;
      96             :         }
      97             : 
      98     1013800 :         return wbc_status;
      99             : }
     100             : 
     101             : /**
     102             :  * @brief Wrapper around Winbind's send/receive API call
     103             :  *
     104             :  * @param ctx       Context
     105             :  * @param cmd       Winbind command operation to perform
     106             :  * @param request   Send structure
     107             :  * @param response  Receive structure
     108             :  *
     109             :  * @return #wbcErr
     110             :  */
     111             : _PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
     112     1001533 : wbcErr wbcRequestResponse(struct wbcContext *ctx, int cmd,
     113             :                           struct winbindd_request *request,
     114             :                           struct winbindd_response *response)
     115             : {
     116     1001533 :         struct winbindd_context *wbctx = NULL;
     117             : 
     118     1001533 :         if (ctx) {
     119        1224 :                 wbctx = ctx->winbindd_ctx;
     120             :         }
     121             : 
     122     1001533 :         return wbcRequestResponseInt(wbctx, cmd, request, response,
     123             :                                      winbindd_request_response);
     124             : }
     125             : 
     126             : _PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
     127       12267 : wbcErr wbcRequestResponsePriv(struct wbcContext *ctx, int cmd,
     128             :                               struct winbindd_request *request,
     129             :                               struct winbindd_response *response)
     130             : {
     131       12267 :         struct winbindd_context *wbctx = NULL;
     132             : 
     133       12267 :         if (ctx) {
     134           0 :                 wbctx = ctx->winbindd_ctx;
     135             :         }
     136             : 
     137       12267 :         return wbcRequestResponseInt(wbctx, cmd, request, response,
     138             :                                      winbindd_priv_request_response);
     139             : }
     140             : 
     141             : /** @brief Translate an error value into a string
     142             :  *
     143             :  * @param error
     144             :  *
     145             :  * @return a pointer to a static string
     146             :  **/
     147             : _PUBLIC_
     148         420 : const char *wbcErrorString(wbcErr error)
     149             : {
     150         420 :         switch (error) {
     151         220 :         case WBC_ERR_SUCCESS:
     152         220 :                 return "WBC_ERR_SUCCESS";
     153           0 :         case WBC_ERR_NOT_IMPLEMENTED:
     154           0 :                 return "WBC_ERR_NOT_IMPLEMENTED";
     155           0 :         case WBC_ERR_UNKNOWN_FAILURE:
     156           0 :                 return "WBC_ERR_UNKNOWN_FAILURE";
     157           0 :         case WBC_ERR_NO_MEMORY:
     158           0 :                 return "WBC_ERR_NO_MEMORY";
     159           0 :         case WBC_ERR_INVALID_SID:
     160           0 :                 return "WBC_ERR_INVALID_SID";
     161           0 :         case WBC_ERR_INVALID_PARAM:
     162           0 :                 return "WBC_ERR_INVALID_PARAM";
     163          12 :         case WBC_ERR_WINBIND_NOT_AVAILABLE:
     164          12 :                 return "WBC_ERR_WINBIND_NOT_AVAILABLE";
     165         112 :         case WBC_ERR_DOMAIN_NOT_FOUND:
     166         112 :                 return "WBC_ERR_DOMAIN_NOT_FOUND";
     167           0 :         case WBC_ERR_INVALID_RESPONSE:
     168           0 :                 return "WBC_ERR_INVALID_RESPONSE";
     169           0 :         case WBC_ERR_NSS_ERROR:
     170           0 :                 return "WBC_ERR_NSS_ERROR";
     171           0 :         case WBC_ERR_UNKNOWN_USER:
     172           0 :                 return "WBC_ERR_UNKNOWN_USER";
     173           0 :         case WBC_ERR_UNKNOWN_GROUP:
     174           0 :                 return "WBC_ERR_UNKNOWN_GROUP";
     175          76 :         case WBC_ERR_AUTH_ERROR:
     176          76 :                 return "WBC_ERR_AUTH_ERROR";
     177           0 :         case WBC_ERR_PWD_CHANGE_FAILED:
     178           0 :                 return "WBC_ERR_PWD_CHANGE_FAILED";
     179             :         }
     180             : 
     181           0 :         return "unknown wbcErr value";
     182             : }
     183             : 
     184             : #define WBC_MAGIC (0x7a2b0e1e)
     185             : #define WBC_MAGIC_FREE (0x875634fe)
     186             : 
     187             : struct wbcMemPrefix {
     188             :         uint32_t magic;
     189             :         void (*destructor)(void *ptr);
     190             : };
     191             : 
     192      443812 : static size_t wbcPrefixLen(void)
     193             : {
     194      443828 :         size_t result = sizeof(struct wbcMemPrefix);
     195      443812 :         return (result + 15) & ~15;
     196             : }
     197             : 
     198      147312 : static struct wbcMemPrefix *wbcMemToPrefix(void *ptr)
     199             : {
     200      147312 :         return (struct wbcMemPrefix *)(((char *)ptr) - wbcPrefixLen());
     201             : }
     202             : 
     203             : _PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
     204      148258 : void *wbcAllocateMemory(size_t nelem, size_t elsize,
     205             :                         void (*destructor)(void *ptr))
     206             : {
     207           6 :         struct wbcMemPrefix *result;
     208             : 
     209      148258 :         if (nelem >= (2<<24)/elsize) {
     210             :                 /* basic protection against integer wrap */
     211           0 :                 return NULL;
     212             :         }
     213             : 
     214      148258 :         result = (struct wbcMemPrefix *)calloc(
     215      148258 :                 1, nelem*elsize + wbcPrefixLen());
     216      148258 :         if (result == NULL) {
     217           0 :                 return NULL;
     218             :         }
     219      148258 :         result->magic = WBC_MAGIC;
     220      148258 :         result->destructor = destructor;
     221      148258 :         return ((char *)result) + wbcPrefixLen();
     222             : }
     223             : 
     224             : /* Free library allocated memory */
     225             : _PUBLIC_
     226      160524 : void wbcFreeMemory(void *p)
     227             : {
     228           8 :         struct wbcMemPrefix *wbcMem;
     229             : 
     230      160524 :         if (p == NULL) {
     231       13208 :                 return;
     232             :         }
     233      147312 :         wbcMem = wbcMemToPrefix(p);
     234      147312 :         if (wbcMem->magic != WBC_MAGIC) {
     235           0 :                 return;
     236             :         }
     237             : 
     238             :         /* paranoid check to ensure we don't double free */
     239      147312 :         wbcMem->magic = WBC_MAGIC_FREE;
     240             : 
     241      147312 :         if (wbcMem->destructor != NULL) {
     242      142768 :                 wbcMem->destructor(p);
     243             :         }
     244      147312 :         free(wbcMem);
     245      147312 :         return;
     246             : }
     247             : 
     248             : _PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
     249        1918 : char *wbcStrDup(const char *str)
     250             : {
     251           0 :         char *result;
     252           0 :         size_t len;
     253             : 
     254        1918 :         len = strlen(str);
     255        1918 :         result = (char *)wbcAllocateMemory(len+1, sizeof(char), NULL);
     256        1918 :         if (result == NULL) {
     257           0 :                 return NULL;
     258             :         }
     259        1918 :         memcpy(result, str, len+1);
     260        1918 :         return result;
     261             : }
     262             : 
     263          72 : static void wbcStringArrayDestructor(void *ptr)
     264             : {
     265          72 :         char **p = (char **)ptr;
     266        6560 :         while (*p != NULL) {
     267        6488 :                 free(*p);
     268        6488 :                 p += 1;
     269             :         }
     270          72 : }
     271             : 
     272             : _PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
     273          72 : const char **wbcAllocateStringArray(int num_strings)
     274             : {
     275         144 :         return (const char **)wbcAllocateMemory(
     276          72 :                 num_strings + 1, sizeof(const char *),
     277             :                 wbcStringArrayDestructor);
     278             : }
     279             : 
     280             : _PUBLIC_
     281           4 : wbcErr wbcLibraryDetails(struct wbcLibraryDetails **_details)
     282             : {
     283           0 :         struct wbcLibraryDetails *info;
     284             : 
     285           4 :         info = (struct wbcLibraryDetails *)wbcAllocateMemory(
     286             :                 1, sizeof(struct wbcLibraryDetails), NULL);
     287             : 
     288           4 :         if (info == NULL) {
     289           0 :                 return WBC_ERR_NO_MEMORY;
     290             :         }
     291             : 
     292           4 :         info->major_version = WBCLIENT_MAJOR_VERSION;
     293           4 :         info->minor_version = WBCLIENT_MINOR_VERSION;
     294           4 :         info->vendor_version = WBCLIENT_VENDOR_VERSION;
     295             : 
     296           4 :         *_details = info;
     297           4 :         return WBC_ERR_SUCCESS;
     298             : }
     299             : 
     300             : /* Context handling functions */
     301             : 
     302         266 : static void wbcContextDestructor(void *ptr)
     303             : {
     304         266 :         struct wbcContext *ctx = (struct wbcContext *)ptr;
     305             : 
     306         266 :         winbindd_ctx_free(ctx->winbindd_ctx);
     307         266 : }
     308             : 
     309             : _PUBLIC_
     310         266 : struct wbcContext *wbcCtxCreate(void)
     311             : {
     312           0 :         struct wbcContext *ctx;
     313           0 :         struct winbindd_context *wbctx;
     314             : 
     315         266 :         ctx = (struct wbcContext *)wbcAllocateMemory(
     316             :                 1, sizeof(struct wbcContext), wbcContextDestructor);
     317             : 
     318         266 :         if (!ctx) {
     319           0 :                 return NULL;
     320             :         }
     321             : 
     322         266 :         wbctx = winbindd_ctx_create();
     323             : 
     324         266 :         if (!wbctx) {
     325           0 :                 wbcFreeMemory(ctx);
     326           0 :                 return NULL;
     327             :         }
     328             : 
     329         266 :         ctx->winbindd_ctx = wbctx;
     330             : 
     331         266 :         return ctx;
     332             : }
     333             : 
     334             : _PUBLIC_
     335         266 : void wbcCtxFree(struct wbcContext *ctx)
     336             : {
     337         266 :         wbcFreeMemory(ctx);
     338         266 : }
     339             : 
     340             : _PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
     341           0 : struct wbcContext *wbcGetGlobalCtx(void)
     342             : {
     343           0 :         return &wbcGlobalCtx;
     344             : }

Generated by: LCOV version 1.14