#include "libwbclient.h"
/* Convert a binary GUID to a character string */
+_PUBLIC_
wbcErr wbcGuidToString(const struct wbcGuid *guid,
char **guid_string)
{
}
/* @brief Convert a character string to a binary GUID */
+_PUBLIC_
wbcErr wbcStringToGuid(const char *str,
struct wbcGuid *guid)
{
#include "lib/util/smb_strtox.h"
/* Convert a Windows SID to a Unix uid, allocating an uid if needed */
+_PUBLIC_
wbcErr wbcCtxSidToUid(struct wbcContext *ctx, const struct wbcDomainSid *sid,
uid_t *puid)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcSidToUid(const struct wbcDomainSid *sid, uid_t *puid)
{
return wbcCtxSidToUid(NULL, sid, puid);
}
/* Convert a Windows SID to a Unix uid if there already is a mapping */
+_PUBLIC_
wbcErr wbcQuerySidToUid(const struct wbcDomainSid *sid,
uid_t *puid)
{
}
/* Convert a Unix uid to a Windows SID, allocating a SID if needed */
+_PUBLIC_
wbcErr wbcCtxUidToSid(struct wbcContext *ctx, uid_t uid,
struct wbcDomainSid *psid)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcUidToSid(uid_t uid, struct wbcDomainSid *sid)
{
return wbcCtxUidToSid(NULL, uid, sid);
}
/* Convert a Unix uid to a Windows SID if there already is a mapping */
+_PUBLIC_
wbcErr wbcQueryUidToSid(uid_t uid,
struct wbcDomainSid *sid)
{
*
**/
+_PUBLIC_
wbcErr wbcCtxSidToGid(struct wbcContext *ctx, const struct wbcDomainSid *sid,
gid_t *pgid)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcSidToGid(const struct wbcDomainSid *sid, gid_t *pgid)
{
return wbcCtxSidToGid(NULL, sid, pgid);
/* Convert a Windows SID to a Unix gid if there already is a mapping */
+_PUBLIC_
wbcErr wbcQuerySidToGid(const struct wbcDomainSid *sid,
gid_t *pgid)
{
/* Convert a Unix gid to a Windows SID, allocating a SID if needed */
+_PUBLIC_
wbcErr wbcCtxGidToSid(struct wbcContext *ctx, gid_t gid,
struct wbcDomainSid *psid)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGidToSid(gid_t gid, struct wbcDomainSid *sid)
{
return wbcCtxGidToSid(NULL, gid, sid);
}
/* Convert a Unix gid to a Windows SID if there already is a mapping */
+_PUBLIC_
wbcErr wbcQueryGidToSid(gid_t gid,
struct wbcDomainSid *sid)
{
}
/* Obtain a new uid from Winbind */
+_PUBLIC_
wbcErr wbcCtxAllocateUid(struct wbcContext *ctx, uid_t *puid)
{
struct winbindd_request request;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcAllocateUid(uid_t *puid)
{
return wbcCtxAllocateUid(NULL, puid);
}
/* Obtain a new gid from Winbind */
+_PUBLIC_
wbcErr wbcCtxAllocateGid(struct wbcContext *ctx, gid_t *pgid)
{
struct winbindd_request request;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcAllocateGid(gid_t *pgid)
{
return wbcCtxAllocateGid(NULL, pgid);
#define _ID_TYPE_GID 2
/* Set an user id mapping - not implemented any more */
+_PUBLIC_
wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid)
{
return WBC_ERR_NOT_IMPLEMENTED;
}
/* Set a group id mapping - not implemented any more */
+_PUBLIC_
wbcErr wbcSetGidMapping(gid_t gid, const struct wbcDomainSid *sid)
{
return WBC_ERR_NOT_IMPLEMENTED;
}
/* Remove a user id mapping - not implemented any more */
+_PUBLIC_
wbcErr wbcRemoveUidMapping(uid_t uid, const struct wbcDomainSid *sid)
{
return WBC_ERR_NOT_IMPLEMENTED;
}
/* Remove a group id mapping - not implemented any more */
+_PUBLIC_
wbcErr wbcRemoveGidMapping(gid_t gid, const struct wbcDomainSid *sid)
{
return WBC_ERR_NOT_IMPLEMENTED;
}
/* Set the highwater mark for allocated uids - not implemented any more */
+_PUBLIC_
wbcErr wbcSetUidHwm(uid_t uid_hwm)
{
return WBC_ERR_NOT_IMPLEMENTED;
}
/* Set the highwater mark for allocated gids - not implemented any more */
+_PUBLIC_
wbcErr wbcSetGidHwm(gid_t gid_hwm)
{
return WBC_ERR_NOT_IMPLEMENTED;
}
/* Convert a list of SIDs */
+_PUBLIC_
wbcErr wbcCtxSidsToUnixIds(struct wbcContext *ctx,
const struct wbcDomainSid *sids,
uint32_t num_sids, struct wbcUnixId *ids)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcSidsToUnixIds(const struct wbcDomainSid *sids, uint32_t num_sids,
struct wbcUnixId *ids)
{
return wbcCtxSidsToUnixIds(NULL, sids, num_sids, ids);
}
+_PUBLIC_
wbcErr wbcCtxUnixIdsToSids(struct wbcContext *ctx,
const struct wbcUnixId *ids, uint32_t num_ids,
struct wbcDomainSid *sids)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcUnixIdsToSids(const struct wbcUnixId *ids, uint32_t num_ids,
struct wbcDomainSid *sids)
{
#include "../winbind_client.h"
/* Authenticate a username/password pair */
+_PUBLIC_
wbcErr wbcCtxAuthenticateUser(struct wbcContext *ctx,
const char *username, const char *password)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcAuthenticateUser(const char *username, const char *password)
{
return wbcCtxAuthenticateUser(NULL, username, password);
/* Authenticate with more detailed information */
+_PUBLIC_
wbcErr wbcCtxAuthenticateUserEx(struct wbcContext *ctx,
const struct wbcAuthUserParams *params,
struct wbcAuthUserInfo **info,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcAuthenticateUserEx(const struct wbcAuthUserParams *params,
struct wbcAuthUserInfo **info,
struct wbcAuthErrorInfo **error)
}
/* Trigger a verification of the trust credentials of a specific domain */
+_PUBLIC_
wbcErr wbcCtxCheckTrustCredentials(struct wbcContext *ctx, const char *domain,
struct wbcAuthErrorInfo **error)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcCheckTrustCredentials(const char *domain,
struct wbcAuthErrorInfo **error)
{
}
/* Trigger a change of the trust credentials for a specific domain */
+_PUBLIC_
wbcErr wbcCtxChangeTrustCredentials(struct wbcContext *ctx, const char *domain,
struct wbcAuthErrorInfo **error)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcChangeTrustCredentials(const char *domain,
struct wbcAuthErrorInfo **error)
{
* Trigger a no-op NETLOGON call. Lightweight version of
* wbcCheckTrustCredentials
*/
+_PUBLIC_
wbcErr wbcCtxPingDc(struct wbcContext *ctx, const char *domain,
struct wbcAuthErrorInfo **error)
{
return wbcCtxPingDc2(ctx, domain, error, NULL);
}
+_PUBLIC_
wbcErr wbcPingDc(const char *domain, struct wbcAuthErrorInfo **error)
{
return wbcPingDc2(domain, error, NULL);
* Trigger a no-op NETLOGON call. Lightweight version of
* wbcCheckTrustCredentials, optionally return attempted DC
*/
+_PUBLIC_
wbcErr wbcCtxPingDc2(struct wbcContext *ctx, const char *domain,
struct wbcAuthErrorInfo **error, char **dcname)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcPingDc2(const char *domain, struct wbcAuthErrorInfo **error,
char **dcname)
{
}
/* Trigger an extended logoff notification to Winbind for a specific user */
+_PUBLIC_
wbcErr wbcCtxLogoffUserEx(struct wbcContext *ctx,
const struct wbcLogoffUserParams *params,
struct wbcAuthErrorInfo **error)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLogoffUserEx(const struct wbcLogoffUserParams *params,
struct wbcAuthErrorInfo **error)
{
}
/* Trigger a logoff notification to Winbind for a specific user */
+_PUBLIC_
wbcErr wbcCtxLogoffUser(struct wbcContext *ctx,
const char *username, uid_t uid,
const char *ccfilename)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLogoffUser(const char *username,
uid_t uid,
const char *ccfilename)
}
/* Change a password for a user with more detailed information upon failure */
+_PUBLIC_
wbcErr wbcCtxChangeUserPasswordEx(struct wbcContext *ctx,
const struct wbcChangePasswordParams *params,
struct wbcAuthErrorInfo **error,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcChangeUserPasswordEx(const struct wbcChangePasswordParams *params,
struct wbcAuthErrorInfo **error,
enum wbcPasswordChangeRejectReason *reject_reason,
}
/* Change a password for a user */
+_PUBLIC_
wbcErr wbcCtxChangeUserPassword(struct wbcContext *ctx,
const char *username,
const char *old_password,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcChangeUserPassword(const char *username,
const char *old_password,
const char *new_password)
}
/* Logon a User */
+_PUBLIC_
wbcErr wbcCtxLogonUser(struct wbcContext *ctx,
const struct wbcLogonUserParams *params,
struct wbcLogonUserInfo **info,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLogonUser(const struct wbcLogonUserParams *params,
struct wbcLogonUserInfo **info,
struct wbcAuthErrorInfo **error,
}
/* Authenticate a user with cached credentials */
+_PUBLIC_
wbcErr wbcCtxCredentialCache(struct wbcContext *ctx,
struct wbcCredentialCacheParams *params,
struct wbcCredentialCacheInfo **info,
return status;
}
+_PUBLIC_
wbcErr wbcCredentialCache(struct wbcCredentialCacheParams *params,
struct wbcCredentialCacheInfo **info,
struct wbcAuthErrorInfo **error)
}
/* Authenticate a user with cached credentials */
+_PUBLIC_
wbcErr wbcCtxCredentialSave(struct wbcContext *ctx,
const char *user, const char *password)
{
return wbcRequestResponse(ctx, WINBINDD_CCACHE_SAVE, &request, &response);
}
+_PUBLIC_
wbcErr wbcCredentialSave(const char *user, const char *password)
{
return wbcCtxCredentialSave(NULL, user, password);
}
/* Fill in a struct passwd* for a domain user based on username */
+_PUBLIC_
wbcErr wbcCtxGetpwnam(struct wbcContext *ctx,
const char *name, struct passwd **pwd)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetpwnam(const char *name, struct passwd **pwd)
{
return wbcCtxGetpwnam(NULL, name, pwd);
}
/* Fill in a struct passwd* for a domain user based on uid */
+_PUBLIC_
wbcErr wbcCtxGetpwuid(struct wbcContext *ctx, uid_t uid, struct passwd **pwd)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetpwuid(uid_t uid, struct passwd **pwd)
{
return wbcCtxGetpwuid(NULL, uid, pwd);
}
/* Fill in a struct passwd* for a domain user based on sid */
+_PUBLIC_
wbcErr wbcCtxGetpwsid(struct wbcContext *ctx,
struct wbcDomainSid *sid, struct passwd **pwd)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetpwsid(struct wbcDomainSid *sid, struct passwd **pwd)
{
return wbcCtxGetpwsid(NULL, sid, pwd);
}
/* Fill in a struct passwd* for a domain user based on username */
+_PUBLIC_
wbcErr wbcCtxGetgrnam(struct wbcContext *ctx,
const char *name, struct group **grp)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetgrnam(const char *name, struct group **grp)
{
return wbcCtxGetgrnam(NULL, name, grp);
}
/* Fill in a struct passwd* for a domain user based on uid */
+_PUBLIC_
wbcErr wbcCtxGetgrgid(struct wbcContext *ctx, gid_t gid, struct group **grp)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetgrgid(gid_t gid, struct group **grp)
{
return wbcCtxGetgrgid(NULL, gid, grp);
static struct winbindd_response pw_response;
/* Reset the passwd iterator */
+_PUBLIC_
wbcErr wbcCtxSetpwent(struct wbcContext *ctx)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcSetpwent(void)
{
return wbcCtxSetpwent(NULL);
}
/* Close the passwd iterator */
+_PUBLIC_
wbcErr wbcCtxEndpwent(struct wbcContext *ctx)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcEndpwent(void)
{
return wbcCtxEndpwent(NULL);
}
/* Return the next struct passwd* entry from the pwent iterator */
+_PUBLIC_
wbcErr wbcCtxGetpwent(struct wbcContext *ctx, struct passwd **pwd)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetpwent(struct passwd **pwd)
{
return wbcCtxGetpwent(NULL, pwd);
static struct winbindd_response gr_response;
/* Reset the group iterator */
+_PUBLIC_
wbcErr wbcCtxSetgrent(struct wbcContext *ctx)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcSetgrent(void)
{
return wbcCtxSetgrent(NULL);
}
/* Close the group iterator */
+_PUBLIC_
wbcErr wbcCtxEndgrent(struct wbcContext *ctx)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcEndgrent(void)
{
return wbcCtxEndgrent(NULL);
}
/* Return the next struct group* entry from the pwent iterator */
+_PUBLIC_
wbcErr wbcCtxGetgrent(struct wbcContext *ctx, struct group **grp)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetgrent(struct group **grp)
{
return wbcCtxGetgrent(NULL, grp);
}
/* Return the next struct group* entry from the pwent iterator */
+_PUBLIC_
wbcErr wbcCtxGetgrlist(struct wbcContext *ctx, struct group **grp)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetgrlist(struct group **grp)
{
return wbcCtxGetgrlist(NULL, grp);
}
/* Return the unix group array belonging to the given user */
+_PUBLIC_
wbcErr wbcCtxGetGroups(struct wbcContext *ctx, const char *account,
uint32_t *num_groups, gid_t **_groups)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetGroups(const char *account, uint32_t *num_groups, gid_t **_groups)
{
return wbcCtxGetGroups(NULL, account, num_groups, _groups);
/* Convert a sid to a string into a buffer. Return the string
* length. If buflen is too small, return the string length that would
* result if it was long enough. */
+_PUBLIC_
int wbcSidToStringBuf(const struct wbcDomainSid *sid, char *buf, int buflen)
{
uint64_t id_auth;
}
/* Convert a binary SID to a character string */
+_PUBLIC_
wbcErr wbcSidToString(const struct wbcDomainSid *sid,
char **sid_string)
{
#define AUTHORITY_MASK (~(0xffffffffffffULL))
/* Convert a character string to a binary SID */
+_PUBLIC_
wbcErr wbcStringToSid(const char *str,
struct wbcDomainSid *sid)
{
/* Convert a domain and name to SID */
+_PUBLIC_
wbcErr wbcCtxLookupName(struct wbcContext *ctx,
const char *domain,
const char *name,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupName(const char *domain,
const char *name,
struct wbcDomainSid *sid,
/* Convert a SID to a domain and name */
+_PUBLIC_
wbcErr wbcCtxLookupSid(struct wbcContext *ctx,
const struct wbcDomainSid *sid,
char **pdomain,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
char **pdomain,
char **pname,
}
}
+_PUBLIC_
wbcErr wbcCtxLookupSids(struct wbcContext *ctx,
const struct wbcDomainSid *sids, int num_sids,
struct wbcDomainInfo **pdomains, int *pnum_domains,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
struct wbcDomainInfo **pdomains, int *pnum_domains,
struct wbcTranslatedName **pnames)
/* Translate a collection of RIDs within a domain to names */
+_PUBLIC_
wbcErr wbcCtxLookupRids(struct wbcContext *ctx, struct wbcDomainSid *dom_sid,
int num_rids,
uint32_t *rids,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupRids(struct wbcDomainSid *dom_sid,
int num_rids,
uint32_t *rids,
}
/* Get the groups a user belongs to */
+_PUBLIC_
wbcErr wbcCtxLookupUserSids(struct wbcContext *ctx,
const struct wbcDomainSid *user_sid,
bool domain_groups_only,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupUserSids(const struct wbcDomainSid *user_sid,
bool domain_groups_only,
uint32_t *num_sids,
}
/* Get alias membership for sids */
+_PUBLIC_
wbcErr wbcCtxGetSidAliases(struct wbcContext *ctx,
const struct wbcDomainSid *dom_sid,
struct wbcDomainSid *sids,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetSidAliases(const struct wbcDomainSid *dom_sid,
struct wbcDomainSid *sids,
uint32_t num_sids,
/* Lists Users */
+_PUBLIC_
wbcErr wbcCtxListUsers(struct wbcContext *ctx,
const char *domain_name,
uint32_t *_num_users,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcListUsers(const char *domain_name,
uint32_t *_num_users,
const char ***_users)
}
/* Lists Groups */
+_PUBLIC_
wbcErr wbcCtxListGroups(struct wbcContext *ctx,
const char *domain_name,
uint32_t *_num_groups,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcListGroups(const char *domain_name,
uint32_t *_num_groups,
const char ***_groups)
return wbcCtxListGroups(NULL, domain_name, _num_groups, _groups);
}
+_PUBLIC_
wbcErr wbcCtxGetDisplayName(struct wbcContext *ctx,
const struct wbcDomainSid *sid,
char **pdomain,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcGetDisplayName(const struct wbcDomainSid *sid,
char **pdomain,
char **pfullname,
return wbcCtxGetDisplayName(NULL, sid, pdomain, pfullname, pname_type);
}
+_PUBLIC_
const char* wbcSidTypeString(enum wbcSidType type)
{
switch (type) {
*
* @return #wbcErr
**/
+_PUBLIC_
wbcErr wbcCtxPing(struct wbcContext *ctx)
{
struct winbindd_request request;
return wbcRequestResponse(ctx, WINBINDD_PING, &request, &response);
}
+_PUBLIC_
wbcErr wbcPing(void)
{
return wbcCtxPing(NULL);
* @return #wbcErr
*/
+_PUBLIC_
wbcErr wbcCtxInterfaceDetails(struct wbcContext *ctx,
struct wbcInterfaceDetails **_details)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcInterfaceDetails(struct wbcInterfaceDetails **_details)
{
return wbcCtxInterfaceDetails(NULL, _details);
* @return #wbcErr
*/
+_PUBLIC_
wbcErr wbcCtxDomainInfo(struct wbcContext *ctx,
const char *domain,
struct wbcDomainInfo **dinfo)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcDomainInfo(const char *domain, struct wbcDomainInfo **dinfo)
{
return wbcCtxDomainInfo(NULL, domain, dinfo);
}
/* Get the list of current DCs */
+_PUBLIC_
wbcErr wbcCtxDcInfo(struct wbcContext *ctx,
const char *domain, size_t *num_dcs,
const char ***dc_names, const char ***dc_ips)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcDcInfo(const char *domain, size_t *num_dcs,
const char ***dc_names, const char ***dc_ips)
{
}
/* Resolve a NetbiosName via WINS */
+_PUBLIC_
wbcErr wbcCtxResolveWinsByName(struct wbcContext *ctx,
const char *name, char **ip)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcResolveWinsByName(const char *name, char **ip)
{
return wbcCtxResolveWinsByName(NULL, name, ip);
}
/* Resolve an IP address via WINS into a NetbiosName */
+_PUBLIC_
wbcErr wbcCtxResolveWinsByIP(struct wbcContext *ctx,
const char *ip, char **name)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcResolveWinsByIP(const char *ip, char **name)
{
return wbcCtxResolveWinsByIP(NULL, ip, name);
}
/* Enumerate the domain trusts known by Winbind */
+_PUBLIC_
wbcErr wbcCtxListTrusts(struct wbcContext *ctx,
struct wbcDomainInfo **domains, size_t *num_domains)
{
return wbc_status;
}
+_PUBLIC_
wbcErr wbcListTrusts(struct wbcDomainInfo **domains, size_t *num_domains)
{
return wbcCtxListTrusts(NULL, domains, num_domains);
}
/* Enumerate the domain trusts known by Winbind */
+_PUBLIC_
wbcErr wbcCtxLookupDomainController(struct wbcContext *ctx,
const char *domain, uint32_t flags,
struct wbcDomainControllerInfo **dc_info)
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupDomainController(const char *domain, uint32_t flags,
struct wbcDomainControllerInfo **dc_info)
{
}
/* Get extended domain controller information */
+_PUBLIC_
wbcErr wbcCtxLookupDomainControllerEx(struct wbcContext *ctx,
const char *domain,
struct wbcGuid *guid,
return wbc_status;
}
+_PUBLIC_
wbcErr wbcLookupDomainControllerEx(const char *domain,
struct wbcGuid *guid,
const char *site,
}
/* Initialize a named blob and add to list of blobs */
+_PUBLIC_
wbcErr wbcAddNamedBlob(size_t *num_blobs,
struct wbcNamedBlob **pblobs,
const char *name,
return wbc_status;
}
+_PUBLIC_
void wbcSetClientProcessName(const char *name)
{
winbind_set_client_name(name);
*
* @return #wbcErr
*/
+_PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
wbcErr wbcRequestResponse(struct wbcContext *ctx, int cmd,
struct winbindd_request *request,
struct winbindd_response *response)
winbindd_request_response);
}
+_PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
wbcErr wbcRequestResponsePriv(struct wbcContext *ctx, int cmd,
struct winbindd_request *request,
struct winbindd_response *response)
*
* @return a pointer to a static string
**/
+_PUBLIC_
const char *wbcErrorString(wbcErr error)
{
switch (error) {
return (struct wbcMemPrefix *)(((char *)ptr) - wbcPrefixLen());
}
+_PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
void *wbcAllocateMemory(size_t nelem, size_t elsize,
void (*destructor)(void *ptr))
{
}
/* Free library allocated memory */
+_PUBLIC_
void wbcFreeMemory(void *p)
{
struct wbcMemPrefix *wbcMem;
return;
}
+_PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
char *wbcStrDup(const char *str)
{
char *result;
}
}
+_PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
const char **wbcAllocateStringArray(int num_strings)
{
return (const char **)wbcAllocateMemory(
wbcStringArrayDestructor);
}
+_PUBLIC_
wbcErr wbcLibraryDetails(struct wbcLibraryDetails **_details)
{
struct wbcLibraryDetails *info;
winbindd_ctx_free(ctx->winbindd_ctx);
}
+_PUBLIC_
struct wbcContext *wbcCtxCreate(void)
{
struct wbcContext *ctx;
return ctx;
}
+_PUBLIC_
void wbcCtxFree(struct wbcContext *ctx)
{
wbcFreeMemory(ctx);
}
+_PUBLIC_ /* this is internal to wbclient_internal.h, but part of the ABI */
struct wbcContext *wbcGetGlobalCtx(void)
{
return &wbcGlobalCtx;
wbc_pwd.c
wbc_sid.c
wbc_util.c''',
+ hide_symbols=True,
deps='winbind-client smb_strtox',
pc_files='wbclient.pc',
public_headers='wbclient.h',
git.samba.org / samba.git / commitdiff