return vfswrap_lseek(NULL, fsp, filedes, offset, whence);
}
-static int skel_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
+static int skel_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
{
- return vfswrap_rename(NULL, conn, old, new);
+ return vfswrap_rename(NULL, conn, oldname, newname);
}
static int skel_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
return SMB_VFS_NEXT_LSEEK(handle, fsp, filedes, offset, whence);
}
-static int skel_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
+static int skel_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
{
- return SMB_VFS_NEXT_RENAME(handle, conn, old, new);
+ return SMB_VFS_NEXT_RENAME(handle, conn, oldname, newname);
}
static int skel_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
/* we are contacting the privileged pipe */
become_root();
- result = winbindd_request(WINBINDD_PAM_AUTH_CRAP, &request, &response);
+ result = winbindd_request_response(WINBINDD_PAM_AUTH_CRAP, &request, &response);
unbecome_root();
if ( result == NSS_STATUS_UNAVAIL ) {
#include "config.h"
#endif
+#ifndef __cplusplus
+#define class #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define private #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define public #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define template #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define this #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define new #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define delete #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#define friend #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
+#endif
+
#include "local.h"
#ifdef AIX
#define PRINTF_ATTRIBUTE(a1, a2)
#endif
-#ifdef __GNUC__
+#if defined(__GNUC__) && !defined(__cplusplus)
/** gcc attribute used on function parameters so that it does not emit
* warnings about them being unused. **/
# define UNUSED(param) param __attribute__ ((unused))
uint32 reserved2;
uint32 panningwidth;
uint32 panningheight;
- uint8 *private;
+ uint8 *nt_dev_private;
} NT_DEVICEMODE;
typedef struct nt_printer_info_level_2
const struct pdb_methods *backend_private_methods;
void *backend_private_data;
void (*backend_private_data_free_fn)(void **);
- } private;
+ } private_u;
/* Lets see if the remaining code can get the hint that you
are meant to use the pdb_...() functions. */
uint32 mem_num; /* Number of member SIDs */
DOM_SID *members; /* SID array */
- } private;
+ } private_g;
} SAM_GROUP;
uint32 num_entries;
ssize_t cache_size;
BOOL search_ended;
- void *private;
+ void *private_data;
BOOL (*next_entry)(struct pdb_search *search,
struct samr_displayentry *entry);
void (*search_end)(struct pdb_search *search);
typedef struct {
POLICY_HND handle;
UNISTR4 name;
- UNISTR4 class;
+ UNISTR4 key_class;
uint32 reserved;
uint32 access;
uint32 *sec_info;
typedef struct {
POLICY_HND pol;
- UNISTR4 class;
+ UNISTR4 key_class;
} REG_Q_QUERY_KEY;
typedef struct {
- UNISTR4 class;
+ UNISTR4 key_class;
uint32 num_subkeys;
uint32 max_subkeylen;
uint32 reserved; /* 0x0000 0000 - according to MSDN (max_subkeysize?) */
uint32 reserved2;
uint32 panningwidth;
uint32 panningheight;
- uint8 *private;
+ uint8 *dev_private;
}
DEVICEMODE;
#include "sysquotas.h"
/* used to hold an arbitrary blob of data */
-typedef struct data_blob
-{
+typedef struct data_blob_ {
uint8 *data;
size_t length;
- void (*free)(struct data_blob *data_blob);
+ void (*free)(struct data_blob_ *data_blob);
} DATA_BLOB;
/*
{
const char *label;
parm_type type;
- parm_class class;
+ parm_class p_class;
void *ptr;
BOOL (*special)(int snum, const char *, char **);
const struct enum_list *enum_list;
unsigned int name_type;
};
-
/* A netbios node status array element. */
-struct node_status {
+typedef struct node_status_ {
nstring name;
unsigned char type;
unsigned char flags;
-};
+} NODE_STATUS_STRUCT;
/* The extra info from a NetBIOS node status query */
struct node_status_extra {
} negResult_t;
typedef struct spnego_negTokenInit {
- const char **mechTypes;
+ char **mechTypes;
int reqFlags;
DATA_BLOB mechToken;
DATA_BLOB mechListMIC;
typedef struct spnego_negTokenTarg {
uint8 negResult;
- const char *supportedMech;
+ char *supportedMech;
DATA_BLOB responseToken;
DATA_BLOB mechListMIC;
} negTokenTarg_t;
ssize_t (*pwrite)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, const void *data, size_t n, SMB_OFF_T offset);
SMB_OFF_T (*lseek)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_OFF_T offset, int whence);
ssize_t (*sendfile)(struct vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
- int (*rename)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *old, const char *new);
+ int (*rename)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *oldname, const char *newname);
int (*fsync)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd);
int (*stat)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf);
int (*fstat)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf);
construct a data blob, must be freed with data_blob_free()
you can pass NULL for p and get a blank data blob
*******************************************************************/
+
DATA_BLOB data_blob(const void *p, size_t length)
{
DATA_BLOB ret;
adds new SID with its permissions to ACE list
********************************************************************/
-NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, SEC_ACE **new, SEC_ACE *old, unsigned *num, DOM_SID *sid, uint32 mask)
+NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, SEC_ACE **pp_new, SEC_ACE *old, unsigned *num, DOM_SID *sid, uint32 mask)
{
unsigned int i = 0;
- if (!ctx || !new || !old || !sid || !num) return NT_STATUS_INVALID_PARAMETER;
+ if (!ctx || !pp_new || !old || !sid || !num) return NT_STATUS_INVALID_PARAMETER;
*num += 1;
- if((new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
+ if((pp_new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
return NT_STATUS_NO_MEMORY;
for (i = 0; i < *num - 1; i ++)
- sec_ace_copy(&(*new)[i], &old[i]);
+ sec_ace_copy(&(*pp_new)[i], &old[i]);
- (*new)[i].type = 0;
- (*new)[i].flags = 0;
- (*new)[i].size = SEC_ACE_HEADER_SIZE + sid_size(sid);
- (*new)[i].info.mask = mask;
- sid_copy(&(*new)[i].trustee, sid);
+ (*pp_new)[i].type = 0;
+ (*pp_new)[i].flags = 0;
+ (*pp_new)[i].size = SEC_ACE_HEADER_SIZE + sid_size(sid);
+ (*pp_new)[i].info.mask = mask;
+ sid_copy(&(*pp_new)[i].trustee, sid);
return NT_STATUS_OK;
}
delete SID from ACL
********************************************************************/
-NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, SEC_ACE **new, SEC_ACE *old, uint32 *num, DOM_SID *sid)
+NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, SEC_ACE **pp_new, SEC_ACE *old, uint32 *num, DOM_SID *sid)
{
unsigned int i = 0;
unsigned int n_del = 0;
- if (!ctx || !new || !old || !sid || !num) return NT_STATUS_INVALID_PARAMETER;
+ if (!ctx || !pp_new || !old || !sid || !num) return NT_STATUS_INVALID_PARAMETER;
- if((new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
+ if((pp_new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
return NT_STATUS_NO_MEMORY;
for (i = 0; i < *num; i ++) {
if (sid_compare(&old[i].trustee, sid) != 0)
- sec_ace_copy(&(*new)[i], &old[i]);
+ sec_ace_copy(&(*pp_new)[i], &old[i]);
else
n_del ++;
}
Possibly replace mkstemp if it is broken.
*****************************************************************/
-int smb_mkstemp(char *template)
+int smb_mkstemp(char *name_template)
{
#if HAVE_SECURE_MKSTEMP
- return mkstemp(template);
+ return mkstemp(name_template);
#else
/* have a reasonable go at emulating it. Hope that
the system mktemp() isn't completly hopeless */
- char *p = mktemp(template);
+ char *p = mktemp(name_template);
if (!p)
return -1;
return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
int flgs2 = SVAL(cli->inbuf,smb_flg2);
if (!(flgs2 & FLAGS2_32_BIT_ERROR_CODES)) {
- int class = CVAL(cli->inbuf,smb_rcls);
+ int e_class = CVAL(cli->inbuf,smb_rcls);
int code = SVAL(cli->inbuf,smb_err);
- return dos_to_ntstatus(class, code);
+ return dos_to_ntstatus(e_class, code);
}
return NT_STATUS(IVAL(cli->inbuf,smb_rcls));
* Add a new connection to the server cache.
* This function is only used if the external cache is not enabled
*/
-static int smbc_add_cached_server(SMBCCTX * context, SMBCSRV * new,
+static int smbc_add_cached_server(SMBCCTX * context, SMBCSRV * newsrv,
const char * server, const char * share,
const char * workgroup, const char * username)
{
ZERO_STRUCTP(srvcache);
- srvcache->server = new;
+ srvcache->server = newsrv;
srvcache->server_name = SMB_STRDUP(server);
if (!srvcache->server_name) {
/* add an ACE to a list of ACEs in a SEC_ACL */
static BOOL add_ace(SEC_ACL **the_acl, SEC_ACE *ace, TALLOC_CTX *ctx)
{
- SEC_ACL *new;
+ SEC_ACL *newacl;
SEC_ACE *aces;
if (! *the_acl) {
(*the_acl) = make_sec_acl(ctx, 3, 1, ace);
aces = SMB_CALLOC_ARRAY(SEC_ACE, 1+(*the_acl)->num_aces);
memcpy(aces, (*the_acl)->ace, (*the_acl)->num_aces * sizeof(SEC_ACE));
memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
- new = make_sec_acl(ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
+ newacl = make_sec_acl(ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
SAFE_FREE(aces);
- (*the_acl) = new;
+ (*the_acl) = newacl;
return True;
}
Parse a node status response into an array of structures.
****************************************************************************/
-static struct node_status *parse_node_status(char *p, int *num_names, struct node_status_extra *extra)
+static NODE_STATUS_STRUCT *parse_node_status(char *p, int *num_names, struct node_status_extra *extra)
{
- struct node_status *ret;
+ NODE_STATUS_STRUCT *ret;
int i;
*num_names = CVAL(p,0);
if (*num_names == 0)
return NULL;
- ret = SMB_MALLOC_ARRAY(struct node_status,*num_names);
+ ret = SMB_MALLOC_ARRAY(NODE_STATUS_STRUCT,*num_names);
if (!ret)
return NULL;
structures holding the returned names or NULL if the query failed.
**************************************************************************/
-struct node_status *node_status_query(int fd,struct nmb_name *name,
+NODE_STATUS_STRUCT *node_status_query(int fd,struct nmb_name *name,
struct in_addr to_ip, int *num_names,
struct node_status_extra *extra)
{
struct packet_struct p;
struct packet_struct *p2;
struct nmb_packet *nmb = &p.packet.nmb;
- struct node_status *ret;
+ NODE_STATUS_STRUCT *ret;
ZERO_STRUCT(p);
BOOL name_status_find(const char *q_name, int q_type, int type, struct in_addr to_ip, fstring name)
{
- struct node_status *status = NULL;
+ NODE_STATUS_STRUCT *status = NULL;
struct nmb_name nname;
int count, i;
int sock;
const struct
{
int code;
- const char *class;
+ const char *e_class;
err_code_struct *err_msgs;
} err_classes[] = {
{0,"SUCCESS",NULL},
/****************************************************************************
return a SMB error name from a class and code
****************************************************************************/
-const char *smb_dos_err_name(uint8 class, uint16 num)
+const char *smb_dos_err_name(uint8 e_class, uint16 num)
{
static pstring ret;
int i,j;
- for (i=0;err_classes[i].class;i++)
- if (err_classes[i].code == class) {
+ for (i=0;err_classes[i].e_class;i++)
+ if (err_classes[i].code == e_class) {
if (err_classes[i].err_msgs) {
err_code_struct *err = err_classes[i].err_msgs;
for (j=0;err[j].name;j++)
return ret;
}
- slprintf(ret, sizeof(ret) - 1, "Error: Unknown error class (%d,%d)",class,num);
+ slprintf(ret, sizeof(ret) - 1, "Error: Unknown error class (%d,%d)",e_class,num);
return(ret);
}
/****************************************************************************
return a SMB error class name as a string.
****************************************************************************/
-const char *smb_dos_err_class(uint8 class)
+const char *smb_dos_err_class(uint8 e_class)
{
static pstring ret;
int i;
- for (i=0;err_classes[i].class;i++) {
- if (err_classes[i].code == class) {
- return err_classes[i].class;
+ for (i=0;err_classes[i].e_class;i++) {
+ if (err_classes[i].code == e_class) {
+ return err_classes[i].e_class;
}
}
- slprintf(ret, sizeof(ret) - 1, "Error: Unknown class (%d)",class);
+ slprintf(ret, sizeof(ret) - 1, "Error: Unknown class (%d)",e_class);
return(ret);
}
char *smb_dos_errstr(char *inbuf)
{
static pstring ret;
- int class = CVAL(inbuf,smb_rcls);
+ int e_class = CVAL(inbuf,smb_rcls);
int num = SVAL(inbuf,smb_err);
int i,j;
- for (i=0;err_classes[i].class;i++)
- if (err_classes[i].code == class) {
+ for (i=0;err_classes[i].e_class;i++)
+ if (err_classes[i].code == e_class) {
if (err_classes[i].err_msgs) {
err_code_struct *err = err_classes[i].err_msgs;
for (j=0;err[j].name;j++)
if (num == err[j].code) {
if (DEBUGLEVEL > 0)
slprintf(ret, sizeof(ret) - 1, "%s - %s (%s)",
- err_classes[i].class,
+ err_classes[i].e_class,
err[j].name,err[j].message);
else
slprintf(ret, sizeof(ret) - 1, "%s - %s",
- err_classes[i].class,err[j].name);
+ err_classes[i].e_class,err[j].name);
return ret;
}
}
- slprintf(ret, sizeof(ret) - 1, "%s - %d",err_classes[i].class,num);
+ slprintf(ret, sizeof(ret) - 1, "%s - %d",err_classes[i].e_class,num);
return ret;
}
- slprintf(ret, sizeof(ret) - 1, "Error: Unknown error (%d,%d)",class,num);
+ slprintf(ret, sizeof(ret) - 1, "Error: Unknown error (%d,%d)",e_class,num);
return(ret);
}
0 < asn1_tag_remaining(asn1); i++) {
token->mechTypes =
SMB_REALLOC_ARRAY(token->mechTypes, char *, i + 2);
- asn1_read_OID(asn1, token->mechTypes + i);
+ asn1_read_OID(asn1, &token->mechTypes[i]);
}
token->mechTypes[i] = NULL;
static int audit_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path);
static int audit_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode);
static int audit_close(vfs_handle_struct *handle, files_struct *fsp, int fd);
-static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new);
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname);
static int audit_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path);
static int audit_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode);
static int audit_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode);
return result;
}
-static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
{
int result;
- result = SMB_VFS_NEXT_RENAME(handle, conn, old, new);
+ result = SMB_VFS_NEXT_RENAME(handle, conn, oldname, newname);
syslog(audit_syslog_priority(handle), "rename %s -> %s %s%s\n",
- old, new,
+ oldname, newname,
(result < 0) ? "failed: " : "",
(result < 0) ? strerror(errno) : "");
return SMB_VFS_NEXT_OPEN(handle, conn, capname, flags, mode);
}
-static int cap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
+static int cap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
{
pstring capold, capnew;
- capencode(capold, old);
- capencode(capnew, new);
+ capencode(capold, oldname);
+ capencode(capnew, newname);
return SMB_VFS_NEXT_RENAME(handle, conn, capold, capnew);
}
static int audit_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path);
static int audit_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode);
static int audit_close(vfs_handle_struct *handle, files_struct *fsp, int fd);
-static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new);
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname);
static int audit_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path);
static int audit_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode);
static int audit_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode);
return result;
}
-static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
{
int result;
- result = SMB_VFS_NEXT_RENAME(handle, conn, old, new);
+ result = SMB_VFS_NEXT_RENAME(handle, conn, oldname, newname);
syslog(audit_syslog_priority(handle), "rename %s -> %s %s%s\n",
- old, new,
+ oldname, newname,
(result < 0) ? "failed: " : "",
(result < 0) ? strerror(errno) : "");
- DEBUG(1, ("vfs_extd_audit: rename old: %s new: %s %s %s\n",
- old, new,
+ DEBUG(1, ("vfs_extd_audit: rename old: %s newname: %s %s %s\n",
+ oldname, newname,
(result < 0) ? "failed: " : "",
(result < 0) ? strerror(errno) : ""));
const DATA_BLOB *hdr, SMB_OFF_T offset,
size_t n);
static int smb_full_audit_rename(vfs_handle_struct *handle, connection_struct *conn,
- const char *old, const char *new);
+ const char *oldname, const char *newname);
static int smb_full_audit_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd);
static int smb_full_audit_stat(vfs_handle_struct *handle, connection_struct *conn,
const char *fname, SMB_STRUCT_STAT *sbuf);
}
static int smb_full_audit_rename(vfs_handle_struct *handle, connection_struct *conn,
- const char *old, const char *new)
+ const char *oldname, const char *newname)
{
int result;
- result = SMB_VFS_NEXT_RENAME(handle, conn, old, new);
+ result = SMB_VFS_NEXT_RENAME(handle, conn, oldname, newname);
- do_log(SMB_VFS_OP_RENAME, (result >= 0), handle, "%s|%s", old, new);
+ do_log(SMB_VFS_OP_RENAME, (result >= 0), handle, "%s|%s", oldname, newname);
return result;
}
/* File operations */
-static int atalk_rename(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *old, const char *new)
+static int atalk_rename(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *oldname, const char *newname)
{
int ret = 0;
char *adbl_path = 0;
SMB_STRUCT_STAT orig_info;
TALLOC_CTX *ctx;
- ret = SMB_VFS_NEXT_RENAME(handle, conn, old, new);
+ ret = SMB_VFS_NEXT_RENAME(handle, conn, oldname, newname);
- if (!conn || !old) return ret;
+ if (!conn || !oldname) return ret;
if (!(ctx = talloc_init("rename_file")))
return ret;
- if (atalk_build_paths(ctx, conn->origpath, old, &adbl_path, &orig_path,
+ if (atalk_build_paths(ctx, conn->origpath, oldname, &adbl_path, &orig_path,
&adbl_info, &orig_info) != 0)
return ret;
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
-NSS_STATUS winbindd_request(int req_type,
+NSS_STATUS winbindd_request_response(int req_type,
struct winbindd_request *request,
struct winbindd_response *response);
fstrcpy(request.data.name.dom_name, dom_name);
fstrcpy(request.data.name.name, name);
- if ((result = winbindd_request(WINBINDD_LOOKUPNAME, &request,
+ if ((result = winbindd_request_response(WINBINDD_LOOKUPNAME, &request,
&response)) == NSS_STATUS_SUCCESS) {
if (!string_to_sid(sid, response.data.sid.sid))
return False;
/* Make request */
- result = winbindd_request(WINBINDD_LOOKUPSID, &request, &response);
+ result = winbindd_request_response(WINBINDD_LOOKUPSID, &request, &response);
/* Copy out result */
/* Make request */
- result = winbindd_request(WINBINDD_SID_TO_UID, &request, &response);
+ result = winbindd_request_response(WINBINDD_SID_TO_UID, &request, &response);
/* Copy out result */
/* Make request */
- result = winbindd_request(WINBINDD_UID_TO_SID, &request, &response);
+ result = winbindd_request_response(WINBINDD_UID_TO_SID, &request, &response);
/* Copy out result */
/* Make request */
- result = winbindd_request(WINBINDD_SID_TO_GID, &request, &response);
+ result = winbindd_request_response(WINBINDD_SID_TO_GID, &request, &response);
/* Copy out result */
/* Make request */
- result = winbindd_request(WINBINDD_GID_TO_SID, &request, &response);
+ result = winbindd_request_response(WINBINDD_GID_TO_SID, &request, &response);
/* Copy out result */
/* Make request */
- result = winbindd_request(WINBINDD_ALLOCATE_RID, &request, &response);
+ result = winbindd_request_response(WINBINDD_ALLOCATE_RID, &request, &response);
if (result != NSS_STATUS_SUCCESS)
return False;
/* Make request */
- result = winbindd_request(WINBINDD_ALLOCATE_RID_AND_GID, &request,
+ result = winbindd_request_response(WINBINDD_ALLOCATE_RID_AND_GID, &request,
&response);
if (result != NSS_STATUS_SUCCESS)
ZERO_STRUCT(response);
- result = winbindd_request(WINBINDD_GETGROUPS, &request, &response);
+ result = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
if (result == NSS_STATUS_SUCCESS) {
{
NSS_STATUS result;
- result = winbindd_request(WINBINDD_PING, NULL, NULL);
+ result = winbindd_request_response(WINBINDD_PING, NULL, NULL);
return result == NSS_STATUS_SUCCESS;
}
fstrcpy(request.domain_name, domain);
- return winbindd_request(WINBINDD_DOMAIN_INFO, &request, &response);
+ return winbindd_request_response(WINBINDD_DOMAIN_INFO, &request, &response);
}
/* version-check the socket */
- if ((winbindd_request(WINBINDD_INTERFACE_VERSION, &request, &response) != NSS_STATUS_SUCCESS) || (response.data.interface_version != WINBIND_INTERFACE_VERSION)) {
+ if ((winbindd_request_response(WINBINDD_INTERFACE_VERSION, &request, &response) != NSS_STATUS_SUCCESS) || (response.data.interface_version != WINBIND_INTERFACE_VERSION)) {
close_sock();
return -1;
}
/* try and get priv pipe */
- if (winbindd_request(WINBINDD_PRIV_PIPE_DIR, &request, &response) == NSS_STATUS_SUCCESS) {
+ if (winbindd_request_response(WINBINDD_PRIV_PIPE_DIR, &request, &response) == NSS_STATUS_SUCCESS) {
int fd;
if ((fd = winbind_named_pipe_sock(response.extra_data)) != -1) {
close(winbindd_fd);
/* Handle simple types of requests */
-NSS_STATUS winbindd_request(int req_type,
+NSS_STATUS winbindd_request_response(int req_type,
struct winbindd_request *request,
struct winbindd_response *response)
{
/* Send off request */
- if (winbindd_request(WINBINDD_INFO, NULL, &response) !=
+ if (winbindd_request_response(WINBINDD_INFO, NULL, &response) !=
NSS_STATUS_SUCCESS) {
d_printf("could not obtain winbind separator!\n");
/* HACK: (this module should not call lp_ funtions) */
/* Send off request */
- if (winbindd_request(WINBINDD_DOMAIN_NAME, NULL, &response) !=
+ if (winbindd_request_response(WINBINDD_DOMAIN_NAME, NULL, &response) !=
NSS_STATUS_SUCCESS) {
d_printf("could not obtain winbind domain name!\n");
fstrcpy(request.data.username, user);
- result = winbindd_request(WINBINDD_GETGROUPS, &request, &response);
+ result = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
if (result != NSS_STATUS_SUCCESS)
return False;
/* Send request */
fstrcpy(request.data.sid, user_sid);
- result = winbindd_request(WINBINDD_GETUSERSIDS, &request, &response);
+ result = winbindd_request_response(WINBINDD_GETUSERSIDS, &request, &response);
if (result != NSS_STATUS_SUCCESS)
return False;
/* Send request */
fstrcpy(request.data.sid, user_sid);
- result = winbindd_request(WINBINDD_GETUSERDOMGROUPS, &request,
+ result = winbindd_request_response(WINBINDD_GETUSERDOMGROUPS, &request,
&response);
if (result != NSS_STATUS_SUCCESS)
fstrcpy(request.data.winsreq, name);
- if (winbindd_request(WINBINDD_WINS_BYNAME, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_WINS_BYNAME, &request, &response) !=
NSS_STATUS_SUCCESS) {
return False;
}
fstrcpy(request.data.winsreq, ip);
- if (winbindd_request(WINBINDD_WINS_BYIP, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_WINS_BYIP, &request, &response) !=
NSS_STATUS_SUCCESS) {
return False;
}
/* Send request */
- if (winbindd_request(WINBINDD_LIST_TRUSTDOM, NULL, &response) !=
+ if (winbindd_request_response(WINBINDD_LIST_TRUSTDOM, NULL, &response) !=
NSS_STATUS_SUCCESS)
return False;
/* Send request */
- if (winbindd_request(WINBINDD_SHOW_SEQUENCE, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_SHOW_SEQUENCE, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
/* Send request */
- if (winbindd_request(WINBINDD_DOMAIN_INFO, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_DOMAIN_INFO, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
/* Send request */
- if (winbindd_request(WINBINDD_GETDCNAME, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_GETDCNAME, &request, &response) !=
NSS_STATUS_SUCCESS) {
d_printf("Could not get dc name for %s\n", domain_name);
return False;
ZERO_STRUCT(response);
- result = winbindd_request(WINBINDD_CHECK_MACHACC, NULL, &response);
+ result = winbindd_request_response(WINBINDD_CHECK_MACHACC, NULL, &response);
d_printf("checking the trust secret via RPC calls %s\n",
(result == NSS_STATUS_SUCCESS) ? "succeeded" : "failed");
request.data.uid = uid;
- if (winbindd_request(WINBINDD_UID_TO_SID, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_UID_TO_SID, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
request.data.gid = gid;
- if (winbindd_request(WINBINDD_GID_TO_SID, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_GID_TO_SID, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
fstrcpy(request.data.sid, sid);
- if (winbindd_request(WINBINDD_SID_TO_UID, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_SID_TO_UID, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
fstrcpy(request.data.sid, sid);
- if (winbindd_request(WINBINDD_SID_TO_GID, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_SID_TO_GID, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
fstrcpy(request.data.sid, sid);
- if (winbindd_request(WINBINDD_LOOKUPSID, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_LOOKUPSID, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
parse_wbinfo_domain_user(name, request.data.name.dom_name,
request.data.name.name);
- if (winbindd_request(WINBINDD_LOOKUPNAME, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
} else
fstrcpy(request.data.auth.user, username);
- result = winbindd_request(WINBINDD_PAM_AUTH, &request, &response);
+ result = winbindd_request_response(WINBINDD_PAM_AUTH, &request, &response);
/* Display response */
request.data.auth_crap.nt_resp_len = 24;
}
- result = winbindd_request(WINBINDD_PAM_AUTH_CRAP, &request, &response);
+ result = winbindd_request_response(WINBINDD_PAM_AUTH_CRAP, &request, &response);
/* Display response */
request.flags |= WBFLAG_PAM_AFS_TOKEN;
- result = winbindd_request(WINBINDD_PAM_AUTH, &request, &response);
+ result = winbindd_request_response(WINBINDD_PAM_AUTH, &request, &response);
/* Display response */
fstrcpy( request.domain_name, domain );
}
- if (winbindd_request(WINBINDD_LIST_USERS, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_LIST_USERS, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
fstrcpy( request.domain_name, domain );
}
- if (winbindd_request(WINBINDD_LIST_GROUPS, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_LIST_GROUPS, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
{
NSS_STATUS result;
- result = winbindd_request(WINBINDD_PING, NULL, NULL);
+ result = winbindd_request_response(WINBINDD_PING, NULL, NULL);
/* Display response */
NSS_STATUS winbindd_send_request(int req_type,
struct winbindd_request *request);
NSS_STATUS winbindd_get_response(struct winbindd_response *response);
-NSS_STATUS winbindd_request(int req_type,
+NSS_STATUS winbindd_request_response(int req_type,
struct winbindd_request *request,
struct winbindd_response *response);
int winbind_open_pipe_sock(void);
free_response(&getpwent_response);
}
- return winbindd_request(WINBINDD_SETPWENT, NULL, NULL);
+ return winbindd_request_response(WINBINDD_SETPWENT, NULL, NULL);
}
/* Close ntdom password database "file pointer" */
free_response(&getpwent_response);
}
- return winbindd_request(WINBINDD_ENDPWENT, NULL, NULL);
+ return winbindd_request_response(WINBINDD_ENDPWENT, NULL, NULL);
}
/* Fetch the next password entry from ntdom password database */
request.data.num_entries = MAX_GETPWENT_USERS;
- ret = winbindd_request(WINBINDD_GETPWENT, &request,
+ ret = winbindd_request_response(WINBINDD_GETPWENT, &request,
&getpwent_response);
if (ret == NSS_STATUS_SUCCESS) {
request.data.uid = uid;
- ret = winbindd_request(WINBINDD_GETPWUID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GETPWUID, &request, &response);
if (ret == NSS_STATUS_SUCCESS) {
ret = fill_pwent(result, &response.data.pw,
request.data.username
[sizeof(request.data.username) - 1] = '\0';
- ret = winbindd_request(WINBINDD_GETPWNAM, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GETPWNAM, &request, &response);
if (ret == NSS_STATUS_SUCCESS) {
ret = fill_pwent(result, &response.data.pw, &buffer,
free_response(&getgrent_response);
}
- return winbindd_request(WINBINDD_SETGRENT, NULL, NULL);
+ return winbindd_request_response(WINBINDD_SETGRENT, NULL, NULL);
}
/* Close "file pointer" for ntdom group database */
free_response(&getgrent_response);
}
- return winbindd_request(WINBINDD_ENDGRENT, NULL, NULL);
+ return winbindd_request_response(WINBINDD_ENDGRENT, NULL, NULL);
}
/* Get next entry from ntdom group database */
request.data.num_entries = MAX_GETGRENT_USERS;
- ret = winbindd_request(cmd, &request,
+ ret = winbindd_request_response(cmd, &request,
&getgrent_response);
if (ret == NSS_STATUS_SUCCESS) {
request.data.groupname
[sizeof(request.data.groupname) - 1] = '\0';
- ret = winbindd_request(WINBINDD_GETGRNAM, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GETGRNAM, &request, &response);
if (ret == NSS_STATUS_SUCCESS) {
ret = fill_grent(result, &response.data.gr,
request.data.gid = gid;
- ret = winbindd_request(WINBINDD_GETGRGID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GETGRGID, &request, &response);
if (ret == NSS_STATUS_SUCCESS) {
strncpy(request.data.username, user,
sizeof(request.data.username) - 1);
- ret = winbindd_request(WINBINDD_GETGROUPS, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
if (ret == NSS_STATUS_SUCCESS) {
int num_gids = response.data.num_entries;
strncpy(request.data.sid, user_sid,sizeof(request.data.sid) - 1);
request.data.sid[sizeof(request.data.sid) - 1] = '\0';
- ret = winbindd_request(WINBINDD_GETUSERSIDS, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GETUSERSIDS, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
goto done;
sizeof(request.data.name.name) - 1);
request.data.name.name[sizeof(request.data.name.name) - 1] = '\0';
- ret = winbindd_request(WINBINDD_LOOKUPNAME, &request, &response);
+ ret = winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
/* we need to fetch the separator first time through */
if (!sep_char) {
- ret = winbindd_request(WINBINDD_INFO, &request, &response);
+ ret = winbindd_request_response(WINBINDD_INFO, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
sizeof(request.data.sid) - 1);
request.data.sid[sizeof(request.data.sid) - 1] = '\0';
- ret = winbindd_request(WINBINDD_LOOKUPSID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_LOOKUPSID, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
strncpy(request.data.sid, sid, sizeof(request.data.sid) - 1);
request.data.sid[sizeof(request.data.sid) - 1] = '\0';
- ret = winbindd_request(WINBINDD_SID_TO_UID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_SID_TO_UID, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
strncpy(request.data.sid, sid, sizeof(request.data.sid) - 1);
request.data.sid[sizeof(request.data.sid) - 1] = '\0';
- ret = winbindd_request(WINBINDD_SID_TO_GID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_SID_TO_GID, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
request.data.uid = uid;
- ret = winbindd_request(WINBINDD_UID_TO_SID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_UID_TO_SID, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
request.data.gid = gid;
- ret = winbindd_request(WINBINDD_GID_TO_SID, &request, &response);
+ ret = winbindd_request_response(WINBINDD_GID_TO_SID, &request, &response);
if (ret != NSS_STATUS_SUCCESS) {
*errnop = errno = EINVAL;
goto failed;
if (done <= 0) {
event->flags = 0;
- event->finished(event->private, False);
+ event->finished(event->private_data, False);
return;
}
}
if (done <= 0) {
event->flags = 0;
- event->finished(event->private, False);
+ event->finished(event->private_data, False);
return;
}
}
if (event->done == event->length) {
event->flags = 0;
- event->finished(event->private, True);
+ event->finished(event->private_data, True);
}
}
*/
void setup_async_read(struct fd_event *event, void *data, size_t length,
- void (*finished)(void *private, BOOL success),
- void *private)
+ void (*finished)(void *private_data, BOOL success),
+ void *private_data)
{
SMB_ASSERT(event->flags == 0);
event->data = data;
event->done = 0;
event->handler = rw_callback;
event->finished = finished;
- event->private = private;
+ event->private_data = private_data;
event->flags = EVENT_FD_READ;
}
void setup_async_write(struct fd_event *event, void *data, size_t length,
- void (*finished)(void *private, BOOL success),
- void *private)
+ void (*finished)(void *private_data, BOOL success),
+ void *private_data)
{
SMB_ASSERT(event->flags == 0);
event->data = data;
event->done = 0;
event->handler = rw_callback;
event->finished = finished;
- event->private = private;
+ event->private_data = private_data;
event->flags = EVENT_FD_WRITE;
}
* to call request_finished which schedules sending the response.
*/
-static void request_len_recv(void *private, BOOL success);
-static void request_recv(void *private, BOOL success);
+static void request_len_recv(void *private_data, BOOL success);
+static void request_recv(void *private_data, BOOL success);
static void request_finished(struct winbindd_cli_state *state);
-void request_finished_cont(void *private, BOOL success);
-static void response_main_sent(void *private, BOOL success);
-static void response_extra_sent(void *private, BOOL success);
+void request_finished_cont(void *private_data, BOOL success);
+static void response_main_sent(void *private_data, BOOL success);
+static void response_extra_sent(void *private_data, BOOL success);
-static void response_extra_sent(void *private, BOOL success)
+static void response_extra_sent(void *private_data, BOOL success)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (state->mem_ctx != NULL) {
talloc_destroy(state->mem_ctx);
request_len_recv, state);
}
-static void response_main_sent(void *private, BOOL success)
+static void response_main_sent(void *private_data, BOOL success)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
state->finished = True;
request_finished(state);
}
-void request_finished_cont(void *private, BOOL success)
+void request_finished_cont(void *private_data, BOOL success)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (success)
request_ok(state);
request_error(state);
}
-static void request_recv(void *private, BOOL success)
+static void request_recv(void *private_data, BOOL success)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
state->finished = True;
process_request(state);
}
-static void request_len_recv(void *private, BOOL success)
+static void request_len_recv(void *private_data, BOOL success)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
state->finished = True;
void (*handler)(struct fd_event *fde, int flags);
void *data;
size_t length, done;
- void (*finished)(void *private, BOOL success);
- void *private;
+ void (*finished)(void *private_data, BOOL success);
+ void *private_data;
};
struct winbindd_cli_state {
/* Private data for the backends (used for connection cache) */
- void *private;
+ void *private_data;
/* A working DC */
fstring dcname;
ADS_STRUCT *ads;
ADS_STATUS status;
- if (domain->private) {
- ads = (ADS_STRUCT *)domain->private;
+ if (domain->private_data) {
+ ads = (ADS_STRUCT *)domain->private_data;
/* check for a valid structure */
ads->is_mine = True;
ads_destroy( &ads );
ads_kdestroy("MEMORY:winbind_ccache");
- domain->private = NULL;
+ domain->private_data = NULL;
}
}
ads->is_mine = False;
- domain->private = (void *)ads;
+ domain->private_data = (void *)ads;
return ads;
}
through since ads_USN() has already done
that indirectly */
- domain->private = NULL;
+ domain->private_data = NULL;
}
return ads_ntstatus(rc);
}
void (*cont)(TALLOC_CTX *mem_ctx,
BOOL success,
struct winbindd_response *response,
- void *c, void *private);
- void *c, *private;
+ void *c, void *private_data);
+ void *c, *private_data;
};
-static void do_async_recv(void *private, BOOL success)
+static void do_async_recv(void *private_data, BOOL success)
{
struct do_async_state *state =
- talloc_get_type_abort(private, struct do_async_state);
+ talloc_get_type_abort(private_data, struct do_async_state);
state->cont(state->mem_ctx, success, &state->response,
- state->c, state->private);
+ state->c, state->private_data);
}
static void do_async(TALLOC_CTX *mem_ctx, struct winbindd_child *child,
const struct winbindd_request *request,
void (*cont)(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private),
- void *c, void *private)
+ void *c, void *private_data),
+ void *c, void *private_data)
{
struct do_async_state *state;
state = TALLOC_P(mem_ctx, struct do_async_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- cont(mem_ctx, False, NULL, c, private);
+ cont(mem_ctx, False, NULL, c, private_data);
return;
}
state->request.length = sizeof(state->request);
state->cont = cont;
state->c = c;
- state->private = private;
+ state->private_data = private_data;
async_request(mem_ctx, child, &state->request,
&state->response, do_async_recv, state);
const struct winbindd_request *request,
void (*cont)(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private),
- void *c, void *private)
+ void *c, void *private_data),
+ void *c, void *private_data)
{
struct do_async_state *state;
state = TALLOC_P(mem_ctx, struct do_async_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- cont(mem_ctx, False, NULL, c, private);
+ cont(mem_ctx, False, NULL, c, private_data);
return;
}
state->request.length = sizeof(state->request);
state->cont = cont;
state->c = c;
- state->private = private;
+ state->private_data = private_data;
async_domain_request(mem_ctx, domain, &state->request,
&state->response, do_async_recv, state);
static void idmap_set_mapping_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ) = c;
if (!success) {
DEBUG(5, ("Could not trigger idmap_set_mapping\n"));
- cont(private, False);
+ cont(private_data, False);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("idmap_set_mapping returned an error\n"));
- cont(private, False);
+ cont(private_data, False);
return;
}
- cont(private, True);
+ cont(private_data, True);
}
void idmap_set_mapping_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
unid_t id, int id_type,
- void (*cont)(void *private, BOOL success),
- void *private)
+ void (*cont)(void *private_data, BOOL success),
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
sid_to_string(request.data.dual_idmapset.sid, sid);
do_async(mem_ctx, idmap_child(), &request, idmap_set_mapping_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_idmapset(struct winbindd_domain *domain,
static void idmap_sid2uid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private);
+ void *c, void *private_data);
void idmap_sid2uid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid, BOOL alloc,
- void (*cont)(void *private, BOOL success, uid_t uid),
- void *private)
+ void (*cont)(void *private_data, BOOL success, uid_t uid),
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
sid_to_string(request.data.dual_sid2id.sid, sid);
request.data.dual_sid2id.alloc = alloc;
do_async(mem_ctx, idmap_child(), &request, idmap_sid2uid_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_sid2uid(struct winbindd_domain *domain,
static void idmap_sid2uid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, uid_t uid) = c;
if (!success) {
DEBUG(5, ("Could not trigger sid2uid\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("sid2uid returned an error\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
- cont(private, True, response->data.uid);
+ cont(private_data, True, response->data.uid);
}
static void uid2name_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private);
+ void *c, void *private_data);
void winbindd_uid2name_async(TALLOC_CTX *mem_ctx, uid_t uid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
const char *name),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
request.cmd = WINBINDD_DUAL_UID2NAME;
request.data.uid = uid;
do_async(mem_ctx, idmap_child(), &request, uid2name_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_uid2name(struct winbindd_domain *domain,
static void uid2name_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, const char *name) = c;
if (!success) {
DEBUG(5, ("Could not trigger uid2name\n"));
- cont(private, False, NULL);
+ cont(private_data, False, NULL);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("uid2name returned an error\n"));
- cont(private, False, NULL);
+ cont(private_data, False, NULL);
return;
}
- cont(private, True, response->data.name.name);
+ cont(private_data, True, response->data.name.name);
}
static void name2uid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private);
+ void *c, void *private_data);
static void winbindd_name2uid_async(TALLOC_CTX *mem_ctx, const char *name,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
uid_t uid),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
request.cmd = WINBINDD_DUAL_NAME2UID;
fstrcpy(request.data.username, name);
do_async(mem_ctx, idmap_child(), &request, name2uid_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_name2uid(struct winbindd_domain *domain,
static void name2uid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, uid_t uid) = c;
if (!success) {
DEBUG(5, ("Could not trigger name2uid\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("name2uid returned an error\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
- cont(private, True, response->data.uid);
+ cont(private_data, True, response->data.uid);
}
static void idmap_sid2gid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private);
+ void *c, void *private_data);
void idmap_sid2gid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid, BOOL alloc,
- void (*cont)(void *private, BOOL success, gid_t gid),
- void *private)
+ void (*cont)(void *private_data, BOOL success, gid_t gid),
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
sid_to_string(request.data.dual_sid2id.sid, sid);
request.data.dual_sid2id.alloc = alloc;
do_async(mem_ctx, idmap_child(), &request, idmap_sid2gid_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_sid2gid(struct winbindd_domain *domain,
static void idmap_sid2gid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, gid_t gid) = c;
if (!success) {
DEBUG(5, ("Could not trigger sid2gid\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("sid2gid returned an error\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
- cont(private, True, response->data.gid);
+ cont(private_data, True, response->data.gid);
}
static void gid2name_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, const char *name) = c;
if (!success) {
DEBUG(5, ("Could not trigger gid2name\n"));
- cont(private, False, NULL);
+ cont(private_data, False, NULL);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("gid2name returned an error\n"));
- cont(private, False, NULL);
+ cont(private_data, False, NULL);
return;
}
- cont(private, True, response->data.name.name);
+ cont(private_data, True, response->data.name.name);
}
void winbindd_gid2name_async(TALLOC_CTX *mem_ctx, gid_t gid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
const char *name),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
request.cmd = WINBINDD_DUAL_GID2NAME;
request.data.gid = gid;
do_async(mem_ctx, idmap_child(), &request, gid2name_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_gid2name(struct winbindd_domain *domain,
static void name2gid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private);
+ void *c, void *private_data);
static void winbindd_name2gid_async(TALLOC_CTX *mem_ctx, const char *name,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
gid_t gid),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
request.cmd = WINBINDD_DUAL_NAME2GID;
fstrcpy(request.data.groupname, name);
do_async(mem_ctx, idmap_child(), &request, name2gid_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_name2gid(struct winbindd_domain *domain,
static void name2gid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, gid_t gid) = c;
if (!success) {
DEBUG(5, ("Could not trigger name2gid\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("name2gid returned an error\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
- cont(private, True, response->data.gid);
+ cont(private_data, True, response->data.gid);
}
static void lookupsid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, const char *dom_name,
const char *name, enum SID_NAME_USE type) = c;
if (!success) {
DEBUG(5, ("Could not trigger lookupsid\n"));
- cont(private, False, NULL, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("lookupsid returned an error\n"));
- cont(private, False, NULL, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
- cont(private, True, response->data.name.dom_name,
+ cont(private_data, True, response->data.name.dom_name,
response->data.name.name, response->data.name.type);
}
void winbindd_lookupsid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
const char *dom_name,
const char *name,
enum SID_NAME_USE type),
- void *private)
+ void *private_data)
{
struct winbindd_domain *domain;
struct winbindd_request request;
if (domain == NULL) {
DEBUG(5, ("Could not find domain for sid %s\n",
sid_string_static(sid)));
- cont(private, False, NULL, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
fstrcpy(request.data.sid, sid_string_static(sid));
do_async_domain(mem_ctx, domain, &request, lookupsid_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_lookupsid(struct winbindd_domain *domain,
static void lookupname_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, const DOM_SID *sid,
enum SID_NAME_USE type) = c;
if (!success) {
DEBUG(5, ("Could not trigger lookup_name\n"));
- cont(private, False, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("lookup_name returned an error\n"));
- cont(private, False, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
if (!string_to_sid(&sid, response->data.sid.sid)) {
DEBUG(0, ("Could not convert string %s to sid\n",
response->data.sid.sid));
- cont(private, False, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
- cont(private, True, &sid, response->data.sid.type);
+ cont(private_data, True, &sid, response->data.sid.type);
}
void winbindd_lookupname_async(TALLOC_CTX *mem_ctx, const char *dom_name,
const char *name,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
const DOM_SID *sid,
enum SID_NAME_USE type),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
struct winbindd_domain *domain;
if (domain == NULL) {
DEBUG(5, ("Could not find domain for name %s\n", dom_name));
- cont(private, False, NULL, SID_NAME_UNKNOWN);
+ cont(private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
fstrcpy(request.data.name.name, name);
do_async_domain(mem_ctx, domain, &request, lookupname_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_lookupname(struct winbindd_domain *domain,
static void getsidaliases_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ,
DOM_SID *aliases, int num_aliases) = c;
if (!success) {
DEBUG(5, ("Could not trigger getsidaliases\n"));
- cont(private, success, NULL, 0);
+ cont(private_data, success, NULL, 0);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("getsidaliases returned an error\n"));
- cont(private, False, NULL, 0);
+ cont(private_data, False, NULL, 0);
return;
}
if (aliases_str == NULL) {
DEBUG(10, ("getsidaliases return 0 SIDs\n"));
- cont(private, True, NULL, 0);
+ cont(private_data, True, NULL, 0);
return;
}
if (!parse_sidlist(mem_ctx, aliases_str, &sids, &num_sids)) {
DEBUG(0, ("Could not parse sids\n"));
- cont(private, False, NULL, 0);
+ cont(private_data, False, NULL, 0);
return;
}
SAFE_FREE(response->extra_data);
- cont(private, True, sids, num_sids);
+ cont(private_data, True, sids, num_sids);
}
void winbindd_getsidaliases_async(struct winbindd_domain *domain,
TALLOC_CTX *mem_ctx,
const DOM_SID *sids, int num_sids,
- void (*cont)(void *private,
+ void (*cont)(void *private_data,
BOOL success,
const DOM_SID *aliases,
int num_aliases),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
char *sidstr = NULL;
char *keystr;
if (num_sids == 0) {
- cont(private, True, NULL, 0);
+ cont(private_data, True, NULL, 0);
return;
}
if (!print_sidlist(mem_ctx, sids, num_sids, &sidstr)) {
- cont(private, False, NULL, 0);
+ cont(private_data, False, NULL, 0);
return;
}
keystr = cache_store_request_data(mem_ctx, sidstr);
if (keystr == NULL) {
- cont(private, False, NULL, 0);
+ cont(private_data, False, NULL, 0);
return;
}
fstrcpy(request.data.dual_sidaliases.cache_key, keystr);
do_async_domain(mem_ctx, domain, &request, getsidaliases_recv,
- cont, private);
+ cont, private_data);
}
enum winbindd_result winbindd_dual_getsidaliases(struct winbindd_domain *domain,
struct winbindd_domain *builtin_domain;
DOM_SID *sids;
int num_sids;
- void (*cont)(void *private, BOOL success, DOM_SID *sids, int num_sids);
- void *private;
+ void (*cont)(void *private_data, BOOL success, DOM_SID *sids, int num_sids);
+ void *private_data;
};
static void gettoken_recvdomgroups(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private);
-static void gettoken_recvaliases(void *private, BOOL success,
+ void *c, void *private_data);
+static void gettoken_recvaliases(void *private_data, BOOL success,
const DOM_SID *aliases,
int num_aliases);
void winbindd_gettoken_async(TALLOC_CTX *mem_ctx, const DOM_SID *user_sid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
DOM_SID *sids, int num_sids),
- void *private)
+ void *private_data)
{
struct winbindd_domain *domain;
struct winbindd_request request;
state = TALLOC_P(mem_ctx, struct gettoken_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- cont(private, False, NULL, 0);
+ cont(private_data, False, NULL, 0);
return;
}
state->alias_domain = find_our_domain();
state->builtin_domain = find_builtin_domain();
state->cont = cont;
- state->private = private;
+ state->private_data = private_data;
domain = find_domain_from_sid_noinit(user_sid);
if (domain == NULL) {
DEBUG(5, ("Could not find domain from SID %s\n",
sid_string_static(user_sid)));
- cont(private, False, NULL, 0);
+ cont(private_data, False, NULL, 0);
return;
}
static void gettoken_recvdomgroups(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
struct gettoken_state *state =
- talloc_get_type_abort(private, struct gettoken_state);
+ talloc_get_type_abort(private_data, struct gettoken_state);
char *sids_str;
if (!success) {
DEBUG(10, ("Could not get domain groups\n"));
- state->cont(state->private, False, NULL, 0);
+ state->cont(state->private_data, False, NULL, 0);
return;
}
if (sids_str == NULL) {
DEBUG(10, ("Received no domain groups\n"));
- state->cont(state->private, True, NULL, 0);
+ state->cont(state->private_data, True, NULL, 0);
return;
}
if (!parse_sidlist(mem_ctx, sids_str, &state->sids,
&state->num_sids)) {
DEBUG(0, ("Could not parse sids\n"));
- state->cont(state->private, False, NULL, 0);
+ state->cont(state->private_data, False, NULL, 0);
return;
}
if (state->alias_domain == NULL) {
DEBUG(10, ("Don't expand domain local groups\n"));
- state->cont(state->private, True, state->sids,
+ state->cont(state->private_data, True, state->sids,
state->num_sids);
return;
}
gettoken_recvaliases, state);
}
-static void gettoken_recvaliases(void *private, BOOL success,
+static void gettoken_recvaliases(void *private_data, BOOL success,
const DOM_SID *aliases,
int num_aliases)
{
- struct gettoken_state *state = private;
+ struct gettoken_state *state = private_data;
int i;
if (!success) {
DEBUG(10, ("Could not receive domain local groups\n"));
- state->cont(state->private, False, NULL, 0);
+ state->cont(state->private_data, False, NULL, 0);
return;
}
return;
}
- state->cont(state->private, True, state->sids, state->num_sids);
+ state->cont(state->private_data, True, state->sids, state->num_sids);
}
struct sid2uid_state {
DOM_SID sid;
char *username;
uid_t uid;
- void (*cont)(void *private, BOOL success, uid_t uid);
- void *private;
+ void (*cont)(void *private_data, BOOL success, uid_t uid);
+ void *private_data;
};
-static void sid2uid_lookup_sid_recv(void *private, BOOL success,
+static void sid2uid_lookup_sid_recv(void *private_data, BOOL success,
const char *dom_name, const char *name,
enum SID_NAME_USE type);
-static void sid2uid_noalloc_recv(void *private, BOOL success, uid_t uid);
-static void sid2uid_alloc_recv(void *private, BOOL success, uid_t uid);
-static void sid2uid_name2uid_recv(void *private, BOOL success, uid_t uid);
-static void sid2uid_set_mapping_recv(void *private, BOOL success);
+static void sid2uid_noalloc_recv(void *private_data, BOOL success, uid_t uid);
+static void sid2uid_alloc_recv(void *private_data, BOOL success, uid_t uid);
+static void sid2uid_name2uid_recv(void *private_data, BOOL success, uid_t uid);
+static void sid2uid_set_mapping_recv(void *private_data, BOOL success);
void winbindd_sid2uid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
uid_t uid),
- void *private)
+ void *private_data)
{
struct sid2uid_state *state;
NTSTATUS result;
if (idmap_proxyonly()) {
DEBUG(10, ("idmap proxy only\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
result = idmap_sid_to_uid(sid, &uid, ID_QUERY_ONLY|ID_CACHE_ONLY);
if (NT_STATUS_IS_OK(result)) {
- cont(private, True, uid);
+ cont(private_data, True, uid);
return;
}
state = TALLOC_P(mem_ctx, struct sid2uid_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
state->mem_ctx = mem_ctx;
state->sid = *sid;
state->cont = cont;
- state->private = private;
+ state->private_data = private_data;
/* Let's see if it's really a user before allocating a uid */
winbindd_lookupsid_async(mem_ctx, sid, sid2uid_lookup_sid_recv, state);
}
-static void sid2uid_lookup_sid_recv(void *private, BOOL success,
+static void sid2uid_lookup_sid_recv(void *private_data, BOOL success,
const char *dom_name, const char *name,
enum SID_NAME_USE type)
{
struct sid2uid_state *state =
- talloc_get_type_abort(private, struct sid2uid_state);
+ talloc_get_type_abort(private_data, struct sid2uid_state);
if (!success) {
DEBUG(5, ("Could not trigger lookup_sid\n"));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
if ((type != SID_NAME_USER) && (type != SID_NAME_COMPUTER)) {
DEBUG(5, ("SID is not a user\n"));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
sid2uid_noalloc_recv, state);
}
-static void sid2uid_noalloc_recv(void *private, BOOL success, uid_t uid)
+static void sid2uid_noalloc_recv(void *private_data, BOOL success, uid_t uid)
{
struct sid2uid_state *state =
- talloc_get_type_abort(private, struct sid2uid_state);
+ talloc_get_type_abort(private_data, struct sid2uid_state);
if (success) {
DEBUG(10, ("found uid for sid %s in remote backend\n",
sid_string_static(&state->sid)));
- state->cont(state->private, True, uid);
+ state->cont(state->private_data, True, uid);
return;
}
sid2uid_alloc_recv, state);
}
-static void sid2uid_alloc_recv(void *private, BOOL success, uid_t uid)
+static void sid2uid_alloc_recv(void *private_data, BOOL success, uid_t uid)
{
struct sid2uid_state *state =
- talloc_get_type_abort(private, struct sid2uid_state);
+ talloc_get_type_abort(private_data, struct sid2uid_state);
if (!success) {
DEBUG(5, ("Could not allocate uid\n"));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
- state->cont(state->private, True, uid);
+ state->cont(state->private_data, True, uid);
}
-static void sid2uid_name2uid_recv(void *private, BOOL success, uid_t uid)
+static void sid2uid_name2uid_recv(void *private_data, BOOL success, uid_t uid)
{
struct sid2uid_state *state =
- talloc_get_type_abort(private, struct sid2uid_state);
+ talloc_get_type_abort(private_data, struct sid2uid_state);
unid_t id;
if (!success) {
DEBUG(5, ("Could not find uid for name %s\n",
state->username));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
sid2uid_set_mapping_recv, state);
}
-static void sid2uid_set_mapping_recv(void *private, BOOL success)
+static void sid2uid_set_mapping_recv(void *private_data, BOOL success)
{
struct sid2uid_state *state =
- talloc_get_type_abort(private, struct sid2uid_state);
+ talloc_get_type_abort(private_data, struct sid2uid_state);
if (!success) {
DEBUG(5, ("Could not set ID mapping for sid %s\n",
sid_string_static(&state->sid)));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
- state->cont(state->private, True, state->uid);
+ state->cont(state->private_data, True, state->uid);
}
struct sid2gid_state {
DOM_SID sid;
char *groupname;
gid_t gid;
- void (*cont)(void *private, BOOL success, gid_t gid);
- void *private;
+ void (*cont)(void *private_data, BOOL success, gid_t gid);
+ void *private_data;
};
-static void sid2gid_lookup_sid_recv(void *private, BOOL success,
+static void sid2gid_lookup_sid_recv(void *private_data, BOOL success,
const char *dom_name, const char *name,
enum SID_NAME_USE type);
-static void sid2gid_noalloc_recv(void *private, BOOL success, gid_t gid);
-static void sid2gid_alloc_recv(void *private, BOOL success, gid_t gid);
-static void sid2gid_name2gid_recv(void *private, BOOL success, gid_t gid);
-static void sid2gid_set_mapping_recv(void *private, BOOL success);
+static void sid2gid_noalloc_recv(void *private_data, BOOL success, gid_t gid);
+static void sid2gid_alloc_recv(void *private_data, BOOL success, gid_t gid);
+static void sid2gid_name2gid_recv(void *private_data, BOOL success, gid_t gid);
+static void sid2gid_set_mapping_recv(void *private_data, BOOL success);
void winbindd_sid2gid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
gid_t gid),
- void *private)
+ void *private_data)
{
struct sid2gid_state *state;
NTSTATUS result;
if (idmap_proxyonly()) {
DEBUG(10, ("idmap proxy only\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
result = idmap_sid_to_gid(sid, &gid, ID_QUERY_ONLY|ID_CACHE_ONLY);
if (NT_STATUS_IS_OK(result)) {
- cont(private, True, gid);
+ cont(private_data, True, gid);
return;
}
state = TALLOC_P(mem_ctx, struct sid2gid_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- cont(private, False, 0);
+ cont(private_data, False, 0);
return;
}
state->mem_ctx = mem_ctx;
state->sid = *sid;
state->cont = cont;
- state->private = private;
+ state->private_data = private_data;
/* Let's see if it's really a user before allocating a gid */
winbindd_lookupsid_async(mem_ctx, sid, sid2gid_lookup_sid_recv, state);
}
-static void sid2gid_lookup_sid_recv(void *private, BOOL success,
+static void sid2gid_lookup_sid_recv(void *private_data, BOOL success,
const char *dom_name, const char *name,
enum SID_NAME_USE type)
{
struct sid2gid_state *state =
- talloc_get_type_abort(private, struct sid2gid_state);
+ talloc_get_type_abort(private_data, struct sid2gid_state);
if (!success) {
DEBUG(5, ("Could not trigger lookup_sid\n"));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
if (((type != SID_NAME_DOM_GRP) && (type != SID_NAME_ALIAS) &&
(type != SID_NAME_WKN_GRP))) {
DEBUG(5, ("SID is not a group\n"));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
sid2gid_noalloc_recv, state);
}
-static void sid2gid_noalloc_recv(void *private, BOOL success, gid_t gid)
+static void sid2gid_noalloc_recv(void *private_data, BOOL success, gid_t gid)
{
struct sid2gid_state *state =
- talloc_get_type_abort(private, struct sid2gid_state);
+ talloc_get_type_abort(private_data, struct sid2gid_state);
if (success) {
DEBUG(10, ("found gid for sid %s in remote backend\n",
sid_string_static(&state->sid)));
- state->cont(state->private, True, gid);
+ state->cont(state->private_data, True, gid);
return;
}
sid2gid_alloc_recv, state);
}
-static void sid2gid_alloc_recv(void *private, BOOL success, gid_t gid)
+static void sid2gid_alloc_recv(void *private_data, BOOL success, gid_t gid)
{
struct sid2gid_state *state =
- talloc_get_type_abort(private, struct sid2gid_state);
+ talloc_get_type_abort(private_data, struct sid2gid_state);
if (!success) {
DEBUG(5, ("Could not allocate gid\n"));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
- state->cont(state->private, True, gid);
+ state->cont(state->private_data, True, gid);
}
-static void sid2gid_name2gid_recv(void *private, BOOL success, gid_t gid)
+static void sid2gid_name2gid_recv(void *private_data, BOOL success, gid_t gid)
{
struct sid2gid_state *state =
- talloc_get_type_abort(private, struct sid2gid_state);
+ talloc_get_type_abort(private_data, struct sid2gid_state);
unid_t id;
if (!success) {
DEBUG(5, ("Could not find gid for name %s\n",
state->groupname));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
sid2gid_set_mapping_recv, state);
}
-static void sid2gid_set_mapping_recv(void *private, BOOL success)
+static void sid2gid_set_mapping_recv(void *private_data, BOOL success)
{
struct sid2gid_state *state =
- talloc_get_type_abort(private, struct sid2gid_state);
+ talloc_get_type_abort(private_data, struct sid2gid_state);
if (!success) {
DEBUG(5, ("Could not set ID mapping for sid %s\n",
sid_string_static(&state->sid)));
- state->cont(state->private, False, 0);
+ state->cont(state->private_data, False, 0);
return;
}
- state->cont(state->private, True, state->gid);
+ state->cont(state->private_data, True, state->gid);
}
static void query_user_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
- void *c, void *private)
+ void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, const char *acct_name,
const char *full_name, uint32 group_rid) = c;
if (!success) {
DEBUG(5, ("Could not trigger query_user\n"));
- cont(private, False, NULL, NULL, -1);
+ cont(private_data, False, NULL, NULL, -1);
return;
}
- cont(private, True, response->data.user_info.acct_name,
+ cont(private_data, True, response->data.user_info.acct_name,
response->data.user_info.full_name,
response->data.user_info.group_rid);
}
void query_user_async(TALLOC_CTX *mem_ctx, struct winbindd_domain *domain,
const DOM_SID *sid,
- void (*cont)(void *private, BOOL success,
+ void (*cont)(void *private_data, BOOL success,
const char *acct_name,
const char *full_name,
uint32 group_rid),
- void *private)
+ void *private_data)
{
struct winbindd_request request;
ZERO_STRUCT(request);
request.cmd = WINBINDD_DUAL_USERINFO;
sid_to_string(request.data.sid, sid);
do_async_domain(mem_ctx, domain, &request, query_user_recv,
- cont, private);
+ cont, private_data);
}
-
struct winbindd_child *child;
struct winbindd_request *request;
struct winbindd_response *response;
- void (*continuation)(void *private, BOOL success);
- void *private;
+ void (*continuation)(void *private_data, BOOL success);
+ void *private_data;
};
-static void async_request_sent(void *private, BOOL success);
-static void async_reply_recv(void *private, BOOL success);
+static void async_request_sent(void *private_data, BOOL success);
+static void async_reply_recv(void *private_data, BOOL success);
static void schedule_async_request(struct winbindd_child *child);
void async_request(TALLOC_CTX *mem_ctx, struct winbindd_child *child,
struct winbindd_request *request,
struct winbindd_response *response,
- void (*continuation)(void *private, BOOL success),
- void *private)
+ void (*continuation)(void *private_data, BOOL success),
+ void *private_data)
{
struct winbindd_async_request *state, *tmp;
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- continuation(private, False);
+ continuation(private_data, False);
return;
}
state->request = request;
state->response = response;
state->continuation = continuation;
- state->private = private;
+ state->private_data = private_data;
DLIST_ADD_END(child->requests, state, tmp);
return;
}
-static void async_request_sent(void *private, BOOL success)
+static void async_request_sent(void *private_data, BOOL success)
{
struct winbindd_async_request *state =
- talloc_get_type_abort(private, struct winbindd_async_request);
+ talloc_get_type_abort(private_data, struct winbindd_async_request);
if (!success) {
DEBUG(5, ("Could not send async request\n"));
state->response->length = sizeof(struct winbindd_response);
state->response->result = WINBINDD_ERROR;
- state->continuation(state->private, False);
+ state->continuation(state->private_data, False);
return;
}
async_reply_recv, state);
}
-static void async_reply_recv(void *private, BOOL success)
+static void async_reply_recv(void *private_data, BOOL success)
{
struct winbindd_async_request *state =
- talloc_get_type_abort(private, struct winbindd_async_request);
+ talloc_get_type_abort(private_data, struct winbindd_async_request);
struct winbindd_child *child = state->child;
state->response->length = sizeof(struct winbindd_response);
schedule_async_request(child);
- state->continuation(state->private, True);
+ state->continuation(state->private_data, True);
}
static BOOL fork_domain_child(struct winbindd_child *child);
while (request != NULL) {
/* request might be free'd in the continuation */
struct winbindd_async_request *next = request->next;
- request->continuation(request->private, False);
+ request->continuation(request->private_data, False);
request = next;
}
return;
struct winbindd_domain *domain;
struct winbindd_request *request;
struct winbindd_response *response;
- void (*continuation)(void *private, BOOL success);
- void *private;
+ void (*continuation)(void *private_data, BOOL success);
+ void *private_data;
};
-static void domain_init_recv(void *private, BOOL success);
+static void domain_init_recv(void *private_data, BOOL success);
void async_domain_request(TALLOC_CTX *mem_ctx,
struct winbindd_domain *domain,
struct winbindd_request *request,
struct winbindd_response *response,
- void (*continuation)(void *private, BOOL success),
- void *private)
+ void (*continuation)(void *private_data, BOOL success),
+ void *private_data)
{
struct domain_request_state *state;
if (domain->initialized) {
async_request(mem_ctx, &domain->child, request, response,
- continuation, private);
+ continuation, private_data);
return;
}
state = TALLOC_P(mem_ctx, struct domain_request_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
- continuation(private, False);
+ continuation(private_data, False);
return;
}
state->request = request;
state->response = response;
state->continuation = continuation;
- state->private = private;
+ state->private_data = private_data;
init_child_connection(domain, domain_init_recv, state);
}
-static void recvfrom_child(void *private, BOOL success)
+static void recvfrom_child(void *private_data, BOOL success)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
enum winbindd_result result = state->response.result;
/* This is an optimization: The child has written directly to the
recvfrom_child, state);
}
-static void domain_init_recv(void *private, BOOL success)
+static void domain_init_recv(void *private_data, BOOL success)
{
struct domain_request_state *state =
- talloc_get_type_abort(private, struct domain_request_state);
+ talloc_get_type_abort(private_data, struct domain_request_state);
if (!success) {
DEBUG(5, ("Domain init returned an error\n"));
- state->continuation(state->private, False);
+ state->continuation(state->private_data, False);
return;
}
async_request(state->mem_ctx, &state->domain->child,
state->request, state->response,
- state->continuation, state->private);
+ state->continuation, state->private_data);
}
struct winbindd_child_dispatch_table {
int num_token_gids;
};
-static void getgroups_usersid_recv(void *private, BOOL success,
+static void getgroups_usersid_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type);
-static void getgroups_tokensids_recv(void *private, BOOL success,
+static void getgroups_tokensids_recv(void *private_data, BOOL success,
DOM_SID *token_sids, int num_token_sids);
-static void getgroups_sid2gid_recv(void *private, BOOL success, gid_t gid);
+static void getgroups_sid2gid_recv(void *private_data, BOOL success, gid_t gid);
void winbindd_getgroups(struct winbindd_cli_state *state)
{
getgroups_usersid_recv, s);
}
-static void getgroups_usersid_recv(void *private, BOOL success,
+static void getgroups_usersid_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type)
{
- struct getgroups_state *s = private;
+ struct getgroups_state *s = private_data;
if ((!success) ||
((type != SID_NAME_USER) && (type != SID_NAME_COMPUTER))) {
getgroups_tokensids_recv, s);
}
-static void getgroups_tokensids_recv(void *private, BOOL success,
+static void getgroups_tokensids_recv(void *private_data, BOOL success,
DOM_SID *token_sids, int num_token_sids)
{
- struct getgroups_state *s = private;
+ struct getgroups_state *s = private_data;
/* We need at least the user sid and the primary group in the token,
* otherwise it's an error */
getgroups_sid2gid_recv(s, False, 0);
}
-static void getgroups_sid2gid_recv(void *private, BOOL success, gid_t gid)
+static void getgroups_sid2gid_recv(void *private_data, BOOL success, gid_t gid)
{
- struct getgroups_state *s = private;
+ struct getgroups_state *s = private_data;
if (success)
add_gid_to_array_unique(NULL, gid,
results.
*/
-static void getusersids_recv(void *private, BOOL success, DOM_SID *sids,
+static void getusersids_recv(void *private_data, BOOL success, DOM_SID *sids,
int num_sids);
void winbindd_getusersids(struct winbindd_cli_state *state)
state);
}
-static void getusersids_recv(void *private, BOOL success, DOM_SID *sids,
+static void getusersids_recv(void *private_data, BOOL success, DOM_SID *sids,
int num_sids)
{
- struct winbindd_cli_state *state = private;
+ struct winbindd_cli_state *state = private_data;
char *ret = NULL;
unsigned ofs, ret_size = 0;
int i;
char *extra_data;
};
-static void sequence_recv(void *private, BOOL success);
+static void sequence_recv(void *private_data, BOOL success);
void winbindd_show_sequence(struct winbindd_cli_state *state)
{
sequence_recv, seq);
}
-static void sequence_recv(void *private, BOOL success)
+static void sequence_recv(void *private_data, BOOL success)
{
- struct sequence_state *state = private;
+ struct sequence_state *state = private_data;
uint32 seq = DOM_SEQUENCE_NONE;
if ((success) && (state->response->result == WINBINDD_OK))
struct winbindd_cli_state *cli_state;
};
-static void domain_info_init_recv(void *private, BOOL success);
+static void domain_info_init_recv(void *private_data, BOOL success);
void winbindd_domain_info(struct winbindd_cli_state *state)
{
request_ok(state);
}
-static void domain_info_init_recv(void *private, BOOL success)
+static void domain_info_init_recv(void *private_data, BOOL success)
{
- struct domain_info_state *istate = private;
+ struct domain_info_state *istate = private_data;
struct winbindd_cli_state *state = istate->cli_state;
struct winbindd_domain *domain = istate->domain;
/* Convert a string */
-static void lookupsid_recv(void *private, BOOL success,
+static void lookupsid_recv(void *private_data, BOOL success,
const char *dom_name, const char *name,
enum SID_NAME_USE type);
winbindd_lookupsid_async(state->mem_ctx, &sid, lookupsid_recv, state);
}
-static void lookupsid_recv(void *private, BOOL success,
+static void lookupsid_recv(void *private_data, BOOL success,
const char *dom_name, const char *name,
enum SID_NAME_USE type)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
DEBUG(5, ("lookupsid returned an error\n"));
* Look up the SID for a qualified name.
**/
-static void lookupname_recv(void *private, BOOL success,
+static void lookupname_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type);
void winbindd_lookupname(struct winbindd_cli_state *state)
lookupname_recv, state);
}
-static void lookupname_recv(void *private, BOOL success,
+static void lookupname_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
DEBUG(5, ("lookupname returned an error\n"));
/* Convert a sid to a uid. We assume we only have one rid attached to the
sid. */
-static void sid2uid_recv(void *private, BOOL success, uid_t uid);
+static void sid2uid_recv(void *private_data, BOOL success, uid_t uid);
void winbindd_sid_to_uid(struct winbindd_cli_state *state)
{
winbindd_sid2uid_async(state->mem_ctx, &sid, sid2uid_recv, state);
}
-static void sid2uid_recv(void *private, BOOL success, uid_t uid)
+static void sid2uid_recv(void *private_data, BOOL success, uid_t uid)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
DEBUG(5, ("Could not convert sid %s\n",
/* Convert a sid to a gid. We assume we only have one rid attached to the
sid.*/
-static void sid2gid_recv(void *private, BOOL success, gid_t gid);
+static void sid2gid_recv(void *private_data, BOOL success, gid_t gid);
void winbindd_sid_to_gid(struct winbindd_cli_state *state)
{
winbindd_sid2gid_async(state->mem_ctx, &sid, sid2gid_recv, state);
}
-static void sid2gid_recv(void *private, BOOL success, gid_t gid)
+static void sid2gid_recv(void *private_data, BOOL success, gid_t gid)
{
struct winbindd_cli_state *state =
- talloc_get_type_abort(private, struct winbindd_cli_state);
+ talloc_get_type_abort(private_data, struct winbindd_cli_state);
if (!success) {
DEBUG(5, ("Could not convert sid %s\n",
enum SID_NAME_USE type;
};
-static void uid2sid_uid2name_recv(void *private, BOOL success,
+static void uid2sid_uid2name_recv(void *private_data, BOOL success,
const char *username);
-static void uid2sid_lookupname_recv(void *private, BOOL success,
+static void uid2sid_lookupname_recv(void *private_data, BOOL success,
const DOM_SID *sid,
enum SID_NAME_USE type);
-static void uid2sid_idmap_set_mapping_recv(void *private, BOOL success);
+static void uid2sid_idmap_set_mapping_recv(void *private_data, BOOL success);
void winbindd_uid_to_sid(struct winbindd_cli_state *state)
{
uid2sid_uid2name_recv, uid2sid_state);
}
-static void uid2sid_uid2name_recv(void *private, BOOL success,
+static void uid2sid_uid2name_recv(void *private_data, BOOL success,
const char *username)
{
struct uid2sid_state *state =
- talloc_get_type_abort(private, struct uid2sid_state);
+ talloc_get_type_abort(private_data, struct uid2sid_state);
DEBUG(10, ("uid2sid: uid %lu has name %s\n",
(unsigned long)state->uid, username));
uid2sid_lookupname_recv, state);
}
-static void uid2sid_lookupname_recv(void *private, BOOL success,
+static void uid2sid_lookupname_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type)
{
struct uid2sid_state *state =
- talloc_get_type_abort(private, struct uid2sid_state);
+ talloc_get_type_abort(private_data, struct uid2sid_state);
unid_t id;
if ((!success) || (type != SID_NAME_USER)) {
uid2sid_idmap_set_mapping_recv, state );
}
-static void uid2sid_idmap_set_mapping_recv(void *private, BOOL success)
+static void uid2sid_idmap_set_mapping_recv(void *private_data, BOOL success)
{
struct uid2sid_state *state =
- talloc_get_type_abort(private, struct uid2sid_state);
+ talloc_get_type_abort(private_data, struct uid2sid_state);
/* don't fail if we can't store it */
enum SID_NAME_USE type;
};
-static void gid2sid_gid2name_recv(void *private, BOOL success,
+static void gid2sid_gid2name_recv(void *private_data, BOOL success,
const char *groupname);
-static void gid2sid_lookupname_recv(void *private, BOOL success,
+static void gid2sid_lookupname_recv(void *private_data, BOOL success,
const DOM_SID *sid,
enum SID_NAME_USE type);
-static void gid2sid_idmap_set_mapping_recv(void *private, BOOL success);
+static void gid2sid_idmap_set_mapping_recv(void *private_data, BOOL success);
void winbindd_gid_to_sid(struct winbindd_cli_state *state)
{
gid2sid_gid2name_recv, gid2sid_state);
}
-static void gid2sid_gid2name_recv(void *private, BOOL success,
+static void gid2sid_gid2name_recv(void *private_data, BOOL success,
const char *username)
{
struct gid2sid_state *state =
- talloc_get_type_abort(private, struct gid2sid_state);
+ talloc_get_type_abort(private_data, struct gid2sid_state);
DEBUG(10, ("gid2sid: gid %lu has name %s\n",
(unsigned long)state->gid, username));
gid2sid_lookupname_recv, state);
}
-static void gid2sid_lookupname_recv(void *private, BOOL success,
+static void gid2sid_lookupname_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type)
{
struct gid2sid_state *state =
- talloc_get_type_abort(private, struct gid2sid_state);
+ talloc_get_type_abort(private_data, struct gid2sid_state);
unid_t id;
if ((!success) ||
gid2sid_idmap_set_mapping_recv, state );
}
-static void gid2sid_idmap_set_mapping_recv(void *private, BOOL success)
+static void gid2sid_idmap_set_mapping_recv(void *private_data, BOOL success)
{
- struct gid2sid_state *state = private;
+ struct gid2sid_state *state = private_data;
/* don't fail if we can't store it */
gid_t gid;
};
-static void getpwsid_queryuser_recv(void *private, BOOL success,
+static void getpwsid_queryuser_recv(void *private_data, BOOL success,
const char *acct_name,
const char *full_name, uint32 group_rid);
-static void getpwsid_sid2uid_recv(void *private, BOOL success, uid_t uid);
-static void getpwsid_sid2gid_recv(void *private, BOOL success, gid_t gid);
+static void getpwsid_sid2uid_recv(void *private_data, BOOL success, uid_t uid);
+static void getpwsid_sid2gid_recv(void *private_data, BOOL success, gid_t gid);
static void winbindd_getpwsid(struct winbindd_cli_state *state,
const DOM_SID *sid)
request_error(state);
}
-static void getpwsid_queryuser_recv(void *private, BOOL success,
+static void getpwsid_queryuser_recv(void *private_data, BOOL success,
const char *acct_name,
const char *full_name, uint32 group_rid)
{
struct getpwsid_state *s =
- talloc_get_type_abort(private, struct getpwsid_state);
+ talloc_get_type_abort(private_data, struct getpwsid_state);
if (!success) {
DEBUG(5, ("Could not query user %s\\%s\n", s->domain->name,
getpwsid_sid2uid_recv, s);
}
-static void getpwsid_sid2uid_recv(void *private, BOOL success, uid_t uid)
+static void getpwsid_sid2uid_recv(void *private_data, BOOL success, uid_t uid)
{
struct getpwsid_state *s =
- talloc_get_type_abort(private, struct getpwsid_state);
+ talloc_get_type_abort(private_data, struct getpwsid_state);
if (!success) {
DEBUG(5, ("Could not query user's %s\\%s uid\n",
getpwsid_sid2gid_recv, s);
}
-static void getpwsid_sid2gid_recv(void *private, BOOL success, gid_t gid)
+static void getpwsid_sid2gid_recv(void *private_data, BOOL success, gid_t gid)
{
struct getpwsid_state *s =
- talloc_get_type_abort(private, struct getpwsid_state);
+ talloc_get_type_abort(private_data, struct getpwsid_state);
struct winbindd_pw *pw;
fstring output_username;
char *homedir;
/* Return a password structure from a username. */
-static void getpwnam_name2sid_recv(void *private, BOOL success,
+static void getpwnam_name2sid_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type);
void winbindd_getpwnam(struct winbindd_cli_state *state)
getpwnam_name2sid_recv, state);
}
-static void getpwnam_name2sid_recv(void *private, BOOL success,
+static void getpwnam_name2sid_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum SID_NAME_USE type)
{
- struct winbindd_cli_state *state = private;
+ struct winbindd_cli_state *state = private_data;
if (!success) {
DEBUG(5, ("Could not lookup name for user %s\n",
struct winbindd_response *response;
};
-static void trustdom_recv(void *private, BOOL success);
+static void trustdom_recv(void *private_data, BOOL success);
static void add_trusted_domains( struct winbindd_domain *domain )
{
trustdom_recv, state);
}
-static void trustdom_recv(void *private, BOOL success)
+static void trustdom_recv(void *private_data, BOOL success)
{
extern struct winbindd_methods cache_methods;
struct trustdom_state *state =
- talloc_get_type_abort(private, struct trustdom_state);
+ talloc_get_type_abort(private_data, struct trustdom_state);
struct winbindd_response *response = state->response;
char *p;
struct winbindd_domain *domain;
struct winbindd_request *request;
struct winbindd_response *response;
- void (*continuation)(void *private, BOOL success);
- void *private;
+ void (*continuation)(void *private_data, BOOL success);
+ void *private_data;
};
-static void init_child_recv(void *private, BOOL success);
-static void init_child_getdc_recv(void *private, BOOL success);
+static void init_child_recv(void *private_data, BOOL success);
+static void init_child_getdc_recv(void *private_data, BOOL success);
enum winbindd_result init_child_connection(struct winbindd_domain *domain,
- void (*continuation)(void *private,
+ void (*continuation)(void *private_data,
BOOL success),
- void *private)
+ void *private_data)
{
TALLOC_CTX *mem_ctx;
struct winbindd_request *request;
if ((request == NULL) || (response == NULL) || (state == NULL)) {
DEBUG(0, ("talloc failed\n"));
- continuation(private, False);
+ continuation(private_data, False);
return WINBINDD_ERROR;
}
state->request = request;
state->response = response;
state->continuation = continuation;
- state->private = private;
+ state->private_data = private_data;
if (domain->primary) {
/* The primary domain has to find the DC name itself */
return WINBINDD_PENDING;
}
-static void init_child_getdc_recv(void *private, BOOL success)
+static void init_child_getdc_recv(void *private_data, BOOL success)
{
struct init_child_state *state =
- talloc_get_type_abort(private, struct init_child_state);
+ talloc_get_type_abort(private_data, struct init_child_state);
const char *dcname = "";
DEBUG(10, ("Received getdcname response\n"));
init_child_recv, state);
}
-static void init_child_recv(void *private, BOOL success)
+static void init_child_recv(void *private_data, BOOL success)
{
struct init_child_state *state =
- talloc_get_type_abort(private, struct init_child_state);
+ talloc_get_type_abort(private_data, struct init_child_state);
DEBUG(5, ("Received child initialization response for domain %s\n",
state->domain->name));
if ((!success) || (state->response->result != WINBINDD_OK)) {
DEBUG(3, ("Could not init child\n"));
- state->continuation(state->private, False);
+ state->continuation(state->private_data, False);
talloc_destroy(state->mem_ctx);
return;
}
state->domain->initialized = 1;
if (state->continuation != NULL)
- state->continuation(state->private, True);
+ state->continuation(state->private_data, True);
talloc_destroy(state->mem_ctx);
}
}
-static struct node_status *lookup_byaddr_backend(char *addr, int *count)
+static NODE_STATUS_STRUCT *lookup_byaddr_backend(char *addr, int *count)
{
int fd;
struct in_addr ip;
struct nmb_name nname;
- struct node_status *status;
+ NODE_STATUS_STRUCT *status;
fd = wins_lookup_open_socket_in();
if (fd == -1)
{
fstring response;
int i, count, maxlen, size;
- struct node_status *status;
+ NODE_STATUS_STRUCT *status;
/* Ensure null termination */
state->request.data.winsreq[sizeof(state->request.data.winsreq)-1]='\0';
#ifdef HAVE_NS_API_H
-static struct node_status *lookup_byaddr_backend(char *addr, int *count)
+static NODE_STATUS_STRUCT *lookup_byaddr_backend(char *addr, int *count)
{
int fd;
struct in_addr ip;
struct nmb_name nname;
- struct node_status *status;
+ NODE_STATUS_STRUCT *status;
if (!initialised) {
nss_wins_init();
char *key;
char *addr;
struct in_addr *ip_list;
- struct node_status *status;
+ NODE_STATUS_STRUCT *status;
int i, count, len, size;
char response[1024];
BOOL found = False;
if ((parm_table[i].type == P_STRING ||
parm_table[i].type == P_USTRING) &&
parm_table[i].ptr)
- string_set(parm_table[i].ptr, "");
+ string_set((char **)parm_table[i].ptr, "");
string_set(&sDefault.fstype, FSTYPE_STRING);
for (i = 0; parm_table[i].label; i++) {
if ((parm_table[i].type == P_STRING ||
parm_table[i].type == P_USTRING) &&
- parm_table[i].class == P_LOCAL)
+ parm_table[i].p_class == P_LOCAL)
string_free((char **)
(((char *)pservice) +
PTR_DIFF(parm_table[i].ptr, &sDefault)));
else if (parm_table[i].type == P_LIST &&
- parm_table[i].class == P_LOCAL)
+ parm_table[i].p_class == P_LOCAL)
str_list_free((char ***)
(((char *)pservice) +
PTR_DIFF(parm_table[i].ptr, &sDefault)));
for ( classIndex=0; section_names[classIndex]; classIndex++) {
printf("[%s]\n", section_names[classIndex]);
for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
- if (parm_table[parmIndex].class == classIndex) {
+ if (parm_table[parmIndex].p_class == classIndex) {
printf("%s=%s",
parm_table[parmIndex].label,
type[parm_table[parmIndex].type]);
BOOL not_added;
for (i = 0; parm_table[i].label; i++)
- if (parm_table[i].ptr && parm_table[i].class == P_LOCAL &&
+ if (parm_table[i].ptr && parm_table[i].p_class == P_LOCAL &&
(bcopyall || pcopymapDest[i])) {
void *def_ptr = parm_table[i].ptr;
void *src_ptr =
break;
case P_STRING:
- string_set(dest_ptr,
+ string_set((char **)dest_ptr,
*(char **)src_ptr);
break;
case P_USTRING:
- string_set(dest_ptr,
+ string_set((char **)dest_ptr,
*(char **)src_ptr);
strupper_m(*(char **)dest_ptr);
break;
if (snum < 0) {
parm_ptr = def_ptr;
} else {
- if (parm_table[parmnum].class == P_GLOBAL) {
+ if (parm_table[parmnum].p_class == P_GLOBAL) {
DEBUG(0,
("Global parameter %s found in service section!\n",
pszParmName));
switch (parm_table[parmnum].type)
{
case P_BOOL:
- set_boolean(parm_ptr, pszParmValue);
+ set_boolean((BOOL *)parm_ptr, pszParmValue);
break;
case P_BOOLREV:
- set_boolean(parm_ptr, pszParmValue);
+ set_boolean((BOOL *)parm_ptr, pszParmValue);
*(BOOL *)parm_ptr = !*(BOOL *)parm_ptr;
break;
break;
case P_LIST:
- str_list_free(parm_ptr);
+ str_list_free((char ***)parm_ptr);
*(char ***)parm_ptr = str_list_make(pszParmValue, NULL);
break;
case P_STRING:
- string_set(parm_ptr, pszParmValue);
+ string_set((char **)parm_ptr, pszParmValue);
break;
case P_USTRING:
- string_set(parm_ptr, pszParmValue);
+ string_set((char **)parm_ptr, pszParmValue);
strupper_m(*(char **)parm_ptr);
break;
fprintf(f, "[global]\n");
for (i = 0; parm_table[i].label; i++)
- if (parm_table[i].class == P_GLOBAL &&
+ if (parm_table[i].p_class == P_GLOBAL &&
parm_table[i].ptr &&
(i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
if (defaults_saved && is_default(i))
for (i = 0; parm_table[i].label; i++) {
- if (parm_table[i].class == P_LOCAL &&
+ if (parm_table[i].p_class == P_LOCAL &&
parm_table[i].ptr &&
(*parm_table[i].label != '-') &&
(i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
{
service * pService = ServicePtrs[snum];
int i, result = False;
- parm_class class;
+ parm_class p_class;
unsigned flag = 0;
if (isGlobal) {
- class = P_GLOBAL;
+ p_class = P_GLOBAL;
flag = FLAG_GLOBAL;
} else
- class = P_LOCAL;
+ p_class = P_LOCAL;
for (i = 0; parm_table[i].label; i++) {
if (strwicmp(parm_table[i].label, parm_name) == 0 &&
- (parm_table[i].class == class || parm_table[i].flags & flag) &&
+ (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
parm_table[i].ptr &&
(*parm_table[i].label != '-') &&
(i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
if (snum < 0) {
/* do the globals */
for (; parm_table[*i].label; (*i)++) {
- if (parm_table[*i].class == P_SEPARATOR)
+ if (parm_table[*i].p_class == P_SEPARATOR)
return &parm_table[(*i)++];
if (!parm_table[*i].ptr
service *pService = ServicePtrs[snum];
for (; parm_table[*i].label; (*i)++) {
- if (parm_table[*i].class == P_SEPARATOR)
+ if (parm_table[*i].p_class == P_SEPARATOR)
return &parm_table[(*i)++];
- if (parm_table[*i].class == P_LOCAL &&
+ if (parm_table[*i].p_class == P_LOCAL &&
parm_table[*i].ptr &&
(*parm_table[*i].label != '-') &&
((*i) == 0 ||
printf("\n\tNon-Copied parameters:\n");
for (i = 0; parm_table[i].label; i++)
- if (parm_table[i].class == P_LOCAL &&
+ if (parm_table[i].p_class == P_LOCAL &&
parm_table[i].ptr && !pcopymap[i] &&
(i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
{
if( i > (bSize - 2) ) {
char *tb;
- tb = SMB_REALLOC( bufr, bSize +BUFR_INC );
+ tb = (char *)SMB_REALLOC( bufr, bSize +BUFR_INC );
if( NULL == tb ) {
DEBUG(0, ("%s Memory re-allocation failure.", func) );
return False;
/* Loop until we've found the start of the value. */
if( i > (bSize - 2) ) {
/* Ensure there's space for next char. */
- char *tb = SMB_REALLOC( bufr, bSize + BUFR_INC );
+ char *tb = (char *)SMB_REALLOC( bufr, bSize + BUFR_INC );
if( NULL == tb ) {
DEBUG(0, ("%s Memory re-allocation failure.", func) );
return False;
while( (EOF !=c) && (c > 0) ) {
if( i > (bSize - 2) ) {
/* Make sure there's enough room. */
- char *tb = SMB_REALLOC( bufr, bSize + BUFR_INC );
+ char *tb = (char *)SMB_REALLOC( bufr, bSize + BUFR_INC );
if( NULL == tb ) {
DEBUG(0, ("%s Memory re-allocation failure.", func));
return False;
void pdb_fill_default_sam(SAM_ACCOUNT *user)
{
- ZERO_STRUCT(user->private); /* Don't touch the talloc context */
+ ZERO_STRUCT(user->private_u); /* Don't touch the talloc context */
/* no initial methods */
user->methods = NULL;
/* Don't change these timestamp settings without a good reason.
They are important for NT member server compatibility. */
- user->private.logon_time = (time_t)0;
- user->private.pass_last_set_time = (time_t)0;
- user->private.pass_can_change_time = (time_t)0;
- user->private.logoff_time =
- user->private.kickoff_time =
- user->private.pass_must_change_time = get_time_t_max();
- user->private.fields_present = 0x00ffffff;
- user->private.logon_divs = 168; /* hours per week */
- user->private.hours_len = 21; /* 21 times 8 bits = 168 */
- memset(user->private.hours, 0xff, user->private.hours_len); /* available at all hours */
- user->private.bad_password_count = 0;
- user->private.logon_count = 0;
- user->private.unknown_6 = 0x000004ec; /* don't know */
+ user->private_u.logon_time = (time_t)0;
+ user->private_u.pass_last_set_time = (time_t)0;
+ user->private_u.pass_can_change_time = (time_t)0;
+ user->private_u.logoff_time =
+ user->private_u.kickoff_time =
+ user->private_u.pass_must_change_time = get_time_t_max();
+ user->private_u.fields_present = 0x00ffffff;
+ user->private_u.logon_divs = 168; /* hours per week */
+ user->private_u.hours_len = 21; /* 21 times 8 bits = 168 */
+ memset(user->private_u.hours, 0xff, user->private_u.hours_len); /* available at all hours */
+ user->private_u.bad_password_count = 0;
+ user->private_u.logon_count = 0;
+ user->private_u.unknown_6 = 0x000004ec; /* don't know */
/* Some parts of samba strlen their pdb_get...() returns,
so this keeps the interface unchanged for now. */
- user->private.username = "";
- user->private.domain = "";
- user->private.nt_username = "";
- user->private.full_name = "";
- user->private.home_dir = "";
- user->private.logon_script = "";
- user->private.profile_path = "";
- user->private.acct_desc = "";
- user->private.workstations = "";
- user->private.unknown_str = "";
- user->private.munged_dial = "";
-
- user->private.plaintext_pw = NULL;
+ user->private_u.username = "";
+ user->private_u.domain = "";
+ user->private_u.nt_username = "";
+ user->private_u.full_name = "";
+ user->private_u.home_dir = "";
+ user->private_u.logon_script = "";
+ user->private_u.profile_path = "";
+ user->private_u.acct_desc = "";
+ user->private_u.workstations = "";
+ user->private_u.unknown_str = "";
+ user->private_u.munged_dial = "";
+
+ user->private_u.plaintext_pw = NULL;
/*
Unless we know otherwise have a Account Control Bit
asks for a filtered list of users.
*/
- user->private.acct_ctrl = ACB_NORMAL;
+ user->private_u.acct_ctrl = ACB_NORMAL;
}
static void destroy_pdb_talloc(SAM_ACCOUNT **user)
{
if (*user) {
- data_blob_clear_free(&((*user)->private.lm_pw));
- data_blob_clear_free(&((*user)->private.nt_pw));
+ data_blob_clear_free(&((*user)->private_u.lm_pw));
+ data_blob_clear_free(&((*user)->private_u.nt_pw));
- if((*user)->private.plaintext_pw!=NULL)
- memset((*user)->private.plaintext_pw,'\0',strlen((*user)->private.plaintext_pw));
+ if((*user)->private_u.plaintext_pw!=NULL)
+ memset((*user)->private_u.plaintext_pw,'\0',strlen((*user)->private_u.plaintext_pw));
talloc_destroy((*user)->mem_ctx);
*user = NULL;
}
/* Kill off sensitive data. Free()ed by the
talloc mechinism */
- data_blob_clear_free(&(user->private.lm_pw));
- data_blob_clear_free(&(user->private.nt_pw));
- if (user->private.plaintext_pw!=NULL)
- memset(user->private.plaintext_pw,'\0',strlen(user->private.plaintext_pw));
+ data_blob_clear_free(&(user->private_u.lm_pw));
+ data_blob_clear_free(&(user->private_u.nt_pw));
+ if (user->private_u.plaintext_pw!=NULL)
+ memset(user->private_u.plaintext_pw,'\0',strlen(user->private_u.plaintext_pw));
- if (user->private.backend_private_data && user->private.backend_private_data_free_fn) {
- user->private.backend_private_data_free_fn(&user->private.backend_private_data);
+ if (user->private_u.backend_private_data && user->private_u.backend_private_data_free_fn) {
+ user->private_u.backend_private_data_free_fn(&user->private_u.backend_private_data);
}
}
uint16 pdb_get_acct_ctrl (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.acct_ctrl);
+ return (sampass->private_u.acct_ctrl);
else
return (ACB_DISABLED);
}
time_t pdb_get_logon_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.logon_time);
+ return (sampass->private_u.logon_time);
else
return (0);
}
time_t pdb_get_logoff_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.logoff_time);
+ return (sampass->private_u.logoff_time);
else
return (-1);
}
time_t pdb_get_kickoff_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.kickoff_time);
+ return (sampass->private_u.kickoff_time);
else
return (-1);
}
time_t pdb_get_bad_password_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.bad_password_time);
+ return (sampass->private_u.bad_password_time);
else
return (-1);
}
time_t pdb_get_pass_last_set_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.pass_last_set_time);
+ return (sampass->private_u.pass_last_set_time);
else
return (-1);
}
time_t pdb_get_pass_can_change_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.pass_can_change_time);
+ return (sampass->private_u.pass_can_change_time);
else
return (-1);
}
time_t pdb_get_pass_must_change_time (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.pass_must_change_time);
+ return (sampass->private_u.pass_must_change_time);
else
return (-1);
}
uint16 pdb_get_logon_divs (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.logon_divs);
+ return (sampass->private_u.logon_divs);
else
return (-1);
}
uint32 pdb_get_hours_len (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.hours_len);
+ return (sampass->private_u.hours_len);
else
return (-1);
}
const uint8* pdb_get_hours (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.hours);
+ return (sampass->private_u.hours);
else
return (NULL);
}
const uint8* pdb_get_nt_passwd (const SAM_ACCOUNT *sampass)
{
if (sampass) {
- SMB_ASSERT((!sampass->private.nt_pw.data)
- || sampass->private.nt_pw.length == NT_HASH_LEN);
- return ((uint8*)sampass->private.nt_pw.data);
+ SMB_ASSERT((!sampass->private_u.nt_pw.data)
+ || sampass->private_u.nt_pw.length == NT_HASH_LEN);
+ return ((uint8*)sampass->private_u.nt_pw.data);
}
else
return (NULL);
const uint8* pdb_get_lanman_passwd (const SAM_ACCOUNT *sampass)
{
if (sampass) {
- SMB_ASSERT((!sampass->private.lm_pw.data)
- || sampass->private.lm_pw.length == LM_HASH_LEN);
- return ((uint8*)sampass->private.lm_pw.data);
+ SMB_ASSERT((!sampass->private_u.lm_pw.data)
+ || sampass->private_u.lm_pw.length == LM_HASH_LEN);
+ return ((uint8*)sampass->private_u.lm_pw.data);
}
else
return (NULL);
const uint8* pdb_get_pw_history (const SAM_ACCOUNT *sampass, uint32 *current_hist_len)
{
if (sampass) {
- SMB_ASSERT((!sampass->private.nt_pw_his.data)
- || ((sampass->private.nt_pw_his.length % PW_HISTORY_ENTRY_LEN) == 0));
- *current_hist_len = sampass->private.nt_pw_his.length / PW_HISTORY_ENTRY_LEN;
- return ((uint8*)sampass->private.nt_pw_his.data);
+ SMB_ASSERT((!sampass->private_u.nt_pw_his.data)
+ || ((sampass->private_u.nt_pw_his.length % PW_HISTORY_ENTRY_LEN) == 0));
+ *current_hist_len = sampass->private_u.nt_pw_his.length / PW_HISTORY_ENTRY_LEN;
+ return ((uint8*)sampass->private_u.nt_pw_his.data);
} else {
*current_hist_len = 0;
return (NULL);
const char* pdb_get_plaintext_passwd (const SAM_ACCOUNT *sampass)
{
if (sampass) {
- return (sampass->private.plaintext_pw);
+ return (sampass->private_u.plaintext_pw);
}
else
return (NULL);
const DOM_SID *pdb_get_user_sid(const SAM_ACCOUNT *sampass)
{
if (sampass)
- return &sampass->private.user_sid;
+ return &sampass->private_u.user_sid;
else
return (NULL);
}
const DOM_SID *pdb_get_group_sid(const SAM_ACCOUNT *sampass)
{
if (sampass)
- return &sampass->private.group_sid;
+ return &sampass->private_u.group_sid;
else
return (NULL);
}
{
enum pdb_value_state ret = PDB_DEFAULT;
- if (!sampass || !sampass->private.change_flags || !sampass->private.set_flags)
+ if (!sampass || !sampass->private_u.change_flags || !sampass->private_u.set_flags)
return ret;
- if (bitmap_query(sampass->private.set_flags, element)) {
+ if (bitmap_query(sampass->private_u.set_flags, element)) {
DEBUG(11, ("element %d: SET\n", element));
ret = PDB_SET;
}
- if (bitmap_query(sampass->private.change_flags, element)) {
+ if (bitmap_query(sampass->private_u.change_flags, element)) {
DEBUG(11, ("element %d: CHANGED\n", element));
ret = PDB_CHANGED;
}
const char* pdb_get_username (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.username);
+ return (sampass->private_u.username);
else
return (NULL);
}
const char* pdb_get_domain (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.domain);
+ return (sampass->private_u.domain);
else
return (NULL);
}
const char* pdb_get_nt_username (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.nt_username);
+ return (sampass->private_u.nt_username);
else
return (NULL);
}
const char* pdb_get_fullname (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.full_name);
+ return (sampass->private_u.full_name);
else
return (NULL);
}
const char* pdb_get_homedir (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.home_dir);
+ return (sampass->private_u.home_dir);
else
return (NULL);
}
const char* pdb_get_unix_homedir (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.unix_home_dir);
+ return (sampass->private_u.unix_home_dir);
else
return (NULL);
}
const char* pdb_get_dir_drive (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.dir_drive);
+ return (sampass->private_u.dir_drive);
else
return (NULL);
}
const char* pdb_get_logon_script (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.logon_script);
+ return (sampass->private_u.logon_script);
else
return (NULL);
}
const char* pdb_get_profile_path (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.profile_path);
+ return (sampass->private_u.profile_path);
else
return (NULL);
}
const char* pdb_get_acct_desc (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.acct_desc);
+ return (sampass->private_u.acct_desc);
else
return (NULL);
}
const char* pdb_get_workstations (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.workstations);
+ return (sampass->private_u.workstations);
else
return (NULL);
}
const char* pdb_get_unknown_str (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.unknown_str);
+ return (sampass->private_u.unknown_str);
else
return (NULL);
}
const char* pdb_get_munged_dial (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.munged_dial);
+ return (sampass->private_u.munged_dial);
else
return (NULL);
}
uint16 pdb_get_bad_password_count(const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.bad_password_count);
+ return (sampass->private_u.bad_password_count);
else
return 0;
}
uint16 pdb_get_logon_count(const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.logon_count);
+ return (sampass->private_u.logon_count);
else
return 0;
}
uint32 pdb_get_unknown_6 (const SAM_ACCOUNT *sampass)
{
if (sampass)
- return (sampass->private.unknown_6);
+ return (sampass->private_u.unknown_6);
else
return (-1);
}
void *pdb_get_backend_private_data (const SAM_ACCOUNT *sampass, const struct pdb_methods *my_methods)
{
- if (sampass && my_methods == sampass->private.backend_private_methods)
- return sampass->private.backend_private_data;
+ if (sampass && my_methods == sampass->private_u.backend_private_methods)
+ return sampass->private_u.backend_private_data;
else
return NULL;
}
if (!sampass)
return False;
- sampass->private.acct_ctrl = acct_ctrl;
+ sampass->private_u.acct_ctrl = acct_ctrl;
return pdb_set_init_flags(sampass, PDB_ACCTCTRL, flag);
}
if (!sampass)
return False;
- sampass->private.logon_time = mytime;
+ sampass->private_u.logon_time = mytime;
return pdb_set_init_flags(sampass, PDB_LOGONTIME, flag);
}
if (!sampass)
return False;
- sampass->private.logoff_time = mytime;
+ sampass->private_u.logoff_time = mytime;
return pdb_set_init_flags(sampass, PDB_LOGOFFTIME, flag);
}
if (!sampass)
return False;
- sampass->private.kickoff_time = mytime;
+ sampass->private_u.kickoff_time = mytime;
return pdb_set_init_flags(sampass, PDB_KICKOFFTIME, flag);
}
if (!sampass)
return False;
- sampass->private.bad_password_time = mytime;
+ sampass->private_u.bad_password_time = mytime;
return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_TIME, flag);
}
if (!sampass)
return False;
- sampass->private.pass_can_change_time = mytime;
+ sampass->private_u.pass_can_change_time = mytime;
return pdb_set_init_flags(sampass, PDB_CANCHANGETIME, flag);
}
if (!sampass)
return False;
- sampass->private.pass_must_change_time = mytime;
+ sampass->private_u.pass_must_change_time = mytime;
return pdb_set_init_flags(sampass, PDB_MUSTCHANGETIME, flag);
}
if (!sampass)
return False;
- sampass->private.pass_last_set_time = mytime;
+ sampass->private_u.pass_last_set_time = mytime;
return pdb_set_init_flags(sampass, PDB_PASSLASTSET, flag);
}
if (!sampass)
return False;
- sampass->private.hours_len = len;
+ sampass->private_u.hours_len = len;
return pdb_set_init_flags(sampass, PDB_HOURSLEN, flag);
}
if (!sampass)
return False;
- sampass->private.logon_divs = hours;
+ sampass->private_u.logon_divs = hours;
return pdb_set_init_flags(sampass, PDB_LOGONDIVS, flag);
}
if (!sampass || !sampass->mem_ctx)
return False;
- if (!sampass->private.set_flags) {
- if ((sampass->private.set_flags =
+ if (!sampass->private_u.set_flags) {
+ if ((sampass->private_u.set_flags =
bitmap_talloc(sampass->mem_ctx,
PDB_COUNT))==NULL) {
DEBUG(0,("bitmap_talloc failed\n"));
return False;
}
}
- if (!sampass->private.change_flags) {
- if ((sampass->private.change_flags =
+ if (!sampass->private_u.change_flags) {
+ if ((sampass->private_u.change_flags =
bitmap_talloc(sampass->mem_ctx,
PDB_COUNT))==NULL) {
DEBUG(0,("bitmap_talloc failed\n"));
switch(value_flag) {
case PDB_CHANGED:
- if (!bitmap_set(sampass->private.change_flags, element)) {
+ if (!bitmap_set(sampass->private_u.change_flags, element)) {
DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
return False;
}
- if (!bitmap_set(sampass->private.set_flags, element)) {
+ if (!bitmap_set(sampass->private_u.set_flags, element)) {
DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
return False;
}
DEBUG(11, ("element %d -> now CHANGED\n", element));
break;
case PDB_SET:
- if (!bitmap_clear(sampass->private.change_flags, element)) {
+ if (!bitmap_clear(sampass->private_u.change_flags, element)) {
DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
return False;
}
- if (!bitmap_set(sampass->private.set_flags, element)) {
+ if (!bitmap_set(sampass->private_u.set_flags, element)) {
DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
return False;
}
break;
case PDB_DEFAULT:
default:
- if (!bitmap_clear(sampass->private.change_flags, element)) {
+ if (!bitmap_clear(sampass->private_u.change_flags, element)) {
DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
return False;
}
- if (!bitmap_clear(sampass->private.set_flags, element)) {
+ if (!bitmap_clear(sampass->private_u.set_flags, element)) {
DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
return False;
}
if (!sampass || !u_sid)
return False;
- sid_copy(&sampass->private.user_sid, u_sid);
+ sid_copy(&sampass->private_u.user_sid, u_sid);
DEBUG(10, ("pdb_set_user_sid: setting user sid %s\n",
- sid_string_static(&sampass->private.user_sid)));
+ sid_string_static(&sampass->private_u.user_sid)));
return pdb_set_init_flags(sampass, PDB_USERSID, flag);
}
if (!sampass || !g_sid)
return False;
- sid_copy(&sampass->private.group_sid, g_sid);
+ sid_copy(&sampass->private_u.group_sid, g_sid);
DEBUG(10, ("pdb_set_group_sid: setting group sid %s\n",
- sid_string_static(&sampass->private.group_sid)));
+ sid_string_static(&sampass->private_u.group_sid)));
return pdb_set_init_flags(sampass, PDB_GROUPSID, flag);
}
if (username) {
DEBUG(10, ("pdb_set_username: setting username %s, was %s\n", username,
- (sampass->private.username)?(sampass->private.username):"NULL"));
+ (sampass->private_u.username)?(sampass->private_u.username):"NULL"));
- sampass->private.username = talloc_strdup(sampass->mem_ctx, username);
+ sampass->private_u.username = talloc_strdup(sampass->mem_ctx, username);
- if (!sampass->private.username) {
+ if (!sampass->private_u.username) {
DEBUG(0, ("pdb_set_username: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.username = PDB_NOT_QUITE_NULL;
+ sampass->private_u.username = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_USERNAME, flag);
if (domain) {
DEBUG(10, ("pdb_set_domain: setting domain %s, was %s\n", domain,
- (sampass->private.domain)?(sampass->private.domain):"NULL"));
+ (sampass->private_u.domain)?(sampass->private_u.domain):"NULL"));
- sampass->private.domain = talloc_strdup(sampass->mem_ctx, domain);
+ sampass->private_u.domain = talloc_strdup(sampass->mem_ctx, domain);
- if (!sampass->private.domain) {
+ if (!sampass->private_u.domain) {
DEBUG(0, ("pdb_set_domain: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.domain = PDB_NOT_QUITE_NULL;
+ sampass->private_u.domain = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_DOMAIN, flag);
if (nt_username) {
DEBUG(10, ("pdb_set_nt_username: setting nt username %s, was %s\n", nt_username,
- (sampass->private.nt_username)?(sampass->private.nt_username):"NULL"));
+ (sampass->private_u.nt_username)?(sampass->private_u.nt_username):"NULL"));
- sampass->private.nt_username = talloc_strdup(sampass->mem_ctx, nt_username);
+ sampass->private_u.nt_username = talloc_strdup(sampass->mem_ctx, nt_username);
- if (!sampass->private.nt_username) {
+ if (!sampass->private_u.nt_username) {
DEBUG(0, ("pdb_set_nt_username: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.nt_username = PDB_NOT_QUITE_NULL;
+ sampass->private_u.nt_username = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_NTUSERNAME, flag);
if (full_name) {
DEBUG(10, ("pdb_set_full_name: setting full name %s, was %s\n", full_name,
- (sampass->private.full_name)?(sampass->private.full_name):"NULL"));
+ (sampass->private_u.full_name)?(sampass->private_u.full_name):"NULL"));
- sampass->private.full_name = talloc_strdup(sampass->mem_ctx, full_name);
+ sampass->private_u.full_name = talloc_strdup(sampass->mem_ctx, full_name);
- if (!sampass->private.full_name) {
+ if (!sampass->private_u.full_name) {
DEBUG(0, ("pdb_set_fullname: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.full_name = PDB_NOT_QUITE_NULL;
+ sampass->private_u.full_name = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_FULLNAME, flag);
if (logon_script) {
DEBUG(10, ("pdb_set_logon_script: setting logon script %s, was %s\n", logon_script,
- (sampass->private.logon_script)?(sampass->private.logon_script):"NULL"));
+ (sampass->private_u.logon_script)?(sampass->private_u.logon_script):"NULL"));
- sampass->private.logon_script = talloc_strdup(sampass->mem_ctx, logon_script);
+ sampass->private_u.logon_script = talloc_strdup(sampass->mem_ctx, logon_script);
- if (!sampass->private.logon_script) {
+ if (!sampass->private_u.logon_script) {
DEBUG(0, ("pdb_set_logon_script: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.logon_script = PDB_NOT_QUITE_NULL;
+ sampass->private_u.logon_script = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_LOGONSCRIPT, flag);
if (profile_path) {
DEBUG(10, ("pdb_set_profile_path: setting profile path %s, was %s\n", profile_path,
- (sampass->private.profile_path)?(sampass->private.profile_path):"NULL"));
+ (sampass->private_u.profile_path)?(sampass->private_u.profile_path):"NULL"));
- sampass->private.profile_path = talloc_strdup(sampass->mem_ctx, profile_path);
+ sampass->private_u.profile_path = talloc_strdup(sampass->mem_ctx, profile_path);
- if (!sampass->private.profile_path) {
+ if (!sampass->private_u.profile_path) {
DEBUG(0, ("pdb_set_profile_path: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.profile_path = PDB_NOT_QUITE_NULL;
+ sampass->private_u.profile_path = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_PROFILE, flag);
if (dir_drive) {
DEBUG(10, ("pdb_set_dir_drive: setting dir drive %s, was %s\n", dir_drive,
- (sampass->private.dir_drive)?(sampass->private.dir_drive):"NULL"));
+ (sampass->private_u.dir_drive)?(sampass->private_u.dir_drive):"NULL"));
- sampass->private.dir_drive = talloc_strdup(sampass->mem_ctx, dir_drive);
+ sampass->private_u.dir_drive = talloc_strdup(sampass->mem_ctx, dir_drive);
- if (!sampass->private.dir_drive) {
+ if (!sampass->private_u.dir_drive) {
DEBUG(0, ("pdb_set_dir_drive: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.dir_drive = PDB_NOT_QUITE_NULL;
+ sampass->private_u.dir_drive = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_DRIVE, flag);
if (home_dir) {
DEBUG(10, ("pdb_set_homedir: setting home dir %s, was %s\n", home_dir,
- (sampass->private.home_dir)?(sampass->private.home_dir):"NULL"));
+ (sampass->private_u.home_dir)?(sampass->private_u.home_dir):"NULL"));
- sampass->private.home_dir = talloc_strdup(sampass->mem_ctx, home_dir);
+ sampass->private_u.home_dir = talloc_strdup(sampass->mem_ctx, home_dir);
- if (!sampass->private.home_dir) {
+ if (!sampass->private_u.home_dir) {
DEBUG(0, ("pdb_set_home_dir: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.home_dir = PDB_NOT_QUITE_NULL;
+ sampass->private_u.home_dir = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_SMBHOME, flag);
if (unix_home_dir) {
DEBUG(10, ("pdb_set_unix_homedir: setting home dir %s, was %s\n", unix_home_dir,
- (sampass->private.unix_home_dir)?(sampass->private.unix_home_dir):"NULL"));
+ (sampass->private_u.unix_home_dir)?(sampass->private_u.unix_home_dir):"NULL"));
- sampass->private.unix_home_dir = talloc_strdup(sampass->mem_ctx,
+ sampass->private_u.unix_home_dir = talloc_strdup(sampass->mem_ctx,
unix_home_dir);
- if (!sampass->private.unix_home_dir) {
+ if (!sampass->private_u.unix_home_dir) {
DEBUG(0, ("pdb_set_unix_home_dir: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.unix_home_dir = PDB_NOT_QUITE_NULL;
+ sampass->private_u.unix_home_dir = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_UNIXHOMEDIR, flag);
return False;
if (acct_desc) {
- sampass->private.acct_desc = talloc_strdup(sampass->mem_ctx, acct_desc);
+ sampass->private_u.acct_desc = talloc_strdup(sampass->mem_ctx, acct_desc);
- if (!sampass->private.acct_desc) {
+ if (!sampass->private_u.acct_desc) {
DEBUG(0, ("pdb_set_acct_desc: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.acct_desc = PDB_NOT_QUITE_NULL;
+ sampass->private_u.acct_desc = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_ACCTDESC, flag);
if (workstations) {
DEBUG(10, ("pdb_set_workstations: setting workstations %s, was %s\n", workstations,
- (sampass->private.workstations)?(sampass->private.workstations):"NULL"));
+ (sampass->private_u.workstations)?(sampass->private_u.workstations):"NULL"));
- sampass->private.workstations = talloc_strdup(sampass->mem_ctx, workstations);
+ sampass->private_u.workstations = talloc_strdup(sampass->mem_ctx, workstations);
- if (!sampass->private.workstations) {
+ if (!sampass->private_u.workstations) {
DEBUG(0, ("pdb_set_workstations: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.workstations = PDB_NOT_QUITE_NULL;
+ sampass->private_u.workstations = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_WORKSTATIONS, flag);
return False;
if (unknown_str) {
- sampass->private.unknown_str = talloc_strdup(sampass->mem_ctx, unknown_str);
+ sampass->private_u.unknown_str = talloc_strdup(sampass->mem_ctx, unknown_str);
- if (!sampass->private.unknown_str) {
+ if (!sampass->private_u.unknown_str) {
DEBUG(0, ("pdb_set_unknown_str: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.unknown_str = PDB_NOT_QUITE_NULL;
+ sampass->private_u.unknown_str = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_UNKNOWNSTR, flag);
return False;
if (munged_dial) {
- sampass->private.munged_dial = talloc_strdup(sampass->mem_ctx, munged_dial);
+ sampass->private_u.munged_dial = talloc_strdup(sampass->mem_ctx, munged_dial);
- if (!sampass->private.munged_dial) {
+ if (!sampass->private_u.munged_dial) {
DEBUG(0, ("pdb_set_munged_dial: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.munged_dial = PDB_NOT_QUITE_NULL;
+ sampass->private_u.munged_dial = PDB_NOT_QUITE_NULL;
}
return pdb_set_init_flags(sampass, PDB_MUNGEDDIAL, flag);
if (!sampass)
return False;
- data_blob_clear_free(&sampass->private.nt_pw);
+ data_blob_clear_free(&sampass->private_u.nt_pw);
if (pwd) {
- sampass->private.nt_pw = data_blob(pwd, NT_HASH_LEN);
+ sampass->private_u.nt_pw = data_blob(pwd, NT_HASH_LEN);
} else {
- sampass->private.nt_pw = data_blob(NULL, 0);
+ sampass->private_u.nt_pw = data_blob(NULL, 0);
}
return pdb_set_init_flags(sampass, PDB_NTPASSWD, flag);
if (!sampass)
return False;
- data_blob_clear_free(&sampass->private.lm_pw);
+ data_blob_clear_free(&sampass->private_u.lm_pw);
if (pwd) {
- sampass->private.lm_pw = data_blob(pwd, LM_HASH_LEN);
+ sampass->private_u.lm_pw = data_blob(pwd, LM_HASH_LEN);
} else {
- sampass->private.lm_pw = data_blob(NULL, 0);
+ sampass->private_u.lm_pw = data_blob(NULL, 0);
}
return pdb_set_init_flags(sampass, PDB_LMPASSWD, flag);
return False;
if (historyLen && pwd){
- sampass->private.nt_pw_his = data_blob_talloc(sampass->mem_ctx,
+ sampass->private_u.nt_pw_his = data_blob_talloc(sampass->mem_ctx,
pwd, historyLen*PW_HISTORY_ENTRY_LEN);
- if (!sampass->private.nt_pw_his.length) {
+ if (!sampass->private_u.nt_pw_his.length) {
DEBUG(0, ("pdb_set_pw_history: data_blob_talloc() failed!\n"));
return False;
}
} else {
- sampass->private.nt_pw_his = data_blob_talloc(sampass->mem_ctx, NULL, 0);
+ sampass->private_u.nt_pw_his = data_blob_talloc(sampass->mem_ctx, NULL, 0);
}
return pdb_set_init_flags(sampass, PDB_PWHISTORY, flag);
return False;
if (password) {
- if (sampass->private.plaintext_pw!=NULL)
- memset(sampass->private.plaintext_pw,'\0',strlen(sampass->private.plaintext_pw)+1);
+ if (sampass->private_u.plaintext_pw!=NULL)
+ memset(sampass->private_u.plaintext_pw,'\0',strlen(sampass->private_u.plaintext_pw)+1);
- sampass->private.plaintext_pw = talloc_strdup(sampass->mem_ctx, password);
+ sampass->private_u.plaintext_pw = talloc_strdup(sampass->mem_ctx, password);
- if (!sampass->private.plaintext_pw) {
+ if (!sampass->private_u.plaintext_pw) {
DEBUG(0, ("pdb_set_unknown_str: talloc_strdup() failed!\n"));
return False;
}
} else {
- sampass->private.plaintext_pw = NULL;
+ sampass->private_u.plaintext_pw = NULL;
}
return pdb_set_init_flags(sampass, PDB_PLAINTEXT_PW, flag);
if (!sampass)
return False;
- sampass->private.bad_password_count = bad_password_count;
+ sampass->private_u.bad_password_count = bad_password_count;
return pdb_set_init_flags(sampass, PDB_BAD_PASSWORD_COUNT, flag);
}
if (!sampass)
return False;
- sampass->private.logon_count = logon_count;
+ sampass->private_u.logon_count = logon_count;
return pdb_set_init_flags(sampass, PDB_LOGON_COUNT, flag);
}
if (!sampass)
return False;
- sampass->private.unknown_6 = unkn;
+ sampass->private_u.unknown_6 = unkn;
return pdb_set_init_flags(sampass, PDB_UNKNOWN6, flag);
}
return False;
if (!hours) {
- memset ((char *)sampass->private.hours, 0, MAX_HOURS_LEN);
+ memset ((char *)sampass->private_u.hours, 0, MAX_HOURS_LEN);
return True;
}
- memcpy (sampass->private.hours, hours, MAX_HOURS_LEN);
+ memcpy (sampass->private_u.hours, hours, MAX_HOURS_LEN);
return pdb_set_init_flags(sampass, PDB_HOURS, flag);
}
if (!sampass)
return False;
- if (sampass->private.backend_private_data && sampass->private.backend_private_data_free_fn) {
- sampass->private.backend_private_data_free_fn(&sampass->private.backend_private_data);
+ if (sampass->private_u.backend_private_data && sampass->private_u.backend_private_data_free_fn) {
+ sampass->private_u.backend_private_data_free_fn(&sampass->private_u.backend_private_data);
}
- sampass->private.backend_private_data = private_data;
- sampass->private.backend_private_data_free_fn = free_fn;
- sampass->private.backend_private_methods = my_methods;
+ sampass->private_u.backend_private_data = private_data;
+ sampass->private_u.backend_private_data_free_fn = free_fn;
+ sampass->private_u.backend_private_methods = my_methods;
return pdb_set_init_flags(sampass, PDB_BACKEND_PRIVATE_DATA, flag);
}
static BOOL next_entry_users(struct pdb_search *s,
struct samr_displayentry *entry)
{
- struct user_search *state = s->private;
+ struct user_search *state = s->private_data;
SAM_ACCOUNT *user = NULL;
NTSTATUS status;
state->acct_flags = acct_flags;
- search->private = state;
+ search->private_data = state;
search->next_entry = next_entry_users;
search->search_end = search_end_users;
return True;
static BOOL next_entry_groups(struct pdb_search *s,
struct samr_displayentry *entry)
{
- struct group_search *state = s->private;
+ struct group_search *state = s->private_data;
uint32 rid;
GROUP_MAP *map = &state->groups[state->current_group];
static void search_end_groups(struct pdb_search *search)
{
- struct group_search *state = search->private;
+ struct group_search *state = search->private_data;
SAFE_FREE(state->groups);
}
}
state->current_group = 0;
- search->private = state;
+ search->private_data = state;
search->next_entry = next_entry_groups;
search->search_end = search_end_groups;
return True;
static BOOL ldapsam_search_firstpage(struct pdb_search *search)
{
- struct ldap_search_state *state = search->private;
+ struct ldap_search_state *state = search->private_data;
LDAP *ld;
int rc = LDAP_OPERATIONS_ERROR;
static BOOL ldapsam_search_nextpage(struct pdb_search *search)
{
- struct ldap_search_state *state = search->private;
+ struct ldap_search_state *state = search->private_data;
LDAP *ld = state->connection->ldap_struct;
int rc;
static BOOL ldapsam_search_next_entry(struct pdb_search *search,
struct samr_displayentry *entry)
{
- struct ldap_search_state *state = search->private;
+ struct ldap_search_state *state = search->private_data;
LDAP *ld = state->connection->ldap_struct;
BOOL result;
static void ldapsam_search_end(struct pdb_search *search)
{
- struct ldap_search_state *state = search->private;
+ struct ldap_search_state *state = search->private_data;
int rc;
if (state->pagedresults_cookie == NULL)
return False;
}
- search->private = state;
+ search->private_data = state;
search->next_entry = ldapsam_search_next_entry;
search->search_end = ldapsam_search_end;
return False;
}
- search->private = state;
+ search->private_data = state;
search->next_entry = ldapsam_search_next_entry;
search->search_end = ldapsam_search_end;
nt_devmode->reserved2,
nt_devmode->panningwidth,
nt_devmode->panningheight,
- nt_devmode->private);
+ nt_devmode->nt_dev_private);
- if (nt_devmode->private) {
+ if (nt_devmode->nt_dev_private) {
len += tdb_pack(buf+len, buflen-len, "B",
nt_devmode->driverextra,
- nt_devmode->private);
+ nt_devmode->nt_dev_private);
}
DEBUG(8,("Packed devicemode [%s]\n", nt_devmode->formname));
nt_devmode->panningwidth = 0;
nt_devmode->panningheight = 0;
- nt_devmode->private = NULL;
+ nt_devmode->nt_dev_private = NULL;
return nt_devmode;
}
return NULL;
}
- new_nt_devicemode->private = NULL;
- if (nt_devicemode->private != NULL) {
- if ((new_nt_devicemode->private = memdup(nt_devicemode->private, nt_devicemode->driverextra)) == NULL) {
+ new_nt_devicemode->nt_dev_private = NULL;
+ if (nt_devicemode->nt_dev_private != NULL) {
+ if ((new_nt_devicemode->nt_dev_private = memdup(nt_devicemode->nt_dev_private, nt_devicemode->driverextra)) == NULL) {
SAFE_FREE(new_nt_devicemode);
DEBUG(0,("dup_nt_devicemode: malloc fail.\n"));
return NULL;
DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n"));
- SAFE_FREE(nt_devmode->private);
+ SAFE_FREE(nt_devmode->nt_dev_private);
SAFE_FREE(*devmode_ptr);
}
&devmode.reserved2,
&devmode.panningwidth,
&devmode.panningheight,
- &devmode.private);
+ &devmode.nt_dev_private);
- if (devmode.private) {
+ if (devmode.nt_dev_private) {
/* the len in tdb_unpack is an int value and
* devmode.driverextra is only a short
*/
- len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.private);
+ len += tdb_unpack(buf+len, buflen-len, "B", &extra_len, &devmode.nt_dev_private);
devmode.driverextra=(uint16)extra_len;
/* check to catch an invalid TDB entry so we don't segfault */
if (devmode.driverextra == 0) {
- devmode.private = NULL;
+ devmode.nt_dev_private = NULL;
}
}
*nt_devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode));
DEBUG(8,("Unpacked devicemode [%s](%s)\n", devmode.devicename, devmode.formname));
- if (devmode.private)
+ if (devmode.nt_dev_private)
DEBUG(8,("with a private section of %d bytes\n", devmode.driverextra));
return len;
/* Prototypes from common.h */
-NSS_STATUS winbindd_request(int req_type,
+NSS_STATUS winbindd_request_response(int req_type,
struct winbindd_request *request,
struct winbindd_response *response);
fstrcpy(request.data.name.name, name);
}
- if (winbindd_request(WINBINDD_LOOKUPNAME, &request, &response)
+ if (winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
fstrcpy(request.data.sid, sid);
- if (winbindd_request(WINBINDD_LOOKUPSID, &request, &response)
+ if (winbindd_request_response(WINBINDD_LOOKUPSID, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
ZERO_STRUCT(response);
- if (winbindd_request(WINBINDD_LIST_USERS, NULL, &response)
+ if (winbindd_request_response(WINBINDD_LIST_USERS, NULL, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
ZERO_STRUCT(response);
- if (winbindd_request(WINBINDD_LIST_GROUPS, NULL, &response)
+ if (winbindd_request_response(WINBINDD_LIST_GROUPS, NULL, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
ZERO_STRUCT(response);
- if (winbindd_request(WINBINDD_LIST_TRUSTDOM, NULL, &response)
+ if (winbindd_request_response(WINBINDD_LIST_TRUSTDOM, NULL, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
ZERO_STRUCT(response);
- if (winbindd_request(WINBINDD_CHECK_MACHACC, NULL, &response)
+ if (winbindd_request_response(WINBINDD_CHECK_MACHACC, NULL, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
request.data.uid = id;
- if (winbindd_request(WINBINDD_UID_TO_SID, &request, &response)
+ if (winbindd_request_response(WINBINDD_UID_TO_SID, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
request.data.gid = id;
- if (winbindd_request(WINBINDD_GID_TO_SID, &request, &response)
+ if (winbindd_request_response(WINBINDD_GID_TO_SID, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
fstrcpy(request.data.sid, sid);
- if (winbindd_request(WINBINDD_SID_TO_UID, &request, &response)
+ if (winbindd_request_response(WINBINDD_SID_TO_UID, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
fstrcpy(request.data.sid, sid);
- if (winbindd_request(WINBINDD_SID_TO_GID, &request, &response)
+ if (winbindd_request_response(WINBINDD_SID_TO_GID, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
fstrcpy(request.data.auth.user, username);
fstrcpy(request.data.auth.pass, password);
- if (winbindd_request(WINBINDD_PAM_AUTH, &request, &response)
+ if (winbindd_request_response(WINBINDD_PAM_AUTH, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
request.data.auth_crap.nt_resp_len = 24;
}
- if (winbindd_request(WINBINDD_PAM_AUTH_CRAP, &request, &response)
+ if (winbindd_request_response(WINBINDD_PAM_AUTH_CRAP, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
- if (winbindd_request(WINBINDD_SMBD_AUTH_CRAP, &request, &response)
+ if (winbindd_request_response(WINBINDD_SMBD_AUTH_CRAP, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
fstrcpy(request.data.username, username);
- if (winbindd_request(WINBINDD_GETPWNAM, &request, &response)
+ if (winbindd_request_response(WINBINDD_GETPWNAM, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
request.data.uid = uid;
- if (winbindd_request(WINBINDD_GETPWUID, &request, &response)
+ if (winbindd_request_response(WINBINDD_GETPWUID, &request, &response)
!= NSS_STATUS_SUCCESS) {
PyErr_SetString(winbind_error, "lookup failed");
return NULL;
if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
ZERO_STRUCT (in);
- *class_len = out.class.string->uni_max_len;
+ *class_len = out.key_class.string->uni_max_len;
if ( *class_len > saved_class_len )
return out.status;
if ( !W_ERROR_IS_OK( out.status ) )
return out.status;
- *class_len = out.class.string->uni_max_len;
- unistr2_to_ascii(key_class, out.class.string, saved_class_len-1);
+ *class_len = out.key_class.string->uni_max_len;
+ unistr2_to_ascii(key_class, out.key_class.string, saved_class_len-1);
*num_subkeys = out.num_subkeys ;
*max_subkeylen = out.max_subkeylen ;
*num_values = out.num_values ;
********************************************************************/
void init_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
- char *name, char *class, uint32 access_desired,
+ char *name, char *key_class, uint32 access_desired,
SEC_DESC_BUF *sec_buf)
{
ZERO_STRUCTP(q_c);
init_unistr4( &q_c->name, name, UNI_STR_TERMINATE );
- init_unistr4( &q_c->class, class, UNI_STR_TERMINATE );
+ init_unistr4( &q_c->key_class, key_class, UNI_STR_TERMINATE );
q_c->access = access_desired;
if(!prs_align(ps))
return False;
- if(!prs_unistr4 ("class", ps, depth, &q_u->class))
+ if(!prs_unistr4 ("key_class", ps, depth, &q_u->key_class))
return False;
if(!prs_align(ps))
return False;
Inits a structure.
********************************************************************/
-void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd, const char *class)
+void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd, const char *key_class)
{
ZERO_STRUCTP(q_o);
memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
- init_unistr4(&q_o->class, class, UNI_STR_TERMINATE);
+ init_unistr4(&q_o->key_class, key_class, UNI_STR_TERMINATE);
}
/*******************************************************************
if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
return False;
- if(!prs_unistr4("class", ps, depth, &q_u->class))
+ if(!prs_unistr4("key_class", ps, depth, &q_u->key_class))
return False;
if(!prs_align(ps))
if(!prs_align(ps))
return False;
- if(!prs_unistr4("class", ps, depth, &r_u->class))
+ if(!prs_unistr4("key_class", ps, depth, &r_u->key_class))
return False;
if(!prs_align(ps))
if (devmode->driverextra!=0) {
if (UNMARSHALLING(ps)) {
- devmode->private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
- if(devmode->private == NULL)
+ devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
+ if(devmode->dev_private == NULL)
return False;
- DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra));
+ DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
}
- DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra));
- if (!prs_uint8s(False, "private", ps, depth,
- devmode->private, devmode->driverextra))
+ DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
+ if (!prs_uint8s(False, "dev_private", ps, depth,
+ devmode->dev_private, devmode->driverextra))
return False;
}
void free_devmode(DEVICEMODE *devmode)
{
if (devmode!=NULL) {
- SAFE_FREE(devmode->private);
+ SAFE_FREE(devmode->dev_private);
SAFE_FREE(devmode);
}
}
if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
return False;
- if (!prs_uint8s(False, "private", ps, depth, q_u->unknown2, 5))
+ if (!prs_uint8s(False, "dev_private", ps, depth, q_u->unknown2, 5))
return False;
return True;
Eventlog_entry *entry)
{
uint8 *offset;
- Eventlog_entry *new = NULL;
+ Eventlog_entry *ee_new = NULL;
- new = PRS_ALLOC_MEM(ps, Eventlog_entry, 1);
- if(new == NULL)
+ ee_new = PRS_ALLOC_MEM(ps, Eventlog_entry, 1);
+ if(ee_new == NULL)
return NULL;
entry->data_record.sid_padding = ((4 - ((entry->data_record.source_name_len
memcpy(offset, &(entry->data_record.user_data), entry->data_record.user_data_len);
offset += entry->data_record.user_data_len;
- memcpy(&(new->record), &entry->record, sizeof(Eventlog_record));
- memcpy(&(new->data_record), &entry->data_record, sizeof(Eventlog_data_record));
- new->data = entry->data;
+ memcpy(&(ee_new->record), &entry->record, sizeof(Eventlog_record));
+ memcpy(&(ee_new->data_record), &entry->data_record, sizeof(Eventlog_data_record));
+ ee_new->data = entry->data;
- return new;
+ return ee_new;
}
-static BOOL _eventlog_add_record_to_resp(EVENTLOG_R_READ_EVENTLOG *r_u, Eventlog_entry *new)
+static BOOL _eventlog_add_record_to_resp(EVENTLOG_R_READ_EVENTLOG *r_u, Eventlog_entry *ee_new)
{
Eventlog_entry *insert_point;
if (NULL == insert_point)
{
- r_u->entry = new;
- new->next = NULL;
+ r_u->entry = ee_new;
+ ee_new->next = NULL;
}
else
{
{
insert_point=insert_point->next;
}
- new->next = NULL;
- insert_point->next = new;
+ ee_new->next = NULL;
+ insert_point->next = ee_new;
}
r_u->num_records++;
- r_u->num_bytes_in_resp += new->record.length;
+ r_u->num_bytes_in_resp += ee_new->record.length;
return True;
}
{
Eventlog_info *info = NULL;
POLICY_HND *handle;
- Eventlog_entry entry, *new;
+ Eventlog_entry entry, *ee_new;
BOOL eof = False, eor = False;
const char *direction = "";
uint32 num_records_read = 0;
_eventlog_read_parse_line(buffer[i], &entry, &eor);
if(eor == True)
{
- /* package new entry */
- if((new = _eventlog_read_package_entry(ps, q_u, r_u, &entry)) == NULL)
+ /* package ee_new entry */
+ if((ee_new = _eventlog_read_package_entry(ps, q_u, r_u, &entry)) == NULL)
{
free(buffer);
return WERR_NOMEM;
}
/* Now see if there is enough room to add */
- if(r_u->num_bytes_in_resp + new->record.length > q_u->max_read_size)
+ if(r_u->num_bytes_in_resp + ee_new->record.length > q_u->max_read_size)
{
- r_u->bytes_in_next_record = new->record.length;
+ r_u->bytes_in_next_record = ee_new->record.length;
/* response would be too big to fit in client-size buffer */
break;
}
- _eventlog_add_record_to_resp(r_u, new);
+ _eventlog_add_record_to_resp(r_u, ee_new);
ZERO_STRUCT(entry);
eor=False;
num_records_read = r_u->num_records - num_records_read;
}
if (from->fields_present & ACCT_LOGON_HOURS) {
- pstring old, new;
+ pstring oldstr, newstr;
DEBUG(15,("INFO_21 LOGON_DIVS: %08X -> %08X\n",pdb_get_logon_divs(to),from->logon_divs));
if (from->logon_divs != pdb_get_logon_divs(to)) {
pdb_set_logon_divs(to, from->logon_divs, PDB_CHANGED);
}
DEBUG(15,("INFO_21 LOGON_HRS.HOURS: %s -> %s\n",pdb_get_hours(to),from->logon_hrs.hours));
- pdb_sethexhours(old, pdb_get_hours(to));
- pdb_sethexhours(new, from->logon_hrs.hours);
- if (!strequal(old, new)) {
+ pdb_sethexhours(oldstr, pdb_get_hours(to));
+ pdb_sethexhours(newstr, from->logon_hrs.hours);
+ if (!strequal(oldstr, newstr)) {
pdb_set_hours(to, from->logon_hrs.hours, PDB_CHANGED);
}
}
return NULL;
}
- d->private = TALLOC_MEMDUP(ctx, devmode->private, devmode->driverextra);
+ d->dev_private = TALLOC_MEMDUP(ctx, devmode->dev_private, devmode->driverextra);
return d;
}
* has a new one. JRA.
*/
- if ((devmode->driverextra != 0) && (devmode->private != NULL)) {
- SAFE_FREE(nt_devmode->private);
+ if ((devmode->driverextra != 0) && (devmode->dev_private != NULL)) {
+ SAFE_FREE(nt_devmode->nt_dev_private);
nt_devmode->driverextra=devmode->driverextra;
- if((nt_devmode->private=SMB_MALLOC_ARRAY(uint8, nt_devmode->driverextra)) == NULL)
+ if((nt_devmode->nt_dev_private=SMB_MALLOC_ARRAY(uint8, nt_devmode->driverextra)) == NULL)
return False;
- memcpy(nt_devmode->private, devmode->private, nt_devmode->driverextra);
+ memcpy(nt_devmode->nt_dev_private, devmode->dev_private, nt_devmode->driverextra);
}
*pp_nt_devmode = nt_devmode;
if (dev == NULL)
return;
- SAFE_FREE(dev->private);
+ SAFE_FREE(dev->dev_private);
SAFE_FREE(dev);
}
devmode->mediatype = ntdevmode->mediatype;
devmode->dithertype = ntdevmode->dithertype;
- if (ntdevmode->private != NULL) {
- if ((devmode->private=(uint8 *)memdup(ntdevmode->private, ntdevmode->driverextra)) == NULL)
+ if (ntdevmode->nt_dev_private != NULL) {
+ if ((devmode->dev_private=(uint8 *)memdup(ntdevmode->nt_dev_private, ntdevmode->driverextra)) == NULL)
return False;
}
gotstart = 1;
}
+ if( $0 ~ /^NODE_STATUS_STRUCT/ ) {
+ gotstart = 1;
+ }
+
if(!gotstart) {
next;
}
return True;
}
- dump_data(100, new_nt_p16, NT_HASH_LEN);
- dump_data(100, pwhistory, PW_HISTORY_ENTRY_LEN*pwHisLen);
+ dump_data(100, (const char *)new_nt_p16, NT_HASH_LEN);
+ dump_data(100, (const char *)pwhistory, PW_HISTORY_ENTRY_LEN*pwHisLen);
memset(zero_md5_nt_pw, '\0', SALTED_MD5_HASH_LEN);
for (i=0; i<pwHisLen; i++) {
connection_struct *conn, *next;
fstring sharename;
- fstrcpy(sharename, buf);
+ fstrcpy(sharename, (const char *)buf);
if (strcmp(sharename, "*") == 0) {
DEBUG(1,("Forcing close of all shares\n"));
wcp->offset = 0;
wcp->alloc_size = alloc_size;
wcp->data_size = 0;
- if((wcp->data = SMB_MALLOC(wcp->alloc_size)) == NULL) {
+ if((wcp->data = (char *)SMB_MALLOC(wcp->alloc_size)) == NULL) {
DEBUG(0,("setup_write_cache: malloc fail for buffer size %u.\n",
(unsigned int)wcp->alloc_size ));
SAFE_FREE(wcp);
static BOOL api_rpc_trans_reply(char *outbuf, smb_np_struct *p)
{
BOOL is_data_outstanding;
- char *rdata = SMB_MALLOC(p->max_trans_reply);
+ char *rdata = (char *)SMB_MALLOC(p->max_trans_reply);
int data_len;
if(rdata == NULL) {
vuser->n_groups = server_info->n_groups;
if (vuser->n_groups) {
- if (!(vuser->groups = memdup(server_info->groups, sizeof(gid_t) * vuser->n_groups))) {
+ if (!(vuser->groups = (gid_t *)memdup(server_info->groups, sizeof(gid_t) * vuser->n_groups))) {
DEBUG(0,("register_vuid: failed to memdup vuser->groups\n"));
data_blob_free(&session_key);
free(vuser);
DEBUG(3,("add_session_user: session userlist already too large.\n"));
return;
}
- newlist = SMB_REALLOC( session_userlist, len_session_userlist + PSTRING_LEN );
+ newlist = (char *)SMB_REALLOC( session_userlist, len_session_userlist + PSTRING_LEN );
if( newlist == NULL ) {
DEBUG(1,("Unable to resize session_userlist\n"));
return;
for processing.
****************************************************************************/
-static BOOL push_queued_message(enum q_type qt, char *buf, int msg_len, struct timeval *ptv, char *private, size_t private_len)
+static BOOL push_queued_message(enum q_type qt, char *buf, int msg_len, struct timeval *ptv, char *private_data, size_t private_len)
{
struct pending_message_list *tmp_msg;
struct pending_message_list *msg = SMB_MALLOC_P(struct pending_message_list);
msg->msg_time = *ptv;
}
- if (private) {
- msg->private_data = data_blob(private, private_len);
+ if (private_data) {
+ msg->private_data = data_blob(private_data, private_len);
if (msg->private_data.data == NULL) {
DEBUG(0,("push_message: malloc fail (3)\n"));
data_blob_free(&msg->buf);
for processing.
****************************************************************************/
-BOOL push_sharing_violation_open_smb_message(struct timeval *ptv, char *private, size_t priv_len)
+BOOL push_sharing_violation_open_smb_message(struct timeval *ptv, char *private_data, size_t priv_len)
{
uint16 mid = SVAL(InBuffer,smb_mid);
struct timeval tv;
(unsigned int)tv.tv_sec, (unsigned int)tv.tv_usec));
return push_queued_message(SHARE_VIOLATION_QUEUE, InBuffer,
- smb_len(InBuffer)+4, &tv, private, priv_len);
+ smb_len(InBuffer)+4, &tv, private_data, priv_len);
}
/****************************************************************************
fstrcpy(wb_request.domain_name, domain);
- wb_result = winbindd_request(WINBINDD_DOMAIN_INFO,
+ wb_result = winbindd_request_response(WINBINDD_DOMAIN_INFO,
&wb_request, &wb_response);
if (wb_result == NSS_STATUS_SUCCESS) {
return -1;
}
-int vfswrap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
+int vfswrap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
{
int result;
START_PROFILE(syscall_rename);
- result = rename(old, new);
+ result = rename(oldname, newname);
if (errno == EXDEV) {
/* Rename across filesystems needed. */
- result = copy_reg(old, new);
+ result = copy_reg(oldname, newname);
}
END_PROFILE(syscall_rename);
if fn is NULL then it is not called
a non-zero return value from fn() indicates that the traversal should stop
*/
-int tdb_traverse(TDB_CONTEXT *tdb, tdb_traverse_func fn, void *private)
+int tdb_traverse(TDB_CONTEXT *tdb, tdb_traverse_func fn, void *private_val)
{
TDB_DATA key, dbuf;
struct list_struct rec;
ret = -1;
goto out;
}
- if (fn && fn(tdb, key, dbuf, private)) {
+ if (fn && fn(tdb, key, dbuf, private_val)) {
/* They want us to terminate traversal */
ret = count;
if (unlock_record(tdb, tl.off) != 0) {
}
}
-void nb_rename(const char *old, const char *new)
+void nb_rename(const char *oldname, const char *newname)
{
- if (!cli_rename(c, old, new)) {
+ if (!cli_rename(c, oldname, newname)) {
printf("ERROR: rename %s %s failed (%s)\n",
old, new, cli_errstr(c));
exit(1);
fstrcpy(request.data.name.dom_name, domain);
fstrcpy(request.data.name.name, user);
- result = winbindd_request(WINBINDD_LOOKUPNAME, &request, &response);
+ result = winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response);
if (result != NSS_STATUS_SUCCESS) {
DEBUG(1, ("winbind could not find %s\n", full_name));
fstrcpy(request.data.username, full_name);
- result = winbindd_request(WINBINDD_GETGROUPS, &request, &response);
+ result = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
if (result != NSS_STATUS_SUCCESS) {
DEBUG(1, ("winbind could not get groups of %s\n", full_name));
sidrequest.data.gid = gid;
- result = winbindd_request(WINBINDD_GID_TO_SID,
+ result = winbindd_request_response(WINBINDD_GID_TO_SID,
&sidrequest, &sidresponse);
if (result != NSS_STATUS_SUCCESS) {
ZERO_STRUCT(request);
ZERO_STRUCT(response);
- if (winbindd_request(WINBINDD_LIST_USERS, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_LIST_USERS, &request, &response) !=
NSS_STATUS_SUCCESS)
return False;
/* Logon Hours */
if (delta->buf_logon_hrs.buffer) {
- pstring old, new;
- pdb_sethexhours(old, pdb_get_hours(account));
- pdb_sethexhours(new, delta->buf_logon_hrs.buffer);
- if (!strequal(old, new))
+ pstring oldstr, newstr;
+ pdb_sethexhours(oldstr, pdb_get_hours(account));
+ pdb_sethexhours(newstr, delta->buf_logon_hrs.buffer);
+ if (!strequal(oldstr, newstr))
pdb_set_hours(account, (const char *)delta->buf_logon_hrs.buffer, PDB_CHANGED);
}
{
struct nmb_name nname;
int count, i, j;
- struct node_status *status;
+ NODE_STATUS_STRUCT *status;
struct node_status_extra extra;
fstring cleanname;
/* Send off request */
- if (winbindd_request(WINBINDD_INFO, NULL, &response) !=
+ if (winbindd_request_response(WINBINDD_INFO, NULL, &response) !=
NSS_STATUS_SUCCESS) {
d_printf("could not obtain winbind separator!\n");
return *lp_winbind_separator();
/* Send off request */
- if (winbindd_request(WINBINDD_DOMAIN_NAME, NULL, &response) !=
+ if (winbindd_request_response(WINBINDD_DOMAIN_NAME, NULL, &response) !=
NSS_STATUS_SUCCESS) {
DEBUG(0, ("could not obtain winbind domain name!\n"));
return lp_workgroup();
/* Send off request */
- if (winbindd_request(WINBINDD_NETBIOS_NAME, NULL, &response) !=
+ if (winbindd_request_response(WINBINDD_NETBIOS_NAME, NULL, &response) !=
NSS_STATUS_SUCCESS) {
DEBUG(0, ("could not obtain winbind netbios name!\n"));
return global_myname();
return False;
}
- if (winbindd_request(WINBINDD_LOOKUPNAME, &request, &response) !=
+ if (winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response) !=
NSS_STATUS_SUCCESS) {
DEBUG(0, ("Winbindd lookupname failed to resolve %s into a SID!\n",
require_membership_of));
if (require_membership_of_sid)
fstrcpy(request.data.auth.require_membership_of_sid, require_membership_of_sid);
- result = winbindd_request(WINBINDD_PAM_AUTH, &request, &response);
+ result = winbindd_request_response(WINBINDD_PAM_AUTH, &request, &response);
/* Display response */
request.data.auth_crap.nt_resp_len = nt_response->length;
}
- result = winbindd_request(WINBINDD_PAM_AUTH_CRAP, &request, &response);
+ result = winbindd_request_response(WINBINDD_PAM_AUTH_CRAP, &request, &response);
/* Display response */
while (NT_STATUS_IS_OK(in->pdb_getsampwent(in, user))) {
DEBUG(4, ("Processing account %s\n",
- user->private.username));
+ user->private_u.username));
if (!username ||
- (strcmp(username, user->private.username)
+ (strcmp(username, user->private_u.username)
== 0)) {
out->pdb_add_sam_account(out, user);
if (!NT_STATUS_IS_OK(pdb_reset_sam(user))) {
int verbose = 1;
DOM_SID old_sid, new_sid;
-int change = 0, new = 0;
+int change = 0, new_val = 0;
/* Compare two SIDs for equality */
static int my_sid_equal(DOM_SID *s1, DOM_SID *s2)
break;
case 'n':
- new = 1;
+ new_val = 1;
if (!get_sid(&new_sid, poptGetOptArg(pc))) {
fprintf(stderr, "Argument to -n should be a SID in form of S-1-5-...\n");
poptPrintUsage(pc, stderr, 0);
exit(1);
}
- if ((!change & new) || (change & !new)) {
+ if ((!change & new_val) || (change & !new_val)) {
fprintf(stderr, "You must specify both -c and -n if one or the other is set!\n");
poptPrintUsage(pc, stderr, 0);
exit(252);
/* add an ACE to a list of ACEs in a SEC_ACL */
static BOOL add_ace(SEC_ACL **the_acl, SEC_ACE *ace)
{
- SEC_ACL *new;
+ SEC_ACL *new_ace;
SEC_ACE *aces;
if (! *the_acl) {
(*the_acl) = make_sec_acl(ctx, 3, 1, ace);
aces = SMB_CALLOC_ARRAY(SEC_ACE, 1+(*the_acl)->num_aces);
memcpy(aces, (*the_acl)->ace, (*the_acl)->num_aces * sizeof(SEC_ACE));
memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
- new = make_sec_acl(ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
+ new_ace = make_sec_acl(ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
SAFE_FREE(aces);
- (*the_acl) = new;
+ (*the_acl) = new_ace;
return True;
}
#ifdef WITH_WINBIND
-NSS_STATUS winbindd_request(int req_type,
- struct winbindd_request *request,
- struct winbindd_response *response);
-
/* check to see if winbind is running by pinging it */
BOOL winbindd_running(void)
void *ptr = parm->ptr;
char *utf8_s1, *utf8_s2;
- if (parm->class == P_LOCAL && snum >= 0) {
+ if (parm->p_class == P_LOCAL && snum >= 0) {
ptr = lp_local_ptr(snum, ptr);
}
const char *last_heading = NULL;
while ((parm = lp_next_parameter(snum, &i, allparameters))) {
- if (snum < 0 && parm->class == P_LOCAL && !(parm->flags & FLAG_GLOBAL))
+ if (snum < 0 && parm->p_class == P_LOCAL && !(parm->flags & FLAG_GLOBAL))
continue;
- if (parm->class == P_SEPARATOR) {
+ if (parm->p_class == P_SEPARATOR) {
heading = parm->label;
continue;
}
if (!(parm->flags & FLAG_BASIC)) {
void *ptr = parm->ptr;
- if (parm->class == P_LOCAL && snum >= 0) {
+ if (parm->p_class == P_LOCAL && snum >= 0) {
ptr = lp_local_ptr(snum, ptr);
}
int i;
char *s;
- if (snum < 0 && parm->class == P_LOCAL) {
+ if (snum < 0 && parm->p_class == P_LOCAL) {
/* this handles the case where we are changing a local
variable globally. We need to change the parameter in
all shares where it is currently set to the default */