mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
2664d9070f
There are some global variables in use in the libwbclient library. Now that we have a context, move these into it so that they are thread-safe when the wbcCtx* functions are used. Signed-off-by: Matthew Newton <matthew-git@newtoncomputing.co.uk> Reviewed-by: Volker Lendecke <vl@samba.org> Reviewed-by: Jeremy Allison <jra@samba.org>
334 lines
7.6 KiB
C
334 lines
7.6 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
|
|
Winbind client API
|
|
|
|
Copyright (C) Gerald (Jerry) Carter 2007
|
|
Copyright (C) Matthew Newton 2015
|
|
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* Required Headers */
|
|
|
|
#include "replace.h"
|
|
#include "libwbclient.h"
|
|
|
|
/* From wb_common.c */
|
|
|
|
struct winbindd_context;
|
|
|
|
NSS_STATUS winbindd_request_response(struct winbindd_context *wbctx,
|
|
int req_type,
|
|
struct winbindd_request *request,
|
|
struct winbindd_response *response);
|
|
NSS_STATUS winbindd_priv_request_response(struct winbindd_context *wbctx,
|
|
int req_type,
|
|
struct winbindd_request *request,
|
|
struct winbindd_response *response);
|
|
struct winbindd_context *winbindd_ctx_create(void);
|
|
void winbindd_ctx_free(struct winbindd_context *ctx);
|
|
|
|
/* Global context used for non-Ctx functions */
|
|
|
|
static struct wbcContext wbcGlobalCtx = {
|
|
.winbindd_ctx = NULL,
|
|
.pw_cache_size = 0,
|
|
.pw_cache_idx = 0,
|
|
.gr_cache_size = 0,
|
|
.gr_cache_idx = 0
|
|
};
|
|
|
|
/*
|
|
result == NSS_STATUS_UNAVAIL: winbind not around
|
|
result == NSS_STATUS_NOTFOUND: winbind around, but domain missing
|
|
|
|
Due to a bad API NSS_STATUS_NOTFOUND is returned both when winbind_off
|
|
and when winbind return WINBINDD_ERROR. So the semantics of this
|
|
routine depends on winbind_on. Grepping for winbind_off I just
|
|
found 3 places where winbind is turned off, and this does not conflict
|
|
(as far as I have seen) with the callers of is_trusted_domains.
|
|
|
|
--Volker
|
|
*/
|
|
|
|
static wbcErr wbcRequestResponseInt(
|
|
struct winbindd_context *wbctx,
|
|
int cmd,
|
|
struct winbindd_request *request,
|
|
struct winbindd_response *response,
|
|
NSS_STATUS (*fn)(struct winbindd_context *wbctx, int req_type,
|
|
struct winbindd_request *request,
|
|
struct winbindd_response *response))
|
|
{
|
|
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
|
|
NSS_STATUS nss_status;
|
|
|
|
/* for some calls the request and/or response can be NULL */
|
|
|
|
nss_status = fn(wbctx, cmd, request, response);
|
|
|
|
switch (nss_status) {
|
|
case NSS_STATUS_SUCCESS:
|
|
wbc_status = WBC_ERR_SUCCESS;
|
|
break;
|
|
case NSS_STATUS_UNAVAIL:
|
|
wbc_status = WBC_ERR_WINBIND_NOT_AVAILABLE;
|
|
break;
|
|
case NSS_STATUS_NOTFOUND:
|
|
wbc_status = WBC_ERR_DOMAIN_NOT_FOUND;
|
|
break;
|
|
default:
|
|
wbc_status = WBC_ERR_NSS_ERROR;
|
|
break;
|
|
}
|
|
|
|
return wbc_status;
|
|
}
|
|
|
|
/**
|
|
* @brief Wrapper around Winbind's send/receive API call
|
|
*
|
|
* @param ctx Context
|
|
* @param cmd Winbind command operation to perform
|
|
* @param request Send structure
|
|
* @param response Receive structure
|
|
*
|
|
* @return #wbcErr
|
|
*/
|
|
wbcErr wbcRequestResponse(struct wbcContext *ctx, int cmd,
|
|
struct winbindd_request *request,
|
|
struct winbindd_response *response)
|
|
{
|
|
struct winbindd_context *wbctx = NULL;
|
|
|
|
if (ctx) {
|
|
wbctx = ctx->winbindd_ctx;
|
|
}
|
|
|
|
return wbcRequestResponseInt(wbctx, cmd, request, response,
|
|
winbindd_request_response);
|
|
}
|
|
|
|
wbcErr wbcRequestResponsePriv(struct wbcContext *ctx, int cmd,
|
|
struct winbindd_request *request,
|
|
struct winbindd_response *response)
|
|
{
|
|
struct winbindd_context *wbctx = NULL;
|
|
|
|
if (ctx) {
|
|
wbctx = ctx->winbindd_ctx;
|
|
}
|
|
|
|
return wbcRequestResponseInt(wbctx, cmd, request, response,
|
|
winbindd_priv_request_response);
|
|
}
|
|
|
|
/** @brief Translate an error value into a string
|
|
*
|
|
* @param error
|
|
*
|
|
* @return a pointer to a static string
|
|
**/
|
|
const char *wbcErrorString(wbcErr error)
|
|
{
|
|
switch (error) {
|
|
case WBC_ERR_SUCCESS:
|
|
return "WBC_ERR_SUCCESS";
|
|
case WBC_ERR_NOT_IMPLEMENTED:
|
|
return "WBC_ERR_NOT_IMPLEMENTED";
|
|
case WBC_ERR_UNKNOWN_FAILURE:
|
|
return "WBC_ERR_UNKNOWN_FAILURE";
|
|
case WBC_ERR_NO_MEMORY:
|
|
return "WBC_ERR_NO_MEMORY";
|
|
case WBC_ERR_INVALID_SID:
|
|
return "WBC_ERR_INVALID_SID";
|
|
case WBC_ERR_INVALID_PARAM:
|
|
return "WBC_ERR_INVALID_PARAM";
|
|
case WBC_ERR_WINBIND_NOT_AVAILABLE:
|
|
return "WBC_ERR_WINBIND_NOT_AVAILABLE";
|
|
case WBC_ERR_DOMAIN_NOT_FOUND:
|
|
return "WBC_ERR_DOMAIN_NOT_FOUND";
|
|
case WBC_ERR_INVALID_RESPONSE:
|
|
return "WBC_ERR_INVALID_RESPONSE";
|
|
case WBC_ERR_NSS_ERROR:
|
|
return "WBC_ERR_NSS_ERROR";
|
|
case WBC_ERR_UNKNOWN_USER:
|
|
return "WBC_ERR_UNKNOWN_USER";
|
|
case WBC_ERR_UNKNOWN_GROUP:
|
|
return "WBC_ERR_UNKNOWN_GROUP";
|
|
case WBC_ERR_AUTH_ERROR:
|
|
return "WBC_ERR_AUTH_ERROR";
|
|
case WBC_ERR_PWD_CHANGE_FAILED:
|
|
return "WBC_ERR_PWD_CHANGE_FAILED";
|
|
}
|
|
|
|
return "unknown wbcErr value";
|
|
}
|
|
|
|
#define WBC_MAGIC (0x7a2b0e1e)
|
|
#define WBC_MAGIC_FREE (0x875634fe)
|
|
|
|
struct wbcMemPrefix {
|
|
uint32_t magic;
|
|
void (*destructor)(void *ptr);
|
|
};
|
|
|
|
static size_t wbcPrefixLen(void)
|
|
{
|
|
size_t result = sizeof(struct wbcMemPrefix);
|
|
return (result + 15) & ~15;
|
|
}
|
|
|
|
static struct wbcMemPrefix *wbcMemToPrefix(void *ptr)
|
|
{
|
|
return (struct wbcMemPrefix *)(((char *)ptr) - wbcPrefixLen());
|
|
}
|
|
|
|
void *wbcAllocateMemory(size_t nelem, size_t elsize,
|
|
void (*destructor)(void *ptr))
|
|
{
|
|
struct wbcMemPrefix *result;
|
|
|
|
if (nelem >= (2<<24)/elsize) {
|
|
/* basic protection against integer wrap */
|
|
return NULL;
|
|
}
|
|
|
|
result = (struct wbcMemPrefix *)calloc(
|
|
1, nelem*elsize + wbcPrefixLen());
|
|
if (result == NULL) {
|
|
return NULL;
|
|
}
|
|
result->magic = WBC_MAGIC;
|
|
result->destructor = destructor;
|
|
return ((char *)result) + wbcPrefixLen();
|
|
}
|
|
|
|
/* Free library allocated memory */
|
|
void wbcFreeMemory(void *p)
|
|
{
|
|
struct wbcMemPrefix *wbcMem;
|
|
|
|
if (p == NULL) {
|
|
return;
|
|
}
|
|
wbcMem = wbcMemToPrefix(p);
|
|
if (wbcMem->magic != WBC_MAGIC) {
|
|
return;
|
|
}
|
|
|
|
/* paranoid check to ensure we don't double free */
|
|
wbcMem->magic = WBC_MAGIC_FREE;
|
|
|
|
if (wbcMem->destructor != NULL) {
|
|
wbcMem->destructor(p);
|
|
}
|
|
free(wbcMem);
|
|
return;
|
|
}
|
|
|
|
char *wbcStrDup(const char *str)
|
|
{
|
|
char *result;
|
|
size_t len;
|
|
|
|
len = strlen(str);
|
|
result = (char *)wbcAllocateMemory(len+1, sizeof(char), NULL);
|
|
if (result == NULL) {
|
|
return NULL;
|
|
}
|
|
memcpy(result, str, len+1);
|
|
return result;
|
|
}
|
|
|
|
static void wbcStringArrayDestructor(void *ptr)
|
|
{
|
|
char **p = (char **)ptr;
|
|
while (*p != NULL) {
|
|
free(*p);
|
|
p += 1;
|
|
}
|
|
}
|
|
|
|
const char **wbcAllocateStringArray(int num_strings)
|
|
{
|
|
return (const char **)wbcAllocateMemory(
|
|
num_strings + 1, sizeof(const char *),
|
|
wbcStringArrayDestructor);
|
|
}
|
|
|
|
wbcErr wbcLibraryDetails(struct wbcLibraryDetails **_details)
|
|
{
|
|
struct wbcLibraryDetails *info;
|
|
|
|
info = (struct wbcLibraryDetails *)wbcAllocateMemory(
|
|
1, sizeof(struct wbcLibraryDetails), NULL);
|
|
|
|
if (info == NULL) {
|
|
return WBC_ERR_NO_MEMORY;
|
|
}
|
|
|
|
info->major_version = WBCLIENT_MAJOR_VERSION;
|
|
info->minor_version = WBCLIENT_MINOR_VERSION;
|
|
info->vendor_version = WBCLIENT_VENDOR_VERSION;
|
|
|
|
*_details = info;
|
|
return WBC_ERR_SUCCESS;
|
|
}
|
|
|
|
/* Context handling functions */
|
|
|
|
static void wbcContextDestructor(void *ptr)
|
|
{
|
|
struct wbcContext *ctx = (struct wbcContext *)ptr;
|
|
|
|
winbindd_ctx_free(ctx->winbindd_ctx);
|
|
}
|
|
|
|
struct wbcContext *wbcCtxCreate(void)
|
|
{
|
|
struct wbcContext *ctx;
|
|
struct winbindd_context *wbctx;
|
|
|
|
ctx = (struct wbcContext *)wbcAllocateMemory(
|
|
1, sizeof(struct wbcContext), wbcContextDestructor);
|
|
|
|
if (!ctx) {
|
|
return NULL;
|
|
}
|
|
|
|
wbctx = winbindd_ctx_create();
|
|
|
|
if (!wbctx) {
|
|
wbcFreeMemory(ctx);
|
|
return NULL;
|
|
}
|
|
|
|
ctx->winbindd_ctx = wbctx;
|
|
|
|
return ctx;
|
|
}
|
|
|
|
void wbcCtxFree(struct wbcContext *ctx)
|
|
{
|
|
wbcFreeMemory(ctx);
|
|
}
|
|
|
|
struct wbcContext *wbcGetGlobalCtx(void)
|
|
{
|
|
return &wbcGlobalCtx;
|
|
}
|